bosun 0.34.7 → 0.34.9

package/agent-work-analyzer.mjs

@@ -63,6 +63,88 @@ const activeSessions = new Map();
 // Alert cooldowns: "alert_type:attempt_id" -> timestamp
 const alertCooldowns = new Map();
 const ALERT_COOLDOWN_MS = 5 * 60 * 1000; // 5 minutes between same alert
+const FAILED_SESSION_ALERT_MIN_COOLDOWN_MS = 60 * 60 * 1000; // Keep noisy failed-session summaries coarse-grained
+const ALERT_COOLDOWN_RETENTION_MS = Math.max(
+  FAILED_SESSION_ALERT_MIN_COOLDOWN_MS * 3,
+  3 * 60 * 60 * 1000,
+); // keep cooldown history bounded
+const ALERT_COOLDOWN_REPLAY_MAX_BYTES = Math.max(
+  256 * 1024,
+  Number(process.env.AGENT_ALERT_COOLDOWN_REPLAY_MAX_BYTES || 2 * 1024 * 1024) || 2 * 1024 * 1024,
+);
+
+function getAlertCooldownMs(alert) {
+  const type = String(alert?.type || "").trim().toLowerCase();
+  if (type === "failed_session_high_errors") {
+    return Math.max(ALERT_COOLDOWN_MS, FAILED_SESSION_ALERT_MIN_COOLDOWN_MS);
+  }
+  return Math.max(0, ALERT_COOLDOWN_MS);
+}
+
+function extractTaskToken(value) {
+  const normalized = String(value || "").trim();
+  if (!normalized) return "";
+  const prefixMatch = normalized.match(
+    /^([0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12})(?:-|$)/i,
+  );
+  return prefixMatch?.[1] || normalized;
+}
+
+function deriveAlertScopeId(alert) {
+  const taskId = extractTaskToken(alert?.task_id);
+  if (taskId) return taskId;
+  return extractTaskToken(alert?.attempt_id);
+}
+
+function buildAlertCooldownKey(alert) {
+  const type = String(alert?.type || "unknown").trim().toLowerCase() || "unknown";
+  const scopeId = deriveAlertScopeId(alert);
+  if (scopeId && (type === "failed_session_high_errors" || type === "stuck_agent")) {
+    return `${type}:task:${scopeId}`;
+  }
+  return `${type}:${String(alert?.attempt_id || "unknown")}`;
+}
+
+function pruneStaleAlertCooldowns(nowMs = Date.now()) {
+  const now = Number(nowMs) || Date.now();
+  const cutoff = now - ALERT_COOLDOWN_RETENTION_MS;
+  for (const [key, ts] of alertCooldowns.entries()) {
+    const lastTs = Number(ts);
+    if (!Number.isFinite(lastTs) || lastTs < cutoff) {
+      alertCooldowns.delete(key);
+    }
+  }
+}
+
+async function hydrateAlertCooldownsFromLog() {
+  if (!existsSync(ALERTS_LOG)) return;
+  try {
+    const fileStat = await stat(ALERTS_LOG);
+    if (!fileStat.size) return;
+    const start = Math.max(0, fileStat.size - ALERT_COOLDOWN_REPLAY_MAX_BYTES);
+    const stream = createReadStream(ALERTS_LOG, { start, encoding: "utf8" });
+    const rl = createInterface({ input: stream, crlfDelay: Infinity });
+    const maxCooldownMs = Math.max(ALERT_COOLDOWN_MS, FAILED_SESSION_ALERT_MIN_COOLDOWN_MS);
+    const cutoff = Date.now() - maxCooldownMs;
+    for await (const line of rl) {
+      const trimmed = String(line || "").trim();
+      if (!trimmed) continue;
+      try {
+        const entry = JSON.parse(trimmed);
+        const ts = Date.parse(String(entry?.timestamp || ""));
+        if (!Number.isFinite(ts) || ts < cutoff) continue;
+        const cooldownMs = getAlertCooldownMs(entry);
+        if (ts < Date.now() - cooldownMs) continue;
+        const key = String(entry?._cooldown_key || "").trim() || buildAlertCooldownKey(entry);
+        alertCooldowns.set(key, ts);
+      } catch {
+        // ignore malformed jsonl
+      }
+    }
+  } catch {
+    // best-effort hydration only
+  }
+}
 
 // ── Log Tailing ─────────────────────────────────────────────────────────────
 
@@ -70,6 +152,14 @@ let filePosition = 0;
 let isRunning = false;
 let stuckSweepTimer = null;
 
+function parseEnvBoolean(value, fallback = false) {
+  if (value == null || value === "") return fallback;
+  const normalized = String(value).trim().toLowerCase();
+  if (["1", "true", "yes", "y", "on"].includes(normalized)) return true;
+  if (["0", "false", "no", "n", "off"].includes(normalized)) return false;
+  return fallback;
+}
+
 /**
  * Start the analyzer loop
  */
@@ -88,14 +178,29 @@ export async function startAnalyzer() {
     if (!existsSync(ALERTS_LOG)) {
       await writeFile(ALERTS_LOG, "");
     }
+    await hydrateAlertCooldownsFromLog();
   } catch (err) {
     console.warn(`[agent-work-analyzer] Failed to init alerts log: ${err.message}`);
   }
 
-  // Initial read of existing log
+  // Initial positioning for existing log.
+  // Default behavior is true tailing (start at EOF) to avoid replaying stale
+  // historical sessions on monitor restart, which can re-emit old alerts and
+  // trigger noisy false-positive loops. Operators can opt in to replay for
+  // forensics via AGENT_ANALYZER_REPLAY_STARTUP=1.
   if (existsSync(AGENT_WORK_STREAM)) {
-    filePosition = await processLogFile(filePosition);
-    pruneStaleSessionsAfterReplay();
+    const replayStartup = parseEnvBoolean(
+      process.env.AGENT_ANALYZER_REPLAY_STARTUP,
+      false,
+    );
+    if (replayStartup) {
+      filePosition = await processLogFile(filePosition);
+      pruneStaleSessionsAfterReplay();
+    } else {
+      const streamStats = await stat(AGENT_WORK_STREAM);
+      filePosition = Math.max(0, Number(streamStats?.size || 0));
+      activeSessions.clear();
+    }
   } else {
     // Ensure the stream file exists so the watcher doesn't throw
     try {
@@ -154,7 +259,12 @@ export function stopAnalyzer() {
 async function processLogFile(startPosition) {
   try {
     const stats = await stat(AGENT_WORK_STREAM);
-    if (stats.size <= startPosition) {
+    if (stats.size < startPosition) {
+      // Log file was truncated/rotated. Reset offset so new entries are not
+      // skipped forever after rotation.
+      return 0;
+    }
+    if (stats.size === startPosition) {
       return startPosition; // No new data
     }
 
@@ -163,12 +273,29 @@ async function processLogFile(startPosition) {
       encoding: "utf8",
     });
 
-    const rl = createInterface({ input: stream });
-    let bytesRead = startPosition;
+    let chunkText = "";
+    for await (const chunk of stream) {
+      chunkText += String(chunk || "");
+    }
+    if (!chunkText) {
+      return startPosition;
+    }
 
-    for await (const line of rl) {
-      bytesRead += Buffer.byteLength(line, "utf8") + 1; // +1 for newline
+    const lastNewlineIdx = chunkText.lastIndexOf("\n");
+    let processText = "";
+    let trailing = "";
+    if (lastNewlineIdx >= 0) {
+      processText = chunkText.slice(0, lastNewlineIdx + 1);
+      trailing = chunkText.slice(lastNewlineIdx + 1);
+    } else {
+      trailing = chunkText;
+    }
 
+    const lines = processText
+      .split(/\r?\n/)
+      .map((line) => String(line || "").trim())
+      .filter(Boolean);
+    for (const line of lines) {
       try {
         const event = JSON.parse(line);
         await analyzeEvent(event);
@@ -179,7 +306,21 @@ async function processLogFile(startPosition) {
       }
     }
 
-    return bytesRead;
+    // If trailing text is present without newline, treat it as a potentially
+    // partial line and only consume it when it is valid JSON. This avoids data
+    // loss when writers flush an incomplete line temporarily.
+    const trailingTrimmed = String(trailing || "").trim();
+    if (trailingTrimmed) {
+      try {
+        const trailingEvent = JSON.parse(trailingTrimmed);
+        await analyzeEvent(trailingEvent);
+        return startPosition + Buffer.byteLength(chunkText, "utf8");
+      } catch {
+        return startPosition + Buffer.byteLength(processText, "utf8");
+      }
+    }
+
+    return startPosition + Buffer.byteLength(processText, "utf8");
   } catch (err) {
     if (err.code !== "ENOENT") {
       console.error(`[agent-work-analyzer] Error reading log: ${err.message}`);
@@ -450,11 +591,12 @@ function startStuckSweep() {
  * @param {Object} alert - Alert data
  */
 async function emitAlert(alert) {
-  const alertKey = `${alert.type}:${alert.attempt_id}`;
+  const alertKey = buildAlertCooldownKey(alert);
+  const cooldownMs = getAlertCooldownMs(alert);
 
   // Check cooldown
   const lastAlert = alertCooldowns.get(alertKey);
-  if (lastAlert && Date.now() - lastAlert < ALERT_COOLDOWN_MS) {
+  if (lastAlert && Date.now() - lastAlert < cooldownMs) {
     return; // Skip duplicate alerts
   }
 
@@ -462,6 +604,7 @@ async function emitAlert(alert) {
 
   const alertEntry = {
     timestamp: new Date().toISOString(),
+    _cooldown_key: alertKey,
     ...alert,
   };
 
@@ -477,7 +620,7 @@ async function emitAlert(alert) {
 
 // ── Cleanup Old Sessions ────────────────────────────────────────────────────
 
-setInterval(() => {
+const cleanupTimer = setInterval(() => {
   const cutoff = Date.now() - 60 * 60 * 1000; // 1 hour
 
   for (const [attemptId, session] of activeSessions.entries()) {
@@ -486,7 +629,8 @@ setInterval(() => {
       activeSessions.delete(attemptId);
     }
   }
+  pruneStaleAlertCooldowns();
 }, 10 * 60 * 1000); // Cleanup every 10 minutes
+cleanupTimer.unref?.();
 
 // ── Exports ─────────────────────────────────────────────────────────────────
-

package/cli.mjs

@@ -34,6 +34,15 @@ import {
   migrateFromLegacy,
 } from "./compat.mjs";
 
+const MONITOR_START_MAX_WAIT_MS = Math.max(
+  0,
+  Number(process.env.BOSUN_MONITOR_START_MAX_WAIT_MS || "15000") || 15000,
+);
+const MONITOR_START_RETRY_MS = Math.max(
+  100,
+  Number(process.env.BOSUN_MONITOR_START_RETRY_MS || "500") || 500,
+);
+
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const args = process.argv.slice(2);
 
@@ -1484,133 +1493,189 @@ function detectExistingMonitorLockOwner(excludePid = null) {
   return null;
 }
 
+function getRequiredMonitorRuntimeFiles(monitorPath) {
+  const required = [monitorPath];
+  const copilotDir = resolve(
+    __dirname,
+    "node_modules",
+    "@github",
+    "copilot",
+  );
+  const conptyAgentPath = resolve(copilotDir, "conpty_console_list_agent.js");
+  if (process.platform === "win32" && existsSync(copilotDir)) {
+    required.push(conptyAgentPath);
+  }
+  return required;
+}
+
+function listMissingFiles(paths) {
+  return paths.filter((entry) => !existsSync(entry));
+}
+
+async function waitForMonitorRuntimeFiles(monitorPath) {
+  const required = getRequiredMonitorRuntimeFiles(monitorPath);
+  const startedAt = Date.now();
+  let missing = listMissingFiles(required);
+  while (
+    missing.length > 0 &&
+    Date.now() - startedAt < MONITOR_START_MAX_WAIT_MS
+  ) {
+    await new Promise((resolveWait) => {
+      setTimeout(resolveWait, MONITOR_START_RETRY_MS);
+    });
+    missing = listMissingFiles(required);
+  }
+  return {
+    ready: missing.length === 0,
+    missing,
+    waitedMs: Date.now() - startedAt,
+  };
+}
+
 function runMonitor({ restartReason = "" } = {}) {
   return new Promise((resolve, reject) => {
     const monitorPath = fileURLToPath(
       new URL("./monitor.mjs", import.meta.url),
     );
-    const childEnv = { ...process.env };
-    if (restartReason) {
-      childEnv.BOSUN_MONITOR_RESTART_REASON = restartReason;
-    } else {
-      delete childEnv.BOSUN_MONITOR_RESTART_REASON;
-    }
-    monitorChild = fork(monitorPath, process.argv.slice(2), {
-      stdio: "inherit",
-      execArgv: ["--max-old-space-size=4096"],
-      env: childEnv,
-      windowsHide: IS_DAEMON_CHILD && process.platform === "win32",
-    });
-    daemonCrashTracker.markStart();
-
-    monitorChild.on("exit", (code, signal) => {
-      const childPid = monitorChild?.pid ?? null;
-      monitorChild = null;
-      if (code === SELF_RESTART_EXIT_CODE) {
-        console.log(
-          "\n  \u21BB Monitor restarting with fresh modules...\n",
-        );
-        // Small delay to let file writes / port releases settle
-        setTimeout(() => resolve(runMonitor({ restartReason: "self-restart" })), 2000);
-      } else {
-        const exitCode = code ?? (signal ? 1 : 0);
-        const existingOwner =
-          !gracefulShutdown && exitCode === 1
-            ? detectExistingMonitorLockOwner(childPid)
-            : null;
-        if (existingOwner) {
-          console.log(
-            `\n  bosun is already running (PID ${existingOwner.pid}); exiting duplicate start.\n`,
+    waitForMonitorRuntimeFiles(monitorPath)
+      .then(({ ready, missing, waitedMs }) => {
+        if (!ready) {
+          throw new Error(
+            `monitor runtime files missing after waiting ${Math.round(waitedMs / 1000)}s: ${missing.join(", ")}`,
           );
-          process.exit(0);
-          return;
         }
-        // 4294967295 (0xFFFFFFFF / -1 signed) = OS killed the process (OOM, external termination)
-        const isOSKill = exitCode === 4294967295 || exitCode === -1;
-        const shouldAutoRestart =
-          !gracefulShutdown &&
-          (isOSKill || (IS_DAEMON_CHILD && exitCode !== 0));
-        if (shouldAutoRestart) {
-          const crashState = daemonCrashTracker.recordExit();
-          daemonRestartCount += 1;
-          const delayMs = isOSKill ? 5000 : DAEMON_RESTART_DELAY_MS;
-          if (IS_DAEMON_CHILD && crashState.exceeded) {
-            const durationSec = Math.max(
-              1,
-              Math.round(crashState.runDurationMs / 1000),
-            );
-            const windowSec = Math.max(
-              1,
-              Math.round(crashState.instantCrashWindowMs / 1000),
-            );
-            console.error(
-              `\n  ✖ Monitor crashed too quickly ${crashState.instantCrashCount} times in a row (each <= ${windowSec}s, latest ${durationSec}s). Auto-restart is now paused.`,
-            );
-            sendCrashNotification(exitCode, signal).finally(() =>
-              process.exit(exitCode),
-            );
-            return;
-          }
-          if (
-            IS_DAEMON_CHILD &&
-            DAEMON_MAX_RESTARTS > 0 &&
-            daemonRestartCount > DAEMON_MAX_RESTARTS
-          ) {
-            console.error(
-              `\n  ✖ Monitor crashed too many times (${daemonRestartCount - 1} restarts, max ${DAEMON_MAX_RESTARTS}).`,
-            );
-            sendCrashNotification(exitCode, signal).finally(() =>
-              process.exit(exitCode),
-            );
-            return;
-          }
-          const reasonLabel = signal
-            ? `signal ${signal}`
-            : `exit code ${exitCode}`;
-          const attemptLabel =
-            IS_DAEMON_CHILD && DAEMON_MAX_RESTARTS > 0
-              ? `${daemonRestartCount}/${DAEMON_MAX_RESTARTS}`
-              : `${daemonRestartCount}`;
-          console.error(
-            `\n  ⚠ Monitor exited (${reasonLabel}) — auto-restarting in ${Math.max(1, Math.round(delayMs / 1000))}s${IS_DAEMON_CHILD ? ` [attempt ${attemptLabel}]` : ""}...`,
+        if (waitedMs >= MONITOR_START_RETRY_MS) {
+          console.warn(
+            `[cli] delayed monitor start by ${Math.round(waitedMs / 1000)}s while waiting for runtime files to settle`,
           );
-          sendCrashNotification(exitCode, signal, {
-            autoRestartInMs: delayMs,
-            restartAttempt: daemonRestartCount,
-            maxRestarts: IS_DAEMON_CHILD ? DAEMON_MAX_RESTARTS : 0,
-          }).catch(() => {});
-          setTimeout(
-            () =>
-              resolve(
-                runMonitor({
-                  restartReason: isOSKill ? "os-kill" : "crash",
-                }),
-              ),
-            delayMs,
-          );
-          return;
         }
-
-        if (exitCode !== 0 && !gracefulShutdown) {
-          console.error(
-            `\n  ✖ Monitor crashed (${signal ? `signal ${signal}` : `exit code ${exitCode}`}) — sending crash notification...`,
-          );
-          sendCrashNotification(exitCode, signal).finally(() =>
-            process.exit(exitCode),
-          );
+        const childEnv = { ...process.env };
+        if (restartReason) {
+          childEnv.BOSUN_MONITOR_RESTART_REASON = restartReason;
         } else {
-          daemonRestartCount = 0;
-          daemonCrashTracker.reset();
-          process.exit(exitCode);
+          delete childEnv.BOSUN_MONITOR_RESTART_REASON;
         }
-      }
-    });
-
-    monitorChild.on("error", (err) => {
-      monitorChild = null;
-      console.error(`\n  ✖ Monitor failed to start: ${err.message}`);
-      sendCrashNotification(1, null).finally(() => reject(err));
-    });
+        monitorChild = fork(monitorPath, process.argv.slice(2), {
+          stdio: "inherit",
+          execArgv: ["--max-old-space-size=4096"],
+          env: childEnv,
+          windowsHide: IS_DAEMON_CHILD && process.platform === "win32",
+        });
+        daemonCrashTracker.markStart();
+
+        monitorChild.on("exit", (code, signal) => {
+          const childPid = monitorChild?.pid ?? null;
+          monitorChild = null;
+          if (code === SELF_RESTART_EXIT_CODE) {
+            console.log(
+              "\n  ↻ Monitor restarting with fresh modules...\n",
+            );
+            // Small delay to let file writes / port releases settle
+            setTimeout(() => resolve(runMonitor({ restartReason: "self-restart" })), 2000);
+          } else {
+            const exitCode = code ?? (signal ? 1 : 0);
+            const existingOwner =
+              !gracefulShutdown && exitCode === 1
+                ? detectExistingMonitorLockOwner(childPid)
+                : null;
+            if (existingOwner) {
+              console.log(
+                `\n  bosun is already running (PID ${existingOwner.pid}); exiting duplicate start.\n`,
+              );
+              process.exit(0);
+              return;
+            }
+            // 4294967295 (0xFFFFFFFF / -1 signed) = OS killed the process (OOM, external termination)
+            const isOSKill = exitCode === 4294967295 || exitCode === -1;
+            const shouldAutoRestart =
+              !gracefulShutdown &&
+              (isOSKill || (IS_DAEMON_CHILD && exitCode !== 0));
+            if (shouldAutoRestart) {
+              const crashState = daemonCrashTracker.recordExit();
+              daemonRestartCount += 1;
+              const delayMs = isOSKill ? 5000 : DAEMON_RESTART_DELAY_MS;
+              if (IS_DAEMON_CHILD && crashState.exceeded) {
+                const durationSec = Math.max(
+                  1,
+                  Math.round(crashState.runDurationMs / 1000),
+                );
+                const windowSec = Math.max(
+                  1,
+                  Math.round(crashState.instantCrashWindowMs / 1000),
+                );
+                console.error(
+                  `\n  ✖ Monitor crashed too quickly ${crashState.instantCrashCount} times in a row (each <= ${windowSec}s, latest ${durationSec}s). Auto-restart is now paused.`,
+                );
+                sendCrashNotification(exitCode, signal).finally(() =>
+                  process.exit(exitCode),
+                );
+                return;
+              }
+              if (
+                IS_DAEMON_CHILD &&
+                DAEMON_MAX_RESTARTS > 0 &&
+                daemonRestartCount > DAEMON_MAX_RESTARTS
+              ) {
+                console.error(
+                  `\n  ✖ Monitor crashed too many times (${daemonRestartCount - 1} restarts, max ${DAEMON_MAX_RESTARTS}).`,
+                );
+                sendCrashNotification(exitCode, signal).finally(() =>
+                  process.exit(exitCode),
+                );
+                return;
+              }
+              const reasonLabel = signal
+                ? `signal ${signal}`
+                : `exit code ${exitCode}`;
+              const attemptLabel =
+                IS_DAEMON_CHILD && DAEMON_MAX_RESTARTS > 0
+                  ? `${daemonRestartCount}/${DAEMON_MAX_RESTARTS}`
+                  : `${daemonRestartCount}`;
+              console.error(
+                `\n  ⚠ Monitor exited (${reasonLabel}) — auto-restarting in ${Math.max(1, Math.round(delayMs / 1000))}s${IS_DAEMON_CHILD ? ` [attempt ${attemptLabel}]` : ""}...`,
+              );
+              sendCrashNotification(exitCode, signal, {
+                autoRestartInMs: delayMs,
+                restartAttempt: daemonRestartCount,
+                maxRestarts: IS_DAEMON_CHILD ? DAEMON_MAX_RESTARTS : 0,
+              }).catch(() => {});
+              setTimeout(
+                () =>
+                  resolve(
+                    runMonitor({
+                      restartReason: isOSKill ? "os-kill" : "crash",
+                    }),
+                  ),
+                delayMs,
+              );
+              return;
+            }
+
+            if (exitCode !== 0 && !gracefulShutdown) {
+              console.error(
+                `\n  ✖ Monitor crashed (${signal ? `signal ${signal}` : `exit code ${exitCode}`}) — sending crash notification...`,
+              );
+              sendCrashNotification(exitCode, signal).finally(() =>
+                process.exit(exitCode),
+              );
+            } else {
+              daemonRestartCount = 0;
+              daemonCrashTracker.reset();
+              process.exit(exitCode);
+            }
+          }
+        });
+
+        monitorChild.on("error", (err) => {
+          monitorChild = null;
+          console.error(`\n  ✖ Monitor failed to start: ${err.message}`);
+          sendCrashNotification(1, null).finally(() => reject(err));
+        });
+      })
+      .catch((err) => {
+        console.error(`\n  ✖ Monitor failed to start: ${err.message}`);
+        sendCrashNotification(1, null).finally(() => reject(err));
+      });
   });
 }
 

package/lib/logger.mjs

@@ -68,6 +68,45 @@ let errorLogDirEnsured = false;
 /** @type {Set<string>} Modules to always show at DEBUG level even when console is at INFO */
 const verboseModules = new Set();
 
+const STDERR_NOISE_PATTERNS = [
+  /^(?:\(node:\d+\)\s+)?ExperimentalWarning:\s+SQLite is an experimental feature.*$/i,
+  /^\(Use `node --trace-warnings .*`.*\)\s*$/i,
+  /^Use `node --trace-warnings .*`.*$/i,
+  /^warning:\s+in the working copy of '.*',\s+(?:CRLF will be replaced by LF|LF will be replaced by CRLF) the next time Git touches it\.?\s*$/i,
+  /^(?:\[maintenance\]\s+)?local\s+'[^']+'\s+diverged\s+\(\d+↑\s+\d+↓\)\s+but has uncommitted changes\s+[—-]\s+skipping\.?\s*$/i,
+];
+
+function normalizeStderrNoiseLine(line) {
+  return String(line || "")
+    .replace(/\u001b\[[0-9;]*[A-Za-z]/g, "")
+    .replace(/^\d{4}-\d{2}-\d{2}T[0-9:.+-]+Z?\s+/, "")
+    .replace(/^\d{2}:\d{2}:\d{2}(?:\.\d+)?\s+/, "")
+    .trim()
+    .replace(/^(?:\[[^\]]+\]\s*)+/, "")
+    .trim();
+}
+
+function shouldSuppressStderrNoise(text) {
+  const normalized = String(text || "")
+    .split(/\r?\n/)
+    .map((line) => normalizeStderrNoiseLine(line))
+    .filter(Boolean);
+  if (normalized.length === 0) return false;
+  return normalized.every((line) =>
+    STDERR_NOISE_PATTERNS.some((pattern) => pattern.test(line)),
+  );
+}
+
+function stripKnownStderrNoiseLines(text) {
+  const rawLines = String(text || "").split(/\r?\n/);
+  const kept = rawLines.filter((line) => {
+    const normalized = normalizeStderrNoiseLine(line);
+    if (!normalized) return false;
+    return !STDERR_NOISE_PATTERNS.some((pattern) => pattern.test(normalized));
+  });
+  return kept.join("\n").trim();
+}
+
 // ── Configuration ───────────────────────────────────────────────────────────
 
 /**
@@ -229,6 +268,7 @@ function writeToFile(levelName, module, msg) {
  */
 function writeToErrorFile(levelName, module, msg) {
   if (!errorLogFilePath) return;
+  if (shouldSuppressStderrNoise(msg)) return;
   if (!errorLogDirEnsured) {
     try {
       mkdirSync(dirname(errorLogFilePath), { recursive: true });
@@ -482,6 +522,9 @@ export function installConsoleInterceptor(opts = {}) {
       const msg = args
         .map((a) => (typeof a === "string" ? a : String(a)))
         .join(" ");
+      if (shouldSuppressStderrNoise(msg)) {
+        return;
+      }
       const tagMatch = typeof msg === "string" ? msg.match(TAG_RE) : null;
       const mod = tagMatch?.[1] || "stderr";
       if (logFilePath && LogLevel.WARN >= fileLevel) {
@@ -507,6 +550,9 @@ export function installConsoleInterceptor(opts = {}) {
           return typeof a === "string" ? a : String(a);
         })
         .join(" ");
+      if (shouldSuppressStderrNoise(msg)) {
+        return;
+      }
       const tagMatch = typeof msg === "string" ? msg.match(TAG_RE) : null;
       const mod = tagMatch?.[1] || "stderr";
       if (logFilePath && LogLevel.ERROR >= fileLevel) {
@@ -578,11 +624,29 @@ export function installConsoleInterceptor(opts = {}) {
       throw err;
     }
   };
+  const acknowledgeSuppressedWrite = (...rest) => {
+    const cb = rest.find((value) => typeof value === "function");
+    if (cb) {
+      try {
+        cb();
+      } catch {
+        /* ignore callback failures for suppressed noise */
+      }
+    }
+    return true;
+  };
   process.stderr.write = (chunk, ...rest) => {
     if (!_inInterceptor) {
       const text = typeof chunk === "string" ? chunk : chunk?.toString?.("utf8") || "";
       if (text.trim()) {
-        writeToErrorFile("STDERR", "process", text.replace(/\n$/, ""));
+        if (shouldSuppressStderrNoise(text)) {
+          return acknowledgeSuppressedWrite(...rest);
+        }
+        const filtered = stripKnownStderrNoiseLines(text);
+        if (!filtered) {
+          return acknowledgeSuppressedWrite(...rest);
+        }
+        writeToErrorFile("STDERR", "process", filtered.replace(/\n$/, ""));
       }
     }
     return safeStderrWrite(chunk, ...rest);