bosun 0.34.7 → 0.34.8

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/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);

package/maintenance.mjs

@@ -935,7 +935,7 @@ export function syncLocalTrackingBranches(repoRoot, branches) {
           windowsHide: true,
         });
         if (statusCheck.stdout?.trim()) {
-          console.warn(
+          console.log(
             `[maintenance] local '${branch}' diverged (${ahead}↑ ${behind}↓) but has uncommitted changes — skipping`,
           );
           continue;
@@ -988,7 +988,7 @@ export function syncLocalTrackingBranches(repoRoot, branches) {
           windowsHide: true,
         });
         if (statusCheck.stdout?.trim()) {
-          console.warn(
+          console.log(
             `[maintenance] '${branch}' is checked out with uncommitted changes — skipping pull`,
           );
           continue;
@@ -1139,4 +1139,3 @@ export async function runMaintenanceSweep(opts = {}) {
     branchesDeleted,
   };
 }
-