fix(knowledge): require an enabled chunk when a tag filter decides a document

A document whose only tagged chunk is disabled could be admitted by the probe
and then discarded by ranking, spending the probe's document bound on a
document that can contribute no candidate.

Update the KB block fan-out integration test to the strategy it now exercises:
a scope too small to fill the traversal probes once and rescues once.

Author: waleedlatif1

apps/sim/lib/knowledge/__integration__/kb-block-search.integration.ts

@@ -91,7 +91,7 @@ describe('API-key KB block fan-out', () => {
       const previousDebug = db.$client.options.debug
       const statements: string[] = []
       db.$client.options.debug = (_connection, query) => {
-        if (statements.length < 250) statements.push(query)
+        if (statements.length < 1000) statements.push(query)
       }
       try {
         const results = await Promise.all(
@@ -124,9 +124,26 @@ describe('API-key KB block fan-out', () => {
           expect(result.rows[0].knowledgeBaseId).toBe(bases[index].id)
           expect(result.rows[0].distance).toBeCloseTo(0)
         }
-        expect(statements.filter((query) => query.includes('statement_timeout'))).toHaveLength(54)
-        expect(statements.filter((query) => query.includes('+ 0'))).toHaveLength(18)
-        expect(statements.some((query) => query.includes('hnsw.iterative_scan'))).toBe(false)
+        const matching = (fragment: string) =>
+          statements.filter((query) => query.includes(fragment))
+        /**
+         * Every statement runs under the leg's deadline: the candidate search reinstates it after
+         * tuning the scan, and the probe, the exact ranking, the rerank and hydration each open
+         * with one of their own.
+         */
+        expect(matching('statement_timeout')).toHaveLength(bases.length * 6)
+        /**
+         * A scope this small leaves the bounded traversal short of its candidate limit, so every
+         * search probes once and rescues once — never a widening retry loop.
+         */
+        expect(matching('hnsw.iterative_scan')).toHaveLength(bases.length)
+        expect(matching('AS visible')).toHaveLength(bases.length)
+        expect(matching(') + 0 LIMIT')).toHaveLength(bases.length)
+        expect(matching('scored_search_candidates')).toHaveLength(bases.length)
+        /** The probe enumerates visible documents; it never ranks them. */
+        expect(
+          statements.filter((query) => query.includes('AS id FROM') && !query.includes('ORDER BY'))
+        ).toHaveLength(bases.length)
       } finally {
         db.$client.options.debug = previousDebug
       }

apps/sim/lib/knowledge/search/queries.test.ts

@@ -437,6 +437,24 @@ describe('workspace-scoped vector retrieval', () => {
     expect(getForConnectors).not.toHaveBeenCalled()
   })
 
+  it('counts only chunks the search can return when a tag filter decides a document', async () => {
+    traversedRows = ranked
+    probeRows = [{ id: 'near-doc' }]
+    exactRows = ranked
+    queueTableRows(schemaMock.embedding, [...ranked].reverse())
+    await handleTagAndVectorSearch({
+      ...params,
+      structuredFilters: [{ tagSlot: 'tag1', fieldType: 'text', operator: 'eq', value: 'common' }],
+    })
+    /**
+     * A document whose only tagged chunk is disabled contributes no candidate, so admitting it
+     * would spend the probe's document bound on a document the ranking then discards.
+     */
+    const probe = JSON.stringify(statements().find((query) => isProbeStatement(query.sql))!)
+    expect(probe).toContain(String(schemaMock.embedding.tag1))
+    expect(probe).toContain(`"left":"${schemaMock.embedding.enabled}","right":true`)
+  })
+
   it('keeps the tuple budget an order of magnitude above the beam so the scan can iterate', async () => {
     queueTableRows(schemaMock.embedding, [...ranked].reverse())
     await handleVectorOnlySearch(params)

apps/sim/lib/knowledge/search/queries.ts

@@ -847,12 +847,16 @@ async function probeVisibleDocuments(
   }
 }
 
-/** Tags live on chunks, so a row qualifies when a chunk it joins to carries them. */
+/**
+ * Tags live on chunks, so a row qualifies when a chunk it joins to carries them — and only a
+ * chunk the search can actually return counts, or a document whose sole match is disabled would
+ * be admitted by a check that ranking then discards.
+ */
 function chunkTagCondition(join: SQL, tagConditions: SQL[]): SQL | undefined {
   if (!tagConditions.length) return undefined
   return sql`EXISTS (
     SELECT 1 FROM ${embedding}
-    WHERE ${and(join, ...tagConditions)}
+    WHERE ${and(join, eq(embedding.enabled, true), ...tagConditions)}
   )`
 }