bosun 0.41.2 → 0.41.3

package/ui/demo.html

@@ -3311,6 +3311,67 @@
         const t = findTask(params.get('taskId'));
         return { data: t || null };
       }
+      if (route === '/api/tasks/export') {
+        return {
+          ok: true,
+          data: {
+            schemaVersion: 1,
+            kind: 'bosun-task-state-export',
+            exportedAt: new Date().toISOString(),
+            backend: 'demo',
+            tasks: Array.isArray(STATE.tasks) ? [...STATE.tasks] : [],
+          },
+        };
+      }
+      if (route === '/api/tasks/import' && method === 'POST') {
+        const importedTasks = Array.isArray(body)
+          ? body
+          : Array.isArray(body?.tasks)
+            ? body.tasks
+            : Array.isArray(body?.backlog)
+              ? body.backlog
+              : Array.isArray(body?.data?.tasks)
+                ? body.data.tasks
+                : [];
+        let created = 0;
+        let updated = 0;
+        const results = [];
+        for (const candidate of importedTasks) {
+          if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) continue;
+          const id = String(candidate.id || '').trim();
+          const title = String(candidate.title || '').trim();
+          if (!id || !title) {
+            results.push({ id: id || null, status: 'failed', error: 'task.id and task.title are required' });
+            continue;
+          }
+          const existing = findTask(id);
+          if (existing) {
+            Object.assign(existing, candidate, { updated: Date.now() });
+            updated += 1;
+            results.push({ id, status: 'updated' });
+            continue;
+          }
+          const createdTask = { ...candidate, created: candidate.created || Date.now(), updated: Date.now() };
+          STATE.tasks.unshift(createdTask);
+          created += 1;
+          results.push({ id, status: 'created' });
+        }
+        addLog('info', 'tasks', `Imported task state snapshot: ${created} created, ${updated} updated`);
+        return {
+          ok: true,
+          data: {
+            backend: 'demo',
+            mode: String(body?.mode || 'merge'),
+            summary: {
+              total: importedTasks.length,
+              created,
+              updated,
+              failed: results.filter((entry) => entry.status === 'failed').length,
+            },
+            results,
+          },
+        };
+      }
       if (route === '/api/tasks/sprints') {
         if (method === 'GET') {
           const sprints = Array.isArray(STATE.taskSprints) ? STATE.taskSprints : [];
@@ -3389,6 +3450,41 @@
           },
         };
       }
+      if (route === '/api/tasks/dag/organize' && method === 'POST') {
+        const sprintId = body?.sprintId || body?.sprint || null;
+        const tasks = Array.isArray(STATE.tasks) ? STATE.tasks : [];
+        const scoped = sprintId
+          ? tasks.filter((task) => String(task.sprintId || '') === String(sprintId))
+          : tasks;
+        const edges = [];
+        for (const task of scoped) {
+          const deps = Array.isArray(task.dependencyTaskIds) ? task.dependencyTaskIds : [];
+          for (const dep of deps) {
+            if (scoped.some((candidate) => candidate.id === dep)) {
+              edges.push({ from: dep, to: task.id });
+            }
+          }
+        }
+        return {
+          ok: true,
+          sprintId,
+          source: 'demo',
+          suggestions: [],
+          data: {
+            sprintId,
+            updatedSprintCount: sprintId ? 1 : 0,
+            nodes: scoped.map((task) => ({
+              id: task.id,
+              title: task.title,
+              status: task.status,
+              sprintId: task.sprintId || null,
+              sprintOrder: task.sprintOrder ?? null,
+            })),
+            edges,
+            suggestions: [],
+          },
+        };
+      }
       if (route === '/api/tasks/dag-of-dags') {
         const sprints = Array.isArray(STATE.taskSprints) ? STATE.taskSprints : [];
         const tasks = Array.isArray(STATE.tasks) ? STATE.tasks : [];
@@ -3600,6 +3696,17 @@
         if (t) { t.status = 'todo'; t.updated = Date.now(); addLog('info', 'task-executor', `Task retried: ${t.title}`); }
         return { ok: true, data: t || null };
       }
+      if (route === '/api/tasks/unblock') {
+        const t = findTask(body?.taskId || body?.id);
+        if (t) {
+          t.status = 'todo';
+          t.blockedReason = null;
+          if (t.meta && typeof t.meta === 'object') t.meta.blockedReason = null;
+          t.updated = Date.now();
+          addLog('info', 'task-executor', `Task unblocked: ${t.title}`);
+        }
+        return { ok: true, data: t || null };
+      }
       if (route === '/api/tasks/ignore') {
         const t = findTask(body?.taskId || body?.id);
         if (t) { t.status = 'ignored'; t.updated = Date.now(); addLog('info', 'kanban', `Task ignored: ${t.title}`); }
@@ -4231,6 +4338,54 @@
           .filter(Boolean);
         return { ok: true, updates };
       }
+      if (route === '/api/workflows/reflow-template-layouts') {
+        const requestedIds = Array.isArray(body?.workflowIds)
+          ? body.workflowIds.map((value) => String(value || '').trim()).filter(Boolean)
+          : (body?.workflowId ? [String(body.workflowId).trim()].filter(Boolean) : []);
+        const targetIds = new Set(requestedIds);
+        const updatedWorkflows = [];
+
+        STATE.workflows = STATE.workflows.map((wf, index) => {
+          const workflowId = String(wf?.id || '').trim();
+          const isTemplateBacked = Boolean(wf?.metadata?.installedFrom);
+          const isTargeted = targetIds.size === 0 || targetIds.has(workflowId);
+          if (!workflowId || !isTemplateBacked || !isTargeted) return wf;
+
+          const next = JSON.parse(JSON.stringify(wf));
+          next.nodes = (next.nodes || []).map((node, nodeIndex) => ({
+            ...node,
+            position: {
+              x: 160 + (nodeIndex % 3) * 280,
+              y: 96 + Math.floor(nodeIndex / 3) * 180,
+            },
+          }));
+          next.metadata = {
+            ...(next.metadata || {}),
+            updatedAt: new Date().toISOString(),
+            templateState: {
+              ...(next.metadata?.templateState || {}),
+              isCustomized: false,
+              updateAvailable: false,
+            },
+          };
+          next.nodeCount = (next.nodes || []).length;
+          updatedWorkflows.push(next);
+          return next;
+        });
+
+        return {
+          ok: true,
+          result: {
+            scanned: targetIds.size > 0 ? targetIds.size : STATE.workflows.length,
+            updated: updatedWorkflows.length,
+            skipped: Math.max(0, (targetIds.size > 0 ? targetIds.size : STATE.workflows.length) - updatedWorkflows.length),
+            updatedWorkflowIds: updatedWorkflows.map((wf) => wf.id),
+            skippedWorkflowIds: [],
+            errors: [],
+          },
+          workflows: updatedWorkflows,
+        };
+      }
       if (route.startsWith('/api/workflows/runs/')) {
         const runId = decodeURIComponent(route.replace('/api/workflows/runs/', '')).trim();
         const run = STATE.workflowRuns.find((item) => item.runId === runId);

package/ui/modules/session-api.js

@@ -3,6 +3,102 @@
  * Keeps workspace scoping explicit for /api/sessions/:id routes.
  */
 
+export const SESSION_RETRY_DEFAULTS = Object.freeze({
+  maxAttempts: 5,
+  baseDelayMs: 1500,
+  maxDelayMs: 20000,
+  backoffMultiplier: 2,
+});
+
+function normalizeRetryNumber(value, fallback, min = 0) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) return fallback;
+  return Math.max(min, Math.floor(n));
+}
+
+function resolveRetryConfig(meta = {}) {
+  const maxAttempts = normalizeRetryNumber(
+    meta.maxAttempts,
+    SESSION_RETRY_DEFAULTS.maxAttempts,
+    1,
+  );
+  const baseDelayMs = normalizeRetryNumber(
+    meta.baseDelayMs,
+    SESSION_RETRY_DEFAULTS.baseDelayMs,
+    1,
+  );
+  const maxDelayMs = Math.max(
+    baseDelayMs,
+    normalizeRetryNumber(meta.maxDelayMs, SESSION_RETRY_DEFAULTS.maxDelayMs, 1),
+  );
+  const backoffMultiplier = Math.max(
+    1,
+    Number(meta.backoffMultiplier || SESSION_RETRY_DEFAULTS.backoffMultiplier),
+  );
+  return { maxAttempts, baseDelayMs, maxDelayMs, backoffMultiplier };
+}
+
+export function createSessionLoadMeta(overrides = {}) {
+  const config = resolveRetryConfig(overrides);
+  return {
+    ...config,
+    stale: Boolean(overrides?.stale),
+    lastSuccessAt: overrides?.lastSuccessAt ? String(overrides.lastSuccessAt) : null,
+    retryAttempt: normalizeRetryNumber(overrides?.retryAttempt, 0, 0),
+    retryDelayMs: normalizeRetryNumber(overrides?.retryDelayMs, 0, 0),
+    nextRetryAt: overrides?.nextRetryAt ? String(overrides.nextRetryAt) : null,
+    retriesExhausted: Boolean(overrides?.retriesExhausted),
+  };
+}
+
+export function getSessionRetryDelayMs(attemptNumber, meta = {}) {
+  const { baseDelayMs, maxDelayMs, backoffMultiplier } = resolveRetryConfig(meta);
+  const attempt = Math.max(1, normalizeRetryNumber(attemptNumber, 1, 1));
+  const delay = Math.round(baseDelayMs * Math.pow(backoffMultiplier, attempt - 1));
+  return Math.min(maxDelayMs, Math.max(baseDelayMs, delay));
+}
+
+export function markSessionLoadSuccess(previousMeta, now = Date.now()) {
+  const meta = createSessionLoadMeta(previousMeta || {});
+  return {
+    ...meta,
+    stale: false,
+    lastSuccessAt: new Date(now).toISOString(),
+    retryAttempt: 0,
+    retryDelayMs: 0,
+    nextRetryAt: null,
+    retriesExhausted: false,
+  };
+}
+
+export function markSessionLoadFailure(previousMeta, now = Date.now()) {
+  const meta = createSessionLoadMeta(previousMeta || {});
+  const retryAttempt = normalizeRetryNumber(meta.retryAttempt, 0, 0) + 1;
+  const retriesExhausted = retryAttempt > meta.maxAttempts;
+  const retryDelayMs = retriesExhausted
+    ? 0
+    : getSessionRetryDelayMs(retryAttempt, meta);
+  return {
+    ...meta,
+    stale: true,
+    retryAttempt,
+    retryDelayMs,
+    nextRetryAt: retriesExhausted ? null : new Date(now + retryDelayMs).toISOString(),
+    retriesExhausted,
+  };
+}
+
+export function resetSessionRetryMeta(previousMeta) {
+  const meta = createSessionLoadMeta(previousMeta || {});
+  return {
+    ...meta,
+    retryAttempt: 0,
+    retryDelayMs: 0,
+    nextRetryAt: null,
+    retriesExhausted: false,
+  };
+}
+
 function normalizeWorkspaceHint(value) {
   const raw = String(value || "").trim();
   if (!raw) return "";

package/ui/modules/settings-schema.js

@@ -248,7 +248,7 @@ export const SETTINGS_SCHEMA = [
   { key: "DEVMODE",                        label: "Dev Mode",                   category: "advanced", type: "boolean", defaultVal: false, description: "Enable development mode with extra logging, self-restart watcher, and debug endpoints." },
   { 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: "RESTART_DELAY_MS",               label: "Restart Delay",              category: "advanced", type: "number", defaultVal: 180000, min: 1000, max: 1800000, 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." },
@@ -358,4 +358,3 @@ export function validateSetting(def, value) {
 export const SENSITIVE_KEYS = new Set(
   SETTINGS_SCHEMA.filter((s) => s.sensitive).map((s) => s.key),
 );
-

package/ui/modules/state.js

@@ -83,6 +83,17 @@ export function sanitizeTaskText(value) {
   return text.replace(/\s{2,}/g, " ").trim();
 }
 
+export function isPlaceholderTaskDescription(value) {
+  const text = sanitizeTaskText(value || "");
+  if (!text) return false;
+  const normalized = text.toLowerCase();
+  return (
+    normalized === "internal server error" ||
+    normalized === "{\"ok\":false,\"error\":\"internal server error\"}" ||
+    normalized === "{\"error\":\"internal server error\"}"
+  );
+}
+
 function synthesizeTaskDescription(task) {
   const title = sanitizeTaskText(task?.title || "");
   if (!title) {
@@ -94,12 +105,18 @@ function synthesizeTaskDescription(task) {
 function normalizeTaskForUi(task) {
   if (!task || typeof task !== "object") return task;
   const title = sanitizeTaskText(task.title || "");
-  const description = sanitizeTaskText(task.description || "");
+  const rawDescription = sanitizeTaskText(task.description || "");
+  const description = isPlaceholderTaskDescription(rawDescription) ? "" : rawDescription;
   const meta = task.meta && typeof task.meta === "object"
     ? {
         ...task.meta,
         title: task.meta.title != null ? sanitizeTaskText(task.meta.title) : task.meta.title,
-        description: task.meta.description != null ? sanitizeTaskText(task.meta.description) : task.meta.description,
+        description:
+          task.meta.description != null
+            ? (isPlaceholderTaskDescription(task.meta.description)
+              ? ""
+              : sanitizeTaskText(task.meta.description))
+            : task.meta.description,
       }
     : task.meta;
   return {
@@ -153,7 +170,7 @@ export const tasksSearch = signal("");
 export const tasksSort = signal("updated");
 export const tasksTotalPages = signal(1);
 export const tasksTotal = signal(0);
-export const tasksStatusCounts = signal({ draft: 0, backlog: 0, inProgress: 0, inReview: 0, done: 0 });
+export const tasksStatusCounts = signal({ draft: 0, backlog: 0, blocked: 0, inProgress: 0, inReview: 0, done: 0 });
 
 // ── Retry Queue
 export const retryQueueData = signal({ count: 0, items: [] });
@@ -556,6 +573,7 @@ export async function loadTasks(options = {}) {
   tasksStatusCounts.value = {
     draft: Number(res?.statusCounts?.draft || 0),
     backlog: Number(res?.statusCounts?.backlog || 0),
+    blocked: Number(res?.statusCounts?.blocked || 0),
     inProgress: Number(res?.statusCounts?.inProgress || 0),
     inReview: Number(res?.statusCounts?.inReview || 0),
     done: Number(res?.statusCounts?.done || 0),

package/ui/setup.html

@@ -1019,7 +1019,7 @@ function App() {
   const [sentinelRepairAgentEnabled, setSentinelRepairAgentEnabled] = useState(false);
   const [sentinelRepairTimeoutMin, setSentinelRepairTimeoutMin] = useState(15);
   // Daemon restart policy
-  const [daemonRestartDelayMs, setDaemonRestartDelayMs] = useState(10000);
+  const [daemonRestartDelayMs, setDaemonRestartDelayMs] = useState(180000);
   const [daemonMaxRestarts, setDaemonMaxRestarts] = useState(0);
   const [daemonMaxInstantRestarts, setDaemonMaxInstantRestarts] = useState(3);
   const [daemonInstantCrashWindowMs, setDaemonInstantCrashWindowMs] = useState(15000);
@@ -2023,7 +2023,7 @@ function App() {
       if (env.SENTINEL_REPAIR_AGENT_ENABLED) { setSentinelRepairAgentEnabled(env.SENTINEL_REPAIR_AGENT_ENABLED === "true"); envLoaded = true; }
       if (env.SENTINEL_REPAIR_TIMEOUT_MIN) { setSentinelRepairTimeoutMin(Number(env.SENTINEL_REPAIR_TIMEOUT_MIN) || 15); envLoaded = true; }
       // Daemon restart policy
-      if (env.RESTART_DELAY_MS) { setDaemonRestartDelayMs(Number(env.RESTART_DELAY_MS) || 10000); envLoaded = true; }
+      if (env.RESTART_DELAY_MS) { setDaemonRestartDelayMs(Number(env.RESTART_DELAY_MS) || 180000); envLoaded = true; }
       if (env.MAX_RESTARTS) { setDaemonMaxRestarts(Number(env.MAX_RESTARTS) || 0); envLoaded = true; }
       if (env.BOSUN_DAEMON_MAX_INSTANT_RESTARTS) { setDaemonMaxInstantRestarts(Number(env.BOSUN_DAEMON_MAX_INSTANT_RESTARTS) || 3); envLoaded = true; }
       if (env.BOSUN_DAEMON_INSTANT_CRASH_WINDOW_MS) { setDaemonInstantCrashWindowMs(Number(env.BOSUN_DAEMON_INSTANT_CRASH_WINDOW_MS) || 15000); envLoaded = true; }
@@ -4845,8 +4845,8 @@ function App() {
           <div class="form-group">
             <label>Restart Delay (ms)</label>
             <input type="number" value=${daemonRestartDelayMs} min="0"
-              oninput=${(e) => setDaemonRestartDelayMs(Number(e.target.value) || 10000)} />
-            <div class="hint">Delay before restarting after a crash. Default: 10 000 ms.</div>
+              oninput=${(e) => setDaemonRestartDelayMs(Number(e.target.value) || 180000)} />
+            <div class="hint">Delay before restarting after a crash. Default: 180 000 ms (180 s).</div>
           </div>
           <div class="form-group">
             <label>Max Restarts (0 = unlimited)</label>
@@ -5094,4 +5094,3 @@ render(html`<${App} />`, document.getElementById("app"));
 <script defer src="https://cloud.umami.is/script.js" data-website-id="24c5d605-7f25-4be5-875e-25c8f3cb4059"></script>
 </html>
 
-

package/ui/styles/components.css

@@ -6242,16 +6242,12 @@ select.input {
 }
 .task-detail-main {
   padding: 20px 24px;
-  overflow-y: auto;
-  scrollbar-width: thin;
   display: flex;
   flex-direction: column;
   gap: 20px;
 }
 .task-detail-sidebar {
   padding: 16px 20px;
-  overflow-y: auto;
-  scrollbar-width: thin;
   border-left: 1px solid var(--border, #30363d);
   background: var(--bg-surface, #0d1117);
   display: flex;
@@ -6306,6 +6302,64 @@ select.input {
   padding: 14px;
 }
 
+.task-blocked-banner {
+  display: grid;
+  gap: 8px;
+  padding: 12px 14px;
+  border: 1px solid rgba(248, 113, 113, 0.28);
+  border-radius: 10px;
+  background:
+    linear-gradient(135deg, rgba(248, 113, 113, 0.14), rgba(245, 158, 11, 0.08)),
+    var(--bg-card, #161b22);
+}
+
+.task-blocked-banner[data-category="dependency_blocked"],
+.task-blocked-banner[data-category="start_guard_blocked"] {
+  border-color: rgba(251, 191, 36, 0.28);
+  background:
+    linear-gradient(135deg, rgba(251, 191, 36, 0.14), rgba(245, 158, 11, 0.08)),
+    var(--bg-card, #161b22);
+}
+
+.task-blocked-banner-title {
+  font-size: 14px;
+  font-weight: 700;
+  color: var(--text-primary, #f8fafc);
+}
+
+.task-blocked-banner-copy {
+  font-size: 13px;
+  line-height: 1.55;
+  color: var(--text-secondary, #c9d1d9);
+}
+
+.task-workflow-run-card[data-clickable="true"] {
+  cursor: pointer;
+  transition: border-color 120ms ease, background 120ms ease, transform 120ms ease;
+}
+
+.task-workflow-run-card[data-clickable="true"]:hover,
+.task-workflow-run-card[data-clickable="true"]:focus-visible {
+  border-color: var(--accent, #3b82f6);
+  background: rgba(59, 130, 246, 0.08);
+  transform: translateY(-1px);
+  outline: none;
+}
+
+.task-workflow-run-head {
+  display: flex;
+  gap: 10px;
+  justify-content: space-between;
+  align-items: flex-start;
+}
+
+.task-workflow-run-actions {
+  display: flex;
+  gap: 6px;
+  flex-wrap: wrap;
+  justify-content: flex-end;
+}
+
 /* Priority dot */
 .task-priority-dot {
   display: inline-block;

package/ui/tabs/agents.js

@@ -128,6 +128,13 @@ function fleetThreadKey(thread, index) {
   return `thread-${index}:${taskKey}:${id}`;
 }
 
+function resolveFleetEntrySessionId(entry) {
+  const sessionId = String(entry?.session?.id || "").trim();
+  if (sessionId) return sessionId;
+  if (entry?.isTaskFallback || entry?.slot?.synthetic) return "";
+  return String(entry?.slot?.sessionId || "").trim();
+}
+
 function buildSessionLogQueryParts(values = []) {
   return Array.from(
     new Set(
@@ -2016,7 +2023,7 @@ function FleetSessionsPanel({ slots, taskFallbackEntries = [], onOpenWorkspace,
           branch: task?.branchName || task?.branch || task?.meta?.branchName || "",
           baseBranch: task?.baseBranch || task?.meta?.baseBranch || null,
           status: task?.status || task?.runtimeSnapshot?.state || "idle",
-          sessionId: String(task?.id || task?.taskId || "").trim(),
+          sessionId: "",
           startedAt:
             task?.lastActivityAt ||
             task?.updatedAt ||
@@ -2109,19 +2116,10 @@ function FleetSessionsPanel({ slots, taskFallbackEntries = [], onOpenWorkspace,
     visibleEntries.find((entry) => entry.key === selectedEntryKey)
     || visibleEntries[0]
     || null;
-  const streamSessionId =
-    selectedEntry?.session?.id
-    || selectedEntry?.slot?.sessionId
-    || selectedEntry?.slot?.taskId
-    || null;
-  const diffSessionId =
-    selectedEntry?.session?.id
-    || selectedEntry?.slot?.sessionId
-    || null;
-  const contextSessionId =
-    selectedEntry?.session?.id
-    || selectedEntry?.slot?.sessionId
-    || "";
+  const resolvedSessionId = resolveFleetEntrySessionId(selectedEntry);
+  const streamSessionId = resolvedSessionId || null;
+  const diffSessionId = resolvedSessionId || null;
+  const contextSessionId = resolvedSessionId || "";
   const contextTaskId =
     selectedEntry?.slot?.taskId
     || selectedEntry?.session?.taskId
@@ -2489,4 +2487,3 @@ export function FleetSessionsTab() {
     `}
   `;
 }
-

package/ui/tabs/control.js

@@ -23,6 +23,7 @@ import { ICONS } from "../modules/icons.js";
 import { iconText as iconTextUtil } from "../modules/icon-utils.js";
 import { cloneValue, truncate } from "../modules/utils.js";
 import { SegmentedControl, Collapsible } from "../components/forms.js";
+import { SkeletonCard } from "../components/shared.js";
 
 /* ─── Command registry for autocomplete ─── */
 const CMD_REGISTRY = [