Skip to content

[Due for payment 2026-04-28] [CMB] [$250] Notifications - A notification is received by submitter when admin edits expense description #87467

Closed

Description

@jponikarchuk

If you haven’t already, check out our contributing guidelines for onboarding and email contributors@expensify.com to request to join our Slack channel!


Version Number: 9.3.55-0
Reproducible in staging?: Yes
Reproducible in production?: Yes
If this was caught during regression testing, add the test name, ID and link from BrowserStack: #87034
Email or phone of affected tester (no customers): ibellicotest+2250@gmail.com
Issue reported by: Applause Internal Team
Bug source: Pull Request QA execution
Device used: Motorola MotoG60 / Android 12 (Hybrid app)
App Component: Notifications

Action Performed:

Prerequisite: Require two accounts in a policy, a submitter and a manager. (User A as submitter and User B as manager/owner)

  1. Open the Expensify app as User A.
  2. Open workspace chat where User B is manager.
  3. Create a manual expense.
  4. Open report of the just created expense and send a message.
  5. Navigate away from report to "Inbox"
  6. As User B, open the expense created by User A.
  7. Tap on "Description" field, add a description and save.
  8. As User A, note that a notification is received showing that manager just edited the description of the expense.

Expected Result:

Notifications shouldn´t be received for non-actionable actions on a report, such as the edition of description.

Actual Result:

Submitter of a workspace receives a notification after the manager edits the description of an expense.

Workaround:

Unknown

Platforms:

  • Android: App
  • Android: mWeb Chrome
  • iOS: App
  • iOS: mWeb Safari
  • iOS: mWeb Chrome
  • Windows: Chrome
  • MacOS: Chrome / Safari

Screenshots/Videos

Video.mp4

View all open jobs on GitHub

Issue OwnerCurrent Issue Owner: @bernhardoj
Upwork Automation - Do Not Edit
  • Upwork Job URL: https://www.upwork.com/jobs/~022042163892991660040
  • Upwork Job ID: 2042163892991660040
  • Last Price Increase: 2026-04-09

Activity

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

    @MelvinBot
    Contributor

    Proposal

    What is the root cause of that problem?

    Push notifications for expense modifications are controlled by a two-layer system:

    1. Server-side (Web-Expensify/lib/MobilePushNotifications.php): Decides to send push notifications via Airship and populates actionableForAccountIDs in the MODIFIEDEXPENSE report action's originalMessage.
    2. Client-side (src/libs/ReportActionsUtils.ts:1008-1033): The isActionable() function checks if the current user's accountID is in actionableForAccountIDs to decide whether to display the notification.

    The bug is that the server includes the submitter's accountID in actionableForAccountIDs for all expense modifications, including non-actionable edits like description changes. Additionally, the client-side filter (shouldShowPushNotification.ts) only runs as a foreground display predicate (ForegroundNotifications/index.android.ts:6, index.ios.ts:17). When the app is backgrounded, the OS displays the push notification directly from Airship with no client-side filtering opportunity.

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

    The fix should be server-side in Web-Expensify/lib/MobilePushNotifications.php: when creating MODIFIEDEXPENSE report actions for non-financially-relevant modifications (description, category, tag, comment), the server should either:

    • Not include the submitter in actionableForAccountIDs, OR
    • Not send a push notification at all for these modification types

    This is the only reliable fix because background push notifications bypass all client-side filtering.

    What alternative solutions did you explore?

    Client-side filtering was considered but is insufficient: shouldShowPushNotification.ts is registered as a foreground display predicate on both Android and iOS. When the app is backgrounded (the common case for receiving notifications), the OS shows whatever the server sends without consulting the client. The isActionable() check at ReportActionsUtils.ts:1028-1032 would correctly suppress these notifications, but only when the foreground predicate is actually invoked.

    Supporting evidence
    • isActionable() at src/libs/ReportActionsUtils.ts:1008-1033 does NOT include MODIFIED_EXPENSE in actionableTypes, falling through to actionableForAccountIDs check
    • shouldShowReportActionNotification() at src/libs/actions/Report/index.ts:4107-4110 gates on isActionable()
    • Foreground-only registration at ForegroundNotifications/index.android.ts:6 and index.ios.ts:17
    • Local notifications are no-ops on native mobile (Notification/LocalNotification/index.native.ts)
    • Test at tests/unit/showReportActionNotificationTest.ts:154-170 confirms: without actionableForAccountIDs, MODIFIEDEXPENSE notifications are suppressed

    Next Steps for Contributor+ team: Reply with @MelvinBot implement this to create a draft PR, @MelvinBot <your feedback> to refine this analysis, or explain why you are rejecting Melvin's proposal.

  3. added
    ExternalAdded to denote the issue can be worked on by a contributor
    on Apr 9, 2026
  4. added
    Help WantedApply this label when an issue is open to proposals by contributors
    on Apr 9, 2026
  5. melvin-bot commented on Apr 9, 2026

    @melvin-bot

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

  6. MobileMage commented on Apr 9, 2026

    @MobileMage
    Contributor

    Proposal

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

    When a workspace admin edits a description (or other non-actionable field) on an expense created by a submitter, the submitter receives a push notification on mobile even though the change requires no action from them.

    What is the root cause of that problem?

    PR #87034 added an isActionable guard in shouldShowReportActionNotification so that non-actionable report actions (like MODIFIED_EXPENSE) no longer trigger local or foreground push notifications. However, that guard only applies when data.type is not 'transaction'. In shouldShowPushNotification.ts, there is a hard-coded early return that unconditionally shows any notification whose payload type is 'transaction', before the isActionable check is ever reached.

    Editing an expense description modifies a transaction field, so the server sends a push notification with type === 'transaction'. The client receives this and immediately returns shouldShow = true on line 32 without consulting shouldShowReportActionNotification at all. The MODIFIED_EXPENSE report action that accompanies the update is never examined.

    let shouldShow = false;
    if (data.type === 'transaction') {
    shouldShow = true;
    } else {
    const reportAction = ReportActionUtils.getLatestReportActionFromOnyxData(data.onyxData ?? null);
    shouldShow = Report.shouldShowReportActionNotification(String(data.reportID), currentUserAccountID, reportAction, true);
    }

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

    The 'transaction' branch in shouldShowPushNotification should not blindly return true. Instead, it should apply the same shouldShowReportActionNotification check used for other notification types, extracting the associated report action from onyxData. If no report action is present in the payload (stripped payload), the notification should still be shown since we cannot determine it is non-actionable — this preserves the existing safe-default behavior for payloads that lack action data.

    import type {PushPayload} from '@ua/react-native-airship';
    import Onyx from 'react-native-onyx';
    import Log from '@libs/Log';
    import * as ReportActionUtils from '@libs/ReportActionsUtils';
    import * as Report from '@userActions/Report';
    import CONST from '@src/CONST';
    import ONYXKEYS from '@src/ONYXKEYS';
    import parsePushNotificationPayload from './parsePushNotificationPayload';
    // We do not depend on updates on the UI for notifications, so we can use `connectWithoutView` here.
    let currentUserAccountID = -1;
    Onyx.connectWithoutView({
    key: ONYXKEYS.SESSION,
    callback: (value) => {
    currentUserAccountID = value?.accountID ?? CONST.DEFAULT_NUMBER_ID;
    },
    });
    /**
    * Returns whether the given Airship notification should be shown depending on the current state of the app
    */
    export default function shouldShowPushNotification(pushPayload: PushPayload): boolean {
    Log.info('[PushNotification] push notification received', false, {pushPayload});
    const data = parsePushNotificationPayload(pushPayload.extras.payload);
    if (!data) {
    return true;
    }
    let shouldShow = false;
    if (data.type === 'transaction') {
    shouldShow = true;
    } else {
    const reportAction = ReportActionUtils.getLatestReportActionFromOnyxData(data.onyxData ?? null);
    shouldShow = Report.shouldShowReportActionNotification(String(data.reportID), currentUserAccountID, reportAction, true);
    }
    Log.info(`[PushNotification] ${shouldShow ? 'Showing' : 'Not showing'} notification`);
    return shouldShow;
    }

         let shouldShow = false;
    -    if (data.type === 'transaction') {
    -        shouldShow = true;
    -    } else {
    -        const reportAction = ReportActionUtils.getLatestReportActionFromOnyxData(data.onyxData ?? null);
    -        shouldShow = Report.shouldShowReportActionNotification(String(data.reportID), currentUserAccountID, reportAction, true);
    -    }
    +    const reportAction = ReportActionUtils.getLatestReportActionFromOnyxData(data.onyxData ?? null);
    +    if (data.type === 'transaction' && !reportAction) {
    +        // Payload was stripped — we cannot determine actionability, so show the notification.
    +        shouldShow = true;
    +    } else {
    +        shouldShow = Report.shouldShowReportActionNotification(String(data.reportID), currentUserAccountID, reportAction, true);
    +    }

    With this change, transaction-type notifications that carry a MODIFIED_EXPENSE action in their onyxData will go through shouldShowReportActionNotification → isActionable → false → notification suppressed. Transaction-type notifications with stripped payloads (no action available) still show as before, preserving the safe fallback. All other notification types are unaffected.

    What alternative solutions did you explore? (Optional)

    N/A

  7. changed the title [-]Notifications - A notification is received by submitter when admin edits expense description[/-] [+][$250] Notifications - A notification is received by submitter when admin edits expense description[/+] on Apr 9, 2026
  8. melvin-bot commented on Apr 9, 2026

    @melvin-bot
  9. twilight2294 commented on Apr 9, 2026

    @twilight2294
    Contributor

    Proposal

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

    When an admin edits only the description of an expense, the submitter receives a notification even though this change requires no action from them.

    What is the root cause of that problem?

    shouldShowReportActionNotification() in Report has no filtering for MODIFIED_EXPENSE actions. It checks whether the action is deleted, whether the actor is the current user, whether the report is currently visible, etc. — but it never inspects what was modified. So a description-only edit passes every gate and triggers a notification to the submitter via both the foreground push filter in shouldShowPushNotification and the Onyx-driven path in triggerNotifications.

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

    In shouldShowReportActionNotification() in Report, after the existing whisper check, add a guard that suppresses notifications for description-only expense modifications:

    if (action && ReportActionsUtils.isModifiedExpenseAction(action)) {
        const originalMessage = ReportActionsUtils.getOriginalMessage(
            action as ReportAction<typeof CONST.REPORT.ACTIONS.TYPE.MODIFIED_EXPENSE>,
        );
        if (
            originalMessage &&
            (originalMessage.oldComment !== undefined || originalMessage.newComment !== undefined) &&
            !originalMessage.oldAmount && !originalMessage.amount &&
            !originalMessage.oldMerchant && !originalMessage.merchant &&
            !originalMessage.oldCategory && !originalMessage.category &&
            !originalMessage.oldTag && !originalMessage.tag &&
            !originalMessage.oldCurrency && !originalMessage.currency
        ) {
            return false;
        }
    }

    This checks the OriginalMessageModifiedExpense fields (defined in OriginalMessage) to confirm only the comment/description changed, with no financially relevant modifications.

    What alternative solutions did you explore?

    MelvinBot's proposal suggests this must be fixed exclusively on the API side, arguing that client-side filtering cannot suppress background push notifications. That analysis is partially correct for OS-level push delivery, but it overlooks the Onyx-driven notification path: triggerNotifications() in User calls showReportActionNotification() which calls shouldShowReportActionNotification() — this path runs regardless of app state and is where the client controls notification display. Fixing shouldShowReportActionNotification provides concrete, immediately deployable coverage in the App repo with a targeted field-level check, rather than a broad directive to change API behavior.

  10. abbasifaizan70 commented on Apr 9, 2026

    @abbasifaizan70
    Contributor

    Proposal

    What is the root cause of that problem?

    This happens because description edits are created as MODIFIED_EXPENSE actions, and notification gating treats them as actionable when actionableForAccountIDs includes the submitter. There is no special check to suppress notifications for description-only expense edits (which are non-actionable for this flow).

    App/src/libs/ReportUtils.ts

    Lines 5591 to 5605 in 441332c

    function getModifiedExpenseOriginalMessage(
    oldTransaction: OnyxInputOrEntry<Transaction>,
    transactionChanges: TransactionChanges,
    isFromExpenseReport: boolean,
    policy: OnyxInputOrEntry<Policy>,
    updatedTransaction?: OnyxInputOrEntry<Transaction>,
    allowNegative = false,
    ): OriginalMessageModifiedExpense {
    const originalMessage: OriginalMessageModifiedExpense = {};
    // Remark: Comment field is the only one which has new/old prefixes for the keys (newComment/ oldComment),
    // all others have old/- pattern such as oldCreated/created
    if ('comment' in transactionChanges) {
    originalMessage.oldComment = getDescription(oldTransaction);
    originalMessage.newComment = transactionChanges?.comment;
    }

    function shouldShowReportActionNotification(reportID: string, currentUserAccountID: number, action: ReportAction | null = null, isRemote = false): boolean {
    const tag = isRemote ? '[PushNotification]' : '[LocalNotification]';
    const topmostReportID = Navigation.getTopmostReportId();
    // Due to payload size constraints, some push notifications may have their report action stripped
    // so we must double check that we were provided an action before using it in these checks.
    if (action && ReportActionsUtils.isDeletedAction(action)) {
    Log.info(`${tag} Skipping notification because the action was deleted`, false, {reportID, action});
    return false;
    }
    if (!ActiveClientManager.isClientTheLeader()) {
    Log.info(`${tag} Skipping notification because this client is not the leader`);
    return false;
    }
    // We don't want to send a local notification if the user preference is daily, mute or hidden.
    const notificationPreference = getReportNotificationPreference(allReports?.[`${ONYXKEYS.COLLECTION.REPORT}${reportID}`]);
    if (notificationPreference !== CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS) {
    Log.info(`${tag} No notification because user preference is to be notified: ${notificationPreference}`);
    return false;
    }
    // If this comment is from the current user we don't want to parrot whatever they wrote back to them.
    if (action && action.actorAccountID === currentUserAccountID) {
    Log.info(`${tag} No notification because comment is from the currently logged in user`);
    return false;
    }
    // If we are currently viewing this report do not show a notification.
    if (reportID === topmostReportID && Visibility.isVisible() && Visibility.hasFocus()) {
    Log.info(`${tag} No notification because it was a comment for the current report`);
    return false;
    }
    // If the report is a transaction thread and we are currently viewing the associated one-transaction report do no show a notification.
    const topmostReport = allReports?.[`${ONYXKEYS.COLLECTION.REPORT}${topmostReportID}`];
    const topmostReportActions = allReportActions?.[`${topmostReport?.reportID}`];
    const chatTopmostReport = allReports?.[`${ONYXKEYS.COLLECTION.REPORT}${topmostReport?.chatReportID}`];
    if (reportID === ReportActionsUtils.getOneTransactionThreadReportID(topmostReport, chatTopmostReport, topmostReportActions) && Visibility.isVisible() && Visibility.hasFocus()) {
    Log.info(`${tag} No notification because the report is a transaction thread associated with the current one-transaction report`);
    return false;
    }
    const report = allReports?.[`${ONYXKEYS.COLLECTION.REPORT}${reportID}`];
    if (!report || (report && report.pendingAction === CONST.RED_BRICK_ROAD_PENDING_ACTION.DELETE)) {
    Log.info(`${tag} No notification because the report does not exist or is pending deleted`, false);
    return false;
    }
    // If this notification was delayed and the user saw the message already, don't show it
    if (action && report?.lastReadTime && report.lastReadTime >= action.created) {
    Log.info(`${tag} No notification because the comment was already read`, false, {created: action.created, lastReadTime: report.lastReadTime});
    return false;
    }
    // If this is a whisper targeted to someone else, don't show it
    if (action && ReportActionsUtils.isWhisperActionTargetedToOthers(action)) {
    Log.info(`${tag} No notification because the action is whispered to someone else`, false);
    return false;
    }
    if (action && !ReportActionsUtils.isActionable(action, currentUserAccountID)) {
    Log.info(`${tag} No notification because report action is not actionable`);
    return false;
    }
    return true;

    function isActionable(reportAction: OnyxInputOrEntry<ReportAction>, currentUserAccountID: number) {
    if (!reportAction) {
    return false;
    }
    const actionableTypes = [
    CONST.REPORT.ACTIONS.TYPE.ADD_COMMENT,
    CONST.REPORT.ACTIONS.TYPE.ACTIONABLE_MENTION_WHISPER,
    CONST.REPORT.ACTIONS.TYPE.ACTIONABLE_REPORT_MENTION_WHISPER,
    CONST.REPORT.ACTIONS.TYPE.CREATED,
    CONST.REPORT.ACTIONS.TYPE.ROOM_CHANGE_LOG.INVITE_TO_ROOM,
    CONST.REPORT.ACTIONS.TYPE.ROOM_CHANGE_LOG.LEAVE_ROOM,
    CONST.REPORT.ACTIONS.TYPE.CONCIERGE_CATEGORY_OPTIONS,
    ] as const;
    if ((actionableTypes as readonly string[]).includes(reportAction.actionName)) {
    return true;
    }
    const originalMessage = getOriginalMessage(reportAction);
    const actionableForAccountIDs = (
    originalMessage && typeof originalMessage === 'object' && 'actionableForAccountIDs' in originalMessage ? originalMessage?.actionableForAccountIDs : []
    ) as number[];
    return actionableForAccountIDs.includes(currentUserAccountID);
    }

    So a manager’s description-only edit can still pass notification checks and notify the submitter.

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

    function shouldShowReportActionNotification(reportID: string, currentUserAccountID: number, action: ReportAction | null = null, isRemote = false): boolean {
    const tag = isRemote ? '[PushNotification]' : '[LocalNotification]';
    const topmostReportID = Navigation.getTopmostReportId();
    // Due to payload size constraints, some push notifications may have their report action stripped
    // so we must double check that we were provided an action before using it in these checks.
    if (action && ReportActionsUtils.isDeletedAction(action)) {
    Log.info(`${tag} Skipping notification because the action was deleted`, false, {reportID, action});
    return false;
    }
    if (!ActiveClientManager.isClientTheLeader()) {
    Log.info(`${tag} Skipping notification because this client is not the leader`);
    return false;
    }
    // We don't want to send a local notification if the user preference is daily, mute or hidden.
    const notificationPreference = getReportNotificationPreference(allReports?.[`${ONYXKEYS.COLLECTION.REPORT}${reportID}`]);
    if (notificationPreference !== CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS) {
    Log.info(`${tag} No notification because user preference is to be notified: ${notificationPreference}`);
    return false;
    }
    // If this comment is from the current user we don't want to parrot whatever they wrote back to them.
    if (action && action.actorAccountID === currentUserAccountID) {
    Log.info(`${tag} No notification because comment is from the currently logged in user`);
    return false;
    }
    // If we are currently viewing this report do not show a notification.
    if (reportID === topmostReportID && Visibility.isVisible() && Visibility.hasFocus()) {
    Log.info(`${tag} No notification because it was a comment for the current report`);
    return false;
    }
    // If the report is a transaction thread and we are currently viewing the associated one-transaction report do no show a notification.
    const topmostReport = allReports?.[`${ONYXKEYS.COLLECTION.REPORT}${topmostReportID}`];
    const topmostReportActions = allReportActions?.[`${topmostReport?.reportID}`];
    const chatTopmostReport = allReports?.[`${ONYXKEYS.COLLECTION.REPORT}${topmostReport?.chatReportID}`];
    if (reportID === ReportActionsUtils.getOneTransactionThreadReportID(topmostReport, chatTopmostReport, topmostReportActions) && Visibility.isVisible() && Visibility.hasFocus()) {
    Log.info(`${tag} No notification because the report is a transaction thread associated with the current one-transaction report`);
    return false;
    }
    const report = allReports?.[`${ONYXKEYS.COLLECTION.REPORT}${reportID}`];
    if (!report || (report && report.pendingAction === CONST.RED_BRICK_ROAD_PENDING_ACTION.DELETE)) {
    Log.info(`${tag} No notification because the report does not exist or is pending deleted`, false);
    return false;
    }
    // If this notification was delayed and the user saw the message already, don't show it
    if (action && report?.lastReadTime && report.lastReadTime >= action.created) {
    Log.info(`${tag} No notification because the comment was already read`, false, {created: action.created, lastReadTime: report.lastReadTime});
    return false;
    }
    // If this is a whisper targeted to someone else, don't show it
    if (action && ReportActionsUtils.isWhisperActionTargetedToOthers(action)) {
    Log.info(`${tag} No notification because the action is whispered to someone else`, false);
    return false;
    }
    if (action && !ReportActionsUtils.isActionable(action, currentUserAccountID)) {
    Log.info(`${tag} No notification because report action is not actionable`);
    return false;
    }
    return true;

    function shouldShowReportActionNotification(reportID: string, currentUserAccountID: number, action: ReportAction | null = null, isRemote = false): boolean {
        ...
        if (action && ReportActionsUtils.isWhisperActionTargetedToOthers(action)) {
            return false;
        }
    
        if (action && ReportActionsUtils.isDescriptionOnlyModifiedExpenseAction(action)) {
            return false;
        }
    
        if (action && !ReportActionsUtils.isActionable(action, currentUserAccountID)) {
            return false;
        }
    
        return true;
    }

    function isModifiedExpenseAction(reportAction: OnyxInputOrEntry<ReportAction>): reportAction is ReportAction<typeof CONST.REPORT.ACTIONS.TYPE.MODIFIED_EXPENSE> {
    return isActionOfType(reportAction, CONST.REPORT.ACTIONS.TYPE.MODIFIED_EXPENSE);
    }

    function isDescriptionOnlyModifiedExpenseAction(reportAction: OnyxInputOrEntry<ReportAction>): boolean {
        if (!isModifiedExpenseAction(reportAction)) {
            return false;
        }
    
        const originalMessage = getOriginalMessage(reportAction) as OriginalMessageModifiedExpense | undefined;
        if (!originalMessage || !('oldComment' in originalMessage) || !('newComment' in originalMessage)) {
            return false;
        }
    
        const nonDescriptionFields: Array<keyof OriginalMessageModifiedExpense> = [
            'merchant',
            'oldCreated',
            'created',
            'oldMerchant',
            'oldAmount',
            'amount',
            'oldCurrency',
            'currency',
            'category',
            'oldCategory',
            'tag',
            'oldTag',
            'billable',
            'oldBillable',
            'oldTaxAmount',
            'taxAmount',
            'taxRate',
            'oldTaxRate',
            'reimbursable',
            'oldReimbursable',
            'movedToReportID',
            'movedFromReport',
            'oldAttendees',
            'newAttendees',
            'policyRulesModifiedFields',
            'personalRulesModifiedFields',
        ];
    
        return nonDescriptionFields.every((field) => !(field in originalMessage));
    }

    This keeps notifications for actionable expense changes (amount/category/tag/etc.) but suppresses notifications for non-actionable description-only edits.

  11. github-actions commented on Apr 9, 2026

    @github-actions
    Contributor

    ⚠️ @abbasifaizan70 Your proposal is a duplicate of an already existing proposal and has been automatically withdrawn to prevent spam. Please review the existing proposals before submitting a new one.

  12. Ltbltbltbltb commented on Apr 9, 2026

    @Ltbltbltbltb

    🚫 Duplicated proposal withdrawn by 🤖 ProposalPolice.

  13. 14 remaining items

  14. s77rt commented on Apr 14, 2026

    @s77rt
    Member

    Auth PR is merged. Waiting for deploy to unhold App PR.

  15. melvin-bot commented on Apr 17, 2026

    @melvin-bot

    @s77rt Whoops! This issue is 2 days overdue. Let's get this updated quick!

  16. s77rt commented on Apr 17, 2026

    @s77rt
    Member

    Waiting for PR to hit production

  17. changed the title [-][CMB] [$250] Notifications - A notification is received by submitter when admin edits expense description[/-] [+][Due for payment 2026-04-28] [CMB] [$250] Notifications - A notification is received by submitter when admin edits expense description[/+] on Apr 21, 2026
  18. melvin-bot commented on Apr 21, 2026

    @melvin-bot

    The solution for this issue has been 🚀 deployed to production 🚀 in version 9.3.60-22 and is now subject to a 7-day regression period 📆. Here is the list of pull requests that resolve this issue:

    If no regressions arise, payment will be issued on 2026-04-28. 🎊

    For reference, here are some details about the assignees on this issue:

    • @s77rt does not require payment (Contractor)
    • @bernhardoj requires payment through NewDot Manual Requests
  19. melvin-bot commented on Apr 21, 2026

    @melvin-bot

    @bernhardoj The PR fixing this issue has been merged! The following checklist (instructions) will need to be completed before the issue can be closed. Please copy/paste the BugZero Checklist from here into a new comment on this GH and complete it. If you have the K2 extension, you can simply click: [this button]

  20. melvin-bot commented on Apr 21, 2026

    @melvin-bot

    @bernhardoj Uh oh! This issue is overdue by 2 days. Don't forget to update your issues!

  21. s77rt commented on Apr 21, 2026

    @s77rt
    Member

    This is done and I think no payment is due here. Closing!

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

Metadata

Metadata

Labels

BugSomething is broken. Auto assigns a BugZero manager.DailyKSv2InternalRequires API changes or must be handled by Expensify staff

Type

No type

Projects

Milestone

No milestone

Relationships

None yet

Development

No branches or pull requests

Issue actions