bosun 0.34.4 → 0.34.5

package/agent-endpoint.mjs

@@ -30,7 +30,7 @@ const TAG = "[agent-endpoint]";
 const DEFAULT_PORT = 18432;
 const MAX_BODY_SIZE = 1024 * 1024; // 1 MB
 const REQUEST_TIMEOUT_MS = 30_000; // 30 seconds
-const ACCESS_DENIED_COOLDOWN_MS = 10 * 60 * 1000; // 10 minutes
+const ACCESS_DENIED_COOLDOWN_MS = 10 * 60 * 1000; // 10 minutes
 const BOSUN_ROOT_HINT = __dirname.toLowerCase().replace(/\\/g, '/');
 
 // Valid status transitions when an agent self-reports
@@ -1387,4 +1387,4 @@ export class AgentEndpoint {
 export function createAgentEndpoint(options) {
   return new AgentEndpoint(options);
 }
-
+

package/agent-event-bus.mjs

@@ -112,8 +112,8 @@ export class AgentEventBus {
       options.staleThresholdMs || DEFAULTS.staleThresholdMs;
     this._staleCheckIntervalMs =
       options.staleCheckIntervalMs || DEFAULTS.staleCheckIntervalMs;
-    this._maxAutoRetries =
-      options.maxAutoRetries ?? DEFAULTS.maxAutoRetries;
+    this._maxAutoRetries =
+      options.maxAutoRetries ?? DEFAULTS.maxAutoRetries;
     this._dedupeWindowMs = options.dedupeWindowMs || DEFAULTS.dedupeWindowMs;
 
     /** @type {Array<{type: string, taskId: string, payload: object, ts: number}>} ring buffer */
@@ -203,7 +203,7 @@ export class AgentEventBus {
 
     // ── Dedup
     const key = `${type}:${taskId}`;
-    const last = this._recentEmits.get(key);
+    const last = this._recentEmits.get(key);
     if (typeof last === "number" && ts - last < this._dedupeWindowMs) return;
     this._recentEmits.set(key, ts);
     if (this._recentEmits.size > 200) {

package/agent-work-report.mjs

@@ -359,4 +359,4 @@ export function shouldSendWeeklyReport(options = {}) {
     return true;
   }
   return lastSentMs < scheduledThisWeek.getTime();
-}
+}

package/maintenance.mjs

@@ -888,26 +888,93 @@ export function syncLocalTrackingBranches(repoRoot, branches) {
       );
       if (remoteCheck.status !== 0) continue;
 
-      // Compare: is local behind?
+      // Measure divergence in both directions up front
       const behindCheck = spawnSync(
         "git",
         ["rev-list", "--count", `${branch}..${remoteRef}`],
         { cwd: repoRoot, encoding: "utf8", timeout: 5000, windowsHide: true },
       );
       const behind = parseInt(behindCheck.stdout?.trim(), 10) || 0;
-      if (behind === 0) continue; // Already up to date
 
-      // Check if local has commits not in remote (diverged)
       const aheadCheck = spawnSync(
         "git",
         ["rev-list", "--count", `${remoteRef}..${branch}`],
         { cwd: repoRoot, encoding: "utf8", timeout: 5000, windowsHide: true },
       );
       const ahead = parseInt(aheadCheck.stdout?.trim(), 10) || 0;
-      if (ahead > 0) {
-        console.warn(
-          `[maintenance] local '${branch}' has ${ahead} commit(s) ahead of ${remoteRef} — skipping (diverged)`,
+
+      if (behind === 0 && ahead === 0) continue; // Already in sync
+
+      // Local is ahead of remote but not behind — try a plain push
+      if (behind === 0 && ahead > 0) {
+        const push = spawnSync(
+          "git",
+          ["push", "origin", `${branch}:refs/heads/${branch}`, "--quiet"],
+          { cwd: repoRoot, encoding: "utf8", timeout: 30_000, windowsHide: true },
         );
+        if (push.status === 0) {
+          console.log(
+            `[maintenance] pushed local '${branch}' to origin (${ahead} commit(s) ahead)`,
+          );
+          synced++;
+        } else {
+          console.warn(
+            `[maintenance] git push '${branch}' failed: ${(push.stderr || push.stdout || "").toString().trim()}`,
+          );
+        }
+        continue;
+      }
+
+      // Truly diverged: local has unique commits AND is missing remote commits.
+      // Attempt rebase onto remote then push (checked-out branch only).
+      if (ahead > 0) {
+        const statusCheck = spawnSync("git", ["status", "--porcelain"], {
+          cwd: repoRoot,
+          encoding: "utf8",
+          timeout: 5000,
+          windowsHide: true,
+        });
+        if (statusCheck.stdout?.trim()) {
+          console.warn(
+            `[maintenance] local '${branch}' diverged (${ahead}↑ ${behind}↓) but has uncommitted changes — skipping`,
+          );
+          continue;
+        }
+        if (branch === currentBranch) {
+          const rebase = spawnSync(
+            "git",
+            ["rebase", remoteRef, "--quiet"],
+            { cwd: repoRoot, encoding: "utf8", timeout: 60_000, windowsHide: true },
+          );
+          if (rebase.status !== 0) {
+            spawnSync("git", ["rebase", "--abort"], {
+              cwd: repoRoot, timeout: 10_000, windowsHide: true,
+            });
+            console.warn(
+              `[maintenance] rebase of '${branch}' onto ${remoteRef} failed (${ahead}↑ ${behind}↓) — skipping`,
+            );
+            continue;
+          }
+          const push = spawnSync(
+            "git",
+            ["push", "origin", `${branch}:refs/heads/${branch}`, "--quiet"],
+            { cwd: repoRoot, encoding: "utf8", timeout: 30_000, windowsHide: true },
+          );
+          if (push.status === 0) {
+            console.log(
+              `[maintenance] rebased and pushed '${branch}' (was ${ahead}↑ ${behind}↓)`,
+            );
+            synced++;
+          } else {
+            console.warn(
+              `[maintenance] push after rebase of '${branch}' failed: ${(push.stderr || push.stdout || "").toString().trim()}`,
+            );
+          }
+        } else {
+          console.warn(
+            `[maintenance] local '${branch}' diverged (${ahead}↑ ${behind}↓) and not checked out — skipping (rebase requires checkout)`,
+          );
+        }
         continue;
       }
 

package/monitor.mjs

@@ -678,6 +678,23 @@ async function pollAgentAlerts() {
         }),
       );
     }
+
+    // Act on high-error alerts: apply a cooldown so the task-executor does not
+    // immediately restart the same session against an API that is failing.
+    if (alert.type === "failed_session_high_errors" && alert.task_id && internalTaskExecutor) {
+      try {
+        const taskId = alert.task_id;
+        const cooldownUntil = Date.now() + 15 * 60_000; // 15-minute cooldown
+        if (typeof internalTaskExecutor.applyTaskCooldown === "function") {
+          internalTaskExecutor.applyTaskCooldown(taskId, cooldownUntil);
+        } else if (internalTaskExecutor._skipUntil instanceof Map) {
+          internalTaskExecutor._skipUntil.set(taskId, cooldownUntil);
+        }
+        console.warn(
+          `[monitor] 15m cooldown applied to task ${taskId} after ${alert.error_count || "?"} API errors (executor: ${alert.executor || "unknown"})`,
+        );
+      } catch { /* best effort */ }
+    }
   }
   saveAgentAlertsState();
 }
@@ -1500,11 +1517,11 @@ const ALLOW_INTERNAL_RUNTIME_RESTARTS = isTruthyFlag(
 );
 const SELF_RESTART_DEFER_HARD_CAP = Math.max(
   1,
-  Number(process.env.SELF_RESTART_DEFER_HARD_CAP || "20") || 20,
+  Number(process.env.SELF_RESTART_DEFER_HARD_CAP || "6") || 6,
 );
 const SELF_RESTART_MAX_DEFER_MS = Math.max(
   60_000,
-  Number(process.env.SELF_RESTART_MAX_DEFER_MS || "600000") || 600000,
+  Number(process.env.SELF_RESTART_MAX_DEFER_MS || "180000") || 180000,
 );
 const SELF_RESTART_FORCE_ACTIVE_SLOT_MIN_AGE_MS = Math.max(
   60_000,
@@ -4784,12 +4801,39 @@ async function isBranchMerged(branch, baseBranch) {
     const baseRef = `${baseInfo.remote}/${baseInfo.name}`;
     const ghHead = branchInfo.name || branch;
 
-    // ── Strategy 1: Check GitHub for a merged PR with this head branch ──
-    // This is the most reliable signal — if GitHub says merged, it's merged.
+    // ── Strategy 1: Check GitHub PR state for this head branch ───────────
+    // Open PR always wins over historical merged PRs for the same head.
+    // A branch can have an old merged PR and a newer open PR with fresh commits.
+    // In that case, treat as NOT merged.
     if (ghAvailable()) {
+      try {
+        const openResult = execSync(
+          `gh pr list --head "${ghHead}" --state open --json number,baseRefName --limit 10`,
+          {
+            cwd: repoRoot,
+            encoding: "utf8",
+            stdio: ["pipe", "pipe", "ignore"],
+            timeout: 15000,
+          },
+        ).trim();
+        const openPRs = JSON.parse(openResult || "[]");
+        const hasOpenForTarget = openPRs.some((pr) => {
+          const prBase = normalizeBranchName(pr?.baseRefName);
+          return !prBase || prBase === baseInfo.name;
+        });
+        if (hasOpenForTarget || openPRs.length > 0) {
+          console.log(
+            `[monitor] Branch ${branch} has open PR(s) — treating as NOT merged`,
+          );
+          return false;
+        }
+      } catch {
+        // best-effort
+      }
+
       try {
         const ghResult = execSync(
-          `gh pr list --head "${ghHead}" --state merged --json number,mergedAt --limit 1`,
+          `gh pr list --head "${ghHead}" --base "${baseInfo.name}" --state merged --json number,mergedAt --limit 1`,
           {
             cwd: repoRoot,
             encoding: "utf8",
@@ -4805,7 +4849,27 @@ async function isBranchMerged(branch, baseBranch) {
           return true;
         }
       } catch {
-        // gh failed — fall through to git-based checks
+        // Fallback for older gh variants / edge cases that reject --base here.
+        try {
+          const ghResult = execSync(
+            `gh pr list --head "${ghHead}" --state merged --json number,mergedAt --limit 1`,
+            {
+              cwd: repoRoot,
+              encoding: "utf8",
+              stdio: ["pipe", "pipe", "ignore"],
+              timeout: 15000,
+            },
+          ).trim();
+          const mergedPRs = JSON.parse(ghResult || "[]");
+          if (mergedPRs.length > 0) {
+            console.log(
+              `[monitor] Branch ${branch} has merged PR #${mergedPRs[0].number}`,
+            );
+            return true;
+          }
+        } catch {
+          // gh failed — fall through to git-based checks
+        }
       }
     }
 
@@ -4873,6 +4937,45 @@ const mergedTaskCache = new Set();
  */
 const mergedBranchCache = new Set();
 
+function normalizeMergedBranchKey(branch) {
+  const normalized = normalizeBranchName(branch);
+  if (normalized) return normalized;
+  const raw = String(branch || "").trim();
+  return raw || "";
+}
+
+function addMergedBranchCache(branch) {
+  const key = normalizeMergedBranchKey(branch);
+  if (!key) return false;
+  mergedBranchCache.add(key);
+  return true;
+}
+
+function hasMergedBranchCache(branch) {
+  const key = normalizeMergedBranchKey(branch);
+  if (!key) return false;
+  return mergedBranchCache.has(key);
+}
+
+function removeMergedBranchCache(branch) {
+  const key = normalizeMergedBranchKey(branch);
+  if (!key) return false;
+  return mergedBranchCache.delete(key);
+}
+
+async function isMergedBranchCacheEntryStillValid(branch, baseBranch) {
+  if (!hasMergedBranchCache(branch)) return false;
+  const stillMerged = await isBranchMerged(branch, baseBranch);
+  if (stillMerged) return true;
+  if (removeMergedBranchCache(branch)) {
+    saveMergedTaskCache();
+    console.log(
+      `[monitor] Branch ${branch} removed from merged cache after revalidation`,
+    );
+  }
+  return false;
+}
+
 /** Path to the persistent merged-task cache file */
 const mergedTaskCachePath = resolve(
   config.cacheDir || resolve(config.repoRoot, ".cache"),
@@ -4892,7 +4995,7 @@ function loadMergedTaskCache() {
       }
       if (Array.isArray(data.branches)) {
         for (const b of data.branches) {
-          mergedBranchCache.add(b);
+          addMergedBranchCache(b);
         }
       }
       const total = mergedTaskCache.size + mergedBranchCache.size;
@@ -5236,9 +5339,27 @@ async function checkMergedPRsAndUpdateTasks() {
         }
       }
     });
-    const reviewTasks = Array.from(taskMap.values()).filter(
-      (entry) => !mergedTaskCache.has(entry.task.id),
-    );
+    const reviewTasks = [];
+    let prunedMergedTaskCacheCount = 0;
+    for (const entry of taskMap.values()) {
+      const taskId = String(entry?.task?.id || "").trim();
+      if (!taskId) continue;
+      if (!mergedTaskCache.has(taskId)) {
+        reviewTasks.push(entry);
+        continue;
+      }
+      // Task is active (inprogress/inreview) so a previous done-cache entry
+      // is stale (e.g. task reopened or status rollback) and must be purged.
+      mergedTaskCache.delete(taskId);
+      prunedMergedTaskCacheCount++;
+      reviewTasks.push(entry);
+    }
+    if (prunedMergedTaskCacheCount > 0) {
+      saveMergedTaskCache();
+      console.log(
+        `[monitor] Pruned ${prunedMergedTaskCacheCount} stale merged-task cache entr${prunedMergedTaskCacheCount === 1 ? "y" : "ies"} for active tasks`,
+      );
+    }
     if (reviewTasks.length === 0) {
       console.log(
         "[monitor] No tasks in review/inprogress status (after dedup)",
@@ -5533,34 +5654,40 @@ async function checkMergedPRsAndUpdateTasks() {
 
       // ── Branch-level dedup: skip if ANY branch is already known-merged ──
       const knownBranch = candidates.find(
-        (c) => c.branch && mergedBranchCache.has(c.branch),
+        (c) => c.branch && hasMergedBranchCache(c.branch),
       );
-      if (knownBranch) {
-        const canFinalize = await shouldFinalizeMergedTask(task, {
-          branch: knownBranch.branch,
-          prNumber: knownBranch.prNumber,
-          reason: "known_merged_branch",
-        });
-        if (!canFinalize) {
+      if (knownBranch?.branch) {
+        const cachedStillMerged = await isMergedBranchCacheEntryStillValid(
+          knownBranch.branch,
+          knownBranch.baseBranch,
+        );
+        if (cachedStillMerged) {
+          const canFinalize = await shouldFinalizeMergedTask(task, {
+            branch: knownBranch.branch,
+            prNumber: knownBranch.prNumber,
+            reason: "known_merged_branch",
+          });
+          if (!canFinalize) {
+            continue;
+          }
+          mergedTaskCache.add(task.id);
+          pendingMergeStrategyByTask.delete(String(task.id || "").trim());
+          // Cache all branches for this task
+          for (const c of candidates) {
+            if (c.branch) addMergedBranchCache(c.branch);
+          }
+          saveMergedTaskCache();
+          void updateTaskStatus(task.id, "done", {
+            taskData: task,
+            workflowEvent: "pr.merged",
+            workflowData: {
+              prNumber: knownBranch.prNumber || null,
+              branch: knownBranch.branch || null,
+              triggerReason: "known_merged_branch",
+            },
+          });
           continue;
         }
-        mergedTaskCache.add(task.id);
-        pendingMergeStrategyByTask.delete(String(task.id || "").trim());
-        // Cache all branches for this task
-        for (const c of candidates) {
-          if (c.branch) mergedBranchCache.add(c.branch);
-        }
-        saveMergedTaskCache();
-        void updateTaskStatus(task.id, "done", {
-          taskData: task,
-          workflowEvent: "pr.merged",
-          workflowData: {
-            prNumber: knownBranch.prNumber || null,
-            branch: knownBranch.branch || null,
-            triggerReason: "known_merged_branch",
-          },
-        });
-        continue;
       }
 
       // ── Check ALL candidates for a merged PR/branch ──
@@ -5624,7 +5751,7 @@ async function checkMergedPRsAndUpdateTasks() {
             mergedTaskCache.add(task.id);
             pendingMergeStrategyByTask.delete(String(task.id || "").trim());
             for (const c of candidates) {
-              if (c.branch) mergedBranchCache.add(c.branch);
+              if (c.branch) addMergedBranchCache(c.branch);
             }
             saveMergedTaskCache();
             completedTaskNames.push(task.title);
@@ -5709,7 +5836,7 @@ async function checkMergedPRsAndUpdateTasks() {
           mergedTaskCache.add(task.id);
           pendingMergeStrategyByTask.delete(String(task.id || "").trim());
           for (const c of candidates) {
-            if (c.branch) mergedBranchCache.add(c.branch);
+            if (c.branch) addMergedBranchCache(c.branch);
           }
           saveMergedTaskCache();
           completedTaskNames.push(task.title);
@@ -8018,7 +8145,16 @@ async function smartPRFlow(attemptId, shortId, status) {
     const attemptInfo = await getAttemptInfo(attemptId);
     let taskData = null;
     if (attemptInfo?.branch) {
-      if (mergedBranchCache.has(attemptInfo.branch)) {
+      if (
+        await isMergedBranchCacheEntryStillValid(
+          attemptInfo.branch,
+          attemptInfo?.target_branch ||
+            attemptInfo?.targetBranch ||
+            attemptInfo?.base_branch ||
+            attemptInfo?.baseBranch ||
+            null,
+        )
+      ) {
         console.log(
           `[monitor] ${tag}: branch already in merged cache — archiving`,
         );
@@ -8047,7 +8183,7 @@ async function smartPRFlow(attemptId, shortId, status) {
         console.log(
           `[monitor] ${tag}: branch ${attemptInfo.branch} confirmed merged — ${canFinalize ? "completing task" : "awaiting review gate"}`,
         );
-        mergedBranchCache.add(attemptInfo.branch);
+        addMergedBranchCache(attemptInfo.branch);
         if (attemptInfo.task_id && canFinalize) {
           mergedTaskCache.add(attemptInfo.task_id);
           pendingMergeStrategyByTask.delete(
@@ -8553,7 +8689,16 @@ async function resolveAndTriggerSmartPR(shortId, status) {
     // ── Early merged-branch check: skip if branch is already merged ──
     const resolvedAttempt = match;
     if (resolvedAttempt?.branch) {
-      if (mergedBranchCache.has(resolvedAttempt.branch)) {
+      if (
+        await isMergedBranchCacheEntryStillValid(
+          resolvedAttempt.branch,
+          resolvedAttempt?.target_branch ||
+            resolvedAttempt?.targetBranch ||
+            resolvedAttempt?.base_branch ||
+            resolvedAttempt?.baseBranch ||
+            null,
+        )
+      ) {
         console.log(
           `[monitor] smartPR(${shortId}): branch ${resolvedAttempt.branch} already in mergedBranchCache — skipping`,
         );
@@ -8582,7 +8727,7 @@ async function resolveAndTriggerSmartPR(shortId, status) {
         console.log(
           `[monitor] smartPR(${shortId}): branch ${resolvedAttempt.branch} confirmed merged — ${canFinalize ? "completing task and skipping PR flow" : "awaiting review gate"}`,
         );
-        mergedBranchCache.add(resolvedAttempt.branch);
+        addMergedBranchCache(resolvedAttempt.branch);
         if (resolvedAttempt.task_id && canFinalize) {
           mergedTaskCache.add(resolvedAttempt.task_id);
           pendingMergeStrategyByTask.delete(
@@ -15099,5 +15244,3 @@ export {
   getContainerStatus,
   isContainerEnabled,
 };
-
-

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bosun",
-  "version": "0.34.4",
+  "version": "0.34.5",
   "description": "AI-powered orchestrator supervisor — manages AI agent executors with failover, auto-restarts on failure, analyzes crashes with Codex SDK, 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",

package/primary-agent.mjs

@@ -39,6 +39,7 @@ import {
   resetClaudeSession,
   initClaudeShell,
 } from "./claude-shell.mjs";
+import { getModelsForExecutor } from "./task-complexity.mjs";
 
 /** Valid agent interaction modes */
 const VALID_MODES = ["ask", "agent", "plan"];
@@ -703,6 +704,7 @@ export function getAvailableAgents() {
       provider: adapter.provider,
       available: !disabled,
       busy,
+      models: getModelsForExecutor(adapter.provider), // use provider ("CODEX"/"COPILOT"/"CLAUDE") — always in the alias map
       capabilities: {
         sessions: typeof adapter.listSessions === "function",
         steering: typeof adapter.steer === "function",

package/setup-web-server.mjs

@@ -141,6 +141,56 @@ const KANBAN_BACKENDS = [
   { value: "jira", label: "Atlassian Jira" },
 ];
 
+function buildStableSetupDefaults({
+  projectName,
+  slug,
+  repoRoot,
+  bosunHome,
+  workspacesDir,
+}) {
+  return {
+    projectName: projectName || slug?.split("/").pop() || "my-project",
+    repoSlug: slug,
+    repoRoot,
+    configDir: bosunHome,
+    bosunHome,
+    workspacesDir,
+    executors: [
+      {
+        name: "primary",
+        executor: "CODEX",
+        model: "gpt-5.3-codex",
+        weight: 100,
+        role: "primary",
+        authMode: "oauth",
+        apiKey: "",
+        baseUrl: "",
+        connections: [],
+        codexProfile: "",
+      },
+    ],
+    executor: "CODEX",
+    model: "gpt-5.3-codex",
+    kanbanBackend: "internal",
+    kanbanSyncPolicy: "internal-primary",
+    executorMode: "internal",
+    executorDistribution: "primary-only",
+    maxParallel: 4,
+    maxRetries: 3,
+    failoverStrategy: "next-in-line",
+    failoverCooldownMinutes: 5,
+    failoverDisableOnConsecutive: 3,
+    internalReplenishEnabled: false,
+    internalReplenishMin: 1,
+    internalReplenishMax: 2,
+    workflowAutomationEnabled: true,
+    copilotEnableAllMcpTools: false,
+    // Backward-compatible fields consumed by older setup UI revisions.
+    distribution: "primary-only",
+    cooldownMinutes: 5,
+  };
+}
+
 const MIME_TYPES = {
   ".html": "text/html; charset=utf-8",
   ".css": "text/css; charset=utf-8",
@@ -443,22 +493,13 @@ function handleDefaults() {
 
   return {
     ok: true,
-    defaults: {
-      projectName: projectName || slug?.split("/").pop() || "my-project",
-      repoSlug: slug,
+    defaults: buildStableSetupDefaults({
+      projectName,
+      slug,
       repoRoot,
-      configDir: bosunHome,
       bosunHome,
       workspacesDir,
-      executor: "COPILOT",
-      model: "claude-sonnet-4",
-      kanbanBackend: "internal",
-      maxParallel: 6,
-      maxRetries: 3,
-      cooldownMinutes: 5,
-      distribution: "weighted",
-      failoverStrategy: "next-in-line",
-    },
+    }),
   };
 }
 
@@ -676,7 +717,7 @@ function handleApply(body) {
     const envMap = {
       PROJECT_NAME: env.projectName || "",
       GITHUB_REPO: env.repoSlug || "",
-      ORCHESTRATOR_ARGS: env.orchestratorArgs || `-MaxParallel ${env.maxParallel || 6}`,
+      ORCHESTRATOR_ARGS: env.orchestratorArgs || `-MaxParallel ${env.maxParallel || 4}`,
       EXECUTORS: env.executors || "",
       KANBAN_BACKEND: env.kanbanBackend || "internal",
       VK_PROJECT_DIR: bosunHome,
@@ -848,7 +889,7 @@ function handleApply(body) {
         cooldownMinutes: Number(env.failoverCooldownMinutes) || 5,
         disableOnConsecutiveFailures: Number(env.failoverDisableOnConsecutive) || 3,
       },
-      distribution: configJson.distribution || env.executorDistribution || "weighted",
+      distribution: configJson.distribution || env.executorDistribution || "primary-only",
     };
 
     if (configJson.executorMode)               config.executorMode               = configJson.executorMode;