weave-typescript 0.27.0 → 0.28.0

package/dist/weavesql/weavedb/retrieval_sql.js

@@ -0,0 +1,769 @@
+"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.searchApprovedThreadsSemanticByUserPermissionsQuery = exports.searchApprovedThreadsSemanticQuery = exports.refreshThreadReinforcementScoresQuery = void 0;
+exports.refreshThreadReinforcementScores = refreshThreadReinforcementScores;
+exports.searchApprovedThreadsSemantic = searchApprovedThreadsSemantic;
+exports.searchApprovedThreadsSemanticByUserPermissions = searchApprovedThreadsSemanticByUserPermissions;
+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.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]
+        };
+    });
+}