@sesamespace/hivemind 0.8.13 → 0.11.0

package/dist/{chunk-ZM7RK5YV.js → chunk-OB6OXLPC.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
@@ -7351,6 +7874,428 @@ ${output || err.message}`;
   );
 }
 
+// packages/runtime/src/tools/learn.ts
+function slugify(topic) {
+  return topic.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 60);
+}
+async function discoverResearch(topic, depth, registry) {
+  if (!registry.has("web_search")) {
+    throw new Error("web_search tool not available \u2014 is BRAVE_API_KEY set?");
+  }
+  const sources = [];
+  const primary = await registry.execute("web_search", { query: topic, count: 8 });
+  if (primary.startsWith("Error:")) throw new Error(primary);
+  sources.push(...parseSearchResults(primary));
+  if (depth === "deep") {
+    const refinedQueries = [
+      `"${topic}" tutorial`,
+      `"${topic}" best practices`
+    ];
+    for (const q of refinedQueries) {
+      const result = await registry.execute("web_search", { query: q, count: 5 });
+      if (!result.startsWith("Error:")) {
+        sources.push(...parseSearchResults(result));
+      }
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return sources.filter((s) => {
+    if (seen.has(s.url)) return false;
+    seen.add(s.url);
+    return true;
+  });
+}
+function parseSearchResults(raw) {
+  const entries = [];
+  const blocks = raw.split(/\n\n(?=\d+\.\s)/);
+  for (const block of blocks) {
+    const titleMatch = block.match(/\*\*(.+?)\*\*/);
+    const urlMatch = block.match(/\s+(https?:\/\/\S+)/);
+    const lines = block.split("\n");
+    const snippet = lines.length >= 3 ? lines.slice(2).join(" ").trim() : "";
+    if (titleMatch && urlMatch) {
+      entries.push({
+        title: titleMatch[1],
+        url: urlMatch[1],
+        snippet
+      });
+    }
+  }
+  return entries;
+}
+async function exploreResearch(topic, sources, depth, focusAreas, registry, llm) {
+  if (!registry.has("web_fetch")) {
+    throw new Error("web_fetch tool not available");
+  }
+  const maxSources = depth === "deep" ? 6 : 3;
+  const toFetch = sources.slice(0, maxSources);
+  const findings = [];
+  for (const source of toFetch) {
+    try {
+      const content = await registry.execute("web_fetch", {
+        url: source.url,
+        max_chars: 15e3
+      });
+      if (content.startsWith("Fetch failed:") || content.startsWith("Fetch error:")) {
+        continue;
+      }
+      const focusClause = focusAreas.length > 0 ? `Focus especially on: ${focusAreas.join(", ")}.` : "";
+      const messages = [
+        {
+          role: "system",
+          content: "You are a research assistant. Extract key facts concisely. Return a numbered list of 5-10 key points, one per line."
+        },
+        {
+          role: "user",
+          content: `Extract 5-10 key facts about "${topic}" from this text. ${focusClause}
+
+Source: ${source.title} (${source.url})
+
+${content.slice(0, 12e3)}`
+        }
+      ];
+      const response = await llm.chat(messages);
+      const keyPoints = response.content.split("\n").map((l) => l.replace(/^\d+[\.\)]\s*/, "").trim()).filter((l) => l.length > 0);
+      findings.push({ source: `${source.title} \u2014 ${source.url}`, keyPoints });
+    } catch {
+    }
+  }
+  return findings;
+}
+async function discoverCodebase(topic, registry) {
+  if (!registry.has("shell")) {
+    throw new Error("shell tool not available");
+  }
+  const sources = [];
+  let targetDir = topic;
+  if (topic.startsWith("http://") || topic.startsWith("https://") || topic.startsWith("git@")) {
+    const slug = slugify(topic.split("/").pop()?.replace(".git", "") || "repo");
+    const cloneDir = `/tmp/learn-${slug}`;
+    const cloneResult = await registry.execute("shell", {
+      command: `rm -rf ${cloneDir} && git clone --depth 1 ${topic} ${cloneDir} 2>&1 | tail -1`
+    });
+    if (cloneResult.toLowerCase().includes("fatal")) {
+      throw new Error(`Failed to clone: ${cloneResult}`);
+    }
+    targetDir = cloneDir;
+  }
+  const fileList = await registry.execute("shell", {
+    command: `find ${targetDir} -type f \\( -name '*.ts' -o -name '*.tsx' -o -name '*.js' -o -name '*.jsx' -o -name '*.py' -o -name '*.rs' -o -name '*.go' -o -name '*.java' \\) ! -path '*/node_modules/*' ! -path '*/.git/*' ! -path '*/dist/*' ! -path '*/build/*' | head -50`
+  });
+  for (const line of fileList.split("\n").filter(Boolean)) {
+    sources.push({ title: line.split("/").pop() || line, url: line, snippet: "" });
+  }
+  if (registry.has("read_file")) {
+    const readmeResult = await registry.execute("read_file", { path: `${targetDir}/README.md` });
+    if (!readmeResult.startsWith("Error:")) {
+      sources.unshift({ title: "README.md", url: `${targetDir}/README.md`, snippet: readmeResult.slice(0, 200) });
+    }
+  }
+  const manifestCmd = `cat ${targetDir}/package.json 2>/dev/null || cat ${targetDir}/Cargo.toml 2>/dev/null || cat ${targetDir}/go.mod 2>/dev/null || cat ${targetDir}/pyproject.toml 2>/dev/null || echo ""`;
+  const manifestResult = await registry.execute("shell", { command: manifestCmd });
+  if (manifestResult.trim()) {
+    sources.unshift({ title: "manifest", url: `${targetDir}/package.json`, snippet: manifestResult.slice(0, 200) });
+  }
+  return sources;
+}
+async function exploreCodebase(topic, sources, depth, focusAreas, registry, llm) {
+  const maxFiles = depth === "deep" ? 12 : 5;
+  const toRead = sources.slice(0, maxFiles);
+  const findings = [];
+  for (const source of toRead) {
+    try {
+      let content;
+      if (registry.has("read_file")) {
+        content = await registry.execute("read_file", { path: source.url });
+      } else {
+        content = await registry.execute("shell", { command: `cat "${source.url}" 2>/dev/null | head -200` });
+      }
+      if (!content || content.startsWith("Error:")) continue;
+      const focusClause = focusAreas.length > 0 ? `Pay special attention to: ${focusAreas.join(", ")}.` : "";
+      const messages = [
+        {
+          role: "system",
+          content: "You are a code analyst. Analyze the given code file concisely. Return a numbered list of key observations."
+        },
+        {
+          role: "user",
+          content: `Analyze this code file from a project about "${topic}". Extract: purpose, key exports, patterns used, dependencies. ${focusClause}
+
+File: ${source.title}
+
+${content.slice(0, 1e4)}`
+        }
+      ];
+      const response = await llm.chat(messages);
+      const keyPoints = response.content.split("\n").map((l) => l.replace(/^\d+[\.\)]\s*/, "").trim()).filter((l) => l.length > 0);
+      findings.push({ source: source.title, keyPoints });
+    } catch {
+    }
+  }
+  return findings;
+}
+async function synthesize(topic, findings, focusAreas, llm) {
+  const findingText = findings.map((f) => `### ${f.source}
+${f.keyPoints.map((p) => `- ${p}`).join("\n")}`).join("\n\n");
+  const focusClause = focusAreas.length > 0 ? `
+Focus areas: ${focusAreas.join(", ")}` : "";
+  const messages = [
+    {
+      role: "system",
+      content: [
+        "You are a knowledge synthesizer. Distill research findings into structured, actionable knowledge.",
+        "Output format:",
+        "## Core Concepts",
+        "(key ideas and definitions)",
+        "## Key Relationships",
+        "(how concepts connect)",
+        "## Important Details",
+        "(specifics worth remembering)",
+        "## Practical Implications",
+        "(how to apply this knowledge)",
+        "",
+        "Be concise but thorough. Maximum 8000 characters."
+      ].join("\n")
+    },
+    {
+      role: "user",
+      content: `Synthesize all findings about "${topic}" into structured knowledge.${focusClause}
+
+${findingText}`
+    }
+  ];
+  const response = await llm.chat(messages);
+  return response.content.slice(0, 8e3);
+}
+async function storeInMemory(contextName, topic, findings, synthesis, daemonUrl) {
+  const storedIds = [];
+  try {
+    await fetch(`${daemonUrl}/api/contexts`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        name: contextName,
+        description: `Learned knowledge: ${topic}`
+      })
+    });
+  } catch {
+  }
+  for (const finding of findings) {
+    const content = `[Source: ${finding.source}]
+${finding.keyPoints.join("\n")}`;
+    try {
+      const resp = await fetch(`${daemonUrl}/api/episodes`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          context_name: contextName,
+          role: "system",
+          content
+        })
+      });
+      if (resp.ok) {
+        const data = await resp.json();
+        if (data.id) storedIds.push(data.id);
+      }
+    } catch {
+    }
+  }
+  try {
+    const resp = await fetch(`${daemonUrl}/api/episodes`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        context_name: contextName,
+        role: "assistant",
+        content: `[SYNTHESIS: ${topic}]
+${synthesis}`
+      })
+    });
+    if (resp.ok) {
+      const data = await resp.json();
+      if (data.id) storedIds.push(data.id);
+    }
+  } catch {
+  }
+  try {
+    await fetch(`${daemonUrl}/api/promotion/run?context=${encodeURIComponent(contextName)}`, {
+      method: "POST"
+    });
+  } catch {
+  }
+  return storedIds;
+}
+function registerLearnTools(registry, config) {
+  let llm = null;
+  if (config.llmConfig) {
+    try {
+      llm = new LLMClient({
+        ...config.llmConfig,
+        max_tokens: 2048
+      });
+    } catch {
+    }
+  }
+  let synthesisLlm = null;
+  if (config.llmConfig) {
+    try {
+      synthesisLlm = new LLMClient({
+        ...config.llmConfig,
+        max_tokens: 4096
+      });
+    } catch {
+    }
+  }
+  registry.register(
+    "learn",
+    [
+      "Deeply research a topic and store organized knowledge in memory.",
+      "Supports two modes: 'research' (web search + fetch) and 'codebase' (local/remote repo analysis).",
+      "Findings are synthesized via LLM and stored as L2 episodes in a dedicated memory context,",
+      "eligible for L3 promotion. Use this when you need thorough understanding of a topic."
+    ].join(" "),
+    {
+      type: "object",
+      properties: {
+        topic: {
+          type: "string",
+          description: "What to learn about (e.g., 'WebSocket protocol', '/path/to/repo', 'https://github.com/user/repo')"
+        },
+        type: {
+          type: "string",
+          enum: ["research", "codebase"],
+          description: "Learning type: 'research' for web-based topics, 'codebase' for analyzing code (default: research)"
+        },
+        depth: {
+          type: "string",
+          enum: ["shallow", "deep"],
+          description: "How many sources to explore: shallow (3 sources) or deep (6+ sources) (default: shallow)"
+        },
+        context: {
+          type: "string",
+          description: "Custom memory context name (default: auto-generated learn-{slug})"
+        },
+        focus_areas: {
+          type: "array",
+          items: { type: "string" },
+          description: "Specific aspects to focus on (e.g., ['performance', 'security'])"
+        },
+        store: {
+          type: "boolean",
+          description: "Whether to persist findings in memory (default: true)"
+        }
+      },
+      required: ["topic"]
+    },
+    async (params) => {
+      const topic = params.topic;
+      const type = params.type || "research";
+      const depth = params.depth || "shallow";
+      const contextName = params.context || `learn-${slugify(topic)}`;
+      const focusAreas = params.focus_areas || [];
+      const shouldStore = params.store !== false;
+      if (!llm || !synthesisLlm) {
+        return "Error: LLM not configured \u2014 learn tool requires an LLM for synthesis. Check your llm config.";
+      }
+      try {
+        let sources;
+        if (type === "codebase") {
+          sources = await discoverCodebase(topic, registry);
+        } else {
+          sources = await discoverResearch(topic, depth, registry);
+        }
+        if (sources.length === 0) {
+          return `No sources found for "${topic}". Try a different query or check connectivity.`;
+        }
+        let findings;
+        if (type === "codebase") {
+          findings = await exploreCodebase(topic, sources, depth, focusAreas, registry, llm);
+        } else {
+          findings = await exploreResearch(topic, sources, depth, focusAreas, registry, llm);
+        }
+        if (findings.length === 0) {
+          return `Found ${sources.length} sources but could not extract meaningful findings for "${topic}".`;
+        }
+        const synthesis = await synthesize(topic, findings, focusAreas, synthesisLlm);
+        let storageNote = "";
+        if (shouldStore) {
+          const storedIds = await storeInMemory(
+            contextName,
+            topic,
+            findings,
+            synthesis,
+            config.memoryDaemonUrl
+          );
+          storageNote = storedIds.length > 0 ? `
+
+---
+Stored ${storedIds.length} episodes in memory context "${contextName}". Use learn_recall to retrieve later.` : "\n\n---\nNote: Could not store in memory (daemon may be offline). Knowledge is shown above but not persisted.";
+        }
+        return `# Learned: ${topic}
+
+Sources explored: ${findings.length}
+Type: ${type} | Depth: ${depth}
+
+${synthesis}${storageNote}`;
+      } catch (err) {
+        return `Learn failed: ${err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "learn_recall",
+    "Retrieve knowledge from a previous learn session. Searches across learn-* memory contexts for stored findings and synthesis.",
+    {
+      type: "object",
+      properties: {
+        topic: {
+          type: "string",
+          description: "Search query to find previously learned knowledge"
+        },
+        context: {
+          type: "string",
+          description: "Specific learn context to search (e.g., 'learn-websocket-protocol'). If omitted, searches all learn contexts."
+        }
+      },
+      required: ["topic"]
+    },
+    async (params) => {
+      const topic = params.topic;
+      const context = params.context;
+      const daemonUrl = config.memoryDaemonUrl;
+      try {
+        if (context) {
+          const resp2 = await fetch(`${daemonUrl}/api/search`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ query: topic, context_name: context, top_k: 10 })
+          });
+          if (!resp2.ok) return `Memory search failed: ${resp2.status}`;
+          const data2 = await resp2.json();
+          if (!data2.results?.length) return `No learned knowledge found for "${topic}" in context "${context}".`;
+          return data2.results.map((r, i) => `${i + 1}. [score: ${r.score.toFixed(3)}] [${r.role}]
+${r.content.slice(0, 500)}`).join("\n\n");
+        }
+        const resp = await fetch(`${daemonUrl}/api/search/cross-context`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ query: topic, top_k: 15 })
+        });
+        if (!resp.ok) return `Memory cross-search failed: ${resp.status}`;
+        const data = await resp.json();
+        const learnResults = data.results?.filter((r) => r.context_name.startsWith("learn-")) || [];
+        if (learnResults.length === 0) {
+          return `No previously learned knowledge found for "${topic}". Use the learn tool first.`;
+        }
+        return learnResults.map((r, i) => `${i + 1}. [score: ${r.score.toFixed(3)}] [${r.context_name}] [${r.role}]
+${r.content.slice(0, 500)}`).join("\n\n");
+      } catch (err) {
+        return `Memory daemon unreachable: ${err.message}`;
+      }
+    }
+  );
+}
+
 // packages/runtime/src/tools/register.ts
 import { resolve as resolve18 } from "path";
 import { mkdirSync as mkdirSync13, existsSync as existsSync18 } from "fs";
@@ -7381,6 +8326,11 @@ function registerAllTools(hivemindHome, config) {
   registerMacOSTools(registry, workspaceDir);
   registerDataTools(registry, workspaceDir);
   registerCodingAgentTools(registry, workspaceDir);
+  registerLearnTools(registry, {
+    llmConfig: config?.llmConfig,
+    memoryDaemonUrl: config?.memoryDaemonUrl || "http://localhost:3434",
+    workspaceDir
+  });
   return registry;
 }
 
@@ -7674,8 +8624,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, {
@@ -7683,7 +8633,8 @@ async function startPipeline(configPath) {
     workspace: config.agent.workspace || "workspace",
     braveApiKey: process.env.BRAVE_API_KEY,
     memoryDaemonUrl: config.memory.daemon_url,
-    configPath
+    configPath,
+    llmConfig: config.llm
   });
   const workspaceDir = resolve20(hivemindHome, config.agent.workspace || "workspace");
   const skillsEngine = new SkillsEngine(workspaceDir, toolRegistry);
@@ -8029,7 +8980,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 +8991,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 +9069,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 +9415,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-OB6OXLPC.js.map