From 0eb277f1b41d6528438176ff1d53fdb416c752a4 Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 20:31:07 +0000
Subject: [PATCH 01/71] Revert featured and homepage links when undoing
 move-content (#64161)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 .github/workflows/move-content.yml         | 25 ++++++++++++++++++++++
 src/content-render/scripts/move-content.ts |  9 +++++---
 2 files changed, 31 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/move-content.yml b/.github/workflows/move-content.yml
index b0a817c3b0c7..d1ae254ca5a6 100644
--- a/.github/workflows/move-content.yml
+++ b/.github/workflows/move-content.yml
@@ -46,6 +46,31 @@ jobs:
             src/fixtures/fixtures/content/get-started/start-your-journey/hello-wurld.md
           git log | head -n 100
 
+      - name: Undo moving hello-world.md to hello-wurld.md
+        env:
+          ROOT: src/fixtures/fixtures
+        run: |
+          # The fixtures start with hello-world, so confirm the move rewrote them before testing undo.
+          for file in src/fixtures/fixtures/content/index.md src/fixtures/fixtures/content/get-started/index.md; do
+            grep -q -- '- /get-started/start-your-journey/hello-wurld$' "$file"
+          done
+
+          npm run move-content -- --undo \
+            src/fixtures/fixtures/content/get-started/start-your-journey/hello-world.md \
+            src/fixtures/fixtures/content/get-started/start-your-journey/hello-wurld.md
+
+          test -f src/fixtures/fixtures/content/get-started/start-your-journey/hello-world.md
+          test ! -e src/fixtures/fixtures/content/get-started/start-your-journey/hello-wurld.md
+          # Undo must revert featuredLinks too, or they point at a page that no longer exists.
+          for file in src/fixtures/fixtures/content/index.md src/fixtures/fixtures/content/get-started/index.md; do
+            grep -q -- '- /get-started/start-your-journey/hello-world$' "$file"
+            if grep -q hello-wurld "$file"; then
+              echo "$file still links to hello-wurld"
+              exit 1
+            fi
+          done
+          git log | head -n 100
+
       - name: Move code-security/getting-started to code-security/got-started
         env:
           ROOT: src/fixtures/fixtures
diff --git a/src/content-render/scripts/move-content.ts b/src/content-render/scripts/move-content.ts
index 07aab6e2096e..da4b94b4290e 100755
--- a/src/content-render/scripts/move-content.ts
+++ b/src/content-render/scripts/move-content.ts
@@ -7,7 +7,7 @@
 // Run npm run move-content --help for options.
 // Run file: npm run move-content PATH/TO/CURRENT-FILE.md PATH/TO/DESIRED-FILE-LOCATION-OR-NAME.md.
 // Run folder: npm run move-content PATH/TO/CURRENT-FOLDER PATH/TO/DESIRED-FOLDER-LOCATION-OR-NAME.
-// Undo: npm run move-content --undo PATH/TO/OLD PATH/TO/NEW.
+// Undo: npm run move-content -- --undo PATH/TO/OLD PATH/TO/NEW.
 
 import fs from 'fs'
 import path from 'path'
@@ -161,10 +161,13 @@ async function main(opts: MoveOptions, nameTuple: string[]) {
     }
   }
 
+  // oldHref and newHref keep the forward direction for undoFiles, so swap them to revert links.
+  const [fromHref, toHref] = undo ? [newHref, oldHref] : [oldHref, newHref]
+
   // featuredLinks updates need old and new hrefs, not whether the path is a file or folder.
-  changeFeaturedLinks(oldHref, newHref)
+  changeFeaturedLinks(fromHref, toHref)
 
-  changeHomepageLinks(oldHref, newHref, verbose)
+  changeHomepageLinks(fromHref, toHref, verbose)
 
   if (!undo) {
     if (verbose) {

From 695c8009582f2ee9bfc28c8bbb9565a3543393f8 Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 20:31:14 +0000
Subject: [PATCH 02/71] Let modifier-clicks on tool and platform tabs open a
 new tab (#64173)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 .../tests/playwright-rendering.spec.ts        | 25 +++++++++++++++++++
 src/tools/components/InArticlePicker.tsx      |  2 ++
 2 files changed, 27 insertions(+)

diff --git a/src/fixtures/tests/playwright-rendering.spec.ts b/src/fixtures/tests/playwright-rendering.spec.ts
index 99d7846315d0..e365a1095505 100644
--- a/src/fixtures/tests/playwright-rendering.spec.ts
+++ b/src/fixtures/tests/playwright-rendering.spec.ts
@@ -6,6 +6,7 @@ import {
   HOVERCARDS_ENABLED,
   ANALYTICS_ENABLED,
   COLOR_MODE_COOKIE_NAME,
+  TOOL_PREFERRED_COOKIE_NAME,
 } from '../../frame/lib/constants'
 
 // Local Playwright loads .env so tests read ELASTICSEARCH_URL independently of start-server.ts.
@@ -1266,6 +1267,30 @@ test.describe('tool picker', () => {
     await expect(page.getByText('This is webui content')).toBeVisible()
   })
 
+  test('modifier-click opens the tool in a new tab', async ({ page }) => {
+    await page.goto('/get-started/liquid/tool-specific')
+    await turnOffExperimentsInPage(page)
+    await page.getByTestId('tool-picker').getByRole('link', { name: 'Web browser' }).click()
+    await expect(page).toHaveURL(/\?tool=webui/)
+
+    // Chromium opens modifier-click tabs without an opener, so the page never emits 'popup'.
+    const newTabPromise = page.context().waitForEvent('page')
+    await page
+      .getByTestId('tool-picker')
+      .getByRole('link', { name: 'GitHub CLI' })
+      .click({ modifiers: ['ControlOrMeta'] })
+    const newTab = await newTabPromise
+    await expect(newTab).toHaveURL(/\?tool=cli/)
+    await newTab.close()
+
+    await expect(page).toHaveURL(/\?tool=webui/)
+    await expect(page.getByText('This is webui content')).toBeVisible()
+    await expect(page.getByText('This is cli content')).not.toBeVisible()
+    const cookies = await page.context().cookies()
+    const toolCookie = cookies.find((cookie) => cookie.name === TOOL_PREFERRED_COOKIE_NAME)
+    expect(toolCookie?.value).toBe('webui')
+  })
+
   test('minitoc matches picker', async ({ page }) => {
     // Avoid the drawer's exact reveal breakpoint.
     await page.setViewportSize({ width: 1440, height: 900 })
diff --git a/src/tools/components/InArticlePicker.tsx b/src/tools/components/InArticlePicker.tsx
index 27c0f2c2097c..9117ebb4fd00 100644
--- a/src/tools/components/InArticlePicker.tsx
+++ b/src/tools/components/InArticlePicker.tsx
@@ -155,6 +155,8 @@ export const InArticlePicker = ({
               key={option.value}
               aria-current={option.value === currentValue ? 'page' : undefined}
               onSelect={(event: React.MouseEvent | React.KeyboardEvent) => {
+                // Leave new-tab and new-window gestures to the browser and the href.
+                if (event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) return
                 event.preventDefault()
                 onClickChoice(option.value)
               }}

From 49fd997ed49d96b6bc898013cac718e8b30a4268 Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 20:31:21 +0000
Subject: [PATCH 03/71] Keep custom feature headings when rerunning the release
 notes generator (#64180)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 src/ghes-releases/lib/parse-release-notes.ts  | 11 +++--
 .../scripts/generate-release-notes.ts         |  1 +
 .../tests/generate-release-notes.ts           | 44 ++++++++++++++++++-
 3 files changed, 50 insertions(+), 6 deletions(-)

diff --git a/src/ghes-releases/lib/parse-release-notes.ts b/src/ghes-releases/lib/parse-release-notes.ts
index 080232749eb8..d68b02fa61d0 100644
--- a/src/ghes-releases/lib/parse-release-notes.ts
+++ b/src/ghes-releases/lib/parse-release-notes.ts
@@ -271,8 +271,10 @@ export function buildReleaseNotesYaml(
 
   lines.push('sections:')
 
-  const featureEntries = noteEntries.filter((e) => featureHeadings.includes(e.heading))
-  const otherEntries = noteEntries.filter((e) => !featureHeadings.includes(e.heading))
+  // Writers add their own feature headings, so only section headings stay out of features.
+  const sectionHeadings = ['Changes', 'Closing down', 'Retired']
+  const featureEntries = noteEntries.filter((e) => !sectionHeadings.includes(e.heading))
+  const otherEntries = noteEntries.filter((e) => sectionHeadings.includes(e.heading))
 
   lines.push('')
   lines.push('  features:')
@@ -285,7 +287,8 @@ export function buildReleaseNotesYaml(
       byHeading.set(entry.heading, existing)
     }
 
-    for (const heading of featureHeadings) {
+    const extraHeadings = [...byHeading.keys()].filter((h) => !featureHeadings.includes(h))
+    for (const heading of [...featureHeadings, ...extraHeadings]) {
       const entries = byHeading.get(heading)
       if (!entries) continue
 
@@ -298,7 +301,7 @@ export function buildReleaseNotesYaml(
     lines.push('    # TODO: Add feature notes')
   }
 
-  const changeEntries = otherEntries.filter((e) => !['Closing down', 'Retired'].includes(e.heading))
+  const changeEntries = otherEntries.filter((e) => e.heading === 'Changes')
   if (changeEntries.length > 0) {
     lines.push('')
     lines.push('  changes:')
diff --git a/src/ghes-releases/scripts/generate-release-notes.ts b/src/ghes-releases/scripts/generate-release-notes.ts
index a034e0a179b7..c8826c06d436 100644
--- a/src/ghes-releases/scripts/generate-release-notes.ts
+++ b/src/ghes-releases/scripts/generate-release-notes.ts
@@ -683,6 +683,7 @@ program
                 console.log(
                   `    ⚠ Unknown heading "${entry.heading}" — will be placed in changes section`,
                 )
+                entry.heading = 'Changes'
               }
             }
           }
diff --git a/src/ghes-releases/tests/generate-release-notes.ts b/src/ghes-releases/tests/generate-release-notes.ts
index 6d78f7826177..4f66473d9ddd 100644
--- a/src/ghes-releases/tests/generate-release-notes.ts
+++ b/src/ghes-releases/tests/generate-release-notes.ts
@@ -340,9 +340,9 @@ describe('buildReleaseNotesYaml', () => {
     expect(yaml).toContain('Repo note.')
   })
 
-  test('places non-feature entries in changes section', () => {
+  test('places Changes entries in changes section', () => {
     const entries = [
-      { heading: 'Some Other Heading', notes: ['A change.'], sourceUrl: 'https://example.com/1' },
+      { heading: 'Changes', notes: ['A change.'], sourceUrl: 'https://example.com/1' },
     ]
     const yaml = buildReleaseNotesYaml(entries, false, featureHeadings)
 
@@ -352,6 +352,46 @@ describe('buildReleaseNotesYaml', () => {
     expect(yaml).toContain('A change.')
   })
 
+  test('keeps feature headings that are not in the template after template headings', () => {
+    const entries = [
+      { heading: 'Copilot', notes: ['Copilot note.'], sourceUrl: 'https://example.com/1' },
+      { heading: 'APIs', notes: ['API note.'], sourceUrl: 'https://example.com/2' },
+    ]
+    const yaml = buildReleaseNotesYaml(entries, false, featureHeadings)
+
+    const apisIdx = yaml.indexOf('    - heading: APIs')
+    const copilotIdx = yaml.indexOf('    - heading: Copilot')
+    expect(apisIdx).toBeGreaterThan(-1)
+    expect(copilotIdx).toBeGreaterThan(apisIdx)
+    expect(copilotIdx).toBeLessThan(yaml.indexOf('  known_issues:'))
+    expect(yaml).toContain('Copilot note.')
+    expect(yaml).not.toContain('  changes:')
+  })
+
+  test('preserves feature headings that are not in the template on reload', () => {
+    const entries = [
+      {
+        heading: 'Code scanning',
+        notes: ['Code scanning note.'],
+        sourceUrl: 'https://github.com/github/releases/issues/1',
+      },
+      {
+        heading: 'Secret scanning',
+        notes: ['Secret scanning note.'],
+        sourceUrl: 'https://github.com/github/releases/issues/2',
+      },
+      {
+        heading: 'Changes',
+        notes: ['A change.'],
+        sourceUrl: 'https://github.com/github/releases/issues/3',
+      },
+    ]
+    const yaml = buildReleaseNotesYaml(entries, false, featureHeadings)
+    const reloaded = loadExistingEntriesFromString(yaml)
+
+    expect(reloaded.entries).toEqual(entries)
+  })
+
   test('places Closing down and Retired entries in their own sections', () => {
     const entries = [
       {

From ea81eb5821e9504bd53ef9ddc750c89688c869ee Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 20:31:27 +0000
Subject: [PATCH 04/71] Run REST anchor redirects on versioned REST pages
 (#64183)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 src/rest/components/ClientSideRedirects.tsx |  6 +++--
 src/rest/lib/is-rest-path.ts                |  7 ++++++
 src/rest/tests/is-rest-path.ts              | 28 +++++++++++++++++++++
 3 files changed, 39 insertions(+), 2 deletions(-)
 create mode 100644 src/rest/lib/is-rest-path.ts
 create mode 100644 src/rest/tests/is-rest-path.ts

diff --git a/src/rest/components/ClientSideRedirects.tsx b/src/rest/components/ClientSideRedirects.tsx
index bed8d7d6ac64..5fdb327f5bd8 100644
--- a/src/rest/components/ClientSideRedirects.tsx
+++ b/src/rest/components/ClientSideRedirects.tsx
@@ -2,6 +2,8 @@ import { useState, useEffect } from 'react'
 import dynamic from 'next/dynamic'
 import { useRouter } from 'next/router'
 
+import { isRestPath } from '@/rest/lib/is-rest-path'
+
 const ClientSideRedirectExceptions = dynamic(
   () => import('@/rest/components/ClientSideRedirectExceptions'),
   {
@@ -18,8 +20,8 @@ export function ClientSideRedirects() {
   useEffect(() => {
     const { hash } = window.location
 
-    // Redirect exceptions apply only under /rest.
-    if (hash && asPath.startsWith('/rest')) {
+    // Redirect exceptions apply only to REST pages, including versioned URLs.
+    if (hash && isRestPath(asPath)) {
       setLoad(true)
     }
   }, [])
diff --git a/src/rest/lib/is-rest-path.ts b/src/rest/lib/is-rest-path.ts
new file mode 100644
index 000000000000..477810086452
--- /dev/null
+++ b/src/rest/lib/is-rest-path.ts
@@ -0,0 +1,7 @@
+// Next.js strips the locale from asPath but keeps the version segment, so allow an optional
+// version prefix such as /enterprise-server@3.18 before /rest.
+const REST_PATH_REGEX = /^(\/[^/#?]+@[^/#?]+)?\/rest(\/|#|\?|$)/
+
+export function isRestPath(asPath: string): boolean {
+  return REST_PATH_REGEX.test(asPath)
+}
diff --git a/src/rest/tests/is-rest-path.ts b/src/rest/tests/is-rest-path.ts
new file mode 100644
index 000000000000..76ca3d4fdbd2
--- /dev/null
+++ b/src/rest/tests/is-rest-path.ts
@@ -0,0 +1,28 @@
+import { describe, expect, test } from 'vitest'
+
+import { isRestPath } from '@/rest/lib/is-rest-path'
+
+describe('isRestPath', () => {
+  test('matches unversioned REST paths', () => {
+    expect(isRestPath('/rest')).toBe(true)
+    expect(isRestPath('/rest#statuses')).toBe(true)
+    expect(isRestPath('/rest/repos#statuses')).toBe(true)
+    expect(isRestPath('/rest/repos?apiVersion=2022-11-28#statuses')).toBe(true)
+  })
+
+  test('matches versioned REST paths', () => {
+    expect(
+      isRestPath('/enterprise-cloud@latest/rest/enterprise-admin#code-security-and-analysis'),
+    ).toBe(true)
+    expect(isRestPath('/enterprise-server@3.18/rest/repos#statuses')).toBe(true)
+    expect(isRestPath('/free-pro-team@latest/rest/repos#deploy-keys')).toBe(true)
+  })
+
+  test('does not match non-REST paths', () => {
+    expect(isRestPath('/')).toBe(false)
+    expect(isRestPath('/enterprise-cloud@latest/admin#x')).toBe(false)
+    expect(isRestPath('/restricted#x')).toBe(false)
+    expect(isRestPath('/enterprise-server@3.18/restricted#x')).toBe(false)
+    expect(isRestPath('/graphql/rest#x')).toBe(false)
+  })
+})

From ea0970e06c4db983208638328a4ebcebf7b21397 Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 20:31:38 +0000
Subject: [PATCH 05/71] Drop undefined content type from REST example labels
 (#64184)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 src/rest/lib/code-example-utils.ts   | 20 +++++--------
 src/rest/tests/code-example-logic.ts | 44 ++++++++++++++++++++++++++++
 2 files changed, 52 insertions(+), 12 deletions(-)

diff --git a/src/rest/lib/code-example-utils.ts b/src/rest/lib/code-example-utils.ts
index f8fcdadddadb..e5b4c30d6fa7 100644
--- a/src/rest/lib/code-example-utils.ts
+++ b/src/rest/lib/code-example-utils.ts
@@ -5,7 +5,7 @@ export interface CodeExample {
     contentType?: string
   }
   response: {
-    contentType: string
+    contentType?: string
   }
   description: string
 }
@@ -33,23 +33,19 @@ export function shouldShowResponseContentType(examples: CodeExample[]): boolean
 export function generateExampleOptions(examples: CodeExample[]): ExampleOption[] {
   const responseContentTypesDiffer = shouldShowResponseContentType(examples)
   const requestContentTypesDiffer = shouldShowRequestContentType(examples)
-  const showExampleOptionMediaType = responseContentTypesDiffer || requestContentTypesDiffer
 
   return examples.map((example, index) => {
     const requestContentType = example.request?.contentType
     const responseContentType = example.response.contentType
 
-    let text = example.description
+    // Examples without a body, such as 204 responses, have no content type to show.
+    const contentTypes: string[] = []
+    if (requestContentTypesDiffer && requestContentType) contentTypes.push(requestContentType)
+    if (responseContentTypesDiffer && responseContentType) contentTypes.push(responseContentType)
 
-    if (showExampleOptionMediaType) {
-      if (requestContentTypesDiffer && responseContentTypesDiffer) {
-        text = `${example.description} (${requestContentType} → ${responseContentType})`
-      } else if (requestContentTypesDiffer) {
-        text = `${example.description} (${requestContentType})`
-      } else if (responseContentTypesDiffer) {
-        text = `${example.description} (${responseContentType})`
-      }
-    }
+    const text = contentTypes.length
+      ? `${example.description} (${contentTypes.join(' → ')})`
+      : example.description
 
     return {
       text,
diff --git a/src/rest/tests/code-example-logic.ts b/src/rest/tests/code-example-logic.ts
index 73717c31b17d..3788b256dd3a 100644
--- a/src/rest/tests/code-example-logic.ts
+++ b/src/rest/tests/code-example-logic.ts
@@ -128,6 +128,50 @@ describe('Request Content Type Logic', () => {
     expect(options).toEqual(['First example', 'Second example'])
   })
 
+  test('omits the content type suffix for an example with no response body', () => {
+    const noContentExamples: CodeExample[] = [
+      {
+        description: 'Example 1: Status Code 201',
+        request: { contentType: 'application/json' },
+        response: { contentType: 'application/json' },
+      },
+      {
+        description: 'Example 2: Status Code 204',
+        request: { contentType: 'application/json' },
+        response: {},
+      },
+    ]
+
+    const options = generateExampleOptionTexts(noContentExamples)
+
+    expect(options).toEqual([
+      'Example 1: Status Code 201 (application/json)',
+      'Example 2: Status Code 204',
+    ])
+  })
+
+  test('omits a missing request content type when request and response types differ', () => {
+    const mixedExamples: CodeExample[] = [
+      {
+        description: 'JSON request',
+        request: { contentType: 'application/json' },
+        response: { contentType: 'application/json' },
+      },
+      {
+        description: 'No request body',
+        request: {},
+        response: { contentType: 'text/html' },
+      },
+    ]
+
+    const options = generateExampleOptionTexts(mixedExamples)
+
+    expect(options).toEqual([
+      'JSON request (application/json → application/json)',
+      'No request body (text/html)',
+    ])
+  })
+
   test('handles single example correctly', () => {
     const singleExample: CodeExample[] = [
       {

From 6325fb6e662c593890e502a9aae05a4ad5fe14f1 Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 20:31:45 +0000
Subject: [PATCH 06/71] Show Basic auth on Basic-auth REST endpoints in Article
 API Markdown (#64185)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 .../templates/rest-page.template.md           | 10 ++-
 .../tests/rest-transformer-auth.test.ts       | 84 +++++++++++++++++++
 .../transformers/rest-transformer.ts          |  2 +
 3 files changed, 95 insertions(+), 1 deletion(-)
 create mode 100644 src/article-api/tests/rest-transformer-auth.test.ts

diff --git a/src/article-api/templates/rest-page.template.md b/src/article-api/templates/rest-page.template.md
index 754c7c2598b5..da5372bc577f 100644
--- a/src/article-api/templates/rest-page.template.md
+++ b/src/article-api/templates/rest-page.template.md
@@ -17,6 +17,13 @@
 
 {{ operation.description }}
 
+{% if operation.basicAuth %}
+
+> [!NOTE]
+> This endpoint requires [Basic authentication](/rest/authentication/authenticating-to-the-rest-api#using-basic-authentication). Use the application's `client_id` as the username and the `client_secret` as the password. Do not send an `Authorization: Bearer` header with this request, because it replaces the Basic credentials.
+
+{% endif %}
+
 {% if operation.hasParameters %}
 
 ### Parameters
@@ -84,7 +91,8 @@
 ```curl
 curl -L \
   -X {{ operation.verb | upcase }} \
-  {{ example.request.url }}{% if example.request.acceptHeader and example.request.acceptHeader != 'application/vnd.github+json' and example.request.acceptHeader != 'application/vnd.github.v3+json' %} \
+  {{ example.request.url }}{% if operation.basicAuth %} \
+  -u "<YOUR_CLIENT_ID>:<YOUR_CLIENT_SECRET>"{% endif %}{% if example.request.acceptHeader and example.request.acceptHeader != 'application/vnd.github+json' and example.request.acceptHeader != 'application/vnd.github.v3+json' %} \
   -H "Accept: {{ example.request.acceptHeader }}"{% endif %}{% if example.request.needsContentTypeHeader %} \
   -H "Content-Type: {{ example.request.contentType }}"{% endif %}{% if example.request.bodyParameters.size > 0 %}{% for bodyParameter in example.request.bodyParameters %} \
   {{ bodyParameter }}{% endfor %}{% endif %}
diff --git a/src/article-api/tests/rest-transformer-auth.test.ts b/src/article-api/tests/rest-transformer-auth.test.ts
new file mode 100644
index 000000000000..10961ef31086
--- /dev/null
+++ b/src/article-api/tests/rest-transformer-auth.test.ts
@@ -0,0 +1,84 @@
+import { describe, expect, test, vi } from 'vitest'
+
+import { RestTransformer } from '@/article-api/transformers/rest-transformer'
+import getRest from '@/rest/lib/index'
+import { allVersions } from '@/versions/lib/all-versions'
+import type { CodeSample, Operation } from '@/rest/components/types'
+import type { Context, Page } from '@/types'
+
+vi.mock('@/rest/lib/index', () => ({ default: vi.fn() }))
+
+const stubPage = {
+  autogenerated: 'rest',
+  relativePath: 'rest/apps/oauth-applications.md',
+  title: 'OAuth authorizations',
+  intro: '',
+  markdown: '',
+  renderProp: vi.fn().mockResolvedValue(''),
+} as unknown as Page
+
+const context = {
+  currentVersion: 'free-pro-team@latest',
+  currentVersionObj: allVersions['free-pro-team@latest'],
+  allVersions,
+} as unknown as Context
+
+const makeOperation = (title: string, requestPath: string, basicAuth: boolean): Operation =>
+  ({
+    serverUrl: 'https://api.github.com',
+    verb: 'post',
+    title,
+    requestPath,
+    descriptionHTML: '',
+    category: 'apps',
+    subcategory: 'oauth-applications',
+    statusCodes: [],
+    bodyParameters: [],
+    parameters: [],
+    progAccess: { permissions: [], ...(basicAuth ? { basicAuth: true } : {}) },
+    codeExamples: [
+      {
+        request: { description: 'Example', acceptHeader: 'application/vnd.github.v3+json' },
+        response: { statusCode: '200' },
+      } as unknown as CodeSample,
+    ],
+  }) as unknown as Operation
+
+async function renderSections() {
+  vi.mocked(getRest).mockResolvedValue({
+    'oauth-applications': [
+      makeOperation('Check a token', '/applications/CLIENT_ID/token', true),
+      makeOperation('Create a thing', '/things', false),
+    ],
+  } as never)
+  const body = await new RestTransformer().transform(
+    stubPage,
+    '/en/rest/apps/oauth-applications',
+    context,
+  )
+  const [, basicAuthSection, otherSection] = body.split(/^## /m)
+  return { basicAuthSection, otherSection }
+}
+
+describe('RestTransformer basic authentication', () => {
+  test('adds Basic auth credentials to the curl example for basicAuth operations', async () => {
+    const { basicAuthSection, otherSection } = await renderSections()
+
+    expect(basicAuthSection).toContain(
+      'https://api.github.com/applications/CLIENT_ID/token \\\n  -u "<YOUR_CLIENT_ID>:<YOUR_CLIENT_SECRET>"',
+    )
+    expect(otherSection).not.toContain('-u "')
+  })
+
+  test('adds a Basic authentication note to basicAuth operations', async () => {
+    const { basicAuthSection, otherSection } = await renderSections()
+
+    expect(basicAuthSection).toContain('Basic authentication')
+    expect(basicAuthSection).toContain('`client_id`')
+    expect(basicAuthSection).toContain('`client_secret`')
+    expect(basicAuthSection).toContain('Do not send an `Authorization: Bearer` header')
+    expect(otherSection).not.toContain('Do not send an `Authorization: Bearer` header')
+    expect(otherSection).not.toContain('Basic authentication')
+    expect(otherSection).not.toContain('client_secret')
+  })
+})
diff --git a/src/article-api/transformers/rest-transformer.ts b/src/article-api/transformers/rest-transformer.ts
index 8f0a22315896..8d5aeacdae2c 100644
--- a/src/article-api/transformers/rest-transformer.ts
+++ b/src/article-api/transformers/rest-transformer.ts
@@ -46,6 +46,7 @@ type PreparedOperation = Omit<Operation, 'statusCodes' | 'codeExamples'> & {
   hasParameters: boolean
   showHeaders: boolean
   needsContentTypeHeader: boolean
+  basicAuth: boolean
   statusCodes?: Array<{ httpStatusCode: string; description?: string }>
   codeExamples: PreparedCodeExample[]
 }
@@ -262,6 +263,7 @@ export class RestTransformer implements PageTransformer {
       hasParameters,
       showHeaders,
       needsContentTypeHeader,
+      basicAuth: Boolean(operation.progAccess?.basicAuth),
       statusCodes,
       codeExamples,
     }

From 0233863f5c28677d8593dc53b1e09438711fceef Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 20:31:52 +0000
Subject: [PATCH 07/71] Indent every line of REST parameter descriptions in
 markdown output (#64186)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 src/article-api/liquid-renderers/rest-tags.ts | 14 +++-
 src/article-api/tests/rest-tags.test.ts       | 83 +++++++++++++++++++
 2 files changed, 94 insertions(+), 3 deletions(-)
 create mode 100644 src/article-api/tests/rest-tags.test.ts

diff --git a/src/article-api/liquid-renderers/rest-tags.ts b/src/article-api/liquid-renderers/rest-tags.ts
index b7fc29a222c2..464fac7a7ff4 100644
--- a/src/article-api/liquid-renderers/rest-tags.ts
+++ b/src/article-api/liquid-renderers/rest-tags.ts
@@ -37,7 +37,7 @@ export class RestParameter {
 
     if (param.description) {
       const description = await htmlToMarkdown(param.description, context)
-      lines.push(`  ${description}`)
+      lines.push(indentLines(description, '  '))
     }
 
     if (param.schema?.default !== undefined) {
@@ -87,7 +87,7 @@ export class RestBodyParameter {
 
     if (param.description) {
       const description = await htmlToMarkdown(param.description, context)
-      lines.push(`${prefix}  ${description}`)
+      lines.push(indentLines(description, `${prefix}  `))
     }
 
     if (param.default !== undefined) {
@@ -160,7 +160,7 @@ async function renderChildParameter(
 
   if (param.description) {
     const description = await htmlToMarkdown(param.description, context)
-    lines.push(`${prefix}  ${description}`)
+    lines.push(indentLines(description, `${prefix}  `))
   }
 
   if (param.default !== undefined) {
@@ -180,6 +180,14 @@ async function renderChildParameter(
   return lines.join('\n')
 }
 
+// Description text keeps newlines between blocks, and a column-0 line after a blank line ends the list item.
+function indentLines(text: string, indent: string): string {
+  return text
+    .split('\n')
+    .map((line) => (line.trim() ? `${indent}${line}` : ''))
+    .join('\n')
+}
+
 async function htmlToMarkdown(html: string, context: Context): Promise<string> {
   if (!html) return ''
 
diff --git a/src/article-api/tests/rest-tags.test.ts b/src/article-api/tests/rest-tags.test.ts
new file mode 100644
index 000000000000..3081e7f62c77
--- /dev/null
+++ b/src/article-api/tests/rest-tags.test.ts
@@ -0,0 +1,83 @@
+import { describe, expect, test } from 'vitest'
+import { Liquid } from 'liquidjs'
+import { fromMarkdown } from 'mdast-util-from-markdown'
+import type { List } from 'mdast'
+
+import { restTags } from '@/article-api/liquid-renderers/rest-tags'
+
+const engine = new Liquid()
+for (const [tagName, tagClass] of Object.entries(restTags)) {
+  engine.registerTag(tagName, tagClass as unknown as Parameters<typeof engine.registerTag>[1])
+}
+
+const multiLineDescription =
+  '<p>Intro.</p>\n<ul>\n<li><code>a</code>: first value</li>\n<li><code>b</code>: second value</li>\n</ul>\n<p>Closing note.</p>'
+
+async function render(template: string, param: unknown): Promise<string> {
+  return engine.parseAndRender(template, { param, context: {} })
+}
+
+function linesAfterFirst(output: string): string[] {
+  return output
+    .split('\n')
+    .slice(1)
+    .filter((line) => line.trim() !== '')
+}
+
+describe('REST Liquid tags with multi-line descriptions', () => {
+  test('rest_parameter indents every description line under the list item', async () => {
+    const output = await render('{% rest_parameter param %}', {
+      name: 'scope',
+      in: 'query',
+      required: false,
+      description: multiLineDescription,
+      schema: { type: 'string', enum: ['a', 'b'] },
+    })
+
+    expect(output).toContain('a: first value')
+    expect(output).toContain('Closing note.')
+    for (const line of linesAfterFirst(output)) {
+      expect(line).toMatch(/^ {2}\S/)
+    }
+
+    const tree = fromMarkdown(output)
+    expect(tree.children.map((node) => node.type)).toEqual(['list'])
+  })
+
+  test('rest_body_parameter keeps child parameters nested under their parent', async () => {
+    const output = await render('{% rest_body_parameter param %}', {
+      name: 'budget_scope',
+      type: 'object',
+      isRequired: true,
+      description: multiLineDescription,
+      enum: ['a', 'b'],
+      childParamsGroups: [
+        {
+          name: 'value',
+          type: 'string',
+          description: multiLineDescription,
+        },
+      ],
+    })
+
+    const lines = output.split('\n')
+    const childIndex = lines.findIndex((line) => line.includes('**`value`**'))
+    expect(childIndex).toBeGreaterThan(0)
+    for (const line of lines.slice(1, childIndex).filter((l) => l.trim() !== '')) {
+      expect(line).toMatch(/^ {2}\S/)
+    }
+    expect(lines[childIndex]).toMatch(/^ {2}- /)
+    for (const line of lines.slice(childIndex + 1).filter((l) => l.trim() !== '')) {
+      expect(line).toMatch(/^ {4}\S/)
+    }
+
+    const tree = fromMarkdown(output)
+    expect(tree.children.map((node) => node.type)).toEqual(['list'])
+    const topList = tree.children[0] as List
+    expect(topList.children).toHaveLength(1)
+    const nestedLists = topList.children[0].children.filter(
+      (node): node is List => node.type === 'list' && node.children.length === 1,
+    )
+    expect(nestedLists.some((list) => JSON.stringify(list).includes('"value":"value"'))).toBe(true)
+  })
+})

From a22af715bcbf65b65b004c42bfebb7b00ded45cd Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 20:31:58 +0000
Subject: [PATCH 08/71] Fix reusables CLI crash when the repo path has a space
 (#64189)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 src/content-render/scripts/reusables-cli/shared.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/content-render/scripts/reusables-cli/shared.ts b/src/content-render/scripts/reusables-cli/shared.ts
index 454e0477159e..6d36e1ffb53c 100644
--- a/src/content-render/scripts/reusables-cli/shared.ts
+++ b/src/content-render/scripts/reusables-cli/shared.ts
@@ -1,10 +1,11 @@
 import walk from 'walk-sync'
 import path from 'path'
+import { fileURLToPath } from 'url'
 import { TokenizationError, TokenKind } from 'liquidjs'
 import type { TagToken } from 'liquidjs'
 import { getLiquidTokens } from '@/content-linter/lib/helpers/liquid-utils'
 
-const __dirname = path.dirname(new URL(import.meta.url).pathname)
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
 
 const repoRoot = path.resolve(__dirname, '../../../../')
 const contentDirectory = path.resolve(__dirname, repoRoot, 'content/')

From 596d3984f243cf07c0f15b7e3a5a594d838f6d65 Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 21:03:22 +0000
Subject: [PATCH 09/71] Render Liquid in headings before mapping English
 heading IDs (#63928)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 .../unified/use-english-headings.ts           |  9 +-
 src/frame/lib/page.ts                         |  2 +-
 src/languages/lib/get-english-headings.ts     | 36 +++++--
 src/languages/tests/get-english-headings.ts   | 94 +++++++++++++++++--
 4 files changed, 121 insertions(+), 20 deletions(-)

diff --git a/src/content-render/unified/use-english-headings.ts b/src/content-render/unified/use-english-headings.ts
index aef89ec7333a..7035f9a3f162 100644
--- a/src/content-render/unified/use-english-headings.ts
+++ b/src/content-render/unified/use-english-headings.ts
@@ -3,8 +3,6 @@ import { toString } from 'hast-util-to-string'
 import { visit } from 'unist-util-visit'
 import type { Element, Root } from 'hast'
 
-const slugger = new GithubSlugger()
-
 interface UseEnglishHeadingsOptions {
   englishHeadings?: Record<string, string>
 }
@@ -13,11 +11,14 @@ interface UseEnglishHeadingsOptions {
 export default function useEnglishHeadings({ englishHeadings }: UseEnglishHeadingsOptions) {
   if (!englishHeadings) return
   return (tree: Root) => {
+    // One slugger per document gives repeated headings the same suffixes as the English page.
+    const slugger = new GithubSlugger()
     visit(tree, 'element', (node: Element) => {
       if (!['h2', 'h3', 'h4'].includes(node.tagName)) return
-      slugger.reset()
       const text: string = toString(node)
-      const englishHeading: string = englishHeadings[text]
+      const englishHeading: string | undefined = englishHeadings[text]
+      // Unmatched headings would otherwise register an empty slug and shift later suffixes.
+      if (!englishHeading) return
       const englishSlug: string = slugger.slug(englishHeading)
       if (englishSlug) {
         // Leave the existing ID when no English slug exists.
diff --git a/src/frame/lib/page.ts b/src/frame/lib/page.ts
index b8aa960970ff..77fd93f680bb 100644
--- a/src/frame/lib/page.ts
+++ b/src/frame/lib/page.ts
@@ -286,7 +286,7 @@ class Page {
   private async _render(context: Context): Promise<string> {
     // English heading IDs keep translated links stable.
     if (this.languageCode !== 'en') {
-      const englishHeadings = getEnglishHeadings(this, context)
+      const englishHeadings = await getEnglishHeadings(this, context)
       context.englishHeadings = englishHeadings
     }
 
diff --git a/src/languages/lib/get-english-headings.ts b/src/languages/lib/get-english-headings.ts
index 0faf7839bf8b..935d0a41d49d 100644
--- a/src/languages/lib/get-english-headings.ts
+++ b/src/languages/lib/get-english-headings.ts
@@ -3,6 +3,7 @@ import { toString } from 'mdast-util-to-string'
 import { visit } from 'unist-util-visit'
 import type { Node } from 'unist'
 
+import { renderLiquid } from '@/content-render/liquid/index'
 import findPage from '@/frame/lib/find-page'
 import Permalink from '@/frame/lib/permalink'
 import { trailingSlash } from '@/frame/lib/patterns'
@@ -24,10 +25,10 @@ interface GlossaryTerm {
   slug: string
 }
 
-export default function getEnglishHeadings(
+export default async function getEnglishHeadings(
   page: PageWithMarkdown,
   context: Context,
-): Record<string, string> | undefined {
+): Promise<Record<string, string> | undefined> {
   // Glossary headings come from data, not page markdown.
   if (page.relativePath.endsWith('/github-glossary.md')) {
     const languageGlossary = getDataByLanguage('glossaries.external', 'en') as GlossaryTerm[]
@@ -37,7 +38,7 @@ export default function getEnglishHeadings(
     }, {})
   }
 
-  const translatedHeadings = getHeadings(page.markdown)
+  const translatedHeadings = await getHeadings(page.markdown, context)
   if (!translatedHeadings.length) return
 
   // Page keys drop the trailing slash that relativePathToSuffix can leave.
@@ -49,7 +50,10 @@ export default function getEnglishHeadings(
   if (!englishPage) return
 
   // English heading changes can misalign with unsynced translations.
-  const englishHeadings = getHeadings(englishPage.markdown)
+  const englishHeadings = await getHeadings(englishPage.markdown, {
+    ...context,
+    currentLanguage: 'en',
+  })
   if (!englishHeadings.length) return
 
   const headingMap: Record<string, string> = {}
@@ -60,16 +64,32 @@ export default function getEnglishHeadings(
   return headingMap
 }
 
-function getHeadings(markdown: string): string[] {
+// Keys and values must match the heading text after Liquid renders, which is what the page shows.
+async function getHeadings(markdown: string, context: Context): Promise<string[]> {
   const ast = fromMarkdown(markdown)
-  const headings: string[] = []
+  const headingNodes: HeadingNode[] = []
 
   visit(ast, (node: Node) => {
     if (node.type !== 'heading') return
     const headingNode = node as HeadingNode
     if (![2, 3, 4].includes(headingNode.depth)) return
-    headings.push(toString(node))
+    headingNodes.push(headingNode)
   })
 
-  return headings
+  return Promise.all(headingNodes.map((node) => renderHeading(node, markdown, context)))
+}
+
+async function renderHeading(node: HeadingNode, markdown: string, context: Context) {
+  const text = toString(node)
+  const start = node.position?.start.offset
+  const end = node.position?.end.offset
+  if (start === undefined || end === undefined) return text
+  const source = markdown.slice(start, end)
+  if (!source.includes('{%') && !source.includes('{{')) return text
+  try {
+    return toString(fromMarkdown(await renderLiquid(source, context)))
+  } catch {
+    // A heading can hold half of a Liquid block that only parses as part of the whole page.
+    return text
+  }
 }
diff --git a/src/languages/tests/get-english-headings.ts b/src/languages/tests/get-english-headings.ts
index 565b533c0467..25a053f72137 100644
--- a/src/languages/tests/get-english-headings.ts
+++ b/src/languages/tests/get-english-headings.ts
@@ -1,8 +1,18 @@
 import { describe, expect, test } from 'vitest'
 
+import { renderContent } from '@/content-render/index'
 import getEnglishHeadings from '@/languages/lib/get-english-headings'
 import type { Context, Page } from '@/types'
 
+function makeContext(englishMarkdown: string): Context {
+  return {
+    currentLanguage: 'en',
+    currentVersion: 'free-pro-team@latest',
+    pages: { '/en/foo/bar': { markdown: englishMarkdown } as unknown as Page },
+    redirects: {},
+  } as Context
+}
+
 const pages = {
   '/en': {
     relativePath: 'index.md',
@@ -18,21 +28,91 @@ const pages = {
   },
 } as unknown as Record<string, Page>
 
-const context = { pages, redirects: {} } as Context
+const indexContext = { pages, redirects: {} } as Context
 
 describe('getEnglishHeadings', () => {
-  test('maps headings on index.md pages', () => {
+  test('maps headings on index.md pages', async () => {
     const page = { relativePath: 'rest/git/index.md', markdown: '## 見出し' }
-    expect(getEnglishHeadings(page, context)).toEqual({ 見出し: 'About Git database' })
+    expect(await getEnglishHeadings(page, indexContext)).toEqual({ 見出し: 'About Git database' })
   })
 
-  test('maps headings on non-index pages', () => {
+  test('maps headings on non-index pages', async () => {
     const page = { relativePath: 'rest/git/blobs.md', markdown: '## 見出し' }
-    expect(getEnglishHeadings(page, context)).toEqual({ 見出し: 'About Git blobs' })
+    expect(await getEnglishHeadings(page, indexContext)).toEqual({ 見出し: 'About Git blobs' })
   })
 
-  test('maps headings on the root index.md page', () => {
+  test('maps headings on the root index.md page', async () => {
     const page = { relativePath: 'index.md', markdown: '## 見出し' }
-    expect(getEnglishHeadings(page, context)).toEqual({ 見出し: 'Get started' })
+    expect(await getEnglishHeadings(page, indexContext)).toEqual({ 見出し: 'Get started' })
+  })
+
+  test('renders Liquid in translated and English headings', async () => {
+    const page = {
+      relativePath: 'foo/bar.md',
+      markdown: [
+        '## {% data variables.product.prodname_dependabot_alerts %} の有効化',
+        '## {% data variables.product.prodname_actions %} について',
+        '## Plain & simple',
+        '## Acerca de Copilot',
+      ].join('\n\n'),
+    }
+    const context = makeContext(
+      [
+        '## Enabling {% data variables.product.prodname_dependabot_alerts %}',
+        '## About {% data variables.product.prodname_actions %}',
+        '## Plain and simple',
+        '## About {% data variables.product.prodname_copilot %}',
+      ].join('\n\n'),
+    )
+    const headings = await getEnglishHeadings(page, context)
+    expect(headings).toEqual({
+      'Dependabot alerts の有効化': 'Enabling Dependabot alerts',
+      'GitHub Actions について': 'About GitHub Actions',
+      'Plain & simple': 'Plain and simple',
+      'Acerca de Copilot': 'About GitHub Copilot',
+    })
+  })
+
+  test('falls back to the raw heading text when Liquid fails to render', async () => {
+    const page = { relativePath: 'foo/bar.md', markdown: '## Roto {% ifversion fpt %}' }
+    const context = makeContext('## Broken {% ifversion fpt %}')
+    const headings = await getEnglishHeadings(page, context)
+    expect(headings).toEqual({ 'Roto {% ifversion fpt %}': 'Broken {% ifversion fpt %}' })
+  })
+
+  test('gives translated headings with Liquid their English IDs', async () => {
+    const page = {
+      relativePath: 'foo/bar.md',
+      markdown: '## {% data variables.product.prodname_dependabot_alerts %} の有効化',
+    }
+    const context = makeContext(
+      '## Enabling {% data variables.product.prodname_dependabot_alerts %}',
+    )
+    context.englishHeadings = await getEnglishHeadings(page, context)
+    const html = await renderContent(page.markdown, context)
+    expect(html).toContain('id="enabling-dependabot-alerts"')
+  })
+
+  test('keeps English suffixes for repeated translated headings with Liquid', async () => {
+    const page = {
+      relativePath: 'foo/bar.md',
+      markdown: [
+        '## {% data variables.product.prodname_actions %} の使用',
+        '## 概要',
+        '## {% data variables.product.prodname_actions %} の使用',
+      ].join('\n\n'),
+    }
+    const context = makeContext(
+      [
+        '## Using {% data variables.product.prodname_actions %}',
+        '## Overview',
+        '## Using {% data variables.product.prodname_actions %}',
+      ].join('\n\n'),
+    )
+    context.englishHeadings = await getEnglishHeadings(page, context)
+    const html = await renderContent(page.markdown, context)
+    expect(html).toContain('id="using-github-actions"')
+    expect(html).toContain('id="overview"')
+    expect(html).toContain('id="using-github-actions-1"')
   })
 })

From 0fe63e03a68f574335819a7efc311a709e6f2b59 Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 21:03:29 +0000
Subject: [PATCH 10/71] Validate the Copilot model comparison table against its
 schema (#64153)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Co-authored-by: Hector A. <v-halfaro@github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 src/data-directory/lib/data-schemas/index.ts  |  3 ++
 .../tables/copilot/model-comparison.ts        | 49 ++++++++-----------
 2 files changed, 24 insertions(+), 28 deletions(-)

diff --git a/src/data-directory/lib/data-schemas/index.ts b/src/data-directory/lib/data-schemas/index.ts
index 8d7b75ce9e60..871ce19bab99 100644
--- a/src/data-directory/lib/data-schemas/index.ts
+++ b/src/data-directory/lib/data-schemas/index.ts
@@ -55,6 +55,9 @@ const manualSchemas: DataSchemas = {
   'data/tables/copilot/model-supported-plans.yml': resolveSchemaPath(
     'tables/copilot/model-supported-plans.ts',
   ),
+  'data/tables/copilot/model-comparison.yml': resolveSchemaPath(
+    'tables/copilot/model-comparison.ts',
+  ),
   'data/tables/copilot/auto-model-selection.yml': resolveSchemaPath(
     'tables/copilot/auto-model-selection.ts',
   ),
diff --git a/src/data-directory/lib/data-schemas/tables/copilot/model-comparison.ts b/src/data-directory/lib/data-schemas/tables/copilot/model-comparison.ts
index 6189c00e9ff6..f768c02e6aba 100644
--- a/src/data-directory/lib/data-schemas/tables/copilot/model-comparison.ts
+++ b/src/data-directory/lib/data-schemas/tables/copilot/model-comparison.ts
@@ -1,32 +1,25 @@
 const modelComparisonSchema = {
-  type: 'object',
-  additionalProperties: false,
-  required: ['models'],
-  properties: {
-    models: {
-      type: 'array',
-      items: {
-        type: 'object',
-        additionalProperties: false,
-        required: ['name', 'task_area', 'excels_at', 'further_reading'],
-        properties: {
-          name: {
-            type: 'string',
-            lintable: true,
-          },
-          task_area: {
-            type: 'string',
-            lintable: true,
-          },
-          excels_at: {
-            type: 'string',
-            lintable: true,
-          },
-          further_reading: {
-            type: 'string',
-            lintable: true,
-          },
-        },
+  type: 'array',
+  items: {
+    type: 'object',
+    additionalProperties: false,
+    required: ['name', 'task_area', 'excels_at', 'further_reading'],
+    properties: {
+      name: {
+        type: 'string',
+        lintable: true,
+      },
+      task_area: {
+        type: 'string',
+        lintable: true,
+      },
+      excels_at: {
+        type: 'string',
+        lintable: true,
+      },
+      further_reading: {
+        type: 'string',
+        lintable: true,
       },
     },
   },

From 7b1cf855aee6912db2a67f534c130f2c7199174d Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 21:03:35 +0000
Subject: [PATCH 11/71] Show types for oneOf path and query parameters in REST
 docs (#64187)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 src/article-api/liquid-renderers/rest-tags.ts |  4 +-
 src/rest/scripts/utils/operation.ts           |  7 +--
 src/rest/scripts/utils/parameter-schema.ts    | 45 +++++++++++++++
 src/rest/tests/parameter-schema.ts            | 56 +++++++++++++++++++
 4 files changed, 106 insertions(+), 6 deletions(-)
 create mode 100644 src/rest/scripts/utils/parameter-schema.ts
 create mode 100644 src/rest/tests/parameter-schema.ts

diff --git a/src/article-api/liquid-renderers/rest-tags.ts b/src/article-api/liquid-renderers/rest-tags.ts
index 464fac7a7ff4..38ca91d86af6 100644
--- a/src/article-api/liquid-renderers/rest-tags.ts
+++ b/src/article-api/liquid-renderers/rest-tags.ts
@@ -31,7 +31,9 @@ export class RestParameter {
 
     const lines: string[] = []
     const required = param.required ? ' (required)' : ''
-    const type = param.schema?.type || 'string'
+    const type = Array.isArray(param.schema?.type)
+      ? param.schema.type.join(' or ')
+      : param.schema?.type || 'string'
 
     lines.push(`- **\`${param.name}\`** (${type})${required}`)
 
diff --git a/src/rest/scripts/utils/operation.ts b/src/rest/scripts/utils/operation.ts
index 0b56297e87d7..e06c4b18ad12 100644
--- a/src/rest/scripts/utils/operation.ts
+++ b/src/rest/scripts/utils/operation.ts
@@ -9,6 +9,7 @@ import getCodeSamples from './create-rest-examples'
 import operationSchema from './operation-schema'
 import { validateJson } from '@/tests/lib/validate-json-schema'
 import { getBodyParams, type TransformedParam } from './get-body-params'
+import { simplifyParameterSchema } from './parameter-schema'
 import type { OpenApiOperation, OpenApiParameter, OpenApiServer } from './openapi-types'
 import type { MergedExample } from './create-rest-examples'
 
@@ -155,12 +156,8 @@ export default class Operation {
           delete param.example
           delete param.examples
           delete param['x-multi-segment']
-          // Keep only parameter schema subfields that renderers consume: type, default, and enum.
           if (param.schema && typeof param.schema === 'object') {
-            const { type, default: defaultVal, enum: enumVal } = param.schema
-            param.schema = { type }
-            if (defaultVal !== undefined) param.schema.default = defaultVal
-            if (enumVal !== undefined) param.schema.enum = enumVal
+            param.schema = simplifyParameterSchema(param.schema)
           }
           return param
         }),
diff --git a/src/rest/scripts/utils/parameter-schema.ts b/src/rest/scripts/utils/parameter-schema.ts
new file mode 100644
index 000000000000..4458df15e1cb
--- /dev/null
+++ b/src/rest/scripts/utils/parameter-schema.ts
@@ -0,0 +1,45 @@
+import type { OpenApiParameterSchema } from './openapi-types'
+
+interface SchemaVariant {
+  type?: string | string[]
+  enum?: unknown[]
+  items?: { type?: unknown; enum?: unknown[] }
+}
+
+// Keep only the schema fields that parameter renderers read: type, default, and enum.
+// Multi-type parameters use oneOf or anyOf with no top-level type, so their type
+// and allowed values come from the variants instead.
+export function simplifyParameterSchema(schema: OpenApiParameterSchema): OpenApiParameterSchema {
+  const { type, default: defaultVal } = schema
+  let enumVal = schema.enum
+  const simplified: OpenApiParameterSchema = { type }
+
+  const variants = (schema.oneOf ?? schema.anyOf) as SchemaVariant[] | undefined
+  if (type === undefined && Array.isArray(variants)) {
+    const types = new Set<string>()
+    const enums = new Set<unknown>()
+    let everyVariantRestricted = variants.length > 0
+    for (const variant of variants) {
+      const variantTypes = Array.isArray(variant.type) ? variant.type : [variant.type]
+      for (const variantType of variantTypes) {
+        if (variantType === undefined) continue
+        // Match the "array of <type>s" wording that body parameters use.
+        types.add(
+          variantType === 'array' && typeof variant.items?.type === 'string'
+            ? `array of ${variant.items.type}s`
+            : variantType,
+        )
+      }
+      const variantEnum = variant.enum ?? variant.items?.enum
+      if (!variantEnum?.length) everyVariantRestricted = false
+      for (const value of variantEnum ?? []) enums.add(value)
+    }
+    if (types.size > 0) simplified.type = types.size === 1 ? [...types][0] : [...types]
+    // A variant without an enum accepts any value, so a combined list would wrongly narrow the parameter.
+    if (enumVal === undefined && everyVariantRestricted) enumVal = [...enums]
+  }
+
+  if (defaultVal !== undefined) simplified.default = defaultVal
+  if (enumVal !== undefined) simplified.enum = enumVal
+  return simplified
+}
diff --git a/src/rest/tests/parameter-schema.ts b/src/rest/tests/parameter-schema.ts
new file mode 100644
index 000000000000..643cdc646028
--- /dev/null
+++ b/src/rest/tests/parameter-schema.ts
@@ -0,0 +1,56 @@
+import { describe, expect, test } from 'vitest'
+
+import { simplifyParameterSchema } from '@/rest/scripts/utils/parameter-schema'
+
+describe('simplifyParameterSchema', () => {
+  test('keeps only type, default, and enum for a typed schema', () => {
+    expect(
+      simplifyParameterSchema({
+        type: 'string',
+        default: 'open',
+        enum: ['open', 'closed'],
+        example: 'open',
+      }),
+    ).toEqual({ type: 'string', default: 'open', enum: ['open', 'closed'] })
+  })
+
+  test('derives the type from oneOf variants', () => {
+    expect(
+      simplifyParameterSchema({
+        oneOf: [{ type: 'integer' }, { type: 'string' }],
+      }),
+    ).toEqual({ type: ['integer', 'string'] })
+  })
+
+  test('describes array variants by item type and omits enum when a variant is unrestricted', () => {
+    expect(
+      simplifyParameterSchema({
+        oneOf: [{ type: 'string' }, { type: 'array', items: { type: 'string', enum: ['patch'] } }],
+      }),
+    ).toEqual({ type: ['string', 'array of strings'] })
+  })
+
+  test('combines enum values when every variant is restricted', () => {
+    expect(
+      simplifyParameterSchema({
+        oneOf: [
+          { type: 'string', enum: ['patch'] },
+          { type: 'array', items: { type: 'string', enum: ['patch', 'deployment'] } },
+        ],
+      }),
+    ).toEqual({ type: ['string', 'array of strings'], enum: ['patch', 'deployment'] })
+  })
+
+  test('derives the type from anyOf variants and drops duplicate types', () => {
+    expect(
+      simplifyParameterSchema({
+        anyOf: [{ type: 'string' }, { type: 'string', enum: ['all'] }],
+        default: 'all',
+      }),
+    ).toEqual({ type: 'string', default: 'all' })
+  })
+
+  test('leaves the type undefined for an empty schema', () => {
+    expect(simplifyParameterSchema({})).toEqual({ type: undefined })
+  })
+})

From 40d586b705696e85ca43b6015deff02a0900a5aa Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 21:03:41 +0000
Subject: [PATCH 12/71] Count indented_data_reference uses in reusables find
 used and top-used (#64190)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 .../scripts/reusables-cli/README.md           |  2 +-
 .../scripts/reusables-cli/find/used.ts        |  6 ++--
 .../scripts/reusables-cli/shared.ts           |  5 ++-
 src/content-render/tests/reusables-cli.ts     | 31 +++++++++++++++++++
 4 files changed, 40 insertions(+), 4 deletions(-)
 create mode 100644 src/content-render/tests/reusables-cli.ts

diff --git a/src/content-render/scripts/reusables-cli/README.md b/src/content-render/scripts/reusables-cli/README.md
index eae841f38b02..75dd77bf6473 100644
--- a/src/content-render/scripts/reusables-cli/README.md
+++ b/src/content-render/scripts/reusables-cli/README.md
@@ -20,7 +20,7 @@ Helps find where reusables are already used, and where they could be used.
 
 ### Command: `npm run reusables -- find used <reusable-path>`
 
-Find where a specific reusable is used
+Find where a specific reusable is used. This counts both `{% data %}` and `{% indented_data_reference %}` tags.
 
 #### Example
 
diff --git a/src/content-render/scripts/reusables-cli/find/used.ts b/src/content-render/scripts/reusables-cli/find/used.ts
index 23e44a37d38f..1578e99d2811 100644
--- a/src/content-render/scripts/reusables-cli/find/used.ts
+++ b/src/content-render/scripts/reusables-cli/find/used.ts
@@ -57,8 +57,10 @@ export function findTopUsed(numberOfMostUsedToFind: number, { absolute }: { abso
     )
     for (const token of liquidTokens) {
       const { args, name } = token
-      if (name === 'data' && args.startsWith('reusables.')) {
-        reusableCounts.set(args, (reusableCounts.get(args) || 0) + 1)
+      if (name !== 'data' && name !== 'indented_data_reference') continue
+      const key = args.trim().split(/\s+/)[0]
+      if (key.startsWith('reusables.')) {
+        reusableCounts.set(key, (reusableCounts.get(key) || 0) + 1)
       }
     }
   }
diff --git a/src/content-render/scripts/reusables-cli/shared.ts b/src/content-render/scripts/reusables-cli/shared.ts
index 6d36e1ffb53c..5f30e7a3972e 100644
--- a/src/content-render/scripts/reusables-cli/shared.ts
+++ b/src/content-render/scripts/reusables-cli/shared.ts
@@ -61,7 +61,10 @@ export function getIndicesOfLiquidVariable(liquidVariable: string, fileContents:
       (token): token is TagToken => token.kind === TokenKind.Tag,
     )
     for (const token of tokens) {
-      if (token.name === 'data' && token.args.trim() === liquidVariable) {
+      if (
+        (token.name === 'data' || token.name === 'indented_data_reference') &&
+        token.args.trim().split(/\s+/)[0] === liquidVariable
+      ) {
         indices.push(token.begin)
       }
     }
diff --git a/src/content-render/tests/reusables-cli.ts b/src/content-render/tests/reusables-cli.ts
new file mode 100644
index 000000000000..3258788a03e1
--- /dev/null
+++ b/src/content-render/tests/reusables-cli.ts
@@ -0,0 +1,31 @@
+import { describe, expect, test } from 'vitest'
+
+import { getIndicesOfLiquidVariable } from '@/content-render/scripts/reusables-cli/shared'
+
+describe('getIndicesOfLiquidVariable', () => {
+  test('finds data and indented_data_reference tags', () => {
+    const contents = [
+      '{% data reusables.foo.bar %}',
+      '1. Step',
+      '   {% indented_data_reference reusables.foo.bar spaces=3 %}',
+    ].join('\n')
+    const indices = getIndicesOfLiquidVariable('reusables.foo.bar', contents)
+    expect(indices).toEqual([0, contents.indexOf('{% indented_data_reference')])
+  })
+
+  test('does not match a reusable that shares a prefix', () => {
+    const contents = [
+      '{% data reusables.foo.barbaz %}',
+      '{% indented_data_reference reusables.foo.barbaz spaces=3 %}',
+    ].join('\n')
+    expect(getIndicesOfLiquidVariable('reusables.foo.bar', contents)).toEqual([])
+  })
+
+  test('ignores other tags', () => {
+    const contents = [
+      '{% octicon "check" aria-label="reusables.foo.bar" %}',
+      '{% other_tag reusables.foo.bar spaces=3 %}',
+    ].join('\n')
+    expect(getIndicesOfLiquidVariable('reusables.foo.bar', contents)).toEqual([])
+  })
+})

From 0a0a880e70c6c0f487b88d06f0af642b7d7dc6b1 Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 21:03:48 +0000
Subject: [PATCH 13/71] Redirect /index.md to the homepage instead of an empty
 Location (#64192)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 src/fixtures/tests/bad-urls.ts                |  2 +-
 .../middleware/handle-invalid-paths.ts        |  4 ++-
 src/shielding/tests/handle-invalid-paths.ts   | 32 +++++++++++++++++++
 src/shielding/tests/shielding.ts              | 12 +++++++
 4 files changed, 48 insertions(+), 2 deletions(-)
 create mode 100644 src/shielding/tests/handle-invalid-paths.ts

diff --git a/src/fixtures/tests/bad-urls.ts b/src/fixtures/tests/bad-urls.ts
index eefeeb7f879b..1eb7950e4396 100644
--- a/src/fixtures/tests/bad-urls.ts
+++ b/src/fixtures/tests/bad-urls.ts
@@ -8,7 +8,7 @@ describe('bad URLs', () => {
     for (const url of URLs) {
       const res = await head(url)
       expect(res.statusCode).toBe(302)
-      expect(res.headers.location).toBe(url.replace(/\/index\.md$/, ''))
+      expect(res.headers.location).toBe(url.replace(/\/index\.md$/, '') || '/')
       expect(res.headers['cache-control']).toContain('public')
       expect(res.headers['cache-control']).toMatch(/max-age=[1-9]/)
     }
diff --git a/src/shielding/middleware/handle-invalid-paths.ts b/src/shielding/middleware/handle-invalid-paths.ts
index 6988c6f4adba..43ac8c7a2a5e 100644
--- a/src/shielding/middleware/handle-invalid-paths.ts
+++ b/src/shielding/middleware/handle-invalid-paths.ts
@@ -78,7 +78,9 @@ export default function handleInvalidPaths(
 
   if (req.path.endsWith('/index.md')) {
     defaultCacheControl(res)
-    const newUrl = req.originalUrl.replace(req.path, req.path.replace(/\/index\.md$/, ''))
+    // An empty path for /index.md would make the Location resolve back to /index.md.
+    const newPath = req.path.replace(/\/index\.md$/, '') || '/'
+    const newUrl = req.originalUrl.replace(req.path, newPath)
     return res.safeRedirect(newUrl)
   }
 
diff --git a/src/shielding/tests/handle-invalid-paths.ts b/src/shielding/tests/handle-invalid-paths.ts
new file mode 100644
index 000000000000..2da489598124
--- /dev/null
+++ b/src/shielding/tests/handle-invalid-paths.ts
@@ -0,0 +1,32 @@
+import type { NextFunction, Response } from 'express'
+import { describe, expect, test, vi } from 'vitest'
+
+import handleInvalidPaths from '@/shielding/middleware/handle-invalid-paths'
+import type { ExtendedRequest } from '@/types'
+
+describe('handleInvalidPaths /index.md redirects', () => {
+  test.each([
+    ['/index.md', '/index.md', '/'],
+    ['/index.md', '/index.md?foo=bar', '/?foo=bar'],
+    ['/en/index.md', '/en/index.md', '/en'],
+    ['/get-started/index.md', '/get-started/index.md?foo=bar', '/get-started?foo=bar'],
+  ])('%s with URL %s redirects to %s', (path, originalUrl, expected) => {
+    const req = { path, originalUrl } as ExtendedRequest
+    const res = {
+      headers: {} as Record<string, string>,
+      hasHeader: vi.fn(() => false),
+      set(name: string, value: string) {
+        res.headers[name] = value
+        return res
+      },
+      safeRedirect: vi.fn(),
+    }
+    const next = vi.fn() as NextFunction
+
+    handleInvalidPaths(req, res as unknown as Response, next)
+
+    expect(next).not.toHaveBeenCalled()
+    expect(res.safeRedirect).toHaveBeenCalledWith(expected)
+    expect(res.headers['cache-control']).toMatch('public')
+  })
+})
diff --git a/src/shielding/tests/shielding.ts b/src/shielding/tests/shielding.ts
index 43d297158c67..5d78bac64cb7 100644
--- a/src/shielding/tests/shielding.ts
+++ b/src/shielding/tests/shielding.ts
@@ -89,6 +89,18 @@ describe('index.md and .md suffixes', () => {
       expect(res.statusCode).toBe(302)
       expect(res.headers.location).toBe('/get-started?foo=bar')
     }
+    // Root
+    {
+      const res = await get('/index.md')
+      expect(res.statusCode).toBe(302)
+      expect(res.headers.location).toBe('/')
+    }
+    // Root with query string
+    {
+      const res = await get('/index.md?foo=bar')
+      expect(res.statusCode).toBe(302)
+      expect(res.headers.location).toBe('/?foo=bar')
+    }
   })
 
   test('any URL that ends with .md serves markdown directly', async () => {

From 20bae77517ba3f7477622ff49f74417d1a7ea48f Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 21:03:54 +0000
Subject: [PATCH 14/71] Send external search analytics without blocking the
 search (#64196)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 .../lib/helpers/external-search-analytics.ts  | 13 +++++++++--
 src/search/tests/external-search-analytics.ts | 22 ++++++++++++++++++-
 2 files changed, 32 insertions(+), 3 deletions(-)

diff --git a/src/search/lib/helpers/external-search-analytics.ts b/src/search/lib/helpers/external-search-analytics.ts
index bdbbafc28d70..5c39fc8cd266 100644
--- a/src/search/lib/helpers/external-search-analytics.ts
+++ b/src/search/lib/helpers/external-search-analytics.ts
@@ -1,5 +1,5 @@
 import { ExtendedRequest } from '@/types'
-import { publish } from '@/events/lib/hydro'
+import { publish, type EventT } from '@/events/lib/hydro'
 import { hydroNames } from '@/events/lib/schema'
 import { createLogger } from '@/observability/logger'
 
@@ -77,7 +77,8 @@ export async function handleExternalSearchAnalytics(
       },
     }
 
-    await publish(analyticsPayload)
+    // Publish in the background so Hydro latency never delays the search response.
+    sendAnalytics(analyticsPayload)
   } catch (error) {
     // Don't fail the request if analytics fails
     logger.error('Failed to send search analytics:', { error })
@@ -86,6 +87,14 @@ export async function handleExternalSearchAnalytics(
   return null
 }
 
+async function sendAnalytics(payload: EventT) {
+  try {
+    await publish(payload)
+  } catch (error) {
+    logger.error('Failed to send search analytics:', { error })
+  }
+}
+
 // Reduces a user agent down to its primary client identifier.
 function sanitizeUserAgent(userAgent: string | undefined): string {
   if (!userAgent) return 'unknown'
diff --git a/src/search/tests/external-search-analytics.ts b/src/search/tests/external-search-analytics.ts
index 484b60babd23..6c8676c9ffd9 100644
--- a/src/search/tests/external-search-analytics.ts
+++ b/src/search/tests/external-search-analytics.ts
@@ -5,7 +5,7 @@ import { handleExternalSearchAnalytics } from '@/search/lib/helpers/external-sea
 import type { ExtendedRequest } from '@/types'
 
 vi.mock('@/events/lib/hydro', () => ({
-  publish: vi.fn(),
+  publish: vi.fn(() => Promise.resolve()),
 }))
 
 function buildRequest(headers: Record<string, string>, query: Record<string, string> = {}) {
@@ -45,4 +45,24 @@ describe('handleExternalSearchAnalytics', () => {
     )
     expect(publish).not.toHaveBeenCalled()
   })
+
+  test('returns without waiting for publish to finish', async () => {
+    vi.mocked(publish).mockReturnValueOnce(new Promise<never>(() => {}))
+    const result = await handleExternalSearchAnalytics(
+      buildRequest({ 'user-agent': 'curl/8.0' }, { client_name: 'my-tool' }),
+      'general-search',
+    )
+    expect(result).toBeNull()
+    expect(publish).toHaveBeenCalledTimes(1)
+  })
+
+  test('returns null when publish rejects', async () => {
+    vi.mocked(publish).mockReturnValueOnce(Promise.reject(new Error('Hydro unavailable')))
+    const result = await handleExternalSearchAnalytics(
+      buildRequest({ 'user-agent': 'curl/8.0' }, { client_name: 'my-tool' }),
+      'general-search',
+    )
+    expect(result).toBeNull()
+    expect(publish).toHaveBeenCalledTimes(1)
+  })
 })

From 196ead00a1df3d1745903e11c4f1ba461f4a83fc Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 21:04:01 +0000
Subject: [PATCH 15/71] Run docs search on Enter after a Copilot error in
 search (#64197)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 .../tests/playwright-rendering.spec.ts        | 21 +++++++++++++++++++
 src/search/components/input/SearchOverlay.tsx |  6 ++++++
 2 files changed, 27 insertions(+)

diff --git a/src/fixtures/tests/playwright-rendering.spec.ts b/src/fixtures/tests/playwright-rendering.spec.ts
index e365a1095505..a1c03b56c17a 100644
--- a/src/fixtures/tests/playwright-rendering.spec.ts
+++ b/src/fixtures/tests/playwright-rendering.spec.ts
@@ -1053,6 +1053,27 @@ test.describe('search dialog', () => {
     await expect(rule).toHaveCSS('background-image', 'none')
   })
 
+  test('Enter with nothing selected runs the docs search after a Copilot error', async ({
+    page,
+  }) => {
+    // No upstreamStatus, so the overlay treats it as a Copilot error and shows the banner.
+    await page.route('**/api/ai-search/v1', (route) => route.fulfill({ status: 500, body: '{}' }))
+    await mockSearch(page)
+    await page.goto('/')
+    await turnOffExperimentsInPage(page)
+
+    await page.getByTestId('toggle-search').click()
+    const input = page.getByTestId('overlay-search-input')
+    await input.fill('foo')
+    await expect(page.locator('#search-option-general-0')).toBeVisible()
+    await input.press('Enter') // nothing selected: ask Copilot
+    await expect(page.getByText('There was an error loading Copilot.')).toBeVisible()
+
+    await input.fill('bar')
+    await input.press('Enter')
+    await expect(page).toHaveURL(/\/search\?.*query=bar/)
+  })
+
   test.describe('in a German-language browser', () => {
     test.use({ locale: 'de-DE' })
 
diff --git a/src/search/components/input/SearchOverlay.tsx b/src/search/components/input/SearchOverlay.tsx
index 50ee754d8f02..ecb15425a9a4 100644
--- a/src/search/components/input/SearchOverlay.tsx
+++ b/src/search/components/input/SearchOverlay.tsx
@@ -407,6 +407,12 @@ export function SearchOverlay({
         if (!urlSearchInputQuery.trim()) {
           return
         }
+        // Copilot stays off after an error, so Enter runs the docs search the banner offers.
+        if (aiSearchError) {
+          sendKeyboardEvent(event.key, 'view-all', searchEventGroupId, SEARCH_OVERLAY_EVENT_GROUP)
+          performGeneralSearch()
+          return
+        }
         sendKeyboardEvent(event.key, AI_SEARCH_CONTEXT, askAIEventGroupId, ASK_AI_EVENT_GROUP)
         aiSearchOptionOnSelect({ term: urlSearchInputQuery } as AutocompleteSearchHit)
         return

From e898cb287837084f6e44dc5f77e08de48d5eda4e Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 21:04:07 +0000
Subject: [PATCH 16/71] List valid version values for general search index runs
 (#64198)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 .github/workflows/index-general-search.yml | 2 +-
 src/search/README.md                       | 2 +-
 src/search/scripts/index/index-cli.ts      | 6 +++++-
 3 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/index-general-search.yml b/.github/workflows/index-general-search.yml
index 6ec3b423bf42..50ef546ed3ba 100644
--- a/.github/workflows/index-general-search.yml
+++ b/.github/workflows/index-general-search.yml
@@ -7,7 +7,7 @@ on:
   workflow_dispatch:
     inputs:
       version:
-        description: "Version to exclusively generate the search index for. E.g. 'dotcom', 'ghes-3.12'"
+        description: "Version to exclusively generate the search index for: 'fpt', 'ghec', or a supported 'ghes-X.Y'. Leave empty for all."
         required: false
         default: ''
       languages:
diff --git a/src/search/README.md b/src/search/README.md
index d7e787f4cc49..a921e87dca50 100644
--- a/src/search/README.md
+++ b/src/search/README.md
@@ -51,7 +51,7 @@ The workflow runs are only accessible to GitHub employees using internal resourc
 
 ## Manually triggering the search index update workflow
 
-You can manually run the workflow to generate the indexes after you push your changes to `main` to speed up the indexing when needed. It's recommended to do this for only the `free-pro-team@latest` version and the `en` language because running all languages and versions takes about 40 minutes. To run it manually, click "Run workflow" button in the Actions tab. Enter the language and version you'd like to generate the indexes for as inputs to the workflow. By default, all languages and versions are generated.
+You can manually run the workflow to generate the indexes after you push your changes to `main` to speed up the indexing when needed. It's recommended to do this for only the `fpt` version and the `en` language because running all languages and versions takes about 40 minutes. To run it manually, click "Run workflow" button in the Actions tab. Enter the language and version you'd like to generate the indexes for as inputs to the workflow. By default, all languages and versions are generated.
 
 ### Build and sync
 
diff --git a/src/search/scripts/index/index-cli.ts b/src/search/scripts/index/index-cli.ts
index 92564524d8f9..4ed5ea0d2d26 100644
--- a/src/search/scripts/index/index-cli.ts
+++ b/src/search/scripts/index/index-cli.ts
@@ -7,6 +7,7 @@ import { languageKeys } from '@/languages/lib/languages-server'
 import { indexGeneralSearch } from './lib/index-general-search'
 import {
   allIndexVersionKeys,
+  allIndexVersionOptions,
   supportedAutocompletePlanVersions,
   versionToIndexVersionMap,
 } from '@/search/lib/elasticsearch-versions'
@@ -25,7 +26,10 @@ const generalSearchCommand = new Command('general-search')
   )
   .option('-v, --verbose', 'Verbose outputs')
   .addOption(
-    new Option('-V, --version [VERSION...]', 'Specific versions').choices(allVersionKeysWithAll),
+    new Option('-V, --version [VERSION...]', 'Specific versions').choices([
+      ...allIndexVersionOptions,
+      'all',
+    ]),
   )
   .addOption(
     new Option('-l, --language <LANGUAGE...>', 'Which languages to focus on').choices(languageKeys),

From b8921b03d45b717462ac8b01aab77b5d4bd57511 Mon Sep 17 00:00:00 2001
From: Salil <salilsub@users.noreply.github.com>
Date: Tue, 20 Oct 2026 21:30:05 +0000
Subject: [PATCH 17/71] Updating the Agentic Workflows docs (#64258)

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 54a5e5f3-b258-4016-bf42-7e3ef2e50fd1
---
 .../about-github-agentic-workflows.md                       | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/content/copilot/concepts/agent-capabilities/agent-powered-workflows-and-operations/about-github-agentic-workflows.md b/content/copilot/concepts/agent-capabilities/agent-powered-workflows-and-operations/about-github-agentic-workflows.md
index e7b93f90cfda..8022260619e3 100644
--- a/content/copilot/concepts/agent-capabilities/agent-powered-workflows-and-operations/about-github-agentic-workflows.md
+++ b/content/copilot/concepts/agent-capabilities/agent-powered-workflows-and-operations/about-github-agentic-workflows.md
@@ -16,7 +16,7 @@ category:
 
 ## About {% data variables.copilot.agentic_workflows_short %}
 
-{% data variables.copilot.github_agentic_workflows %} are AI-powered repository automations that you define in markdown and run as {% data variables.product.prodname_actions %} workflows. Unlike traditional automation with fixed if-then rules, {% data variables.copilot.agentic_workflows_short %} use coding agents to understand context, make decisions, and take meaningful actions—all from natural language instructions.
+{% data variables.copilot.github_agentic_workflows %} are AI-powered repository automations that you define in markdown and run as {% data variables.product.prodname_actions %} workflows. Unlike traditional automation with fixed if-then rules, {% data variables.copilot.agentic_workflows_short %} use coding agents to understand context, evaluate decisions, and propose meaningful actions—all from natural language instructions.
 
 In practice, compared with traditional workflows that execute predefined steps:
 
@@ -35,7 +35,7 @@ With {% data variables.copilot.agentic_workflows_short %}, you can automate task
 
 * **Automate repetitive repository work**. Define issue triage, CI investigation, documentation updates, and reporting in natural language.
 * **Reduce workflow complexity**. Write markdown instructions instead of building complex procedural scripts for every scenario.
-* **Keep human review in the loop**. {% data variables.copilot.agentic_workflows_short_cap %} can generate ready-to-review outputs, such as issues, comments, and pull requests, while you control approvals and merges.
+* **Keep human review in the loop**. {% data variables.copilot.agentic_workflows_short_cap %} can generate reviewable outputs, such as issues, comments, and pull requests, while you control approvals and merges.
 * **Run agents with layered security**. Agents run in firewalled containers with read-only tokens by default. Write actions are limited to declared "safe outputs" that you have defined, and checked by agentic threat detection.
 
 ## Requirements
@@ -56,7 +56,7 @@ Each workflow markdown file has two parts:
 At a high level, the process to create and use {% data variables.copilot.agentic_workflows_short %} is:
 
 1. Define the agentic workflow `.md` file, including YAML frontmatter and markdown instructions.
-1. Compile the markdown workflow file into a hardened `.lock.yml` {% data variables.product.prodname_actions %} workflow file.
+1. Compile the markdown workflow file into a `.lock.yml` {% data variables.product.prodname_actions %} workflow file.
 1. Commit and push both files to the default branch of your repository.
 1. Run the workflow like any other {% data variables.product.prodname_actions %} workflow, on a trigger or in the {% data variables.product.github %} web interface for your repository. You can also run it from the {% data variables.product.prodname_cli %}.
 

From f1e045786674dbf4403d0ab2961f8c45553c4477 Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 21:31:04 +0000
Subject: [PATCH 18/71] Report links to missing pages as broken in the link
 checker (#63946)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 ...leshooting-resource-allocation-problems.md |  2 +-
 src/links/lib/extract-links.ts                | 36 +++++++++--
 src/links/tests/extract-links.ts              | 64 ++++++++++++++++++-
 3 files changed, 94 insertions(+), 8 deletions(-)

diff --git a/content/admin/monitoring-and-managing-your-instance/monitoring-your-instance/troubleshooting-resource-allocation-problems.md b/content/admin/monitoring-and-managing-your-instance/monitoring-your-instance/troubleshooting-resource-allocation-problems.md
index 75a63202ba2a..2a3c8d9f2fc2 100644
--- a/content/admin/monitoring-and-managing-your-instance/monitoring-your-instance/troubleshooting-resource-allocation-problems.md
+++ b/content/admin/monitoring-and-managing-your-instance/monitoring-your-instance/troubleshooting-resource-allocation-problems.md
@@ -22,7 +22,7 @@ category:
 
 We recommend using the monitor dashboard to stay informed on your appliance's resource health and make decisions on how to fix high usage issues, such as the ones outlined on this page.
 
-For system-critical issues, and prior to making modifications to your appliance, we highly recommend contacting us by visiting {% data variables.contact.contact_ent_support %} and including your support bundle. For more information, see [AUTOTITLE](/enterprise/{{ currentVersion}}/support/contacting-github-support/providing-data-to-github-support#creating-and-sharing-support-bundles).
+For system-critical issues, and prior to making modifications to your appliance, we highly recommend contacting us by visiting {% data variables.contact.contact_ent_support %} and including your support bundle. For more information, see [AUTOTITLE](/support/contacting-github-support/providing-data-to-github-support#creating-and-sharing-support-bundles).
 
 ## High CPU usage
 
diff --git a/src/links/lib/extract-links.ts b/src/links/lib/extract-links.ts
index 18f13f34188d..039806eea743 100644
--- a/src/links/lib/extract-links.ts
+++ b/src/links/lib/extract-links.ts
@@ -7,6 +7,7 @@ import { latestStable } from '@/versions/lib/enterprise-server-releases'
 import removeFPTFromPath from '@/versions/lib/remove-fpt-from-path'
 import { getDataByLanguage } from '@/data-directory/lib/get-data'
 import getRedirect from '@/redirects/lib/get-redirect'
+import { applyGraphqlCategoryRedirect } from '@/redirects/lib/graphql-category-redirect'
 import { isArchivedVersionByPath } from '@/archives/lib/is-archived-version'
 import { getFeaturesByVersion } from '@/versions/middleware/features'
 import type { Context, Page } from '@/types'
@@ -473,6 +474,28 @@ function versionedPageKey(
   return { key: `/${language}${withoutLanguage}`, withoutLanguage }
 }
 
+// getRedirect guesses some destinations without checking pages, and the redirect middleware
+// skips those when the page is missing, so an unverified target is a broken link.
+function redirectTargetExists(
+  redirect: string,
+  redirectTarget: string,
+  pageMap: Record<string, Page>,
+  language: string,
+): boolean {
+  if (redirect.includes('://')) return true
+  // The redirect middleware looks up pages without query strings, fragments, or .md.
+  const toLookupKey = (uri: string) => uri.split(/[?#]/)[0].replace(/\.md$/, '')
+  const target = toLookupKey(redirectTarget)
+  // Non-English runs load only their own pages, so the target must exist in the checked language.
+  const localizedTarget = target === '/' ? `/${language}` : `/${language}${target}`
+  return Boolean(
+    pageMap[toLookupKey(redirect)] ||
+    pageMap[target] ||
+    pageMap[localizedTarget] ||
+    isArchivedVersionByPath(redirect).isArchived,
+  )
+}
+
 // Resolve versionless links inside the checked version first, matching runtime rendering.
 // Without version context, non-FPT versionless links can fall through to fallback redirects
 // and look like links that need updating.
@@ -572,13 +595,14 @@ export function checkInternalLink(
       userLanguage: 'en',
       pages: pageMap,
     }
-    const redirect = getRedirect(withEn, context as unknown as Context)
-    if (redirect) {
+    const resolvedRedirect = getRedirect(withEn, context as unknown as Context)
+    if (resolvedRedirect) {
+      // The redirect middleware rewrites legacy GraphQL kind URLs before it checks the target.
+      const redirect = applyGraphqlCategoryRedirect(resolvedRedirect) || resolvedRedirect
       // Strip locale prefixes to match flat-map branches; a bare locale root normalizes to /.
-      return {
-        exists: true,
-        isRedirect: true,
-        redirectTarget: redirect.replace(/^\/[a-z]{2}(-[a-z]{2})?(?=\/|$)/, '') || '/',
+      const redirectTarget = redirect.replace(/^\/[a-z]{2}(-[a-z]{2})?(?=\/|$)/, '') || '/'
+      if (redirectTargetExists(redirect, redirectTarget, pageMap, language)) {
+        return { exists: true, isRedirect: true, redirectTarget }
       }
     }
   } catch {
diff --git a/src/links/tests/extract-links.ts b/src/links/tests/extract-links.ts
index a47294423d65..ef2d8a046080 100644
--- a/src/links/tests/extract-links.ts
+++ b/src/links/tests/extract-links.ts
@@ -9,7 +9,7 @@ import {
   createLiquidContext,
   extractLinksWithLiquid,
 } from '../lib/extract-links'
-import { latestStable } from '@/versions/lib/enterprise-server-releases'
+import { latest, latestStable } from '@/versions/lib/enterprise-server-releases'
 import { getFeaturesByVersion } from '@/versions/middleware/features'
 import type { Page } from '@/types'
 
@@ -533,6 +533,7 @@ describe('normalizeLinkPath', () => {
 
 describe('checkInternalLink', () => {
   const pageMap = {
+    '/en': {} as unknown as Page,
     '/en/actions/getting-started': {} as unknown as Page,
     '/en/repositories/overview': {} as unknown as Page,
     '/actions/guides': {} as unknown as Page,
@@ -797,6 +798,67 @@ describe('checkInternalLink', () => {
     expect(result.isRedirect).toBe(true)
     expect(result.redirectTarget).toBe('/')
   })
+
+  test.each([
+    '/admin/does-not-exist',
+    '/admin/guides/does-not-exist',
+    '/desktop/guides/does-not-exist',
+    '/free-pro-team@latest/does-not-exist',
+    '/enterprise-server/does-not-exist',
+    '/enterprise/user/does-not-exist',
+  ])('reports %s as broken when the redirect resolver target is missing', (href) => {
+    const result = checkInternalLink(href, pageMap, redirects)
+    expect(result.exists).toBe(false)
+    expect(result.isRedirect).toBe(false)
+  })
+
+  test('resolves an /admin/guides link through a versioned redirect to a real page', () => {
+    const result = checkInternalLink(
+      '/admin/guides/old-guide',
+      { [`/en/enterprise-server@${latest}/admin/new-guide`]: {} as unknown as Page },
+      {
+        [`/enterprise-server@${latest}/admin/old-guide`]: `/enterprise-server@${latest}/admin/new-guide`,
+      },
+    )
+    expect(result.exists).toBe(true)
+    expect(result.isRedirect).toBe(true)
+    expect(result.redirectTarget).toBe(`/enterprise-server@${latest}/admin/new-guide`)
+  })
+
+  test('ignores .md when checking a fallback redirect target', () => {
+    const result = checkInternalLink(
+      '/free-pro-team@latest/actions/getting-started.md',
+      pageMap,
+      redirects,
+    )
+    expect(result.exists).toBe(true)
+    expect(result.isRedirect).toBe(true)
+    expect(result.redirectTarget).toBe('/actions/getting-started.md')
+  })
+
+  test('applies the GraphQL category rewrite before checking a fallback redirect target', () => {
+    const result = checkInternalLink(
+      '/free-pro-team@latest/v4/scalar/boolean',
+      { '/en/graphql/reference/other': {} as unknown as Page },
+      { '/v4/scalar/boolean': '/graphql/reference/scalars#boolean' },
+    )
+    expect(result.exists).toBe(true)
+    expect(result.isRedirect).toBe(true)
+    expect(result.redirectTarget).toBe('/graphql/reference/other#scalar-boolean')
+  })
+
+  test('resolves fallback redirects in the checked language', () => {
+    const result = checkInternalLink(
+      '/free-pro-team@latest',
+      { '/ja': {} as unknown as Page },
+      {},
+      undefined,
+      'ja',
+    )
+    expect(result.exists).toBe(true)
+    expect(result.isRedirect).toBe(true)
+    expect(result.redirectTarget).toBe('/')
+  })
 })
 
 describe('resolveInternalLinkKey', () => {

From 9801575680e417f0a49ae44f3f0194c299ca2ab2 Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 21:31:11 +0000
Subject: [PATCH 19/71] Include required query params in Octokit REST code
 examples (#63990)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 src/rest/components/get-rest-code-samples.ts |  19 ++-
 src/rest/tests/get-rest-code-samples-2.ts    | 116 +++++++++++++++++++
 2 files changed, 131 insertions(+), 4 deletions(-)

diff --git a/src/rest/components/get-rest-code-samples.ts b/src/rest/components/get-rest-code-samples.ts
index 63b000ca93ac..74ee7cd3296d 100644
--- a/src/rest/components/get-rest-code-samples.ts
+++ b/src/rest/components/get-rest-code-samples.ts
@@ -344,6 +344,13 @@ export function getJSExample(
     }
   }
 
+  // Code examples only carry path params, so required query params need explicit values.
+  for (const [name, value] of Object.entries(getRequiredQueryParams(operation, codeSample))) {
+    if (!Object.hasOwn(parameters, name)) {
+      parameters[name] = value
+    }
+  }
+
   let queryParameters = ''
 
   if (
@@ -405,17 +412,21 @@ function findMatchingQueryKey(exampleObj: CodeExamples | CodeExamples[], matchKe
   return match
 }
 
-export function getRequiredQueryParamsPath(operation: Operation, codeSample: CodeSample) {
-  const requiredQueryParams = new URLSearchParams()
+function getRequiredQueryParams(operation: Operation, codeSample: CodeSample) {
+  const requiredQueryParams: Record<string, string> = {}
   for (const param of operation.parameters) {
     if (param.in === 'query' && param.required === true) {
       const codeExamples = codeSample.response?.example
       const match = findMatchingQueryKey(codeExamples, param.name)
-      requiredQueryParams.append(param.name, match || param.name.toUpperCase())
+      requiredQueryParams[param.name] = match || param.name.toUpperCase()
     }
   }
 
-  return requiredQueryParams.toString()
+  return requiredQueryParams
+}
+
+export function getRequiredQueryParamsPath(operation: Operation, codeSample: CodeSample) {
+  return new URLSearchParams(getRequiredQueryParams(operation, codeSample)).toString()
 }
 
 export function getAcceptHeader(codeSample: CodeSample) {
diff --git a/src/rest/tests/get-rest-code-samples-2.ts b/src/rest/tests/get-rest-code-samples-2.ts
index 82420df02509..4565996826e8 100644
--- a/src/rest/tests/get-rest-code-samples-2.ts
+++ b/src/rest/tests/get-rest-code-samples-2.ts
@@ -549,6 +549,122 @@ describe('REST code samples authentication header handling', () => {
       expect(result).toContain("id: 'MVS-2026-001'")
       expect(result).not.toMatch(/["']0["']\s*:/)
     })
+
+    test('includes required query params for GET requests', () => {
+      const searchOperation: Operation = {
+        ...standardOperation,
+        verb: 'get',
+        title: 'Search code',
+        requestPath: '/search/code',
+        parameters: [
+          {
+            in: 'query',
+            name: 'q',
+            description: '',
+            required: true,
+            schema: { type: 'string' },
+          },
+        ],
+      }
+      const searchCodeSample = {
+        request: {
+          description: 'Example',
+          acceptHeader: 'application/vnd.github+json',
+        },
+        response: {
+          statusCode: '200',
+          contentType: 'application/json',
+          description: 'Response',
+          example: { total_count: 0, items: [] },
+        },
+      } as unknown as CodeSample
+
+      const result = getJSExample(
+        searchOperation,
+        searchCodeSample,
+        'free-pro-team@latest',
+        mockVersions,
+      )
+
+      expect(result).toContain("await octokit.request('GET /search/code', {")
+      expect(result).toContain("q: 'Q'")
+    })
+
+    test('fills required query params in the URL template for mutating requests', () => {
+      const deleteCacheOperation: Operation = {
+        ...standardOperation,
+        verb: 'delete',
+        title: 'Delete GitHub Actions caches for a repository (using a cache key)',
+        requestPath: '/repos/{owner}/{repo}/actions/caches',
+        parameters: [
+          {
+            in: 'path',
+            name: 'owner',
+            description: '',
+            required: true,
+            schema: { type: 'string' },
+          },
+          {
+            in: 'path',
+            name: 'repo',
+            description: '',
+            required: true,
+            schema: { type: 'string' },
+          },
+          {
+            in: 'query',
+            name: 'key',
+            description: '',
+            required: true,
+            schema: { type: 'string' },
+          },
+          {
+            in: 'query',
+            name: 'ref',
+            description: '',
+            required: false,
+            schema: { type: 'string' },
+          },
+        ],
+      }
+      const deleteCacheCodeSample = {
+        request: {
+          description: 'Example',
+          acceptHeader: 'application/vnd.github+json',
+          parameters: { owner: 'OWNER', repo: 'REPO' },
+        },
+        response: {
+          statusCode: '200',
+          contentType: 'application/json',
+          description: 'Response',
+          example: {
+            total_count: 1,
+            actions_caches: [{ id: 505, ref: 'refs/heads/main', key: 'Linux-node-958aff96' }],
+          },
+        },
+      } as unknown as CodeSample
+
+      const jsResult = getJSExample(
+        deleteCacheOperation,
+        deleteCacheCodeSample,
+        'free-pro-team@latest',
+        mockVersions,
+      )
+      const shellResult = getShellExample(
+        deleteCacheOperation,
+        deleteCacheCodeSample,
+        'free-pro-team@latest',
+        mockVersions,
+      )
+
+      expect(jsResult).toContain(
+        "await octokit.request('DELETE /repos/{owner}/{repo}/actions/caches{?key,ref}'",
+      )
+      expect(jsResult).toContain("owner: 'OWNER'")
+      expect(jsResult).toContain("key: 'Linux-node-958aff96'")
+      expect(jsResult).not.toContain('ref:')
+      expect(shellResult).toContain('/repos/OWNER/REPO/actions/caches?key=Linux-node-958aff96')
+    })
   })
 
   describe('edge cases and special scenarios', () => {

From 0bb87cef7dab5eb111aaf810f45346c785d9c4c5 Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 21:31:17 +0000
Subject: [PATCH 20/71] Show intro links in Article API markdown for bespoke
 landing pages (#64023)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
Copilot-Session: fb5d8be8-479c-4950-8197-ef0220dbdcb0
---
 .../lib/get-intro-links-section.ts            |  25 ++++
 .../tests/bespoke-landing-transformer.ts      |  18 +++
 .../tests/landing-intro-links.test.ts         | 112 ++++++++++++++++++
 .../bespoke-landing-transformer.ts            |   5 +
 .../discovery-landing-transformer.ts          |  42 +------
 .../get-started/article-grid-bespoke/index.md |   3 +
 6 files changed, 167 insertions(+), 38 deletions(-)
 create mode 100644 src/article-api/lib/get-intro-links-section.ts
 create mode 100644 src/article-api/tests/landing-intro-links.test.ts

diff --git a/src/article-api/lib/get-intro-links-section.ts b/src/article-api/lib/get-intro-links-section.ts
new file mode 100644
index 000000000000..4311a73d01b4
--- /dev/null
+++ b/src/article-api/lib/get-intro-links-section.ts
@@ -0,0 +1,25 @@
+import type { Context, Page } from '@/types'
+import type { LinkData, Section } from '@/article-api/transformers/types'
+
+interface PageWithIntroLinks extends Page {
+  rawIntroLinks?: Record<string, string>
+}
+
+// Reads rawIntroLinks because Page.render overwrites introLinks on the Page that every version shares.
+export async function getIntroLinksSection(page: Page, context: Context): Promise<Section | null> {
+  const { rawIntroLinks } = page as PageWithIntroLinks
+  if (!rawIntroLinks) return null
+
+  const { default: getPageLinkData } = await import('@/frame/lib/get-link-data')
+  const links: LinkData[] = []
+  for (const rawHref of Object.values(rawIntroLinks)) {
+    if (typeof rawHref !== 'string') continue
+    const [item] = (await getPageLinkData(rawHref, context)) ?? []
+    if (item?.href) {
+      links.push({ href: item.href, title: item.title || '', intro: item.intro || '' })
+    }
+  }
+
+  if (links.length === 0) return null
+  return { title: 'Links', groups: [{ title: 'Getting started', links }] }
+}
diff --git a/src/article-api/tests/bespoke-landing-transformer.ts b/src/article-api/tests/bespoke-landing-transformer.ts
index d6f2827ee5a3..f3c0edad7078 100644
--- a/src/article-api/tests/bespoke-landing-transformer.ts
+++ b/src/article-api/tests/bespoke-landing-transformer.ts
@@ -26,4 +26,22 @@ describe('bespoke landing transformer', () => {
     expect(res.body).toContain('[Grid Article Three]')
     expect(res.body).toContain('[Grid Article Four]')
   })
+
+  test('renders intro links as a getting started section', async () => {
+    const res = await get(makeURL('/en/get-started/article-grid-bespoke'))
+    expect(res.statusCode).toBe(200)
+
+    const start = res.body.indexOf('## Links')
+    expect(start).toBeGreaterThan(-1)
+    const end = res.body.indexOf('\n## ', start)
+    const linksSection = res.body.slice(start, end === -1 ? undefined : end)
+    expect(linksSection).toContain('### Getting started')
+    expect(linksSection).toContain(
+      '[Grid Article One](/en/get-started/article-grid-bespoke/grid-category-one/grid-article-one)',
+    )
+    expect(linksSection).toContain(
+      '[Grid Article Three](/en/get-started/article-grid-bespoke/grid-category-two/grid-article-three)',
+    )
+    expect(linksSection).not.toContain('[Grid Article Two]')
+  })
 })
diff --git a/src/article-api/tests/landing-intro-links.test.ts b/src/article-api/tests/landing-intro-links.test.ts
new file mode 100644
index 000000000000..4b2b1dfd9b32
--- /dev/null
+++ b/src/article-api/tests/landing-intro-links.test.ts
@@ -0,0 +1,112 @@
+import { describe, expect, test } from 'vitest'
+
+import { BespokeLandingTransformer } from '@/article-api/transformers/bespoke-landing-transformer'
+import { DiscoveryLandingTransformer } from '@/article-api/transformers/discovery-landing-transformer'
+import shortVersionsMiddleware from '@/versions/middleware/short-versions'
+import { allVersions } from '@/versions/lib/all-versions'
+import enterpriseServerReleases from '@/versions/lib/enterprise-server-releases'
+import type { Context, ExtendedRequest, Page } from '@/types'
+
+const ghesVersion = `enterprise-server@${enterpriseServerReleases.latest}`
+const overviewPath = '/billing/get-started/how-billing-works'
+const ghesOverviewPath = '/billing/concepts/enterprise-billing/billing-for-enterprises'
+const rawOverview = `{% ifversion fpt or ghec %}${overviewPath} {% elsif ghes %}${ghesOverviewPath}{% endif %}`
+
+const makeLinkedPage = (title: string) =>
+  ({
+    title,
+    intro: '',
+    // resolveCarouselLinks drops links whose page does not apply to the requested version.
+    applicableVersions: Object.keys(allVersions),
+    renderTitle: async () => title,
+    renderProp: async () => '',
+  }) as unknown as Page
+
+const pages: Record<string, Page> = {
+  [`/en${overviewPath}`]: makeLinkedPage('How billing works'),
+  [`/en${ghesOverviewPath}`]: makeLinkedPage('Billing for enterprises'),
+  [`/en/${ghesVersion}${ghesOverviewPath}`]: makeLinkedPage('Billing for enterprises'),
+}
+
+// staleOverview stands in for the introLinks value that Page.render leaves on the shared Page.
+const makeLandingPage = (layout: string, staleOverview: string) =>
+  ({
+    layout,
+    title: 'Billing',
+    intro: '',
+    rawIntroLinks: { overview: rawOverview },
+    introLinks: { overview: staleOverview },
+    rawCarousels: { recommended: [ghesOverviewPath] },
+    renderTitle: async () => 'Billing',
+    renderProp: async () => '',
+  }) as unknown as Page
+
+const buildContext = async (currentVersion: string): Promise<Context> => {
+  const req = { language: 'en', query: {} } as ExtendedRequest
+  req.context = {
+    currentLanguage: 'en',
+    currentVersion,
+    currentVersionObj: allVersions[currentVersion],
+    allVersions,
+    enterpriseServerReleases,
+    pages,
+    redirects: {},
+  } as Context
+  await shortVersionsMiddleware(req, null, () => {})
+  return req.context
+}
+
+const getLinksSection = (body: string) => {
+  const start = body.indexOf('## Links')
+  if (start === -1) return ''
+  const end = body.indexOf('\n## ', start)
+  return end === -1 ? body.slice(start) : body.slice(start, end)
+}
+
+describe.each([
+  {
+    name: 'discovery',
+    layout: 'discovery-landing',
+    transformer: new DiscoveryLandingTransformer(),
+  },
+  { name: 'bespoke', layout: 'bespoke-landing', transformer: new BespokeLandingTransformer() },
+])('$name landing intro links', ({ layout, transformer }) => {
+  test('renders raw intro links for fpt when the page holds a GHES render', async () => {
+    const page = makeLandingPage(layout, ghesOverviewPath)
+    const body = await transformer.transform(
+      page,
+      '/en/billing',
+      await buildContext('free-pro-team@latest'),
+    )
+
+    const linksSection = getLinksSection(body)
+    expect(linksSection).toContain('### Getting started')
+    expect(linksSection).toContain(`[How billing works](/en${overviewPath})`)
+    expect(linksSection).not.toContain('Billing for enterprises')
+  })
+
+  test('renders raw intro links for GHES when the page holds an fpt render', async () => {
+    const page = makeLandingPage(layout, overviewPath)
+    const body = await transformer.transform(page, '/en/billing', await buildContext(ghesVersion))
+
+    const linksSection = getLinksSection(body)
+    expect(linksSection).toContain(
+      `[Billing for enterprises](/en/${ghesVersion}${ghesOverviewPath})`,
+    )
+    expect(body).not.toContain('How billing works')
+  })
+})
+
+describe('bespoke landing intro links order', () => {
+  test('lists intro links before carousels, like the page hero', async () => {
+    const page = makeLandingPage('bespoke-landing', overviewPath)
+    const body = await new BespokeLandingTransformer().transform(
+      page,
+      '/en/billing',
+      await buildContext('free-pro-team@latest'),
+    )
+
+    expect(body.indexOf('## Links')).toBeGreaterThan(-1)
+    expect(body.indexOf('## Links')).toBeLessThan(body.indexOf('## Recommended'))
+  })
+})
diff --git a/src/article-api/transformers/bespoke-landing-transformer.ts b/src/article-api/transformers/bespoke-landing-transformer.ts
index 2d95160ba0bf..3927bf6c936a 100644
--- a/src/article-api/transformers/bespoke-landing-transformer.ts
+++ b/src/article-api/transformers/bespoke-landing-transformer.ts
@@ -3,6 +3,7 @@ import type { PageTransformer, TemplateData, Section } from './types'
 import { renderContent } from '@/content-render/index'
 import { loadTemplate } from '@/article-api/lib/load-template'
 import { getAllTocItems, flattenTocItems } from '@/article-api/lib/get-all-toc-items'
+import { getIntroLinksSection } from '@/article-api/lib/get-intro-links-section'
 import { resolveCarouselLinks } from '@/article-api/lib/resolve-carousel-links'
 
 interface BespokeLandingPage extends Omit<Page, 'featuredLinks'> {
@@ -42,6 +43,10 @@ export class BespokeLandingTransformer implements PageTransformer {
     const bespokePage = page as BespokeLandingPage
     const sections: Section[] = []
 
+    // Intro links come first to match the hero, which renders above the carousels.
+    const introLinksSection = await getIntroLinksSection(page, context)
+    if (introLinksSection) sections.push(introLinksSection)
+
     // resolve-carousels overwrites page.carousels on the shared Page with another version's links.
     const carousels = bespokePage.rawCarousels
     if (carousels && typeof carousels === 'object') {
diff --git a/src/article-api/transformers/discovery-landing-transformer.ts b/src/article-api/transformers/discovery-landing-transformer.ts
index 331b6f46e006..03d5a9cc8e7e 100644
--- a/src/article-api/transformers/discovery-landing-transformer.ts
+++ b/src/article-api/transformers/discovery-landing-transformer.ts
@@ -1,13 +1,12 @@
 import type { Context, Page } from '@/types'
-import type { PageTransformer, TemplateData, Section, LinkData } from './types'
+import type { PageTransformer, TemplateData, Section } from './types'
 import { renderContent } from '@/content-render/index'
 import { loadTemplate } from '@/article-api/lib/load-template'
 import { getAllTocItems, flattenTocItems } from '@/article-api/lib/get-all-toc-items'
+import { getIntroLinksSection } from '@/article-api/lib/get-intro-links-section'
 import { resolveCarouselLinks } from '@/article-api/lib/resolve-carousel-links'
 
 interface DiscoveryPage extends Page {
-  rawIntroLinks?: Record<string, string>
-  introLinks?: Record<string, string>
   rawCarousels?: Record<string, string[]>
   includedCategories?: string[]
   children?: string[]
@@ -60,41 +59,8 @@ export class DiscoveryLandingTransformer implements PageTransformer {
       }
     }
 
-    const rawIntroLinks = discoveryPage.introLinks ?? discoveryPage.rawIntroLinks
-    if (rawIntroLinks) {
-      const { default: getPageLinkData } = await import('@/frame/lib/get-link-data')
-      const links = await Promise.all(
-        Object.values(rawIntroLinks).map(async (href): Promise<LinkData> => {
-          if (typeof href === 'string') {
-            const linkData = await getPageLinkData(href, context)
-            if (Array.isArray(linkData) && linkData.length > 0) {
-              const item = linkData[0]
-              return { href: item.href || '', title: item.title || '', intro: item.intro || '' }
-            } else if (
-              linkData &&
-              typeof linkData === 'object' &&
-              !Array.isArray(linkData) &&
-              'href' in linkData
-            ) {
-              const item = linkData as { href?: string; title?: string; intro?: string }
-              return {
-                href: item.href || '',
-                title: item.title || '',
-                intro: item.intro || '',
-              }
-            }
-          }
-          return { href: '', title: '' }
-        }),
-      )
-      const validLinks = links.filter((l) => l.href)
-      if (validLinks.length > 0) {
-        sections.push({
-          title: 'Links',
-          groups: [{ title: 'Getting started', links: validLinks }],
-        })
-      }
-    }
+    const introLinksSection = await getIntroLinksSection(page, context)
+    if (introLinksSection) sections.push(introLinksSection)
 
     // getAllTocItems sets basePath to keep /rest from recursing into /enterprise-admin children.
     if (discoveryPage.children && discoveryPage.children.length > 0) {
diff --git a/src/fixtures/fixtures/content/get-started/article-grid-bespoke/index.md b/src/fixtures/fixtures/content/get-started/article-grid-bespoke/index.md
index 44447fafcc3a..fa16125b4202 100644
--- a/src/fixtures/fixtures/content/get-started/article-grid-bespoke/index.md
+++ b/src/fixtures/fixtures/content/get-started/article-grid-bespoke/index.md
@@ -6,6 +6,9 @@ versions:
   ghes: "*"
   ghec: "*"
 layout: bespoke-landing
+introLinks:
+  overview: "{% ifversion fpt or ghec %}/get-started/article-grid-bespoke/grid-category-one/grid-article-one{% elsif ghes %}/get-started/article-grid-bespoke/grid-category-one/grid-article-two{% endif %}"
+  quickstart: /get-started/article-grid-bespoke/grid-category-two/grid-article-three
 carousels:
   recommended:
     - /grid-category-one/grid-article-one

From 567fa4a087abe380e137868aa69db4b274623301 Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 21:31:24 +0000
Subject: [PATCH 21/71] Skip hidden pages in Article API landing page article
 lists (#64044)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 src/article-api/lib/get-all-toc-items.ts   |  2 ++
 src/article-api/tests/get-all-toc-items.ts | 41 +++++++++++++++++++++-
 2 files changed, 42 insertions(+), 1 deletion(-)

diff --git a/src/article-api/lib/get-all-toc-items.ts b/src/article-api/lib/get-all-toc-items.ts
index d4e8ca5bc7db..51ed67bd1ec1 100644
--- a/src/article-api/lib/get-all-toc-items.ts
+++ b/src/article-api/lib/get-all-toc-items.ts
@@ -16,6 +16,7 @@ interface TocItem extends LinkData {
 }
 
 // Mirrors getTocItems() in src/frame/middleware/context/generic-toc.ts for frontmatter children.
+// The site shows hidden children only in early access TOCs, so skip them here.
 export async function getAllTocItems(
   page: Page,
   context: Context,
@@ -49,6 +50,7 @@ export async function getAllTocItems(
     .filter(
       (entry): entry is { childHref: string; childPage: PageWithChildren } =>
         entry.childPage !== undefined &&
+        !entry.childPage.hidden &&
         // resolvePath can return a page from another version, which the website hides.
         (!context.currentVersion ||
           entry.childPage.applicableVersions.includes(context.currentVersion)),
diff --git a/src/article-api/tests/get-all-toc-items.ts b/src/article-api/tests/get-all-toc-items.ts
index de877a40154e..a024c3e78de5 100644
--- a/src/article-api/tests/get-all-toc-items.ts
+++ b/src/article-api/tests/get-all-toc-items.ts
@@ -1,5 +1,5 @@
 import { describe, expect, test, vi } from 'vitest'
-import { getAllTocItems } from '@/article-api/lib/get-all-toc-items'
+import { getAllTocItems, flattenTocItems } from '@/article-api/lib/get-all-toc-items'
 import type { Context, Page, Permalink } from '@/types'
 
 function createMockPage(options: {
@@ -7,6 +7,7 @@ function createMockPage(options: {
   applicableVersions: string[]
   permalinks: Partial<Permalink>[]
   children?: string[]
+  hidden?: boolean
 }): Page {
   return {
     languageCode: 'en',
@@ -14,6 +15,7 @@ function createMockPage(options: {
     applicableVersions: options.applicableVersions,
     permalinks: options.permalinks as Permalink[],
     children: options.children,
+    hidden: options.hidden,
     renderProp: vi.fn().mockResolvedValue(''),
   } as unknown as Page
 }
@@ -61,4 +63,41 @@ describe('getAllTocItems', () => {
     expect(items.map((item) => item.href)).toEqual(['/en/rest/quickstart'])
     expect(items[0].title).toBe('Quickstart')
   })
+
+  test('skips hidden children and does not recurse into hidden categories', async () => {
+    const VERSION = 'free-pro-team@latest'
+    const page = (
+      href: string,
+      rawTitle: string,
+      extra: { children?: string[]; hidden?: boolean } = {},
+    ) =>
+      createMockPage({
+        rawTitle,
+        applicableVersions: [VERSION],
+        permalinks: [{ languageCode: 'en', pageVersion: VERSION, href }],
+        ...extra,
+      })
+    const landing = page('/en/policy', 'Policy', {
+      children: ['/visible-article', '/hidden-article', '/hidden-category'],
+    })
+    const pages = [
+      landing,
+      page('/en/policy/visible-article', 'Visible Article'),
+      page('/en/policy/hidden-article', 'Hidden Article', { hidden: true }),
+      page('/en/policy/hidden-category', 'Hidden Category', {
+        children: ['/visible-leaf'],
+        hidden: true,
+      }),
+      // A visible leaf proves a hidden category drops its whole subtree.
+      page('/en/policy/hidden-category/visible-leaf', 'Visible Leaf'),
+    ]
+    const byHref: Record<string, Page> = {}
+    for (const p of pages) byHref[p.permalinks[0].href] = p
+    const context = { pages: byHref, redirects: {}, currentVersion: VERSION } as unknown as Context
+
+    const tocItems = await getAllTocItems(landing, context)
+    const titles = flattenTocItems(tocItems).map((item) => item.title)
+
+    expect(titles).toEqual(['Visible Article'])
+  })
 })

From e4ef78791a19eeb9a9f3a07a4479bb82048f92f5 Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 21:31:30 +0000
Subject: [PATCH 22/71] Keep links in English fallback content in the reader's
 language (#64100)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 .../unified/rewrite-local-links.ts            | 16 ++++-
 src/languages/lib/render-with-fallback.ts     | 15 +++-
 .../tests/translation-error-comments.ts       | 71 +++++++++++++++++++
 3 files changed, 98 insertions(+), 4 deletions(-)

diff --git a/src/content-render/unified/rewrite-local-links.ts b/src/content-render/unified/rewrite-local-links.ts
index 924b01a925e5..c8eeaa65b616 100644
--- a/src/content-render/unified/rewrite-local-links.ts
+++ b/src/content-render/unified/rewrite-local-links.ts
@@ -197,7 +197,21 @@ async function getNewTitle(href: string, context: Context, child: Text, original
     const line = child.position?.start.line || 1
     throw autotitleResolutionError(originalHref || href, line, context)
   }
-  return await page.renderProp('title', context, { textOnly: true })
+  return await page.renderProp('title', getTitleContext(page, href, context), { textOnly: true })
+}
+
+// Translated title fallbacks need the linked page's English version, not the rendered page's.
+function getTitleContext(page: Page, href: string, context: Context): Context {
+  if (!context.getEnglishPage) return context
+  const enPage =
+    page.languageCode === 'en'
+      ? page
+      : findPage(
+          path.posix.join('/en', getPathWithoutLanguage(href)),
+          context.pages,
+          context.redirects,
+        )
+  return enPage ? { ...context, enPage } : context
 }
 
 export function autotitleResolutionError(
diff --git a/src/languages/lib/render-with-fallback.ts b/src/languages/lib/render-with-fallback.ts
index 54b419516664..f863680d5b3a 100644
--- a/src/languages/lib/render-with-fallback.ts
+++ b/src/languages/lib/render-with-fallback.ts
@@ -131,8 +131,12 @@ export async function renderContentWithFallback(
       const enPage = getEnglishFallbackPage(page, context)
       if (!enPage) throw error
       const englishTemplate = (enPage as unknown as Record<string, string>)[property]
-      // Set currentLanguage to en so Liquid plugins such as data.ts read English data.
-      const enContext = Object.assign({}, context, { currentLanguage: 'en' })
+      // data.ts reads English data while rewriteLocalLinks keeps links in the reader's language.
+      const enContext = {
+        ...context,
+        currentLanguage: 'en',
+        autotitleLanguage: context.autotitleLanguage || context.currentLanguage,
+      }
 
       const fallbackContent = await renderContent(englishTemplate, enContext, options)
 
@@ -165,7 +169,12 @@ export async function executeWithFallback<T>(
     return await Promise.resolve(callable(context))
   } catch (error) {
     if (isFallbackableError(error) && context.currentLanguage !== 'en') {
-      const enContext = Object.assign({}, context, { currentLanguage: 'en' })
+      // data.ts reads English data while rewriteLocalLinks keeps links in the reader's language.
+      const enContext = {
+        ...context,
+        currentLanguage: 'en',
+        autotitleLanguage: context.autotitleLanguage || context.currentLanguage,
+      }
       const fallbackContent = await Promise.resolve(fallback(enContext))
 
       // Only HTML fallback content can carry a comment without changing plain-text output.
diff --git a/src/languages/tests/translation-error-comments.ts b/src/languages/tests/translation-error-comments.ts
index 5619ebd84b5a..790fc0562511 100644
--- a/src/languages/tests/translation-error-comments.ts
+++ b/src/languages/tests/translation-error-comments.ts
@@ -8,6 +8,7 @@ import {
 } from '../lib/render-with-fallback'
 import { TitleFromAutotitleError } from '@/content-render/unified/rewrite-local-links'
 import Page from '@/frame/lib/page'
+import type { Context } from '@/types'
 
 describe('Translation Error Comments', () => {
   let mockRenderContent: MockedFunction<
@@ -361,6 +362,57 @@ describe('Translation Error Comments', () => {
         expect(result).toBe('English Title')
       })
 
+      test('keeps fallback links in the reader language', async () => {
+        const mockPage = Object.create(Page.prototype)
+        mockPage.markdown = '{% badtag %} [x](/actions/foo)'
+
+        const context = {
+          currentLanguage: 'ja',
+          currentVersion: 'free-pro-team@latest',
+          getEnglishPage: () => {
+            const enPage = Object.create(Page.prototype)
+            enPage.markdown = 'English [link](/actions/foo)'
+            return enPage
+          },
+        }
+
+        const result = await renderContentWithFallback(mockPage, 'markdown', context)
+
+        expect(result).toContain('<!-- TRANSLATION_FALLBACK')
+        expect(result).toContain('href="/ja/actions/foo"')
+        expect(result).not.toContain('href="/en/')
+      })
+
+      test('uses the linked page English title when its translated title fails', async () => {
+        const mockPage = Object.create(Page.prototype)
+        mockPage.markdown = '{% badtag %} [AUTOTITLE](/actions/b)'
+
+        const enPageA = Object.create(Page.prototype)
+        enPageA.rawTitle = 'English A'
+        enPageA.markdown = 'See [AUTOTITLE](/actions/b)'
+
+        const jaPageB = Object.create(Page.prototype)
+        jaPageB.languageCode = 'ja'
+        jaPageB.rawTitle = '{% badtag %}'
+
+        const enPageB = Object.create(Page.prototype)
+        enPageB.languageCode = 'en'
+        enPageB.rawTitle = 'English B'
+
+        const context = {
+          currentLanguage: 'ja',
+          currentVersion: 'free-pro-team@latest',
+          pages: { '/ja/actions/b': jaPageB, '/en/actions/b': enPageB },
+          // Matches contextualize, which caches the English page of the article being rendered.
+          getEnglishPage: (ctx: Context) => (ctx.enPage ||= enPageA),
+        }
+
+        const result = await renderContentWithFallback(mockPage, 'markdown', context)
+
+        expect(result).toContain('<a href="/ja/actions/b">English B</a>')
+        expect(result).not.toContain('English A')
+      })
+
       describe('when rendering a page other than the request page', () => {
         const makePage = (languageCode: string, href: string, props: Record<string, string>) => {
           const page = Object.create(Page.prototype)
@@ -472,6 +524,25 @@ describe('Translation Error Comments', () => {
         expect(result).not.toContain('<!-- TRANSLATION_FALLBACK')
         expect(result).toBe('Plain text fallback')
       })
+
+      test('passes an English context that keeps links in the reader language', async () => {
+        const context = {
+          currentLanguage: 'es',
+        }
+
+        const failingCallable = async () => {
+          throw new LiquidError('Test error', 'RenderError')
+        }
+
+        const fallbackCallable = vi.fn(async () => 'Fallback')
+
+        await executeWithFallback(context, failingCallable, fallbackCallable)
+
+        expect(fallbackCallable).toHaveBeenCalledWith(
+          expect.objectContaining({ currentLanguage: 'en', autotitleLanguage: 'es' }),
+        )
+        expect(context).not.toHaveProperty('autotitleLanguage')
+      })
     })
   })
 })

From 8c721fe6630c15b9a8346b20bad2baa2c29d08cf Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 21:31:37 +0000
Subject: [PATCH 23/71] Focus the first new search result after pagination
 loads (#64199)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 .../tests/playwright-rendering.spec.ts        | 39 +++++++++++++++++++
 .../components/results/SearchResults.tsx      | 24 +++++-------
 2 files changed, 49 insertions(+), 14 deletions(-)

diff --git a/src/fixtures/tests/playwright-rendering.spec.ts b/src/fixtures/tests/playwright-rendering.spec.ts
index a1c03b56c17a..0675ed1c8a85 100644
--- a/src/fixtures/tests/playwright-rendering.spec.ts
+++ b/src/fixtures/tests/playwright-rendering.spec.ts
@@ -1173,6 +1173,45 @@ test('search from enterprise-cloud and filter by top-level Fooing', async ({ pag
   await page.getByRole('link', { name: 'Clear' }).click()
 })
 
+test('search pagination focuses the first new result after the next page renders', async ({
+  page,
+}) => {
+  test.skip(!SEARCH_TESTS, 'No local Elasticsearch, no tests involving search')
+
+  // size=1 puts each fixture hit that matches foo on its own page.
+  await page.goto('/search?query=foo&size=1')
+  const firstResultLink = page.locator('.search-result-link').first()
+  // Primer Brand appends "..." to the last page's aria-label.
+  const pageTwo = page.getByLabel(/^Page 2(\.\.\.)?$/)
+  await expect(firstResultLink).toHaveText('Foo')
+
+  // Holding the data response proves focus waits for the new hits, not the old ones.
+  let releaseNavigation = () => {}
+  const navigationHeld = new Promise<void>((resolve) => {
+    releaseNavigation = resolve
+  })
+  await page.route('**/_next/data/**', async (route) => {
+    await navigationHeld
+    await route.continue()
+  })
+
+  await pageTwo.press('Enter')
+  await expect(page).not.toHaveURL(/page=2/)
+  releaseNavigation()
+  await expect(page).toHaveURL(/page=2/)
+  await expect(firstResultLink).not.toHaveText('Foo')
+  await expect(firstResultLink).toBeFocused()
+
+  // Pagination stays mounted across Back, so a repeat visit to page 2 must still move focus.
+  await page.goBack()
+  await expect(page).not.toHaveURL(/page=2/)
+  await expect(firstResultLink).toHaveText('Foo')
+  await pageTwo.press('Enter')
+  await expect(page).toHaveURL(/page=2/)
+  await expect(firstResultLink).not.toHaveText('Foo')
+  await expect(firstResultLink).toBeFocused()
+})
+
 test('404 page renders correctly', async ({ page }) => {
   const response = await page.goto('/this-definitely-does-not-exist')
   expect(response?.status()).toBe(404)
diff --git a/src/search/components/results/SearchResults.tsx b/src/search/components/results/SearchResults.tsx
index ec28a82cd566..a2e4543a3726 100644
--- a/src/search/components/results/SearchResults.tsx
+++ b/src/search/components/results/SearchResults.tsx
@@ -1,7 +1,7 @@
 import { Heading, Pagination, Text, Token } from '@primer/react-brand'
 import { SearchIcon } from '@primer/octicons-react'
 import { useRouter } from 'next/router'
-import React, { useEffect, useRef, useState } from 'react'
+import React, { useEffect, useRef } from 'react'
 import cx from 'clsx'
 
 import { useTranslation } from '@/languages/components/useTranslation'
@@ -161,18 +161,8 @@ function SearchResultHit({
 
 function ResultsPagination({ page, totalPages }: { page: number; totalPages: number }) {
   const router = useRouter()
-  const [asPath, setAsPath] = useState('')
   const [asPathRoot, asPathQuery = ''] = router.asPath.split('#')[0].split('?')
 
-  useEffect(() => {
-    if (asPath) {
-      const firstSearchResult = document.getElementsByClassName(
-        'search-result-link',
-      )[0] as HTMLElement
-      firstSearchResult?.focus()
-    }
-  }, [asPath])
-
   function hrefBuilder(pageNumber: number) {
     const params = new URLSearchParams(asPathQuery)
     if (pageNumber === 1) {
@@ -190,7 +180,7 @@ function ResultsPagination({ page, totalPages }: { page: number; totalPages: num
           pageCount={Math.min(totalPages, 10)}
           currentPage={page}
           hrefBuilder={hrefBuilder}
-          onPageChange={(event: React.MouseEvent, pageNum: number) => {
+          onPageChange={async (event: React.MouseEvent, pageNum: number) => {
             event.preventDefault()
 
             const [pathRoot, pathQuery = ''] = router.asPath.split('#')[0].split('?')
@@ -204,8 +194,14 @@ function ResultsPagination({ page, totalPages }: { page: number; totalPages: num
             if (params.toString()) {
               newPath += `?${params}`
             }
-            setAsPath(newPath)
-            router.push(newPath)
+            // router.push resolves after the new results render, so focus lands on a new hit
+            const navigated = await router.push(newPath)
+            if (navigated) {
+              const firstSearchResult = document.getElementsByClassName('search-result-link')[0] as
+                | HTMLElement
+                | undefined
+              firstSearchResult?.focus()
+            }
           }}
         />
       </div>

From 3560f69b6038eac81fcca6a8b6c33ef71449284e Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 21:31:43 +0000
Subject: [PATCH 24/71] Point the search page Article API body at
 /api/search/v1 (#64201)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 .../tests/search-page-transformer.test.ts     | 22 +++++++++++++++++++
 .../transformers/search-page-transformer.ts   |  2 +-
 2 files changed, 23 insertions(+), 1 deletion(-)
 create mode 100644 src/article-api/tests/search-page-transformer.test.ts

diff --git a/src/article-api/tests/search-page-transformer.test.ts b/src/article-api/tests/search-page-transformer.test.ts
new file mode 100644
index 000000000000..b13bd1d2b3a7
--- /dev/null
+++ b/src/article-api/tests/search-page-transformer.test.ts
@@ -0,0 +1,22 @@
+import { describe, expect, test, vi } from 'vitest'
+
+import { SearchPageTransformer } from '@/article-api/transformers/search-page-transformer'
+import type { Context, Page } from '@/types'
+
+const stubPage = {
+  relativePath: 'search/index.md',
+  renderTitle: vi.fn().mockResolvedValue('Search'),
+} as unknown as Page
+
+describe('SearchPageTransformer', () => {
+  test('points to the versioned Search API endpoint', async () => {
+    const transformer = new SearchPageTransformer()
+    const result = await transformer.transform(stubPage, '/en/search', {} as Context)
+
+    expect(result).toContain('# Search')
+    // The bare /api/search path redirects, and curl requests without client_name get a 400.
+    expect(result).toContain(
+      'curl "https://docs.github.com/api/search/v1?query=actions&client_name=docs-api-example&language=en&version=free-pro-team@latest"',
+    )
+  })
+})
diff --git a/src/article-api/transformers/search-page-transformer.ts b/src/article-api/transformers/search-page-transformer.ts
index d489a2ebcf78..d5b71f206303 100644
--- a/src/article-api/transformers/search-page-transformer.ts
+++ b/src/article-api/transformers/search-page-transformer.ts
@@ -16,7 +16,7 @@ export class SearchPageTransformer implements PageTransformer {
 Use the Search API to search programmatically:
 
 \`\`\`
-curl "https://docs.github.com/api/search?query=actions&language=en&version=free-pro-team@latest"
+curl "https://docs.github.com/api/search/v1?query=actions&client_name=docs-api-example&language=en&version=free-pro-team@latest"
 \`\`\`
 `
   }

From ff7aa4cd2bf352815752bf0cc641668be346f769 Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 21:31:49 +0000
Subject: [PATCH 25/71] Combine search popularity across redirected paths
 (#64202)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 .../scripts/scrape/lib/popular-pages.ts       | 31 ++++++++--
 .../scrape/lib/scrape-into-index-json.ts      | 12 +---
 .../pageviews/en/free-pro-team/rollup.json    | 12 ++++
 src/search/tests/popular-pages.ts             | 60 +++++++++++++++++++
 4 files changed, 99 insertions(+), 16 deletions(-)
 create mode 100644 src/search/tests/fixtures/popular-pages/hydro/rollups/pageviews/en/free-pro-team/rollup.json
 create mode 100644 src/search/tests/popular-pages.ts

diff --git a/src/search/scripts/scrape/lib/popular-pages.ts b/src/search/scripts/scrape/lib/popular-pages.ts
index 1c4ca2b40436..e5fae4a239c6 100644
--- a/src/search/scripts/scrape/lib/popular-pages.ts
+++ b/src/search/scripts/scrape/lib/popular-pages.ts
@@ -4,7 +4,27 @@ import fs from 'fs/promises'
 
 import { getPlanVersionFromIndexVersion } from '@/search/lib/elasticsearch-versions'
 
-import type { Redirects, PopularPages } from '@/search/scripts/scrape/types'
+import type { Page, Redirects, PopularPages } from '@/search/scripts/scrape/types'
+
+export function buildRedirects(pages: Pick<Page, 'relativePath' | 'redirect_from'>[]): Redirects {
+  // Match the popularity lookup key in build-records-from-api, so actions/index.md becomes actions.
+  const toKey = (page: Pick<Page, 'relativePath'>) =>
+    page.relativePath.replace('/index.md', '').replace('.md', '')
+  const pageKeys = new Set(pages.map(toKey))
+  const redirects: Redirects = {}
+  for (const page of pages) {
+    const href = toKey(page)
+    for (let redirectFrom of page.redirect_from || []) {
+      // redirect_from values start with / and often end with /.
+      if (redirectFrom.startsWith('/')) redirectFrom = redirectFrom.slice(1)
+      if (redirectFrom.endsWith('/')) redirectFrom = redirectFrom.slice(0, -1)
+      // Some live pages appear in another page's redirect_from for other versions, so keep their counts separate.
+      if (pageKeys.has(redirectFrom)) continue
+      redirects[redirectFrom] = href
+    }
+  }
+  return redirects
+}
 
 export default async function getPopularPages(
   dirPath: string,
@@ -39,17 +59,16 @@ export default async function getPopularPages(
       // We never index these anyway so their popularity is never relevant.
       continue
     }
-    all[path] = count as number
+    // Combine old and new paths because rollups can lag behind content changes.
+    const key = redirects[path] || path
+    all[key] = (all[key] || 0) + (count as number)
   }
 
   const biggestCount = Math.max(...Object.values(all))
   const popularPages: PopularPages = {}
   for (const [path, count] of Object.entries(all)) {
     // Seven decimal places keep records smaller without useful popularity precision loss.
-    const ratio = Number((count / biggestCount).toFixed(7))
-
-    // Apply redirects because rollups can lag behind content changes.
-    popularPages[redirects[path] || path] = ratio
+    popularPages[path] = Number((count / biggestCount).toFixed(7))
   }
 
   return popularPages
diff --git a/src/search/scripts/scrape/lib/scrape-into-index-json.ts b/src/search/scripts/scrape/lib/scrape-into-index-json.ts
index d9ad3f408034..f0c5cdeefad3 100644
--- a/src/search/scripts/scrape/lib/scrape-into-index-json.ts
+++ b/src/search/scripts/scrape/lib/scrape-into-index-json.ts
@@ -3,6 +3,7 @@ import chalk from 'chalk'
 import languages from '@/languages/lib/languages-server'
 import buildRecords from '@/search/scripts/scrape/lib/build-records-from-api'
 import findIndexablePages from '@/search/scripts/scrape/lib/find-indexable-pages'
+import { buildRedirects } from '@/search/scripts/scrape/lib/popular-pages'
 import { writeIndexRecords } from '@/search/scripts/scrape/lib/search-index-records'
 import { getElasticSearchIndex } from '@/search/lib/elasticsearch-indexes'
 
@@ -31,16 +32,7 @@ export default async function scrapeIntoIndexJson({
 
   // Excludes hidden pages, the absolute homepage, and visible WIP products.
   const indexablePages: Page[] = await findIndexablePages(config.filter)
-  const redirects: Redirects = {}
-  for (const page of indexablePages) {
-    const href = page.relativePath.replace('index.md', '').replace('.md', '')
-    for (let redirectFrom of page.redirect_from || []) {
-      // redirect_from values start with / and often end with /.
-      if (redirectFrom.startsWith('/')) redirectFrom = redirectFrom.slice(1)
-      if (redirectFrom.endsWith('/')) redirectFrom = redirectFrom.slice(0, -1)
-      redirects[redirectFrom] = href
-    }
-  }
+  const redirects: Redirects = buildRedirects(indexablePages)
 
   let countRecordsTotal = 0
   let totalFailedPages = 0
diff --git a/src/search/tests/fixtures/popular-pages/hydro/rollups/pageviews/en/free-pro-team/rollup.json b/src/search/tests/fixtures/popular-pages/hydro/rollups/pageviews/en/free-pro-team/rollup.json
new file mode 100644
index 000000000000..500e859c6647
--- /dev/null
+++ b/src/search/tests/fixtures/popular-pages/hydro/rollups/pageviews/en/free-pro-team/rollup.json
@@ -0,0 +1,12 @@
+{
+  "get-started": 10000,
+  "foo/old": 5000,
+  "old-actions": 3000,
+  "baz/legacy": 2000,
+  "actions": 1000,
+  "bar/old-1": 400,
+  "bar/old-2": 300,
+  "foo/new": 200,
+  "bar/page": 100,
+  "baz/new": 50
+}
diff --git a/src/search/tests/popular-pages.ts b/src/search/tests/popular-pages.ts
new file mode 100644
index 000000000000..4389215b4180
--- /dev/null
+++ b/src/search/tests/popular-pages.ts
@@ -0,0 +1,60 @@
+import path from 'path'
+import { fileURLToPath } from 'url'
+
+import { describe, expect, test } from 'vitest'
+
+import getPopularPages, { buildRedirects } from '@/search/scripts/scrape/lib/popular-pages'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const fixturesDir = path.join(__dirname, 'fixtures/popular-pages')
+
+const pages = [
+  { relativePath: 'foo/new.md', redirect_from: ['/foo/old'] },
+  { relativePath: 'actions/index.md', redirect_from: ['/old-actions/'] },
+  { relativePath: 'bar/page.md', redirect_from: ['/bar/old-1', '/bar/old-2/'] },
+  { relativePath: 'baz/legacy.md' },
+  { relativePath: 'baz/new.md', redirect_from: ['/baz/legacy'] },
+]
+
+describe('buildRedirects', () => {
+  test('maps redirect_from paths to the same key build-records uses for popularity', () => {
+    expect(buildRedirects(pages)).toEqual({
+      'foo/old': 'foo/new',
+      'old-actions': 'actions',
+      'bar/old-1': 'bar/page',
+      'bar/old-2': 'bar/page',
+    })
+  })
+
+  test('skips redirect_from paths that are still live pages', () => {
+    expect(buildRedirects(pages)['baz/legacy']).toBeUndefined()
+  })
+})
+
+describe('getPopularPages', () => {
+  test('combines counts from old and new paths of a moved page', async () => {
+    const popularPages = await getPopularPages(fixturesDir, buildRedirects(pages), 'fpt', 'en')
+    expect(popularPages['get-started']).toBe(1)
+    expect(popularPages['foo/new']).toBe(0.52)
+    expect(popularPages['foo/old']).toBeUndefined()
+  })
+
+  test('combines counts from every redirect_from path of one page', async () => {
+    const popularPages = await getPopularPages(fixturesDir, buildRedirects(pages), 'fpt', 'en')
+    expect(popularPages['bar/page']).toBe(0.08)
+    expect(popularPages['bar/old-1']).toBeUndefined()
+    expect(popularPages['bar/old-2']).toBeUndefined()
+  })
+
+  test('applies redirects of index pages to the key without a trailing slash', async () => {
+    const popularPages = await getPopularPages(fixturesDir, buildRedirects(pages), 'fpt', 'en')
+    expect(popularPages.actions).toBe(0.4)
+    expect(popularPages['actions/']).toBeUndefined()
+  })
+
+  test('keeps counts separate when a redirect_from path is still a live page', async () => {
+    const popularPages = await getPopularPages(fixturesDir, buildRedirects(pages), 'fpt', 'en')
+    expect(popularPages['baz/legacy']).toBe(0.2)
+    expect(popularPages['baz/new']).toBe(0.005)
+  })
+})

From 4ed87ae8f8cbbe8148fd3e0a0893266afb89a352 Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 21:56:01 +0000
Subject: [PATCH 26/71] Validate the Copilot model retirement table against its
 schema (#64154)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Co-authored-by: Hector A. <v-halfaro@github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 src/data-directory/lib/data-schemas/index.ts  |  3 ++
 .../copilot/model-deprecation-history.ts      | 41 ++++++++-----------
 2 files changed, 20 insertions(+), 24 deletions(-)

diff --git a/src/data-directory/lib/data-schemas/index.ts b/src/data-directory/lib/data-schemas/index.ts
index 871ce19bab99..dada87a43468 100644
--- a/src/data-directory/lib/data-schemas/index.ts
+++ b/src/data-directory/lib/data-schemas/index.ts
@@ -61,6 +61,9 @@ const manualSchemas: DataSchemas = {
   'data/tables/copilot/auto-model-selection.yml': resolveSchemaPath(
     'tables/copilot/auto-model-selection.ts',
   ),
+  'data/tables/copilot/model-deprecation-history.yml': resolveSchemaPath(
+    'tables/copilot/model-deprecation-history.ts',
+  ),
 }
 
 const dataSchemas: DataSchemas = {
diff --git a/src/data-directory/lib/data-schemas/tables/copilot/model-deprecation-history.ts b/src/data-directory/lib/data-schemas/tables/copilot/model-deprecation-history.ts
index 84fc98abac18..894fc74b2349 100644
--- a/src/data-directory/lib/data-schemas/tables/copilot/model-deprecation-history.ts
+++ b/src/data-directory/lib/data-schemas/tables/copilot/model-deprecation-history.ts
@@ -1,28 +1,21 @@
 const modelDeprecationHistorySchema = {
-  type: 'object',
-  additionalProperties: false,
-  required: ['models'],
-  properties: {
-    models: {
-      type: 'object',
-      items: {
-        type: 'object',
-        additionalProperties: false,
-        required: ['name', 'retirement_date', 'suggested_alternative'],
-        properties: {
-          name: {
-            type: 'string',
-            lintable: true,
-          },
-          retirement_date: {
-            type: 'string',
-            format: 'date',
-          },
-          suggested_alternative: {
-            type: 'string',
-            lintable: true,
-          },
-        },
+  type: 'array',
+  items: {
+    type: 'object',
+    additionalProperties: false,
+    required: ['name', 'retirement_date', 'suggested_alternative'],
+    properties: {
+      name: {
+        type: 'string',
+        lintable: true,
+      },
+      retirement_date: {
+        type: 'string',
+        format: 'date',
+      },
+      suggested_alternative: {
+        type: 'string',
+        lintable: true,
       },
     },
   },

From 0bb86a6e48c62f7a28678520ecf4eeba70496197 Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 21:56:07 +0000
Subject: [PATCH 27/71] Keep URL language and add Vary on legacy search query
 redirects (#64203)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 src/redirects/middleware/handle-redirects.ts  | 11 ++-
 src/redirects/tests/redirects.ts              |  6 +-
 .../tests/unit/handle-redirects-search.ts     | 81 +++++++++++++++++++
 3 files changed, 95 insertions(+), 3 deletions(-)
 create mode 100644 src/redirects/tests/unit/handle-redirects-search.ts

diff --git a/src/redirects/middleware/handle-redirects.ts b/src/redirects/middleware/handle-redirects.ts
index d680b274e8a6..9cbef19ad591 100644
--- a/src/redirects/middleware/handle-redirects.ts
+++ b/src/redirects/middleware/handle-redirects.ts
@@ -62,7 +62,9 @@ export default function handleRedirects(req: ExtendedRequest, res: Response, nex
   const hasQ = 'q' in req.query
   const hasQuery = 'query' in req.query
   if ((hasQ && !hasQuery) || (hasQuery && !onSearch)) {
-    const language = getLanguage(req)
+    // A browser-cached 301 cannot vary on the user_language cookie, so preference redirects use 302.
+    const languagePrefixed = pathLanguagePrefixed(req.path)
+    const language = languagePrefixed && req.language ? req.language : getLanguage(req)
     const sp = new URLSearchParams(req.query as URLSearchParamsTypes)
     if (sp.has('q') && !sp.has('query')) {
       sp.set('query', sp.get('q')!)
@@ -78,7 +80,12 @@ export default function handleRedirects(req: ExtendedRequest, res: Response, nex
     }
 
     redirectTo += `/search?${sp.toString()}`
-    return res.safeRedirect(301, redirectTo)
+    if (languagePrefixed) {
+      defaultCacheControl(res)
+      return res.safeRedirect(301, redirectTo)
+    }
+    languageCacheControl(res)
+    return res.safeRedirect(302, redirectTo)
   }
 
   if (queryParams) {
diff --git a/src/redirects/tests/redirects.ts b/src/redirects/tests/redirects.ts
index ab6dbf0b3bf7..c459044dc01a 100644
--- a/src/redirects/tests/redirects.ts
+++ b/src/redirects/tests/redirects.ts
@@ -47,9 +47,12 @@ describe('redirects', () => {
   describe('query params', () => {
     test('are preserved in redirected URLs', async () => {
       const res = await get('/enterprise/admin?query=pulls')
-      expect(res.statusCode).toBe(301)
+      // Without a language prefix, the target depends on language preference.
+      expect(res.statusCode).toBe(302)
       const expected = `/en/enterprise-server@${enterpriseServerReleases.latest}/search?query=pulls`
       expect(res.headers.location).toBe(expected)
+      expect(res.headers.vary).toContain('accept-language')
+      expect(res.headers.vary).toContain('x-user-language')
     })
 
     test('have q= converted to query=', async () => {
@@ -70,6 +73,7 @@ describe('redirects', () => {
       expect(res.statusCode).toBe(301)
       const expected = '/en/search?query=pulls'
       expect(res.headers.location).toBe(expected)
+      expect(res.headers['cache-control']).toContain('public')
     })
 
     test('have faq= not converted to query=', async () => {
diff --git a/src/redirects/tests/unit/handle-redirects-search.ts b/src/redirects/tests/unit/handle-redirects-search.ts
new file mode 100644
index 000000000000..a0b9f9f6ab6f
--- /dev/null
+++ b/src/redirects/tests/unit/handle-redirects-search.ts
@@ -0,0 +1,81 @@
+import { describe, expect, test } from 'vitest'
+import type { NextFunction, Response } from 'express'
+
+import handleRedirects from '@/redirects/middleware/handle-redirects'
+import { getLanguageCodeFromPath } from '@/languages/middleware/detect-language'
+import type { Context, ExtendedRequest } from '@/types'
+
+function run(url: string, userLanguage?: string) {
+  const parsed = new URL(url, 'https://docs.github.com')
+  const language = getLanguageCodeFromPath(parsed.pathname)
+  const req = {
+    path: parsed.pathname,
+    url,
+    originalUrl: url,
+    query: Object.fromEntries(parsed.searchParams),
+    language,
+    context: {
+      currentLanguage: language,
+      userLanguage,
+      currentVersion: 'free-pro-team@latest',
+      pages: {},
+      redirects: {},
+    } as unknown as Context,
+  } as unknown as ExtendedRequest
+
+  const headers: Record<string, string> = {}
+  const result: { statusCode?: number; location?: string } = {}
+  const res = {
+    set(key: string, value: string) {
+      headers[key.toLowerCase()] = value
+      return res
+    },
+    append(key: string, value: string) {
+      const name = key.toLowerCase()
+      headers[name] = headers[name] ? `${headers[name]}, ${value}` : value
+      return res
+    },
+    hasHeader(key: string) {
+      return key.toLowerCase() in headers
+    },
+    safeRedirect(status: number, location: string) {
+      result.statusCode = status
+      result.location = location
+    },
+  } as unknown as Response
+
+  const next: NextFunction = () => {}
+  handleRedirects(req, res, next)
+  return { ...result, headers }
+}
+
+describe('handleRedirects search query redirects', () => {
+  test('keeps the path language for q= on the search page', () => {
+    const result = run('/en/search?q=pulls', 'ja')
+    expect(result.statusCode).toBe(301)
+    expect(result.location).toBe('/en/search?query=pulls')
+    expect(result.headers['cache-control']).toMatch(/public/)
+    expect(result.headers.vary || '').not.toMatch(/accept-language/)
+  })
+
+  test('keeps the path language for query= on a non-search page', () => {
+    const result = run('/en/actions?query=foo', 'ja')
+    expect(result.statusCode).toBe(301)
+    expect(result.location).toBe('/en/search?query=foo')
+  })
+
+  test('uses the preferred language with a temporary redirect when the path has no language', () => {
+    const result = run('/search?q=pulls', 'ja')
+    expect(result.statusCode).toBe(302)
+    expect(result.location).toBe('/ja/search?query=pulls')
+    expect(result.headers['cache-control']).toMatch(/public/)
+    expect(result.headers.vary).toMatch(/accept-language/)
+    expect(result.headers.vary).toMatch(/x-user-language/)
+  })
+
+  test('defaults to English when the path has no language and no preference is set', () => {
+    const result = run('/actions?query=foo')
+    expect(result.statusCode).toBe(302)
+    expect(result.location).toBe('/en/search?query=foo')
+  })
+})

From 7552e264102ef2be36aebed61a0da31bec15dd3b Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 21:56:14 +0000
Subject: [PATCH 28/71] Show a filter checkbox for every product on the search
 page (#64204)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 src/search/lib/get-elasticsearch-results/general-search.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/search/lib/get-elasticsearch-results/general-search.ts b/src/search/lib/get-elasticsearch-results/general-search.ts
index 220714a0bd52..1a74abfaab78 100644
--- a/src/search/lib/get-elasticsearch-results/general-search.ts
+++ b/src/search/lib/get-elasticsearch-results/general-search.ts
@@ -9,7 +9,8 @@ import type {
 } from '@/search/lib/search-request-params/types'
 import type { SearchAggregation, GeneralSearchHit, GeneralSearchResponse } from '@/search/types'
 
-const MAX_AGGREGATE_SIZE = 30
+// Must exceed the number of products in any version, or Elasticsearch drops the smallest buckets
+const MAX_AGGREGATE_SIZE = 100
 
 const isDevMode: boolean = process.env.NODE_ENV !== 'production'
 

From 84d1d0f67f629640cdb648c978a84edea29b9552 Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 21:56:20 +0000
Subject: [PATCH 29/71] Reject inherited object keys in search version and
 language params (#64205)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 src/search/lib/elasticsearch-indexes.ts       |  2 +-
 .../search-params-objects.ts                  |  6 +--
 src/search/tests/search-request-params.ts     | 49 +++++++++++++++++++
 3 files changed, 53 insertions(+), 4 deletions(-)
 create mode 100644 src/search/tests/search-request-params.ts

diff --git a/src/search/lib/elasticsearch-indexes.ts b/src/search/lib/elasticsearch-indexes.ts
index e75ad30a0b36..553fcbba14bf 100644
--- a/src/search/lib/elasticsearch-indexes.ts
+++ b/src/search/lib/elasticsearch-indexes.ts
@@ -46,7 +46,7 @@ export function getElasticSearchIndex(
   }
   const index = indexes[type] as SearchIndex
 
-  if (!(language in languages)) {
+  if (!Object.hasOwn(languages, language)) {
     throw new Error(
       `Language ${language} not found in languages for getElasticSearchIndex function.`,
     )
diff --git a/src/search/lib/search-request-params/search-params-objects.ts b/src/search/lib/search-request-params/search-params-objects.ts
index 56e53bbb5e77..99aa1d51f7bc 100644
--- a/src/search/lib/search-request-params/search-params-objects.ts
+++ b/src/search/lib/search-request-params/search-params-objects.ts
@@ -37,7 +37,7 @@ const SHARED_PARAMS_OBJ: SearchRequestQueryParams[] = [
     key: 'version',
     default_: 'free-pro-team',
     validate: (version) => {
-      if (!versionToIndexVersionMap[version as string]) {
+      if (!Object.hasOwn(versionToIndexVersionMap, version as string)) {
         throw new ValidationError(`'${version}' not in ${allIndexVersionKeys.join(', ')}`)
       }
       return true
@@ -48,7 +48,7 @@ const SHARED_PARAMS_OBJ: SearchRequestQueryParams[] = [
 const GENERAL_SEARCH_PARAMS_OBJ: SearchRequestQueryParams[] = [
   ...SHARED_PARAMS_OBJ,
   { key: 'query' },
-  { key: 'language', default_: 'en', validate: (v) => (v as string) in languages },
+  { key: 'language', default_: 'en', validate: (v) => Object.hasOwn(languages, v as string) },
   {
     key: 'size',
     default_: DEFAULT_SIZE,
@@ -126,7 +126,7 @@ const SHARED_AUTOCOMPLETE_PARAMS_OBJ: SearchRequestQueryParams[] = [
     key: 'version',
     default_: 'free-pro-team',
     validate: (version) => {
-      if (!versionToIndexVersionMap[version as string]) {
+      if (!Object.hasOwn(versionToIndexVersionMap, version as string)) {
         throw new ValidationError(`'${version}' not in ${allIndexVersionKeys.join(', ')}`)
       }
       return true
diff --git a/src/search/tests/search-request-params.ts b/src/search/tests/search-request-params.ts
new file mode 100644
index 000000000000..0378b8c77488
--- /dev/null
+++ b/src/search/tests/search-request-params.ts
@@ -0,0 +1,49 @@
+import { describe, expect, test } from 'vitest'
+import type { Request } from 'express'
+
+import { getSearchFromRequestParams } from '@/search/lib/search-request-params/get-search-from-request-params'
+
+function fakeRequest(query: Record<string, string>): Request {
+  return { query } as unknown as Request
+}
+
+// Inherited Object.prototype names must fail validation instead of reaching
+// getElasticSearchIndex, which throws a non-validation error.
+const PROTOTYPE_KEYS = ['constructor', 'toString', '__proto__', 'hasOwnProperty', 'valueOf']
+
+describe('getSearchFromRequestParams', () => {
+  test('accepts a valid version', () => {
+    const { indexName, validationErrors } = getSearchFromRequestParams(
+      fakeRequest({ query: 'git', version: 'free-pro-team' }),
+      'generalSearch',
+    )
+    expect(validationErrors).toEqual([])
+    expect(indexName).toContain('_fpt_en')
+  })
+
+  for (const type of ['generalSearch', 'aiSearchAutocomplete'] as const) {
+    for (const version of PROTOTYPE_KEYS) {
+      test(`rejects version '${version}' for ${type}`, () => {
+        const { indexName, validationErrors } = getSearchFromRequestParams(
+          fakeRequest({ query: 'git', version }),
+          type,
+        )
+        expect(validationErrors.length).toBe(1)
+        expect(validationErrors[0].field).toBe('version')
+        expect(indexName).toBe('')
+      })
+    }
+  }
+
+  for (const language of PROTOTYPE_KEYS) {
+    test(`rejects language '${language}' for generalSearch`, () => {
+      const { indexName, validationErrors } = getSearchFromRequestParams(
+        fakeRequest({ query: 'git', language }),
+        'generalSearch',
+      )
+      expect(validationErrors.length).toBe(1)
+      expect(validationErrors[0].key).toBe('language')
+      expect(indexName).toBe('')
+    })
+  }
+})

From 0963560dbd88b350e4359a09836b24bc7da460fa Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 21:56:26 +0000
Subject: [PATCH 30/71] Retry 429 secondary rate limits and honor retry-after
 (#64206)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 src/workflows/secondary-ratelimit-retry.ts    | 29 +++++-
 .../tests/secondary-ratelimit-retry.ts        | 91 +++++++++++++++++++
 2 files changed, 115 insertions(+), 5 deletions(-)
 create mode 100644 src/workflows/tests/secondary-ratelimit-retry.ts

diff --git a/src/workflows/secondary-ratelimit-retry.ts b/src/workflows/secondary-ratelimit-retry.ts
index 4c7cd8cf0329..2117afb5fe32 100644
--- a/src/workflows/secondary-ratelimit-retry.ts
+++ b/src/workflows/secondary-ratelimit-retry.ts
@@ -2,8 +2,12 @@ import { isRequestError } from '@/workflows/github'
 
 const DEFAULT_SLEEPTIME = parseInt(process.env.SECONDARY_RATELIMIT_RETRY_SLEEPTIME || '30000', 10)
 const DEFAULT_ATTEMPTS = parseInt(process.env.SECONDARY_RATELIMIT_RETRY_ATTEMPTS || '5', 10)
+// Keeps a single wait well inside the 5 minute step timeout in notify-about-deployment.
+// Retrying before retry-after elapses risks more throttling, so longer waits give up instead.
+const MAX_RETRY_AFTER_MS = 120_000
 
-// Secondary rate limits return 403 with "You have exceeded a secondary rate limit."
+// Secondary rate limits return 403 or 429 with "You have exceeded a secondary rate limit."
+// When a retry-after header is present, GitHub asks clients to wait that many seconds.
 // https://docs.github.com/en/rest/using-the-rest-api/rate-limits-for-the-rest-api?apiVersion=2022-11-28#about-secondary-rate-limits
 export async function octoSecondaryRatelimitRetry<T>(
   fn: () => Promise<T>,
@@ -15,14 +19,20 @@ export async function octoSecondaryRatelimitRetry<T>(
       return await fn()
     } catch (error) {
       if (
-        isRequestError(error, 403) &&
+        (isRequestError(error, 403) || isRequestError(error, 429)) &&
         /You have exceeded a secondary rate limit/.test(error.message)
       ) {
-        if (tries < attempts) {
+        const retryAfterMs = getRetryAfterMs(error)
+        if (retryAfterMs !== null && retryAfterMs > MAX_RETRY_AFTER_MS) {
           console.warn(
-            `Sleeping for ${(sleepTime / 1000).toFixed(1)}s before retrying after ${tries + 1} try`,
+            `Not retrying because retry-after of ${(retryAfterMs / 1000).toFixed(1)}s exceeds the wait limit`,
           )
-          await sleep(sleepTime)
+        } else if (tries < attempts) {
+          const waitTime = retryAfterMs ?? sleepTime
+          console.warn(
+            `Sleeping for ${(waitTime / 1000).toFixed(1)}s before retrying after ${tries + 1} try`,
+          )
+          await sleep(waitTime)
           tries++
           continue
         } else {
@@ -34,6 +44,15 @@ export async function octoSecondaryRatelimitRetry<T>(
   }
 }
 
+function getRetryAfterMs(error: object): number | null {
+  const headers = (error as { response?: { headers?: Record<string, unknown> } }).response?.headers
+  const value = headers?.['retry-after']
+  if (typeof value !== 'string' && typeof value !== 'number') return null
+  const seconds = Number(value)
+  if (String(value).trim() === '' || !Number.isFinite(seconds) || seconds < 0) return null
+  return seconds * 1000
+}
+
 async function sleep(ms: number) {
   return new Promise((resolve) => {
     setTimeout(resolve, ms)
diff --git a/src/workflows/tests/secondary-ratelimit-retry.ts b/src/workflows/tests/secondary-ratelimit-retry.ts
new file mode 100644
index 000000000000..403601acd209
--- /dev/null
+++ b/src/workflows/tests/secondary-ratelimit-retry.ts
@@ -0,0 +1,91 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
+import { RequestError } from '@octokit/request-error'
+
+import { octoSecondaryRatelimitRetry } from '@/workflows/secondary-ratelimit-retry'
+
+const SECONDARY_MESSAGE = 'You have exceeded a secondary rate limit. Please wait a few minutes.'
+
+function makeError(status: number, message: string, headers: Record<string, string> = {}) {
+  return new RequestError(message, status, {
+    request: { method: 'POST', url: 'https://api.github.com/x', headers: {} },
+    response: { status, url: 'https://api.github.com/x', headers, data: { message } },
+  })
+}
+
+function failOnceThen<T>(error: Error, value: T) {
+  return vi.fn().mockRejectedValueOnce(error).mockResolvedValue(value)
+}
+
+describe('octoSecondaryRatelimitRetry', () => {
+  beforeEach(() => {
+    vi.spyOn(console, 'warn').mockImplementation(() => {})
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+    vi.restoreAllMocks()
+  })
+
+  test.each([403, 429])('retries a %i secondary rate limit and resolves', async (status) => {
+    const fn = failOnceThen(makeError(status, SECONDARY_MESSAGE), 'ok')
+    await expect(octoSecondaryRatelimitRetry(fn, { attempts: 2, sleepTime: 0 })).resolves.toBe('ok')
+    expect(fn).toHaveBeenCalledTimes(2)
+  })
+
+  test('does not retry a 429 without the secondary rate limit message', async () => {
+    const error = makeError(429, 'Too Many Requests')
+    const fn = vi.fn().mockRejectedValue(error)
+    await expect(octoSecondaryRatelimitRetry(fn, { attempts: 2, sleepTime: 0 })).rejects.toBe(error)
+    expect(fn).toHaveBeenCalledTimes(1)
+  })
+
+  test('gives up after the configured number of attempts', async () => {
+    const error = makeError(429, SECONDARY_MESSAGE)
+    const fn = vi.fn().mockRejectedValue(error)
+    await expect(octoSecondaryRatelimitRetry(fn, { attempts: 2, sleepTime: 0 })).rejects.toBe(error)
+    expect(fn).toHaveBeenCalledTimes(3)
+  })
+
+  test('waits for the retry-after header instead of sleepTime', async () => {
+    vi.useFakeTimers()
+    const fn = failOnceThen(makeError(429, SECONDARY_MESSAGE, { 'retry-after': '5' }), 'ok')
+    const promise = octoSecondaryRatelimitRetry(fn, { attempts: 2, sleepTime: 60_000 })
+
+    await vi.advanceTimersByTimeAsync(4_999)
+    expect(fn).toHaveBeenCalledTimes(1)
+    await vi.advanceTimersByTimeAsync(1)
+    expect(fn).toHaveBeenCalledTimes(2)
+    await expect(promise).resolves.toBe('ok')
+  })
+
+  test('gives up without retrying when retry-after exceeds 120 seconds', async () => {
+    const error = makeError(403, SECONDARY_MESSAGE, { 'retry-after': '3600' })
+    const fn = vi.fn().mockRejectedValue(error)
+    await expect(octoSecondaryRatelimitRetry(fn, { attempts: 2, sleepTime: 0 })).rejects.toBe(error)
+    expect(fn).toHaveBeenCalledTimes(1)
+  })
+
+  test('waits the full retry-after at the 120 second limit', async () => {
+    vi.useFakeTimers()
+    const fn = failOnceThen(makeError(429, SECONDARY_MESSAGE, { 'retry-after': '120' }), 'ok')
+    const promise = octoSecondaryRatelimitRetry(fn, { attempts: 2, sleepTime: 0 })
+
+    await vi.advanceTimersByTimeAsync(119_999)
+    expect(fn).toHaveBeenCalledTimes(1)
+    await vi.advanceTimersByTimeAsync(1)
+    expect(fn).toHaveBeenCalledTimes(2)
+    await expect(promise).resolves.toBe('ok')
+  })
+
+  test('falls back to sleepTime when retry-after is not a number', async () => {
+    vi.useFakeTimers()
+    const fn = failOnceThen(makeError(429, SECONDARY_MESSAGE, { 'retry-after': 'soon' }), 'ok')
+    const promise = octoSecondaryRatelimitRetry(fn, { attempts: 2, sleepTime: 1_000 })
+
+    await vi.advanceTimersByTimeAsync(999)
+    expect(fn).toHaveBeenCalledTimes(1)
+    await vi.advanceTimersByTimeAsync(1)
+    expect(fn).toHaveBeenCalledTimes(2)
+    await expect(promise).resolves.toBe('ok')
+  })
+})

From ec5807614527a3ab82175d2e375b7ba47fdcb250 Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 21:56:32 +0000
Subject: [PATCH 31/71] Keep secret scanning table page in range and off the
 URL hash (#64207)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 .../tests/playwright-secret-scanning.spec.ts  | 28 +++++++++++++++++++
 .../components/SecretScanningTable.tsx        | 10 +++++--
 2 files changed, 35 insertions(+), 3 deletions(-)

diff --git a/src/fixtures/tests/playwright-secret-scanning.spec.ts b/src/fixtures/tests/playwright-secret-scanning.spec.ts
index cf8d459ba466..541189fd0ca9 100644
--- a/src/fixtures/tests/playwright-secret-scanning.spec.ts
+++ b/src/fixtures/tests/playwright-secret-scanning.spec.ts
@@ -141,6 +141,34 @@ test.describe('Secret scanning DataTable accessibility', () => {
     expect(count).toBeGreaterThan(0)
   })
 
+  test('pagination stays in range after switching to a version with fewer patterns', async ({
+    page,
+  }) => {
+    await page.goto(PAGE_PATH)
+
+    const status = page.getByText(/^Showing \d+ of \d+ patterns$/)
+    const fptStatus = await status.textContent()
+    const pagination = page.getByRole('navigation', {
+      name: 'Secret scanning patterns pagination',
+    })
+    const lastPage = pagination.locator('[aria-label^="Page "]').last()
+    await lastPage.click()
+    await expect(lastPage).toHaveAttribute('aria-current', 'page')
+    expect(new URL(page.url()).hash).toBe('')
+
+    // The oldest supported Enterprise Server release has fewer patterns than Free, Pro, & Team.
+    await page.getByTestId('desktop-header').getByTestId('version-picker-button').click()
+    await page
+      .getByRole('menuitemradio', { name: /^Enterprise Server / })
+      .last()
+      .click()
+    await expect(page).toHaveURL(/\/enterprise-server@[\d.]+\//)
+    await expect(status).not.toHaveText(fptStatus!)
+
+    await expect(page.locator('[role="rowheader"]').first()).toBeVisible()
+    await expect(pagination.locator('[aria-current="page"]')).toHaveCount(1)
+  })
+
   test.describe('narrow viewport', () => {
     test.use({ viewport: { width: 320, height: 256 } })
 
diff --git a/src/secret-scanning/components/SecretScanningTable.tsx b/src/secret-scanning/components/SecretScanningTable.tsx
index cffffa5fbf54..e8404c3368b6 100644
--- a/src/secret-scanning/components/SecretScanningTable.tsx
+++ b/src/secret-scanning/components/SecretScanningTable.tsx
@@ -157,7 +157,9 @@ export function SecretScanningTable({ data }: { data: SecretScanningData[] }) {
 
   // The Pagination component is 1-indexed.
   const pageCount = Math.ceil(sorted.length / PAGE_SIZE)
-  const pageData = sorted.slice((currentPage - 1) * PAGE_SIZE, currentPage * PAGE_SIZE)
+  // Clamp because a client-side version switch keeps currentPage while data shrinks.
+  const visiblePage = Math.min(currentPage, Math.max(pageCount, 1))
+  const pageData = sorted.slice((visiblePage - 1) * PAGE_SIZE, visiblePage * PAGE_SIZE)
 
   return (
     <div>
@@ -357,8 +359,10 @@ export function SecretScanningTable({ data }: { data: SecretScanningData[] }) {
         <Pagination
           aria-label={t('pagination_label')}
           pageCount={pageCount}
-          currentPage={currentPage}
-          onPageChange={(_e: React.MouseEvent, page: number) => {
+          currentPage={visiblePage}
+          onPageChange={(e: React.MouseEvent, page: number) => {
+            // Brand renders page links with a #N href, so block the hash change and history entry.
+            e.preventDefault()
             setCurrentPage(page)
             trackInteraction('paginate', 'page', String(page))
           }}

From 4686831a496f42d949d79c8be0cbbab5927b76bc Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 21:56:38 +0000
Subject: [PATCH 32/71] Stop expanding unrelated sidebar categories that share
 a URL prefix (#64209)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 src/landings/components/SidebarProduct.tsx    |  5 +-
 .../components/sidebar-active-chain.ts        |  6 +++
 src/landings/tests/sidebar-active-chain.ts    | 52 +++++++++++++++++++
 3 files changed, 61 insertions(+), 2 deletions(-)
 create mode 100644 src/landings/components/sidebar-active-chain.ts
 create mode 100644 src/landings/tests/sidebar-active-chain.ts

diff --git a/src/landings/components/SidebarProduct.tsx b/src/landings/components/SidebarProduct.tsx
index c97d05be3cae..2b866e87ad6d 100644
--- a/src/landings/components/SidebarProduct.tsx
+++ b/src/landings/components/SidebarProduct.tsx
@@ -20,6 +20,7 @@ import { usePrefetchOnInteraction } from '@/frame/components/lib/prefetch'
 import { useIsHydrating } from '@/frame/components/hooks/useIsHydrating'
 import { SidebarExpandStateProvider, useSidebarExpandState } from './useSidebarExpandState'
 import { flattenDescendants, MAX_NAVLIST_LEVEL } from './sidebar-navlist-depth'
+import { isOnActiveChain } from '@/landings/components/sidebar-active-chain'
 
 import styles from './SidebarProduct.module.scss'
 
@@ -334,7 +335,7 @@ const NavListItem = memo(function NavListItem({
     <ExpandableItem
       title={childPage.title}
       nodeKey={childPage.href}
-      onActiveChain={routePath.includes(childPage.href)}
+      onActiveChain={isOnActiveChain(routePath, childPage.href)}
       subNavLabel={`${childPage.title} submenu`}
     >
       {childPage.sidebarLink && (
@@ -427,7 +428,7 @@ function RestNavListItem({ category }: { category: ProductTreeNode }) {
     <ExpandableItem
       title={category.title}
       nodeKey={category.href}
-      onActiveChain={routePath.includes(category.href)}
+      onActiveChain={isOnActiveChain(routePath, category.href)}
       subNavLabel={`${category.title} submenu`}
     >
       {category.childPages.map((childPage) => {
diff --git a/src/landings/components/sidebar-active-chain.ts b/src/landings/components/sidebar-active-chain.ts
new file mode 100644
index 000000000000..0e93fff5eba7
--- /dev/null
+++ b/src/landings/components/sidebar-active-chain.ts
@@ -0,0 +1,6 @@
+// Kept free of React and Next imports so unit tests can load it in isolation.
+
+// Match whole path segments so a category like /rest/git stays closed on /rest/gitignore.
+export function isOnActiveChain(routePath: string, href: string): boolean {
+  return routePath === href || routePath.startsWith(`${href}/`)
+}
diff --git a/src/landings/tests/sidebar-active-chain.ts b/src/landings/tests/sidebar-active-chain.ts
new file mode 100644
index 000000000000..f74dcbfa1c07
--- /dev/null
+++ b/src/landings/tests/sidebar-active-chain.ts
@@ -0,0 +1,52 @@
+import { describe, expect, test } from 'vitest'
+
+import { isOnActiveChain } from '@/landings/components/sidebar-active-chain'
+
+// Sidebar categories auto-expand when they are on the current page's ancestor chain.
+// A category whose href is a plain string prefix of a sibling's path must stay closed.
+
+describe('isOnActiveChain', () => {
+  test('matches the current page itself', () => {
+    expect(isOnActiveChain('/en/get-started/using-github', '/en/get-started/using-github')).toBe(
+      true,
+    )
+  })
+
+  test('matches real ancestors', () => {
+    expect(
+      isOnActiveChain('/en/get-started/using-github/hello-world', '/en/get-started/using-github'),
+    ).toBe(true)
+    expect(isOnActiveChain('/en/get-started/using-github/hello-world', '/en/get-started')).toBe(
+      true,
+    )
+    expect(
+      isOnActiveChain(
+        '/en/enterprise-cloud@latest/rest/git/blobs',
+        '/en/enterprise-cloud@latest/rest/git',
+      ),
+    ).toBe(true)
+  })
+
+  test('does not match siblings that share a string prefix', () => {
+    expect(
+      isOnActiveChain('/en/get-started/using-github/hello-world', '/en/get-started/using-git'),
+    ).toBe(false)
+    expect(
+      isOnActiveChain('/en/get-started/using-github-docs/about', '/en/get-started/using-github'),
+    ).toBe(false)
+    expect(isOnActiveChain('/en/rest/gitignore/gitignore', '/en/rest/git')).toBe(false)
+    expect(isOnActiveChain('/en/rest/copilot-spaces/copilot-spaces', '/en/rest/copilot')).toBe(
+      false,
+    )
+    expect(
+      isOnActiveChain(
+        '/en/copilot/how-tos/copilot-cli/use-copilot-cli-in-actions',
+        '/en/copilot/how-tos/copilot-cli/use-copilot-cli',
+      ),
+    ).toBe(false)
+  })
+
+  test('does not match descendants of the current page', () => {
+    expect(isOnActiveChain('/en/rest/git', '/en/rest/git/blobs')).toBe(false)
+  })
+})

From b161010502b4ac4b23363f19e9f92e554303023b Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 21:56:44 +0000
Subject: [PATCH 33/71] Print startup errors instead of exiting silently under
 nodemon (#64210)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 .../lib/handle-package-not-found.ts           |  7 ++-
 .../tests/handle-package-not-found.ts         | 58 +++++++++++++++++++
 2 files changed, 64 insertions(+), 1 deletion(-)
 create mode 100644 src/observability/tests/handle-package-not-found.ts

diff --git a/src/observability/lib/handle-package-not-found.ts b/src/observability/lib/handle-package-not-found.ts
index 80c6c122d19b..7d789aac69bf 100644
--- a/src/observability/lib/handle-package-not-found.ts
+++ b/src/observability/lib/handle-package-not-found.ts
@@ -2,7 +2,8 @@
 // Recommend npm ci instead of npm install to avoid unexpected package-lock.json changes.
 // package.json loads this file through nodemonConfig before start-server.ts loads handle-exceptions.ts.
 // Keep it dependency-free so missing packages can reach this handler.
-// Other uncaught exceptions fall through to handle-exceptions.ts.
+// Until handle-exceptions.ts registers its listener, other uncaught exceptions print and exit 1.
+// Once it registers, they fall through to handle-exceptions.ts.
 
 type ErrorWithCode = {
   code: string
@@ -37,5 +38,9 @@ process.on('uncaughtException', async (err: Error | unknown) => {
     console.error('   npm ci')
     console.error('==========================================\n')
     process.exit(1)
+  } else if (process.listenerCount('uncaughtException') === 1) {
+    // A lone listener marks the error as handled, so print and exit like Node does without one.
+    console.error(err)
+    process.exit(1)
   }
 })
diff --git a/src/observability/tests/handle-package-not-found.ts b/src/observability/tests/handle-package-not-found.ts
new file mode 100644
index 000000000000..c3ca0a9be483
--- /dev/null
+++ b/src/observability/tests/handle-package-not-found.ts
@@ -0,0 +1,58 @@
+// Runs tsx with the same --import flag as nodemonConfig in package.json,
+// so the listener is in place before the entry module loads.
+
+import { spawnSync } from 'child_process'
+import path from 'path'
+import { describe, expect, test } from 'vitest'
+
+const rootDir = path.join(__dirname, '../../..')
+// spawnSync cannot launch the node_modules/.bin shell shim on Windows, so run the tsx CLI with node.
+const tsxCli = path.join(rootDir, 'node_modules/tsx/dist/cli.mjs')
+const handler = './src/observability/lib/handle-package-not-found.ts'
+
+function runWithHandler(code: string) {
+  const result = spawnSync(
+    process.execPath,
+    [tsxCli, '--import', handler, '--input-type=module', '-e', code],
+    {
+      cwd: rootDir,
+      encoding: 'utf8',
+      timeout: 15000,
+    },
+  )
+  return { status: result.status, stdout: result.stdout, stderr: result.stderr }
+}
+
+describe('handle-package-not-found', { timeout: 30000 }, () => {
+  test('prints the npm ci prompt and exits 1 for a missing package', () => {
+    const { status, stderr } = runWithHandler(
+      "import x from 'not-a-real-package-xyz'; console.log(x)",
+    )
+    expect(status).toBe(1)
+    expect(stderr).toContain('ERR_MODULE_NOT_FOUND')
+    expect(stderr).toContain('npm ci')
+  })
+
+  test('prints other startup errors and exits 1', () => {
+    const { status, stderr } = runWithHandler("throw new Error('startup boom')")
+    expect(status).toBe(1)
+    expect(stderr).toContain('startup boom')
+    expect(stderr).not.toContain('npm ci')
+  })
+
+  test('prints missing named export errors and exits 1', () => {
+    const { status, stderr } = runWithHandler("import { nope } from 'node:path'; console.log(nope)")
+    expect(status).toBe(1)
+    expect(stderr).toContain('nope')
+  })
+
+  test('leaves errors to other uncaughtException listeners when present', () => {
+    const { status, stdout, stderr } = runWithHandler(
+      "process.on('uncaughtException', (err) => console.log('handled', err.message)); setTimeout(() => { throw new Error('later') }, 0)",
+    )
+    expect(status).toBe(0)
+    expect(stdout).toContain('handled later')
+    // Node 26 prints a tsx deprecation warning to stderr, so check for the error instead of empty output.
+    expect(stderr).not.toContain('later')
+  })
+})

From dcac19a35b2545024a10f2b332370afc224c4c7d Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 22:16:09 +0000
Subject: [PATCH 34/71] Use English anchor IDs for terms on translated glossary
 pages (#63938)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
Copilot-Session: fb5d8be8-479c-4950-8197-ef0220dbdcb0
---
 src/languages/lib/get-english-headings.ts   |  57 ++++++++---
 src/languages/tests/get-english-headings.ts | 105 +++++++++++++++++++-
 2 files changed, 148 insertions(+), 14 deletions(-)

diff --git a/src/languages/lib/get-english-headings.ts b/src/languages/lib/get-english-headings.ts
index 935d0a41d49d..78d45fc347fa 100644
--- a/src/languages/lib/get-english-headings.ts
+++ b/src/languages/lib/get-english-headings.ts
@@ -1,3 +1,4 @@
+import GithubSlugger from 'github-slugger'
 import { fromMarkdown } from 'mdast-util-from-markdown'
 import { toString } from 'mdast-util-to-string'
 import { visit } from 'unist-util-visit'
@@ -8,7 +9,7 @@ import findPage from '@/frame/lib/find-page'
 import Permalink from '@/frame/lib/permalink'
 import { trailingSlash } from '@/frame/lib/patterns'
 import { getDataByLanguage } from '@/data-directory/lib/get-data'
-import type { Context } from '@/types'
+import type { Context, Glossary } from '@/types'
 
 interface HeadingNode extends Node {
   type: 'heading'
@@ -20,24 +21,56 @@ interface PageWithMarkdown {
   markdown: string
 }
 
-interface GlossaryTerm {
-  term: string
-  slug: string
-}
-
 export default async function getEnglishHeadings(
   page: PageWithMarkdown,
   context: Context,
 ): Promise<Record<string, string> | undefined> {
-  // Glossary headings come from data, not page markdown.
+  // Glossary term headings come from data, not page markdown.
   if (page.relativePath.endsWith('/github-glossary.md')) {
-    const languageGlossary = getDataByLanguage('glossaries.external', 'en') as GlossaryTerm[]
-    return languageGlossary.reduce((prev: Record<string, string>, curr: GlossaryTerm) => {
-      prev[curr.term] = curr.slug
-      return prev
-    }, {})
+    const enGlossary = getDataByLanguage('glossaries.external', 'en') as Glossary[]
+    const translatedGlossary = getDataByLanguage(
+      'glossaries.external',
+      context.currentLanguage!,
+    ) as Glossary[]
+    const headingMap = await getMarkdownHeadingMap(page, context)
+    // Translated glossary files keep the English term order, but lag behind English additions and removals.
+    if (translatedGlossary.length !== enGlossary.length) return headingMap
+    const enSlugs = getEnglishGlossarySlugs(enGlossary)
+    const termCounts = new Map<string, number>()
+    for (const entry of translatedGlossary) {
+      if (entry?.term) termCounts.set(entry.term, (termCounts.get(entry.term) || 0) + 1)
+    }
+    const glossaryMap: Record<string, string> = {}
+    for (let i = 0; i < translatedGlossary.length; i++) {
+      if (!translatedGlossary[i]?.term || !enSlugs[i]) continue
+      // Some translations reuse one term for two English terms, and a single key cannot map to both IDs.
+      if ((termCounts.get(translatedGlossary[i].term) || 0) > 1) continue
+      glossaryMap[translatedGlossary[i].term] = enSlugs[i]
+    }
+    return { ...headingMap, ...glossaryMap }
+  }
+
+  return getMarkdownHeadingMap(page, context)
+}
+
+// The English page slugs terms in sorted order, so duplicates like @mention and mention get suffixed IDs.
+// useEnglishHeadings slugs these values again, which leaves them unchanged.
+function getEnglishGlossarySlugs(enGlossary: Glossary[]): string[] {
+  const slugger = new GithubSlugger()
+  const slugs: string[] = []
+  const sortedIndexes = enGlossary
+    .map((_, i) => i)
+    .sort((a, b) => (enGlossary[a]?.term || '').localeCompare(enGlossary[b]?.term || '', 'en'))
+  for (const i of sortedIndexes) {
+    if (enGlossary[i]?.term) slugs[i] = slugger.slug(enGlossary[i].term)
   }
+  return slugs
+}
 
+async function getMarkdownHeadingMap(
+  page: PageWithMarkdown,
+  context: Context,
+): Promise<Record<string, string> | undefined> {
   const translatedHeadings = await getHeadings(page.markdown, context)
   if (!translatedHeadings.length) return
 
diff --git a/src/languages/tests/get-english-headings.ts b/src/languages/tests/get-english-headings.ts
index 25a053f72137..08e218db3533 100644
--- a/src/languages/tests/get-english-headings.ts
+++ b/src/languages/tests/get-english-headings.ts
@@ -1,8 +1,66 @@
-import { describe, expect, test } from 'vitest'
+import rehypeSlug from 'rehype-slug'
+import remarkParse from 'remark-parse'
+import remarkRehype from 'remark-rehype'
+import { unified } from 'unified'
+import { visit } from 'unist-util-visit'
+import type { Element, Root } from 'hast'
+import { beforeEach, describe, expect, test, vi } from 'vitest'
 
 import { renderContent } from '@/content-render/index'
+import useEnglishHeadings from '@/content-render/unified/use-english-headings'
 import getEnglishHeadings from '@/languages/lib/get-english-headings'
-import type { Context, Page } from '@/types'
+import type { Context, Glossary, Page } from '@/types'
+
+const glossaries = vi.hoisted(() => ({
+  en: [] as Glossary[],
+  es: [] as Glossary[],
+}))
+
+vi.mock('@/data-directory/lib/get-data', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('@/data-directory/lib/get-data')>()
+  return {
+    ...actual,
+    getDataByLanguage: (dottedPath: string, langCode: string) => {
+      if (dottedPath !== 'glossaries.external')
+        return actual.getDataByLanguage(dottedPath, langCode)
+      return glossaries[langCode as 'en' | 'es']
+    },
+  }
+})
+
+const glossaryPage = {
+  relativePath: 'get-started/learning-about-github/github-glossary.md',
+  markdown:
+    '{% for glossary in glossaries %}\n\n## {{ glossary.term }}\n\n{% endfor %}\n\n## Lectura adicional',
+}
+const glossaryContext = {
+  currentLanguage: 'es',
+  pages: {
+    '/en/get-started/learning-about-github/github-glossary': {
+      markdown:
+        '{% for glossary in glossaries %}\n\n## {{ glossary.term }}\n\n{% endfor %}\n\n## Further reading',
+    } as unknown as Page,
+  },
+  redirects: {},
+} as unknown as Context
+
+function toGlossary(terms: string[]): Glossary[] {
+  return terms.map((term) => ({ term, description: '' }))
+}
+
+async function renderHeadingIds(markdown: string, englishHeadings: Record<string, string>) {
+  const processor = unified()
+    .use(remarkParse)
+    .use(remarkRehype)
+    .use(rehypeSlug)
+    .use(useEnglishHeadings, { englishHeadings })
+  const tree = (await processor.run(processor.parse(markdown))) as Root
+  const ids: string[] = []
+  visit(tree, 'element', (node: Element) => {
+    if (node.tagName === 'h2') ids.push(String(node.properties.id))
+  })
+  return ids
+}
 
 function makeContext(englishMarkdown: string): Context {
   return {
@@ -116,3 +174,46 @@ describe('getEnglishHeadings', () => {
     expect(html).toContain('id="using-github-actions-1"')
   })
 })
+
+describe('getEnglishHeadings on glossary pages', () => {
+  beforeEach(() => {
+    glossaries.en = toGlossary(['fork', 'branch'])
+    glossaries.es = toGlossary(['bifurcación', 'rama'])
+  })
+
+  test('maps translated glossary terms and page headings to English', async () => {
+    const map = await getEnglishHeadings(glossaryPage, glossaryContext)
+    expect(map?.['bifurcación']).toBe('fork')
+    expect(map?.['rama']).toBe('branch')
+    expect(map?.['Lectura adicional']).toBe('Further reading')
+  })
+
+  test('renders English IDs for special characters and duplicate slugs', async () => {
+    glossaries.en = toGlossary(['@mention', 'fork & branch', 'mention'])
+    glossaries.es = toGlossary(['@mención', "bifurcación & l'rama", 'mención'])
+    const map = (await getEnglishHeadings(glossaryPage, glossaryContext))!
+    // Translated pages sort terms by localized text, so use an order that differs from English.
+    const ids = await renderHeadingIds(
+      "## mención\n\n## bifurcación & l'rama\n\n## @mención\n\n## Lectura adicional",
+      map,
+    )
+    expect(ids).toEqual(['mention-1', 'fork--branch', 'mention', 'further-reading'])
+  })
+
+  test('keeps localized IDs for a translated term shared by two English terms', async () => {
+    glossaries.en = toGlossary(['fork', 'merge', 'squash'])
+    glossaries.es = toGlossary(['bifurcación', 'combinar', 'combinar'])
+    const map = (await getEnglishHeadings(glossaryPage, glossaryContext))!
+    expect(map['combinar']).toBeUndefined()
+    const ids = await renderHeadingIds('## bifurcación\n\n## combinar\n\n## combinar', map)
+    expect(ids).toEqual(['fork', 'combinar', 'combinar-1'])
+  })
+
+  test('keeps localized term IDs when glossary lengths differ', async () => {
+    glossaries.en = toGlossary(['branch', 'fork', 'pull request'])
+    const map = await getEnglishHeadings(glossaryPage, glossaryContext)
+    expect(map?.['bifurcación']).toBeUndefined()
+    expect(map?.['rama']).toBeUndefined()
+    expect(map?.['Lectura adicional']).toBe('Further reading')
+  })
+})

From 6d53bfa83c22231b022033eafb7b9286b8581221 Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 22:16:16 +0000
Subject: [PATCH 35/71] Skip commit and push in site policy sync when nothing
 changed (#64211)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 .github/workflows/site-policy-sync.yml | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

diff --git a/.github/workflows/site-policy-sync.yml b/.github/workflows/site-policy-sync.yml
index 7cc23c8e72b1..685ce239c93d 100644
--- a/.github/workflows/site-policy-sync.yml
+++ b/.github/workflows/site-policy-sync.yml
@@ -48,19 +48,21 @@ jobs:
           echo PR_TITLE: $PR_TITLE
           [[ ! -z $PR_TITLE ]] && DESCRIPTION="${PR_TITLE}" || DESCRIPTION="Update manually triggered by workflow"
           echo "DESCRIPTION=$DESCRIPTION" >> $GITHUB_ENV
-          git commit -m "$(echo $DESCRIPTION)"
+          # git commit exits 1 when the public repo already matches, which would fail the job.
+          if git diff --cached --quiet; then
+            echo "No updates to push to the public repo"
+            echo "HAS_CHANGES=false" >> "$GITHUB_ENV"
+          else
+            git commit -m "$(echo $DESCRIPTION)"
+            echo "HAS_CHANGES=true" >> "$GITHUB_ENV"
+          fi
 
       - name: If there are changes to push, create a branch in the public repo and push changes
+        if: env.HAS_CHANGES == 'true'
         env:
           GITHUB_TOKEN: ${{ secrets.DOCS_BOT_PAT_BASE }}
         run: |
           cd public-repo
           git config --local user.name 'site-policy-bot'
           git config --local user.email 'site-policy-bot@github.com'
-          NUM_FILES_CHANGED=$(git diff --name-only HEAD^..HEAD | wc -l)
-          if [[ $NUM_FILES_CHANGED -ge 1 ]]
-            then
-              git push --set-upstream origin automated-sync-$GITHUB_RUN_ID
-            else
-              echo "No updates to push to the public repo"
-          fi
+          git push --set-upstream origin automated-sync-$GITHUB_RUN_ID

From a2687455cbc9b1c1af608a46924650cbfd61690b Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 22:16:22 +0000
Subject: [PATCH 36/71] Let approved content-removal PRs pass the spammy PR
 check (#64212)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 .github/workflows/check-for-spammy-prs.yml | 50 +++++++++++++++++++---
 1 file changed, 45 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/check-for-spammy-prs.yml b/.github/workflows/check-for-spammy-prs.yml
index c2f6021a22bc..bb17e6836478 100644
--- a/.github/workflows/check-for-spammy-prs.yml
+++ b/.github/workflows/check-for-spammy-prs.yml
@@ -8,6 +8,7 @@ on:
 
 permissions:
   contents: read
+  issues: read
   pull-requests: write
 
 jobs:
@@ -52,10 +53,49 @@ jobs:
             )
             const onlyIndexMd = files.length === 1 && files[0].filename.split('/').pop() === 'index.md'
 
+            // Content removals are allowed once the Docs team marks the linked issue `help wanted`.
+            let hasApprovedIssue = false
+            if (onlyDeletesLines || onlyDeletes) {
+              try {
+                const { repository } = await github.graphql(
+                  `query($owner: String!, $repo: String!, $number: Int!) {
+                    repository(owner: $owner, name: $repo) {
+                      pullRequest(number: $number) {
+                        closingIssuesReferences(first: 100) {
+                          nodes {
+                            repository {
+                              nameWithOwner
+                            }
+                            labels(first: 100) {
+                              nodes {
+                                name
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }`,
+                  { owner, repo, number: pull_number },
+                )
+                const closingIssues = repository?.pullRequest?.closingIssuesReferences?.nodes || []
+                // Issues in other repos don't count, since their owners can add the label themselves.
+                hasApprovedIssue = closingIssues.some(issue =>
+                  issue.repository?.nameWithOwner?.toLowerCase() === `${owner}/${repo}` &&
+                  issue.labels.nodes.some(label => label.name.toLowerCase() === 'help wanted'),
+                )
+              } catch (error) {
+                // Without the lookup, treat the removal as unapproved, as before.
+                core.warning(`Could not check linked issues: ${error.message}`)
+              }
+            }
+            const unapprovedLineDeletion = onlyDeletesLines && !hasApprovedIssue
+            const unapprovedFileDeletion = onlyDeletes && !hasApprovedIssue
+
             if (
               targetsNonMain ||
-              onlyDeletesLines ||
-              onlyDeletes ||
+              unapprovedLineDeletion ||
+              unapprovedFileDeletion ||
               isEmptyCommit ||
               touchesTooMany ||
               isBlankLineEdit ||
@@ -75,8 +115,8 @@ jobs:
                 issue_number: pull_number,
                 body: targetsNonMain
                   ? 'Pull requests must target the `main` branch. This pull request has been closed as invalid. If you think this is incorrect, please mention this in a corresponding issue.'
-                  : onlyDeletesLines
-                    ? 'This pull request only removes existing content. Before submitting a content-removal pull request, please [open an issue](https://github.com/github/docs/issues/new/choose) explaining the proposed removal and wait for approval from the GitHub Docs team. Once the change has been approved, you can open a new pull request and link it to the issue.'
+                  : unapprovedLineDeletion
+                    ? 'This pull request only removes existing content. Before submitting a content-removal pull request, please [open an issue](https://github.com/github/docs/issues/new/choose) explaining the proposed removal and wait for the GitHub Docs team to add the `help wanted` label to it. Once the issue has the `help wanted` label, you can open a new pull request that links the issue with `Closes: #<issue number>` in the description.'
                     : "This pull request may have been opened accidentally. I'm going to close it now, but feel free to check out our [contribution guidelines](https://docs.github.com/en/contributing), or raise an issue.",
               })
 
@@ -89,7 +129,7 @@ jobs:
                 })
               }
 
-              if (onlyDeletesLines) {
+              if (unapprovedLineDeletion) {
                 core.setFailed(
                   'This pull request only deletes lines. An approved issue is required first.',
                 )

From 12eaacba12b68e75143e484baae21cf696a6fc18 Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 22:16:28 +0000
Subject: [PATCH 37/71] Drop stale hovercard responses after the pointer leaves
 (#64213)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 .../tests/playwright-rendering.spec.ts        | 82 +++++++++++++++++++
 src/links/components/LinkPreviewPopover.tsx   | 12 +++
 2 files changed, 94 insertions(+)

diff --git a/src/fixtures/tests/playwright-rendering.spec.ts b/src/fixtures/tests/playwright-rendering.spec.ts
index 0675ed1c8a85..69ac12ff5563 100644
--- a/src/fixtures/tests/playwright-rendering.spec.ts
+++ b/src/fixtures/tests/playwright-rendering.spec.ts
@@ -1568,6 +1568,88 @@ test.describe('hover cards', () => {
       ),
     ).not.toBeVisible()
   })
+
+  test('Escape before the hovercard opening delay ends keeps the card closed', async ({ page }) => {
+    await page.goto('/pages/quickstart')
+    await turnOffExperimentsInPage(page)
+
+    let metaRequests = 0
+    page.on('request', (request) => {
+      if (/\/api\/article\/meta\?/.test(request.url())) metaRequests++
+    })
+
+    const link = page.locator('#article-contents').getByRole('link', { name: 'Start your journey' })
+    await link.focus()
+    await page.keyboard.press('Alt+ArrowUp')
+    await page.keyboard.press('Escape')
+
+    await page.waitForTimeout(1000)
+    expect(metaRequests).toBe(0)
+    await expect(page.getByTestId('popover')).not.toBeVisible()
+    await expect(link).toBeFocused()
+  })
+
+  test('late hovercard response after the pointer leaves does not open the card', async ({
+    page,
+  }) => {
+    await page.goto('/pages/quickstart')
+    await turnOffExperimentsInPage(page)
+
+    let releaseMeta = () => {}
+    const metaHeld = new Promise<void>((resolve) => {
+      releaseMeta = resolve
+    })
+    await page.route(/\/api\/article\/meta\?/, async (route) => {
+      await metaHeld
+      await route.continue()
+    })
+
+    const metaRequest = page.waitForRequest(/\/api\/article\/meta\?/)
+    await page
+      .locator('#article-contents')
+      .getByRole('link', { name: 'Start your journey' })
+      .hover()
+    const request = await metaRequest
+    await page.mouse.move(0, 0)
+
+    releaseMeta()
+    await request.response()
+    await page.waitForTimeout(500)
+    await expect(page.getByTestId('popover')).not.toBeVisible()
+  })
+
+  test('late hovercard response for an earlier link does not replace the current card', async ({
+    page,
+  }) => {
+    await page.goto('/pages/quickstart')
+    await turnOffExperimentsInPage(page)
+
+    let releaseMeta = () => {}
+    const metaHeld = new Promise<void>((resolve) => {
+      releaseMeta = resolve
+    })
+    await page.route(/\/api\/article\/meta\?/, async (route) => {
+      await metaHeld
+      await route.continue()
+    })
+
+    const intro = page.locator('#article-intro')
+    const popover = page.getByTestId('popover')
+    const metaRequest = page.waitForRequest(/\/api\/article\/meta\?/)
+    await intro.getByRole('link', { name: 'another link' }).hover()
+    const request = await metaRequest
+    await intro.getByRole('link', { name: 'article intro link' }).hover()
+    await expect(popover.getByText('You can use HubGit Pages to showcase')).toBeVisible()
+
+    // The in-page anchor card fills without a fetch, so only the earlier link's request is held.
+    releaseMeta()
+    await request.response()
+    await page.waitForTimeout(500)
+    await expect(popover.getByText('You can use HubGit Pages to showcase')).toBeVisible()
+    await expect(
+      popover.getByText('Follow this Hello World exercise to get started with HubGit.'),
+    ).not.toBeVisible()
+  })
 })
 
 test.describe('test nav at different viewports', () => {
diff --git a/src/links/components/LinkPreviewPopover.tsx b/src/links/components/LinkPreviewPopover.tsx
index e9dd3bd96440..e3935c8f4d37 100644
--- a/src/links/components/LinkPreviewPopover.tsx
+++ b/src/links/components/LinkPreviewPopover.tsx
@@ -13,6 +13,9 @@ let popoverStartTimer: number | null = null
 // Re-entering the source link for the open hovercard skips the first-open delay.
 let currentlyOpen: HTMLLinkElement | null = null
 
+// Each wrap and hide bumps this ID so a fetch that lands after a hide or a newer hover is dropped.
+let popoverRequestId = 0
+
 // Links within 300 px of the viewport top render below the link to avoid an after-render flip.
 // Hidden hovercards report height 0 until display, so this keeps placement stable.
 const BOUNDING_TOP_MARGIN = 300
@@ -164,6 +167,7 @@ function popoverWrap(element: HTMLLinkElement, filledCallback?: (popover: HTMLDi
   if (element.parentElement && element.parentElement.classList.contains('Popover')) {
     return
   }
+  const requestId = ++popoverRequestId
   let title = ''
   let product = ''
   let intro = ''
@@ -217,6 +221,7 @@ function popoverWrap(element: HTMLLinkElement, filledCallback?: (popover: HTMLDi
     })
     if (response.ok) {
       const meta = (await response.json()) as PageMetadata
+      if (requestId !== popoverRequestId) return
       fillPopover(element, meta, filledCallback)
     }
   }
@@ -361,6 +366,7 @@ function popoverHide() {
   if (popoverStartTimer) {
     window.clearTimeout(popoverStartTimer)
   }
+  popoverRequestId++
 
   popoverCloseTimer = window.setTimeout(() => {
     const popover = getOrCreatePopoverGlobal()
@@ -430,6 +436,12 @@ export function LinkPreviewPopover() {
           if (lastFocussedLink) {
             lastFocussedLink.focus()
           }
+        } else {
+          // A hovercard still in its opening delay or waiting on its fetch must not open after Escape.
+          if (popoverStartTimer) {
+            window.clearTimeout(popoverStartTimer)
+          }
+          popoverRequestId++
         }
       }
     }

From 561b84032b568ef81f8e67af5da16bbdd934db01 Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 22:16:35 +0000
Subject: [PATCH 38/71] Check table rows that lack a closing pipe in GHD047
 (#64216)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 .../codeql-language-identifiers-table.md      | 10 +--
 .../linting-rules/table-column-integrity.ts   | 37 +++++---
 .../unit/table-column-integrity-simple.ts     | 85 +++++++++++++++++++
 3 files changed, 117 insertions(+), 15 deletions(-)

diff --git a/data/reusables/code-scanning/codeql-language-identifiers-table.md b/data/reusables/code-scanning/codeql-language-identifiers-table.md
index e6a90bff99e9..66f801a1287d 100644
--- a/data/reusables/code-scanning/codeql-language-identifiers-table.md
+++ b/data/reusables/code-scanning/codeql-language-identifiers-table.md
@@ -2,13 +2,13 @@
 | Language | Identifier | Optional alternative identifiers (if any)
 |------------------|------------------- | ---------------
 | C/C++ | `c-cpp` | `c` or `cpp` |
-| C# | `csharp` |
-| {% data variables.product.prodname_actions %} workflows | `actions` |
-| Go | `go` |
+| C# | `csharp` | |
+| {% data variables.product.prodname_actions %} workflows | `actions` | |
+| Go | `go` | |
 | Java/Kotlin | `java-kotlin` | `java` or `kotlin` |
 | JavaScript/TypeScript | `javascript-typescript` | `javascript` or `typescript` |
-| Python | `python` |
-| Ruby | `ruby` |
+| Python | `python` | |
+| Ruby | `ruby` | |
 | {% ifversion codeql-rust-available %} |
 Rust | `rust`
 | {% else ifversion codeql-rust-public-preview %}
diff --git a/src/content-linter/lib/linting-rules/table-column-integrity.ts b/src/content-linter/lib/linting-rules/table-column-integrity.ts
index 51682abde73d..7d39cb4541da 100644
--- a/src/content-linter/lib/linting-rules/table-column-integrity.ts
+++ b/src/content-linter/lib/linting-rules/table-column-integrity.ts
@@ -4,12 +4,15 @@ import frontmatter from '@/frame/lib/read-frontmatter'
 
 import type { RuleParams, RuleErrorCallback } from '@/content-linter/types'
 
-// After optional leading whitespace, a candidate table row opens and closes
-// with a pipe.
-const TABLE_ROW_REGEX = /^\s*\|.*\|\s*$/
-// Between the boundary pipes, a candidate separator holds only pipes, colons,
+// After optional leading whitespace, a candidate table row opens with a pipe.
+// GFM does not require a closing pipe.
+const TABLE_ROW_REGEX = /^\s*\|/
+// After the opening pipe, a candidate separator holds only pipes, colons,
 // hyphens, and whitespace.
-const TABLE_SEPARATOR_REGEX = /^\s*\|[\s\-:|\s]*\|\s*$/
+const TABLE_SEPARATOR_REGEX = /^\s*\|[\s\-:|\s]*$/
+// Trailing HTML comments are often markdownlint directives rather than cell content.
+// Comment bodies exclude "<!--" so a literal opener in an earlier code span does not match.
+const TRAILING_HTML_COMMENTS_REGEX = /(?:\s*<!--(?:(?!-->|<!--).)*-->)+\s*$/
 // A Liquid-only cell is whitespace, a Liquid tag, then whitespace.
 const LIQUID_ONLY_CELL_REGEX = /^\s*{%\s*(ifversion|else|endif|elsif|for|endfor).*%}\s*$/
 // Escaped pipes (\|) are cell content, not separators.
@@ -34,6 +37,12 @@ function countColumns(row: string): number {
   return cells.length
 }
 
+// Without a closing pipe, a trailing comment can be the content of the last cell,
+// so return the count without trailing comments and the count with them.
+function countColumnOptions(row: string): [number, number] {
+  return [countColumns(row.replace(TRAILING_HTML_COMMENTS_REGEX, '')), countColumns(row)]
+}
+
 function isLiquidOnlyRow(row: string): boolean {
   const trimmed = row.trim()
   if (!trimmed.includes('|')) return false
@@ -66,7 +75,7 @@ export const tableColumnIntegrity = {
     let expectedColumnCount: number | null = null
 
     for (let i = 0; i < lines.length; i++) {
-      const line = lines[i]
+      const line = lines[i].replace(TRAILING_HTML_COMMENTS_REGEX, '')
 
       if (line.trim().startsWith('```')) {
         inCodeFence = !inCodeFence
@@ -82,10 +91,15 @@ export const tableColumnIntegrity = {
 
       if (!inTable && isTableRow) {
         // A following separator row confirms the current row starts a table.
-        const nextLine = lines[i + 1]
+        const nextLine = lines[i + 1]?.replace(TRAILING_HTML_COMMENTS_REGEX, '')
         if (nextLine && TABLE_SEPARATOR_REGEX.test(nextLine)) {
           inTable = true
-          expectedColumnCount = countColumns(line)
+          const [headerCount, headerCountWithComments] = countColumnOptions(lines[i])
+          // GFM requires the header and separator to have the same number of cells.
+          expectedColumnCount =
+            headerCountWithComments === countColumns(nextLine)
+              ? headerCountWithComments
+              : headerCount
           continue
         }
       }
@@ -102,9 +116,12 @@ export const tableColumnIntegrity = {
           continue
         }
 
-        const actualColumnCount = countColumns(line)
+        const [actualColumnCount, actualCountWithComments] = countColumnOptions(lines[i])
 
-        if (actualColumnCount !== expectedColumnCount) {
+        if (
+          actualColumnCount !== expectedColumnCount &&
+          actualCountWithComments !== expectedColumnCount
+        ) {
           const range = getRange(line, line.trim())
           let errorMessage
 
diff --git a/src/content-linter/tests/unit/table-column-integrity-simple.ts b/src/content-linter/tests/unit/table-column-integrity-simple.ts
index 14137e8709e8..bca8bc9cc861 100644
--- a/src/content-linter/tests/unit/table-column-integrity-simple.ts
+++ b/src/content-linter/tests/unit/table-column-integrity-simple.ts
@@ -52,6 +52,91 @@ describe(tableColumnIntegrity.names.join(' - '), () => {
     }
   })
 
+  test('Rows after a row without a closing pipe are still checked', async () => {
+    const markdown = ['| A | B |', '| --- | --- |', '| x | y', '| p | q | r |'].join('\n')
+    const result = await runRule(tableColumnIntegrity, { strings: { markdown } })
+    const errors = result.markdown
+    expect(errors.length).toBe(1)
+    expect(errors[0].lineNumber).toBe(4)
+    expect(errors[0].errorDetail).toContain('Table row has 3 columns but header has 2')
+  })
+
+  test('Tables whose header and separator lack closing pipes are checked', async () => {
+    const markdown = ['| A | B', '| --- | ---', '| p | q | r |'].join('\n')
+    const result = await runRule(tableColumnIntegrity, { strings: { markdown } })
+    const errors = result.markdown
+    expect(errors.length).toBe(1)
+    expect(errors[0].lineNumber).toBe(3)
+    expect(errors[0].errorDetail).toContain('Table row has 3 columns but header has 2')
+  })
+
+  test('Trailing HTML comments are not counted as cells', async () => {
+    const markdown = [
+      '| Option | Description |',
+      '|--------|-------------|',
+      '| `--json` | Emit JSON. | <!-- markdownlint-disable-line GHD046 -->',
+      '| `--help` | Show help. | Extra |',
+    ].join('\n')
+    const result = await runRule(tableColumnIntegrity, { strings: { markdown } })
+    const errors = result.markdown
+    expect(errors.length).toBe(1)
+    expect(errors[0].lineNumber).toBe(4)
+    expect(errors[0].errorDetail).toContain('Table row has 3 columns but header has 2')
+  })
+
+  test('Multiple trailing HTML comments are not counted as cells', async () => {
+    const markdown = [
+      '| A | B | <!-- first --> <!-- second -->',
+      '| --- | --- |',
+      '| x | y | <!-- first --> <!-- second -->',
+      '| p | q | r |',
+    ].join('\n')
+    const result = await runRule(tableColumnIntegrity, { strings: { markdown } })
+    const errors = result.markdown
+    expect(errors.length).toBe(1)
+    expect(errors[0].lineNumber).toBe(4)
+    expect(errors[0].errorDetail).toContain('Table row has 3 columns but header has 2')
+  })
+
+  test('Comment openers inside code spans do not hide cells', async () => {
+    const markdown = [
+      '| Syntax | Meaning |',
+      '| --- | --- |',
+      '| `<!--` | Starts a comment | <!-- note -->',
+    ].join('\n')
+    const result = await runRule(tableColumnIntegrity, { strings: { markdown } })
+    const errors = result.markdown
+    expect(errors.length).toBe(0)
+  })
+
+  test('Comment-only final cells without a closing pipe are counted', async () => {
+    const markdown = [
+      '| A | <!-- intentionally empty -->',
+      '| --- | --- |',
+      '| value | <!-- intentionally empty -->',
+      '| x | y |',
+      '| p | q | r |',
+    ].join('\n')
+    const result = await runRule(tableColumnIntegrity, { strings: { markdown } })
+    const errors = result.markdown
+    expect(errors.length).toBe(1)
+    expect(errors[0].lineNumber).toBe(5)
+    expect(errors[0].errorDetail).toContain('Table row has 3 columns but header has 2')
+  })
+
+  test('Valid table mixing rows with and without closing pipes passes', async () => {
+    const markdown = [
+      '| Name | Status',
+      '| ---- | ------',
+      '| Alpha | Active |',
+      '| Beta | Inactive',
+      '| Gamma | Active |',
+    ].join('\n')
+    const result = await runRule(tableColumnIntegrity, { strings: { markdown } })
+    const errors = result.markdown
+    expect(errors.length).toBe(0)
+  })
+
   test('Liquid-only rows are ignored', async () => {
     const markdown = [
       '| Feature | Status |',

From 28323034b4fd4c790ac4bdd9e7f7112cd37549f8 Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 22:16:42 +0000
Subject: [PATCH 39/71] Show body params for REST request bodies with a
 top-level anyOf (#64219)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 src/rest/scripts/utils/get-body-params.ts     | 41 +++++++++-
 .../utils/tests/get-body-params.test.ts       | 78 +++++++++++++++++++
 2 files changed, 118 insertions(+), 1 deletion(-)

diff --git a/src/rest/scripts/utils/get-body-params.ts b/src/rest/scripts/utils/get-body-params.ts
index 787f414bd12b..1b3a3fd49a5b 100644
--- a/src/rest/scripts/utils/get-body-params.ts
+++ b/src/rest/scripts/utils/get-body-params.ts
@@ -93,6 +93,40 @@ async function getTopLevelOneOfProperty(
   return { properties, required }
 }
 
+// A top-level anyOf of objects, like Review custom deployment protection rules for a workflow
+// run, has no properties on the schema object, so getTopLevelAnyOfProperty merges all options.
+// A request can match any option, so only fields every option requires are marked required,
+// plus fields the parent requires, since parent constraints apply alongside anyOf.
+// The first option that defines a property keeps its description.
+function getTopLevelAnyOfProperty(
+  anyOf: Schema[],
+  parentRequired: string[] = [],
+): {
+  properties: Record<string, Schema>
+  required: string[]
+} {
+  const properties: Record<string, Schema> = {}
+  for (const each of anyOf) {
+    for (const [key, value] of Object.entries(each.properties || {})) {
+      if (!Object.hasOwn(properties, key)) properties[key] = value
+    }
+  }
+  const sharedRequired = (anyOf[0].required || []).filter((name) =>
+    anyOf.every((each) => each.required?.includes(name)),
+  )
+  const required = [...new Set([...parentRequired, ...sharedRequired])]
+  return { properties, required }
+}
+
+function isTopLevelObjectAnyOf(schema: Schema): schema is Schema & { anyOf: Schema[] } {
+  return (
+    !schema.properties &&
+    Array.isArray(schema.anyOf) &&
+    schema.anyOf.length > 0 &&
+    schema.anyOf.every((elem) => elem.type === 'object')
+  )
+}
+
 async function handleObjectOnlyOneOf(
   param: Schema,
   paramType: string[],
@@ -120,7 +154,12 @@ function getArrayItemTypes(items: Schema): string[] {
 // while mixed oneOf adds types and descriptions without creating child parameter groups.
 export async function getBodyParams(schema: Schema, topLevel = false): Promise<TransformedParam[]> {
   const bodyParametersParsed: TransformedParam[] = []
-  const schemaObject = schema.oneOf && topLevel ? await getTopLevelOneOfProperty(schema) : schema
+  let schemaObject: Schema = schema
+  if (schema.oneOf && topLevel) {
+    schemaObject = await getTopLevelOneOfProperty(schema)
+  } else if (topLevel && isTopLevelObjectAnyOf(schema)) {
+    schemaObject = getTopLevelAnyOfProperty(schema.anyOf, schema.required)
+  }
   const properties = schemaObject.properties || {}
   const required = schemaObject.required || []
 
diff --git a/src/rest/scripts/utils/tests/get-body-params.test.ts b/src/rest/scripts/utils/tests/get-body-params.test.ts
index c39779f2d727..e2314801e599 100644
--- a/src/rest/scripts/utils/tests/get-body-params.test.ts
+++ b/src/rest/scripts/utils/tests/get-body-params.test.ts
@@ -104,6 +104,84 @@ describe('getBodyParams — OAS 3.1 nullable handling', () => {
     ])
   })
 
+  it('merges object-only top-level anyOf alternatives and requires only shared fields', async () => {
+    const schema: Schema = {
+      anyOf: [
+        {
+          type: 'object',
+          properties: {
+            environment_name: { type: 'string', description: 'The environment name' },
+            comment: { type: 'string', description: 'Required when state is not provided.' },
+          },
+          required: ['environment_name', 'comment'],
+        },
+        {
+          type: 'object',
+          properties: {
+            environment_name: { type: 'string', description: 'The environment name' },
+            state: { type: 'string', description: 'The state', enum: ['approved', 'rejected'] },
+            comment: { type: 'string', description: 'Optional comment.' },
+          },
+          required: ['environment_name', 'state'],
+        },
+      ],
+    }
+    const params = await getBodyParams(schema, true)
+    expect(params.map(({ name, isRequired }) => [name, isRequired])).toEqual([
+      ['environment_name', true],
+      ['comment', undefined],
+      ['state', undefined],
+    ])
+    expect(params[1].description).toBe('Required when state is not provided.')
+  })
+
+  it('keeps parent required fields alongside a top-level object anyOf', async () => {
+    const schema: Schema = {
+      type: 'object',
+      required: ['environment_name'],
+      anyOf: [
+        {
+          type: 'object',
+          properties: {
+            environment_name: { type: 'string', description: 'The environment name' },
+            comment: { type: 'string', description: 'A comment' },
+          },
+          required: ['comment'],
+        },
+        {
+          type: 'object',
+          properties: {
+            environment_name: { type: 'string', description: 'The environment name' },
+            state: { type: 'string', description: 'The state' },
+          },
+          required: ['state'],
+        },
+      ],
+    }
+    const params = await getBodyParams(schema, true)
+    expect(params.map(({ name, isRequired }) => [name, isRequired])).toEqual([
+      ['environment_name', true],
+      ['comment', undefined],
+      ['state', undefined],
+    ])
+  })
+
+  it('keeps parent properties when a top-level anyOf only lists required fields', async () => {
+    const schema: Schema = {
+      type: 'object',
+      properties: {
+        first: { type: 'string', description: 'First value' },
+        second: { type: 'string', description: 'Second value' },
+      },
+      anyOf: [{ required: ['first'] }, { required: ['second'] }],
+    }
+    const params = await getBodyParams(schema, true)
+    expect(params.map(({ name, isRequired }) => [name, isRequired])).toEqual([
+      ['first', undefined],
+      ['second', undefined],
+    ])
+  })
+
   it('keeps parent properties when top-level oneOf options only constrain them', async () => {
     const schema: Schema = {
       type: 'object',

From c18b5ae685b70fe76e039d9d0cf633e88872a8c5 Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 22:16:49 +0000
Subject: [PATCH 40/71] Set feature flags when counting translation corruptions
 (#64220)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 .../scripts/count-translation-corruptions.ts  |  9 ++++---
 .../tests/count-translation-corruptions.ts    | 27 ++++++++++++++++++-
 2 files changed, 32 insertions(+), 4 deletions(-)

diff --git a/src/languages/scripts/count-translation-corruptions.ts b/src/languages/scripts/count-translation-corruptions.ts
index f0a27eb21b58..c8729160f6c9 100644
--- a/src/languages/scripts/count-translation-corruptions.ts
+++ b/src/languages/scripts/count-translation-corruptions.ts
@@ -6,6 +6,7 @@ import walk from 'walk-sync'
 
 import { engine } from '@/content-render/liquid/engine'
 import { allVersions } from '@/versions/lib/all-versions'
+import { getFeaturesByVersion } from '@/versions/middleware/features'
 import languages from '@/languages/lib/languages-server'
 import warmServer from '@/frame/lib/warm-server'
 import type { Site } from '@/types'
@@ -172,11 +173,13 @@ function getReusables(): Reusables {
 
 // Build a minimal Liquid render context for validating translated content.
 // ifversion needs currentVersionObj; data tags call getDataByLanguage internally.
-// Mirror shortVersions middleware so bare conditionals such as {% ifversion ghes %} resolve.
-// Without the short-name flag, Liquid sees an undefined variable and hides real corruptions.
-function buildRenderContext(languageCode: string, version: string) {
+// Mirror shortVersions and features middleware so bare conditionals such as
+// {% ifversion ghes %} or {% ifversion some-feature %} resolve.
+// Without these flags, Liquid sees an undefined variable and hides real corruptions.
+export function buildRenderContext(languageCode: string, version: string) {
   const currentVersionObj = allVersions[version]
   return {
+    ...getFeaturesByVersion(version),
     currentLanguage: languageCode,
     currentVersion: version,
     currentVersionObj,
diff --git a/src/languages/tests/count-translation-corruptions.ts b/src/languages/tests/count-translation-corruptions.ts
index 2d1601aceca1..1bc10009bb7a 100644
--- a/src/languages/tests/count-translation-corruptions.ts
+++ b/src/languages/tests/count-translation-corruptions.ts
@@ -1,7 +1,12 @@
 import { describe, expect, test } from 'vitest'
 
 import { allVersions } from '@/versions/lib/all-versions'
-import { resolveRequestedVersions } from '@/languages/scripts/count-translation-corruptions'
+import { getFeaturesByVersion } from '@/versions/middleware/features'
+import { engine } from '@/content-render/liquid/engine'
+import {
+  buildRenderContext,
+  resolveRequestedVersions,
+} from '@/languages/scripts/count-translation-corruptions'
 
 // Pick a real GHES key at runtime rather than hard-coding one. allVersions
 // only contains supported releases, so enterprise-server@3.16 fails after
@@ -35,3 +40,23 @@ describe('resolveRequestedVersions', () => {
     expect(() => resolveRequestedVersions('free-pro-team@latest,nope')).toThrow(/nope/)
   })
 })
+
+describe('buildRenderContext', () => {
+  const fptFeature = Object.entries(getFeaturesByVersion('free-pro-team@latest')).find(
+    ([, enabled]) => enabled,
+  )![0]
+
+  test('sets feature flags for the version', () => {
+    const ctx = buildRenderContext('es', 'free-pro-team@latest')
+    expect(ctx[fptFeature]).toBe(true)
+    expect(ctx.currentVersion).toBe('free-pro-team@latest')
+    expect(ctx.fpt).toBe(true)
+  })
+
+  test('renders feature-gated branches so render-time errors surface', async () => {
+    const ctx = buildRenderContext('es', 'free-pro-team@latest')
+    await expect(
+      engine.parseAndRender(`{% ifversion ${fptFeature} %}{% octicon "lapiz" %}{% endif %}`, ctx),
+    ).rejects.toThrow(/Octicon lapiz does not exist/)
+  })
+})

From 6622cb99edd126275dc7289fcae12fa246764075 Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 22:16:57 +0000
Subject: [PATCH 41/71] Match whole path segments in update-filepaths --paths
 (#64227)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 src/content-render/lib/is-path-within.ts      | 10 +++++
 .../scripts/update-filepaths.ts               |  4 +-
 src/content-render/tests/is-path-within.ts    | 37 +++++++++++++++++++
 3 files changed, 49 insertions(+), 2 deletions(-)
 create mode 100644 src/content-render/lib/is-path-within.ts
 create mode 100644 src/content-render/tests/is-path-within.ts

diff --git a/src/content-render/lib/is-path-within.ts b/src/content-render/lib/is-path-within.ts
new file mode 100644
index 000000000000..ea6ac727d5f6
--- /dev/null
+++ b/src/content-render/lib/is-path-within.ts
@@ -0,0 +1,10 @@
+import path from 'path'
+
+// Compare whole path segments so content/foo does not also match content/foo-bar.
+export function isPathWithin(file: string, target: string): boolean {
+  const normalizedFile = path.normalize(file)
+  const normalizedTarget = path.normalize(target).replace(/[\\/]+$/, '')
+  return (
+    normalizedFile === normalizedTarget || normalizedFile.startsWith(normalizedTarget + path.sep)
+  )
+}
diff --git a/src/content-render/scripts/update-filepaths.ts b/src/content-render/scripts/update-filepaths.ts
index 45bc147c26d8..0a93b486c511 100755
--- a/src/content-render/scripts/update-filepaths.ts
+++ b/src/content-render/scripts/update-filepaths.ts
@@ -10,6 +10,7 @@ import { execFileSync } from 'child_process'
 import walkFiles from '@/workflows/walk-files'
 import frontmatter from '@/frame/lib/read-frontmatter'
 import { renderContent } from '@/content-render/index'
+import { isPathWithin } from '@/content-render/lib/is-path-within'
 import fpt from '@/versions/lib/non-enterprise-default-version'
 import { allVersions } from '@/versions/lib/all-versions'
 import type { PageFrontmatter, Context } from '@/types'
@@ -205,8 +206,7 @@ function filterFiles(contentDir: string, scriptOptions: ScriptOptions) {
         console.error(`${p} not found`)
         process.exit(1)
       }
-      if (path.relative(process.cwd(), file).startsWith(p)) return true
-      return false
+      return isPathWithin(path.relative(process.cwd(), file), p)
     })
   })
 }
diff --git a/src/content-render/tests/is-path-within.ts b/src/content-render/tests/is-path-within.ts
new file mode 100644
index 000000000000..0db9ac69db46
--- /dev/null
+++ b/src/content-render/tests/is-path-within.ts
@@ -0,0 +1,37 @@
+import path from 'path'
+import { describe, expect, test } from 'vitest'
+import { isPathWithin } from '@/content-render/lib/is-path-within'
+
+const p = (...segments: string[]) => path.join(...segments)
+
+describe('isPathWithin', () => {
+  test('matches files inside the target directory', () => {
+    expect(isPathWithin(p('content', 'search', 'foo.md'), p('content', 'search'))).toBe(true)
+    expect(isPathWithin(p('content', 'search', 'a', 'index.md'), p('content', 'search'))).toBe(true)
+  })
+
+  test('matches the target file itself', () => {
+    const file = p('content', 'search', 'foo.md')
+    expect(isPathWithin(file, file)).toBe(true)
+  })
+
+  test('does not match sibling directories that share a name prefix', () => {
+    expect(isPathWithin(p('content', 'search-github', 'foo.md'), p('content', 'search'))).toBe(
+      false,
+    )
+    expect(
+      isPathWithin(p('content', 'rest', 'gitignore', 'x.md'), p('content', 'rest', 'git')),
+    ).toBe(false)
+  })
+
+  test('does not match sibling files that share a name prefix', () => {
+    expect(isPathWithin(p('content', 'a', 'foo-bar.md'), p('content', 'a', 'foo'))).toBe(false)
+  })
+
+  test('accepts a trailing separator on the target', () => {
+    expect(isPathWithin(p('content', 'search', 'foo.md'), `${p('content', 'search')}/`)).toBe(true)
+    expect(
+      isPathWithin(p('content', 'search-github', 'foo.md'), `${p('content', 'search')}/`),
+    ).toBe(false)
+  })
+})

From 5d8713df7d5abac53b7ce35e32bc44791b07406b Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 22:35:59 +0000
Subject: [PATCH 42/71] Check PR links in every version the changed page
 supports (#63993)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 src/links/lib/extract-links.ts      |  5 ++
 src/links/lib/link-report.ts        | 41 +++++++++++++
 src/links/scripts/check-links-pr.ts | 92 ++++++++++++++++-------------
 src/links/tests/extract-links.ts    | 29 +++++++++
 src/links/tests/link-report.ts      | 64 ++++++++++++++++++++
 5 files changed, 189 insertions(+), 42 deletions(-)

diff --git a/src/links/lib/extract-links.ts b/src/links/lib/extract-links.ts
index 039806eea743..216470d96856 100644
--- a/src/links/lib/extract-links.ts
+++ b/src/links/lib/extract-links.ts
@@ -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
diff --git a/src/links/lib/link-report.ts b/src/links/lib/link-report.ts
index 4ffe824e4f3e..82aaccb7642f 100644
--- a/src/links/lib/link-report.ts
+++ b/src/links/lib/link-report.ts
@@ -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: {
diff --git a/src/links/scripts/check-links-pr.ts b/src/links/scripts/check-links-pr.ts
index 3499a5e7bb39..93d9075ba6fb 100644
--- a/src/links/scripts/check-links-pr.ts
+++ b/src/links/scripts/check-links-pr.ts
@@ -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,13 +53,11 @@ 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
@@ -64,53 +65,60 @@ async function checkFile(
     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)),
diff --git a/src/links/tests/extract-links.ts b/src/links/tests/extract-links.ts
index ef2d8a046080..64b80ff47dc5 100644
--- a/src/links/tests/extract-links.ts
+++ b/src/links/tests/extract-links.ts
@@ -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])
diff --git a/src/links/tests/link-report.ts b/src/links/tests/link-report.ts
index 8bdb0689021a..b0db40b7d3ce 100644
--- a/src/links/tests/link-report.ts
+++ b/src/links/tests/link-report.ts
@@ -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,

From 53f9cdeeddecca96d85f3b5035b47beed1c8fbd5 Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 22:36:05 +0000
Subject: [PATCH 43/71] Drop cross-product children from Article API landing
 lists (#64047)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 src/article-api/lib/get-all-toc-items.ts   | 24 ++++++------
 src/article-api/tests/get-all-toc-items.ts | 45 ++++++++++++++++++++++
 2 files changed, 57 insertions(+), 12 deletions(-)

diff --git a/src/article-api/lib/get-all-toc-items.ts b/src/article-api/lib/get-all-toc-items.ts
index 51ed67bd1ec1..591880f387e1 100644
--- a/src/article-api/lib/get-all-toc-items.ts
+++ b/src/article-api/lib/get-all-toc-items.ts
@@ -41,15 +41,20 @@ export async function getAllTocItems(
   const basePath = options.basePath ?? pathname
 
   const resolvedChildren = pageWithChildren.children
-    .map((childHref) => ({
-      childHref,
-      childPage: resolvePath(childHref, languageCode, pathname, context) as
+    .map((childHref) => {
+      const childPage = resolvePath(childHref, languageCode, pathname, context) as
         | PageWithChildren
-        | undefined,
-    }))
+        | undefined
+      const childPermalink = childPage?.permalinks.find(
+        (p) => p.languageCode === languageCode && p.pageVersion === context.currentVersion,
+      )
+      return { href: childPermalink?.href, childPage }
+    })
+    // Frontmatter children live under the parent, so other matches are wrong-product fallbacks.
     .filter(
-      (entry): entry is { childHref: string; childPage: PageWithChildren } =>
+      (entry): entry is { href: string; childPage: PageWithChildren } =>
         entry.childPage !== undefined &&
+        !!entry.href?.startsWith(`${pathname}/`) &&
         !entry.childPage.hidden &&
         // resolvePath can return a page from another version, which the website hides.
         (!context.currentVersion ||
@@ -57,12 +62,7 @@ export async function getAllTocItems(
     )
 
   const items = await Promise.all(
-    resolvedChildren.map(async ({ childHref, childPage }) => {
-      const childPermalink = childPage.permalinks.find(
-        (p) => p.languageCode === languageCode && p.pageVersion === context.currentVersion,
-      )
-      const href = childPermalink ? childPermalink.href : childHref
-
+    resolvedChildren.map(async ({ href, childPage }) => {
       const title = await renderPropFast(childPage, 'title', context)
       const intro = await renderPropFast(childPage, 'intro', context)
 
diff --git a/src/article-api/tests/get-all-toc-items.ts b/src/article-api/tests/get-all-toc-items.ts
index a024c3e78de5..b1021f1720be 100644
--- a/src/article-api/tests/get-all-toc-items.ts
+++ b/src/article-api/tests/get-all-toc-items.ts
@@ -100,4 +100,49 @@ describe('getAllTocItems', () => {
 
     expect(titles).toEqual(['Visible Article'])
   })
+
+  test('drops children that resolve to another product', async () => {
+    const ghes = 'enterprise-server@3.19'
+    const parent = createMockPage({
+      rawTitle: 'REST API',
+      applicableVersions: [ghes],
+      permalinks: [{ languageCode: 'en', pageVersion: ghes, href: `/en/${ghes}/rest` }],
+      children: ['/actions', '/copilot', '/codespaces'],
+    })
+    const actions = createMockPage({
+      rawTitle: 'Actions',
+      applicableVersions: [ghes],
+      permalinks: [{ languageCode: 'en', pageVersion: ghes, href: `/en/${ghes}/rest/actions` }],
+    })
+    const copilot = createMockPage({
+      rawTitle: 'GitHub Copilot documentation',
+      applicableVersions: ['free-pro-team@latest', ghes],
+      permalinks: [
+        { languageCode: 'en', pageVersion: 'free-pro-team@latest', href: '/en/copilot' },
+        { languageCode: 'en', pageVersion: ghes, href: `/en/${ghes}/copilot` },
+      ],
+    })
+    const codespaces = createMockPage({
+      rawTitle: 'GitHub Codespaces documentation',
+      applicableVersions: ['free-pro-team@latest'],
+      permalinks: [
+        { languageCode: 'en', pageVersion: 'free-pro-team@latest', href: '/en/codespaces' },
+      ],
+    })
+    const context = {
+      currentVersion: ghes,
+      pages: {
+        [`/en/${ghes}/rest`]: parent,
+        [`/en/${ghes}/rest/actions`]: actions,
+        '/en/copilot': copilot,
+        '/en/codespaces': codespaces,
+      },
+      redirects: {},
+    } as unknown as Context
+
+    const items = await getAllTocItems(parent, context)
+
+    expect(items.map((item) => item.href)).toEqual([`/en/${ghes}/rest/actions`])
+    expect(items[0].title).toBe('Actions')
+  })
 })

From 706124246aa7b6b092a51fb435b9e8dba0d03eba Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 22:36:12 +0000
Subject: [PATCH 44/71] Skip translation fallback comment when unwrapping
 titles (#64101)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 src/languages/README-translation-comments.md  |  1 +
 src/languages/lib/render-with-fallback.ts     |  5 ++-
 .../tests/translation-error-comments.ts       | 39 +++++++++++++++++++
 3 files changed, 43 insertions(+), 2 deletions(-)

diff --git a/src/languages/README-translation-comments.md b/src/languages/README-translation-comments.md
index 7e6c577f02ad..5a94c2552e66 100644
--- a/src/languages/README-translation-comments.md
+++ b/src/languages/README-translation-comments.md
@@ -86,6 +86,7 @@ Comments are added when:
 Comments are skipped for:
 - English content (no fallback needed)
 - Text-only rendering (to avoid breaking plain text output)
+- Unwrapped rendering, such as Markdown titles from the Article API (the comment would stop the outer tag from being removed)
 - Non-fallbackable errors (these throw and stop rendering)
 
 ### Error Message Sanitization
diff --git a/src/languages/lib/render-with-fallback.ts b/src/languages/lib/render-with-fallback.ts
index f863680d5b3a..641d3f878470 100644
--- a/src/languages/lib/render-with-fallback.ts
+++ b/src/languages/lib/render-with-fallback.ts
@@ -24,6 +24,7 @@ export class LiquidError extends Error {
 interface RenderOptions {
   throwIfEmpty?: boolean
   textOnly?: boolean
+  unwrap?: boolean
   cache?: boolean | ((template: string, context: Context) => string)
   [key: string]: unknown
 }
@@ -140,8 +141,8 @@ export async function renderContentWithFallback(
 
       const fallbackContent = await renderContent(englishTemplate, enContext, options)
 
-      // HTML fallback comments break textOnly output, so add them only for non-English HTML.
-      if (context.currentLanguage !== 'en' && !options?.textOnly) {
+      // HTML fallback comments break textOnly output and stop unwrap from removing the outer tag.
+      if (context.currentLanguage !== 'en' && !options?.textOnly && !options?.unwrap) {
         const errorComment = createTranslationFallbackComment(error as Error, property)
         return `${errorComment}\n${fallbackContent}`
       }
diff --git a/src/languages/tests/translation-error-comments.ts b/src/languages/tests/translation-error-comments.ts
index 790fc0562511..a08b53562be4 100644
--- a/src/languages/tests/translation-error-comments.ts
+++ b/src/languages/tests/translation-error-comments.ts
@@ -362,6 +362,45 @@ describe('Translation Error Comments', () => {
         expect(result).toBe('English Title')
       })
 
+      test('does not add comment for unwrapped rendering', async () => {
+        const mockPage = Object.create(Page.prototype)
+        mockPage.rawTitle = '{% badtag %}'
+
+        const context = {
+          currentLanguage: 'ja',
+          getEnglishPage: () => {
+            const enPage = Object.create(Page.prototype)
+            enPage.rawTitle = 'English Title'
+            return enPage
+          },
+        }
+
+        const result = await renderContentWithFallback(mockPage, 'rawTitle', context, {
+          unwrap: true,
+        })
+
+        expect(result).not.toContain('<!-- TRANSLATION_FALLBACK')
+        expect(result).toBe('<p>English Title</p>')
+      })
+
+      test('renderTitle with unwrap returns the plain English title', async () => {
+        const mockPage = Object.create(Page.prototype)
+        mockPage.rawTitle = '{% badtag %}'
+
+        const context = {
+          currentLanguage: 'ja',
+          getEnglishPage: () => {
+            const enPage = Object.create(Page.prototype)
+            enPage.rawTitle = 'English Title'
+            return enPage
+          },
+        }
+
+        const result = await mockPage.renderTitle(context, { unwrap: true })
+
+        expect(result).toBe('English Title')
+      })
+
       test('keeps fallback links in the reader language', async () => {
         const mockPage = Object.create(Page.prototype)
         mockPage.markdown = '{% badtag %} [x](/actions/foo)'

From 99d10c75a45ba121ae20b32ff70e900258127f63 Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 22:36:18 +0000
Subject: [PATCH 45/71] Validate the Copilot model release status table with
 its schema (#64155)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Co-authored-by: Hector A. <v-halfaro@github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 src/data-directory/README.md                  |  4 +-
 src/data-directory/lib/data-schemas/index.ts  |  3 ++
 .../tables/copilot/model-release-status.ts    | 40 ++++++++-----------
 3 files changed, 21 insertions(+), 26 deletions(-)

diff --git a/src/data-directory/README.md b/src/data-directory/README.md
index e1c644be9ac9..85da680e7899 100644
--- a/src/data-directory/README.md
+++ b/src/data-directory/README.md
@@ -31,7 +31,7 @@ Purpose-built utilities, schemas, and workflows that power our Liquid `{% data %
 - Tests: `src/data-directory/tests/data-schemas.ts` loads schemas via AJV and asserts every registered file validates.
 - Adding a schema:
   1. Create `src/data-directory/lib/data-schemas/<name>.ts` (or `tables/<table>.ts`).
-  2. If non-table, add to `manualSchemas` in `data-schemas/index.ts`; table schemas are auto-detected.
+  2. If non-table or nested under `data/tables/<subdir>/`, add to `manualSchemas` in `data-schemas/index.ts`. Only top-level `data/tables/*.yml` schemas are auto-detected.
   3. Run tests (see below).
 
 ## Middleware
@@ -70,7 +70,7 @@ Purpose-built utilities, schemas, and workflows that power our Liquid `{% data %
 - When adding a new data directory:
   - Prefer YAML for structured data; add schema if shape matters to correctness.
   - Add README under `data/<dir>/` when introducing new contracts.
-  - Update `manualSchemas` if not a table.
+  - Update `manualSchemas` if not a top-level table.
 
 ## Ownership & escalation
 - Primary: Docs Engineering.
diff --git a/src/data-directory/lib/data-schemas/index.ts b/src/data-directory/lib/data-schemas/index.ts
index dada87a43468..403e0efe9305 100644
--- a/src/data-directory/lib/data-schemas/index.ts
+++ b/src/data-directory/lib/data-schemas/index.ts
@@ -55,6 +55,9 @@ const manualSchemas: DataSchemas = {
   'data/tables/copilot/model-supported-plans.yml': resolveSchemaPath(
     'tables/copilot/model-supported-plans.ts',
   ),
+  'data/tables/copilot/model-release-status.yml': resolveSchemaPath(
+    'tables/copilot/model-release-status.ts',
+  ),
   'data/tables/copilot/model-comparison.yml': resolveSchemaPath(
     'tables/copilot/model-comparison.ts',
   ),
diff --git a/src/data-directory/lib/data-schemas/tables/copilot/model-release-status.ts b/src/data-directory/lib/data-schemas/tables/copilot/model-release-status.ts
index 6918f92a8903..0ea1641d7a40 100644
--- a/src/data-directory/lib/data-schemas/tables/copilot/model-release-status.ts
+++ b/src/data-directory/lib/data-schemas/tables/copilot/model-release-status.ts
@@ -1,28 +1,20 @@
 const modelsReleaseStatusSchema = {
-  type: 'object',
-  additionalProperties: false,
-  required: ['models'],
-  properties: {
-    models: {
-      type: 'object',
-      items: {
-        type: 'object',
-        additionalProperties: false,
-        required: ['name', 'provider', 'release_status'],
-        properties: {
-          name: {
-            type: 'string',
-            lintable: true,
-          },
-          provider: {
-            type: 'string',
-            enum: ['OpenAI', 'Anthropic', 'Google', 'xAI'],
-          },
-          release_status: {
-            type: 'string',
-            lintable: true,
-          },
-        },
+  type: 'array',
+  items: {
+    type: 'object',
+    additionalProperties: false,
+    required: ['name', 'provider', 'release_status'],
+    properties: {
+      name: {
+        type: 'string',
+        lintable: true,
+      },
+      provider: {
+        type: 'string',
+      },
+      release_status: {
+        type: 'string',
+        lintable: true,
       },
     },
   },

From 39767c33b870afb795469104c41924f8fd643c68 Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 22:36:24 +0000
Subject: [PATCH 46/71] Show survey email warning for short invalid input
 (#64214)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 src/events/components/Survey.tsx               |  4 ++--
 .../tests/playwright-rendering.spec.ts         | 18 ++++++++++++++++++
 2 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/src/events/components/Survey.tsx b/src/events/components/Survey.tsx
index 43f76212cdcb..0147c72aae56 100644
--- a/src/events/components/Survey.tsx
+++ b/src/events/components/Survey.tsx
@@ -185,7 +185,7 @@ export const Survey = () => {
             ></textarea>
           </p>
 
-          <div className={cx('form-group', isEmailError && email.trim().length > 3 ? 'warn' : '')}>
+          <div className={cx('form-group', isEmailError ? 'warn' : '')}>
             <label className="d-block mb-1 f6" htmlFor="survey-email">
               {t`email_label`}
             </label>
@@ -202,7 +202,7 @@ export const Survey = () => {
               aria-invalid={isEmailError}
               {...(isEmailError ? { 'aria-describedby': 'email-input-validation' } : {})}
             />
-            {isEmailError && email.trim().length > 3 && (
+            {isEmailError && (
               <p className="note warning" id="email-input-validation">
                 {t`email_validation`}
               </p>
diff --git a/src/fixtures/tests/playwright-rendering.spec.ts b/src/fixtures/tests/playwright-rendering.spec.ts
index 69ac12ff5563..fcbde08afa70 100644
--- a/src/fixtures/tests/playwright-rendering.spec.ts
+++ b/src/fixtures/tests/playwright-rendering.spec.ts
@@ -2203,6 +2203,24 @@ test.describe('survey', () => {
     expect(typesSentOnSecondHide).toContain('survey')
   })
 
+  test('short invalid email shows the warning while Send is disabled', async ({ page }) => {
+    // Install the route before interacting with the page to avoid event races.
+    await page.route('**/api/events', (route) => {
+      route.fulfill({})
+    })
+
+    await page.goto('/get-started/foo/for-playwright')
+
+    await page.locator('[for=survey-yes]').click()
+    await page.locator('[name=survey-email]').fill('no')
+    await expect(page.locator('#email-input-validation')).toBeVisible()
+    await expect(page.getByRole('button', { name: 'Send' })).toBeDisabled()
+
+    await page.locator('[name=survey-email]').fill('test@example.com')
+    await expect(page.locator('#email-input-validation')).not.toBeVisible()
+    await expect(page.getByRole('button', { name: 'Send' })).toBeEnabled()
+  })
+
   test('vote on one page, then go to another and it should reset', async ({ page }) => {
     // Install the route before interacting with the page to avoid event races.
     await page.route('**/api/events', (route) => {

From 136d6e5ecc3b278f5e9a6e4e95734f8054b47910 Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 22:36:30 +0000
Subject: [PATCH 47/71] Report broken translation frontmatter in corruption
 counts (#64221)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 .../lib/frontmatter-error-capture.ts          | 46 +++++++++++++++
 .../scripts/count-translation-corruptions.ts  | 43 +++-----------
 .../tests/frontmatter-error-capture.ts        | 59 +++++++++++++++++++
 3 files changed, 114 insertions(+), 34 deletions(-)
 create mode 100644 src/languages/lib/frontmatter-error-capture.ts
 create mode 100644 src/languages/tests/frontmatter-error-capture.ts

diff --git a/src/languages/lib/frontmatter-error-capture.ts b/src/languages/lib/frontmatter-error-capture.ts
new file mode 100644
index 000000000000..ece75072107e
--- /dev/null
+++ b/src/languages/lib/frontmatter-error-capture.ts
@@ -0,0 +1,46 @@
+export interface FrontmatterError {
+  file: string
+  message: string
+}
+
+// The structured logger prints warnings through console.log, so capture it too.
+// Nothing reaches stdout, which keeps the JSON report clean.
+export function captureConsole() {
+  const originalError = console.error
+  const originalWarn = console.warn
+  const originalLog = console.log
+  const output: string[] = []
+  const collect = (...args: unknown[]) => {
+    output.push(args.map(String).join(' '))
+  }
+  console.error = collect
+  console.warn = collect
+  console.log = collect
+  return {
+    output,
+    restore() {
+      console.error = originalError
+      console.warn = originalWarn
+      console.log = originalLog
+    },
+  }
+}
+
+// Match only the page-data.ts YAML fallback message so other logs with translation paths do not count.
+const YAML_FALLBACK_PATTERN =
+  /Unable to parse YAML frontmatter in (.+?\.md), falling back to English/
+
+export function parseFrontmatterErrors(capturedOutput: string[]): FrontmatterError[] {
+  const errors: FrontmatterError[] = []
+  const seen = new Set<string>()
+  for (const line of capturedOutput) {
+    const fullPath = line.match(YAML_FALLBACK_PATTERN)?.[1]
+    // Windows paths and logfmt escaping both add backslashes, so fold any run of them into one slash.
+    const file = fullPath?.replace(/\\+/g, '/').match(/translations\/.+$/)?.[0]
+    if (file && !seen.has(file)) {
+      seen.add(file)
+      errors.push({ file, message: 'YML parsing error' })
+    }
+  }
+  return errors
+}
diff --git a/src/languages/scripts/count-translation-corruptions.ts b/src/languages/scripts/count-translation-corruptions.ts
index c8729160f6c9..ed58816e2736 100644
--- a/src/languages/scripts/count-translation-corruptions.ts
+++ b/src/languages/scripts/count-translation-corruptions.ts
@@ -11,6 +11,11 @@ import languages from '@/languages/lib/languages-server'
 import warmServer from '@/frame/lib/warm-server'
 import type { Site } from '@/types'
 import { correctTranslatedContentStrings } from '@/languages/lib/correct-translation-content'
+import {
+  captureConsole,
+  parseFrontmatterErrors,
+  type FrontmatterError,
+} from '@/languages/lib/frontmatter-error-capture'
 
 if (import.meta.url === `file://${process.argv[1]}`) {
   program
@@ -46,11 +51,6 @@ interface LanguageResult {
   topIllegalTags: Array<{ tag: string; count: number }>
 }
 
-interface FrontmatterError {
-  file: string
-  message: string
-}
-
 interface CorruptionReport {
   hasFailures: boolean
   totalCount: number
@@ -85,18 +85,8 @@ async function main(languageCodes: string[], options: { versions?: string } = {}
   // Validate requested versions before suppressing console output, so errors stay visible.
   const versions = resolveRequestedVersions(options.versions)
 
-  // Capture warmServer frontmatter noise as structured data instead of stderr.
-  const originalError = console.error
-  const originalWarn = console.warn
-  const originalLog = console.log
-  const suppressedErrors: string[] = []
-  console.error = (...args: unknown[]) => {
-    suppressedErrors.push(args.map(String).join(' '))
-  }
-  console.warn = (...args: unknown[]) => {
-    suppressedErrors.push(args.map(String).join(' '))
-  }
-  console.log = () => {}
+  // Capture warmServer output so YAML frontmatter failures become structured data.
+  const capture = captureConsole()
 
   let langCodes: string[]
   let site: Site
@@ -119,12 +109,10 @@ async function main(languageCodes: string[], options: { versions?: string } = {}
     site = await warmServer(languageCodes.length ? ['en', ...langCodes] : [])
     reusables = getReusables()
   } finally {
-    console.error = originalError
-    console.warn = originalWarn
-    console.log = originalLog
+    capture.restore()
   }
 
-  const frontmatterErrors = parseFrontmatterErrors(suppressedErrors)
+  const frontmatterErrors = parseFrontmatterErrors(capture.output)
   const languageResults: LanguageResult[] = []
 
   for (const languageCode of langCodes) {
@@ -144,19 +132,6 @@ async function main(languageCodes: string[], options: { versions?: string } = {}
   console.log(JSON.stringify(report, null, 2))
 }
 
-function parseFrontmatterErrors(suppressedErrors: string[]): FrontmatterError[] {
-  const errors: FrontmatterError[] = []
-  const seen = new Set<string>()
-  for (const err of suppressedErrors) {
-    const match = err.match(/translations\/[^\s']+/)
-    if (match && !seen.has(match[0])) {
-      seen.add(match[0])
-      errors.push({ file: match[0], message: 'YML parsing error' })
-    }
-  }
-  return errors
-}
-
 function getReusables(): Reusables {
   const reusables = new Map()
   const files = walk('data/reusables', {
diff --git a/src/languages/tests/frontmatter-error-capture.ts b/src/languages/tests/frontmatter-error-capture.ts
new file mode 100644
index 000000000000..f0afedceb86d
--- /dev/null
+++ b/src/languages/tests/frontmatter-error-capture.ts
@@ -0,0 +1,59 @@
+import { describe, expect, test } from 'vitest'
+
+import { createLogger } from '@/observability/logger'
+import { toLogfmt } from '@/observability/logger/lib/to-logfmt'
+import { captureConsole, parseFrontmatterErrors } from '@/languages/lib/frontmatter-error-capture'
+
+const devLine =
+  '17:15:35.802 WARN  (src/frame/lib/page-data.ts) Unable to parse YAML frontmatter in /abs/translations/ja-jp/content/get-started/index.md, falling back to English. Details: bad indentation  path=get-started/index.md'
+const prodLine =
+  'timestamp=2026-10-16T00:00:00.000Z level=warn file=src/frame/lib/page-data.ts message="Unable to parse YAML frontmatter in translations/es-es/content/actions/index.md, falling back to English. Details: bad indentation" included.path=actions/index.md'
+const unrelatedLine =
+  '17:15:35.900 INFO  (src/frame/lib/warm-server.ts) Loaded pages from translations/ja-jp/content/index.md'
+
+describe('parseFrontmatterErrors', () => {
+  test('reports each YAML fallback file once with a clean path', () => {
+    expect(parseFrontmatterErrors([devLine, prodLine, devLine])).toEqual([
+      { file: 'translations/ja-jp/content/get-started/index.md', message: 'YML parsing error' },
+      { file: 'translations/es-es/content/actions/index.md', message: 'YML parsing error' },
+    ])
+  })
+
+  test('handles roots with spaces, Windows separators, and logfmt escaping', () => {
+    const fallback = (fullPath: string) =>
+      `Unable to parse YAML frontmatter in ${fullPath}, falling back to English. Details: bad indentation`
+    const spacedLine = `WARN ${fallback('/tmp/docs checkout/translations/ja-jp/content/index.md')}`
+    const windowsLine = `WARN ${fallback('C:\\docs\\translations\\ko-kr\\content\\index.md')}`
+    const logfmtLine = toLogfmt({
+      level: 'warn',
+      message: fallback('C:\\docs\\translations\\ko-kr\\content\\index.md'),
+    })
+    expect(logfmtLine).toContain('\\\\translations\\\\')
+    expect(parseFrontmatterErrors([spacedLine, windowsLine, logfmtLine])).toEqual([
+      { file: 'translations/ja-jp/content/index.md', message: 'YML parsing error' },
+      { file: 'translations/ko-kr/content/index.md', message: 'YML parsing error' },
+    ])
+  })
+
+  test('ignores other log lines that mention a translations path', () => {
+    expect(parseFrontmatterErrors([unrelatedLine])).toEqual([])
+  })
+})
+
+describe('captureConsole', () => {
+  test('collects YAML fallback warnings from the structured logger', () => {
+    const logger = createLogger('file:///repo/src/frame/lib/page-data.ts')
+    const capture = captureConsole()
+    try {
+      logger.warn(
+        'Unable to parse YAML frontmatter in translations/ja-jp/content/get-started/index.md, falling back to English. Details: bad indentation',
+        { path: 'get-started/index.md' },
+      )
+    } finally {
+      capture.restore()
+    }
+    expect(parseFrontmatterErrors(capture.output)).toEqual([
+      { file: 'translations/ja-jp/content/get-started/index.md', message: 'YML parsing error' },
+    ])
+  })
+})

From d7612f0f5f341bbfc72bef8273a7672d94d8284f Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 22:36:37 +0000
Subject: [PATCH 48/71] Run asset image validation when the validator or its
 deps change (#64228)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 .github/workflows/validate-asset-images.yml | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/.github/workflows/validate-asset-images.yml b/.github/workflows/validate-asset-images.yml
index f2e9a770c31d..495460ddc34d 100644
--- a/.github/workflows/validate-asset-images.yml
+++ b/.github/workflows/validate-asset-images.yml
@@ -8,6 +8,10 @@ on:
     paths:
       - 'assets/**'
       - '.github/workflows/validate-asset-images.yml'
+      # Dependency changes can break the validator.
+      - 'package*.json'
+      - 'src/assets/scripts/validate-asset-images.ts'
+      - '.github/actions/node-npm-setup/action.yml'
 
 permissions:
   contents: read

From 5afaa8ee888ef596ac9516c7f0bc6e56c75b0fe5 Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 22:36:44 +0000
Subject: [PATCH 49/71] Decode the Vitest @/ alias path so checkouts with
 spaces work (#64230)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 vitest.config.ts | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/vitest.config.ts b/vitest.config.ts
index b53bfef9b7e7..d30371d32893 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -1,3 +1,5 @@
+import { fileURLToPath } from 'node:url'
+
 export default {
   test: {
     // Default is `['**/*.{test,spec}.?(c|m)[jt]s?(x)']`
@@ -7,8 +9,9 @@ export default {
     watch: false,
     // vitest doesn't account for tsconfig.json `paths` settings so we have to
     // manually set this alias to resolve our TS @-imports
+    // No trailing slashes because Windows paths end in `\`, which stops Vite from stripping `/` off the key.
     alias: {
-      '@/': new URL('./src/', import.meta.url).pathname,
+      '@': fileURLToPath(new URL('./src', import.meta.url)),
     },
 
     globalSetup: './src/tests/vitest.setup.ts',

From 30a94967aa2cdd2ee719f19dfb540da5ced135d0 Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 22:54:59 +0000
Subject: [PATCH 50/71] Keep existing release note when single-issue
 regeneration fails (#64008)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 src/ghes-releases/lib/parse-release-notes.ts  | 29 +++++++++
 .../scripts/generate-release-notes.ts         | 46 +++++++-------
 .../tests/generate-release-notes.ts           | 62 +++++++++++++++++++
 3 files changed, 114 insertions(+), 23 deletions(-)

diff --git a/src/ghes-releases/lib/parse-release-notes.ts b/src/ghes-releases/lib/parse-release-notes.ts
index d68b02fa61d0..ef64a7f3698f 100644
--- a/src/ghes-releases/lib/parse-release-notes.ts
+++ b/src/ghes-releases/lib/parse-release-notes.ts
@@ -220,6 +220,35 @@ export function loadExistingEntriesFromString(content: string): {
   return { entries, coveredUrls }
 }
 
+export function isSameNoteEntry(a: NoteEntry, b: NoteEntry): boolean {
+  return (
+    a.sourceUrl === b.sourceUrl &&
+    a.heading === b.heading &&
+    a.notes.length === b.notes.length &&
+    a.notes.every((n, idx) => n === b.notes[idx])
+  )
+}
+
+// Mutate in place because the Ctrl+C flush closure holds a reference to this array.
+// With no new entries, keep the existing ones so a failed regeneration does not delete a note.
+// Returns how many unique entries were added, since agent output can repeat an entry.
+export function replaceEntriesForSource(
+  entries: NoteEntry[],
+  sourceUrl: string,
+  newEntries: NoteEntry[],
+): number {
+  if (newEntries.length === 0) return 0
+  for (let i = entries.length - 1; i >= 0; i--) {
+    if (entries[i].sourceUrl === sourceUrl) entries.splice(i, 1)
+  }
+  const unique: NoteEntry[] = []
+  for (const entry of newEntries) {
+    if (!unique.some((u) => isSameNoteEntry(u, entry))) unique.push(entry)
+  }
+  entries.push(...unique)
+  return unique.length
+}
+
 export function appendNoteLines(lines: string[], noteEntries: NoteEntry[], indent: string): void {
   for (const entry of noteEntries) {
     lines.push(`${indent}# ${entry.sourceUrl}`)
diff --git a/src/ghes-releases/scripts/generate-release-notes.ts b/src/ghes-releases/scripts/generate-release-notes.ts
index c8826c06d436..b6995c3ac2d2 100644
--- a/src/ghes-releases/scripts/generate-release-notes.ts
+++ b/src/ghes-releases/scripts/generate-release-notes.ts
@@ -21,6 +21,8 @@ import {
   extractPreservedBlocks,
   buildReleaseNotesYaml,
   appendNoteLines,
+  isSameNoteEntry,
+  replaceEntriesForSource,
 } from '@/ghes-releases/lib/parse-release-notes'
 import {
   type IssueState,
@@ -577,14 +579,12 @@ program
         preserved = extractPreservedBlocks(existingContent) ?? undefined
         const existing = loadExistingEntriesFromString(existingContent)
         if (existing.entries.length > 0) {
-          // Regenerate a single issue by dropping its previous source URL entry first.
+          // Keep the issue's current entry until the agent produces a replacement.
           if (singleIssue) {
-            const issueUrl = `https://github.com/github/releases/issues/${singleIssue}`
-            const kept = existing.entries.filter((e) => e.sourceUrl !== issueUrl)
-            allEntries.push(...kept)
-            existing.coveredUrls.delete(issueUrl)
-            existingCoveredUrls = existing.coveredUrls
-            console.log(`  Loaded ${kept.length} existing note(s), will regenerate #${singleIssue}`)
+            allEntries.push(...existing.entries)
+            console.log(
+              `  Loaded ${existing.entries.length} existing note(s), will regenerate #${singleIssue}`,
+            )
           } else {
             allEntries.push(...existing.entries)
             existingCoveredUrls = existing.coveredUrls
@@ -622,12 +622,14 @@ program
 
       const failures: { issue: ReleaseIssue; error: string }[] = []
       const existingEntryCount = allEntries.length
+      let newCount = 0
 
       const featureHeadings = loadFeatureHeadings()
 
       // Flush after each success and on Ctrl+C so long runs keep completed notes.
       const writeCurrentOutput = () => {
-        if (stdout || allEntries.length === 0) return
+        // Skip when nothing is new because rebuilding drops known issues, the date, and stacked source URL comments.
+        if (stdout || newCount === 0) return
         try {
           if (!fs.existsSync(outputDir)) {
             fs.mkdirSync(outputDir, { recursive: true })
@@ -688,17 +690,16 @@ program
             }
           }
 
-          // Avoid duplicates when an existing file already contributed the same issue note.
-          for (const entry of entries) {
-            const isDuplicate = allEntries.some(
-              (existing) =>
-                existing.sourceUrl === entry.sourceUrl &&
-                existing.heading === entry.heading &&
-                existing.notes.length === entry.notes.length &&
-                existing.notes.every((n, idx) => n === entry.notes[idx]),
-            )
-            if (!isDuplicate) {
-              allEntries.push(entry)
+          if (singleIssue) {
+            newCount += replaceEntriesForSource(allEntries, issue.url, entries)
+          } else {
+            // Avoid duplicates when an existing file already contributed the same issue note.
+            for (const entry of entries) {
+              const isDuplicate = allEntries.some((existing) => isSameNoteEntry(existing, entry))
+              if (!isDuplicate) {
+                allEntries.push(entry)
+                newCount++
+              }
             }
           }
           const retryNote = result.attempts > 1 ? ` (attempt ${result.attempts})` : ''
@@ -734,10 +735,9 @@ program
       }
 
       flushBeforeExit = null
-      const newCount = allEntries.length - existingEntryCount
       if (existingEntryCount > 0) {
         console.log(
-          `\nTotal: ${allEntries.length} note(s) (${existingEntryCount} existing + ${newCount} new from ${issues.length} issues)`,
+          `\nTotal: ${allEntries.length} note(s) (${allEntries.length - newCount} existing + ${newCount} new from ${issues.length} issues)`,
         )
       } else {
         console.log(`\nGenerated ${allEntries.length} note(s) from ${issues.length} issues`)
@@ -774,11 +774,11 @@ program
           console.log('\n--- Generated YAML ---\n')
           console.log(yamlOutput)
         }
-      } else if (allEntries.length > 0) {
+      } else if (newCount > 0) {
         writeCurrentOutput()
         console.log(`\n✅ Written to: ${path.relative(process.cwd(), outputPath)}`)
       } else {
-        console.log('\nNo entries generated — no file written.')
+        console.log('\nNo new notes generated. No file written.')
       }
 
       // Clean up stdin raw mode so the process can exit gracefully.
diff --git a/src/ghes-releases/tests/generate-release-notes.ts b/src/ghes-releases/tests/generate-release-notes.ts
index 4f66473d9ddd..53b987acf9af 100644
--- a/src/ghes-releases/tests/generate-release-notes.ts
+++ b/src/ghes-releases/tests/generate-release-notes.ts
@@ -8,6 +8,7 @@ import {
   loadExistingEntriesFromString,
   extractPreservedBlocks,
   buildReleaseNotesYaml,
+  replaceEntriesForSource,
 } from '@/ghes-releases/lib/parse-release-notes'
 
 const handEditedFile = `date: '2026-05-12'
@@ -534,3 +535,64 @@ sections:
     ])
   })
 })
+
+describe('replaceEntriesForSource', () => {
+  const urlA = 'https://github.com/github/releases/issues/1'
+  const urlB = 'https://github.com/github/releases/issues/2'
+
+  test('replaces entries for the source URL and keeps other entries and array identity', () => {
+    const entries = [
+      { heading: 'Repositories', notes: ['Old A note.'], sourceUrl: urlA },
+      { heading: 'APIs', notes: ['B note.'], sourceUrl: urlB },
+      { heading: 'Changes', notes: ['Old A change.'], sourceUrl: urlA },
+    ]
+    const original = entries
+    const added = replaceEntriesForSource(entries, urlA, [
+      { heading: 'Repositories', notes: ['New A note.'], sourceUrl: urlA },
+    ])
+
+    expect(added).toBe(1)
+    expect(entries).toBe(original)
+    expect(entries).toEqual([
+      { heading: 'APIs', notes: ['B note.'], sourceUrl: urlB },
+      { heading: 'Repositories', notes: ['New A note.'], sourceUrl: urlA },
+    ])
+  })
+
+  test('appends new entries when no existing entry matches the source URL', () => {
+    const entries = [{ heading: 'APIs', notes: ['B note.'], sourceUrl: urlB }]
+    replaceEntriesForSource(entries, urlA, [
+      { heading: 'Repositories', notes: ['A note.'], sourceUrl: urlA },
+    ])
+
+    expect(entries).toEqual([
+      { heading: 'APIs', notes: ['B note.'], sourceUrl: urlB },
+      { heading: 'Repositories', notes: ['A note.'], sourceUrl: urlA },
+    ])
+  })
+
+  test('keeps existing entries when there are no new entries', () => {
+    const entries = [
+      { heading: 'Repositories', notes: ['Old A note.'], sourceUrl: urlA },
+      { heading: 'APIs', notes: ['B note.'], sourceUrl: urlB },
+    ]
+    expect(replaceEntriesForSource(entries, urlA, [])).toBe(0)
+
+    expect(entries).toEqual([
+      { heading: 'Repositories', notes: ['Old A note.'], sourceUrl: urlA },
+      { heading: 'APIs', notes: ['B note.'], sourceUrl: urlB },
+    ])
+    const yaml = buildReleaseNotesYaml(entries, false, ['Repositories', 'APIs'])
+    expect(yaml).toContain(`# ${urlA}`)
+    expect(yaml).toContain('Old A note.')
+  })
+
+  test('adds identical new entries only once', () => {
+    const entries = [{ heading: 'Repositories', notes: ['Old A note.'], sourceUrl: urlA }]
+    const repeated = { heading: 'Repositories', notes: ['New A note.'], sourceUrl: urlA }
+    const added = replaceEntriesForSource(entries, urlA, [repeated, { ...repeated }])
+
+    expect(added).toBe(1)
+    expect(entries).toEqual([repeated])
+  })
+})

From b3dbab929c25a63d2fedc09242564b975590c23f Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 22:55:07 +0000
Subject: [PATCH 51/71] Keep query strings when redirecting URLs with double
 slashes (#64098)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 src/frame/middleware/trailing-slashes.ts     |  7 +-
 src/frame/tests/trailing-slashes.ts          | 69 ++++++++++++++++++++
 src/redirects/middleware/handle-redirects.ts |  6 +-
 src/redirects/tests/redirects.ts             |  7 ++
 src/redirects/tests/unit/handle-redirects.ts | 41 ++++++++++++
 5 files changed, 126 insertions(+), 4 deletions(-)
 create mode 100644 src/frame/tests/trailing-slashes.ts

diff --git a/src/frame/middleware/trailing-slashes.ts b/src/frame/middleware/trailing-slashes.ts
index cd80572031b9..0a0f6bd52453 100644
--- a/src/frame/middleware/trailing-slashes.ts
+++ b/src/frame/middleware/trailing-slashes.ts
@@ -11,12 +11,13 @@ export default function trailingSlashes(req: ExtendedRequest, res: Response, nex
       while (pathname.endsWith('/')) {
         pathname = pathname.slice(0, pathname.length - 1)
       }
-      let url = pathname
+      // An empty Location resolves to the same URL, so a path of only slashes goes to the homepage.
+      if (!pathname) pathname = '/'
+      // Collapse repeated slashes in the path only, because query values can contain //.
+      let url = pathname.replace(/\/+/g, '/')
       if (split.length) {
         url += `?${split.join('?')}`
       }
-      // Collapse repeated slashes so the redirect points to one canonical URL.
-      url = url.replace(/\/+/g, '/')
       defaultCacheControl(res)
       return res.safeRedirect(301, url)
     }
diff --git a/src/frame/tests/trailing-slashes.ts b/src/frame/tests/trailing-slashes.ts
new file mode 100644
index 000000000000..0204ced3a551
--- /dev/null
+++ b/src/frame/tests/trailing-slashes.ts
@@ -0,0 +1,69 @@
+import { describe, expect, test } from 'vitest'
+import type { Response } from 'express'
+
+import trailingSlashes from '@/frame/middleware/trailing-slashes'
+import { safeRedirectUrl } from '@/frame/middleware/safe-redirect'
+import type { ExtendedRequest } from '@/types'
+
+function run(url: string) {
+  const req = { method: 'GET', url } as ExtendedRequest
+  const headers: Record<string, string> = {}
+  const result: { status?: number; location?: string; nextCalled: boolean } = {
+    nextCalled: false,
+  }
+  const res = {
+    set(key: string, value: string) {
+      headers[key.toLowerCase()] = value
+      return this
+    },
+    hasHeader(key: string) {
+      return key.toLowerCase() in headers
+    },
+    safeRedirect(status: number, location: string) {
+      result.status = status
+      result.location = safeRedirectUrl(location)
+    },
+  } as unknown as Response
+  trailingSlashes(req, res, () => {
+    result.nextCalled = true
+  })
+  return { ...result, headers }
+}
+
+describe('trailingSlashes middleware', () => {
+  test('redirects a path of only slashes to the homepage', () => {
+    const result = run('//')
+    expect(result.status).toBe(301)
+    expect(result.location).toBe('/')
+    expect(result.headers['cache-control']).toMatch(/max-age=\d+/)
+  })
+
+  test('keeps the query string when redirecting a path of only slashes', () => {
+    const result = run('//?foo=1')
+    expect(result.status).toBe(301)
+    expect(result.location).toBe('/?foo=1')
+  })
+
+  test('keeps double slashes inside query values', () => {
+    expect(run('//?next=https://github.com').location).toBe('/?next=https://github.com')
+    expect(run('/en//search/?query=a//b').location).toBe('/en/search?query=a//b')
+  })
+
+  test('removes a trailing slash and keeps the query string', () => {
+    const result = run('/foo/?a=1')
+    expect(result.status).toBe(301)
+    expect(result.location).toBe('/foo?a=1')
+  })
+
+  test('removes trailing double slashes', () => {
+    const result = run('/en//')
+    expect(result.status).toBe(301)
+    expect(result.location).toBe('/en')
+  })
+
+  test('calls next for the homepage', () => {
+    const result = run('/')
+    expect(result.nextCalled).toBe(true)
+    expect(result.status).toBeUndefined()
+  })
+})
diff --git a/src/redirects/middleware/handle-redirects.ts b/src/redirects/middleware/handle-redirects.ts
index 9cbef19ad591..4b4a8f3570ef 100644
--- a/src/redirects/middleware/handle-redirects.ts
+++ b/src/redirects/middleware/handle-redirects.ts
@@ -27,7 +27,11 @@ export default function handleRedirects(req: ExtendedRequest, res: Response, nex
 
   // Collapse duplicate slashes before patterns.assetPaths, so //example.com cannot bypass handling.
   if (req.path.includes('//')) {
-    return res.safeRedirect(301, req.path.replace(/\/+/g, '/'))
+    // Take only the query from req.url, because an absolute-form req.url also holds the scheme and host.
+    const queryIndex = req.url.indexOf('?')
+    const query = queryIndex === -1 ? '' : req.url.slice(queryIndex)
+    defaultCacheControl(res)
+    return res.safeRedirect(301, req.path.replace(/\/+/g, '/') + query)
   }
 
   if (patterns.assetPaths.test(req.path)) return next()
diff --git a/src/redirects/tests/redirects.ts b/src/redirects/tests/redirects.ts
index c459044dc01a..9c87a3c83379 100644
--- a/src/redirects/tests/redirects.ts
+++ b/src/redirects/tests/redirects.ts
@@ -456,6 +456,13 @@ describe('redirects', () => {
       expect(res.headers.location).toBe(`/en/rest`)
     })
 
+    test('double-slash in the URL keeps the query string', async () => {
+      const res = await get(`/en//search?query=git`)
+      expect(res.statusCode).toBe(301)
+      expect(res.headers.location).toBe(`/en/search?query=git`)
+      expect(res.headers['cache-control']).toMatch(/max-age=\d+/)
+    })
+
     test('double-slash trailing in the URL', async () => {
       const res = await get(`/en//`)
       expect(res.statusCode).toBe(301)
diff --git a/src/redirects/tests/unit/handle-redirects.ts b/src/redirects/tests/unit/handle-redirects.ts
index d37c803d5910..b9fc62866957 100644
--- a/src/redirects/tests/unit/handle-redirects.ts
+++ b/src/redirects/tests/unit/handle-redirects.ts
@@ -2,6 +2,7 @@ import { describe, expect, test } from 'vitest'
 import type { NextFunction, Response } from 'express'
 
 import handleRedirects from '@/redirects/middleware/handle-redirects'
+import { safeRedirectUrl } from '@/frame/middleware/safe-redirect'
 import type { Context, ExtendedRequest } from '@/types'
 
 type TestResponse = {
@@ -100,3 +101,43 @@ describe('handleRedirects with :// in the query string', () => {
     expect(result.location).toBe('https://example.com/docs?ref=abc')
   })
 })
+
+function runWithPath(url: string, path: string) {
+  const req = { method: 'GET', url, path, context: {} } as unknown as ExtendedRequest
+  const headers: Record<string, string> = {}
+  const result: { status?: number; location?: string } = {}
+  const res = {
+    set(key: string, value: string) {
+      headers[key.toLowerCase()] = value
+      return this
+    },
+    hasHeader(key: string) {
+      return key.toLowerCase() in headers
+    },
+    safeRedirect(status: number, location: string) {
+      result.status = status
+      result.location = safeRedirectUrl(location)
+    },
+  } as unknown as Response
+  handleRedirects(req, res, () => {})
+  return { ...result, headers }
+}
+
+describe('handleRedirects double slashes', () => {
+  test('collapses slashes in the path and keeps the query string', () => {
+    const result = runWithPath('/en//search?query=git', '/en//search')
+    expect(result.status).toBe(301)
+    expect(result.location).toBe('/en/search?query=git')
+    expect(result.headers['cache-control']).toMatch(/max-age=\d+/)
+  })
+
+  test('keeps double slashes inside query values', () => {
+    const result = runWithPath('/en//search?query=a//b', '/en//search')
+    expect(result.location).toBe('/en/search?query=a//b')
+  })
+
+  test('stays origin-relative for an absolute-form request target', () => {
+    const result = runWithPath('https://docs.github.com/en//search?query=git', '/en//search')
+    expect(result.location).toBe('/en/search?query=git')
+  })
+})

From 9adb39b8c40ddceb0ecd0c78a228bf0113ea8f87 Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 22:55:13 +0000
Subject: [PATCH 52/71] Count a newer production build as a match when waiting
 for a deploy (#64231)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 .github/workflows/purge-fastly.yml            |  2 +
 src/workflows/purge-fastly-changed-content.ts |  4 +-
 .../tests/purge-fastly-changed-content.ts     | 14 +++++
 src/workflows/tests/wait-for-build.ts         | 51 +++++++++++++++++++
 src/workflows/wait-for-build.ts               | 35 +++++++++++++
 5 files changed, 105 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/purge-fastly.yml b/.github/workflows/purge-fastly.yml
index 1e350232c7a5..4d3422023e28 100644
--- a/.github/workflows/purge-fastly.yml
+++ b/.github/workflows/purge-fastly.yml
@@ -65,6 +65,8 @@ jobs:
 
       - name: Wait for production to serve this build
         if: ${{ github.event_name == 'deployment_status' }}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: npm run wait-for-build
 
       - name: Purge Fastly (manual)
diff --git a/src/workflows/purge-fastly-changed-content.ts b/src/workflows/purge-fastly-changed-content.ts
index 98d60b5f78e8..688989e6c9ae 100644
--- a/src/workflows/purge-fastly-changed-content.ts
+++ b/src/workflows/purge-fastly-changed-content.ts
@@ -113,7 +113,9 @@ export async function resolvePreviousProductionSha(
     per_page: 30,
   })
 
-  for (const deployment of deployments) {
+  // A newer deploy can succeed before this run resolves its base, so search only older entries.
+  const headIndex = deployments.findIndex((deployment) => deployment.sha === headSha)
+  for (const deployment of deployments.slice(headIndex + 1)) {
     if (deployment.sha === headSha) continue
     const { data: statuses } = await octokit.rest.repos.listDeploymentStatuses({
       owner,
diff --git a/src/workflows/tests/purge-fastly-changed-content.ts b/src/workflows/tests/purge-fastly-changed-content.ts
index 91b26b1ca876..f598b92810fe 100644
--- a/src/workflows/tests/purge-fastly-changed-content.ts
+++ b/src/workflows/tests/purge-fastly-changed-content.ts
@@ -63,6 +63,20 @@ describe('resolvePreviousProductionSha', () => {
     )
   })
 
+  test('ignores a newer deployment that succeeded after the head deployment', async () => {
+    const octokit = makeOctokit(
+      [
+        { id: 4, sha: 'newer' },
+        { id: 3, sha: 'head' },
+        { id: 2, sha: 'prev' },
+      ],
+      { 4: ['success'], 3: ['success'], 2: ['success', 'inactive'] },
+    )
+    expect(await resolvePreviousProductionSha(octokit, 'github', 'docs-internal', 'head')).toBe(
+      'prev',
+    )
+  })
+
   test('skips deployments matching the head sha', async () => {
     const octokit = makeOctokit([{ id: 3, sha: 'head' }], { 3: ['success'] })
     expect(
diff --git a/src/workflows/tests/wait-for-build.ts b/src/workflows/tests/wait-for-build.ts
index 7dd0b15dfab9..b34a38714e6f 100644
--- a/src/workflows/tests/wait-for-build.ts
+++ b/src/workflows/tests/wait-for-build.ts
@@ -10,6 +10,15 @@ vi.mock('node:child_process', () => ({
   execFileSync: (...args: unknown[]) => execFileSync(...args),
 }))
 
+const compareCommitsWithBasehead = vi.fn()
+vi.mock('../github', () => ({
+  default: () => ({ rest: { repos: { compareCommitsWithBasehead } } }),
+}))
+
+vi.mock('../action-context', () => ({
+  getActionContext: () => ({ owner: 'github', repo: 'docs-internal' }),
+}))
+
 const { waitForBuild } = await import('../wait-for-build')
 
 // The build endpoint returns the deployed sha as plain text.
@@ -19,6 +28,7 @@ function serves(sha: string) {
 
 beforeEach(() => {
   execFileSync.mockReturnValue('deployed-sha\n')
+  compareCommitsWithBasehead.mockResolvedValue({ data: { status: 'behind' } })
   vi.spyOn(console, 'log').mockImplementation(() => {})
 })
 
@@ -59,6 +69,47 @@ describe('waitForBuild', () => {
     expect(fetchWithRetry).toHaveBeenCalledTimes(4)
   })
 
+  test('counts a newer production build that contains this commit as a match', async () => {
+    // A back-to-back deploy can replace this build before the streak completes.
+    fetchWithRetry.mockResolvedValue(serves('newer-sha'))
+    compareCommitsWithBasehead.mockResolvedValue({ data: { status: 'ahead' } })
+
+    await waitForBuild({ requiredMatches: 3, intervalMs: 0, timeoutMs: 1000 })
+
+    expect(fetchWithRetry).toHaveBeenCalledTimes(3)
+    expect(compareCommitsWithBasehead).toHaveBeenCalledTimes(1)
+    expect(compareCommitsWithBasehead).toHaveBeenCalledWith({
+      owner: 'github',
+      repo: 'docs-internal',
+      basehead: 'deployed-sha...newer-sha',
+    })
+  })
+
+  test('compares each distinct production sha only once', async () => {
+    fetchWithRetry
+      .mockResolvedValueOnce(serves('older-sha'))
+      .mockResolvedValueOnce(serves('older-sha'))
+      .mockResolvedValueOnce(serves('older-sha'))
+      .mockResolvedValue(serves('deployed-sha'))
+
+    await waitForBuild({ requiredMatches: 2, intervalMs: 0 })
+
+    expect(fetchWithRetry).toHaveBeenCalledTimes(5)
+    expect(compareCommitsWithBasehead).toHaveBeenCalledTimes(1)
+    expect(compareCommitsWithBasehead.mock.calls[0][0].basehead).toBe('deployed-sha...older-sha')
+  })
+
+  test('treats a failed commit comparison as a non-match', async () => {
+    fetchWithRetry
+      .mockResolvedValueOnce(serves('newer-sha'))
+      .mockResolvedValue(serves('deployed-sha'))
+    compareCommitsWithBasehead.mockRejectedValue(new Error('API down'))
+
+    await waitForBuild({ requiredMatches: 1, intervalMs: 0 })
+
+    expect(fetchWithRetry).toHaveBeenCalledTimes(2)
+  })
+
   test('treats a non-ok response as a non-match', async () => {
     fetchWithRetry
       .mockResolvedValueOnce({ ok: false, text: async () => 'deployed-sha' })
diff --git a/src/workflows/wait-for-build.ts b/src/workflows/wait-for-build.ts
index 117c32da24fd..b1aa1fc93d34 100644
--- a/src/workflows/wait-for-build.ts
+++ b/src/workflows/wait-for-build.ts
@@ -3,6 +3,8 @@ import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 
 import { fetchWithRetry } from '@/frame/lib/fetch-utils'
+import github from './github'
+import { getActionContext } from './action-context'
 
 // Polls production until it serves the current commit, then exits. The post-deploy
 // content purge waits on this so it doesn't evict pages before the new build is live.
@@ -15,6 +17,24 @@ const TIMEOUT = 1200 * 1000
 
 const sleep = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms))
 
+// Back-to-back merge queue deploys can replace this build before the wait finishes.
+// A newer build that contains this commit serves its changes, so it counts as a match.
+// Returns undefined when the comparison fails so the caller can retry on a later poll.
+async function containsCommit(needs: string, current: string): Promise<boolean | undefined> {
+  try {
+    const { owner, repo } = getActionContext()
+    const { data } = await github().rest.repos.compareCommitsWithBasehead({
+      owner,
+      repo,
+      basehead: `${needs}...${current}`,
+    })
+    return data.status === 'ahead'
+  } catch (error) {
+    console.log(`Could not compare ${current} with the build commit: ${error}`)
+    return undefined
+  }
+}
+
 type WaitForBuildOptions = {
   requiredMatches?: number
   intervalMs?: number
@@ -29,6 +49,7 @@ export async function waitForBuild({
   const needs = execFileSync('git', ['rev-parse', 'HEAD']).toString().trim()
   const startTime = Date.now()
   let consecutive = 0
+  const containsByCommit = new Map<string, boolean>()
 
   console.log(`Waiting for production to serve build ${needs}...`)
 
@@ -54,9 +75,23 @@ export async function waitForBuild({
       current = ''
     }
 
+    let newer = false
+    if (current && current !== needs) {
+      if (!containsByCommit.has(current)) {
+        const contains = await containsCommit(needs, current)
+        if (contains !== undefined) containsByCommit.set(current, contains)
+      }
+      newer = containsByCommit.get(current) === true
+    }
+
     if (current && current === needs) {
       consecutive += 1
       console.log(`Production matches the build commit (${consecutive}/${requiredMatches})...`)
+    } else if (newer) {
+      consecutive += 1
+      console.log(
+        `Production serves newer commit ${current}, which includes the build commit (${consecutive}/${requiredMatches})...`,
+      )
     } else {
       if (consecutive > 0) {
         console.log('Production stopped matching the build commit; resetting consecutive count...')

From b85dd0c26aa83581630ec5585c72499c60632fff Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 22:55:19 +0000
Subject: [PATCH 53/71] Skip whitespace-only image alt text in GHD031 (#64233)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 .../linting-rules/image-alt-text-exclude-start-words.ts   | 8 ++++----
 .../tests/unit/image-alt-text-exclude-start-words.ts      | 6 ++++++
 2 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/src/content-linter/lib/linting-rules/image-alt-text-exclude-start-words.ts b/src/content-linter/lib/linting-rules/image-alt-text-exclude-start-words.ts
index b4ecea14d1a4..77b04477cb64 100644
--- a/src/content-linter/lib/linting-rules/image-alt-text-exclude-start-words.ts
+++ b/src/content-linter/lib/linting-rules/image-alt-text-exclude-start-words.ts
@@ -12,15 +12,15 @@ export const imageAltTextExcludeStartWords: Rule = {
   parser: 'markdownit',
   function: (params: RuleParams, onError: RuleErrorCallback) => {
     forEachInlineChild(params, 'image', function forToken(token: MarkdownToken) {
-      // Empty alt text belongs to image-alt-text-length and cannot produce a range.
-      if (!token.content) return
+      const imageAltText = token.content?.trim()
 
-      const imageAltText = token.content.trim()
+      // Empty alt text belongs to image-alt-text-length and cannot produce a range.
+      if (!imageAltText) return
 
-      const range = getRange(token.line, imageAltText)
       if (
         excludeStartWords.some((excludeWord) => imageAltText.toLowerCase().startsWith(excludeWord))
       ) {
+        const range = getRange(token.line, imageAltText)
         addError(
           onError,
           token.lineNumber,
diff --git a/src/content-linter/tests/unit/image-alt-text-exclude-start-words.ts b/src/content-linter/tests/unit/image-alt-text-exclude-start-words.ts
index b63b6674828b..3194768fb143 100644
--- a/src/content-linter/tests/unit/image-alt-text-exclude-start-words.ts
+++ b/src/content-linter/tests/unit/image-alt-text-exclude-start-words.ts
@@ -41,4 +41,10 @@ describe(imageAltTextExcludeStartWords.names.join(' - '), () => {
     const errors = result.markdown
     expect(errors.length).toBe(0)
   })
+  test('image alt text that is only whitespace', async () => {
+    const markdown = ['![ ](/images/x.png)', '![\t](/images/x.png)'].join('\n')
+    const result = await runRule(imageAltTextExcludeStartWords, { strings: { markdown } })
+    const errors = result.markdown
+    expect(errors.length).toBe(0)
+  })
 })

From 93743e28233a8c0d5901acbe3d8699e028ed5d09 Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 22:55:25 +0000
Subject: [PATCH 54/71] Keep custom link text in YAML strings when setting
 AUTOTITLE (#64234)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 src/links/lib/update-internal-links.ts        | 42 ++++++++++++++++++-
 src/links/tests/update-internal-links-yaml.ts | 42 ++++++++++++++++++-
 2 files changed, 80 insertions(+), 4 deletions(-)

diff --git a/src/links/lib/update-internal-links.ts b/src/links/lib/update-internal-links.ts
index 550e24e2568c..cb77b4ce622d 100644
--- a/src/links/lib/update-internal-links.ts
+++ b/src/links/lib/update-internal-links.ts
@@ -139,6 +139,7 @@ export async function updateFile(file: string, context: LinkContext, opts: typeo
   const parseSource = isYaml ? dedentLines(source) : source
   const lineStarts = buildLineStarts(source)
   const indents = isYaml ? source.split('\n').map((line) => /^[ \t]*/.exec(line)![0].length) : null
+  const blockScalarLines = isYaml ? findBlockScalarLines(source) : null
 
   // Report original columns by adding YAML indentation back onto the dedented parse.
   function sourceColumn(node: Nodes): number | undefined {
@@ -255,7 +256,13 @@ export async function updateFile(file: string, context: LinkContext, opts: typeo
       let baseHref = node.url
       let fragment: CarriedFragment | undefined
 
-      const hasQuotesAroundLink = content.includes(`"${asMarkdown}`)
+      const span = sourceSpan(node, asMarkdown)
+      const inYamlStructure =
+        blockScalarLines !== null && !blockScalarLines[(node.position?.start.line ?? 1) - 1]
+      // Without a source range, fall back to searching the whole file for a quoted copy.
+      const hasQuotesAroundLink = span
+        ? hasProseQuoteBefore(source, span[0], inYamlStructure)
+        : content.includes(`"${asMarkdown}`)
 
       const xValue = (node.children[0] as { value?: string } | undefined)?.value
 
@@ -305,7 +312,7 @@ export async function updateFile(file: string, context: LinkContext, opts: typeo
         baseHref,
         makeMarkdown: (href) => `[${newTitle}](${href})`,
         fragment,
-        span: sourceSpan(node, asMarkdown),
+        span,
       })
     } else if (opts.verbose) {
       logger.warn('Unable to find link as Markdown in the source content', {
@@ -407,6 +414,37 @@ function dedentLines(content: string): string {
     .join('\n')
 }
 
+// YAML requires quotes around a scalar that starts with '[', so a quote that opens the value is syntax.
+function hasProseQuoteBefore(source: string, start: number, inYamlStructure: boolean): boolean {
+  if (source[start - 1] !== '"') return false
+  if (!inYamlStructure) return true
+  const lineStart = source.lastIndexOf('\n', start - 1) + 1
+  return !/^\s*(?:-\s+)?(?:[\w.-]+:\s+)?$/.test(source.slice(lineStart, start - 1))
+}
+
+// Lines inside YAML | and > block scalars are Markdown text, so a quote there is never YAML syntax.
+function findBlockScalarLines(source: string): boolean[] {
+  const lines = source.split('\n')
+  const inside = lines.map(() => false)
+  // Block scalar content continues while lines are blank or indented past the parent key or dash.
+  let parentIndent = -1
+  for (const [i, line] of lines.entries()) {
+    if (parentIndent >= 0 && (line.trim() === '' || /^ */.exec(line)![0].length > parentIndent)) {
+      inside[i] = true
+      continue
+    }
+    parentIndent = -1
+    if (line.trimStart().startsWith('#')) continue
+    if (!/(?:^\s*-|:)\s+[|>](?:[1-9][+-]?|[+-][1-9]?)?\s*(?:#.*)?$/.test(line)) continue
+    const prefix = /^\s*(?:-\s+)*/.exec(line)![0]
+    // A sequence item like '- |' nests its content under the dash, not under the text after it.
+    parentIndent = /^[|>]/.test(line.slice(prefix.length))
+      ? prefix.trimEnd().length - 1
+      : prefix.length
+  }
+  return inside
+}
+
 function buildLineStarts(content: string): number[] {
   const starts = [0]
   for (let i = 0; i < content.length; i++) {
diff --git a/src/links/tests/update-internal-links-yaml.ts b/src/links/tests/update-internal-links-yaml.ts
index 08d0ec3a8806..ee6120c95895 100644
--- a/src/links/tests/update-internal-links-yaml.ts
+++ b/src/links/tests/update-internal-links-yaml.ts
@@ -101,12 +101,12 @@ describe('rewriting links in YAML', () => {
     keepStaleFragments: false,
   }
 
-  async function run(yaml: string) {
+  async function run(yaml: string, overrides: Partial<typeof opts> = {}) {
     const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'codemod-yaml-'))
     const file = path.join(dir, 'notes.yml')
     fs.writeFileSync(file, yaml)
     try {
-      return await updateFile(file, context, opts)
+      return await updateFile(file, context, { ...opts, ...overrides })
     } finally {
       fs.rmSync(dir, { recursive: true, force: true })
     }
@@ -169,6 +169,44 @@ sections:
     expect(result.newContent!.match(/\/admin\/old-path/g)).toHaveLength(1)
   })
 
+  test('sets AUTOTITLE only on links inside prose quotes, not YAML string quotes', async () => {
+    const yaml = `rows:
+  - action: "[Custom text](/admin/new-path)"
+  - note: |
+      See "[Other](/admin/new-path)" here, or [Other](/admin/new-path) inline.
+`
+    const result = await run(yaml, { setAutotitle: true })
+    expect(result.newContent).toBe(`rows:
+  - action: "[Custom text](/admin/new-path)"
+  - note: |
+      See "[AUTOTITLE](/admin/new-path)" here, or [Other](/admin/new-path) inline.
+`)
+  })
+
+  test('sets AUTOTITLE on prose quotes that start a line inside YAML block scalars', async () => {
+    const yaml = `rows:
+  - note: |
+      "[Other](/admin/new-path)" has details.
+      - "[Other](/admin/new-path)" in a list.
+      See: "[Other](/admin/new-path)" for more.
+    action: "[Custom text](/admin/new-path)"
+  - >-
+    "[Other](/admin/new-path)" folded.
+  - "[Custom text](/admin/new-path)"
+`
+    const result = await run(yaml, { setAutotitle: true })
+    expect(result.newContent).toBe(`rows:
+  - note: |
+      "[AUTOTITLE](/admin/new-path)" has details.
+      - "[AUTOTITLE](/admin/new-path)" in a list.
+      See: "[AUTOTITLE](/admin/new-path)" for more.
+    action: "[Custom text](/admin/new-path)"
+  - >-
+    "[AUTOTITLE](/admin/new-path)" folded.
+  - "[Custom text](/admin/new-path)"
+`)
+  })
+
   test('preserves every byte that is not a rewritten link', async () => {
     const yaml = `date: '2026-01-15'
 sections:

From 3831b0ec487b7823df64784a04c62ad313fe993d Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 22:55:32 +0000
Subject: [PATCH 55/71] Fix GitHub CLI example for uploading a release asset
 (#64241)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
Copilot-Session: fb5d8be8-479c-4950-8197-ef0220dbdcb0
---
 src/rest/components/get-rest-code-samples.ts | 16 ++++-
 src/rest/tests/get-rest-code-samples-2.ts    | 71 ++++++++++++++++++++
 2 files changed, 84 insertions(+), 3 deletions(-)

diff --git a/src/rest/components/get-rest-code-samples.ts b/src/rest/components/get-rest-code-samples.ts
index 74ee7cd3296d..3e8560a5b358 100644
--- a/src/rest/components/get-rest-code-samples.ts
+++ b/src/rest/components/get-rest-code-samples.ts
@@ -121,7 +121,10 @@ export function getGHExample(
   if (operation?.progAccess?.basicAuth) return
 
   const defaultAcceptHeader = getAcceptHeader(codeSample)
-  const hostname = operation.serverUrl !== 'https://api.github.com' ? '--hostname HOSTNAME' : ''
+  // Scalar bodies are file uploads that must go to the upload server URL, not the API host.
+  const isFileUpload = typeof codeSample.request.bodyParameters === 'string'
+  const hostname =
+    !isFileUpload && operation.serverUrl !== 'https://api.github.com' ? '--hostname HOSTNAME' : ''
 
   let requestPath = codeSample?.request?.parameters
     ? parseTemplate(operation.requestPath).expand(codeSample.request.parameters)
@@ -135,8 +138,11 @@ export function getGHExample(
 
   const requiredQueryParams = getRequiredQueryParamsPath(operation, codeSample)
   requestPath += requiredQueryParams ? `?${requiredQueryParams}` : ''
-  // Quote paths containing ? so shells don't expand it as a glob or split on &.
-  if (requestPath.includes('?')) {
+  if (isFileUpload) {
+    requestPath = `${operation.serverUrl}${requestPath}`
+  }
+  // Quote upload URLs and paths containing ? so shells don't expand it as a glob or split on &.
+  if (isFileUpload || requestPath.includes('?')) {
     requestPath = `"${requestPath}"`
   }
 
@@ -167,6 +173,8 @@ export function getGHExample(
       } else {
         requestBodyParams += handleObjectParameter(bodyParameters as NestedObjectParameter)
       }
+    } else if (isFileUpload) {
+      requestBodyParams = `--input ${(bodyParameters as string).replace(/^@/, '')}`
     } else {
       requestBodyParams += handleSingleParameter('', bodyParameters as NestedObjectParameter)
     }
@@ -176,6 +184,8 @@ export function getGHExample(
     operation.verb !== 'get' && `--method ${operation.verb.toUpperCase()}`,
     `-H "Accept: ${defaultAcceptHeader}"`,
     apiVersionHeader,
+    isFileUpload &&
+      `-H "Content-Type: ${codeSample.request.contentType || 'application/octet-stream'}"`,
     hostname,
     requestPath,
     requestBodyParams,
diff --git a/src/rest/tests/get-rest-code-samples-2.ts b/src/rest/tests/get-rest-code-samples-2.ts
index 4565996826e8..a4a56a7368c5 100644
--- a/src/rest/tests/get-rest-code-samples-2.ts
+++ b/src/rest/tests/get-rest-code-samples-2.ts
@@ -438,6 +438,77 @@ describe('REST code samples authentication header handling', () => {
 
       expect(result).toContain('--hostname HOSTNAME')
     })
+
+    const uploadAssetOperation: Operation = {
+      ...standardOperation,
+      title: 'Upload a release asset',
+      requestPath: '/repos/{owner}/{repo}/releases/{release_id}/assets',
+      serverUrl: 'https://uploads.github.com',
+      category: 'releases',
+      subcategory: 'assets',
+      parameters: [
+        {
+          name: 'name',
+          in: 'query',
+          required: true,
+          description: '',
+          schema: { type: 'string' },
+        },
+      ],
+    }
+
+    const uploadAssetCodeSample = {
+      key: 'default',
+      request: {
+        contentType: 'application/octet-stream',
+        acceptHeader: 'application/vnd.github.v3+json',
+        bodyParameters: '@example.zip',
+        parameters: { owner: 'OWNER', repo: 'REPO', release_id: 'RELEASE_ID' },
+        description: 'Example',
+      },
+      response: {
+        contentType: 'application/json',
+        description: 'Response',
+        example: { name: 'example.zip' },
+        statusCode: '201',
+      },
+    } as unknown as CodeSample
+
+    test('uploads a binary file body with --input to the full upload URL', () => {
+      const result = getGHExample(
+        uploadAssetOperation,
+        uploadAssetCodeSample,
+        'free-pro-team@latest',
+        mockVersions,
+      )
+
+      expect(result).toContain(
+        '"https://uploads.github.com/repos/OWNER/REPO/releases/RELEASE_ID/assets?name=example.zip"',
+      )
+      expect(result).toContain('-H "Content-Type: application/octet-stream"')
+      expect(result).toContain('--input example.zip')
+      expect(result).not.toContain('--hostname')
+      expect(result).not.toContain("-f '@")
+    })
+
+    test('uses the GHES upload URL for binary file bodies', () => {
+      const ghesUploadOperation = {
+        ...uploadAssetOperation,
+        serverUrl: 'https://HOSTNAME/api/uploads',
+      }
+      const result = getGHExample(
+        ghesUploadOperation,
+        uploadAssetCodeSample,
+        'enterprise-server@3.17',
+        mockVersions,
+      )
+
+      expect(result).toContain(
+        '"https://HOSTNAME/api/uploads/repos/OWNER/REPO/releases/RELEASE_ID/assets?name=example.zip"',
+      )
+      expect(result).toContain('--input example.zip')
+      expect(result).not.toContain('--hostname')
+    })
   })
 
   describe('getJSExample', () => {

From 4dfff0bad210777f09157be8162a5e1262a27b19 Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 22:55:38 +0000
Subject: [PATCH 56/71] Show deprecation notices for deprecated GraphQL enum
 values (#64242)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 .../templates/graphql-reference.template.md   |  2 +-
 .../graphql-reference-transformer.ts          |  4 +++
 src/graphql/components/Enum.tsx               |  6 +++-
 src/graphql/components/Notice.tsx             |  2 +-
 src/graphql/components/types.tsx              |  2 ++
 src/graphql/lib/validator.ts                  |  6 ++++
 src/graphql/scripts/utils/process-schemas.ts  |  7 ++++
 src/graphql/tests/enum-value-deprecation.ts   | 33 +++++++++++++++++++
 8 files changed, 59 insertions(+), 3 deletions(-)
 create mode 100644 src/graphql/tests/enum-value-deprecation.ts

diff --git a/src/article-api/templates/graphql-reference.template.md b/src/article-api/templates/graphql-reference.template.md
index 1f054b5d8ff8..8413cecfc6d2 100644
--- a/src/article-api/templates/graphql-reference.template.md
+++ b/src/article-api/templates/graphql-reference.template.md
@@ -84,7 +84,7 @@
 
 ### Values for `{{ item.name }}`
 
-{% for value in item.values %}* `{{ value.name }}`: {{ value.description }}
+{% for value in item.values %}* `{{ value.name }}`: {{ value.description }}{% if value.isDeprecated %} **Deprecated:** {{ value.deprecationReason }}{% endif %}
 {% endfor %}
 {% endif %}
 
diff --git a/src/article-api/transformers/graphql-reference-transformer.ts b/src/article-api/transformers/graphql-reference-transformer.ts
index 8335f91b0ab5..7de9c1f68c4e 100644
--- a/src/article-api/transformers/graphql-reference-transformer.ts
+++ b/src/article-api/transformers/graphql-reference-transformer.ts
@@ -227,6 +227,10 @@ export class GraphQLReferenceTransformer implements PageTransformer {
       values: item.values.map((value) => ({
         name: value.name,
         description: value.description ? fastTextOnly(value.description) : '',
+        isDeprecated: value.isDeprecated || false,
+        deprecationReason: value.deprecationReason
+          ? fastTextOnly(value.deprecationReason)
+          : undefined,
       })),
     }
   }
diff --git a/src/graphql/components/Enum.tsx b/src/graphql/components/Enum.tsx
index 68d802f131ae..bafb0e5f1568 100644
--- a/src/graphql/components/Enum.tsx
+++ b/src/graphql/components/Enum.tsx
@@ -1,5 +1,6 @@
 import { useTranslation } from '@/languages/components/useTranslation'
 import { GraphqlItem } from './GraphqlItem'
+import { Notice } from '@/graphql/components/Notice'
 import type { EnumT } from './types'
 import { RenderedHTML } from '@/frame/components/ui/RenderedHTML/RenderedHTML'
 
@@ -27,7 +28,10 @@ export function Enum({ item, headingLevel = 2 }: Props) {
               <td>
                 <code>{value.name}</code>
               </td>
-              <RenderedHTML as="td" html={value.description} />
+              <td>
+                <RenderedHTML html={value.description} />
+                {value.isDeprecated && <Notice item={value} variant="deprecation" />}
+              </td>
             </tr>
           ))}
         </tbody>
diff --git a/src/graphql/components/Notice.tsx b/src/graphql/components/Notice.tsx
index 48a69fbed1b6..088eed817d21 100644
--- a/src/graphql/components/Notice.tsx
+++ b/src/graphql/components/Notice.tsx
@@ -5,7 +5,7 @@ import type { GraphqlT } from './types'
 import { RenderedHTML } from '@/frame/components/ui/RenderedHTML/RenderedHTML'
 
 type Props = {
-  item: GraphqlT
+  item: Pick<GraphqlT, 'name' | 'preview' | 'deprecationReason'>
   variant: 'preview' | 'deprecation'
 }
 
diff --git a/src/graphql/components/types.tsx b/src/graphql/components/types.tsx
index 7f3d1d7c3596..54c214cf0c94 100644
--- a/src/graphql/components/types.tsx
+++ b/src/graphql/components/types.tsx
@@ -84,6 +84,8 @@ export type InterfaceImplementerT = Pick<ObjectT, 'name' | 'href'> & {
 export type EnumValuesT = {
   name: string
   description: string
+  isDeprecated?: boolean
+  deprecationReason?: string
 }
 
 export type EnumT = GraphqlT & {
diff --git a/src/graphql/lib/validator.ts b/src/graphql/lib/validator.ts
index eac02970e166..b0560561a7c7 100644
--- a/src/graphql/lib/validator.ts
+++ b/src/graphql/lib/validator.ts
@@ -213,6 +213,12 @@ enums.properties.values = {
       description: {
         type: 'string',
       },
+      isDeprecated: {
+        type: 'boolean',
+      },
+      deprecationReason: {
+        type: 'string',
+      },
     },
   },
 }
diff --git a/src/graphql/scripts/utils/process-schemas.ts b/src/graphql/scripts/utils/process-schemas.ts
index d415670c3485..a6ade603dd05 100755
--- a/src/graphql/scripts/utils/process-schemas.ts
+++ b/src/graphql/scripts/utils/process-schemas.ts
@@ -143,6 +143,8 @@ interface GraphQLInterfaceInfo {
 interface EnumValueInfo {
   name: string
   description: string
+  isDeprecated?: boolean
+  deprecationReason?: string
 }
 
 interface EnumInfo {
@@ -820,6 +822,11 @@ export default async function processSchemas(
               name: value.name.value,
               description: await helpers.getDescription(value.description?.value || ''),
             }
+            enumValue.isDeprecated = helpers.getDeprecationStatus(value.directives || [])
+            enumValue.deprecationReason = await helpers.getDeprecationReason(
+              value.directives || [],
+              enumValue,
+            )
             enumValues.push(enumValue)
           }),
         )
diff --git a/src/graphql/tests/enum-value-deprecation.ts b/src/graphql/tests/enum-value-deprecation.ts
new file mode 100644
index 000000000000..59501e0561e9
--- /dev/null
+++ b/src/graphql/tests/enum-value-deprecation.ts
@@ -0,0 +1,33 @@
+import { describe, expect, test } from 'vitest'
+
+import processSchemas from '@/graphql/scripts/utils/process-schemas'
+
+const IDL = `
+type Query {
+  viewer: String
+}
+
+enum MergeStateStatus {
+  "The head ref is out of date."
+  BEHIND
+  "The merge is blocked due to the pull request being a draft."
+  DRAFT
+    @deprecated(
+      reason: "DRAFT state will be removed from this enum and \`isDraft\` should be used instead Use PullRequest.isDraft instead. Removal on 2021-01-01 UTC."
+    )
+}
+`
+
+describe('enum value deprecation', () => {
+  test('keeps the deprecated status and reason on enum values', async () => {
+    const data = await processSchemas(IDL, [])
+    const mergeStateStatus = data.enums.find((item) => item.name === 'MergeStateStatus')
+    const draft = mergeStateStatus?.values.find((value) => value.name === 'DRAFT')
+    const behind = mergeStateStatus?.values.find((value) => value.name === 'BEHIND')
+
+    expect(draft?.isDeprecated).toBe(true)
+    expect(draft?.deprecationReason).toContain('PullRequest.isDraft')
+    expect(behind?.isDeprecated).toBeUndefined()
+    expect(behind?.deprecationReason).toBeUndefined()
+  })
+})

From 196d6a378dc60b7bbd00455620992561728438da Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Tue, 20 Oct 2026 22:56:11 +0000
Subject: [PATCH 57/71] Keep curly quote autofix from breaking quoted YAML
 frontmatter (#63923)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 .../linting-rules/frontmatter-curly-quotes.ts | 78 ++++++++++++++----
 .../tests/unit/frontmatter-curly-quotes.ts    | 81 +++++++++++++++++++
 2 files changed, 143 insertions(+), 16 deletions(-)

diff --git a/src/content-linter/lib/linting-rules/frontmatter-curly-quotes.ts b/src/content-linter/lib/linting-rules/frontmatter-curly-quotes.ts
index a6b04cbb37de..2ddfd9d97896 100644
--- a/src/content-linter/lib/linting-rules/frontmatter-curly-quotes.ts
+++ b/src/content-linter/lib/linting-rules/frontmatter-curly-quotes.ts
@@ -1,19 +1,57 @@
+import { isDeepStrictEqual } from 'node:util'
 import { addError } from 'markdownlint-rule-helpers'
+import { load } from 'js-yaml'
 
 import { getFrontmatterLines } from '../helpers/utils'
 import type { RuleParams, RuleErrorCallback, Rule } from '@/content-linter/types'
 
 const CURLY_QUOTE_PATTERN = /[\u2018\u2019\u201c\u201d]/g
-const CURLY_QUOTE_MAP: Record<string, string> = {
-  '\u2018': "'",
-  '\u2019': "'",
-  '\u201c': '"',
-  '\u201d': '"',
-}
 
 const CHECKED_FIELDS = ['title', 'intro']
 const BLOCK_SCALAR_PATTERN = /^\s*[|>][-+1-9]*\s*(#.*)?$/
 
+function toStraight(text: string, single: string, double: string): string {
+  return text.replace(CURLY_QUOTE_PATTERN, (ch) =>
+    ch === '\u2018' || ch === '\u2019' ? single : double,
+  )
+}
+
+// The replacement must respect the YAML quote style, or a bare quote can end the string early.
+function getFixedLine(fmLines: string[], idx: number, field: string): string | undefined {
+  const line = fmLines[idx]
+  const match = line.match(new RegExp(`^(\\s*${field}:\\s*)(.*)$`))
+  if (!match) return undefined
+  const [, prefix, value] = match
+
+  let fixedValue: string
+  if (value.startsWith("'")) {
+    fixedValue = toStraight(value, "''", '"')
+  } else if (value.startsWith('"')) {
+    fixedValue = toStraight(value, "'", '\\"')
+  } else {
+    fixedValue = toStraight(value, "'", '"')
+    if (fixedValue.startsWith("'") || fixedValue.startsWith('"')) {
+      fixedValue = `'${fixedValue.replace(/'/g, "''")}'`
+    }
+  }
+  const fixedLine = prefix + fixedValue
+
+  // Parse the whole frontmatter because a value can continue onto the next lines.
+  const fixedLines = [...fmLines]
+  fixedLines[idx] = fixedLine
+  try {
+    const original = load(fmLines.slice(1, -1).join('\n')) as Record<string, unknown>
+    const fixed = load(fixedLines.slice(1, -1).join('\n'))
+    const originalValue = original[field]
+    if (typeof originalValue !== 'string') return undefined
+    const expected = { ...original, [field]: toStraight(originalValue, "'", '"') }
+    if (!isDeepStrictEqual(fixed, expected)) return undefined
+  } catch {
+    return undefined
+  }
+  return fixedLine
+}
+
 export const frontmatterCurlyQuotes: Rule = {
   names: ['GHD034', 'frontmatter-curly-quotes'],
   description: 'Frontmatter title and intro should not contain curly quotes',
@@ -24,11 +62,16 @@ export const frontmatterCurlyQuotes: Rule = {
 
     const fmStart = params.lines.indexOf('---')
 
-    const checkLine = (line: string, lineNumber: number, field: string) => {
+    const checkLine = (
+      line: string,
+      lineNumber: number,
+      field: string,
+      getFix: () => string | undefined,
+    ) => {
       if (!CURLY_QUOTE_PATTERN.test(line)) return
       CURLY_QUOTE_PATTERN.lastIndex = 0
 
-      const fixedLine = line.replace(CURLY_QUOTE_PATTERN, (ch) => CURLY_QUOTE_MAP[ch] || ch)
+      const fixedLine = getFix()
 
       addError(
         onError,
@@ -36,12 +79,14 @@ export const frontmatterCurlyQuotes: Rule = {
         `Curly quotes in '${field}' cause mojibake in plain-text contexts like llms.txt. Use straight quotes instead.`,
         line,
         [1, line.length],
-        {
-          lineNumber,
-          editColumn: 1,
-          deleteCount: line.length,
-          insertText: fixedLine,
-        },
+        fixedLine === undefined
+          ? undefined
+          : {
+              lineNumber,
+              editColumn: 1,
+              deleteCount: line.length,
+              insertText: fixedLine,
+            },
       )
     }
 
@@ -50,7 +95,7 @@ export const frontmatterCurlyQuotes: Rule = {
       if (idx === -1) continue
 
       const line = fmLines[idx]
-      checkLine(line, fmStart + idx + 1, field)
+      checkLine(line, fmStart + idx + 1, field, () => getFixedLine(fmLines, idx, field))
 
       const value = line.trim().slice(field.length + 1)
       if (!BLOCK_SCALAR_PATTERN.test(value)) continue
@@ -60,7 +105,8 @@ export const frontmatterCurlyQuotes: Rule = {
       for (let j = idx + 1; j < fmLines.length - 1; j++) {
         const next = fmLines[j]
         if (next.trim() && next.length - next.trimStart().length <= keyIndent) break
-        checkLine(next, fmStart + j + 1, field)
+        // Block scalar text is literal, so straight quotes need no YAML escaping.
+        checkLine(next, fmStart + j + 1, field, () => toStraight(next, "'", '"'))
       }
     }
   },
diff --git a/src/content-linter/tests/unit/frontmatter-curly-quotes.ts b/src/content-linter/tests/unit/frontmatter-curly-quotes.ts
index d44c579358ca..bb5fff9f75f1 100644
--- a/src/content-linter/tests/unit/frontmatter-curly-quotes.ts
+++ b/src/content-linter/tests/unit/frontmatter-curly-quotes.ts
@@ -1,4 +1,5 @@
 import { describe, expect, test } from 'vitest'
+import { load } from 'js-yaml'
 
 import { runRule } from '../../lib/init-test'
 import { frontmatterCurlyQuotes } from '../../lib/linting-rules/frontmatter-curly-quotes'
@@ -91,6 +92,86 @@ describe(frontmatterCurlyQuotes.names.join(' - '), () => {
     expect(errors.length).toBe(2)
   })
 
+  const fixCases = [
+    {
+      name: 'single-quoted value with curly apostrophe',
+      line: "intro: 'Learn about the repository\u2019s settings.'",
+      field: 'intro',
+      expected: "Learn about the repository's settings.",
+    },
+    {
+      name: 'double-quoted value with curly double quotes',
+      line: 'title: "Use the \u201cupstream\u201d remote"',
+      field: 'title',
+      expected: 'Use the "upstream" remote',
+    },
+    {
+      name: 'plain value that starts with a curly double quote',
+      line: 'title: \u201cUpstream\u201d remotes',
+      field: 'title',
+      expected: '"Upstream" remotes',
+    },
+    {
+      name: 'single-quoted value with curly double quotes',
+      line: "intro: 'About the \u201cupstream\u201d repo.'",
+      field: 'intro',
+      expected: 'About the "upstream" repo.',
+    },
+    {
+      name: 'double-quoted value with curly apostrophe',
+      line: 'title: "Your organization\u2019s settings"',
+      field: 'title',
+      expected: "Your organization's settings",
+    },
+    {
+      name: 'plain value with curly apostrophe',
+      line: 'title: Managing your repository\u2019s settings',
+      field: 'title',
+      expected: "Managing your repository's settings",
+    },
+  ]
+
+  for (const { name, line, field, expected } of fixCases) {
+    test(`fix produces valid YAML for ${name}`, async () => {
+      const strings = { test: ['---', line, '---', '', 'Some content.'].join('\n') }
+      const result = await runRule(frontmatterCurlyQuotes, { strings, ...fmOptions })
+      const errors = result.test
+      expect(errors.length).toBe(1)
+      expect(errors[0].fixInfo).toBeTruthy()
+      const parsed = load(errors[0].fixInfo!.insertText!) as Record<string, unknown>
+      expect(parsed[field]).toBe(expected)
+    })
+  }
+
+  test('fix keeps a quoted value spanning multiple lines valid', async () => {
+    const fm = ['intro: "Learn about the \u201cupstream\u201d', '  repository."']
+    const strings = { test: ['---', ...fm, '---', '', 'Some content.'].join('\n') }
+    const result = await runRule(frontmatterCurlyQuotes, { strings, ...fmOptions })
+    const errors = result.test
+    expect(errors.length).toBe(1)
+    expect(errors[0].fixInfo).toBeTruthy()
+    const fixed = [errors[0].fixInfo!.insertText!, ...fm.slice(1)].join('\n')
+    const parsed = load(fixed) as Record<string, unknown>
+    expect(parsed.intro).toBe('Learn about the "upstream" repository.')
+  })
+
+  test('plain value continued on the next line is reported without a fix', async () => {
+    const strings = {
+      test: [
+        '---',
+        'intro: \u201cUpstream\u201d remotes',
+        '  and forks',
+        '---',
+        '',
+        'Some content.',
+      ].join('\n'),
+    }
+    const result = await runRule(frontmatterCurlyQuotes, { strings, ...fmOptions })
+    const errors = result.test
+    expect(errors.length).toBe(1)
+    expect(errors[0].fixInfo).toBeFalsy()
+  })
+
   test('curly quotes in block scalar intro trigger warning', async () => {
     const strings = {
       test: [

From d7da1274af390b44e6f76302f22d6d1223301d0c Mon Sep 17 00:00:00 2001
From: hubwriter <hubwriter@github.com>
Date: Wed, 21 Oct 2026 09:30:56 +0000
Subject: [PATCH 58/71] Change PR creation to draft until skip FR label applied
 (#64245)

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Copilot-Session: ece718f6-8247-4776-90bd-c960b3b61a7f
---
 .github/workflows/content-pipelines.yml  |  42 ++++--
 src/workflows/tests/content-pipelines.ts | 161 +++++++++++++++++++++++
 2 files changed, 192 insertions(+), 11 deletions(-)
 create mode 100644 src/workflows/tests/content-pipelines.ts

diff --git a/.github/workflows/content-pipelines.yml b/.github/workflows/content-pipelines.yml
index 16f6cf0b27d8..70c590077b2a 100644
--- a/.github/workflows/content-pipelines.yml
+++ b/.github/workflows/content-pipelines.yml
@@ -49,7 +49,10 @@ jobs:
           GH_TOKEN: ${{ github.token }}
           UPDATE_BRANCH: ${{ steps.branch.outputs.update_branch }}
         run: |
-          PR_NUMBER=$(gh pr list --head "$UPDATE_BRANCH" --state open --json number --jq '.[0].number // empty' 2>/dev/null || echo "")
+          PR_NUMBER=$(gh pr list --head "$UPDATE_BRANCH" --state open --json number --jq '.[0].number // empty') || {
+            echo "::error::Could not look up the PR for ${UPDATE_BRANCH}."
+            exit 1
+          }
           echo "pr_number=$PR_NUMBER" >> "$GITHUB_OUTPUT"
 
       - name: Setup branch
@@ -137,23 +140,22 @@ jobs:
           echo "source_path=$SOURCE_PATH" >> "$GITHUB_OUTPUT"
 
       - name: Create or update PR
-        if: steps.commit.outputs.has_changes == 'true'
+        if: steps.commit.outputs.has_changes == 'true' || steps.check-pr.outputs.pr_number != ''
         env:
           GH_TOKEN: ${{ secrets.DOCS_BOT_PAT_BASE }}
           UPDATE_BRANCH: ${{ steps.branch.outputs.update_branch }}
           PIPELINE_ID: ${{ matrix.id }}
           SOURCE_REPO: ${{ steps.source-info.outputs.source_repo }}
           SOURCE_PATH: ${{ steps.source-info.outputs.source_path }}
+          PR_REF: ${{ steps.check-pr.outputs.pr_number }}
         run: |
-          PR_NUMBER="${{ steps.check-pr.outputs.pr_number }}"
+          set -euo pipefail
+
           PR_TITLE="docs: update ${PIPELINE_ID} content from source docs"
           SOURCE_LINK="See the [upstream repo](https://github.com/${SOURCE_REPO}/tree/main/${SOURCE_PATH}) for changes that triggered this update."
 
-          if [ -n "$PR_NUMBER" ]; then
-            echo "PR #$PR_NUMBER already exists"
-
-            echo "Ensuring PR #$PR_NUMBER is marked ready for review"
-            gh pr ready "$PR_NUMBER" || echo "Unable to mark PR #$PR_NUMBER as ready (it may already be ready)"
+          if [ -n "$PR_REF" ]; then
+            echo "PR #$PR_REF already exists"
           else
             echo "Creating new PR"
 
@@ -178,12 +180,30 @@ jobs:
             PR_BODY+="* Once satisfied, merge to keep docs up to date"$'\n'
             PR_BODY+="* A new PR will be created on the next run if there are further changes"
 
-            gh pr create \
+            # The opened event must describe a draft before any labels are applied.
+            PR_REF=$(gh pr create --draft \
               --title "$PR_TITLE" \
               --body "$PR_BODY" \
               --base main \
-              --head "$UPDATE_BRANCH" \
-              --label "workflow-generated,content-pipeline-update,ready-for-doc-review,skip FR board"
+              --head "$UPDATE_BRANCH")
+          fi
+
+          # Retry publication for existing PRs, including runs without content changes.
+          gh pr edit "$PR_REF" --add-label "skip FR board" || {
+            echo "::error::Could not apply skip FR board. The PR will not be marked ready."
+            exit 1
+          }
+          for LABEL in "workflow-generated" "content-pipeline-update" "ready-for-doc-review"; do
+            gh pr edit "$PR_REF" --add-label "$LABEL" \
+              || echo "::warning::Could not apply the \"$LABEL\" label."
+          done
+
+          IS_DRAFT=$(gh pr view "$PR_REF" --json isDraft --jq '.isDraft')
+          if [ "$IS_DRAFT" = "true" ]; then
+            gh pr ready "$PR_REF" || {
+              echo "::error::Could not mark the labeled PR ready for review."
+              exit 1
+            }
           fi
 
       - uses: ./.github/actions/create-workflow-failure-issue
diff --git a/src/workflows/tests/content-pipelines.ts b/src/workflows/tests/content-pipelines.ts
new file mode 100644
index 000000000000..7e44191f8ba2
--- /dev/null
+++ b/src/workflows/tests/content-pipelines.ts
@@ -0,0 +1,161 @@
+import { spawnSync } from 'node:child_process'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+
+import { load } from 'js-yaml'
+import { describe, expect, test } from 'vitest'
+
+const workflow = load(fs.readFileSync('.github/workflows/content-pipelines.yml', 'utf8')) as {
+  jobs: { update: { steps: Array<{ name?: string; if?: string; run?: string }> } }
+}
+
+function step(name: string) {
+  const found = workflow.jobs.update.steps.find((entry) => entry.name === name)
+  if (!found?.run) throw new Error(`Missing workflow step: ${name}`)
+  return { ...found, run: found.run }
+}
+
+function run(
+  name: string,
+  options: {
+    existing?: boolean
+    draft?: boolean
+    failure?: 'list' | 'create' | 'label' | 'routing-label' | 'view' | 'ready'
+  } = {},
+) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'content-pipeline-pr-'))
+  try {
+    fs.writeFileSync(path.join(dir, 'draft'), String(options.draft ?? true))
+    const script = step(name).run.replace(/\$\{\{\s*([^}]+?)\s*\}\}/g, (_, expression: string) => {
+      if (expression === 'steps.check-pr.outputs.pr_number') return options.existing ? '42' : ''
+      return 'workflow-test'
+    })
+    const result = spawnSync(
+      'bash',
+      [
+        '-e',
+        '-c',
+        `
+          gh() {
+            printf '%s\\n' "$*" >> "$TEST_DIR/calls"
+            case "$1 $2" in
+              "pr list")
+                [ "$FAILURE" != list ] || return 1
+                printf '%s\\n' "$PR_REF"
+                ;;
+              "pr create")
+                [ "$FAILURE" != create ] || return 1
+                if [[ "$*" == *"--draft"* ]]; then
+                  touch "$TEST_DIR/created-draft"
+                else
+                  touch "$TEST_DIR/created-ready"
+                fi
+                echo https://github.com/github/docs-internal/pull/42
+                ;;
+              "pr edit")
+                if [[ "$*" == *"skip FR board"* ]]; then
+                  [ "$FAILURE" != label ] || return 1
+                  touch "$TEST_DIR/labeled"
+                fi
+                if [[ "$*" == *"content-pipeline-update"* ]]; then
+                  [ "$FAILURE" != routing-label ] || return 1
+                fi
+                ;;
+              "pr view")
+                [ "$FAILURE" != view ] || return 1
+                cat "$TEST_DIR/draft"
+                ;;
+              "pr ready")
+                [ -f "$TEST_DIR/labeled" ] || return 2
+                [ "$FAILURE" != ready ] || return 1
+                touch "$TEST_DIR/ready"
+                ;;
+              *) return 3 ;;
+            esac
+          }
+          ${script}
+        `,
+      ],
+      {
+        encoding: 'utf8',
+        env: {
+          ...process.env,
+          TEST_DIR: dir,
+          GITHUB_OUTPUT: path.join(dir, 'output'),
+          PR_REF: options.existing ? '42' : '',
+          UPDATE_BRANCH: 'docs/content-pipeline-copilot-cli-update',
+          PIPELINE_ID: 'copilot-cli',
+          SOURCE_REPO: 'github/copilot-agent-runtime',
+          SOURCE_PATH: 'docs',
+          FAILURE: options.failure ?? '',
+        },
+      },
+    )
+    return {
+      status: result.status,
+      output: result.stdout + result.stderr,
+      createdDraft: fs.existsSync(path.join(dir, 'created-draft')),
+      createdReady: fs.existsSync(path.join(dir, 'created-ready')),
+      ready: fs.existsSync(path.join(dir, 'ready')),
+      calls: fs.existsSync(path.join(dir, 'calls'))
+        ? fs.readFileSync(path.join(dir, 'calls'), 'utf8')
+        : '',
+    }
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true })
+  }
+}
+
+describe('content pipeline PR publication', () => {
+  test('creates a draft and applies the exclusion before marking it ready', () => {
+    const result = run('Create or update PR')
+    expect(result.status, result.output).toBe(0)
+    expect(result.createdDraft).toBe(true)
+    expect(result.createdReady).toBe(false)
+    expect(result.ready).toBe(true)
+  })
+
+  test('finishes an existing draft without creating another PR', () => {
+    const result = run('Create or update PR', { existing: true })
+    expect(result.status, result.output).toBe(0)
+    expect(result.calls).not.toContain('pr create')
+    expect(result.ready).toBe(true)
+  })
+
+  test('warns but marks the PR ready when a routing label fails', () => {
+    const result = run('Create or update PR', { failure: 'routing-label' })
+    expect(result.status, result.output).toBe(0)
+    expect(result.output).toContain('Could not apply the "content-pipeline-update" label.')
+    expect(result.calls).toContain('pr ready https://github.com/github/docs-internal/pull/42')
+    expect(result.ready).toBe(true)
+  })
+
+  test('runs for an existing PR even without new content changes', () => {
+    expect(step('Create or update PR').if).toBe(
+      "steps.commit.outputs.has_changes == 'true' || steps.check-pr.outputs.pr_number != ''",
+    )
+  })
+
+  test('does not try to mark an already-ready PR ready again', () => {
+    const result = run('Create or update PR', { existing: true, draft: false })
+    expect(result.status, result.output).toBe(0)
+    expect(result.calls).not.toContain('pr ready')
+  })
+
+  test.each(['create', 'label', 'view', 'ready'] as const)(
+    'fails visibly when %s fails',
+    (failure) => {
+      const result = run('Create or update PR', { failure })
+      expect(result.status, result.output).not.toBe(0)
+      expect(result.ready).toBe(false)
+      expect(result.createdReady).toBe(false)
+      if (failure !== 'ready') expect(result.calls).not.toContain('pr ready')
+    },
+  )
+
+  test('does not treat a failed PR lookup as an absent PR', () => {
+    const result = run('Check for existing PR', { failure: 'list' })
+    expect(result.status, result.output).not.toBe(0)
+  })
+})

From 5c55c2beea730ee33867da7e9807927329201ada Mon Sep 17 00:00:00 2001
From: docs-bot <77750099+docs-bot@users.noreply.github.com>
Date: Wed, 21 Oct 2026 11:23:52 +0000
Subject: [PATCH 59/71] docs: update copilot-cli content from source docs
 (#64303)

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
Co-authored-by: hubwriter <hubwriter@github.com>
---
 .../reference/copilot-cli-reference/cli-config-dir-reference.md | 1 +
 src/content-pipelines/state/copilot-cli.sha                     | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/content/copilot/reference/copilot-cli-reference/cli-config-dir-reference.md b/content/copilot/reference/copilot-cli-reference/cli-config-dir-reference.md
index c25221f5ef1f..aff8fb5c8170 100644
--- a/content/copilot/reference/copilot-cli-reference/cli-config-dir-reference.md
+++ b/content/copilot/reference/copilot-cli-reference/cli-config-dir-reference.md
@@ -510,6 +510,7 @@ These settings apply across all your sessions and repositories. You can use the
 | `screenReader` | `boolean` | `false` | Enable screen reader optimizations. |
 | `scrollbar` | `boolean` | `true` | Show the scrollbar in scrollable views. Set to `false` to hide it and use the full terminal width. |
 | `shellShortcut` | `boolean` | `true` | Let a lone `$` at the prompt, followed by <kbd>Enter</kbd>, open an interactive shell rooted at the session's working directory (activates only for a local, trusted, idle session on a real TTY). User- or managed-scoped only—not repo-overridable. |
+| `showReasoning` | `boolean` | None | Show model reasoning in the timeline. You can set this with `/config` or `/settings`, or toggle it with <kbd>Ctrl</kbd>+<kbd>T</kbd>. Your preference is saved across sessions. |
 | `showTimestamps` | `boolean` | `true` | Show dim `HH:mm` timestamps next to user messages in the timeline. |
 | `showTipsOnStartup` | `boolean` | `true` | Show a random command tip when the CLI starts. |
 | `sidebar` | `boolean` | `true` | Enable the current-session sidebar. Set to `false` to disable it entirely, hiding the composer hint and the <kbd>←</kbd> open gesture. See [AUTOTITLE](/copilot/reference/copilot-cli-reference/cli-command-reference#sidebar-and-sessions-tab-shortcuts). |
diff --git a/src/content-pipelines/state/copilot-cli.sha b/src/content-pipelines/state/copilot-cli.sha
index 8ab18a85c9e2..8b56a4ad4020 100644
--- a/src/content-pipelines/state/copilot-cli.sha
+++ b/src/content-pipelines/state/copilot-cli.sha
@@ -1 +1 @@
-8860daf23f911fa47684866555ce82856e79a14a
+4fe31058ce5a3e55180ccda41fc625afcb7f5ead

From f8f9eb2c2be23dfaf40b33d070704be625d7e873 Mon Sep 17 00:00:00 2001
From: hubwriter <hubwriter@github.com>
Date: Wed, 21 Oct 2026 11:48:29 +0000
Subject: [PATCH 60/71] Remove redundant copilot_ prefix from model variables
 (#64249)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: Kevin Heis <heiskr@users.noreply.github.com>
Copilot-Session: 9a4bfecd-e316-4317-a51d-b3121470bdfc
Copilot-Session: 37f9dd70-a938-4033-9446-fc296cdcb01f
---
 ...lop-agentic-workflows-in-github-actions.md |   2 +-
 .../github-copilot-with-data-residency.md     |  38 +++---
 .../models/fallback-and-lts-models.md         |   4 +-
 content/copilot/get-started/plans.md          |   2 +-
 .../how-tos/copilot-cli/cli-best-practices.md |  12 +-
 .../reference/ai-models/model-comparison.md   |  24 ++--
 .../reference/ai-models/model-hosting.md      |  82 ++++++------
 .../reference/ai-models/supported-models.md   |  92 +++++++-------
 .../copilot-billing/models-and-pricing.md     |   6 +-
 .../model-multipliers-for-annual-plans.md     |   2 +-
 content/copilot/tutorials/vibe-coding.md      |   2 +-
 ...gentic-workflows-third-party-agent-clis.md |   2 +-
 .../copilot/anthropic-claude-agent-models.md  |  12 +-
 .../copilot/available-models-per-plan.md      |   2 +-
 .../copilot-cloud-agent-non-auto-models.md    |  36 +++---
 .../model-autoenablement-excluded-models.md   |   4 +-
 .../copilot/openai-codex-agent-models.md      |   4 +-
 data/variables/copilot.yml                    | 120 +++++++++---------
 18 files changed, 223 insertions(+), 223 deletions(-)

diff --git a/content/actions/tutorials/develop-agentic-workflows-in-github-actions.md b/content/actions/tutorials/develop-agentic-workflows-in-github-actions.md
index 8d31eedcf10f..365bd75775e3 100644
--- a/content/actions/tutorials/develop-agentic-workflows-in-github-actions.md
+++ b/content/actions/tutorials/develop-agentic-workflows-in-github-actions.md
@@ -51,7 +51,7 @@ This article walks through a simple setup that adds the agent's credential as a
 | --- | --- | --- |
 | Claude Code | `claude` | `ANTHROPIC_API_KEY` containing an Anthropic API key |
 | {% data variables.product.prodname_openai_codex %} | `codex` | `OPENAI_API_KEY` containing an OpenAI API key |
-| Google {% data variables.copilot.copilot_gemini %} CLI | `gemini` | `GEMINI_API_KEY` containing a Google AI Studio API key |
+| Google {% data variables.copilot.gemini %} CLI | `gemini` | `GEMINI_API_KEY` containing a Google AI Studio API key |
 | {% data variables.copilot.copilot_cli_short %} (default) | `copilot` | No secret needed for organization repositories (see below). For personal repositories, `COPILOT_GITHUB_TOKEN` containing a fine-grained {% data variables.product.pat_generic %} with **Copilot Requests** set to **Read**. |
 
 Other engines such as Pi (experimental) are also supported. For the full list, see the [{% data variables.copilot.github_agentic_workflows %} authentication reference](https://github.github.com/gh-aw/reference/auth/).
diff --git a/content/admin/data-residency/github-copilot-with-data-residency.md b/content/admin/data-residency/github-copilot-with-data-residency.md
index 1943ac71bda5..6e4b1c8b49e5 100644
--- a/content/admin/data-residency/github-copilot-with-data-residency.md
+++ b/content/admin/data-residency/github-copilot-with-data-residency.md
@@ -52,25 +52,25 @@ The models available for {% data variables.product.prodname_copilot_short %} var
 
 ### European Union
 
-* {% data variables.copilot.copilot_gpt_4o_mini %}
-* {% data variables.copilot.copilot_gpt_41 %}
-* {% data variables.copilot.copilot_gpt_52 %}
-* {% data variables.copilot.copilot_gpt_53_codex %}
-* {% data variables.copilot.copilot_gpt_54_nano %}
-* {% data variables.copilot.copilot_gpt_56_luna %}
-* {% data variables.copilot.copilot_gpt_56_sol %}
-* {% data variables.copilot.copilot_gpt_56_terra %}
-* {% data variables.copilot.copilot_gpt_6_astra %}
-* {% data variables.copilot.copilot_gpt_6_luna %}
-* {% data variables.copilot.copilot_gpt_6_sol %}
-* {% data variables.copilot.copilot_gpt_61_sol %}
-* {% data variables.copilot.copilot_claude_haiku_45 %}
-* {% data variables.copilot.copilot_claude_haiku_55 %}
-* {% data variables.copilot.copilot_claude_opus_48 %}
-* {% data variables.copilot.copilot_claude_opus_5 %}
-* {% data variables.copilot.copilot_claude_opus_55 %}
-* {% data variables.copilot.copilot_claude_sonnet_5 %}
-* {% data variables.copilot.copilot_claude_sonnet_55 %}
+* {% data variables.copilot.gpt_4o_mini %}
+* {% data variables.copilot.gpt_41 %}
+* {% data variables.copilot.gpt_52 %}
+* {% data variables.copilot.gpt_53_codex %}
+* {% data variables.copilot.gpt_54_nano %}
+* {% data variables.copilot.gpt_56_luna %}
+* {% data variables.copilot.gpt_56_sol %}
+* {% data variables.copilot.gpt_56_terra %}
+* {% data variables.copilot.gpt_6_astra %}
+* {% data variables.copilot.gpt_6_luna %}
+* {% data variables.copilot.gpt_6_sol %}
+* {% data variables.copilot.gpt_61_sol %}
+* {% data variables.copilot.claude_haiku_45 %}
+* {% data variables.copilot.claude_haiku_55 %}
+* {% data variables.copilot.claude_opus_48 %}
+* {% data variables.copilot.claude_opus_5 %}
+* {% data variables.copilot.claude_opus_55 %}
+* {% data variables.copilot.claude_sonnet_5 %}
+* {% data variables.copilot.claude_sonnet_55 %}
 
 ## Pricing changes
 
diff --git a/content/copilot/concepts/models/fallback-and-lts-models.md b/content/copilot/concepts/models/fallback-and-lts-models.md
index cbac874b20b5..55e010edffbc 100644
--- a/content/copilot/concepts/models/fallback-and-lts-models.md
+++ b/content/copilot/concepts/models/fallback-and-lts-models.md
@@ -15,7 +15,7 @@ redirect_from:
 ## About base models
 
 > [!IMPORTANT]
-> * On March 18, 2026, {% data variables.product.github %} designated {% data variables.copilot.copilot_gpt_53_codex %} as the base model.
+> * On March 18, 2026, {% data variables.product.github %} designated {% data variables.copilot.gpt_53_codex %} as the base model.
 > * Base models apply only to {% data variables.copilot.copilot_business_short %} and {% data variables.copilot.copilot_enterprise_short %}.
 
  A base model is the default AI model that {% data variables.product.prodname_copilot %} uses when no other models are enabled. The base model is automatically enabled for all {% data variables.copilot.copilot_business_short %} or {% data variables.copilot.copilot_enterprise_short %} accounts within 60 days after the model is designated as a base model.
@@ -31,7 +31,7 @@ When a new model is designated a base model, the following timeline applies:
 ## About long-term support (LTS) models
 
 > [!IMPORTANT]
-> * On March 18, 2026, {% data variables.product.github %} designated {% data variables.copilot.copilot_gpt_53_codex %} as the LTS model.
+> * On March 18, 2026, {% data variables.product.github %} designated {% data variables.copilot.gpt_53_codex %} as the LTS model.
 > * LTS models apply only to {% data variables.copilot.copilot_business_short %} and {% data variables.copilot.copilot_enterprise_short %}.
 
 An LTS model is an AI model that {% data variables.product.github %} commits to supporting for an extended period of one year from its designation date. During that period, the model remains available, which allows users to build around the model without concern that it will be {% data variables.release-phases.closing_down %} unexpectedly.
diff --git a/content/copilot/get-started/plans.md b/content/copilot/get-started/plans.md
index d5b082eb1fe5..dcf1a7b777f4 100644
--- a/content/copilot/get-started/plans.md
+++ b/content/copilot/get-started/plans.md
@@ -271,4 +271,4 @@ For a full explanation of how {% data variables.product.prodname_ai_credits_shor
 * To compare models supported across plans, features, and IDEs, see [AUTOTITLE](/copilot/reference/ai-models/supported-models).
 
 [^1]: {% data variables.copilot.copilot_chat_short %} skills in IDEs is available in {% data variables.product.prodname_vscode %} and {% data variables.product.prodname_vs %}.
-[^claude-fable-5]: When {% data variables.copilot.copilot_claude_fable_5 %} or {% data variables.copilot.copilot_claude_fable_51 %} is used, Anthropic retains data, including prompts and outputs, by default to operate safety classifiers that detect harmful use. Customers can request to use {% data variables.copilot.copilot_claude_fable_5 %} or {% data variables.copilot.copilot_claude_fable_51 %} with zero data retention (ZDR) through the end of 2026 under a time-bound exemption while Anthropic rolls out Enterprise Frontier Safeguards (EFS). After that point, continued use of these models would require EFS, which will enable eligible customers to keep their data under their own control while also enabling automated safety monitoring. For an enterprise that has been approved and configured for this type of access, {% data variables.copilot.copilot_claude_fable_5 %} and {% data variables.copilot.copilot_claude_fable_51 %} requests will use the ZDR endpoint through the end of 2026 when the models are enabled. To learn whether your enterprise is eligible and request access, contact your {% data variables.product.github %} account team. Approval for access does not automatically enable {% data variables.copilot.copilot_claude_fable_5 %} or {% data variables.copilot.copilot_claude_fable_51 %}. An enterprise or organization administrator must still enable each model before users can access it. Other Claude models, except for {% data variables.copilot.copilot_claude_fable_5 %} and {% data variables.copilot.copilot_claude_fable_51 %}, continue to operate under ZDR. Customers who enable a Fable model with ZDR agree to use this model only for internal operations, including to develop and evaluate products for their own customers. They may not make the model endpoints or outputs available externally. To enable these models, see [AUTOTITLE](/copilot/how-tos/copilot-on-github/set-up-copilot/configure-access-to-ai-models).
+[^claude-fable-5]: When {% data variables.copilot.claude_fable_5 %} or {% data variables.copilot.claude_fable_51 %} is used, Anthropic retains data, including prompts and outputs, by default to operate safety classifiers that detect harmful use. Customers can request to use {% data variables.copilot.claude_fable_5 %} or {% data variables.copilot.claude_fable_51 %} with zero data retention (ZDR) through the end of 2026 under a time-bound exemption while Anthropic rolls out Enterprise Frontier Safeguards (EFS). After that point, continued use of these models would require EFS, which will enable eligible customers to keep their data under their own control while also enabling automated safety monitoring. For an enterprise that has been approved and configured for this type of access, {% data variables.copilot.claude_fable_5 %} and {% data variables.copilot.claude_fable_51 %} requests will use the ZDR endpoint through the end of 2026 when the models are enabled. To learn whether your enterprise is eligible and request access, contact your {% data variables.product.github %} account team. Approval for access does not automatically enable {% data variables.copilot.claude_fable_5 %} or {% data variables.copilot.claude_fable_51 %}. An enterprise or organization administrator must still enable each model before users can access it. Other Claude models, except for {% data variables.copilot.claude_fable_5 %} and {% data variables.copilot.claude_fable_51 %}, continue to operate under ZDR. Customers who enable a Fable model with ZDR agree to use this model only for internal operations, including to develop and evaluate products for their own customers. They may not make the model endpoints or outputs available externally. To enable these models, see [AUTOTITLE](/copilot/how-tos/copilot-on-github/set-up-copilot/configure-access-to-ai-models).
diff --git a/content/copilot/how-tos/copilot-cli/cli-best-practices.md b/content/copilot/how-tos/copilot-cli/cli-best-practices.md
index d99161f44fd3..42f15f2f69e5 100644
--- a/content/copilot/how-tos/copilot-cli/cli-best-practices.md
+++ b/content/copilot/how-tos/copilot-cli/cli-best-practices.md
@@ -87,15 +87,15 @@ Use `/model` to choose from available models based on your task complexity:
 | Model | Best For | Tradeoffs |
 | ----- | -------- | --------- |
 | **Auto** | Reduced rate limiting and lower latency and errors | See [AUTOTITLE](/copilot/concepts/models/auto-model-selection) |
-| **{% data variables.copilot.copilot_claude_opus_5 %}** | Complex architecture, difficult debugging, nuanced refactoring | Most capable but more costly |
-| **{% data variables.copilot.copilot_claude_sonnet_5 %}** | Day-to-day coding, most routine tasks | Fast, cost-effective, handles most work well |
-| **{% data variables.copilot.copilot_gpt_53_codex %}** | Code generation, code review, straightforward implementations | Excellent for reviewing code produced by other models |
+| **{% data variables.copilot.claude_opus_5 %}** | Complex architecture, difficult debugging, nuanced refactoring | Most capable but more costly |
+| **{% data variables.copilot.claude_sonnet_5 %}** | Day-to-day coding, most routine tasks | Fast, cost-effective, handles most work well |
+| **{% data variables.copilot.gpt_53_codex %}** | Code generation, code review, straightforward implementations | Excellent for reviewing code produced by other models |
 
 **Recommendations:**
 
 * **Auto** intelligently chooses models based on real-time system health and model performance (reducing rate limiting and providing lower latency and errors), and the complexity of the task you have given {% data variables.product.prodname_copilot_short %}.
-* **{% data variables.copilot.copilot_claude_opus_5 %}** is ideal for tasks requiring deep reasoning, complex system design, subtle bug investigation, or extensive context understanding.
-* **Switch to {% data variables.copilot.copilot_claude_sonnet_5 %}** for routine tasks where speed and cost efficiency matter—it handles the majority of everyday coding effectively.
+* **{% data variables.copilot.claude_opus_5 %}** is ideal for tasks requiring deep reasoning, complex system design, subtle bug investigation, or extensive context understanding.
+* **Switch to {% data variables.copilot.claude_sonnet_5 %}** for routine tasks where speed and cost efficiency matter—it handles the majority of everyday coding effectively.
 * **Use Codex** for high-volume code generation and as a second opinion for reviewing code produced by other models.
 
 You can switch models mid-session with `/model` as task complexity changes.
@@ -336,7 +336,7 @@ Pair with {% data variables.copilot.copilot_cli_short %} to develop tests.
 ### Code review assistance
 
 * ``/security-review Review my current local changes for security issues. Prioritize high-severity findings and suggest remediations I can apply before opening a pull request.``
-* ``/review Use {% data variables.copilot.copilot_claude_opus_5 %} and {% data variables.copilot.copilot_gpt_53_codex %} to review the changes in my current branch against `main`. Focus on potential bugs and security issues.``
+* ``/review Use {% data variables.copilot.claude_opus_5 %} and {% data variables.copilot.gpt_53_codex %} to review the changes in my current branch against `main`. Focus on potential bugs and security issues.``
 * Triage high-severity findings first, validate your fixes, then continue through your normal pull request review workflow.
 
 ### Git operations
diff --git a/content/copilot/reference/ai-models/model-comparison.md b/content/copilot/reference/ai-models/model-comparison.md
index b32efb96c733..97a7c8fafc19 100644
--- a/content/copilot/reference/ai-models/model-comparison.md
+++ b/content/copilot/reference/ai-models/model-comparison.md
@@ -41,8 +41,8 @@ Use these models for common development tasks that require a balance of quality,
 
 | Model                                             | Why it's a good fit                                                                                                                             |
 |---------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------|
-| {% data variables.copilot.copilot_gpt_53_codex %} | Delivers higher-quality code on complex engineering tasks like features, tests, debugging, refactors, and reviews without lengthy instructions. |
-| {% data variables.copilot.copilot_gpt_56_terra %} | Balanced all-round choice for everyday interactive and agentic coding.                                                                          |
+| {% data variables.copilot.gpt_53_codex %} | Delivers higher-quality code on complex engineering tasks like features, tests, debugging, refactors, and reviews without lengthy instructions. |
+| {% data variables.copilot.gpt_56_terra %} | Balanced all-round choice for everyday interactive and agentic coding.                                                                          |
 
 ### When to use these models
 
@@ -65,8 +65,8 @@ These models are optimized for speed and responsiveness. They’re ideal for qui
 
 | Model                                                 | Why it's a good fit                                                                                        |
 |-------------------------------------------------------|------------------------------------------------------------------------------------------------------------|
-| {% data variables.copilot.copilot_gpt_56_luna %}      | Lightweight, cost-efficient option for smaller, faster tasks. The lowest-cost model in the GPT-5.6 family. |
-| {% data variables.copilot.copilot_claude_haiku_45 %}  | Balances fast responses with quality output. Ideal for small tasks and lightweight code explanations.      |
+| {% data variables.copilot.gpt_56_luna %}      | Lightweight, cost-efficient option for smaller, faster tasks. The lowest-cost model in the GPT-5.6 family. |
+| {% data variables.copilot.claude_haiku_45 %}  | Balances fast responses with quality output. Ideal for small tasks and lightweight code explanations.      |
 
 ### When to use these models
 
@@ -90,8 +90,8 @@ These models are designed for tasks that require step-by-step reasoning, complex
 
 | Model                                                 | Why it's a good fit                                                                                                                                             |
 |-------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| {% data variables.copilot.copilot_gpt_56_sol %}       | The highest reasoning ceiling in the GPT-5.6 family. Best for complex reasoning over large codebases and demanding, long-running agentic work. |
-| {% data variables.copilot.copilot_claude_sonnet_46 %} | Reliable completions and smarter reasoning under pressure.                                                                     |
+| {% data variables.copilot.gpt_56_sol %}       | The highest reasoning ceiling in the GPT-5.6 family. Best for complex reasoning over large codebases and demanding, long-running agentic work. |
+| {% data variables.copilot.claude_sonnet_46 %} | Reliable completions and smarter reasoning under pressure.                                                                     |
 
 ### When to use these models
 
@@ -114,8 +114,8 @@ Use these models when you want to ask questions about screenshots, diagrams, UI
 
 | Model                                                 | Why it's a good fit                                                                                                                                                       |
 |-------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| {% data variables.copilot.copilot_gpt_56_luna %}      | Quick, cost-efficient responses for smaller coding tasks, and supports multimodal input for visual reasoning tasks. |
-| {% data variables.copilot.copilot_claude_sonnet_46 %} | Reliable completions and smarter reasoning under pressure.                                                                               |
+| {% data variables.copilot.gpt_56_luna %}      | Quick, cost-efficient responses for smaller coding tasks, and supports multimodal input for visual reasoning tasks. |
+| {% data variables.copilot.claude_sonnet_46 %} | Reliable completions and smarter reasoning under pressure.                                                                               |
 
 ### When to use these models
 
@@ -136,17 +136,17 @@ If your task involves deep reasoning or large-scale refactoring, consider a mode
 
 Some models have behaviors, limitations, or safeguards that are useful to understand before you choose them for a task.
 
-### {% data variables.copilot.copilot_kimi_k3 %}
+### {% data variables.copilot.kimi_k3 %}
 
-{% data variables.copilot.copilot_kimi_k3 %} is designed for long-context, multi-step coding and agentic workflows. Fine-tuned model variants may be included as part of the {% data variables.copilot.copilot_kimi_k3 %} ({% data variables.product.github %}) offering on individual plans only. Fine-tuned variants are not included for {% data variables.copilot.copilot_business_short %} or {% data variables.copilot.copilot_enterprise_short %} plans. In pre-release testing, the model exhibited elevated risk on certain higher-risk prompts and was less consistent than some other models in refusing requests involving sensitive topics. These behaviors may reflect differences in the model's safety post-training and alignment. We have deployed additional safeguards in {% data variables.product.prodname_copilot %} to help mitigate the identified risks. As with any model, enterprises should evaluate model capabilities, limitations, and safeguards in light of their particular use cases and requirements.
+{% data variables.copilot.kimi_k3 %} is designed for long-context, multi-step coding and agentic workflows. Fine-tuned model variants may be included as part of the {% data variables.copilot.kimi_k3 %} ({% data variables.product.github %}) offering on individual plans only. Fine-tuned variants are not included for {% data variables.copilot.copilot_business_short %} or {% data variables.copilot.copilot_enterprise_short %} plans. In pre-release testing, the model exhibited elevated risk on certain higher-risk prompts and was less consistent than some other models in refusing requests involving sensitive topics. These behaviors may reflect differences in the model's safety post-training and alignment. We have deployed additional safeguards in {% data variables.product.prodname_copilot %} to help mitigate the identified risks. As with any model, enterprises should evaluate model capabilities, limitations, and safeguards in light of their particular use cases and requirements.
 
 ## Next steps
 
 [^mai-models]: MAI models are continuously improving models. Performance and behavior may evolve over time as new checkpoints are released.
 
-[^kimi-k3]: For important information about {% data variables.copilot.copilot_kimi_k3 %} behavior and safeguards, see [Model-specific considerations](#kimi-k3).
+[^kimi-k3]: For important information about {% data variables.copilot.kimi_k3 %} behavior and safeguards, see [Model-specific considerations](#kimi-k3).
 
-Choosing the right model helps you get the most out of {% data variables.product.prodname_copilot_short %}. If you're not sure which model to use, start with a general-purpose option like {% data variables.copilot.copilot_gpt_56_terra %}, then adjust based on your needs.
+Choosing the right model helps you get the most out of {% data variables.product.prodname_copilot_short %}. If you're not sure which model to use, start with a general-purpose option like {% data variables.copilot.gpt_56_terra %}, then adjust based on your needs.
 
 * For detailed model specs and pricing, see [AUTOTITLE](/copilot/reference/ai-models/supported-models).
 * To switch between models, refer to [AUTOTITLE](/copilot/how-tos/copilot-in-your-ide/chat-with-copilot/change-the-chat-model) or [AUTOTITLE](/copilot/how-tos/copilot-in-your-ide/copilot-for-common-tasks/change-the-completion-model).
diff --git a/content/copilot/reference/ai-models/model-hosting.md b/content/copilot/reference/ai-models/model-hosting.md
index 48c7590e495f..f726fadf3e56 100644
--- a/content/copilot/reference/ai-models/model-hosting.md
+++ b/content/copilot/reference/ai-models/model-hosting.md
@@ -18,15 +18,15 @@ contentType: reference
 
 Used for:
 
-* {% data variables.copilot.copilot_gpt_53_codex %}
-* {% data variables.copilot.copilot_gpt_54_nano %}
-* {% data variables.copilot.copilot_gpt_56_luna %}
-* {% data variables.copilot.copilot_gpt_56_sol %}
-* {% data variables.copilot.copilot_gpt_56_terra %}
-* {% data variables.copilot.copilot_gpt_6_astra %}
-* {% data variables.copilot.copilot_gpt_6_luna %}
-* {% data variables.copilot.copilot_gpt_6_sol %}
-* {% data variables.copilot.copilot_gpt_61_sol %}
+* {% data variables.copilot.gpt_53_codex %}
+* {% data variables.copilot.gpt_54_nano %}
+* {% data variables.copilot.gpt_56_luna %}
+* {% data variables.copilot.gpt_56_sol %}
+* {% data variables.copilot.gpt_56_terra %}
+* {% data variables.copilot.gpt_6_astra %}
+* {% data variables.copilot.gpt_6_luna %}
+* {% data variables.copilot.gpt_6_sol %}
+* {% data variables.copilot.gpt_61_sol %}
 
 These models are hosted by OpenAI and {% data variables.product.github %}'s Azure infrastructure.
 
@@ -40,26 +40,26 @@ All input requests and output responses processed by {% data variables.product.p
 
 Used for:
 
-* {% data variables.copilot.copilot_claude_haiku_45 %}
-* {% data variables.copilot.copilot_claude_haiku_55 %}
-* {% data variables.copilot.copilot_claude_sonnet_46 %}
-* {% data variables.copilot.copilot_claude_sonnet_5 %}
-* {% data variables.copilot.copilot_claude_sonnet_55 %}
-* {% data variables.copilot.copilot_claude_opus_48 %}
-* {% data variables.copilot.copilot_claude_opus_48_fast %}
-* {% data variables.copilot.copilot_claude_opus_5 %}
-* {% data variables.copilot.copilot_claude_opus_55 %}
-* {% data variables.copilot.copilot_claude_fable_5 %}
-* {% data variables.copilot.copilot_claude_fable_51 %}
+* {% data variables.copilot.claude_haiku_45 %}
+* {% data variables.copilot.claude_haiku_55 %}
+* {% data variables.copilot.claude_sonnet_46 %}
+* {% data variables.copilot.claude_sonnet_5 %}
+* {% data variables.copilot.claude_sonnet_55 %}
+* {% data variables.copilot.claude_opus_48 %}
+* {% data variables.copilot.claude_opus_48_fast %}
+* {% data variables.copilot.claude_opus_5 %}
+* {% data variables.copilot.claude_opus_55 %}
+* {% data variables.copilot.claude_fable_5 %}
+* {% data variables.copilot.claude_fable_51 %}
 
 > [!WARNING]
-> When {% data variables.copilot.copilot_claude_fable_5 %} or {% data variables.copilot.copilot_claude_fable_51 %} is used, Anthropic retains data, including prompts and outputs, by default to operate safety classifiers that detect harmful use.
+> When {% data variables.copilot.claude_fable_5 %} or {% data variables.copilot.claude_fable_51 %} is used, Anthropic retains data, including prompts and outputs, by default to operate safety classifiers that detect harmful use.
 >
-> Customers can request to use {% data variables.copilot.copilot_claude_fable_5 %} or {% data variables.copilot.copilot_claude_fable_51 %} with zero data retention (ZDR) through the end of 2026 under a time-bound exemption while Anthropic rolls out Enterprise Frontier Safeguards (EFS). After that point, continued use of these models would require EFS, which will enable eligible customers to keep their data under their own control while also enabling automated safety monitoring. For an enterprise that has been approved and configured for this type of access, {% data variables.copilot.copilot_claude_fable_5 %} and {% data variables.copilot.copilot_claude_fable_51 %} requests will use the ZDR endpoint through the end of 2026 when the models are enabled.
+> Customers can request to use {% data variables.copilot.claude_fable_5 %} or {% data variables.copilot.claude_fable_51 %} with zero data retention (ZDR) through the end of 2026 under a time-bound exemption while Anthropic rolls out Enterprise Frontier Safeguards (EFS). After that point, continued use of these models would require EFS, which will enable eligible customers to keep their data under their own control while also enabling automated safety monitoring. For an enterprise that has been approved and configured for this type of access, {% data variables.copilot.claude_fable_5 %} and {% data variables.copilot.claude_fable_51 %} requests will use the ZDR endpoint through the end of 2026 when the models are enabled.
 >
 > To learn whether your enterprise is eligible and request access, contact your {% data variables.product.github %} account team.
 >
-> Approval for access does not automatically enable {% data variables.copilot.copilot_claude_fable_5 %} or {% data variables.copilot.copilot_claude_fable_51 %}. An enterprise or organization administrator must still enable each model before users can access it. Other Claude models, except for {% data variables.copilot.copilot_claude_fable_5 %} and {% data variables.copilot.copilot_claude_fable_51 %}, continue to operate under ZDR.
+> Approval for access does not automatically enable {% data variables.copilot.claude_fable_5 %} or {% data variables.copilot.claude_fable_51 %}. An enterprise or organization administrator must still enable each model before users can access it. Other Claude models, except for {% data variables.copilot.claude_fable_5 %} and {% data variables.copilot.claude_fable_51 %}, continue to operate under ZDR.
 >
 > Customers who enable a Fable model with ZDR agree to use this model only for internal operations, including to develop and evaluate products for their own customers. They may not make the model endpoints or outputs available externally.
 
@@ -67,34 +67,34 @@ These models are hosted by Amazon Web Services, Anthropic PBC, and Google Cloud
 
 * Amazon Bedrock: Amazon makes the [following data commitments](https://docs.aws.amazon.com/bedrock/latest/userguide/data-protection.html): _Amazon Bedrock doesn't store or log your prompts and completions. Amazon Bedrock doesn't use your prompts and completions to train any AWS models and doesn't distribute them to third parties_.
 <!-- markdownlint-disable GHD046 -->
-* Anthropic PBC: {% data variables.product.github %} maintains a [zero data retention agreement](https://privacy.anthropic.com/en/articles/8956058-i-have-a-zero-retention-agreement-with-anthropic-what-products-does-it-apply-to) with Anthropic for generally available Anthropic features in {% data variables.product.prodname_copilot %}. {% data variables.copilot.copilot_claude_fable_5 %} and {% data variables.copilot.copilot_claude_fable_51 %} are not covered by this agreement by default. Enterprises that meet eligibility requirements can use {% data variables.copilot.copilot_claude_fable_5 %} and {% data variables.copilot.copilot_claude_fable_51 %} with zero data retention through the end of 2026 under a separate time-bound exemption; contact your account manager to learn more. Some Anthropic features in beta or {% data variables.release-phases.public_preview %}—including tool search via the Messages API—are also not covered by this agreement. For these features, data may be retained by Anthropic in accordance with [Anthropic's ZDR documentation](https://platform.claude.com/docs/en/build-with-claude/zero-data-retention). {% data variables.product.github %} will update this page as ZDR coverage changes.
+* Anthropic PBC: {% data variables.product.github %} maintains a [zero data retention agreement](https://privacy.anthropic.com/en/articles/8956058-i-have-a-zero-retention-agreement-with-anthropic-what-products-does-it-apply-to) with Anthropic for generally available Anthropic features in {% data variables.product.prodname_copilot %}. {% data variables.copilot.claude_fable_5 %} and {% data variables.copilot.claude_fable_51 %} are not covered by this agreement by default. Enterprises that meet eligibility requirements can use {% data variables.copilot.claude_fable_5 %} and {% data variables.copilot.claude_fable_51 %} with zero data retention through the end of 2026 under a separate time-bound exemption; contact your account manager to learn more. Some Anthropic features in beta or {% data variables.release-phases.public_preview %}—including tool search via the Messages API—are also not covered by this agreement. For these features, data may be retained by Anthropic in accordance with [Anthropic's ZDR documentation](https://platform.claude.com/docs/en/build-with-claude/zero-data-retention). {% data variables.product.github %} will update this page as ZDR coverage changes.
 <!-- markdownlint-enable GHD046 -->
 * Google Cloud: [Google commits to not training on {% data variables.product.github %} data as part of their service terms](https://cloud.google.com/vertex-ai/generative-ai/docs/data-governance). {% data variables.product.github %} is additionally not subject to prompt logging for abuse monitoring.
 
 To provide better service quality and reduce latency, {% data variables.product.github %} uses [prompt caching](https://platform.claude.com/docs/en/build-with-claude/prompt-caching). You can read more about prompt caching on [Anthropic PBC](https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching), [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/prompt-caching.html), and [Google Cloud](https://cloud.google.com/vertex-ai/generative-ai/docs/partner-models/claude-prompt-caching).
 
-When using {% data variables.copilot.copilot_claude %}, input prompts and output completions continue to run through {% data variables.product.prodname_copilot %}'s content filters for public code matching, when applied, along with those for harmful or offensive content.
+When using {% data variables.copilot.claude %}, input prompts and output completions continue to run through {% data variables.product.prodname_copilot %}'s content filters for public code matching, when applied, along with those for harmful or offensive content.
 
 ## Google models
 
 Used for:
 
-* {% data variables.copilot.copilot_gemini_38_flash %}
-* {% data variables.copilot.copilot_gemini_4_argon %}
+* {% data variables.copilot.gemini_38_flash %}
+* {% data variables.copilot.gemini_4_argon %}
 
-{% data variables.product.prodname_copilot %} uses {% data variables.copilot.copilot_gemini %} models hosted on Google Cloud Platform (GCP). When using {% data variables.copilot.copilot_gemini %} models, prompts and metadata are sent to GCP, which makes the [following data commitment](https://cloud.google.com/vertex-ai/generative-ai/docs/data-governance): _{% data variables.copilot.copilot_gemini %} doesn't use your prompts, or its responses, as data to train its models._
+{% data variables.product.prodname_copilot %} uses {% data variables.copilot.gemini %} models hosted on Google Cloud Platform (GCP). When using {% data variables.copilot.gemini %} models, prompts and metadata are sent to GCP, which makes the [following data commitment](https://cloud.google.com/vertex-ai/generative-ai/docs/data-governance): _{% data variables.copilot.gemini %} doesn't use your prompts, or its responses, as data to train its models._
 
 To provide better service quality and reduce latency, {% data variables.product.github %} uses [Google's Durable Caching](https://docs.cloud.google.com/gemini-enterprise-agent-platform/resources/zero-data-retention#durable-data-caching). Cached data is encrypted and held for up to 24 hours. Cached data is never used to train or fine-tune models.
 
-When using {% data variables.copilot.copilot_gemini %} models, input prompts and output completions continue to run through {% data variables.product.prodname_copilot %}'s content filters for public code matching, when applied, along with those for harmful or offensive content.
+When using {% data variables.copilot.gemini %} models, input prompts and output completions continue to run through {% data variables.product.prodname_copilot %}'s content filters for public code matching, when applied, along with those for harmful or offensive content.
 
 ## xAI models
 
 Used for:
 
-* {% data variables.copilot.copilot_grok_45 %}
-* {% data variables.copilot.copilot_grok_46 %}
-* {% data variables.copilot.copilot_grok_47 %}
+* {% data variables.copilot.grok_45 %}
+* {% data variables.copilot.grok_46 %}
+* {% data variables.copilot.grok_47 %}
 
 These models are hosted on xAI. xAI operates these models in {% data variables.product.prodname_copilot %} under a zero data retention API policy. This means xAI commits that user content (both inputs sent to the model and outputs generated by the model):
 
@@ -114,15 +114,15 @@ When using xAI, input prompts and output completions continue to run through {%
 
 Used for:
 
-* {% data variables.copilot.copilot_mai_code_1_1_flash %}
+* {% data variables.copilot.mai_code_1_1_flash %}
 
-{% data variables.copilot.copilot_mai_code_1_1_flash %} is a first-party Microsoft model hosted on Azure in {% data variables.product.github %}'s tenant.
+{% data variables.copilot.mai_code_1_1_flash %} is a first-party Microsoft model hosted on Azure in {% data variables.product.github %}'s tenant.
 
 {% data variables.product.github %} does not use {% data variables.copilot.copilot_business_short %} or {% data variables.copilot.copilot_enterprise_short %} customer data to train AI models. For individual subscribers—{% data variables.copilot.copilot_free_short %}, {% data variables.copilot.copilot_pro_short %}, {% data variables.copilot.copilot_pro_plus_short %}, and {% data variables.copilot.copilot_max_short %} users—{% data variables.product.github %} may use {% data variables.product.prodname_copilot_short %} interaction data, including prompts (inputs), suggestions (outputs), and code snippets generated during {% data variables.product.prodname_copilot_short %} sessions to train and improve AI models, in accordance with our [AUTOTITLE](/free-pro-team@latest/site-policy/privacy-policies/github-general-privacy-statement) and applicable user settings. Individual subscribers can opt out of having their data used for AI model training. To manage this setting, see [AUTOTITLE](/copilot/how-tos/manage-your-account/manage-policies#model-training-and-improvements).
 
-{% data variables.copilot.copilot_mai_code_1_1_flash %} is served on Microsoft Azure AI Foundry within {% data variables.product.github %}'s tenant and is subject to {% data variables.product.github %}'s data handling configuration for that deployment. For details about how data is processed, retained, and secured for models served on Azure AI Foundry, see [Data, privacy, and security for Foundry Models sold by Azure](https://learn.microsoft.com/en-us/azure/foundry/responsible-ai/openai/data-privacy?tabs=azure-portal) in the Microsoft documentation.
+{% data variables.copilot.mai_code_1_1_flash %} is served on Microsoft Azure AI Foundry within {% data variables.product.github %}'s tenant and is subject to {% data variables.product.github %}'s data handling configuration for that deployment. For details about how data is processed, retained, and secured for models served on Azure AI Foundry, see [Data, privacy, and security for Foundry Models sold by Azure](https://learn.microsoft.com/en-us/azure/foundry/responsible-ai/openai/data-privacy?tabs=azure-portal) in the Microsoft documentation.
 
-When using {% data variables.copilot.copilot_mai_code_1_1_flash %}, input prompts and output completions continue to run through {% data variables.product.prodname_copilot %}'s content filters for public code matching, when applied, along with those for harmful or offensive content.
+When using {% data variables.copilot.mai_code_1_1_flash %}, input prompts and output completions continue to run through {% data variables.product.prodname_copilot %}'s content filters for public code matching, when applied, along with those for harmful or offensive content.
 
 ## Open-weight models
 
@@ -132,17 +132,17 @@ Open-weight models have publicly available weights. {% data reusables.copilot.op
 
 Used for:
 
-* {% data variables.copilot.copilot_kimi_k3 %}
+* {% data variables.copilot.kimi_k3 %}
 
-{% data variables.copilot.copilot_kimi_k3 %} was developed by Moonshot AI. It is an open-weight model that may be less aligned than other {% data variables.product.prodname_copilot_short %} models, with an elevated risk of geographic bias. Before you enable the model, review the [{% data variables.copilot.copilot_kimi_k3 %} model card](https://huggingface.co/moonshotai/Kimi-K3) and run your own evaluations.
+{% data variables.copilot.kimi_k3 %} was developed by Moonshot AI. It is an open-weight model that may be less aligned than other {% data variables.product.prodname_copilot_short %} models, with an elevated risk of geographic bias. Before you enable the model, review the [{% data variables.copilot.kimi_k3 %} model card](https://huggingface.co/moonshotai/Kimi-K3) and run your own evaluations.
 
-{% data variables.copilot.copilot_kimi_k3 %} is hosted by {% data variables.product.github %} on Fireworks AI.
+{% data variables.copilot.kimi_k3 %} is hosted by {% data variables.product.github %} on Fireworks AI.
 
-{% data variables.copilot.copilot_kimi_k3 %} is covered by a zero data retention agreement with the hosting provider. Fireworks AI does not use prompts or completions to train models, and prompts and completions are not sent to Moonshot AI.
+{% data variables.copilot.kimi_k3 %} is covered by a zero data retention agreement with the hosting provider. Fireworks AI does not use prompts or completions to train models, and prompts and completions are not sent to Moonshot AI.
 
 {% data variables.product.github %} does not use {% data variables.copilot.copilot_business_short %} or {% data variables.copilot.copilot_enterprise_short %} customer data to train AI models. For individual subscribers—{% data variables.copilot.copilot_free_short %}, {% data variables.copilot.copilot_pro_short %}, {% data variables.copilot.copilot_pro_plus_short %}, and {% data variables.copilot.copilot_max_short %} users—{% data variables.product.github %} may use {% data variables.product.prodname_copilot_short %} interaction data, including prompts (inputs), suggestions (outputs), and code snippets generated during {% data variables.product.prodname_copilot_short %} sessions to train and improve AI models, in accordance with our [AUTOTITLE](/free-pro-team@latest/site-policy/privacy-policies/github-general-privacy-statement) and applicable user settings. Individual subscribers can opt out of having their data used for AI model training. To manage this setting, see [AUTOTITLE](/copilot/how-tos/manage-your-account/manage-policies#model-training-and-improvements).
 
-When using {% data variables.copilot.copilot_kimi_k3 %}, input prompts and output completions continue to run through {% data variables.product.prodname_copilot %}'s content filters.
+When using {% data variables.copilot.kimi_k3 %}, input prompts and output completions continue to run through {% data variables.product.prodname_copilot %}'s content filters.
 
 ## Inline suggestions
 
diff --git a/content/copilot/reference/ai-models/supported-models.md b/content/copilot/reference/ai-models/supported-models.md
index a31ebb1d5520..bb40b4be56f2 100644
--- a/content/copilot/reference/ai-models/supported-models.md
+++ b/content/copilot/reference/ai-models/supported-models.md
@@ -44,11 +44,11 @@ This table lists the AI models available in {% data variables.product.prodname_c
 
 {% endrowheaders %}
 
-[^claude-fable-5]: When {% data variables.copilot.copilot_claude_fable_5 %} or {% data variables.copilot.copilot_claude_fable_51 %} is used, Anthropic retains data, including prompts and outputs, by default to operate safety classifiers that detect harmful use. Customers can request to use {% data variables.copilot.copilot_claude_fable_5 %} or {% data variables.copilot.copilot_claude_fable_51 %} with zero data retention (ZDR) through the end of 2026 under a time-bound exemption while Anthropic rolls out Enterprise Frontier Safeguards (EFS). After that point, continued use of these models would require EFS, which will enable eligible customers to keep their data under their own control while also enabling automated safety monitoring. For an enterprise that has been approved and configured for this type of access, {% data variables.copilot.copilot_claude_fable_5 %} and {% data variables.copilot.copilot_claude_fable_51 %} requests will use the ZDR endpoint through the end of 2026 when the models are enabled. To learn whether your enterprise is eligible and request access, contact your {% data variables.product.github %} account team. Approval for access does not automatically enable {% data variables.copilot.copilot_claude_fable_5 %} or {% data variables.copilot.copilot_claude_fable_51 %}. An enterprise or organization administrator must still enable each model before users can access it. Other Claude models, except for {% data variables.copilot.copilot_claude_fable_5 %} and {% data variables.copilot.copilot_claude_fable_51 %}, continue to operate under ZDR. Customers who enable a Fable model with ZDR agree to use this model only for internal operations, including to develop and evaluate products for their own customers. They may not make the model endpoints or outputs available externally. To enable these models, see [AUTOTITLE](/copilot/how-tos/copilot-on-github/set-up-copilot/configure-access-to-ai-models).
+[^claude-fable-5]: When {% data variables.copilot.claude_fable_5 %} or {% data variables.copilot.claude_fable_51 %} is used, Anthropic retains data, including prompts and outputs, by default to operate safety classifiers that detect harmful use. Customers can request to use {% data variables.copilot.claude_fable_5 %} or {% data variables.copilot.claude_fable_51 %} with zero data retention (ZDR) through the end of 2026 under a time-bound exemption while Anthropic rolls out Enterprise Frontier Safeguards (EFS). After that point, continued use of these models would require EFS, which will enable eligible customers to keep their data under their own control while also enabling automated safety monitoring. For an enterprise that has been approved and configured for this type of access, {% data variables.copilot.claude_fable_5 %} and {% data variables.copilot.claude_fable_51 %} requests will use the ZDR endpoint through the end of 2026 when the models are enabled. To learn whether your enterprise is eligible and request access, contact your {% data variables.product.github %} account team. Approval for access does not automatically enable {% data variables.copilot.claude_fable_5 %} or {% data variables.copilot.claude_fable_51 %}. An enterprise or organization administrator must still enable each model before users can access it. Other Claude models, except for {% data variables.copilot.claude_fable_5 %} and {% data variables.copilot.claude_fable_51 %}, continue to operate under ZDR. Customers who enable a Fable model with ZDR agree to use this model only for internal operations, including to develop and evaluate products for their own customers. They may not make the model endpoints or outputs available externally. To enable these models, see [AUTOTITLE](/copilot/how-tos/copilot-on-github/set-up-copilot/configure-access-to-ai-models).
 
 ## Supported AI models in {% data variables.copilot.copilot_auto_model_selection_short_cap_a %}
 
-This table lists the supported AI models for {% data variables.copilot.copilot_auto_model_selection_short_cap_a %}. Available models may be limited by model policies. For example, as the long term support model, {% data variables.copilot.copilot_gpt_53_codex %} will be used in the event no other models are available. See [AUTOTITLE](/copilot/concepts/models/fallback-and-lts-models) and [AUTOTITLE](/copilot/concepts/models/auto-model-selection).
+This table lists the supported AI models for {% data variables.copilot.copilot_auto_model_selection_short_cap_a %}. Available models may be limited by model policies. For example, as the long term support model, {% data variables.copilot.gpt_53_codex %} will be used in the event no other models are available. See [AUTOTITLE](/copilot/concepts/models/fallback-and-lts-models) and [AUTOTITLE](/copilot/concepts/models/auto-model-selection).
 
 {% rowheaders %}
 
@@ -78,25 +78,25 @@ Choosing a larger context window or higher reasoning will impact {% data variabl
 
 | Model | 1 million token context window | Configurable reasoning |
 | --- | --- | --- |
-| {% data variables.copilot.copilot_claude_sonnet_46 %} | {% octicon "check" aria-label="Supported" %} | {% octicon "check" aria-label="Supported" %} |
-| {% data variables.copilot.copilot_claude_opus_48 %} | {% octicon "check" aria-label="Supported" %} | {% octicon "check" aria-label="Supported" %} |
-| {% data variables.copilot.copilot_claude_opus_5 %} | {% octicon "check" aria-label="Supported" %} | {% octicon "check" aria-label="Supported" %} |
-| {% data variables.copilot.copilot_claude_opus_55 %} | {% octicon "check" aria-label="Supported" %} | {% octicon "check" aria-label="Supported" %} |
-| {% data variables.copilot.copilot_claude_sonnet_5 %} | {% octicon "check" aria-label="Supported" %} | {% octicon "check" aria-label="Supported" %} |
-| {% data variables.copilot.copilot_claude_sonnet_55 %} | {% octicon "check" aria-label="Supported" %} | {% octicon "check" aria-label="Supported" %} |
-| {% data variables.copilot.copilot_claude_haiku_55 %} | {% octicon "check" aria-label="Supported" %} | {% octicon "check" aria-label="Supported" %} |
-| {% data variables.copilot.copilot_claude_opus_48_fast %} | {% octicon "x" aria-label="Not supported" %} | {% octicon "check" aria-label="Supported" %} |
-| {% data variables.copilot.copilot_claude_fable_5 %} | {% octicon "check" aria-label="Supported" %} | {% octicon "check" aria-label="Supported" %} |
-| {% data variables.copilot.copilot_claude_fable_51 %} | {% octicon "check" aria-label="Supported" %} | {% octicon "check" aria-label="Supported" %} |
-| {% data variables.copilot.copilot_gpt_53_codex %} | {% octicon "check" aria-label="Supported" %} | {% octicon "check" aria-label="Supported" %} |
-| {% data variables.copilot.copilot_gpt_56_luna %} | {% octicon "check" aria-label="Supported" %} | {% octicon "check" aria-label="Supported" %} |
-| {% data variables.copilot.copilot_gpt_56_sol %} | {% octicon "check" aria-label="Supported" %} | {% octicon "check" aria-label="Supported" %} |
-| {% data variables.copilot.copilot_gpt_56_terra %} | {% octicon "check" aria-label="Supported" %} | {% octicon "check" aria-label="Supported" %} |
-| {% data variables.copilot.copilot_gpt_6_astra %} | {% octicon "check" aria-label="Supported" %} | {% octicon "check" aria-label="Supported" %} |
-| {% data variables.copilot.copilot_gpt_6_luna %} | {% octicon "check" aria-label="Supported" %} | {% octicon "check" aria-label="Supported" %} |
-| {% data variables.copilot.copilot_gpt_6_sol %} | {% octicon "check" aria-label="Supported" %} | {% octicon "check" aria-label="Supported" %} |
-| {% data variables.copilot.copilot_gpt_61_sol %} | {% octicon "check" aria-label="Supported" %} | {% octicon "check" aria-label="Supported" %} |
-| {% data variables.copilot.copilot_kimi_k3 %} | {% octicon "check" aria-label="Supported" %} | {% octicon "check" aria-label="Supported" %} |
+| {% data variables.copilot.claude_sonnet_46 %} | {% octicon "check" aria-label="Supported" %} | {% octicon "check" aria-label="Supported" %} |
+| {% data variables.copilot.claude_opus_48 %} | {% octicon "check" aria-label="Supported" %} | {% octicon "check" aria-label="Supported" %} |
+| {% data variables.copilot.claude_opus_5 %} | {% octicon "check" aria-label="Supported" %} | {% octicon "check" aria-label="Supported" %} |
+| {% data variables.copilot.claude_opus_55 %} | {% octicon "check" aria-label="Supported" %} | {% octicon "check" aria-label="Supported" %} |
+| {% data variables.copilot.claude_sonnet_5 %} | {% octicon "check" aria-label="Supported" %} | {% octicon "check" aria-label="Supported" %} |
+| {% data variables.copilot.claude_sonnet_55 %} | {% octicon "check" aria-label="Supported" %} | {% octicon "check" aria-label="Supported" %} |
+| {% data variables.copilot.claude_haiku_55 %} | {% octicon "check" aria-label="Supported" %} | {% octicon "check" aria-label="Supported" %} |
+| {% data variables.copilot.claude_opus_48_fast %} | {% octicon "x" aria-label="Not supported" %} | {% octicon "check" aria-label="Supported" %} |
+| {% data variables.copilot.claude_fable_5 %} | {% octicon "check" aria-label="Supported" %} | {% octicon "check" aria-label="Supported" %} |
+| {% data variables.copilot.claude_fable_51 %} | {% octicon "check" aria-label="Supported" %} | {% octicon "check" aria-label="Supported" %} |
+| {% data variables.copilot.gpt_53_codex %} | {% octicon "check" aria-label="Supported" %} | {% octicon "check" aria-label="Supported" %} |
+| {% data variables.copilot.gpt_56_luna %} | {% octicon "check" aria-label="Supported" %} | {% octicon "check" aria-label="Supported" %} |
+| {% data variables.copilot.gpt_56_sol %} | {% octicon "check" aria-label="Supported" %} | {% octicon "check" aria-label="Supported" %} |
+| {% data variables.copilot.gpt_56_terra %} | {% octicon "check" aria-label="Supported" %} | {% octicon "check" aria-label="Supported" %} |
+| {% data variables.copilot.gpt_6_astra %} | {% octicon "check" aria-label="Supported" %} | {% octicon "check" aria-label="Supported" %} |
+| {% data variables.copilot.gpt_6_luna %} | {% octicon "check" aria-label="Supported" %} | {% octicon "check" aria-label="Supported" %} |
+| {% data variables.copilot.gpt_6_sol %} | {% octicon "check" aria-label="Supported" %} | {% octicon "check" aria-label="Supported" %} |
+| {% data variables.copilot.gpt_61_sol %} | {% octicon "check" aria-label="Supported" %} | {% octicon "check" aria-label="Supported" %} |
+| {% data variables.copilot.kimi_k3 %} | {% octicon "check" aria-label="Supported" %} | {% octicon "check" aria-label="Supported" %} |
 
 {% endrowheaders %}
 
@@ -125,35 +125,35 @@ Some {% data variables.product.prodname_copilot_short %} models require minimum
 
 | Model                                                    | {% data variables.product.prodname_vscode %} | {% data variables.product.prodname_vs %} | JetBrains IDEs | Xcode | Eclipse |
 |----------------------------------------------------------|----------------------------------------------|------------------------------------------|----------------|-------|---------|
-| {% data variables.copilot.copilot_gemini_38_flash %}     | TBD | `17.14.22` or `18.1.0`         | TBD | TBD | TBD |
-| {% data variables.copilot.copilot_gemini_4_argon %}      | TBD | `17.14.22` or `18.1.0`         | TBD | TBD | TBD |
-| {% data variables.copilot.copilot_gpt_53_codex %}        | `v1.104.1` | `17.14.19`                     | `1.5.61` | `0.45.0` | `0.13.0` |
-| {% data variables.copilot.copilot_gpt_56_luna %}         | `1.128.0` | TBD | TBD | TBD | TBD |
-| {% data variables.copilot.copilot_gpt_56_sol %}          | `1.128.0` | TBD | TBD | TBD | TBD |
-| {% data variables.copilot.copilot_gpt_56_terra %}        | `1.128.0` | TBD | TBD | TBD | TBD |
-| {% data variables.copilot.copilot_gpt_6_astra %}         | `1.136.1` | `17.14.19` | TBD | TBD | TBD |
-| {% data variables.copilot.copilot_gpt_6_luna %}          | TBD | `17.14.19` | TBD | TBD | TBD |
-| {% data variables.copilot.copilot_gpt_6_sol %}           | TBD | `17.14.19` | TBD | TBD | TBD |
-| {% data variables.copilot.copilot_gpt_61_sol %}          | TBD | `17.14.19` | TBD | TBD | TBD |
-| {% data variables.copilot.copilot_claude_opus_48 %}      | `v1.118` | `17.14.6`                     | TBD | TBD | TBD |
-| {% data variables.copilot.copilot_claude_opus_5 %}       | `v1.128.0` | `17.14.22` | TBD | TBD | TBD |
-| {% data variables.copilot.copilot_claude_opus_55 %}      | TBD | `17.14.6` | TBD | TBD | TBD |
-| {% data variables.copilot.copilot_claude_sonnet_5 %}  | `v1.124` | `17.14.6` | TBD | TBD | TBD |
-| {% data variables.copilot.copilot_claude_sonnet_55 %} | TBD | `17.14.6` | TBD | TBD | TBD |
-| {% data variables.copilot.copilot_claude_haiku_55 %}  | TBD | TBD | TBD | TBD | TBD |
-| {% data variables.copilot.copilot_claude_fable_5 %}      | `v1.124` | `17.14.6`                    | TBD | TBD | TBD |
-| {% data variables.copilot.copilot_claude_fable_51 %}    | TBD | TBD                    | TBD | TBD | TBD |
-| {% data variables.copilot.copilot_kimi_k3 %}     | `v1.131` | TBD            | TBD | TBD | TBD |
-| {% data variables.copilot.copilot_mai_code_1_1_flash %}  | `v1.121` | TBD                            | TBD | TBD | TBD |
-| {% data variables.copilot.copilot_grok_45 %}             | TBD | `17.14.19` | TBD | TBD | TBD |
-| {% data variables.copilot.copilot_grok_46 %}             | TBD | TBD | TBD | TBD | TBD |
-| {% data variables.copilot.copilot_grok_47 %}             | TBD | `17.14.19` | TBD | TBD | TBD |
+| {% data variables.copilot.gemini_38_flash %}     | TBD | `17.14.22` or `18.1.0`         | TBD | TBD | TBD |
+| {% data variables.copilot.gemini_4_argon %}      | TBD | `17.14.22` or `18.1.0`         | TBD | TBD | TBD |
+| {% data variables.copilot.gpt_53_codex %}        | `v1.104.1` | `17.14.19`                     | `1.5.61` | `0.45.0` | `0.13.0` |
+| {% data variables.copilot.gpt_56_luna %}         | `1.128.0` | TBD | TBD | TBD | TBD |
+| {% data variables.copilot.gpt_56_sol %}          | `1.128.0` | TBD | TBD | TBD | TBD |
+| {% data variables.copilot.gpt_56_terra %}        | `1.128.0` | TBD | TBD | TBD | TBD |
+| {% data variables.copilot.gpt_6_astra %}         | `1.136.1` | `17.14.19` | TBD | TBD | TBD |
+| {% data variables.copilot.gpt_6_luna %}          | TBD | `17.14.19` | TBD | TBD | TBD |
+| {% data variables.copilot.gpt_6_sol %}           | TBD | `17.14.19` | TBD | TBD | TBD |
+| {% data variables.copilot.gpt_61_sol %}          | TBD | `17.14.19` | TBD | TBD | TBD |
+| {% data variables.copilot.claude_opus_48 %}      | `v1.118` | `17.14.6`                     | TBD | TBD | TBD |
+| {% data variables.copilot.claude_opus_5 %}       | `v1.128.0` | `17.14.22` | TBD | TBD | TBD |
+| {% data variables.copilot.claude_opus_55 %}      | TBD | `17.14.6` | TBD | TBD | TBD |
+| {% data variables.copilot.claude_sonnet_5 %}  | `v1.124` | `17.14.6` | TBD | TBD | TBD |
+| {% data variables.copilot.claude_sonnet_55 %} | TBD | `17.14.6` | TBD | TBD | TBD |
+| {% data variables.copilot.claude_haiku_55 %}  | TBD | TBD | TBD | TBD | TBD |
+| {% data variables.copilot.claude_fable_5 %}      | `v1.124` | `17.14.6`                    | TBD | TBD | TBD |
+| {% data variables.copilot.claude_fable_51 %}    | TBD | TBD                    | TBD | TBD | TBD |
+| {% data variables.copilot.kimi_k3 %}     | `v1.131` | TBD            | TBD | TBD | TBD |
+| {% data variables.copilot.mai_code_1_1_flash %}  | `v1.121` | TBD                            | TBD | TBD | TBD |
+| {% data variables.copilot.grok_45 %}             | TBD | `17.14.19` | TBD | TBD | TBD |
+| {% data variables.copilot.grok_46 %}             | TBD | TBD | TBD | TBD | TBD |
+| {% data variables.copilot.grok_47 %}             | TBD | `17.14.19` | TBD | TBD | TBD |
 
 {% endrowheaders %}
 
 > [!NOTE]
 >
-> * For {% data variables.copilot.copilot_gpt_53_codex %} in {% data variables.product.prodname_vscode %}, `v1.108` and later provide improved prompting and response quality.
+> * For {% data variables.copilot.gpt_53_codex %} in {% data variables.product.prodname_vscode %}, `v1.108` and later provide improved prompting and response quality.
 > * "No minimum listed" means the reviewed changelog or release guidance did not specify a minimum version, not that all older versions are supported.
 > * Even when a model appears in the model picker on older supported versions, prompting and model behavior may work best with the latest IDE and {% data variables.product.prodname_copilot_short %} extension or plugin versions.
 
@@ -218,7 +218,7 @@ The following table lists AI models that are retired or scheduled for retirement
 
 {% endrowheaders %}
 
-[^claude-sonnet-46-annual]: {% data variables.copilot.copilot_claude_sonnet_46 %} remains available to individual {% data variables.product.prodname_copilot_short %} subscribers on annual plans. The retirement of {% data variables.copilot.copilot_claude_sonnet_46 %} does not apply to these subscribers.
+[^claude-sonnet-46-annual]: {% data variables.copilot.claude_sonnet_46 %} remains available to individual {% data variables.product.prodname_copilot_short %} subscribers on annual plans. The retirement of {% data variables.copilot.claude_sonnet_46 %} does not apply to these subscribers.
 
 ## Next steps
 
diff --git a/content/copilot/reference/copilot-billing/models-and-pricing.md b/content/copilot/reference/copilot-billing/models-and-pricing.md
index 0d193afb7f01..c35f81c2b76f 100644
--- a/content/copilot/reference/copilot-billing/models-and-pricing.md
+++ b/content/copilot/reference/copilot-billing/models-and-pricing.md
@@ -33,7 +33,7 @@ All prices are **per 1 million tokens**.
 
 {% data reusables.copilot.extended-context-pricing %}
 
-{% data variables.copilot.copilot_gpt_56_sol %}, {% data variables.copilot.copilot_gpt_56_terra %}, {% data variables.copilot.copilot_gpt_56_luna %}, {% data variables.copilot.copilot_gpt_6_astra %}, {% data variables.copilot.copilot_gpt_6_luna %}, {% data variables.copilot.copilot_gpt_6_sol %}, and {% data variables.copilot.copilot_gpt_61_sol %} include a cache write cost in addition to cached input. Earlier OpenAI models have no cache write cost.
+{% data variables.copilot.gpt_56_sol %}, {% data variables.copilot.gpt_56_terra %}, {% data variables.copilot.gpt_56_luna %}, {% data variables.copilot.gpt_6_astra %}, {% data variables.copilot.gpt_6_luna %}, {% data variables.copilot.gpt_6_sol %}, and {% data variables.copilot.gpt_61_sol %} include a cache write cost in addition to cached input. Earlier OpenAI models have no cache write cost.
 
 | Model | Release status | Category | Tier | Threshold (input tokens) | Input | Cached input | Cache write | Output |
 | --- | --- | --- | --- | --- | ---: | ---: | ---: | ---: |
@@ -120,10 +120,10 @@ You can view your current {% data variables.product.prodname_actions %} usage fo
 
 {% data variables.copilot.copilot_pro_short %} and {% data variables.copilot.copilot_pro_plus_short %} subscribers on **existing annual billing plans** using the **request-based billing** model have different model multipliers. See [AUTOTITLE](/copilot/reference/copilot-billing/request-based-billing-legacy/model-multipliers-for-annual-plans).
 
-[^gemini-flash-promo]: {% data variables.copilot.copilot_gemini_38_flash %} is available at the promotional pricing of $0.75 per 1M input tokens, $0.075 per 1M cached input tokens, and $3.75 per 1M output tokens through December 31, 2026.
+[^gemini-flash-promo]: {% data variables.copilot.gemini_38_flash %} is available at the promotional pricing of $0.75 per 1M input tokens, $0.075 per 1M cached input tokens, and $3.75 per 1M output tokens through December 31, 2026.
 
 <!-- expires 2026-12-01 -->
 
-[^gemini-4-argon-promo]: {% data variables.copilot.copilot_gemini_4_argon %} is available at the promotional pricing of $2.00 per 1M input tokens, $0.10 per 1M cached input tokens, and $10.00 per 1M output tokens until December 1, 2026.
+[^gemini-4-argon-promo]: {% data variables.copilot.gemini_4_argon %} is available at the promotional pricing of $2.00 per 1M input tokens, $0.10 per 1M cached input tokens, and $10.00 per 1M output tokens until December 1, 2026.
 
 <!-- end expires 2026-12-01 -->
diff --git a/content/copilot/reference/copilot-billing/request-based-billing-legacy/model-multipliers-for-annual-plans.md b/content/copilot/reference/copilot-billing/request-based-billing-legacy/model-multipliers-for-annual-plans.md
index 81098d27e996..20e4e5a183d2 100644
--- a/content/copilot/reference/copilot-billing/request-based-billing-legacy/model-multipliers-for-annual-plans.md
+++ b/content/copilot/reference/copilot-billing/request-based-billing-legacy/model-multipliers-for-annual-plans.md
@@ -33,7 +33,7 @@ The following table shows the model multipliers per supported model.
 > [!NOTE]
 > The multiplier for these models are subject to change.
 >
-> * {% data variables.copilot.copilot_claude_sonnet_46 %}
+> * {% data variables.copilot.claude_sonnet_46 %}
 > 
 > If you use {% data variables.copilot.copilot_auto_model_selection_short %} in {% data variables.copilot.copilot_chat_short %}, {% data variables.copilot.copilot_cli_short %}, the {% data variables.copilot.github_copilot_app %}, or {% data variables.copilot.copilot_cloud_agent %}, you qualify for a 10% discount. For example, if a model has a multiplier of 1x you'll be billed at 0.9x instead.
 
diff --git a/content/copilot/tutorials/vibe-coding.md b/content/copilot/tutorials/vibe-coding.md
index 210331f0ae21..b422e4a32714 100644
--- a/content/copilot/tutorials/vibe-coding.md
+++ b/content/copilot/tutorials/vibe-coding.md
@@ -71,7 +71,7 @@ We'll create a time-tracking app in a new {% data variables.product.github %} re
 1. Choose a model from the models dropdown.
 
    > [!NOTE]
-   > The responses referred to in this tutorial were received while using {% data variables.copilot.copilot_claude_sonnet_45 %}, which has since been retired. Other models will respond differently, but you should get roughly similar results.
+   > The responses referred to in this tutorial were received while using {% data variables.copilot.claude_sonnet_45 %}, which has since been retired. Other models will respond differently, but you should get roughly similar results.
    >
    > Set the model to **Auto**, or select a model of your choice.
 
diff --git a/data/reusables/copilot/agentic-workflows-third-party-agent-clis.md b/data/reusables/copilot/agentic-workflows-third-party-agent-clis.md
index f33a0a931eda..0345bca19b50 100644
--- a/data/reusables/copilot/agentic-workflows-third-party-agent-clis.md
+++ b/data/reusables/copilot/agentic-workflows-third-party-agent-clis.md
@@ -1 +1 @@
-Claude Code, {% data variables.product.prodname_openai_codex %}, or Google {% data variables.copilot.copilot_gemini %} CLI
+Claude Code, {% data variables.product.prodname_openai_codex %}, or Google {% data variables.copilot.gemini %} CLI
diff --git a/data/reusables/copilot/anthropic-claude-agent-models.md b/data/reusables/copilot/anthropic-claude-agent-models.md
index 132cd68a834c..e52cccd31b2a 100644
--- a/data/reusables/copilot/anthropic-claude-agent-models.md
+++ b/data/reusables/copilot/anthropic-claude-agent-models.md
@@ -1,6 +1,6 @@
-* {% data variables.copilot.copilot_claude_sonnet_46 %}
-* {% data variables.copilot.copilot_claude_sonnet_5 %}
-* {% data variables.copilot.copilot_claude_opus_48 %}
-* {% data variables.copilot.copilot_claude_opus_48_fast %}
-* {% data variables.copilot.copilot_claude_opus_5 %}
-* {% data variables.copilot.copilot_claude_fable_51 %}
+* {% data variables.copilot.claude_sonnet_46 %}
+* {% data variables.copilot.claude_sonnet_5 %}
+* {% data variables.copilot.claude_opus_48 %}
+* {% data variables.copilot.claude_opus_48_fast %}
+* {% data variables.copilot.claude_opus_5 %}
+* {% data variables.copilot.claude_fable_51 %}
diff --git a/data/reusables/copilot/available-models-per-plan.md b/data/reusables/copilot/available-models-per-plan.md
index 6efe53aa7921..323d33a090c9 100644
--- a/data/reusables/copilot/available-models-per-plan.md
+++ b/data/reusables/copilot/available-models-per-plan.md
@@ -12,4 +12,4 @@
 
 [^gpt54nano]: GPT-5.4 nano is currently only available in the Codex {% data variables.product.prodname_vscode %} extension ({% data variables.copilot.copilot_pro_plus_short %} only) and is not available in {% data variables.copilot.copilot_chat_short %}.
 
-[^claude-sonnet-46-plans]: {% data variables.copilot.copilot_claude_sonnet_46 %} was retired on September 1, 2026, but remains available to individual {% data variables.product.prodname_copilot_short %} subscribers on annual {% data variables.copilot.copilot_pro_short %} and {% data variables.copilot.copilot_pro_plus_short %} plans. It is not available to subscribers on monthly plans.
+[^claude-sonnet-46-plans]: {% data variables.copilot.claude_sonnet_46 %} was retired on September 1, 2026, but remains available to individual {% data variables.product.prodname_copilot_short %} subscribers on annual {% data variables.copilot.copilot_pro_short %} and {% data variables.copilot.copilot_pro_plus_short %} plans. It is not available to subscribers on monthly plans.
diff --git a/data/reusables/copilot/copilot-cloud-agent-non-auto-models.md b/data/reusables/copilot/copilot-cloud-agent-non-auto-models.md
index 6da4ff46e703..df58864e20f6 100644
--- a/data/reusables/copilot/copilot-cloud-agent-non-auto-models.md
+++ b/data/reusables/copilot/copilot-cloud-agent-non-auto-models.md
@@ -1,18 +1,18 @@
-* {% data variables.copilot.copilot_claude_opus_5 %}
-* {% data variables.copilot.copilot_claude_opus_55 %}
-* {% data variables.copilot.copilot_claude_sonnet_55 %}
-* {% data variables.copilot.copilot_claude_haiku_45 %}
-* {% data variables.copilot.copilot_claude_haiku_55 %}
-* {% data variables.copilot.copilot_gemini_38_flash %}
-* {% data variables.copilot.copilot_gemini_4_argon %}
-* {% data variables.copilot.copilot_gpt_56_luna %}
-* {% data variables.copilot.copilot_gpt_56_sol %}
-* {% data variables.copilot.copilot_gpt_56_terra %}
-* {% data variables.copilot.copilot_gpt_6_astra %}
-* {% data variables.copilot.copilot_gpt_6_luna %}
-* {% data variables.copilot.copilot_gpt_6_sol %}
-* {% data variables.copilot.copilot_gpt_61_sol %}
-* {% data variables.copilot.copilot_grok_45 %}
-* {% data variables.copilot.copilot_grok_46 %}
-* {% data variables.copilot.copilot_grok_47 %}
-* {% data variables.copilot.copilot_mai_code_1_1_flash %}
+* {% data variables.copilot.claude_opus_5 %}
+* {% data variables.copilot.claude_opus_55 %}
+* {% data variables.copilot.claude_sonnet_55 %}
+* {% data variables.copilot.claude_haiku_45 %}
+* {% data variables.copilot.claude_haiku_55 %}
+* {% data variables.copilot.gemini_38_flash %}
+* {% data variables.copilot.gemini_4_argon %}
+* {% data variables.copilot.gpt_56_luna %}
+* {% data variables.copilot.gpt_56_sol %}
+* {% data variables.copilot.gpt_56_terra %}
+* {% data variables.copilot.gpt_6_astra %}
+* {% data variables.copilot.gpt_6_luna %}
+* {% data variables.copilot.gpt_6_sol %}
+* {% data variables.copilot.gpt_61_sol %}
+* {% data variables.copilot.grok_45 %}
+* {% data variables.copilot.grok_46 %}
+* {% data variables.copilot.grok_47 %}
+* {% data variables.copilot.mai_code_1_1_flash %}
diff --git a/data/reusables/copilot/model-autoenablement-excluded-models.md b/data/reusables/copilot/model-autoenablement-excluded-models.md
index 37fe8dd99409..3ae1f43176f3 100644
--- a/data/reusables/copilot/model-autoenablement-excluded-models.md
+++ b/data/reusables/copilot/model-autoenablement-excluded-models.md
@@ -3,6 +3,6 @@ The default policy applies to models that you have not explicitly configured. Th
 The following models are **not** in scope. They are disabled by default, regardless of your "Default availability" policy setting.
 
 * Pre-GA models
-* Open weight models (DeepSeek, {% data variables.copilot.copilot_kimi_k3 %})
-* Models that are not covered by {% data variables.product.company_short %}'s data retention agreement ({% data variables.copilot.copilot_claude_fable_5 %}, {% data variables.copilot.copilot_claude_fable_51 %})
+* Open weight models (DeepSeek, {% data variables.copilot.kimi_k3 %})
+* Models that are not covered by {% data variables.product.company_short %}'s data retention agreement ({% data variables.copilot.claude_fable_5 %}, {% data variables.copilot.claude_fable_51 %})
 * For enterprises that have restricted models to data-resident or FedRAMP-compliant models, any models that do not respect these policies
diff --git a/data/reusables/copilot/openai-codex-agent-models.md b/data/reusables/copilot/openai-codex-agent-models.md
index 3ff97c9ed39a..b42391ed1fb1 100644
--- a/data/reusables/copilot/openai-codex-agent-models.md
+++ b/data/reusables/copilot/openai-codex-agent-models.md
@@ -1,2 +1,2 @@
-* {% data variables.copilot.copilot_gpt_53_codex %}
-* {% data variables.copilot.copilot_gpt_54_nano %}
+* {% data variables.copilot.gpt_53_codex %}
+* {% data variables.copilot.gpt_54_nano %}
diff --git a/data/variables/copilot.yml b/data/variables/copilot.yml
index 49704a34dc1d..67221b29b1e7 100644
--- a/data/variables/copilot.yml
+++ b/data/variables/copilot.yml
@@ -182,74 +182,74 @@ max-chat-indexed-repos: '50'
 
 ## LLM models for Copilot
 # Claude:
-copilot_claude: 'Claude'
-copilot_claude_haiku_45: 'Claude Haiku 4.5'
-copilot_claude_haiku_55: 'Claude Haiku 5.5'
-copilot_claude_opus: 'Claude Opus 4'
-copilot_claude_opus_41: 'Claude Opus 4.1'
-copilot_claude_opus_45: 'Claude Opus 4.5'
-copilot_claude_opus_46: 'Claude Opus 4.6'
-copilot_claude_opus_46_fast: 'Claude Opus 4.6 (fast mode) (preview)'
-copilot_claude_opus_48: 'Claude Opus 4.8'
-copilot_claude_opus_48_fast: 'Claude Opus 4.8 (fast mode) (preview)'
-copilot_claude_opus_5: 'Claude Opus 5'
-copilot_claude_opus_55: 'Claude Opus 5.5'
-copilot_claude_fable_5: 'Claude Fable 5'
-copilot_claude_fable_51: 'Claude Fable 5.1'
-copilot_claude_sonnet: 'Claude Sonnet'
-copilot_claude_sonnet_35: 'Claude Sonnet 3.5'
-copilot_claude_sonnet_37: 'Claude Sonnet 3.7'
-copilot_claude_sonnet_40: 'Claude Sonnet 4'
-copilot_claude_sonnet_45: 'Claude Sonnet 4.5'
-copilot_claude_sonnet_46: 'Claude Sonnet 4.6'
-copilot_claude_sonnet_5: 'Claude Sonnet 5'
-copilot_claude_sonnet_55: 'Claude Sonnet 5.5'
+claude: 'Claude'
+claude_haiku_45: 'Claude Haiku 4.5'
+claude_haiku_55: 'Claude Haiku 5.5'
+claude_opus: 'Claude Opus 4'
+claude_opus_41: 'Claude Opus 4.1'
+claude_opus_45: 'Claude Opus 4.5'
+claude_opus_46: 'Claude Opus 4.6'
+claude_opus_46_fast: 'Claude Opus 4.6 (fast mode) (preview)'
+claude_opus_48: 'Claude Opus 4.8'
+claude_opus_48_fast: 'Claude Opus 4.8 (fast mode) (preview)'
+claude_opus_5: 'Claude Opus 5'
+claude_opus_55: 'Claude Opus 5.5'
+claude_fable_5: 'Claude Fable 5'
+claude_fable_51: 'Claude Fable 5.1'
+claude_sonnet: 'Claude Sonnet'
+claude_sonnet_35: 'Claude Sonnet 3.5'
+claude_sonnet_37: 'Claude Sonnet 3.7'
+claude_sonnet_40: 'Claude Sonnet 4'
+claude_sonnet_45: 'Claude Sonnet 4.5'
+claude_sonnet_46: 'Claude Sonnet 4.6'
+claude_sonnet_5: 'Claude Sonnet 5'
+claude_sonnet_55: 'Claude Sonnet 5.5'
 # Gemini:
-copilot_gemini: 'Gemini'
-copilot_gemini_flash: 'Gemini 2.0 Flash'
-copilot_gemini_3_flash: 'Gemini 3 Flash'
-copilot_gemini_25_pro: 'Gemini 2.5 Pro'
-copilot_gemini_3_pro: 'Gemini 3 Pro'
-copilot_gemini_31_pro: 'Gemini 3.1 Pro'
-copilot_gemini_38_flash: 'Gemini 3.8 Flash'
-copilot_gemini_4_argon: 'Gemini 4 Argon'
+gemini: 'Gemini'
+gemini_flash: 'Gemini 2.0 Flash'
+gemini_3_flash: 'Gemini 3 Flash'
+gemini_25_pro: 'Gemini 2.5 Pro'
+gemini_3_pro: 'Gemini 3 Pro'
+gemini_31_pro: 'Gemini 3.1 Pro'
+gemini_38_flash: 'Gemini 3.8 Flash'
+gemini_4_argon: 'Gemini 4 Argon'
 # OpenAI GPT series:
-copilot_gpt_4o: 'GPT-4o'
-copilot_gpt_4o_mini: 'GPT-4o mini'
-copilot_gpt_41: 'GPT-4.1'
-copilot_gpt_5: 'GPT-5'
-copilot_gpt_5_codex: 'GPT-5-Codex'
-copilot_gpt_51: 'GPT-5.1'
-copilot_gpt_51_codex: 'GPT-5.1-Codex'
-copilot_gpt_51_codex_mini: 'GPT-5.1-Codex-Mini'
-copilot_gpt_51_codex_max: 'GPT-5.1-Codex-Max'
-copilot_gpt_52: 'GPT-5.2'
-copilot_gpt_52_codex: 'GPT-5.2-Codex'
-copilot_gpt_53_codex: 'GPT-5.3-Codex'
-copilot_gpt_54_nano: 'GPT-5.4 nano'
-copilot_gpt_56_luna: 'GPT-5.6 Luna'
-copilot_gpt_56_sol: 'GPT-5.6 Sol'
-copilot_gpt_56_terra: 'GPT-5.6 Terra'
-copilot_gpt_6_astra: 'GPT-6 Astra'
-copilot_gpt_6_luna: 'GPT-6 Luna'
-copilot_gpt_6_sol: 'GPT-6 Sol'
-copilot_gpt_61_sol: 'GPT-6.1 Sol'
+gpt_4o: 'GPT-4o'
+gpt_4o_mini: 'GPT-4o mini'
+gpt_41: 'GPT-4.1'
+gpt_5: 'GPT-5'
+gpt_5_codex: 'GPT-5-Codex'
+gpt_51: 'GPT-5.1'
+gpt_51_codex: 'GPT-5.1-Codex'
+gpt_51_codex_mini: 'GPT-5.1-Codex-Mini'
+gpt_51_codex_max: 'GPT-5.1-Codex-Max'
+gpt_52: 'GPT-5.2'
+gpt_52_codex: 'GPT-5.2-Codex'
+gpt_53_codex: 'GPT-5.3-Codex'
+gpt_54_nano: 'GPT-5.4 nano'
+gpt_56_luna: 'GPT-5.6 Luna'
+gpt_56_sol: 'GPT-5.6 Sol'
+gpt_56_terra: 'GPT-5.6 Terra'
+gpt_6_astra: 'GPT-6 Astra'
+gpt_6_luna: 'GPT-6 Luna'
+gpt_6_sol: 'GPT-6 Sol'
+gpt_61_sol: 'GPT-6.1 Sol'
 # OpenAI 'o' series:
-copilot_o3: 'o3'
-copilot_o4_mini: 'o4-mini'
+o3: 'o3'
+o4_mini: 'o4-mini'
 ## xAI:
-copilot_grok_code: 'Grok Code Fast 1'
-copilot_grok_45: 'Grok 4.5'
-copilot_grok_46: 'Grok 4.6'
-copilot_grok_47: 'Grok 4.7'
+grok_code: 'Grok Code Fast 1'
+grok_45: 'Grok 4.5'
+grok_46: 'Grok 4.6'
+grok_47: 'Grok 4.7'
 # Qwen:
-copilot_qwen_25: 'Qwen2.5'
+qwen_25: 'Qwen2.5'
 # Microsoft:
-copilot_mai_code_1_1_flash: 'MAI-Code-1.1-Flash'
+mai_code_1_1_flash: 'MAI-Code-1.1-Flash'
 # Microsoft fine-tuned:
-copilot_raptor_mini: 'Raptor mini'
+raptor_mini: 'Raptor mini'
 # Open-weight models:
-copilot_kimi_k3: 'Kimi K3'
+kimi_k3: 'Kimi K3'
 
 ## Next edit suggestions
 next_edit_suggestions: 'next edit suggestions'

From 527f71da381c72fb4d4f0fe64c4eae928d2edaa5 Mon Sep 17 00:00:00 2001
From: Pantelis <85220850+Pantelis-Santorinios@users.noreply.github.com>
Date: Wed, 21 Oct 2026 13:27:03 +0000
Subject: [PATCH 61/71] Update supported processor architectures section for
 self-hosted runners (#64317)

---
 content/actions/reference/runners/self-hosted-runners.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/content/actions/reference/runners/self-hosted-runners.md b/content/actions/reference/runners/self-hosted-runners.md
index 66f804626618..a82b03bde608 100644
--- a/content/actions/reference/runners/self-hosted-runners.md
+++ b/content/actions/reference/runners/self-hosted-runners.md
@@ -59,7 +59,6 @@ You can use a machine as a self-hosted runner as long as it meets these requirem
 
 * `x64` - Linux, macOS, Windows.
 * `ARM64` - Linux, macOS{% ifversion actions-windows-arm %}, Windows (currently in {% data variables.release-phases.public_preview %}){% endif %}.
-* `ARM32` - Linux.
 
 ## Routing precedence for self-hosted runners
 

From bca24fc390b0c8d7109a08f9d7b5c9f62318e529 Mon Sep 17 00:00:00 2001
From: Carlin Cherry <61124041+carlincherry@users.noreply.github.com>
Date: Wed, 21 Oct 2026 13:33:08 +0000
Subject: [PATCH 62/71] Document the Transitive label in Dependabot alert
 filters (#64309)

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 5ec3aa8f-d7ea-435a-95da-fb99d518dac6
---
 data/reusables/dependabot/dependabot-alerts-filters.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/data/reusables/dependabot/dependabot-alerts-filters.md b/data/reusables/dependabot/dependabot-alerts-filters.md
index 064a1b09dd7f..fb44f5029225 100644
--- a/data/reusables/dependabot/dependabot-alerts-filters.md
+++ b/data/reusables/dependabot/dependabot-alerts-filters.md
@@ -17,7 +17,7 @@ You can sort and filter {% data variables.product.prodname_dependabot_alerts %}
 | `manifest` | Displays alerts for the selected manifest | Use `manifest:webwolf/pom.xml` to show alerts on the pom.xml file of the webwolf application |
 | `package` | Displays alerts for the selected package | Use `package:django` to show alerts for django |
 | {% ifversion transitive-dependency-labeling-npm %} |
-| `relationship` |  Displays alerts of the selected relationship status<br>Note that this filter is only available for ecosystems with transitive support.  | Use `relationship:direct` to show alerts for direct dependencies (marked with the `Direct` label). |
+| `relationship` |  Displays alerts of the selected relationship status<br>Note that this filter is only available for ecosystems with transitive support.  | Use `relationship:direct` to show alerts for direct dependencies (marked with the `Direct` label), or `relationship:transitive` to show alerts for transitive dependencies (marked with the `Transitive` label). |
 | {% endif %} |
 | `resolution` | Displays alerts of the selected resolution status | Use `resolution:no-bandwidth` to show alerts previously parked due to lack of resources or time to fix them |
 | `repo` |  Displays alerts based on the repository they relate to<br>Note that this filter is only available for security overview. For more information, see [AUTOTITLE](/code-security/concepts/security-at-scale/security-overview) | Use `repo:octocat-repo` to show alerts in the repository called `octocat-repo` |

From 0501c1f24604948e69084f1c1681e9977b57a041 Mon Sep 17 00:00:00 2001
From: pararohan <pararohan@github.com>
Date: Wed, 21 Oct 2026 13:39:04 +0000
Subject: [PATCH 63/71] Rule insights dashboard: org-level is cloud only,
 repo-level available on GHES 3.23+ (#64300)

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 562249f9-a044-4d1e-aaa4-ebcb04d23f72
---
 .../managing-rulesets-for-a-repository.md                 | 8 ++++++++
 data/features/rule-insights-dashboard-org-level.yml       | 1 -
 data/features/rule-insights-dashboard.yml                 | 1 +
 3 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/content/repositories/configuring-branches-and-merges-in-your-repository/managing-rulesets/managing-rulesets-for-a-repository.md b/content/repositories/configuring-branches-and-merges-in-your-repository/managing-rulesets/managing-rulesets-for-a-repository.md
index 80ab6a4de568..b6180455cc92 100644
--- a/content/repositories/configuring-branches-and-merges-in-your-repository/managing-rulesets/managing-rulesets-for-a-repository.md
+++ b/content/repositories/configuring-branches-and-merges-in-your-repository/managing-rulesets/managing-rulesets-for-a-repository.md
@@ -115,9 +115,13 @@ You can view insights for rulesets to see how rulesets are affecting a repositor
 
 ### Viewing the rule insights dashboard
 
+{% ifversion fpt or ghec %}
+
 > [!NOTE]
 > The rule insights dashboard is available for {% data variables.product.prodname_team %} and {% data variables.product.prodname_ghe_cloud %} plans.
 
+{% endif %}
+
 The rule insights dashboard gives you a visual, high-level summary of rule evaluation activity for your repository, including:
 
 * **Successes, failures, and bypasses over time**: A chart showing trends in rule evaluation results, helping you spot spikes in blocked pushes or unusual patterns.
@@ -132,12 +136,16 @@ To view the dashboard:
 1. In the left sidebar, under "Code and automation," click **Rules**, then click **Insights**.
 1. At the top of the "Rule Insights" page, view the dashboard charts for an overview of rule evaluation activity.
 
+{% ifversion rule-insights-dashboard-org-level %}
+
 At the organization level, you can view the rule insights dashboard to review the evaluation activity of rulesets across your organization. See [AUTOTITLE](/organizations/managing-organization-settings/managing-rulesets-for-repositories-in-your-organization#viewing-the-rule-insights-dashboard).
 
 {% endif %}
 
 {% endif %}
 
+{% endif %}
+
 {% ifversion push-rule-delegated-bypass %}
 
 {% data reusables.repositories.managing-delegated-bypass %}
diff --git a/data/features/rule-insights-dashboard-org-level.yml b/data/features/rule-insights-dashboard-org-level.yml
index 33e16d808761..3a4030c563e1 100644
--- a/data/features/rule-insights-dashboard-org-level.yml
+++ b/data/features/rule-insights-dashboard-org-level.yml
@@ -3,4 +3,3 @@
 versions:
   fpt: '*'
   ghec: '*'
-  ghes: '>=3.23'
diff --git a/data/features/rule-insights-dashboard.yml b/data/features/rule-insights-dashboard.yml
index 14ba8f5e2d5b..d14197926f73 100644
--- a/data/features/rule-insights-dashboard.yml
+++ b/data/features/rule-insights-dashboard.yml
@@ -1,3 +1,4 @@
 versions:
   fpt: '*'
   ghec: '*'
+  ghes: '>=3.24'

From 86e45eebccc0be5e2c760cf3ded666ec6fc99c53 Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Wed, 21 Oct 2026 14:02:44 +0000
Subject: [PATCH 64/71] Stop GHD022 from deleting content behind ifversion !=
 (#63936)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 .../liquid-ifversion-versions.ts              |  69 ++++++++--
 .../tests/unit/liquid-ifversion-versions.ts   | 128 +++++++++++++++++-
 2 files changed, 187 insertions(+), 10 deletions(-)

diff --git a/src/content-linter/lib/linting-rules/liquid-ifversion-versions.ts b/src/content-linter/lib/linting-rules/liquid-ifversion-versions.ts
index 30b176e2b028..9abc73c5820d 100644
--- a/src/content-linter/lib/linting-rules/liquid-ifversion-versions.ts
+++ b/src/content-linter/lib/linting-rules/liquid-ifversion-versions.ts
@@ -59,6 +59,8 @@ type CondTagItem = {
   versionsObj: VersionsObject
   featureVersionsObj?: VersionsObject
   versionsObjAll: VersionsObject
+  // A bare ghes in an and chain, such as ghes and ghes != 3.20, keeps fpt and ghec excluded.
+  ghesGuard: boolean
   versions: string[]
   action: CondTagAction
   // addError accepts this cached range, but this rule never sets it.
@@ -314,6 +316,7 @@ async function initTagObject(
     versionsObj: {},
     featureVersionsObj: undefined,
     versionsObjAll: {},
+    ghesGuard: false,
     versions: [],
     action: { type: 'none' },
   }
@@ -326,14 +329,57 @@ async function initTagObject(
       ...condTagItem.versionsObj,
       ...condTagItem.featureVersionsObj,
     }
-    condTagItem.versions = getApplicableVersions(condTagItem.versionsObj, '', {
-      doNotThrow: true,
-      includeNextVersion: true,
-    })
+    condTagItem.ghesGuard = condTagItem.cond
+      .split(' or ')
+      .some(
+        (part) =>
+          part.includes(' and ') && part.split(' and ').some((and) => and.trim() === 'ghes'),
+      )
+    condTagItem.versions = getApplicableVersions(
+      toSemverVersionsObj(condTagItem.versionsObj, condTagItem.ghesGuard),
+      '',
+      { doNotThrow: true, includeNextVersion: true },
+    )
   }
   return condTagItem
 }
 
+// semver has no != comparator, so split each != term into < and > branches.
+// The ifversion tag renders a version comparison as false on other plans, except !=, which
+// renders as true. So a GHES range made only of != terms also applies to fpt and ghec.
+function toSemverVersionsObj(versionsObj: VersionsObject, ghesGuard: boolean): VersionsObject {
+  const ghes = versionsObj.ghes
+  if (!ghes || !ghes.includes('!=')) return versionsObj
+  const terms = rangeTerms(ghes)
+  const notEqualReleases = terms
+    .filter(([operator]) => operator === '!=')
+    .map(([, release]) => release)
+  const otherTerms = terms
+    .filter(([operator]) => operator !== '!=')
+    .map(([operator, release]) => `${operator} ${release}`)
+  let branches: string[][] = [otherTerms]
+  for (const release of notEqualReleases) {
+    branches = branches.flatMap((branch) => [
+      [...branch, `< ${release}`],
+      [...branch, `> ${release}`],
+    ])
+  }
+  const semverRange = branches.map((branch) => branch.join(' ')).join(' || ')
+  return otherTerms.length || ghesGuard
+    ? { ...versionsObj, ghes: semverRange }
+    : { ...versionsObj, fpt: '*', ghec: '*', ghes: semverRange }
+}
+
+// Dropping the last bound beside != terms would make the condition render true on fpt and ghec.
+function widensToOtherPlans(range: string, simplifiedRange: string): boolean {
+  return !isNotEqualOnly(range) && isNotEqualOnly(simplifiedRange)
+}
+
+function isNotEqualOnly(range: string): boolean {
+  const terms = rangeTerms(range)
+  return terms.length > 0 && terms.every(([operator]) => operator === '!=')
+}
+
 // Resolve each feature through getFeatureVersionsObject, which reads ROOT at call time.
 // Frontmatter can combine plans with a feature, list several features, or use full plan names.
 function getResolvedVersions(versionsObj: FileVersionsFm): string[] {
@@ -497,13 +543,16 @@ function updateConditionals(condTagItems: CondTagItem[]) {
       }
       // Also drop deprecated lower bounds so one fix pass leaves no GHD022 error.
       if (item.versionsObj.ghes && item.versionsObj.ghes !== '*') {
-        item.versionsObj.ghes = getSimplifiedSemverRange(
+        const simplifiedGhes = getSimplifiedSemverRange(
           rangeTerms(item.versionsObj.ghes)
             .map((term) => term.join(' '))
             .join(' '),
         )
+        if (!widensToOtherPlans(item.versionsObj.ghes, simplifiedGhes)) {
+          item.versionsObj.ghes = simplifiedGhes
+        }
       }
-      item.action.cond = toLiquidCondition(item.versionsObj)
+      item.action.cond = toLiquidCondition(item.versionsObj, item.ghesGuard)
       item.action.type = 'change'
       continue
     }
@@ -512,11 +561,12 @@ function updateConditionals(condTagItems: CondTagItem[]) {
     if (!item.versionsObjAll.ghes || item.versionsObjAll.ghes === '*') continue
 
     const simplifiedSemver = getSimplifiedSemverRange(item.versionsObjAll.ghes)
+    if (widensToOtherPlans(item.versionsObjAll.ghes, simplifiedSemver)) continue
     // Drop GHES from the conditional when other products still apply.
     if (simplifiedSemver === '' && Object.keys(item.versionsObj).length > 1) {
       item.action.type = 'change'
       delete item.versionsObj.ghes
-      item.action.cond = toLiquidCondition(item.versionsObj)
+      item.action.cond = toLiquidCondition(item.versionsObj, item.ghesGuard)
       continue
     }
 
@@ -524,7 +574,7 @@ function updateConditionals(condTagItems: CondTagItem[]) {
     if (item.versionsObjAll.ghes !== simplifiedSemver && !item.versionsObjAll.feature) {
       item.action.type = 'change'
       item.versionsObj.ghes = simplifiedSemver
-      item.action.cond = toLiquidCondition(item.versionsObj)
+      item.action.cond = toLiquidCondition(item.versionsObj, item.ghesGuard)
     }
   }
 
@@ -562,11 +612,12 @@ function updateConditionals(condTagItems: CondTagItem[]) {
 
 // Turn a versions object back into Liquid, such as { ghes: '> 3.18 < 3.22', fpt: '*' }
 // into 'ghes > 3.18 and ghes < 3.22 or fpt'.
-function toLiquidCondition(versionsObj: VersionsObject): string {
+function toLiquidCondition(versionsObj: VersionsObject, ghesGuard = false): string {
   return Object.entries(versionsObj)
     .map(([key, value]) => {
       if (key === 'feature') return value
       const terms = rangeTerms(value).map(([operator, release]) => `${key} ${operator} ${release}`)
+      if (key === 'ghes' && ghesGuard && isNotEqualOnly(value)) terms.unshift(key)
       return terms.length ? terms.join(' and ') : key
     })
     .join(' or ')
diff --git a/src/content-linter/tests/unit/liquid-ifversion-versions.ts b/src/content-linter/tests/unit/liquid-ifversion-versions.ts
index 4802a6786b28..cc47a4f5d497 100644
--- a/src/content-linter/tests/unit/liquid-ifversion-versions.ts
+++ b/src/content-linter/tests/unit/liquid-ifversion-versions.ts
@@ -2,7 +2,7 @@ import { afterAll, beforeAll, describe, expect, test } from 'vitest'
 
 import { runRule } from '../../lib/init-test'
 import { liquidIfversionVersions } from '../../lib/linting-rules/liquid-ifversion-versions'
-import { supported } from '@/versions/lib/enterprise-server-releases'
+import { deprecated, supported } from '@/versions/lib/enterprise-server-releases'
 
 describe(liquidIfversionVersions.names.join(' - '), () => {
   const envVarValueBefore: string | undefined = process.env.ROOT
@@ -385,6 +385,132 @@ describe(liquidIfversionVersions.names.join(' - '), () => {
     expect(errors[0].fixInfo?.insertText).toBe('ifversion ghec')
   })
 
+  test.each([
+    `{% ifversion ghes != ${supported[2]} %}A{% endif %}`,
+    `{% ifversion ghes != ${supported[2]} %}A{% else %}B{% endif %}`,
+    `{% ifversion ghes != ${supported[2]} and ghes > ${supported[4]} %}A{% else %}B{% endif %}`,
+    `{% ifversion ghes != ${supported[2]} and ghes != ${supported[1]} %}A{% else %}B{% endif %}`,
+  ])('ifversion using != keeps the content: %s', async (liquid) => {
+    const markdown = [...placeholderAllVersionsFm, liquid].join('\n')
+    const result = await runRule(liquidIfversionVersions, {
+      strings: { markdown },
+    })
+    expect(result.markdown).toEqual([])
+  })
+
+  test('ifversion using != on a GHES-only page keeps the content', async () => {
+    const markdown = [
+      '---',
+      'title: "Hello"',
+      'versions:',
+      '  ghes: "*"',
+      '---',
+      `{% ifversion ghes != ${supported[2]} %}A{% else %}B{% endif %}`,
+    ].join('\n')
+    const result = await runRule(liquidIfversionVersions, {
+      strings: { markdown },
+    })
+    expect(result.markdown).toEqual([])
+  })
+
+  test('ifversion using != with a deprecated release applies to all versions', async () => {
+    const markdown = [
+      ...placeholderAllVersionsFm,
+      `{% ifversion ghes != ${deprecated[0]} %}A{% endif %}`,
+    ].join('\n')
+    const result = await runRule(liquidIfversionVersions, {
+      strings: { markdown },
+    })
+    const errors = result.markdown
+    expect(errors.length).toBe(2)
+    expect(errors[0].errorDetail).toContain('applies to all versions')
+  })
+
+  test.each([
+    `{% ifversion ghes and ghes != ${supported[2]} %}A{% else %}B{% endif %}`,
+    `{% ifversion ghes != ${supported[2]} and ghes %}A{% else %}B{% endif %}`,
+  ])('ifversion using != with a ghes guard applies to no cloud versions: %s', async (liquid) => {
+    const markdown = [
+      '---',
+      'title: "Hello"',
+      'versions:',
+      '  fpt: "*"',
+      '  ghec: "*"',
+      '---',
+      liquid,
+    ].join('\n')
+    const result = await runRule(liquidIfversionVersions, {
+      strings: { markdown },
+    })
+    const errors = result.markdown
+    expect(errors[0].errorDetail).toContain('applies to no versions')
+    expect(errors.some((error) => error.errorDetail.includes('applies to all versions'))).toBe(true)
+  })
+
+  test.each([
+    `{% ifversion ghes and ghes != ${deprecated[0]} %}A{% else %}B{% endif %}`,
+    `{% ifversion ghes != ${deprecated[0]} and ghes %}A{% else %}B{% endif %}`,
+  ])('ifversion using != with a ghes guard keeps the else content: %s', async (liquid) => {
+    const markdown = [...placeholderAllVersionsFm, liquid].join('\n')
+    const result = await runRule(liquidIfversionVersions, {
+      strings: { markdown },
+    })
+    expect(result.markdown).toEqual([])
+  })
+
+  test('ifversion using != keeps the ghes guard when removing a product', async () => {
+    const markdown = [
+      '---',
+      'title: "Hello"',
+      'versions:',
+      '  fpt: "*"',
+      '  ghes: "*"',
+      '---',
+      `{% ifversion ghes and ghes != ${supported[0]} or ghec %}A{% endif %}`,
+    ].join('\n')
+    const result = await runRule(liquidIfversionVersions, {
+      strings: { markdown },
+    })
+    const errors = result.markdown
+    expect(errors.length).toBe(1)
+    expect(errors[0].fixInfo?.insertText).toBe(`ifversion ghes and ghes != ${supported[0]}`)
+  })
+
+  test('ifversion using != keeps a deprecated lower bound so fpt and ghec stay excluded', async () => {
+    const markdown = [
+      ...placeholderAllVersionsFm,
+      `{% ifversion ghes != ${supported[0]} and ghes > ${deprecated[0]} %}A{% endif %}`,
+    ].join('\n')
+    const result = await runRule(liquidIfversionVersions, {
+      strings: { markdown },
+    })
+    const errors = result.markdown
+    expect(errors.map((error) => error.fixInfo?.insertText)).not.toContain(
+      `ifversion ghes != ${supported[0]}`,
+    )
+    expect(errors).toEqual([])
+  })
+
+  test('ifversion using != keeps a deprecated lower bound when removing a product', async () => {
+    const markdown = [
+      '---',
+      'title: "Hello"',
+      'versions:',
+      '  fpt: "*"',
+      '  ghes: "*"',
+      '---',
+      `{% ifversion ghes != ${supported[0]} and ghes > ${deprecated[0]} or ghec %}A{% endif %}`,
+    ].join('\n')
+    const result = await runRule(liquidIfversionVersions, {
+      strings: { markdown },
+    })
+    const errors = result.markdown
+    expect(errors.length).toBe(1)
+    expect(errors[0].fixInfo?.insertText).toBe(
+      `ifversion ghes != ${supported[0]} and ghes > ${deprecated[0]}`,
+    )
+  })
+
   test('does not crash with nested if blocks inside ifversion', async () => {
     const markdown = [
       ...placeholderAllVersionsFm,

From 961986067876ea6eb91286c35c2238fda519836d Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Wed, 21 Oct 2026 14:02:52 +0000
Subject: [PATCH 65/71] Keep locale and version in landing page hero links
 (#63944)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 .../fixtures/article-with-introLinks.md       |  2 +
 src/frame/tests/page.ts                       | 28 +++++++++
 .../components/shared/LandingHero.tsx         | 13 +++-
 src/landings/lib/intro-links.ts               | 20 ++++++
 src/landings/pages/product.tsx                |  7 +++
 src/landings/tests/intro-links.ts             | 56 +++++++++++++++++
 src/landings/tests/landing-hero.ts            | 63 +++++++++++++++++++
 7 files changed, 188 insertions(+), 1 deletion(-)
 create mode 100644 src/landings/lib/intro-links.ts
 create mode 100644 src/landings/tests/intro-links.ts
 create mode 100644 src/landings/tests/landing-hero.ts

diff --git a/src/fixtures/fixtures/article-with-introLinks.md b/src/fixtures/fixtures/article-with-introLinks.md
index bfff0ffec3d2..5f7491a83e10 100644
--- a/src/fixtures/fixtures/article-with-introLinks.md
+++ b/src/fixtures/fixtures/article-with-introLinks.md
@@ -6,4 +6,6 @@ versions:
 introLinks:
   overview: 'https://github.com'
   custom link!: 'https://github.com/features'
+  quickstart: /get-started/quickstart
+  reference: /get-started/reference
 ---
diff --git a/src/frame/tests/page.ts b/src/frame/tests/page.ts
index 7e14641ed98d..7242c55800fc 100644
--- a/src/frame/tests/page.ts
+++ b/src/frame/tests/page.ts
@@ -270,8 +270,36 @@ describe('Page class', () => {
       expect(page!.introLinks).toStrictEqual({
         overview: 'https://github.com',
         'custom link!': 'https://github.com/features',
+        quickstart: '/get-started/quickstart',
+        reference: '/get-started/reference',
       })
     })
+
+    // Markdown and article API requests read introLinks from the shared Page without rendering it.
+    test('keeps every link after rendering a version that lacks a target page', async () => {
+      const page = await Page.init({
+        relativePath: 'article-with-introLinks.md',
+        basePath: path.join(__dirname, '../../../src/fixtures/fixtures'),
+        languageCode: 'en',
+      })
+      const pages = {
+        '/en/get-started/quickstart': { applicableVersions: [nonEnterpriseDefaultVersion] },
+        '/en/get-started/reference': { applicableVersions: Object.keys(allVersions) },
+      } as unknown as Context['pages']
+
+      await page!.render({
+        currentLanguage: 'en',
+        currentVersion: `enterprise-server@${latest}`,
+        pages,
+        redirects: {},
+      })
+      expect(Object.keys(page!.introLinks!)).toEqual([
+        'overview',
+        'custom link!',
+        'quickstart',
+        'reference',
+      ])
+    })
   })
 
   describe('Page.parseFrontmatter()', () => {
diff --git a/src/landings/components/shared/LandingHero.tsx b/src/landings/components/shared/LandingHero.tsx
index 4870022da520..6eb7da6e8aea 100644
--- a/src/landings/components/shared/LandingHero.tsx
+++ b/src/landings/components/shared/LandingHero.tsx
@@ -1,8 +1,10 @@
+import { useRouter } from 'next/router'
 import { LinkExternalIcon } from '@primer/octicons-react'
 import { Button, ButtonGroup, Heading, Text } from '@primer/react-brand'
 import styles from './LandingHero.module.scss'
 import { LandingSection } from './LandingSection'
 import { useTranslation } from '@/languages/components/useTranslation'
+import { DEFAULT_VERSION, useVersion } from '@/versions/components/useVersion'
 import { RenderedHTML } from '@/frame/components/ui/RenderedHTML/RenderedHTML'
 
 type LandingHeroProps = {
@@ -24,6 +26,15 @@ function heroBackgroundCss(heroImage: string | undefined) {
 
 export const LandingHero = ({ title, intro, heroImage, introLinks }: LandingHeroProps) => {
   const { t } = useTranslation(['product_landing'])
+  const router = useRouter()
+  const { currentVersion } = useVersion()
+
+  // Frontmatter paths lack locale and version, and redirects for bare paths take both from cookies or headers, not this page.
+  const localizeHref = (href: string) => {
+    if (!href.startsWith('/') || href.startsWith('//')) return href
+    const versionPrefix = currentVersion !== DEFAULT_VERSION ? `/${currentVersion}` : ''
+    return `/${router.locale}${versionPrefix}${href}`
+  }
 
   const linkEntries = introLinks ? Object.entries(introLinks) : []
 
@@ -51,7 +62,7 @@ export const LandingHero = ({ title, intro, heroImage, introLinks }: LandingHero
                   <Button
                     key={label}
                     as="a"
-                    href={href}
+                    href={localizeHref(href)}
                     variant={i === 0 ? 'primary' : 'secondary'}
                     trailingVisual={
                       href.startsWith('https') ? (
diff --git a/src/landings/lib/intro-links.ts b/src/landings/lib/intro-links.ts
new file mode 100644
index 000000000000..3138c1690aa5
--- /dev/null
+++ b/src/landings/lib/intro-links.ts
@@ -0,0 +1,20 @@
+import findPage from '@/frame/lib/find-page'
+import nonEnterpriseDefaultVersion from '@/versions/lib/non-enterprise-default-version'
+import type { Context } from '@/types'
+
+// Hero buttons add the current version to internal intro links, and that URL is a 404 when the target page lacks the version.
+export function getIntroLinksForVersion(
+  introLinks: Record<string, string>,
+  context: Context,
+): Record<string, string> {
+  const { pages, redirects, currentLanguage, currentVersion } = context
+  if (!pages || !currentVersion || currentVersion === nonEnterpriseDefaultVersion) return introLinks
+  return Object.fromEntries(
+    Object.entries(introLinks).filter(([, href]) => {
+      const linkPath = href.trim()
+      if (!linkPath.startsWith('/') || linkPath.startsWith('//')) return true
+      const target = findPage(`/${currentLanguage || 'en'}${linkPath}`, pages, redirects)
+      return !target || target.applicableVersions.includes(currentVersion)
+    }),
+  )
+}
diff --git a/src/landings/pages/product.tsx b/src/landings/pages/product.tsx
index d9b4bec186e4..1c62110f835a 100644
--- a/src/landings/pages/product.tsx
+++ b/src/landings/pages/product.tsx
@@ -179,6 +179,13 @@ export const getServerSideProps: GetServerSideProps<Props> = async (context) =>
     }
   }
 
+  // Filter per request because every version shares one Page instance.
+  const landingContext = props.bespokeContext ?? props.journeyContext ?? props.discoveryContext
+  if (landingContext?.introLinks && req.context) {
+    const { getIntroLinksForVersion } = await import('@/landings/lib/intro-links')
+    landingContext.introLinks = getIntroLinksForVersion(landingContext.introLinks, req.context)
+  }
+
   addUINamespaces(req, props.mainContext.data.ui, additionalUINamespaces)
 
   return {
diff --git a/src/landings/tests/intro-links.ts b/src/landings/tests/intro-links.ts
new file mode 100644
index 000000000000..e83d1b4e1686
--- /dev/null
+++ b/src/landings/tests/intro-links.ts
@@ -0,0 +1,56 @@
+import { describe, expect, test } from 'vitest'
+
+import { getIntroLinksForVersion } from '@/landings/lib/intro-links'
+import { allVersions } from '@/versions/lib/all-versions'
+import { latest } from '@/versions/lib/enterprise-server-releases'
+import nonEnterpriseDefaultVersion from '@/versions/lib/non-enterprise-default-version'
+import type { Context } from '@/types'
+
+const introLinks = {
+  overview: 'https://github.com',
+  'custom link!': 'https://github.com/features',
+  quickstart: '/get-started/quickstart',
+  reference: '/get-started/reference',
+  missing: '/get-started/missing',
+}
+
+const pages = {
+  '/en/get-started/quickstart': {
+    applicableVersions: [nonEnterpriseDefaultVersion, 'enterprise-cloud@latest'],
+  },
+  '/en/get-started/reference': { applicableVersions: Object.keys(allVersions) },
+} as unknown as Context['pages']
+
+const context = { currentLanguage: 'ja', pages, redirects: {} }
+
+describe('getIntroLinksForVersion', () => {
+  test('drops internal links whose target page is not in the current version', () => {
+    const result = getIntroLinksForVersion(introLinks, {
+      ...context,
+      currentVersion: `enterprise-server@${latest}`,
+    })
+    expect(Object.keys(result)).toEqual(['overview', 'custom link!', 'reference', 'missing'])
+  })
+
+  test('keeps links whose target page is in the current version', () => {
+    const result = getIntroLinksForVersion(introLinks, {
+      ...context,
+      currentVersion: 'enterprise-cloud@latest',
+    })
+    expect(result).toEqual(introLinks)
+  })
+
+  test('keeps every link on the default version', () => {
+    const result = getIntroLinksForVersion(introLinks, {
+      ...context,
+      currentVersion: nonEnterpriseDefaultVersion,
+    })
+    expect(result).toBe(introLinks)
+  })
+
+  test('does not change the input map', () => {
+    const input = { ...introLinks }
+    getIntroLinksForVersion(input, { ...context, currentVersion: `enterprise-server@${latest}` })
+    expect(input).toEqual(introLinks)
+  })
+})
diff --git a/src/landings/tests/landing-hero.ts b/src/landings/tests/landing-hero.ts
new file mode 100644
index 000000000000..6022afee8df7
--- /dev/null
+++ b/src/landings/tests/landing-hero.ts
@@ -0,0 +1,63 @@
+import { createElement } from 'react'
+import type { ReactNode } from 'react'
+import { renderToStaticMarkup } from 'react-dom/server'
+import { load } from 'cheerio'
+import { beforeEach, describe, expect, test, vi } from 'vitest'
+
+const router = vi.hoisted(() => ({
+  locale: 'en',
+  query: {} as Record<string, string>,
+}))
+
+vi.mock('next/router', () => ({ useRouter: () => router }))
+vi.mock('@/languages/components/useTranslation', () => ({
+  useTranslation: () => ({ t: (key: string) => key }),
+}))
+// Primer packages import CSS files, which Node cannot load outside a bundler.
+vi.mock('@primer/react-brand', () => {
+  const passthrough = ({ children }: { children?: ReactNode }) =>
+    createElement('div', null, children)
+  return {
+    Button: ({ href, children }: { href: string; children?: ReactNode }) =>
+      createElement('a', { href }, children),
+    ButtonGroup: passthrough,
+    Heading: passthrough,
+    Text: passthrough,
+  }
+})
+vi.mock('@/frame/components/ui/RenderedHTML/RenderedHTML', () => ({ RenderedHTML: () => null }))
+
+const { LandingHero } = await import('@/landings/components/shared/LandingHero')
+
+function renderHrefs(introLinks: Record<string, string>) {
+  const $ = load(renderToStaticMarkup(createElement(LandingHero, { title: 'Title', introLinks })))
+  return $('a')
+    .map((_, el) => $(el).attr('href'))
+    .get()
+}
+
+describe('LandingHero introLinks', () => {
+  beforeEach(() => {
+    router.locale = 'en'
+    router.query = {}
+  })
+
+  test('prefixes internal links with the locale on the default version', () => {
+    expect(renderHrefs({ quickstart: '/actions/quickstart' })).toEqual(['/en/actions/quickstart'])
+  })
+
+  test('prefixes internal links with the locale and current version', () => {
+    router.locale = 'ja'
+    router.query = { versionId: 'enterprise-server@3.16' }
+    expect(renderHrefs({ overview: '/billing/overview' })).toEqual([
+      '/ja/enterprise-server@3.16/billing/overview',
+    ])
+  })
+
+  test('leaves external links unchanged', () => {
+    router.query = { versionId: 'enterprise-cloud@latest' }
+    expect(
+      renderHrefs({ overview: 'https://github.com/features', other: '//example.com/x' }),
+    ).toEqual(['https://github.com/features', '//example.com/x'])
+  })
+})

From 565c81c4576d44f46c319d6269bd39a483ce4fe1 Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Wed, 21 Oct 2026 14:02:59 +0000
Subject: [PATCH 66/71] Block encoded dot segments in archived asset proxy
 paths (#63960)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 .../archived-enterprise-versions-assets.ts    | 34 +++++++++++++----
 .../archived-enterprise-versions-assets.ts    | 37 +++++++++++++++++++
 2 files changed, 64 insertions(+), 7 deletions(-)
 create mode 100644 src/archives/tests/archived-enterprise-versions-assets.ts

diff --git a/src/archives/middleware/archived-enterprise-versions-assets.ts b/src/archives/middleware/archived-enterprise-versions-assets.ts
index 3c8c213b6bec..e5bb2cd81b95 100644
--- a/src/archives/middleware/archived-enterprise-versions-assets.ts
+++ b/src/archives/middleware/archived-enterprise-versions-assets.ts
@@ -13,6 +13,31 @@ const logger = createLogger(import.meta.url)
 // Proxies archived CSS and JS assets from docs-ghes-<release number> repositories.
 // archived-enterprise-versions.ts handles non-asset paths.
 
+// req.path keeps percent-encoding, and fetch resolves encoded dot segments such as
+// %2e%2e, so the parsed URL must stay inside the docs-ghes repository for the version.
+export function getArchivedAssetProxyUrl(assetPath: string, version: string): string | null {
+  if (
+    assetPath.includes('../') ||
+    assetPath.includes('://') ||
+    (assetPath.includes(':') && assetPath.includes('@')) ||
+    /%2f|%5c|\\/i.test(assetPath)
+  ) {
+    return null
+  }
+
+  const repoPrefix = `/docs-ghes-${version}/`
+  let url: URL
+  try {
+    url = new URL(`https://github.github.com/docs-ghes-${version}${assetPath}`)
+  } catch {
+    return null
+  }
+  if (url.origin !== 'https://github.github.com' || !url.pathname.startsWith(repoPrefix)) {
+    return null
+  }
+  return url.href
+}
+
 export default async function archivedEnterpriseVersionsAssets(
   req: ExtendedRequest,
   res: Response,
@@ -52,17 +77,12 @@ export default async function archivedEnterpriseVersionsAssets(
   const legacyEnterprisePrefix = `/enterprise/${requestedVersion}`
   const assetPath = req.path.replace(newEnterprisePrefix, '').replace(legacyEnterprisePrefix, '')
 
-  // Reject traversal and embedded URL syntax before constructing the proxy path.
-  if (
-    assetPath.includes('../') ||
-    assetPath.includes('://') ||
-    (assetPath.includes(':') && assetPath.includes('@'))
-  ) {
+  const proxyPath = getArchivedAssetProxyUrl(assetPath, requestedVersion)
+  if (!proxyPath) {
     defaultCacheControl(res)
     return res.status(404).type('text/plain').send('Asset path not valid')
   }
 
-  const proxyPath = `https://github.github.com/docs-ghes-${requestedVersion}${assetPath}`
   try {
     const r = await fetchWithRetry(
       proxyPath,
diff --git a/src/archives/tests/archived-enterprise-versions-assets.ts b/src/archives/tests/archived-enterprise-versions-assets.ts
new file mode 100644
index 000000000000..aadfaaa3567f
--- /dev/null
+++ b/src/archives/tests/archived-enterprise-versions-assets.ts
@@ -0,0 +1,37 @@
+import { describe, expect, test } from 'vitest'
+
+import { getArchivedAssetProxyUrl } from '@/archives/middleware/archived-enterprise-versions-assets'
+
+describe('getArchivedAssetProxyUrl', () => {
+  test('builds the proxy URL for a normal asset path', () => {
+    expect(getArchivedAssetProxyUrl('/_next/static/css/a.css', '3.5')).toBe(
+      'https://github.github.com/docs-ghes-3.5/_next/static/css/a.css',
+    )
+    expect(getArchivedAssetProxyUrl('/assets/images/site/favicon.png', '2.18')).toBe(
+      'https://github.github.com/docs-ghes-2.18/assets/images/site/favicon.png',
+    )
+  })
+
+  test('rejects literal dot segments', () => {
+    expect(getArchivedAssetProxyUrl('/_next/../../x', '3.5')).toBeNull()
+    expect(getArchivedAssetProxyUrl('/dist/index../css', '2.18')).toBeNull()
+  })
+
+  test('rejects percent-encoded dot segments that escape the archive', () => {
+    expect(getArchivedAssetProxyUrl('/_next/%2e%2e/%2e%2e/x/index.html', '3.5')).toBeNull()
+    expect(getArchivedAssetProxyUrl('/assets/%2E%2e/.%2e/x/', '3.5')).toBeNull()
+    expect(getArchivedAssetProxyUrl('/_next/%2e./%2E./x/index.html', '3.5')).toBeNull()
+  })
+
+  test('rejects backslashes and encoded slashes', () => {
+    expect(getArchivedAssetProxyUrl('/_next/..%2f..%2fx', '3.5')).toBeNull()
+    expect(getArchivedAssetProxyUrl('/_next/..%5C..%5Cx', '3.5')).toBeNull()
+    expect(getArchivedAssetProxyUrl('/_next/..\\..\\x', '3.5')).toBeNull()
+  })
+
+  test('rejects embedded URL syntax', () => {
+    expect(getArchivedAssetProxyUrl('/dist/index.csshttp://example.com', '2.18')).toBeNull()
+    expect(getArchivedAssetProxyUrl('/dist/index.css:password@example.com', '2.18')).toBeNull()
+    expect(getArchivedAssetProxyUrl('a:b@c', '3.5')).toBeNull()
+  })
+})

From 477688b1b018fab7d73f2c770660427b1e1574cb Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Wed, 21 Oct 2026 14:03:05 +0000
Subject: [PATCH 67/71] Follow fragment and GraphQL kind redirects in the
 Article API (#64046)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 src/article-api/middleware/validation.ts |  7 ++-
 src/article-api/tests/page-validation.ts | 67 ++++++++++++++++++++++++
 src/article-api/tests/pageinfo.ts        | 15 ++++++
 3 files changed, 88 insertions(+), 1 deletion(-)
 create mode 100644 src/article-api/tests/page-validation.ts

diff --git a/src/article-api/middleware/validation.ts b/src/article-api/middleware/validation.ts
index cb89a7be74c5..7fd07caab15e 100644
--- a/src/article-api/middleware/validation.ts
+++ b/src/article-api/middleware/validation.ts
@@ -4,6 +4,7 @@ import type { NextFunction, Response } from 'express'
 import { ExtendedRequest, Page } from '@/types'
 import { isArchivedVersionByPath } from '@/archives/lib/is-archived-version'
 import getRedirect from '@/redirects/lib/get-redirect'
+import { applyGraphqlCategoryRedirect } from '@/redirects/lib/graphql-category-redirect'
 import { pathLanguagePrefixed } from '@/languages/lib/languages-server'
 import { getVersionStringFromPath, getLangFromPath } from '@/frame/lib/path-utils'
 import nonEnterpriseDefaultVersion from '@/versions/lib/non-enterprise-default-version'
@@ -64,6 +65,7 @@ export const pathValidationMiddleware = (
 // pageValidationMiddleware calls getRedirect directly because findPage hides pathname changes.
 // Redirected pathnames must match page.permalinks for translated-page fallback.
 // Archived enterprise paths skip redirect lookup, even if they also match a redirect.
+// Redirect destinations get the legacy GraphQL kind rewrite and lose their #fragment.
 // This matches the site middleware order.
 export const pageValidationMiddleware = (
   req: ExtendedRequestWithPageInfo,
@@ -96,7 +98,10 @@ export const pageValidationMiddleware = (
       const redirect = getRedirect(pathname, redirectsContext)
       if (redirect) {
         req.pageinfo.redirectedFrom = pathname
-        pathname = redirect
+        const rewritten =
+          applyGraphqlCategoryRedirect(redirect, req.context.currentLanguage) || redirect
+        // Pages are keyed without fragments, so drop the #anchor from internal destinations.
+        pathname = rewritten.includes('://') ? rewritten : rewritten.split('#')[0]
       } else if (!pathLanguagePrefixed(pathname)) {
         // The redirect table omits live permalinks, so add the language prefix as the site does.
         const prefixedPathname = `/${req.context.currentLanguage}${pathname}`
diff --git a/src/article-api/tests/page-validation.ts b/src/article-api/tests/page-validation.ts
new file mode 100644
index 000000000000..da0716d23458
--- /dev/null
+++ b/src/article-api/tests/page-validation.ts
@@ -0,0 +1,67 @@
+import { describe, expect, test, vi } from 'vitest'
+import type { Response } from 'express'
+
+import { pageValidationMiddleware } from '@/article-api/middleware/validation'
+import type { ExtendedRequestWithPageInfo } from '@/article-api/types'
+import { latest } from '@/versions/lib/enterprise-server-releases'
+import type { Page } from '@/types'
+
+const restPage = { title: 'Activity' } as unknown as Page
+const checksPage = { title: 'Checks' } as unknown as Page
+const referencePage = { title: 'Reference' } as unknown as Page
+
+const pages: Record<string, Page> = {
+  [`/en/enterprise-server@${latest}/rest/activity`]: restPage,
+  '/en/graphql/reference/checks': checksPage,
+  '/en/graphql/reference': referencePage,
+}
+
+// Mirrors developer.json entries after precompile resolves enterprise-server@latest.
+const redirects: Record<string, string> = {
+  '/enterprise/v3/activity/events': `/enterprise-server@${latest}/rest/activity#events`,
+  '/v4/enum/checkruntype': '/graphql/reference/enums#checkruntype',
+  '/v4/mutation': '/graphql/reference/mutations',
+}
+
+function run(pathname: string) {
+  const req = {
+    pageinfo: { pathname, page: {} as Page },
+    context: { pages, redirects, currentLanguage: 'en', userLanguage: 'en' },
+  } as unknown as ExtendedRequestWithPageInfo
+  const res = {
+    status: vi.fn().mockReturnThis(),
+    json: vi.fn().mockReturnThis(),
+  } as unknown as Response
+  const next = vi.fn()
+  pageValidationMiddleware(req, res, next)
+  return { req, res, next }
+}
+
+describe('pageValidationMiddleware redirects', () => {
+  test('drops the fragment from a redirect destination before the page lookup', () => {
+    const { req, res, next } = run('/en/enterprise/v3/activity/events')
+    expect(res.status).not.toHaveBeenCalled()
+    expect(next).toHaveBeenCalled()
+    expect(req.pageinfo.page).toBe(restPage)
+    expect(req.pageinfo.pathname).toBe(`/en/enterprise-server@${latest}/rest/activity`)
+    expect(req.pageinfo.redirectedFrom).toBe('/en/enterprise/v3/activity/events')
+  })
+
+  test('maps legacy GraphQL kind redirects with a type fragment to category pages', () => {
+    const { req, res, next } = run('/en/v4/enum/checkruntype')
+    expect(res.status).not.toHaveBeenCalled()
+    expect(next).toHaveBeenCalled()
+    expect(req.pageinfo.page).toBe(checksPage)
+    expect(req.pageinfo.pathname).toBe('/en/graphql/reference/checks')
+    expect(req.pageinfo.redirectedFrom).toBe('/en/v4/enum/checkruntype')
+  })
+
+  test('maps legacy GraphQL kind redirects without a fragment to the reference root', () => {
+    const { req, res, next } = run('/en/v4/mutation')
+    expect(res.status).not.toHaveBeenCalled()
+    expect(next).toHaveBeenCalled()
+    expect(req.pageinfo.page).toBe(referencePage)
+    expect(req.pageinfo.pathname).toBe('/en/graphql/reference')
+    expect(req.pageinfo.redirectedFrom).toBe('/en/v4/mutation')
+  })
+})
diff --git a/src/article-api/tests/pageinfo.ts b/src/article-api/tests/pageinfo.ts
index 1e6553864201..291c15fc8a93 100644
--- a/src/article-api/tests/pageinfo.ts
+++ b/src/article-api/tests/pageinfo.ts
@@ -138,6 +138,21 @@ describe('pageinfo api', () => {
       const meta = JSON.parse(res.body) as PageMetadata
       expect(meta.title).toBe('Only in Enterprise Cloud and Enterprise Server')
     }
+    // Legacy GraphQL redirect destinations carry a kind and #fragment that pages lack.
+    {
+      const res = await get(makeURL('/en/v4/enum/checkruntype'))
+      expect(res.statusCode).toBe(200)
+      const meta = JSON.parse(res.body) as PageMetadata
+      expect(meta.title).toBe('Checks')
+      expect(meta.redirectedFrom).toBe('/en/v4/enum/checkruntype')
+    }
+    {
+      const res = await get(makeURL('/en/v4/mutation'))
+      expect(res.statusCode).toBe(200)
+      const meta = JSON.parse(res.body) as PageMetadata
+      expect(meta.title).toBe('Reference')
+      expect(meta.redirectedFrom).toBe('/en/v4/mutation')
+    }
   })
 
   test('a page that uses non-trivial Liquid to render', async () => {

From 55a9892b7dfaf9328ff86549c5afa6a7e8307177 Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Wed, 21 Oct 2026 14:03:12 +0000
Subject: [PATCH 68/71] Stop Ask AI transitions from flashing No results found
 (#64051)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 .../tests/playwright-rendering.spec.ts        | 80 +++++++++++++++++++
 .../hooks/useAISearchAutocomplete.ts          | 25 +++---
 src/search/components/input/SearchOverlay.tsx |  3 +-
 3 files changed, 96 insertions(+), 12 deletions(-)

diff --git a/src/fixtures/tests/playwright-rendering.spec.ts b/src/fixtures/tests/playwright-rendering.spec.ts
index fcbde08afa70..609e8fe67e54 100644
--- a/src/fixtures/tests/playwright-rendering.spec.ts
+++ b/src/fixtures/tests/playwright-rendering.spec.ts
@@ -880,6 +880,86 @@ test.describe('search dialog', () => {
     await expect(input).toHaveAttribute('aria-activedescendant', 'search-option-reference-0')
   })
 
+  // A flash can last one frame, so record every text the page adds instead of the end state.
+  async function recordAddedText(page: Page) {
+    await page.evaluate(() => {
+      const seen: string[] = []
+      ;(window as unknown as { __addedText: string[] }).__addedText = seen
+      new MutationObserver((records) => {
+        for (const record of records) {
+          if (record.type === 'characterData') seen.push(record.target.textContent || '')
+          for (const node of record.addedNodes) seen.push(node.textContent || '')
+        }
+      }).observe(document.body, { subtree: true, childList: true, characterData: true })
+    })
+  }
+
+  async function addedText(page: Page) {
+    return page.evaluate(() =>
+      (window as unknown as { __addedText: string[] }).__addedText.join('\n'),
+    )
+  }
+
+  test('asking Copilot and going back never flashes "No results found"', async ({ page }) => {
+    await page.route('**/api/ai-search/v1', (route) =>
+      route.fulfill({
+        status: 200,
+        headers: { 'Content-Type': 'application/x-ndjson' },
+        body: '{"chunkType":"MESSAGE_CHUNK","text":"An answer."}\n',
+      }),
+    )
+    await mockSearch(page)
+    await page.goto('/')
+    await turnOffExperimentsInPage(page)
+
+    await page.getByTestId('toggle-search').click()
+    const input = page.getByTestId('overlay-search-input')
+    await input.fill('foo')
+    await expect(page.locator('#search-option-general-0')).toBeVisible()
+    await recordAddedText(page)
+
+    await input.press('Enter') // nothing selected: ask Copilot
+    await expect(page.getByText('An answer.')).toBeVisible()
+    await page.getByRole('button', { name: 'Back to search' }).click()
+    await expect(page.locator('#search-option-ai-0')).toBeVisible()
+    await expect(page.locator('#search-option-general-0')).toBeVisible()
+    // Past the 100ms autocomplete debounce, while the emptied results used to render.
+    await page.waitForTimeout(300)
+
+    // Also matches the "Search Docs: No results found" live region announcement.
+    expect(await addedText(page)).not.toContain('No results found')
+  })
+
+  test('a Copilot cannot-answer response never flashes "No results found"', async ({ page }) => {
+    await page.route('**/api/ai-search/v1', (route) =>
+      route.fulfill({
+        status: 200,
+        headers: { 'Content-Type': 'application/x-ndjson' },
+        body: '{"chunkType":"NO_CONTENT_SIGNAL"}\n',
+      }),
+    )
+    await mockSearch(page)
+    await page.goto('/')
+    await turnOffExperimentsInPage(page)
+
+    await page.getByTestId('toggle-search').click()
+    const input = page.getByTestId('overlay-search-input')
+    await input.fill('foo')
+    await expect(page.locator('#search-option-general-0')).toBeVisible()
+    await recordAddedText(page)
+
+    await input.press('Enter') // nothing selected: ask Copilot
+    await expect(page.locator('#ask-ai-result-container article')).toContainText(
+      "I'm unable to answer that question",
+    )
+    await expect(page.locator('#search-option-general-0')).toBeVisible()
+    // Past the 100ms autocomplete debounce, while the emptied results used to render.
+    await page.waitForTimeout(300)
+
+    // Also matches the "Search Docs: No results found" live region announcement.
+    expect(await addedText(page)).not.toContain('No results found')
+  })
+
   // Streams one answer chunk, then holds until releaseCopilot, then ends the stream as asked.
   // Also records event beacons, since Chromium hides sendBeacon payloads from Playwright.
   async function streamCopilotAnswer(
diff --git a/src/search/components/hooks/useAISearchAutocomplete.ts b/src/search/components/hooks/useAISearchAutocomplete.ts
index f83cd4a96292..13329984e80a 100644
--- a/src/search/components/hooks/useAISearchAutocomplete.ts
+++ b/src/search/components/hooks/useAISearchAutocomplete.ts
@@ -21,7 +21,7 @@ type UseCombinedSearchReturn = {
   searchLoading: boolean
   setSearchLoading: (loading: boolean) => void
   searchError: boolean
-  updateAutocompleteResults: (query: string) => void
+  updateAutocompleteResults: (query: string, options?: { immediate?: boolean }) => void
   clearAutocompleteResults: () => void
 }
 
@@ -137,16 +137,19 @@ export function useCombinedSearchResults({
     [router, currentVersion, debug],
   )
 
-  const updateAutocompleteResults = useCallback((queryValue: string) => {
-    // Don't debounce an empty input: show the (possibly cached) options at once.
-    if (queryValue === '') {
-      debouncedFetchRef.current?.cancel()
-      fetchAutocompleteResults('')
-      return
-    } else {
-      debouncedFetchRef.current?.(queryValue)
-    }
-  }, [])
+  const updateAutocompleteResults = useCallback(
+    (queryValue: string, { immediate = false }: { immediate?: boolean } = {}) => {
+      // Skip the debounce for an empty input or an immediate request so cached options show at once.
+      if (queryValue === '' || immediate) {
+        debouncedFetchRef.current?.cancel()
+        fetchAutocompleteResults(queryValue)
+        return
+      } else {
+        debouncedFetchRef.current?.(queryValue)
+      }
+    },
+    [],
+  )
 
   const clearAutocompleteResults = useCallback(() => {
     setSearchOptions({
diff --git a/src/search/components/input/SearchOverlay.tsx b/src/search/components/input/SearchOverlay.tsx
index ecb15425a9a4..e9c17e594cb7 100644
--- a/src/search/components/input/SearchOverlay.tsx
+++ b/src/search/components/input/SearchOverlay.tsx
@@ -232,7 +232,8 @@ export function SearchOverlay({
       if (!searchEventGroupId.current) {
         searchEventGroupId.current = uuidv4()
       }
-      updateAutocompleteResults(urlSearchInputQuery)
+      // Skip the debounce so the cleanup's cleared results never render as "No results found".
+      updateAutocompleteResults(urlSearchInputQuery, { immediate: true })
     } else {
       // Clear shared loading state so the next open does not inherit a spinner.
       setSearchLoading(false)

From 641670f765ac6be54bed09e3b79715d96f32f20c Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Wed, 21 Oct 2026 14:03:20 +0000
Subject: [PATCH 69/71] Reuse unchanged pages and keep category versions on dev
 reload (#64081)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 src/frame/lib/create-tree.ts        | 100 ++++++++++++------------
 src/frame/lib/page-data.ts          |   8 +-
 src/frame/middleware/reload-tree.ts |   9 ++-
 src/frame/tests/create-tree.ts      | 115 ++++++++++++++++++++++++++++
 4 files changed, 176 insertions(+), 56 deletions(-)
 create mode 100644 src/frame/tests/create-tree.ts

diff --git a/src/frame/lib/create-tree.ts b/src/frame/lib/create-tree.ts
index aac7b670d404..507864b7eba1 100644
--- a/src/frame/lib/create-tree.ts
+++ b/src/frame/lib/create-tree.ts
@@ -68,77 +68,73 @@ export default async function createTree(
     page = newPage as unknown as Page
   }
 
+  // A reused page has filtered children, so the declared list comes from the previous tree.
+  const declaredChildren =
+    previousTree && previousTree.page === page ? previousTree.children : page.children || []
+
   const item: UnversionedTree = {
     page,
-    // Development reloads reuse subtrees only when the ordered children list matches.
-    children: page.children || [],
+    // Declared children stay intact so later reloads retry skipped content that appears on disk.
+    children: declaredChildren,
     childPages: [],
   }
 
-  if (page.children) {
+  if (declaredChildren.length) {
     assertUniqueChildren(page)
-    item.childPages = (
-      await Promise.all(
-        (page.children as string[]).map(async (child: string, i: number) => {
-          let childPreviousTree: UnversionedTree | undefined
-          if (previousTree && previousTree.childPages) {
-            if (equalArray(page.children as string[], previousTree.children)) {
-              // Matching child names and order keep indexes tied to the same previous subtree.
-              childPreviousTree = previousTree.childPages[i]
-            }
-          }
-
-          // Absolute paths such as /content/actions/workflows pull a subtree, even from another product.
-          let childPath: string
-          if (child.startsWith('/content/')) {
-            const absoluteChildPath = child.slice('/content/'.length)
-            childPath = path.posix.join(basePath, absoluteChildPath)
-
-            // Reject path traversal by requiring the resolved path to stay under the content root.
-            const resolvedPath = path.resolve(childPath)
-            const resolvedBasePath = path.resolve(basePath)
-            if (!resolvedPath.startsWith(resolvedBasePath + path.sep)) {
-              throw new Error(
-                `Invalid child path "${child}" in ${originalPath}/index.md - path traversal detected. ` +
-                  `Resolved path "${resolvedPath}" escapes content directory "${resolvedBasePath}".`,
-              )
-            }
-          } else {
-            // Relative child paths resolve from their parent path.
-            childPath = path.posix.join(originalPath, child)
-          }
-
-          const subTree = await createTree(childPath, basePath, childPreviousTree)
-          if (subTree && child.startsWith('/content/')) {
-            // Cross-product children stay out of the sidebar.
-            subTree.crossProductChild = true
-          }
-          if (!subTree) {
-            // Remove skipped subtrees so development reloads compare against the rendered child list.
-            ;(page.children as string[]) = (page.children as string[]).filter(
-              (c: string) => c !== child,
+    // The previous page's children line up with its childPages, so cached subtrees match by name.
+    const previousChildPages = new Map<string, UnversionedTree>()
+    if (previousTree) {
+      for (const [i, child] of (previousTree.page.children || []).entries()) {
+        previousChildPages.set(child, previousTree.childPages[i])
+      }
+    }
+    const subTrees = await Promise.all(
+      declaredChildren.map(async (child: string) => {
+        const childPreviousTree = previousChildPages.get(child)
+
+        // Absolute paths such as /content/actions/workflows pull a subtree, even from another product.
+        let childPath: string
+        if (child.startsWith('/content/')) {
+          const absoluteChildPath = child.slice('/content/'.length)
+          childPath = path.posix.join(basePath, absoluteChildPath)
+
+          // Reject path traversal by requiring the resolved path to stay under the content root.
+          const resolvedPath = path.resolve(childPath)
+          const resolvedBasePath = path.resolve(basePath)
+          if (!resolvedPath.startsWith(resolvedBasePath + path.sep)) {
+            throw new Error(
+              `Invalid child path "${child}" in ${originalPath}/index.md - path traversal detected. ` +
+                `Resolved path "${resolvedPath}" escapes content directory "${resolvedBasePath}".`,
             )
           }
-          return subTree
-        }),
-      )
-    ).filter((tree): tree is UnversionedTree => tree !== undefined)
+        } else {
+          // Relative child paths resolve from their parent path.
+          childPath = path.posix.join(originalPath, child)
+        }
+
+        const subTree = await createTree(childPath, basePath, childPreviousTree)
+        if (subTree && child.startsWith('/content/')) {
+          // Cross-product children stay out of the sidebar.
+          subTree.crossProductChild = true
+        }
+        return subTree
+      }),
+    )
+    // Skipped subtrees, such as missing early-access content, leave the rendered children list.
+    page.children = declaredChildren.filter((_, i) => subTrees[i])
+    item.childPages = subTrees.filter((tree): tree is UnversionedTree => tree !== undefined)
   }
 
   return item
 }
 
-function equalArray(arr1: string[], arr2: string[]): boolean {
-  return arr1.length === arr2.length && arr1.every((value, i) => value === arr2[i])
-}
-
 async function getMtime(filePath: string): Promise<number> {
   if (isProduction) {
     // Production skips the full stat but still verifies existence.
     await fs.access(filePath)
     return 1
   }
-  return Math.round((await fs.stat(filePath)).mtimeMs)
+  return (await fs.stat(filePath)).mtimeMs
 }
 
 function assertUniqueChildren(page: Page): void {
diff --git a/src/frame/lib/page-data.ts b/src/frame/lib/page-data.ts
index fc77b6db4d4c..499e06bfd1f9 100644
--- a/src/frame/lib/page-data.ts
+++ b/src/frame/lib/page-data.ts
@@ -85,9 +85,12 @@ export async function loadUnversionedTree(
 }
 
 // Category pages inherit applicable versions from immediate children.
-function setCategoryApplicableVersions(tree: UnversionedTree): void {
-  for (const childPage of tree.childPages) {
+export function setCategoryApplicableVersions(tree: UnversionedTree): void {
+  // Translated leaves have no childPages array.
+  for (const childPage of tree.childPages || []) {
     if (childPage.page.relativePath.endsWith('index.md')) {
+      // Nested categories settle first so the union reads their current versions.
+      setCategoryApplicableVersions(childPage)
       const combinedApplicableVersions: string[] = []
       let moreThanOneChild = false
       for (const childChildPage of childPage.childPages || []) {
@@ -96,7 +99,6 @@ function setCategoryApplicableVersions(tree: UnversionedTree): void {
             combinedApplicableVersions.push(version)
           }
         }
-        setCategoryApplicableVersions(childPage)
         moreThanOneChild = true
       }
       if (
diff --git a/src/frame/middleware/reload-tree.ts b/src/frame/middleware/reload-tree.ts
index 4432194a54dc..9ea38a29e5ab 100644
--- a/src/frame/middleware/reload-tree.ts
+++ b/src/frame/middleware/reload-tree.ts
@@ -11,7 +11,12 @@ import type { ExtendedRequest, UnversionedTree, SiteTree } from '@/types'
 import languages, { languageKeys } from '@/languages/lib/languages-server'
 import createTree from '@/frame/lib/create-tree'
 import warmServer from '@/frame/lib/warm-server'
-import { loadSiteTree, loadPages, loadPageMap } from '@/frame/lib/page-data'
+import {
+  loadSiteTree,
+  loadPages,
+  loadPageMap,
+  setCategoryApplicableVersions,
+} from '@/frame/lib/page-data'
 import loadRedirects from '@/redirects/lib/precompile'
 
 const languagePrefixRegex = new RegExp(`^/(${languageKeys.join('|')})(/|$)`)
@@ -38,6 +43,8 @@ export default async function reloadTree(req: ExtendedRequest, res: Response, ne
   const after = getMtimes(warmed.unversionedTree.en)
   // Dependent maps take about 140ms after a 40ms tree refresh, so skip them when mtimes match.
   if (before !== after) {
+    // Reinitialized category pages lose the child-derived versions that startup applies.
+    setCategoryApplicableVersions(warmed.unversionedTree.en)
     warmed.siteTree = (await loadSiteTree(warmed.unversionedTree)) as SiteTree
     warmed.pageList = await loadPages(warmed.unversionedTree)
     warmed.pages = await loadPageMap(warmed.pageList)
diff --git a/src/frame/tests/create-tree.ts b/src/frame/tests/create-tree.ts
new file mode 100644
index 000000000000..c0ba7396c1f1
--- /dev/null
+++ b/src/frame/tests/create-tree.ts
@@ -0,0 +1,115 @@
+import fs from 'fs/promises'
+
+import { describe, expect, test } from 'vitest'
+
+import createTree from '@/frame/lib/create-tree'
+import { setCategoryApplicableVersions } from '@/frame/lib/page-data'
+import type { Page, UnversionedTree } from '@/types'
+
+const contentDir = 'src/fixtures/fixtures/content'
+
+function flattenPages(tree: UnversionedTree): Page[] {
+  return [tree.page, ...tree.childPages.flatMap(flattenPages)]
+}
+
+function stubTree(relativePath: string, versions: string[], childPages: UnversionedTree[] = []) {
+  const page = {
+    relativePath,
+    languageCode: 'en',
+    title: relativePath,
+    applicableVersions: versions,
+    permalinks: [],
+  } as unknown as Page
+  return { page, children: [], childPages } as UnversionedTree
+}
+
+describe('createTree', () => {
+  test('reuses every unchanged page from the previous tree', async () => {
+    const first = (await createTree(contentDir)) as UnversionedTree
+    const second = (await createTree(contentDir, undefined, first)) as UnversionedTree
+
+    const firstPages = flattenPages(first)
+    const secondPages = flattenPages(second)
+    expect(firstPages.length).toBeGreaterThan(1)
+    expect(secondPages.length).toBe(firstPages.length)
+    const notReused = secondPages.filter((page, i) => page !== firstPages[i])
+    expect(notReused.map((page) => page.relativePath)).toEqual([])
+  })
+
+  test('revisits a declared child that an earlier build skipped', async () => {
+    const first = (await createTree(contentDir)) as UnversionedTree
+    const declared = [...first.children]
+    const skipped = declared[1]
+    // Missing early-access content leaves this shape: declared children kept, rendered list filtered.
+    first.page.children = declared.filter((child) => child !== skipped)
+    first.childPages.splice(1, 1)
+
+    const second = (await createTree(contentDir, undefined, first)) as UnversionedTree
+
+    expect(second.page).toBe(first.page)
+    expect(second.children).toEqual(declared)
+    expect(second.page.children).toEqual(declared)
+    expect(second.childPages.length).toBe(declared.length)
+    const previousPages = new Set(first.childPages.map((tree) => tree.page))
+    const reused = second.childPages.filter((tree) => previousPages.has(tree.page))
+    expect(reused.length).toBe(declared.length - 1)
+  })
+
+  test('stores the file mtime on the page', async () => {
+    const tree = (await createTree(contentDir)) as UnversionedTree
+    const { mtimeMs } = await fs.stat(tree.page.fullPath)
+    expect(tree.page.mtime).toBe(mtimeMs)
+  })
+})
+
+describe('setCategoryApplicableVersions', () => {
+  test('narrows a category to the versions of its children', () => {
+    const category = stubTree(
+      'rest/credentials/index.md',
+      ['free-pro-team@latest', 'enterprise-cloud@latest', 'enterprise-server@3.20'],
+      [
+        stubTree('rest/credentials/article.md', [
+          'free-pro-team@latest',
+          'enterprise-cloud@latest',
+        ]),
+      ],
+    )
+    const root = stubTree('index.md', ['free-pro-team@latest'], [category])
+
+    setCategoryApplicableVersions(root)
+
+    expect(category.page.applicableVersions).toEqual([
+      'free-pro-team@latest',
+      'enterprise-cloud@latest',
+    ])
+    expect(category.page.permalinks.map((permalink) => permalink.pageVersion)).toEqual([
+      'free-pro-team@latest',
+      'enterprise-cloud@latest',
+    ])
+  })
+
+  test('carries a leaf version change up through an already narrowed tree', () => {
+    const allVersions = ['free-pro-team@latest', 'enterprise-cloud@latest']
+    const article = stubTree('rest/credentials/article.md', ['free-pro-team@latest'])
+    const category = stubTree('rest/credentials/index.md', allVersions, [article])
+    const product = stubTree('rest/index.md', allVersions, [category])
+    const root = stubTree('index.md', allVersions, [product])
+    setCategoryApplicableVersions(root)
+    expect(product.page.applicableVersions).toEqual(['free-pro-team@latest'])
+
+    article.page.applicableVersions = allVersions
+    setCategoryApplicableVersions(root)
+
+    expect(category.page.applicableVersions).toEqual(allVersions)
+    expect(product.page.applicableVersions).toEqual(allVersions)
+  })
+
+  test('skips a category without a childPages array, as in translated trees', () => {
+    const leafCategory = stubTree('rest/empty/index.md', ['free-pro-team@latest'])
+    delete (leafCategory as Partial<UnversionedTree>).childPages
+    const root = stubTree('index.md', ['free-pro-team@latest'], [leafCategory])
+
+    expect(() => setCategoryApplicableVersions(root)).not.toThrow()
+    expect(leafCategory.page.applicableVersions).toEqual(['free-pro-team@latest'])
+  })
+})

From fa8b3ef859c6a440898d719fd30402e3e5e10e0c Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Wed, 21 Oct 2026 14:03:28 +0000
Subject: [PATCH 70/71] Exclude early-access symlinks from the Docker build
 context (#64084)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 .dockerignore | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/.dockerignore b/.dockerignore
index 087716df1f38..8be236839d86 100644
--- a/.dockerignore
+++ b/.dockerignore
@@ -8,3 +8,7 @@ docs-early-access/
 node_modules/
 README.md
 tests/
+# Local symlinks to docs-early-access. merge-early-access.sh creates these during the build.
+assets/images/early-access
+content/early-access
+data/early-access

From ad8d32c9875c30961a7135bfea862eba55060b80 Mon Sep 17 00:00:00 2001
From: Kevin Heis <heiskr@users.noreply.github.com>
Date: Wed, 21 Oct 2026 14:03:35 +0000
Subject: [PATCH 71/71] Stop GHD009 from hiding frontmatter errors and crashing
 lint (#64089)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf5940de-658e-4a1a-bffa-3018fb78b138
---
 .../linting-rules/early-access-references.ts  | 75 +++++++++++-----
 .../lib/linting-rules/frontmatter-children.ts |  6 ++
 .../early-access-child.md                     |  8 ++
 .../tests/unit/early-access-references.ts     | 90 +++++++++++++++++++
 .../tests/unit/frontmatter-children.ts        | 10 +++
 5 files changed, 166 insertions(+), 23 deletions(-)
 create mode 100644 src/content-linter/tests/fixtures/frontmatter-children/early-access-child.md

diff --git a/src/content-linter/lib/linting-rules/early-access-references.ts b/src/content-linter/lib/linting-rules/early-access-references.ts
index 327487f64a79..39efb87c50f9 100644
--- a/src/content-linter/lib/linting-rules/early-access-references.ts
+++ b/src/content-linter/lib/linting-rules/early-access-references.ts
@@ -1,15 +1,10 @@
 import { addError } from 'markdownlint-rule-helpers'
-import { dump } from 'js-yaml'
+import { EVENT_ID, getScalarValue, parseEvents } from 'js-yaml'
+import type { Event } from 'js-yaml'
 
-import { getRange, getFrontmatter } from '../helpers/utils'
+import { getRange, getFrontmatterLines } from '../helpers/utils'
 import type { RuleParams, RuleErrorCallback, Rule } from '@/content-linter/types'
 
-interface Frontmatter {
-  redirect_from?: string | string[]
-  children?: string[]
-  [key: string]: unknown
-}
-
 const ERROR_MESSAGE =
   'An early access reference appears to be used in a non-early access doc. Remove early access references or disable this rule.'
 
@@ -56,31 +51,65 @@ export const frontmatterEarlyAccessReferences: Rule = {
     const filepath = params.name
     if (isEarlyAccessFilepath(filepath)) return
 
-    const fm = getFrontmatter(params.lines) as Frontmatter | null
-    if (!fm) return
+    if (params.lines[0] !== '---') return
 
     // redirect_from preserves early-access paths for redirects.
-    delete fm.redirect_from
-
+    const skippedKeys = new Set(['redirect_from'])
     // The home page links to early access content, and fixture indexes mirror that pattern.
     if (filepath === 'content/index.md' || filepath.includes('fixtures/content/index.md'))
-      delete fm.children
+      skippedKeys.add('children')
 
-    // YAML serialization lets the rule search every remaining frontmatter value.
-    const fmStrings = dump(fm).split('\n')
+    // Parser events exclude YAML comments and give source offsets for quoted, folded, and block values.
+    const fmLines = getFrontmatterLines(params.lines)
+    const source = fmLines.slice(1, -1).join('\n')
+    let events: Event[]
+    try {
+      events = parseEvents(source, {})
+    } catch {
+      // Other frontmatter rules and page loading report invalid YAML.
+      return
+    }
 
-    for (const line of fmStrings) {
-      const matches = line.match(EARLY_ACCESS_REGEX)
-      if (matches && !EARLY_ACCESS_ARTICLE_REGEX.test(line)) {
-        for (const match of matches) {
-          const lineNumber = params.lines.indexOf(line) + 1
-          const range = getRange(line, match)
+    const lineStarts = [0]
+    for (let i = 0; i < source.length; i++) if (source[i] === '\n') lineStarts.push(i + 1)
+    const containers: { isMapping: boolean; count: number }[] = []
+    let topLevelKey = ''
+    for (const event of events) {
+      if (event.type === EVENT_ID.POP) {
+        containers.pop()
+        continue
+      }
+      const parent = containers.at(-1)
+      const isTopLevelKey =
+        containers.length === 2 && parent?.isMapping === true && parent.count % 2 === 0
+      if (parent) parent.count++
+      if (event.type !== EVENT_ID.SCALAR) {
+        if (isTopLevelKey) topLevelKey = ''
+        if (event.type !== EVENT_ID.ALIAS) {
+          containers.push({ isMapping: event.type === EVENT_ID.MAPPING, count: 0 })
+        }
+        continue
+      }
+      if (isTopLevelKey) topLevelKey = getScalarValue(source, event)
+      if (skippedKeys.has(topLevelKey)) continue
+
+      for (let i = 0; i < lineStarts.length; i++) {
+        const lineStart = lineStarts[i]
+        const lineEnd = i + 1 < lineStarts.length ? lineStarts[i + 1] - 1 : source.length
+        const segmentStart = Math.max(event.valueStart, lineStart)
+        const segmentEnd = Math.min(event.valueEnd, lineEnd)
+        if (segmentStart >= segmentEnd) continue
+
+        const segment = source.slice(segmentStart, segmentEnd)
+        if (EARLY_ACCESS_ARTICLE_REGEX.test(segment)) continue
+        const line = fmLines[i + 1]
+        for (const match of segment.matchAll(EARLY_ACCESS_REGEX)) {
           addError(
             onError,
-            lineNumber,
+            i + 2,
             ERROR_MESSAGE,
             line,
-            range,
+            [segmentStart - lineStart + match.index + 1, match[0].length],
             null, // No fix possible
           )
         }
diff --git a/src/content-linter/lib/linting-rules/frontmatter-children.ts b/src/content-linter/lib/linting-rules/frontmatter-children.ts
index f09c80f1a93e..677754bf5bba 100644
--- a/src/content-linter/lib/linting-rules/frontmatter-children.ts
+++ b/src/content-linter/lib/linting-rules/frontmatter-children.ts
@@ -32,6 +32,12 @@ function isValidChildPath(childPath: string, currentFilePath: string): boolean {
     return false
   }
 
+  // Early access content comes from a separate repo that may not be cloned, so create-tree only warns when it is missing.
+  const earlyAccessDir = path.join(contentDir, 'early-access')
+  if (resolvedPath === earlyAccessDir || resolvedPath.startsWith(earlyAccessDir + path.sep)) {
+    return true
+  }
+
   const mdPath = `${resolvedPath}.md`
   if (fs.existsSync(mdPath) && fs.statSync(mdPath).isFile()) {
     return true
diff --git a/src/content-linter/tests/fixtures/frontmatter-children/early-access-child.md b/src/content-linter/tests/fixtures/frontmatter-children/early-access-child.md
new file mode 100644
index 000000000000..6ae5bbd7faea
--- /dev/null
+++ b/src/content-linter/tests/fixtures/frontmatter-children/early-access-child.md
@@ -0,0 +1,8 @@
+---
+title: Missing early access child
+children:
+  - /content/get-started/foo
+  - /content/early-access/not-cloned
+---
+
+Early access content lives in a separate repository that might not be cloned.
diff --git a/src/content-linter/tests/unit/early-access-references.ts b/src/content-linter/tests/unit/early-access-references.ts
index cb6209e80094..b442446512bd 100644
--- a/src/content-linter/tests/unit/early-access-references.ts
+++ b/src/content-linter/tests/unit/early-access-references.ts
@@ -1,6 +1,7 @@
 import { describe, expect, test } from 'vitest'
 
 import { runRule } from '../../lib/init-test'
+import { getFrontmatter } from '../../lib/helpers/utils'
 import {
   earlyAccessReferences,
   frontmatterEarlyAccessReferences,
@@ -51,4 +52,93 @@ describe(frontmatterEarlyAccessReferences.names.join(' - '), () => {
     const errors = result[FIXTURE_FILEPATH_EA]
     expect(errors.length).toBe(0)
   })
+  test('reports source line numbers for quoted and folded values', async () => {
+    const markdown = [
+      '---',
+      "title: 'About early-access features'",
+      'intro: "Join the early-access program"',
+      'shortTitle: >-',
+      '  A folded value that mentions',
+      '  early-access on a continuation line',
+      'redirect_from:',
+      '  - /early-access/old',
+      '---',
+      '',
+    ].join('\n')
+    const result = await runRule(frontmatterEarlyAccessReferences, {
+      strings: { markdown },
+      ...fmOptions,
+    })
+    const lineNumbers = result.markdown.map((error) => error.lineNumber)
+    expect(lineNumbers).toEqual([2, 3, 6])
+  })
+  test('home page children can reference early access', async () => {
+    const markdown = ['---', 'title: Home', 'children:', '  - early-access', '---', ''].join('\n')
+    const result = await runRule(frontmatterEarlyAccessReferences, {
+      strings: { 'content/index.md': markdown },
+      ...fmOptions,
+    })
+    expect(result['content/index.md']).toEqual([])
+  })
+  test('quoted skipped keys can reference early access', async () => {
+    const markdown = [
+      '---',
+      'title: Home',
+      '"redirect_from":',
+      '  - /early-access/double',
+      "'children':",
+      '  - early-access',
+      '---',
+      '',
+    ].join('\n')
+    const result = await runRule(frontmatterEarlyAccessReferences, {
+      strings: { 'content/index.md': markdown },
+      ...fmOptions,
+    })
+    expect(result['content/index.md']).toEqual([])
+    const swapped = markdown
+      .replace('"redirect_from"', "'redirect_from'")
+      .replace("'children'", '"children"')
+    const swappedResult = await runRule(frontmatterEarlyAccessReferences, {
+      strings: { 'content/index.md': swapped },
+      ...fmOptions,
+    })
+    expect(swappedResult['content/index.md']).toEqual([])
+  })
+  test('ignores YAML comments and checks block scalar lines that start with #', async () => {
+    const markdown = [
+      '---',
+      'title: Public # early-access reminder',
+      '# early-access comment',
+      'intro: |',
+      '  # [Preview](/early-access/secret)',
+      '---',
+      '',
+    ].join('\n')
+    const result = await runRule(frontmatterEarlyAccessReferences, {
+      strings: { markdown },
+      ...fmOptions,
+    })
+    expect(result.markdown.map((error) => error.lineNumber)).toEqual([5])
+    expect(result.markdown[0].errorRange).toEqual([16, 12])
+  })
+  test('does not remove frontmatter keys that later rules read', async () => {
+    const markdown = [
+      '---',
+      'title: Home',
+      'redirect_from:',
+      '  - /early-access/old',
+      'children:',
+      '  - early-access',
+      '---',
+      '',
+    ].join('\n')
+    await runRule(frontmatterEarlyAccessReferences, {
+      strings: { 'content/index.md': markdown },
+      ...fmOptions,
+    })
+    const fm = getFrontmatter(markdown.split('\n'))
+    expect(fm?.redirect_from).toEqual(['/early-access/old'])
+    expect(fm?.children).toEqual(['early-access'])
+  })
 })
diff --git a/src/content-linter/tests/unit/frontmatter-children.ts b/src/content-linter/tests/unit/frontmatter-children.ts
index 32fa9eca920f..b45ef3727012 100644
--- a/src/content-linter/tests/unit/frontmatter-children.ts
+++ b/src/content-linter/tests/unit/frontmatter-children.ts
@@ -7,6 +7,8 @@ const VALID_CONTENT_PREFIX =
   'src/content-linter/tests/fixtures/frontmatter-children/valid-content-prefix.md'
 const INVALID_PATHS = 'src/content-linter/tests/fixtures/frontmatter-children/invalid-paths.md'
 const NO_CHILDREN = 'src/content-linter/tests/fixtures/frontmatter-children/no-children.md'
+const EARLY_ACCESS_CHILD =
+  'src/content-linter/tests/fixtures/frontmatter-children/early-access-child.md'
 
 const ruleName = frontmatterChildren.names[1]
 
@@ -50,4 +52,12 @@ describe(ruleName, () => {
     expect(result[INVALID_PATHS][0].errorDetail).toContain('/content/nonexistent/product')
     expect(result[INVALID_PATHS][0].errorDetail).toContain('/another/invalid/path')
   })
+
+  test('missing early access children pass', async () => {
+    const result = await runRule(frontmatterChildren, {
+      files: [EARLY_ACCESS_CHILD],
+      ...fmOptions,
+    })
+    expect(result[EARLY_ACCESS_CHILD]).toEqual([])
+  })
 })