weave-typescript 0.27.0 → 0.29.0

package/dist/weavesql/weavedb/ingestion_sql.js

@@ -0,0 +1,2924 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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.deleteDocumentThreadByOrganizationAndIDQuery = exports.editDocumentThreadQuery = exports.editPendingThreadQuery = exports.updateThreadClassificationQuery = exports.promoteThreadNextEmbeddingsByOrganizationQuery = exports.setThreadNextEmbeddingQuery = exports.updateThreadEmbeddingQuery = exports.listPendingThreadsByOrganizationQuery = exports.listPendingThreadsByRunQuery = exports.listThreadsByDocumentQuery = exports.listThreadsByIngestionRunQuery = exports.getThreadByOrganizationAndIDQuery = exports.createThreadQuery = exports.deleteDocumentByOrganizationAndIDQuery = exports.listDocumentTagsByDocumentIDQuery = exports.createDocumentTagQuery = exports.deleteDocumentTagByDocumentIDAndTagQuery = exports.deleteDocumentTagsByDocumentIDQuery = exports.listIngestionHistoryQuery = exports.listIngestionRunsByDocumentQuery = exports.listIngestionRunsByOrganizationQuery = exports.updateIngestionRunStateQuery = exports.getIngestionRunByOrganizationAndIDQuery = exports.createIngestionRunQuery = exports.getDatabaseConfigQuery = exports.getAccessibleDocumentSummaryQuery = exports.listAccessibleDocumentSummariesQuery = exports.listDocumentsByOrganizationQuery = exports.setDocumentStatusQuery = exports.setDocumentParseResultQuery = exports.getDocumentByOrganizationAndFingerprintQuery = exports.getDocumentByOrganizationAndIDQuery = exports.createDocumentQuery = void 0;
+exports.deactivateFacetConfigQuery = exports.upsertFacetConfigQuery = exports.listActiveFacetConfigsQuery = exports.listFacetConfigsQuery = exports.syncOrganizationIngestionReasoningDefaultsQuery = exports.upsertOrganizationIngestionSettingsQuery = exports.getOrganizationIngestionSettingsQuery = exports.ensureOrganizationIngestionSettingsQuery = void 0;
+exports.createDocument = createDocument;
+exports.getDocumentByOrganizationAndID = getDocumentByOrganizationAndID;
+exports.getDocumentByOrganizationAndFingerprint = getDocumentByOrganizationAndFingerprint;
+exports.setDocumentParseResult = setDocumentParseResult;
+exports.setDocumentStatus = setDocumentStatus;
+exports.listDocumentsByOrganization = listDocumentsByOrganization;
+exports.listAccessibleDocumentSummaries = listAccessibleDocumentSummaries;
+exports.getAccessibleDocumentSummary = getAccessibleDocumentSummary;
+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.listThreadsByDocument = listThreadsByDocument;
+exports.listPendingThreadsByRun = listPendingThreadsByRun;
+exports.listPendingThreadsByOrganization = listPendingThreadsByOrganization;
+exports.updateThreadEmbedding = updateThreadEmbedding;
+exports.setThreadNextEmbedding = setThreadNextEmbedding;
+exports.updateThreadClassification = updateThreadClassification;
+exports.editPendingThread = editPendingThread;
+exports.editDocumentThread = editDocumentThread;
+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.listAccessibleDocumentSummariesQuery = `-- name: ListAccessibleDocumentSummaries :many
+WITH latest_runs AS (
+    SELECT DISTINCT ON (r.document_id)
+        r.document_id,
+        r.id AS latest_ingestion_run_id,
+        r.status AS latest_ingestion_status
+    FROM weave.ingestion_runs r
+    WHERE r.organization_id = $1
+    ORDER BY r.document_id, r.started_at DESC
+),
+thread_counts AS (
+    SELECT
+        t.document_id,
+        COUNT(*)::int AS thread_count,
+        COUNT(*) FILTER (
+            WHERE t.retrieval_status = 'THREAD_RETRIEVAL_STATUS_PENDING'
+        )::int AS pending_count,
+        COUNT(*) FILTER (
+            WHERE t.retrieval_status = 'THREAD_RETRIEVAL_STATUS_APPROVED'
+        )::int AS approved_count,
+        COUNT(*) FILTER (
+            WHERE t.retrieval_status = 'THREAD_RETRIEVAL_STATUS_REJECTED'
+        )::int AS rejected_count
+    FROM weave.threads t
+    WHERE t.organization_id = $1
+    GROUP BY t.document_id
+),
+tag_data AS (
+    SELECT
+        dt.document_id,
+        array_agg(dt.tag ORDER BY dt.tag ASC) AS tags,
+        array_agg(dt.confidence ORDER BY dt.tag ASC) AS tag_confidences
+    FROM weave.document_tags dt
+    JOIN weave.documents d ON d.id = dt.document_id
+    WHERE d.organization_id = $1
+    GROUP BY dt.document_id
+)
+SELECT
+    d.id,
+    d.organization_id,
+    d.filename,
+    d.mime_type,
+    d.parser_name,
+    d.status,
+    d.scope,
+    d.sensitivity_tags,
+    COALESCE(tag_data.tags, '{}'::text[]) AS tags,
+    COALESCE(tag_data.tag_confidences, '{}'::real[]) AS tag_confidences,
+    d.uploaded_by_user_id,
+    d.uploaded_at,
+    d.updated_at,
+    d.page_count,
+    d.char_count,
+    d.metadata,
+    COALESCE(latest_runs.latest_ingestion_run_id, '00000000-0000-0000-0000-000000000000'::uuid) AS latest_ingestion_run_id,
+    COALESCE(latest_runs.latest_ingestion_status, 'INGESTION_RUN_STATUS_UNSPECIFIED') AS latest_ingestion_status,
+    COALESCE(thread_counts.thread_count, 0)::int AS thread_count,
+    COALESCE(thread_counts.pending_count, 0)::int AS pending_count,
+    COALESCE(thread_counts.approved_count, 0)::int AS approved_count,
+    COALESCE(thread_counts.rejected_count, 0)::int AS rejected_count
+FROM weave.documents d
+LEFT JOIN latest_runs ON latest_runs.document_id = d.id
+LEFT JOIN thread_counts ON thread_counts.document_id = d.id
+LEFT JOIN tag_data ON tag_data.document_id = d.id
+WHERE d.organization_id = $1
+  AND (
+      d.scope = 'DOCUMENT_SCOPE_ORG'
+      OR (d.scope = 'DOCUMENT_SCOPE_PRIVATE'
+          AND d.uploaded_by_user_id = $2)
+      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 = $2
+                AND cardinality(d.sensitivity_tags) = 1
+                AND c.sensitivity_tag_slug = d.sensitivity_tags[1]
+          ))
+  )
+  AND (cardinality($3::text[]) = 0 OR d.status = ANY($3::text[]))
+  AND (cardinality($4::text[]) = 0 OR latest_runs.latest_ingestion_status = ANY($4::text[]))
+  AND (cardinality($5::text[]) = 0 OR d.scope = ANY($5::text[]))
+  AND (cardinality($6::text[]) = 0 OR tag_data.tags && $6::text[] OR d.sensitivity_tags && $6::text[])
+  AND (cardinality($7::text[]) = 0 OR d.sensitivity_tags && $7::text[])
+  AND ($8::timestamptz IS NULL OR d.uploaded_at >= $8::timestamptz)
+  AND ($9::timestamptz IS NULL OR d.uploaded_at <= $9::timestamptz)
+ORDER BY d.uploaded_at DESC, d.id DESC
+LIMIT $11 OFFSET $10`;
+async function listAccessibleDocumentSummaries(client, args) {
+    const result = await client.query({
+        text: exports.listAccessibleDocumentSummariesQuery,
+        values: [args.organizationId, args.actingUserId, args.documentStatuses, args.ingestionStatuses, args.scopes, args.tags, args.restrictedTags, args.uploadedAfter, args.uploadedBefore, 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],
+            status: row[5],
+            scope: row[6],
+            sensitivityTags: row[7],
+            tags: row[8],
+            tagConfidences: row[9],
+            uploadedByUserId: row[10],
+            uploadedAt: row[11],
+            updatedAt: row[12],
+            pageCount: row[13],
+            charCount: row[14],
+            metadata: row[15],
+            latestIngestionRunId: row[16],
+            latestIngestionStatus: row[17],
+            threadCount: row[18],
+            pendingCount: row[19],
+            approvedCount: row[20],
+            rejectedCount: row[21]
+        };
+    });
+}
+exports.getAccessibleDocumentSummaryQuery = `-- name: GetAccessibleDocumentSummary :one
+WITH latest_runs AS (
+    SELECT DISTINCT ON (r.document_id)
+        r.document_id,
+        r.id AS latest_ingestion_run_id,
+        r.status AS latest_ingestion_status
+    FROM weave.ingestion_runs r
+    WHERE r.organization_id = $1
+      AND r.document_id = $2
+    ORDER BY r.document_id, r.started_at DESC
+),
+thread_counts AS (
+    SELECT
+        t.document_id,
+        COUNT(*)::int AS thread_count,
+        COUNT(*) FILTER (
+            WHERE t.retrieval_status = 'THREAD_RETRIEVAL_STATUS_PENDING'
+        )::int AS pending_count,
+        COUNT(*) FILTER (
+            WHERE t.retrieval_status = 'THREAD_RETRIEVAL_STATUS_APPROVED'
+        )::int AS approved_count,
+        COUNT(*) FILTER (
+            WHERE t.retrieval_status = 'THREAD_RETRIEVAL_STATUS_REJECTED'
+        )::int AS rejected_count
+    FROM weave.threads t
+    WHERE t.organization_id = $1
+      AND t.document_id = $2
+    GROUP BY t.document_id
+),
+tag_data AS (
+    SELECT
+        dt.document_id,
+        array_agg(dt.tag ORDER BY dt.tag ASC) AS tags,
+        array_agg(dt.confidence ORDER BY dt.tag ASC) AS tag_confidences
+    FROM weave.document_tags dt
+    JOIN weave.documents d ON d.id = dt.document_id
+    WHERE d.organization_id = $1
+      AND dt.document_id = $2
+    GROUP BY dt.document_id
+)
+SELECT
+    d.id,
+    d.organization_id,
+    d.filename,
+    d.mime_type,
+    d.parser_name,
+    d.status,
+    d.scope,
+    d.sensitivity_tags,
+    COALESCE(tag_data.tags, '{}'::text[]) AS tags,
+    COALESCE(tag_data.tag_confidences, '{}'::real[]) AS tag_confidences,
+    d.uploaded_by_user_id,
+    d.uploaded_at,
+    d.updated_at,
+    d.page_count,
+    d.char_count,
+    d.metadata,
+    COALESCE(latest_runs.latest_ingestion_run_id, '00000000-0000-0000-0000-000000000000'::uuid) AS latest_ingestion_run_id,
+    COALESCE(latest_runs.latest_ingestion_status, 'INGESTION_RUN_STATUS_UNSPECIFIED') AS latest_ingestion_status,
+    COALESCE(thread_counts.thread_count, 0)::int AS thread_count,
+    COALESCE(thread_counts.pending_count, 0)::int AS pending_count,
+    COALESCE(thread_counts.approved_count, 0)::int AS approved_count,
+    COALESCE(thread_counts.rejected_count, 0)::int AS rejected_count
+FROM weave.documents d
+LEFT JOIN latest_runs ON latest_runs.document_id = d.id
+LEFT JOIN thread_counts ON thread_counts.document_id = d.id
+LEFT JOIN tag_data ON tag_data.document_id = d.id
+WHERE d.organization_id = $1
+  AND d.id = $2
+  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]
+          ))
+  )`;
+async function getAccessibleDocumentSummary(client, args) {
+    const result = await client.query({
+        text: exports.getAccessibleDocumentSummaryQuery,
+        values: [args.organizationId, args.documentId, args.actingUserId],
+        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],
+        status: row[5],
+        scope: row[6],
+        sensitivityTags: row[7],
+        tags: row[8],
+        tagConfidences: row[9],
+        uploadedByUserId: row[10],
+        uploadedAt: row[11],
+        updatedAt: row[12],
+        pageCount: row[13],
+        charCount: row[14],
+        metadata: row[15],
+        latestIngestionRunId: row[16],
+        latestIngestionStatus: row[17],
+        threadCount: row[18],
+        pendingCount: row[19],
+        approvedCount: row[20],
+        rejectedCount: row[21]
+    };
+}
+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.deleteDocumentTagByDocumentIDAndTagQuery = `-- name: DeleteDocumentTagByDocumentIDAndTag :execrows
+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
+  AND dt.tag = $3`;
+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.deleteDocumentByOrganizationAndIDQuery = `-- name: DeleteDocumentByOrganizationAndID :execrows
+DELETE FROM weave.documents
+WHERE organization_id = $1
+  AND id = $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.listThreadsByDocumentQuery = `-- name: ListThreadsByDocument :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.document_id = $2
+ORDER BY t.extracted_at ASC, t.id ASC`;
+async function listThreadsByDocument(client, args) {
+    const result = await client.query({
+        text: exports.listThreadsByDocumentQuery,
+        values: [args.organizationId, args.documentId],
+        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.editDocumentThreadQuery = `-- name: EditDocumentThread :one
+WITH updated AS (
+    UPDATE weave.threads AS t
+    SET
+        text_original = CASE
+            WHEN t.text_original IS NULL OR t.text_original = '' THEN t.text
+            ELSE t.text_original
+        END,
+        text = $1,
+        source_location = COALESCE($2::jsonb, t.source_location),
+        metadata = t.metadata || COALESCE($3::jsonb, '{}'::jsonb),
+        edited = TRUE
+    WHERE t.id = $4
+      AND t.organization_id = $5
+      AND t.document_id = $6
+      AND t.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
+)
+SELECT
+    updated.id,
+    updated.organization_id,
+    updated.document_id,
+    d.filename AS document_name,
+    updated.ingestion_run_id,
+    updated.text,
+    updated.text_original,
+    updated.knowledge_type,
+    updated.facet_fields,
+    updated.confidence,
+    updated.temporal_validity,
+    updated.classification,
+    updated.retrieval_status,
+    updated.source_location,
+    updated.superseded_by,
+    updated.supersedes,
+    updated.cluster_id,
+    updated.extracted_at,
+    updated.approved_at,
+    updated.approved_by_user_id,
+    updated.edited,
+    updated.metadata
+FROM updated
+JOIN weave.documents d ON d.id = updated.document_id`;
+async function editDocumentThread(client, args) {
+    const result = await client.query({
+        text: exports.editDocumentThreadQuery,
+        values: [args.text, args.sourceLocation, args.metadata, args.id, args.organizationId, args.documentId],
+        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.deleteDocumentThreadByOrganizationAndIDQuery = `-- name: DeleteDocumentThreadByOrganizationAndID :execrows
+DELETE FROM weave.threads
+WHERE organization_id = $1
+  AND document_id = $2
+  AND id = $3
+  AND retrieval_status = 'THREAD_RETRIEVAL_STATUS_PENDING'`;
+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]
+    };
+}