@rudderhq/server 0.2.7-canary.2 → 0.2.7-canary.20

package/dist/services/messenger.d.ts

@@ -1,5 +1,5 @@
 import type { Db } from "@rudderhq/db";
-import { type MessengerApprovalThreadItem, type MessengerBudgetThreadItem, type MessengerHeartbeatRunThreadItem, type MessengerIssueThreadItem, type MessengerJoinRequestThreadItem, type MessengerSystemThreadKind, type MessengerThreadSummary } from "@rudderhq/shared";
+import { type MessengerApprovalThreadItem, type MessengerBudgetThreadItem, type MessengerHeartbeatRunThreadItem, type MessengerIssueThreadItem, type MessengerJoinRequestThreadItem, type MessengerSystemThreadKind, type MessengerThreadDetail, type MessengerThreadSummary } from "@rudderhq/shared";
 import { chatService } from "./chats.js";
 type ThreadReadState = {
     lastReadAt: Date;
@@ -14,21 +14,7 @@ export declare function messengerService(db: Db): {
     } | null>;
     getIssuesThread: (orgId: string, userId: string) => Promise<{
         summary: MessengerThreadSummary;
-        detail: {
-            threadKey: string;
-            kind: "issues";
-            title: string;
-            subtitle: string;
-            preview: string | null;
-            latestActivityAt: Date | null;
-            lastReadAt: Date | null;
-            unreadCount: number;
-            needsAttention: boolean;
-            isPinned: false;
-            href: string;
-            description: string;
-            items: MessengerIssueThreadItem[];
-        };
+        detail: MessengerThreadDetail<MessengerIssueThreadItem>;
     }>;
     getApprovalsThread: (orgId: string, userId: string) => Promise<{
         summary: MessengerThreadSummary;

package/dist/services/messenger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"messenger.d.ts","sourceRoot":"","sources":["../../src/services/messenger.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,cAAc,CAAC;AAcvC,OAAO,EASL,KAAK,2BAA2B,EAChC,KAAK,yBAAyB,EAE9B,KAAK,+BAA+B,EACpC,KAAK,wBAAwB,EAC7B,KAAK,8BAA8B,EACnC,KAAK,yBAAyB,EAG9B,KAAK,sBAAsB,EAC5B,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AA8BzC,KAAK,eAAe,GAAG;IACrB,UAAU,EAAE,IAAI,CAAC;CAClB,CAAC;AAuHF,KAAK,mBAAmB,GAAG,OAAO,CAAC,UAAU,CAAC,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;AAC/F,KAAK,cAAc,GAAG,OAAO,CAAC,UAAU,CAAC,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;AA0hBlG,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,EAAE;iCAmcK,MAAM,UAAU,MAAM;oCAmDnB,MAAM,UAAU,MAAM;sBAKjC,mBAAmB;kBAC3B,cAAc,EAAE;;6BA3BJ,MAAM,UAAU,MAAM;;;;;;;;;;;;;;;;;;gCAInB,MAAM,UAAU,MAAM;;;;;;;;;;;;;;;;;;6BAIzB,MAAM,UAAU,MAAM,cAAc,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAuB9D,MAAM,UAAU,MAAM,aAAa,MAAM;;;;;;;;;4BAQzC,MAAM,UAAU,MAAM,aAAa,MAAM;2BAAzC,MAAM,UAAU,MAAM,aAAa,MAAM;EA+C/E"}
+{"version":3,"file":"messenger.d.ts","sourceRoot":"","sources":["../../src/services/messenger.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,cAAc,CAAC;AAcvC,OAAO,EASL,KAAK,2BAA2B,EAChC,KAAK,yBAAyB,EAE9B,KAAK,+BAA+B,EACpC,KAAK,wBAAwB,EAC7B,KAAK,8BAA8B,EACnC,KAAK,yBAAyB,EAE9B,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,EAC5B,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AA8BzC,KAAK,eAAe,GAAG;IACrB,UAAU,EAAE,IAAI,CAAC;CAClB,CAAC;AAgIF,KAAK,mBAAmB,GAAG,OAAO,CAAC,UAAU,CAAC,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;AAK/F,KAAK,cAAc,GAAG,OAAO,CAAC,UAAU,CAAC,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;AAqiBlG,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,EAAE;iCA2rBK,MAAM,UAAU,MAAM;oCA0DnB,MAAM,UAAU,MAAM;sBAKjC,mBAAmB;kBAC3B,cAAc,EAAE;;6BA3BJ,MAAM,UAAU,MAAM;;;;gCAInB,MAAM,UAAU,MAAM;;;;;;;;;;;;;;;;;;6BAIzB,MAAM,UAAU,MAAM,cAAc,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAuB9D,MAAM,UAAU,MAAM,aAAa,MAAM;;;;;;;;;4BAQzC,MAAM,UAAU,MAAM,aAAa,MAAM;2BAAzC,MAAM,UAAU,MAAM,aAAa,MAAM;EA+C/E"}

package/dist/services/messenger.js

@@ -1,4 +1,4 @@
-import { and, desc, eq, inArray, isNull, or } from "drizzle-orm";
+import { and, desc, eq, gt, inArray, isNull, or, sql } from "drizzle-orm";
 import { activityLog, approvalComments, approvals, agents, authUsers, heartbeatRuns, issueComments, issues, joinRequests, messengerThreadUserStates, } from "@rudderhq/db";
 import { formatMessengerPreview, formatMessengerTitle, } from "@rudderhq/shared";
 import { issueService } from "./issues.js";
@@ -496,6 +496,10 @@ async function loadThreadStates(db, orgId, userId, threadKeys) {
         .where(and(eq(messengerThreadUserStates.orgId, orgId), eq(messengerThreadUserStates.userId, userId), inArray(messengerThreadUserStates.threadKey, threadKeys)));
     return new Map(rows.map((row) => [row.threadKey, row]));
 }
+async function lastReadAtForThread(db, orgId, userId, threadKey, threadStates) {
+    const states = threadStates ?? loadThreadStates(db, orgId, userId, [threadKey]);
+    return (await states).get(threadKey)?.lastReadAt ?? null;
+}
 export function messengerService(db) {
     const issuesSvc = issueService(db);
     const chatsSvc = chatService(db);
@@ -538,30 +542,45 @@ export function messengerService(db) {
         }
         return Array.from(universe.values());
     }
-    async function loadIssueSummaryData(orgId, userId) {
+    async function loadIssueData(orgId, userId, threadStates, options) {
+        const lastReadAtPromise = lastReadAtForThread(db, orgId, userId, "issues", threadStates);
         const issuesUniverse = await loadIssueUniverse(orgId, userId);
         const issueIds = issuesUniverse.map((row) => row.id);
-        const threadStates = await loadThreadStates(db, orgId, userId, ["issues"]);
-        const lastReadAt = threadStates.get("issues")?.lastReadAt ?? null;
+        const lastReadAt = await lastReadAtPromise;
         const [commentRows, activityRows] = await Promise.all([
             issueIds.length === 0
                 ? Promise.resolve([])
-                : db
-                    .select({
-                    id: issueComments.id,
-                    issueId: issueComments.issueId,
-                    body: issueComments.body,
-                    authorAgentId: issueComments.authorAgentId,
-                    authorUserId: issueComments.authorUserId,
-                    authorAgentName: agents.name,
-                    authorUserName: authUsers.name,
-                    createdAt: issueComments.createdAt,
-                })
-                    .from(issueComments)
-                    .leftJoin(agents, eq(issueComments.authorAgentId, agents.id))
-                    .leftJoin(authUsers, eq(issueComments.authorUserId, authUsers.id))
-                    .where(and(eq(issueComments.orgId, orgId), inArray(issueComments.issueId, issueIds)))
-                    .orderBy(desc(issueComments.createdAt)),
+                : options.includeDetail
+                    ? db
+                        .select({
+                        id: issueComments.id,
+                        issueId: issueComments.issueId,
+                        body: issueComments.body,
+                        authorAgentId: issueComments.authorAgentId,
+                        authorUserId: issueComments.authorUserId,
+                        authorAgentName: agents.name,
+                        authorUserName: authUsers.name,
+                        createdAt: issueComments.createdAt,
+                    })
+                        .from(issueComments)
+                        .leftJoin(agents, eq(issueComments.authorAgentId, agents.id))
+                        .leftJoin(authUsers, eq(issueComments.authorUserId, authUsers.id))
+                        .where(and(eq(issueComments.orgId, orgId), inArray(issueComments.issueId, issueIds)))
+                        .orderBy(desc(issueComments.createdAt))
+                    : db
+                        .select({
+                        id: issueComments.id,
+                        issueId: issueComments.issueId,
+                        body: issueComments.body,
+                        authorAgentId: issueComments.authorAgentId,
+                        authorUserId: issueComments.authorUserId,
+                        authorAgentName: sql `null`,
+                        authorUserName: sql `null`,
+                        createdAt: issueComments.createdAt,
+                    })
+                        .from(issueComments)
+                        .where(and(eq(issueComments.orgId, orgId), inArray(issueComments.issueId, issueIds), sql `(${issueComments.authorUserId} is null or ${issueComments.authorUserId} <> ${userId})`))
+                        .orderBy(desc(issueComments.createdAt)),
             issueIds.length === 0
                 ? Promise.resolve([])
                 : db
@@ -582,7 +601,7 @@ export function messengerService(db) {
         const latestCommentByIssue = new Map();
         const latestExternalCommentByIssue = new Map();
         for (const row of commentRows) {
-            if (!latestCommentByIssue.has(row.issueId)) {
+            if (options.includeDetail && !latestCommentByIssue.has(row.issueId)) {
                 latestCommentByIssue.set(row.issueId, row);
             }
             if (!isSelfAuthoredComment(row, userId) && !latestExternalCommentByIssue.has(row.issueId)) {
@@ -648,20 +667,26 @@ export function messengerService(db) {
                         : null;
             const summaryPreview = attentionActivityAt ? issueThreadPreview(issue, attentionPreview) : null;
             return {
-                item: issueCard(issue, userId, issue.followed, latestPreview, latestActivityAt ?? issue.updatedAt, latestSourceIsComment ? latestVisibleComment : null, statusChangeActivity),
+                issue,
+                item: options.includeDetail
+                    ? issueCard(issue, userId, issue.followed, latestPreview, latestActivityAt ?? issue.updatedAt, latestSourceIsComment ? latestVisibleComment : null, statusChangeActivity)
+                    : null,
                 attentionActivityAt,
                 attentionPreview: summaryPreview,
             };
         });
-        const unsortedItems = unsortedEntries.map((entry) => entry.item);
         const latestFirstEntries = [...unsortedEntries].sort((a, b) => {
             const aTime = a.attentionActivityAt?.getTime() ?? Number.NEGATIVE_INFINITY;
             const bTime = b.attentionActivityAt?.getTime() ?? Number.NEGATIVE_INFINITY;
             if (aTime !== bTime)
                 return bTime - aTime;
-            return a.item.title.localeCompare(b.item.title);
+            return issueDisplayLabel(a.issue).localeCompare(issueDisplayLabel(b.issue));
         });
-        const chronologicalItems = [...unsortedItems].sort(compareChronologicalActivity);
+        const chronologicalItems = options.includeDetail
+            ? unsortedEntries
+                .flatMap((entry) => entry.item ? [entry.item] : [])
+                .sort(compareChronologicalActivity)
+            : [];
         const latestAttentionEntry = latestFirstEntries.find((entry) => entry.attentionActivityAt);
         const latestActivityAt = latestAttentionEntry?.attentionActivityAt ?? null;
         const unreadCount = unsortedEntries.filter((entry) => {
@@ -672,9 +697,12 @@ export function messengerService(db) {
                 return true;
             return itemActivity.getTime() > lastReadAt.getTime();
         }).length;
-        return {
+        const data = {
             summary: issueSummary(issuesUniverse.length, latestActivityAt, unreadCount, lastReadAt, latestAttentionEntry?.attentionPreview ?? null),
-            detail: {
+            itemCount: issuesUniverse.length,
+        };
+        if (options.includeDetail) {
+            data.detail = {
                 threadKey: "issues",
                 kind: "issues",
                 title: "Issues",
@@ -688,12 +716,22 @@ export function messengerService(db) {
                 href: "/messenger/issues",
                 description: "Followed issues, issues I created, issues assigned to me, and issues ready for my review",
                 items: chronologicalItems,
-            },
+            };
+        }
+        return data;
+    }
+    async function loadIssueSummaryData(orgId, userId, threadStates) {
+        const data = await loadIssueData(orgId, userId, threadStates, { includeDetail: true });
+        return {
+            summary: data.summary,
+            detail: data.detail,
         };
     }
-    async function loadApprovalSummaryData(orgId, userId) {
-        const threadStates = await loadThreadStates(db, orgId, userId, ["approvals"]);
-        const lastReadAt = threadStates.get("approvals")?.lastReadAt ?? null;
+    async function loadIssueThreadSummaryData(orgId, userId, threadStates) {
+        return loadIssueData(orgId, userId, threadStates, { includeDetail: false });
+    }
+    async function loadApprovalSummaryData(orgId, userId, threadStates) {
+        const lastReadAtPromise = lastReadAtForThread(db, orgId, userId, "approvals", threadStates);
         const [approvalRows, latestComments] = await Promise.all([
             db
                 .select()
@@ -711,6 +749,7 @@ export function messengerService(db) {
                 .where(eq(approvals.orgId, orgId))
                 .orderBy(desc(approvalComments.createdAt)),
         ]);
+        const lastReadAt = await lastReadAtPromise;
         const latestCommentByApproval = new Map();
         for (const row of latestComments) {
             if (!latestCommentByApproval.has(row.approvalId)) {
@@ -754,9 +793,95 @@ export function messengerService(db) {
             },
         };
     }
-    async function loadFailedRunData(orgId, userId) {
-        const threadStates = await loadThreadStates(db, orgId, userId, ["failed-runs"]);
-        const lastReadAt = threadStates.get("failed-runs")?.lastReadAt ?? null;
+    async function loadApprovalThreadSummaryData(orgId, userId, threadStates) {
+        const lastReadAt = await lastReadAtForThread(db, orgId, userId, "approvals", threadStates);
+        const approvalPredicate = eq(approvals.orgId, orgId);
+        const pendingApprovalPredicate = and(eq(approvals.orgId, orgId), eq(approvals.status, "pending"));
+        const [summaryRows, latestApprovalRows, latestCommentRows, unreadRows] = await Promise.all([
+            db
+                .select({
+                itemCount: sql `count(*)::int`,
+            })
+                .from(approvals)
+                .where(approvalPredicate),
+            db
+                .select()
+                .from(approvals)
+                .where(approvalPredicate)
+                .orderBy(desc(approvals.updatedAt), desc(approvals.createdAt))
+                .limit(1),
+            db
+                .execute(sql `
+          select
+            latest_comment.approval_id as "approvalId",
+            latest_comment.body as "body",
+            latest_comment.created_at as "createdAt"
+          from ${approvals}
+          inner join lateral (
+            select
+              ${approvalComments.approvalId},
+              ${approvalComments.body},
+              ${approvalComments.createdAt}
+            from ${approvalComments}
+            where ${approvalComments.orgId} = ${orgId}
+              and ${approvalComments.approvalId} = ${approvals.id}
+            order by ${approvalComments.createdAt} desc
+            limit 1
+          ) latest_comment on true
+          where ${approvals.orgId} = ${orgId}
+          order by latest_comment.created_at desc
+          limit 1
+        `),
+            db
+                .select({
+                unreadCount: sql `count(*)::int`,
+            })
+                .from(approvals)
+                .where(lastReadAt ? and(pendingApprovalPredicate, gt(approvals.updatedAt, lastReadAt)) : pendingApprovalPredicate),
+        ]);
+        const latestApproval = (latestApprovalRows[0] ?? null);
+        const latestApprovalCommentRows = latestApproval
+            ? await db
+                .select({
+                approvalId: approvalComments.approvalId,
+                body: approvalComments.body,
+                createdAt: approvalComments.createdAt,
+            })
+                .from(approvalComments)
+                .where(eq(approvalComments.approvalId, latestApproval.id))
+                .orderBy(desc(approvalComments.createdAt))
+                .limit(1)
+            : [];
+        const latestCommentRow = (latestCommentRows[0] ?? null);
+        const latestCommentApprovalRows = latestCommentRow
+            ? await db
+                .select()
+                .from(approvals)
+                .where(and(eq(approvals.id, latestCommentRow.approvalId), approvalPredicate))
+                .limit(1)
+            : [];
+        const candidateItems = [];
+        if (latestApproval) {
+            const latestComment = (latestApprovalCommentRows[0] ?? null);
+            const latestActivityAt = maxDate(latestApproval.updatedAt, latestComment?.createdAt) ?? latestApproval.updatedAt;
+            candidateItems.push(approvalCard(latestApproval, latestComment, userId, latestActivityAt));
+        }
+        if (latestCommentRow) {
+            const approval = (latestCommentApprovalRows[0] ?? null);
+            if (approval) {
+                const latestActivityAt = maxDate(approval.updatedAt, latestCommentRow.createdAt) ?? approval.updatedAt;
+                candidateItems.push(approvalCard(approval, latestCommentRow, userId, latestActivityAt));
+            }
+        }
+        const latestItem = candidateItems.sort(compareLatestActivity)[0] ?? null;
+        const itemCount = Number(summaryRows[0]?.itemCount ?? 0);
+        return {
+            itemCount,
+            summary: approvalSummary(itemCount, latestItem?.latestActivityAt ?? null, Number(unreadRows[0]?.unreadCount ?? 0), lastReadAt, latestItem?.preview ?? null),
+        };
+    }
+    async function loadFailedRunData(orgId, userId, threadStates) {
+        const lastReadAtPromise = lastReadAtForThread(db, orgId, userId, "failed-runs", threadStates);
         const [runRows, agentRows] = await Promise.all([
             db
                 .select({
@@ -782,6 +907,7 @@ export function messengerService(db) {
                 .from(agents)
                 .where(eq(agents.orgId, orgId)),
         ]);
+        const lastReadAt = await lastReadAtPromise;
         const agentNames = new Map(agentRows.map((row) => [row.id, row.name]));
         const items = runRows.map((run) => failedRunCard(run, agentNames.get(run.agentId) ?? null));
         const latestFirstItems = [...items].sort(compareLatestActivity);
@@ -807,10 +933,49 @@ export function messengerService(db) {
             },
         };
     }
-    async function loadBudgetAlertData(orgId, userId) {
-        const threadStates = await loadThreadStates(db, orgId, userId, ["budget-alerts"]);
-        const lastReadAt = threadStates.get("budget-alerts")?.lastReadAt ?? null;
+    async function loadFailedRunSummaryData(orgId, userId, threadStates) {
+        const lastReadAt = await lastReadAtForThread(db, orgId, userId, "failed-runs", threadStates);
+        const latestActivitySql = sql `max(coalesce(${heartbeatRuns.updatedAt}, ${heartbeatRuns.createdAt}))`;
+        const failedRunPredicate = and(eq(heartbeatRuns.orgId, orgId), eq(heartbeatRuns.status, "failed"));
+        const [summaryRows, latestRows, unreadRows] = await Promise.all([
+            db
+                .select({
+                itemCount: sql `count(*)::int`,
+                latestActivityAt: latestActivitySql,
+            })
+                .from(heartbeatRuns)
+                .where(failedRunPredicate),
+            db
+                .select({
+                error: heartbeatRuns.error,
+                stderrExcerpt: heartbeatRuns.stderrExcerpt,
+            })
+                .from(heartbeatRuns)
+                .where(failedRunPredicate)
+                .orderBy(desc(heartbeatRuns.updatedAt), desc(heartbeatRuns.createdAt))
+                .limit(1),
+            lastReadAt
+                ? db
+                    .select({
+                    unreadCount: sql `count(*)::int`,
+                })
+                    .from(heartbeatRuns)
+                    .where(and(failedRunPredicate, gt(heartbeatRuns.updatedAt, lastReadAt)))
+                : Promise.resolve([]),
+        ]);
+        const summaryRow = summaryRows[0];
+        const latestRun = latestRows[0] ?? null;
+        const itemCount = Number(summaryRow?.itemCount ?? 0);
+        const unreadCount = lastReadAt ? Number(unreadRows[0]?.unreadCount ?? 0) : itemCount;
+        return {
+            itemCount,
+            summary: systemSummary("failed-runs", "Failed runs", itemCount, normalizeDate(summaryRow?.latestActivityAt ?? null), unreadCount, lastReadAt, "No failed runs yet", truncate(latestRun?.error) ?? truncate(latestRun?.stderrExcerpt)),
+        };
+    }
+    async function loadBudgetAlertData(orgId, userId, threadStates) {
+        const lastReadAtPromise = lastReadAtForThread(db, orgId, userId, "budget-alerts", threadStates);
         const incidents = ((await budgetsSvc.overview(orgId)).activeIncidents ?? []);
+        const lastReadAt = await lastReadAtPromise;
         const items = incidents.map((incident) => budgetCard(incident));
         const latestActivityAt = items[0]?.latestActivityAt ?? null;
         const unreadCount = systemUnreadCountSince(incidents, lastReadAt);
@@ -833,14 +998,14 @@ export function messengerService(db) {
             },
         };
     }
-    async function loadJoinRequestData(orgId, userId) {
-        const threadStates = await loadThreadStates(db, orgId, userId, ["join-requests"]);
-        const lastReadAt = threadStates.get("join-requests")?.lastReadAt ?? null;
+    async function loadJoinRequestData(orgId, userId, threadStates) {
+        const lastReadAtPromise = lastReadAtForThread(db, orgId, userId, "join-requests", threadStates);
         const rows = (await db
             .select()
             .from(joinRequests)
             .where(and(eq(joinRequests.orgId, orgId), eq(joinRequests.status, "pending_approval")))
             .orderBy(desc(joinRequests.updatedAt), desc(joinRequests.createdAt)));
+        const lastReadAt = await lastReadAtPromise;
         const items = rows.map((row) => joinRequestCard(row));
         const latestActivityAt = items[0]?.latestActivityAt ?? null;
         const unreadCount = systemUnreadCountSince(rows, lastReadAt);
@@ -863,25 +1028,71 @@ export function messengerService(db) {
             },
         };
     }
+    async function loadJoinRequestSummaryData(orgId, userId, threadStates) {
+        const lastReadAt = await lastReadAtForThread(db, orgId, userId, "join-requests", threadStates);
+        const latestActivitySql = sql `max(coalesce(${joinRequests.updatedAt}, ${joinRequests.createdAt}))`;
+        const joinRequestPredicate = and(eq(joinRequests.orgId, orgId), eq(joinRequests.status, "pending_approval"));
+        const [summaryRows, latestRows, unreadRows] = await Promise.all([
+            db
+                .select({
+                itemCount: sql `count(*)::int`,
+                latestActivityAt: latestActivitySql,
+            })
+                .from(joinRequests)
+                .where(joinRequestPredicate),
+            db
+                .select({
+                capabilities: joinRequests.capabilities,
+                requestEmailSnapshot: joinRequests.requestEmailSnapshot,
+            })
+                .from(joinRequests)
+                .where(joinRequestPredicate)
+                .orderBy(desc(joinRequests.updatedAt), desc(joinRequests.createdAt))
+                .limit(1),
+            lastReadAt
+                ? db
+                    .select({
+                    unreadCount: sql `count(*)::int`,
+                })
+                    .from(joinRequests)
+                    .where(and(joinRequestPredicate, gt(joinRequests.updatedAt, lastReadAt)))
+                : Promise.resolve([]),
+        ]);
+        const summaryRow = summaryRows[0];
+        const latestRequest = latestRows[0] ?? null;
+        const itemCount = Number(summaryRow?.itemCount ?? 0);
+        const unreadCount = lastReadAt ? Number(unreadRows[0]?.unreadCount ?? 0) : itemCount;
+        return {
+            itemCount,
+            summary: systemSummary("join-requests", "Join requests", itemCount, normalizeDate(summaryRow?.latestActivityAt ?? null), unreadCount, lastReadAt, "No pending join requests", latestRequest?.capabilities ?? latestRequest?.requestEmailSnapshot ?? null),
+        };
+    }
     async function listThreadSummaries(orgId, userId) {
+        const syntheticThreadStates = loadThreadStates(db, orgId, userId, [
+            "issues",
+            "approvals",
+            "failed-runs",
+            "budget-alerts",
+            "join-requests",
+        ]);
         const [chats, issueData, approvalData, failedRunData, budgetData, joinRequestData] = await Promise.all([
-            chatsSvc.list(orgId, { status: "active" }, userId),
-            loadIssueSummaryData(orgId, userId),
-            loadApprovalSummaryData(orgId, userId),
-            loadFailedRunData(orgId, userId),
-            loadBudgetAlertData(orgId, userId),
-            loadJoinRequestData(orgId, userId),
+            chatsSvc.listSummaries(orgId, { status: "active" }, userId),
+            loadIssueThreadSummaryData(orgId, userId, syntheticThreadStates),
+            loadApprovalThreadSummaryData(orgId, userId, syntheticThreadStates),
+            loadFailedRunSummaryData(orgId, userId, syntheticThreadStates),
+            loadBudgetAlertData(orgId, userId, syntheticThreadStates),
+            loadJoinRequestSummaryData(orgId, userId, syntheticThreadStates),
         ]);
         const syntheticSummaries = [];
-        if (issueData.detail.items.length > 0)
+        if (issueData.itemCount > 0)
             syntheticSummaries.push(issueData.summary);
-        if (approvalData.detail.items.length > 0)
+        if (approvalData.itemCount > 0)
             syntheticSummaries.push(approvalData.summary);
-        if (failedRunData.detail.items.length > 0)
+        if (failedRunData.itemCount > 0)
             syntheticSummaries.push(failedRunData.summary);
         if (budgetData.detail.items.length > 0)
             syntheticSummaries.push(budgetData.summary);
-        if (joinRequestData.detail.items.length > 0)
+        if (joinRequestData.itemCount > 0)
             syntheticSummaries.push(joinRequestData.summary);
         const threadSummaries = [
             ...chats.map(chatSummary),