bosun 0.40.11 → 0.40.13

package/cli.mjs

@@ -336,6 +336,19 @@ const DAEMON_MAX_INSTANT_RESTARTS = Math.max(
   1,
   Number(process.env.BOSUN_DAEMON_MAX_INSTANT_RESTARTS || 5) || 5,
 );
+const DAEMON_MISCONFIG_GUARD_ENABLED = !["0", "false", "off", "no"].includes(
+  String(process.env.BOSUN_DAEMON_MISCONFIG_GUARD || "1")
+    .trim()
+    .toLowerCase(),
+);
+const DAEMON_MISCONFIG_GUARD_MIN_RESTARTS = Math.max(
+  1,
+  Number(process.env.BOSUN_DAEMON_MISCONFIG_GUARD_MIN_RESTARTS || 3) || 3,
+);
+const DAEMON_MISCONFIG_LOG_SCAN_LINES = Math.max(
+  20,
+  Number(process.env.BOSUN_DAEMON_MISCONFIG_LOG_SCAN_LINES || 250) || 250,
+);
 let daemonRestartCount = 0;
 const daemonCrashTracker = createDaemonCrashTracker({
   instantCrashWindowMs: DAEMON_INSTANT_CRASH_WINDOW_MS,
@@ -2080,6 +2093,77 @@ function getMonitorPidFileCandidates(extraCacheDirs = []) {
   ]);
 }
 
+function tailLinesFromFile(filePath, maxLines = 200) {
+  try {
+    if (!existsSync(filePath)) return [];
+    const raw = readFileSync(filePath, "utf8");
+    if (!raw) return [];
+    const lines = raw.split(/\r?\n/).filter(Boolean);
+    if (lines.length <= maxLines) return lines;
+    return lines.slice(-maxLines);
+  } catch {
+    return [];
+  }
+}
+
+function detectDaemonRestartStormSignals(options) {
+  const resolvedOptions = options && typeof options === "object" ? options : {};
+  const logDir = resolvedOptions.logDir || resolve(__dirname, "logs");
+  const maxLines = resolvedOptions.maxLines || DAEMON_MISCONFIG_LOG_SCAN_LINES;
+  const reasons = [];
+  const monitorErrorLines = tailLinesFromFile(
+    resolve(logDir, "monitor-error.log"),
+    maxLines,
+  );
+  const monitorLines = tailLinesFromFile(resolve(logDir, "monitor.log"), maxLines);
+  const combined = [...monitorErrorLines, ...monitorLines].join("\n");
+  if (!combined) {
+    return { hasSignal: false, reasons: [] };
+  }
+
+  if (
+    /missing prerequisites:\s*no API key|codex unavailable:\s*no API key/i.test(
+      combined,
+    )
+  ) {
+    reasons.push("missing_api_key");
+  }
+  if (
+    /another bosun instance holds the lock|duplicate start ignored|another bosun is already running/i
+      .test(combined)
+  ) {
+    reasons.push("duplicate_runtime");
+  }
+  if (/Shared state heartbeat FATAL.*owner_mismatch/i.test(combined)) {
+    reasons.push("shared_state_owner_mismatch");
+  }
+  if (
+    /There is no tracking information for the current branch|git pull <remote> <branch>/i
+      .test(combined)
+  ) {
+    reasons.push("workspace_git_tracking_missing");
+  }
+
+  return {
+    hasSignal: reasons.length > 0,
+    reasons,
+  };
+}
+
+function shouldPauseDaemonRestartStorm(options) {
+  const resolvedOptions = options && typeof options === "object" ? options : {};
+  const restartCount = Number(resolvedOptions.restartCount || 0);
+  const logDir = resolvedOptions.logDir;
+  if (!IS_DAEMON_CHILD) return { pause: false, reasons: [] };
+  if (!DAEMON_MISCONFIG_GUARD_ENABLED) return { pause: false, reasons: [] };
+  if (restartCount < DAEMON_MISCONFIG_GUARD_MIN_RESTARTS) {
+    return { pause: false, reasons: [] };
+  }
+  const signals = detectDaemonRestartStormSignals({ logDir });
+  if (!signals.hasSignal) return { pause: false, reasons: [] };
+  return { pause: true, reasons: signals.reasons };
+}
+
 function detectExistingMonitorLockOwner(excludePid = null) {
   try {
     for (const pidFile of getMonitorPidFileCandidates()) {
@@ -2213,6 +2297,19 @@ function runMonitor({ restartReason = "" } = {}) {
                 DAEMON_MAX_RESTART_DELAY_MS,
               );
               const delayMs = isOSKill ? 5000 : backoffDelay;
+              const restartStormGuard = shouldPauseDaemonRestartStorm({
+                restartCount: daemonRestartCount,
+              });
+              if (restartStormGuard.pause) {
+                const reasonLabel = restartStormGuard.reasons.join(", ");
+                console.error(
+                  `\n  :close: Monitor restart storm paused after ${daemonRestartCount} attempts due to persistent runtime issues (${reasonLabel}).`,
+                );
+                sendCrashNotification(exitCode, signal).finally(() =>
+                  process.exit(exitCode),
+                );
+                return;
+              }
               if (IS_DAEMON_CHILD && crashState.exceeded) {
                 const durationSec = Math.max(
                   1,

package/git/git-safety.mjs

@@ -15,6 +15,8 @@ const STRIPPED_GIT_ENV_KEYS = [
 const BLOCKED_TEST_GIT_IDENTITIES = new Set([
   "test@example.com",
   "bosun-tests@example.com",
+  "bot@example.com",
+  "test@test.com",
 ]);
 
 const TEST_FIXTURE_SENTINEL_PATHS = new Set([
@@ -264,3 +266,18 @@ export function evaluateBranchSafetyForPush(worktreePath, opts = {}) {
     },
   };
 }
+
+/**
+ * Clear any blocked test git identity from a worktree's local config.
+ * Worktrees inherit the parent repo's config, so if a test ever set
+ * user.name/email there it will poison all task commits until cleared.
+ * Call this after acquiring any worktree.
+ */
+export function clearBlockedWorktreeIdentity(worktreePath) {
+  const email = getGitConfig(worktreePath, "user.email").toLowerCase();
+  if (!BLOCKED_TEST_GIT_IDENTITIES.has(email)) return false;
+
+  runGit(["config", "--local", "--unset", "user.email"], worktreePath, 5_000);
+  runGit(["config", "--local", "--unset", "user.name"], worktreePath, 5_000);
+  return true;
+}

package/infra/monitor.mjs

@@ -197,7 +197,7 @@ import {
   installConsoleInterceptor,
   setErrorLogFile,
 } from "../lib/logger.mjs";
-import { fixGitConfigCorruption } from "../workspace/worktree-manager.mjs";
+import { fixGitConfigCorruption, listActiveWorktrees } from "../workspace/worktree-manager.mjs";
 // ── Task management subsystem imports ──────────────────────────────────────
 import {
   configureTaskStore,
@@ -14062,6 +14062,98 @@ safeSetInterval("workflow-review-merge-reconcile", async () => {
 
 // Legacy merged PR check removed (workflow-only control).
 
+// ── Periodic stale worktree sync: every 5 min ─────────────────────────────
+// Detects task worktrees that are diverged from their remote (local commits
+// not pushed, or remote has newer commits from a previous run).  For each
+// diverged worktree it: fetches remote, rebases local onto the remote tracking
+// ref for that branch, then pushes with --force-with-lease.  This keeps the
+// VS Code source-control view clean and unblocks tasks that got stuck mid-push.
+async function syncDivergedWorktrees() {
+  const worktrees = listActiveWorktrees(repoRoot);
+  let synced = 0;
+  let failed = 0;
+
+  for (const wt of worktrees) {
+    const { path: wtPath, branch } = wt;
+    if (!wtPath || !branch || !branch.startsWith("task/")) continue;
+
+    try {
+      // Fetch remote to update tracking refs
+      execSync("git fetch origin --no-tags", {
+        cwd: wtPath, timeout: 30_000, stdio: ["ignore", "pipe", "pipe"],
+      });
+
+      // Check ahead/behind vs remote tracking ref
+      const remoteRef = `origin/${branch}`;
+      let remoteExists = false;
+      try {
+        execSync(`git rev-parse --verify ${remoteRef}`, {
+          cwd: wtPath, timeout: 5_000, stdio: ["ignore", "pipe", "pipe"],
+        });
+        remoteExists = true;
+      } catch { /* branch not yet pushed — nothing to sync */ }
+
+      if (!remoteExists) continue;
+
+      const ahead = parseInt(
+        execSync(`git rev-list --count ${remoteRef}..HEAD`, {
+          cwd: wtPath, encoding: "utf8", timeout: 10_000, stdio: ["ignore", "pipe", "pipe"],
+        }).trim(), 10);
+      const behind = parseInt(
+        execSync(`git rev-list --count HEAD..${remoteRef}`, {
+          cwd: wtPath, encoding: "utf8", timeout: 10_000, stdio: ["ignore", "pipe", "pipe"],
+        }).trim(), 10);
+
+      // Only act on diverged worktrees (behind > 0 AND ahead > 0)
+      if (ahead === 0 || behind === 0) continue;
+
+      console.log(
+        `[monitor:worktree-sync] ${branch} diverged: ${ahead} ahead, ${behind} behind — rebasing and pushing`,
+      );
+
+      // Rebase local onto remote tracking ref to incorporate remote commits
+      let rebased = false;
+      try {
+        execSync(`git rebase ${remoteRef}`, {
+          cwd: wtPath, encoding: "utf8", timeout: 60_000, stdio: ["ignore", "pipe", "pipe"],
+        });
+        rebased = true;
+      } catch (rebaseErr) {
+        try { execSync("git rebase --abort", { cwd: wtPath, timeout: 10_000, stdio: ["ignore", "pipe", "pipe"] }); } catch { /* ok */ }
+        console.warn(
+          `[monitor:worktree-sync] ${branch} rebase conflict — skipping push: ${rebaseErr.message?.slice(0, 200)}`,
+        );
+        failed++;
+        continue;
+      }
+
+      // Push with --force-with-lease (safe: we just fetched fresh remote refs)
+      try {
+        execSync(`git push --force-with-lease --set-upstream origin HEAD`, {
+          cwd: wtPath, encoding: "utf8", timeout: 30_000, stdio: ["ignore", "pipe", "pipe"],
+        });
+        console.log(`[monitor:worktree-sync] ${branch} sync-pushed successfully`);
+        synced++;
+      } catch (pushErr) {
+        console.warn(
+          `[monitor:worktree-sync] ${branch} push failed: ${pushErr.message?.slice(0, 200)}`,
+        );
+        failed++;
+      }
+    } catch (err) {
+      console.warn(`[monitor:worktree-sync] ${branch} error: ${err.message?.slice(0, 200)}`);
+      failed++;
+    }
+  }
+
+  if (synced > 0 || failed > 0) {
+    console.log(`[monitor:worktree-sync] cycle complete — synced=${synced} failed=${failed}`);
+  }
+}
+
+const worktreeSyncIntervalMs = 5 * 60 * 1000; // 5 min
+safeSetInterval("worktree-sync", syncDivergedWorktrees, worktreeSyncIntervalMs);
+
 // ── Periodic epic branch sync/merge: every 15 min ──────────────────────────
 const epicMergeIntervalMs = 15 * 60 * 1000;
 safeSetInterval("epic-merge-check", () => checkEpicBranches("interval"), epicMergeIntervalMs);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bosun",
-  "version": "0.40.11",
+  "version": "0.40.13",
   "description": "Bosun Autonomous Engineering — manages AI agent executors with failover, extremely powerful workflow builder, and a massive amount of included default workflow templates for autonomous engineering, creates PRs via Vibe-Kanban API, and sends Telegram notifications. Supports N executors with weighted distribution, multi-repo projects, and auto-setup.",
   "type": "module",
   "license": "Apache-2.0",