Skip to content

[$250] Concierge options loads every time when choose an option #92364

Closed

Description

@applause-bot

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: v9.3.91-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: https://test-management.browserstack.com/projects/2219752/test-runs/TR-37256/folder/13176924/41237571/1455625236?sort=%2Bstatus_id
Email or phone of affected tester (no customers): gocemate+b215490617@gmail.com
Issue reported by: Applause Internal Team
Bug source: Exploratory - Significant User Experience Deterioration
Device used: Windows 10/Chrome
App Component: Other

Action Performed:

  1. Sign up with a account with the following format: [anything]@tstsg.com e.g: isagoicotest@tstsg.com
  2. Verify the first modal for the onboarding flow is "What's your name" modal
  3. Fill in the required personal details (First Name, Last Name) and continue
  4. Verify that the next screen is the "People you may know are already here! Verify your email to join them." step, prompting the user to confirm their email
  5. Select the "Skip" option on the verification screen.
  6. Verify that the flow proceeds to the "What do you want to do today? step
  7. Select the "Manage expenses for employees", > "5-10 employees" option and complete the process
  8. Navigate to #admins
  9. Select any of Concierge options
  10. Verify that Concierge provide an answer
  11. Wait for the new Concierge options

Expected Result:

Concierge questions should not load long every time

Actual Result:

Concierge questions loads long every time

Workaround:

Unknown

Platforms:

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

Screenshots/Videos

Bug7169516_1780400237803.Recording__786.mp4

View all open jobs on GitHub

Applause Internal Information
Exported by: Svetlana Lazutkina
Bug ID: 7169516

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

Activity

  1. applause-bot commented on Jun 2, 2026

    @applause-bot
    Author

    While Applause doesn't embed attachments for this bug, here are the links for quick view:
    https://platform.applause.com/services/links/v1/external/4f02f7a4081d7468f85d4e64268b5f316ed1b8c4a6731a1148c33179941d9d1b

  2. added
    BugSomething is broken. Auto assigns a BugZero manager.
    on Jun 2, 2026
  3. MelvinBot commented on Jun 2, 2026

    @MelvinBot
    Contributor

    Issue Analysis

    Root Cause (Medium confidence): The repeated "loading" after each Concierge option is the new guided‑setup streaming UX waiting on the backend to generate the next reply and the next set of suggested options. After you tap an option, the App shows a "Concierge is thinking…" indicator and a follow‑up‑list skeleton, then renders the next options only once the server delivers a report action whose HTML contains the next <followup-list>. The options are parsed from server‑delivered HTML (ChatActionableButtons.tsx:139-161), so how long the wait feels is driven by backend (Concierge/Agent Zero) generation time — not by an App‑side rendering bug.

    On top of the backend wait, the App adds intentional client‑side delays that lengthen the perceived load:

    Recommended next step: This is largely expected behavior of the new streaming experience, so there is no clean App‑side bug to fix here. Meaningfully reducing the wait requires backend changes to how fast Concierge/Agent Zero produces each next response + follow‑up list, which lives outside the App repo. This should be escalated to an internal engineer who owns Concierge/Agent Zero generation. The only App‑side levers are the intentional delay constants above, which are deliberate UX tuning rather than defects.

    Possibly related open issues:

    Investigation details & evidence chain

    Flow when an option is tapped (resolveSuggestedFollowup):

    1. The tapped follow‑up list is optimistically marked resolved and the user's choice is posted as a comment.
    2. If the follow‑up has no pre‑generated response, the App just addComments and waits for the full server Concierge reply (backend latency) — this is the common path in guided setup.
    3. If it does have a pre‑generated response, the answer is queued with the deliberate 4s delay via addOptimisticConciergeActionWithDelay.
    4. When the answer is shown, applyPendingConciergeAction sets the CONCIERGE_PENDING_FOLLOWUP_LIST skeleton marker for the next set of options.
    5. The skeleton clears only when a report action's HTML contains a parsed <followup-list> — see the clearing effect in usePendingConciergeResponse.ts:101-130 — otherwise it falls back to the 2‑minute TTL.

    Why this is backend‑gated: the actual button text/options are produced by parseFollowupsFromHtml(messageHtml) on the server‑delivered report‑action HTML, and the skeleton is rendered whenever there are no parsed buttons yet (ChatActionableButtons.tsx:212-216). The App can't produce the next options until the backend sends them.

    Alternative considered (needs backend confirmation): the skeleton marker is keyed to the answer action's reportActionID (applyPendingConciergeAction). If the server delivers the next <followup-list> as a separate report action rather than overwriting that same ID, the skeleton would only clear via the 2‑minute TTL — which would look exactly like "loads long every time." Confirming this requires inspecting the server reconciliation behavior (internal/backend), which can't be done from the App repo.

    Not verified: production logs of the actual backend follow‑up generation latency for this tester's flow. The mechanism above is fully evidenced in public App code; the magnitude of the wait is the remaining unknown and is backend‑owned.


    Next Steps: Reply with @MelvinBot <your feedback> to refine this analysis. Because the substantive fix is backend (Concierge/Agent Zero generation latency), this needs an internal engineer with backend access rather than an App code change.

  4. added
    ExternalAdded to denote the issue can be worked on by a contributor
    on Jun 2, 2026
  5. added
    Help WantedApply this label when an issue is open to proposals by contributors
    on Jun 2, 2026
  6. MobileMage commented on Jun 2, 2026

    @MobileMage
    Contributor

    Proposal

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

    When a user selects a Concierge option (quick-reply suggestion button) in the #admins chat and Concierge responds, the next set of followup suggestion buttons shows a loading skeleton every single time before the real options appear. This happens repeatedly on every interaction, not just the first time, making the experience feel slow and broken even though the underlying response is pregenerated.

    What is the root cause of that problem?

    The root cause is that applyPendingConciergeAction in SuggestedFollowup.ts unconditionally writes a new CONCIERGE_PENDING_FOLLOWUP_LIST Onyx entry every time it fires, and that entry only gets cleared after parseFollowupsFromHtml confirms the real <followup-list> HTML has landed in REPORT_ACTIONS. The problem is that the "clear on followup arrival" logic inside usePendingConciergeResponse depends on pendingFollowupAction — the persisted report action identified by pendingFollowupList.reportActionID — having its HTML updated by the server. But when Concierge responds with a pregenerated response (the followup.response branch in resolveSuggestedFollowup), the optimistic action is written to REPORT_ACTIONS by applyPendingConciergeAction itself, and that action's HTML is the pregenerated response HTML. The server later overwrites that action with a canonical version. If the server-canonical action does not yet include the <followup-list> tag at the moment applyPendingConciergeAction fires, the pendingFollowupList entry stays alive in Onyx, and the skeleton continues to render on every subsequent message until the TTL (MAX_AGE_MS) fires.

    The write path: resolveSuggestedFollowup → addOptimisticConciergeActionWithDelay → applyPendingConciergeAction. Inside applyPendingConciergeAction:

    Onyx.update([
        { onyxMethod: Onyx.METHOD.SET, key: `${ONYXKEYS.COLLECTION.PENDING_CONCIERGE_RESPONSE}${reportID}`, value: null },
        { onyxMethod: Onyx.METHOD.MERGE, key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${reportID}`, value: { ... } },
        { onyxMethod: Onyx.METHOD.SET, key: `${ONYXKEYS.COLLECTION.CONCIERGE_PENDING_FOLLOWUP_LIST}${reportID}`, value: { reportActionID: reportAction.reportActionID, createdAt: Date.now() } },
    ]);

    This unconditionally sets a new CONCIERGE_PENDING_FOLLOWUP_LIST entry pointing at the newly applied action. The read path: ChatMessageContent subscribes to CONCIERGE_PENDING_FOLLOWUP_LIST via hasPendingFollowupListSkeletonSelector, which returns true when pending?.reportActionID === reportActionID && !pending?.hidden. As long as that Onyx key is non-null and hasn't been cleared, every re-render of ChatActionableButtons for the action that has actionableItemButtons.length === 0 (because the HTML doesn't yet have a <followup-list>) will fall through to <FollowupListSkeleton />.

    The real gap: applyPendingConciergeAction writes CONCIERGE_PENDING_FOLLOWUP_LIST even when the pregenerated response HTML it is writing already contains a <followup-list> element. In that case, the skeleton would be unnecessary — the follow-up buttons are available immediately in the action that was just merged. The usePendingConciergeResponse cleanup effect does check for this, but only on the next render cycle (async), creating a flash of the skeleton. More importantly, when the optimistic action does NOT contain a <followup-list> (i.e. the server will add it later), the skeleton is legitimate — but on the second and subsequent interactions within the same session, the report's Onyx state may already hold a stale CONCIERGE_PENDING_FOLLOWUP_LIST from the previous round if clearPendingFollowupList was invoked before the new applyPendingConciergeAction wrote a fresh one. Each interaction re-creates the skeleton anew regardless.

    function applyPendingConciergeAction(reportID: string | undefined, reportAction: ReportAction) {
    Onyx.update([
    {
    onyxMethod: Onyx.METHOD.SET,
    key: `${ONYXKEYS.COLLECTION.PENDING_CONCIERGE_RESPONSE}${reportID}`,
    value: null,
    },
    {
    onyxMethod: Onyx.METHOD.MERGE,
    key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${reportID}`,
    value: {[reportAction.reportActionID]: reportAction},
    },
    {
    onyxMethod: Onyx.METHOD.SET,
    key: `${ONYXKEYS.COLLECTION.CONCIERGE_PENDING_FOLLOWUP_LIST}${reportID}`,
    value: {reportActionID: reportAction.reportActionID, createdAt: Date.now()},
    },
    ]);
    }

    useEffect(() => {
    if (!reportID || !pendingFollowupList) {
    return;
    }
    const html = pendingFollowupAction ? getReportActionHtml(pendingFollowupAction) : '';
    const hardClearIndicator = () => {
    // Skip clearing agent thinking indicator when a newer agent request has kicked off.
    const optimisticEntry = AgentZeroOptimisticStore.getEntry(reportID);
    const hasNewerRequest = !!optimisticEntry && optimisticEntry.startedAt > pendingFollowupList.createdAt;
    if (!hasNewerRequest) {
    clearAgentZeroProcessingIndicator(reportID);
    }
    clearPendingFollowupList(reportID);
    };
    if (parseFollowupsFromHtml(html)?.length) {
    hardClearIndicator();
    return;
    }
    if (isOffline) {
    return;
    }
    const effectiveStart = Math.max(pendingFollowupList.createdAt, lastOnlineTransitionAtRef.current);
    const remainingTTL = effectiveStart + PENDING_FOLLOWUP_LIST_HARD_CAP_MS - Date.now();
    if (remainingTTL <= 0) {
    hardClearIndicator();
    return;
    }
    const ttlTimer = setTimeout(hardClearIndicator, remainingTTL);
    return () => clearTimeout(ttlTimer);
    }, [reportID, pendingFollowupList, pendingFollowupAction, isOffline]);

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

    The fix is in applyPendingConciergeAction in src/libs/actions/Report/SuggestedFollowup.ts. Before unconditionally writing a new CONCIERGE_PENDING_FOLLOWUP_LIST entry, check whether the pregenerated reportAction HTML already contains a resolved or populated <followup-list>. Import parseFollowupsFromHtml from ReportActionFollowupUtils and getReportActionHtml from ReportActionsUtils (both are already used elsewhere in the file and its callers), then gate the skeleton write:

    function applyPendingConciergeAction(reportID: string | undefined, reportAction: ReportAction) {
        const html = getReportActionHtml(reportAction);
        const followups = parseFollowupsFromHtml(html ?? '');
        // Only show the skeleton if the optimistic action doesn't already contain followup buttons
        const shouldSetFollowupSkeleton = !followups || followups.length === 0;
    
        Onyx.update([
            { onyxMethod: Onyx.METHOD.SET, key: `${ONYXKEYS.COLLECTION.PENDING_CONCIERGE_RESPONSE}${reportID}`, value: null },
            { onyxMethod: Onyx.METHOD.MERGE, key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${reportID}`, value: { [reportAction.reportActionID]: reportAction } },
            shouldSetFollowupSkeleton
                ? { onyxMethod: Onyx.METHOD.SET, key: `${ONYXKEYS.COLLECTION.CONCIERGE_PENDING_FOLLOWUP_LIST}${reportID}`, value: { reportActionID: reportAction.reportActionID, createdAt: Date.now() } }
                : { onyxMethod: Onyx.METHOD.SET, key: `${ONYXKEYS.COLLECTION.CONCIERGE_PENDING_FOLLOWUP_LIST}${reportID}`, value: null },
        ]);
    }

    When the pregenerated action already embeds a <followup-list>, the skeleton Onyx key is cleared (or never set), and ChatMessageContent's hasPendingFollowupListSkeleton immediately evaluates to false. The ChatActionableButtons component will proceed directly to rendering the real followup buttons parsed from the action HTML via parseFollowupsFromHtml, with no skeleton flash at all. When the action does not contain a followup list (Concierge expects to add one server-side), the skeleton write is preserved as-is, and the existing usePendingConciergeResponse TTL cleanup continues to work correctly.

    function addOptimisticConciergeActionWithDelay(reportID: string, optimisticConciergeAction: OptimisticReportAction) {
    // The "Concierge is thinking..." indicator is driven by the server-owned
    // agentZeroProcessingIndicator NVP, so this client-local delayed response
    // must not also write REPORT_USER_IS_TYPING for Concierge.
    Onyx.set(`${ONYXKEYS.COLLECTION.PENDING_CONCIERGE_RESPONSE}${reportID}`, {
    reportAction: optimisticConciergeAction.reportAction,
    displayAfter: Date.now() + CONCIERGE_RESPONSE_DELAY_MS,
    });
    }

    What alternative solutions did you explore? (Optional)

    An alternative would be to reduce PENDING_FOLLOWUP_LIST_HARD_CAP_MS to a shorter TTL so the skeleton clears faster, but this would be a band-aid that hides the symptom without fixing the actual redundant skeleton write. It would also risk clearing the skeleton before the server has delivered a legitimate followup list in slow-network conditions, creating a different regression where valid follow-up options never appear.

  7. David-2002065 commented on Jun 2, 2026

    @David-2002065
    Contributor

    🚨 Edited by proposal-police: This proposal was edited at 2026-06-05.

    🚨 Updated 2026-06-05: my original root cause was wrong. New analysis below, based on live Onyx/log evidence from the staging repro.


    Proposal (updated)

    What is the root cause of that problem?

    The bug is in the trickle path, not the binary path I originally analyzed. Live log capture from the staging repro (tapping "To connect your workspace to QuickBooks Online:" in #admins as a fresh @tstsg.com account):

    [ConciergeTrickle] complete — {"reportActionID":"7591935693004905759","reason":"natural","tokenCount":509,"durationMs":15000,"totalElapsedMs":15043}
    [Onyx] set called for key: pendingConciergeResponse_786904193557754 => null passed, so key was removed
    [Onyx] set called for key: conciergePendingFollowupList_786904193557754 properties: reportActionID,createdAt hasChanged: true
    [Onyx] merge called for key: reportActions_786904193557754 properties: …,7591935693004905759 hasChanged: true
    [Sentry][ManualSkeleton_FollowupListSkeleton__r_p_] Starting span
    

    Key observations:

    1. tokenCount: 509 — the pregenerated guided-setup response is well above MIN_TRICKLE_TOKEN_COUNT = 100, so shouldTrickle resolves true and the trickle path is taken, not the binary one.
    2. reason: "natural" — accelerateRef.current was never called during the 15s reveal, i.e. no canonical Concierge reply landed at REPORT_ACTIONS[optimisticConciergeReportActionID] within the trickle window. trickleInputsRef.current.persistedAction was also undefined at completion time.
    3. Per the trickle's completion branch, both arms of the canonical-detection check fail, so the else runs: applyPendingConciergeAction(reportID, reportAction) — which unconditionally arms CONCIERGE_PENDING_FOLLOWUP_LIST on optimisticConciergeReportActionID.
    4. The FollowupListSkeleton then renders (Sentry span captured above). Per the reconciliation effect, the skeleton stays armed until either REPORT_ACTIONS[optimisticConciergeReportActionID] is updated to include a parseable <followup-list> or PENDING_FOLLOWUP_LIST_HARD_CAP_MS = 120000 ms elapses.

    In the reproduced run, the canonical Concierge reply (with <followup-list>) eventually lands ~1 minute later (likely via Pusher, given the [Report] Handled multipleEvents event sent by Pusher cadence visible just before the trickle completed); the reconciliation effect then clears the skeleton and the three real follow-up options appear. From the user's perspective: answer text in ~15s, then a 3-button skeleton spinning for ~1 minute, then the real options. That ~1-minute spin is exactly the bug Applause reported as "Concierge questions loads long every time."

    So the issue is not a race between a binary setTimeout and the canonical (my original framing); it's that applyPendingConciergeAction arms the followup-list skeleton even when there is no live signal that a followup-list is on its way. The trickle's own canonical-detection arms (arrival || trickleInputsRef.current.persistedAction) are necessary conditions for the skeleton to be useful — yet the else branch unconditionally arms it regardless.

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

    Make the skeleton arming conditional on a real "canonical arriving" signal at the moment we apply the optimistic. The cleanest place to express this is at the trickle's completion site and at the binary path's apply site — both call into applyPendingConciergeAction, which today always writes CONCIERGE_PENDING_FOLLOWUP_LIST.

    Concretely:

    1. Split the skeleton arming out of applyPendingConciergeAction. That function should only do what its name says — move the pending optimistic into REPORT_ACTIONS and clear PENDING_CONCIERGE_RESPONSE. The skeleton write becomes a separate, opt-in helper (armPendingFollowupList(reportID, reportActionID)).
    2. Only call armPendingFollowupList when we have a positive reason to think a followup-list is coming. The agentZeroProcessingRequestIndicator NVP on reportNameValuePairs_<reportID> is the existing server-driven signal — when it's set to a "Concierge is …" value at the moment of apply, the server has announced that it's still processing and a follow-up payload is expected. When it's clear, the user has either already gotten the canonical or the server isn't going to send more — no skeleton needed.
    3. Keep the existing reconciliation effect — if a followup-list does land later (same reportActionID via merge, or a fresh one delivered via Pusher), it renders naturally with its real options, no skeleton required.

    Combined with the trickle path's existing canonical-cancellation arms (arrival || persistedAction → discardPendingConciergeAction), the user-visible flow becomes:

    • Canonical lands during trickle → optimistic discarded, canonical renders with followup-list. (Already worked, unchanged.)
    • Canonical lands after trickle but agentZeroProcessingRequestIndicator still says processing → apply optimistic, arm skeleton, canonical merges in, reconciliation clears it. (Same shape as today, but the skeleton is bounded by real server signal rather than a 120s blind TTL.)
    • Canonical never lands / server isn't processing anything more → apply optimistic, don't arm the skeleton, user sees the answer text and the conversation continues naturally. (Today: 120s skeleton spin.)

    What alternative solutions did you explore? (Optional)

    1. Shorten PENDING_FOLLOWUP_LIST_HARD_CAP_MS from 120s to a few seconds. Rejected — it shortens the visible symptom but still arms the skeleton in every guided-setup tap, including ones where no followup-list is coming. We'd still flash a skeleton then collapse it; the underlying "arm without evidence" bug stays.
    2. Don't arm the skeleton at all in the trickle path. Rejected — the trickle path is for long responses, which are exactly the guided-setup branch where follow-up options legitimately are on their way. Suppressing the skeleton blindly there would regress the case where the canonical arrives a few seconds after trickle completion (skeleton briefly visible → real options → smooth UX).
    3. Scan all of REPORT_ACTIONS for any newer Concierge action with <followup-list> instead of looking only at pendingFollowupList.reportActionID. Considered — it would handle a scenario where the server doesn't reuse optimisticConciergeReportActionID. But the log capture above shows the canonical does land at the same reportActionID (the reconciliation effect successfully clears the skeleton at the ~1-minute mark via pendingFollowupAction), so the lookup is correct. Scanning unnecessarily widens the surface and risks false positives from unrelated Concierge messages in the same conversation.
    4. My original "binary path race" fix. Withdrawn — the binary path was never taken in this repro (tokenCount: 509 >> 100). The fix as-committed is harmless (its effect is to discard a pending response when the canonical arrives at the same ID before any binary timer fires, which is a degenerate sub-case of the trickle's existing arms), but it does not address the user-visible bug. I'll keep the test it adds (regression guard for that sub-case) and rework the source change to match (2) above.
  8. moxw commented on Jun 2, 2026

    @moxw

    Proposal

    What is the root cause of that problem?

    When a Concierge suggested follow-up is selected, resolveSuggestedFollowup() queues a delayed optimistic Concierge answer. Once that delayed answer is applied, applyPendingConciergeAction() always writes CONCIERGE_PENDING_FOLLOWUP_LIST for that new action.

    ChatMessageContent/ChatActionableButtons then render FollowupListSkeleton whenever that marker matches the action and the action does not yet have unresolved <followup-list> options. The marker only clears after a later canonical action contains parseable unresolved follow-ups, or after the 120s TTL. So every option click forces the next options area into a loading/skeleton state, even when the optimistic response already contains options or when the client has no confirmed follow-up list to wait for.

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

    Make the pending follow-up skeleton conditional instead of always setting it after applying the delayed Concierge response.

    Specifically:

    1. In applyPendingConciergeAction(), inspect the applied reportAction HTML with parseFollowupsFromHtml().
    2. If the delayed response already contains unresolved follow-ups, merge the action and clear CONCIERGE_PENDING_FOLLOWUP_LIST instead of setting it. The existing ChatActionableButtons path will render those options immediately.
    3. If the delayed response has no unresolved follow-ups, do not leave a follow-up-list skeleton active by default. The skeleton should only be set when we explicitly know this same optimistic Concierge action is waiting for a canonical replacement with follow-up options.
    4. Keep the server-owned AgentZero/Concierge processing indicator separate from the follow-up-list skeleton, so we do not suppress normal thinking state just because the local answer was applied.

    Tests:

    • Add/update usePendingConciergeResponse tests for an applied delayed response that already includes <followup-list> and assert no pending skeleton marker remains.
    • Add a regression test for an applied delayed response without follow-ups and assert it does not keep CONCIERGE_PENDING_FOLLOWUP_LIST until TTL.
    • Verify the #admins Concierge follow-up flow: selecting an option posts the selected question, shows the answer, and does not repeatedly show a long-loading options skeleton unless the backend has explicitly indicated options are still pending.

    What alternative solutions did you explore? (Optional)

    Lowering CONCIERGE_RESPONSE_DELAY_MS or the 120s TTL would only shorten the visible loading state. It would not fix the root issue that we create a pending follow-up skeleton for every delayed Concierge answer, regardless of whether follow-up options are actually pending.

  9. melvin-bot commented on Jun 2, 2026

    @melvin-bot

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

  10. changed the title [-]Concierge options loads every time when choose an option[/-] [+][$250] Concierge options loads every time when choose an option[/+] on Jun 2, 2026
  11. melvin-bot commented on Jun 2, 2026

    @melvin-bot
  12. ReaperOAK commented on Jun 2, 2026

    @ReaperOAK
    Contributor

    🚫 Duplicated proposal withdrawn by 🤖 ProposalPolice.

  13. github-actions commented on Jun 2, 2026

    @github-actions
    Contributor

    ⚠️ @ReaperOAK 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.

  14. 54 remaining items

  15. melvin-bot commented on Jun 22, 2026

    @melvin-bot

    @s77rt Still overdue 6 days?! Let's take care of this!

  16. s77rt commented on Jun 24, 2026

    @s77rt
    Member

    Yeah but I think most of the time is spent on waiting on the AI model response

  17. marufsharifi commented on Jun 29, 2026

    @marufsharifi
    Contributor

    @s77rt, what's next here? thanks.

  18. s77rt commented on Jun 29, 2026

    @s77rt
    Member

    Closing for now. Let's reopen if this is found worth addressing.

  19. marufsharifi commented on Jun 30, 2026

    @marufsharifi
    Contributor

    @mallenexpensify, I’ve reviewed all the proposals here, and I understand the team decided to close this as not worth addressing.

    Could you please confirm whether I’m still eligible for payment for the work I completed on this issue?

    Thank you.

  20. mallenexpensify commented on Jul 6, 2026

    @mallenexpensify
    Contributor

    Payment Summary

    Contributor+: @marufsharifi paid $75 via Upwork

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

    We don't have a stated policy for when payment is due to a C+ for issue-only review (our internal C+ process is here ) Paying $75 because thorough review of the issue to only find out it's backend.

  21. marufsharifi commented on Jul 7, 2026

    @marufsharifi
    Contributor

    @mallenexpensify, I've accepted the offer. thanks

  22. mallenexpensify commented on Jul 7, 2026

    @mallenexpensify
    Contributor

    @marufsharifi paid, summary updated above. Thx.

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.DailyKSv2ExternalAdded to denote the issue can be worked on by a contributor

Type

No type

Projects

Milestone

No milestone

Relationships

None yet

Development

No branches or pull requests

Issue actions