@@ -151,11 +151,9 @@ describe('bounded embedding insert transactions', () => {
         .from(embedding)
         .where(eq(embedding.documentId, file.documentId))
     ).toEqual([{ id: previousId }])
-    for (const table of ['embedding_search', 'embedding_keyword_search']) {
-      expect(
-        await db.$client.unsafe(`SELECT id FROM ${table} WHERE document_id = $1`, [file.documentId])
-      ).toEqual([{ id: previousId }])
-    }
+    expect(
+      await db.$client`SELECT id FROM embedding_search WHERE document_id = ${file.documentId}`
+    ).toEqual([{ id: previousId }])
     expect(
       await db
         .select()
@@ -175,13 +173,18 @@ describe('bounded embedding insert transactions', () => {
     expect(await db.select().from(document).where(eq(document.id, file.documentId))).toMatchObject([
       { processingStatus: 'completed', chunkCount: 205, processingError: null },
     ])
-    for (const table of ['embedding', 'embedding_search', 'embedding_keyword_search']) {
+    /** A workspace knowledge base keeps no keyword projection rows: its keywords rank on `embedding`. */
+    for (const [table, count] of [
+      ['embedding', 205],
+      ['embedding_search', 205],
+      ['embedding_keyword_search', 0],
+    ] as const) {
       expect(
         await db.$client.unsafe(
           `SELECT count(*)::int AS count FROM ${table} WHERE document_id = $1`,
           [file.documentId]
         )
-      ).toEqual([{ count: 205 }])
+      ).toEqual([{ count }])
     }
     expect(
       await db.$client`SELECT count(*)::int AS count FROM embedding_secret_provenance p
 
@@ -24,6 +24,7 @@ import {
   credentialGroupEnrollment,
   document,
   embedding,
+  embeddingKeywordSearch,
   embeddingKeywordTin,
   embeddingSearch,
   knowledgeBase,
@@ -383,7 +384,6 @@ beforeAll(async () => {
       sql.raw(`CREATE SCHEMA tin;
       CREATE FUNCTION tin.full_score(tid) RETURNS double precision LANGUAGE sql IMMUTABLE AS 'SELECT 1.0::float8';
       CREATE FUNCTION knowledge_tin_base_token(text) RETURNS text LANGUAGE sql IMMUTABLE AS $$SELECT 'kb'$$;
-      CREATE FUNCTION knowledge_tin_membership_key(text) RETURNS bigint LANGUAGE sql IMMUTABLE AS $$SELECT hashtextextended('embedding_keyword_tin:' || $1, 0)$$;
       CREATE FUNCTION knowledge_tin_stream(vector tsvector) RETURNS text LANGUAGE sql IMMUTABLE AS $$
         SELECT coalesce(string_agg(entry.lexeme, ' ' ORDER BY position), '')
         FROM unnest(vector) AS entry(lexeme, positions, weights), unnest(entry.positions) AS position
@@ -400,7 +400,6 @@ afterAll(async () => {
       sql.raw(`DROP OPERATOR IF EXISTS ==> (text, text);
       DROP FUNCTION IF EXISTS tin_fixture_match(text, text);
       DROP FUNCTION IF EXISTS knowledge_tin_base_token(text);
-      DROP FUNCTION IF EXISTS knowledge_tin_membership_key(text);
       DROP FUNCTION IF EXISTS knowledge_tin_stream(tsvector);
       DROP SCHEMA IF EXISTS tin CASCADE;`)
     )
@@ -730,6 +729,46 @@ describe('the projector', () => {
     expect(await markOf()).toBeUndefined()
   })
 
+  it('writes keyword rows for search-index knowledge bases only', async () => {
+    const workspaceBaseId = generateId()
+    const workspaceDocument = generateId()
+    const workspaceChunk = generateId()
+    await db.insert(knowledgeBase).values({
+      id: workspaceBaseId,
+      userId: ids.aliceId,
+      workspaceId: ids.workspaceId,
+      name: 'Workspace keyword fixture',
+      chunkingConfig: { maxSize: 1024, minSize: 1, overlap: 20 },
+    })
+    try {
+      await db.insert(document).values({
+        id: workspaceDocument,
+        knowledgeBaseId: workspaceBaseId,
+        filename: 'keyword.md',
+        fileUrl: 'https://fixture.test/keyword',
+        fileSize: 12,
+        mimeType: 'text/plain',
+        processingStatus: 'completed',
+      })
+      await write('async', (tx) =>
+        tx.insert(embedding).values({
+          ...chunkRow(workspaceChunk, 0),
+          documentId: workspaceDocument,
+          knowledgeBaseId: workspaceBaseId,
+        })
+      )
+      await project()
+      const keywordRows = await db
+        .select({ id: embeddingKeywordSearch.id })
+        .from(embeddingKeywordSearch)
+        .where(inArray(embeddingKeywordSearch.id, [chunkId, workspaceChunk]))
+      expect(keywordRows).toEqual([{ id: chunkId }])
+      expect(await rowAcl(embeddingSearch, workspaceChunk)).toBeDefined()
+    } finally {
+      await db.delete(knowledgeBase).where(eq(knowledgeBase.id, workspaceBaseId))
+    }
+  })
+
   it.each(['sync', 'async'] as const)(
     'writes %s projection rows from a chunk commit only when the writer did not defer them',
     async (mode) => {
 
@@ -14,7 +14,7 @@ While the gate is off:
 - Indexed-only surfaces refuse with `SearchIndexDormantError` (a `409`): the Stats report and connecting a source that crawls into a search index. The indexed document page is not found.
 - A knowledge search that names a search-index knowledge base (the Knowledge block, v1, v2, Sim's knowledge tool) still answers from the documents it already holds, decided on each document exactly as a workspace knowledge base is.
 - Nothing crawls into search indexes: content syncs, member syncs, and processing recovery skip them (`lib/knowledge/connectors/indexing-policy.ts`).
-- The projector owes search-index documents nothing: their marks are released with the rest, and it writes no Tin keyword rows.
+- The projector owes search-index documents nothing: their marks are released with the rest, and it writes no Tin keyword rows. The GIN keyword projection follows `is_search_index` alone, so it keeps its search-index rows either way.
 
 ## Layout
 
@@ -28,7 +28,7 @@ The dormant UI sits in `indexed/` folders next to the component that picks it fr
 ## Re-enabling
 
 1. Set `SIM_SEARCH_LIVE=false` in both the app and the Trigger.dev environment, and deploy. The container entrypoint (`apps/sim/bootstrap.ts`) mirrors it to `NEXT_PUBLIC_SIM_SEARCH_LIVE` for the client; crawling, processing, and projection read it in whichever process runs them.
-2. Confirm the Tin objects exist (`0019_tin_keyword_projection`, `0024_knowledge_projection_async`), backfill `embedding_keyword_tin` for every search-index knowledge base, and build its index.
+2. Confirm the keyword projection objects exist (`0019_tin_keyword_projection`, `0024_knowledge_projection_async`, `0025_scope_keyword_projections`). Both keyword projections, `embedding_keyword_search` and `embedding_keyword_tin`, hold only search-index rows, written by the chunk triggers and by the trigger on `knowledge_base.is_search_index`. Backfill both for every search-index knowledge base whose rows were removed while dormant, and build the Tin index.
 3. Resume and fully resync the connectors of search-index knowledge bases, so content that went stale while dormant is indexed again.
 
 Projection rows written before projections carried their document's source and ACL are decided on their document until they are rewritten.
 
@@ -106,6 +106,10 @@ export type SourceAclProjection = (typeof SOURCE_ACL_PROJECTIONS)[number]
 const mirrorsSourceAcl = (projection: KnowledgeProjection): projection is SourceAclProjection =>
   (SOURCE_ACL_PROJECTIONS as readonly string[]).includes(projection)
 
+/** The keyword projections, which hold only the rows of search-index knowledge bases. */
+const holdsSearchIndexesOnly = (projection: KnowledgeProjection) =>
+  projection === 'embedding_keyword_search' || projection === 'embedding_keyword_tin'
+
 /**
  * The chunks one page covers: the next {@link PROJECTION_ROW_BATCH_SIZE} of the document in
  * chunk order, read off `emb_doc_chunk_idx`. Every projection pages the same way, so a page is
@@ -163,10 +167,16 @@ function contentPageStatement(projection: KnowledgeProjection): string {
   }
   if (projection === 'embedding_keyword_search') {
     const compared = ['knowledge_base_id', 'document_id', 'enabled', 'content_tsv']
-    return `WITH ${PAGE}, written AS (
-        INSERT INTO embedding_keyword_search AS s (${['id', ...compared].join(', ')})
-        SELECT e.id, e.knowledge_base_id, e.document_id, e.enabled, e.content_tsv
+    return `WITH ${PAGE}, source AS MATERIALIZED (
+        SELECT e.id, ${compared.map((column) => `e.${column}`).join(', ')}, k.is_search_index
         FROM page p JOIN embedding e ON e.id = p.id
+        JOIN knowledge_base k ON k.id = e.knowledge_base_id
+      ), removed AS (
+        DELETE FROM embedding_keyword_search s USING source
+        WHERE s.id = source.id AND NOT source.is_search_index
+      ), written AS (
+        INSERT INTO embedding_keyword_search AS s (${['id', ...compared].join(', ')})
+        SELECT id, ${compared.join(', ')} FROM source WHERE is_search_index
         ON CONFLICT (id) DO UPDATE SET
           ${compared.map((column) => `${column} = EXCLUDED.${column}`).join(', ')}
         WHERE (${compared.map((column) => `s.${column}`).join(', ')})
@@ -249,8 +259,9 @@ export interface KnowledgeProjectionOptions {
   /**
    * Whether search-index rows are read, that is whether indexed organization search is on (see
    * {@link MarkScope}). Only then is the Tin keyword projection written, since it holds only
-   * search-index rows; the other projections are written either way, and Tin is still skipped
-   * where it is not installed.
+   * search-index rows; the other projections are written either way, the GIN keyword projection
+   * for search-index bases alone whatever this says, and Tin is still skipped where it is not
+   * installed.
    */
   searchIndexes: boolean
   /** Called after each page commits, for tests that interleave writes with a run. */
@@ -375,8 +386,8 @@ async function projectDocumentRows(
     if (Date.now() >= deadline) return { pages, written, finished: false }
     const page = await sql.begin(async (tx) => {
       await enterProjectorTransaction(tx, PROJECTION_PAGE_LOCK_TIMEOUT_MS)
-      /** Shares the base's Tin membership lock, as the embedding trigger does, so a flip of its marker waits. */
-      if (projection === 'embedding_keyword_tin')
+      /** Shares the base's membership lock, as the embedding triggers do, so a flip of its marker waits. */
+      if (holdsSearchIndexesOnly(projection))
         await tx`SELECT pg_advisory_xact_lock_shared(knowledge_tin_membership_key(${mark.knowledgeBaseId}))`
       const [row] = await tx.unsafe<
         Array<{ scanned: number; written: number; last_chunk: number | null }>
 
@@ -395,6 +395,7 @@ describe('search projection upgrade in PostgreSQL', () => {
       { name: '0022_projection_source_acl_backfill' },
       { name: '0023_projection_acl_skip_unfilled' },
       { name: '0024_knowledge_projection_async' },
+      { name: '0025_scope_keyword_projections' },
     ])
     const [{ complete }] = await sql`SELECT count(*)::int AS complete FROM embedding e
       JOIN embedding_search s ON s.id = e.id JOIN embedding_keyword_search k ON k.id = e.id
 
@@ -2,7 +2,7 @@ import { EMBEDDING_KEYWORD_TIN_INDEX } from '@sim/db/schema'
 import { resolveMigrationDatabaseUrl } from '@sim/db/script-migrations/database-url'
 import { type ScriptMigration, ScriptMigrationDeferred } from '@sim/db/script-migrations/types'
 import { createLogger } from '@sim/logger'
-import postgres, { type Sql } from 'postgres'
+import postgres, { type Sql, type TransactionSql } from 'postgres'
 
 const logger = createLogger('TinKeywordProjection')
 const BATCH_SIZE = 500
@@ -39,6 +39,17 @@ async function tinAvailable(sql: Sql): Promise<boolean> {
   return rows.length > 0
 }
 
+/**
+ * The advisory lock key that serializes a knowledge base's keyword projection writers with a change
+ * of its search-index marker (see {@link installProjection}).
+ */
+export async function installMembershipKey(tx: Sql | TransactionSql): Promise<void> {
+  await tx.unsafe(`CREATE OR REPLACE FUNCTION knowledge_tin_membership_key(knowledge_base_id text)
+    RETURNS bigint LANGUAGE sql IMMUTABLE PARALLEL SAFE AS $$
+      SELECT hashtextextended('embedding_keyword_tin:' || knowledge_base_id, 0)
+    $$`)
+}
+
 /**
  * Installs the stream and base-token functions shared by the triggers and the query path, and the
  * embedding and knowledge base triggers, atomically with respect to embedding writers.
@@ -75,10 +86,7 @@ export async function installProjection(sql: Sql): Promise<void> {
       RETURNS text LANGUAGE sql IMMUTABLE PARALLEL SAFE AS $$
         SELECT 'zkb' || md5(knowledge_base_id)
       $$`)
-    await tx.unsafe(`CREATE OR REPLACE FUNCTION knowledge_tin_membership_key(knowledge_base_id text)
-      RETURNS bigint LANGUAGE sql IMMUTABLE PARALLEL SAFE AS $$
-        SELECT hashtextextended('embedding_keyword_tin:' || knowledge_base_id, 0)
-      $$`)
+    await installMembershipKey(tx)
     await tx.unsafe(`CREATE OR REPLACE FUNCTION sync_embedding_keyword_tin()
       RETURNS trigger LANGUAGE plpgsql AS $$
       BEGIN