@rudderhq/server 0.5.0 → 0.5.1

package/dist/services/messenger.js

@@ -1,11 +1,15 @@
-import { activityLog, agents, approvalComments, approvals, authUsers, heartbeatRuns, issueComments, issueFollows, issues, joinRequests, messengerCustomGroupEntries, messengerCustomGroups, messengerThreadUserStates, projects } from "@rudderhq/db";
-import { formatMessengerPreview, formatMessengerTitle, issueUpdatedChangedKeys, toPublicHeartbeatRunContextSnapshot } from "@rudderhq/shared";
+import { activityLog, agents, approvalComments, approvals, authUsers, heartbeatRuns, issueComments, issueFollows, issues, joinRequests, messengerCustomGroupEntries, messengerCustomGroups, messengerSavedViews, messengerThreadUserStates, projects } from "@rudderhq/db";
+import { formatMessengerPreview, formatMessengerTitle, issueUpdatedChangedKeys, messengerSavedViewIdSchema } from "@rudderhq/shared";
 import { and, asc, desc, eq, gt, inArray, isNull, ne, or, sql } from "drizzle-orm";
 import { badRequest, conflict, notFound } from "../errors.js";
 import { redactEventPayload } from "../redaction.js";
+import { logActivity } from "./activity-log.js";
 import { budgetService } from "./budgets.js";
 import { chatService } from "./chats.js";
 import { issueLowSignalContentOnlyActivitySql } from "./issue-activity-filters.js";
+import { hydrateMessengerFailedRunOrigins, messengerFailedRunSourceAction, } from "./messenger-run-origin.js";
+import { failedRunUserSummary } from "./messenger-run-summary.js";
+import { lockMessengerCustomGroupPlacement, lockMessengerSavedViewPlacement, } from "./messenger-saved-views.js";
 const ISSUE_ACTIVITY_ACTIONS = [
     "issue.updated",
     "issue.followed",
@@ -25,7 +29,6 @@ const DEFAULT_THREAD_SUMMARY_LIMIT = 40;
 const MAX_THREAD_SUMMARY_LIMIT = 100;
 const DEFAULT_ISSUE_THREAD_DETAIL_LIMIT = 50;
 const MAX_ISSUE_THREAD_DETAIL_LIMIT = 100;
-const FAILED_RUN_USER_SUMMARY = "The run hit a system-level execution problem. Rudder saved the technical details for diagnostics.";
 function truncate(value, max = 140) {
     return formatMessengerPreview(value, { max });
 }
@@ -556,10 +559,9 @@ function approvalCard(approval, latestComment, currentUserId, latestActivityAt)
         approval: approval,
     };
 }
-function failedRunCard(run, agentName) {
+function failedRunCard(run, agentName, origin) {
     const summary = failedRunUserSummary(run);
-    const publicContextSnapshot = toPublicHeartbeatRunContextSnapshot(run.contextSnapshot);
-    const publicRun = { ...run, contextSnapshot: publicContextSnapshot };
+    const sourceAction = messengerFailedRunSourceAction(origin);
     return {
         id: run.id,
         threadKey: "failed-runs",
@@ -572,23 +574,17 @@ function failedRunCard(run, agentName) {
         latestActivityAt: run.updatedAt ?? run.createdAt,
         actions: [
             buildAction("Retry", `/agent-runs/${run.id}/retry`, "POST"),
+            ...(sourceAction ? [sourceAction] : []),
             buildAction("Open run", `/agents/${run.agentId}/runs/${run.id}`, "GET"),
         ],
         metadata: {
             runId: run.id,
             agentId: run.agentId,
             status: run.status,
-            contextSnapshot: publicContextSnapshot,
         },
-        run: publicRun,
+        origin,
     };
 }
-function readNonEmptyString(value) {
-    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
-}
-function failedRunUserSummary(run) {
-    return readNonEmptyString(run.resultJson?.userMessage) ?? FAILED_RUN_USER_SUMMARY;
-}
 function budgetCard(incident) {
     return {
         id: incident.id,
@@ -676,8 +672,30 @@ export function messengerService(db) {
             || threadKey === "budget-alerts"
             || threadKey === "join-requests";
     }
-    async function getCustomGroupOrThrow(orgId, userId, groupId) {
-        const [group] = await db
+    function savedViewIdFromItemKey(itemKey) {
+        if (!itemKey.startsWith("saved-view:"))
+            return null;
+        const parsed = messengerSavedViewIdSchema.safeParse(itemKey.slice("saved-view:".length));
+        if (!parsed.success)
+            throw badRequest("Invalid Messenger Saved View item key");
+        return parsed.data;
+    }
+    async function logSavedViewPlacement(database, orgId, userId, itemKey, action, details) {
+        const savedViewId = savedViewIdFromItemKey(itemKey);
+        if (!savedViewId)
+            return;
+        await logActivity(database, {
+            orgId,
+            actorType: "user",
+            actorId: userId,
+            action,
+            entityType: "messenger_saved_view",
+            entityId: savedViewId,
+            details: { itemKey, ...details },
+        });
+    }
+    async function getCustomGroupOrThrowWithDb(database, orgId, userId, groupId) {
+        const [group] = await database
             .select()
             .from(messengerCustomGroups)
             .where(and(eq(messengerCustomGroups.orgId, orgId), eq(messengerCustomGroups.userId, userId), eq(messengerCustomGroups.id, groupId)))
@@ -686,6 +704,9 @@ export function messengerService(db) {
             throw notFound("Messenger custom group not found");
         return group;
     }
+    async function getCustomGroupOrThrow(orgId, userId, groupId) {
+        return getCustomGroupOrThrowWithDb(db, orgId, userId, groupId);
+    }
     async function loadIssueThreadSummaryById(orgId, userId, issueId) {
         const lastReadAtPromise = lastReadAtForThread(db, orgId, userId, "issues");
         const rows = (await db.execute(issueEntryRowsQuery(orgId, userId, sql `
@@ -754,9 +775,28 @@ export function messengerService(db) {
             throw notFound("Messenger thread not found");
         }
     }
+    async function findMessengerSavedViewWithDb(database, orgId, userId, itemKey) {
+        const savedViewId = savedViewIdFromItemKey(itemKey);
+        if (!savedViewId)
+            return null;
+        return database
+            .select()
+            .from(messengerSavedViews)
+            .where(and(eq(messengerSavedViews.orgId, orgId), eq(messengerSavedViews.userId, userId), eq(messengerSavedViews.id, savedViewId)))
+            .limit(1)
+            .then((rows) => rows[0] ?? null);
+    }
+    async function findMessengerSavedView(orgId, userId, itemKey) {
+        return findMessengerSavedViewWithDb(db, orgId, userId, itemKey);
+    }
     async function listThreadTitles(orgId, userId, threadKeys) {
         const titles = [];
         for (const threadKey of [...new Set(threadKeys)]) {
+            const savedView = await findMessengerSavedView(orgId, userId, threadKey);
+            if (savedView?.title) {
+                titles.push(savedView.title);
+                continue;
+            }
             const summary = await findMessengerThreadSummary(orgId, userId, threadKey);
             if (summary?.title)
                 titles.push(summary.title);
@@ -785,8 +825,22 @@ export function messengerService(db) {
                 .where(and(eq(messengerCustomGroupEntries.orgId, orgId), eq(messengerCustomGroupEntries.userId, userId)))
                 .orderBy(asc(messengerCustomGroupEntries.sortOrder), asc(messengerCustomGroupEntries.createdAt)),
         ]);
+        const savedViewItemKeys = entries
+            .map((entry) => entry.threadKey)
+            .filter((itemKey) => Boolean(savedViewIdFromItemKey(itemKey)));
+        const savedViewIds = savedViewItemKeys
+            .map((itemKey) => savedViewIdFromItemKey(itemKey))
+            .filter((id) => Boolean(id));
+        const savedViews = savedViewIds.length > 0
+            ? await db
+                .select()
+                .from(messengerSavedViews)
+                .where(and(eq(messengerSavedViews.orgId, orgId), eq(messengerSavedViews.userId, userId), inArray(messengerSavedViews.id, savedViewIds)))
+            : [];
+        const savedViewByItemKey = new Map(savedViews.map((savedView) => [`saved-view:${savedView.id}`, savedView]));
         const conversationIds = entries
             .map((entry) => entry.threadKey)
+            .filter((itemKey) => !savedViewIdFromItemKey(itemKey))
             .map((threadKey) => chatConversationIdFromThreadKey(threadKey))
             .filter((id) => Boolean(id));
         const conversations = await chatsSvc.listSummariesByIds(orgId, conversationIds, userId);
@@ -796,6 +850,7 @@ export function messengerService(db) {
         }));
         const nonChatThreadKeys = [...new Set(entries
                 .map((entry) => entry.threadKey)
+                .filter((itemKey) => !savedViewIdFromItemKey(itemKey))
                 .filter((threadKey) => !chatConversationIdFromThreadKey(threadKey)))];
         const issueThreadKeys = nonChatThreadKeys.filter((threadKey) => Boolean(issueIdFromThreadKey(threadKey)));
         if (nonChatThreadKeys.length > 0) {
@@ -819,6 +874,36 @@ export function messengerService(db) {
         const staleEntryIds = [];
         const entriesByGroupId = new Map();
         for (const entry of entries) {
+            const savedViewId = savedViewIdFromItemKey(entry.threadKey);
+            if (savedViewId) {
+                const savedView = savedViewByItemKey.get(entry.threadKey);
+                if (!savedView) {
+                    staleEntryIds.push(entry.id);
+                    continue;
+                }
+                // Hidden Saved Views retain their exact membership and order, but are
+                // omitted from the visible hydrated directory until restored.
+                if (savedView.hiddenAt)
+                    continue;
+                const { threadKey: _storedItemKey, ...entryFields } = entry;
+                const item = {
+                    type: "saved_view",
+                    itemKey: entry.threadKey,
+                    title: savedView.title,
+                    savedView,
+                };
+                const hydratedEntry = {
+                    ...entryFields,
+                    itemKey: entry.threadKey,
+                    item,
+                };
+                const groupEntries = entriesByGroupId.get(entry.groupId);
+                if (groupEntries)
+                    groupEntries.push(hydratedEntry);
+                else
+                    entriesByGroupId.set(entry.groupId, [hydratedEntry]);
+                continue;
+            }
             const summary = summaryByThreadKey.get(entry.threadKey);
             if (!summary) {
                 if (isSyntheticMessengerThreadKey(entry.threadKey)) {
@@ -829,6 +914,13 @@ export function messengerService(db) {
             }
             const hydratedEntry = {
                 ...entry,
+                itemKey: entry.threadKey,
+                item: {
+                    type: "thread",
+                    itemKey: entry.threadKey,
+                    title: summary.title,
+                    thread: summary,
+                },
                 thread: summary,
             };
             const groupEntries = entriesByGroupId.get(entry.groupId);
@@ -891,15 +983,33 @@ export function messengerService(db) {
             .returning();
         return group;
     }
+    async function removeCustomGroup(orgId, userId, groupId, source) {
+        return db.transaction(async (tx) => {
+            const txDb = tx;
+            await lockMessengerSavedViewPlacement(txDb, orgId, userId);
+            await lockMessengerCustomGroupPlacement(txDb, orgId, userId, groupId);
+            await getCustomGroupOrThrowWithDb(txDb, orgId, userId, groupId);
+            const savedMemberships = (await txDb
+                .select({ threadKey: messengerCustomGroupEntries.threadKey })
+                .from(messengerCustomGroupEntries)
+                .where(and(eq(messengerCustomGroupEntries.orgId, orgId), eq(messengerCustomGroupEntries.userId, userId), eq(messengerCustomGroupEntries.groupId, groupId))))
+                .filter((entry) => Boolean(savedViewIdFromItemKey(entry.threadKey)));
+            for (const membership of savedMemberships) {
+                await logSavedViewPlacement(txDb, orgId, userId, membership.threadKey, "messenger.saved_view_group_removed", { groupId, source });
+            }
+            const [group] = await txDb
+                .delete(messengerCustomGroups)
+                .where(and(eq(messengerCustomGroups.orgId, orgId), eq(messengerCustomGroups.userId, userId), eq(messengerCustomGroups.id, groupId)))
+                .returning();
+            return group;
+        });
+    }
     async function separateCustomGroup(orgId, userId, groupId) {
-        await getCustomGroupOrThrow(orgId, userId, groupId);
-        const [group] = await db
-            .delete(messengerCustomGroups)
-            .where(and(eq(messengerCustomGroups.orgId, orgId), eq(messengerCustomGroups.userId, userId), eq(messengerCustomGroups.id, groupId)))
-            .returning();
-        return group;
+        return removeCustomGroup(orgId, userId, groupId, "group_separate");
+    }
+    async function deleteCustomGroup(orgId, userId, groupId) {
+        return removeCustomGroup(orgId, userId, groupId, "group_delete");
     }
-    const deleteCustomGroup = separateCustomGroup;
     async function reorderCustomGroups(orgId, userId, groupIds) {
         const uniqueGroupIds = [...new Set(groupIds)];
         if (uniqueGroupIds.length === 0)
@@ -922,16 +1032,15 @@ export function messengerService(db) {
         });
         return listCustomGroups(orgId, userId);
     }
-    async function assignThreadToCustomGroupWithClient(client, orgId, userId, groupId, threadKey) {
-        await ensureMessengerThreadCanBeGrouped(orgId, userId, threadKey);
-        const [lastEntry] = await client
+    async function assignThreadToCustomGroupWithClient(database, orgId, userId, groupId, threadKey) {
+        const [lastEntry] = await database
             .select({ sortOrder: messengerCustomGroupEntries.sortOrder })
             .from(messengerCustomGroupEntries)
             .where(and(eq(messengerCustomGroupEntries.orgId, orgId), eq(messengerCustomGroupEntries.userId, userId), eq(messengerCustomGroupEntries.groupId, groupId)))
             .orderBy(desc(messengerCustomGroupEntries.sortOrder))
             .limit(1);
         const now = new Date();
-        const [entry] = await client
+        const [entry] = await database
             .insert(messengerCustomGroupEntries)
             .values({
             orgId,
@@ -954,49 +1063,159 @@ export function messengerService(db) {
             },
         })
             .returning();
-        return entry;
+        if (savedViewIdFromItemKey(threadKey)) {
+            const { threadKey: _storedItemKey, ...entryFields } = entry;
+            return { ...entryFields, itemKey: threadKey };
+        }
+        return { ...entry, itemKey: threadKey };
     }
     async function assignThreadToCustomGroup(orgId, userId, groupId, threadKey) {
-        await getCustomGroupOrThrow(orgId, userId, groupId);
-        return assignThreadToCustomGroupWithClient(db, orgId, userId, groupId, threadKey);
+        const savedViewId = savedViewIdFromItemKey(threadKey);
+        if (!savedViewId) {
+            await ensureMessengerThreadCanBeGrouped(orgId, userId, threadKey);
+        }
+        return db.transaction(async (tx) => {
+            const txDb = tx;
+            // The owner lock keeps the source membership stable while we resolve and
+            // acquire all affected group locks. Saved placements also share it with
+            // Saved View delete, preventing a post-cleanup orphan insert.
+            await lockMessengerSavedViewPlacement(txDb, orgId, userId);
+            const [existingMembership] = await txDb
+                .select({ groupId: messengerCustomGroupEntries.groupId })
+                .from(messengerCustomGroupEntries)
+                .where(and(eq(messengerCustomGroupEntries.orgId, orgId), eq(messengerCustomGroupEntries.userId, userId), eq(messengerCustomGroupEntries.threadKey, threadKey)))
+                .limit(1);
+            const affectedGroupIds = [...new Set([existingMembership?.groupId, groupId].filter((id) => Boolean(id)))].sort();
+            for (const affectedGroupId of affectedGroupIds) {
+                await lockMessengerCustomGroupPlacement(txDb, orgId, userId, affectedGroupId);
+            }
+            await getCustomGroupOrThrowWithDb(txDb, orgId, userId, groupId);
+            if (savedViewId && !await findMessengerSavedViewWithDb(txDb, orgId, userId, threadKey)) {
+                throw notFound("Messenger Saved View not found");
+            }
+            const entry = await assignThreadToCustomGroupWithClient(txDb, orgId, userId, groupId, threadKey);
+            if (savedViewId) {
+                await logSavedViewPlacement(txDb, orgId, userId, threadKey, "messenger.saved_view_group_assigned", { groupId });
+            }
+            return entry;
+        });
     }
     async function createCustomGroupWithEntries(orgId, userId, name, icon, threadKeys) {
         const uniqueThreadKeys = [...new Set(threadKeys)];
         if (uniqueThreadKeys.length === 0)
             throw badRequest("At least one thread key is required");
+        const savedViewItemKeys = new Set();
+        for (const threadKey of uniqueThreadKeys) {
+            if (savedViewIdFromItemKey(threadKey))
+                savedViewItemKeys.add(threadKey);
+            else
+                await ensureMessengerThreadCanBeGrouped(orgId, userId, threadKey);
+        }
         await db.transaction(async (tx) => {
+            const txDb = tx;
+            await lockMessengerSavedViewPlacement(txDb, orgId, userId);
             const group = await createCustomGroupWithClient(tx, orgId, userId, name, icon);
+            await lockMessengerCustomGroupPlacement(txDb, orgId, userId, group.id);
             for (const threadKey of uniqueThreadKeys) {
-                await assignThreadToCustomGroupWithClient(tx, orgId, userId, group.id, threadKey);
+                if (savedViewItemKeys.has(threadKey) && !await findMessengerSavedViewWithDb(txDb, orgId, userId, threadKey)) {
+                    throw notFound("Messenger Saved View not found");
+                }
+                await assignThreadToCustomGroupWithClient(txDb, orgId, userId, group.id, threadKey);
+                await logSavedViewPlacement(txDb, orgId, userId, threadKey, "messenger.saved_view_group_assigned", {
+                    groupId: group.id,
+                    source: "group_create",
+                });
             }
         });
         return listCustomGroups(orgId, userId);
     }
     async function removeThreadFromCustomGroups(orgId, userId, threadKey) {
-        await db
-            .delete(messengerCustomGroupEntries)
-            .where(and(eq(messengerCustomGroupEntries.orgId, orgId), eq(messengerCustomGroupEntries.userId, userId), eq(messengerCustomGroupEntries.threadKey, threadKey)));
-        return { threadKey };
+        const savedViewId = savedViewIdFromItemKey(threadKey);
+        await db.transaction(async (tx) => {
+            const txDb = tx;
+            await lockMessengerSavedViewPlacement(txDb, orgId, userId);
+            if (savedViewId) {
+                if (!await findMessengerSavedViewWithDb(txDb, orgId, userId, threadKey)) {
+                    throw notFound("Messenger Saved View not found");
+                }
+            }
+            const [membership] = await txDb
+                .select({ id: messengerCustomGroupEntries.id, groupId: messengerCustomGroupEntries.groupId })
+                .from(messengerCustomGroupEntries)
+                .where(and(eq(messengerCustomGroupEntries.orgId, orgId), eq(messengerCustomGroupEntries.userId, userId), eq(messengerCustomGroupEntries.threadKey, threadKey)))
+                .limit(1);
+            if (!membership)
+                return;
+            await lockMessengerCustomGroupPlacement(txDb, orgId, userId, membership.groupId);
+            const deleted = await txDb
+                .delete(messengerCustomGroupEntries)
+                .where(and(eq(messengerCustomGroupEntries.id, membership.id), eq(messengerCustomGroupEntries.orgId, orgId), eq(messengerCustomGroupEntries.userId, userId), eq(messengerCustomGroupEntries.groupId, membership.groupId), eq(messengerCustomGroupEntries.threadKey, threadKey)))
+                .returning({ id: messengerCustomGroupEntries.id });
+            if (savedViewId && deleted.length > 0) {
+                await logSavedViewPlacement(txDb, orgId, userId, threadKey, "messenger.saved_view_group_removed", {
+                    groupId: membership.groupId,
+                    source: "item_remove",
+                });
+            }
+        });
+        return savedViewId ? { itemKey: threadKey } : { itemKey: threadKey, threadKey };
     }
     async function reorderCustomGroupEntries(orgId, userId, groupId, threadKeys) {
-        await getCustomGroupOrThrow(orgId, userId, groupId);
-        const entries = await db
-            .select()
-            .from(messengerCustomGroupEntries)
-            .where(and(eq(messengerCustomGroupEntries.orgId, orgId), eq(messengerCustomGroupEntries.userId, userId), eq(messengerCustomGroupEntries.groupId, groupId)))
-            .orderBy(asc(messengerCustomGroupEntries.sortOrder), asc(messengerCustomGroupEntries.createdAt));
-        const entryByThreadKey = new Map(entries.map((entry) => [entry.threadKey, entry]));
-        const orderedKeys = [
-            ...threadKeys.filter((threadKey) => entryByThreadKey.has(threadKey)),
-            ...entries.map((entry) => entry.threadKey).filter((threadKey) => !threadKeys.includes(threadKey)),
-        ];
-        const now = new Date();
+        if (new Set(threadKeys).size !== threadKeys.length) {
+            throw badRequest("Messenger custom group reorder keys must be unique");
+        }
+        for (const itemKey of threadKeys)
+            savedViewIdFromItemKey(itemKey);
         await db.transaction(async (tx) => {
-            for (const [index, threadKey] of orderedKeys.entries()) {
-                await tx
+            const txDb = tx;
+            await lockMessengerSavedViewPlacement(txDb, orgId, userId);
+            await lockMessengerCustomGroupPlacement(txDb, orgId, userId, groupId);
+            await getCustomGroupOrThrowWithDb(txDb, orgId, userId, groupId);
+            const entries = await txDb
+                .select()
+                .from(messengerCustomGroupEntries)
+                .where(and(eq(messengerCustomGroupEntries.orgId, orgId), eq(messengerCustomGroupEntries.userId, userId), eq(messengerCustomGroupEntries.groupId, groupId)))
+                .orderBy(asc(messengerCustomGroupEntries.sortOrder), asc(messengerCustomGroupEntries.createdAt));
+            const savedIds = entries
+                .map((entry) => savedViewIdFromItemKey(entry.threadKey))
+                .filter((id) => Boolean(id));
+            const savedViews = savedIds.length > 0
+                ? await txDb
+                    .select({ id: messengerSavedViews.id, hiddenAt: messengerSavedViews.hiddenAt })
+                    .from(messengerSavedViews)
+                    .where(and(eq(messengerSavedViews.orgId, orgId), eq(messengerSavedViews.userId, userId), inArray(messengerSavedViews.id, savedIds)))
+                : [];
+            const hiddenSavedIds = new Set(savedViews.filter((view) => view.hiddenAt).map((view) => view.id));
+            const visibleEntries = entries.filter((entry) => {
+                const savedViewId = savedViewIdFromItemKey(entry.threadKey);
+                return !savedViewId || !hiddenSavedIds.has(savedViewId);
+            });
+            const visibleByKey = new Map(visibleEntries.map((entry) => [entry.threadKey, entry]));
+            const requested = new Set(threadKeys);
+            const orderedKeys = [
+                ...threadKeys.filter((itemKey) => visibleByKey.has(itemKey)),
+                ...visibleEntries.map((entry) => entry.threadKey).filter((itemKey) => !requested.has(itemKey)),
+            ];
+            const visibleSlots = visibleEntries.map((entry) => entry.sortOrder);
+            const now = new Date();
+            const changedSavedItemKeys = [];
+            for (const [index, itemKey] of orderedKeys.entries()) {
+                const entry = visibleByKey.get(itemKey);
+                const nextSortOrder = visibleSlots[index];
+                if (!entry || nextSortOrder === undefined || entry.sortOrder === nextSortOrder)
+                    continue;
+                await txDb
                     .update(messengerCustomGroupEntries)
-                    .set({ sortOrder: index, updatedAt: now })
-                    .where(and(eq(messengerCustomGroupEntries.orgId, orgId), eq(messengerCustomGroupEntries.userId, userId), eq(messengerCustomGroupEntries.groupId, groupId), eq(messengerCustomGroupEntries.threadKey, threadKey)));
+                    .set({ sortOrder: nextSortOrder, updatedAt: now })
+                    .where(and(eq(messengerCustomGroupEntries.orgId, orgId), eq(messengerCustomGroupEntries.userId, userId), eq(messengerCustomGroupEntries.groupId, groupId), eq(messengerCustomGroupEntries.threadKey, itemKey)));
+                if (savedViewIdFromItemKey(itemKey))
+                    changedSavedItemKeys.push(itemKey);
+            }
+            for (const itemKey of changedSavedItemKeys) {
+                await logSavedViewPlacement(txDb, orgId, userId, itemKey, "messenger.saved_view_group_reordered", {
+                    groupId,
+                    itemKeys: orderedKeys,
+                });
             }
         });
         return listCustomGroups(orgId, userId);
@@ -1652,12 +1871,12 @@ export function messengerService(db) {
                 id: heartbeatRuns.id,
                 orgId: heartbeatRuns.orgId,
                 agentId: heartbeatRuns.agentId,
+                invocationSource: heartbeatRuns.invocationSource,
+                triggerDetail: heartbeatRuns.triggerDetail,
                 status: heartbeatRuns.status,
-                error: heartbeatRuns.error,
-                errorCode: heartbeatRuns.errorCode,
+                wakeupRequestId: heartbeatRuns.wakeupRequestId,
+                chatConversationId: heartbeatRuns.chatConversationId,
                 resultJson: heartbeatRuns.resultJson,
-                stderrExcerpt: heartbeatRuns.stderrExcerpt,
-                stdoutExcerpt: heartbeatRuns.stdoutExcerpt,
                 contextSnapshot: heartbeatRuns.contextSnapshot,
                 createdAt: heartbeatRuns.createdAt,
                 updatedAt: heartbeatRuns.updatedAt,
@@ -1675,7 +1894,8 @@ export function messengerService(db) {
         ]);
         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 origins = await hydrateMessengerFailedRunOrigins(db, orgId, runRows);
+        const items = runRows.map((run) => failedRunCard(run, agentNames.get(run.agentId) ?? null, origins.get(run.id)));
         const latestFirstItems = [...items].sort(compareLatestActivity);
         const chronologicalItems = [...items].sort(compareChronologicalActivity);
         const latestActivityAt = latestFirstItems[0]?.latestActivityAt ?? null;