@chrysb/alphaclaw 0.4.0 → 0.4.1-beta.0

package/lib/server/routes/webhooks.js

@@ -6,9 +6,12 @@ const {
   validateWebhookName,
 } = require("../webhooks");
 
-const isFiniteInteger = (value) => Number.isFinite(value) && Number.isInteger(value);
+const isFiniteInteger = (value) =>
+  Number.isFinite(value) && Number.isInteger(value);
 const parseBooleanFlag = (value) => {
-  const normalized = String(value == null ? "" : value).trim().toLowerCase();
+  const normalized = String(value == null ? "" : value)
+    .trim()
+    .toLowerCase();
   return ["1", "true", "yes", "on"].includes(normalized);
 };
 
@@ -40,20 +43,24 @@ const mergeWebhookAndSummary = ({ webhook, summary }) => {
 };
 
 const normalizeStatusFilter = (rawStatus) => {
-  const status = String(rawStatus || "all").trim().toLowerCase();
+  const status = String(rawStatus || "all")
+    .trim()
+    .toLowerCase();
   if (["all", "success", "error"].includes(status)) return status;
   return "all";
 };
 
 const buildWebhookUrls = ({ baseUrl, name }) => {
   const fullUrl = `${baseUrl}/hooks/${name}`;
-  const token = String(process.env.WEBHOOK_TOKEN || "").trim();
+  const token = String(
+    process.env.OPENCLAW_HOOKS_TOKEN || process.env.WEBHOOK_TOKEN || "",
+  ).trim();
   const queryStringUrl = token
     ? `${fullUrl}?token=${encodeURIComponent(token)}`
-    : `${fullUrl}?token=<WEBHOOK_TOKEN>`;
+    : `${fullUrl}?token=<OPENCLAW_HOOKS_TOKEN>`;
   const authHeaderValue = token
     ? `Authorization: Bearer ${token}`
-    : "Authorization: Bearer <WEBHOOK_TOKEN>";
+    : "Authorization: Bearer <OPENCLAW_HOOKS_TOKEN>";
   return { fullUrl, queryStringUrl, authHeaderValue, hasRuntimeToken: !!token };
 };
 
@@ -71,7 +78,8 @@ const registerWebhookRoutes = ({
     getSnapshot: async () => ({ restartRequired: false }),
   };
   const resolvedRestartState = restartRequiredState || fallbackRestartState;
-  const { markRequired: markRestartRequired, getSnapshot: getRestartSnapshot } = resolvedRestartState;
+  const { markRequired: markRestartRequired, getSnapshot: getRestartSnapshot } =
+    resolvedRestartState;
   const runWebhookGitSync = async (action, name) => {
     if (typeof shellCmd !== "function") return null;
     const safeName = String(name || "").trim();
@@ -95,7 +103,8 @@ const registerWebhookRoutes = ({
         mergeWebhookAndSummary({
           webhook,
           summary: summaryByHook.get(webhook.name),
-        }));
+        }),
+      );
       res.json({ ok: true, webhooks });
     } catch (err) {
       res.status(500).json({ ok: false, error: err.message });
@@ -106,8 +115,11 @@ const registerWebhookRoutes = ({
     try {
       const name = validateWebhookName(req.params.name);
       const detail = getWebhookDetail({ fs, constants, name });
-      if (!detail) return res.status(404).json({ ok: false, error: "Webhook not found" });
-      const summary = webhooksDb.getHookSummaries().find((item) => item.hookName === name);
+      if (!detail)
+        return res.status(404).json({ ok: false, error: "Webhook not found" });
+      const summary = webhooksDb
+        .getHookSummaries()
+        .find((item) => item.hookName === name);
       const merged = mergeWebhookAndSummary({ webhook: detail, summary });
       const baseUrl = getBaseUrl(req);
       const urls = buildWebhookUrls({ baseUrl, name });
@@ -151,7 +163,9 @@ const registerWebhookRoutes = ({
         syncWarning,
       });
     } catch (err) {
-      const status = String(err.message || "").includes("already exists") ? 409 : 400;
+      const status = String(err.message || "").includes("already exists")
+        ? 409
+        : 400;
       return res.status(status).json({ ok: false, error: err.message });
     }
   });
@@ -159,9 +173,23 @@ const registerWebhookRoutes = ({
   app.delete("/api/webhooks/:name", async (req, res) => {
     try {
       const name = validateWebhookName(req.params.name);
-      const deleteTransformDir = parseBooleanFlag(req?.body?.deleteTransformDir);
-      const deletion = deleteWebhook({ fs, constants, name, deleteTransformDir });
-      if (!deletion?.removed) return res.status(404).json({ ok: false, error: "Webhook not found" });
+      const deleteTransformDir = parseBooleanFlag(
+        req?.body?.deleteTransformDir,
+      );
+      const deletion = deleteWebhook({
+        fs,
+        constants,
+        name,
+        deleteTransformDir,
+      });
+      if (deletion?.managed) {
+        return res.status(409).json({
+          ok: false,
+          error: `Webhook "${name}" is managed by system setup and cannot be deleted`,
+        });
+      }
+      if (!deletion?.removed)
+        return res.status(404).json({ ok: false, error: "Webhook not found" });
       const deletedRequestCount = webhooksDb.deleteRequestsByHook(name);
       const syncWarning = await runWebhookGitSync("delete", name);
       markRestartRequired("webhooks");
@@ -184,9 +212,15 @@ const registerWebhookRoutes = ({
       const limit = Number.parseInt(String(req.query.limit || 50), 10);
       const offset = Number.parseInt(String(req.query.offset || 0), 10);
       const status = normalizeStatusFilter(req.query.status);
-      const hasBadPaging = !isFiniteInteger(limit) || limit <= 0 || !isFiniteInteger(offset) || offset < 0;
+      const hasBadPaging =
+        !isFiniteInteger(limit) ||
+        limit <= 0 ||
+        !isFiniteInteger(offset) ||
+        offset < 0;
       if (hasBadPaging) {
-        return res.status(400).json({ ok: false, error: "Invalid limit/offset" });
+        return res
+          .status(400)
+          .json({ ok: false, error: "Invalid limit/offset" });
       }
       const requests = webhooksDb.getRequests(name, { limit, offset, status });
       return res.json({ ok: true, requests });
@@ -203,7 +237,8 @@ const registerWebhookRoutes = ({
         return res.status(400).json({ ok: false, error: "Invalid request id" });
       }
       const request = webhooksDb.getRequestById(name, requestId);
-      if (!request) return res.status(404).json({ ok: false, error: "Request not found" });
+      if (!request)
+        return res.status(404).json({ ok: false, error: "Request not found" });
       return res.json({ ok: true, request });
     } catch (err) {
       return res.status(400).json({ ok: false, error: err.message });

package/lib/server/usage-db.js

@@ -7,7 +7,10 @@ const kMaxSessionLimit = 200;
 const kDefaultDays = 30;
 const kDefaultMaxPoints = 100;
 const kMaxMaxPoints = 1000;
+const kDayMs = 24 * 60 * 60 * 1000;
 const kTokensPerMillion = 1_000_000;
+const kUtcTimeZone = "UTC";
+const kDayKeyFormatterCache = new Map();
 const kGlobalModelPricing = {
   "claude-opus-4-6": { input: 15.0, output: 75.0 },
   "claude-sonnet-4-6": { input: 3.0, output: 15.0 },
@@ -31,6 +34,39 @@ const coerceInt = (value, fallbackValue = 0) => {
 const clampInt = (value, minValue, maxValue, fallbackValue) =>
   Math.min(maxValue, Math.max(minValue, coerceInt(value, fallbackValue)));
 
+const normalizeTimeZone = (value) => {
+  const raw = String(value || "").trim();
+  if (!raw) return kUtcTimeZone;
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: raw });
+    return raw;
+  } catch {
+    return kUtcTimeZone;
+  }
+};
+
+const getDayKeyFormatter = (timeZone) => {
+  if (kDayKeyFormatterCache.has(timeZone)) {
+    return kDayKeyFormatterCache.get(timeZone);
+  }
+  const formatter = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+  });
+  kDayKeyFormatterCache.set(timeZone, formatter);
+  return formatter;
+};
+
+const toTimeZoneDayKey = (timestampMs, timeZone) => {
+  const parts = getDayKeyFormatter(timeZone).formatToParts(new Date(timestampMs));
+  const year = parts.find((part) => part.type === "year")?.value || "0000";
+  const month = parts.find((part) => part.type === "month")?.value || "01";
+  const day = parts.find((part) => part.type === "day")?.value || "01";
+  return `${year}-${month}-${day}`;
+};
+
 const resolvePricing = (model) => {
   const normalized = String(model || "").toLowerCase();
   if (!normalized) return null;
@@ -174,11 +210,15 @@ const initUsageDb = ({ rootDir }) => {
 
 const toDayKey = (timestampMs) => new Date(timestampMs).toISOString().slice(0, 10);
 
-const getPeriodRange = (days) => {
+const getPeriodRange = (days, timeZone = kUtcTimeZone) => {
   const now = Date.now();
   const safeDays = clampInt(days, 1, 3650, kDefaultDays);
-  const startMs = now - safeDays * 24 * 60 * 60 * 1000;
-  return { now, safeDays, startDay: toDayKey(startMs) };
+  const startMs = now - safeDays * kDayMs;
+  const normalizedTimeZone = normalizeTimeZone(timeZone);
+  const startDay = normalizedTimeZone === kUtcTimeZone
+    ? toDayKey(startMs)
+    : toTimeZoneDayKey(startMs, normalizedTimeZone);
+  return { now, safeDays, startDay, timeZone: normalizedTimeZone };
 };
 
 const appendCostToRows = (rows) =>
@@ -208,27 +248,253 @@ const appendCostToRows = (rows) =>
     };
   });
 
-const getDailySummary = ({ days = kDefaultDays } = {}) => {
+const parseAgentAndSourceFromSessionRef = (sessionRef) => {
+  const raw = String(sessionRef || "").trim();
+  if (!raw) {
+    return { agent: "unknown", source: "chat" };
+  }
+  const parts = raw.split(":");
+  const agent =
+    parts[0] === "agent" && String(parts[1] || "").trim()
+      ? String(parts[1] || "").trim()
+      : "unknown";
+  const source = parts.includes("hook")
+    ? "hooks"
+    : parts.includes("cron")
+      ? "cron"
+      : "chat";
+  return { agent, source };
+};
+
+const getAgentCostDistribution = ({
+  eventsRows = [],
+  startDay = "",
+  timeZone = kUtcTimeZone,
+}) => {
+  const byAgent = new Map();
+  const ensureAgentBucket = (agent) => {
+    if (byAgent.has(agent)) return byAgent.get(agent);
+    const bucket = {
+      agent,
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheReadTokens: 0,
+      cacheWriteTokens: 0,
+      totalTokens: 0,
+      totalCost: 0,
+      turnCount: 0,
+      sourceBreakdown: {
+        chat: {
+          source: "chat",
+          inputTokens: 0,
+          outputTokens: 0,
+          cacheReadTokens: 0,
+          cacheWriteTokens: 0,
+          totalTokens: 0,
+          totalCost: 0,
+          turnCount: 0,
+        },
+        hooks: {
+          source: "hooks",
+          inputTokens: 0,
+          outputTokens: 0,
+          cacheReadTokens: 0,
+          cacheWriteTokens: 0,
+          totalTokens: 0,
+          totalCost: 0,
+          turnCount: 0,
+        },
+        cron: {
+          source: "cron",
+          inputTokens: 0,
+          outputTokens: 0,
+          cacheReadTokens: 0,
+          cacheWriteTokens: 0,
+          totalTokens: 0,
+          totalCost: 0,
+          turnCount: 0,
+        },
+      },
+    };
+    byAgent.set(agent, bucket);
+    return bucket;
+  };
+
+  for (const eventRow of eventsRows) {
+    const timestamp = coerceInt(eventRow.timestamp);
+    const dayKey = timeZone === kUtcTimeZone
+      ? toDayKey(timestamp)
+      : toTimeZoneDayKey(timestamp, timeZone);
+    if (dayKey < startDay) continue;
+
+    const inputTokens = coerceInt(eventRow.input_tokens);
+    const outputTokens = coerceInt(eventRow.output_tokens);
+    const cacheReadTokens = coerceInt(eventRow.cache_read_tokens);
+    const cacheWriteTokens = coerceInt(eventRow.cache_write_tokens);
+    const totalTokens =
+      coerceInt(eventRow.total_tokens) ||
+      inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens;
+    const { totalCost } = deriveCostBreakdown({
+      inputTokens,
+      outputTokens,
+      cacheReadTokens,
+      cacheWriteTokens,
+      model: eventRow.model,
+    });
+    const sessionRef = String(eventRow.session_key || eventRow.session_id || "");
+    const { agent, source } = parseAgentAndSourceFromSessionRef(sessionRef);
+    const agentBucket = ensureAgentBucket(agent);
+    const sourceBucket = agentBucket.sourceBreakdown[source];
+
+    agentBucket.inputTokens += inputTokens;
+    agentBucket.outputTokens += outputTokens;
+    agentBucket.cacheReadTokens += cacheReadTokens;
+    agentBucket.cacheWriteTokens += cacheWriteTokens;
+    agentBucket.totalTokens += totalTokens;
+    agentBucket.totalCost += totalCost;
+    agentBucket.turnCount += 1;
+
+    sourceBucket.inputTokens += inputTokens;
+    sourceBucket.outputTokens += outputTokens;
+    sourceBucket.cacheReadTokens += cacheReadTokens;
+    sourceBucket.cacheWriteTokens += cacheWriteTokens;
+    sourceBucket.totalTokens += totalTokens;
+    sourceBucket.totalCost += totalCost;
+    sourceBucket.turnCount += 1;
+  }
+
+  const agents = Array.from(byAgent.values())
+    .map((bucket) => ({
+      agent: bucket.agent,
+      inputTokens: bucket.inputTokens,
+      outputTokens: bucket.outputTokens,
+      cacheReadTokens: bucket.cacheReadTokens,
+      cacheWriteTokens: bucket.cacheWriteTokens,
+      totalTokens: bucket.totalTokens,
+      totalCost: bucket.totalCost,
+      turnCount: bucket.turnCount,
+      sourceBreakdown: ["chat", "hooks", "cron"].map(
+        (source) => bucket.sourceBreakdown[source],
+      ),
+    }))
+    .sort((a, b) => b.totalCost - a.totalCost);
+
+  return {
+    agents,
+    totals: agents.reduce(
+      (acc, agentBucket) => {
+        acc.totalCost += Number(agentBucket.totalCost || 0);
+        acc.totalTokens += Number(agentBucket.totalTokens || 0);
+        acc.turnCount += Number(agentBucket.turnCount || 0);
+        return acc;
+      },
+      { totalCost: 0, totalTokens: 0, turnCount: 0 },
+    ),
+  };
+};
+
+const getDailySummary = ({ days = kDefaultDays, timeZone = kUtcTimeZone } = {}) => {
   const database = ensureDb();
-  const { safeDays, startDay } = getPeriodRange(days);
-  const rows = database
+  const { now, safeDays, startDay, timeZone: normalizedTimeZone } = getPeriodRange(
+    days,
+    timeZone,
+  );
+  let rows = [];
+  if (normalizedTimeZone === kUtcTimeZone) {
+    rows = database
+      .prepare(`
+        SELECT
+          date,
+          model,
+          provider,
+          input_tokens,
+          output_tokens,
+          cache_read_tokens,
+          cache_write_tokens,
+          total_tokens,
+          turn_count
+        FROM usage_daily
+        WHERE date >= $startDay
+        ORDER BY date ASC, total_tokens DESC
+      `)
+      .all({ $startDay: startDay });
+  } else {
+    const lookbackMs = now - (safeDays + 2) * kDayMs;
+    const eventRows = database
+      .prepare(`
+        SELECT
+          timestamp,
+          provider,
+          model,
+          input_tokens,
+          output_tokens,
+          cache_read_tokens,
+          cache_write_tokens,
+          total_tokens
+        FROM usage_events
+        WHERE timestamp >= $lookbackMs
+        ORDER BY timestamp ASC
+      `)
+      .all({ $lookbackMs: lookbackMs });
+    const byDateModel = new Map();
+    for (const eventRow of eventRows) {
+      const dayKey = toTimeZoneDayKey(coerceInt(eventRow.timestamp), normalizedTimeZone);
+      if (dayKey < startDay) continue;
+      const model = String(eventRow.model || "unknown");
+      const mapKey = `${dayKey}\u0000${model}`;
+      if (!byDateModel.has(mapKey)) {
+        byDateModel.set(mapKey, {
+          date: dayKey,
+          model,
+          provider: String(eventRow.provider || "unknown"),
+          input_tokens: 0,
+          output_tokens: 0,
+          cache_read_tokens: 0,
+          cache_write_tokens: 0,
+          total_tokens: 0,
+          turn_count: 0,
+        });
+      }
+      const aggregate = byDateModel.get(mapKey);
+      aggregate.input_tokens += coerceInt(eventRow.input_tokens);
+      aggregate.output_tokens += coerceInt(eventRow.output_tokens);
+      aggregate.cache_read_tokens += coerceInt(eventRow.cache_read_tokens);
+      aggregate.cache_write_tokens += coerceInt(eventRow.cache_write_tokens);
+      aggregate.total_tokens += coerceInt(eventRow.total_tokens);
+      aggregate.turn_count += 1;
+      if (!aggregate.provider && eventRow.provider) {
+        aggregate.provider = String(eventRow.provider || "unknown");
+      }
+    }
+    rows = Array.from(byDateModel.values()).sort((a, b) => {
+      if (a.date === b.date) return b.total_tokens - a.total_tokens;
+      return a.date.localeCompare(b.date);
+    });
+  }
+  const enriched = appendCostToRows(rows);
+  const lookbackMs = now - (safeDays + 2) * kDayMs;
+  const eventsRows = database
     .prepare(`
       SELECT
-        date,
+        timestamp,
+        session_id,
+        session_key,
         model,
-        provider,
         input_tokens,
         output_tokens,
         cache_read_tokens,
         cache_write_tokens,
-        total_tokens,
-        turn_count
-      FROM usage_daily
-      WHERE date >= $startDay
-      ORDER BY date ASC, total_tokens DESC
+        total_tokens
+      FROM usage_events
+      WHERE timestamp >= $lookbackMs
+      ORDER BY timestamp ASC
     `)
-    .all({ $startDay: startDay });
-  const enriched = appendCostToRows(rows);
+    .all({ $lookbackMs: lookbackMs });
+  const costByAgent = getAgentCostDistribution({
+    eventsRows,
+    startDay,
+    timeZone: normalizedTimeZone,
+  });
   const byDate = new Map();
   for (const row of enriched) {
     if (!byDate.has(row.date)) byDate.set(row.date, []);
@@ -294,8 +560,10 @@ const getDailySummary = ({ days = kDefaultDays } = {}) => {
   return {
     updatedAt: Date.now(),
     days: safeDays,
+    timeZone: normalizedTimeZone,
     daily,
     totals,
+    costByAgent,
   };
 };
 

package/lib/server/watchdog.js

@@ -1,5 +1,7 @@
 const {
   kWatchdogCheckIntervalMs,
+  kWatchdogDegradedCheckIntervalMs,
+  kWatchdogStartupFailureThreshold,
   kWatchdogMaxRepairAttempts,
   kWatchdogCrashLoopWindowMs,
   kWatchdogCrashLoopThreshold,
@@ -64,9 +66,34 @@ const createWatchdog = ({
     expectedRestartInProgress: false,
     expectedRestartUntilMs: 0,
     pendingRecoveryNoticeSource: "",
+    startupConsecutiveHealthFailures: 0,
   };
   let healthTimer = null;
   let bootstrapHealthTimer = null;
+  let degradedHealthTimer = null;
+
+  const clearDegradedHealthCheckTimer = () => {
+    if (!degradedHealthTimer) return;
+    clearTimeout(degradedHealthTimer);
+    degradedHealthTimer = null;
+  };
+
+  const scheduleDegradedHealthCheck = () => {
+    if (degradedHealthTimer) return;
+    if (state.health !== "degraded" || state.lifecycle !== "running") return;
+    degradedHealthTimer = setTimeout(async () => {
+      degradedHealthTimer = null;
+      if (state.health !== "degraded" || state.lifecycle !== "running") return;
+      await runHealthCheck({
+        source: "degraded_retry",
+        allowAutoRepair: false,
+      });
+      if (state.health === "degraded" && state.lifecycle === "running") {
+        scheduleDegradedHealthCheck();
+      }
+    }, kWatchdogDegradedCheckIntervalMs);
+    if (typeof degradedHealthTimer.unref === "function") degradedHealthTimer.unref();
+  };
 
   const clearExpectedRestartWindow = () => {
     state.expectedRestartInProgress = false;
@@ -337,6 +364,8 @@ const createWatchdog = ({
     }
     if (parsed.ok) {
       const wasUnhealthy = state.health !== "healthy";
+      state.startupConsecutiveHealthFailures = 0;
+      clearDegradedHealthCheckTimer();
       clearExpectedRestartWindow();
       state.health = "healthy";
       if (state.lifecycle !== "crash_loop") state.lifecycle = "running";
@@ -359,6 +388,8 @@ const createWatchdog = ({
       return true;
     }
     if (restartWindowActive) {
+      state.startupConsecutiveHealthFailures = 0;
+      clearDegradedHealthCheckTimer();
       logEvent(
         "health_check",
         source,
@@ -381,6 +412,8 @@ const createWatchdog = ({
       state.lifecycle === "running" &&
       !state.crashRecoveryActive;
     if (withinStartupGrace) {
+      state.startupConsecutiveHealthFailures = 0;
+      clearDegradedHealthCheckTimer();
       logEvent(
         "health_check",
         source,
@@ -397,7 +430,31 @@ const createWatchdog = ({
       return false;
     }
 
+    if (state.health === "unknown" && state.lifecycle === "running") {
+      state.startupConsecutiveHealthFailures += 1;
+      if (state.startupConsecutiveHealthFailures < kWatchdogStartupFailureThreshold) {
+        logEvent(
+          "health_check",
+          source,
+          "ok",
+          {
+            reason: parsed.reason,
+            result,
+            skipped: true,
+            startupFailureRetryActive: true,
+            startupConsecutiveFailures: state.startupConsecutiveHealthFailures,
+            startupFailureThreshold: kWatchdogStartupFailureThreshold,
+          },
+          correlationId,
+        );
+        return false;
+      }
+    } else {
+      state.startupConsecutiveHealthFailures = 0;
+    }
+
     state.health = "degraded";
+    scheduleDegradedHealthCheck();
     logEvent(
       "health_check",
       source,
@@ -435,6 +492,7 @@ const createWatchdog = ({
 
   const onGatewayExit = ({ code, signal, expectedExit = false, stderrTail = [] } = {}) => {
     const correlationId = createCorrelationId();
+    clearDegradedHealthCheckTimer();
     if (expectedExit) {
       state.lifecycle = "restarting";
       state.health = "unknown";
@@ -504,8 +562,10 @@ const createWatchdog = ({
   };
 
   const onGatewayLaunch = ({ startedAt = Date.now(), pid = null } = {}) => {
+    clearDegradedHealthCheckTimer();
     state.lifecycle = "running";
     state.health = "unknown";
+    state.startupConsecutiveHealthFailures = 0;
     state.crashRecoveryActive = false;
     clearExpectedRestartWindow();
     state.uptimeStartedAt = startedAt;
@@ -515,8 +575,10 @@ const createWatchdog = ({
   };
 
   const onExpectedRestart = () => {
+    clearDegradedHealthCheckTimer();
     state.lifecycle = "restarting";
     state.health = "unknown";
+    state.startupConsecutiveHealthFailures = 0;
     state.crashRecoveryActive = false;
     markExpectedRestartWindow();
     startBootstrapHealthChecks();
@@ -533,14 +595,17 @@ const createWatchdog = ({
 
   const start = () => {
     if (healthTimer || bootstrapHealthTimer) return;
+    clearDegradedHealthCheckTimer();
     state.lifecycle = "running";
     state.health = "unknown";
+    state.startupConsecutiveHealthFailures = 0;
     state.uptimeStartedAt = Date.now();
     state.gatewayStartedAt = Date.now();
     startBootstrapHealthChecks();
   };
 
   const stop = () => {
+    clearDegradedHealthCheckTimer();
     if (bootstrapHealthTimer) {
       clearTimeout(bootstrapHealthTimer);
       bootstrapHealthTimer = null;
@@ -550,6 +615,7 @@ const createWatchdog = ({
       healthTimer = null;
     }
     state.lifecycle = "stopped";
+    state.startupConsecutiveHealthFailures = 0;
   };
 
   const getStatus = () => {