weave-typescript 0.27.0 → 0.29.0

package/dist/weavesql/weavedb/retrieval_sql.js

@@ -0,0 +1,880 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listApprovedReconcilePoolByOrganizationQuery = exports.deleteSessionRetrievalContextQuery = exports.listSessionRetrievalContextQuery = exports.insertSessionRetrievalContextQuery = exports.searchConceptClusterThreadsBySimilarityAndUserPermissionsQuery = exports.searchConceptClusterThreadsBySimilarityQuery = exports.searchLeafConceptClustersBySimilarityQuery = exports.searchApprovedThreadsByEntitiesAndUserPermissionsQuery = exports.searchApprovedThreadsByEntitiesQuery = exports.searchApprovedThreadsSemanticByKnowledgeTypesAndUserPermissionsQuery = exports.searchApprovedThreadsSemanticByKnowledgeTypesQuery = exports.searchAccessibleDocumentsSemanticQuery = exports.searchApprovedThreadsSemanticByUserPermissionsQuery = exports.searchApprovedThreadsSemanticQuery = exports.refreshThreadReinforcementScoresQuery = void 0;
+exports.refreshThreadReinforcementScores = refreshThreadReinforcementScores;
+exports.searchApprovedThreadsSemantic = searchApprovedThreadsSemantic;
+exports.searchApprovedThreadsSemanticByUserPermissions = searchApprovedThreadsSemanticByUserPermissions;
+exports.searchAccessibleDocumentsSemantic = searchAccessibleDocumentsSemantic;
+exports.searchApprovedThreadsSemanticByKnowledgeTypes = searchApprovedThreadsSemanticByKnowledgeTypes;
+exports.searchApprovedThreadsSemanticByKnowledgeTypesAndUserPermissions = searchApprovedThreadsSemanticByKnowledgeTypesAndUserPermissions;
+exports.searchApprovedThreadsByEntities = searchApprovedThreadsByEntities;
+exports.searchApprovedThreadsByEntitiesAndUserPermissions = searchApprovedThreadsByEntitiesAndUserPermissions;
+exports.searchLeafConceptClustersBySimilarity = searchLeafConceptClustersBySimilarity;
+exports.searchConceptClusterThreadsBySimilarity = searchConceptClusterThreadsBySimilarity;
+exports.searchConceptClusterThreadsBySimilarityAndUserPermissions = searchConceptClusterThreadsBySimilarityAndUserPermissions;
+exports.insertSessionRetrievalContext = insertSessionRetrievalContext;
+exports.listSessionRetrievalContext = listSessionRetrievalContext;
+exports.deleteSessionRetrievalContext = deleteSessionRetrievalContext;
+exports.listApprovedReconcilePoolByOrganization = listApprovedReconcilePoolByOrganization;
+exports.refreshThreadReinforcementScoresQuery = `-- name: RefreshThreadReinforcementScores :exec
+REFRESH MATERIALIZED VIEW CONCURRENTLY weave.thread_reinforcement_scores`;
+async function refreshThreadReinforcementScores(client) {
+    await client.query({
+        text: exports.refreshThreadReinforcementScoresQuery,
+        values: [],
+        rowMode: "array"
+    });
+}
+exports.searchApprovedThreadsSemanticQuery = `-- name: SearchApprovedThreadsSemantic :many
+SELECT
+    t.id AS thread_id,
+    t.text,
+    t.knowledge_type,
+    t.facet_fields,
+    similarity.score,
+    t.classification,
+    t.document_id,
+    d.filename AS document_name,
+    t.source_location,
+    t.approved_at,
+    t.temporal_validity,
+    COALESCE(entity_data.entities, '{}'::text[]) AS entities,
+    COALESCE(rs.reinforcement_count, 0) AS reinforcement_count,
+    COALESCE(cc.name, '') AS concept_cluster
+FROM weave.threads t
+JOIN weave.documents d ON d.id = t.document_id
+CROSS JOIN LATERAL (
+    SELECT CAST(
+        1.0::double precision
+        - (t.embedding <=> $1::vector)::double precision
+        AS double precision
+    ) AS score
+) similarity
+LEFT JOIN weave.thread_reinforcement_scores rs ON rs.thread_id = t.id
+LEFT JOIN weave.concept_clusters cc ON cc.id = t.cluster_id
+LEFT JOIN LATERAL (
+    SELECT array_agg(DISTINCT e.canonical ORDER BY e.canonical) AS entities
+    FROM weave.thread_entities te
+    JOIN weave.entities e ON e.id = te.entity_id
+    WHERE te.thread_id = t.id
+) entity_data ON TRUE
+WHERE t.organization_id = $2
+  AND t.retrieval_status = 'THREAD_RETRIEVAL_STATUS_APPROVED'
+  AND t.embedding IS NOT NULL
+  AND similarity.score >= $3::double precision
+ORDER BY score DESC, t.approved_at DESC
+LIMIT $4`;
+async function searchApprovedThreadsSemantic(client, args) {
+    const result = await client.query({
+        text: exports.searchApprovedThreadsSemanticQuery,
+        values: [args.queryEmbedding, args.organizationId, args.minSimilarity, args.resultLimit],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            threadId: row[0],
+            text: row[1],
+            knowledgeType: row[2],
+            facetFields: row[3],
+            score: row[4],
+            classification: row[5],
+            documentId: row[6],
+            documentName: row[7],
+            sourceLocation: row[8],
+            approvedAt: row[9],
+            temporalValidity: row[10],
+            entities: row[11],
+            reinforcementCount: row[12],
+            conceptCluster: row[13]
+        };
+    });
+}
+exports.searchApprovedThreadsSemanticByUserPermissionsQuery = `-- name: SearchApprovedThreadsSemanticByUserPermissions :many
+SELECT
+    t.id AS thread_id,
+    t.text,
+    t.knowledge_type,
+    t.facet_fields,
+    similarity.score,
+    t.classification,
+    t.document_id,
+    d.filename AS document_name,
+    t.source_location,
+    t.approved_at,
+    t.temporal_validity,
+    COALESCE(entity_data.entities, '{}'::text[]) AS entities,
+    COALESCE(rs.reinforcement_count, 0) AS reinforcement_count,
+    COALESCE(cc.name, '') AS concept_cluster
+FROM weave.threads t
+JOIN weave.documents d ON d.id = t.document_id
+CROSS JOIN LATERAL (
+    SELECT CAST(
+        1.0::double precision
+        - (t.embedding <=> $1::vector)::double precision
+        AS double precision
+    ) AS score
+) similarity
+LEFT JOIN weave.thread_reinforcement_scores rs ON rs.thread_id = t.id
+LEFT JOIN weave.concept_clusters cc ON cc.id = t.cluster_id
+LEFT JOIN LATERAL (
+    SELECT array_agg(DISTINCT e.canonical ORDER BY e.canonical) AS entities
+    FROM weave.thread_entities te
+    JOIN weave.entities e ON e.id = te.entity_id
+    WHERE te.thread_id = t.id
+) entity_data ON TRUE
+WHERE t.organization_id = $2
+  AND t.retrieval_status = 'THREAD_RETRIEVAL_STATUS_APPROVED'
+  AND t.embedding IS NOT NULL
+  AND similarity.score >= $3::double precision
+  AND (
+      d.scope = 'DOCUMENT_SCOPE_ORG'
+      OR (d.scope = 'DOCUMENT_SCOPE_PRIVATE'
+          AND d.uploaded_by_user_id = $4)
+      OR (d.scope = 'DOCUMENT_SCOPE_RESTRICTED'
+          AND EXISTS (
+              SELECT 1
+              FROM weave.user_sensitivity_clearances c
+              WHERE c.organization_id = $2
+                AND c.user_id = $4
+                AND cardinality(d.sensitivity_tags) = 1
+                AND c.sensitivity_tag_slug = d.sensitivity_tags[1]
+          ))
+  )
+ORDER BY score DESC, t.approved_at DESC
+LIMIT $5`;
+async function searchApprovedThreadsSemanticByUserPermissions(client, args) {
+    const result = await client.query({
+        text: exports.searchApprovedThreadsSemanticByUserPermissionsQuery,
+        values: [args.queryEmbedding, args.organizationId, args.minSimilarity, args.actingUserId, args.resultLimit],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            threadId: row[0],
+            text: row[1],
+            knowledgeType: row[2],
+            facetFields: row[3],
+            score: row[4],
+            classification: row[5],
+            documentId: row[6],
+            documentName: row[7],
+            sourceLocation: row[8],
+            approvedAt: row[9],
+            temporalValidity: row[10],
+            entities: row[11],
+            reinforcementCount: row[12],
+            conceptCluster: row[13]
+        };
+    });
+}
+exports.searchAccessibleDocumentsSemanticQuery = `-- name: SearchAccessibleDocumentsSemantic :many
+WITH tag_data AS (
+    SELECT
+        dt.document_id,
+        array_agg(dt.tag ORDER BY dt.tag ASC) AS tags,
+        array_agg(dt.confidence ORDER BY dt.tag ASC) AS tag_confidences
+    FROM weave.document_tags dt
+    JOIN weave.documents d ON d.id = dt.document_id
+    WHERE d.organization_id = $4
+    GROUP BY dt.document_id
+),
+matches AS (
+    SELECT
+        t.id AS thread_id,
+        t.text,
+        t.classification,
+        t.document_id,
+        d.filename AS document_name,
+        d.mime_type,
+        d.scope,
+        d.sensitivity_tags,
+        d.uploaded_at,
+        COALESCE(tag_data.tags, '{}'::text[]) AS tags,
+        COALESCE(tag_data.tag_confidences, '{}'::real[]) AS tag_confidences,
+        t.source_location,
+        t.approved_at,
+        CAST(
+            1.0::double precision
+            - (t.embedding <=> $5::vector)::double precision
+            AS double precision
+        ) AS score
+    FROM weave.threads t
+    JOIN weave.documents d ON d.id = t.document_id
+    LEFT JOIN tag_data ON tag_data.document_id = d.id
+    WHERE t.organization_id = $4
+      AND t.retrieval_status = 'THREAD_RETRIEVAL_STATUS_APPROVED'
+      AND t.embedding IS NOT NULL
+      AND (
+          d.scope = 'DOCUMENT_SCOPE_ORG'
+          OR (d.scope = 'DOCUMENT_SCOPE_PRIVATE'
+              AND d.uploaded_by_user_id = $6)
+          OR (d.scope = 'DOCUMENT_SCOPE_RESTRICTED'
+              AND EXISTS (
+                  SELECT 1
+                  FROM weave.user_sensitivity_clearances c
+                  WHERE c.organization_id = $4
+                    AND c.user_id = $6
+                    AND cardinality(d.sensitivity_tags) = 1
+                    AND c.sensitivity_tag_slug = d.sensitivity_tags[1]
+              ))
+      )
+      AND (cardinality($7::text[]) = 0 OR tag_data.tags && $7::text[] OR d.sensitivity_tags && $7::text[])
+      AND (cardinality($8::text[]) = 0 OR d.sensitivity_tags && $8::text[])
+      AND (cardinality($9::text[]) = 0 OR d.scope = ANY($9::text[]))
+      AND ($10::timestamptz IS NULL OR d.uploaded_at >= $10::timestamptz)
+      AND ($11::timestamptz IS NULL OR d.uploaded_at <= $11::timestamptz)
+)
+SELECT
+    document_id,
+    document_name,
+    mime_type,
+    scope,
+    sensitivity_tags,
+    tags,
+    tag_confidences,
+    uploaded_at,
+    MAX(score)::double precision AS score,
+    COUNT(*)::int AS matched_thread_count,
+    (array_agg(thread_id ORDER BY score DESC, approved_at DESC))[1] AS best_thread_id,
+    (array_agg(text ORDER BY score DESC, approved_at DESC))[1] AS best_text,
+    (array_agg(classification ORDER BY score DESC, approved_at DESC))[1] AS best_classification,
+    (array_agg(source_location ORDER BY score DESC, approved_at DESC))[1] AS best_source_location
+FROM matches
+WHERE score >= $1::double precision
+GROUP BY
+    document_id,
+    document_name,
+    mime_type,
+    scope,
+    sensitivity_tags,
+    tags,
+    tag_confidences,
+    uploaded_at
+ORDER BY score DESC, uploaded_at DESC
+LIMIT $3 OFFSET $2`;
+async function searchAccessibleDocumentsSemantic(client, args) {
+    const result = await client.query({
+        text: exports.searchAccessibleDocumentsSemanticQuery,
+        values: [args.minSimilarity, args.pageOffset, args.resultLimit, args.organizationId, args.queryEmbedding, args.actingUserId, args.tags, args.restrictedTags, args.scopes, args.uploadedAfter, args.uploadedBefore],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            documentId: row[0],
+            documentName: row[1],
+            mimeType: row[2],
+            scope: row[3],
+            sensitivityTags: row[4],
+            tags: row[5],
+            tagConfidences: row[6],
+            uploadedAt: row[7],
+            score: row[8],
+            matchedThreadCount: row[9],
+            bestThreadId: row[10],
+            bestText: row[11],
+            bestClassification: row[12],
+            bestSourceLocation: row[13]
+        };
+    });
+}
+exports.searchApprovedThreadsSemanticByKnowledgeTypesQuery = `-- name: SearchApprovedThreadsSemanticByKnowledgeTypes :many
+SELECT
+    t.id AS thread_id,
+    t.text,
+    t.knowledge_type,
+    t.facet_fields,
+    similarity.score,
+    t.classification,
+    t.document_id,
+    d.filename AS document_name,
+    t.source_location,
+    t.approved_at,
+    t.temporal_validity,
+    COALESCE(entity_data.entities, '{}'::text[]) AS entities,
+    COALESCE(rs.reinforcement_count, 0) AS reinforcement_count,
+    COALESCE(cc.name, '') AS concept_cluster
+FROM weave.threads t
+JOIN weave.documents d ON d.id = t.document_id
+CROSS JOIN LATERAL (
+    SELECT CAST(
+        1.0::double precision
+        - (t.embedding <=> $1::vector)::double precision
+        AS double precision
+    ) AS score
+) similarity
+LEFT JOIN weave.thread_reinforcement_scores rs ON rs.thread_id = t.id
+LEFT JOIN weave.concept_clusters cc ON cc.id = t.cluster_id
+LEFT JOIN LATERAL (
+    SELECT array_agg(DISTINCT e.canonical ORDER BY e.canonical) AS entities
+    FROM weave.thread_entities te
+    JOIN weave.entities e ON e.id = te.entity_id
+    WHERE te.thread_id = t.id
+) entity_data ON TRUE
+WHERE t.organization_id = $2
+  AND t.retrieval_status = 'THREAD_RETRIEVAL_STATUS_APPROVED'
+  AND t.embedding IS NOT NULL
+  AND t.knowledge_type = ANY($3::text[])
+  AND similarity.score >= $4::double precision
+ORDER BY score DESC, t.approved_at DESC
+LIMIT $5`;
+async function searchApprovedThreadsSemanticByKnowledgeTypes(client, args) {
+    const result = await client.query({
+        text: exports.searchApprovedThreadsSemanticByKnowledgeTypesQuery,
+        values: [args.queryEmbedding, args.organizationId, args.knowledgeTypes, args.minSimilarity, args.resultLimit],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            threadId: row[0],
+            text: row[1],
+            knowledgeType: row[2],
+            facetFields: row[3],
+            score: row[4],
+            classification: row[5],
+            documentId: row[6],
+            documentName: row[7],
+            sourceLocation: row[8],
+            approvedAt: row[9],
+            temporalValidity: row[10],
+            entities: row[11],
+            reinforcementCount: row[12],
+            conceptCluster: row[13]
+        };
+    });
+}
+exports.searchApprovedThreadsSemanticByKnowledgeTypesAndUserPermissionsQuery = `-- name: SearchApprovedThreadsSemanticByKnowledgeTypesAndUserPermissions :many
+SELECT
+    t.id AS thread_id,
+    t.text,
+    t.knowledge_type,
+    t.facet_fields,
+    similarity.score,
+    t.classification,
+    t.document_id,
+    d.filename AS document_name,
+    t.source_location,
+    t.approved_at,
+    t.temporal_validity,
+    COALESCE(entity_data.entities, '{}'::text[]) AS entities,
+    COALESCE(rs.reinforcement_count, 0) AS reinforcement_count,
+    COALESCE(cc.name, '') AS concept_cluster
+FROM weave.threads t
+JOIN weave.documents d ON d.id = t.document_id
+CROSS JOIN LATERAL (
+    SELECT CAST(
+        1.0::double precision
+        - (t.embedding <=> $1::vector)::double precision
+        AS double precision
+    ) AS score
+) similarity
+LEFT JOIN weave.thread_reinforcement_scores rs ON rs.thread_id = t.id
+LEFT JOIN weave.concept_clusters cc ON cc.id = t.cluster_id
+LEFT JOIN LATERAL (
+    SELECT array_agg(DISTINCT e.canonical ORDER BY e.canonical) AS entities
+    FROM weave.thread_entities te
+    JOIN weave.entities e ON e.id = te.entity_id
+    WHERE te.thread_id = t.id
+) entity_data ON TRUE
+WHERE t.organization_id = $2
+  AND t.retrieval_status = 'THREAD_RETRIEVAL_STATUS_APPROVED'
+  AND t.embedding IS NOT NULL
+  AND t.knowledge_type = ANY($3::text[])
+  AND similarity.score >= $4::double precision
+  AND (
+      d.scope = 'DOCUMENT_SCOPE_ORG'
+      OR (d.scope = 'DOCUMENT_SCOPE_PRIVATE'
+          AND d.uploaded_by_user_id = $5)
+      OR (d.scope = 'DOCUMENT_SCOPE_RESTRICTED'
+          AND EXISTS (
+              SELECT 1
+              FROM weave.user_sensitivity_clearances c
+              WHERE c.organization_id = $2
+                AND c.user_id = $5
+                AND cardinality(d.sensitivity_tags) = 1
+                AND c.sensitivity_tag_slug = d.sensitivity_tags[1]
+          ))
+  )
+ORDER BY score DESC, t.approved_at DESC
+LIMIT $6`;
+async function searchApprovedThreadsSemanticByKnowledgeTypesAndUserPermissions(client, args) {
+    const result = await client.query({
+        text: exports.searchApprovedThreadsSemanticByKnowledgeTypesAndUserPermissionsQuery,
+        values: [args.queryEmbedding, args.organizationId, args.knowledgeTypes, args.minSimilarity, args.actingUserId, args.resultLimit],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            threadId: row[0],
+            text: row[1],
+            knowledgeType: row[2],
+            facetFields: row[3],
+            score: row[4],
+            classification: row[5],
+            documentId: row[6],
+            documentName: row[7],
+            sourceLocation: row[8],
+            approvedAt: row[9],
+            temporalValidity: row[10],
+            entities: row[11],
+            reinforcementCount: row[12],
+            conceptCluster: row[13]
+        };
+    });
+}
+exports.searchApprovedThreadsByEntitiesQuery = `-- name: SearchApprovedThreadsByEntities :many
+SELECT DISTINCT
+    t.id AS thread_id,
+    t.text,
+    t.knowledge_type,
+    t.facet_fields,
+    te.confidence::double precision AS score,
+    t.classification,
+    t.document_id,
+    d.filename AS document_name,
+    t.source_location,
+    t.approved_at,
+    t.temporal_validity,
+    COALESCE(entity_data.entities, '{}'::text[]) AS entities,
+    COALESCE(rs.reinforcement_count, 0) AS reinforcement_count,
+    COALESCE(cc.name, '') AS concept_cluster
+FROM weave.threads t
+JOIN weave.documents d ON d.id = t.document_id
+JOIN weave.thread_entities te ON te.thread_id = t.id
+JOIN weave.entities e ON e.id = te.entity_id
+LEFT JOIN weave.thread_reinforcement_scores rs ON rs.thread_id = t.id
+LEFT JOIN weave.concept_clusters cc ON cc.id = t.cluster_id
+LEFT JOIN LATERAL (
+    SELECT array_agg(DISTINCT e2.canonical ORDER BY e2.canonical) AS entities
+    FROM weave.thread_entities te2
+    JOIN weave.entities e2 ON e2.id = te2.entity_id
+    WHERE te2.thread_id = t.id
+) entity_data ON TRUE
+WHERE t.organization_id = $1
+  AND t.retrieval_status = 'THREAD_RETRIEVAL_STATUS_APPROVED'
+  AND e.canonical = ANY($2::text[])
+ORDER BY score DESC, t.approved_at DESC
+LIMIT $3`;
+async function searchApprovedThreadsByEntities(client, args) {
+    const result = await client.query({
+        text: exports.searchApprovedThreadsByEntitiesQuery,
+        values: [args.organizationId, args.entityCanonicals, args.resultLimit],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            threadId: row[0],
+            text: row[1],
+            knowledgeType: row[2],
+            facetFields: row[3],
+            score: row[4],
+            classification: row[5],
+            documentId: row[6],
+            documentName: row[7],
+            sourceLocation: row[8],
+            approvedAt: row[9],
+            temporalValidity: row[10],
+            entities: row[11],
+            reinforcementCount: row[12],
+            conceptCluster: row[13]
+        };
+    });
+}
+exports.searchApprovedThreadsByEntitiesAndUserPermissionsQuery = `-- name: SearchApprovedThreadsByEntitiesAndUserPermissions :many
+SELECT DISTINCT
+    t.id AS thread_id,
+    t.text,
+    t.knowledge_type,
+    t.facet_fields,
+    te.confidence::double precision AS score,
+    t.classification,
+    t.document_id,
+    d.filename AS document_name,
+    t.source_location,
+    t.approved_at,
+    t.temporal_validity,
+    COALESCE(entity_data.entities, '{}'::text[]) AS entities,
+    COALESCE(rs.reinforcement_count, 0) AS reinforcement_count,
+    COALESCE(cc.name, '') AS concept_cluster
+FROM weave.threads t
+JOIN weave.documents d ON d.id = t.document_id
+JOIN weave.thread_entities te ON te.thread_id = t.id
+JOIN weave.entities e ON e.id = te.entity_id
+LEFT JOIN weave.thread_reinforcement_scores rs ON rs.thread_id = t.id
+LEFT JOIN weave.concept_clusters cc ON cc.id = t.cluster_id
+LEFT JOIN LATERAL (
+    SELECT array_agg(DISTINCT e2.canonical ORDER BY e2.canonical) AS entities
+    FROM weave.thread_entities te2
+    JOIN weave.entities e2 ON e2.id = te2.entity_id
+    WHERE te2.thread_id = t.id
+) entity_data ON TRUE
+WHERE t.organization_id = $1
+  AND t.retrieval_status = 'THREAD_RETRIEVAL_STATUS_APPROVED'
+  AND e.canonical = ANY($2::text[])
+  AND (
+      d.scope = 'DOCUMENT_SCOPE_ORG'
+      OR (d.scope = 'DOCUMENT_SCOPE_PRIVATE'
+          AND d.uploaded_by_user_id = $3)
+      OR (d.scope = 'DOCUMENT_SCOPE_RESTRICTED'
+          AND EXISTS (
+              SELECT 1
+              FROM weave.user_sensitivity_clearances c
+              WHERE c.organization_id = $1
+                AND c.user_id = $3
+                AND cardinality(d.sensitivity_tags) = 1
+                AND c.sensitivity_tag_slug = d.sensitivity_tags[1]
+          ))
+  )
+ORDER BY score DESC, t.approved_at DESC
+LIMIT $4`;
+async function searchApprovedThreadsByEntitiesAndUserPermissions(client, args) {
+    const result = await client.query({
+        text: exports.searchApprovedThreadsByEntitiesAndUserPermissionsQuery,
+        values: [args.organizationId, args.entityCanonicals, args.actingUserId, args.resultLimit],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            threadId: row[0],
+            text: row[1],
+            knowledgeType: row[2],
+            facetFields: row[3],
+            score: row[4],
+            classification: row[5],
+            documentId: row[6],
+            documentName: row[7],
+            sourceLocation: row[8],
+            approvedAt: row[9],
+            temporalValidity: row[10],
+            entities: row[11],
+            reinforcementCount: row[12],
+            conceptCluster: row[13]
+        };
+    });
+}
+exports.searchLeafConceptClustersBySimilarityQuery = `-- name: SearchLeafConceptClustersBySimilarity :many
+SELECT
+    cc.id,
+    cc.organization_id,
+    cc.realm_kind,
+    cc.realm_key,
+    cc.name,
+    cc.description,
+    cc.knowledge_type,
+    cc.level,
+    cc.parent_id,
+    cc.thread_count,
+    cc.consolidation_run_id,
+    cc.created_at,
+    cc.updated_at,
+    similarity.score
+FROM weave.concept_clusters cc
+CROSS JOIN LATERAL (
+    SELECT CAST(
+        1.0::double precision
+        - (cc.embedding <=> $1::vector)::double precision
+        AS double precision
+    ) AS score
+) similarity
+WHERE cc.organization_id = $2
+  AND cc.realm_kind = $3
+  AND cc.realm_key = $4
+  AND cc.level = 0
+  AND cc.embedding IS NOT NULL
+  AND similarity.score >= $5::double precision
+ORDER BY score DESC, cc.updated_at DESC
+LIMIT $6`;
+async function searchLeafConceptClustersBySimilarity(client, args) {
+    const result = await client.query({
+        text: exports.searchLeafConceptClustersBySimilarityQuery,
+        values: [args.queryEmbedding, args.organizationId, args.realmKind, args.realmKey, args.minSimilarity, args.resultLimit],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            organizationId: row[1],
+            realmKind: row[2],
+            realmKey: row[3],
+            name: row[4],
+            description: row[5],
+            knowledgeType: row[6],
+            level: row[7],
+            parentId: row[8],
+            threadCount: row[9],
+            consolidationRunId: row[10],
+            createdAt: row[11],
+            updatedAt: row[12],
+            score: row[13]
+        };
+    });
+}
+exports.searchConceptClusterThreadsBySimilarityQuery = `-- name: SearchConceptClusterThreadsBySimilarity :many
+SELECT
+    t.id AS thread_id,
+    t.text,
+    t.knowledge_type,
+    t.facet_fields,
+    similarity.score,
+    t.classification,
+    t.document_id,
+    d.filename AS document_name,
+    t.source_location,
+    t.approved_at,
+    t.temporal_validity,
+    COALESCE(entity_data.entities, '{}'::text[]) AS entities,
+    COALESCE(rs.reinforcement_count, 0) AS reinforcement_count,
+    cc.name AS concept_cluster
+FROM weave.concept_clusters cc
+CROSS JOIN LATERAL (
+    SELECT CAST(
+        1.0::double precision
+        - (cc.embedding <=> $1::vector)::double precision
+        AS double precision
+    ) AS score
+) similarity
+JOIN weave.threads t ON t.cluster_id = cc.id
+JOIN weave.documents d ON d.id = t.document_id
+LEFT JOIN weave.thread_reinforcement_scores rs ON rs.thread_id = t.id
+LEFT JOIN LATERAL (
+    SELECT array_agg(DISTINCT e.canonical ORDER BY e.canonical) AS entities
+    FROM weave.thread_entities te
+    JOIN weave.entities e ON e.id = te.entity_id
+    WHERE te.thread_id = t.id
+) entity_data ON TRUE
+WHERE cc.organization_id = $2
+  AND cc.realm_kind = $3
+  AND cc.realm_key = $4
+  AND cc.level = 0
+  AND cc.embedding IS NOT NULL
+  AND t.retrieval_status = 'THREAD_RETRIEVAL_STATUS_APPROVED'
+  AND similarity.score >= $5::double precision
+ORDER BY score DESC, t.approved_at DESC
+LIMIT $6`;
+async function searchConceptClusterThreadsBySimilarity(client, args) {
+    const result = await client.query({
+        text: exports.searchConceptClusterThreadsBySimilarityQuery,
+        values: [args.queryEmbedding, args.organizationId, args.realmKind, args.realmKey, args.minSimilarity, args.resultLimit],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            threadId: row[0],
+            text: row[1],
+            knowledgeType: row[2],
+            facetFields: row[3],
+            score: row[4],
+            classification: row[5],
+            documentId: row[6],
+            documentName: row[7],
+            sourceLocation: row[8],
+            approvedAt: row[9],
+            temporalValidity: row[10],
+            entities: row[11],
+            reinforcementCount: row[12],
+            conceptCluster: row[13]
+        };
+    });
+}
+exports.searchConceptClusterThreadsBySimilarityAndUserPermissionsQuery = `-- name: SearchConceptClusterThreadsBySimilarityAndUserPermissions :many
+SELECT
+    t.id AS thread_id,
+    t.text,
+    t.knowledge_type,
+    t.facet_fields,
+    similarity.score,
+    t.classification,
+    t.document_id,
+    d.filename AS document_name,
+    t.source_location,
+    t.approved_at,
+    t.temporal_validity,
+    COALESCE(entity_data.entities, '{}'::text[]) AS entities,
+    COALESCE(rs.reinforcement_count, 0) AS reinforcement_count,
+    cc.name AS concept_cluster
+FROM weave.concept_clusters cc
+CROSS JOIN LATERAL (
+    SELECT CAST(
+        1.0::double precision
+        - (cc.embedding <=> $1::vector)::double precision
+        AS double precision
+    ) AS score
+) similarity
+JOIN weave.threads t ON t.cluster_id = cc.id
+JOIN weave.documents d ON d.id = t.document_id
+LEFT JOIN weave.thread_reinforcement_scores rs ON rs.thread_id = t.id
+LEFT JOIN LATERAL (
+    SELECT array_agg(DISTINCT e.canonical ORDER BY e.canonical) AS entities
+    FROM weave.thread_entities te
+    JOIN weave.entities e ON e.id = te.entity_id
+    WHERE te.thread_id = t.id
+) entity_data ON TRUE
+WHERE cc.organization_id = $2
+  AND cc.realm_kind = $3
+  AND cc.realm_key = $4
+  AND cc.level = 0
+  AND cc.embedding IS NOT NULL
+  AND t.retrieval_status = 'THREAD_RETRIEVAL_STATUS_APPROVED'
+  AND similarity.score >= $5::double precision
+  AND (
+      d.scope = 'DOCUMENT_SCOPE_ORG'
+      OR (d.scope = 'DOCUMENT_SCOPE_PRIVATE'
+          AND d.uploaded_by_user_id = $6)
+      OR (d.scope = 'DOCUMENT_SCOPE_RESTRICTED'
+          AND EXISTS (
+              SELECT 1
+              FROM weave.user_sensitivity_clearances c
+              WHERE c.organization_id = $2
+                AND c.user_id = $6
+                AND cardinality(d.sensitivity_tags) = 1
+                AND c.sensitivity_tag_slug = d.sensitivity_tags[1]
+          ))
+  )
+ORDER BY score DESC, t.approved_at DESC
+LIMIT $7`;
+async function searchConceptClusterThreadsBySimilarityAndUserPermissions(client, args) {
+    const result = await client.query({
+        text: exports.searchConceptClusterThreadsBySimilarityAndUserPermissionsQuery,
+        values: [args.queryEmbedding, args.organizationId, args.realmKind, args.realmKey, args.minSimilarity, args.actingUserId, args.resultLimit],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            threadId: row[0],
+            text: row[1],
+            knowledgeType: row[2],
+            facetFields: row[3],
+            score: row[4],
+            classification: row[5],
+            documentId: row[6],
+            documentName: row[7],
+            sourceLocation: row[8],
+            approvedAt: row[9],
+            temporalValidity: row[10],
+            entities: row[11],
+            reinforcementCount: row[12],
+            conceptCluster: row[13]
+        };
+    });
+}
+exports.insertSessionRetrievalContextQuery = `-- name: InsertSessionRetrievalContext :one
+INSERT INTO weave.session_retrieval_context (
+    session_id,
+    turn_number,
+    thread_id,
+    relevance
+) SELECT
+    $1,
+    $2,
+    t.id,
+    $3
+FROM weave.threads t
+WHERE t.organization_id = $4
+  AND t.id = $5
+RETURNING
+    session_id,
+    turn_number,
+    thread_id,
+    relevance,
+    retrieved_at`;
+async function insertSessionRetrievalContext(client, args) {
+    const result = await client.query({
+        text: exports.insertSessionRetrievalContextQuery,
+        values: [args.sessionId, args.turnNumber, args.relevance, args.organizationId, args.threadId],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        sessionId: row[0],
+        turnNumber: row[1],
+        threadId: row[2],
+        relevance: row[3],
+        retrievedAt: row[4]
+    };
+}
+exports.listSessionRetrievalContextQuery = `-- name: ListSessionRetrievalContext :many
+SELECT
+    session_id,
+    turn_number,
+    thread_id,
+    relevance,
+    retrieved_at
+FROM weave.session_retrieval_context
+WHERE session_id = $1
+  AND thread_id IN (
+      SELECT id
+      FROM weave.threads
+      WHERE organization_id = $2
+  )
+ORDER BY turn_number DESC, relevance DESC, retrieved_at DESC
+LIMIT $3`;
+async function listSessionRetrievalContext(client, args) {
+    const result = await client.query({
+        text: exports.listSessionRetrievalContextQuery,
+        values: [args.sessionId, args.organizationId, args.resultLimit],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            sessionId: row[0],
+            turnNumber: row[1],
+            threadId: row[2],
+            relevance: row[3],
+            retrievedAt: row[4]
+        };
+    });
+}
+exports.deleteSessionRetrievalContextQuery = `-- name: DeleteSessionRetrievalContext :exec
+DELETE FROM weave.session_retrieval_context
+WHERE session_id = $1
+  AND thread_id IN (
+      SELECT id
+      FROM weave.threads
+      WHERE organization_id = $2
+  )`;
+async function deleteSessionRetrievalContext(client, args) {
+    await client.query({
+        text: exports.deleteSessionRetrievalContextQuery,
+        values: [args.sessionId, args.organizationId],
+        rowMode: "array"
+    });
+}
+exports.listApprovedReconcilePoolByOrganizationQuery = `-- name: ListApprovedReconcilePoolByOrganization :many
+SELECT
+    t.id AS thread_id,
+    t.text,
+    t.knowledge_type,
+    t.embedding::text AS embedding_text,
+    COALESCE(entity_data.entities, '{}'::text[]) AS entity_canonicals,
+    t.approved_at
+FROM weave.threads t
+LEFT JOIN LATERAL (
+    SELECT array_agg(DISTINCT e.canonical ORDER BY e.canonical) AS entities
+    FROM weave.thread_entities te
+    JOIN weave.entities e ON e.id = te.entity_id
+    WHERE te.thread_id = t.id
+) entity_data ON TRUE
+WHERE t.organization_id = $1
+  AND t.retrieval_status = 'THREAD_RETRIEVAL_STATUS_APPROVED'
+  AND t.embedding IS NOT NULL
+ORDER BY t.approved_at DESC, t.id ASC
+LIMIT $3 OFFSET $2`;
+async function listApprovedReconcilePoolByOrganization(client, args) {
+    const result = await client.query({
+        text: exports.listApprovedReconcilePoolByOrganizationQuery,
+        values: [args.organizationId, args.pageOffset, args.pageSize],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            threadId: row[0],
+            text: row[1],
+            knowledgeType: row[2],
+            embeddingText: row[3],
+            entityCanonicals: row[4],
+            approvedAt: row[5]
+        };
+    });
+}