@sesamespace/hivemind 0.8.11 → 0.8.13

package/dist/{chunk-OG6GPQDK.js → chunk-ZM7RK5YV.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) {
@@ -3012,7 +3045,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 +3059,7 @@ var SesameClient = class {
               this.authenticated = true;
               this.startHeartbeat(event.heartbeatIntervalMs ?? 3e4);
               this.sendReplay();
-              resolve20();
+              resolve21();
               return;
             }
             if (event.type === "pong")
@@ -3585,6 +3618,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 +4598,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 +4629,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 +4690,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 +4709,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 {
       }
@@ -3890,8 +4894,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 +4922,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 +4949,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 +4976,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 +5017,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 +5049,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 +5081,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 +5092,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 +5109,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 +5362,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 +5437,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 +5454,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 +5464,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 +5504,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 +5519,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 +5561,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 +5604,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 +5617,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 +5672,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 +5714,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 +5797,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 +5810,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,8 +6034,8 @@ ${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;
@@ -5074,7 +6078,7 @@ async function closeBrowser() {
   }
 }
 function registerBrowserTools(registry, workspaceDir) {
-  const screenshotDir = resolve11(workspaceDir, "screenshots");
+  const screenshotDir = resolve12(workspaceDir, "screenshots");
   registry.register(
     "browse",
     [
@@ -5158,11 +6162,11 @@ 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}`;
           }
@@ -5213,7 +6217,7 @@ function registerBrowserTools(registry, workspaceDir) {
 }
 
 // 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 +6228,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 +6475,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 +6493,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 +6555,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 +6692,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 +6726,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 +6750,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 +6819,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 +6936,7 @@ ${output || err.message}`;
     async (params) => {
       const content = params.content;
       try {
-        execSync6("pbcopy", {
+        execSync7("pbcopy", {
           input: content,
           timeout: 5e3,
           encoding: "utf-8",
@@ -5995,26 +6999,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 +7036,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 +7051,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 +7091,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 +7152,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 +7196,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 +7241,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 +7282,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 +7310,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 +7352,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 +7417,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 +7487,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 +7501,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 +7511,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 +7564,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 +7584,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 +7632,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 +7673,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"));
+  const requestLogger = new RequestLogger(resolve20(dirname8(configPath), "data", "dashboard.db"));
   startDashboardServer(requestLogger, config.memory);
   const agent = new Agent(config);
   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 +7685,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 +7693,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 +7910,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 +7922,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 +7935,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 +7952,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 +7983,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() {
@@ -7072,10 +8119,10 @@ var WorkerServer = class {
   }
 };
 function readBody(req) {
-  return new Promise((resolve20, reject) => {
+  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 +8389,8 @@ async function startWorker(config) {
 }
 
 export {
+  setLogLevel,
+  createLogger,
   getClaudeCodeOAuthToken,
   LLMClient,
   MemoryClient,
@@ -7362,6 +8411,10 @@ export {
   SesameClient2,
   HEALTH_PATH,
   SkillsEngine,
+  hashError,
+  ErrorRegistry,
+  LogWatcher,
+  AutoDebugger,
   startPipeline,
   PRIMARY_ROUTES,
   WORKER_ROUTES,
@@ -7411,4 +8464,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-ZM7RK5YV.js.map