bosun 0.40.2 → 0.40.3

package/cli.mjs

@@ -864,6 +864,46 @@ function findAllBosunProcessPids() {
   }
 }
 
+function getRunningDaemonPids() {
+  const trackedDaemonPid = getDaemonPid();
+  if (trackedDaemonPid) return [trackedDaemonPid];
+  const ghostPids = findGhostDaemonPids();
+  return ghostPids.length > 0 ? ghostPids : [];
+}
+
+function stopBosunProcesses(
+  pids,
+  { reason = null, timeoutMs = 5000 } = {},
+) {
+  const targets = Array.from(
+    new Set(
+      (Array.isArray(pids) ? pids : []).filter(
+        (pid) => Number.isFinite(pid) && pid > 0 && pid !== process.pid,
+      ),
+    ),
+  );
+  if (targets.length === 0) return [];
+  if (reason) {
+    console.log(`  ${reason}: ${targets.join(", ")}`);
+  }
+  for (const pid of targets) {
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {
+      /* already dead */
+    }
+  }
+  const alive = waitForPidsToExit(targets, timeoutMs);
+  for (const pid of alive) {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
+      /* already dead */
+    }
+  }
+  return targets;
+}
+
 function removeKnownPidFiles(extraCacheDirs = []) {
   const pidFiles = uniqueResolvedPaths([
     ...getPidFileCandidates("bosun-daemon.pid", extraCacheDirs),
@@ -1506,78 +1546,57 @@ async function main() {
 
   // Handle --update (force update)
   if (args.includes("--update")) {
-    // Pre-stop any sibling Bosun processes to avoid Windows EBUSY locks during
-    // global npm install (especially portal/desktop/non-daemon instances).
-    const siblingPids = findAllBosunProcessPids().filter((pid) => pid !== process.pid);
-    if (siblingPids.length > 0) {
+    const runningDaemonPids = getRunningDaemonPids();
+    const shouldRestartDaemon = runningDaemonPids.length > 0;
+    const runningSiblingPids = findAllBosunProcessPids().filter(
+      (pid) => pid !== process.pid,
+    );
+    const runningNonDaemonPids = runningSiblingPids.filter(
+      (pid) => !runningDaemonPids.includes(pid),
+    );
+    if (shouldRestartDaemon) {
       console.log(
-        `  Stopping ${siblingPids.length} running bosun process(es) before update: ${siblingPids.join(", ")}`,
+        "  Note: a successful update will restart the bosun daemon automatically.",
+      );
+    }
+    if (runningNonDaemonPids.length > 0) {
+      console.log(
+        `  Note: ${runningNonDaemonPids.length} other running bosun process(es) will be stopped after a successful update.`,
       );
-      for (const pid of siblingPids) {
-        try {
-          process.kill(pid, "SIGTERM");
-        } catch {
-          /* already dead */
-        }
-      }
-      const deadline = Date.now() + 5000;
-      let alive = siblingPids.filter((pid) => isProcessAlive(pid));
-      while (alive.length > 0 && Date.now() < deadline) {
-        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 200);
-        alive = alive.filter((pid) => isProcessAlive(pid));
-      }
-      for (const pid of alive) {
-        try {
-          process.kill(pid, "SIGKILL");
-        } catch {
-          /* already dead */
-        }
-      }
     }
 
     const { forceUpdate } = await import("./infra/update-check.mjs");
     const updated = await forceUpdate(VERSION);
-    if (updated) {
-      // If a daemon or other bosun process is running, restart it so it picks
-      // up the new version automatically — no manual restart needed.
-      const daemonPid = getDaemonPid();
-      const ghostPids = findGhostDaemonPids();
-      const daemonPids = daemonPid
-        ? [daemonPid]
-        : ghostPids.length > 0
-          ? ghostPids
-          : [];
+    if (!updated) {
+      process.exit(0);
+    }
+
+    // Only stop sibling processes once npm has actually installed the update.
+    const daemonPids = getRunningDaemonPids();
+    const siblingPids = Array.from(
+      new Set([
+        ...findAllBosunProcessPids().filter((pid) => pid !== process.pid),
+        ...daemonPids,
+      ]),
+    );
+    stopBosunProcesses(siblingPids, {
+      reason: `Stopping ${siblingPids.length} running bosun process(es) to finish update`,
+      timeoutMs: 5000,
+    });
+
+    if (shouldRestartDaemon) {
       if (daemonPids.length > 0) {
-        console.log(
-          `  Daemon running (PID ${daemonPids.join(", ")}). Stopping for restart...`,
-        );
-        for (const p of daemonPids) {
-          try {
-            process.kill(p, "SIGTERM");
-          } catch {
-            /* already dead */
-          }
-        }
-        // Wait up to 4 s for graceful exit
-        const deadline = Date.now() + 4000;
-        let alive = daemonPids.filter((p) => isProcessAlive(p));
-        while (alive.length > 0 && Date.now() < deadline) {
-          Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 200);
-          alive = alive.filter((p) => isProcessAlive(p));
-        }
-        for (const p of alive) {
-          try {
-            process.kill(p, "SIGKILL");
-          } catch {
-            /* ok */
-          }
-        }
         removePidFile();
-        console.log("  Restarting daemon with updated version...");
-        startDaemon(); // spawns new daemon-child and calls process.exit(0)
-        return; // unreachable — startDaemon exits
       }
+      console.log("  Restarting daemon with updated version...");
+      startDaemon(); // spawns new daemon-child and calls process.exit(0)
+      return; // unreachable — startDaemon exits
+    }
+
+    if (siblingPids.length > 0) {
+      console.log("  Restart stopped bosun sessions manually if you still need them.");
     }
+    console.log("  Restart bosun to use the new version.\n");
     process.exit(0);
   }
 
@@ -1610,7 +1629,7 @@ async function main() {
   if (args.includes("--workspace-list") || args.includes("workspace-list")) {
     const { listWorkspaces, getActiveWorkspace } = await import("./workspace/workspace-manager.mjs");
     const configDirArg = getArgValue("--config-dir");
-    const configDir = configDirArg || process.env.BOSUN_DIR || resolve(os.homedir(), "bosun");
+    const configDir = configDirArg || process.env.BOSUN_DIR || resolveConfigDirForCli();
     const workspaces = listWorkspaces(configDir);
     const active = getActiveWorkspace(configDir);
     if (workspaces.length === 0) {
@@ -1634,7 +1653,7 @@ async function main() {
   if (args.includes("--workspace-add")) {
     const { createWorkspace } = await import("./workspace/workspace-manager.mjs");
     const configDirArg = getArgValue("--config-dir");
-    const configDir = configDirArg || process.env.BOSUN_DIR || resolve(os.homedir(), "bosun");
+    const configDir = configDirArg || process.env.BOSUN_DIR || resolveConfigDirForCli();
     const name = getArgValue("--workspace-add");
     if (!name) {
       console.error("  Error: workspace name is required. Usage: bosun --workspace-add <name>");
@@ -1653,7 +1672,7 @@ async function main() {
   if (args.includes("--workspace-switch")) {
     const { setActiveWorkspace, getWorkspace } = await import("./workspace/workspace-manager.mjs");
     const configDirArg = getArgValue("--config-dir");
-    const configDir = configDirArg || process.env.BOSUN_DIR || resolve(os.homedir(), "bosun");
+    const configDir = configDirArg || process.env.BOSUN_DIR || resolveConfigDirForCli();
     const wsId = getArgValue("--workspace-switch");
     if (!wsId) {
       console.error("  Error: workspace ID required. Usage: bosun --workspace-switch <id>");
@@ -1673,7 +1692,7 @@ async function main() {
   if (args.includes("--workspace-add-repo")) {
     const { addRepoToWorkspace, getActiveWorkspace, listWorkspaces } = await import("./workspace/workspace-manager.mjs");
     const configDirArg = getArgValue("--config-dir");
-    const configDir = configDirArg || process.env.BOSUN_DIR || resolve(os.homedir(), "bosun");
+    const configDir = configDirArg || process.env.BOSUN_DIR || resolveConfigDirForCli();
     const active = getActiveWorkspace(configDir);
     if (!active) {
       console.error("  No active workspace. Create one first: bosun --workspace-add <name>");
@@ -1702,7 +1721,7 @@ async function main() {
     const { runWorkspaceHealthCheck, formatWorkspaceHealthReport } =
       await import("./config/config-doctor.mjs");
     const configDirArg = getArgValue("--config-dir");
-    const configDir = configDirArg || process.env.BOSUN_DIR || resolve(os.homedir(), "bosun");
+    const configDir = configDirArg || process.env.BOSUN_DIR || resolveConfigDirForCli();
     const result = runWorkspaceHealthCheck({ configDir });
     console.log(formatWorkspaceHealthReport(result));
     process.exit(result.ok ? 0 : 1);

package/infra/monitor.mjs

@@ -201,6 +201,7 @@ import { fixGitConfigCorruption } from "../workspace/worktree-manager.mjs";
 // ── Task management subsystem imports ──────────────────────────────────────
 import {
   configureTaskStore,
+  canStartTask,
   getTask as getInternalTask,
   getTasksByStatus as getInternalTasksByStatus,
   updateTask as updateInternalTask,
@@ -548,6 +549,9 @@ async function ensureWorkflowAutomationEngine() {
       const services = {
         telegram: telegramService,
         kanban: kanbanService,
+        taskStore: {
+          canStartTask,
+        },
         agentPool: agentPoolService,
         meeting: meetingService,
         prompts: Object.keys(promptServices).length > 0 ? promptServices : null,
@@ -13509,9 +13513,10 @@ safeSetInterval("flush-error-queue", () => flushErrorQueue(), 60 * 1000);
 // Legacy periodic maintenance sweep removed (workflow-only control).
 
 // ── 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.
+// Check all installed polling workflows (trigger.schedule, trigger.scheduled_once,
+// trigger.task_available, trigger.task_low) and fire any whose interval has elapsed.
+// This keeps scheduled and task-poll lifecycle templates executing without hardcoded
+// per-workflow timers.
 const scheduleCheckIntervalMs = 60 * 1000; // check every 60s
 safeSetInterval("workflow-schedule-check", async () => {
   try {

package/infra/update-check.mjs

@@ -463,9 +463,7 @@ export async function forceUpdate(currentVersion) {
       stdio: "inherit",
       timeout: 120000,
     });
-    console.log(
-      `\n  :check: Updated to v${latest}. Restart bosun to use the new version.\n`,
-    );
+    console.log(`\n  :check: Updated to v${latest}.\n`);
     return true; // update was installed
   } catch (err) {
     console.error(`\n  :close: Update failed: ${err.message}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bosun",
-  "version": "0.40.2",
+  "version": "0.40.3",
   "description": "Bosun Autonomous Engineering — manages AI agent executors with failover, extremely powerful workflow builder, and a massive amount of included default workflow templates for autonomous engineering, 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/server/ui-server.mjs

@@ -188,6 +188,12 @@ const TASK_STORE_DEPENDENCY_EXPORTS = {
   update: ["updateTask"],
 };
 const TASK_STORE_ASSIGN_SPRINT_EXPORTS = ["assignTaskToSprint", "setTaskSprint"];
+const TASK_STORE_EPIC_DEPENDENCY_EXPORTS = Object.freeze({
+  list: ["getEpicDependencies", "listEpicDependencies"],
+  set: ["setEpicDependencies", "updateEpicDependencies"],
+  add: ["addEpicDependency"],
+  remove: ["removeEpicDependency"],
+});
 let taskStoreApi = null;
 let taskStoreApiPromise = null;
 let didLogTaskStoreLoadFailure = false;
@@ -6154,6 +6160,68 @@ async function setTaskDependenciesForApi({
   };
 }
 
+async function listEpicDependenciesForApi() {
+  const listed = await callTaskStoreFunction(TASK_STORE_EPIC_DEPENDENCY_EXPORTS.list, []);
+  if (listed.found && Array.isArray(listed.value)) {
+    return {
+      ok: true,
+      source: `task-store.${listed.found}`,
+      data: listed.value
+        .map((entry) => ({
+          epicId: String(entry?.epicId || entry?.id || "").trim(),
+          dependencies: normalizeTaskIdList(entry?.dependencies || entry?.dependsOn || []),
+        }))
+        .filter((entry) => entry.epicId),
+    };
+  }
+  return { ok: false, source: null, data: [] };
+}
+
+async function setEpicDependenciesForApi({ epicId, dependencies }) {
+  const normalizedEpicId = String(epicId || "").trim();
+  if (!normalizedEpicId) return { ok: false, status: 400, error: "epicId required" };
+  const normalizedDependencies = normalizeTaskIdList(dependencies, { exclude: normalizedEpicId });
+
+  const setResult = await callTaskStoreFunction(
+    TASK_STORE_EPIC_DEPENDENCY_EXPORTS.set,
+    [normalizedEpicId, normalizedDependencies],
+  );
+  if (setResult.found) {
+    return {
+      ok: true,
+      source: `task-store.${setResult.found}`,
+      data: {
+        epicId: normalizedEpicId,
+        dependencies: normalizeTaskIdList(setResult.value?.dependencies || normalizedDependencies),
+      },
+    };
+  }
+
+  const listed = await listEpicDependenciesForApi();
+  const current = listed.ok
+    ? normalizeTaskIdList((listed.data.find((entry) => entry.epicId === normalizedEpicId) || {}).dependencies || [])
+    : [];
+
+  const toRemove = current.filter((entry) => !normalizedDependencies.includes(entry));
+  const toAdd = normalizedDependencies.filter((entry) => !current.includes(entry));
+
+  for (const dep of toRemove) {
+    await callTaskStoreFunction(TASK_STORE_EPIC_DEPENDENCY_EXPORTS.remove, [normalizedEpicId, dep]);
+  }
+  for (const dep of toAdd) {
+    await callTaskStoreFunction(TASK_STORE_EPIC_DEPENDENCY_EXPORTS.add, [normalizedEpicId, dep]);
+  }
+
+  const refreshed = await listEpicDependenciesForApi();
+  const row = refreshed.ok
+    ? refreshed.data.find((entry) => entry.epicId === normalizedEpicId)
+    : null;
+  return {
+    ok: true,
+    source: refreshed.source || "task-store.fallback",
+    data: { epicId: normalizedEpicId, dependencies: normalizeTaskIdList(row?.dependencies || []) },
+  };
+}
 async function getTaskCommentsForApi(taskId, adapter = null) {
   const storeComments = await callTaskStoreFunction(TASK_STORE_COMMENT_EXPORTS, [taskId]);
   if (storeComments.found && Array.isArray(storeComments.value)) {
@@ -9053,6 +9121,55 @@ async function handleApi(req, res, url) {
     }
     return;
   }
+  if (path === "/api/tasks/epic-dependencies" && req.method === "GET") {
+    try {
+      const listed = await listEpicDependenciesForApi();
+      if (!listed.ok) {
+        jsonResponse(res, 501, { ok: false, error: "Epic dependency APIs are unavailable." });
+        return;
+      }
+      jsonResponse(res, 200, { ok: true, source: listed.source, data: listed.data });
+    } catch (err) {
+      jsonResponse(res, 500, { ok: false, error: err.message });
+    }
+    return;
+  }
+
+  if (path === "/api/tasks/epic-dependencies" && req.method === "PUT") {
+    try {
+      const body = await readJsonBody(req);
+      const epicId = String(body?.epicId || body?.id || "").trim();
+      const dependencies = Array.isArray(body?.dependencies)
+        ? body.dependencies
+        : Array.isArray(body?.dependsOn)
+          ? body.dependsOn
+          : [];
+      if (!epicId) {
+        jsonResponse(res, 400, { ok: false, error: "epicId required" });
+        return;
+      }
+      const updated = await setEpicDependenciesForApi({ epicId, dependencies });
+      if (!updated.ok) {
+        jsonResponse(res, updated.status || 400, { ok: false, error: updated.error || "Failed to update epic dependencies" });
+        return;
+      }
+      const globalDag = await getGlobalDagData();
+      jsonResponse(res, 200, {
+        ok: true,
+        source: updated.source,
+        data: updated.data,
+        dag: globalDag?.data || null,
+      });
+      broadcastUiEvent(["tasks", "overview"], "invalidate", {
+        reason: "epic-dependencies-updated",
+        epicId,
+      });
+    } catch (err) {
+      jsonResponse(res, 500, { ok: false, error: err.message });
+    }
+    return;
+  }
+
   if (path === "/api/tasks/start") {
     try {
       const body = await readJsonBody(req);