@neotx/core 0.1.0-alpha.21 → 0.1.0-alpha.24

package/dist/index.js

@@ -20,17 +20,32 @@ var agentToolSchema = z.enum([
 ]);
 var agentToolEntrySchema = z.union([agentToolSchema, z.literal("$inherited")]);
 var agentSandboxSchema = z.enum(["writable", "readonly"]);
+var subagentDefinitionSchema = z.object({
+  description: z.string(),
+  prompt: z.string(),
+  tools: z.array(agentToolSchema).optional(),
+  model: agentModelSchema.optional()
+});
 var agentConfigSchema = z.object({
   name: z.string(),
   extends: z.string().optional(),
   description: z.string().optional(),
+  version: z.string().optional(),
   model: agentModelSchema.optional(),
   tools: z.array(agentToolEntrySchema).optional(),
   prompt: z.string().optional(),
   promptAppend: z.string().optional(),
   sandbox: agentSandboxSchema.optional(),
   maxTurns: z.number().optional(),
-  mcpServers: z.array(z.string()).optional()
+  /**
+   * Maximum cost in USD for this agent session.
+   * Checked post-session (SDK provides cost only after session ends).
+   * If session cost >= maxCost, a budget_exceeded error is thrown.
+   * Child agents can override the parent's maxCost.
+   */
+  maxCost: z.number().min(0).optional(),
+  mcpServers: z.array(z.string()).optional(),
+  agents: z.record(z.string(), subagentDefinitionSchema).optional()
 });
 
 // src/agents/loader.ts
@@ -60,8 +75,24 @@ ${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)}`
+      );
+    }
+  }
+  if (config.agents) {
+    for (const [name, subagent] of Object.entries(config.agents)) {
+      if (subagent.prompt.endsWith(".md")) {
+        const subagentPromptPath = path.resolve(path.dirname(filePath), subagent.prompt);
+        try {
+          subagent.prompt = await readFile(subagentPromptPath, "utf-8");
+        } catch (err) {
+          throw new Error(
+            `Subagent "${name}" prompt file not found: ${subagentPromptPath} (referenced in ${filePath}). Error: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
     }
   }
   return config;
@@ -89,18 +120,25 @@ function resolveExtendedAgent(config, extendsName, builtIns) {
   const tools = mergeTools(config.tools, base.tools);
   const prompt = mergePrompt(config.prompt, config.promptAppend, base.prompt);
   const mcpServers = mergeMcpServerNames(base.mcpServers, config.mcpServers);
+  const agents = mergeAgents(
+    base.agents,
+    config.agents
+  );
   const definition = {
     description: config.description ?? base.description ?? "",
     prompt,
     tools,
     model: config.model ?? base.model ?? "sonnet",
-    ...mcpServers.length > 0 ? { mcpServers } : {}
+    ...mcpServers.length > 0 ? { mcpServers } : {},
+    ...agents ? { agents } : {}
   };
   return {
     name: config.name,
     definition,
     sandbox: config.sandbox ?? base.sandbox ?? "readonly",
     ...config.maxTurns !== void 0 ? { maxTurns: config.maxTurns } : base.maxTurns !== void 0 ? { maxTurns: base.maxTurns } : {},
+    ...config.maxCost !== void 0 ? { maxCost: config.maxCost } : base.maxCost !== void 0 ? { maxCost: base.maxCost } : {},
+    ...config.version !== void 0 ? { version: config.version } : base.version !== void 0 ? { version: base.version } : {},
     source: config.name === extendsName && !config.extends ? "built-in" : "extended"
   };
 }
@@ -142,13 +180,16 @@ ${config.promptAppend}`;
     prompt,
     tools,
     model: config.model,
-    ...config.mcpServers?.length ? { mcpServers: config.mcpServers } : {}
+    ...config.mcpServers?.length ? { mcpServers: config.mcpServers } : {},
+    ...config.agents ? { agents: config.agents } : {}
   };
   return {
     name: config.name,
     definition,
     sandbox: config.sandbox,
     ...config.maxTurns !== void 0 ? { maxTurns: config.maxTurns } : {},
+    ...config.maxCost !== void 0 ? { maxCost: config.maxCost } : {},
+    ...config.version !== void 0 ? { version: config.version } : {},
     source: "custom"
   };
 }
@@ -173,6 +214,12 @@ function mergeMcpServerNames(base, override) {
   if (!base?.length && !override?.length) return [];
   return [.../* @__PURE__ */ new Set([...base ?? [], ...override ?? []])];
 }
+function mergeAgents(base, override) {
+  if (!base && !override) return void 0;
+  if (!base) return override;
+  if (!override) return base;
+  return { ...base, ...override };
+}
 
 // src/agents/registry.ts
 var AgentRegistry = class {
@@ -198,7 +245,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 +555,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 +603,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 +658,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 +788,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 +807,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 +907,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 +923,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 +999,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 +1057,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 +1083,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 +1119,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 +1171,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 +1183,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");
   }
@@ -1127,7 +1285,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);
@@ -1163,14 +1324,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
@@ -1180,7 +1365,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,
@@ -1234,14 +1424,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;
@@ -1261,15 +1457,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) {
@@ -1282,6 +1484,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]);
 }
 
@@ -1343,15 +1547,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 = {
@@ -1506,12 +1716,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
@@ -1597,7 +1807,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;
@@ -1612,13 +1822,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;
   }
@@ -1831,7 +2041,7 @@ function buildQueryOptions(options) {
     // Always pass cwd: session clone for writable agents, repo root for readonly.
     // Without this, readonly agents default to process.cwd() and may write to main tree.
     cwd: sessionPath ?? options.repoPath,
-    // maxTurns: agent.maxTurns,
+    ...options.maxTurns ? { maxTurns: options.maxTurns } : {},
     allowedTools: sandboxConfig.allowedTools,
     // Workers run detached without a TTY — bypass interactive permission prompts.
     // Required pair: permissionMode alone is not enough, SDK also needs the flag.
@@ -1848,6 +2058,9 @@ function buildQueryOptions(options) {
   if (options.mcpServers && Object.keys(options.mcpServers).length > 0) {
     queryOptions.mcpServers = options.mcpServers;
   }
+  if (options.agents && Object.keys(options.agents).length > 0) {
+    queryOptions.agents = options.agents;
+  }
   if (options.env && Object.keys(options.env).length > 0) {
     queryOptions.env = { ...process.env, ...options.env };
   }
@@ -2076,14 +2289,23 @@ ALWAYS run commands from this directory. NEVER cd to or operate on any other rep
       sandboxConfig,
       hooks,
       env: agentEnv,
+      agents: agent.definition.agents,
       initTimeoutMs: this.config.initTimeoutMs,
       maxDurationMs: this.config.maxDurationMs,
       maxRetries: this.config.maxRetries,
       backoffBaseMs: this.config.backoffBaseMs,
       ...sessionPath ? { sessionPath } : {},
       ...mcpServers ? { mcpServers } : {},
-      ...onAttempt ? { onAttempt } : {}
+      ...onAttempt ? { onAttempt } : {},
+      ...agent.maxTurns ? { maxTurns: agent.maxTurns } : {}
     });
+    if (agent.maxCost !== void 0 && sessionResult.costUsd >= agent.maxCost) {
+      throw new SessionError(
+        `Agent session exceeded budget: $${sessionResult.costUsd.toFixed(4)} >= $${agent.maxCost.toFixed(4)} limit`,
+        "budget_exceeded",
+        sessionResult.sessionId
+      );
+    }
     const parsed = parseOutput(sessionResult.output);
     const result = {
       status: "success",
@@ -2684,6 +2906,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,
@@ -2694,6 +2917,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();
@@ -2865,7 +3097,10 @@ 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 {
@@ -2895,14 +3130,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) {
@@ -2979,7 +3217,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;
   }
@@ -3046,7 +3287,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;
     }
   }
@@ -3197,17 +3441,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;
@@ -3217,10 +3461,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;
   }
@@ -3263,9 +3513,20 @@ 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, stat as stat3, writeFile as writeFile3 } from "fs/promises";
 import path11 from "path";
 import { z as z4 } from "zod";
+var DecisionFileSizeError = class extends Error {
+  constructor(filePath, fileSizeBytes, maxSizeBytes) {
+    super(
+      `Decision 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 = "DecisionFileSizeError";
+  }
+};
 var decisionOptionSchema = z4.object({
   key: z4.string(),
   label: z4.string(),
@@ -3279,21 +3540,49 @@ 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 tombstoneSchema = z4.object({
+  action: z4.literal("tombstone"),
+  id: z4.string(),
+  createdAt: z4.coerce.string(),
+  reason: z4.enum(["deleted", "expired", "purged"])
 });
 var DecisionStore = class {
   filePath;
   dir;
   dirCache = /* @__PURE__ */ new Set();
+  /** Promise-based mutex to serialize write operations */
+  writeLock = Promise.resolve();
+  /** Maximum file size in bytes before validation fails (default: 10MB) */
+  maxFileSizeBytes = 10 * 1024 * 1024;
   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
@@ -3313,19 +3602,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).
@@ -3362,33 +3654,40 @@ 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");
+      const stats = await stat3(this.filePath);
+      if (stats.size > this.maxFileSizeBytes) {
+        throw new DecisionFileSizeError(this.filePath, stats.size, this.maxFileSizeBytes);
+      }
+      content = await readFile6(this.filePath, "utf-8");
     } catch (error) {
       if (error.code === "ENOENT") {
         return [];
@@ -3514,7 +3813,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 stat4 } from "fs/promises";
 import path12 from "path";
 var ACTIVITY_FILE = "activity.jsonl";
 var MAX_SIZE_BYTES = 10 * 1024 * 1024;
@@ -3553,8 +3852,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);
@@ -3563,14 +3865,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 stat4(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`);
@@ -3584,13 +3889,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();
@@ -3743,7 +4048,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;
     }
@@ -3768,7 +4073,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;
     }
@@ -3804,7 +4109,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) => {
@@ -3832,7 +4137,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";
 
@@ -3888,7 +4193,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 stat5, writeFile as writeFile5 } from "fs/promises";
 import path13 from "path";
 var LOG_BUFFER_FILE = "log-buffer.jsonl";
 var MAX_FILE_BYTES = 1024 * 1024;
@@ -3902,16 +4207,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 [];
   }
 }
@@ -3923,8 +4234,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);
@@ -3938,7 +4252,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);
     }
   }
@@ -3949,8 +4266,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();
@@ -3966,7 +4286,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")}
@@ -3982,7 +4305,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)}`
+    );
   }
 }
 
@@ -4000,7 +4326,10 @@ 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.
+- **Decision routing**: when a pending decision arrives from an agent, answer within 1-2 heartbeats. Route: (1) answer directly if strategic/scope/priority, (2) dispatch scout to investigate if codebase context needed, (3) wait for human if autoDecide is off or genuinely uncertain. Agents are BLOCKED waiting \u2014 stale decisions waste session budget.
+- **Verify agent output**: always read agent output with \`neo runs <runId>\` before dispatching follow-up work. Route based on agent output contracts documented in SUPERVISOR.md.`;
 var COMMANDS = `### Dispatching agents
 \`\`\`bash
 neo run <agent> --prompt "..." --repo <path> --branch <name> [--priority critical|high|medium|low] [--meta '<json>']
@@ -4025,7 +4354,7 @@ neo runs <runId>                    # full run details + agent output (MUST READ
 neo cost --short [--all]            # check budget
 \`\`\`
 
-\`neo runs <runId>\` returns the agent's full output. **ALWAYS read it when a run completes** \u2014 it contains structured JSON (PR URLs, issues, plans, milestones) that you need to decide next steps.
+\`neo runs <runId>\` returns the agent's full output. **ALWAYS read it when a run completes** \u2014 it contains the agent's results that you need to decide next steps per SUPERVISOR.md routing rules.
 
 ### Memory
 \`\`\`bash
@@ -4076,8 +4405,9 @@ var HEARTBEAT_RULES = `### Heartbeat lifecycle
 1. DEDUP FIRST \u2014 check focus for PROCESSED entries. Skip any runId already processed.
 2. MONITOR RUNS \u2014 \`neo runs --short\` to check active run status. If a run completed since last HB, read its output with \`neo runs <runId>\` BEFORE doing anything else.
 3. PENDING TASKS? \u2014 dispatch the next eligible task from work queue. Do not re-plan.
-4. EVENTS? \u2014 process run completions, messages, webhooks. Parse agent JSON output.
+4. EVENTS? \u2014 process run completions, messages, webhooks. Read agent output and route per SUPERVISOR.md contracts.
 5. FOLLOW-UPS? \u2014 check CI (\`gh pr checks\`), deferred dispatches.
+5b. DECISIONS? \u2014 check \`neo decision list\` for pending decisions from agents. Route each: answer directly, dispatch scout to investigate, or wait for human. Agents are blocked waiting \u2014 prioritize these.
 6. DISPATCH \u2014 route work to agents. Mark tasks \`in_progress\`, add ACTIVE to focus.
 7. UPDATE TASKS \u2014 review ALL in_progress/blocked tasks. For each: confirm status matches reality (run still active? PR merged? blocked resolved?). Update outcomes immediately \u2014 do not defer to next heartbeat.
 8. SERIALIZE & YIELD \u2014 rewrite focus (see <focus>), log your decisions, and yield. Do not poll.
@@ -4086,15 +4416,15 @@ var HEARTBEAT_RULES = `### Heartbeat lifecycle
 <run-monitoring>
 Runs are your agents in the field. You MUST actively track them:
 - **On dispatch**: include a label in \`--meta\` for identification: \`--meta '{"label":"T6-csv-export","ticketId":"YC-42",...}'\`
-- **On completion**: ALWAYS run \`neo runs <runId>\` to read the full output. Parse structured JSON (PR URLs, issues, plans). This is NOT optional \u2014 you cannot decide next steps without reading the output.
+- **On completion**: ALWAYS run \`neo runs <runId>\` to read the full output. This is NOT optional \u2014 you cannot decide next steps without reading the output.
 - **On failure**: read the output to understand why. Decide: retry (blocked), abandon, or escalate.
 - **Active runs**: check \`neo runs --short --status running\` to verify your runs are still alive. If a run disappeared, investigate.
 </run-monitoring>
 
 <multi-task-initiatives>
-**Branch strategy:** one branch per initiative \u2014 all tasks push to the same branch sequentially (never in parallel). First task creates the branch; open PR after it completes. Later tasks add commits to the same PR. Independent initiatives CAN run in parallel on different branches.
+**Branch strategy:** one branch per initiative. Architect produces a plan; developer executes all tasks on that branch. Independent initiatives CAN run in parallel on different branches.
 
-**Dispatch quality:** write a detailed \`--prompt\` with acceptance criteria, files to modify, and context from completed sibling tasks (commits, APIs added, files changed). When dispatching task N, summarize what tasks 1..N-1 produced.
+**Dispatch quality:** when dispatching developer with a plan, include the plan path and any context from completed prior work (PR numbers, APIs added). For direct tasks (no plan), write a detailed \`--prompt\` with acceptance criteria.
 
 **Post-completion:** if agent opened a PR, dispatch \`reviewer\` in parallel with CI (do not wait). Update task outcome with concrete details (PR#, what was done) and update the initiative note.
 
@@ -4183,7 +4513,7 @@ function buildMemoryRulesExamples(supervisorDir) {
 neo memory write --type focus --expires 2h "ACTIVE: 5900a64a developer 'T1' branch:feat/x (cat ${notesDir}/plan-YC-2670-kanban.md)"
 neo memory write --type fact --scope /repo "main branch uses protected merges \u2014 agents must create PRs, never push directly"
 neo memory write --type fact --scope /repo "pnpm build must pass before push \u2014 CI does not rebuild, run 2g589f34a5a failed without it"
-neo memory write --type procedure --scope /repo "After architect run: parse milestones from JSON output, create one task per milestone with --tags initiative:<name>"
+neo memory write --type procedure --scope /repo "After architect run: read plan path from output, dispatch developer with plan per SUPERVISOR.md routing"
 neo memory write --type procedure --scope /repo "When developer run fails with ENOSPC: the repo has large fixtures \u2014 use --branch with shallow clone flag"
 neo memory write --type feedback --scope /repo "User wants PR descriptions in French even though code is in English"
 neo memory write --type task --scope /repo --severity high --category "neo runs 2g589f34a5a" --tags "initiative:auth-v2,depends:mem_xyz" "T1: Auth middleware"
@@ -4216,7 +4546,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 "";
   }
@@ -4235,7 +4565,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>
@@ -4243,10 +4573,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")}
 
@@ -4278,7 +4605,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);
   }
@@ -4589,7 +4916,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)}
 
@@ -4604,7 +4931,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)}
 
@@ -4653,29 +4980,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) {
@@ -4944,7 +5250,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();
   }
@@ -4955,21 +5262,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
     });
@@ -4979,27 +5279,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
       }
     );
@@ -5011,17 +5315,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,
@@ -5044,13 +5342,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 = {
@@ -5066,21 +5443,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.
@@ -5183,10 +5545,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,
@@ -5197,13 +5555,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) {
@@ -5313,7 +5672,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;
@@ -5321,7 +5680,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");
@@ -5346,7 +5705,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(
@@ -5380,7 +5739,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 {
@@ -5495,7 +5854,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),
@@ -5873,9 +6232,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;
     }
   }
@@ -5885,10 +6247,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;
     }
   }
@@ -5924,8 +6289,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";
@@ -5945,14 +6310,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);
@@ -5966,6 +6337,7 @@ var StatusReader = class {
       stopped: "idle"
     };
     const recentActivity = this.queryActivity({ limit: 5 });
+    const activeRunCount = await this.countActiveRuns();
     return {
       pid: daemon.pid,
       sessionId: daemon.sessionId,
@@ -5975,8 +6347,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}`)
     };
   }
@@ -5989,7 +6360,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);
@@ -6001,7 +6375,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) {
@@ -6017,16 +6394,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({
@@ -6044,10 +6485,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);
 }