bosun 0.40.2 → 0.40.4

package/README.md

@@ -181,6 +181,10 @@ npm run hooks:install
 - `docs/` and `_docs/` — product docs, deep technical references, and long-form source material
 - `tools/` and `tests/` — build utilities, release checks, and regression coverage
 
+If you find this project useful or would like to stay up to date with new releases, a star is appreciated!
+
+[![Star History Chart](https://api.star-history.com/image?repos=VirtEngine/Bosun&type=date&legend=top-left)](https://www.star-history.com/?repos=VirtEngine%2FBosun&type=date&legend=top-left)
+
 ---
 
 ## License

package/cli.mjs

@@ -16,7 +16,7 @@
  *   3. Configuration loading from config.mjs
  */
 
-import { resolve, dirname } from "node:path";
+import { isAbsolute, resolve, dirname } from "node:path";
 import {
   existsSync,
   readFileSync,
@@ -237,6 +237,9 @@ function isWslInteropRuntime() {
 }
 
 function resolveConfigDirForCli() {
+  const configDirArg = getArgValue("--config-dir");
+  if (configDirArg) return resolve(configDirArg);
+  if (process.env.BOSUN_HOME) return resolve(process.env.BOSUN_HOME);
   if (process.env.BOSUN_DIR) return resolve(process.env.BOSUN_DIR);
   const preferWindowsDirs =
     process.platform === "win32" && !isWslInteropRuntime();
@@ -612,6 +615,40 @@ function removePidFile() {
   }
 }
 
+function absolutizeDaemonArgPath(value) {
+  const raw = String(value || "").trim();
+  if (!raw) return raw;
+  return isAbsolute(raw) ? raw : resolve(process.cwd(), raw);
+}
+
+function normalizeDetachedDaemonArgs(rawArgs = []) {
+  const normalized = Array.isArray(rawArgs) ? [...rawArgs] : [];
+  const pathFlags = new Set(["--config-dir", "--repo-root", "--log-dir"]);
+  for (let i = 0; i < normalized.length; i += 1) {
+    const arg = String(normalized[i] || "").trim();
+    if (!arg.startsWith("--")) continue;
+
+    const eq = arg.indexOf("=");
+    if (eq > 0) {
+      const flag = arg.slice(0, eq);
+      const value = arg.slice(eq + 1);
+      if (pathFlags.has(flag)) {
+        normalized[i] = flag + "=" + absolutizeDaemonArgPath(value);
+      }
+      continue;
+    }
+
+    if (pathFlags.has(arg) && i + 1 < normalized.length) {
+      const value = String(normalized[i + 1] || "").trim();
+      if (value && !value.startsWith("--")) {
+        normalized[i + 1] = absolutizeDaemonArgPath(value);
+        i += 1;
+      }
+    }
+  }
+  return normalized;
+}
+
 function startDaemon() {
   const existing = getDaemonPid();
   if (existing) {
@@ -656,7 +693,9 @@ function startDaemon() {
       ...runAsNode,
       "--max-old-space-size=4096",
       fileURLToPath(new URL("./cli.mjs", import.meta.url)),
-      ...process.argv.slice(2).filter((a) => a !== "--daemon" && a !== "-d"),
+      ...normalizeDetachedDaemonArgs(
+        process.argv.slice(2).filter((a) => a !== "--daemon" && a !== "-d"),
+      ),
       "--daemon-child",
     ],
     {
@@ -864,6 +903,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 +1585,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 +1668,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 +1692,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 +1711,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 +1731,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 +1760,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/config/config.mjs

@@ -1292,6 +1292,13 @@ export function loadConfig(argv = process.argv, options = {}) {
   const normalizedRepoRootOverride = repoRootOverride
     ? resolve(repoRootOverride)
     : "";
+  const explicitConfigDirRaw =
+    cli["config-dir"] || process.env.BOSUN_HOME || process.env.BOSUN_DIR || "";
+  const hasExplicitConfigDir = String(explicitConfigDirRaw || "").trim() !== "";
+  const allowRepoEnvWithExplicitConfig = isEnvEnabled(
+    process.env.BOSUN_LOAD_REPO_ENV_WITH_EXPLICIT_CONFIG,
+    false,
+  );
   let detectedRepoRoot = "";
   const getFallbackRepoRoot = () => {
     if (normalizedRepoRootOverride) return normalizedRepoRootOverride;
@@ -1301,8 +1308,7 @@ export function loadConfig(argv = process.argv, options = {}) {
 
   // Determine config directory (where bosun stores its config)
   const configDir =
-    cli["config-dir"] ||
-    process.env.BOSUN_DIR ||
+    explicitConfigDirRaw ||
     resolveConfigDir(normalizedRepoRootOverride);
 
   const configFile = loadConfigFile(configDir);
@@ -1345,16 +1351,20 @@ export function loadConfig(argv = process.argv, options = {}) {
     repositories[0] ||
     null;
 
-  // Resolve repoRoot with workspace-awareness:
-  // When workspaces configured and the workspace repo has .git, prefer it
-  // over REPO_ROOT (env); REPO_ROOT becomes "developer root" for config only.
+  // Resolve repo root. Explicit repo-root/REPO_ROOT must win over workspace clones
+  // so source-based runs can pin execution to the developer working tree.
+  const explicitRepoRoot = normalizedRepoRootOverride ||
+    (process.env.REPO_ROOT ? resolve(process.env.REPO_ROOT) : "");
   const selectedRepoPath = selectedRepository?.path || "";
   const selectedRepoHasGit = selectedRepoPath && existsSync(resolve(selectedRepoPath, ".git"));
   let repoRoot =
-    (selectedRepoHasGit ? selectedRepoPath : null) || getFallbackRepoRoot();
+    explicitRepoRoot ||
+    (selectedRepoHasGit ? selectedRepoPath : null) ||
+    getFallbackRepoRoot();
 
-  // Resolve agent execution root (workspace-aware, separate from developer root)
-  const agentRepoRoot = resolveAgentRepoRoot();
+  // Resolve agent execution root. Keep workspace-aware behavior by default,
+  // but honor explicit repo-root/REPO_ROOT overrides.
+  const agentRepoRoot = explicitRepoRoot || resolveAgentRepoRoot();
 
   // Load .env from config dir — Bosun's .env is the primary source of truth
   // for Bosun-specific configuration, so it should override any stale shell
@@ -1363,8 +1373,14 @@ export function loadConfig(argv = process.argv, options = {}) {
   const envOverride = reloadEnv || !isEnvEnabled(process.env.BOSUN_ENV_NO_OVERRIDE, false);
   loadDotEnv(configDir, { override: envOverride });
 
-  // Also load .env from repo root if different
-  if (resolve(repoRoot) !== resolve(configDir)) {
+  const shouldLoadRepoEnv =
+    resolve(repoRoot) !== resolve(configDir) &&
+    (!hasExplicitConfigDir || allowRepoEnvWithExplicitConfig);
+
+  // Also load .env from repo root if different.
+  // When config-dir/BOSUN_HOME is explicit, keep that environment isolated
+  // from the repo root unless explicitly re-enabled.
+  if (shouldLoadRepoEnv) {
     loadDotEnv(repoRoot, { override: envOverride });
   }
 
@@ -1419,14 +1435,17 @@ export function loadConfig(argv = process.argv, options = {}) {
     repoRoot = (selHasGit ? selPath : null) || getFallbackRepoRoot();
   }
 
-  if (resolve(repoRoot) !== resolve(initialRepoRoot)) {
+  if (
+    shouldLoadRepoEnv &&
+    resolve(repoRoot) !== resolve(initialRepoRoot)
+  ) {
     loadDotEnv(repoRoot, { override: envOverride });
   }
 
-  const envPaths = [
-    resolve(configDir, ".env"),
-    resolve(repoRoot, ".env"),
-  ].filter((p, i, arr) => arr.indexOf(p) === i);
+  const envPaths = [resolve(configDir, ".env")];
+  if (shouldLoadRepoEnv) {
+    envPaths.push(resolve(repoRoot, ".env"));
+  }
   const kanbanSource = resolveKanbanBackendSource({
     envPaths,
     configFilePath: configFile.path,
@@ -2396,3 +2415,4 @@ export {
   resolveAgentRepoRoot,
 };
 export default loadConfig;
+

package/desktop/package.json

@@ -22,8 +22,8 @@
     "electron-updater": "^6.3.9"
   },
   "devDependencies": {
-    "electron": "^30.0.0",
-    "electron-builder": "^24.13.3"
+    "electron": "^35.7.5",
+    "electron-builder": "^26.8.1"
   },
   "build": {
     "appId": "com.virtengine.bosun",

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,
@@ -1194,6 +1198,8 @@ const isMonitorTestRuntime =
       .trim()
       .toLowerCase(),
   ) || String(process.env.NODE_ENV || "").trim().toLowerCase() === "test";
+// Shared schedule poll hook used across startup/timer sections.
+let pollWorkflowSchedulesOnce = async () => {};
 
 // ── Load unified configuration ──────────────────────────────────────────────
 let config;
@@ -4901,9 +4907,13 @@ function getConfiguredKanbanProjectId(backend) {
   );
 }
 
+function hasUnresolvedTemplateToken(value) {
+  return /{{[^{}]+}}/.test(String(value || ""));
+}
+
 function resolveTaskIdForBackend(taskId, backend) {
   const rawId = String(taskId || "").trim();
-  if (!rawId) return null;
+  if (!rawId || hasUnresolvedTemplateToken(rawId)) return null;
   if (backend !== "github") return rawId;
   const directMatch = parseGitHubIssueNumber(rawId);
   if (directMatch) return directMatch;
@@ -13509,14 +13519,19 @@ 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 () => {
+pollWorkflowSchedulesOnce = async function pollWorkflowSchedulesOnce(
+  triggerSource = "schedule-poll",
+  opts = {},
+) {
   try {
     const engine = await ensureWorkflowAutomationEngine();
     if (!engine?.evaluateScheduleTriggers) return;
+    const includeTaskPoll = opts?.includeTaskPoll !== false;
 
     const triggered = engine.evaluateScheduleTriggers();
     if (!Array.isArray(triggered) || triggered.length === 0) return;
@@ -13524,9 +13539,18 @@ safeSetInterval("workflow-schedule-check", async () => {
     for (const match of triggered) {
       const workflowId = String(match?.workflowId || "").trim();
       if (!workflowId) continue;
+      if (!includeTaskPoll) {
+        const workflow = typeof engine.get === "function" ? engine.get(workflowId) : null;
+        const triggerNode = Array.isArray(workflow?.nodes)
+          ? workflow.nodes.find((node) => node?.id === match?.triggeredBy)
+          : null;
+        if (triggerNode?.type === "trigger.task_available" || triggerNode?.type === "trigger.task_low") {
+          continue;
+        }
+      }
       void engine
         .execute(workflowId, {
-          _triggerSource: "schedule-poll",
+          _triggerSource: triggerSource,
           _triggeredBy: match?.triggeredBy || null,
           _lastRunAt: Date.now(),
           repoRoot,
@@ -13554,9 +13578,12 @@ safeSetInterval("workflow-schedule-check", async () => {
       );
     }
   } catch (err) {
-    // Schedule evaluation must not crash the monitor
     console.warn(`[workflows] schedule-check error: ${err?.message || err}`);
   }
+};
+
+safeSetInterval("workflow-schedule-check", async () => {
+  await pollWorkflowSchedulesOnce();
 }, scheduleCheckIntervalMs);
 
 // Legacy merged PR check removed (workflow-only control).
@@ -13653,12 +13680,15 @@ if (telegramWeeklyReportEnabled) {
 }
 
 // ── Self-updating: poll npm every 10 min, auto-install + restart ────────────
+const isDaemonChildForAutoUpdate =
+  process.argv.includes("--daemon-child") || process.env.BOSUN_DAEMON === "1";
 startAutoUpdateLoop({
   onRestart: (reason) => restartSelf(reason),
   onNotify: (msg) =>
     // Priority 1 (critical) bypasses the live digest so the user gets a
     // direct push notification for update-detected and restarting events.
     sendTelegramMessage(msg, { priority: 1, skipDedup: true }).catch(() => {}),
+  trackParent: !isDaemonChildForAutoUpdate,
 });
 
 startWatcher();
@@ -13822,13 +13852,16 @@ let errorDetector = null;
 let agentSupervisor = null;
 
 if (!isMonitorTestRuntime) {
-if (workflowAutomationEnabled) {
-  await ensureWorkflowAutomationEngine().catch(() => {});
-} else {
-  console.log(
-    "[workflows] automation disabled (set WORKFLOW_AUTOMATION_ENABLED=true to enable event-driven workflow triggers)",
-  );
-}
+  if (workflowAutomationEnabled) {
+    await ensureWorkflowAutomationEngine().catch(() => {});
+    void pollWorkflowSchedulesOnce("startup", { includeTaskPoll: false }).catch((err) => {
+      console.warn(`[workflows] startup poll error: ${err?.message || err}`);
+    });
+  } else {
+    console.log(
+      "[workflows] automation disabled (set WORKFLOW_AUTOMATION_ENABLED=true to enable event-driven workflow triggers)",
+    );
+  }
 // ── Task Management Subsystem Initialization ────────────────────────────────
 try {
   mkdirSync(monitorStateCacheDir, { recursive: true });
@@ -14065,6 +14098,11 @@ if (isExecutorDisabled()) {
     };
     internalTaskExecutor = getTaskExecutor(execOpts);
     internalTaskExecutor.start();
+    if (workflowOwnsTaskExecutorLifecycle) {
+      void pollWorkflowSchedulesOnce("startup").catch((err) => {
+        console.warn(`[workflows] startup poll error: ${err?.message || err}`);
+      });
+    }
 
     // Write executor slots to status file every 30s for Telegram /tasks
     startStatusFileWriter(30000);
@@ -14629,5 +14667,3 @@ export {
   // Workflow event bridge — for fleet/kanban modules to emit events
   queueWorkflowEvent,
 };
-
-

package/infra/session-tracker.mjs

@@ -551,6 +551,7 @@ export class SessionTracker {
         status: s.status,
         workspaceId: String(s?.metadata?.workspaceId || "").trim() || null,
         workspaceDir: String(s?.metadata?.workspaceDir || "").trim() || null,
+        branch: String(s?.metadata?.branch || "").trim() || null,
         turnCount: s.turnCount || 0,
         createdAt: s.createdAt || new Date(s.startedAt).toISOString(),
         lastActiveAt: s.lastActiveAt || new Date(s.lastActivityAt).toISOString(),

package/infra/sync-engine.mjs

@@ -1018,8 +1018,13 @@ export class SyncEngine {
   }
 
   async #createExternalTask(task, baseBranchCandidate = null) {
+    const normalizedTitle = String(task?.title || "").trim();
+    if (!normalizedTitle) {
+      throw new Error(`cannot create external task for ${task?.id || "<unknown>"}: missing title`);
+    }
+
     const payload = {
-      title: task.title || "Untitled task",
+      title: normalizedTitle,
       description: task.description || "",
       status: "todo",
       assignee: task.assignee || null,

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}`);
@@ -556,6 +554,7 @@ function isSuppressedStreamNoiseError(err) {
  * @param {function} [opts.onNotify]  - Called with message string for Telegram/log
  * @param {number}   [opts.intervalMs] - Poll interval (default: 10 min)
  * @param {number}   [opts.parentPid]  - Parent process PID to monitor (default: process.ppid)
+ * @param {boolean}  [opts.trackParent] - Monitor parent liveness (default: true)
  */
 export function startAutoUpdateLoop(opts = {}) {
   if (process.env.BOSUN_SKIP_AUTO_UPDATE === "1") {
@@ -596,14 +595,21 @@ export function startAutoUpdateLoop(opts = {}) {
 
   // Register cleanup handlers to prevent zombie processes
   registerCleanupHandlers();
-
-  // Track parent process if provided
-  if (opts.parentPid) {
-    parentPid = opts.parentPid;
-    console.log(`[auto-update] Monitoring parent process PID ${parentPid}`);
+  const trackParent = opts.trackParent !== false;
+
+  // Track parent process when enabled. Detached daemon-child monitor sessions
+  // should opt out so they do not self-terminate when the launcher exits.
+  if (trackParent) {
+    if (opts.parentPid) {
+      parentPid = opts.parentPid;
+      console.log(`[auto-update] Monitoring parent process PID ${parentPid}`);
+    } else {
+      parentPid = process.ppid; // Track parent by default
+      console.log(`[auto-update] Monitoring parent process PID ${parentPid}`);
+    }
   } else {
-    parentPid = process.ppid; // Track parent by default
-    console.log(`[auto-update] Monitoring parent process PID ${parentPid}`);
+    parentPid = null;
+    console.log("[auto-update] Parent process monitoring disabled");
   }
 
   console.log(