bosun 0.35.2 → 0.35.4

package/ui/tabs/agents.js

@@ -1503,14 +1503,7 @@ export function AgentsTab() {
       </div>
 
       <div class="fleet-span">
-        <${FleetSessionsPanel}
-          slots=${slots}
-          onOpenWorkspace=${openWorkspace}
-          onForceStop=${handleForceStop}
-        />
-      </div>
-
-      ${agents.length > 0 &&
+        ${agents.length > 0 &&
       html`
         <div class="fleet-span">
           <${Collapsible} title="Agent Threads" defaultOpen=${false}>
@@ -1971,3 +1964,68 @@ function FleetSessionsPanel({ slots, onOpenWorkspace, onForceStop }) {
     <//>
   `;
 }
+
+/* ─── Fleet Sessions Tab (standalone) ─── */
+export function FleetSessionsTab() {
+  const executor = executorData.value;
+  const execData = executor?.data;
+  const slots = execData?.slots || [];
+
+  useEffect(() => {
+    let active = true;
+    const refreshTaskSessions = () => {
+      if (!active) return;
+      loadSessions({ type: "task" });
+    };
+    refreshTaskSessions();
+    const interval = setInterval(refreshTaskSessions, 5000);
+    return () => {
+      active = false;
+      clearInterval(interval);
+    };
+  }, []);
+
+  /* Force stop a specific agent slot */
+  const handleForceStop = async (slot) => {
+    const ok = await showConfirm(
+      `Force-stop agent working on "${truncate(slot.taskTitle || slot.taskId || "task", 40)}"?`,
+    );
+    if (!ok) return;
+    haptic("heavy");
+    try {
+      await apiFetch("/api/executor/stop-slot", {
+        method: "POST",
+        body: JSON.stringify({ slotIndex: slot.index, taskId: slot.taskId }),
+      });
+      showToast("Stop signal sent", "success");
+      scheduleRefresh(200);
+    } catch {
+      /* toast via apiFetch */
+    }
+  };
+
+  /* Open workspace viewer for an agent */
+  const [selectedAgent, setSelectedAgent] = useState(null);
+  const openWorkspace = (slot, i) => {
+    haptic();
+    setSelectedAgent({ ...slot, index: i });
+  };
+
+  return html`
+    <div class="fleet-layout">
+      <div class="fleet-span">
+        <${FleetSessionsPanel}
+          slots=${slots}
+          onOpenWorkspace=${openWorkspace}
+          onForceStop=${handleForceStop}
+        />
+      </div>
+    </div>
+    ${selectedAgent && html`
+      <${WorkspaceViewer}
+        agent=${selectedAgent}
+        onClose=${() => setSelectedAgent(null)}
+      />
+    `}
+  `;
+}

package/ui/tabs/workflows.js

@@ -184,6 +184,29 @@ async function installTemplate(templateId) {
   }
 }
 
+async function applyTemplateUpdate(workflowId, mode = "replace", force = false) {
+  try {
+    const data = await apiFetch(`/api/workflows/${encodeURIComponent(workflowId)}/template-update`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ mode, force }),
+    });
+    if (data?.workflow) {
+      showToast(
+        mode === "copy"
+          ? "Updated template copy created"
+          : "Workflow updated to latest template",
+        "success",
+      );
+      loadWorkflows();
+      return data.workflow;
+    }
+  } catch (err) {
+    showToast(`Template update failed: ${err.message}`, "error");
+  }
+  return null;
+}
+
 async function loadRuns(workflowId) {
   try {
     const url = workflowId
@@ -1570,6 +1593,11 @@ function WorkflowListView() {
           </h3>
           <div style="display: grid; gap: 10px; grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));">
             ${wfs.map(wf => html`
+              ${(() => {
+                const templateState = wf.metadata?.templateState || null;
+                const hasTemplateUpdate = templateState?.updateAvailable === true;
+                const isCustomizedTemplate = templateState?.isCustomized === true;
+                return html`
               <div key=${wf.id} class="wf-card" style="background: var(--color-bg-secondary, #1a1f2e); border-radius: 12px; padding: 14px; border: 1px solid var(--color-border, #2a3040); cursor: pointer; transition: border-color 0.15s;"
                    onClick=${() => {
                      apiFetch("/api/workflows/" + wf.id).then(d => {
@@ -1583,17 +1611,70 @@ function WorkflowListView() {
                   <span class="wf-badge" style="background: ${wf.enabled ? '#10b98130' : '#6b728030'}; color: ${wf.enabled ? '#10b981' : '#6b7280'}; font-size: 10px;">
                     ${wf.enabled ? "Active" : "Paused"}
                   </span>
+                  ${templateState?.templateId && html`
+                    <span class="wf-badge" style="background: #3b82f620; color: #60a5fa; font-size: 10px;">
+                      Template
+                    </span>
+                  `}
+                  ${isCustomizedTemplate && html`
+                    <span class="wf-badge" style="background: #f59e0b20; color: #f59e0b; font-size: 10px;">
+                      Customized
+                    </span>
+                  `}
+                  ${hasTemplateUpdate && html`
+                    <span class="wf-badge" style="background: #ef444420; color: #f87171; font-size: 10px;">
+                      Update Available
+                    </span>
+                  `}
                 </div>
                 ${wf.description && html`
                   <div style="font-size: 12px; color: var(--color-text-secondary, #8b95a5); margin-bottom: 8px; line-height: 1.4;">
                     ${wf.description.slice(0, 120)}${wf.description.length > 120 ? "…" : ""}
                   </div>
                 `}
+                ${templateState?.templateId && html`
+                  <div style="font-size: 11px; color: var(--color-text-secondary, #7f8aa0); margin-bottom: 8px;">
+                    ${templateState.templateName || templateState.templateId}
+                    ${templateState.installedTemplateVersion && templateState.templateVersion && templateState.installedTemplateVersion !== templateState.templateVersion && html`
+                      <span> · v${templateState.installedTemplateVersion} → v${templateState.templateVersion}</span>
+                    `}
+                  </div>
+                `}
                 <div style="display: flex; gap: 8px; align-items: center; font-size: 11px; color: var(--color-text-secondary, #6b7280);">
                   <span>${wf.nodeCount || 0} nodes</span>
                   <span>·</span>
                   <span>${wf.category || "custom"}</span>
                   <div style="flex: 1;"></div>
+                  ${hasTemplateUpdate && html`
+                    <button
+                      class="wf-btn wf-btn-sm"
+                      style="font-size: 11px; border-color: #f59e0b80; color: #f59e0b;"
+                      onClick=${async (e) => {
+                        e.stopPropagation();
+                        if (!isCustomizedTemplate) {
+                          await applyTemplateUpdate(wf.id, "replace", true);
+                          return;
+                        }
+                        const choice = window.prompt(
+                          "Template update available for customized workflow.\nType 'copy' to create an updated copy, or 'replace' to overwrite this workflow.",
+                          "copy",
+                        );
+                        const normalized = String(choice || "").trim().toLowerCase();
+                        if (normalized === "copy") {
+                          await applyTemplateUpdate(wf.id, "copy", false);
+                          return;
+                        }
+                        if (normalized === "replace") {
+                          const ok = window.confirm("Replace this customized workflow with latest template? This cannot be undone.");
+                          if (!ok) return;
+                          await applyTemplateUpdate(wf.id, "replace", true);
+                        }
+                      }}
+                    >
+                      <span class="icon-inline">${resolveIcon("refresh")}</span>
+                      Update
+                    </button>
+                  `}
                   <button
                     class="wf-btn wf-btn-sm"
                     style="font-size: 11px;"
@@ -1624,6 +1705,8 @@ function WorkflowListView() {
                   </button>
                 </div>
               </div>
+            `;
+              })()}
             `)}
           </div>
         </div>

package/ui-server.mjs

@@ -355,6 +355,15 @@ async function getWorkflowEngineModule() {
         };
         _wfEngine.getWorkflowEngine({ services });
         _wfServicesReady = true;
+
+        // Resume any runs that were interrupted by a previous shutdown.
+        // This must happen AFTER services are wired so node executors work.
+        const engine = _wfEngine.getWorkflowEngine();
+        if (typeof engine.resumeInterruptedRuns === "function") {
+          engine.resumeInterruptedRuns().catch((err) => {
+            console.warn("[workflows] Failed to resume interrupted runs:", err.message);
+          });
+        }
       } catch (err) {
         console.warn("[workflows] services setup failed (engine still usable):", err.message);
       }
@@ -397,6 +406,27 @@ async function getWorkflowEngineModule() {
         if (result.errors.length) {
           console.warn("[workflows] Default template install errors:", result.errors);
         }
+        if (typeof _wfTemplates.reconcileInstalledTemplates === "function") {
+          const reconcile = _wfTemplates.reconcileInstalledTemplates(engine, {
+            autoUpdateUnmodified: true,
+          });
+          if (reconcile.autoUpdated > 0) {
+            console.log(
+              `[workflows] Auto-updated ${reconcile.autoUpdated} unmodified template workflow(s) to latest`,
+            );
+          }
+          if (reconcile.customized.length > 0) {
+            const pending = reconcile.customized.filter((entry) => entry.updateAvailable).length;
+            if (pending > 0) {
+              console.log(
+                `[workflows] ${pending} customized template workflow(s) have updates available`,
+              );
+            }
+          }
+          if (reconcile.errors.length > 0) {
+            console.warn("[workflows] Template reconcile errors:", reconcile.errors);
+          }
+        }
       } catch (err) {
         console.warn("[workflows] Default template install failed:", err.message);
       } finally {
@@ -1361,6 +1391,28 @@ let uiInstanceLockHeld = false;
 const logStreamers = new Map();
 let uiDeps = {};
 
+/**
+ * Resolve the execPrimaryPrompt function. Prefers the injected dependency,
+ * falls back to importing directly from primary-agent.mjs so the chat
+ * agent works even when the UI server starts standalone.
+ */
+let _fallbackExecPrimaryPrompt = null;
+async function resolveExecPrimaryPrompt() {
+  if (typeof uiDeps.execPrimaryPrompt === "function") return uiDeps.execPrimaryPrompt;
+  if (_fallbackExecPrimaryPrompt) return _fallbackExecPrimaryPrompt;
+  try {
+    const mod = await import("./primary-agent.mjs");
+    if (typeof mod.execPrimaryPrompt === "function") {
+      _fallbackExecPrimaryPrompt = mod.execPrimaryPrompt;
+      console.log("[ui-server] loaded execPrimaryPrompt fallback from primary-agent.mjs");
+      return _fallbackExecPrimaryPrompt;
+    }
+  } catch (err) {
+    console.warn("[ui-server] failed to load execPrimaryPrompt fallback:", err.message);
+  }
+  return null;
+}
+
 /**
  * Resolve the bosun config directory. Falls back through:
  *   1. uiDeps.configDir (injected at server start)
@@ -6227,6 +6279,9 @@ async function handleApi(req, res, url) {
       const wfMod = await getWorkflowEngine();
       if (!wfMod) { jsonResponse(res, 503, { ok: false, error: "Workflow engine not available" }); return; }
       const engine = wfMod.getWorkflowEngine();
+      if (typeof _wfTemplates?.applyWorkflowTemplateState === "function") {
+        _wfTemplates.applyWorkflowTemplateState(body);
+      }
       const saved = await engine.save(body);
       jsonResponse(res, 200, { ok: true, workflow: saved });
     } catch (err) {
@@ -6263,6 +6318,65 @@ async function handleApi(req, res, url) {
     return;
   }
 
+  if (path === "/api/workflows/template-updates") {
+    try {
+      const wfMod = await getWorkflowEngine();
+      if (!wfMod) { jsonResponse(res, 503, { ok: false, error: "Workflow engine not available" }); return; }
+      const engine = wfMod.getWorkflowEngine();
+      if (typeof _wfTemplates?.reconcileInstalledTemplates === "function") {
+        _wfTemplates.reconcileInstalledTemplates(engine, {
+          autoUpdateUnmodified: true,
+        });
+      }
+      const updates = engine
+        .list()
+        .map((wf) => {
+          const state = wf.metadata?.templateState || null;
+          if (!state?.templateId) return null;
+          return {
+            workflowId: wf.id,
+            workflowName: wf.name,
+            templateId: state.templateId,
+            templateName: state.templateName || state.templateId,
+            updateAvailable: state.updateAvailable === true,
+            isCustomized: state.isCustomized === true,
+            templateVersion: state.templateVersion || null,
+            installedTemplateVersion: state.installedTemplateVersion || null,
+          };
+        })
+        .filter(Boolean);
+      jsonResponse(res, 200, { ok: true, updates });
+    } catch (err) {
+      jsonResponse(res, 500, { ok: false, error: err.message });
+    }
+    return;
+  }
+
+  if (path.startsWith("/api/workflows/") && path.endsWith("/template-update")) {
+    try {
+      const wfMod = await getWorkflowEngine();
+      if (!wfMod) { jsonResponse(res, 503, { ok: false, error: "Workflow engine not available" }); return; }
+      const engine = wfMod.getWorkflowEngine();
+      const workflowId = decodeURIComponent(path.split("/")[3] || "");
+      if (!workflowId) {
+        jsonResponse(res, 400, { ok: false, error: "Missing workflow id" });
+        return;
+      }
+      const body = await readJsonBody(req).catch(() => ({}));
+      const mode = String(body?.mode || "replace").toLowerCase();
+      const force = body?.force === true;
+      if (typeof _wfTemplates?.updateWorkflowFromTemplate !== "function") {
+        jsonResponse(res, 503, { ok: false, error: "Template update service unavailable" });
+        return;
+      }
+      const workflow = _wfTemplates.updateWorkflowFromTemplate(engine, workflowId, { mode, force });
+      jsonResponse(res, 200, { ok: true, workflow });
+    } catch (err) {
+      jsonResponse(res, 500, { ok: false, error: err.message });
+    }
+    return;
+  }
+
   if (path === "/api/workflows/node-types") {
     try {
       const wfMod = await getWorkflowEngine();
@@ -6302,11 +6416,68 @@ async function handleApi(req, res, url) {
       const wfMod = await getWorkflowEngine();
       if (!wfMod) { jsonResponse(res, 503, { ok: false, error: "Workflow engine not available" }); return; }
       const engine = wfMod.getWorkflowEngine();
-      const runId = decodeURIComponent(path.replace("/api/workflows/runs/", "")).trim();
+      const subPath = path.replace("/api/workflows/runs/", "");
+      const segments = subPath.split("/").map(decodeURIComponent);
+      const runId = (segments[0] || "").trim();
+      const action = (segments[1] || "").trim();
+
       if (!runId) {
         jsonResponse(res, 400, { ok: false, error: "runId is required" });
         return;
       }
+
+      // ── POST /api/workflows/runs/:id/retry ──────────────────────────
+      // Manual retry endpoint. Accepts { mode: "from_failed" | "from_scratch" }.
+      // If mode is omitted, returns available retry options so the UI can
+      // present a choice to the user.
+      if (action === "retry" && req.method === "POST") {
+        const run = engine.getRunDetail ? engine.getRunDetail(runId) : null;
+        if (!run) {
+          jsonResponse(res, 404, { ok: false, error: "Workflow run not found" });
+          return;
+        }
+        if (run.status !== "failed") {
+          jsonResponse(res, 400, { ok: false, error: `Run status is "${run.status}" — only failed runs can be retried` });
+          return;
+        }
+        const body = await readJsonBody(req);
+        const mode = body?.mode;
+        if (!mode) {
+          // No mode specified — return available retry options so the UI can
+          // present a picker (from scratch vs from failed step).
+          const failedNodes = [];
+          const nodeStatuses = run.detail?.nodeStatuses || {};
+          for (const [nodeId, status] of Object.entries(nodeStatuses)) {
+            if (status === "failed") failedNodes.push(nodeId);
+          }
+          jsonResponse(res, 200, {
+            ok: true,
+            runId,
+            status: run.status,
+            options: [
+              { mode: "from_failed", label: "Retry from last failed step", failedNodes },
+              { mode: "from_scratch", label: "Retry from scratch" },
+            ],
+          });
+          return;
+        }
+        if (mode !== "from_failed" && mode !== "from_scratch") {
+          jsonResponse(res, 400, { ok: false, error: `Invalid mode "${mode}". Use "from_failed" or "from_scratch".` });
+          return;
+        }
+        const result = await engine.retryRun(runId, { mode });
+        const retryStatus = result.ctx?.errors?.length > 0 ? "failed" : "completed";
+        jsonResponse(res, 200, {
+          ok: true,
+          retryRunId: result.retryRunId,
+          originalRunId: result.originalRunId,
+          mode: result.mode,
+          status: retryStatus,
+        });
+        return;
+      }
+
+      // ── GET /api/workflows/runs/:id ─────────────────────────────────
       const run = engine.getRunDetail ? engine.getRunDetail(runId) : null;
       if (!run) {
         jsonResponse(res, 404, { ok: false, error: "Workflow run not found" });
@@ -7217,7 +7388,26 @@ async function handleApi(req, res, url) {
           jsonResponse(res, 404, { ok: false, error: "Session not found" });
           return;
         }
-        jsonResponse(res, 200, { ok: true, session });
+        // Support ?limit=N&offset=N for message pagination
+        const reqUrl = new URL(req.url, `http://${req.headers.host || "localhost"}`);
+        const limitParam = reqUrl.searchParams.get("limit");
+        const offsetParam = reqUrl.searchParams.get("offset");
+        if (limitParam) {
+          const limit = Math.max(1, Math.min(Number(limitParam) || 20, 500));
+          const allMessages = session.messages || [];
+          const total = allMessages.length;
+          const offset = offsetParam != null
+            ? Math.max(0, Math.min(Number(offsetParam) || 0, total))
+            : Math.max(0, total - limit);
+          const sliced = allMessages.slice(offset, offset + limit);
+          jsonResponse(res, 200, {
+            ok: true,
+            session: { ...session, messages: sliced },
+            pagination: { total, offset, limit, hasMore: offset > 0 },
+          });
+        } else {
+          jsonResponse(res, 200, { ok: true, session });
+        }
       } catch (err) {
         jsonResponse(res, 500, { ok: false, error: err.message });
       }
@@ -7306,12 +7496,44 @@ async function handleApi(req, res, url) {
         const messageModel = body?.model || undefined;
 
         // Forward to primary agent if applicable (exec records user + assistant events)
-        const exec = session.type === "primary" ? uiDeps.execPrimaryPrompt : null;
+        let exec = session.type === "primary" ? uiDeps.execPrimaryPrompt : null;
+        // Fallback: resolve execPrimaryPrompt from primary-agent.mjs if not injected
+        if (!exec && session.type === "primary") {
+          exec = await resolveExecPrimaryPrompt();
+        }
         if (exec) {
           // Don't record user event here — execPrimaryPrompt records it
           // Respond immediately so the UI doesn't block on agent execution
           jsonResponse(res, 200, { ok: true, messageId });
           broadcastUiEvent(["sessions"], "invalidate", { reason: "session-message", sessionId });
+
+          // Build an onEvent callback so intermediate SDK events (thinking,
+          // tool calls, code edits, etc.) are streamed to the UI in real-time
+          // via the existing session-tracker → WebSocket listener pipeline.
+          // Without this, chat/telegram dispatches only show the final
+          // user+assistant pair instead of the full thought stream that Flows
+          // clients see.
+          const streamOnEvent = (err, event) => {
+            // The adapters call onEvent(err, event) or onEvent(event).
+            // Normalise both calling conventions.
+            const ev = event || err;
+            if (!ev) return;
+            try {
+              if (typeof ev === "string") {
+                tracker.recordEvent(sessionId, {
+                  role: "system",
+                  type: "system",
+                  content: ev,
+                  timestamp: new Date().toISOString(),
+                });
+              } else {
+                tracker.recordEvent(sessionId, ev);
+              }
+            } catch {
+              /* best-effort — never crash the agent loop */
+            }
+          };
+
           // Fire-and-forget: run agent asynchronously so the request handler
           // doesn't block and the agent doesn't appear "busy" to subsequent
           // messages from chat, telegram, portal, or any other source.
@@ -7320,8 +7542,11 @@ async function handleApi(req, res, url) {
             sessionType: "primary",
             mode: messageMode,
             model: messageModel,
+            persistent: true,
+            sendRawEvents: true,
             attachments,
             attachmentsAppended,
+            onEvent: streamOnEvent,
           }).then(() => {
             broadcastUiEvent(["sessions"], "invalidate", { reason: "agent-response", sessionId });
           }).catch((execErr) => {
@@ -7335,14 +7560,20 @@ async function handleApi(req, res, url) {
             broadcastUiEvent(["sessions"], "invalidate", { reason: "agent-error", sessionId });
           });
         } else {
-          // No agent — record user event and acknowledge
+          // No agent available — record user event and notify user
           tracker.recordEvent(sessionId, {
             role: "user",
             content: messageContent,
             attachments,
             timestamp: new Date().toISOString(),
           });
-          jsonResponse(res, 200, { ok: true, messageId });
+          tracker.recordEvent(sessionId, {
+            role: "system",
+            type: "error",
+            content: "⚠️ No agent is available to process this message. The primary agent may not be initialized — try restarting bosun or check the Logs tab for details.",
+            timestamp: new Date().toISOString(),
+          });
+          jsonResponse(res, 200, { ok: true, messageId, warning: "no_agent_available" });
           broadcastUiEvent(["sessions"], "invalidate", { reason: "session-message", sessionId });
         }
       } catch (err) {