@checkstack/healthcheck-backend 1.17.0 → 1.19.0

package/src/adaptive-timeout.test.ts

@@ -0,0 +1,91 @@
+import { describe, expect, test } from "bun:test";
+import {
+  adaptiveTimeout,
+  DEFAULT_TIMEOUT_ABSOLUTE_FLOOR_MS,
+} from "./adaptive-timeout";
+
+describe("adaptiveTimeout", () => {
+  const configuredMs = 30_000;
+
+  test("guardrail 1: no baseline => never shrink", () => {
+    expect(
+      adaptiveTimeout({
+        configuredMs,
+        healthyBaselineMs: undefined,
+        isSuspect: true,
+        isRecoveryProbe: false,
+      }),
+    ).toBe(configuredMs);
+  });
+
+  test("non-suspect check keeps the full configured timeout", () => {
+    expect(
+      adaptiveTimeout({
+        configuredMs,
+        healthyBaselineMs: 200,
+        isSuspect: false,
+        isRecoveryProbe: false,
+      }),
+    ).toBe(configuredMs);
+  });
+
+  test("guardrail 3: recovery probe always uses the full configured timeout", () => {
+    expect(
+      adaptiveTimeout({
+        configuredMs,
+        healthyBaselineMs: 200,
+        isSuspect: true,
+        isRecoveryProbe: true,
+      }),
+    ).toBe(configuredMs);
+  });
+
+  test("fast healthy check shrinks toward the floor (200ms => ~1s)", () => {
+    // 200 * 1.5 = 300 < floor => clamped to the absolute floor.
+    expect(
+      adaptiveTimeout({
+        configuredMs,
+        healthyBaselineMs: 200,
+        isSuspect: true,
+        isRecoveryProbe: false,
+      }),
+    ).toBe(DEFAULT_TIMEOUT_ABSOLUTE_FLOOR_MS);
+  });
+
+  test("deadlock guard: a slow-but-healthy check (10s) never shrinks below its own latency", () => {
+    // 10_000 * 1.5 = 15_000: a recovering 10s run still passes at 15s.
+    const t = adaptiveTimeout({
+      configuredMs,
+      healthyBaselineMs: 10_000,
+      isSuspect: true,
+      isRecoveryProbe: false,
+    });
+    expect(t).toBe(15_000);
+    expect(t).toBeGreaterThan(10_000);
+  });
+
+  test("shrink never exceeds the configured timeout", () => {
+    // baseline*factor would exceed configured => clamp down to configured.
+    expect(
+      adaptiveTimeout({
+        configuredMs: 5_000,
+        healthyBaselineMs: 8_000,
+        isSuspect: true,
+        isRecoveryProbe: false,
+      }),
+    ).toBe(5_000);
+  });
+
+  test("honors custom safetyFactor and absoluteFloor", () => {
+    expect(
+      adaptiveTimeout({
+        configuredMs,
+        healthyBaselineMs: 1_000,
+        isSuspect: true,
+        isRecoveryProbe: false,
+        safetyFactor: 2,
+        absoluteFloorMs: 500,
+      }),
+    ).toBe(2_000);
+  });
+});

package/src/adaptive-timeout.ts

@@ -0,0 +1,75 @@
+/**
+ * Adaptive execution timeout for slot-hogging health checks.
+ *
+ * A check that hangs holds its concurrency slot for the FULL configured timeout
+ * (see `queue-executor.ts` — the per-env `Promise.race` frees the slot only when
+ * the timeout fires). When a target is consistently timing out, we can free that
+ * slot sooner by probing it with a SHORTER timeout — but only down to a value at
+ * which a genuinely HEALTHY run of this same check would still succeed, or we
+ * would abort even a recovering target and never let it go healthy again.
+ *
+ * The floor is therefore derived from the check's OWN measured healthy latency,
+ * never a global constant. Four guardrails make a recovery deadlock impossible:
+ *
+ *   1. No baseline (no recent healthy run) => NO shrink. Without evidence of the
+ *      target's healthy latency we cannot tell "hung" from "legitimately slow and
+ *      about to succeed", so we keep the full configured timeout.
+ *   2. The baseline is computed from SUCCESSFUL runs only (caller's job), so a
+ *      timed-out run (latency ~= timeout) can never ratchet the floor downward.
+ *   3. The periodic recovery probe passes `isRecoveryProbe: true` and always gets
+ *      the FULL configured timeout — so a genuinely-slow-but-healthy target (e.g.
+ *      a 10s computation) is always eventually re-measured at its real latency.
+ *      This is the by-construction deadlock breaker.
+ *   4. A single healthy run clears the suspect classification upstream, so the
+ *      full timeout is restored immediately (hysteresis).
+ */
+
+/** Default multiplier applied to the healthy-latency baseline. */
+export const DEFAULT_TIMEOUT_SAFETY_FACTOR = 1.5;
+/** Default absolute lower bound; the timeout is never shrunk below this. */
+export const DEFAULT_TIMEOUT_ABSOLUTE_FLOOR_MS = 1000;
+
+export interface AdaptiveTimeoutInput {
+  /** The user-configured execution timeout (ms). The shrink never exceeds it. */
+  configuredMs: number;
+  /**
+   * p95 (or max) latency of this check's recent SUCCESSFUL runs, in ms.
+   * `undefined` means "no healthy baseline" => guardrail 1 (never shrink).
+   */
+  healthyBaselineMs: number | undefined;
+  /** Whether this check is classified as a consistent slot-hogging failure. */
+  isSuspect: boolean;
+  /** Whether this run is the periodic full-timeout recovery probe (guardrail 3). */
+  isRecoveryProbe: boolean;
+  /** Multiplier on the baseline. Defaults to {@link DEFAULT_TIMEOUT_SAFETY_FACTOR}. */
+  safetyFactor?: number;
+  /** Hard lower bound. Defaults to {@link DEFAULT_TIMEOUT_ABSOLUTE_FLOOR_MS}. */
+  absoluteFloorMs?: number;
+}
+
+/**
+ * Resolve the effective execution timeout for a single (env-scoped) run.
+ * Returns `configuredMs` unchanged unless the check is a suspect slot-hogger
+ * WITH a healthy baseline AND this is not a recovery probe.
+ */
+export function adaptiveTimeout(input: AdaptiveTimeoutInput): number {
+  const {
+    configuredMs,
+    healthyBaselineMs,
+    isSuspect,
+    isRecoveryProbe,
+    safetyFactor = DEFAULT_TIMEOUT_SAFETY_FACTOR,
+    absoluteFloorMs = DEFAULT_TIMEOUT_ABSOLUTE_FLOOR_MS,
+  } = input;
+
+  // Guardrails 1 & 3, and the non-suspect fast path: use the full timeout.
+  if (!isSuspect || isRecoveryProbe || healthyBaselineMs === undefined) {
+    return configuredMs;
+  }
+
+  // Shrink toward the target's own healthy latency, clamped to
+  // [absoluteFloor, configured]. For a 10s-healthy check this stays >= ~15s;
+  // for a 200ms-healthy check it drops to the floor (~1s).
+  const shrunk = Math.round(healthyBaselineMs * safetyFactor);
+  return Math.min(configuredMs, Math.max(absoluteFloorMs, shrunk));
+}

package/src/ai/system-signals-contributor.test.ts

@@ -20,6 +20,8 @@ const unhealthyStatuses: HealthcheckSignalStatuses = {
         configurationName: "Ping",
         status: "unhealthy",
         runsConsidered: 5,
+        sliceCount: 1,
+        failingSliceCount: 1,
       },
     ],
   },

package/src/automations.test.ts

@@ -10,6 +10,7 @@ import {
   assignmentArtifactType,
   checkFailedTrigger,
   createHealthCheckActions,
+  type HealthCheckActionDeps,
   healthCheckTriggers,
   systemDegradedTrigger,
   systemHealthChangedTrigger,
@@ -146,13 +147,18 @@ describe("assignmentArtifactType", () => {
 
 function makeService(args: {
   setAssignmentEnabledReturn?: boolean;
+  enqueueEnvironmentIds?: (string | null)[];
 }): HealthCheckService & { setMock: ReturnType<typeof mock> } {
   const setMock = mock(
     async (_sysId: string, _cfgId: string, _enabled: boolean) =>
       args.setAssignmentEnabledReturn ?? true,
   );
+  const resolveEnqueueEnvironmentIds = mock(
+    async () => args.enqueueEnvironmentIds ?? [null],
+  );
   return {
     setAssignmentEnabled: setMock,
+    resolveEnqueueEnvironmentIds,
     setMock,
   } as unknown as HealthCheckService & { setMock: ReturnType<typeof mock> };
 }
@@ -174,6 +180,11 @@ function makeQueueManager(): QueueEnqueueRecorder {
   return { queueManager, enqueueMock };
 }
 
+// The actions only need a catalog client shape for `run_now`, which delegates
+// environment resolution to the service mock, so a bare stub suffices.
+const catalogClientStub =
+  {} as unknown as HealthCheckActionDeps["catalogClient"];
+
 describe("healthcheck.run_now", () => {
   it("enqueues a one-off job and emits an enqueued=true artifact", async () => {
     const service = makeService({});
@@ -182,6 +193,7 @@ describe("healthcheck.run_now", () => {
     const [runNow] = createHealthCheckActions({
       service,
       queueManager,
+      catalogClient: catalogClientStub,
       emitHook: emitHook as never,
     });
 
@@ -198,10 +210,42 @@ describe("healthcheck.run_now", () => {
     expect(enqueueMock.mock.calls[0]![0]).toEqual({
       configId: "cfg-1",
       systemId: "sys-1",
+      environmentId: null,
     });
     // run_now doesn't mutate any DB row → no hook to emit.
     expect(emitHook).not.toHaveBeenCalled();
   });
+
+  it("enqueues one job per effective environment slice", async () => {
+    const service = makeService({ enqueueEnvironmentIds: ["prod", "staging"] });
+    const { queueManager, enqueueMock } = makeQueueManager();
+    const emitHook = mock(async (_hook: unknown, _payload: unknown) => {});
+    const [runNow] = createHealthCheckActions({
+      service,
+      queueManager,
+      catalogClient: catalogClientStub,
+      emitHook: emitHook as never,
+    });
+
+    const result = await runNow!.execute({
+      ...ctxBase,
+      consumedArtifacts: {},
+      config: { systemId: "sys-1", configurationId: "cfg-1" } as never,
+    });
+
+    expect(result.success).toBe(true);
+    expect(enqueueMock).toHaveBeenCalledTimes(2);
+    expect(enqueueMock.mock.calls[0]![0]).toEqual({
+      configId: "cfg-1",
+      systemId: "sys-1",
+      environmentId: "prod",
+    });
+    expect(enqueueMock.mock.calls[1]![0]).toEqual({
+      configId: "cfg-1",
+      systemId: "sys-1",
+      environmentId: "staging",
+    });
+  });
 });
 
 describe("healthcheck.enable_assignment", () => {
@@ -212,6 +256,7 @@ describe("healthcheck.enable_assignment", () => {
     const [, enable] = createHealthCheckActions({
       service,
       queueManager,
+      catalogClient: catalogClientStub,
       emitHook: emitHook as never,
     });
 
@@ -236,6 +281,7 @@ describe("healthcheck.enable_assignment", () => {
     const [, enable] = createHealthCheckActions({
       service,
       queueManager,
+      catalogClient: catalogClientStub,
       emitHook: emitHook as never,
     });
 
@@ -260,6 +306,7 @@ describe("healthcheck.disable_assignment", () => {
     const [, , disable] = createHealthCheckActions({
       service,
       queueManager,
+      catalogClient: catalogClientStub,
       emitHook: emitHook as never,
     });
 

package/src/automations.ts

@@ -26,6 +26,8 @@
 import { z } from "zod";
 import { Versioned, type Hook } from "@checkstack/backend-api";
 import type { QueueManager } from "@checkstack/queue-api";
+import type { InferClient } from "@checkstack/common";
+import type { CatalogApi } from "@checkstack/catalog-common";
 import type {
   ActionDefinition,
   TriggerDefinition,
@@ -234,6 +236,7 @@ export const assignmentArtifactType = {
 export interface HealthCheckActionDeps {
   service: HealthCheckService;
   queueManager: QueueManager;
+  catalogClient: InferClient<typeof CatalogApi>;
   emitHook: <T>(hook: Hook<T>, payload: T) => Promise<void>;
 }
 
@@ -256,12 +259,25 @@ export function createHealthCheckActions(
       const queue = deps.queueManager.getQueue<HealthCheckJobPayload>(
         HEALTH_CHECK_QUEUE,
       );
-      await queue.enqueue({
-        configId: config.configurationId,
+      // Enqueue one one-off job per effective environment slice so a manual
+      // run covers exactly the same slices the recurring schedule does. An
+      // assignment with no effective environments enqueues a single env-less
+      // run (`environmentId: null`).
+      const environmentIds = await deps.service.resolveEnqueueEnvironmentIds({
         systemId: config.systemId,
+        configurationId: config.configurationId,
+        catalogClient: deps.catalogClient,
+        logger,
       });
+      for (const environmentId of environmentIds) {
+        await queue.enqueue({
+          configId: config.configurationId,
+          systemId: config.systemId,
+          environmentId,
+        });
+      }
       logger.info(
-        `Automation enqueued run for ${config.systemId}:${config.configurationId}`,
+        `Automation enqueued ${environmentIds.length} run(s) for ${config.systemId}:${config.configurationId}`,
       );
       return {
         success: true,

package/src/health-notification-content.test.ts

@@ -0,0 +1,89 @@
+import { describe, it, expect } from "bun:test";
+import { buildHealthTransitionNotification } from "./health-notification-content";
+
+describe("buildHealthTransitionNotification", () => {
+  const base = {
+    systemId: "sys-1",
+    systemName: "Payments API",
+    configurationId: "cfg-9",
+    checkName: "HTTP 200 probe",
+    newStatus: "unhealthy" as const,
+  };
+
+  it("names the failing check in the body for an unhealthy transition", () => {
+    const payload = buildHealthTransitionNotification({
+      ...base,
+      transition: "escalation",
+    });
+    expect(payload.body).toContain('Health check **"HTTP 200 probe"**');
+    expect(payload.body).toContain("**Payments API**");
+    expect(payload.importance).toBe("critical");
+  });
+
+  it("names the failing check for a degraded transition", () => {
+    const payload = buildHealthTransitionNotification({
+      ...base,
+      newStatus: "degraded",
+      transition: "escalation",
+    });
+    expect(payload.body).toContain('Health check **"HTTP 200 probe"**');
+    expect(payload.importance).toBe("warning");
+  });
+
+  it("pushes a healthcheck.healthcheck subject alongside the system subject", () => {
+    const payload = buildHealthTransitionNotification({
+      ...base,
+      transition: "escalation",
+    });
+    const subjects = payload.subjects ?? [];
+    expect(subjects).toHaveLength(2);
+    expect(subjects[0]).toMatchObject({
+      kind: "catalog.system",
+      id: "sys-1",
+      name: "Payments API",
+    });
+    expect(subjects[1]).toMatchObject({
+      kind: "healthcheck.healthcheck",
+      id: "cfg-9",
+      name: "HTTP 200 probe",
+      status: "unhealthy",
+    });
+    // Check subject deep-links to its run history.
+    expect(subjects[1]?.url).toContain("sys-1");
+    expect(subjects[1]?.url).toContain("cfg-9");
+  });
+
+  it("falls back to the configuration id when no name is resolved", () => {
+    const payload = buildHealthTransitionNotification({
+      ...base,
+      checkName: "cfg-9",
+      transition: "escalation",
+    });
+    expect(payload.body).toContain('Health check **"cfg-9"**');
+    expect((payload.subjects ?? [])[1]).toMatchObject({ name: "cfg-9" });
+  });
+
+  it("qualifies the body with the environment name when env-scoped", () => {
+    const payload = buildHealthTransitionNotification({
+      ...base,
+      transition: "escalation",
+      environmentId: "env-prod",
+      environmentName: "Production",
+    });
+    expect(payload.body).toContain("in environment **Production**");
+    expect(payload.title).toContain("(Production)");
+  });
+
+  it("stays system-level and omits the check subject on recovery", () => {
+    const payload = buildHealthTransitionNotification({
+      ...base,
+      newStatus: "healthy",
+      transition: "recovery",
+    });
+    expect(payload.body).not.toContain("Health check **");
+    expect(payload.importance).toBe("info");
+    const subjects = payload.subjects ?? [];
+    expect(subjects).toHaveLength(1);
+    expect(subjects[0]).toMatchObject({ kind: "catalog.system" });
+  });
+});

package/src/health-notification-content.ts

@@ -0,0 +1,138 @@
+import { resolveRoute, type InferClient } from "@checkstack/common";
+import { catalogRoutes, createSystemSubject } from "@checkstack/catalog-common";
+import type { NotificationApi } from "@checkstack/notification-common";
+import {
+  createHealthcheckSubject,
+  healthcheckRoutes,
+  systemHealthCollapseKey,
+  healthcheckSystemSubscription,
+  type HealthCheckStatus,
+} from "@checkstack/healthcheck-common";
+import type { TransitionKind } from "./notification-policy";
+
+/** The subset of `notifyForSubscription`'s input this builder produces. */
+type NotifyForSubscriptionInput = Parameters<
+  InferClient<typeof NotificationApi>["notifyForSubscription"]
+>[0];
+
+/**
+ * Inputs to {@link buildHealthTransitionNotification}. Pure data only - the
+ * catalog client is unused here (parents are resolved server-side) and thus
+ * omitted; every field is derived before the call site in the queue executor.
+ */
+export interface HealthTransitionNotificationInput {
+  transition: Exclude<TransitionKind, "none">;
+  systemId: string;
+  systemName: string;
+  configurationId: string;
+  /** Resolved display name of the check that drove the transition. */
+  checkName: string;
+  newStatus: HealthCheckStatus;
+  /** Concrete env id for a per-env slice, null/undefined for the system rollup. */
+  environmentId?: string | null;
+  /** Human-readable env name for the body/title. */
+  environmentName?: string;
+}
+
+/**
+ * Build the notification payload for a health-state transition. Pure and
+ * side-effect free so it can be unit-tested directly. Extracted from
+ * `notifyStateChange` so the body/title/subject wording (which now NAMES the
+ * failing check and pushes a `healthcheck.healthcheck` subject) is verifiable
+ * without booting the whole queue executor.
+ *
+ * Recovery bodies stay system-level (the whole system is green again; naming
+ * one check would mislead) and omit the check subject. Failing transitions
+ * (escalation / de-escalation) name the check in the body and add it as a
+ * subject deep-linked to its run history.
+ */
+export function buildHealthTransitionNotification(
+  input: HealthTransitionNotificationInput,
+): NotifyForSubscriptionInput {
+  const {
+    transition,
+    systemId,
+    systemName,
+    configurationId,
+    checkName,
+    newStatus,
+    environmentId,
+    environmentName,
+  } = input;
+
+  const envScoped = typeof environmentId === "string";
+  const envSuffix = envScoped && environmentName ? ` (${environmentName})` : "";
+  const envQualifier = envScoped
+    ? ` in environment **${environmentName ?? environmentId}**`
+    : "";
+
+  let title: string;
+  let body: string;
+  let importance: "info" | "warning" | "critical";
+
+  if (transition === "recovery") {
+    title = `System health restored${envSuffix}: ${systemName}`;
+    body = envScoped
+      ? `Health checks for **${systemName}** in environment **${environmentName ?? environmentId}** are now passing. The system has returned to normal operation in that environment.`
+      : `All health checks for **${systemName}** are now passing. The system has returned to normal operation.`;
+    importance = "info";
+  } else if (newStatus === "unhealthy") {
+    title = `System health critical${envSuffix}: ${systemName}`;
+    body = `Health check **"${checkName}"** on **${systemName}**${envQualifier} is failing. The system is unhealthy and may be down${envScoped ? " in that environment" : ""}.`;
+    importance = "critical";
+  } else {
+    // degraded - either an escalation from healthy or a partial recovery
+    title = `System health degraded${envSuffix}: ${systemName}`;
+    body = `Health check **"${checkName}"** on **${systemName}**${envQualifier} is failing. The system may be experiencing issues${envScoped ? " in that environment" : ""}.`;
+    importance = "warning";
+  }
+
+  const systemDetailPath = resolveRoute(catalogRoutes.routes.systemDetail, {
+    systemId,
+  });
+  // Recovery lands on the default (all) view; failing transitions deep-link
+  // operators into the failing-checks filter so they can debug immediately.
+  const actionUrl =
+    transition === "recovery"
+      ? systemDetailPath
+      : `${systemDetailPath}?filter=failing`;
+  const actionLabel =
+    transition === "recovery" ? "View System" : "View failing checks";
+
+  return {
+    specId: healthcheckSystemSubscription.specId,
+    resourceKeys: [systemId],
+    title,
+    body,
+    importance,
+    action: { label: actionLabel, url: actionUrl },
+    // Env-qualified collapse key so two failing envs of one system generate
+    // two independent notification cards (one per env) instead of merging.
+    collapseKey: envScoped
+      ? systemHealthCollapseKey(systemId, environmentId)
+      : systemHealthCollapseKey(systemId),
+    subjects: [
+      createSystemSubject({
+        id: systemId,
+        name: systemName,
+        url: systemDetailPath,
+        status: newStatus,
+      }),
+      // Name the failing check as its own subject for every non-recovery
+      // transition, deep-linked to its run history. Omitted on recovery.
+      ...(transition === "recovery"
+        ? []
+        : [
+            createHealthcheckSubject({
+              id: configurationId,
+              name: checkName,
+              url: resolveRoute(healthcheckRoutes.routes.historyDetail, {
+                systemId,
+                configurationId,
+              }),
+              status: newStatus,
+            }),
+          ]),
+    ],
+  };
+}

package/src/healthcheck-gitops-kinds.test.ts

@@ -20,6 +20,34 @@ import { Versioned } from "@checkstack/backend-api";
  * System → healthchecks extension in isolation with mock services.
  */
 
+// The System extension's reconcile converges the per-env recurring jobs via
+// `reconcileHealthCheckJobs`. That path has its own dedicated tests
+// (schedule-reconciler.test.ts); here we feed it EMPTY db/catalog/queue stubs so
+// it is a safe no-op and these tests can focus on the association logic.
+// (A `mock.module` would leak process-wide and break schedule-reconciler.test.)
+function emptyReconcileDbStub() {
+  return {
+    select: () => ({
+      from: () => ({
+        innerJoin: () => ({ where: () => Promise.resolve([]) }),
+        groupBy: () => Promise.resolve([]),
+      }),
+    }),
+  } as never;
+}
+function emptyReconcileQueueManager() {
+  return {
+    getQueue: () => ({
+      scheduleRecurring: async () => "job-123",
+      listRecurringJobs: async () => [],
+      getRecurringJobDetails: async () => undefined,
+      cancelRecurring: async () => {},
+    }),
+  } as never;
+}
+const emptyCatalogClient = () =>
+  ({ resolveSystemEnvironments: async () => [] }) as never;
+
 // ─── Mock Healthcheck Service ──────────────────────────────────────────────
 
 interface MockConfig {
@@ -231,7 +259,9 @@ describe("Healthcheck GitOps Kind: Healthcheck", () => {
       createService: () => mockService as any,
       getHealthCheckRegistry: () => mockHCRegistry as any,
       getCollectorRegistry: () => mockCollectorRegistry as any,
-      getQueueManager: () => ({ getQueue: () => ({ scheduleRecurring: async () => "job-123" }) } as any),
+      getQueueManager: () => emptyReconcileQueueManager(),
+      getDb: () => emptyReconcileDbStub(),
+      getCatalogClient: () => emptyCatalogClient(),
     };
     return buildHealthcheckKind(mockDeps);
   }
@@ -594,7 +624,9 @@ describe("Healthcheck GitOps Kind: System Extension", () => {
         }) as never,
       getHealthCheckRegistry: () => createMockHealthCheckRegistry() as never,
       getCollectorRegistry: () => createMockCollectorRegistry() as never,
-      getQueueManager: () => ({ getQueue: () => ({ scheduleRecurring: async () => "job-123" }) } as any),
+      getQueueManager: () => emptyReconcileQueueManager(),
+      getDb: () => emptyReconcileDbStub(),
+      getCatalogClient: () => emptyCatalogClient(),
     });
   }
 

package/src/healthcheck-gitops-kinds.ts

@@ -25,7 +25,11 @@ import {
   enumField,
 } from "@checkstack/backend-api";
 import type { QueueManager } from "@checkstack/queue-api";
-import { scheduleHealthCheck } from "./queue-executor";
+import type { SafeDatabase } from "@checkstack/backend-api";
+import type { InferClient } from "@checkstack/common";
+import type { CatalogApi } from "@checkstack/catalog-common";
+import type * as schema from "./schema";
+import { reconcileHealthCheckJobs } from "./schedule-reconciler";
 
 /**
  * Lazy accessor functions — populated during init(), consumed during reconcile.
@@ -37,6 +41,8 @@ interface HealthcheckGitOpsKindsDeps {
   getHealthCheckRegistry: () => HealthCheckRegistry;
   getCollectorRegistry: () => CollectorRegistry;
   getQueueManager: () => QueueManager;
+  getDb: () => SafeDatabase<typeof schema>;
+  getCatalogClient: () => InferClient<typeof CatalogApi>;
 }
 
 // ─── Healthcheck Spec Schema ───────────────────────────────────────────────
@@ -382,18 +388,16 @@ export function buildSystemHealthcheckExtension(
           notificationPolicy,
         });
 
-        // Retrieve config to get the interval for scheduling
-        const config = await service.getConfiguration(configId);
-        if (config) {
-          await scheduleHealthCheck({
-            queueManager: deps.getQueueManager(),
-            payload: {
-              configId,
-              systemId: systemEntityId,
-            },
-            intervalSeconds: config.intervalSeconds,
-          });
-        }
+        // Reconcile this system's per-env recurring jobs so the new
+        // association starts probing right away (system-scoped: add/update
+        // only, orphan cleanup is owned by the periodic full reconcile).
+        await reconcileHealthCheckJobs({
+          db: deps.getDb(),
+          queueManager: deps.getQueueManager(),
+          catalogClient: deps.getCatalogClient(),
+          logger: context.logger,
+          systemId: systemEntityId,
+        });
 
         context.logger.info(
           `GitOps: associated ${entry.ref.kind} "${entry.ref.name}" (${configId}) with System "${entity.metadata.name}" and scheduled execution`,