weave-typescript 0.27.0 → 0.28.0

package/dist/weavesql/weavedb/ingestion_sql.js

@@ -0,0 +1,2503 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upsertFacetConfigQuery = exports.listActiveFacetConfigsQuery = exports.listFacetConfigsQuery = exports.syncOrganizationIngestionReasoningDefaultsQuery = exports.upsertOrganizationIngestionSettingsQuery = exports.getOrganizationIngestionSettingsQuery = exports.ensureOrganizationIngestionSettingsQuery = exports.listEntitiesByThreadQuery = exports.upsertEntityRelationshipQuery = exports.upsertThreadEntityQuery = exports.upsertEntityQuery = exports.listThreadActivityByThreadQuery = exports.createThreadActivityQuery = exports.listThreadReconciliationByPendingThreadQuery = exports.upsertThreadReconciliationQuery = exports.deleteThreadReconciliationByPendingThreadQuery = exports.getIngestionRunThreadCountsQuery = exports.listThreadsByIDsQuery = exports.listThreadsBySupersedesQuery = exports.markThreadsSupersededQuery = exports.bulkRejectThreadsQuery = exports.rejectThreadQuery = exports.bulkApproveThreadsQuery = exports.approveThreadQuery = exports.editPendingThreadQuery = exports.updateThreadClassificationQuery = exports.promoteThreadNextEmbeddingsByOrganizationQuery = exports.setThreadNextEmbeddingQuery = exports.updateThreadEmbeddingQuery = exports.listPendingThreadsByOrganizationQuery = exports.listPendingThreadsByRunQuery = exports.listThreadsByIngestionRunQuery = exports.getThreadByOrganizationAndIDQuery = exports.createThreadQuery = exports.listDocumentTagsByDocumentIDQuery = exports.createDocumentTagQuery = exports.deleteDocumentTagsByDocumentIDQuery = exports.listIngestionHistoryQuery = exports.listIngestionRunsByDocumentQuery = exports.listIngestionRunsByOrganizationQuery = exports.updateIngestionRunStateQuery = exports.getIngestionRunByOrganizationAndIDQuery = exports.createIngestionRunQuery = exports.getDatabaseConfigQuery = exports.listDocumentsByOrganizationQuery = exports.setDocumentStatusQuery = exports.setDocumentParseResultQuery = exports.getDocumentByOrganizationAndFingerprintQuery = exports.getDocumentByOrganizationAndIDQuery = exports.createDocumentQuery = void 0;
+exports.deactivateFacetConfigQuery = void 0;
+exports.createDocument = createDocument;
+exports.getDocumentByOrganizationAndID = getDocumentByOrganizationAndID;
+exports.getDocumentByOrganizationAndFingerprint = getDocumentByOrganizationAndFingerprint;
+exports.setDocumentParseResult = setDocumentParseResult;
+exports.setDocumentStatus = setDocumentStatus;
+exports.listDocumentsByOrganization = listDocumentsByOrganization;
+exports.getDatabaseConfig = getDatabaseConfig;
+exports.createIngestionRun = createIngestionRun;
+exports.getIngestionRunByOrganizationAndID = getIngestionRunByOrganizationAndID;
+exports.updateIngestionRunState = updateIngestionRunState;
+exports.listIngestionRunsByOrganization = listIngestionRunsByOrganization;
+exports.listIngestionRunsByDocument = listIngestionRunsByDocument;
+exports.listIngestionHistory = listIngestionHistory;
+exports.deleteDocumentTagsByDocumentID = deleteDocumentTagsByDocumentID;
+exports.createDocumentTag = createDocumentTag;
+exports.listDocumentTagsByDocumentID = listDocumentTagsByDocumentID;
+exports.createThread = createThread;
+exports.getThreadByOrganizationAndID = getThreadByOrganizationAndID;
+exports.listThreadsByIngestionRun = listThreadsByIngestionRun;
+exports.listPendingThreadsByRun = listPendingThreadsByRun;
+exports.listPendingThreadsByOrganization = listPendingThreadsByOrganization;
+exports.updateThreadEmbedding = updateThreadEmbedding;
+exports.setThreadNextEmbedding = setThreadNextEmbedding;
+exports.updateThreadClassification = updateThreadClassification;
+exports.editPendingThread = editPendingThread;
+exports.approveThread = approveThread;
+exports.bulkApproveThreads = bulkApproveThreads;
+exports.rejectThread = rejectThread;
+exports.bulkRejectThreads = bulkRejectThreads;
+exports.listThreadsBySupersedes = listThreadsBySupersedes;
+exports.listThreadsByIDs = listThreadsByIDs;
+exports.getIngestionRunThreadCounts = getIngestionRunThreadCounts;
+exports.deleteThreadReconciliationByPendingThread = deleteThreadReconciliationByPendingThread;
+exports.upsertThreadReconciliation = upsertThreadReconciliation;
+exports.listThreadReconciliationByPendingThread = listThreadReconciliationByPendingThread;
+exports.createThreadActivity = createThreadActivity;
+exports.listThreadActivityByThread = listThreadActivityByThread;
+exports.upsertEntity = upsertEntity;
+exports.upsertThreadEntity = upsertThreadEntity;
+exports.upsertEntityRelationship = upsertEntityRelationship;
+exports.listEntitiesByThread = listEntitiesByThread;
+exports.ensureOrganizationIngestionSettings = ensureOrganizationIngestionSettings;
+exports.getOrganizationIngestionSettings = getOrganizationIngestionSettings;
+exports.upsertOrganizationIngestionSettings = upsertOrganizationIngestionSettings;
+exports.syncOrganizationIngestionReasoningDefaults = syncOrganizationIngestionReasoningDefaults;
+exports.listFacetConfigs = listFacetConfigs;
+exports.listActiveFacetConfigs = listActiveFacetConfigs;
+exports.upsertFacetConfig = upsertFacetConfig;
+exports.deactivateFacetConfig = deactivateFacetConfig;
+exports.createDocumentQuery = `-- name: CreateDocument :one
+INSERT INTO weave.documents (
+    id,
+    organization_id,
+    filename,
+    mime_type,
+    fingerprint,
+    storage_ref,
+    status,
+    scope,
+    sensitivity_tags,
+    uploaded_by_user_id,
+    metadata
+) VALUES (
+    $1,
+    $2,
+    $3,
+    $4,
+    $5,
+    $6,
+    $7,
+    $8,
+    $9,
+    $10,
+    $11
+)
+RETURNING
+    id,
+    organization_id,
+    filename,
+    mime_type,
+    parser_name,
+    fingerprint,
+    storage_ref,
+    status,
+    scope,
+    sensitivity_tags,
+    uploaded_by_user_id,
+    uploaded_at,
+    updated_at,
+    page_count,
+    char_count,
+    metadata`;
+async function createDocument(client, args) {
+    const result = await client.query({
+        text: exports.createDocumentQuery,
+        values: [args.id, args.organizationId, args.filename, args.mimeType, args.fingerprint, args.storageRef, args.status, args.scope, args.sensitivityTags, args.uploadedByUserId, args.metadata],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        filename: row[2],
+        mimeType: row[3],
+        parserName: row[4],
+        fingerprint: row[5],
+        storageRef: row[6],
+        status: row[7],
+        scope: row[8],
+        sensitivityTags: row[9],
+        uploadedByUserId: row[10],
+        uploadedAt: row[11],
+        updatedAt: row[12],
+        pageCount: row[13],
+        charCount: row[14],
+        metadata: row[15]
+    };
+}
+exports.getDocumentByOrganizationAndIDQuery = `-- name: GetDocumentByOrganizationAndID :one
+SELECT
+    id,
+    organization_id,
+    filename,
+    mime_type,
+    parser_name,
+    fingerprint,
+    storage_ref,
+    status,
+    scope,
+    sensitivity_tags,
+    uploaded_by_user_id,
+    uploaded_at,
+    updated_at,
+    page_count,
+    char_count,
+    metadata
+FROM weave.documents
+WHERE organization_id = $1
+  AND id = $2`;
+async function getDocumentByOrganizationAndID(client, args) {
+    const result = await client.query({
+        text: exports.getDocumentByOrganizationAndIDQuery,
+        values: [args.organizationId, args.id],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        filename: row[2],
+        mimeType: row[3],
+        parserName: row[4],
+        fingerprint: row[5],
+        storageRef: row[6],
+        status: row[7],
+        scope: row[8],
+        sensitivityTags: row[9],
+        uploadedByUserId: row[10],
+        uploadedAt: row[11],
+        updatedAt: row[12],
+        pageCount: row[13],
+        charCount: row[14],
+        metadata: row[15]
+    };
+}
+exports.getDocumentByOrganizationAndFingerprintQuery = `-- name: GetDocumentByOrganizationAndFingerprint :one
+SELECT
+    id,
+    organization_id,
+    filename,
+    mime_type,
+    parser_name,
+    fingerprint,
+    storage_ref,
+    status,
+    scope,
+    sensitivity_tags,
+    uploaded_by_user_id,
+    uploaded_at,
+    updated_at,
+    page_count,
+    char_count,
+    metadata
+FROM weave.documents
+WHERE organization_id = $1
+  AND fingerprint = $2`;
+async function getDocumentByOrganizationAndFingerprint(client, args) {
+    const result = await client.query({
+        text: exports.getDocumentByOrganizationAndFingerprintQuery,
+        values: [args.organizationId, args.fingerprint],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        filename: row[2],
+        mimeType: row[3],
+        parserName: row[4],
+        fingerprint: row[5],
+        storageRef: row[6],
+        status: row[7],
+        scope: row[8],
+        sensitivityTags: row[9],
+        uploadedByUserId: row[10],
+        uploadedAt: row[11],
+        updatedAt: row[12],
+        pageCount: row[13],
+        charCount: row[14],
+        metadata: row[15]
+    };
+}
+exports.setDocumentParseResultQuery = `-- name: SetDocumentParseResult :one
+UPDATE weave.documents
+SET
+    parser_name = $1,
+    status = $2,
+    page_count = $3,
+    char_count = $4,
+    updated_at = now()
+WHERE organization_id = $5
+  AND id = $6
+RETURNING
+    id,
+    organization_id,
+    filename,
+    mime_type,
+    parser_name,
+    fingerprint,
+    storage_ref,
+    status,
+    scope,
+    sensitivity_tags,
+    uploaded_by_user_id,
+    uploaded_at,
+    updated_at,
+    page_count,
+    char_count,
+    metadata`;
+async function setDocumentParseResult(client, args) {
+    const result = await client.query({
+        text: exports.setDocumentParseResultQuery,
+        values: [args.parserName, args.status, args.pageCount, args.charCount, args.organizationId, args.id],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        filename: row[2],
+        mimeType: row[3],
+        parserName: row[4],
+        fingerprint: row[5],
+        storageRef: row[6],
+        status: row[7],
+        scope: row[8],
+        sensitivityTags: row[9],
+        uploadedByUserId: row[10],
+        uploadedAt: row[11],
+        updatedAt: row[12],
+        pageCount: row[13],
+        charCount: row[14],
+        metadata: row[15]
+    };
+}
+exports.setDocumentStatusQuery = `-- name: SetDocumentStatus :one
+UPDATE weave.documents
+SET
+    status = $1,
+    updated_at = now()
+WHERE organization_id = $2
+  AND id = $3
+RETURNING
+    id,
+    organization_id,
+    filename,
+    mime_type,
+    parser_name,
+    fingerprint,
+    storage_ref,
+    status,
+    scope,
+    sensitivity_tags,
+    uploaded_by_user_id,
+    uploaded_at,
+    updated_at,
+    page_count,
+    char_count,
+    metadata`;
+async function setDocumentStatus(client, args) {
+    const result = await client.query({
+        text: exports.setDocumentStatusQuery,
+        values: [args.status, args.organizationId, args.id],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        filename: row[2],
+        mimeType: row[3],
+        parserName: row[4],
+        fingerprint: row[5],
+        storageRef: row[6],
+        status: row[7],
+        scope: row[8],
+        sensitivityTags: row[9],
+        uploadedByUserId: row[10],
+        uploadedAt: row[11],
+        updatedAt: row[12],
+        pageCount: row[13],
+        charCount: row[14],
+        metadata: row[15]
+    };
+}
+exports.listDocumentsByOrganizationQuery = `-- name: ListDocumentsByOrganization :many
+SELECT
+    id,
+    organization_id,
+    filename,
+    mime_type,
+    parser_name,
+    fingerprint,
+    storage_ref,
+    status,
+    scope,
+    sensitivity_tags,
+    uploaded_by_user_id,
+    uploaded_at,
+    updated_at,
+    page_count,
+    char_count,
+    metadata
+FROM weave.documents
+WHERE organization_id = $1
+ORDER BY uploaded_at DESC
+LIMIT $3 OFFSET $2`;
+async function listDocumentsByOrganization(client, args) {
+    const result = await client.query({
+        text: exports.listDocumentsByOrganizationQuery,
+        values: [args.organizationId, args.pageOffset, args.pageSize],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            organizationId: row[1],
+            filename: row[2],
+            mimeType: row[3],
+            parserName: row[4],
+            fingerprint: row[5],
+            storageRef: row[6],
+            status: row[7],
+            scope: row[8],
+            sensitivityTags: row[9],
+            uploadedByUserId: row[10],
+            uploadedAt: row[11],
+            updatedAt: row[12],
+            pageCount: row[13],
+            charCount: row[14],
+            metadata: row[15]
+        };
+    });
+}
+exports.getDatabaseConfigQuery = `-- name: GetDatabaseConfig :one
+SELECT
+    id,
+    embedding_dimension,
+    deployment_mode,
+    created_at,
+    updated_at
+FROM weave.database_config
+WHERE id = 1`;
+async function getDatabaseConfig(client) {
+    const result = await client.query({
+        text: exports.getDatabaseConfigQuery,
+        values: [],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        embeddingDimension: row[1],
+        deploymentMode: row[2],
+        createdAt: row[3],
+        updatedAt: row[4]
+    };
+}
+exports.createIngestionRunQuery = `-- name: CreateIngestionRun :one
+INSERT INTO weave.ingestion_runs (
+    id,
+    organization_id,
+    document_id,
+    status,
+    reasoning_model_id,
+    reasoning_provider_configuration_id,
+    embedding_model_id,
+    embedding_provider_configuration_id,
+    embedding_dimensions
+) VALUES (
+    $1,
+    $2,
+    $3,
+    $4,
+    $5,
+    $6,
+    $7,
+    $8,
+    $9
+)
+RETURNING
+    id,
+    organization_id,
+    document_id,
+    status,
+    reasoning_model_id,
+    reasoning_provider_configuration_id,
+    embedding_model_id,
+    embedding_provider_configuration_id,
+    embedding_dimensions,
+    thread_count,
+    pending_count,
+    approved_count,
+    rejected_count,
+    error,
+    token_usage,
+    started_at,
+    completed_at,
+    committed_at`;
+async function createIngestionRun(client, args) {
+    const result = await client.query({
+        text: exports.createIngestionRunQuery,
+        values: [args.id, args.organizationId, args.documentId, args.status, args.reasoningModelId, args.reasoningProviderConfigurationId, args.embeddingModelId, args.embeddingProviderConfigurationId, args.embeddingDimensions],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        documentId: row[2],
+        status: row[3],
+        reasoningModelId: row[4],
+        reasoningProviderConfigurationId: row[5],
+        embeddingModelId: row[6],
+        embeddingProviderConfigurationId: row[7],
+        embeddingDimensions: row[8],
+        threadCount: row[9],
+        pendingCount: row[10],
+        approvedCount: row[11],
+        rejectedCount: row[12],
+        error: row[13],
+        tokenUsage: row[14],
+        startedAt: row[15],
+        completedAt: row[16],
+        committedAt: row[17]
+    };
+}
+exports.getIngestionRunByOrganizationAndIDQuery = `-- name: GetIngestionRunByOrganizationAndID :one
+SELECT
+    id,
+    organization_id,
+    document_id,
+    status,
+    reasoning_model_id,
+    reasoning_provider_configuration_id,
+    embedding_model_id,
+    embedding_provider_configuration_id,
+    embedding_dimensions,
+    thread_count,
+    pending_count,
+    approved_count,
+    rejected_count,
+    error,
+    token_usage,
+    started_at,
+    completed_at,
+    committed_at
+FROM weave.ingestion_runs
+WHERE organization_id = $1
+  AND id = $2`;
+async function getIngestionRunByOrganizationAndID(client, args) {
+    const result = await client.query({
+        text: exports.getIngestionRunByOrganizationAndIDQuery,
+        values: [args.organizationId, args.id],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        documentId: row[2],
+        status: row[3],
+        reasoningModelId: row[4],
+        reasoningProviderConfigurationId: row[5],
+        embeddingModelId: row[6],
+        embeddingProviderConfigurationId: row[7],
+        embeddingDimensions: row[8],
+        threadCount: row[9],
+        pendingCount: row[10],
+        approvedCount: row[11],
+        rejectedCount: row[12],
+        error: row[13],
+        tokenUsage: row[14],
+        startedAt: row[15],
+        completedAt: row[16],
+        committedAt: row[17]
+    };
+}
+exports.updateIngestionRunStateQuery = `-- name: UpdateIngestionRunState :one
+UPDATE weave.ingestion_runs
+SET
+    status = $1,
+    thread_count = $2,
+    pending_count = $3,
+    approved_count = $4,
+    rejected_count = $5,
+    error = $6,
+    token_usage = $7,
+    completed_at = $8,
+    committed_at = $9
+WHERE id = $10
+  AND organization_id = $11
+RETURNING
+    id,
+    organization_id,
+    document_id,
+    status,
+    reasoning_model_id,
+    reasoning_provider_configuration_id,
+    embedding_model_id,
+    embedding_provider_configuration_id,
+    embedding_dimensions,
+    thread_count,
+    pending_count,
+    approved_count,
+    rejected_count,
+    error,
+    token_usage,
+    started_at,
+    completed_at,
+    committed_at`;
+async function updateIngestionRunState(client, args) {
+    const result = await client.query({
+        text: exports.updateIngestionRunStateQuery,
+        values: [args.status, args.threadCount, args.pendingCount, args.approvedCount, args.rejectedCount, args.error, args.tokenUsage, args.completedAt, args.committedAt, args.id, args.organizationId],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        documentId: row[2],
+        status: row[3],
+        reasoningModelId: row[4],
+        reasoningProviderConfigurationId: row[5],
+        embeddingModelId: row[6],
+        embeddingProviderConfigurationId: row[7],
+        embeddingDimensions: row[8],
+        threadCount: row[9],
+        pendingCount: row[10],
+        approvedCount: row[11],
+        rejectedCount: row[12],
+        error: row[13],
+        tokenUsage: row[14],
+        startedAt: row[15],
+        completedAt: row[16],
+        committedAt: row[17]
+    };
+}
+exports.listIngestionRunsByOrganizationQuery = `-- name: ListIngestionRunsByOrganization :many
+SELECT
+    id,
+    organization_id,
+    document_id,
+    status,
+    reasoning_model_id,
+    reasoning_provider_configuration_id,
+    embedding_model_id,
+    embedding_provider_configuration_id,
+    embedding_dimensions,
+    thread_count,
+    pending_count,
+    approved_count,
+    rejected_count,
+    error,
+    token_usage,
+    started_at,
+    completed_at,
+    committed_at
+FROM weave.ingestion_runs
+WHERE organization_id = $1
+ORDER BY started_at DESC
+LIMIT $3 OFFSET $2`;
+async function listIngestionRunsByOrganization(client, args) {
+    const result = await client.query({
+        text: exports.listIngestionRunsByOrganizationQuery,
+        values: [args.organizationId, args.pageOffset, args.pageSize],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            organizationId: row[1],
+            documentId: row[2],
+            status: row[3],
+            reasoningModelId: row[4],
+            reasoningProviderConfigurationId: row[5],
+            embeddingModelId: row[6],
+            embeddingProviderConfigurationId: row[7],
+            embeddingDimensions: row[8],
+            threadCount: row[9],
+            pendingCount: row[10],
+            approvedCount: row[11],
+            rejectedCount: row[12],
+            error: row[13],
+            tokenUsage: row[14],
+            startedAt: row[15],
+            completedAt: row[16],
+            committedAt: row[17]
+        };
+    });
+}
+exports.listIngestionRunsByDocumentQuery = `-- name: ListIngestionRunsByDocument :many
+SELECT
+    id,
+    organization_id,
+    document_id,
+    status,
+    reasoning_model_id,
+    reasoning_provider_configuration_id,
+    embedding_model_id,
+    embedding_provider_configuration_id,
+    embedding_dimensions,
+    thread_count,
+    pending_count,
+    approved_count,
+    rejected_count,
+    error,
+    token_usage,
+    started_at,
+    completed_at,
+    committed_at
+FROM weave.ingestion_runs
+WHERE organization_id = $1
+  AND document_id = $2
+ORDER BY started_at DESC`;
+async function listIngestionRunsByDocument(client, args) {
+    const result = await client.query({
+        text: exports.listIngestionRunsByDocumentQuery,
+        values: [args.organizationId, args.documentId],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            organizationId: row[1],
+            documentId: row[2],
+            status: row[3],
+            reasoningModelId: row[4],
+            reasoningProviderConfigurationId: row[5],
+            embeddingModelId: row[6],
+            embeddingProviderConfigurationId: row[7],
+            embeddingDimensions: row[8],
+            threadCount: row[9],
+            pendingCount: row[10],
+            approvedCount: row[11],
+            rejectedCount: row[12],
+            error: row[13],
+            tokenUsage: row[14],
+            startedAt: row[15],
+            completedAt: row[16],
+            committedAt: row[17]
+        };
+    });
+}
+exports.listIngestionHistoryQuery = `-- name: ListIngestionHistory :many
+SELECT
+    r.id AS ingestion_run_id,
+    d.id AS document_id,
+    d.filename AS document_name,
+    d.status AS document_status,
+    r.status AS ingestion_status,
+    r.thread_count,
+    r.pending_count,
+    r.approved_count,
+    r.rejected_count,
+    d.uploaded_at,
+    r.started_at,
+    r.completed_at,
+    r.committed_at
+FROM weave.ingestion_runs r
+JOIN weave.documents d ON d.id = r.document_id
+WHERE r.organization_id = $1
+ORDER BY r.started_at DESC
+LIMIT $3 OFFSET $2`;
+async function listIngestionHistory(client, args) {
+    const result = await client.query({
+        text: exports.listIngestionHistoryQuery,
+        values: [args.organizationId, args.pageOffset, args.pageSize],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            ingestionRunId: row[0],
+            documentId: row[1],
+            documentName: row[2],
+            documentStatus: row[3],
+            ingestionStatus: row[4],
+            threadCount: row[5],
+            pendingCount: row[6],
+            approvedCount: row[7],
+            rejectedCount: row[8],
+            uploadedAt: row[9],
+            startedAt: row[10],
+            completedAt: row[11],
+            committedAt: row[12]
+        };
+    });
+}
+exports.deleteDocumentTagsByDocumentIDQuery = `-- name: DeleteDocumentTagsByDocumentID :exec
+DELETE FROM weave.document_tags dt
+USING weave.documents d
+WHERE dt.document_id = d.id
+  AND d.organization_id = $1
+  AND dt.document_id = $2`;
+async function deleteDocumentTagsByDocumentID(client, args) {
+    await client.query({
+        text: exports.deleteDocumentTagsByDocumentIDQuery,
+        values: [args.organizationId, args.documentId],
+        rowMode: "array"
+    });
+}
+exports.createDocumentTagQuery = `-- name: CreateDocumentTag :one
+INSERT INTO weave.document_tags (
+    document_id,
+    tag,
+    confidence
+) VALUES (
+    $1,
+    $2,
+    $3
+)
+RETURNING document_id, tag, confidence`;
+async function createDocumentTag(client, args) {
+    const result = await client.query({
+        text: exports.createDocumentTagQuery,
+        values: [args.documentId, args.tag, args.confidence],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        documentId: row[0],
+        tag: row[1],
+        confidence: row[2]
+    };
+}
+exports.listDocumentTagsByDocumentIDQuery = `-- name: ListDocumentTagsByDocumentID :many
+SELECT document_id, tag, confidence
+FROM weave.document_tags dt
+JOIN weave.documents d ON d.id = dt.document_id
+WHERE d.organization_id = $1
+  AND dt.document_id = $2
+ORDER BY confidence DESC, tag ASC`;
+async function listDocumentTagsByDocumentID(client, args) {
+    const result = await client.query({
+        text: exports.listDocumentTagsByDocumentIDQuery,
+        values: [args.organizationId, args.documentId],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            documentId: row[0],
+            tag: row[1],
+            confidence: row[2]
+        };
+    });
+}
+exports.createThreadQuery = `-- name: CreateThread :one
+INSERT INTO weave.threads (
+    id,
+    organization_id,
+    document_id,
+    ingestion_run_id,
+    text,
+    knowledge_type,
+    facet_fields,
+    confidence,
+    temporal_validity,
+    classification,
+    retrieval_status,
+    source_location,
+    metadata
+) VALUES (
+    $1,
+    $2,
+    $3,
+    $4,
+    $5,
+    $6,
+    $7,
+    $8,
+    $9,
+    $10,
+    $11,
+    $12,
+    $13
+)
+RETURNING
+    id,
+    organization_id,
+    document_id,
+    ingestion_run_id,
+    text,
+    text_original,
+    knowledge_type,
+    facet_fields,
+    confidence,
+    temporal_validity,
+    classification,
+    retrieval_status,
+    source_location,
+    superseded_by,
+    supersedes,
+    cluster_id,
+    extracted_at,
+    approved_at,
+    approved_by_user_id,
+    edited,
+    metadata`;
+async function createThread(client, args) {
+    const result = await client.query({
+        text: exports.createThreadQuery,
+        values: [args.id, args.organizationId, args.documentId, args.ingestionRunId, args.text, args.knowledgeType, args.facetFields, args.confidence, args.temporalValidity, args.classification, args.retrievalStatus, args.sourceLocation, args.metadata],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        documentId: row[2],
+        ingestionRunId: row[3],
+        text: row[4],
+        textOriginal: row[5],
+        knowledgeType: row[6],
+        facetFields: row[7],
+        confidence: row[8],
+        temporalValidity: row[9],
+        classification: row[10],
+        retrievalStatus: row[11],
+        sourceLocation: row[12],
+        supersededBy: row[13],
+        supersedes: row[14],
+        clusterId: row[15],
+        extractedAt: row[16],
+        approvedAt: row[17],
+        approvedByUserId: row[18],
+        edited: row[19],
+        metadata: row[20]
+    };
+}
+exports.getThreadByOrganizationAndIDQuery = `-- name: GetThreadByOrganizationAndID :one
+SELECT
+    t.id,
+    t.organization_id,
+    t.document_id,
+    d.filename AS document_name,
+    t.ingestion_run_id,
+    t.text,
+    t.text_original,
+    t.knowledge_type,
+    t.facet_fields,
+    t.confidence,
+    t.temporal_validity,
+    t.classification,
+    t.retrieval_status,
+    t.source_location,
+    t.superseded_by,
+    t.supersedes,
+    t.cluster_id,
+    t.extracted_at,
+    t.approved_at,
+    t.approved_by_user_id,
+    t.edited,
+    t.metadata
+FROM weave.threads t
+JOIN weave.documents d ON d.id = t.document_id
+WHERE t.organization_id = $1
+  AND t.id = $2`;
+async function getThreadByOrganizationAndID(client, args) {
+    const result = await client.query({
+        text: exports.getThreadByOrganizationAndIDQuery,
+        values: [args.organizationId, args.id],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        documentId: row[2],
+        documentName: row[3],
+        ingestionRunId: row[4],
+        text: row[5],
+        textOriginal: row[6],
+        knowledgeType: row[7],
+        facetFields: row[8],
+        confidence: row[9],
+        temporalValidity: row[10],
+        classification: row[11],
+        retrievalStatus: row[12],
+        sourceLocation: row[13],
+        supersededBy: row[14],
+        supersedes: row[15],
+        clusterId: row[16],
+        extractedAt: row[17],
+        approvedAt: row[18],
+        approvedByUserId: row[19],
+        edited: row[20],
+        metadata: row[21]
+    };
+}
+exports.listThreadsByIngestionRunQuery = `-- name: ListThreadsByIngestionRun :many
+SELECT
+    t.id,
+    t.organization_id,
+    t.document_id,
+    d.filename AS document_name,
+    t.ingestion_run_id,
+    t.text,
+    t.text_original,
+    t.knowledge_type,
+    t.facet_fields,
+    t.confidence,
+    t.temporal_validity,
+    t.classification,
+    t.retrieval_status,
+    t.source_location,
+    t.superseded_by,
+    t.supersedes,
+    t.cluster_id,
+    t.extracted_at,
+    t.approved_at,
+    t.approved_by_user_id,
+    t.edited,
+    t.metadata
+FROM weave.threads t
+JOIN weave.documents d ON d.id = t.document_id
+WHERE t.organization_id = $1
+  AND t.ingestion_run_id = $2
+ORDER BY t.extracted_at ASC, t.id ASC`;
+async function listThreadsByIngestionRun(client, args) {
+    const result = await client.query({
+        text: exports.listThreadsByIngestionRunQuery,
+        values: [args.organizationId, args.ingestionRunId],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            organizationId: row[1],
+            documentId: row[2],
+            documentName: row[3],
+            ingestionRunId: row[4],
+            text: row[5],
+            textOriginal: row[6],
+            knowledgeType: row[7],
+            facetFields: row[8],
+            confidence: row[9],
+            temporalValidity: row[10],
+            classification: row[11],
+            retrievalStatus: row[12],
+            sourceLocation: row[13],
+            supersededBy: row[14],
+            supersedes: row[15],
+            clusterId: row[16],
+            extractedAt: row[17],
+            approvedAt: row[18],
+            approvedByUserId: row[19],
+            edited: row[20],
+            metadata: row[21]
+        };
+    });
+}
+exports.listPendingThreadsByRunQuery = `-- name: ListPendingThreadsByRun :many
+SELECT
+    id,
+    organization_id,
+    document_id,
+    ingestion_run_id,
+    text,
+    text_original,
+    knowledge_type,
+    facet_fields,
+    confidence,
+    temporal_validity,
+    classification,
+    retrieval_status,
+    source_location,
+    superseded_by,
+    supersedes,
+    cluster_id,
+    extracted_at,
+    approved_at,
+    approved_by_user_id,
+    edited,
+    metadata
+FROM weave.threads
+WHERE organization_id = $1
+  AND ingestion_run_id = $2
+  AND retrieval_status = 'THREAD_RETRIEVAL_STATUS_PENDING'
+ORDER BY extracted_at ASC, id ASC`;
+async function listPendingThreadsByRun(client, args) {
+    const result = await client.query({
+        text: exports.listPendingThreadsByRunQuery,
+        values: [args.organizationId, args.ingestionRunId],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            organizationId: row[1],
+            documentId: row[2],
+            ingestionRunId: row[3],
+            text: row[4],
+            textOriginal: row[5],
+            knowledgeType: row[6],
+            facetFields: row[7],
+            confidence: row[8],
+            temporalValidity: row[9],
+            classification: row[10],
+            retrievalStatus: row[11],
+            sourceLocation: row[12],
+            supersededBy: row[13],
+            supersedes: row[14],
+            clusterId: row[15],
+            extractedAt: row[16],
+            approvedAt: row[17],
+            approvedByUserId: row[18],
+            edited: row[19],
+            metadata: row[20]
+        };
+    });
+}
+exports.listPendingThreadsByOrganizationQuery = `-- name: ListPendingThreadsByOrganization :many
+SELECT
+    t.id,
+    t.organization_id,
+    t.document_id,
+    d.filename AS document_name,
+    t.ingestion_run_id,
+    t.text,
+    t.text_original,
+    t.knowledge_type,
+    t.facet_fields,
+    t.confidence,
+    t.temporal_validity,
+    t.classification,
+    t.retrieval_status,
+    t.source_location,
+    t.superseded_by,
+    t.supersedes,
+    t.cluster_id,
+    t.extracted_at,
+    t.approved_at,
+    t.approved_by_user_id,
+    t.edited,
+    t.metadata
+FROM weave.threads t
+JOIN weave.documents d ON d.id = t.document_id
+WHERE t.organization_id = $1
+  AND t.retrieval_status = 'THREAD_RETRIEVAL_STATUS_PENDING'
+ORDER BY t.extracted_at DESC, t.id DESC
+LIMIT $3 OFFSET $2`;
+async function listPendingThreadsByOrganization(client, args) {
+    const result = await client.query({
+        text: exports.listPendingThreadsByOrganizationQuery,
+        values: [args.organizationId, args.pageOffset, args.pageSize],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            organizationId: row[1],
+            documentId: row[2],
+            documentName: row[3],
+            ingestionRunId: row[4],
+            text: row[5],
+            textOriginal: row[6],
+            knowledgeType: row[7],
+            facetFields: row[8],
+            confidence: row[9],
+            temporalValidity: row[10],
+            classification: row[11],
+            retrievalStatus: row[12],
+            sourceLocation: row[13],
+            supersededBy: row[14],
+            supersedes: row[15],
+            clusterId: row[16],
+            extractedAt: row[17],
+            approvedAt: row[18],
+            approvedByUserId: row[19],
+            edited: row[20],
+            metadata: row[21]
+        };
+    });
+}
+exports.updateThreadEmbeddingQuery = `-- name: UpdateThreadEmbedding :one
+UPDATE weave.threads
+SET
+    embedding = $1::vector
+WHERE organization_id = $2
+  AND id = $3
+  AND retrieval_status = 'THREAD_RETRIEVAL_STATUS_PENDING'
+RETURNING
+    id,
+    organization_id,
+    document_id,
+    ingestion_run_id,
+    text,
+    text_original,
+    knowledge_type,
+    facet_fields,
+    confidence,
+    temporal_validity,
+    classification,
+    retrieval_status,
+    source_location,
+    superseded_by,
+    supersedes,
+    cluster_id,
+    extracted_at,
+    approved_at,
+    approved_by_user_id,
+    edited,
+    metadata`;
+async function updateThreadEmbedding(client, args) {
+    const result = await client.query({
+        text: exports.updateThreadEmbeddingQuery,
+        values: [args.embedding, args.organizationId, args.id],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        documentId: row[2],
+        ingestionRunId: row[3],
+        text: row[4],
+        textOriginal: row[5],
+        knowledgeType: row[6],
+        facetFields: row[7],
+        confidence: row[8],
+        temporalValidity: row[9],
+        classification: row[10],
+        retrievalStatus: row[11],
+        sourceLocation: row[12],
+        supersededBy: row[13],
+        supersedes: row[14],
+        clusterId: row[15],
+        extractedAt: row[16],
+        approvedAt: row[17],
+        approvedByUserId: row[18],
+        edited: row[19],
+        metadata: row[20]
+    };
+}
+exports.setThreadNextEmbeddingQuery = `-- name: SetThreadNextEmbedding :one
+UPDATE weave.threads
+SET
+    embedding_next = $1::vector
+WHERE organization_id = $2
+  AND id = $3
+  AND retrieval_status = 'THREAD_RETRIEVAL_STATUS_PENDING'
+RETURNING
+    id,
+    organization_id,
+    document_id,
+    ingestion_run_id,
+    text,
+    text_original,
+    knowledge_type,
+    facet_fields,
+    confidence,
+    temporal_validity,
+    classification,
+    retrieval_status,
+    source_location,
+    superseded_by,
+    supersedes,
+    cluster_id,
+    extracted_at,
+    approved_at,
+    approved_by_user_id,
+    edited,
+    metadata`;
+async function setThreadNextEmbedding(client, args) {
+    const result = await client.query({
+        text: exports.setThreadNextEmbeddingQuery,
+        values: [args.embedding, args.organizationId, args.id],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        documentId: row[2],
+        ingestionRunId: row[3],
+        text: row[4],
+        textOriginal: row[5],
+        knowledgeType: row[6],
+        facetFields: row[7],
+        confidence: row[8],
+        temporalValidity: row[9],
+        classification: row[10],
+        retrievalStatus: row[11],
+        sourceLocation: row[12],
+        supersededBy: row[13],
+        supersedes: row[14],
+        clusterId: row[15],
+        extractedAt: row[16],
+        approvedAt: row[17],
+        approvedByUserId: row[18],
+        edited: row[19],
+        metadata: row[20]
+    };
+}
+exports.promoteThreadNextEmbeddingsByOrganizationQuery = `-- name: PromoteThreadNextEmbeddingsByOrganization :execrows
+UPDATE weave.threads
+SET
+    embedding = embedding_next,
+    embedding_next = NULL
+WHERE organization_id = $1
+  AND embedding_next IS NOT NULL`;
+exports.updateThreadClassificationQuery = `-- name: UpdateThreadClassification :one
+UPDATE weave.threads
+SET
+    classification = $1,
+    supersedes = $2
+WHERE organization_id = $3
+  AND id = $4
+RETURNING
+    id,
+    organization_id,
+    document_id,
+    ingestion_run_id,
+    text,
+    text_original,
+    knowledge_type,
+    facet_fields,
+    confidence,
+    temporal_validity,
+    classification,
+    retrieval_status,
+    source_location,
+    superseded_by,
+    supersedes,
+    cluster_id,
+    extracted_at,
+    approved_at,
+    approved_by_user_id,
+    edited,
+    metadata`;
+async function updateThreadClassification(client, args) {
+    const result = await client.query({
+        text: exports.updateThreadClassificationQuery,
+        values: [args.classification, args.supersedes, args.organizationId, args.id],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        documentId: row[2],
+        ingestionRunId: row[3],
+        text: row[4],
+        textOriginal: row[5],
+        knowledgeType: row[6],
+        facetFields: row[7],
+        confidence: row[8],
+        temporalValidity: row[9],
+        classification: row[10],
+        retrievalStatus: row[11],
+        sourceLocation: row[12],
+        supersededBy: row[13],
+        supersedes: row[14],
+        clusterId: row[15],
+        extractedAt: row[16],
+        approvedAt: row[17],
+        approvedByUserId: row[18],
+        edited: row[19],
+        metadata: row[20]
+    };
+}
+exports.editPendingThreadQuery = `-- name: EditPendingThread :one
+UPDATE weave.threads
+SET
+    text_original = CASE
+        WHEN text_original IS NULL OR text_original = '' THEN text
+        ELSE text_original
+    END,
+    text = $1,
+    edited = TRUE
+WHERE id = $2
+  AND organization_id = $3
+  AND retrieval_status = 'THREAD_RETRIEVAL_STATUS_PENDING'
+RETURNING
+    id,
+    organization_id,
+    document_id,
+    ingestion_run_id,
+    text,
+    text_original,
+    knowledge_type,
+    facet_fields,
+    confidence,
+    temporal_validity,
+    classification,
+    retrieval_status,
+    source_location,
+    superseded_by,
+    supersedes,
+    cluster_id,
+    extracted_at,
+    approved_at,
+    approved_by_user_id,
+    edited,
+    metadata`;
+async function editPendingThread(client, args) {
+    const result = await client.query({
+        text: exports.editPendingThreadQuery,
+        values: [args.text, args.id, args.organizationId],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        documentId: row[2],
+        ingestionRunId: row[3],
+        text: row[4],
+        textOriginal: row[5],
+        knowledgeType: row[6],
+        facetFields: row[7],
+        confidence: row[8],
+        temporalValidity: row[9],
+        classification: row[10],
+        retrievalStatus: row[11],
+        sourceLocation: row[12],
+        supersededBy: row[13],
+        supersedes: row[14],
+        clusterId: row[15],
+        extractedAt: row[16],
+        approvedAt: row[17],
+        approvedByUserId: row[18],
+        edited: row[19],
+        metadata: row[20]
+    };
+}
+exports.approveThreadQuery = `-- name: ApproveThread :one
+UPDATE weave.threads
+SET
+    retrieval_status = 'THREAD_RETRIEVAL_STATUS_APPROVED',
+    approved_at = now(),
+    approved_by_user_id = $1,
+    embedding = COALESCE($2::vector, embedding),
+    embedding_next = NULL
+WHERE id = $3
+  AND organization_id = $4
+  AND retrieval_status = 'THREAD_RETRIEVAL_STATUS_PENDING'
+RETURNING
+    id,
+    organization_id,
+    document_id,
+    ingestion_run_id,
+    text,
+    text_original,
+    knowledge_type,
+    facet_fields,
+    confidence,
+    temporal_validity,
+    classification,
+    retrieval_status,
+    source_location,
+    superseded_by,
+    supersedes,
+    cluster_id,
+    extracted_at,
+    approved_at,
+    approved_by_user_id,
+    edited,
+    metadata`;
+async function approveThread(client, args) {
+    const result = await client.query({
+        text: exports.approveThreadQuery,
+        values: [args.approvedByUserId, args.embedding, args.id, args.organizationId],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        documentId: row[2],
+        ingestionRunId: row[3],
+        text: row[4],
+        textOriginal: row[5],
+        knowledgeType: row[6],
+        facetFields: row[7],
+        confidence: row[8],
+        temporalValidity: row[9],
+        classification: row[10],
+        retrievalStatus: row[11],
+        sourceLocation: row[12],
+        supersededBy: row[13],
+        supersedes: row[14],
+        clusterId: row[15],
+        extractedAt: row[16],
+        approvedAt: row[17],
+        approvedByUserId: row[18],
+        edited: row[19],
+        metadata: row[20]
+    };
+}
+exports.bulkApproveThreadsQuery = `-- name: BulkApproveThreads :many
+UPDATE weave.threads
+SET
+    retrieval_status = 'THREAD_RETRIEVAL_STATUS_APPROVED',
+    approved_at = now(),
+    approved_by_user_id = $1,
+    embedding_next = NULL
+WHERE organization_id = $2
+  AND ingestion_run_id = $3
+  AND id = ANY($4::uuid[])
+  AND retrieval_status = 'THREAD_RETRIEVAL_STATUS_PENDING'
+RETURNING
+    id,
+    organization_id,
+    document_id,
+    ingestion_run_id,
+    text,
+    text_original,
+    knowledge_type,
+    facet_fields,
+    confidence,
+    temporal_validity,
+    classification,
+    retrieval_status,
+    source_location,
+    superseded_by,
+    supersedes,
+    cluster_id,
+    extracted_at,
+    approved_at,
+    approved_by_user_id,
+    edited,
+    metadata`;
+async function bulkApproveThreads(client, args) {
+    const result = await client.query({
+        text: exports.bulkApproveThreadsQuery,
+        values: [args.approvedByUserId, args.organizationId, args.ingestionRunId, args.threadIds],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            organizationId: row[1],
+            documentId: row[2],
+            ingestionRunId: row[3],
+            text: row[4],
+            textOriginal: row[5],
+            knowledgeType: row[6],
+            facetFields: row[7],
+            confidence: row[8],
+            temporalValidity: row[9],
+            classification: row[10],
+            retrievalStatus: row[11],
+            sourceLocation: row[12],
+            supersededBy: row[13],
+            supersedes: row[14],
+            clusterId: row[15],
+            extractedAt: row[16],
+            approvedAt: row[17],
+            approvedByUserId: row[18],
+            edited: row[19],
+            metadata: row[20]
+        };
+    });
+}
+exports.rejectThreadQuery = `-- name: RejectThread :one
+UPDATE weave.threads
+SET
+    retrieval_status = 'THREAD_RETRIEVAL_STATUS_REJECTED'
+WHERE organization_id = $1
+  AND id = $2
+  AND retrieval_status = 'THREAD_RETRIEVAL_STATUS_PENDING'
+RETURNING
+    id,
+    organization_id,
+    document_id,
+    ingestion_run_id,
+    text,
+    text_original,
+    knowledge_type,
+    facet_fields,
+    confidence,
+    temporal_validity,
+    classification,
+    retrieval_status,
+    source_location,
+    superseded_by,
+    supersedes,
+    cluster_id,
+    extracted_at,
+    approved_at,
+    approved_by_user_id,
+    edited,
+    metadata`;
+async function rejectThread(client, args) {
+    const result = await client.query({
+        text: exports.rejectThreadQuery,
+        values: [args.organizationId, args.id],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        documentId: row[2],
+        ingestionRunId: row[3],
+        text: row[4],
+        textOriginal: row[5],
+        knowledgeType: row[6],
+        facetFields: row[7],
+        confidence: row[8],
+        temporalValidity: row[9],
+        classification: row[10],
+        retrievalStatus: row[11],
+        sourceLocation: row[12],
+        supersededBy: row[13],
+        supersedes: row[14],
+        clusterId: row[15],
+        extractedAt: row[16],
+        approvedAt: row[17],
+        approvedByUserId: row[18],
+        edited: row[19],
+        metadata: row[20]
+    };
+}
+exports.bulkRejectThreadsQuery = `-- name: BulkRejectThreads :many
+UPDATE weave.threads
+SET
+    retrieval_status = 'THREAD_RETRIEVAL_STATUS_REJECTED'
+WHERE organization_id = $1
+  AND ingestion_run_id = $2
+  AND id = ANY($3::uuid[])
+  AND retrieval_status = 'THREAD_RETRIEVAL_STATUS_PENDING'
+RETURNING
+    id,
+    organization_id,
+    document_id,
+    ingestion_run_id,
+    text,
+    text_original,
+    knowledge_type,
+    facet_fields,
+    confidence,
+    temporal_validity,
+    classification,
+    retrieval_status,
+    source_location,
+    superseded_by,
+    supersedes,
+    cluster_id,
+    extracted_at,
+    approved_at,
+    approved_by_user_id,
+    edited,
+    metadata`;
+async function bulkRejectThreads(client, args) {
+    const result = await client.query({
+        text: exports.bulkRejectThreadsQuery,
+        values: [args.organizationId, args.ingestionRunId, args.threadIds],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            organizationId: row[1],
+            documentId: row[2],
+            ingestionRunId: row[3],
+            text: row[4],
+            textOriginal: row[5],
+            knowledgeType: row[6],
+            facetFields: row[7],
+            confidence: row[8],
+            temporalValidity: row[9],
+            classification: row[10],
+            retrievalStatus: row[11],
+            sourceLocation: row[12],
+            supersededBy: row[13],
+            supersedes: row[14],
+            clusterId: row[15],
+            extractedAt: row[16],
+            approvedAt: row[17],
+            approvedByUserId: row[18],
+            edited: row[19],
+            metadata: row[20]
+        };
+    });
+}
+exports.markThreadsSupersededQuery = `-- name: MarkThreadsSuperseded :execrows
+UPDATE weave.threads
+SET
+    retrieval_status = 'THREAD_RETRIEVAL_STATUS_SUPERSEDED',
+    superseded_by = $1
+WHERE organization_id = $2
+  AND id = ANY($3::uuid[])`;
+exports.listThreadsBySupersedesQuery = `-- name: ListThreadsBySupersedes :many
+SELECT
+    id,
+    organization_id,
+    document_id,
+    ingestion_run_id,
+    text,
+    text_original,
+    knowledge_type,
+    facet_fields,
+    confidence,
+    temporal_validity,
+    classification,
+    retrieval_status,
+    source_location,
+    superseded_by,
+    supersedes,
+    cluster_id,
+    extracted_at,
+    approved_at,
+    approved_by_user_id,
+    edited,
+    metadata
+FROM weave.threads
+WHERE organization_id = $1
+  AND $2 = ANY(supersedes)
+ORDER BY approved_at DESC NULLS LAST, extracted_at DESC, id DESC`;
+async function listThreadsBySupersedes(client, args) {
+    const result = await client.query({
+        text: exports.listThreadsBySupersedesQuery,
+        values: [args.organizationId, args.threadId],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            organizationId: row[1],
+            documentId: row[2],
+            ingestionRunId: row[3],
+            text: row[4],
+            textOriginal: row[5],
+            knowledgeType: row[6],
+            facetFields: row[7],
+            confidence: row[8],
+            temporalValidity: row[9],
+            classification: row[10],
+            retrievalStatus: row[11],
+            sourceLocation: row[12],
+            supersededBy: row[13],
+            supersedes: row[14],
+            clusterId: row[15],
+            extractedAt: row[16],
+            approvedAt: row[17],
+            approvedByUserId: row[18],
+            edited: row[19],
+            metadata: row[20]
+        };
+    });
+}
+exports.listThreadsByIDsQuery = `-- name: ListThreadsByIDs :many
+SELECT
+    id,
+    organization_id,
+    document_id,
+    ingestion_run_id,
+    text,
+    text_original,
+    knowledge_type,
+    facet_fields,
+    confidence,
+    temporal_validity,
+    classification,
+    retrieval_status,
+    source_location,
+    superseded_by,
+    supersedes,
+    cluster_id,
+    extracted_at,
+    approved_at,
+    approved_by_user_id,
+    edited,
+    metadata
+FROM weave.threads
+WHERE organization_id = $1
+  AND id = ANY($2::uuid[])
+ORDER BY extracted_at ASC, id ASC`;
+async function listThreadsByIDs(client, args) {
+    const result = await client.query({
+        text: exports.listThreadsByIDsQuery,
+        values: [args.organizationId, args.threadIds],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            organizationId: row[1],
+            documentId: row[2],
+            ingestionRunId: row[3],
+            text: row[4],
+            textOriginal: row[5],
+            knowledgeType: row[6],
+            facetFields: row[7],
+            confidence: row[8],
+            temporalValidity: row[9],
+            classification: row[10],
+            retrievalStatus: row[11],
+            sourceLocation: row[12],
+            supersededBy: row[13],
+            supersedes: row[14],
+            clusterId: row[15],
+            extractedAt: row[16],
+            approvedAt: row[17],
+            approvedByUserId: row[18],
+            edited: row[19],
+            metadata: row[20]
+        };
+    });
+}
+exports.getIngestionRunThreadCountsQuery = `-- name: GetIngestionRunThreadCounts :one
+SELECT
+    COUNT(*)::int AS thread_count,
+    COUNT(*) FILTER (
+        WHERE retrieval_status = 'THREAD_RETRIEVAL_STATUS_PENDING'
+    )::int AS pending_count,
+    COUNT(*) FILTER (
+        WHERE retrieval_status = 'THREAD_RETRIEVAL_STATUS_APPROVED'
+    )::int AS approved_count,
+    COUNT(*) FILTER (
+        WHERE retrieval_status = 'THREAD_RETRIEVAL_STATUS_REJECTED'
+    )::int AS rejected_count
+FROM weave.threads
+WHERE organization_id = $1
+  AND ingestion_run_id = $2`;
+async function getIngestionRunThreadCounts(client, args) {
+    const result = await client.query({
+        text: exports.getIngestionRunThreadCountsQuery,
+        values: [args.organizationId, args.ingestionRunId],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        threadCount: row[0],
+        pendingCount: row[1],
+        approvedCount: row[2],
+        rejectedCount: row[3]
+    };
+}
+exports.deleteThreadReconciliationByPendingThreadQuery = `-- name: DeleteThreadReconciliationByPendingThread :exec
+DELETE FROM weave.thread_reconciliation tr
+USING weave.threads t
+WHERE tr.pending_thread_id = t.id
+  AND t.organization_id = $1
+  AND tr.pending_thread_id = $2`;
+async function deleteThreadReconciliationByPendingThread(client, args) {
+    await client.query({
+        text: exports.deleteThreadReconciliationByPendingThreadQuery,
+        values: [args.organizationId, args.pendingThreadId],
+        rowMode: "array"
+    });
+}
+exports.upsertThreadReconciliationQuery = `-- name: UpsertThreadReconciliation :one
+INSERT INTO weave.thread_reconciliation (
+    pending_thread_id,
+    existing_thread_id,
+    similarity,
+    entity_overlap
+) VALUES (
+    $1,
+    $2,
+    $3,
+    $4
+)
+ON CONFLICT (pending_thread_id, existing_thread_id) DO UPDATE
+SET
+    similarity = EXCLUDED.similarity,
+    entity_overlap = EXCLUDED.entity_overlap
+RETURNING
+    pending_thread_id,
+    existing_thread_id,
+    similarity,
+    entity_overlap`;
+async function upsertThreadReconciliation(client, args) {
+    const result = await client.query({
+        text: exports.upsertThreadReconciliationQuery,
+        values: [args.pendingThreadId, args.existingThreadId, args.similarity, args.entityOverlap],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        pendingThreadId: row[0],
+        existingThreadId: row[1],
+        similarity: row[2],
+        entityOverlap: row[3]
+    };
+}
+exports.listThreadReconciliationByPendingThreadQuery = `-- name: ListThreadReconciliationByPendingThread :many
+SELECT
+    pending_thread_id,
+    existing_thread_id,
+    similarity,
+    entity_overlap
+FROM weave.thread_reconciliation
+WHERE pending_thread_id IN (
+    SELECT id
+    FROM weave.threads
+    WHERE organization_id = $1
+      AND id = $2
+)
+ORDER BY similarity DESC, entity_overlap DESC, existing_thread_id ASC`;
+async function listThreadReconciliationByPendingThread(client, args) {
+    const result = await client.query({
+        text: exports.listThreadReconciliationByPendingThreadQuery,
+        values: [args.organizationId, args.pendingThreadId],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            pendingThreadId: row[0],
+            existingThreadId: row[1],
+            similarity: row[2],
+            entityOverlap: row[3]
+        };
+    });
+}
+exports.createThreadActivityQuery = `-- name: CreateThreadActivity :one
+INSERT INTO weave.thread_activity (
+    id,
+    thread_id,
+    action,
+    actor_id,
+    metadata
+) VALUES (
+    $1,
+    $2,
+    $3,
+    $4,
+    $5
+)
+RETURNING
+    id,
+    thread_id,
+    action,
+    actor_id,
+    metadata,
+    created_at`;
+async function createThreadActivity(client, args) {
+    const result = await client.query({
+        text: exports.createThreadActivityQuery,
+        values: [args.id, args.threadId, args.action, args.actorId, args.metadata],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        threadId: row[1],
+        action: row[2],
+        actorId: row[3],
+        metadata: row[4],
+        createdAt: row[5]
+    };
+}
+exports.listThreadActivityByThreadQuery = `-- name: ListThreadActivityByThread :many
+SELECT
+    id,
+    thread_id,
+    action,
+    actor_id,
+    metadata,
+    created_at
+FROM weave.thread_activity
+WHERE thread_id IN (
+    SELECT t.id
+    FROM weave.threads t
+    WHERE t.organization_id = $1
+      AND t.id = $2
+)
+ORDER BY created_at DESC`;
+async function listThreadActivityByThread(client, args) {
+    const result = await client.query({
+        text: exports.listThreadActivityByThreadQuery,
+        values: [args.organizationId, args.threadId],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            threadId: row[1],
+            action: row[2],
+            actorId: row[3],
+            metadata: row[4],
+            createdAt: row[5]
+        };
+    });
+}
+exports.upsertEntityQuery = `-- name: UpsertEntity :one
+INSERT INTO weave.entities (
+    id,
+    organization_id,
+    name,
+    type,
+    canonical,
+    metadata
+) VALUES (
+    $1,
+    $2,
+    $3,
+    $4,
+    $5,
+    $6
+)
+ON CONFLICT (organization_id, type, canonical) DO UPDATE
+SET
+    name = EXCLUDED.name,
+    metadata = EXCLUDED.metadata,
+    updated_at = now()
+RETURNING
+    id,
+    organization_id,
+    name,
+    type,
+    canonical,
+    metadata,
+    created_at,
+    updated_at`;
+async function upsertEntity(client, args) {
+    const result = await client.query({
+        text: exports.upsertEntityQuery,
+        values: [args.id, args.organizationId, args.name, args.type, args.canonical, args.metadata],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        name: row[2],
+        type: row[3],
+        canonical: row[4],
+        metadata: row[5],
+        createdAt: row[6],
+        updatedAt: row[7]
+    };
+}
+exports.upsertThreadEntityQuery = `-- name: UpsertThreadEntity :one
+INSERT INTO weave.thread_entities (
+    thread_id,
+    entity_id,
+    role,
+    confidence
+) VALUES (
+    $1,
+    $2,
+    $3,
+    $4
+)
+ON CONFLICT (thread_id, entity_id) DO UPDATE
+SET
+    role = EXCLUDED.role,
+    confidence = EXCLUDED.confidence
+RETURNING
+    thread_id,
+    entity_id,
+    role,
+    confidence`;
+async function upsertThreadEntity(client, args) {
+    const result = await client.query({
+        text: exports.upsertThreadEntityQuery,
+        values: [args.threadId, args.entityId, args.role, args.confidence],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        threadId: row[0],
+        entityId: row[1],
+        role: row[2],
+        confidence: row[3]
+    };
+}
+exports.upsertEntityRelationshipQuery = `-- name: UpsertEntityRelationship :one
+INSERT INTO weave.entity_relationships (
+    id,
+    organization_id,
+    source_entity_id,
+    target_entity_id,
+    relationship,
+    source_thread_id,
+    confidence
+) VALUES (
+    $1,
+    $2,
+    $3,
+    $4,
+    $5,
+    $6,
+    $7
+)
+ON CONFLICT (source_entity_id, target_entity_id, relationship, source_thread_id) DO UPDATE
+SET
+    confidence = EXCLUDED.confidence
+RETURNING
+    id,
+    organization_id,
+    source_entity_id,
+    target_entity_id,
+    relationship,
+    source_thread_id,
+    confidence,
+    created_at`;
+async function upsertEntityRelationship(client, args) {
+    const result = await client.query({
+        text: exports.upsertEntityRelationshipQuery,
+        values: [args.id, args.organizationId, args.sourceEntityId, args.targetEntityId, args.relationship, args.sourceThreadId, args.confidence],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        sourceEntityId: row[2],
+        targetEntityId: row[3],
+        relationship: row[4],
+        sourceThreadId: row[5],
+        confidence: row[6],
+        createdAt: row[7]
+    };
+}
+exports.listEntitiesByThreadQuery = `-- name: ListEntitiesByThread :many
+SELECT
+    e.id,
+    e.organization_id,
+    e.name,
+    e.type,
+    e.canonical,
+    e.metadata,
+    e.created_at,
+    e.updated_at,
+    te.role,
+    te.confidence AS relationship_confidence
+FROM weave.thread_entities te
+JOIN weave.entities e ON e.id = te.entity_id
+WHERE te.thread_id IN (
+    SELECT t.id
+    FROM weave.threads t
+    WHERE t.organization_id = $1
+      AND t.id = $2
+)
+ORDER BY e.type ASC, e.canonical ASC`;
+async function listEntitiesByThread(client, args) {
+    const result = await client.query({
+        text: exports.listEntitiesByThreadQuery,
+        values: [args.organizationId, args.threadId],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            organizationId: row[1],
+            name: row[2],
+            type: row[3],
+            canonical: row[4],
+            metadata: row[5],
+            createdAt: row[6],
+            updatedAt: row[7],
+            role: row[8],
+            relationshipConfidence: row[9]
+        };
+    });
+}
+exports.ensureOrganizationIngestionSettingsQuery = `-- name: EnsureOrganizationIngestionSettings :one
+WITH upsert AS (
+    INSERT INTO weave.org_ingestion_settings (organization_id)
+    VALUES ($1)
+    ON CONFLICT (organization_id) DO UPDATE
+    SET organization_id = EXCLUDED.organization_id
+    RETURNING
+        organization_id,
+        reasoning_model_id,
+        reasoning_provider_configuration_id,
+        embedding_model_id,
+        embedding_provider_configuration_id,
+        updated_at
+)
+SELECT
+    upsert.organization_id,
+    upsert.reasoning_model_id,
+    upsert.reasoning_provider_configuration_id,
+    upsert.embedding_model_id,
+    upsert.embedding_provider_configuration_id,
+    cfg.embedding_dimension AS embedding_dimensions,
+    upsert.updated_at
+FROM upsert
+JOIN weave.database_config cfg
+  ON cfg.id = 1`;
+async function ensureOrganizationIngestionSettings(client, args) {
+    const result = await client.query({
+        text: exports.ensureOrganizationIngestionSettingsQuery,
+        values: [args.organizationId],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        organizationId: row[0],
+        reasoningModelId: row[1],
+        reasoningProviderConfigurationId: row[2],
+        embeddingModelId: row[3],
+        embeddingProviderConfigurationId: row[4],
+        embeddingDimensions: row[5],
+        updatedAt: row[6]
+    };
+}
+exports.getOrganizationIngestionSettingsQuery = `-- name: GetOrganizationIngestionSettings :one
+SELECT
+    settings.organization_id,
+    settings.reasoning_model_id,
+    settings.reasoning_provider_configuration_id,
+    settings.embedding_model_id,
+    settings.embedding_provider_configuration_id,
+    cfg.embedding_dimension AS embedding_dimensions,
+    settings.updated_at
+FROM weave.org_ingestion_settings settings
+JOIN weave.database_config cfg
+  ON cfg.id = 1
+WHERE settings.organization_id = $1`;
+async function getOrganizationIngestionSettings(client, args) {
+    const result = await client.query({
+        text: exports.getOrganizationIngestionSettingsQuery,
+        values: [args.organizationId],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        organizationId: row[0],
+        reasoningModelId: row[1],
+        reasoningProviderConfigurationId: row[2],
+        embeddingModelId: row[3],
+        embeddingProviderConfigurationId: row[4],
+        embeddingDimensions: row[5],
+        updatedAt: row[6]
+    };
+}
+exports.upsertOrganizationIngestionSettingsQuery = `-- name: UpsertOrganizationIngestionSettings :one
+WITH cfg AS (
+    SELECT embedding_dimension
+    FROM weave.database_config
+    WHERE id = 1
+      AND ($1 = 0 OR $1 = embedding_dimension)
+), upsert AS (
+    INSERT INTO weave.org_ingestion_settings (
+        organization_id,
+        reasoning_model_id,
+        reasoning_provider_configuration_id,
+        embedding_model_id,
+        embedding_provider_configuration_id
+    )
+    SELECT
+        $2,
+        $3,
+        $4,
+        $5,
+        $6
+    FROM cfg
+    ON CONFLICT (organization_id) DO UPDATE
+    SET
+        reasoning_model_id = EXCLUDED.reasoning_model_id,
+        reasoning_provider_configuration_id = EXCLUDED.reasoning_provider_configuration_id,
+        embedding_model_id = EXCLUDED.embedding_model_id,
+        embedding_provider_configuration_id = EXCLUDED.embedding_provider_configuration_id,
+        updated_at = now()
+    RETURNING
+        organization_id,
+        reasoning_model_id,
+        reasoning_provider_configuration_id,
+        embedding_model_id,
+        embedding_provider_configuration_id,
+        updated_at
+)
+SELECT
+    upsert.organization_id,
+    upsert.reasoning_model_id,
+    upsert.reasoning_provider_configuration_id,
+    upsert.embedding_model_id,
+    upsert.embedding_provider_configuration_id,
+    cfg.embedding_dimension AS embedding_dimensions,
+    upsert.updated_at
+FROM upsert
+JOIN cfg
+  ON TRUE`;
+async function upsertOrganizationIngestionSettings(client, args) {
+    const result = await client.query({
+        text: exports.upsertOrganizationIngestionSettingsQuery,
+        values: [args.embeddingDimensions, args.organizationId, args.reasoningModelId, args.reasoningProviderConfigurationId, args.embeddingModelId, args.embeddingProviderConfigurationId],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        organizationId: row[0],
+        reasoningModelId: row[1],
+        reasoningProviderConfigurationId: row[2],
+        embeddingModelId: row[3],
+        embeddingProviderConfigurationId: row[4],
+        embeddingDimensions: row[5],
+        updatedAt: row[6]
+    };
+}
+exports.syncOrganizationIngestionReasoningDefaultsQuery = `-- name: SyncOrganizationIngestionReasoningDefaults :one
+WITH cfg AS (
+    SELECT embedding_dimension
+    FROM weave.database_config
+    WHERE id = 1
+), upsert AS (
+    INSERT INTO weave.org_ingestion_settings (
+        organization_id,
+        reasoning_model_id,
+        reasoning_provider_configuration_id
+    )
+    SELECT
+        cs.organization_id,
+        cs.default_chat_model_id,
+        cs.default_provider_configuration_id
+    FROM weave.organization_chat_settings cs
+    WHERE cs.organization_id = $1
+    ON CONFLICT (organization_id) DO UPDATE
+    SET
+        reasoning_model_id = COALESCE(weave.org_ingestion_settings.reasoning_model_id, EXCLUDED.reasoning_model_id),
+        reasoning_provider_configuration_id = COALESCE(
+            weave.org_ingestion_settings.reasoning_provider_configuration_id,
+            EXCLUDED.reasoning_provider_configuration_id
+        ),
+        updated_at = now()
+    RETURNING
+        organization_id,
+        reasoning_model_id,
+        reasoning_provider_configuration_id,
+        embedding_model_id,
+        embedding_provider_configuration_id,
+        updated_at
+)
+SELECT
+    upsert.organization_id,
+    upsert.reasoning_model_id,
+    upsert.reasoning_provider_configuration_id,
+    upsert.embedding_model_id,
+    upsert.embedding_provider_configuration_id,
+    cfg.embedding_dimension AS embedding_dimensions,
+    upsert.updated_at
+FROM upsert
+JOIN cfg
+  ON TRUE`;
+async function syncOrganizationIngestionReasoningDefaults(client, args) {
+    const result = await client.query({
+        text: exports.syncOrganizationIngestionReasoningDefaultsQuery,
+        values: [args.organizationId],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        organizationId: row[0],
+        reasoningModelId: row[1],
+        reasoningProviderConfigurationId: row[2],
+        embeddingModelId: row[3],
+        embeddingProviderConfigurationId: row[4],
+        embeddingDimensions: row[5],
+        updatedAt: row[6]
+    };
+}
+exports.listFacetConfigsQuery = `-- name: ListFacetConfigs :many
+SELECT
+    organization_id,
+    knowledge_type,
+    label,
+    extraction_hint,
+    required_fields,
+    active
+FROM weave.org_facet_config
+WHERE organization_id = $1
+ORDER BY knowledge_type ASC`;
+async function listFacetConfigs(client, args) {
+    const result = await client.query({
+        text: exports.listFacetConfigsQuery,
+        values: [args.organizationId],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            organizationId: row[0],
+            knowledgeType: row[1],
+            label: row[2],
+            extractionHint: row[3],
+            requiredFields: row[4],
+            active: row[5]
+        };
+    });
+}
+exports.listActiveFacetConfigsQuery = `-- name: ListActiveFacetConfigs :many
+SELECT
+    organization_id,
+    knowledge_type,
+    label,
+    extraction_hint,
+    required_fields,
+    active
+FROM weave.org_facet_config
+WHERE organization_id = $1
+  AND active = TRUE
+ORDER BY knowledge_type ASC`;
+async function listActiveFacetConfigs(client, args) {
+    const result = await client.query({
+        text: exports.listActiveFacetConfigsQuery,
+        values: [args.organizationId],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            organizationId: row[0],
+            knowledgeType: row[1],
+            label: row[2],
+            extractionHint: row[3],
+            requiredFields: row[4],
+            active: row[5]
+        };
+    });
+}
+exports.upsertFacetConfigQuery = `-- name: UpsertFacetConfig :one
+INSERT INTO weave.org_facet_config (
+    organization_id,
+    knowledge_type,
+    label,
+    extraction_hint,
+    required_fields,
+    active
+) VALUES (
+    $1,
+    $2,
+    $3,
+    $4,
+    $5,
+    $6
+)
+ON CONFLICT (organization_id, knowledge_type) DO UPDATE
+SET
+    label = EXCLUDED.label,
+    extraction_hint = EXCLUDED.extraction_hint,
+    required_fields = EXCLUDED.required_fields,
+    active = EXCLUDED.active
+RETURNING
+    organization_id,
+    knowledge_type,
+    label,
+    extraction_hint,
+    required_fields,
+    active`;
+async function upsertFacetConfig(client, args) {
+    const result = await client.query({
+        text: exports.upsertFacetConfigQuery,
+        values: [args.organizationId, args.knowledgeType, args.label, args.extractionHint, args.requiredFields, args.active],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        organizationId: row[0],
+        knowledgeType: row[1],
+        label: row[2],
+        extractionHint: row[3],
+        requiredFields: row[4],
+        active: row[5]
+    };
+}
+exports.deactivateFacetConfigQuery = `-- name: DeactivateFacetConfig :one
+UPDATE weave.org_facet_config
+SET active = FALSE
+WHERE organization_id = $1
+  AND knowledge_type = $2
+RETURNING
+    organization_id,
+    knowledge_type,
+    label,
+    extraction_hint,
+    required_fields,
+    active`;
+async function deactivateFacetConfig(client, args) {
+    const result = await client.query({
+        text: exports.deactivateFacetConfigQuery,
+        values: [args.organizationId, args.knowledgeType],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        organizationId: row[0],
+        knowledgeType: row[1],
+        label: row[2],
+        extractionHint: row[3],
+        requiredFields: row[4],
+        active: row[5]
+    };
+}