@@ -49,6 +49,11 @@ describe('bounded embedding insert transactions', () => {
   beforeAll(async () => {
     fixtures.root = mkdtempSync(path.join(tmpdir(), 'sim-embedding-batches-'))
     await seedKnowledgeAclFixture(ids, { connectorType: 'google_drive' })
+    /** A search index, the only kind of base whose chunks the keyword projection holds. */
+    await db
+      .update(knowledgeBase)
+      .set({ isSearchIndex: true })
+      .where(eq(knowledgeBase.id, ids.knowledgeBaseId))
     vi.spyOn(embeddingClient, 'assertKnowledgeEmbeddingCapacity').mockResolvedValue(undefined)
   })
 
@@ -151,9 +156,11 @@ describe('bounded embedding insert transactions', () => {
         .from(embedding)
         .where(eq(embedding.documentId, file.documentId))
     ).toEqual([{ id: previousId }])
-    expect(
-      await db.$client`SELECT id FROM embedding_search WHERE document_id = ${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
         .select()
@@ -173,18 +180,13 @@ describe('bounded embedding insert transactions', () => {
     expect(await db.select().from(document).where(eq(document.id, file.documentId))).toMatchObject([
       { processingStatus: 'completed', chunkCount: 205, processingError: null },
     ])
-    /** 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) {
+    for (const table of ['embedding', 'embedding_search', 'embedding_keyword_search']) {
       expect(
         await db.$client.unsafe(
           `SELECT count(*)::int AS count FROM ${table} WHERE document_id = $1`,
           [file.documentId]
         )
-      ).toEqual([{ count }])
+      ).toEqual([{ count: 205 }])
     }
     expect(
       await db.$client`SELECT count(*)::int AS count FROM embedding_secret_provenance p
 
@@ -54,6 +54,11 @@ describe('document processing commit lock scope', () => {
   beforeAll(async () => {
     fixtures.root = mkdtempSync(path.join(tmpdir(), 'sim-processing-lock-scope-'))
     await seedKnowledgeAclFixture(ids, { connectorType: 'google_drive' })
+    /** A search index, the only kind of base whose chunks the keyword projection holds. */
+    await db
+      .update(knowledgeBase)
+      .set({ isSearchIndex: true })
+      .where(eq(knowledgeBase.id, ids.knowledgeBaseId))
     vi.spyOn(embeddingClient, 'assertKnowledgeEmbeddingCapacity').mockResolvedValue(undefined)
     fixtures.process.mockResolvedValue({
       chunks,
@@ -152,6 +157,14 @@ describe('document processing commit lock scope', () => {
     expect(await db.select().from(document).where(eq(document.id, file.documentId))).toMatchObject([
       { processingStatus: 'completed', chunkCount: 3 },
     ])
+    for (const projection of ['embedding_search', 'embedding_keyword_search']) {
+      expect(
+        await db.$client.unsafe(
+          `SELECT count(*)::int AS count FROM ${projection} WHERE document_id = $1`,
+          [file.documentId]
+        )
+      ).toEqual([{ count: 3 }])
+    }
   })
 
   it.each([
 
@@ -44,9 +44,11 @@ describe('search projection upgrade in PostgreSQL', () => {
     await sql.unsafe(
       `ALTER TABLE embedding_search ${fields.map((field) => `DROP COLUMN ${field}`).join(', ')}`
     )
-    await sql`INSERT INTO knowledge_base (id, user_id, name, workspace_id, embedding_model) VALUES
-      ('prefix', 'reader', 'Prefix fixture', 'workspace', 'text-embedding-3-small'),
-      ('full', 'reader', 'Full fixture', 'workspace', 'gemini-embedding-001')`
+    /** A workspace holds one search index, so each fixture index has its own. */
+    await sql`INSERT INTO knowledge_base (id, user_id, name, workspace_id, embedding_model, is_search_index) VALUES
+      ('prefix', 'reader', 'Prefix fixture', 'workspace', 'text-embedding-3-small', true),
+      ('full', 'reader', 'Full fixture', 'full-workspace', 'gemini-embedding-001', true),
+      ('legacy', 'reader', 'Legacy fixture', 'workspace', 'text-embedding-3-small', false)`
     await backfillEmbeddingSearch(sql)
     await sql.unsafe(`INSERT INTO embedding
       (id, knowledge_base_id, document_id, chunk_index, chunk_hash, content, content_length, token_count, start_offset, end_offset, embedding)
@@ -153,6 +155,22 @@ describe('search projection upgrade in PostgreSQL', () => {
     expect(await backfillSearchKeywords(sql)).toBe(0)
   })
 
+  it('leaves the chunks of a base that is not a search index unfilled', async () => {
+    await sql.unsafe(`INSERT INTO embedding
+      (id, knowledge_base_id, document_id, chunk_index, chunk_hash, content, content_length, token_count, start_offset, end_offset, embedding)
+      VALUES ('legacy-chunk', 'legacy', 'legacy-document', 0, 'legacy-hash', 'Synthetic fixture', 17, 4, 0, 17,
+        array_fill(0.01::real, ARRAY[1536])::vector(1536))`)
+    await sql`DELETE FROM embedding_keyword_search WHERE id = 'legacy-chunk'`
+    try {
+      expect(await backfillSearchKeywords(sql)).toBe(0)
+      expect(
+        await sql`SELECT id FROM embedding_keyword_search WHERE id = 'legacy-chunk'`
+      ).toHaveLength(0)
+    } finally {
+      await sql`DELETE FROM embedding WHERE id = 'legacy-chunk'`
+    }
+  })
+
   it('repairs an interrupted index build and preserves valid indexes on replay', async () => {
     await expect(
       sql.unsafe(
 
@@ -115,7 +115,11 @@ export async function backfillSearchVectors(sql: Sql): Promise<number> {
   return count
 }
 
-/** Keeps keyword scoring independent of the full-vector and chunk-content storage working sets. */
+/**
+ * Keeps keyword scoring independent of the full-vector and chunk-content storage working sets. Only
+ * search-index chunks are filled: they are the only rows the projection holds once
+ * `0025_scope_keyword_projections` scopes its triggers, so a rerun cannot refill the rest.
+ */
 export async function backfillSearchKeywords(sql: Sql): Promise<number> {
   await sql.begin(async (tx) => {
     await tx.unsafe("SET LOCAL lock_timeout = '5s'")
@@ -159,6 +163,7 @@ export async function backfillSearchKeywords(sql: Sql): Promise<number> {
         ), batch AS MATERIALIZED (
           SELECT e.id, e.knowledge_base_id, e.document_id, e.enabled, e.content_tsv
           FROM missing m INNER JOIN embedding e ON e.id = m.id
+          INNER JOIN knowledge_base k ON k.id = e.knowledge_base_id AND k.is_search_index
           ORDER BY e.id FOR KEY SHARE OF e
         ), inserted AS (
           INSERT INTO embedding_keyword_search (id, knowledge_base_id, document_id, enabled, content_tsv)
 
@@ -1,3 +1,4 @@
+import { SYNCHRONOUS_PROJECTION_WHEN } from '@sim/db/knowledge-projection'
 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'
@@ -50,6 +51,35 @@ export async function installMembershipKey(tx: Sql | TransactionSql): Promise<vo
     $$`)
 }
 
+/**
+ * The chunk trigger's body. A chunk outside a search index writes nothing; an update removes the
+ * row a chunk left behind by moving out of one. An insert has nothing to remove, since a new chunk
+ * id has no row and a base adopted meanwhile waits on the membership lock the insert holds.
+ */
+export async function installTinChunkSync(tx: Sql | TransactionSql): Promise<void> {
+  await tx.unsafe(`CREATE OR REPLACE FUNCTION sync_embedding_keyword_tin()
+    RETURNS trigger LANGUAGE plpgsql AS $$
+    BEGIN
+      PERFORM pg_advisory_xact_lock_shared(knowledge_tin_membership_key(NEW.knowledge_base_id));
+      IF NOT EXISTS (
+        SELECT 1 FROM knowledge_base WHERE id = NEW.knowledge_base_id AND is_search_index
+      ) THEN
+        IF TG_OP = 'UPDATE' THEN
+          DELETE FROM embedding_keyword_tin WHERE id = NEW.id;
+        END IF;
+        RETURN NEW;
+      END IF;
+      INSERT INTO embedding_keyword_tin (id, knowledge_base_id, document_id, enabled, content)
+      VALUES (NEW.id, NEW.knowledge_base_id, NEW.document_id, NEW.enabled,
+        knowledge_tin_base_token(NEW.knowledge_base_id) || ' ' || knowledge_tin_stream(NEW.content_tsv))
+      ON CONFLICT (id) DO UPDATE SET
+        knowledge_base_id = EXCLUDED.knowledge_base_id, document_id = EXCLUDED.document_id,
+        enabled = EXCLUDED.enabled, content = EXCLUDED.content;
+      RETURN NEW;
+    END;
+    $$`)
+}
+
 /**
  * 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.
@@ -71,7 +101,9 @@ export async function installMembershipKey(tx: Sql | TransactionSql): Promise<vo
  * other's rows. A row lock cannot do this: a key-share lock on the marker row is compatible with
  * the uncommitted marker update, so a writer would read the old marker without waiting. A whole
  * base is reached through `embedding`'s knowledge base index, since a projected row always carries
- * its chunk's base and the projection keeps no index but Tin's.
+ * its chunk's base and the projection keeps no index but Tin's. The embedding trigger carries the
+ * guard `0024_knowledge_projection_async` added, so a database adopting Tin later ends where a full
+ * migration run does.
  */
 export async function installProjection(sql: Sql): Promise<void> {
   await sql.begin(async (tx) => {
@@ -87,28 +119,10 @@ export async function installProjection(sql: Sql): Promise<void> {
         SELECT 'zkb' || md5(knowledge_base_id)
       $$`)
     await installMembershipKey(tx)
-    await tx.unsafe(`CREATE OR REPLACE FUNCTION sync_embedding_keyword_tin()
-      RETURNS trigger LANGUAGE plpgsql AS $$
-      BEGIN
-        PERFORM pg_advisory_xact_lock_shared(knowledge_tin_membership_key(NEW.knowledge_base_id));
-        IF NOT EXISTS (
-          SELECT 1 FROM knowledge_base WHERE id = NEW.knowledge_base_id AND is_search_index
-        ) THEN
-          DELETE FROM embedding_keyword_tin WHERE id = NEW.id;
-          RETURN NEW;
-        END IF;
-        INSERT INTO embedding_keyword_tin (id, knowledge_base_id, document_id, enabled, content)
-        VALUES (NEW.id, NEW.knowledge_base_id, NEW.document_id, NEW.enabled,
-          knowledge_tin_base_token(NEW.knowledge_base_id) || ' ' || knowledge_tin_stream(NEW.content_tsv))
-        ON CONFLICT (id) DO UPDATE SET
-          knowledge_base_id = EXCLUDED.knowledge_base_id, document_id = EXCLUDED.document_id,
-          enabled = EXCLUDED.enabled, content = EXCLUDED.content;
-        RETURN NEW;
-      END;
-      $$`)
+    await installTinChunkSync(tx)
     await tx.unsafe(`CREATE OR REPLACE TRIGGER embedding_keyword_tin_sync
       AFTER INSERT OR UPDATE OF knowledge_base_id, document_id, enabled, content ON embedding
-      FOR EACH ROW EXECUTE FUNCTION sync_embedding_keyword_tin()`)
+      FOR EACH ROW WHEN (${SYNCHRONOUS_PROJECTION_WHEN}) EXECUTE FUNCTION sync_embedding_keyword_tin()`)
     await tx.unsafe(`CREATE OR REPLACE FUNCTION sync_knowledge_base_keyword_tin()
       RETURNS trigger LANGUAGE plpgsql AS $$
       BEGIN
 
@@ -141,6 +141,21 @@ describe('keyword projections scoped to search indexes in PostgreSQL', () => {
     expect(await tinIds()).toEqual([])
   })
 
+  it('keeps the scoped and guarded Tin trigger when Tin is adopted after this migration', async () => {
+    await installProjection(sql)
+    const [trigger] = await sql<{ definition: string }[]>`
+      SELECT pg_get_triggerdef(oid) AS definition FROM pg_trigger
+      WHERE tgname = 'embedding_keyword_tin_sync' AND tgrelid = 'embedding'::regclass`
+    expect(trigger?.definition).toContain('sim.projection_mode')
+    const scans = await sql.begin(async (tx) => {
+      const before = await scansOf(tx, ['embedding_keyword_tin'])
+      await tx`INSERT INTO embedding (id, knowledge_base_id, document_id, content_tsv)
+        VALUES ('in-legacy', 'legacy', 'doc', to_tsvector('english', 'Release notes'))`
+      return (await scansOf(tx, ['embedding_keyword_tin'])) - before
+    })
+    expect(scans).toBe(0)
+  })
+
   it('projects a base adopted as a search index, and removes it when it is not', async () => {
     await sql`INSERT INTO embedding (id, knowledge_base_id, document_id, enabled, content_tsv) VALUES
       ('legacy-1', 'legacy', 'doc', true, to_tsvector('english', 'Quarterly planning')),
@@ -154,6 +169,27 @@ describe('keyword projections scoped to search indexes in PostgreSQL', () => {
     expect(await keywordIds()).toEqual([])
   })
 
+  it('leaves a current keyword row unwritten when its base is adopted', async () => {
+    await sql`INSERT INTO embedding (id, knowledge_base_id, document_id, content_tsv)
+      VALUES ('kept', 'legacy', 'doc', to_tsvector('english', 'Kept chunk'))`
+    /** A row written before the projection was scoped, already current. */
+    await sql`INSERT INTO embedding_keyword_search (id, knowledge_base_id, document_id, enabled, content_tsv)
+      SELECT id, knowledge_base_id, document_id, enabled, content_tsv FROM embedding WHERE id = 'kept'`
+    const updated = await sql.begin(async (tx) => {
+      const read = async () => {
+        const [row] = await tx<Array<{ updated: number }>>`
+          SELECT n_tup_upd::int AS updated FROM pg_stat_xact_user_tables
+          WHERE relid = 'embedding_keyword_search'::regclass`
+        return row.updated
+      }
+      const before = await read()
+      await tx`UPDATE knowledge_base SET is_search_index = true WHERE id = 'legacy'`
+      return (await read()) - before
+    })
+    expect(updated).toBe(0)
+    expect(await keywordIds()).toEqual(['kept'])
+  })
+
   it('projects a chunk whose insert commits while its base is being adopted', async () => {
     let inserted!: () => void
     const insertedSignal = new Promise<void>((resolve) => {
 
@@ -1,4 +1,7 @@
-import { installMembershipKey } from '@sim/db/script-migrations/0019_tin_keyword_projection'
+import {
+  installMembershipKey,
+  installTinChunkSync,
+} from '@sim/db/script-migrations/0019_tin_keyword_projection'
 import { resolveMigrationDatabaseUrl } from '@sim/db/script-migrations/database-url'
 import type { ScriptMigration } from '@sim/db/script-migrations/types'
 import { createLogger } from '@sim/logger'
@@ -12,10 +15,23 @@ const TRIGGER_LOCK_TIMEOUT = '5s'
 const TRIGGER_LOCK_RETRY_BUDGET_MS = 20 * 60_000
 const TRIGGER_LOCK_RETRY_BACKOFF = { baseMs: 2_000, maxMs: 30_000 } as const
 
-/** How both GIN keyword writers bring an existing row up to its chunk, as `0016_backfill_search_vectors` does. */
+/** The columns a GIN keyword row copies from its chunk. */
+const KEYWORD_SEARCH_COLUMNS = [
+  'knowledge_base_id',
+  'document_id',
+  'enabled',
+  'content_tsv',
+] as const
+
+/**
+ * How both GIN keyword writers bring an existing row (aliased `s`) up to its chunk. A row already
+ * current is left unwritten, as the projector's upserts leave it, so adopting a base whose rows
+ * survived rewrites only what changed while it holds the membership lock.
+ */
 const KEYWORD_SEARCH_UPSERT = `ON CONFLICT (id) DO UPDATE SET
-          knowledge_base_id = EXCLUDED.knowledge_base_id, document_id = EXCLUDED.document_id,
-          enabled = EXCLUDED.enabled, content_tsv = EXCLUDED.content_tsv`
+        ${KEYWORD_SEARCH_COLUMNS.map((column) => `${column} = EXCLUDED.${column}`).join(', ')}
+      WHERE (${KEYWORD_SEARCH_COLUMNS.map((column) => `s.${column}`).join(', ')})
+        IS DISTINCT FROM (${KEYWORD_SEARCH_COLUMNS.map((column) => `EXCLUDED.${column}`).join(', ')})`
 
 /**
  * The GIN keyword projection's chunk trigger, scoped to search indexes as the Tin projection is:
@@ -36,7 +52,7 @@ async function installKeywordSearchSync(tx: TransactionSql): Promise<void> {
         END IF;
         RETURN NEW;
       END IF;
-      INSERT INTO embedding_keyword_search (id, knowledge_base_id, document_id, enabled, content_tsv)
+      INSERT INTO embedding_keyword_search AS s (id, knowledge_base_id, document_id, enabled, content_tsv)
       VALUES (NEW.id, NEW.knowledge_base_id, NEW.document_id, NEW.enabled, NEW.content_tsv)
       ${KEYWORD_SEARCH_UPSERT};
       RETURN NEW;
@@ -58,7 +74,7 @@ async function installKeywordSearchMembership(tx: TransactionSql): Promise<void>
         DELETE FROM embedding_keyword_search WHERE knowledge_base_id = NEW.id;
         RETURN NEW;
       END IF;
-      INSERT INTO embedding_keyword_search (id, knowledge_base_id, document_id, enabled, content_tsv)
+      INSERT INTO embedding_keyword_search AS s (id, knowledge_base_id, document_id, enabled, content_tsv)
       SELECT id, knowledge_base_id, document_id, enabled, content_tsv
       FROM embedding WHERE knowledge_base_id = NEW.id
       ${KEYWORD_SEARCH_UPSERT};
@@ -72,35 +88,13 @@ async function installKeywordSearchMembership(tx: TransactionSql): Promise<void>
 }
 
 /**
- * The Tin chunk trigger's body from `0019_tin_keyword_projection`, where that migration installed
- * it, without the delete an insert outside a search index ran: a new chunk id has no Tin row, and a
- * base adopted meanwhile waits on the membership lock the insert holds.
+ * The Tin chunk trigger's body as `0019_tin_keyword_projection` now installs it, where that
+ * migration installed it: without the delete an insert outside a search index ran.
  */
 async function installTinSync(tx: TransactionSql): Promise<void> {
   const [row] = await tx<Array<{ installed: boolean }>>`
     SELECT to_regprocedure('sync_embedding_keyword_tin()') IS NOT NULL AS installed`
-  if (!row?.installed) return
-  await tx.unsafe(`CREATE OR REPLACE FUNCTION sync_embedding_keyword_tin()
-    RETURNS trigger LANGUAGE plpgsql AS $$
-    BEGIN
-      PERFORM pg_advisory_xact_lock_shared(knowledge_tin_membership_key(NEW.knowledge_base_id));
-      IF NOT EXISTS (
-        SELECT 1 FROM knowledge_base WHERE id = NEW.knowledge_base_id AND is_search_index
-      ) THEN
-        IF TG_OP = 'UPDATE' THEN
-          DELETE FROM embedding_keyword_tin WHERE id = NEW.id;
-        END IF;
-        RETURN NEW;
-      END IF;
-      INSERT INTO embedding_keyword_tin (id, knowledge_base_id, document_id, enabled, content)
-      VALUES (NEW.id, NEW.knowledge_base_id, NEW.document_id, NEW.enabled,
-        knowledge_tin_base_token(NEW.knowledge_base_id) || ' ' || knowledge_tin_stream(NEW.content_tsv))
-      ON CONFLICT (id) DO UPDATE SET
-        knowledge_base_id = EXCLUDED.knowledge_base_id, document_id = EXCLUDED.document_id,
-        enabled = EXCLUDED.enabled, content = EXCLUDED.content;
-      RETURN NEW;
-    END;
-    $$`)
+  if (row?.installed) await installTinChunkSync(tx)
 }
 
 /**