bosun 0.42.0 → 0.42.2

package/github/github-app-auth.mjs

@@ -384,7 +384,9 @@ export function getAppId() {
 
 // ── OAuth state persistence ───────────────────────────────────────────────────
 
-const AUTH_STATE_PATH = join(homedir(), ".bosun", "github-auth-state.json");
+function getAuthStatePath() {
+  return join(homedir(), ".bosun", "github-auth-state.json");
+}
 
 /**
  * Saves OAuth user token state to ~/.bosun/github-auth-state.json.
@@ -392,11 +394,12 @@ const AUTH_STATE_PATH = join(homedir(), ".bosun", "github-auth-state.json");
  * @param {{ user: object, accessToken: string, tokenType: string, scope: string, savedAt: string, installationIds: number[] }} state
  */
 export function saveOAuthState(state) {
-  const dir = dirname(AUTH_STATE_PATH);
+  const authStatePath = getAuthStatePath();
+  const dir = dirname(authStatePath);
   if (!existsSync(dir)) {
     mkdirSync(dir, { recursive: true });
   }
-  writeFileSync(AUTH_STATE_PATH, JSON.stringify(state, null, 2), "utf8");
+  writeFileSync(authStatePath, JSON.stringify(state, null, 2), "utf8");
 }
 
 /**
@@ -407,8 +410,9 @@ export function saveOAuthState(state) {
  */
 export function loadOAuthState() {
   try {
-    if (!existsSync(AUTH_STATE_PATH)) return null;
-    const raw = readFileSync(AUTH_STATE_PATH, "utf8");
+    const authStatePath = getAuthStatePath();
+    if (!existsSync(authStatePath)) return null;
+    const raw = readFileSync(authStatePath, "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null) return null;
     return parsed;

package/infra/maintenance.mjs

@@ -117,11 +117,15 @@ function clearBranchSyncWarning(key) {
 function logThrottledBranchSync(
   key,
   message,
-  {
+  levelOrOptions = {},
+) {
+  const options = typeof levelOrOptions === "string"
+    ? { level: levelOrOptions }
+    : (levelOrOptions || {});
+  const {
     level = "warn",
     throttleMs = BRANCH_SYNC_LOG_THROTTLE_MS,
-  } = {},
-) {
+  } = options;
   const normalizedKey = String(key || "default").trim() || "default";
   const now = Date.now();
   const state = branchSyncLogState.get(normalizedKey) || {
@@ -147,11 +151,12 @@ function logThrottledBranchSync(
       : "";
   const line = `${message}${suffix}`;
 
+  const isConsoleLogLevel = level === "info" || level === "log";
   if (level === "error") {
     console.error(line);
   } else if (level === "info") {
-    console.info(line);
-  } else if (level === "log") {
+    console.log(line);
+  } else if (isConsoleLogLevel) {
     console.log(line);
   } else {
     console.warn(line);
@@ -702,7 +707,7 @@ function parsePidFile(raw) {
   return { pid: Number(text), raw: text };
 }
 
-function formatPidFileSummary(parsed) {
+export function formatPidFileSummary(parsed) {
   const pid = Number(parsed?.pid);
   if (Number.isFinite(pid) && pid > 0) return String(pid);
   const raw = String(parsed?.raw || "").replace(/\s+/g, " ").trim();
@@ -1144,6 +1149,7 @@ export function syncLocalTrackingBranches(repoRoot, branches) {
           windowsHide: true,
         });
         if (statusCheck.stdout?.trim()) {
+          console.log(`[maintenance] local '${branch}' diverged (${ahead}↑ ${behind}↓) but has uncommitted changes — skipping`);
           logThrottledBranchSync(
             `sync:${branch}:diverged-dirty`,
             `[maintenance] local '${branch}' diverged (${ahead}↑ ${behind}↓) but has uncommitted changes — skipping`,
@@ -1205,6 +1211,7 @@ export function syncLocalTrackingBranches(repoRoot, branches) {
           windowsHide: true,
         });
         if (statusCheck.stdout?.trim()) {
+          console.log(`[maintenance] '${branch}' is checked out with uncommitted changes — skipping pull`);
           logThrottledBranchSync(
             `sync:${branch}:dirty-pull-skip`,
             `[maintenance] '${branch}' is checked out with uncommitted changes — skipping pull`,

package/infra/monitor.mjs

@@ -58,7 +58,11 @@ import {
 import { startAnalyzer, stopAnalyzer } from "../agent/agent-work-analyzer.mjs";
 import {
   generateWeeklyAgentWorkReport,
+  getNextWeeklyReportTime,
+  getWeeklyReportStatePath,
+  readWeeklyReportScheduleState,
   shouldSendWeeklyReport,
+  writeWeeklyReportScheduleState,
 } from "../agent/agent-work-report.mjs";
 
 import {
@@ -256,6 +260,9 @@ const ANOMALY_SIGNAL_PATH = resolve(
 );
 
 const AGENT_ALERT_POLL_MS = 10_000;
+const AGENT_ALERTS_REPLAY_STARTUP = isTruthyFlag(
+  process.env.AGENT_ALERTS_REPLAY_STARTUP,
+);
 let agentWorkAnalyzerActive = false;
 let agentAlertsOffset = 0;
 let agentAlertsTimer = null;
@@ -319,6 +326,25 @@ function saveAgentAlertsState() {
   }
 }
 
+function initializeAgentAlertsOffset() {
+  if (AGENT_ALERTS_REPLAY_STARTUP) {
+    // In replay mode, start from the beginning and ignore any persisted
+    // deduplication state so that replayed alerts are not suppressed.
+    agentAlertsOffset = 0;
+    agentAlertsDedup.clear();
+    return;
+  }
+  loadAgentAlertsState();
+  if (agentAlertsOffset > 0) return;
+  const path = getAgentAlertsPath();
+  if (!existsSync(path)) return;
+  try {
+    agentAlertsOffset = statSync(path).size;
+  } catch {
+    agentAlertsOffset = 0;
+  }
+}
+
 function rememberAlert(key) {
   agentAlertsDedup.set(key, Date.now());
   if (agentAlertsDedup.size > 200) {
@@ -381,6 +407,16 @@ function parseEnvInteger(value, defaultValue, { min = null, max = null } = {}) {
   return parsed;
 }
 
+function parseEnvNumber(value, defaultValue, { min = null, max = null } = {}) {
+  const normalized = String(value ?? "").trim();
+  if (!normalized) return defaultValue;
+  const parsed = Number(normalized);
+  if (!Number.isFinite(parsed)) return defaultValue;
+  if (Number.isFinite(min) && parsed < min) return defaultValue;
+  if (Number.isFinite(max) && parsed > max) return defaultValue;
+  return parsed;
+}
+
 const DEFAULT_AGENT_ENDPOINT_PORT = 18432;
 const REPO_SCOPED_AGENT_ENDPOINT_PORT_WINDOW = 2048;
 
@@ -491,6 +527,264 @@ function buildWorkflowEventPayload(eventType, eventData = {}) {
   return payload;
 }
 
+const DEFAULT_WORKFLOW_RECOVERY_POLICY = Object.freeze({
+  maxAttempts: 5,
+  escalationWarnAfterAttempts: 3,
+  baseBackoffMs: 5000,
+  maxBackoffMs: 60_000,
+  jitterRatio: 0.2,
+});
+
+let workflowRecoveryPolicy = DEFAULT_WORKFLOW_RECOVERY_POLICY;
+
+const workflowRecoveryState = new Map();
+const workflowRecoveryTimers = new Map();
+
+function emitWorkflowRecoveryTelemetry(eventName, details = {}) {
+  const payload = {
+    ts: new Date().toISOString(),
+    component: "monitor.workflow-recovery",
+    event: eventName,
+    ...details,
+  };
+  console.log(`[monitor-telemetry] ${JSON.stringify(payload)}`);
+}
+
+function normalizeWorkflowRecoveryPolicy(candidate = {}) {
+  const policy =
+    candidate && typeof candidate === "object" ? candidate : {};
+  const maxAttempts = parseEnvInteger(
+    policy.maxAttempts,
+    DEFAULT_WORKFLOW_RECOVERY_POLICY.maxAttempts,
+    { min: 1, max: 20 },
+  );
+  const escalationWarnAfterAttempts = parseEnvInteger(
+    policy.escalationWarnAfterAttempts,
+    DEFAULT_WORKFLOW_RECOVERY_POLICY.escalationWarnAfterAttempts,
+    { min: 1, max: maxAttempts },
+  );
+  return Object.freeze({
+    maxAttempts,
+    escalationWarnAfterAttempts,
+    baseBackoffMs: parseEnvInteger(
+      policy.baseBackoffMs,
+      DEFAULT_WORKFLOW_RECOVERY_POLICY.baseBackoffMs,
+      { min: 50, max: 60_000 },
+    ),
+    maxBackoffMs: parseEnvInteger(
+      policy.maxBackoffMs,
+      DEFAULT_WORKFLOW_RECOVERY_POLICY.maxBackoffMs,
+      { min: 1000, max: 30 * 60 * 1000 },
+    ),
+    jitterRatio: parseEnvNumber(
+      policy.jitterRatio,
+      DEFAULT_WORKFLOW_RECOVERY_POLICY.jitterRatio,
+      { min: 0, max: 0.9 },
+    ),
+  });
+}
+
+function isWorkflowRecoveryPolicyEqual(left, right) {
+  return (
+    left?.maxAttempts === right?.maxAttempts &&
+    left?.escalationWarnAfterAttempts === right?.escalationWarnAfterAttempts &&
+    left?.baseBackoffMs === right?.baseBackoffMs &&
+    left?.maxBackoffMs === right?.maxBackoffMs &&
+    left?.jitterRatio === right?.jitterRatio
+  );
+}
+
+function applyWorkflowRecoveryPolicy(nextPolicy, reason = "startup") {
+  const normalized = normalizeWorkflowRecoveryPolicy(nextPolicy);
+  const changed = !isWorkflowRecoveryPolicyEqual(
+    workflowRecoveryPolicy,
+    normalized,
+  );
+  workflowRecoveryPolicy = normalized;
+  if (!changed) return;
+
+  for (const operation of workflowRecoveryTimers.keys()) {
+    clearWorkflowRecoveryTimer(operation);
+  }
+  workflowRecoveryState.clear();
+  emitWorkflowRecoveryTelemetry("policy_updated", {
+    reason,
+    policy: normalized,
+  });
+}
+
+function clearWorkflowRecoveryTimer(operation) {
+  const existing = workflowRecoveryTimers.get(operation);
+  if (existing) {
+    clearTimeout(existing);
+    workflowRecoveryTimers.delete(operation);
+  }
+}
+
+function computeWorkflowRecoveryBackoffMs(attempt) {
+  const cappedBase = Math.max(1, workflowRecoveryPolicy.baseBackoffMs);
+  const expDelay = Math.min(
+    cappedBase * Math.pow(2, Math.max(0, attempt - 1)),
+    Math.max(cappedBase, workflowRecoveryPolicy.maxBackoffMs),
+  );
+  const jitterWindow = Math.max(
+    0,
+    Math.round(expDelay * workflowRecoveryPolicy.jitterRatio),
+  );
+  const jitter = jitterWindow > 0
+    ? Math.floor(Math.random() * (jitterWindow * 2 + 1)) - jitterWindow
+    : 0;
+  return Math.max(0, Math.min(
+    Math.round(expDelay + jitter),
+    Math.max(cappedBase, workflowRecoveryPolicy.maxBackoffMs),
+  ));
+}
+
+function emitWorkflowRecoverySuppressed(operation, state, reason, metadata = {}) {
+  if (!state || !reason) return;
+  const counters = state.suppressedCounters || {};
+  const nextCount = Number(counters[reason] || 0) + 1;
+  counters[reason] = nextCount;
+  state.suppressedCounters = counters;
+  workflowRecoveryState.set(operation, state);
+
+  if (nextCount !== 1 && nextCount % 10 !== 0) return;
+  emitWorkflowRecoveryTelemetry("suppressed", {
+    operation,
+    reason,
+    suppressedCount: nextCount,
+    attempts: Number(state.attempts || 0),
+    terminalEscalated: state.terminalEscalated === true,
+    inFlight: state.inFlight === true,
+    nextRetryAt: state.nextRetryAt
+      ? new Date(state.nextRetryAt).toISOString()
+      : null,
+    context: metadata || null,
+  });
+}
+
+function runWorkflowRecoveryWithPolicy(operation, attemptFn, metadata = {}) {
+  const op = String(operation || "").trim();
+  if (!op || typeof attemptFn !== "function") return;
+
+  const now = Date.now();
+  const state = workflowRecoveryState.get(op) || {
+    attempts: 0,
+    warningEscalated: false,
+    terminalEscalated: false,
+    inFlight: false,
+    nextRetryAt: 0,
+    suppressedCounters: {},
+  };
+  if (state.terminalEscalated || state.inFlight) {
+    emitWorkflowRecoverySuppressed(
+      op,
+      state,
+      state.terminalEscalated ? "terminal-escalated" : "in-flight",
+      metadata,
+    );
+    return;
+  }
+  if (state.nextRetryAt > now) {
+    emitWorkflowRecoverySuppressed(op, state, "cooldown", metadata);
+    return;
+  }
+
+  const attempt = state.attempts + 1;
+  state.inFlight = true;
+  workflowRecoveryState.set(op, state);
+  emitWorkflowRecoveryTelemetry("attempt", {
+    operation: op,
+    attempt,
+    maxAttempts: workflowRecoveryPolicy.maxAttempts,
+    escalationWarnAfterAttempts: workflowRecoveryPolicy.escalationWarnAfterAttempts,
+    trigger: metadata?.trigger || "manual",
+    context: metadata || null,
+  });
+
+  const startedAt = Date.now();
+  void Promise.resolve()
+    .then(() => attemptFn({ operation: op, attempt }))
+    .then(() => {
+      clearWorkflowRecoveryTimer(op);
+      workflowRecoveryState.delete(op);
+      emitWorkflowRecoveryTelemetry("success", {
+        operation: op,
+        attempt,
+        durationMs: Date.now() - startedAt,
+        context: metadata || null,
+      });
+    })
+    .catch((err) => {
+      const errorMessage = formatMonitorError(err);
+      const failureAt = Date.now();
+      const willWarnEscalate =
+        !state.warningEscalated &&
+        attempt >= workflowRecoveryPolicy.escalationWarnAfterAttempts;
+      const terminalEscalated = attempt >= workflowRecoveryPolicy.maxAttempts;
+      state.attempts = attempt;
+      state.lastError = errorMessage;
+      state.lastFailureAt = failureAt;
+      state.inFlight = false;
+      if (willWarnEscalate) {
+        state.warningEscalated = true;
+      }
+
+      if (terminalEscalated) {
+        state.terminalEscalated = true;
+        state.nextRetryAt = 0;
+        workflowRecoveryState.set(op, state);
+        clearWorkflowRecoveryTimer(op);
+        emitWorkflowRecoveryTelemetry("escalated", {
+          operation: op,
+          attempt,
+          escalationState: "terminal",
+          error: errorMessage,
+          durationMs: failureAt - startedAt,
+          context: metadata || null,
+        });
+        console.warn(
+          `[workflows] recovery escalated for ${op} after ${attempt} attempt(s): ${errorMessage}`,
+        );
+        return;
+      }
+
+      const backoffMs = computeWorkflowRecoveryBackoffMs(attempt);
+      state.nextRetryAt = failureAt + backoffMs;
+      workflowRecoveryState.set(op, state);
+      emitWorkflowRecoveryTelemetry("retry_scheduled", {
+        operation: op,
+        attempt,
+        error: errorMessage,
+        backoffMs,
+        nextRetryAt: new Date(state.nextRetryAt).toISOString(),
+        escalationState: state.warningEscalated ? "warning" : "none",
+        durationMs: failureAt - startedAt,
+        context: metadata || null,
+      });
+      if (willWarnEscalate) {
+        console.warn(
+          `[workflows] recovery warning for ${op}: ${attempt} consecutive failures (threshold ${workflowRecoveryPolicy.escalationWarnAfterAttempts})`,
+        );
+      }
+
+      clearWorkflowRecoveryTimer(op);
+      const timer = setTimeout(() => {
+        workflowRecoveryTimers.delete(op);
+        runWorkflowRecoveryWithPolicy(op, attemptFn, {
+          ...metadata,
+          trigger: "retry-timer",
+        });
+      }, backoffMs);
+      if (typeof timer.unref === "function") timer.unref();
+      workflowRecoveryTimers.set(op, timer);
+    })
+    .finally(() => {
+      const current = workflowRecoveryState.get(op);
+      if (current) current.inFlight = false;
+    });
+}
+
 async function ensureWorkflowAutomationEngine() {
   if (!workflowAutomationEnabled || process.env.VITEST) return null;
   if (workflowAutomationEngine) return workflowAutomationEngine;
@@ -1627,7 +1921,7 @@ function stopAgentWorkAnalyzer() {
 
 function startAgentAlertTailer() {
   if (agentAlertsTimer) return;
-  loadAgentAlertsState();
+  initializeAgentAlertsOffset();
   agentAlertsTimer = setInterval(() => {
     runDetached("agent-alerts:poll-interval", pollAgentAlerts);
   }, AGENT_ALERT_POLL_MS);
@@ -1835,9 +2129,12 @@ let {
   telegramVerbosity,
   fleet: fleetConfig,
   internalExecutor: internalExecutorConfig,
+  workflowRecovery: configWorkflowRecovery,
   executorMode: configExecutorMode,
 } = config;
 
+applyWorkflowRecoveryPolicy(configWorkflowRecovery, "startup-config");
+
 const telegramWeeklyReportEnabled = parseEnvBoolean(
   process.env.TELEGRAM_WEEKLY_REPORT_ENABLED,
   false,
@@ -2860,6 +3157,8 @@ try {
 let telegramNotifierInterval = null;
 let telegramNotifierTimeout = null;
 let weeklyReportLastSentAt = null;
+let weeklyReportStateLoaded = false;
+const weeklyReportStatePath = getWeeklyReportStatePath();
 const monitorRestartReason = String(
   process.env.BOSUN_MONITOR_RESTART_REASON || "",
 )
@@ -7046,8 +7345,11 @@ function buildEpicMergeBody(tasks, headName, baseName) {
   const maxList = 25;
   const slice = safeTasks.slice(0, maxList);
   for (const task of slice) {
-    const title = String(task?.title || task?.name || "Untitled task").trim();
-    const id = task?.id ? ` (${task.id})` : "";
+    const normalizedTaskId = String(task?.id || "").trim();
+    const title = deriveTaskDisplayTitle(task?.title || task?.name, normalizedTaskId);
+    const shouldOmitIdSuffix =
+      normalizedTaskId && title === `Task ${normalizedTaskId}`;
+    const id = normalizedTaskId && !shouldOmitIdSuffix ? ` (${normalizedTaskId})` : "";
     lines.push(`- ${title}${id}`);
   }
   if (safeTasks.length > maxList) {
@@ -7059,6 +7361,16 @@ function buildEpicMergeBody(tasks, headName, baseName) {
   return lines.join("\n");
 }
 
+function deriveTaskDisplayTitle(titleValue, taskId) {
+  const title = String(titleValue || "").trim();
+  if (title && title.toLowerCase() !== "untitled task") {
+    return title;
+  }
+
+  const normalizedTaskId = String(taskId || "").trim();
+  return normalizedTaskId ? `Task ${normalizedTaskId}` : "Untitled task";
+}
+
 function summarizeEpicBranch(headBranch, baseBranch) {
   const headInfo = splitRemoteRef(headBranch, "origin");
   const baseInfo = splitRemoteRef(baseBranch, "origin");
@@ -10103,9 +10415,10 @@ function formatRecentStatusItems(items, timestampField, maxItems = 6) {
     })
     .slice(0, maxItems)
     .map((entry) => {
-      const title = entry?.task_title || entry?.title || "Untitled task";
       const id = (entry?.task_id || entry?.id || "").toString().slice(0, 8);
-      const suffix = id ? ` (${id})` : "";
+      const title = deriveTaskDisplayTitle(entry?.task_title || entry?.title, id);
+      const suffix =
+        id && title !== `Task ${id}` ? ` (${id})` : "";
       return `- ${title}${suffix}`;
     });
 }
@@ -10275,9 +10588,26 @@ async function sendTelegramMessage(text, options = {}) {
   });
 }
 
+async function ensureWeeklyReportStateLoaded() {
+  if (weeklyReportStateLoaded) return;
+  weeklyReportStateLoaded = true;
+  try {
+    const state = await readWeeklyReportScheduleState({
+      statePath: weeklyReportStatePath,
+    });
+    weeklyReportLastSentAt = state?.lastSentAt || null;
+  } catch (err) {
+    console.warn(
+      `[monitor] failed loading weekly report state from ${weeklyReportStatePath}: ${err?.message || err}`,
+    );
+    weeklyReportLastSentAt = null;
+  }
+}
+
 async function maybeSendWeeklyReport(nowInput = new Date()) {
   if (!telegramWeeklyReportEnabled) return;
   if (!telegramToken || !telegramChatId) return;
+  await ensureWeeklyReportStateLoaded();
   const now = nowInput instanceof Date ? nowInput : new Date(nowInput);
   if (!Number.isFinite(now.getTime())) return;
 
@@ -10299,6 +10629,9 @@ async function maybeSendWeeklyReport(nowInput = new Date()) {
       skipDedup: true,
     });
     weeklyReportLastSentAt = now.toISOString();
+    await writeWeeklyReportScheduleState(weeklyReportLastSentAt, {
+      statePath: weeklyReportStatePath,
+    });
     if (Array.isArray(report.warnings) && report.warnings.length > 0) {
       console.warn(
         `[monitor] weekly report generated with warnings: ${report.warnings.join(" | ")}`,
@@ -14093,6 +14426,10 @@ function applyConfig(nextConfig, options = {}) {
     process.env.WORKFLOW_AUTOMATION_ENABLED,
     workflowAutomationEnabled,
   );
+  applyWorkflowRecoveryPolicy(
+    nextConfig.workflowRecovery,
+    `config-reload:${reason || "unknown"}`,
+  );
   {
     const dedupMs = Number(
       process.env.WORKFLOW_EVENT_DEDUP_WINDOW_MS || workflowEventDedupWindowMs || "15000",
@@ -14677,7 +15014,12 @@ pollWorkflowSchedulesOnce = async function pollWorkflowSchedulesOnce(
 ) {
   try {
     const engine = await ensureWorkflowAutomationEngine();
-    if (!engine?.evaluateScheduleTriggers) return;
+    if (!engine?.evaluateScheduleTriggers) {
+      if (opts?.requireEngine) {
+        throw new Error("workflow automation engine unavailable");
+      }
+      return;
+    }
     const includeTaskPoll = opts?.includeTaskPoll !== false;
 
     const triggered = engine.evaluateScheduleTriggers({ configDir: repoRoot });
@@ -14730,6 +15072,7 @@ pollWorkflowSchedulesOnce = async function pollWorkflowSchedulesOnce(
     }
   } catch (err) {
     console.warn(`[workflows] schedule-check error: ${err?.message || err}`);
+    if (opts?.throwOnError) throw err;
   }
 };
 
@@ -14935,10 +15278,15 @@ if (dependabotAutoMerge) {
 
 if (telegramWeeklyReportEnabled) {
   const weeklyReportPollMs = 60 * 1000;
+  const nextWeeklyReportTime = getNextWeeklyReportTime({
+    now: new Date(),
+    dayOfWeek: telegramWeeklyReportDay,
+    hourUtc: telegramWeeklyReportHour,
+  });
   safeSetInterval("telegram-weekly-report", () => maybeSendWeeklyReport(), weeklyReportPollMs);
   safeSetTimeout("telegram-weekly-report-initial", () => maybeSendWeeklyReport(), 45 * 1000);
   console.log(
-    `[monitor] weekly Telegram report scheduler enabled (day=${telegramWeeklyReportDay}, hourUtc=${telegramWeeklyReportHour}, lookbackDays=${telegramWeeklyReportDays})`,
+    `[monitor] weekly Telegram report scheduler enabled (day=${telegramWeeklyReportDay}, hourUtc=${telegramWeeklyReportHour}, lookbackDays=${telegramWeeklyReportDays}); next scheduled send at ${nextWeeklyReportTime.toISOString()}`,
   );
 }
 
@@ -15118,9 +15466,34 @@ let agentSupervisor = null;
 if (!isMonitorTestRuntime) {
   if (workflowAutomationEnabled) {
     await ensureWorkflowAutomationEngine().catch(() => {});
-    void pollWorkflowSchedulesOnce("startup", { includeTaskPoll: false }).catch((err) => {
-      console.warn(`[workflows] startup poll error: ${err?.message || err}`);
-    });
+    runWorkflowRecoveryWithPolicy(
+      "stale-dispatch-unstick",
+      () =>
+        pollWorkflowSchedulesOnce("startup", {
+          includeTaskPoll: false,
+          requireEngine: true,
+          throwOnError: true,
+        }),
+      {
+        trigger: "startup",
+        operationType: "stale-dispatch-unstick",
+        includeTaskPoll: false,
+      },
+    );
+    runWorkflowRecoveryWithPolicy(
+      "workflow-history-unstick",
+      async () => {
+        const engine = await ensureWorkflowAutomationEngine();
+        if (!engine?.resumeInterruptedRuns) {
+          throw new Error("workflow engine resumeInterruptedRuns unavailable");
+        }
+        await engine.resumeInterruptedRuns();
+      },
+      {
+        trigger: "startup",
+        operationType: "workflow-history-unstick",
+      },
+    );
   } else {
     console.log(
       "[workflows] automation disabled (set WORKFLOW_AUTOMATION_ENABLED=true to enable event-driven workflow triggers)",
@@ -15375,6 +15748,21 @@ if (isExecutorDisabled()) {
     };
     internalTaskExecutor = getTaskExecutor(execOpts);
     internalTaskExecutor.start();
+    if (workflowOwnsTaskExecutorLifecycle) {
+      runWorkflowRecoveryWithPolicy(
+        "stale-dispatch-task-poll-unstick",
+        () =>
+          pollWorkflowSchedulesOnce("startup", {
+            requireEngine: true,
+            throwOnError: true,
+          }),
+        {
+          trigger: "startup",
+          operationType: "stale-dispatch-task-poll-unstick",
+          includeTaskPoll: true,
+        },
+      );
+    }
 
     // Write executor slots to status file every 30s for Telegram /tasks
     startStatusFileWriter(30000);

package/infra/runtime-accumulator.mjs

@@ -28,7 +28,15 @@ const DEFAULT_CACHE_DIR = resolve(__dirname, "..", ".cache");
 const SNAPSHOT_FILE_NAME = "runtime-accumulator.json";
 const SESSION_LOG_FILE_NAME = "session-accumulator.jsonl";
 const MAX_SESSION_TOKENS = 100;
-const MAX_COMPLETED_SESSIONS = 500;
+const DEFAULT_MAX_COMPLETED_SESSIONS = 50_000;
+const MAX_COMPLETED_SESSIONS = (() => {
+	const raw = process.env.RUNTIME_MAX_COMPLETED_SESSIONS;
+	if (!raw) return DEFAULT_MAX_COMPLETED_SESSIONS;
+	const parsed = Number.parseInt(raw, 10);
+	if (!Number.isFinite(parsed) || parsed <= 0) return DEFAULT_MAX_COMPLETED_SESSIONS;
+	// Hard cap to avoid unbounded memory use even if misconfigured.
+	return Math.min(parsed, DEFAULT_MAX_COMPLETED_SESSIONS);
+})();
 
 let _cacheDir = DEFAULT_CACHE_DIR;
 let _runtimeFile = resolve(_cacheDir, SNAPSHOT_FILE_NAME);