@@ -347,6 +347,11 @@ export function createLiquidContext(
   } as Context
 }
 
+// Data and reusable files have no versions of their own, so they render in every current version.
+export function getLinkCheckVersions(page?: Pick<Page, 'applicableVersions'>): string[] {
+  return page?.applicableVersions?.length ? page.applicableVersions : Object.keys(allVersions)
+}
+
 // Cache renderLiquid after a dynamic import to avoid circular imports and repeated import overhead.
 type RenderLiquidModule = (template: string, context: Context) => Promise<string>
 let _renderLiquid: RenderLiquidModule | null = null
 
@@ -433,6 +433,47 @@ export function mergeInternalLinkReports(
   return { ...report, versionsChecked, summary: report.summary + scope }
 }
 
+// One href can redirect in one version and miss in another, so a missing target outranks a
+// redirect warning and the PR check still fails on it.
+export function mergeVersionedLinkFlaws(flaws: BrokenLink[]): {
+  brokenLinks: BrokenLink[]
+  redirectLinks: BrokenLink[]
+} {
+  const merged = new Map<string, BrokenLink>()
+
+  for (const flaw of flaws) {
+    const key = `${flaw.href}\u0000${flaw.file}`
+    const existing = merged.get(key)
+    const lines = [...new Set([...(existing?.lines ?? []), ...flaw.lines])].sort((a, b) => a - b)
+    if (!existing) {
+      merged.set(key, { ...flaw, lines })
+    } else if (existing.isRedirect && !flaw.isRedirect) {
+      const { href, file, text, isAutotitle } = existing
+      merged.set(key, { href, file, lines, text, isAutotitle })
+    } else {
+      existing.lines = lines
+      if (existing.isRedirect && flaw.isRedirect) {
+        existing.requiresVersionContext =
+          existing.requiresVersionContext || flaw.requiresVersionContext
+        if (
+          existing.redirectTarget &&
+          flaw.redirectTarget &&
+          !sameDestination(existing.redirectTarget, flaw.redirectTarget)
+        ) {
+          existing.hasConflictingRedirectTargets = true
+        }
+        existing.redirectTarget = existing.redirectTarget ?? flaw.redirectTarget
+      }
+    }
+  }
+
+  const all = [...merged.values()]
+  return {
+    brokenLinks: all.filter((flaw) => !flaw.isRedirect),
+    redirectLinks: all.filter((flaw) => flaw.isRedirect),
+  }
+}
+
 export function generateInternalLinkReport(
   brokenLinks: BrokenLink[],
   options: {
 
@@ -19,6 +19,8 @@ import {
   checkAssetLink,
   isAssetLink,
   getRelativePath,
+  getLinkCheckVersions,
+  type ExtractedLink,
 } from '@/links/lib/extract-links'
 import {
   buildRenderContext,
@@ -33,6 +35,7 @@ import {
   type CrossPageAnchorFlaw,
   generatePRComment,
   groupBrokenLinks,
+  mergeVersionedLinkFlaws,
 } from '@/links/lib/link-report'
 import { uploadArtifact } from '@/links/scripts/upload-artifact'
 import github from '@/workflows/github'
@@ -50,67 +53,72 @@ interface CheckResult {
 
 async function checkFile(
   filePath: string,
+  sourcePage: Page | undefined,
   pageMap: Record<string, Page>,
   redirects: Record<string, string>,
-  version: string = 'free-pro-team@latest',
   language: string = 'en',
 ): Promise<CheckResult> {
-  const brokenLinks: BrokenLink[] = []
-  const redirectLinks: BrokenLink[] = []
   let totalLinksChecked = 0
 
   let content: string
   try {
     content = fs.readFileSync(filePath, 'utf-8')
   } catch {
     console.warn(`Could not read file: ${filePath}`)
-    return { file: filePath, brokenLinks, redirectLinks, totalLinksChecked }
+    return { file: filePath, brokenLinks: [], redirectLinks: [], totalLinksChecked }
   }
 
-  const context = createLiquidContext(version, language)
+  const file = getRelativePath(filePath)
+  const flaws: BrokenLink[] = []
+  // Liquid shifts rendered lines, so use raw source lines unless a Liquid-built href has none.
+  const flawFor = (link: ExtractedLink): BrokenLink => {
+    const lines = findLinkLines(
+      content,
+      link.fragment ? `${link.href}#${link.fragment}` : link.href,
+    )
+    return {
+      href: link.href,
+      file,
+      lines: lines.length ? lines : [link.line],
+      text: link.text,
+      isAutotitle: link.isAutotitle,
+    }
+  }
 
-  const { internalLinks } = await extractLinksWithLiquid(content, context)
+  // ifversion blocks and versionless links depend on the version, so check each one.
+  for (const version of getLinkCheckVersions(sourcePage)) {
+    // Pages use the anchor check's context so version names and feature flags evaluate like the site.
+    const context = sourcePage
+      ? buildRenderContext(sourcePage, version, pageMap, redirects)
+      : createLiquidContext(version, language)
 
-  // imageLinks are excluded: they're static assets, not docs pages.
-  totalLinksChecked = internalLinks.length
+    const { internalLinks } = await extractLinksWithLiquid(content, context)
 
-  for (const link of internalLinks) {
-    if (isAssetLink(link.href)) {
-      if (!checkAssetLink(link.href)) {
-        brokenLinks.push({
-          href: link.href,
-          file: getRelativePath(filePath),
-          lines: [link.line],
-          text: link.text,
-          isAutotitle: link.isAutotitle,
-        })
+    // imageLinks are excluded: they're static assets, not docs pages.
+    totalLinksChecked = Math.max(totalLinksChecked, internalLinks.length)
+
+    for (const link of internalLinks) {
+      if (isAssetLink(link.href)) {
+        if (!checkAssetLink(link.href)) flaws.push(flawFor(link))
+        continue
       }
-      continue
-    }
 
-    const result = checkInternalLink(link.href, pageMap, redirects)
-
-    if (!result.exists) {
-      brokenLinks.push({
-        href: link.href,
-        file: getRelativePath(filePath),
-        lines: [link.line],
-        text: link.text,
-        isAutotitle: link.isAutotitle,
-      })
-    } else if (result.isRedirect) {
-      redirectLinks.push({
-        href: link.href,
-        file: getRelativePath(filePath),
-        lines: [link.line],
-        text: link.text,
-        isAutotitle: link.isAutotitle,
-        isRedirect: true,
-        redirectTarget: result.redirectTarget,
-      })
+      const result = checkInternalLink(link.href, pageMap, redirects, version, language)
+
+      if (!result.exists) {
+        flaws.push(flawFor(link))
+      } else if (result.isRedirect) {
+        flaws.push({
+          ...flawFor(link),
+          isRedirect: true,
+          redirectTarget: result.redirectTarget,
+          requiresVersionContext: result.requiresVersionContext,
+        })
+      }
     }
   }
 
+  const { brokenLinks, redirectLinks } = mergeVersionedLinkFlaws(flaws)
   return { file: filePath, brokenLinks, redirectLinks, totalLinksChecked }
 }
 
@@ -369,13 +377,13 @@ async function main() {
       console.log(`  Checking: ${file}`)
     }
 
-    const result = await checkFile(filePath, pageMap, redirects)
+    const sourcePage = pageByRelativePath.get(getRelativePath(filePath))
+    const result = await checkFile(filePath, sourcePage, pageMap, redirects)
     allBrokenLinks.push(...result.brokenLinks)
     allRedirectLinks.push(...result.redirectLinks)
     totalLinksChecked += result.totalLinksChecked
 
     // Skip changed files outside pageByRelativePath because data and reusables have no versions of their own.
-    const sourcePage = pageByRelativePath.get(getRelativePath(filePath))
     if (checkAnchors && sourcePage) {
       allBrokenAnchors.push(
         ...(await checkFileAnchors(filePath, sourcePage, pageMap, redirects, headingCache)),
 
@@ -6,10 +6,12 @@ import {
   resolveInternalLinkKey,
   checkAssetLink,
   isAssetLink,
+  getLinkCheckVersions,
   createLiquidContext,
   extractLinksWithLiquid,
 } from '../lib/extract-links'
 import { latest, latestStable } from '@/versions/lib/enterprise-server-releases'
+import { allVersions } from '@/versions/lib/all-versions'
 import { getFeaturesByVersion } from '@/versions/middleware/features'
 import type { Page } from '@/types'
 
@@ -973,6 +975,33 @@ describe('resolveInternalLinkKey version precedence', () => {
   })
 })
 
+describe('getLinkCheckVersions', () => {
+  test('returns every version the page applies to', () => {
+    const versions = ['free-pro-team@latest', 'enterprise-cloud@latest']
+    expect(getLinkCheckVersions({ applicableVersions: versions })).toEqual(versions)
+  })
+
+  test('returns every current version for files without a page', () => {
+    expect(getLinkCheckVersions(undefined)).toEqual(Object.keys(allVersions))
+    expect(getLinkCheckVersions({ applicableVersions: [] })).toEqual(Object.keys(allVersions))
+  })
+
+  test('resolves versionless links on GHEC-only pages without a redirect', () => {
+    // Pages without FPT get a versionless fallback redirect to their first version.
+    const pageMap = {
+      '/en/enterprise-cloud@latest/admin/create-account': {} as unknown as Page,
+    }
+    const redirects = {
+      '/admin/create-account': '/enterprise-cloud@latest/admin/create-account',
+    }
+    const versions = getLinkCheckVersions({ applicableVersions: ['enterprise-cloud@latest'] })
+    for (const version of versions) {
+      const result = checkInternalLink('/admin/create-account', pageMap, redirects, version)
+      expect(result).toEqual({ exists: true, isRedirect: false })
+    }
+  })
+})
+
 describe('extractLinksWithLiquid with createLiquidContext', () => {
   const fptFeatures = getFeaturesByVersion('free-pro-team@latest')
   const fptFeature = Object.keys(fptFeatures).find((name) => fptFeatures[name])
 
@@ -11,6 +11,7 @@ import {
   generateSampleReports,
   classifyFixStrategy,
   mergeInternalLinkReports,
+  mergeVersionedLinkFlaws,
   describeVersions,
 } from '../lib/link-report'
 
@@ -1137,6 +1138,69 @@ describe('merging redirect targets across versions', () => {
   })
 })
 
+describe('mergeVersionedLinkFlaws', () => {
+  const file = 'content/admin/page.md'
+
+  test('reports a missing target even when an earlier version redirects', () => {
+    const { brokenLinks, redirectLinks } = mergeVersionedLinkFlaws([
+      {
+        href: '/admin/old',
+        file,
+        lines: [4],
+        isRedirect: true,
+        redirectTarget: '/enterprise-cloud@latest/admin/new',
+      },
+      { href: '/admin/old', file, lines: [9] },
+    ])
+    expect(redirectLinks).toEqual([])
+    expect(brokenLinks).toEqual([{ href: '/admin/old', file, lines: [4, 9] }])
+  })
+
+  test('keeps a missing target when a later version redirects', () => {
+    const { brokenLinks, redirectLinks } = mergeVersionedLinkFlaws([
+      { href: '/admin/old', file, lines: [9] },
+      { href: '/admin/old', file, lines: [9], isRedirect: true, redirectTarget: '/admin/new' },
+    ])
+    expect(redirectLinks).toEqual([])
+    expect(brokenLinks).toEqual([{ href: '/admin/old', file, lines: [9] }])
+  })
+
+  test('merges redirect occurrences and flags conflicting targets', () => {
+    const { brokenLinks, redirectLinks } = mergeVersionedLinkFlaws([
+      { href: '/old', file, lines: [7], isRedirect: true, redirectTarget: '/new' },
+      {
+        href: '/old',
+        file,
+        lines: [3, 7],
+        isRedirect: true,
+        redirectTarget: '/enterprise-server@3.15/other',
+        requiresVersionContext: true,
+      },
+    ])
+    expect(brokenLinks).toEqual([])
+    expect(redirectLinks).toHaveLength(1)
+    expect(redirectLinks[0]).toMatchObject({
+      lines: [3, 7],
+      redirectTarget: '/new',
+      requiresVersionContext: true,
+      hasConflictingRedirectTargets: true,
+    })
+  })
+
+  test('keeps different hrefs and files separate', () => {
+    const { brokenLinks } = mergeVersionedLinkFlaws([
+      { href: '/a', file, lines: [1] },
+      { href: '/b', file, lines: [2] },
+      { href: '/a', file: 'content/other.md', lines: [1] },
+    ])
+    expect(brokenLinks.map((link) => `${link.file}${link.href}`)).toEqual([
+      `${file}/a`,
+      `${file}/b`,
+      'content/other.md/a',
+    ])
+  })
+})
+
 describe('replacement targets in the JSON report', () => {
   const redirectOccurrence = (
     href: string,