bosun 0.41.0 → 0.41.2

package/ui/modules/settings-schema.js

@@ -19,6 +19,7 @@
  * @property {string}  [unit]      - Display unit (e.g., 'ms', 'min', 'sec')
  * @property {boolean} [restart]   - If true, changing requires process restart
  * @property {boolean} [advanced]  - If true, hidden unless "Show advanced" is on
+ * @property {string}  [section]   - Optional UI subsection label within a category
  */
 
 export const CATEGORIES = [
@@ -248,6 +249,7 @@ export const SETTINGS_SCHEMA = [
   { key: "SELF_RESTART_WATCH_ENABLED",     label: "Self-Restart Watcher",       category: "advanced", type: "boolean", description: "Auto-restart when source files change. Defaults to true in devmode." },
   { key: "MAX_PARALLEL",                   label: "Global Max Parallel",        category: "advanced", type: "number", defaultVal: 6, min: 1, max: 50, description: "Global maximum parallel task slots across all executors." },
   { key: "RESTART_DELAY_MS",               label: "Restart Delay",              category: "advanced", type: "number", defaultVal: 10000, min: 1000, max: 60000, unit: "ms", description: "Delay before restarting after a crash." },
+  { key: "ENV_RELOAD_DELAY_MS",            label: "Settings Reload Delay",      category: "advanced", type: "number", defaultVal: 5000, min: 500, max: 60000, unit: "ms", description: "Quiet period before Bosun reloads runtime config after .env or settings changes. Higher values make restart-sensitive saves less abrupt." },
   { key: "SHARED_STATE_ENABLED",           label: "Shared State",               category: "advanced", type: "boolean", defaultVal: true, description: "Enable distributed task coordination for multi-instance setups." },
   { key: "WORKFLOW_AUTOMATION_ENABLED",    label: "Workflow Automation",        category: "advanced", type: "boolean", defaultVal: true, description: "Enable event-driven workflow auto-triggers from monitor events." },
   { key: "SHARED_STATE_STALE_THRESHOLD_MS", label: "Stale Threshold",           category: "advanced", type: "number", defaultVal: 300000, min: 60000, max: 1800000, unit: "ms", description: "Time before a heartbeat is considered stale.", advanced: true },

package/ui/modules/state.js

@@ -54,6 +54,7 @@ const CACHE_TTL = {
   benchmarks: 8000,
   telemetry: 15000,
   analytics: 30000,
+  "retry-queue": 5000,
 };
 
 function _cacheKey(url) { return url; }
@@ -158,11 +159,31 @@ export const tasksStatusCounts = signal({ draft: 0, backlog: 0, inProgress: 0, i
 export const retryQueueData = signal({ count: 0, items: [] });
 export const retryQueueLoaded = signal(false);
 
+function normalizeRetryQueuePayload(payload) {
+  return {
+    count: Number(payload?.count || 0),
+    items: Array.isArray(payload?.items) ? payload.items : [],
+    stats: payload?.stats && typeof payload.stats === "object"
+      ? {
+          totalRetriesToday: Number(payload.stats.totalRetriesToday || 0),
+          peakRetryDepth: Number(payload.stats.peakRetryDepth || 0),
+          exhaustedTaskIds: Array.isArray(payload.stats.exhaustedTaskIds) ? payload.stats.exhaustedTaskIds : [],
+        }
+      : {
+          totalRetriesToday: 0,
+          peakRetryDepth: 0,
+          exhaustedTaskIds: [],
+        },
+  };
+}
+
 export async function loadRetryQueue() {
-  const res = await apiFetch("/api/retry-queue", { _silent: true }).catch(() => ({ ok: false, items: [], count: 0 }));
-  if (res?.ok) {
-    retryQueueData.value = { count: res.count || 0, items: res.items || [] };
-  }
+  const url = "/api/retry-queue";
+  if (_cacheFresh(url, "retry-queue")) return;
+  const res = await apiFetch(url, { _silent: true }).catch(() => ({ ok: false, items: [], count: 0, stats: null }));
+  retryQueueData.value = normalizeRetryQueuePayload(res);
+  _cacheSet(url, retryQueueData.value);
+  _markFresh("retry-queue");
   retryQueueLoaded.value = true;
 }
 
@@ -353,61 +374,18 @@ export function shouldShowToast(toast) {
 }
 
 /* ═══════════════════════════════════════════════════════════════
- *  EXECUTOR DEFAULTS — apply stored settings on first load
+ *  LEGACY STORED DEFAULTS MIGRATION HOOK
  * ═══════════════════════════════════════════════════════════════ */
 
 let _defaultsApplied = false;
 
 /**
- * Read stored executor defaults from CloudStorage and POST them to
- * the server if they differ from the current config.
- * Only runs once per app lifecycle (not on tab switches).
+ * Reserved for one-time client preference migrations.
+ * Executor runtime defaults now live only in Server Config.
  */
 export async function applyStoredDefaults() {
   if (_defaultsApplied) return;
   _defaultsApplied = true;
-
-  const [maxP, sdk, region] = await Promise.all([
-    _cloudGet("defaultMaxParallel"),
-    _cloudGet("defaultSdk"),
-    _cloudGet("defaultRegion"),
-  ]);
-
-  const promises = [];
-
-  if (maxP != null) {
-    const current = executorData.value;
-    const currentMax =
-      current?.data?.maxParallel ??
-      current?.maxParallel ??
-      null;
-    const isPaused = Boolean(current?.paused || current?.data?.paused);
-    if (!isPaused && currentMax !== maxP) {
-      promises.push(
-        apiFetch("/api/executor/maxparallel", {
-          method: "POST",
-          body: JSON.stringify({ maxParallel: maxP }),
-          _silent: true,
-        }).catch(() => {}),
-      );
-    }
-  }
-
-  const settingsUpdates = {};
-  if (sdk && sdk !== "auto") settingsUpdates.INTERNAL_EXECUTOR_SDK = sdk;
-  if (region && region !== "auto") settingsUpdates.EXECUTOR_REGIONS = region;
-
-  if (Object.keys(settingsUpdates).length) {
-    promises.push(
-      apiFetch("/api/settings/update", {
-        method: "POST",
-        body: JSON.stringify({ changes: settingsUpdates }),
-        _silent: true,
-      }).catch(() => {}),
-    );
-  }
-
-  if (promises.length) await Promise.all(promises);
 }
 
 /* ═══════════════════════════════════════════════════════════════
@@ -667,9 +645,10 @@ export async function loadInfra() {
 }
 
 /** Load system logs → logsData */
-export async function loadLogs() {
+export async function loadLogs(options = {}) {
   const url = `/api/logs?lines=${logsLines.value}`;
-  if (_cacheFresh(url, "logs")) return;
+  const force = Boolean(options?.force);
+  if (!force && _cacheFresh(url, "logs")) return;
   const res = await apiFetch(url, { _silent: true }).catch(() => ({ data: null }));
   logsData.value = res.data ?? res ?? null;
   _cacheSet(url, logsData.value);
@@ -709,7 +688,7 @@ export async function loadAgentLogFileList() {
 }
 
 /** Load tail of the currently selected agent log → agentLogTail */
-export async function loadAgentLogTailData() {
+export async function loadAgentLogTailData(options = {}) {
   if (!agentLogFile.value) {
     agentLogTail.value = null;
     return;
@@ -718,10 +697,20 @@ export async function loadAgentLogTailData() {
     file: agentLogFile.value,
     lines: String(agentLogLines.value),
   });
-  const res = await apiFetch(`/api/agent-logs/tail?${params}`, {
+  const url = `/api/agent-logs/tail?${params}`;
+  if (!options?.force && _cacheFresh(url, "logs")) {
+    const cached = _cacheGet(url);
+    if (cached) {
+      agentLogTail.value = cached.data;
+      return;
+    }
+  }
+  const res = await apiFetch(url, {
     _silent: true,
   }).catch(() => ({ data: null }));
   agentLogTail.value = res.data ?? res ?? null;
+  _cacheSet(url, agentLogTail.value);
+  _markFresh("logs");
 }
 
 /**
@@ -884,7 +873,7 @@ export async function loadBenchmarks(providerId = "") {
 
 const TAB_LOADERS = {
   dashboard: () =>
-    Promise.all([loadStatus(), loadExecutor(), loadProjectSummary()]),
+    Promise.all([loadStatus(), loadExecutor(), loadProjectSummary(), loadRetryQueue()]),
   tasks: () => loadTasks(),
   benchmarks: () => loadBenchmarks(),
   agents: () => Promise.all([loadAgents(), loadExecutor(), import("../components/session-list.js").then((m) => m.loadSessions()).catch(() => {})]),
@@ -905,6 +894,7 @@ const TAB_LOADERS = {
       loadTelemetryExecutors(),
       loadTelemetryAlerts(),
       loadUsageAnalytics(30),
+      loadRetryQueue(),
     ]),
   settings: () => Promise.all([loadStatus(), loadConfig()]),
 };
@@ -990,20 +980,27 @@ export function scheduleRefresh(ms = 5000) {
 /* ─── WebSocket invalidation listener ─── */
 
 const WS_CHANNEL_MAP = {
-  dashboard: ["overview", "executor", "tasks", "agents"],
+  dashboard: ["overview", "executor", "tasks", "agents", "retry-queue"],
   tasks: ["tasks"],
   benchmarks: ["benchmarks", "tasks", "executor", "workflows", "workspaces", "library"],
   agents: ["agents", "executor"],
   infra: ["worktrees", "workspaces", "presence"],
   control: ["executor", "overview"],
   logs: ["*"],
-  telemetry: ["*"],
+  telemetry: ["*", "retry-queue"],
   settings: ["overview"],
 };
 
 /** Start listening for WS invalidation messages and auto-refreshing. */
 export function initWsInvalidationListener() {
   onWsMessage((msg) => {
+    if (msg?.type === "retry-queue-updated") {
+      retryQueueData.value = normalizeRetryQueuePayload(msg?.payload);
+      _cacheSet("/api/retry-queue", retryQueueData.value);
+      _markFresh("retry-queue");
+      retryQueueLoaded.value = true;
+      return;
+    }
     if (msg?.type !== "invalidate") return;
     const channels = Array.isArray(msg.channels) ? msg.channels : [];
     // Clear cache for invalidated channels so next fetch is fresh