@@ -331,192 +331,3 @@ describe('Confluence plain search ranking', () => {
     expect(own.nextCursor).toBe('page-2')
   })
 })
-
-describe('Jira plain search ranking', () => {
-  const search = '/ex/jira/cloud/rest/api/3/search/jql'
-  /** `outsideMatch`: the issue lacks a query term, so a `text ~` all-terms clause drops it. */
-  type Issue = string | { key: string; summary: string; outsideMatch?: boolean }
-  /**
-   * Answers the all-terms query with `exact`, the all-terms summary query with `titled`, and the
-   * half-the-terms summary query with `half`, or their failures.
-   */
-  function jira(
-    exact: { ids: string[]; more: boolean },
-    titled: Issue[] | (() => never),
-    half: Issue[] | (() => never) = []
-  ) {
-    const toRow = (row: Issue): Exclude<Issue, string> =>
-      typeof row === 'string' ? { key: row, summary: row } : row
-    const issues = (rows: Issue[]) =>
-      rows.map(toRow).map(({ key, summary }) => ({ key, fields: { summary } }))
-    const json = vi.fn(
-      async (path: string, options?: { body?: { jql?: string; maxResults?: number } }) => {
-        if (path === '/oauth/token/accessible-resources') return [SITE]
-        if (path !== search) throw new Error(`Unexpected request: ${path}`)
-        const jql = options?.body?.jql ?? ''
-        if (jql.includes('summary ~')) {
-          const rows = jql.includes(' OR ') ? half : titled
-          const picked = (typeof rows === 'function' ? rows() : rows)
-            .map(toRow)
-            .filter((row) => !(row.outsideMatch && jql.includes('text ~')))
-          return { issues: issues(picked).slice(0, options?.body?.maxResults) }
-        }
-        return { issues: issues(exact.ids), ...(exact.more ? { nextPageToken: 'page-2' } : {}) }
-      }
-    )
-    return { json, text: vi.fn(), bytes: vi.fn() } satisfies NativeClient
-  }
-  const query = { query: 'merged results pipelines', limit: 3, scopes: [] }
-  const overflowing = { ids: ['NEW-3', 'NEW-2', 'NEW-1'], more: true }
-
-  it('leads an all-terms match too large for one page with issues whose summary holds every term', async () => {
-    const api = jira(overflowing, ['TOP-1', 'NEW-2'])
-    const page = await searchAtlassian(api, 'jira', query)
-    expect(page.documents.map((document) => document.id)).toEqual(['TOP-1', 'NEW-2', 'NEW-3'])
-    expect(page.hasMore).toBe(true)
-    expect(page.partial).toBe(true)
-    expect(page.nextCursor).toBeUndefined()
-  })
-
-  it('keeps the all-terms page and its cursor when no summary holds every term', async () => {
-    const page = await searchAtlassian(jira(overflowing, []), 'jira', query)
-    expect(page.documents.map((document) => document.id)).toEqual(['NEW-3', 'NEW-2', 'NEW-1'])
-    expect(page.nextCursor).toBe('page-2')
-    expect(page.partial).toBe(false)
-  })
-
-  it.each([
-    ['a provider refusal', new NativeSearchError('rate_limited', 'Rate limited.', 30)],
-    ['a request timeout', new Error('Request timed out after 10000ms')],
-  ])(
-    'keeps the all-terms page and its cursor when the summary search fails on %s',
-    async (_, failure) => {
-      const api = jira(overflowing, () => {
-        throw failure
-      })
-      const page = await searchAtlassian(api, 'jira', query)
-      expect(page.documents.map((document) => document.id)).toEqual(['NEW-3', 'NEW-2', 'NEW-1'])
-      expect(page.nextCursor).toBe('page-2')
-    }
-  )
-
-  it('propagates a cancellation during the summary search', async () => {
-    const caller = new AbortController()
-    const reason = new DOMException('Search cancelled', 'AbortError')
-    const api = jira(overflowing, () => {
-      caller.abort(reason)
-      throw reason
-    })
-    await expect(searchAtlassian(api, 'jira', { ...query, signal: caller.signal })).rejects.toBe(
-      reason
-    )
-  })
-
-  it('keeps an all-terms match that fits on one page without a summary search', async () => {
-    const api = jira({ ids: ['ONLY-1'], more: false }, ['TOP-1'])
-    const page = await searchAtlassian(api, 'jira', query)
-    expect(page.documents.map((document) => document.id)).toEqual(['ONLY-1'])
-    expect(api.json).toHaveBeenCalledTimes(2)
-  })
-
-  it('keeps date order, native queries and any-term matches on their own page', async () => {
-    for (const input of [
-      { ...query, filters: { sortBy: 'newest' as const } },
-      { ...query, native: { provider: 'jira' as const, query: 'text ~ "merged results"' } },
-      { ...query, textMatch: 'any' as const },
-    ]) {
-      const api = jira({ ids: ['NEW-3', 'NEW-2'], more: true }, ['TOP-1'])
-      const page = await searchAtlassian(api, 'jira', input)
-      expect(page.documents.map((document) => document.id)).not.toContain('TOP-1')
-      expect(api.json).toHaveBeenCalledTimes(2)
-    }
-  })
-
-  it('leads with issues whose summary holds at least half the terms when none holds them all', async () => {
-    const api = jira(
-      overflowing,
-      [],
-      [
-        { key: 'LOOSE-1', summary: 'Pipelines dashboard' },
-        { key: 'HALF-1', summary: 'Merged results broke the dashboard' },
-      ]
-    )
-    const page = await searchAtlassian(api, 'jira', query)
-    expect(page.documents.map((document) => document.id)).toEqual(['HALF-1', 'NEW-3', 'NEW-2'])
-    expect(page.nextCursor).toBeUndefined()
-  })
-
-  it('keeps a two-term query to summaries holding every term', async () => {
-    const api = jira(overflowing, [], [{ key: 'HALF-1', summary: 'Merged pipelines' }])
-    const page = await searchAtlassian(api, 'jira', { ...query, query: 'merged pipelines' })
-    expect(page.documents.map((document) => document.id)).toEqual(['NEW-3', 'NEW-2', 'NEW-1'])
-    expect(api.json).toHaveBeenCalledTimes(3)
-  })
-
-  it('keeps the all-terms page and its cursor when the half-the-terms summary search fails', async () => {
-    const api = jira(overflowing, [], () => {
-      throw new NativeSearchError('rate_limited', 'Rate limited.', 30)
-    })
-    const page = await searchAtlassian(api, 'jira', query)
-    expect(page.documents.map((document) => document.id)).toEqual(['NEW-3', 'NEW-2', 'NEW-1'])
-    expect(page.nextCursor).toBe('page-2')
-  })
-
-  it('counts a word and its plural as one term before allowing the half-the-terms fallback', async () => {
-    const api = jira(overflowing, [], [{ key: 'ONE-1', summary: 'Rotation schedule' }])
-    const page = await searchAtlassian(api, 'jira', { ...query, query: 'token tokens rotation' })
-    expect(page.documents.map((document) => document.id)).toEqual(['NEW-3', 'NEW-2', 'NEW-1'])
-  })
-
-  it('orders half-the-terms summaries by how many terms they hold', async () => {
-    const api = jira(
-      overflowing,
-      [],
-      [
-        { key: 'TWO-1', summary: 'Merged results dashboard' },
-        { key: 'THREE-1', summary: 'Merged results in release pipelines' },
-      ]
-    )
-    const page = await searchAtlassian(api, 'jira', {
-      ...query,
-      query: 'merged results release pipelines',
-    })
-    expect(page.documents.map((document) => document.id)).toEqual(['THREE-1', 'TWO-1', 'NEW-3'])
-  })
-
-  it('finds half-the-terms summaries beyond the first page of pair matches', async () => {
-    const pairs = Array.from({ length: 10 }, (_, index) => ({
-      key: `PAIR-${index}`,
-      summary: 'Pipelines dashboard',
-    }))
-    const api = jira(overflowing, [], [...pairs, { key: 'HALF-9', summary: 'Merged pipelines' }])
-    const page = await searchAtlassian(api, 'jira', query)
-    expect(page.documents.map((document) => document.id)[0]).toBe('HALF-9')
-  })
-
-  it('follows summaries holding every term with those holding half of them', async () => {
-    const api = jira(
-      { ids: ['NEW-3', 'NEW-2', 'NEW-1'], more: true },
-      ['ALL-1'],
-      [
-        { key: 'ALL-1', summary: 'Merged results pipelines' },
-        { key: 'HALF-1', summary: 'Merged results dashboard' },
-      ]
-    )
-    const page = await searchAtlassian(api, 'jira', query)
-    expect(page.documents.map((document) => document.id)).toEqual(['ALL-1', 'HALF-1', 'NEW-3'])
-  })
-
-  it('keeps half-the-terms summaries to issues that match every term somewhere', async () => {
-    const api = jira(
-      overflowing,
-      [],
-      [
-        { key: 'OUTSIDE-1', summary: 'Merged results dashboard', outsideMatch: true },
-        { key: 'INSIDE-1', summary: 'Merged results broke the dashboard' },
-      ]
-    )
-    const page = await searchAtlassian(api, 'jira', query)
-    expect(page.documents.map((document) => document.id)).toEqual(['INSIDE-1', 'NEW-3', 'NEW-2'])
-  })
-})
@@ -13,7 +13,6 @@ import {
   confluenceTextClause,
   holdsHalfTheTerms,
   jiraTextClause,
-  stemmedTerms,
 } from '@/lib/sim-search/live/text-match'
 import type {
   NativeClient,
@@ -117,14 +116,6 @@ async function sites(client: NativeClient) {
   return array(await client.json('/oauth/token/accessible-resources', { memo: true }))
 }
 
-/**
- * Issues fetched for the half-the-terms summary tier: summary pair matches within the all-terms
- * match. Jira returns them newest first, not by relevance, and the page is then filtered to
- * summaries holding enough terms, so it starts from a wider pool than the caller's limit or the
- * any-term fallback's.
- */
-const HALF_TERM_CANDIDATES = 50
-
 /**
  * One Atlassian site's page; `ranking` marks a page whose order or completeness differs from the
  * all-terms search.
@@ -184,89 +175,33 @@ export async function searchAtlassian(
       const cloudId = string(site.id)
       const origin = string(site.url).replace(/\/$/, '')
       if (provider === 'jira') {
-        /** One JQL page, each issue with its summary and raw fields. */
-        const searchIssues = async (
-          jql: string,
-          { cursor, maxResults = input.limit }: { cursor?: string; maxResults?: number } = {}
-        ) => {
-          const data = object(
-            await client.json(`/ex/jira/${segment(cloudId)}/rest/api/3/search/jql`, {
-              body: {
-                jql: scopeAtlassianQuery(jql, scope, order),
-                maxResults,
-                fields: ['summary', 'description', 'updated', 'creator', 'status'],
-                ...(cursor ? { nextPageToken: cursor } : {}),
-              },
-              signal: input.signal,
-            })
-          )
-          return {
-            issues: array(data.issues).map((row) => {
-              const fields = object(row.fields)
-              return {
-                document: issue(row, cloudId, origin),
-                summary: string(fields.summary),
-                fields,
-              }
-            }),
-            next: string(data.nextPageToken) || undefined,
-          }
-        }
-        const exact = await searchIssues(
-          input.native?.query || (text ? jiraTextClause(text, input.textMatch) : ''),
-          { cursor: input.native?.cursor && single ? input.native.cursor : undefined }
+        const data = object(
+          await client.json(`/ex/jira/${segment(cloudId)}/rest/api/3/search/jql`, {
+            body: {
+              jql: scopeAtlassianQuery(
+                input.native?.query || (text ? jiraTextClause(text, input.textMatch) : ''),
+                scope,
+                order
+              ),
+              maxResults: input.limit,
+              fields: ['summary', 'description', 'updated', 'creator', 'status'],
+              ...(input.native?.cursor && single ? { nextPageToken: input.native.cursor } : {}),
+            },
+            signal: input.signal,
+          })
         )
-        const exactPage: SitePage = {
-          documents: exact.issues
-            .filter(
-              ({ summary, fields }) =>
-                !relevant || relevant(`${summary}\n${textContent(fields.description)}`)
-            )
-            .map(({ document }) => document),
-          excluded: false,
-          next: exact.next,
-        }
-        // JQL has no relevance order, so an all-terms match larger than a page comes back newest
-        // first. Within that match, issues whose summary holds every term lead it instead, then
-        // those whose summary holds at least half of three or more terms (most terms first); a
-        // summary match never brings in an issue lacking one of the terms.
-        if (!text || input.native || order || input.textMatch === 'any' || !exact.next)
-          return exactPage
-        const terms = stemmedTerms(text)
-        const [every, half] = await Promise.allSettled([
-          searchIssues(jiraTextClause(text, 'all', 'summary')),
-          terms.count >= 3
-            ? searchIssues(
-                `${jiraTextClause(text, 'any', 'summary')} AND ${jiraTextClause(text)}`,
-                { maxResults: HALF_TERM_CANDIDATES }
-              )
-            : undefined,
-        ])
-        // A cancelled search stops here; any other failure keeps the all-terms page.
-        input.signal?.throwIfAborted()
-        const everyTerm =
-          every.status === 'fulfilled' ? every.value.issues.map(({ document }) => document) : []
-        const halfTerms =
-          half.status === 'fulfilled' && half.value
-            ? half.value.issues
-                .map(({ document, summary }) => ({ document, held: terms.held(summary) }))
-                .filter(({ held }) => held >= terms.required)
-                .sort((left, right) => right.held - left.held)
-                .map(({ document }) => document)
-            : []
-        const titled = [...everyTerm, ...halfTerms]
-        if (!titled.length) return exactPage
-        const seen = new Set<string>()
         return {
-          documents: [...titled, ...exactPage.documents]
-            .filter(({ id }) => {
-              if (seen.has(id)) return false
-              seen.add(id)
-              return true
+          documents: array(data.issues)
+            .filter((row) => {
+              const fields = object(row.fields)
+              return (
+                !relevant ||
+                relevant(`${string(fields.summary)}\n${textContent(fields.description)}`)
+              )
             })
-            .slice(0, input.limit),
+            .map((row) => issue(row, cloudId, origin)),
           excluded: false,
-          ranking: 'relevance',
+          next: string(data.nextPageToken) || undefined,
         }
       }
       const searchPages = async (clause: string, cursor?: string) => {
@@ -330,9 +265,7 @@ export async function searchAtlassian(
         ? ' Matches other than pages, blog posts, and spaces (attachments, comments, whiteboards, folders, databases) were excluded because they cannot be read.'
         : '') +
       (pages.some((result) => result.ranking === 'relevance')
-        ? provider === 'jira'
-          ? ' More issues contained every word than fit on one page, so issues whose summary holds every word, then most of them, come first; refine the query, or page with a native JQL query.'
-          : ' More pages contained every word than fit on one page, so this page is ordered by Confluence relevance search; refine the query, or page with a native CQL query.'
+        ? ' More pages contained every word than fit on one page, so this page is ordered by Confluence relevance search; refine the query, or page with a native CQL query.'
         : '') +
       (pages.some((result) => result.ranking === 'unavailable')
         ? ' Relevance ranking was unavailable, so this page keeps the order of the all-terms search.'
 
@@ -89,19 +89,14 @@ const escapeSearchPhrase = (value: string) =>
   JSON.stringify(value.replace(/[+\-&|!(){}[\]^"~*?:\\/]/g, '\\$&'))
 
 /**
- * The clause for a plain query in Jira JQL, over all text fields or the summary alone. `any` ORs
- * every pair of the query's longest terms, so a match contains at least two of them in that field,
- * or either term of a two-term query. Jira stems text search, so a word and its plural share one
- * term.
+ * The `text ~` clause for a plain query in Jira JQL. `any` ORs every pair of the query's longest
+ * terms, so a match contains at least two of them somewhere in the issue, or either term of a
+ * two-term query. Jira stems text search, so a word and its plural share one term.
  */
-export function jiraTextClause(
-  text: string,
-  match: TextMatch = 'all',
-  field: 'text' | 'summary' = 'text'
-): string {
+export function jiraTextClause(text: string, match: TextMatch = 'all'): string {
   const terms = match === 'any' ? distinctTerms(text, singularKey) : []
-  if (terms.length < 2) return `${field} ~ ${escapeSearchPhrase(text)}`
-  const clause = (term: string) => `${field} ~ ${escapeSearchPhrase(term)}`
+  if (terms.length < 2) return `text ~ ${escapeSearchPhrase(text)}`
+  const clause = (term: string) => `text ~ ${escapeSearchPhrase(term)}`
   const groups =
     terms.length === 2
       ? terms.map(clause)
@@ -130,7 +125,7 @@ export function termCoverage(text: string, terms: readonly string[]): number {
  * Query and text words are compared by their singular key, so a word and its regular plural count
  * as one term; a term with punctuation inside it is matched as written.
  */
-export function stemmedTerms(query: string): {
+function stemmedTerms(query: string): {
   count: number
   /** At least half the terms, the minimum a partial match must hold. */
   required: number