fix(file-search): assert the backfill walk still plans as an index seek

Addresses both cubic findings.

Mark the index `.concurrently()` so a schema reconciliation outside the
hand-written migration also builds it without blocking writes, matching how
workflow_execution_logs_workspace_activity_idx is declared. Drizzle now emits
CREATE INDEX CONCURRENTLY itself; the migration keeps its hand-written wrapper
for lock_timeout and replay recovery.

The walk test only proved logical pagination, which the OR spelling also
satisfies. Record the statements the dispatcher issues and EXPLAIN the exact
backfill SELECT, requiring the cursor to appear as a row-wise index condition.
Reverting to the OR spelling now fails on the plan itself, not just on the SQL
text.

That assertion also exposed a third divergence in the fixture: workspace_id was
declared NOT NULL where production has it nullable, which let PostgreSQL drop
the walk's IS NOT NULL clause and then refuse to match the partial index at all.

Author: waleedlatif1

apps/sim/lib/workspace-files/search/dispatcher.integration.ts

@@ -43,6 +43,8 @@ describe('workspace file search dispatch PostgreSQL deadlines', () => {
   ) {
     throw new Error('File search tests require a disposable local integration database')
   }
+  /** Every statement the dispatcher issues, so a test can EXPLAIN the exact SQL it ran. */
+  const statements: { query: string; params: readonly unknown[] }[] = []
   const connection = postgres(
     databaseUrl,
     withUtcTimestamps({
@@ -51,6 +53,9 @@ describe('workspace file search dispatch PostgreSQL deadlines', () => {
       fetch_types: false,
       connection: { search_path: schemaName },
       onnotice: () => {},
+      debug: (_connection: unknown, query: string, params: readonly unknown[]) => {
+        statements.push({ query, params })
+      },
     })
   )
 
@@ -60,8 +65,14 @@ describe('workspace file search dispatch PostgreSQL deadlines', () => {
       id text PRIMARY KEY, after_workspace_id text, after_file_id text,
       completed_at timestamp, updated_at timestamp NOT NULL
     )`
+    /**
+     * `workspace_id` is nullable here because it is nullable in production. Declaring it NOT NULL
+     * lets PostgreSQL discard the walk's `workspace_id IS NOT NULL` clause as trivially true, after
+     * which it can no longer prove the partial keyset index covers the query and silently stops
+     * using it.
+     */
     await connection`CREATE TABLE workspace_files (
-      id text PRIMARY KEY, workspace_id text NOT NULL, context text NOT NULL,
+      id text PRIMARY KEY, workspace_id text, context text NOT NULL,
       deleted_at timestamp, content_updated_at timestamp NOT NULL
     )`
     await connection`CREATE TABLE workspace_file_search_revision (
@@ -218,6 +229,40 @@ describe('workspace file search dispatch PostgreSQL deadlines', () => {
     expect(skipped.missed).toBe(0)
   }, 30_000)
 
+  it('seeks the keyset index for the backfill cursor rather than filtering', async () => {
+    await connection`INSERT INTO workspace_files (id, workspace_id, context, content_updated_at)
+      SELECT md5(n::text), 'workspace-' || lpad((n % 7)::text, 2, '0'), 'workspace', '2026-09-16'
+      FROM generate_series(1, ${2 * FILE_SEARCH_BACKFILL_PAGE_SIZE}) n`
+    await connection`ANALYZE workspace_files`
+
+    /** The first page leaves a cursor behind; the second is the one that has to seek to it. */
+    await prepareWorkspaceFileSearchDispatch()
+    statements.length = 0
+    await prepareWorkspaceFileSearchDispatch()
+
+    const walk = statements.find((statement) =>
+      statement.query.includes('for share of "workspace_files"')
+    )
+    expect(walk).toBeDefined()
+    expect(walk?.query).toContain('"workspace_files"."workspace_id", "workspace_files"."id") >')
+
+    const plan = await connection.begin(async (tx) => {
+      /**
+       * At fixture scale a sequential scan is genuinely cheapest, so the planner is pinned to the
+       * choice production makes on a table where it is not. What is asserted is the shape the
+       * planner can still only reach from a row-wise cursor: the `OR` spelling stays a filter under
+       * these same settings, which is the regression this guards.
+       */
+      await tx`SET LOCAL enable_seqscan = off`
+      await tx`SET LOCAL enable_sort = off`
+      const rows = await tx.unsafe(`EXPLAIN ${walk?.query}`, walk?.params as never[])
+      return rows.map((row: Record<string, unknown>) => row['QUERY PLAN']).join('\n')
+    })
+
+    expect(plan).toContain('workspace_files_workspace_active_keyset_idx')
+    expect(plan).toMatch(/Index Cond:.*ROW\(/)
+  }, 30_000)
+
   it('fails on a locked backfill row and releases the dispatcher lock', async () => {
     let release = () => {}
     let locked = () => {}

packages/db/migrations/meta/0361_snapshot.json

@@ -1,5 +1,5 @@
 {
-  "id": "652fd0ee-d230-441d-9265-6dc83845e800",
+  "id": "adb8500a-f0dc-4352-9153-aa71f94955a8",
   "prevId": "8ad7811c-cbe2-4bac-bebf-4fef00f7d86f",
   "version": "7",
   "dialect": "postgresql",
@@ -26436,7 +26436,7 @@
           ],
           "isUnique": false,
           "where": "\"workspace_files\".\"deleted_at\" IS NULL AND \"workspace_files\".\"context\" = 'workspace' AND \"workspace_files\".\"workspace_id\" IS NOT NULL",
-          "concurrently": false,
+          "concurrently": true,
           "method": "btree",
           "with": {}
         },

packages/db/migrations/meta/_journal.json

@@ -2525,7 +2525,7 @@
     {
       "idx": 361,
       "version": "7",
-      "when": 1789699416165,
+      "when": 1789700848145,
       "tag": "0361_workspace_file_search_backfill_keyset",
       "breakpoints": true
     }

packages/db/schema.ts

@@ -2308,6 +2308,7 @@ export const workspaceFiles = pgTable(
      */
     workspaceActiveKeysetIdx: index('workspace_files_workspace_active_keyset_idx')
       .on(table.workspaceId, table.id)
+      .concurrently()
       .where(
         sql`${table.deletedAt} IS NULL AND ${table.context} = 'workspace' AND ${table.workspaceId} IS NOT NULL`
       ),