@sesamespace/hivemind 0.8.12 → 0.10.0

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

@@ -1,3 +1,36 @@
+import {
+  __require
+} from "./chunk-DGUM43GV.js";
+
+// packages/runtime/src/logger.ts
+var LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };
+var currentLevel = process.env.HIVEMIND_LOG_LEVEL || "info";
+function setLogLevel(level) {
+  currentLevel = level;
+}
+function createLogger(component) {
+  const log4 = (level, msg, data) => {
+    if (LEVELS[level] < LEVELS[currentLevel]) return;
+    const entry = {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      component,
+      msg,
+      ...data
+    };
+    const line = JSON.stringify(entry);
+    if (level === "error") console.error(line);
+    else if (level === "warn") console.warn(line);
+    else console.log(line);
+  };
+  return {
+    debug: (msg, data) => log4("debug", msg, data),
+    info: (msg, data) => log4("info", msg, data),
+    warn: (msg, data) => log4("warn", msg, data),
+    error: (msg, data) => log4("error", msg, data)
+  };
+}
+
 // packages/runtime/src/llm-client.ts
 import { execSync } from "child_process";
 function convertMessagesForAnthropic(messages) {
@@ -1310,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,
@@ -1554,6 +1588,9 @@ var Agent = class {
   getActiveContext() {
     return this.contextManager.getActiveContext();
   }
+  getConversationHistories() {
+    return this.conversationHistories;
+  }
 };
 
 // packages/runtime/src/events.ts
@@ -3012,7 +3049,7 @@ var SesameClient = class {
    * Connect to the real-time WebSocket gateway.
    */
   connect() {
-    return new Promise((resolve20, reject) => {
+    return new Promise((resolve21, reject) => {
       try {
         this.ws = new WebSocket(`${this.config.wsUrl}/v1/connect`);
         this.ws.on("open", () => {
@@ -3026,7 +3063,7 @@ var SesameClient = class {
               this.authenticated = true;
               this.startHeartbeat(event.heartbeatIntervalMs ?? 3e4);
               this.sendReplay();
-              resolve20();
+              resolve21();
               return;
             }
             if (event.type === "pong")
@@ -3585,6 +3622,977 @@ var SkillsEngine = class {
   }
 };
 
+// packages/runtime/src/processors/error-registry.ts
+import { readFileSync as readFileSync7, writeFileSync, mkdirSync as mkdirSync4, existsSync as existsSync6 } from "fs";
+import { createHash } from "crypto";
+import { dirname as dirname4 } from "path";
+var log = createLogger("error-registry");
+function normalizeForHash(msg, stack) {
+  let text = msg;
+  if (stack) {
+    text += "\n" + stack;
+  }
+  text = text.replace(/:\d+:\d+/g, ":X:X");
+  text = text.replace(/\d{4}-\d{2}-\d{2}T[\d:.Z]+/g, "T");
+  text = text.replace(/\b\d{4,}\b/g, "N");
+  return text;
+}
+function hashError(msg, stack) {
+  const normalized = normalizeForHash(msg, stack);
+  return createHash("sha256").update(normalized).digest("hex").slice(0, 16);
+}
+function scoreSeverity(entry) {
+  let score = 0;
+  if (entry.level === "crash") score += 5;
+  const firstMs = new Date(entry.firstSeen).getTime();
+  const lastMs = new Date(entry.lastSeen).getTime();
+  const spanMinutes = (lastMs - firstMs) / 6e4;
+  if (entry.totalOccurrences >= 3 && spanMinutes < 5) score += 3;
+  const spanHours = Math.max(spanMinutes / 60, 1 / 60);
+  if (entry.totalOccurrences / spanHours > 10) score += 2;
+  if (/sesame/i.test(entry.message) || /sesame/i.test(entry.stackTrace ?? "")) {
+    score += 2;
+  }
+  if (/memory/i.test(entry.message) || /memory/i.test(entry.stackTrace ?? "")) {
+    score += 1;
+  }
+  if (entry.status === "fix-submitted" || entry.status === "wont-fix") {
+    score -= 10;
+  }
+  return score;
+}
+var ErrorRegistry = class {
+  filePath;
+  entries = /* @__PURE__ */ new Map();
+  constructor(dataDir) {
+    this.filePath = `${dataDir}/error-registry.json`;
+    this.load();
+  }
+  // ---- persistence -------------------------------------------------------
+  load() {
+    try {
+      if (!existsSync6(this.filePath)) return;
+      const raw = readFileSync7(this.filePath, "utf-8");
+      const data = JSON.parse(raw);
+      if (data.version === 1 && data.errors) {
+        for (const [id, entry] of Object.entries(data.errors)) {
+          this.entries.set(id, entry);
+        }
+      }
+      log.debug("loaded error registry", { count: this.entries.size });
+    } catch (err) {
+      log.warn("failed to load error registry, starting fresh", {
+        error: err.message
+      });
+    }
+  }
+  save() {
+    try {
+      const dir = dirname4(this.filePath);
+      if (!existsSync6(dir)) mkdirSync4(dir, { recursive: true });
+      const data = {
+        version: 1,
+        errors: Object.fromEntries(this.entries)
+      };
+      writeFileSync(this.filePath, JSON.stringify(data, null, 2));
+    } catch (err) {
+      log.error("failed to save error registry", {
+        error: err.message
+      });
+    }
+  }
+  // ---- public API --------------------------------------------------------
+  /** Record an error event, creating or updating the registry entry. */
+  recordError(event) {
+    const existing = this.entries.get(event.id);
+    if (existing) {
+      existing.lastSeen = event.timestamp.toISOString();
+      existing.totalOccurrences += event.occurrences;
+      if (event.level === "crash" && existing.level !== "crash") {
+        existing.level = "crash";
+      }
+      existing.severity = scoreSeverity(existing);
+      this.save();
+      log.debug("updated error entry", {
+        id: event.id,
+        total: existing.totalOccurrences,
+        severity: existing.severity
+      });
+      return existing;
+    }
+    const entry = {
+      id: event.id,
+      message: event.message,
+      source: event.source,
+      level: event.level,
+      stackTrace: event.stackTrace,
+      firstSeen: event.timestamp.toISOString(),
+      lastSeen: event.timestamp.toISOString(),
+      totalOccurrences: event.occurrences,
+      status: "new",
+      severity: 0
+    };
+    entry.severity = scoreSeverity(entry);
+    this.entries.set(event.id, entry);
+    this.save();
+    log.info("new error registered", {
+      id: event.id,
+      message: event.message.slice(0, 120),
+      severity: entry.severity
+    });
+    return entry;
+  }
+  /** Return errors above the severity threshold that are actionable (new or investigating). */
+  getActionable(threshold) {
+    const results = [];
+    for (const entry of this.entries.values()) {
+      entry.severity = scoreSeverity(entry);
+      if (entry.severity >= threshold && (entry.status === "new" || entry.status === "investigating")) {
+        results.push(entry);
+      }
+    }
+    results.sort((a, b) => b.severity - a.severity);
+    return results;
+  }
+  /** Update the status (and optional PR url) for an error. */
+  updateStatus(id, status, prUrl) {
+    const entry = this.entries.get(id);
+    if (!entry) return;
+    entry.status = status;
+    if (prUrl) entry.prUrl = prUrl;
+    entry.severity = scoreSeverity(entry);
+    this.save();
+    log.info("error status updated", { id, status, prUrl });
+  }
+  /** Remove entries older than the given date. */
+  cleanup(olderThan) {
+    let removed = 0;
+    for (const [id, entry] of this.entries) {
+      if (new Date(entry.lastSeen) < olderThan) {
+        this.entries.delete(id);
+        removed++;
+      }
+    }
+    if (removed > 0) {
+      this.save();
+      log.info("cleaned up old errors", { removed });
+    }
+    return removed;
+  }
+  /** Get a single entry by id. */
+  get(id) {
+    return this.entries.get(id);
+  }
+  /** Total number of tracked errors. */
+  get size() {
+    return this.entries.size;
+  }
+};
+
+// packages/runtime/src/processors/log-watcher.ts
+import { readFileSync as readFileSync8, statSync as statSync2, existsSync as existsSync7 } from "fs";
+
+// packages/runtime/src/memory/background-processor.ts
+import { EventEmitter } from "events";
+var BackgroundProcess = class extends EventEmitter {
+  name;
+  interval;
+  enabled = true;
+  timer;
+  running = false;
+  lastRun;
+  lastResult;
+  constructor(name, interval) {
+    super();
+    this.name = name;
+    this.interval = interval;
+  }
+  /**
+   * Determine if this process should run now
+   */
+  async shouldRun(context) {
+    if (!this.enabled || this.running) return false;
+    return true;
+  }
+  /**
+   * Start the background process
+   */
+  start(context) {
+    if (this.timer) return;
+    this.runOnce(context);
+    this.timer = setInterval(() => {
+      this.runOnce(context);
+    }, this.interval);
+  }
+  /**
+   * Stop the background process
+   */
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = void 0;
+    }
+  }
+  /**
+   * Run the process once
+   */
+  async runOnce(context) {
+    if (!await this.shouldRun(context)) return;
+    this.running = true;
+    const startTime2 = Date.now();
+    try {
+      this.emit("start", { name: this.name, time: /* @__PURE__ */ new Date() });
+      const result = await this.process(context);
+      this.lastResult = result;
+      this.lastRun = /* @__PURE__ */ new Date();
+      if (result.nextRunIn && result.nextRunIn !== this.interval) {
+        this.stop();
+        this.interval = result.nextRunIn;
+        this.start(context);
+      }
+      this.emit("complete", {
+        name: this.name,
+        duration: Date.now() - startTime2,
+        result
+      });
+      if (result.errors.length > 0) {
+        this.emit("error", {
+          name: this.name,
+          errors: result.errors
+        });
+      }
+    } catch (error) {
+      this.emit("error", {
+        name: this.name,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    } finally {
+      this.running = false;
+    }
+  }
+  /**
+   * Get process status
+   */
+  getStatus() {
+    return {
+      name: this.name,
+      enabled: this.enabled,
+      running: this.running,
+      interval: this.interval,
+      lastRun: this.lastRun,
+      lastResult: this.lastResult
+    };
+  }
+};
+var ProcessManager = class extends EventEmitter {
+  processes = /* @__PURE__ */ new Map();
+  context;
+  started = false;
+  constructor(context) {
+    super();
+    this.context = context;
+  }
+  /**
+   * Register a background process
+   */
+  register(process2) {
+    if (this.processes.has(process2.name)) {
+      throw new Error(`Process ${process2.name} already registered`);
+    }
+    process2.on("start", (data) => this.emit("process:start", data));
+    process2.on("complete", (data) => this.emit("process:complete", data));
+    process2.on("error", (data) => this.emit("process:error", data));
+    this.processes.set(process2.name, process2);
+    if (this.started) {
+      process2.start(this.context);
+    }
+  }
+  /**
+   * Start all registered processes
+   */
+  start() {
+    if (this.started) return;
+    for (const process2 of this.processes.values()) {
+      process2.start(this.context);
+    }
+    this.started = true;
+    this.emit("started");
+  }
+  /**
+   * Stop all processes
+   */
+  stop() {
+    if (!this.started) return;
+    for (const process2 of this.processes.values()) {
+      process2.stop();
+    }
+    this.started = false;
+    this.emit("stopped");
+  }
+  /**
+   * Get status of all processes
+   */
+  getStatus() {
+    const statuses = {};
+    for (const [name, process2] of this.processes) {
+      statuses[name] = process2.getStatus();
+    }
+    return {
+      started: this.started,
+      processCount: this.processes.size,
+      processes: statuses
+    };
+  }
+  /**
+   * Enable/disable a specific process
+   */
+  setProcessEnabled(name, enabled) {
+    const process2 = this.processes.get(name);
+    if (!process2) {
+      throw new Error(`Process ${name} not found`);
+    }
+    process2.enabled = enabled;
+    if (!enabled) {
+      process2.stop();
+    } else if (this.started) {
+      process2.start(this.context);
+    }
+  }
+  /**
+   * Manually trigger a process run
+   */
+  async runProcess(name) {
+    const process2 = this.processes.get(name);
+    if (!process2) {
+      throw new Error(`Process ${name} not found`);
+    }
+    return process2.process(this.context);
+  }
+};
+
+// packages/runtime/src/processors/log-watcher.ts
+var log2 = createLogger("log-watcher");
+var STACK_TRACE_START = /^(?:Error|TypeError|RangeError|ReferenceError|SyntaxError|URIError|EvalError|AggregateError|UnhandledPromiseRejectionWarning|Uncaught):/;
+var STACK_FRAME = /^\s+at\s+/;
+var CRASH_INDICATOR = /(?:exit\s+code\s+[1-9]\d*|SIGKILL|SIGTERM|SIGSEGV|SIGABRT|uncaughtException|unhandledRejection)/i;
+var WARNING_DEDUP_WINDOW_MS = 5 * 60 * 1e3;
+var WARNING_THRESHOLD = 3;
+var LogWatcher = class extends BackgroundProcess {
+  config;
+  registry;
+  tailPositions = /* @__PURE__ */ new Map();
+  warningAccumulators = /* @__PURE__ */ new Map();
+  positionsFile;
+  constructor(config, dataDir) {
+    super("log-watcher", 1e4);
+    this.config = config;
+    this.registry = new ErrorRegistry(dataDir);
+    this.positionsFile = `${dataDir}/log-watcher-positions.json`;
+    this.loadPositions();
+  }
+  /** Expose the registry so the auto-debugger can consume it. */
+  getRegistry() {
+    return this.registry;
+  }
+  // ---- BackgroundProcess implementation ------------------------------------
+  async process(context) {
+    const errors = [];
+    let itemsProcessed = 0;
+    for (const logFile of this.config.log_files) {
+      try {
+        const result = this.processLogFile(logFile, context);
+        itemsProcessed += result.linesRead;
+      } catch (err) {
+        errors.push(`${logFile}: ${err.message}`);
+      }
+    }
+    this.pruneWarnings();
+    this.savePositions();
+    this.registry.cleanup(new Date(Date.now() - 30 * 24 * 60 * 60 * 1e3));
+    return { itemsProcessed, errors };
+  }
+  // ---- log tailing ---------------------------------------------------------
+  processLogFile(logFile, context) {
+    if (!existsSync7(logFile)) return { linesRead: 0 };
+    let fileSize;
+    try {
+      fileSize = statSync2(logFile).size;
+    } catch {
+      return { linesRead: 0 };
+    }
+    const lastPos = this.tailPositions.get(logFile) ?? 0;
+    if (fileSize < lastPos) {
+      this.tailPositions.set(logFile, 0);
+      return this.processLogFile(logFile, context);
+    }
+    if (fileSize === lastPos) return { linesRead: 0 };
+    let chunk;
+    try {
+      const buf = Buffer.alloc(fileSize - lastPos);
+      const fd = __require("fs").openSync(logFile, "r");
+      try {
+        __require("fs").readSync(fd, buf, 0, buf.length, lastPos);
+      } finally {
+        __require("fs").closeSync(fd);
+      }
+      chunk = buf.toString("utf-8");
+    } catch {
+      return { linesRead: 0 };
+    }
+    this.tailPositions.set(logFile, fileSize);
+    const lines = chunk.split("\n").filter((l) => l.length > 0);
+    if (lines.length === 0) return { linesRead: 0 };
+    let baseLineNumber;
+    try {
+      const fullContent = readFileSync8(logFile, "utf-8");
+      const preContent = fullContent.substring(0, lastPos);
+      baseLineNumber = preContent.split("\n").length;
+    } catch {
+      baseLineNumber = 1;
+    }
+    this.detectErrors(lines, logFile, baseLineNumber, context);
+    return { linesRead: lines.length };
+  }
+  // ---- error detection -----------------------------------------------------
+  detectErrors(lines, logFile, baseLineNumber, context) {
+    const source = this.inferSource(logFile);
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const lineNumber = baseLineNumber + i;
+      const jsonError = this.tryParseJsonError(line);
+      if (jsonError) {
+        this.emitError({
+          message: jsonError.msg,
+          stackTrace: jsonError.stack,
+          level: jsonError.level === "crash" ? "crash" : "error",
+          source,
+          logFile,
+          lineNumber,
+          context: this.getSurroundingLines(lines, i)
+        });
+        continue;
+      }
+      if (STACK_TRACE_START.test(line)) {
+        const { message, stack } = this.collectStackTrace(lines, i);
+        const level = /uncaught|unhandled/i.test(line) ? "crash" : "error";
+        this.emitError({
+          message,
+          stackTrace: stack,
+          level,
+          source,
+          logFile,
+          lineNumber,
+          context: this.getSurroundingLines(lines, i)
+        });
+        continue;
+      }
+      if (CRASH_INDICATOR.test(line)) {
+        this.emitError({
+          message: line.trim(),
+          level: "crash",
+          source,
+          logFile,
+          lineNumber,
+          context: this.getSurroundingLines(lines, i)
+        });
+        continue;
+      }
+      this.accumulateWarning(line, logFile, lineNumber);
+    }
+  }
+  tryParseJsonError(line) {
+    if (!line.startsWith("{")) return null;
+    try {
+      const entry = JSON.parse(line);
+      if (entry.level === "error" || entry.level === "crash") {
+        return {
+          msg: entry.msg || entry.message || "unknown error",
+          stack: entry.stack || entry.stackTrace,
+          level: entry.level
+        };
+      }
+    } catch {
+    }
+    return null;
+  }
+  collectStackTrace(lines, startIdx) {
+    const message = lines[startIdx].trim();
+    const stackLines = [message];
+    for (let j = startIdx + 1; j < lines.length; j++) {
+      if (STACK_FRAME.test(lines[j])) {
+        stackLines.push(lines[j]);
+      } else {
+        break;
+      }
+    }
+    return { message, stack: stackLines.join("\n") };
+  }
+  getSurroundingLines(lines, idx) {
+    const start = Math.max(0, idx - 10);
+    const end = Math.min(lines.length, idx + 11);
+    return lines.slice(start, end);
+  }
+  emitError(params) {
+    const id = hashError(params.message, params.stackTrace);
+    const event = {
+      id,
+      timestamp: /* @__PURE__ */ new Date(),
+      source: params.source,
+      level: params.level,
+      message: params.message,
+      stackTrace: params.stackTrace,
+      logFile: params.logFile,
+      lineNumber: params.lineNumber,
+      occurrences: 1,
+      context: params.context
+    };
+    const entry = this.registry.recordError(event);
+    log2.info("error detected", {
+      id,
+      severity: entry.severity,
+      message: params.message.slice(0, 120),
+      logFile: params.logFile
+    });
+  }
+  // ---- repeated warning detection ------------------------------------------
+  accumulateWarning(line, logFile, lineNumber) {
+    const isWarning = /\bwarn\b/i.test(line) || line.startsWith("{") && line.includes('"warn"');
+    if (!isWarning) return;
+    const normalized = line.replace(/\d{4}-\d{2}-\d{2}T[\d:.Z]+/g, "T").replace(/\b\d{4,}\b/g, "N").trim();
+    const key = `${logFile}::${normalized}`;
+    const existing = this.warningAccumulators.get(key);
+    const now = Date.now();
+    if (existing) {
+      existing.count++;
+      existing.lastLine = lineNumber;
+      if (existing.count >= WARNING_THRESHOLD && now - existing.firstSeen <= WARNING_DEDUP_WINDOW_MS) {
+        const id = hashError(existing.message);
+        const event = {
+          id,
+          timestamp: /* @__PURE__ */ new Date(),
+          source: this.inferSource(logFile),
+          level: "repeated-warning",
+          message: `Repeated warning (${existing.count}x in 5 min): ${existing.message}`,
+          logFile,
+          lineNumber: existing.lastLine,
+          occurrences: existing.count,
+          context: []
+        };
+        this.registry.recordError(event);
+        log2.info("repeated warning detected", {
+          id,
+          count: existing.count,
+          message: existing.message.slice(0, 100)
+        });
+        this.warningAccumulators.delete(key);
+      }
+    } else {
+      this.warningAccumulators.set(key, {
+        message: normalized,
+        count: 1,
+        firstSeen: now,
+        logFile,
+        lastLine: lineNumber
+      });
+    }
+  }
+  pruneWarnings() {
+    const now = Date.now();
+    for (const [key, acc] of this.warningAccumulators) {
+      if (now - acc.firstSeen > WARNING_DEDUP_WINDOW_MS) {
+        this.warningAccumulators.delete(key);
+      }
+    }
+  }
+  // ---- helpers -------------------------------------------------------------
+  inferSource(logFile) {
+    if (logFile.includes("watchdog")) return "watchdog";
+    if (logFile.includes("memory")) return "memory";
+    return "agent";
+  }
+  // ---- position persistence ------------------------------------------------
+  loadPositions() {
+    try {
+      if (!existsSync7(this.positionsFile)) return;
+      const raw = readFileSync8(this.positionsFile, "utf-8");
+      const data = JSON.parse(raw);
+      for (const [file, pos] of Object.entries(data)) {
+        this.tailPositions.set(file, pos);
+      }
+      log2.debug("loaded tail positions", { count: this.tailPositions.size });
+    } catch {
+    }
+  }
+  savePositions() {
+    try {
+      const { mkdirSync: mkdirSync15, writeFileSync: writeFileSync9 } = __require("fs");
+      const { dirname: dirname9 } = __require("path");
+      const dir = dirname9(this.positionsFile);
+      if (!existsSync7(dir)) mkdirSync15(dir, { recursive: true });
+      const data = Object.fromEntries(this.tailPositions);
+      writeFileSync9(this.positionsFile, JSON.stringify(data));
+    } catch (err) {
+      log2.warn("failed to save tail positions", {
+        error: err.message
+      });
+    }
+  }
+};
+
+// packages/runtime/src/processors/auto-debugger.ts
+import { execSync as execSync3 } from "child_process";
+import { readFileSync as readFileSync9, existsSync as existsSync8 } from "fs";
+import { resolve as resolve6 } from "path";
+var log3 = createLogger("auto-debugger");
+var SECRET_PATTERNS = [
+  /(?:api[_-]?key|token|secret|password|credential|auth)[\s=:]+\S+/gi,
+  /sk-[a-zA-Z0-9]{20,}/g,
+  /ghp_[a-zA-Z0-9]{36}/g,
+  /Bearer\s+\S+/g
+];
+function sanitize(text) {
+  let clean = text;
+  for (const pat of SECRET_PATTERNS) {
+    clean = clean.replace(pat, "[REDACTED]");
+  }
+  return clean;
+}
+function extractSourceFiles(stackTrace, repoRoot) {
+  const files = /* @__PURE__ */ new Set();
+  const pathPattern = /(?:[(]|\s)((?:\/[^\s:()]+|[a-zA-Z][a-zA-Z0-9/_.-]+)\.[a-zA-Z]+)(?::\d+){0,2}/g;
+  let m;
+  while ((m = pathPattern.exec(stackTrace)) !== null) {
+    let filePath = m[1];
+    if (filePath.includes("node_modules")) continue;
+    if (!filePath.startsWith("/")) {
+      filePath = resolve6(repoRoot, filePath);
+    }
+    if (filePath.startsWith(repoRoot) && existsSync8(filePath)) {
+      files.add(filePath);
+    }
+  }
+  return [...files].slice(0, 5);
+}
+function ghAvailable() {
+  try {
+    execSync3("gh auth status", { stdio: "ignore", timeout: 5e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function run(cmd, cwd) {
+  try {
+    return execSync3(cmd, { cwd, encoding: "utf-8", timeout: 6e4 }).trim();
+  } catch {
+    return null;
+  }
+}
+var AutoDebugger = class extends BackgroundProcess {
+  config;
+  registry;
+  llm;
+  repoRoot;
+  activeFixes = /* @__PURE__ */ new Set();
+  // error ids currently being fixed
+  cooldowns = /* @__PURE__ */ new Map();
+  // error id → epoch ms of last fix attempt
+  constructor(config, registry, llmConfig, repoRoot) {
+    super("auto-debugger", 6e4);
+    this.config = config;
+    this.registry = registry;
+    this.repoRoot = repoRoot;
+    if (llmConfig && llmConfig.api_key) {
+      try {
+        this.llm = new LLMClient(llmConfig);
+      } catch {
+        this.llm = null;
+      }
+    } else {
+      this.llm = null;
+    }
+  }
+  // ---- BackgroundProcess implementation ------------------------------------
+  async process(_context) {
+    const errors = [];
+    let itemsProcessed = 0;
+    const actionable = this.registry.getActionable(this.config.severity_threshold);
+    if (actionable.length === 0) return { itemsProcessed: 0, errors: [] };
+    log3.info("actionable errors found", { count: actionable.length });
+    for (const entry of actionable) {
+      if (this.activeFixes.size >= this.config.max_concurrent_fixes) {
+        log3.debug("max concurrent fixes reached, skipping remaining");
+        break;
+      }
+      const lastAttempt = this.cooldowns.get(entry.id);
+      if (lastAttempt && Date.now() - lastAttempt < this.config.cooldown_minutes * 6e4) {
+        continue;
+      }
+      try {
+        await this.investigate(entry);
+        itemsProcessed++;
+      } catch (err) {
+        errors.push(`${entry.id}: ${err.message}`);
+        log3.error("investigation failed", {
+          id: entry.id,
+          error: err.message
+        });
+      }
+    }
+    return { itemsProcessed, errors };
+  }
+  // ---- investigation pipeline ----------------------------------------------
+  async investigate(entry) {
+    this.registry.updateStatus(entry.id, "investigating");
+    this.activeFixes.add(entry.id);
+    this.cooldowns.set(entry.id, Date.now());
+    try {
+      const sourceFiles = entry.stackTrace ? extractSourceFiles(entry.stackTrace, this.repoRoot) : [];
+      const fileContents = {};
+      for (const f of sourceFiles) {
+        try {
+          const content = readFileSync9(f, "utf-8");
+          fileContents[f] = content.split("\n").slice(0, 200).join("\n");
+        } catch {
+        }
+      }
+      if (this.llm) {
+        const diagnosis = await this.diagnose(entry, fileContents);
+        log3.info("diagnosis complete", {
+          id: entry.id,
+          diagnosis: diagnosis.slice(0, 200)
+        });
+        if (this.config.auto_pr && ghAvailable()) {
+          await this.attemptFix(entry, diagnosis, fileContents);
+        }
+      } else {
+        log3.info("error detected (no LLM configured for diagnosis)", {
+          id: entry.id,
+          message: entry.message.slice(0, 120),
+          severity: entry.severity,
+          sourceFiles
+        });
+      }
+    } finally {
+      this.activeFixes.delete(entry.id);
+    }
+  }
+  // ---- LLM diagnosis -------------------------------------------------------
+  async diagnose(entry, fileContents) {
+    const fileSection = Object.entries(fileContents).map(([path, content]) => `--- ${path} ---
+${content}`).join("\n\n");
+    const messages = [
+      {
+        role: "system",
+        content: [
+          "You are a senior software engineer diagnosing a bug in the Hivemind agent framework (TypeScript/Node.js).",
+          "Analyze the error, identify the root cause, and suggest a concise fix.",
+          "Be specific: reference exact lines, variables, and logic flows.",
+          "If you cannot determine the cause from the given context, say so."
+        ].join("\n")
+      },
+      {
+        role: "user",
+        content: [
+          `## Error`,
+          `Message: ${entry.message}`,
+          `Level: ${entry.level}`,
+          `Source: ${entry.source}`,
+          `Occurrences: ${entry.totalOccurrences}`,
+          `First seen: ${entry.firstSeen}`,
+          `Last seen: ${entry.lastSeen}`,
+          entry.stackTrace ? `
+Stack trace:
+${entry.stackTrace}` : "",
+          fileSection ? `
+## Source files
+${fileSection}` : "",
+          "\n## Task",
+          "1. What is the root cause?",
+          "2. What is the minimal fix?",
+          "3. Are there any risks with the fix?"
+        ].join("\n")
+      }
+    ];
+    try {
+      const response = await this.llm.chat(messages);
+      return response.content;
+    } catch (err) {
+      log3.error("LLM diagnosis call failed", {
+        error: err.message
+      });
+      return `Diagnosis failed: ${err.message}`;
+    }
+  }
+  // ---- auto PR -------------------------------------------------------------
+  async attemptFix(entry, diagnosis, fileContents) {
+    const shortId = entry.id.slice(0, 8);
+    const branchName = `${this.config.branch_prefix}/${shortId}`;
+    if (run(`git rev-parse --verify ${branchName}`, this.repoRoot) !== null) {
+      log3.info("fix branch already exists, skipping", { branch: branchName });
+      return;
+    }
+    const fix = await this.generateFix(entry, diagnosis, fileContents);
+    if (!fix) {
+      log3.info("LLM could not generate a fix", { id: entry.id });
+      return;
+    }
+    const baseBranch = run("git rev-parse --abbrev-ref HEAD", this.repoRoot) || "main";
+    if (run(`git checkout -b ${branchName}`, this.repoRoot) === null) {
+      log3.error("failed to create fix branch", { branch: branchName });
+      return;
+    }
+    try {
+      let anyApplied = false;
+      for (const [filePath, newContent] of Object.entries(fix.files)) {
+        try {
+          __require("fs").writeFileSync(filePath, newContent);
+          run(`git add "${filePath}"`, this.repoRoot);
+          anyApplied = true;
+        } catch (err) {
+          log3.warn("failed to write fix file", {
+            file: filePath,
+            error: err.message
+          });
+        }
+      }
+      if (!anyApplied) {
+        log3.info("no files were patched, aborting PR", { id: entry.id });
+        return;
+      }
+      const buildResult = run("npx tsup", this.repoRoot);
+      if (buildResult === null) {
+        log3.warn("build failed after applying fix, aborting", { id: entry.id });
+        return;
+      }
+      const commitMsg = [
+        `fix(auto-debug): ${fix.summary}`,
+        "",
+        `Error: ${entry.message}`,
+        `Occurrences: ${entry.totalOccurrences} over ${this.formatTimespan(entry.firstSeen, entry.lastSeen)}`,
+        `Source: ${entry.source}`,
+        "",
+        `Root cause: ${fix.rootCause}`,
+        "",
+        "Auto-generated by hivemind auto-debug processor"
+      ].join("\n");
+      if (run(`git commit -m "${commitMsg.replace(/"/g, '\\"')}"`, this.repoRoot) === null) {
+        log3.error("git commit failed", { id: entry.id });
+        return;
+      }
+      if (run(`git push -u origin ${branchName}`, this.repoRoot) === null) {
+        log3.error("git push failed", { id: entry.id });
+        return;
+      }
+      const prBody = this.buildPrBody(entry, diagnosis, fix);
+      const prUrl = run(
+        `gh pr create --base ${baseBranch} --head ${branchName} --title "fix(auto-debug): ${fix.summary}" --body "${prBody.replace(/"/g, '\\"')}"`,
+        this.repoRoot
+      );
+      if (prUrl) {
+        this.registry.updateStatus(entry.id, "fix-submitted", prUrl);
+        log3.info("PR created", { id: entry.id, prUrl });
+      } else {
+        log3.error("gh pr create failed", { id: entry.id });
+      }
+    } finally {
+      run(`git checkout ${baseBranch}`, this.repoRoot);
+    }
+  }
+  async generateFix(entry, diagnosis, fileContents) {
+    if (!this.llm) return null;
+    const fileSection = Object.entries(fileContents).map(([path, content]) => `--- ${path} ---
+${content}`).join("\n\n");
+    const messages = [
+      {
+        role: "system",
+        content: [
+          "You are a senior TypeScript engineer. Generate a minimal, safe code fix.",
+          "Output ONLY valid JSON with this shape:",
+          '{ "summary": "short commit subject", "rootCause": "one sentence", "files": { "/absolute/path.ts": "full file content" } }',
+          "Do NOT include explanations outside the JSON. Do NOT modify files that don't need changing.",
+          "If you cannot produce a reliable fix, return null."
+        ].join("\n")
+      },
+      {
+        role: "user",
+        content: [
+          `## Error: ${entry.message}`,
+          entry.stackTrace ? `
+Stack trace:
+${entry.stackTrace}` : "",
+          `
+## Diagnosis
+${diagnosis}`,
+          `
+## Current source files
+${fileSection}`,
+          "\nGenerate the fix JSON."
+        ].join("\n")
+      }
+    ];
+    try {
+      const response = await this.llm.chat(messages);
+      const content = response.content.trim();
+      if (content === "null" || content === "null.") return null;
+      const jsonMatch = content.match(/```(?:json)?\s*([\s\S]*?)```/) || content.match(/(\{[\s\S]*\})/);
+      if (!jsonMatch) return null;
+      const parsed = JSON.parse(jsonMatch[1]);
+      if (!parsed.summary || !parsed.files || Object.keys(parsed.files).length === 0) {
+        return null;
+      }
+      for (const filePath of Object.keys(parsed.files)) {
+        if (!filePath.startsWith(this.repoRoot)) {
+          log3.warn("fix targets file outside repo, rejecting", { file: filePath });
+          return null;
+        }
+      }
+      return parsed;
+    } catch (err) {
+      log3.error("failed to generate fix", { error: err.message });
+      return null;
+    }
+  }
+  // ---- PR body builder -----------------------------------------------------
+  buildPrBody(entry, diagnosis, fix) {
+    const logSample = entry.stackTrace ? sanitize(entry.stackTrace.split("\n").slice(0, 15).join("\n")) : sanitize(entry.message);
+    return [
+      "## Auto-Debug Fix",
+      "",
+      `**Error:** \`${sanitize(entry.message).slice(0, 200)}\``,
+      `**Source:** ${entry.source}`,
+      `**Frequency:** ${entry.totalOccurrences} occurrences over ${this.formatTimespan(entry.firstSeen, entry.lastSeen)}`,
+      `**Severity:** ${entry.severity}/10`,
+      "",
+      "### Diagnosis",
+      sanitize(diagnosis),
+      "",
+      "### Fix",
+      sanitize(fix.rootCause),
+      "",
+      "### Log Sample",
+      "```",
+      logSample,
+      "```",
+      "",
+      "### Verification",
+      "- [ ] Build passes (`tsup`)",
+      "- [ ] Error no longer reproduces (monitored for 30 min post-deploy)",
+      "",
+      "---",
+      "*Auto-generated by hivemind auto-debug processor. Review before merging.*"
+    ].join("\n");
+  }
+  // ---- utils ---------------------------------------------------------------
+  formatTimespan(firstSeen, lastSeen) {
+    const ms = new Date(lastSeen).getTime() - new Date(firstSeen).getTime();
+    if (ms < 6e4) return `${Math.round(ms / 1e3)}s`;
+    if (ms < 36e5) return `${Math.round(ms / 6e4)}m`;
+    if (ms < 864e5) return `${Math.round(ms / 36e5)}h`;
+    return `${Math.round(ms / 864e5)}d`;
+  }
+};
+
 // packages/runtime/src/pipeline.ts
 import { createServer as createServer3 } from "http";
 
@@ -3594,23 +4602,23 @@ var HEALTH_PATH = "/health";
 
 // packages/runtime/src/request-logger.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { mkdirSync as mkdirSync4, existsSync as existsSync6, appendFileSync as appendFileSync2, readFileSync as readFileSync7, writeFileSync } from "fs";
-import { dirname as dirname4 } from "path";
+import { mkdirSync as mkdirSync5, existsSync as existsSync9, appendFileSync as appendFileSync2, readFileSync as readFileSync10, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname5 } from "path";
 var RequestLogger = class {
   logPath;
   maxAgeDays = 7;
   constructor(dbPath) {
     this.logPath = dbPath.replace(/\.db$/, ".jsonl");
     if (this.logPath === dbPath) this.logPath = dbPath + ".jsonl";
-    const dir = dirname4(this.logPath);
-    if (!existsSync6(dir)) mkdirSync4(dir, { recursive: true });
+    const dir = dirname5(this.logPath);
+    if (!existsSync9(dir)) mkdirSync5(dir, { recursive: true });
     this.prune();
   }
   prune() {
-    if (!existsSync6(this.logPath)) return;
+    if (!existsSync9(this.logPath)) return;
     const cutoff = new Date(Date.now() - this.maxAgeDays * 24 * 60 * 60 * 1e3).toISOString();
     try {
-      const lines = readFileSync7(this.logPath, "utf-8").split("\n").filter(Boolean);
+      const lines = readFileSync10(this.logPath, "utf-8").split("\n").filter(Boolean);
       const kept = [];
       let pruned = 0;
       for (const line of lines) {
@@ -3625,7 +4633,7 @@ var RequestLogger = class {
         }
       }
       if (pruned > 0) {
-        writeFileSync(this.logPath, kept.join("\n") + (kept.length > 0 ? "\n" : ""));
+        writeFileSync2(this.logPath, kept.join("\n") + (kept.length > 0 ? "\n" : ""));
         console.log(`[dashboard] Pruned ${pruned} old request logs`);
       }
     } catch {
@@ -3686,9 +4694,9 @@ var RequestLogger = class {
   close() {
   }
   readAll() {
-    if (!existsSync6(this.logPath)) return [];
+    if (!existsSync9(this.logPath)) return [];
     try {
-      const lines = readFileSync7(this.logPath, "utf-8").split("\n").filter(Boolean);
+      const lines = readFileSync10(this.logPath, "utf-8").split("\n").filter(Boolean);
       const entries = [];
       for (const line of lines) {
         try {
@@ -3705,17 +4713,17 @@ var RequestLogger = class {
 
 // packages/runtime/src/dashboard.ts
 import { createServer } from "http";
-import { readFileSync as readFileSync8 } from "fs";
-import { resolve as resolve6, dirname as dirname5 } from "path";
+import { readFileSync as readFileSync11 } from "fs";
+import { resolve as resolve7, dirname as dirname6 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-var __dirname = dirname5(fileURLToPath2(import.meta.url));
+var __dirname = dirname6(fileURLToPath2(import.meta.url));
 var DASHBOARD_PORT = 9485;
 var spaHtml = null;
 function getSpaHtml() {
   if (!spaHtml) {
-    for (const dir of [__dirname, resolve6(__dirname, "../src")]) {
+    for (const dir of [__dirname, resolve7(__dirname, "../src")]) {
       try {
-        spaHtml = readFileSync8(resolve6(dir, "dashboard.html"), "utf-8");
+        spaHtml = readFileSync11(resolve7(dir, "dashboard.html"), "utf-8");
         break;
       } catch {
       }
@@ -3741,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();
@@ -3796,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]);
@@ -3817,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);
@@ -3890,8 +4991,8 @@ var ToolRegistry = class {
 };
 
 // packages/runtime/src/tools/shell.ts
-import { execSync as execSync3 } from "child_process";
-import { resolve as resolve7 } from "path";
+import { execSync as execSync4 } from "child_process";
+import { resolve as resolve8 } from "path";
 var MAX_OUTPUT = 5e4;
 function registerShellTool(registry, workspaceDir) {
   registry.register(
@@ -3918,9 +5019,9 @@ function registerShellTool(registry, workspaceDir) {
     async (params) => {
       const command = params.command;
       const timeout = (params.timeout || 30) * 1e3;
-      const cwd = params.workdir ? resolve7(workspaceDir, params.workdir) : workspaceDir;
+      const cwd = params.workdir ? resolve8(workspaceDir, params.workdir) : workspaceDir;
       try {
-        const output = execSync3(command, {
+        const output = execSync4(command, {
           cwd,
           timeout,
           encoding: "utf-8",
@@ -3945,8 +5046,8 @@ ${output || err.message}`;
 }
 
 // packages/runtime/src/tools/files.ts
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync2, existsSync as existsSync7, mkdirSync as mkdirSync5 } from "fs";
-import { resolve as resolve8, dirname as dirname6 } from "path";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync3, existsSync as existsSync10, mkdirSync as mkdirSync6 } from "fs";
+import { resolve as resolve9, dirname as dirname7 } from "path";
 var MAX_READ = 1e5;
 function registerFileTools(registry, workspaceDir) {
   registry.register(
@@ -3972,11 +5073,11 @@ function registerFileTools(registry, workspaceDir) {
     },
     async (params) => {
       const filePath = resolvePath(workspaceDir, params.path);
-      if (!existsSync7(filePath)) {
+      if (!existsSync10(filePath)) {
         return `Error: File not found: ${filePath}`;
       }
       try {
-        let content = readFileSync9(filePath, "utf-8");
+        let content = readFileSync12(filePath, "utf-8");
         if (params.offset || params.limit) {
           const lines = content.split("\n");
           const start = (params.offset || 1) - 1;
@@ -4013,9 +5114,9 @@ function registerFileTools(registry, workspaceDir) {
     async (params) => {
       const filePath = resolvePath(workspaceDir, params.path);
       try {
-        const dir = dirname6(filePath);
-        if (!existsSync7(dir)) mkdirSync5(dir, { recursive: true });
-        writeFileSync2(filePath, params.content);
+        const dir = dirname7(filePath);
+        if (!existsSync10(dir)) mkdirSync6(dir, { recursive: true });
+        writeFileSync3(filePath, params.content);
         return `Written ${params.content.length} bytes to ${filePath}`;
       } catch (err) {
         return `Error writing file: ${err.message}`;
@@ -4045,18 +5146,18 @@ function registerFileTools(registry, workspaceDir) {
     },
     async (params) => {
       const filePath = resolvePath(workspaceDir, params.path);
-      if (!existsSync7(filePath)) {
+      if (!existsSync10(filePath)) {
         return `Error: File not found: ${filePath}`;
       }
       try {
-        const content = readFileSync9(filePath, "utf-8");
+        const content = readFileSync12(filePath, "utf-8");
         const oldText = params.old_text;
         const newText = params.new_text;
         if (!content.includes(oldText)) {
           return `Error: Could not find the exact text to replace in ${filePath}`;
         }
         const updated = content.replace(oldText, newText);
-        writeFileSync2(filePath, updated);
+        writeFileSync3(filePath, updated);
         return `Edited ${filePath}: replaced ${oldText.length} chars with ${newText.length} chars`;
       } catch (err) {
         return `Error editing file: ${err.message}`;
@@ -4077,9 +5178,9 @@ function registerFileTools(registry, workspaceDir) {
       required: []
     },
     async (params) => {
-      const { readdirSync: readdirSync5, statSync: statSync3 } = await import("fs");
+      const { readdirSync: readdirSync5, statSync: statSync4 } = await import("fs");
       const dirPath = params.path ? resolvePath(workspaceDir, params.path) : workspaceDir;
-      if (!existsSync7(dirPath)) {
+      if (!existsSync10(dirPath)) {
         return `Error: Directory not found: ${dirPath}`;
       }
       try {
@@ -4088,7 +5189,7 @@ function registerFileTools(registry, workspaceDir) {
         for (const entry of entries) {
           if (entry.startsWith(".")) continue;
           try {
-            const stat = statSync3(resolve8(dirPath, entry));
+            const stat = statSync4(resolve9(dirPath, entry));
             results.push(stat.isDirectory() ? `${entry}/` : entry);
           } catch {
             results.push(entry);
@@ -4105,7 +5206,7 @@ function resolvePath(workspace, path) {
   if (path.startsWith("/") || path.startsWith("~")) {
     return path.replace(/^~/, process.env.HOME || "/root");
   }
-  return resolve8(workspace, path);
+  return resolve9(workspace, path);
 }
 
 // packages/runtime/src/tools/web.ts
@@ -4358,13 +5459,13 @@ Contexts:
 }
 
 // packages/runtime/src/tools/events.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync6, readdirSync as readdirSync4, readFileSync as readFileSync10, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync7, readdirSync as readdirSync4, readFileSync as readFileSync13, unlinkSync as unlinkSync2, writeFileSync as writeFileSync4 } from "fs";
 import { join as join4 } from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 function registerEventTools(registry, dataDir) {
   const eventsDir = join4(dataDir, "events");
-  if (!existsSync8(eventsDir)) {
-    mkdirSync6(eventsDir, { recursive: true });
+  if (!existsSync11(eventsDir)) {
+    mkdirSync7(eventsDir, { recursive: true });
   }
   registry.register(
     "create_event",
@@ -4433,7 +5534,7 @@ function registerEventTools(registry, dataDir) {
       const filename = `${randomUUID3()}.json`;
       const filePath = join4(eventsDir, filename);
       try {
-        writeFileSync3(filePath, JSON.stringify(event, null, 2));
+        writeFileSync4(filePath, JSON.stringify(event, null, 2));
         return `Event created: ${filename} (type: ${type})`;
       } catch (err) {
         return `Error creating event: ${err.message}`;
@@ -4450,7 +5551,7 @@ function registerEventTools(registry, dataDir) {
     },
     async () => {
       try {
-        if (!existsSync8(eventsDir)) {
+        if (!existsSync11(eventsDir)) {
           return "No events directory found.";
         }
         const files = readdirSync4(eventsDir).filter((f) => f.endsWith(".json"));
@@ -4460,7 +5561,7 @@ function registerEventTools(registry, dataDir) {
         const lines = [];
         for (const file of files) {
           try {
-            const content = readFileSync10(join4(eventsDir, file), "utf-8");
+            const content = readFileSync13(join4(eventsDir, file), "utf-8");
             const event = JSON.parse(content);
             let detail = `${file} \u2014 type: ${event.type}, channel: ${event.channelId}`;
             if (event.type === "one-shot") {
@@ -4500,7 +5601,7 @@ ${lines.join("\n")}`;
       if (filename.includes("/") || filename.includes("\\") || filename.includes("..")) {
         return "Error: Invalid filename.";
       }
-      if (!existsSync8(filePath)) {
+      if (!existsSync11(filePath)) {
         return `Event not found: ${filename}`;
       }
       try {
@@ -4515,16 +5616,16 @@ ${lines.join("\n")}`;
 
 // packages/runtime/src/tools/spawn.ts
 import { spawn } from "child_process";
-import { existsSync as existsSync9, mkdirSync as mkdirSync7, readFileSync as readFileSync11, writeFileSync as writeFileSync4 } from "fs";
-import { join as join5, resolve as resolve9 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync8, readFileSync as readFileSync14, writeFileSync as writeFileSync5 } from "fs";
+import { join as join5, resolve as resolve10 } from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 var spawnedAgents = /* @__PURE__ */ new Map();
 function registerSpawnTools(registry, hivemindHome, dataDir, configPath) {
   const spawnDir = join5(dataDir, "spawn");
-  if (!existsSync9(spawnDir)) {
-    mkdirSync7(spawnDir, { recursive: true });
+  if (!existsSync12(spawnDir)) {
+    mkdirSync8(spawnDir, { recursive: true });
   }
-  const hivemindBin = resolve9(hivemindHome, "node_modules", ".bin", "hivemind");
+  const hivemindBin = resolve10(hivemindHome, "node_modules", ".bin", "hivemind");
   registry.register(
     "spawn_agent",
     "Fork a new hivemind process to run an isolated task. The sub-agent gets its own context, processes the task, and exits. Use for parallel work, long-running tasks, or tasks that need isolation.",
@@ -4557,8 +5658,8 @@ function registerSpawnTools(registry, hivemindHome, dataDir, configPath) {
       const channelId = params.channelId;
       const timeoutSeconds = params.timeoutSeconds || 300;
       const spawnWorkDir = join5(spawnDir, spawnId);
-      mkdirSync7(spawnWorkDir, { recursive: true });
-      writeFileSync4(join5(spawnWorkDir, "task.md"), task);
+      mkdirSync8(spawnWorkDir, { recursive: true });
+      writeFileSync5(join5(spawnWorkDir, "task.md"), task);
       const childEnv = {
         ...process.env,
         SPAWN_TASK: task,
@@ -4600,7 +5701,7 @@ function registerSpawnTools(registry, hivemindHome, dataDir, configPath) {
           agent.exitCode = code;
           agent.exited = true;
           try {
-            writeFileSync4(logPath, Buffer.concat(logChunks).toString("utf-8"));
+            writeFileSync5(logPath, Buffer.concat(logChunks).toString("utf-8"));
           } catch {
           }
         });
@@ -4613,7 +5714,7 @@ function registerSpawnTools(registry, hivemindHome, dataDir, configPath) {
             agent.exited = true;
             agent.exitCode = -1;
             try {
-              writeFileSync4(
+              writeFileSync5(
                 join5(spawnWorkDir, "result.txt"),
                 `[TIMEOUT] Sub-agent killed after ${timeoutSeconds}s`
               );
@@ -4668,9 +5769,9 @@ function registerSpawnTools(registry, hivemindHome, dataDir, configPath) {
   task: "${taskPreview}"`;
         if (agent.exited) {
           const resultPath = join5(spawnDir, id, "result.txt");
-          if (existsSync9(resultPath)) {
+          if (existsSync12(resultPath)) {
             try {
-              const result = readFileSync11(resultPath, "utf-8");
+              const result = readFileSync14(resultPath, "utf-8");
               const preview = result.length > 200 ? result.slice(0, 200) + "..." : result;
               detail += `
   result: "${preview}"`;
@@ -4710,7 +5811,7 @@ ${lines.join("\n\n")}`;
         agent.process.kill("SIGTERM");
         agent.exited = true;
         agent.exitCode = -2;
-        writeFileSync4(
+        writeFileSync5(
           join5(spawnDir, id, "result.txt"),
           `[KILLED] Sub-agent killed by parent agent`
         );
@@ -4793,11 +5894,11 @@ function registerVisionTools(registry) {
 }
 
 // packages/runtime/src/tools/git.ts
-import { execSync as execSync4 } from "child_process";
-import { resolve as resolve10, normalize } from "path";
+import { execSync as execSync5 } from "child_process";
+import { resolve as resolve11, normalize } from "path";
 function resolveRepoPath(workspaceDir, repoPath) {
   if (!repoPath) return workspaceDir;
-  const resolved = resolve10(workspaceDir, repoPath);
+  const resolved = resolve11(workspaceDir, repoPath);
   const normalizedResolved = normalize(resolved);
   const normalizedWorkspace = normalize(workspaceDir);
   if (!normalizedResolved.startsWith(normalizedWorkspace)) {
@@ -4806,7 +5907,7 @@ function resolveRepoPath(workspaceDir, repoPath) {
   return resolved;
 }
 function runGit(args, cwd) {
-  const output = execSync4(`git ${args}`, {
+  const output = execSync5(`git ${args}`, {
     cwd,
     timeout: 3e4,
     encoding: "utf-8",
@@ -5030,11 +6131,12 @@ ${combined}`;
 }
 
 // packages/runtime/src/tools/browser.ts
-import { resolve as resolve11 } from "path";
-import { mkdirSync as mkdirSync8, existsSync as existsSync10 } from "fs";
+import { resolve as resolve12 } from "path";
+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;
@@ -5043,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) {
@@ -5060,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();
@@ -5074,18 +6221,30 @@ async function closeBrowser() {
   }
 }
 function registerBrowserTools(registry, workspaceDir) {
-  const screenshotDir = resolve11(workspaceDir, "screenshots");
+  const screenshotDir = resolve12(workspaceDir, "screenshots");
   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",
@@ -5096,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."
@@ -5128,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) {
@@ -5158,20 +6411,39 @@ function registerBrowserTools(registry, workspaceDir) {
             return trimmed;
           }
           case "screenshot": {
-            if (!existsSync10(screenshotDir)) {
-              mkdirSync8(screenshotDir, { recursive: true });
+            if (!existsSync13(screenshotDir)) {
+              mkdirSync9(screenshotDir, { recursive: true });
             }
             const filename = `${randomUUID5()}.png`;
-            const filepath = resolve11(screenshotDir, filename);
+            const filepath = resolve12(screenshotDir, filename);
             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) {
@@ -5183,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.";
@@ -5196,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}`;
@@ -5210,10 +6645,102 @@ 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
-import { execSync as execSync5 } from "child_process";
+import { execSync as execSync6 } from "child_process";
 import * as os from "os";
 var MAX_OUTPUT3 = 5e4;
 function truncate(output) {
@@ -5224,7 +6751,7 @@ function truncate(output) {
   return output;
 }
 function exec(cmd, timeoutS = 10) {
-  return execSync5(cmd, {
+  return execSync6(cmd, {
     encoding: "utf-8",
     timeout: timeoutS * 1e3,
     maxBuffer: 10 * 1024 * 1024,
@@ -5471,8 +6998,8 @@ function fmt(bytes) {
 
 // packages/runtime/src/tools/http-server.ts
 import { createServer as createServer2 } from "http";
-import { createReadStream, existsSync as existsSync11, statSync as statSync2 } from "fs";
-import { join as join6, extname, resolve as resolve12 } from "path";
+import { createReadStream, existsSync as existsSync14, statSync as statSync3 } from "fs";
+import { join as join6, extname, resolve as resolve13 } from "path";
 var MAX_BODY = 5e4;
 var activeServers = /* @__PURE__ */ new Map();
 var MIME_TYPES = {
@@ -5489,16 +7016,16 @@ var MIME_TYPES = {
 function serveStatic(baseDir, req, res) {
   const urlPath = (req.url || "/").split("?")[0];
   let filePath = join6(baseDir, urlPath === "/" ? "index.html" : urlPath);
-  if (!resolve12(filePath).startsWith(resolve12(baseDir))) {
+  if (!resolve13(filePath).startsWith(resolve13(baseDir))) {
     res.writeHead(403);
     res.end("Forbidden");
     return true;
   }
-  if (!existsSync11(filePath)) return false;
-  const stat = statSync2(filePath);
+  if (!existsSync14(filePath)) return false;
+  const stat = statSync3(filePath);
   if (stat.isDirectory()) {
     filePath = join6(filePath, "index.html");
-    if (!existsSync11(filePath)) return false;
+    if (!existsSync14(filePath)) return false;
   }
   const ext = extname(filePath);
   const mime = MIME_TYPES[ext] || "application/octet-stream";
@@ -5551,8 +7078,8 @@ function registerHttpTools(registry, workspaceDir) {
       if (activeServers.has(port)) {
         return `Error: A server is already running on port ${port}. Stop it first with http_stop.`;
       }
-      const staticDir = directory ? resolve12(workspaceDir, directory) : void 0;
-      if (staticDir && !existsSync11(staticDir)) {
+      const staticDir = directory ? resolve13(workspaceDir, directory) : void 0;
+      if (staticDir && !existsSync14(staticDir)) {
         return `Error: Directory not found: ${directory}`;
       }
       return new Promise((resolvePromise) => {
@@ -5688,8 +7215,8 @@ function registerHttpTools(registry, workspaceDir) {
 }
 
 // packages/runtime/src/tools/watch.ts
-import { watch as watch3, existsSync as existsSync12, mkdirSync as mkdirSync9, writeFileSync as writeFileSync5 } from "fs";
-import { join as join7, resolve as resolve13 } from "path";
+import { watch as watch3, existsSync as existsSync15, mkdirSync as mkdirSync10, writeFileSync as writeFileSync6 } from "fs";
+import { join as join7, resolve as resolve14 } from "path";
 import { randomUUID as randomUUID6 } from "crypto";
 var activeWatchers = /* @__PURE__ */ new Map();
 function registerWatchTools(registry, workspaceDir, dataDir) {
@@ -5722,15 +7249,15 @@ function registerWatchTools(registry, workspaceDir, dataDir) {
       if (activeWatchers.has(id)) {
         return `Error: A watcher with id '${id}' already exists. Stop it first or use a different id.`;
       }
-      const absolutePath = resolve13(workspaceDir, relPath);
-      if (!absolutePath.startsWith(resolve13(workspaceDir))) {
+      const absolutePath = resolve14(workspaceDir, relPath);
+      if (!absolutePath.startsWith(resolve14(workspaceDir))) {
         return "Error: Path must be within the workspace directory.";
       }
-      if (!existsSync12(absolutePath)) {
+      if (!existsSync15(absolutePath)) {
         return `Error: Path not found: ${relPath}`;
       }
-      if (!existsSync12(eventsDir)) {
-        mkdirSync9(eventsDir, { recursive: true });
+      if (!existsSync15(eventsDir)) {
+        mkdirSync10(eventsDir, { recursive: true });
       }
       try {
         let debounceTimer = null;
@@ -5746,7 +7273,7 @@ function registerWatchTools(registry, workspaceDir, dataDir) {
           };
           const eventFile = join7(eventsDir, `watch-${id}-${Date.now()}.json`);
           try {
-            writeFileSync5(eventFile, JSON.stringify(event, null, 2));
+            writeFileSync6(eventFile, JSON.stringify(event, null, 2));
           } catch {
           }
         });
@@ -5815,13 +7342,13 @@ ${lines.join("\n")}`;
 }
 
 // packages/runtime/src/tools/macos.ts
-import { execSync as execSync6 } from "child_process";
-import { resolve as resolve14, normalize as normalize2 } from "path";
-import { mkdirSync as mkdirSync10, existsSync as existsSync13 } from "fs";
+import { execSync as execSync7 } from "child_process";
+import { resolve as resolve15, normalize as normalize2 } from "path";
+import { mkdirSync as mkdirSync11, existsSync as existsSync16 } from "fs";
 import { randomUUID as randomUUID7 } from "crypto";
 var MAX_OUTPUT4 = 5e4;
 function shellExec(command, timeoutMs) {
-  return execSync6(command, {
+  return execSync7(command, {
     timeout: timeoutMs,
     encoding: "utf-8",
     maxBuffer: 10 * 1024 * 1024,
@@ -5932,7 +7459,7 @@ ${output || err.message}`;
     async (params) => {
       const content = params.content;
       try {
-        execSync6("pbcopy", {
+        execSync7("pbcopy", {
           input: content,
           timeout: 5e3,
           encoding: "utf-8",
@@ -5995,26 +7522,26 @@ ${output || err.message}`;
       try {
         let savePath;
         if (params.path) {
-          savePath = resolve14(workspaceDir, params.path);
+          savePath = resolve15(workspaceDir, params.path);
           const normalizedSave = normalize2(savePath);
           const normalizedWorkspace = normalize2(workspaceDir);
           if (!normalizedSave.startsWith(normalizedWorkspace)) {
             return "Error: path must be within the workspace.";
           }
         } else {
-          const screenshotDir = resolve14(workspaceDir, "screenshots");
-          if (!existsSync13(screenshotDir)) {
-            mkdirSync10(screenshotDir, { recursive: true });
+          const screenshotDir = resolve15(workspaceDir, "screenshots");
+          if (!existsSync16(screenshotDir)) {
+            mkdirSync11(screenshotDir, { recursive: true });
           }
-          savePath = resolve14(screenshotDir, `${randomUUID7()}.png`);
+          savePath = resolve15(screenshotDir, `${randomUUID7()}.png`);
         }
-        const parentDir = resolve14(savePath, "..");
-        if (!existsSync13(parentDir)) {
-          mkdirSync10(parentDir, { recursive: true });
+        const parentDir = resolve15(savePath, "..");
+        if (!existsSync16(parentDir)) {
+          mkdirSync11(parentDir, { recursive: true });
         }
         const args = params.region ? `screencapture -i ${escapeShellArg(savePath)}` : `screencapture -x ${escapeShellArg(savePath)}`;
         shellExec(args, 15e3);
-        if (!existsSync13(savePath)) {
+        if (!existsSync16(savePath)) {
           return "Screenshot cancelled or failed \u2014 no file was created.";
         }
         return `Screenshot saved: ${savePath}`;
@@ -6032,12 +7559,12 @@ function escapeAppleString(s) {
 }
 
 // packages/runtime/src/tools/data.ts
-import { execSync as execSync7 } from "child_process";
-import { resolve as resolve15, normalize as normalize3, extname as extname2 } from "path";
-import { mkdirSync as mkdirSync11, existsSync as existsSync14 } from "fs";
+import { execSync as execSync8 } from "child_process";
+import { resolve as resolve16, normalize as normalize3, extname as extname2 } from "path";
+import { mkdirSync as mkdirSync12, existsSync as existsSync17 } from "fs";
 var MAX_OUTPUT5 = 5e4;
 function shellExec2(command, cwd, timeoutMs) {
-  return execSync7(command, {
+  return execSync8(command, {
     cwd,
     timeout: timeoutMs,
     encoding: "utf-8",
@@ -6047,7 +7574,7 @@ function shellExec2(command, cwd, timeoutMs) {
   });
 }
 function safePath(workspaceDir, filePath) {
-  const resolved = resolve15(workspaceDir, filePath);
+  const resolved = resolve16(workspaceDir, filePath);
   const normalizedResolved = normalize3(resolved);
   const normalizedWorkspace = normalize3(workspaceDir);
   if (!normalizedResolved.startsWith(normalizedWorkspace)) {
@@ -6087,7 +7614,7 @@ function registerDataTools(registry, workspaceDir) {
       const queryParams = params.params;
       try {
         const dbPath = safePath(workspaceDir, dbRelative);
-        if (!existsSync14(dbPath) && !query.trim().toUpperCase().startsWith("CREATE")) {
+        if (!existsSync17(dbPath) && !query.trim().toUpperCase().startsWith("CREATE")) {
           return `Error: database file not found: ${dbRelative}`;
         }
         let fullQuery = query;
@@ -6148,16 +7675,16 @@ function registerDataTools(registry, workspaceDir) {
       try {
         const sourcePath = safePath(workspaceDir, source);
         const outputPath = safePath(workspaceDir, output);
-        if (!existsSync14(sourcePath)) {
+        if (!existsSync17(sourcePath)) {
           return `Error: source not found: ${source}`;
         }
-        const outputParent = resolve15(outputPath, "..");
-        if (!existsSync14(outputParent)) {
-          mkdirSync11(outputParent, { recursive: true });
+        const outputParent = resolve16(outputPath, "..");
+        if (!existsSync17(outputParent)) {
+          mkdirSync12(outputParent, { recursive: true });
         }
         let command;
         if (format === "tar.gz") {
-          command = `tar czf ${escapeShellArg2(outputPath)} -C ${escapeShellArg2(resolve15(sourcePath, ".."))} ${escapeShellArg2(sourcePath.split("/").pop())}`;
+          command = `tar czf ${escapeShellArg2(outputPath)} -C ${escapeShellArg2(resolve16(sourcePath, ".."))} ${escapeShellArg2(sourcePath.split("/").pop())}`;
         } else {
           command = `zip -r ${escapeShellArg2(outputPath)} ${escapeShellArg2(source)}`;
         }
@@ -6192,11 +7719,11 @@ function registerDataTools(registry, workspaceDir) {
       try {
         const archivePath = safePath(workspaceDir, archive);
         const destPath = destination ? safePath(workspaceDir, destination) : workspaceDir;
-        if (!existsSync14(archivePath)) {
+        if (!existsSync17(archivePath)) {
           return `Error: archive not found: ${archive}`;
         }
-        if (!existsSync14(destPath)) {
-          mkdirSync11(destPath, { recursive: true });
+        if (!existsSync17(destPath)) {
+          mkdirSync12(destPath, { recursive: true });
         }
         const ext = extname2(archivePath).toLowerCase();
         const isGz = archivePath.endsWith(".tar.gz") || archivePath.endsWith(".tgz");
@@ -6237,7 +7764,7 @@ ${trimmed}`.trim();
       const filePath = params.path;
       try {
         const pdfPath = safePath(workspaceDir, filePath);
-        if (!existsSync14(pdfPath)) {
+        if (!existsSync17(pdfPath)) {
           return `Error: PDF not found: ${filePath}`;
         }
         try {
@@ -6278,8 +7805,8 @@ function truncate2(text) {
 }
 
 // packages/runtime/src/tools/coding-agent.ts
-import { execSync as execSync8 } from "child_process";
-import { resolve as resolve16 } from "path";
+import { execSync as execSync9 } from "child_process";
+import { resolve as resolve17 } from "path";
 var MAX_OUTPUT6 = 5e4;
 function registerCodingAgentTools(registry, workspaceDir) {
   registry.register(
@@ -6306,18 +7833,18 @@ function registerCodingAgentTools(registry, workspaceDir) {
     async (params) => {
       const task = params.task;
       const timeoutSeconds = params.timeout || 300;
-      const cwd = params.workdir ? resolve16(workspaceDir, params.workdir) : workspaceDir;
+      const cwd = params.workdir ? resolve17(workspaceDir, params.workdir) : workspaceDir;
       const homedir = process.env.HOME || "/root";
       const extendedPath = `${homedir}/.local/bin:/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:${process.env.PATH}`;
       try {
-        execSync8("which claude", { stdio: "ignore", env: { ...process.env, PATH: extendedPath } });
+        execSync9("which claude", { stdio: "ignore", env: { ...process.env, PATH: extendedPath } });
       } catch {
         return "Error: 'claude' CLI not found. Install Claude Code first: https://docs.anthropic.com/en/docs/claude-code";
       }
       const escapedTask = task.replace(/'/g, "'\\''");
       const command = `claude --dangerously-skip-permissions -p '${escapedTask}'`;
       try {
-        const output = execSync8(command, {
+        const output = execSync9(command, {
           cwd,
           timeout: timeoutSeconds * 1e3,
           encoding: "utf-8",
@@ -6348,22 +7875,22 @@ ${output || err.message}`;
 }
 
 // packages/runtime/src/tools/register.ts
-import { resolve as resolve17 } from "path";
-import { mkdirSync as mkdirSync12, existsSync as existsSync15 } from "fs";
+import { resolve as resolve18 } from "path";
+import { mkdirSync as mkdirSync13, existsSync as existsSync18 } from "fs";
 function registerAllTools(hivemindHome, config) {
   const registry = new ToolRegistry();
   if (config?.enabled === false) {
     return registry;
   }
-  const workspaceDir = resolve17(hivemindHome, config?.workspace || "workspace");
-  if (!existsSync15(workspaceDir)) {
-    mkdirSync12(workspaceDir, { recursive: true });
+  const workspaceDir = resolve18(hivemindHome, config?.workspace || "workspace");
+  if (!existsSync18(workspaceDir)) {
+    mkdirSync13(workspaceDir, { recursive: true });
   }
   registerShellTool(registry, workspaceDir);
   registerFileTools(registry, workspaceDir);
   registerWebTools(registry, { braveApiKey: config?.braveApiKey });
   registerMemoryTools(registry, config?.memoryDaemonUrl || "http://localhost:3434");
-  const dataDir = resolve17(hivemindHome, "data");
+  const dataDir = resolve18(hivemindHome, "data");
   registerEventTools(registry, dataDir);
   if (config?.configPath && !process.env.SPAWN_TASK) {
     registerSpawnTools(registry, hivemindHome, dataDir, config.configPath);
@@ -6413,10 +7940,10 @@ function registerMessagingTools(registry, sesame) {
 }
 
 // packages/runtime/src/tools/skills-tools.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync13, writeFileSync as writeFileSync6, rmSync } from "fs";
-import { resolve as resolve18 } from "path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync14, writeFileSync as writeFileSync7, rmSync } from "fs";
+import { resolve as resolve19 } from "path";
 function registerSkillsTools(registry, skillsEngine, workspaceDir) {
-  const skillsDir = resolve18(workspaceDir, "skills");
+  const skillsDir = resolve19(workspaceDir, "skills");
   registry.register(
     "skill_list",
     "List all loaded skills with their registered tools and status.",
@@ -6483,11 +8010,11 @@ ${lines.join("\n\n")}`;
       const name = params.name;
       const description = params.description;
       const tools = params.tools;
-      const skillDir = resolve18(skillsDir, name);
-      if (existsSync16(skillDir)) {
+      const skillDir = resolve19(skillsDir, name);
+      if (existsSync19(skillDir)) {
         return `Error: Skill directory "${name}" already exists. Use skill_reload to update it.`;
       }
-      mkdirSync13(skillDir, { recursive: true });
+      mkdirSync14(skillDir, { recursive: true });
       const skillMd = `---
 name: "${name}"
 description: "${description}"
@@ -6497,7 +8024,7 @@ description: "${description}"
 
 ${description}
 `;
-      writeFileSync6(resolve18(skillDir, "SKILL.md"), skillMd);
+      writeFileSync7(resolve19(skillDir, "SKILL.md"), skillMd);
       if (tools && tools.length > 0) {
         const toolsDef = {
           tools: tools.map((t) => ({
@@ -6507,7 +8034,7 @@ ${description}
             command: t.command
           }))
         };
-        writeFileSync6(resolve18(skillDir, "tools.json"), JSON.stringify(toolsDef, null, 2) + "\n");
+        writeFileSync7(resolve19(skillDir, "tools.json"), JSON.stringify(toolsDef, null, 2) + "\n");
       }
       try {
         await skillsEngine.loadSkill(name);
@@ -6560,8 +8087,8 @@ Path: ${skillDir}`;
     },
     async (params) => {
       const name = params.name;
-      const skillDir = resolve18(skillsDir, name);
-      if (!existsSync16(skillDir)) {
+      const skillDir = resolve19(skillsDir, name);
+      if (!existsSync19(skillDir)) {
         return `Error: Skill directory "${name}" does not exist.`;
       }
       try {
@@ -6580,13 +8107,13 @@ Path: ${skillDir}`;
 }
 
 // packages/runtime/src/pipeline.ts
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync7, unlinkSync as unlinkSync3 } from "fs";
-import { resolve as resolve19, dirname as dirname7 } from "path";
+import { readFileSync as readFileSync15, writeFileSync as writeFileSync8, unlinkSync as unlinkSync3 } from "fs";
+import { resolve as resolve20, dirname as dirname8 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var PACKAGE_VERSION = "unknown";
 try {
-  const __dirname2 = dirname7(fileURLToPath3(import.meta.url));
-  const pkg = JSON.parse(readFileSync12(resolve19(__dirname2, "../package.json"), "utf-8"));
+  const __dirname2 = dirname8(fileURLToPath3(import.meta.url));
+  const pkg = JSON.parse(readFileSync15(resolve20(__dirname2, "../package.json"), "utf-8"));
   PACKAGE_VERSION = pkg.version ?? "unknown";
 } catch {
 }
@@ -6628,7 +8155,7 @@ function startHealthServer(port) {
   return server;
 }
 function writePidFile(path) {
-  writeFileSync7(path, String(process.pid));
+  writeFileSync8(path, String(process.pid));
   console.log(`[hivemind] PID file written: ${path}`);
 }
 function cleanupPidFile(path) {
@@ -6669,11 +8196,11 @@ async function startPipeline(configPath) {
       console.log("[hivemind] Global context already exists in memory daemon");
     }
   }
-  const requestLogger = new RequestLogger(resolve19(dirname7(configPath), "data", "dashboard.db"));
-  startDashboardServer(requestLogger, config.memory);
+  const requestLogger = new RequestLogger(resolve20(dirname8(configPath), "data", "dashboard.db"));
   const agent = new Agent(config);
+  startDashboardServer(requestLogger, config.memory, () => agent.getConversationHistories());
   agent.setRequestLogger(requestLogger);
-  const hivemindHome = process.env.HIVEMIND_HOME || resolve19(process.env.HOME || "/root", "hivemind");
+  const hivemindHome = process.env.HIVEMIND_HOME || resolve20(process.env.HOME || "/root", "hivemind");
   const toolRegistry = registerAllTools(hivemindHome, {
     enabled: true,
     workspace: config.agent.workspace || "workspace",
@@ -6681,7 +8208,7 @@ async function startPipeline(configPath) {
     memoryDaemonUrl: config.memory.daemon_url,
     configPath
   });
-  const workspaceDir = resolve19(hivemindHome, config.agent.workspace || "workspace");
+  const workspaceDir = resolve20(hivemindHome, config.agent.workspace || "workspace");
   const skillsEngine = new SkillsEngine(workspaceDir, toolRegistry);
   await skillsEngine.loadAll();
   registerSkillsTools(toolRegistry, skillsEngine, workspaceDir);
@@ -6689,7 +8216,50 @@ async function startPipeline(configPath) {
   process.on("exit", () => skillsEngine.stopWatching());
   agent.setToolRegistry(toolRegistry);
   console.log(`[hivemind] Context manager initialized (active: ${agent.getActiveContext()})`);
-  const dataDir = resolve19(hivemindHome, "data");
+  if (config.auto_debug?.enabled) {
+    const dataDir2 = resolve20(hivemindHome, "data");
+    const autoDebugConfig = config.auto_debug;
+    const logWatcher = new LogWatcher(
+      {
+        log_files: autoDebugConfig.log_files,
+        severity_threshold: autoDebugConfig.severity_threshold,
+        auto_pr: autoDebugConfig.auto_pr,
+        repo: autoDebugConfig.repo,
+        branch_prefix: autoDebugConfig.branch_prefix,
+        max_concurrent_fixes: autoDebugConfig.max_concurrent_fixes,
+        cooldown_minutes: autoDebugConfig.cooldown_minutes,
+        notify_channel: autoDebugConfig.notify_channel
+      },
+      dataDir2
+    );
+    const autoDebugger = new AutoDebugger(
+      {
+        severity_threshold: autoDebugConfig.severity_threshold,
+        auto_pr: autoDebugConfig.auto_pr,
+        repo: autoDebugConfig.repo,
+        branch_prefix: autoDebugConfig.branch_prefix,
+        max_concurrent_fixes: autoDebugConfig.max_concurrent_fixes,
+        cooldown_minutes: autoDebugConfig.cooldown_minutes
+      },
+      logWatcher.getRegistry(),
+      config.llm,
+      hivemindHome
+    );
+    const bgContext = {
+      memoryClient: memory,
+      workspacePath: hivemindHome,
+      currentContext: "auto-debug",
+      agentId: config.agent.name,
+      sharedState: /* @__PURE__ */ new Map()
+    };
+    const processManager = new ProcessManager(bgContext);
+    processManager.register(logWatcher);
+    processManager.register(autoDebugger);
+    processManager.start();
+    process.on("exit", () => processManager.stop());
+    console.log("[hivemind] Auto-debug processors started");
+  }
+  const dataDir = resolve20(hivemindHome, "data");
   if (config.sesame.api_key) {
     await startSesameLoop(config, agent, toolRegistry, dataDir);
   } else {
@@ -6863,8 +8433,8 @@ ${response.content}
       console.error("Error:", err.message);
     }
   });
-  return new Promise((resolve20) => {
-    rl.on("close", resolve20);
+  return new Promise((resolve21) => {
+    rl.on("close", resolve21);
   });
 }
 async function runSpawnTask(config, configPath) {
@@ -6875,7 +8445,7 @@ async function runSpawnTask(config, configPath) {
   const spawnDir = process.env.SPAWN_DIR;
   console.log(`[spawn] Sub-agent starting (id: ${spawnId}, context: ${context})`);
   const agent = new Agent(config, context);
-  const hivemindHome = process.env.HIVEMIND_HOME || resolve19(process.env.HOME || "/root", "hivemind");
+  const hivemindHome = process.env.HIVEMIND_HOME || resolve20(process.env.HOME || "/root", "hivemind");
   const toolRegistry = registerAllTools(hivemindHome, {
     enabled: true,
     workspace: config.agent.workspace || "workspace",
@@ -6888,7 +8458,7 @@ async function runSpawnTask(config, configPath) {
     const result = response.content;
     console.log(`[spawn] Task completed (context: ${response.context})`);
     if (spawnDir) {
-      writeFileSync7(resolve19(spawnDir, "result.txt"), result);
+      writeFileSync8(resolve20(spawnDir, "result.txt"), result);
     }
     if (channelId && config.sesame.api_key) {
       try {
@@ -6905,7 +8475,7 @@ async function runSpawnTask(config, configPath) {
     const errorMsg = `[SPAWN ERROR] ${err.message}`;
     console.error(`[spawn] ${errorMsg}`);
     if (spawnDir) {
-      writeFileSync7(resolve19(spawnDir, "result.txt"), errorMsg);
+      writeFileSync8(resolve20(spawnDir, "result.txt"), errorMsg);
     }
     process.exitCode = 1;
   }
@@ -6936,20 +8506,20 @@ var WorkerServer = class {
   }
   /** Start listening. */
   async start() {
-    return new Promise((resolve20, reject) => {
+    return new Promise((resolve21, reject) => {
       this.server = createServer4((req, res) => this.handleRequest(req, res));
       this.server.on("error", reject);
-      this.server.listen(this.port, () => resolve20());
+      this.server.listen(this.port, () => resolve21());
     });
   }
   /** Stop the server. */
   async stop() {
-    return new Promise((resolve20) => {
+    return new Promise((resolve21) => {
       if (!this.server) {
-        resolve20();
+        resolve21();
         return;
       }
-      this.server.close(() => resolve20());
+      this.server.close(() => resolve21());
     });
   }
   getPort() {
@@ -6982,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/")) {
@@ -6993,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" });
@@ -7071,11 +8641,11 @@ var WorkerServer = class {
     sendJson(res, 200, result);
   }
 };
-function readBody(req) {
-  return new Promise((resolve20, reject) => {
+function readBody2(req) {
+  return new Promise((resolve21, reject) => {
     const chunks = [];
     req.on("data", (chunk) => chunks.push(chunk));
-    req.on("end", () => resolve20(Buffer.concat(chunks).toString("utf-8")));
+    req.on("end", () => resolve21(Buffer.concat(chunks).toString("utf-8")));
     req.on("error", reject);
   });
 }
@@ -7342,6 +8912,8 @@ async function startWorker(config) {
 }
 
 export {
+  setLogLevel,
+  createLogger,
   getClaudeCodeOAuthToken,
   LLMClient,
   MemoryClient,
@@ -7362,6 +8934,10 @@ export {
   SesameClient2,
   HEALTH_PATH,
   SkillsEngine,
+  hashError,
+  ErrorRegistry,
+  LogWatcher,
+  AutoDebugger,
   startPipeline,
   PRIMARY_ROUTES,
   WORKER_ROUTES,
@@ -7411,4 +8987,4 @@ smol-toml/dist/index.js:
    * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    *)
 */
-//# sourceMappingURL=chunk-OG6GPQDK.js.map
+//# sourceMappingURL=chunk-M3A2WRXM.js.map