@@ -44,6 +44,7 @@ import {
   VECTOR_PROBE_DOCUMENT_LIMIT,
   visibleDocumentsQuery,
 } from '@/lib/knowledge/search/queries'
+import { forgetIndexedVectorSources } from '@/lib/knowledge/search/source-vector-indexes'
 import type { StructuredFilter } from '@/lib/knowledge/types'
 
 /**
@@ -1235,6 +1236,7 @@ describe('permitted-document planner', () => {
     rerankRows = []
     sourceExactRows = []
     indexedSourceRows = []
+    forgetIndexedVectorSources()
     dbChainMockFns.execute.mockImplementation(async (query) => {
       const statement = render(query).sql
       if (statement.includes('pg_index')) return indexedSourceRows
@@ -1274,13 +1276,61 @@ describe('permitted-document planner', () => {
     traversedRows = [{ id: 'a' }]
     rerankRows = [hit('a', null)]
     queueTableRows(schemaMock.embedding, [hit('a', null)])
-    await handleVectorOnlySearch({ ...params, permitted: { kind: 'unbounded' } })
+    await handleVectorOnlySearch({ ...params, permitted: { kind: 'unbounded', broad: false } })
     const sqls = statements().map((query) => query.sql)
     expect(sqls.some((sql) => sql.includes('AS visible'))).toBe(true)
     expect(sqls.some(isProbeStatement)).toBe(false)
     expect(sqls.some(isExactRanking)).toBe(false)
   })
 
+  it('walks the whole graph once for a caller whose reach is broad', async () => {
+    const eligibility = { workspace: [], admin: ['other-src'], members: ['member-src'] }
+    indexedSourceRows = [{ name: 'idx', connectorId: 'member-src' }]
+    traversedRows = [{ id: 'walked-hit', distance: 0.2 }]
+    rerankRows = [hit('walked-hit', 'member-src')]
+    queueTableRows(schemaMock.embedding, rerankRows)
+    await handleVectorOnlySearch({
+      ...params,
+      permitted: { kind: 'unbounded', broad: true },
+      accessPlan: {
+        connectors: eligibility,
+        observers: { confirmed: ['m-1'], observed: [] },
+        memberSources: ['member-src'],
+      },
+    })
+    /** One walk over every source, scoped to the bases alone — no source is singled out. */
+    const walks = statements().filter((query) => query.sql.includes('AS visible'))
+    expect(walks).toHaveLength(1)
+    expect(JSON.stringify(walks[0])).not.toContain('"right":"member-src"')
+    expect(statements().some((query) => query.sql.includes('WITH readable_documents'))).toBe(false)
+  })
+
+  it('walks an indexed source a bounded caller is a member of instead of ranking it exactly', async () => {
+    const eligibility = { workspace: [], admin: ['small-src'], members: ['member-src'] }
+    indexedSourceRows = [{ name: 'idx', connectorId: 'member-src' }]
+    sourceExactRows = [{ id: 'small-hit', distance: 0.3, saturated: false }]
+    traversedRows = [{ id: 'walked-hit', distance: 0.2 }]
+    rerankRows = [hit('walked-hit', 'member-src'), hit('small-hit', 'small-src')]
+    queueTableRows(schemaMock.embedding, rerankRows)
+    await handleVectorOnlySearch({
+      ...params,
+      topK: 2,
+      permitted: bounded(
+        { id: 'doc-a', connectorId: 'member-src' },
+        { id: 'doc-b', connectorId: 'small-src' }
+      ),
+      accessPlan: {
+        connectors: eligibility,
+        observers: { confirmed: ['m-1'], observed: [] },
+        memberSources: ['member-src'],
+      },
+    })
+    const walks = statements().filter((query) => query.sql.includes('AS visible'))
+    expect(walks).toHaveLength(1)
+    expect(JSON.stringify(walks[0])).toContain('"right":"member-src"')
+    expect(statements().some((q) => isExactRanking(q.sql))).toBe(false)
+  })
+
   it('walks a source the caller is a member of and ranks every other source exactly', async () => {
     const eligibility = {
       workspace: [],
@@ -1297,7 +1347,7 @@ describe('permitted-document planner', () => {
     queueTableRows(schemaMock.embedding, rerankRows)
     await handleVectorOnlySearch({
       ...params,
-      permitted: { kind: 'unbounded' },
+      permitted: { kind: 'unbounded', broad: false },
       accessPlan: { connectors: eligibility, observers, memberSources },
     })
     const walks = statements().filter((query) => query.sql.includes('AS visible'))
@@ -1320,7 +1370,7 @@ describe('permitted-document planner', () => {
     queueTableRows(schemaMock.embedding, rerankRows)
     await handleVectorOnlySearch({
       ...params,
-      permitted: { kind: 'unbounded' },
+      permitted: { kind: 'unbounded', broad: false },
       accessPlan: {
         connectors: eligibility,
         observers: { confirmed: [], observed: [] },
@@ -1347,7 +1397,7 @@ describe('permitted-document planner', () => {
     await handleVectorOnlySearch({
       ...params,
       topK: 2,
-      permitted: { kind: 'unbounded' },
+      permitted: { kind: 'unbounded', broad: false },
       accessPlan: {
         connectors: eligibility,
         observers: { confirmed: ['m-1'], observed: [] },
@@ -1368,7 +1418,7 @@ describe('permitted-document planner', () => {
     queueTableRows(schemaMock.embedding, rerankRows)
     await handleVectorOnlySearch({
       ...params,
-      permitted: { kind: 'unbounded' },
+      permitted: { kind: 'unbounded', broad: false },
       accessPlan: {
         connectors: { workspace: [], admin: ['sliced-src'], members: [] },
         observers: { confirmed: [], observed: [] },
@@ -1547,6 +1597,29 @@ describe('permitted-document planner', () => {
       resolvePermittedDocuments({ knowledgeBaseIds, access })
     const probes = () => statements().filter((query) => isProbeStatement(query.sql)).length
 
+    it('counts a saturated reach against the broad bound once, and remembers the answer', async () => {
+      /** The index holds a million documents; the bound is a quarter of them. */
+      const counts = { index: 1_000_000, reached: 250_000 }
+      dbChainMockFns.execute.mockImplementation(async (query) => {
+        const statement = render(query).sql
+        if (isProbeStatement(statement)) return [{ id: null, connectorId: null, saturated: true }]
+        if (statement.includes(') reached')) return [{ n: counts.reached }]
+        if (statement.includes('count(*) AS n')) return [{ n: counts.index }]
+        return []
+      })
+      const reachCounts = () => statements().filter((query) => query.sql.includes(') reached'))
+      const broad = await resolve(scope('broad-reach'))
+      expect(broad).toEqual({ kind: 'unbounded', broad: true })
+      expect(reachCounts()).toHaveLength(1)
+      expect(JSON.stringify(reachCounts()[0])).toContain('250000')
+      await resolve(scope('broad-reach'))
+      expect(reachCounts()).toHaveLength(1)
+      counts.reached = 120_000
+      const narrow = await resolve(scope('narrow-reach'))
+      expect(narrow).toEqual({ kind: 'unbounded', broad: false })
+      expect(reachCounts()).toHaveLength(2)
+    })
+
     it('is remembered, so a broad caller skips the probe on the next search', async () => {
       probeRows = [{ id: null, connectorId: null, saturated: true }]
       const broad = scope('broad')
 
@@ -1046,7 +1046,16 @@ type PermittedDocument = {
  */
 export type PermittedDocuments =
   | { kind: 'bounded'; documents: readonly PermittedDocument[] }
-  | { kind: 'unbounded' }
+  | { kind: 'unbounded'; broad: boolean }
+
+/**
+ * The share of the index a caller must reach before the whole graph is walked for them. pgvector
+ * post-filters, so a walk returns a caller's own neighbours in proportion to their reach: above
+ * this share almost every neighbour the graph visits is theirs and one walk is the cheapest exact
+ * answer there is; below it the walk spends its budget on chunks they cannot read, and each
+ * readable source is searched on its own instead.
+ */
+export const BROAD_REACH_SHARE = 0.25
 
 /**
  * How long a caller's saturated reach is remembered. Reach counts the documents a caller's tokens
@@ -1055,7 +1064,51 @@ export type PermittedDocuments =
  */
 const SATURATED_REACH_TTL_MS = 5 * 60 * 1000
 
-const saturatedReach = new LRUCache<string, true>({ max: 10_000, ttl: SATURATED_REACH_TTL_MS })
+/** A saturated reach, and whether it is broad enough to walk the whole graph for. */
+const saturatedReach = new LRUCache<string, { broad: boolean }>({
+  max: 10_000,
+  ttl: SATURATED_REACH_TTL_MS,
+})
+
+/** How many documents the bases hold: the denominator of a reach share, and it moves slowly. */
+const indexDocumentCounts = new LRUCache<string, number>({
+  max: 1000,
+  ttl: SATURATED_REACH_TTL_MS,
+  fetchMethod: async (key) => {
+    const [row] = await db.execute<{ n: number }>(sql`
+      SELECT count(*) AS n FROM ${document}
+      WHERE ${document.knowledgeBaseId} = ANY(${textArrayLiteral(key.split(','))})
+        AND ${document.deletedAt} IS NULL`)
+    /** An empty answer is not remembered; the bases may simply not have been read yet. */
+    return Number(row?.n ?? 0) || undefined
+  },
+})
+
+/**
+ * Whether a saturated reach is broad: the caller reaches at least {@link BROAD_REACH_SHARE} of the
+ * bases' documents. Counted once against that bound and remembered with the saturation, so the
+ * first search after the window pays for it and the rest do not.
+ */
+async function reachIsBroad(
+  knowledgeBaseIds: string[],
+  access: KnowledgeAccessScope,
+  budget: SearchBudget | undefined
+): Promise<boolean> {
+  if (access.kind !== 'user') return true
+  const total = (await indexDocumentCounts.fetch([...knowledgeBaseIds].sort().join(','))) ?? 0
+  const bound = Math.ceil(total * BROAD_REACH_SHARE)
+  if (bound <= VECTOR_PROBE_DOCUMENT_LIMIT) return true
+  const [row] = await runSearchQuery(budget, 'permitted_documents', (executor) =>
+    executor.execute<{ n: number }>(sql`
+      SELECT count(*) AS n FROM (
+        SELECT 1 FROM ${document}
+        WHERE ${document.deletedAt} IS NULL AND ${knowledgeAclOverlapCondition(access)}
+          AND ${inArray(document.knowledgeBaseId, knowledgeBaseIds)}
+        LIMIT ${bound}
+      ) reached`)
+  )
+  return Number(row?.n ?? 0) >= bound
+}
 
 /** Reach depends only on the bases and the caller's tokens; filters narrow the set, not the reach. */
 function reachKey(
@@ -1083,8 +1136,11 @@ export async function resolvePermittedDocuments(params: {
 }): Promise<PermittedDocuments> {
   const key = reachKey(params.knowledgeBaseIds, params.access)
   let probe: ProbeOutcome
-  if (key && saturatedReach.get(key)) {
+  let broad = true
+  const remembered = key ? saturatedReach.get(key) : undefined
+  if (remembered) {
     probe = { kind: 'saturated' }
+    broad = remembered.broad
   } else {
     try {
       probe = await probeVisibleDocuments(
@@ -1103,12 +1159,19 @@ export async function resolvePermittedDocuments(params: {
       if (!params.budget?.isTimeout(error)) throw error
       probe = { kind: 'timed_out' }
     }
-    if (key && probe.kind === 'saturated') saturatedReach.set(key, true)
+    if (probe.kind === 'saturated') {
+      try {
+        broad = await reachIsBroad(params.knowledgeBaseIds, params.access, params.budget)
+      } catch (error) {
+        if (!params.budget?.isTimeout(error)) throw error
+      }
+      if (key) saturatedReach.set(key, { broad })
+    }
   }
   const permitted: PermittedDocuments =
     probe.kind === 'documents'
       ? { kind: 'bounded', documents: probe.documents }
-      : { kind: 'unbounded' }
+      : { kind: 'unbounded', broad }
   annotateSearchDiagnostics({
     permittedDocuments: permitted.kind,
     ...(probe.kind === 'documents' ? { permittedDocumentCount: probe.documents.length } : {}),
@@ -1362,6 +1425,10 @@ async function selectVectorResults(params: SearchParams): Promise<SearchResult[]
       }
       if (params.filters?.documentIds?.length) return exactPage()
       if (candidatePool?.excludedKey !== excludedKey) {
+        const plannedIndexedSources =
+          params.access.kind === 'user' && params.accessPlan?.memberSources.length
+            ? await indexedVectorSources()
+            : undefined
         annotateSearchDiagnostics({
           vectorRanking: 'candidate-rerank',
           vectorCandidateStorage: 'stored-halfvec',
@@ -1395,24 +1462,33 @@ async function selectVectorResults(params: SearchParams): Promise<SearchResult[]
           )
         }
         let selected: Array<{ id: string }>
-        if (params.permitted?.kind === 'bounded') {
+        const plan = params.access.kind === 'user' ? params.accessPlan : undefined
+        /**
+         * A source the caller is a member of that has its own index is walked on its own, which
+         * beats ranking it exactly once it is large enough to have earned that index.
+         */
+        const walksASource = plan?.memberSources.some(
+          (id) => plannedIndexedSources?.has(id) ?? false
+        )
+        if (params.permitted?.kind === 'bounded' && !walksASource) {
           /**
            * A bounded permitted set is ranked exactly without walking the graph first: the walk
            * post-filters, so when the caller reads a small share of the index it spends its whole
            * uninterruptible tuple budget and still returns almost none of their neighbours.
            */
           selected = await rankPermittedExactly(params.permitted.documents.map((entry) => entry.id))
-        } else if (params.accessPlan && params.access.kind === 'user') {
+        } else if (plan && !(params.permitted?.kind === 'unbounded' && params.permitted.broad)) {
           /**
            * Readability follows sources, so each readable source is searched in its own index and
            * the results merged. A member reads a source whole or barely at all: walking one source
            * spends its budget among chunks they can read, where a walk over every source spends it
-           * on the sources they cannot.
+           * on the sources they cannot. A caller whose reach is broad skips this: for them the
+           * whole graph's neighbours are mostly theirs already, and one walk is the cheaper answer.
            */
           selected = await selectSourceVectorCandidates({
             access: params.access,
             knowledgeBaseIds: params.knowledgeBaseIds,
-            plan: params.accessPlan,
+            plan,
             documentConditions: candidateDocumentVisibility,
             tagCondition: candidateTagCondition,
             documentTagCondition,
 
@@ -31,6 +31,11 @@ function indexName(connectorId: string): string {
  */
 const indexedSources = new LRUCache<'sources', ReadonlySet<string>>({ max: 1, ttl: 60 * 1000 })
 
+/** Forgets the cached answer, after an index was built or dropped. */
+export function forgetIndexedVectorSources(): void {
+  indexedSources.clear()
+}
+
 export async function indexedVectorSources(): Promise<ReadonlySet<string>> {
   const cached = indexedSources.get('sources')
   if (cached) return cached
@@ -120,7 +125,7 @@ export async function ensureSourceVectorIndex(connectorId: string): Promise<bool
       documents,
       elapsedMs: Date.now() - startedAt,
     })
-    indexedSources.clear()
+    forgetIndexedVectorSources()
     return true
   } catch (error) {
     logger.error('Source vector index build failed', { connectorId, error: getErrorMessage(error) })
@@ -136,5 +141,5 @@ export async function ensureSourceVectorIndex(connectorId: string): Promise<bool
 export async function dropSourceVectorIndex(connectorId: string): Promise<void> {
   if (!CONNECTOR_ID.test(connectorId)) return
   await db.execute(sql.raw(`DROP INDEX CONCURRENTLY IF EXISTS "${indexName(connectorId)}"`))
-  indexedSources.clear()
+  forgetIndexedVectorSources()
 }