@neotx/core 0.1.0-alpha.20 → 0.1.0-alpha.22

package/dist/index.js

@@ -60,8 +60,10 @@ ${issues}`);
     const promptPath = path.resolve(path.dirname(filePath), config.prompt);
     try {
       config.prompt = await readFile(promptPath, "utf-8");
-    } catch {
-      throw new Error(`Prompt file not found: ${promptPath} (referenced in ${filePath})`);
+    } catch (err) {
+      throw new Error(
+        `Prompt file not found: ${promptPath} (referenced in ${filePath}). Error: ${err instanceof Error ? err.message : String(err)}`
+      );
     }
   }
   return config;
@@ -198,7 +200,10 @@ var AgentRegistry = class {
       let customConfigs;
       try {
         customConfigs = await loadAgentsFromDir(this.customDir);
-      } catch {
+      } catch (err) {
+        console.debug(
+          `[registry] Custom agents dir not found: ${err instanceof Error ? err.message : String(err)}`
+        );
         customConfigs = [];
       }
       for (const config of customConfigs) {
@@ -505,6 +510,15 @@ var sessionsConfigSchema = z2.object({
   maxDurationMs: z2.number().default(36e5),
   dir: z2.string().default("/tmp/neo-sessions")
 }).default({ initTimeoutMs: 12e4, maxDurationMs: 36e5, dir: "/tmp/neo-sessions" });
+var journalConfigSchema = z2.object({
+  maxCostJournalSizeBytes: z2.number().default(100 * 1024 * 1024),
+  // 100MB
+  maxEventJournalSizeBytes: z2.number().default(500 * 1024 * 1024)
+  // 500MB
+}).default({
+  maxCostJournalSizeBytes: 100 * 1024 * 1024,
+  maxEventJournalSizeBytes: 500 * 1024 * 1024
+});
 var supervisorConfigSchema = z2.object({
   port: z2.number().default(7777),
   secret: z2.string().optional(),
@@ -544,6 +558,7 @@ var globalConfigSchema = z2.object({
   budget: budgetConfigSchema,
   recovery: recoveryConfigSchema,
   sessions: sessionsConfigSchema,
+  journal: journalConfigSchema.optional(),
   webhooks: z2.array(
     z2.object({
       url: z2.string().url(),
@@ -598,6 +613,7 @@ var defaultConfig = {
   budget: budgetConfigSchema.parse(void 0),
   recovery: recoveryConfigSchema.parse(void 0),
   sessions: sessionsConfigSchema.parse(void 0),
+  journal: journalConfigSchema.parse(void 0),
   webhooks: [],
   supervisor: {
     port: 7777,
@@ -727,6 +743,7 @@ var ConfigStore = class {
     }
     const parsed = neoConfigSchema.safeParse(raw);
     if (!parsed.success) {
+      console.warn(`[neo] Failed to parse config at ${globalPath}:`, parsed.error.message);
       return null;
     }
     return parsed.data;
@@ -745,6 +762,7 @@ var ConfigStore = class {
     }
     const parsed = repoOverrideConfigSchema.safeParse(raw);
     if (!parsed.success) {
+      console.warn(`[neo] Failed to parse config at ${repoConfigPath}:`, parsed.error.message);
       return null;
     }
     return parsed.data;
@@ -844,6 +862,9 @@ var ConfigWatcher = class extends EventEmitter {
       this.debounceTimer = null;
       this.reloadConfig();
     }, this.debounceMs);
+    if (typeof this.debounceTimer === "object" && "unref" in this.debounceTimer) {
+      this.debounceTimer.unref();
+    }
   }
   /**
    * Reloads the config and emits 'change' event.
@@ -857,6 +878,51 @@ var ConfigWatcher = class extends EventEmitter {
   }
 };
 
+// src/config/parser.ts
+var NEO_CONFIG_KEYS = {
+  "": /* @__PURE__ */ new Set([
+    "repos",
+    "concurrency",
+    "budget",
+    "recovery",
+    "sessions",
+    "webhooks",
+    "supervisor",
+    "memory",
+    "mcpServers",
+    "claudeCodePath",
+    "idempotency"
+  ]),
+  concurrency: /* @__PURE__ */ new Set(["maxSessions", "maxPerRepo", "queueMax"]),
+  budget: /* @__PURE__ */ new Set(["dailyCapUsd", "alertThresholdPct"]),
+  recovery: /* @__PURE__ */ new Set(["maxRetries", "backoffBaseMs"]),
+  sessions: /* @__PURE__ */ new Set(["initTimeoutMs", "maxDurationMs", "dir"]),
+  supervisor: /* @__PURE__ */ new Set([
+    "port",
+    "secret",
+    "heartbeatTimeoutMs",
+    "maxConsecutiveFailures",
+    "maxEventsPerSec",
+    "dailyCapUsd",
+    "consolidationIntervalMs",
+    "compactionIntervalMs",
+    "eventTimeoutMs",
+    "instructions",
+    "idleSkipMax",
+    "activeWorkSkipMax",
+    "autoDecide"
+  ]),
+  memory: /* @__PURE__ */ new Set(["embeddings"]),
+  idempotency: /* @__PURE__ */ new Set(["enabled", "key", "ttlMs"])
+};
+var REPO_OVERRIDE_KEYS = {
+  "": /* @__PURE__ */ new Set(["concurrency", "budget", "recovery", "sessions"]),
+  concurrency: NEO_CONFIG_KEYS.concurrency,
+  budget: NEO_CONFIG_KEYS.budget,
+  recovery: NEO_CONFIG_KEYS.recovery,
+  sessions: NEO_CONFIG_KEYS.sessions
+};
+
 // src/config.ts
 var DEFAULT_GLOBAL_CONFIG = {
   repos: [],
@@ -888,8 +954,10 @@ async function loadConfig(configPath) {
   let raw;
   try {
     raw = await readFile2(configPath, "utf-8");
-  } catch {
-    throw new Error(`Config file not found: ${configPath}. Run 'neo init' to get started.`);
+  } catch (err) {
+    throw new Error(
+      `Config file not found: ${configPath}. Run 'neo init' to get started. (${err instanceof Error ? err.message : String(err)})`
+    );
   }
   const parsed = parseYamlFile(raw, configPath);
   const result = neoConfigSchema.safeParse(parsed);
@@ -944,7 +1012,9 @@ async function listReposFromGlobalConfig() {
 }
 
 // src/cost/journal.ts
-import { appendFile, readFile as readFile3 } from "fs/promises";
+import { createReadStream } from "fs";
+import { appendFile, stat } from "fs/promises";
+import { createInterface } from "readline";
 
 // src/shared/date.ts
 import path5 from "path";
@@ -968,12 +1038,25 @@ async function ensureDir(dirPath, cache) {
 }
 
 // src/cost/journal.ts
+var JournalFileSizeError = class extends Error {
+  constructor(filePath, fileSizeBytes, maxSizeBytes) {
+    super(
+      `Journal file exceeds maximum size: ${filePath} (${(fileSizeBytes / 1024 / 1024).toFixed(2)}MB > ${(maxSizeBytes / 1024 / 1024).toFixed(2)}MB)`
+    );
+    this.filePath = filePath;
+    this.fileSizeBytes = fileSizeBytes;
+    this.maxSizeBytes = maxSizeBytes;
+    this.name = "JournalFileSizeError";
+  }
+};
 var CostJournal = class {
   dir;
   dirCache = /* @__PURE__ */ new Set();
   dayCache = null;
+  maxFileSizeBytes;
   constructor(options) {
     this.dir = options.dir;
+    this.maxFileSizeBytes = options.maxFileSizeBytes ?? 100 * 1024 * 1024;
   }
   async append(entry) {
     await ensureDir(this.dir, this.dirCache);
@@ -991,8 +1074,13 @@ var CostJournal = class {
     const file = fileForDate(d, "cost", this.dir);
     let total = 0;
     try {
-      const content = await readFile3(file, "utf-8");
-      for (const line of content.split("\n")) {
+      const stats = await stat(file);
+      if (stats.size > this.maxFileSizeBytes) {
+        throw new JournalFileSizeError(file, stats.size, this.maxFileSizeBytes);
+      }
+      const stream = createReadStream(file, { encoding: "utf-8" });
+      const rl = createInterface({ input: stream, crlfDelay: Number.POSITIVE_INFINITY });
+      for await (const line of rl) {
         if (!line.trim()) continue;
         const entry = JSON.parse(line);
         if (toDateKey(new Date(entry.timestamp)) === dayKey) {
@@ -1038,7 +1126,11 @@ var NeoEventEmitter = class {
       if (eventType !== "error") {
         try {
           this.emitter.emit("error", error);
-        } catch {
+        } catch (nestedErr) {
+          console.error(
+            "[emitter] Error handler threw:",
+            nestedErr instanceof Error ? nestedErr.message : String(nestedErr)
+          );
         }
       }
     }
@@ -1046,16 +1138,37 @@ var NeoEventEmitter = class {
 };
 
 // src/events/journal.ts
-import { appendFile as appendFile2 } from "fs/promises";
+import { appendFile as appendFile2, stat as stat2 } from "fs/promises";
+var JournalFileSizeError2 = class extends Error {
+  constructor(filePath, fileSizeBytes, maxSizeBytes) {
+    super(
+      `Journal file exceeds maximum size: ${filePath} (${(fileSizeBytes / 1024 / 1024).toFixed(2)}MB > ${(maxSizeBytes / 1024 / 1024).toFixed(2)}MB)`
+    );
+    this.filePath = filePath;
+    this.fileSizeBytes = fileSizeBytes;
+    this.maxSizeBytes = maxSizeBytes;
+    this.name = "JournalFileSizeError";
+  }
+};
 var EventJournal = class {
   dir;
   dirCache = /* @__PURE__ */ new Set();
+  maxFileSizeBytes;
   constructor(options) {
     this.dir = options.dir;
+    this.maxFileSizeBytes = options.maxFileSizeBytes ?? 500 * 1024 * 1024;
   }
   async append(event) {
     await ensureDir(this.dir, this.dirCache);
     const file = fileForDate(new Date(event.timestamp), "events", this.dir);
+    try {
+      const stats = await stat2(file);
+      if (stats.size > this.maxFileSizeBytes) {
+        throw new JournalFileSizeError2(file, stats.size, this.maxFileSizeBytes);
+      }
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
     await appendFile2(file, `${JSON.stringify(event)}
 `, "utf-8");
   }
@@ -1092,7 +1205,11 @@ var WebhookDispatcher = class {
         headers["X-Neo-Signature"] = sign(body, webhook.secret);
       }
       if (RETRY_EVENT_TYPES.has(event.type)) {
-        const p = sendWithRetry(webhook.url, headers, body, webhook.timeoutMs).catch(() => {
+        const p = sendWithRetry(webhook.url, headers, body, webhook.timeoutMs).catch((err) => {
+          console.debug(
+            `[neo] Webhook delivery failed for ${event.type} to ${webhook.url}:`,
+            err
+          );
         }).finally(() => this.pending.delete(p));
         this.pending.add(p);
       } else {
@@ -1101,7 +1218,8 @@ var WebhookDispatcher = class {
           headers,
           body,
           signal: AbortSignal.timeout(webhook.timeoutMs)
-        }).catch(() => {
+        }).catch((err) => {
+          console.debug(`[neo] Webhook delivery failed for ${event.type} to ${webhook.url}:`, err);
         });
       }
     }
@@ -1122,7 +1240,10 @@ async function sendWithRetry(url, headers, body, timeoutMs) {
         signal: AbortSignal.timeout(timeoutMs)
       });
       if (res.ok) return;
-    } catch {
+    } catch (err) {
+      console.debug(
+        `[webhook] Network error on attempt ${attempt}: ${err instanceof Error ? err.message : String(err)}`
+      );
     }
     if (attempt < RETRY_MAX_ATTEMPTS) {
       const delay = RETRY_BASE_DELAY_MS * 2 ** (attempt - 1);
@@ -1158,14 +1279,38 @@ import { dirname, resolve } from "path";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 var GIT_TIMEOUT = 6e4;
+function validateGitRef(refName, paramName) {
+  if (!refName || typeof refName !== "string") {
+    throw new Error(`${paramName} must be a non-empty string`);
+  }
+  if (refName.includes("..")) {
+    throw new Error(`${paramName} contains invalid pattern '..' (directory traversal)`);
+  }
+  if (refName.startsWith("-")) {
+    throw new Error(`${paramName} cannot start with '-' (option injection)`);
+  }
+  const validRefPattern = /^[a-zA-Z0-9/_+.-]+$/;
+  if (!validRefPattern.test(refName)) {
+    throw new Error(
+      `${paramName} contains invalid characters. Only alphanumeric, dash, underscore, slash, plus, and dot are allowed. Got: ${refName}`
+    );
+  }
+}
 async function createSessionClone(options) {
+  validateGitRef(options.branch, "branch");
+  validateGitRef(options.baseBranch, "baseBranch");
   const repoPath = resolve(options.repoPath);
   const sessionDir = resolve(options.sessionDir);
   await mkdir3(dirname(sessionDir), { recursive: true });
   const remoteUrl = await execFileAsync("git", ["config", "--get", "remote.origin.url"], {
     cwd: repoPath,
     timeout: GIT_TIMEOUT
-  }).then(({ stdout }) => stdout.trim()).catch(() => "");
+  }).then(({ stdout }) => stdout.trim()).catch((err) => {
+    console.debug(
+      `[neo] No remote.origin.url for ${repoPath}: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return "";
+  });
   const cloneSource = remoteUrl || repoPath;
   await execFileAsync("git", ["clone", "--branch", options.baseBranch, cloneSource, sessionDir], {
     timeout: GIT_TIMEOUT
@@ -1175,7 +1320,12 @@ async function createSessionClone(options) {
       "git",
       ["ls-remote", "--heads", "origin", options.branch],
       { cwd: sessionDir, timeout: GIT_TIMEOUT }
-    ).then(({ stdout }) => stdout.trim().length > 0).catch(() => false);
+    ).then(({ stdout }) => stdout.trim().length > 0).catch((err) => {
+      console.debug(
+        `[neo] ls-remote failed for branch ${options.branch}: ${err instanceof Error ? err.message : String(err)}`
+      );
+      return false;
+    });
     if (branchExists) {
       await execFileAsync("git", ["fetch", "origin", options.branch], {
         cwd: sessionDir,
@@ -1229,14 +1379,20 @@ async function listSessionClones(sessionsBaseDir) {
         );
         const url = originUrl.trim();
         if (url) repoPath = resolve(clonePath, url);
-      } catch {
+      } catch (err) {
+        console.debug(
+          `[neo] Failed to get origin URL for ${clonePath}: ${err instanceof Error ? err.message : String(err)}`
+        );
       }
       clones.push({
         path: clonePath,
         branch: branchOut.trim(),
         repoPath
       });
-    } catch {
+    } catch (err) {
+      console.debug(
+        `[neo] Skipping ${clonePath}, not a valid git repo: ${err instanceof Error ? err.message : String(err)}`
+      );
     }
   }
   return clones;
@@ -1256,15 +1412,21 @@ async function git(repoPath, args) {
   return stdout.trim();
 }
 async function createBranch(repoPath, branch, baseBranch) {
+  validateGitRef(branch, "branch");
+  validateGitRef(baseBranch, "baseBranch");
   await git(repoPath, ["branch", branch, baseBranch]);
 }
 async function pushBranch(repoPath, branch, remote) {
+  validateGitRef(branch, "branch");
+  validateGitRef(remote, "remote");
   await git(repoPath, ["push", remote, branch]);
 }
 async function fetchRemote(repoPath, remote) {
+  validateGitRef(remote, "remote");
   await git(repoPath, ["fetch", remote]);
 }
 async function deleteBranch(repoPath, branch) {
+  validateGitRef(branch, "branch");
   await git(repoPath, ["branch", "-D", branch]);
 }
 async function getCurrentBranch(repoPath) {
@@ -1277,6 +1439,8 @@ function getBranchName(config, runId, branch) {
   return `${prefix}/run-${sanitized}`;
 }
 async function pushSessionBranch(sessionPath, branch, remote) {
+  validateGitRef(branch, "branch");
+  validateGitRef(remote, "remote");
   await git(sessionPath, ["push", "-u", remote, branch]);
 }
 
@@ -1338,15 +1502,21 @@ function auditLog(options) {
     await appendFile3(filePath, lines.join(""), "utf-8");
     buffers.delete(sessionId);
   }
+  function stopTimer() {
+    if (flushTimer !== void 0) {
+      clearInterval(flushTimer);
+      flushTimer = void 0;
+    }
+  }
   return {
     name: "audit-log",
     on: "PostToolUse",
     async flush() {
+      stopTimer();
       await flushAll();
-      if (flushTimer !== void 0) {
-        clearInterval(flushTimer);
-        flushTimer = void 0;
-      }
+    },
+    cleanup() {
+      stopTimer();
     },
     async handler(event, context) {
       const entry = {
@@ -1501,12 +1671,12 @@ function loopDetection(options) {
 // src/orchestrator.ts
 import { randomUUID as randomUUID3 } from "crypto";
 import { existsSync as existsSync6 } from "fs";
-import { mkdir as mkdir6, readFile as readFile6 } from "fs/promises";
+import { mkdir as mkdir6, readFile as readFile5 } from "fs/promises";
 import path10 from "path";
 
 // src/orchestrator/run-store.ts
 import { existsSync as existsSync4 } from "fs";
-import { mkdir as mkdir5, readdir as readdir3, readFile as readFile4, writeFile as writeFile2 } from "fs/promises";
+import { mkdir as mkdir5, readdir as readdir3, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
 import path7 from "path";
 
 // src/shared/process.ts
@@ -1592,7 +1762,7 @@ var RunStore = class {
    * If so, update its status to "failed" and return it.
    */
   async recoverRunIfOrphaned(filePath) {
-    const content = await readFile4(filePath, "utf-8");
+    const content = await readFile3(filePath, "utf-8");
     const run = JSON.parse(content);
     if (run.status !== "running") return null;
     if (run.pid && run.pid === process.pid) return null;
@@ -1607,13 +1777,13 @@ var RunStore = class {
 };
 
 // src/orchestrator/prompt-builder.ts
-import { readFile as readFile5 } from "fs/promises";
+import { readFile as readFile4 } from "fs/promises";
 import path8 from "path";
 var INSTRUCTIONS_PATH = ".neo/INSTRUCTIONS.md";
 async function loadRepoInstructions(repoPath) {
   const filePath = path8.join(repoPath, INSTRUCTIONS_PATH);
   try {
-    return await readFile5(filePath, "utf-8");
+    return await readFile4(filePath, "utf-8");
   } catch {
     return void 0;
   }
@@ -2679,6 +2849,7 @@ var Orchestrator = class extends NeoEventEmitter {
     return {
       paused: this._paused,
       activeSessions: [...this._activeSessions.values()],
+      activeRunCount: this.activeRunCount,
       queueDepth: this.semaphore.queueDepth(),
       costToday: this._costToday,
       budgetCapUsd: this.config.budget.dailyCapUsd,
@@ -2689,6 +2860,15 @@ var Orchestrator = class extends NeoEventEmitter {
   get activeSessions() {
     return [...this._activeSessions.values()];
   }
+  get activeRunCount() {
+    let count = 0;
+    for (const session of this._activeSessions.values()) {
+      if (session.status === "running") {
+        count++;
+      }
+    }
+    return count;
+  }
   // ─── Lifecycle ─────────────────────────────────────────
   async start() {
     this._startedAt = Date.now();
@@ -2740,7 +2920,8 @@ var Orchestrator = class extends NeoEventEmitter {
   emit(event) {
     super.emit(event);
     if (this.eventJournal) {
-      this.eventJournal.append(event).catch(() => {
+      this.eventJournal.append(event).catch((err) => {
+        console.debug("[neo] Event journal append failed:", err);
       });
     }
     if (this.webhookDispatcher) {
@@ -2859,13 +3040,21 @@ var Orchestrator = class extends NeoEventEmitter {
           outcome: "failure",
           runId
         });
-      } catch {
+      } catch (err) {
+        console.debug(
+          `[orchestrator] Failed to write failure episode to memory: ${err instanceof Error ? err.message : String(err)}`
+        );
       }
       return failResult;
     } finally {
       if (sessionPath) {
         await this.finalizeSession(sessionPath, ctx);
       }
+      for (const mw of this.userMiddleware) {
+        if ("cleanup" in mw && typeof mw.cleanup === "function") {
+          mw.cleanup(sessionId);
+        }
+      }
       this.semaphore.release(sessionId);
       this._activeSessions.delete(sessionId);
       this.abortControllers.delete(sessionId);
@@ -2884,14 +3073,17 @@ var Orchestrator = class extends NeoEventEmitter {
       const branch = ctx.input.branch;
       const remote = ctx.repoConfig.pushRemote ?? "origin";
       try {
-        await pushSessionBranch(sessionPath, branch, remote).catch(() => {
+        await pushSessionBranch(sessionPath, branch, remote).catch((err) => {
+          console.debug("[neo] Push failed:", err);
         });
-      } catch {
+      } catch (err) {
+        console.debug("[neo] Finalization error:", err);
       }
     }
     try {
       await removeSessionClone(sessionPath);
-    } catch {
+    } catch (err) {
+      console.debug("[neo] Session cleanup failed:", err);
     }
   }
   async runAgentSession(ctx, sessionPath) {
@@ -2968,7 +3160,10 @@ var Orchestrator = class extends NeoEventEmitter {
         outcome: isSuccess ? "success" : "failure",
         runId
       });
-    } catch {
+    } catch (err) {
+      console.debug(
+        `[orchestrator] Failed to write completion episode to memory: ${err instanceof Error ? err.message : String(err)}`
+      );
     }
     return result;
   }
@@ -3035,7 +3230,10 @@ var Orchestrator = class extends NeoEventEmitter {
       if (memories.length === 0) return void 0;
       store.markAccessed(memories.map((m) => m.id));
       return formatMemoriesForPrompt(memories);
-    } catch {
+    } catch (err) {
+      console.debug(
+        `[orchestrator] Failed to load memories: ${err instanceof Error ? err.message : String(err)}`
+      );
       return void 0;
     }
   }
@@ -3054,7 +3252,8 @@ var Orchestrator = class extends NeoEventEmitter {
         durationMs: Date.now() - ctx.startedAt,
         repo: ctx.input.repo
       };
-      this.costJournal.append(costEntry).catch(() => {
+      this.costJournal.append(costEntry).catch((err) => {
+        console.debug("[neo] Cost journal append failed:", err);
       });
     }
     this.emit({
@@ -3185,17 +3384,17 @@ var Orchestrator = class extends NeoEventEmitter {
   // ─── Private: Supervisor discovery ─────────────────────
   /** Discover running supervisor daemons and return webhook configs for their endpoints. */
   async discoverSupervisorWebhooks() {
-    const { readdir: readdir6 } = await import("fs/promises");
+    const { readdir: readdir7 } = await import("fs/promises");
     const supervisorsDir = getSupervisorsDir();
     if (!existsSync6(supervisorsDir)) return [];
     const webhooks = [];
     try {
-      const entries = await readdir6(supervisorsDir, { withFileTypes: true });
+      const entries = await readdir7(supervisorsDir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         try {
           const statePath = path10.join(supervisorsDir, entry.name, "state.json");
-          const raw = await readFile6(statePath, "utf-8");
+          const raw = await readFile5(statePath, "utf-8");
           const state = JSON.parse(raw);
           if (state.status !== "running" || !state.port) continue;
           if (state.pid && !isProcessAlive(state.pid)) continue;
@@ -3205,10 +3404,16 @@ var Orchestrator = class extends NeoEventEmitter {
             secret: this.config.supervisor.secret,
             timeoutMs: 5e3
           });
-        } catch {
+        } catch (err) {
+          console.debug(
+            `[orchestrator] Failed to load supervisor webhook config: ${err instanceof Error ? err.message : String(err)}`
+          );
         }
       }
-    } catch {
+    } catch (err) {
+      console.debug(
+        `[orchestrator] Failed to read supervisors directory: ${err instanceof Error ? err.message : String(err)}`
+      );
     }
     return webhooks;
   }
@@ -3251,7 +3456,7 @@ import { z as z5 } from "zod";
 
 // src/supervisor/decisions.ts
 import { randomUUID as randomUUID4 } from "crypto";
-import { appendFile as appendFile4, readFile as readFile7, writeFile as writeFile3 } from "fs/promises";
+import { appendFile as appendFile4, readFile as readFile6, writeFile as writeFile3 } from "fs/promises";
 import path11 from "path";
 import { z as z4 } from "zod";
 var decisionOptionSchema = z4.object({
@@ -3267,21 +3472,41 @@ var decisionSchema = z4.object({
   type: z4.string().default("generic"),
   source: z4.string(),
   metadata: z4.record(z4.string(), z4.unknown()).optional(),
-  createdAt: z4.string(),
-  expiresAt: z4.string().optional(),
+  createdAt: z4.coerce.string(),
+  expiresAt: z4.coerce.string().optional(),
   defaultAnswer: z4.string().optional(),
-  answeredAt: z4.string().optional(),
+  answeredAt: z4.coerce.string().optional(),
   answer: z4.string().optional(),
-  expiredAt: z4.string().optional()
+  expiredAt: z4.coerce.string().optional()
 });
 var DecisionStore = class {
   filePath;
   dir;
   dirCache = /* @__PURE__ */ new Set();
+  /** Promise-based mutex to serialize write operations */
+  writeLock = Promise.resolve();
   constructor(filePath) {
     this.filePath = filePath;
     this.dir = path11.dirname(filePath);
   }
+  /**
+   * Acquire the write lock and execute a callback.
+   * Serializes all write operations to prevent race conditions.
+   */
+  async withWriteLock(fn) {
+    const release = this.writeLock;
+    let releaseLock = () => {
+    };
+    this.writeLock = new Promise((r) => {
+      releaseLock = r;
+    });
+    try {
+      await release;
+      return await fn();
+    } finally {
+      releaseLock();
+    }
+  }
   /**
    * Create a new decision and persist it.
    * @returns The generated decision ID
@@ -3301,19 +3526,22 @@ var DecisionStore = class {
   /**
    * Answer a decision by ID.
    * Reads all entries, updates the matching one, and rewrites the file.
+   * Uses a mutex to serialize concurrent calls and prevent race conditions.
    */
   async answer(id, answer) {
-    const decisions = await this.readAll();
-    const decision = decisions.find((d) => d.id === id);
-    if (!decision) {
-      throw new Error(`Decision not found: ${id}`);
-    }
-    if (decision.answer !== void 0) {
-      throw new Error(`Decision already answered: ${id}`);
-    }
-    decision.answer = answer;
-    decision.answeredAt = (/* @__PURE__ */ new Date()).toISOString();
-    await this.writeAll(decisions);
+    await this.withWriteLock(async () => {
+      const decisions = await this.readAll();
+      const decision = decisions.find((d) => d.id === id);
+      if (!decision) {
+        throw new Error(`Decision not found: ${id}`);
+      }
+      if (decision.answer !== void 0) {
+        throw new Error(`Decision already answered: ${id}`);
+      }
+      decision.answer = answer;
+      decision.answeredAt = (/* @__PURE__ */ new Date()).toISOString();
+      await this.writeAll(decisions);
+    });
   }
   /**
    * Get all pending decisions (unanswered, not expired, not timed out).
@@ -3350,33 +3578,36 @@ var DecisionStore = class {
   /**
    * Auto-answer expired decisions with their defaultAnswer.
    * Decisions without defaultAnswer are marked as expired (expiredAt).
+   * Uses a mutex to serialize concurrent calls and prevent race conditions.
    * @returns The decisions that were auto-answered or marked expired
    */
   async expire() {
-    const decisions = await this.readAll();
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const expired = [];
-    for (const decision of decisions) {
-      if (decision.answer === void 0 && decision.expiredAt === void 0 && decision.expiresAt && decision.expiresAt < now) {
-        if (decision.defaultAnswer !== void 0) {
-          decision.answer = decision.defaultAnswer;
-          decision.answeredAt = now;
-        } else {
-          decision.expiredAt = now;
+    return this.withWriteLock(async () => {
+      const decisions = await this.readAll();
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const expired = [];
+      for (const decision of decisions) {
+        if (decision.answer === void 0 && decision.expiredAt === void 0 && decision.expiresAt && decision.expiresAt < now) {
+          if (decision.defaultAnswer !== void 0) {
+            decision.answer = decision.defaultAnswer;
+            decision.answeredAt = now;
+          } else {
+            decision.expiredAt = now;
+          }
+          expired.push(decision);
         }
-        expired.push(decision);
       }
-    }
-    if (expired.length > 0) {
-      await this.writeAll(decisions);
-    }
-    return expired;
+      if (expired.length > 0) {
+        await this.writeAll(decisions);
+      }
+      return expired;
+    });
   }
   // ─── Private helpers ─────────────────────────────────────
   async readAll() {
     let content;
     try {
-      content = await readFile7(this.filePath, "utf-8");
+      content = await readFile6(this.filePath, "utf-8");
     } catch (error) {
       if (error.code === "ENOENT") {
         return [];
@@ -3502,7 +3733,7 @@ var activityQueryOptionsSchema = z5.object({
 
 // src/supervisor/activity-log.ts
 import { randomUUID as randomUUID5 } from "crypto";
-import { appendFile as appendFile5, readFile as readFile8, rename, stat } from "fs/promises";
+import { appendFile as appendFile5, readFile as readFile7, rename, stat as stat3 } from "fs/promises";
 import path12 from "path";
 var ACTIVITY_FILE = "activity.jsonl";
 var MAX_SIZE_BYTES = 10 * 1024 * 1024;
@@ -3541,8 +3772,11 @@ var ActivityLog = class {
   async tail(n) {
     let content;
     try {
-      content = await readFile8(this.filePath, "utf-8");
-    } catch {
+      content = await readFile7(this.filePath, "utf-8");
+    } catch (err) {
+      console.debug(
+        `[ActivityLog] Failed to read activity log: ${err instanceof Error ? err.message : String(err)}`
+      );
       return [];
     }
     const lines = content.trim().split("\n").filter(Boolean);
@@ -3551,14 +3785,17 @@ var ActivityLog = class {
     for (const line of lastLines) {
       try {
         entries.push(JSON.parse(line));
-      } catch {
+      } catch (err) {
+        console.debug(
+          `[ActivityLog] Skipping malformed line: ${err instanceof Error ? err.message : String(err)}`
+        );
       }
     }
     return entries;
   }
   async checkRotation() {
     try {
-      const stats = await stat(this.filePath);
+      const stats = await stat3(this.filePath);
       if (stats.size > MAX_SIZE_BYTES) {
         const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
         const rotatedPath = path12.join(this.dir, `activity-${timestamp}.jsonl`);
@@ -3572,13 +3809,13 @@ var ActivityLog = class {
 // src/supervisor/daemon.ts
 import { randomUUID as randomUUID7 } from "crypto";
 import { existsSync as existsSync8 } from "fs";
-import { mkdir as mkdir7, readFile as readFile12, rm as rm2, writeFile as writeFile7 } from "fs/promises";
+import { mkdir as mkdir7, readFile as readFile11, rm as rm2, writeFile as writeFile7 } from "fs/promises";
 import { homedir as homedir5 } from "os";
 import path15 from "path";
 
 // src/supervisor/event-queue.ts
 import { watch as watch2 } from "fs";
-import { readFile as readFile9, writeFile as writeFile4 } from "fs/promises";
+import { readFile as readFile8, writeFile as writeFile4 } from "fs/promises";
 var EventQueue = class {
   queue = [];
   seenIds = /* @__PURE__ */ new Set();
@@ -3720,7 +3957,8 @@ var EventQueue = class {
   watchJsonlFile(filePath, kind) {
     try {
       const watcher = watch2(filePath, () => {
-        this.readNewLines(filePath, kind).catch(() => {
+        this.readNewLines(filePath, kind).catch((err) => {
+          console.debug(`[neo] Failed to read new lines from ${filePath}:`, err);
         });
       });
       this.watchers.push(watcher);
@@ -3730,7 +3968,7 @@ var EventQueue = class {
   async readNewLines(filePath, kind) {
     let content;
     try {
-      content = await readFile9(filePath, "utf-8");
+      content = await readFile8(filePath, "utf-8");
     } catch (_err) {
       return;
     }
@@ -3755,7 +3993,7 @@ var EventQueue = class {
   async replayFile(filePath, kind) {
     let content;
     try {
-      content = await readFile9(filePath, "utf-8");
+      content = await readFile8(filePath, "utf-8");
     } catch (_err) {
       return;
     }
@@ -3791,7 +4029,7 @@ var EventQueue = class {
   }
   async markInFile(filePath, matchTimestamp, processedAt) {
     try {
-      const content = await readFile9(filePath, "utf-8");
+      const content = await readFile8(filePath, "utf-8");
       const lines = content.split("\n");
       let changed = false;
       const updated = lines.map((line) => {
@@ -3819,7 +4057,7 @@ var EventQueue = class {
 // src/supervisor/heartbeat.ts
 import { randomUUID as randomUUID6 } from "crypto";
 import { existsSync as existsSync7 } from "fs";
-import { readdir as readdir4, readFile as readFile11, writeFile as writeFile6 } from "fs/promises";
+import { readdir as readdir4, readFile as readFile10, writeFile as writeFile6 } from "fs/promises";
 import { homedir as homedir4 } from "os";
 import path14 from "path";
 
@@ -3875,7 +4113,7 @@ var IdleDetector = class {
 };
 
 // src/supervisor/log-buffer.ts
-import { appendFile as appendFile6, readFile as readFile10, stat as stat2, writeFile as writeFile5 } from "fs/promises";
+import { appendFile as appendFile6, readFile as readFile9, stat as stat4, writeFile as writeFile5 } from "fs/promises";
 import path13 from "path";
 var LOG_BUFFER_FILE = "log-buffer.jsonl";
 var MAX_FILE_BYTES = 1024 * 1024;
@@ -3889,16 +4127,22 @@ function parseLines(content) {
   for (const line of lines) {
     try {
       entries.push(JSON.parse(line));
-    } catch {
+    } catch (err) {
+      console.debug(
+        `[log-buffer] Skipping malformed line: ${err instanceof Error ? err.message : String(err)}`
+      );
     }
   }
   return entries;
 }
 async function readLogBuffer(dir) {
   try {
-    const content = await readFile10(bufferPath(dir), "utf-8");
+    const content = await readFile9(bufferPath(dir), "utf-8");
     return parseLines(content);
-  } catch {
+  } catch (err) {
+    console.debug(
+      `[log-buffer] Failed to read buffer: ${err instanceof Error ? err.message : String(err)}`
+    );
     return [];
   }
 }
@@ -3910,8 +4154,11 @@ async function markConsolidated(dir, ids) {
   const filePath = bufferPath(dir);
   let content;
   try {
-    content = await readFile10(filePath, "utf-8");
-  } catch {
+    content = await readFile9(filePath, "utf-8");
+  } catch (err) {
+    console.debug(
+      `[log-buffer] Failed to read for consolidation: ${err instanceof Error ? err.message : String(err)}`
+    );
     return;
   }
   const idSet = new Set(ids);
@@ -3925,7 +4172,10 @@ async function markConsolidated(dir, ids) {
         entry.consolidatedAt = now;
       }
       updated.push(JSON.stringify(entry));
-    } catch {
+    } catch (err) {
+      console.debug(
+        `[log-buffer] Preserving malformed line during consolidation: ${err instanceof Error ? err.message : String(err)}`
+      );
       updated.push(line);
     }
   }
@@ -3936,8 +4186,11 @@ async function compactLogBuffer(dir) {
   const filePath = bufferPath(dir);
   let content;
   try {
-    content = await readFile10(filePath, "utf-8");
-  } catch {
+    content = await readFile9(filePath, "utf-8");
+  } catch (err) {
+    console.debug(
+      `[log-buffer] Failed to read for compaction: ${err instanceof Error ? err.message : String(err)}`
+    );
     return;
   }
   const now = Date.now();
@@ -3953,7 +4206,10 @@ async function compactLogBuffer(dir) {
         }
       }
       kept.push(JSON.stringify(entry));
-    } catch {
+    } catch (err) {
+      console.debug(
+        `[log-buffer] Dropping malformed line during compaction: ${err instanceof Error ? err.message : String(err)}`
+      );
     }
   }
   let result = `${kept.join("\n")}
@@ -3969,7 +4225,10 @@ async function appendLogBuffer(dir, entry) {
   try {
     await appendFile6(bufferPath(dir), `${JSON.stringify(entry)}
 `, "utf-8");
-  } catch {
+  } catch (err) {
+    console.debug(
+      `[log-buffer] Failed to append entry: ${err instanceof Error ? err.message : String(err)}`
+    );
   }
 }
 
@@ -3987,7 +4246,8 @@ var OPERATING_PRINCIPLES = `### Operating principles
 - Keep initiative boundaries strict: decisions for initiative A must not be influenced by unrelated state from B.
 - Your user-visible channel is \`neo log\` only; produce concise tool calls (not reasoning/explanations) and avoid wasted tokens.
 - You may inspect repositories available via \`neo repos\`, read-only to launch agents.
-- Task hygiene is non-negotiable: update task outcomes EVERY heartbeat. A task without a current outcome is a blind spot.`;
+- Task hygiene is non-negotiable: update task outcomes EVERY heartbeat. A task without a current outcome is a blind spot.
+- **No duplicate dispatches**: before dispatching a \`developer\` for any finding, ALWAYS check for open or recently merged PRs on the same topic: \`gh pr list --repo <repo> --search "<keywords>" --state open\` and \`--state merged --limit 5\`. If a similar PR exists \u2192 skip and log with \`neo log discovery\`. Dispatching duplicate agents wastes budget and pollutes the PR list.`;
 var COMMANDS = `### Dispatching agents
 \`\`\`bash
 neo run <agent> --prompt "..." --repo <path> --branch <name> [--priority critical|high|medium|low] [--meta '<json>']
@@ -4203,7 +4463,7 @@ ${lines}
   }
   return "<focus>\n(empty \u2014 use neo memory write --type focus to set working context)\n</focus>";
 }
-function buildPendingDecisionsSection(decisions, autoDecide = false) {
+function buildPendingDecisionsSection(decisions) {
   if (!decisions || decisions.length === 0) {
     return "";
   }
@@ -4222,7 +4482,7 @@ function buildPendingDecisionsSection(decisions, autoDecide = false) {
       lines.push(`    Context: ${d.context}`);
     }
   }
-  const instruction = autoDecide ? `You are in **autoDecide** mode \u2014 answer each pending decision yourself based on available context, project knowledge, and best engineering judgment.
+  const instruction = `You are in **autoDecide** mode \u2014 answer each pending decision yourself based on available context, project knowledge, and best engineering judgment.
 
 \`\`\`bash
 neo decision answer <decision_id> <answer>
@@ -4230,10 +4490,7 @@ neo decision answer <decision_id> <answer>
 
 For each decision: analyze the options, consider the project context and risk, then answer decisively. Prefer safe, incremental choices when uncertain. Log your reasoning before answering.
 
-**Merge authority:** In autoDecide mode you MAY merge branches when the PR is ready (CI green, reviews approved). Use \`gh pr merge\` with the appropriate merge strategy.` : `To answer a decision, emit a \`decision:answer\` event:
-\`\`\`bash
-neo event emit decision:answer --data '{"id":"<decision_id>","answer":"<option_key>"}'
-\`\`\``;
+**Merge authority:** In autoDecide mode you MAY merge branches when the PR is ready (CI green, reviews approved). Use \`gh pr merge\` with the appropriate merge strategy.`;
   return `Pending decisions (${decisions.length}):
 ${lines.join("\n")}
 
@@ -4265,7 +4522,7 @@ ${opts.activeRuns.map((r) => `- ${r}`).join("\n")}`);
   if (recentActions) {
     parts.push(recentActions);
   }
-  const pendingDecisions = buildPendingDecisionsSection(opts.pendingDecisions, opts.autoDecide);
+  const pendingDecisions = buildPendingDecisionsSection(opts.pendingDecisions);
   if (pendingDecisions) {
     parts.push(pendingDecisions);
   }
@@ -4576,7 +4833,7 @@ function buildIdlePrompt(opts) {
   const budgetLine = `Budget: $${opts.budgetStatus.todayUsd.toFixed(2)} / $${opts.budgetStatus.capUsd.toFixed(2)} (${opts.budgetStatus.remainingPct.toFixed(0)}% remaining)`;
   const hasRepos = opts.repos.length > 0;
   const hasBudget = opts.budgetStatus.remainingPct > 10;
-  const hasPendingDecisions = (opts.pendingDecisions?.length ?? 0) > 0;
+  const hasPendingDecisions = opts.hasPendingDecisions ?? (opts.pendingDecisions?.length ?? 0) > 0;
   if (!hasRepos || !hasBudget) {
     return `${buildRoleSection(opts.heartbeatCount)}
 
@@ -4591,7 +4848,7 @@ Nothing to do. Run \`neo log discovery "idle"\` and yield. Do not produce any ot
   }
   const repoList = opts.repos.map((r) => `- ${r.path} (branch: ${r.defaultBranch})`).join("\n");
   if (hasPendingDecisions) {
-    const pendingSection = buildPendingDecisionsSection(opts.pendingDecisions, opts.autoDecide);
+    const pendingSection = buildPendingDecisionsSection(opts.pendingDecisions);
     if (opts.autoDecide) {
       return `${buildRoleSection(opts.heartbeatCount)}
 
@@ -4640,29 +4897,8 @@ Repositories:
 ${repoList}
 </context>
 
-<reference>
-${getCommandsSection(opts.heartbeatCount)}
-</reference>
-
 <directive>
-Idle \u2014 no work in progress. Use this downtime to dispatch a \`scout\` agent on one of your repositories.
-
-The scout explores the codebase and surfaces bugs, improvements, security issues, and tech debt. It creates decisions (via \`neo decision create\`) for each critical or high-impact finding, so the user can choose what to act on.
-
-**Rules:**
-- Pick the repo that was least recently scouted (check your memory for previous scout runs).
-- Only ONE scout at a time \u2014 never dispatch multiple scouts in parallel.
-- Use \`--branch main\` (or the repo's default branch) \u2014 scouts are read-only.
-- Log your decision before dispatching.
-
-**Example:**
-\`\`\`bash
-neo log decision "Idle \u2014 dispatching scout on <repo>"
-neo run scout --prompt "Explore this repository. Surface bugs, improvements, security issues, and tech debt. Create decisions for critical and high-impact findings." \\
-  --repo <path> \\
-  --branch <default-branch> \\
-  --meta '{"stage":"scout","label":"scout-<repo-name>"}'
-\`\`\`
+Nothing to do. Run \`neo log discovery "idle"\` and yield. Do not produce any other output.
 </directive>`;
 }
 function buildStandardPrompt(opts) {
@@ -4931,7 +5167,8 @@ var HeartbeatLoop = class {
     if (this.configStore) {
       this.config = this.configStore.getAll();
     }
-    this.activityLog.log("event", "Configuration reloaded (hot-reload)").catch(() => {
+    this.activityLog.log("event", "Configuration reloaded (hot-reload)").catch((err) => {
+      console.debug("[neo] Config reload log failed:", err);
     });
     this.eventQueue.interrupt();
   }
@@ -4942,21 +5179,14 @@ var HeartbeatLoop = class {
     const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
     const budgetCheck = await this.checkBudgetExceeded(state, today);
     if (budgetCheck.exceeded) return;
-    const { grouped, rawEvents } = this.eventQueue.drainAndGroup();
-    const totalEventCount = grouped.messages.length + grouped.webhooks.length + grouped.runCompletions.length;
-    const activeRuns = await this.getActiveRuns();
-    const decisionStore = this.getDecisionStore();
-    await this.processDecisionAnswers(rawEvents, decisionStore);
-    const expiredDecisions = await decisionStore.expire();
-    const hasExpiredDecisions = expiredDecisions.length > 0;
-    const pendingDecisions = this.config.supervisor.autoDecide ? await decisionStore.pending() : [];
-    const answeredDecisions = this.config.supervisor.autoDecide ? await decisionStore.answered(state?.lastHeartbeat) : [];
+    const eventCtx = await this.gatherEventContext();
+    const { pendingDecisions, answeredDecisions, hasExpiredDecisions, hasPendingDecisions } = await this.processDecisions(eventCtx.rawEvents, state?.lastHeartbeat);
     const unconsolidatedEntries = await readUnconsolidated(this.supervisorDir);
     const hasPendingConsolidation = unconsolidatedEntries.length > 0;
     const skipResult = await this.handleSkipLogic({
       state,
-      totalEventCount,
-      activeRuns,
+      totalEventCount: eventCtx.totalEventCount,
+      activeRuns: eventCtx.activeRuns,
       hasPendingConsolidation,
       hasExpiredDecisions
     });
@@ -4966,27 +5196,31 @@ var HeartbeatLoop = class {
     }
     const modeResult = await this.determineHeartbeatMode(state);
     const { prompt, modeLabel } = await this.buildHeartbeatModePrompt({
-      grouped,
+      grouped: eventCtx.grouped,
       todayCost: budgetCheck.todayCost,
       heartbeatCount: modeResult.heartbeatCount,
       unconsolidated: modeResult.unconsolidated,
       isCompaction: modeResult.isCompaction,
       isConsolidation: modeResult.isConsolidation,
-      activeRuns,
+      activeRuns: eventCtx.activeRuns,
       pendingDecisions,
       answeredDecisions,
+      hasPendingDecisions,
       lastHeartbeat: state?.lastHeartbeat,
-      lastConsolidationTimestamp: modeResult.lastConsolidationTs
+      lastConsolidationTimestamp: modeResult.lastConsolidationTs,
+      memories: eventCtx.memories,
+      recentActions: eventCtx.recentActions,
+      mcpServerNames: eventCtx.mcpServerNames
     });
     await this.activityLog.log(
       "heartbeat",
       `Heartbeat #${modeResult.heartbeatCount} starting (${modeLabel})`,
       {
         heartbeatId,
-        eventCount: totalEventCount,
-        messages: grouped.messages.length,
-        webhooks: grouped.webhooks.length,
-        runCompletions: grouped.runCompletions.length,
+        eventCount: eventCtx.totalEventCount,
+        messages: eventCtx.grouped.messages.length,
+        webhooks: eventCtx.grouped.webhooks.length,
+        runCompletions: eventCtx.grouped.runCompletions.length,
         isConsolidation: modeResult.isConsolidation
       }
     );
@@ -4998,17 +5232,11 @@ var HeartbeatLoop = class {
         { heartbeatId }
       );
     }
-    if (rawEvents.length > 0) {
-      const inboxPath = path14.join(this.supervisorDir, "inbox.jsonl");
-      await this.eventQueue.markProcessed(inboxPath, this.eventsPath, rawEvents);
-    }
-    if (modeResult.isConsolidation) {
-      const allIds = modeResult.unconsolidated.map((e) => e.id);
-      if (allIds.length > 0) {
-        await markConsolidated(this.supervisorDir, allIds);
-      }
-      await compactLogBuffer(this.supervisorDir);
-    }
+    await this.handlePostSdkProcessing({
+      rawEvents: eventCtx.rawEvents,
+      isConsolidation: modeResult.isConsolidation,
+      unconsolidated: modeResult.unconsolidated
+    });
     const durationMs = Date.now() - startTime;
     const { stateUpdate } = this.buildStateUpdate({
       state,
@@ -5031,13 +5259,92 @@ var HeartbeatLoop = class {
         isConsolidation: modeResult.isConsolidation
       }
     );
+    await this.emitCompletionEvents({
+      heartbeatCount: modeResult.heartbeatCount,
+      activeRuns: eventCtx.activeRuns,
+      todayCost: budgetCheck.todayCost,
+      costUsd,
+      rawEvents: eventCtx.rawEvents
+    });
+  }
+  /**
+   * Check if supervisor daily budget is exceeded.
+   */
+  async checkBudgetExceeded(state, today) {
+    const todayCost = state?.costResetDate === today ? state.todayCostUsd ?? 0 : 0;
+    if (todayCost >= this.config.supervisor.dailyCapUsd) {
+      await this.activityLog.log(
+        "error",
+        `Supervisor daily budget exceeded ($${todayCost.toFixed(2)} / $${this.config.supervisor.dailyCapUsd}). Skipping heartbeat.`
+      );
+      await this.sleep(this.config.supervisor.eventTimeoutMs);
+      return { todayCost, exceeded: true };
+    }
+    return { todayCost, exceeded: false };
+  }
+  /**
+   * Process decision answers from inbox and expire old decisions.
+   * Returns pending, answered, and expiry status for prompt context.
+   */
+  async processDecisions(rawEvents, lastHeartbeat) {
+    const decisionStore = this.getDecisionStore();
+    await this.processDecisionAnswers(rawEvents, decisionStore);
+    const expiredDecisions = await decisionStore.expire();
+    const hasExpiredDecisions = expiredDecisions.length > 0;
+    const allPending = await decisionStore.pending();
+    const hasPendingDecisions = allPending.length > 0;
+    const pendingDecisions = this.config.supervisor.autoDecide ? allPending : [];
+    const answeredDecisions = this.config.supervisor.autoDecide ? await decisionStore.answered(lastHeartbeat) : [];
+    return { pendingDecisions, answeredDecisions, hasExpiredDecisions, hasPendingDecisions };
+  }
+  /**
+   * Gather event context: drain queue, fetch active runs, memories, and recent actions.
+   */
+  async gatherEventContext() {
+    const { grouped, rawEvents } = this.eventQueue.drainAndGroup();
+    const totalEventCount = grouped.messages.length + grouped.webhooks.length + grouped.runCompletions.length;
+    const activeRuns = await this.getActiveRuns();
+    const mcpServerNames = this.config.mcpServers ? Object.keys(this.config.mcpServers) : [];
+    const store = this.getMemoryStore();
+    const memories = store ? store.query({ limit: 40, sortBy: "relevance" }) : [];
+    const recentActions = await this.activityLog.tail(20);
+    return {
+      grouped,
+      rawEvents,
+      totalEventCount,
+      activeRuns,
+      memories,
+      recentActions,
+      mcpServerNames
+    };
+  }
+  /**
+   * Handle post-SDK processing: mark events as processed, consolidate log buffer.
+   */
+  async handlePostSdkProcessing(input) {
+    if (input.rawEvents.length > 0) {
+      const inboxPath = path14.join(this.supervisorDir, "inbox.jsonl");
+      await this.eventQueue.markProcessed(inboxPath, this.eventsPath, input.rawEvents);
+    }
+    if (input.isConsolidation) {
+      const allIds = input.unconsolidated.map((e) => e.id);
+      if (allIds.length > 0) {
+        await markConsolidated(this.supervisorDir, allIds);
+      }
+      await compactLogBuffer(this.supervisorDir);
+    }
+  }
+  /**
+   * Emit completion webhook events: heartbeat completed and run completed events.
+   */
+  async emitCompletionEvents(input) {
     await this.emitHeartbeatCompleted({
-      heartbeatNumber: modeResult.heartbeatCount + 1,
-      runsActive: activeRuns.length,
-      todayUsd: budgetCheck.todayCost + costUsd,
+      heartbeatNumber: input.heartbeatCount + 1,
+      runsActive: input.activeRuns.length,
+      todayUsd: input.todayCost + input.costUsd,
       limitUsd: this.config.supervisor.dailyCapUsd
     });
-    for (const event of rawEvents) {
+    for (const event of input.rawEvents) {
       if (event.kind === "run_complete") {
         const runData = await this.readPersistedRun(event.runId);
         const emitOpts = {
@@ -5053,21 +5360,6 @@ var HeartbeatLoop = class {
       }
     }
   }
-  /**
-   * Check if supervisor daily budget is exceeded.
-   */
-  async checkBudgetExceeded(state, today) {
-    const todayCost = state?.costResetDate === today ? state.todayCostUsd ?? 0 : 0;
-    if (todayCost >= this.config.supervisor.dailyCapUsd) {
-      await this.activityLog.log(
-        "error",
-        `Supervisor daily budget exceeded ($${todayCost.toFixed(2)} / $${this.config.supervisor.dailyCapUsd}). Skipping heartbeat.`
-      );
-      await this.sleep(this.config.supervisor.eventTimeoutMs);
-      return { todayCost, exceeded: true };
-    }
-    return { todayCost, exceeded: false };
-  }
   /**
    * Handle skip logic for idle and active-work scenarios.
    * Uses IdleDetector to make skip decisions based on context.
@@ -5170,10 +5462,6 @@ var HeartbeatLoop = class {
    * Build the prompt for the current heartbeat mode.
    */
   async buildHeartbeatModePrompt(opts) {
-    const mcpServerNames = this.config.mcpServers ? Object.keys(this.config.mcpServers) : [];
-    const store = this.getMemoryStore();
-    const memories = store ? store.query({ limit: 40, sortBy: "relevance" }) : [];
-    const recentActions = await this.activityLog.tail(20);
     const sharedOpts = {
       repos: this.config.repos,
       grouped: opts.grouped,
@@ -5184,13 +5472,14 @@ var HeartbeatLoop = class {
       },
       activeRuns: opts.activeRuns,
       heartbeatCount: opts.heartbeatCount,
-      mcpServerNames,
+      mcpServerNames: opts.mcpServerNames,
       customInstructions: this.customInstructions,
       supervisorDir: this.supervisorDir,
-      memories,
-      recentActions,
+      memories: opts.memories,
+      recentActions: opts.recentActions,
       pendingDecisions: opts.pendingDecisions,
       answeredDecisions: opts.answeredDecisions,
+      hasPendingDecisions: opts.hasPendingDecisions,
       autoDecide: this.config.supervisor.autoDecide
     };
     if (opts.isCompaction) {
@@ -5300,7 +5589,7 @@ var HeartbeatLoop = class {
   }
   async readState() {
     try {
-      const raw = await readFile11(this.statePath, "utf-8");
+      const raw = await readFile10(this.statePath, "utf-8");
       return JSON.parse(raw);
     } catch {
       return null;
@@ -5308,7 +5597,7 @@ var HeartbeatLoop = class {
   }
   async updateState(updates) {
     try {
-      const raw = await readFile11(this.statePath, "utf-8");
+      const raw = await readFile10(this.statePath, "utf-8");
       const state = JSON.parse(raw);
       Object.assign(state, updates);
       await writeFile6(this.statePath, JSON.stringify(state, null, 2), "utf-8");
@@ -5333,7 +5622,7 @@ var HeartbeatLoop = class {
         for (const f of files) {
           if (!f.endsWith(".json")) continue;
           try {
-            const raw = await readFile11(path14.join(subDir, f), "utf-8");
+            const raw = await readFile10(path14.join(subDir, f), "utf-8");
             const run = JSON.parse(raw);
             if (isRunActive(run)) {
               active.push(
@@ -5367,7 +5656,7 @@ var HeartbeatLoop = class {
     }
     for (const filePath of candidates) {
       try {
-        const content = await readFile11(filePath, "utf-8");
+        const content = await readFile10(filePath, "utf-8");
         await this.activityLog.log("event", `Loaded instructions from ${filePath}`);
         return content;
       } catch {
@@ -5482,7 +5771,7 @@ var HeartbeatLoop = class {
         const subDir = path14.join(runsDir, entry.name);
         const runPath = path14.join(subDir, `${runId}.json`);
         if (existsSync7(runPath)) {
-          const raw = await readFile11(runPath, "utf-8");
+          const raw = await readFile10(runPath, "utf-8");
           const run = JSON.parse(raw);
           const totalCostUsd = Object.values(run.steps).reduce(
             (sum, step) => sum + (step.costUsd ?? 0),
@@ -5860,9 +6149,12 @@ var SupervisorDaemon = class {
   async readState() {
     const statePath = path15.join(this.dir, "state.json");
     try {
-      const raw = await readFile12(statePath, "utf-8");
+      const raw = await readFile11(statePath, "utf-8");
       return JSON.parse(raw);
-    } catch {
+    } catch (err) {
+      console.debug(
+        `[SupervisorDaemon] Failed to read state: ${err instanceof Error ? err.message : String(err)}`
+      );
       return null;
     }
   }
@@ -5872,10 +6164,13 @@ var SupervisorDaemon = class {
   }
   async readLockPid(lockPath) {
     try {
-      const raw = await readFile12(lockPath, "utf-8");
+      const raw = await readFile11(lockPath, "utf-8");
       const pid = Number.parseInt(raw.trim(), 10);
       return Number.isNaN(pid) ? null : pid;
-    } catch {
+    } catch (err) {
+      console.debug(
+        `[SupervisorDaemon] Failed to read lock PID from ${lockPath}: ${err instanceof Error ? err.message : String(err)}`
+      );
       return null;
     }
   }
@@ -5911,8 +6206,8 @@ var SupervisorDaemon = class {
 };
 
 // src/supervisor/StatusReader.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { readFile as readFile13 } from "fs/promises";
+import { existsSync as existsSync9, readFileSync as readFileSync2 } from "fs";
+import { readdir as readdir5, readFile as readFile12 } from "fs/promises";
 import path16 from "path";
 var STATE_FILE = "state.json";
 var ACTIVITY_FILE2 = "activity.jsonl";
@@ -5932,14 +6227,20 @@ var StatusReader = class {
   async getStatus() {
     let raw;
     try {
-      raw = await readFile13(this.statePath, "utf-8");
-    } catch {
+      raw = await readFile12(this.statePath, "utf-8");
+    } catch (err) {
+      console.debug(
+        `[StatusReader] State file not found: ${err instanceof Error ? err.message : String(err)}`
+      );
       return null;
     }
     let parsed;
     try {
       parsed = JSON.parse(raw);
-    } catch {
+    } catch (err) {
+      console.debug(
+        `[StatusReader] Malformed state JSON: ${err instanceof Error ? err.message : String(err)}`
+      );
       return null;
     }
     const result = supervisorDaemonStateSchema.safeParse(parsed);
@@ -5953,6 +6254,7 @@ var StatusReader = class {
       stopped: "idle"
     };
     const recentActivity = this.queryActivity({ limit: 5 });
+    const activeRunCount = await this.countActiveRuns();
     return {
       pid: daemon.pid,
       sessionId: daemon.sessionId,
@@ -5962,8 +6264,7 @@ var StatusReader = class {
       todayCostUsd: daemon.todayCostUsd,
       status: statusMap[daemon.status],
       lastHeartbeat: daemon.lastHeartbeat ?? daemon.startedAt,
-      activeRunCount: 0,
-      // TODO: count active runs from .neo/runs/
+      activeRunCount,
       recentActivitySummary: recentActivity.map((e) => `[${e.type}] ${e.summary}`)
     };
   }
@@ -5976,7 +6277,10 @@ var StatusReader = class {
     let content;
     try {
       content = readFileSync2(this.activityPath, "utf-8");
-    } catch {
+    } catch (err) {
+      console.debug(
+        `[StatusReader] Activity file not found: ${err instanceof Error ? err.message : String(err)}`
+      );
       return [];
     }
     const lines = content.trim().split("\n").filter(Boolean);
@@ -5988,7 +6292,10 @@ var StatusReader = class {
         if (result.success) {
           entries.push(result.data);
         }
-      } catch {
+      } catch (err) {
+        console.debug(
+          `[StatusReader] Skipping malformed activity line: ${err instanceof Error ? err.message : String(err)}`
+        );
       }
     }
     if (type) {
@@ -6004,16 +6311,80 @@ var StatusReader = class {
     }
     return entries.slice(offset, offset + limit);
   }
+  /**
+   * Count runs with status "running" from .neo/runs/.
+   * Fails silently — returns 0 if the runs directory doesn't exist.
+   */
+  async countActiveRuns() {
+    const runsDir = getRunsDir();
+    if (!existsSync9(runsDir)) return 0;
+    try {
+      const runFiles = await this.collectRunFiles(runsDir);
+      let count = 0;
+      for (const filePath of runFiles) {
+        if (await this.isRunning(filePath)) count++;
+      }
+      return count;
+    } catch (err) {
+      console.debug(
+        `[StatusReader] Failed to count active runs: ${err instanceof Error ? err.message : String(err)}`
+      );
+      return 0;
+    }
+  }
+  /**
+   * Collect all run JSON files from the runs directory tree.
+   * Searches both top-level and repo subdirectories.
+   */
+  async collectRunFiles(runsDir) {
+    const entries = await readdir5(runsDir, { withFileTypes: true });
+    const jsonFiles = [];
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const subDir = path16.join(runsDir, entry.name);
+        const subFiles = await readdir5(subDir);
+        for (const f of subFiles) {
+          if (this.isRunFile(f)) {
+            jsonFiles.push(path16.join(subDir, f));
+          }
+        }
+      } else if (this.isRunFile(entry.name)) {
+        jsonFiles.push(path16.join(runsDir, entry.name));
+      }
+    }
+    return jsonFiles;
+  }
+  /**
+   * Check if a filename is a run file (JSON but not dispatch).
+   */
+  isRunFile(filename) {
+    return filename.endsWith(".json") && !filename.endsWith(".dispatch.json");
+  }
+  /**
+   * Check if a run file represents an active (running) run.
+   */
+  async isRunning(filePath) {
+    try {
+      const content = await readFile12(filePath, "utf-8");
+      const run = JSON.parse(content);
+      return run.status === "running";
+    } catch (err) {
+      console.debug(
+        `[StatusReader] Failed to read run file ${filePath}: ${err instanceof Error ? err.message : String(err)}`
+      );
+      return false;
+    }
+  }
 };
 
 // src/supervisor/shutdown.ts
-import { existsSync as existsSync9 } from "fs";
-import { readdir as readdir5, readFile as readFile14, writeFile as writeFile8 } from "fs/promises";
+import { existsSync as existsSync10 } from "fs";
+import { readdir as readdir6, readFile as readFile13, writeFile as writeFile8 } from "fs/promises";
 import path17 from "path";
 
 // src/webhook-config.ts
-import { existsSync as existsSync10 } from "fs";
-import { mkdir as mkdir8, readFile as readFile15, writeFile as writeFile9 } from "fs/promises";
+import { existsSync as existsSync11 } from "fs";
+import { mkdir as mkdir8, readFile as readFile14, writeFile as writeFile9 } from "fs/promises";
 import path18 from "path";
 import { z as z8 } from "zod";
 var webhookEntrySchema = z8.object({
@@ -6031,10 +6402,10 @@ function getWebhooksConfigPath() {
 }
 async function loadWebhooksConfig() {
   const configPath = getWebhooksConfigPath();
-  if (!existsSync10(configPath)) {
+  if (!existsSync11(configPath)) {
     return { webhooks: [] };
   }
-  const raw = await readFile15(configPath, "utf-8");
+  const raw = await readFile14(configPath, "utf-8");
   const parsed = JSON.parse(raw);
   return webhooksConfigSchema.parse(parsed);
 }