@@ -16,6 +16,12 @@ const HEADER_LINE = /^[A-Z][A-Za-z-]{1,15}: .*$/
  */
 const WORD_CHARACTER =
   /(?![\p{sc=Han}\p{sc=Hiragana}\p{sc=Katakana}\p{sc=Hangul}\p{sc=Thai}])[\p{L}\p{N}_]/u
+const WORD_RUN = new RegExp(`(?:${WORD_CHARACTER.source})+`, 'gu')
+
+/** The words of a text, split where a run of `WORD_CHARACTER`s ends. */
+export function textWords(text: string): string[] {
+  return text.match(WORD_RUN) ?? []
+}
 
 /**
  * The document text without the header block some connectors prefix (the
 
@@ -23,9 +23,9 @@ import { livePolicyFor, loadLiveSearchPolicies } from '@/lib/sim-search/live/pol
 import { LIVE_SEARCH_PROVIDER_CATALOG } from '@/lib/sim-search/live/provider-catalog'
 import { isSearchProviderEnabled } from '@/lib/sim-search/live/provider-rollout'
 import {
-  anyTermRetry,
   previewNativeText,
   readNativeProvider,
+  requiresEveryTerm,
   searchNativeProvider,
 } from '@/lib/sim-search/live/providers'
 import { searchWithinPolicy } from '@/lib/sim-search/live/scoped-search'
@@ -205,9 +205,8 @@ export async function openLiveAccountSession(
           client ? searchNativeProvider(provider, client, native) : searchMcp(native)
         )
       }
-      const retry = client ? anyTermRetry(provider) : undefined
-      return retry
-        ? searchWithAnyTermFallback(searchOnce, search, signal, retry)
+      return client && requiresEveryTerm(provider)
+        ? searchWithAnyTermFallback(searchOnce, search, signal)
         : searchOnce(search)
     },
     async verify(document) {
 
@@ -26,7 +26,7 @@ const mocks = vi.hoisted(() => ({
   json: vi.fn(),
   service: vi.fn(),
   destroyPool: vi.fn(),
-  anyTermRetry: vi.fn(),
+  requiresEveryTerm: vi.fn(),
   preview: vi.fn(),
 }))
 vi.mock('@/lib/core/security/input-validation.server', () => inputValidationMock)
@@ -67,7 +67,7 @@ vi.mock('@/lib/sim-search/live/providers', () => ({
   liveSearchGuidance: (providers: string[]) => `Live coverage: ${[...new Set(providers)]}`,
   searchNativeProvider: mocks.search,
   readNativeProvider: mocks.read,
-  anyTermRetry: mocks.anyTermRetry,
+  requiresEveryTerm: mocks.requiresEveryTerm,
   previewNativeText: mocks.preview,
 }))
 vi.mock('@/executor/utils/resolved-secret-content-projection', () => ({
@@ -140,7 +140,7 @@ describe('authorized live retrieval', () => {
       documents: [{ ...document, id: 'src/a.ts', container: '42', kind: 'code' }],
     })
     mocks.adminVerify.mockResolvedValue(true)
-    mocks.anyTermRetry.mockReset().mockReturnValue(undefined)
+    mocks.requiresEveryTerm.mockReset().mockReturnValue(false)
     mocks.preview.mockReset().mockResolvedValue(undefined)
   })
   describe('Zoom continuation integrity', () => {
@@ -698,7 +698,7 @@ describe('authorized live retrieval', () => {
   })
 
   it('retries an underfilled search with any term for providers that require every term', async () => {
-    mocks.anyTermRetry.mockReturnValue({})
+    mocks.requiresEveryTerm.mockReturnValue(true)
     const loose = { ...document, id: 'loose', url: 'https://docs.google.com/document/d/loose/edit' }
     mocks.search.mockImplementation(async (_provider, _client, search) => ({
       documents: search.textMatch === 'any' ? [loose, document] : [document],
 
@@ -197,3 +197,36 @@ describe('Confluence live documents', () => {
     expect(await previewConfluence(page('<p>Rollout steps</p>'), document)).toBe('Rollout steps')
   })
 })
+
+describe('Jira any-term search', () => {
+  const issues = {
+    '/ex/jira/cloud/rest/api/3/search/jql': {
+      issues: [
+        { key: 'ENG-1', fields: { summary: 'Token creator role request' } },
+        { key: 'ENG-2', fields: { summary: 'Role request form' } },
+      ],
+    },
+  }
+  const query = { query: 'glean token creator role request', limit: 25, scopes: [] }
+
+  it('keeps only issues holding at least half the query terms', async () => {
+    const page = await searchAtlassian(client(issues), 'jira', { ...query, textMatch: 'any' })
+    expect(page.documents.map((document) => document.id)).toEqual(['ENG-1'])
+  })
+
+  it('keeps every issue an all-terms search returns', async () => {
+    const page = await searchAtlassian(client(issues), 'jira', query)
+    expect(page.documents.map((document) => document.id)).toEqual(['ENG-1', 'ENG-2'])
+  })
+
+  it('leaves a Confluence any-term search to its relevance ranking', async () => {
+    const api = client({
+      '/ex/confluence/cloud/wiki/rest/api/search': {
+        results: [{ content: { id: '5', type: 'page', title: 'Role request form' } }],
+        _links: {},
+      },
+    })
+    const page = await searchAtlassian(api, 'confluence', { ...query, textMatch: 'any' })
+    expect(page.documents.map((document) => document.id)).toEqual(['5'])
+  })
+})
@@ -9,7 +9,11 @@ import {
 } from '@/lib/sim-search/live/http'
 import { interleaveByRank } from '@/lib/sim-search/live/pages'
 import { providerText } from '@/lib/sim-search/live/text'
-import { confluenceTextClause, jiraTextClause } from '@/lib/sim-search/live/text-match'
+import {
+  confluenceTextClause,
+  holdsHalfTheTerms,
+  jiraTextClause,
+} from '@/lib/sim-search/live/text-match'
 import type {
   NativeClient,
   NativeDocument,
@@ -152,6 +156,11 @@ export async function searchAtlassian(
   const direction = dateSortDirection(input.filters)
   const order = direction ? `${field} ${direction.toUpperCase()}` : undefined
   const text = nativeText(input)
+  /**
+   * Jira's any-term query ORs pairs of terms, which on a large site matches issues sharing two
+   * common words; like a minimum-should-match, an issue must hold at least half the terms.
+   */
+  const relevant = input.textMatch === 'any' && text ? holdsHalfTheTerms(text) : undefined
   const pages = await Promise.all(
     selected.map(async (site) => {
       const cloudId = string(site.id)
@@ -173,7 +182,9 @@ export async function searchAtlassian(
           })
         )
         return {
-          documents: array(data.issues).map((row) => issue(row, cloudId, origin)),
+          documents: array(data.issues)
+            .map((row) => issue(row, cloudId, origin))
+            .filter((document) => !relevant || relevant(`${document.title}\n${document.content}`)),
           excluded: false,
           next: string(data.nextPageToken) || undefined,
         }
 
@@ -20,7 +20,6 @@ import {
   type LiveSearchProviderId,
 } from '@/lib/sim-search/live/provider-catalog'
 import { readSlack, searchSlack } from '@/lib/sim-search/live/slack'
-import type { AnyTermFallbackOptions } from '@/lib/sim-search/live/term-fallback'
 import type {
   NativeClient,
   NativeDocument,
@@ -47,12 +46,8 @@ interface NativeQueryGuide {
 
 interface NativeProvider {
   guide: NativeQueryGuide
-  /**
-   * Plain queries must contain every word, so an underfilled search retries with any term.
-   * `requireHalfTheTerms` is for a provider whose any-term query ranks items sharing just a couple
-   * of common words alongside close matches.
-   */
-  anyTermRetry?: AnyTermFallbackOptions
+  /** Plain queries must contain every word, so an underfilled search retries with any term. */
+  requiresEveryTerm?: true
   /**
    * Full text for a search preview, for providers whose search returns only an excerpt or
    * metadata. At most one request; undefined for kinds without a cheap text form.
@@ -181,7 +176,7 @@ export const LIVE_SEARCH_PROVIDERS = {
       avoid:
         'JQL with only an ORDER BY clause (Jira rejects unbounded queries), and identifying users other than currentUser() by display name or email; use their account ID.',
     },
-    anyTermRetry: { requireHalfTheTerms: true },
+    requiresEveryTerm: true,
     search: (client, input) => searchAtlassian(client, 'jira', input),
     read: (client, reference) => readAtlassian(client, 'jira', reference.id, reference.container),
   },
@@ -195,7 +190,7 @@ export const LIVE_SEARCH_PROVIDERS = {
       avoid:
         'starting the query with a negative clause (NOT, !=, !~ or NOT IN), which CQL rejects; lead with a positive clause such as type IN (page, blogpost).',
     },
-    anyTermRetry: { requireHalfTheTerms: false },
+    requiresEveryTerm: true,
     previewText: previewConfluence,
     search: (client, input) => searchAtlassian(client, 'confluence', input),
     read: (client, reference) =>
@@ -318,13 +313,10 @@ export function searchNativeProvider(
   return adapter.search(client, input)
 }
 
-/**
- * How the provider retries an underfilled plain search with any term; undefined when its
- * plain-text search does not require every query word.
- */
-export function anyTermRetry(provider: LiveSearchProviderId): AnyTermFallbackOptions | undefined {
+/** True when the provider's plain-text search matches only items containing every query word. */
+export function requiresEveryTerm(provider: LiveSearchProviderId): boolean {
   const adapter = LIVE_SEARCH_PROVIDERS[provider]
-  return 'anyTermRetry' in adapter ? adapter.anyTermRetry : undefined
+  return 'requiresEveryTerm' in adapter && adapter.requiresEveryTerm === true
 }
 
 /**
 
@@ -217,91 +217,6 @@ describe('searchWithAnyTermFallback', () => {
     expect(search).toHaveBeenCalledTimes(1)
   })
 
-  describe('when partial matches must contain half the terms', () => {
-    const long: NativeSearchInput = {
-      query: 'glean token creator role request',
-      limit: 10,
-      scopes: [],
-    }
-    const halfTheTerms = { requireHalfTheTerms: true }
-
-    it('drops a partial match containing fewer than half the terms', async () => {
-      const search = provider(
-        page(),
-        page(
-          { id: 'two-terms', title: 'Role request form' },
-          { id: 'three-terms', title: 'Token creator role' },
-          { id: 'in-description', title: 'Access', content: 'Glean token request for my team' }
-        )
-      )
-      const result = await searchWithAnyTermFallback(search, long, live, halfTheTerms)
-      expect(result.documents.map((document) => document.id)).toEqual([
-        'three-terms',
-        'in-description',
-      ])
-    })
-
-    it('counts a word and its plural as one term, as the provider matches them', async () => {
-      const search = provider(
-        page(),
-        page({ id: 'plurals', title: 'Glean tokens', content: 'Creators file requests' })
-      )
-      const result = await searchWithAnyTermFallback(search, long, live, halfTheTerms)
-      expect(result.documents.map((document) => document.id)).toEqual(['plurals'])
-    })
-
-    it('counts a singular word whose plural adds -es, in either form', async () => {
-      const search = provider(
-        page(),
-        page(
-          { id: 'singular', title: 'Database release' },
-          { id: 'plural', title: 'Databases', content: 'Weekly releases' }
-        )
-      )
-      const result = await searchWithAnyTermFallback(
-        search,
-        { query: 'database release checklist owner', limit: 10, scopes: [] },
-        live,
-        halfTheTerms
-      )
-      expect(result.documents.map((document) => document.id).sort()).toEqual(['plural', 'singular'])
-    })
-
-    it('counts a term with punctuation inside it, such as ci/cd', async () => {
-      const search = provider(page(), page({ id: 'ci', title: 'CI/CD pipeline' }))
-      const result = await searchWithAnyTermFallback(
-        search,
-        { query: 'ci/cd pipeline failure owner', limit: 10, scopes: [] },
-        live,
-        halfTheTerms
-      )
-      expect(result.documents.map((document) => document.id)).toEqual(['ci'])
-    })
-
-    it('returns the all-terms page unchanged when no partial match is close enough', async () => {
-      const strict = page({ id: 'exact', title: 'Glean token creator role request' })
-      const search = provider(strict, page({ id: 'loose', title: 'Role request' }))
-      expect(await searchWithAnyTermFallback(search, long, live, halfTheTerms)).toBe(strict)
-    })
-
-    it('keeps a single matching term enough for a two-term query', async () => {
-      const search = provider(page(), page({ id: 'one', title: 'Contractor directory' }))
-      const result = await searchWithAnyTermFallback(
-        search,
-        { query: 'contractor offboarding', limit: 4, scopes: [] },
-        live,
-        halfTheTerms
-      )
-      expect(result.documents.map((document) => document.id)).toEqual(['one'])
-    })
-
-    it('leaves providers without the floor adding loose partial matches', async () => {
-      const search = provider(page(), page({ id: 'two-terms', title: 'Role request form' }))
-      const result = await searchWithAnyTermFallback(search, long, live)
-      expect(result.documents.map((document) => document.id)).toEqual(['two-terms'])
-    })
-  })
-
   it('leaves the page untouched when the any-term search adds nothing new', async () => {
     const strict = page({ id: 'exact' })
     const search = provider(strict, page({ id: 'exact' }))
 
@@ -3,11 +3,7 @@ import { getErrorMessage } from '@sim/utils/errors'
 import { dateSortDirection } from '@/lib/sim-search/live/dates'
 import { NativeSearchError } from '@/lib/sim-search/live/http'
 import { joinMessages } from '@/lib/sim-search/live/pages'
-import {
-  containsHalfTheTerms,
-  significantTerms,
-  termCoverage,
-} from '@/lib/sim-search/live/text-match'
+import { significantTerms, termCoverage } from '@/lib/sim-search/live/text-match'
 import type { NativeDocument, NativePage, NativeSearchInput } from '@/lib/sim-search/live/types'
 
 /**
@@ -46,20 +42,11 @@ const documentKey = ({ container, kind, id }: NativeDocument) =>
  * slow OR query is cancelled rather than awaited. Whenever it fails short of the caller's own
  * cancellation (a provider refusal, the budget running out, a transport error), the all-terms page
  * is kept, reported as partial. Cancellation through `signal` propagates like the first search.
- *
- * With `requireHalfTheTerms`, a partial match must contain at least half the query's terms in its
- * title or text, for providers whose OR query matches items sharing only a couple of common words.
  */
-export interface AnyTermFallbackOptions {
-  /** Keep only partial matches holding at least half the query's terms. */
-  requireHalfTheTerms?: boolean
-}
-
 export async function searchWithAnyTermFallback(
   search: (input: NativeSearchInput) => Promise<NativePage>,
   input: NativeSearchInput,
-  signal: AbortSignal,
-  options: AnyTermFallbackOptions = {}
+  signal: AbortSignal
 ): Promise<NativePage> {
   const strict = await search(input)
   const terms = significantTerms(input.query)
@@ -106,12 +93,7 @@ export async function searchWithAnyTermFallback(
   }
   const seen = new Set(strict.documents.map(documentKey))
   const additions = relaxed.documents
-    .filter(
-      (document) =>
-        !seen.has(documentKey(document)) &&
-        (!options.requireHalfTheTerms ||
-          containsHalfTheTerms(`${document.title}\n${document.content}`, input.query))
-    )
+    .filter((document) => !seen.has(documentKey(document)))
     .map((document, rank) => ({
       document,
       rank,
 
@@ -1,5 +1,9 @@
 import { describe, expect, it } from 'vitest'
-import { confluenceTextClause, jiraTextClause } from '@/lib/sim-search/live/text-match'
+import {
+  confluenceTextClause,
+  holdsHalfTheTerms,
+  jiraTextClause,
+} from '@/lib/sim-search/live/text-match'
 
 describe('text match clauses', () => {
   it('matches either term of a two-term query, leaving out stopwords', () => {
@@ -57,4 +61,29 @@ describe('text match clauses', () => {
   it('falls back to the all-terms clause when fewer than two terms are distinctive', () => {
     expect(jiraTextClause('how does it work', 'any')).toBe('text ~ "how does it work"')
   })
+
+  describe('holdsHalfTheTerms', () => {
+    it('needs at least half the distinct terms, rounding up', () => {
+      const holds = holdsHalfTheTerms('glean token creator role request')
+      expect(holds('Role request form')).toBe(false)
+      expect(holds('Token creator role')).toBe(true)
+    })
+
+    it('counts a word and its plural as one term in either direction', () => {
+      expect(holdsHalfTheTerms('glean token creator role request')('Glean tokens, creators')).toBe(
+        true
+      )
+      const holds = holdsHalfTheTerms('database release checklist owner')
+      expect(holds('Database release')).toBe(true)
+      expect(holds('Databases and weekly releases')).toBe(true)
+    })
+
+    it('matches a term with punctuation inside it as written', () => {
+      expect(holdsHalfTheTerms('ci/cd pipeline failure owner')('CI/CD pipeline')).toBe(true)
+    })
+
+    it('accepts one matching term for a two-term query', () => {
+      expect(holdsHalfTheTerms('contractor offboarding')('Contractor directory')).toBe(true)
+    })
+  })
 })