bosun 0.37.1 → 0.37.2

package/.env.example

@@ -21,7 +21,6 @@ SHARED_STATE_STALE_THRESHOLD_MS=300000
 # Maximum retry attempts before permanently ignoring a task (default: 3)
 SHARED_STATE_MAX_RETRIES=3
 # Task claim owner staleness threshold in milliseconds (default: 600000 = 10 minutes)
-# Used by task-claims.mjs to detect stale local claims
 TASK_CLAIM_OWNER_STALE_TTL_MS=600000
 
 # ─── Project Identity ─────────────────────────────────────────────────────────
@@ -178,6 +177,10 @@ VOICE_VISION_MODEL=gpt-4.1-mini
 # Gemini provider mode (Tier 2 voice fallback + Gemini vision)
 # GEMINI_API_KEY=
 # GOOGLE_API_KEY=
+# Transcription model used for audio-to-text (default: gpt-4o-transcribe)
+# VOICE_TRANSCRIPTION_MODEL=gpt-4o-mini-transcribe
+# Enable/disable input audio transcription in realtime sessions (default: true)
+# VOICE_TRANSCRIPTION_ENABLED=true
 # Voice output persona
 VOICE_ID=alloy
 # server_vad | semantic_vad | none

package/agent-tool-config.mjs

@@ -286,12 +286,23 @@ export function getEffectiveTools(rootDir, agentId) {
   const agentConfig = config.agents[agentId] || {};
   const disabledSet = new Set(agentConfig.disabledBuiltinTools || []);
   const defaultIds = new Set(config.defaults?.builtinTools || DEFAULT_BUILTIN_TOOLS.filter((t) => t.default).map((t) => t.id));
+  const builtinIdSet = new Set(DEFAULT_BUILTIN_TOOLS.map((tool) => tool.id));
+  const explicitEnabled = Array.isArray(agentConfig.enabledTools)
+    ? agentConfig.enabledTools.map((id) => String(id || "").trim()).filter(Boolean)
+    : null;
+  const explicitBuiltinEnabled = explicitEnabled
+    ? explicitEnabled.filter((id) => builtinIdSet.has(id))
+    : [];
+  const useBuiltinAllowlist = explicitBuiltinEnabled.length > 0;
+  const explicitBuiltinSet = new Set(explicitBuiltinEnabled);
 
   const builtinTools = DEFAULT_BUILTIN_TOOLS.map((tool) => ({
     ...tool,
-    enabled: !disabledSet.has(tool.id) && (agentConfig.enabledTools === null || agentConfig.enabledTools === undefined
-      ? defaultIds.has(tool.id)
-      : agentConfig.enabledTools.includes(tool.id)),
+    enabled: !disabledSet.has(tool.id) && (
+      useBuiltinAllowlist
+        ? explicitBuiltinSet.has(tool.id)
+        : defaultIds.has(tool.id)
+    ),
   }));
 
   return {

package/bosun-skills.mjs

@@ -16,8 +16,44 @@
  * scan quickly to decide which skill files to read.
  */
 
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSync } from "node:fs";
-import { resolve, basename } from "node:path";
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { dirname, resolve, basename } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// ── Analytics stream path (same file task-executor writes to) ────────────────
+const _SKILL_STREAM_PATH = resolve(
+  __dirname,
+  ".cache",
+  "agent-work-logs",
+  "agent-work-stream.jsonl",
+);
+
+/**
+ * Best-effort: emit a skill_invoke event to the agent work stream so usage
+ * analytics can track which skills are loaded per task.
+ *
+ * @param {string} skillName
+ * @param {string} [skillTitle]
+ * @param {{ taskId?: string, executor?: string }} [opts]
+ */
+function emitSkillInvokeEvent(skillName, skillTitle, opts = {}) {
+  try {
+    const event = {
+      timestamp: new Date().toISOString(),
+      event_type: "skill_invoke",
+      data: { skill_name: skillName, skill_title: skillTitle || skillName },
+      ...(opts.taskId ? { task_id: String(opts.taskId) } : {}),
+      ...(opts.executor ? { executor: String(opts.executor) } : {}),
+    };
+    mkdirSync(dirname(_SKILL_STREAM_PATH), { recursive: true });
+    appendFileSync(_SKILL_STREAM_PATH, JSON.stringify(event) + "\n", "utf8");
+  } catch {
+    /* best effort — never let analytics crash skill loading */
+  }
+}
 
 // ── Built-in skill definitions ────────────────────────────────────────────────
 
@@ -911,14 +947,25 @@ export function loadSkillsIndex(bosunHome) {
  * @param {string}   [taskDescription]
  * @returns {Array<{filename:string,title:string,tags:string[],content:string}>}
  */
-export function findRelevantSkills(bosunHome, taskTitle, taskDescription = "") {
+/**
+ * Find skills relevant to a given task by matching tags against the task title
+ * and description. Also emits `skill_invoke` analytics events for each matched
+ * skill so usage analytics can track skill popularity over time.
+ *
+ * @param {string}   bosunHome
+ * @param {string}   taskTitle
+ * @param {string}   [taskDescription]
+ * @param {{ taskId?: string, executor?: string }} [opts]  - Optional task context for analytics.
+ * @returns {Array<{filename:string,title:string,tags:string[],content:string}>}
+ */
+export function findRelevantSkills(bosunHome, taskTitle, taskDescription = "", opts = {}) {
   const index = loadSkillsIndex(bosunHome);
   if (!index?.skills?.length) return [];
 
   const searchText = `${taskTitle} ${taskDescription}`.toLowerCase();
   const skillsDir = getSkillsDir(bosunHome);
 
-  return index.skills
+  const matched = index.skills
     .filter(({ tags }) =>
       tags.some((tag) => searchText.includes(tag)),
     )
@@ -930,4 +977,12 @@ export function findRelevantSkills(bosunHome, taskTitle, taskDescription = "") {
       return { filename, title, tags, content };
     })
     .filter(({ content }) => !!content);
+
+  // Emit analytics events for each loaded skill
+  for (const skill of matched) {
+    const skillName = skill.filename.replace(/\.md$/i, "");
+    emitSkillInvokeEvent(skillName, skill.title, opts);
+  }
+
+  return matched;
 }

package/desktop/launch.mjs

@@ -17,6 +17,13 @@ const chromeSandbox = resolve(
 
 process.title = "bosun-desktop-launcher";
 
+function hasGuiEnvironment() {
+  if (process.platform !== "linux") return true;
+  if (process.env.DISPLAY || process.env.WAYLAND_DISPLAY) return true;
+  if (process.env.XDG_SESSION_TYPE && process.env.XDG_SESSION_TYPE !== "tty") return true;
+  return false;
+}
+
 function shouldDisableSandbox() {
   if (process.env.BOSUN_DESKTOP_DISABLE_SANDBOX === "1") return true;
   if (process.platform !== "linux") return false;
@@ -49,6 +56,17 @@ function ensureElectronInstalled() {
 }
 
 function launch() {
+  if (!hasGuiEnvironment()) {
+    console.error(
+      [
+        "[desktop] No GUI display server detected.",
+        "Cannot launch Electron portal without DISPLAY/WAYLAND.",
+        "Run Bosun in daemon/web mode instead (for example: `bosun --daemon`).",
+      ].join(" "),
+    );
+    process.exit(1);
+  }
+
   if (!ensureElectronInstalled()) {
     process.exit(1);
   }

package/desktop/main.mjs

@@ -89,6 +89,7 @@ let shuttingDown = false;
 let uiServerStarted = false;
 let uiOrigin = null;
 let uiApi = null;
+let desktopAuthHeaderBridgeInstalled = false;
 let runtimeConfigLoaded = false;
 /** True when the app is running as a persistent background / tray resident. */
 let trayMode = false;
@@ -154,6 +155,38 @@ function isTrustedCaptureOrigin(originLike) {
   }
 }
 
+function isTrustedDesktopRequestUrl(urlLike) {
+  return isTrustedCaptureOrigin(urlLike);
+}
+
+function installDesktopAuthHeaderBridge() {
+  if (desktopAuthHeaderBridgeInstalled) return;
+  const ses = session.defaultSession;
+  if (!ses) return;
+  ses.webRequest.onBeforeSendHeaders((details, callback) => {
+    try {
+      const desktopKey = String(process.env.BOSUN_DESKTOP_API_KEY || "").trim();
+      if (!desktopKey) {
+        callback({ requestHeaders: details.requestHeaders });
+        return;
+      }
+      if (!isTrustedDesktopRequestUrl(details?.url || "")) {
+        callback({ requestHeaders: details.requestHeaders });
+        return;
+      }
+      const headers = { ...(details.requestHeaders || {}) };
+      const existingAuth = String(headers.Authorization || headers.authorization || "").trim();
+      if (!existingAuth) {
+        headers.Authorization = `Bearer ${desktopKey}`;
+      }
+      callback({ requestHeaders: headers });
+    } catch {
+      callback({ requestHeaders: details.requestHeaders });
+    }
+  });
+  desktopAuthHeaderBridgeInstalled = true;
+}
+
 function installDesktopMediaHandlers() {
   const ses = session.defaultSession;
   if (!ses) return;
@@ -583,20 +616,25 @@ async function fetchWorkspaces({ force = false } = {}) {
  * @param {string} workspaceId
  */
 async function switchWorkspace(workspaceId) {
-  if (!uiOrigin || !workspaceId) return;
+  if (!uiOrigin || !workspaceId) return { ok: false, error: "workspace unavailable" };
   const body = JSON.stringify({ workspaceId });
   const data = await uiServerRequest(`${uiOrigin}/api/workspaces/active`, {
     method: "POST",
     body,
   });
-  if (data?.ok) {
-    _cachedActiveWorkspaceId = workspaceId;
-    _workspaceCacheAt = 0; // force re-fetch next time
+  if (!data?.ok) {
+    return {
+      ok: false,
+      error: String(data?.error || "workspace switch failed"),
+    };
   }
+  _cachedActiveWorkspaceId = String(data?.activeId || workspaceId);
+  _workspaceCacheAt = 0; // force re-fetch next time
   await fetchWorkspaces({ force: true });
   Menu.setApplicationMenu(buildAppMenu());
   refreshTrayMenu();
   navigateMainWindow("/");
+  return { ok: true, activeId: _cachedActiveWorkspaceId };
 }
 
 /**
@@ -1265,14 +1303,15 @@ async function openFollowWindow(detail = {}) {
   const win = await createFollowWindow();
   const baseUiUrl = await buildUiUrl();
   const target = buildFollowWindowUrl(baseUiUrl, detail);
+  // Append a cache-buster timestamp so every Call press produces a unique URL.
+  // Without this, a second Call press with the same parameters would match
+  // followWindowLaunchSignature and skip loadURL — leaving the follow window
+  // in its previous dead state (launch params already scrubbed, voice overlay
+  // closed, useEffect([], []) already fired and won't re-run).
+  target.searchParams.set("t", String(Date.now()));
   const signature = target.toString();
-  if (!win.webContents.getURL() || followWindowLaunchSignature !== signature) {
-    followWindowLaunchSignature = signature;
-    await win.loadURL(signature);
-    anchorFollowWindow(win);
-    setWindowVisible(win);
-    return;
-  }
+  followWindowLaunchSignature = signature;
+  await win.loadURL(signature);
   anchorFollowWindow(win);
   setWindowVisible(win);
 }
@@ -1727,8 +1766,7 @@ function registerDesktopIpc() {
    */
   ipcMain.handle("bosun:workspaces:switch", async (_event, { workspaceId } = {}) => {
     if (!workspaceId) return { ok: false, error: "workspaceId required" };
-    await switchWorkspace(workspaceId);
-    return { ok: true, activeId: workspaceId };
+    return switchWorkspace(workspaceId);
   });
 }
 
@@ -1745,6 +1783,7 @@ async function bootstrap() {
       }
       callback(-3); // -3 = use Chromium default chain verification
     });
+    installDesktopAuthHeaderBridge();
     installDesktopMediaHandlers();
 
     if (process.env.ELECTRON_DISABLE_SANDBOX === "1") {

package/fleet-coordinator.mjs

@@ -36,6 +36,24 @@ import {
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
+// ── Workflow Event Bridge ────────────────────────────────────────────────────
+// Lazy-import queueWorkflowEvent from monitor.mjs — cached at module scope.
+let _queueWorkflowEvent = null;
+function emitFleetEvent(eventType, eventData = {}, opts = {}) {
+  if (!_queueWorkflowEvent) {
+    import("./monitor.mjs")
+      .then((mod) => {
+        if (typeof mod.queueWorkflowEvent === "function") {
+          _queueWorkflowEvent = mod.queueWorkflowEvent;
+          _queueWorkflowEvent(eventType, eventData, opts);
+        }
+      })
+      .catch(() => {});
+    return;
+  }
+  _queueWorkflowEvent(eventType, eventData, opts);
+}
+
 // ── Repo Fingerprinting ──────────────────────────────────────────────────────
 
 function buildGitEnv() {
@@ -434,13 +452,21 @@ export function assignTasksToWorkstations(waves, peers, taskMap = new Map()) {
     assignments.push(...waveAssignments);
   }
 
-  return {
+  const result = {
     assignments,
     totalTasks: assignments.length,
     totalPeers: peers.length,
     waveCount: waves.length,
     createdAt: new Date().toISOString(),
   };
+
+  emitFleetEvent("fleet.tasks_assigned", {
+    totalTasks: result.totalTasks,
+    totalPeers: result.totalPeers,
+    waveCount: result.waveCount,
+  }, { dedupKey: `fleet-assign-${result.createdAt}` });
+
+  return result;
 }
 
 // ── Backlog Depth Calculator ─────────────────────────────────────────────────
@@ -502,6 +528,10 @@ export function detectMaintenanceMode(status) {
 
   // Maintenance mode: nothing to do AND nothing in progress
   if (backlog === 0 && todo === 0 && running === 0 && review === 0) {
+    emitFleetEvent("fleet.maintenance_mode", {
+      isMaintenanceMode: true,
+      reason: "all tasks completed — no backlog, no active work",
+    });
     return {
       isMaintenanceMode: true,
       reason: "all tasks completed — no backlog, no active work",
@@ -722,6 +752,9 @@ export function shouldAutoGenerateTasks({
  */
 export function markAutoGenTriggered() {
   lastAutoGenTimestamp = Date.now();
+  emitFleetEvent("fleet.auto_gen_triggered", {
+    triggeredAt: new Date(lastAutoGenTimestamp).toISOString(),
+  });
 }
 
 /**

package/kanban-adapter.mjs

@@ -5823,6 +5823,23 @@ export function getKanbanBackendName() {
 // Convenience exports: direct task operations via active adapter
 // ---------------------------------------------------------------------------
 
+// ── Workflow Event Bridge (lazy-loaded from monitor.mjs) ──────────────────
+let _kanbanQueueWorkflowEvent = null;
+function emitKanbanEvent(eventType, eventData = {}) {
+  if (!_kanbanQueueWorkflowEvent) {
+    import("./monitor.mjs")
+      .then((mod) => {
+        if (typeof mod.queueWorkflowEvent === "function") {
+          _kanbanQueueWorkflowEvent = mod.queueWorkflowEvent;
+          _kanbanQueueWorkflowEvent(eventType, eventData);
+        }
+      })
+      .catch(() => {});
+    return;
+  }
+  _kanbanQueueWorkflowEvent(eventType, eventData);
+}
+
 export async function listProjects() {
   return getKanbanAdapter().listProjects();
 }
@@ -5836,7 +5853,9 @@ export async function getTask(taskId) {
 }
 
 export async function updateTaskStatus(taskId, status, options) {
-  return getKanbanAdapter().updateTaskStatus(taskId, status, options);
+  const result = await getKanbanAdapter().updateTaskStatus(taskId, status, options);
+  emitKanbanEvent("task.status_updated", { taskId, status, options });
+  return result;
 }
 
 export async function updateTask(taskId, patch) {
@@ -5851,11 +5870,19 @@ export async function updateTask(taskId, patch) {
 }
 
 export async function createTask(projectId, taskData) {
-  return getKanbanAdapter().createTask(projectId, taskData);
+  const result = await getKanbanAdapter().createTask(projectId, taskData);
+  emitKanbanEvent("task.created", {
+    projectId,
+    taskId: result?.id || null,
+    title: taskData?.title || null,
+  });
+  return result;
 }
 
 export async function deleteTask(taskId) {
-  return getKanbanAdapter().deleteTask(taskId);
+  const result = await getKanbanAdapter().deleteTask(taskId);
+  emitKanbanEvent("task.deleted", { taskId });
+  return result;
 }
 
 export async function addComment(taskId, body) {

package/library-manager.mjs

@@ -633,6 +633,7 @@ export const BUILTIN_AGENT_PROFILES = [
     hookProfile: null,
     env: {},
     tags: ["ui", "frontend", "portal", "css", "web"],
+    agentType: "task",
   },
   {
     id: "backend-agent",
@@ -647,6 +648,7 @@ export const BUILTIN_AGENT_PROFILES = [
     hookProfile: null,
     env: {},
     tags: ["api", "server", "backend", "database"],
+    agentType: "task",
   },
   {
     id: "devops-agent",
@@ -661,6 +663,7 @@ export const BUILTIN_AGENT_PROFILES = [
     hookProfile: null,
     env: {},
     tags: ["ci", "cd", "build", "deploy", "infra", "devops"],
+    agentType: "task",
   },
   {
     id: "docs-agent",
@@ -675,6 +678,7 @@ export const BUILTIN_AGENT_PROFILES = [
     hookProfile: null,
     env: {},
     tags: ["docs", "documentation", "readme", "markdown"],
+    agentType: "task",
   },
   {
     id: "test-agent",
@@ -689,6 +693,47 @@ export const BUILTIN_AGENT_PROFILES = [
     hookProfile: null,
     env: {},
     tags: ["test", "testing", "e2e", "unit", "coverage"],
+    agentType: "task",
+  },
+  {
+    id: "voice-agent-female",
+    name: "Voice Agent (Female)",
+    description: "Conversational voice specialist with concise guidance and call-friendly pacing.",
+    titlePatterns: ["\\bvoice\\b", "\\bcall\\b", "\\bmeeting\\b", "\\bassistant\\b"],
+    scopes: ["voice", "assistant"],
+    sdk: null,
+    model: null,
+    promptOverride: null,
+    skills: ["concise-voice-guidance", "conversation-memory"],
+    hookProfile: null,
+    env: {},
+    tags: ["voice", "assistant", "realtime", "female", "default", "audio-agent"],
+    agentType: "voice",
+    voiceAgent: true,
+    voicePersona: "female",
+    voiceInstructions: "You are Nova, a female voice agent. Be concise, warm, and practical. Use tools for facts and execution. Keep spoken responses short and clear.",
+    enabledTools: null,
+    enabledMcpServers: [],
+  },
+  {
+    id: "voice-agent-male",
+    name: "Voice Agent (Male)",
+    description: "Operational voice specialist focused on diagnostics and execution.",
+    titlePatterns: ["\\bvoice\\b", "\\bcall\\b", "\\bmeeting\\b", "\\bassistant\\b"],
+    scopes: ["voice", "assistant"],
+    sdk: null,
+    model: null,
+    promptOverride: null,
+    skills: ["ops-diagnostics", "task-execution"],
+    hookProfile: null,
+    env: {},
+    tags: ["voice", "assistant", "realtime", "male", "default", "audio-agent"],
+    agentType: "voice",
+    voiceAgent: true,
+    voicePersona: "male",
+    voiceInstructions: "You are Atlas, a male voice agent. Be direct and execution-oriented. Prefer actionable status updates. Use tools proactively for diagnostics.",
+    enabledTools: null,
+    enabledMcpServers: [],
   },
   {
     id: "voice-agent",
@@ -703,6 +748,9 @@ export const BUILTIN_AGENT_PROFILES = [
     hookProfile: null,
     env: {},
     tags: ["voice", "assistant", "realtime", "default"],
+    agentType: "voice",
+    voiceAgent: true,
+    voicePersona: "neutral",
     enabledTools: null,
     enabledMcpServers: [],
   },

package/maintenance.mjs

@@ -28,6 +28,26 @@ import {
 } from "./worktree-manager.mjs";
 
 const isWindows = process.platform === "win32";
+
+// ── Workflow event bridge ─────────────────────────────────────────────────
+// Lazy-loaded to avoid circular imports (monitor → maintenance → monitor).
+let _queueWorkflowEvent = null;
+function emitMaintenanceEvent(eventType, data = {}) {
+  if (_queueWorkflowEvent) {
+    _queueWorkflowEvent(eventType, data);
+    return;
+  }
+  import("./monitor.mjs")
+    .then((mod) => {
+      if (typeof mod.queueWorkflowEvent === "function") {
+        _queueWorkflowEvent = mod.queueWorkflowEvent;
+        _queueWorkflowEvent(eventType, data);
+      }
+    })
+    .catch(() => {
+      /* best-effort — monitor not available during tests */
+    });
+}
 const BRANCH_SYNC_LOG_THROTTLE_MS = Math.max(
   5_000,
   Number(process.env.BRANCH_SYNC_LOG_THROTTLE_MS || "300000") || 300000,
@@ -1318,11 +1338,7 @@ export async function runMaintenanceSweep(opts = {}) {
     /* best-effort */
   }
 
-  console.log(
-    `[maintenance] sweep complete: ${staleKilled} stale orchestrators, ${pushesReaped} stuck pushes, ${worktreesPruned} worktrees pruned, ${branchesSynced} branches synced, ${branchesDeleted} stale branches deleted`,
-  );
-
-  return {
+  const result = {
     staleKilled,
     pushesReaped,
     worktreesPruned,
@@ -1330,4 +1346,13 @@ export async function runMaintenanceSweep(opts = {}) {
     tasksArchived,
     branchesDeleted,
   };
+
+  console.log(
+    `[maintenance] sweep complete: ${staleKilled} stale orchestrators, ${pushesReaped} stuck pushes, ${worktreesPruned} worktrees pruned, ${branchesSynced} branches synced, ${branchesDeleted} stale branches deleted`,
+  );
+
+  // Emit workflow event so event-driven workflows can react to sweep results
+  emitMaintenanceEvent("maintenance.sweep_complete", result);
+
+  return result;
 }

package/monitor.mjs

@@ -12235,12 +12235,66 @@ runGuarded("startup-maintenance-sweep", () =>
 safeSetInterval("flush-error-queue", () => flushErrorQueue(), 60 * 1000);
 
 // ── Periodic maintenance: every 5 min, reap stuck pushes & prune worktrees ──
+// If a workflow replaces maintenance.mjs, skip the direct call and let
+// the workflow engine handle it via trigger.schedule evaluation.
 const maintenanceIntervalMs = 5 * 60 * 1000;
 safeSetInterval("maintenance-sweep", () => {
+  if (isWorkflowReplacingModule("maintenance.mjs")) return;
   const childPid = currentChild ? currentChild.pid : undefined;
   return runMaintenanceSweep({ repoRoot, childPid });
 }, maintenanceIntervalMs);
 
+// ── Workflow schedule trigger polling ───────────────────────────────────────
+// Check all installed workflows that use trigger.schedule and fire any whose
+// interval has elapsed. This makes schedule-based templates (workspace hygiene,
+// nightly reports, etc.) actually execute without hardcoded safeSetInterval calls.
+const scheduleCheckIntervalMs = 60 * 1000; // check every 60s
+safeSetInterval("workflow-schedule-check", async () => {
+  try {
+    const engine = await ensureWorkflowAutomationEngine();
+    if (!engine?.evaluateScheduleTriggers) return;
+
+    const triggered = engine.evaluateScheduleTriggers();
+    if (!Array.isArray(triggered) || triggered.length === 0) return;
+
+    for (const match of triggered) {
+      const workflowId = String(match?.workflowId || "").trim();
+      if (!workflowId) continue;
+      void engine
+        .execute(workflowId, {
+          _triggerSource: "schedule-poll",
+          _triggeredBy: match?.triggeredBy || null,
+          _lastRunAt: Date.now(),
+          repoRoot,
+        })
+        .then((ctx) => {
+          const runId = ctx?.id || "unknown";
+          const runStatus =
+            Array.isArray(ctx?.errors) && ctx.errors.length > 0
+              ? "failed"
+              : "completed";
+          console.log(
+            `[workflows] schedule-run ${runStatus} workflow=${workflowId} runId=${runId}`,
+          );
+        })
+        .catch((err) => {
+          console.warn(
+            `[workflows] schedule-run failed workflow=${workflowId}: ${err?.message || err}`,
+          );
+        });
+    }
+
+    if (triggered.length > 0) {
+      console.log(
+        `[workflows] schedule poll triggered ${triggered.length} workflow run(s)`,
+      );
+    }
+  } catch (err) {
+    // Schedule evaluation must not crash the monitor
+    console.warn(`[workflows] schedule-check error: ${err?.message || err}`);
+  }
+}, scheduleCheckIntervalMs);
+
 // ── Periodic merged PR check: every 10 min, move merged PRs to done ─────────
 const mergedPRCheckIntervalMs = 10 * 60 * 1000;
 safeSetInterval("merged-pr-check", () => checkMergedPRsAndUpdateTasks(), mergedPRCheckIntervalMs);
@@ -13307,4 +13361,6 @@ export {
   // Container runner re-exports
   getContainerStatus,
   isContainerEnabled,
+  // Workflow event bridge — for fleet/kanban modules to emit events
+  queueWorkflowEvent,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bosun",
-  "version": "0.37.1",
+  "version": "0.37.2",
   "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",
@@ -262,6 +262,7 @@
     "workflow-templates/planning.mjs",
     "workflow-templates/reliability.mjs",
     "workflow-templates/security.mjs",
+    "workflow-templates/task-batch.mjs",
     "workflow-templates/task-lifecycle.mjs",
     "ui/vendor/"
   ],