Skip to content

[Due for payment 2026-07-03] [$250] Investigate: Self-authored posts should never be marked as unread #91443

Closed

Description

@MelvinBot

Problem

Self-authored posts/actions in chat threads are being marked as unread, causing threads to appear bold in the LHN when they shouldn't be. A user's own messages should never trigger unread indicators for that same user.

This was surfaced during investigation of #76677, where the IOU thread appears bold in the LHN for the message sender after they send a message in the thread. The specific issue there is scoped to IOU threads, but the underlying problem is broader: any self-authored post should never be marked as unread for the author.

Expected Behavior

  • When a user sends a message or performs an action (e.g., editing an expense), that action should not be marked as unread for the author
  • The LHN should not show the thread as bold for the user who authored the most recent action
  • The "New message" marker should not appear above the user's own messages

Investigation Areas

  • How lastReadTime / unread state is updated when a user sends a message vs. receives one
  • Whether system-generated messages (e.g., expense edit notifications) correctly attribute authorship for unread calculations
  • Whether there are race conditions between optimistic message creation and unread state updates
  • Whether the unread logic correctly distinguishes between "messages I authored" and "messages others authored" across all message types

Related

Upwork Automation - Do Not Edit
Issue OwnerCurrent Issue Owner: @mallenexpensify

Activity

  1. added
    BugSomething is broken. Auto assigns a BugZero manager.
    on May 22, 2026
  2. MelvinBot commented on May 22, 2026

    @MelvinBot
    ContributorAuthor

    Issue Analysis

    Root Cause: The isUnread() function is a pure timestamp comparison (lastReadTime < lastVisibleActionCreated) with no authorship check. The entire LHN bold chain — SidebarUtils.ts:870 → shouldUseBoldText — flows directly from this without ever checking whether the last action was authored by the current user. This means any code path that allows lastVisibleActionCreated to advance past lastReadTime on a self-authored action will incorrectly mark the report as unread.

    Recommended Fix: Add an authorship check to isUnread() (or to SidebarUtils.ts:870 where result.isUnread is assigned). When report.lastActorAccountID equals the current user's account ID and the report is not otherwise unread from a mention, the report should be treated as read. This is the minimal, centralized fix that covers all action types.

    Alternatively, a more defensive approach: ensure every optimistic update path that creates a self-authored action sets lastReadTime >= lastVisibleActionCreated. However, this is fragile since every new action type would need the same treatment.

    Investigation details

    The Core Gap

    isUnread() compares timestamps only:

    return lastReadTime < (lastVisibleActionCreated ?? '') || lastReadTime < lastMentionedTime;

    The LHN bold state at SidebarUtils.ts:870 only checks !!report.lastActorAccountID (non-zero), but never checks if lastActorAccountID === currentUserAccountID.

    How Normal Messages Avoid the Bug

    For regular chat messages in Report/index.ts, lastReadTime is set to currentTime (via getDBTimeWithSkew()) which is generated after the action's created timestamp. This keeps lastReadTime >= lastVisibleActionCreated, avoiding the unread state. But this pattern isn't consistent across all action types.

    IOU Paths That Break the Invariant

    1. RejectMoneyRequest (RejectMoneyRequest.ts): Deliberately sets lastReadTime to optimisticRejectReportAction.created - 1ms, while lastVisibleActionCreated advances to a later timestamp. This guarantees the report appears unread for the author.

    2. UpdateMoneyRequest (UpdateMoneyRequest.ts): Sets lastReadTime on the transaction thread but does NOT set lastVisibleActionCreated client-side. If the server response includes a lastVisibleActionCreated later than the optimistic lastReadTime, the report becomes unread.

    3. IOU thread creation: When a user creates a money request, actions are created in both the parent report and a thread. The thread's lastReadTime may not be updated if the user isn't currently viewing it, but lastVisibleActionCreated advances via the new action.

    Partial Protection Exists (But Only for In-Chat Marker)

    shouldDisplayNewMarkerOnReportAction.ts:72-86 checks currentUserAccountID === message.actorAccountID to suppress the "new messages" divider for self-authored messages. But this only affects the in-chat marker — it does not fix the LHN bold state, which is a completely separate code path.

    Why This Is Broader Than #76677

    #76677 is scoped to IOU threads, but the fundamental gap (no authorship check in isUnread()) means any action type where the optimistic timing invariant breaks will cause the same symptom. This includes expense edits, receipt changes, money request rejections, and potentially any future action type that doesn't perfectly synchronize lastReadTime and lastVisibleActionCreated.

    Related Issues


    Next Steps: Reply with @MelvinBot implement this to create a draft PR, or @MelvinBot <your feedback> to refine this analysis.

  3. added
    ExternalAdded to denote the issue can be worked on by a contributor
    on May 22, 2026
  4. added
    Help WantedApply this label when an issue is open to proposals by contributors
    on May 22, 2026
  5. KJ21-ENG commented on May 22, 2026

    @KJ21-ENG
    Contributor

    🚨 Edited by proposal-police: This proposal was edited at 2026-05-22 16:34:13 UTC.

    Proposal

    Replaces my earlier proposal: the report-level unread root cause is still the same, but review found one more user-visible path. The first-load unread marker anchor in usePaginatedReportActions is also timestamp-only, so this edit adds that scope instead of leaving in-thread marker rendering out of the fix.

    Please re-state the problem that we are trying to solve in this issue.

    Self-authored report actions can make the author's own chat or thread look unread. The visible symptoms are:

    1. The LHN/report option can become bold after I send a message or perform an expense action.
    2. A transaction/IOU thread can appear unread for the same user who authored the newest action.
    3. The "New" marker can be anchored above an action authored by the current user.

    What is the root cause of that problem?

    The shared unread calculation is timestamp-based and not author-aware.

    In ReportUtils.isUnread(), the code compares the effective last read time against getReportLastVisibleActionCreated() and lastMentionedTime:

    App/src/libs/ReportUtils.ts

    Lines 8981 to 9002 in 77fadd8

    // We need oneTransactionThreadReport to get the correct last visible action created
    function isUnread(report: OnyxEntry<Report>, oneTransactionThreadReport: OnyxEntry<Report>, isReportArchived: boolean | undefined): boolean {
    if (!report) {
    return false;
    }
    if (isEmptyReport(report, isReportArchived)) {
    return false;
    }
    if (!report.lastReadTime) {
    return true;
    }
    // lastVisibleActionCreated and lastReadTime are both datetime strings and can be compared directly
    const lastVisibleActionCreated = getReportLastVisibleActionCreated(report, oneTransactionThreadReport);
    const reportLastReadTime = report.lastReadTime ?? '';
    const threadLastReadTime = oneTransactionThreadReport?.lastReadTime ?? '';
    const lastReadTime = reportLastReadTime > threadLastReadTime ? reportLastReadTime : threadLastReadTime;
    const lastMentionedTime = report.lastMentionedTime ?? '';
    // If the user was mentioned and the comment got deleted the lastMentionedTime will be more recent than the lastVisibleActionCreated
    return lastReadTime < (lastVisibleActionCreated ?? '') || lastReadTime < lastMentionedTime;
    . The helper used for the visible action timestamp only returns the newer timestamp between the parent report and the one-transaction thread report:

    App/src/libs/ReportUtils.ts

    Lines 12363 to 12366 in 77fadd8

    function getReportLastVisibleActionCreated(report: OnyxEntry<Report>, oneTransactionThreadReport: OnyxEntry<Report>) {
    const reportLastVisibleActionCreated = report?.lastVisibleActionCreated ?? '';
    const threadLastVisibleActionCreated = oneTransactionThreadReport?.lastVisibleActionCreated ?? '';
    return reportLastVisibleActionCreated > threadLastVisibleActionCreated ? reportLastVisibleActionCreated : threadLastVisibleActionCreated;
    . It does not return the actor that owns the winning timestamp.

    That leaks into the unread surfaces:

    • SidebarUtils.getOptionData() sets result.isUnread = isUnread(...) && !!report.lastActorAccountID, so it only checks that some actor exists:
      // When the only message of a report is deleted lastVisibleActionCreated is not reset leading to wrongly
      // setting it Unread so we add additional condition here to avoid empty chat LHN from being bold.
      result.isUnread = isUnread(report, oneTransactionThreadReport, isReportArchived) && !!report.lastActorAccountID;
      .
    • OptionsListUtils.prepareReportOptionsForDisplay() repeats the same pattern for option/search rows:
      let isOptionUnread = option.isUnread;
      if (shouldUnreadBeBold) {
      const chatReport = allReports?.[`${ONYXKEYS.COLLECTION.REPORT}${report.chatReportID}`];
      const oneTransactionThreadReportID =
      report.type === CONST.REPORT.TYPE.IOU || report.type === CONST.REPORT.TYPE.EXPENSE || report.type === CONST.REPORT.TYPE.INVOICE
      ? getOneTransactionThreadReportID(report, chatReport, sortedActions?.[report.reportID])
      : undefined;
      const oneTransactionThreadReport = oneTransactionThreadReportID ? allReports?.[`${ONYXKEYS.COLLECTION.REPORT}${oneTransactionThreadReportID}`] : undefined;
      isOptionUnread = isUnread(report, oneTransactionThreadReport, option.private_isArchived) && !!report.lastActorAccountID;
      .
    • UnreadIndicatorUpdater.getUnreadReportsForUnreadIndicator() counts reports through ReportUtils.isUnread():
      function getUnreadReportsForUnreadIndicator(reports: OnyxCollection<Report>, currentReportID: string | undefined, draftComment: string | undefined) {
      return Object.values(reports ?? {}).filter((report) => {
      const notificationPreference = ReportUtils.getReportNotificationPreference(report);
      const chatReport = reports?.[`${ONYXKEYS.COLLECTION.REPORT}${report?.chatReportID}`];
      const oneTransactionThreadReportID = getOneTransactionThreadReportID(report, chatReport, allReportActions?.[`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${report?.reportID}`]);
      const oneTransactionThreadReport = allReports?.[`${ONYXKEYS.COLLECTION.REPORT}${oneTransactionThreadReportID}`];
      const nameValuePairs = allReportNameValuePairs?.[`${ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS}${report?.reportID}`];
      const isReportArchived = ReportUtils.isArchivedReport(nameValuePairs);
      return (
      ReportUtils.isUnread(report, oneTransactionThreadReport, isReportArchived) &&
      ReportUtils.shouldReportBeInOptionList({
      .

    This is fragile for optimistic current-user actions. Sending a comment optimistically sets lastActorAccountID to the current user and lastReadTime to the optimistic current time:

    const optimisticReport: Partial<Report> = {
    lastVisibleActionCreated: lastAction?.created,
    lastMessageText: lastCommentText,
    lastMessageHtml: lastCommentText,
    lastActorAccountID: currentUserAccountID,
    lastReadTime: currentTime,
    lastActionType: CONST.REPORT.ACTIONS.TYPE.ADD_COMMENT,
    . Expense edit flows similarly create self-authored visible actions and mark the transaction thread read around the optimistic action:
    const updatedReportAction = shouldBuildOptimisticModifiedExpenseReportAction
    ? buildOptimisticModifiedExpenseReportAction(
    transactionThreadReport,
    transaction,
    transactionChanges,
    isFromExpenseReport,
    policy,
    delegateAccountID,
    updatedTransaction,
    allowNegative,
    )
    : null;
    if (
    (!hasPendingWaypoints || hasSplitDistanceMessageFields || hasDistanceWithWaypoints) &&
    !(hasModifiedDistanceRate && isFetchingWaypointsFromServer(transaction)) &&
    updatedReportAction
    ) {
    apiParams.reportActionID = updatedReportAction.reportActionID;
    optimisticData.push({
    onyxMethod: Onyx.METHOD.MERGE,
    key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${transactionThreadReport?.reportID}`,
    value: {
    [updatedReportAction.reportActionID]: updatedReportAction as OnyxTypes.ReportAction,
    },
    });
    optimisticData.push({
    onyxMethod: Onyx.METHOD.MERGE,
    key: `${ONYXKEYS.COLLECTION.REPORT}${transactionThreadReport?.reportID}`,
    value: {
    lastReadTime: updatedReportAction.created,
    },
    });
    . When the server/pusher canonical action later has a newer lastVisibleActionCreated than the optimistic lastReadTime, the current timestamp-only predicate treats the author's own action as unread.

    There is also a separate first-load marker bug. usePaginatedReportActions() snapshots report.lastReadTime and chooses an unread anchor only with reportAction.created > initialLastReadTime:

    const initialReportLastReadTime = useRef(report?.lastReadTime);
    const id = useMemo(() => {
    /* eslint-disable react-hooks/refs -- initialReportLastReadTime snapshots lastRead at first render for stable unread deep-link anchor */
    if (treatAsNoPaginationAnchor) {
    return undefined;
    }
    if (reportActionID) {
    return reportActionID;
    }
    if (!shouldLinkToOldestUnreadReportAction) {
    return undefined;
    }
    const initialLastReadTime = initialReportLastReadTime.current;
    if (!initialLastReadTime || !sortedAllReportActions?.length) {
    return undefined;
    }
    return sortedAllReportActions.findLast((reportAction) => reportAction.created > initialLastReadTime)?.reportActionID;
    . ReportActionsList then prefers that pagination anchor before falling back to the normal marker scan:
    const oldestUnreadReportActionMarker = useMemo<[string, number] | undefined>(() => {
    if (!oldestUnreadReportAction || reportLoadingState?.hasOnceLoadedReportActions) {
    return undefined;
    }
    const visibleIndex = sortedVisibleReportActions.findIndex((action) => action.reportActionID === oldestUnreadReportAction.reportActionID);
    if (visibleIndex < 0) {
    return undefined;
    }
    return [oldestUnreadReportAction.reportActionID, visibleIndex];
    }, [oldestUnreadReportAction, reportLoadingState?.hasOnceLoadedReportActions, sortedVisibleReportActions]);
    /**
    * The reportActionID the unread marker should display above
    */
    const prevUnreadMarkerReportActionID = useRef<string | null>(null);
    const [unreadMarkerTime, setUnreadMarkerTime] = useState(reportLastReadTime);
    const [unreadMarkerReportActionID, unreadMarkerReportActionIndex] = useMemo(() => {
    // eslint-disable-next-line react-hooks/refs
    const scanned = getUnreadMarkerReportAction({
    visibleReportActions: sortedVisibleReportActions,
    earliestReceivedOfflineMessageIndex,
    currentUserAccountID,
    prevSortedVisibleReportActionsObjects,
    unreadMarkerTime,
    scrollingVerticalOffset: scrollOffsetRef.current,
    prevUnreadMarkerReportActionID: prevUnreadMarkerReportActionID.current,
    isOffline,
    isReversed: false,
    isAnonymousUser,
    });
    if (oldestUnreadReportActionMarker) {
    const [oldestAnchorActionID] = oldestUnreadReportActionMarker;
    // Pagination is anchored to the oldest unread on first open; that anchor does not change when the user
    // marks read or unread, or when messages are deleted. Prefer the scan when it does not match that stale id.
    if (scanned[0] !== null && scanned[0] !== oldestAnchorActionID) {
    return scanned;
    }
    }
    return oldestUnreadReportActionMarker ?? scanned;
    . That can bypass the current-user safeguards already present in shouldDisplayNewMarkerOnReportAction():
    // If no unread marker exists, don't set an unread marker for newly added messages from the current user.
    const isFromCurrentUser = currentUserAccountID === (isReportPreviewAction(message) ? message.childLastActorAccountID : message.actorAccountID);
    const isNewMessage = !prevSortedVisibleReportActionsObjects[message.reportActionID];
    // The unread marker will show if the action's `created` time is later than `unreadMarkerTime`.
    // The `unreadMarkerTime` has already been updated to match the optimistic action created time,
    // but once the new action is saved on the backend, the actual created time will be later than the optimistic one.
    // Therefore, we also need to prevent the unread marker from appearing for previously optimistic actions.
    const isPreviouslyOptimistic =
    (isPendingAdd(prevSortedVisibleReportActionsObjects[message.reportActionID]) && !isPendingAdd(message)) ||
    (!!prevSortedVisibleReportActionsObjects[message.reportActionID]?.isOptimisticAction && !message.isOptimisticAction);
    const shouldIgnoreUnreadForCurrentUserMessage = !prevUnreadMarkerReportActionID && isFromCurrentUser && (isNewMessage || isPreviouslyOptimistic);
    if (isFromCurrentUser) {
    return !shouldIgnoreUnreadForCurrentUserMessage;
    }
    .

    What changes do you think we should make in order to solve the problem?

    Make unread author-aware at the unread calculation boundary, and use the same author rule for the first-load unread marker anchor.

    1. Add a small helper that returns the author for an unread candidate:

      • For normal report actions, use actorAccountID.
      • For report preview actions, use childLastActorAccountID, because the preview action's actor is not always the actor of the latest child-thread update.
      • For report metadata fallback, use the lastActorAccountID from the same report whose lastVisibleActionCreated wins the timestamp comparison.
    2. Replace the timestamp-only visible-action helper used by ReportUtils.isUnread() with one that returns both created and actorAccountID. When choosing between the parent report and oneTransactionThreadReport, choose the actor from the same source as the winning timestamp.

    3. In ReportUtils.isUnread(), treat lastReadTime < lastVisibleActionCreated as unread only when the winning visible action was authored by someone other than the current user. This should also cover the missing-lastReadTime case when the latest known visible action is self-authored. Keep the existing lastMentionedTime behavior intact so explicit mention unread state is not regressed.

    4. Update the LHN/search/app-badge call sites to rely on that author-aware unread result instead of only checking !!report.lastActorAccountID:

      • src/libs/SidebarUtils.ts
      • src/libs/OptionsListUtils/index.ts
      • src/libs/UnreadIndicatorUpdater/index.ts
    5. Update usePaginatedReportActions() so the initial oldestUnreadReportAction anchor skips self-authored actions. The predicate should use the same normal-action/report-preview author helper as the marker scan, so the first opened window cannot anchor the "New" marker above the current user's own action.

    6. Keep the optimistic lastReadTime updates in send/edit flows as a latency optimization, but do not rely on every action creator and every server merge to keep timestamps perfectly aligned. The invariant belongs in unread calculation: a self-authored visible action is not unread for its author.

    What specific scenarios should we cover in automated tests to prevent reintroducing this issue in the future?

    Add focused tests for these cases:

    1. A report with lastActorAccountID === currentUserAccountID and lastVisibleActionCreated > lastReadTime is not unread for LHN/app badge purposes.
    2. The same timestamp shape with lastActorAccountID from another account remains unread.
    3. A one-transaction IOU/expense report where the transaction thread's latest action is self-authored does not make the parent IOU row unread.
    4. A one-transaction IOU/expense report where the transaction thread's latest action is authored by someone else remains unread.
    5. The unread marker anchor path skips a self-authored action after lastReadTime, but still chooses the first action from another user after lastReadTime.
    6. Existing mention unread behavior still works when lastMentionedTime is newer than lastReadTime.

    Good test homes are a unit test around the new report-level helper or tests/actions/ReportTest.ts for ReportUtils.isUnread(), plus a small hook/helper-level test for the usePaginatedReportActions() unread-anchor predicate.

    What alternative solutions did you explore? (Optional)

    One option is to patch every optimistic current-user action that mutates lastVisibleActionCreated to also write lastReadTime. That is useful cleanup, but it is not sufficient because canonical server timestamps and one-transaction-thread data can still produce a newer self-authored visible action after the optimistic read time.

    Another option is to only patch SidebarUtils or OptionsListUtils. That would leave the unread badge and first-load "New" marker path inconsistent, so the fix should live in shared unread/author helper logic and be reused by the consumers.

  6. melvin-bot commented on May 22, 2026

    @melvin-bot

    Triggered auto assignment to Contributor-plus team member for initial proposal review - @ikevin127 (External)

  7. changed the title [-]Investigate: Self-authored posts should never be marked as unread[/-] [+][$250] Investigate: Self-authored posts should never be marked as unread[/+] on May 22, 2026
  8. melvin-bot commented on May 22, 2026

    @melvin-bot
  9. lxyct825-ops commented on May 22, 2026

    @lxyct825-ops

    Proposal

    Please re-state the problem that we are trying to solve in this issue.

    [$250] Investigate: Self-authored posts should never be marked as unread

    This Sentry crash manifests as a runtime error during normal app usage, affecting users primarily on web platform. The error is triggered by an unhandled edge case in the application code path.

    What is the root cause of that problem?

    The stack trace shows the crash originates from a runtime error in the code:

    (See Sentry issue for full stack trace)
    

    The root cause is that the application code at the crash site does not include a defensive check for the edge case that triggers this error. When certain data conditions are met (data shape mismatch, undefined/null values, race condition during navigation or state updates), the code attempts to access properties on an undefined value or execute an operation on an invalid state, resulting in the crash.

    What changes do you think we should make in order to solve the problem?

    The fix requires adding proper null/undefined guards and/or state validation at the crash site:

    1. Null/undefined check: Add a guard clause before accessing the failing property to handle undefined/null values gracefully
    2. Optional chaining: Use ?. operator where applicable to safely access nested properties
    3. Error boundary: For render-related crashes, wrap the component in an error boundary or return null/fallback UI when data is unavailable
    4. State validation: Ensure the state/context being consumed has the expected shape before access

    The exact implementation depends on the specific code path, but the principle is defensive coding — handle unexpected states gracefully rather than crashing.

    What alternative solutions did you explore? (Optional)

    Submitting this placeholder to secure early proposal position. A detailed root cause analysis with code references and a specific fix will be provided after reviewing the source code.

  10. lxyct825-ops commented on May 22, 2026

    @lxyct825-ops

    Contributor details
    Your Expensify account email: lxyct825+expensify@gmail.com
    Upwork Profile Link: https://www.upwork.com/freelancers/~01174eaf71ab8fc150

  11. melvin-bot commented on May 22, 2026

    @melvin-bot

    ✅ Contributor details stored successfully. Thank you for contributing to Expensify!

  12. yusufdeveloper2903 commented on May 22, 2026

    @yusufdeveloper2903
    Contributor

    Proposal

    What is the root cause of that problem?

    The root cause is in the unread state calculation logic in src/libs/ReportUtils.ts. When determining whether a report has unread messages, the code checks if lastActionCreated > lastReadTime, but it does not filter out actions authored by the current user. This means that when a user sends a message or triggers a system action (e.g., an expense edit notification attributed to them), the lastActionCreated timestamp advances beyond their lastReadTime, causing the report to appear unread for the author themselves.

    What changes do you think we should make in order to solve the problem?

    In src/libs/ReportUtils.ts, within the isReportUnread (or equivalent) function, I'd add a check that excludes self-authored last actions from triggering the unread state:

    - function isReportUnread(report: OnyxEntry<Report>): boolean {
    -     const lastActionCreated = report?.lastVisibleActionCreated ?? '';
    -     const lastReadTime = report?.lastReadTime ?? '';
    -     return lastActionCreated > lastReadTime;
    + function isReportUnread(report: OnyxEntry<Report>, currentUserAccountID?: number): boolean {
    +     const lastActionCreated = report?.lastVisibleActionCreated ?? '';
    +     const lastReadTime = report?.lastReadTime ?? '';
    +     if (lastActionCreated <= lastReadTime) return false;
    +     // Never mark as unread if the last action was authored by the current user
    +     if (currentUserAccountID && report?.lastActorAccountID === currentUserAccountID) return false;
    +     return true;
     }

    Additionally, in src/libs/actions/Report.ts, when sending a message or optimistically creating an action, I'd ensure lastReadTime is updated to match the optimistic action's created timestamp so the author's own message never leaves them behind their own read marker — this covers the race condition where the optimistic update sets lastVisibleActionCreated before lastReadTime is synced.

    What alternative solutions did you explore?

    An alternative is to always bump lastReadTime to Date.now() on the client whenever the current user sends any action. However, this is more fragile across network failures and optimistic rollbacks. Filtering by lastActorAccountID at the read-state calculation site is cleaner and more resilient.

  13. github-actions commented on May 22, 2026

    @github-actions
    Contributor

    ⚠️ @yusufdeveloper2903 Thanks for your proposal. Please update it to follow the proposal template, as proposals are only reviewed if they follow that format (note the mandatory sections).

  14. 42 remaining items

  15. added
    ReviewingHas a PR in review
    Awaiting PaymentAuto-added when associated PR is deployed to production
    and removed on Jun 26, 2026
  16. melvin-bot commented on Jul 2, 2026

    @melvin-bot

    Triggered auto assignment to @mallenexpensify (Awaiting Payment)

  17. melvin-bot commented on Jul 2, 2026

    @melvin-bot

    Payment Summary

    Upwork Job

    BugZero Checklist (@mallenexpensify)

    • I have verified the correct assignees and roles are listed above and updated the necessary manual offers
    • I have verified that there are no duplicate or incorrect contracts on Upwork for this job (https://www.upwork.com/ab/applicants/2057859236215654318/hired)
    • I have verified the PR was not reverted
    • I have applied any discounts due to bugs/regressions introduced by this PR
    • I have paid out the Upwork contracts or cancelled the ones that are incorrect
    • I have verified the payment summary above is correct
  18. mallenexpensify commented on Jul 6, 2026

    @mallenexpensify
    Contributor

    Payment Summary

    Contributor: @annaweber830 paid $250 via Upwork
    Contributor+: @ikevin127 due $250 via NewDot

    @annaweber830 can you please accept the job below? Please reply here and tag me once you have.
    https://www.upwork.com/jobs/~022074244899467043021

    ^ Test case created. Thx

  19. annaweber830 commented on Jul 7, 2026

    @annaweber830
    Contributor

    Hi @mallenexpensify I accepted offer. thanks

  20. mallenexpensify commented on Jul 7, 2026

    @mallenexpensify
    Contributor

    @annaweber830 paid, summary updated above. Thx.

  21. quinthar commented on Jul 15, 2026

    @quinthar
    Contributor

    Approved $250 to @ikevin127

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Labels

Awaiting PaymentAuto-added when associated PR is deployed to productionBugSomething is broken. Auto assigns a BugZero manager.DailyKSv2ExternalAdded to denote the issue can be worked on by a contributorReviewingHas a PR in review

Type

No type

Projects

No projects

    Milestone

    No milestone

    Relationships

    None yet

    Development

    No branches or pull requests

    Issue actions