You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
{{ message }}
Repository navigation
[$250] Concierge options loads every time when choose an option #92364
Sign up with a account with the following format: [anything]@tstsg.com e.g: isagoicotest@tstsg.com
Verify the first modal for the onboarding flow is "What's your name" modal
Fill in the required personal details (First Name, Last Name) and continue
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
Select the "Skip" option on the verification screen.
Verify that the flow proceeds to the "What do you want to do today? step
Select the "Manage expenses for employees", > "5-10 employees" option and complete the process
Navigate to #admins
Select any of Concierge options
Verify that Concierge provide an answer
Wait for the new Concierge options
Expected Result:
Concierge questions should not load long every time
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:
the skeleton can persist up to 2 min if the server never sends a <followup-list> — MAX_AGE_MS = 120000
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.
The tapped follow‑up list is optimistically marked resolved and the user's choice is posted as a comment.
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.
When the answer is shown, applyPendingConciergeAction sets the CONCIERGE_PENDING_FOLLOWUP_LIST skeleton marker for the next set of options.
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.
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:
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.
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:
functionapplyPendingConciergeAction(reportID: string|undefined,reportAction: ReportAction){consthtml=getReportActionHtml(reportAction);constfollowups=parseFollowupsFromHtml(html??'');// Only show the skeleton if the optimistic action doesn't already contain followup buttonsconstshouldSetFollowupSkeleton=!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.
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.
🚨 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:
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.
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.
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.
The FollowupListSkeleton then renders (Sentry span captured above). Per the reconciliation effect, the skeleton stays armed until eitherREPORT_ACTIONS[optimisticConciergeReportActionID] is updated to include a parseable <followup-list>orPENDING_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:
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)).
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.
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)
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.
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).
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.
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.
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:
In applyPendingConciergeAction(), inspect the applied reportAction HTML with parseFollowupsFromHtml().
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.
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.
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.
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
⚠️@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.
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.
Activity
applause-bot commentedon Jun 2, 2026
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
MelvinBot commentedon Jun 2, 2026
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:
CONCIERGE_RESPONSE_DELAY_MS = 4000DEFAULT_STREAM_DURATION_MS = 15_000<followup-list>—MAX_AGE_MS = 120000Recommended 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):addComments and waits for the full server Concierge reply (backend latency) — this is the common path in guided setup.addOptimisticConciergeActionWithDelay.applyPendingConciergeActionsets theCONCIERGE_PENDING_FOLLOWUP_LISTskeleton marker for the next set of options.<followup-list>— see the clearing effect inusePendingConciergeResponse.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.MobileMage commentedon Jun 2, 2026
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
applyPendingConciergeActioninSuggestedFollowup.tsunconditionally writes a newCONCIERGE_PENDING_FOLLOWUP_LISTOnyx entry every time it fires, and that entry only gets cleared afterparseFollowupsFromHtmlconfirms the real<followup-list>HTML has landed inREPORT_ACTIONS. The problem is that the "clear on followup arrival" logic insideusePendingConciergeResponsedepends onpendingFollowupAction— the persisted report action identified bypendingFollowupList.reportActionID— having its HTML updated by the server. But when Concierge responds with a pregenerated response (thefollowup.responsebranch inresolveSuggestedFollowup), the optimistic action is written toREPORT_ACTIONSbyapplyPendingConciergeActionitself, 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 momentapplyPendingConciergeActionfires, thependingFollowupListentry 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. InsideapplyPendingConciergeAction:This unconditionally sets a new
CONCIERGE_PENDING_FOLLOWUP_LISTentry pointing at the newly applied action. The read path:ChatMessageContentsubscribes toCONCIERGE_PENDING_FOLLOWUP_LISTviahasPendingFollowupListSkeletonSelector, which returnstruewhenpending?.reportActionID === reportActionID && !pending?.hidden. As long as that Onyx key is non-null and hasn't been cleared, every re-render ofChatActionableButtonsfor the action that hasactionableItemButtons.length === 0(because the HTML doesn't yet have a<followup-list>) will fall through to<FollowupListSkeleton />.The real gap:
applyPendingConciergeActionwritesCONCIERGE_PENDING_FOLLOWUP_LISTeven 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. TheusePendingConciergeResponsecleanup 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 staleCONCIERGE_PENDING_FOLLOWUP_LISTfrom the previous round ifclearPendingFollowupListwas invoked before the newapplyPendingConciergeActionwrote a fresh one. Each interaction re-creates the skeleton anew regardless.App/src/libs/actions/Report/SuggestedFollowup.ts
Lines 161 to 179 in a22e18b
App/src/hooks/usePendingConciergeResponse.ts
Lines 101 to 130 in a22e18b
What changes do you think we should make in order to solve the problem?
The fix is in
applyPendingConciergeActioninsrc/libs/actions/Report/SuggestedFollowup.ts. Before unconditionally writing a newCONCIERGE_PENDING_FOLLOWUP_LISTentry, check whether the pregeneratedreportActionHTML already contains a resolved or populated<followup-list>. ImportparseFollowupsFromHtmlfromReportActionFollowupUtilsandgetReportActionHtmlfromReportActionsUtils(both are already used elsewhere in the file and its callers), then gate the skeleton write:When the pregenerated action already embeds a
<followup-list>, the skeleton Onyx key is cleared (or never set), andChatMessageContent'shasPendingFollowupListSkeletonimmediately evaluates tofalse. TheChatActionableButtonscomponent will proceed directly to rendering the real followup buttons parsed from the action HTML viaparseFollowupsFromHtml, 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 existingusePendingConciergeResponseTTL cleanup continues to work correctly.App/src/libs/actions/Report/SuggestedFollowup.ts
Lines 116 to 124 in a22e18b
What alternative solutions did you explore? (Optional)
An alternative would be to reduce
PENDING_FOLLOWUP_LIST_HARD_CAP_MSto 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.David-2002065 commentedon Jun 2, 2026
🚨 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
#adminsas a fresh@tstsg.comaccount):Key observations:
tokenCount: 509— the pregenerated guided-setup response is well aboveMIN_TRICKLE_TOKEN_COUNT = 100, soshouldTrickleresolves true and the trickle path is taken, not the binary one.reason: "natural"—accelerateRef.currentwas never called during the 15s reveal, i.e. no canonical Concierge reply landed atREPORT_ACTIONS[optimisticConciergeReportActionID]within the trickle window.trickleInputsRef.current.persistedActionwas also undefined at completion time.elseruns:applyPendingConciergeAction(reportID, reportAction)— which unconditionally armsCONCIERGE_PENDING_FOLLOWUP_LISTonoptimisticConciergeReportActionID.FollowupListSkeletonthen renders (Sentry span captured above). Per the reconciliation effect, the skeleton stays armed until eitherREPORT_ACTIONS[optimisticConciergeReportActionID]is updated to include a parseable<followup-list>orPENDING_FOLLOWUP_LIST_HARD_CAP_MS = 120000ms 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 Pushercadence 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
setTimeoutand the canonical (my original framing); it's thatapplyPendingConciergeActionarms 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 theelsebranch 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 writesCONCIERGE_PENDING_FOLLOWUP_LIST.Concretely:
applyPendingConciergeAction. That function should only do what its name says — move the pending optimistic intoREPORT_ACTIONSand clearPENDING_CONCIERGE_RESPONSE. The skeleton write becomes a separate, opt-in helper (armPendingFollowupList(reportID, reportActionID)).armPendingFollowupListwhen we have a positive reason to think a followup-list is coming. TheagentZeroProcessingRequestIndicatorNVP onreportNameValuePairs_<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.reportActionIDvia 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:agentZeroProcessingRequestIndicatorstill 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.)What alternative solutions did you explore? (Optional)
PENDING_FOLLOWUP_LIST_HARD_CAP_MSfrom 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.REPORT_ACTIONSfor any newer Concierge action with<followup-list>instead of looking only atpendingFollowupList.reportActionID. Considered — it would handle a scenario where the server doesn't reuseoptimisticConciergeReportActionID. But the log capture above shows the canonical does land at the samereportActionID(the reconciliation effect successfully clears the skeleton at the ~1-minute mark viapendingFollowupAction), so the lookup is correct. Scanning unnecessarily widens the surface and risks false positives from unrelated Concierge messages in the same conversation.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.moxw commentedon Jun 2, 2026
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 writesCONCIERGE_PENDING_FOLLOWUP_LISTfor that new action.ChatMessageContent/ChatActionableButtonsthen renderFollowupListSkeletonwhenever 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:
applyPendingConciergeAction(), inspect the appliedreportActionHTML withparseFollowupsFromHtml().CONCIERGE_PENDING_FOLLOWUP_LISTinstead of setting it. The existingChatActionableButtonspath will render those options immediately.Tests:
usePendingConciergeResponsetests for an applied delayed response that already includes<followup-list>and assert no pending skeleton marker remains.CONCIERGE_PENDING_FOLLOWUP_LISTuntil TTL.#adminsConcierge 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_MSor 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.melvin-bot commentedon Jun 2, 2026
Triggered auto assignment to Contributor-plus team member for initial proposal review - @marufsharifi (
External)[-]Concierge options loads every time when choose an option[/-][+][$250] Concierge options loads every time when choose an option[/+]melvin-bot commentedon Jun 2, 2026
Job added to Upwork: https://www.upwork.com/jobs/~022061798385854101836
ReaperOAK commentedon Jun 2, 2026
🚫 Duplicated proposal withdrawn by 🤖 ProposalPolice.
github-actions commentedon Jun 2, 2026
54 remaining items
melvin-bot commentedon Jun 22, 2026
@s77rt Still overdue 6 days?! Let's take care of this!
s77rt commentedon Jun 24, 2026
Yeah but I think most of the time is spent on waiting on the AI model response
marufsharifi commentedon Jun 29, 2026
@s77rt, what's next here? thanks.
s77rt commentedon Jun 29, 2026
Closing for now. Let's reopen if this is found worth addressing.
marufsharifi commentedon Jun 30, 2026
@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.
mallenexpensify commentedon Jul 6, 2026
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.
marufsharifi commentedon Jul 7, 2026
@mallenexpensify, I've accepted the offer. thanks
mallenexpensify commentedon Jul 7, 2026
@marufsharifi paid, summary updated above. Thx.