bosun 0.34.2 → 0.34.4

package/monitor.mjs

@@ -98,6 +98,7 @@ import {
   resetMergeStrategyDedup,
 } from "./merge-strategy.mjs";
 import { assessTask, quickAssess } from "./task-assessment.mjs";
+import { getBosunCoAuthorTrailer } from "./git-commit-helpers.mjs";
 import {
   normalizeDedupKey,
   stripAnsi,
@@ -253,6 +254,60 @@ function getAgentAlertsPath() {
   return resolve(repoRoot, ".cache", "agent-work-logs", "agent-alerts.jsonl");
 }
 
+function getAgentAlertsStatePath() {
+  return resolve(
+    repoRoot,
+    ".cache",
+    "agent-work-logs",
+    "agent-alert-tail-state.json",
+  );
+}
+
+function loadAgentAlertsState() {
+  const statePath = getAgentAlertsStatePath();
+  try {
+    if (!existsSync(statePath)) return;
+    const raw = readFileSync(statePath, "utf8");
+    const parsed = JSON.parse(raw);
+    const offset = Number(parsed?.offset || 0);
+    if (Number.isFinite(offset) && offset >= 0) {
+      agentAlertsOffset = offset;
+    }
+    const dedupEntries = Array.isArray(parsed?.dedupEntries)
+      ? parsed.dedupEntries
+      : [];
+    agentAlertsDedup.clear();
+    for (const entry of dedupEntries) {
+      if (!entry || typeof entry !== "object") continue;
+      const key = String(entry.key || "").trim();
+      const ts = Number(entry.ts || 0);
+      if (!key || !Number.isFinite(ts) || ts <= 0) continue;
+      agentAlertsDedup.set(key, ts);
+    }
+  } catch (err) {
+    console.warn(`[monitor] failed loading alert tail state: ${err.message}`);
+  }
+}
+
+function saveAgentAlertsState() {
+  const statePath = getAgentAlertsStatePath();
+  try {
+    mkdirSync(dirname(statePath), { recursive: true });
+    const dedupEntries = [...agentAlertsDedup.entries()]
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, 200)
+      .map(([key, ts]) => ({ key, ts }));
+    const payload = {
+      offset: agentAlertsOffset,
+      dedupEntries,
+      updatedAt: new Date().toISOString(),
+    };
+    writeFileSync(statePath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+  } catch (err) {
+    console.warn(`[monitor] failed saving alert tail state: ${err.message}`);
+  }
+}
+
 function rememberAlert(key) {
   agentAlertsDedup.set(key, Date.now());
   if (agentAlertsDedup.size > 200) {
@@ -590,6 +645,9 @@ async function pollAgentAlerts() {
   } catch {
     return;
   }
+  if (data.length < agentAlertsOffset) {
+    agentAlertsOffset = 0;
+  }
   if (!data || data.length <= agentAlertsOffset) return;
   const chunk = data.slice(agentAlertsOffset);
   agentAlertsOffset = data.length;
@@ -614,11 +672,14 @@ async function pollAgentAlerts() {
       telegramChatId &&
       process.env.AGENT_ALERTS_NOTIFY === "true"
     ) {
-      void sendTelegramMessage(formatAgentAlert(alert), {
-        dedupKey: `agent-alert:${alert.type || "alert"}:${alert.attempt_id || "unknown"}`,
-      }).catch(() => {});
+      runDetached("agent-alerts:telegram", () =>
+        sendTelegramMessage(formatAgentAlert(alert), {
+          dedupKey: `agent-alert:${alert.type || "alert"}:${alert.attempt_id || "unknown"}`,
+        }),
+      );
     }
   }
+  saveAgentAlertsState();
 }
 
 function startAgentWorkAnalyzer() {
@@ -648,11 +709,12 @@ function stopAgentWorkAnalyzer() {
 
 function startAgentAlertTailer() {
   if (agentAlertsTimer) return;
+  loadAgentAlertsState();
   agentAlertsTimer = setInterval(() => {
-    void pollAgentAlerts();
+    runDetached("agent-alerts:poll", pollAgentAlerts);
   }, AGENT_ALERT_POLL_MS);
   agentAlertsTimer.unref?.();
-  void pollAgentAlerts();
+  runDetached("agent-alerts:poll", pollAgentAlerts);
 }
 
 function stopAgentAlertTailer() {
@@ -2085,7 +2147,9 @@ async function handleMonitorFailure(reason, err) {
     // Ensure we retry after safe-mode window if still running.
     if (!shuttingDown) {
       setTimeout(() => {
-        if (!shuttingDown) void startProcess();
+        if (!shuttingDown) {
+          runDetached("start-process:hard-cap-retry", startProcess);
+        }
       }, pauseMs + 1000);
     }
     return;
@@ -2192,6 +2256,21 @@ function runGuarded(reason, fn) {
     reportGuardedFailure(reason, err);
   }
 }
+function runDetached(label, promiseOrFn) {
+  const logFailure = (err) => {
+    const message = formatMonitorError(err);
+    console.warn(`[monitor] detached ${label} failed: ${message}`);
+  };
+  try {
+    const result =
+      typeof promiseOrFn === "function" ? promiseOrFn() : promiseOrFn;
+    if (result && typeof result.then === "function") {
+      result.catch((err) => logFailure(err));
+    }
+  } catch (err) {
+    logFailure(err);
+  }
+}
 
 function safeSetInterval(reason, fn, ms) {
   return setInterval(() => runGuarded(`interval:${reason}`, fn), ms);
@@ -2554,15 +2633,19 @@ function notifyVkError(line) {
   ]
     .filter(Boolean)
     .join("\n");
-  void sendTelegramMessage(message, { parseMode: "HTML" });
-  triggerVibeKanbanRecovery(line);
+  runDetached("vk-error:telegram", () =>
+    sendTelegramMessage(message, { parseMode: "HTML" }),
+  );
+  runDetached("vk-recovery:notify", () => triggerVibeKanbanRecovery(line));
 }
 
 function notifyCodexTrigger(context) {
   if (!telegramToken || !telegramChatId) {
     return;
   }
-  void sendTelegramMessage(`Codex triggered: ${context}`);
+  runDetached("codex-trigger:telegram", () =>
+    sendTelegramMessage(`Codex triggered: ${context}`),
+  );
 }
 
 async function runCodexRecovery(reason) {
@@ -2796,7 +2879,10 @@ function scheduleVibeKanbanRestart() {
   console.log(
     `[monitor] restarting vibe-kanban in ${delay}ms (attempt ${vkRestartCount}/${vkMaxRestarts})`,
   );
-  setTimeout(() => void startVibeKanbanProcess(), delay);
+  setTimeout(
+    () => runDetached("vk-restart:scheduled", startVibeKanbanProcess),
+    delay,
+  );
 }
 
 async function canConnectTcp(host, port, timeoutMs = 1200) {
@@ -2894,7 +2980,7 @@ function restartVibeKanbanProcess() {
       /* best effort */
     }
   } else {
-    void startVibeKanbanProcess();
+    runDetached("vk-restart:manual", startVibeKanbanProcess);
   }
 }
 
@@ -3109,7 +3195,9 @@ function ensureVkLogStream() {
   }
 
   // Discover any active sessions immediately and keep polling for new sessions
-  void refreshVkSessionStreams("startup");
+  runDetached("vk-session-discovery:startup", () =>
+    refreshVkSessionStreams("startup"),
+  );
   ensureVkSessionDiscoveryLoop();
 }
 
@@ -3117,7 +3205,9 @@ function ensureVkSessionDiscoveryLoop() {
   if (vkSessionDiscoveryTimer) return;
   if (!Number.isFinite(vkEnsureIntervalMs) || vkEnsureIntervalMs <= 0) return;
   vkSessionDiscoveryTimer = setInterval(() => {
-    void refreshVkSessionStreams("periodic");
+    runDetached("vk-session-discovery:periodic", () =>
+      refreshVkSessionStreams("periodic"),
+    );
   }, vkEnsureIntervalMs);
 }
 
@@ -3299,7 +3389,9 @@ async function triggerVibeKanbanRecovery(reason) {
     const notice = codexEnabled
       ? `Codex recovery triggered: vibe-kanban unreachable. Attempting restart. (${link})`
       : `Vibe-kanban recovery triggered (Codex disabled). Attempting restart. (${link})`;
-    void sendTelegramMessage(notice, { parseMode: "HTML" });
+    runDetached("vk-recovery-notify", () =>
+      sendTelegramMessage(notice, { parseMode: "HTML" }),
+    );
   }
   await runCodexRecovery(reason || "vibe-kanban unreachable");
   restartVibeKanbanProcess();
@@ -3409,8 +3501,10 @@ async function fetchVk(path, opts = {}) {
       if (shouldLogVkWarning("network-error")) {
         console.warn(`[monitor] fetchVk ${method} ${path} error: ${msg}`);
       }
-      void triggerVibeKanbanRecovery(
-        `fetchVk ${method} ${path} network error: ${msg}`,
+      runDetached("vk-recovery:network", () =>
+        triggerVibeKanbanRecovery(
+          `fetchVk ${method} ${path} network error: ${msg}`,
+        ),
       );
       noteVkErrorBurst("network-error");
     }
@@ -3428,8 +3522,10 @@ async function fetchVk(path, opts = {}) {
         `[monitor] fetchVk ${method} ${path} error: invalid response object (res=${!!res}, res.ok=${res?.ok})`,
       );
     }
-    void triggerVibeKanbanRecovery(
-      `fetchVk ${method} ${path} invalid response object`,
+    runDetached("vk-recovery:invalid-response", () =>
+      triggerVibeKanbanRecovery(
+        `fetchVk ${method} ${path} invalid response object`,
+      ),
     );
     noteVkErrorBurst("invalid-response");
     return null;
@@ -3443,8 +3539,10 @@ async function fetchVk(path, opts = {}) {
       );
     }
     if (res.status >= 500) {
-      void triggerVibeKanbanRecovery(
-        `fetchVk ${method} ${path} HTTP ${res.status}`,
+      runDetached("vk-recovery:http", () =>
+        triggerVibeKanbanRecovery(
+          `fetchVk ${method} ${path} HTTP ${res.status}`,
+        ),
       );
       noteVkErrorBurst("http-5xx");
     }
@@ -3482,8 +3580,10 @@ async function fetchVk(path, opts = {}) {
         );
       }
     }
-    void triggerVibeKanbanRecovery(
-      `fetchVk ${method} ${path} non-JSON response`,
+    runDetached("vk-recovery:non-json", () =>
+      triggerVibeKanbanRecovery(
+        `fetchVk ${method} ${path} non-JSON response`,
+      ),
     );
     noteVkErrorBurst("non-json");
     if (now - vkNonJsonNotifiedAt > 10 * 60 * 1000) {
@@ -6986,6 +7086,19 @@ function extractPrNumberFromUrl(prUrl) {
   return match ? parsePositivePrNumber(match[1]) : null;
 }
 
+function buildFlowGateMergeBody(taskTitle, taskId) {
+  const trailer = getBosunCoAuthorTrailer();
+  const safeTitle = String(taskTitle || "Task").trim() || "Task";
+  const safeId = String(taskId || "").trim();
+  const lines = [
+    `Merged by Bosun flow gate for: ${safeTitle}`,
+    safeId ? `Task: ${safeId}` : "",
+    "",
+    trailer,
+  ].filter(Boolean);
+  return lines.join("\n");
+}
+
 async function triggerFlowPostReviewMerge(taskId, context = {}) {
   if (!isFlowPrimaryEnabled() || !isFlowReviewGateEnabled()) {
     return false;
@@ -7036,6 +7149,7 @@ async function triggerFlowPostReviewMerge(taskId, context = {}) {
 
   const autoArgs = ["pr", "merge", String(prNumber)];
   if (repoSlug) autoArgs.push("--repo", repoSlug);
+  autoArgs.push("--body", buildFlowGateMergeBody(taskTitle, id));
   autoArgs.push("--auto", "--squash");
 
   const autoResult = spawnSync("gh", autoArgs, {
@@ -7057,6 +7171,7 @@ async function triggerFlowPostReviewMerge(taskId, context = {}) {
   if (/clean status|not in the correct state/i.test(autoErr)) {
     const directArgs = ["pr", "merge", String(prNumber)];
     if (repoSlug) directArgs.push("--repo", repoSlug);
+    directArgs.push("--body", buildFlowGateMergeBody(taskTitle, id));
     directArgs.push("--squash");
     const directResult = spawnSync("gh", directArgs, {
       cwd: repoRoot,
@@ -7227,10 +7342,12 @@ async function runMergeStrategyAnalysis(ctx, opts = {}) {
       // Re-run analysis after the wait period
       setTimeout(
         () => {
-          void runMergeStrategyAnalysis({
-            ...ctx,
-            ciStatus: "re-check",
-          });
+          runDetached("merge-strategy:wait-recheck", () =>
+            runMergeStrategyAnalysis({
+              ...ctx,
+              ciStatus: "re-check",
+            }),
+          );
         },
         (execResult.waitSeconds || 300) * 1000,
       );
@@ -7531,10 +7648,12 @@ async function actOnAssessment(ctx, decision) {
       const waitSec = decision.waitSeconds || 300;
       console.log(`[${tag}] → wait ${waitSec}s`);
       setTimeout(() => {
-        void runTaskAssessment({
-          ...ctx,
-          trigger: "reassessment",
-        });
+        runDetached("task-assessment:recheck", () =>
+          runTaskAssessment({
+            ...ctx,
+            trigger: "reassessment",
+          }),
+        );
       }, waitSec * 1000);
       break;
     }
@@ -9253,11 +9372,15 @@ function startTaskPlannerStatusLoop() {
   if (!taskPlannerStatus.enabled || plannerMode === "disabled") return;
   taskPlannerStatus.timer = setInterval(() => {
     if (shuttingDown) return;
-    void publishTaskPlannerStatus("interval");
+    runDetached("task-planner-status:interval", () =>
+      publishTaskPlannerStatus("interval"),
+    );
   }, taskPlannerStatus.intervalMs);
   setTimeout(() => {
     if (shuttingDown) return;
-    void publishTaskPlannerStatus("startup");
+    runDetached("task-planner-status:startup", () =>
+      publishTaskPlannerStatus("startup"),
+    );
   }, 25_000);
 }
 
@@ -9952,6 +10075,7 @@ async function startTelegramNotifier() {
     await checkStatusMilestones();
   };
 
+
   // Suppress "Notifier started" message on rapid restarts (e.g. code-change restarts).
   // If the last start was <60s ago, skip the notification — just log locally.
   const lastStartPath = resolve(
@@ -9976,10 +10100,16 @@ async function startTelegramNotifier() {
       `[monitor] notifier restarted (suppressed telegram notification — rapid restart)`,
     );
   } else {
-    void sendTelegramMessage(`${projectName} Orchestrator Notifier started.`);
+    runDetached("telegram-notifier:startup", () =>
+      sendTelegramMessage(`${projectName} Orchestrator Notifier started.`),
+    );
   }
-  telegramNotifierTimeout = setTimeout(sendUpdate, intervalMs);
-  telegramNotifierInterval = setInterval(sendUpdate, intervalMs);
+  telegramNotifierTimeout = setTimeout(() => {
+    runDetached("telegram-notifier:tick", sendUpdate);
+  }, intervalMs);
+  telegramNotifierInterval = setInterval(() => {
+    runDetached("telegram-notifier:tick", sendUpdate);
+  }, intervalMs);
 }
 
 async function checkStatusMilestones() {
@@ -10467,7 +10597,9 @@ async function triggerTaskPlanner(
     } else {
       throw new Error(`Unknown planner mode: ${effectiveMode}`);
     }
-    void publishTaskPlannerStatus("trigger-success");
+    runDetached("task-planner-status:trigger-success", () =>
+      publishTaskPlannerStatus("trigger-success"),
+    );
     return result;
   } catch (err) {
     const message = err && err.message ? err.message : String(err);
@@ -10481,7 +10613,9 @@ async function triggerTaskPlanner(
         `Task planner run failed (${effectiveMode}): ${message}`,
       );
     }
-    void publishTaskPlannerStatus("trigger-failed");
+    runDetached("task-planner-status:trigger-failed", () =>
+      publishTaskPlannerStatus("trigger-failed"),
+    );
     throw err; // re-throw so callers (e.g. /plan command) know it failed
   } finally {
     plannerTriggered = false;
@@ -12672,7 +12806,9 @@ async function startProcess() {
     if (!shuttingDown) {
       const retryMs = Math.max(5_000, restartDelayMs || 0);
       safeSetTimeout("startProcess-retry", () => {
-        if (!shuttingDown) void startProcess();
+        if (!shuttingDown) {
+          return startProcess();
+        }
       }, retryMs);
     }
   }
@@ -13184,7 +13320,9 @@ function scheduleEnvReload(reason) {
     clearTimeout(envWatcherDebounce);
   }
   envWatcherDebounce = setTimeout(() => {
-    void reloadConfig(reason || "env-change");
+    runDetached("config-reload:env-change", () =>
+      reloadConfig(reason || "env-change"),
+    );
   }, 400);
 }
 
@@ -14961,3 +15099,5 @@ export {
   getContainerStatus,
   isContainerEnabled,
 };
+
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bosun",
-  "version": "0.34.2",
+  "version": "0.34.4",
   "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",
@@ -152,6 +152,7 @@
     "github-oauth-portal.mjs",
     "github-reconciler.mjs",
     "get-telegram-chat-id.mjs",
+    "git-commit-helpers.mjs",
     "git-safety.mjs",
     "kanban-adapter.mjs",
     "lib/logger.mjs",

package/setup-web-server.mjs

@@ -182,6 +182,17 @@ function getCommandVersion(cmd) {
   }
 }
 
+function isWslInteropRuntime() {
+  return Boolean(
+    process.env.WSL_DISTRO_NAME
+    || process.env.WSL_INTEROP
+    || (process.platform === "win32"
+      && String(process.env.HOME || "")
+        .trim()
+        .startsWith("/home/")),
+  );
+}
+
 /**
  * Resolve the Bosun Home directory — the single root where bosun stores all its
  * configs, workspaces, and tooling.  Resolution order:
@@ -190,7 +201,7 @@ function getCommandVersion(cmd) {
  *   3. cwd if it already has a bosun.config.json AND is not inside a git repo
  *      we don't own (safety: prevents "bosun --setup" from contaminating whatever
  *      repo the user happened to be in when they ran the command)
- *   4. ~/bosun             (cross-platform stable default)
+ *   4. platform default config home + /bosun (same as runtime loader)
  */
 function resolveConfigDir() {
   if (process.env.BOSUN_HOME) return resolve(process.env.BOSUN_HOME);
@@ -211,8 +222,22 @@ function resolveConfigDir() {
     if (isExpectedHome) return cwd;
   }
 
-  // Stable default: ~/bosun — same path on every OS
-  return resolve(homedir(), "bosun");
+  const preferWindowsDirs =
+    process.platform === "win32" && !isWslInteropRuntime();
+  const baseDir = preferWindowsDirs
+    ? process.env.APPDATA
+      || process.env.LOCALAPPDATA
+      || process.env.USERPROFILE
+      || process.env.HOME
+      || homedir()
+    : process.env.HOME
+      || process.env.XDG_CONFIG_HOME
+      || process.env.USERPROFILE
+      || process.env.APPDATA
+      || process.env.LOCALAPPDATA
+      || homedir();
+
+  return resolve(baseDir, "bosun");
 }
 
 /**
@@ -664,7 +689,7 @@ function handleApply(body) {
       envMap.TELEGRAM_UI_ALLOW_UNSAFE = "false";
     }
     if (env.telegramChatId)      envMap.TELEGRAM_CHAT_ID         = env.telegramChatId;
-    if (env.jiraUrl)             envMap.JIRA_URL                 = env.jiraUrl;
+    if (env.jiraUrl)             envMap.JIRA_BASE_URL            = env.jiraUrl;
     if (env.jiraProjectKey)      envMap.JIRA_PROJECT_KEY         = env.jiraProjectKey;
     if (env.jiraApiToken)        envMap.JIRA_API_TOKEN           = env.jiraApiToken;
     if (env.githubProjectNumber) envMap.GITHUB_PROJECT_NUMBER    = String(env.githubProjectNumber);
@@ -674,11 +699,11 @@ function handleApply(body) {
     if (env.executorDistribution)        envMap.EXECUTOR_DISTRIBUTION        = env.executorDistribution;
     if (env.failoverStrategy)            envMap.FAILOVER_STRATEGY            = env.failoverStrategy;
     if (env.maxParallel != null)         envMap.MAX_PARALLEL                 = String(env.maxParallel);
-    if (env.maxRetries != null)          envMap.MAX_RETRIES                  = String(env.maxRetries);
+    if (env.maxRetries != null)          envMap.FAILOVER_MAX_RETRIES         = String(env.maxRetries);
     if (env.failoverCooldownMinutes != null)
-                                         envMap.FAILOVER_COOLDOWN_MINUTES    = String(env.failoverCooldownMinutes);
+                       envMap.FAILOVER_COOLDOWN_MIN        = String(env.failoverCooldownMinutes);
     if (env.failoverDisableOnConsecutive != null)
-                                         envMap.FAILOVER_DISABLE_ON_CONSECUTIVE_FAILURES = String(env.failoverDisableOnConsecutive);
+                       envMap.FAILOVER_DISABLE_AFTER       = String(env.failoverDisableOnConsecutive);
     if (env.primaryAgent)               envMap.PRIMARY_AGENT                 = env.primaryAgent;
     if (env.projectRequirementsProfile) envMap.PROJECT_REQUIREMENTS_PROFILE  = env.projectRequirementsProfile;
     if (env.internalReplenishEnabled != null)

package/task-executor.mjs

@@ -71,6 +71,7 @@ import {
   getRecentCommits,
   collectDiffStats,
 } from "./diff-stats.mjs";
+import { getBosunCoAuthorTrailer } from "./git-commit-helpers.mjs";
 import { createAnomalyDetector } from "./anomaly-detector.mjs";
 import { normalizeDedupKey, yieldToEventLoop, withRetry } from "./utils.mjs";
 import {
@@ -323,26 +324,22 @@ function categorizeError(err) {
 }
 
 /**
- * Returns the Co-authored-by trailer for bosun-ve[bot], or empty string
- * if the GitHub App ID is not configured. Used to attribute agent commits to
- * the Bosun GitHub App so the bot shows up as a contributor.
+ * Returns the Co-authored-by trailer for bosun-ve[bot].
  *
- * To enable: set BOSUN_GITHUB_APP_ID=<your-app-id> in .env
- * App noreply email format: <id>+bosun-ve[bot]@users.noreply.github.com
+ * Attribution should not be gated by auth mode (OAuth/App/env/gh-cli all valid
+ * execution paths). This uses the canonical helper so commit attribution stays
+ * consistent with the rest of Bosun.
  */
 function getBosunCoAuthorLine() {
-  const appId = String(process.env.BOSUN_GITHUB_APP_ID || "").trim();
-  if (!appId) return "";
-  return `Co-authored-by: bosun-ve[bot] <${appId}+bosun-ve[bot]@users.noreply.github.com>`;
+  return getBosunCoAuthorTrailer();
 }
 
 /**
  * Returns a prompt instruction block telling the agent to append the Bosun
- * co-author trailer to every commit. Empty string when app ID not configured.
+ * co-author trailer to every commit.
  */
 function getBosunCoAuthorInstruction() {
   const line = getBosunCoAuthorLine();
-  if (!line) return "";
   return `\n**Attribution (required — do not omit):**
 Every commit message MUST end with a blank line then this exact trailer:
 \`\`\`

package/task-store.mjs

@@ -34,10 +34,34 @@ function inferRepoRoot(startDir) {
   }
 }
 
+function resolveBosunHomeDir() {
+  const explicit = String(
+    process.env.BOSUN_HOME || process.env.BOSUN_DIR || "",
+  ).trim();
+  if (explicit) return resolve(explicit);
+
+  const base = String(
+    process.env.APPDATA ||
+      process.env.LOCALAPPDATA ||
+      process.env.USERPROFILE ||
+      process.env.HOME ||
+      "",
+  ).trim();
+  if (!base) return null;
+  if (/[/\\]bosun$/i.test(base)) return resolve(base);
+  return resolve(base, "bosun");
+}
+
 function resolveDefaultStorePath() {
-  const repoRoot =
-    inferRepoRoot(process.cwd()) || resolve(__dirname, "..", "..");
-  return resolve(repoRoot, ".bosun", ".cache", "kanban-state.json");
+  const repoRoot = inferRepoRoot(process.cwd());
+  if (repoRoot) {
+    return resolve(repoRoot, ".bosun", ".cache", "kanban-state.json");
+  }
+  const bosunHome = resolveBosunHomeDir();
+  if (bosunHome) {
+    return resolve(bosunHome, ".cache", "kanban-state.json");
+  }
+  return resolve(__dirname, ".cache", "kanban-state.json");
 }
 
 let storePath = resolveDefaultStorePath();
@@ -58,13 +82,15 @@ let _didLogInitialLoad = false;
 
 export function configureTaskStore(options = {}) {
   const baseDir = options.baseDir ? resolve(options.baseDir) : null;
+  const repoRoot = inferRepoRoot(process.cwd());
+  const homeDir = resolveBosunHomeDir();
+  const defaultBase = baseDir || repoRoot || homeDir || resolve(__dirname);
+  const needsBosunSubdir = Boolean(baseDir || repoRoot);
   const nextPath = options.storePath
     ? resolve(baseDir || process.cwd(), options.storePath)
     : resolve(
-        baseDir ||
-          inferRepoRoot(process.cwd()) ||
-          resolve(__dirname, "..", ".."),
-        ".bosun",
+        defaultBase,
+        needsBosunSubdir ? ".bosun" : "",
         ".cache",
         "kanban-state.json",
       );
@@ -420,14 +446,21 @@ export function setTaskStatus(taskId, status, source) {
   }
 
   const prev = task.status;
+  const tsNow = now();
   task.status = status;
-  task.updatedAt = now();
-  task.lastActivityAt = now();
+  task.updatedAt = tsNow;
+  task.lastActivityAt = tsNow;
+
+  // No-op transition: keep activity fresh without polluting history/logs.
+  if (prev === status) {
+    saveStore();
+    return { ...task };
+  }
 
   // Append to history (FIFO, max 50)
   task.statusHistory.push({
     status,
-    timestamp: now(),
+    timestamp: tsNow,
     source: source || "unknown",
   });
   if (task.statusHistory.length > MAX_STATUS_HISTORY) {