Repository navigation
Description
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.4.34-2
Reproducible in staging?: Yes
Reproducible in production?: Yes
If this was caught during regression testing, add the test name, ID and link from BrowserStack: #95002
Email or phone of affected tester (no customers): jose.sat94+10jul@gmail.com
Issue reported by: Applause Internal Team
Bug source: Pull Request QA execution
Device used: MacBook Pro/13.7.8
App Component: Workspace Settings
Action Performed:
- Launch the Expensify app.
- Log in with valid credentials to an account with a workspace (or create one).
- Start a 1:1 chat with Concierge and ask a question that returns suggested follow-up buttons (e.g., "Does Expensify support QuickBooks Online?").
- Click one of the suggested follow-up buttons.
- While Concierge is still generating the response (or while the follow-up buttons are still loading), send another message (e.g., "Does Expensify support Certinia?").
- Wait for all responses to finish loading.
Expected Result:
The conversation maintains the correct chronological order, with Concierge responses appearing after their corresponding user messages.
Actual Result:
The message order is not maintained. Concierge responses jump to the latest point in the conversation instead of staying with their corresponding user messages.
Workaround:
Unknown
Platforms:
- Android: App
- Android: mWeb Chrome
- iOS: App
- iOS: mWeb Safari
- iOS: mWeb Chrome
- Windows: Chrome
- MacOS: Chrome Safari
Screenshots/Videos
bandicam.2026-07-14.19-24-15-078.mp4
Applause Internal Information
Exported by: Julia Ponikarchuk
Bug ID: 7208293
Upwork Automation - Do Not Edit
- Upwork Job URL: https://www.upwork.com/jobs/~022077080658161185327
- Upwork Job ID: 2077080658161185327
- Last Price Increase: 2026-07-14
Metadata
Metadata
Assignees
Labels
Type
Projects
- StatusShow more project fieldsDone
Activity
applause-bot commentedon Jul 14, 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/4f8cbedeae3446b256acdc0b5463187975cdfb35d6624fa64e06943f06cde400
MelvinBot commentedon Jul 14, 2026
Issue Analysis
Root Cause: Concierge report actions are ordered purely by their
createdtimestamp (ReportActionsUtils.tsgetSortedReportActions). When you click a suggested-followup and then send another message before the reply lands, the Concierge reply gets a fresh server-sidecreated(current time) instead of the timestamp of the message it belongs to — so on the next server merge it re-sorts to the bottom of the chat, "jumping" past the message you sent in the meantime.This already has an intended fix that is client-side only — the remaining work is on the backend.
PR #95002(merged 2026-07-11, shipped to staging in 9.4.34-0) makes the App build the optimistic Concierge action first and send its exact timestamp (optimisticConciergeCreated) with theAddCommentrequest, so the server can persist the reply at that position. The App half is present in the build this bug was reported against (9.4.34-2), but it only supplies the timestamp — it depends on server-side changes to readoptimisticConciergeCreatedand persist the Concierge reply at that timestamp. Because the bug still reproduces with the App fix deployed, the server half is not yet in effect on staging/production.Recommended next step: The fix required here lives outside the App repository (backend persistence of the Concierge reply timestamp). This can't be resolved with an App-side code change. Please escalate to an internal engineer to confirm the corresponding backend changes are deployed and correctly persisting the reply at the supplied
optimisticConciergeCreatedvalue.Investigation details & evidence
How the timestamp is built and sent (App side, confirmed working):
SuggestedFollowup.ts:88-103— builds the optimistic Concierge action beforeaddComment, withcreatedOffset: CONCIERGE_RESPONSE_DELAY_MS(4000ms) so itscreatedlands strictly after the user's comment.ReportUtils.ts:6389—created: getDBTimeWithSkew(Date.now() + createdOffset).SuggestedFollowup.ts:106-124— passes that exactcreatedaspregeneratedResponseParams.optimisticConciergeCreatedand queues the same action locally, so local render and server payload agree.Report/index.ts:994-999— copies it into theAddCommentAPI params.AddCommentOrAttachmentParams.ts:16—optimisticConciergeCreated?: string(the new API field).Why the reply jumps: display order is
(actionName===CREATED first, created, reportActionID as tiebreak)—previousReportActionIDis not used. If the server assigns a newcreated = nowto the Concierge reply, it sorts below any message the user sent while waiting.Deployment evidence: PR #95002 was deployed to staging in version 9.4.34-0 (per its OSBotify deploy comment); this issue is reported on 9.4.34-2, so the App-side fix is present in the tested build yet the bug persists — pointing to the backend half as the remaining gap.
Alternative explanations considered: (1) App not sending the param — ruled out, code path confirmed above. (2) Offset too small to guarantee ordering — ruled out, offset is 4000ms and the comment at
SuggestedFollowup.ts:90-92notes 1ms was insufficient and was deliberately widened. (3) Different flow than #95002 — ruled out, the reproduction steps match #95002's test steps exactly.Confidence: High on the mechanism and that the fix is not client-side-only; the exact backend deploy status could not be verified from the public App repo.
Related issues: No open duplicate found.
#95634and#91700touch Concierge/agent rendering but are unrelated to message ordering.This appears to require a backend/internal fix, so I'm not proposing an App code change. Reply with
@MelvinBot <feedback>to refine this analysis.aswin-s commentedon Jul 14, 2026
Please re-state the problem that we are trying to solve in this issue.
When a user clicks a Concierge suggested follow-up and then, while that response is still loading, sends another message, the Concierge response for the first question appears AFTER the second user message instead of between the two user messages. Expected behavior is that each Concierge response stays chronologically anchored beneath the user message it answers — that is, the response to the first question must appear before the second user message, not after it.
What is the root cause of that problem?
In src/libs/actions/Report/SuggestedFollowup.ts:93-103, the optimistic Concierge response is built with
createdOffset: CONCIERGE_RESPONSE_DELAY_MS(4000). In src/libs/ReportUtils.ts:6389,buildOptimisticAddCommentReportActioncomputescreated = getDBTimeWithSkew(Date.now() + createdOffset)— i.e. the Concierge action's timestamp is fixed at the moment of the follow-up click + 4s. If the user sends a second message more than ~4s after clicking the first follow-up (exactly the repro window: "while Concierge is still generating"), the second user comment'screated(stamped at second-send time) is later than the pending Concierge action'screated. WhenapplyPendingConciergeAction(SuggestedFollowup.ts:178) later merges the pending Concierge action intoREPORT_ACTIONS, sort bycreated(viagetSortedReportActionsForDisplay) places it before the second user message, producing the observed out-of-order display.What changes do you think we should make in order to solve the problem?
The fix must ensure the Concierge response is anchored between the first user message and the second user message — not pushed to the latest position in the conversation. The correct anchor is a timestamp that is strictly after the first user message but strictly before the second user message that was sent during the delay window.
src/libs/actions/Report/SuggestedFollowup.ts:93-103 — at the moment of the follow-up click, record the click timestamp (
clickedAt = Date.now()). Build the optimistic Concierge action with a smallcreatedOffsetof1(one millisecond after the click), so the initial placeholder timestamp isgetDBTimeWithSkew(clickedAt + 1). StoreclickedAtalongside the pending action in Onyx so it is available when the response arrives.src/libs/actions/Report/SuggestedFollowup.ts:178-199 (
applyPendingConciergeAction) — before merging intoREPORT_ACTIONS, re-stampreportAction.createdtogetDBTimeWithSkew(clickedAt + 1)using the stored click time, notDate.now()at arrival. This anchors the Concierge response immediately after the first user message (click time + 1 ms), which is always earlier than any subsequent user message sent during the delay window. The response correctly appears between the two user messages rather than after the latest one.src/libs/actions/Report/index.ts— sinceoptimisticConciergeCreatedis sent to the server as an API parameter (AddCommentOrAttachmentParams.optimisticConciergeCreated), send the samegetDBTimeWithSkew(clickedAt + 1)value (the click-anchored timestamp) so the server-persisted Concierge action matches the client-visible order.As a complementary guard: in
SuggestedFollowup.ts, if a newaddCommentis issued on the samereportIDwhile a pending Concierge response exists, do not re-stamp the pending action'screated— leave it atclickedAt + 1. Any subsequent user messages will naturally receive a later timestamp, preserving the correct interleaving without extra logic.Add a regression test in
tests/actions/ReportTest.tscovering: click follow-up → recordclickedAt→ wait > 4s → send another comment (timestamped afterclickedAt + 4000) → apply pending Concierge action (anchored toclickedAt + 1) → assert sort order is[user1 (at clickedAt), concierge1 (at clickedAt + 1), user2 (at clickedAt + 4001+)].What alternative solutions did you explore? (Optional)
Re-stamping the Concierge action to
Date.now()at the momentapplyPendingConciergeActionfires was considered, but this would push the Concierge response to the very end of the conversation — after the second user message — which reproduces the same failure mode the issue reports. The click-anchored approach above is preferable because it ties the response to the action that triggered it rather than to its arrival time.David-2002065 commentedon Jul 14, 2026
🚨 Edited by proposal-police: This proposal was edited at 2026-07-14 17:21:20 UTC.
Proposal
Please re-state the problem that we are trying to solve in this issue.
When the user clicks a suggested follow-up button in the Concierge chat and sends another message while the pre-generated response is still pending, the Concierge response is inserted after the newer message instead of staying right below the question it answers, and the wrong order persists after the server round-trip.
What is the root cause of that problem?
When a suggested follow-up has a pre-generated response,
resolveSuggestedFollowupbuilds the optimistic Concierge reply withcreatedOffset: CONCIERGE_RESPONSE_DELAY_MS(4000 ms), so the reply'screatedtimestamp is stamped 4 seconds in the future:App/src/libs/actions/Report/SuggestedFollowup.ts
Lines 90 to 103 in 2790fa4
The offset feeds directly into the action's chronological timestamp:
App/src/libs/ReportUtils.ts
Line 6339 in 2790fa4
That 4-second value is really the display delay, but baking it into
createdopens a 4-second window: any message the user sends during that window gets acreatedthat falls between the follow-up question and its reply. Report actions are sorted bycreated, so the pending reply materializes below the newer user message (Q1, Q2, A1 instead of Q1, A1, Q2).Since PR #95002 this future timestamp is also sent to the backend as
optimisticConciergeCreated, and the server persists the final Concierge reply at that exact position — so the wrong order is now permanent, not just optimistic:App/src/libs/actions/Report/SuggestedFollowup.ts
Lines 115 to 119 in 2790fa4
The 4-second offset exists only because a 1 ms offset was racy (per the code comment): the user's comment gets its
createdfrom a separate, latergetDBTimeWithSkew()read insideaddActions, so the relative order of two independent wall-clock reads wasn't guaranteed:App/src/libs/actions/Report/index.ts
Lines 865 to 869 in 2790fa4
Meanwhile the actual 4-second reveal delay is handled independently by
displayAfterinPENDING_CONCIERGE_RESPONSE, so nothing requires the persisted timestamp to be in the future.What changes do you think we should make in order to solve the problem?
Anchor the Concierge reply's
createdto the user comment'screated+ 1 ms deterministically, and keep the 4 seconds purely as a display delay.In
resolveSuggestedFollowup, stamp the user comment's time once and derive both timestamps from that single read:Add an optional
createdparam tobuildOptimisticAddCommentReportActionthat takes precedence over the wall-clock read:And thread the optional
createdthroughaddComment/addActionsto the user-comment build (same pattern as the existingreportActionIDpass-through), so the user's comment uses the exact same base timestamp.clientCreatedTimesent to the API stays consistent automatically since it readsreportCommentAction.created.Result: the question is stamped at T and its reply at T + 1 ms, so any message sent later sorts after both — optimistically and server-side (the backend already honors
optimisticConciergeCreated). The reply still reveals 4 seconds later viadisplayAfter; it just materializes at its correct chronological slot, right below its question. The now-stale comment about the 4-second offset should be removed, and since both timestamps derive from one clock read, the ordering race that motivated the 4-second hammer is gone by construction.What specific scenarios should we cover in automated tests to prevent reintroducing the issue?
AddCommentAPI call carriesoptimisticConciergeCreatedequal to the queued pending action'screated, exactly 1 ms after the user comment'sclientCreatedTime.displayAfteronPENDING_CONCIERGE_RESPONSEis still roughly now +CONCIERGE_RESPONSE_DELAY_MS, so the display delay is unaffected by the timestamp change.What alternative solutions did you explore? (Optional)
REPORT_ACTIONSearly): this doesn't fix the order — the reply'screated(and theoptimisticConciergeCreatedalready sent to the backend) is still stamped after the new message, so it would still render below it.addActions.lorretheboy commentedon Jul 14, 2026
Proposal
What is the root cause of that problem?
When a suggested follow-up with a pregenerated response is clicked, the optimistic Concierge reply is stamped with a
createdthat is 4 seconds in the future (createdOffset: CONCIERGE_RESPONSE_DELAY_MS):App/src/libs/actions/Report/SuggestedFollowup.ts
Lines 90 to 103 in 2790fa4
Since PR #95002, that future timestamp is also sent to the backend as
optimisticConciergeCreated, and the server now persists the final Concierge reply at exactly that time:App/src/libs/actions/Report/SuggestedFollowup.ts
Lines 115 to 119 in 2790fa4
The causal chain: the reply for message 1 is stamped
t + 4s→ the user sends message 2 during that 4-second window, and its comment is stamped "now" (< t + 4s) becauseaddActionsbuilds it with no offset:App/src/libs/actions/Report/index.ts
Line 874 in 2790fa4
→ report actions sort by
created, so Concierge's reply to message 1 lands after message 2. Before PR #95002 this was only a transient local glitch — the server assigned its owncreatedwhen it persisted the reply, restoring the order. Now the client's future timestamp is pinned server-side, so the wrong order is permanent.The future stamp is unnecessary: the 4-second reveal delay is already handled purely as a display concern by
displayAfterinPENDING_CONCIERGE_RESPONSE, which holds the action out ofREPORT_ACTIONSuntil the delay elapses:App/src/libs/actions/Report/SuggestedFollowup.ts
Lines 133 to 141 in 2790fa4
What changes do you think we should make in order to solve the problem?
Stop using the display delay as the timestamp offset. The Concierge reply only needs to sort just after the user's comment, so stamp it a millisecond or two after that comment — not 4 seconds in the future.
The reason a small offset previously failed (per the comment in
resolveSuggestedFollowup) is that the two actions were built from two independentDate.now()calls, so the user comment could end up later than the Concierge stamp. Fix that by deriving both from one shared base: inresolveSuggestedFollowup, captureDate.now()once, pass it throughaddComment/addActionsas an optional explicit created time for the user's comment (a tiny addition tobuildOptimisticAddCommentReportAction, which already acceptscreatedOffsethere):App/src/libs/ReportUtils.ts
Line 6389 in 2790fa4
and build the Concierge action from the same base with a
createdOffsetof ~2ms (equivalently,DateUtils.addMillisecondsFromDateTimeon the comment'screated). Ordering is then deterministic — reply strictly after its own comment, and any later user message (always stamped at real "now") sorts after both, locally and on the server sinceoptimisticConciergeCreatedcarries the corrected value.displayAfterkeeps handling the 4-second reveal, unchanged.What alternative solutions did you explore? (Optional)
Have the backend clamp
optimisticConciergeCreatedto server time when it's in the future — but that reintroduces the position-shift PR #95002 was fixing and needs a Web-Expensify change; fixing the stamp client-side addresses the actual mistake.ahmdshrif commentedon Jul 14, 2026
🚨 Edited by proposal-police: This proposal was edited at 2026-07-14 17:22:48 UTC.
Proposal
Please re-state the problem that we are trying to solve in this issue.
Click a suggested follow-up button in the Concierge chat, then send another message while the reply is still "generating": the pre-generated Concierge reply renders below your newer message — permanently — instead of directly under the question it answers.
What is the root cause of that problem?
The reply's chronological sort key was given the UI display delay, and PR
#95002made that future-dated key permanent on the server.createdOffset: CONCIERGE_RESPONSE_DELAY_MS(4000 ms) — so itscreatedis stamped 4 seconds in the future:App/src/libs/actions/Report/SuggestedFollowup.ts
Lines 90 to 103 in 2790fa4
App/src/libs/ReportUtils.ts
Line 6389 in 2790fa4
#95002, that timestamp is sent to the API asoptimisticConciergeCreatedand the backend persists the final reply with it verbatim (that PR's goal — keep the reply from jumping on reconcile):App/src/libs/actions/Report/SuggestedFollowup.ts
Lines 115 to 119 in 2790fa4
App/src/libs/actions/Report/index.ts
Lines 994 to 999 in 2790fa4
clientCreatedTime:App/src/libs/actions/Report/index.ts
Line 970 in 2790fa4
created:App/src/libs/ReportActionsUtils.ts
Lines 794 to 802 in 2790fa4
Because both timestamps are client-authored and server-persisted, the wrong order survives reload and shows on every client — which is why QA reproduced it on staging and production right after
#95002. Before that PR the future stamp was a transient local quirk the server silently corrected; now it is the permanent record.All paths this single cause feeds (each covered below): the persisted order on every platform (shared TS, nothing web-specific); the in-flight "trickle" bubble, inserted by the same
createdcomparison (App/src/pages/inbox/report/ReportActionsList.tsx
Lines 211 to 232 in 2790fa4
applyPendingConciergeAction(App/src/libs/actions/Report/SuggestedFollowup.ts
Lines 178 to 198 in 2790fa4
t+4s— that's why "responses" (plural) jumble.What changes do you think we should make in order to solve the problem?
Derive both timestamps from one clock reading, and keep the 4-second delay purely as UI state. In
resolveSuggestedFollowup:Supporting plumbing: add an optional
created?: stringtobuildOptimisticAddCommentReportAction(created: created ?? getDBTimeWithSkew(Date.now() + createdOffset)atApp/src/libs/ReportUtils.ts
Line 6389 in 2790fa4
createdthroughaddComment→addActionsto the comment build atApp/src/libs/actions/Report/index.ts
Line 874 in 2790fa4
displayAfter(App/src/libs/actions/Report/SuggestedFollowup.ts
Lines 133 to 141 in 2790fa4
#95002's persist-the-optimistic-timestamp design are both preserved — only the value becomes correct. Persisted order is then always question (t) → reply (t+1 ms) → anything sent later. I'd update theresolveSuggestedFollowupblock intests/actions/ReportTest.tsto assert the reply'screatedis 1 ms after the comment's rather than ~4 s in the future.Regression safety in one sentence: the new
createdparams are optional with the current expressions as fallback, so every other caller (tasks, onboarding, attachments, plain comments) is byte-for-byte unchanged.Why the obvious one-line fix fails: just shrinking
createdOffsetfrom 4000 to 1 was already tried and abandoned — the in-code comment (App/src/libs/actions/Report/SuggestedFollowup.ts
Lines 90 to 92 in 2790fa4
Date.now()insideaddActions(after synchronous comment parsing), so a 1 ms offset can leave the reply stamped before its own trigger comment; any offset large enough to absorb that jitter re-opens the consecutive-message window proportionally. Deterministic order requires one shared clock reading — threading the explicitcreated, not tuning the offset.What alternative solutions did you explore? (Optional)
createdOffset(e.g. 250 ms) — no plumbing, but it only shrinks the race on both sides (slow-device stamp jitter vs. a fast second message); this class of fix already failed once per the in-code comment.createdwas already sent to the server in the click-timeAddCommentrequest, so a local re-stamp desyncs client and server and reintroduces the reconcile position-jump#95002fixed; flushing early also kills the intentional delayed reveal.optimisticConciergeCreated— the upstream half lives in Web-Expensify, but the App-side change above fully resolves the ordering on its own and is the mergeable fix here.shivang-goliyan commentedon Jul 14, 2026
🚨 Edited by proposal-police: This proposal was edited at 2026-07-14 17:42:43 UTC.
Proposal
Please re-state the problem that we are trying to solve in this issue.
When you click a suggested follow-up button in a Concierge chat and then send another message before the answer finishes loading, the answer ends up below your newer message instead of sitting right after the question it belongs to. The conversation reads out of order.
What is the root cause of that problem?
The pregenerated Concierge reply is stamped roughly 4 seconds in the future. In
resolveSuggestedFollowup(src/libs/actions/Report/SuggestedFollowup.ts:96) the reply is built withcreatedOffset: CONCIERGE_RESPONSE_DELAY_MS(4000, defined at line 19), andbuildOptimisticAddCommentReportActionturns that intocreated = getDBTimeWithSkew(Date.now() + createdOffset)atsrc/libs/ReportUtils.ts:6389. Chat order is decided entirely by thatcreatedstring:getSortedReportActions(src/libs/ReportActionsUtils.ts:788) sorts ascending bycreated, tie-broken byreportActionID, with no special-casing for Concierge orADD_COMMENT. So the reply lands atclick_time + 4000ms. Your second message is stamped at its ownDate.now()with no offset, so if you send it any time inside that 4-second window it sorts between the question and the reply, and the answer renders below it.The 4000 isn't arbitrary, and that's the real issue. The Concierge action is built before the user's comment, so an earlier attempt using a 1ms offset (commit
9e54be51cc9) failed: the reply was measured from an earlierDate.now()than the user comment's own build instant, so it could sort before its own question. Commit83358d1cbd9(2026-03-25) bumped the offset1ms → 4000msto guarantee the reply came after the question. That fixed the single-message race but widened the reorder window from 1ms to a full 4 seconds, which is what makes this so easy to hit. The deeper problem is that one 4000ms constant is doing two unrelated jobs: it's the reply's sort key offset here, and separately it's the reveal delay (displayAfter = Date.now() + 4000at line 139, consumed byusePendingConciergeResponse). The reveal delay legitimately needs 4 seconds; the sort key does not, and coupling them is what puts the reply in the wrong place.This also affects the persisted order, not just the optimistic view.
SuggestedFollowup.ts:117forwards that samecreatedintoaddCommentasoptimisticConciergeCreated, which reaches the backend via #95002 so the server persists the reply at the App-provided timestamp. So the wrong value the App computes is the value the server plants. Fixing the computation here fixes both the optimistic display and what gets persisted.What changes do you think we should make in order to solve the problem?
Anchor the reply's
createdto the user comment's owncreatedplus a 1ms epsilon, instead ofDate.now() + 4000. Concretely: compute one shared base timestamp for the user comment, stamp the user comment with it, and stamp the Concierge reply atbase + 1ms. This is the same "second optimistic action sorts immediately after the first" idiom already used across the codebase viaDateUtils.addMillisecondsFromDateTime(src/libs/DateUtils.ts:377) inIOU/Hold.ts,IOU/RejectMoneyRequest.ts,IOU/SplitTransactionUpdate.tsandReportUtils.ts:7622.One honest note on the plumbing, since it's more than a one-liner:
buildOptimisticAddCommentReportActiontoday only acceptscreatedOffset(an offset fromDate.now()), not an explicitcreated, andaddComment/addActionsbuilds the user comment with its own internalgetDBTimeWithSkew(Date.now()). To make the user comment and its reply share one base, we thread a new optionalcreated(or shared base) throughSuggestedFollowup→addComment/addActions→buildOptimisticAddCommentReportAction, defaulted so every other caller is unchanged. KeepdisplayAfter's 4-second reveal exactly as it is — it's computed independently and doesn't need thecreatedstamp to be future-dated.Why 1ms is enough now when it wasn't before: the old 1ms failed because it was measured from an earlier instant than the user comment's own build time. Deriving the reply from the user comment's own
createdremoves that race — the epsilon is measured against the exact value it has to beat, soquestion < reply < any later messageholds in every case. And the corrected value is what flows intooptimisticConciergeCreated, so the persisted position is right too (assuming the backend honours the App value per #95002's design — worth confirming against Web-Expensify #54097 / Auth #22590, since we can't see server-side persistence from this repo).I'd also add the test coverage that's currently missing. #95002 added a test that
optimisticConciergeCreatedis forwarded, but nothing covers the interleaved-message ordering that actually broke. Add a Jest test that builds the optimistic Concierge action, sends a second user comment with acreatedbetween the click and the reveal, runsgetSortedReportActions, and asserts[Q1, reply-to-Q1, Q2]— plus that the reply'screatedequals the user comment'screated + 1ms, notnow + 4000.What alternative solutions did you explore? (Optional)
Shrinking the offset from 4000 to something small while still measuring off
Date.now()doesn't work — it re-opens the original race (reply can sort before its own question) and still breaks whenever a message lands inside the smaller window. It narrows the bug rather than removing it. Plumbing the timestamp to the backend and stopping there is what #95002 already did, and QA reproduced this on top of it, so it's necessary but not sufficient. Special-casing Concierge replies insidegetSortedReportActionswould touch a global used by every report list, so I'd rather fix the value at its source than change the sort for all chats.KJ21-ENG commentedon Jul 14, 2026
🚨 Edited by proposal-police: This proposal was edited at 2026-07-14 20:32:14 UTC.
Proposal
What is the root cause of that problem?
This is a regression from PR #95002 (
4a7cc2db5c4). For a pre-generated follow-up reply,resolveSuggestedFollowup()uses the four-second UI reveal delay ascreatedOffset, then sends that future timestamp to the API asoptimisticConciergeCreated.App/src/libs/actions/Report/SuggestedFollowup.ts
Lines 87 to 124 in 2790fa4
That timestamp is conversation-ordering data, not merely reveal timing. Report actions are ordered by
created, and the synthetic Concierge draft is also inserted into the list according to its copiedcreatedvalue. Therefore, any second user message sent during those four seconds has an earlier timestamp than the first question's Concierge reply, so the reply moves below the second message. The short-reply and persisted paths have the same problem because they apply the same pending report action.App/src/libs/ReportActionsUtils.ts
Lines 776 to 812 in 2790fa4
App/src/hooks/usePendingConciergeResponse.ts
Lines 150 to 183 in 2790fa4
App/src/pages/inbox/report/ReportActionsList.tsx
Lines 200 to 231 in 2790fa4
What changes do you think we should make in order to solve the problem?
Decouple the response's chronological timestamp from
CONCIERGE_RESPONSE_DELAY_MS. InresolveSuggestedFollowup(), capture one base time for the selected user question, assign that exact time to the optimistic question, and assign the pre-generated Concierge action a deterministic timestamp one millisecond later. Continue usingdisplayAfter = Date.now() + CONCIERGE_RESPONSE_DELAY_MSsolely to control when the response becomes visible. Pass the same paired Concierge timestamp throughoptimisticConciergeCreated, so the optimistic draft, delayed Onyx action, and server action all remain immediately after their corresponding question even when newer messages arrive.To make this deterministic, allow
buildOptimisticAddCommentReportAction()and the narrowaddActions()path to accept an optional explicitcreatedvalue. OnlyresolveSuggestedFollowup()should supply it for the paired user/Concierge actions. Existing builder consumers (addActions()for ordinary text/attachments,buildOptimisticTaskCommentReportAction(), onboarding welcome messages,respondToProactiveAppReview(),pressLockedBankAccount(),buildOnyxDataForTestDriveIOU(), andaddCommentToSplitTransactionThread()) should omit the new option and retain their current timestamp behavior. The shared report-action sorter is correct and should not be changed.App/src/libs/ReportUtils.ts
Lines 337 to 350 in 2790fa4
App/src/libs/ReportUtils.ts
Lines 6347 to 6385 in 2790fa4
App/src/libs/actions/Report/index.ts
Lines 370 to 403 in 2790fa4
App/src/libs/actions/Report/index.ts
Lines 872 to 876 in 2790fa4
Keep the existing API contract that sends the local Concierge ID and timestamp; only change how the timestamp is derived.
App/src/libs/actions/Report/index.ts
Lines 964 to 998 in 2790fa4
Test coverage:
resolveSuggestedFollowuptests to freeze time, click a follow-up with a pre-generated response, add another normal message before the four-second reveal, and assert the sorted order remains selected question, paired Concierge response, then the newer user message.displayAfterremains four seconds later, and the API'soptimisticConciergeCreatedequals the local pending action'screatedvalue.REPORT_ACTIONSand a long response dispatched through the Concierge draft path so optimistic, streaming, and canonical rendering use the same chronological anchor.App/tests/actions/ReportTest.ts
Lines 6336 to 6434 in 2790fa4
What alternative solutions did you explore? (Optional)
I considered changing
ReportActionsListto insert an active Concierge draft next to the user question by report-action ID instead of by timestamp. That would address only the synthetic streaming bubble; short replies and canonicalREPORT_ACTIONSwould still be sorted by the futurecreatedtimestamp, and other clients would still receive the wrong chronology. Correcting the paired timestamps at creation time fixes every rendering path while preserving the shared sorter.melvin-bot commentedon Jul 14, 2026
Triggered auto assignment to Contributor-plus team member for initial proposal review - @bernhardoj (
External)14 remaining items
jl3panadero-source commentedon Jul 14, 2026
🔧 AgentWork — Solución
Análise do Erro
O erro ocorre quando o usuário envia mensagens consecutivas para o Concierge enquanto as respostas anteriores ainda estão sendo geradas. Isso causa a quebra da ordem cronológica da conversa, fazendo com que as respostas do Concierge sejam exibidas no final da conversa em vez de serem exibidas após as mensagens correspondentes do usuário.
Código Corrigido
Para corrigir esse erro, é necessário implementar uma lógica que garanta a ordem cronológica da conversa. Uma possível solução é utilizar um mecanismo de fila para gerenciar as mensagens e respostas do Concierge.
Aqui está um exemplo de código que pode ser utilizado para corrigir o erro:
Nesse exemplo, o Concierge utiliza uma fila para gerenciar as mensagens e respostas. Quando o usuário envia uma mensagem, ela é adicionada à fila. O Concierge processa as mensagens na fila e gera as respostas correspondentes. As respostas são então exibidas na conversa.
Explicação da Correção
A correção consiste em implementar um mecanismo de fila para gerenciar as mensagens e respostas do Concierge. Isso garante que as mensagens sejam processadas na ordem em que foram enviadas e que as respostas sejam exibidas na conversa de forma cronológica.
Além disso, a utilização de uma fila permite que o Concierge processe as mensagens de forma assíncrona, o que melhora a performance e a escalabilidade da aplicação.
══════════════════════════════════════════════════════
TRABAJO ENTREGADO POR AgentWork jl1panadero@hotmail.com🔧
Elige tu método de pago preferido:
══════════════════════════════════════════════════════
💳 Stripe (tarjeta): https://buy.stripe.com/6oUdR9gJJbBEgwo8lW6AM00
◎ Solana (SOL/USDC): DNKb2wYGpUKsEFHbK1qiUvFSKBW1uSgxf7mSPB1HePNk
Ξ Ethereum (ETH): 0xD31405C4CAF55D785937595FB1144d41776a36cc
🌐 Fetch.ai (FET): 0x6600871B4a7a1D10B4081C30C2D73715482e3DfD
₿ Bitcoin (BTC): bc1qt4ue0u4hgwlyqaza98h9099zfqxpl5580ypng4
══════════════════════════════════════════════════════
Gracias por confiar en AgentWork 🔧
══════════════════════════════════════════════════════
Entregado por AgentWork v3.1
Si necesitas un PR, puedo crearlo.
andriiops commentedon Jul 14, 2026
Proposal
Please re-state the problem that we are trying to solve in this issue.
In a 1:1 Concierge chat, clicking a suggested follow-up (which has a pre-generated response) and then sending another message while that reply is still pending causes the Concierge reply to render after the newer message instead of directly beneath the question it answers — and, since PR #95002, the wrong order is now persisted server-side and survives reload.
What is the root cause of that problem?
In
resolveSuggestedFollowup, the optimistic Concierge reply is built withcreatedOffset: CONCIERGE_RESPONSE_DELAY_MS(4000ms), so itscreatedis stamped 4 seconds in the future:https://github.com/Expensify/App/blob/main/src/libs/actions/Report/SuggestedFollowup.ts#L88-L103
createdOffsetflows straight into the sort key:https://github.com/Expensify/App/blob/main/src/libs/ReportUtils.ts#L6389
Since PR #95002, that same future timestamp is sent to the API as
optimisticConciergeCreatedand the backend persists the reply at exactly that position:https://github.com/Expensify/App/blob/main/src/libs/actions/Report/SuggestedFollowup.ts#L106-L119
Meanwhile any message the user sends during the 4s window goes through the normal
addActionspath with no offset, so it getscreated = getDBTimeWithSkew(Date.now())— a value earlier thanT0 + 4000:https://github.com/Expensify/App/blob/main/src/libs/actions/Report/index.ts#L874
Report actions are displayed sorted by
created, so once the pending Concierge action is merged intoREPORT_ACTIONSit sorts after the newer user message →Q1 → Q2 → A1instead ofQ1 → A1 → Q2:https://github.com/Expensify/App/blob/main/src/libs/ReportActionsUtils.ts#L788-L813
The 4s future stamp is unnecessary for display: the reveal delay is handled independently by
displayAfterinPENDING_CONCIERGE_RESPONSE, which holds the action out ofREPORT_ACTIONSuntil the timer fires:https://github.com/Expensify/App/blob/main/src/libs/actions/Report/SuggestedFollowup.ts#L126-L135
So
CONCIERGE_RESPONSE_DELAY_MSis doing double duty — the visual reveal delay AND the sort offset — and those two requirements conflict. The in-code comment notes a 1ms offset was "not enough", because the user's comment is stamped by a separate, laterDate.now()insideaddActions; the two independent clock reads couldn't be ordered reliably, which is why the offset was widened to the full 4s (overcorrecting into this bug).What changes do you think we should make in order to solve the problem?
Derive both timestamps from a single clock read and stamp the reply 1ms after its own question — keeping the 4s purely as a display delay. This respects PR #95002's design (we still send
optimisticConciergeCreated); we only make the value correct.In
resolveSuggestedFollowup:Supporting plumbing:
created?: stringtobuildOptimisticAddCommentReportAction—created: created ?? getDBTimeWithSkew(Date.now() + createdOffset). Optional with the current expression as fallback, so every other caller (tasks, onboarding, attachments, plain comments) is byte-for-byte unchanged.createdthroughaddComment→addActionsto the user comment build (same pattern the existingreportActionIDpass-through uses), so the user's comment and the reply share one base.addOptimisticConciergeActionWithDelay/usePendingConciergeResponseuntouched —displayAfterkeeps driving the 4s reveal.Result: question stamped at
T, reply atT + 1ms, so anything sent later always sorts after both — optimistically and server-side. The reply stays pinned directly beneath its own question (Q1 → A1 → Q2), which is exactly the Expected Result.Note: re-stamping the reply to a fresh
Date.now()at apply time is intentionally NOT used — that pushes the reply to the end of the conversation (afterQ2), contradicting the Expected Result that the reply stays with its corresponding user message.What specific scenarios should we cover in automated tests to prevent reintroducing this issue?
[question1, conciergeReply1, question2].AddCommentrequest carriesoptimisticConciergeCreatedexactly 1ms after the user comment'screated.displayAfteronPENDING_CONCIERGE_RESPONSEis still ≈ now +CONCIERGE_RESPONSE_DELAY_MS(reveal delay unaffected).What alternative solutions did you explore? (Optional)
Date.now()inapplyPendingConciergeAction— sends the reply to the end of the chat (after the newer message) and desyncs from theoptimisticConciergeCreatedalready sent to the server, reintroducing the reconcile jump [Payment due @bernhardoj] Send optimistic Concierge timestamp for pregenerated replies #95002 fixed.optimisticConciergeCreated— the App-side fix fully resolves ordering on its own and is the mergeable change here; a backend clamp would re-open the position-shift [Payment due @bernhardoj] Send optimistic Concierge timestamp for pregenerated replies #95002 addressed.melvin-bot commentedon Jul 14, 2026
📣 @panandrusha-beep! 📣
Hey, it seems we don’t have your contributor details yet! You'll only have to do this once, and this is how we'll hire you on Upwork.
Please follow these steps:
Format:
andriiops commentedon Jul 14, 2026
Contributor details
Your Expensify account email: panandrusha@gmail.com
Upwork Profile Link: https://www.upwork.com/freelancers/~01ddfdbabd386de370
melvin-bot commentedon Jul 14, 2026
✅ Contributor details stored successfully. Thank you for contributing to Expensify!
neerajbachani commentedon Jul 14, 2026
Proposal
Please re-state the problem that we are trying to solve in this issue.
In a 1:1 Concierge chat, when a user taps a suggested follow-up that has a pre-generated response and then sends another message while that reply is still pending (during the ~4s “Concierge is thinking” window), the Concierge answer appears after the newer message instead of directly beneath the question it answers. Expected order is
Q1 → A1 → Q2; actual order isQ1 → Q2 → A1. This matches the QA reproduction for PR #95002 and reproduces on every listed platform because sorting is shared TypeScript, not platform-specific UI.What is the root cause of that problem?
Report actions are ordered primarily by each action’s
createdtimestamp (withreportActionIDonly as a same-millisecond tie-break). There is no separate parent/child link that keeps a Concierge reply next to the prompt that triggered it:App/src/libs/ReportActionsUtils.ts
Lines 788 to 812 in 6d2f215
When a suggested follow-up includes a pre-generated reply,
resolveSuggestedFollowupbuilds that optimistic Concierge action withcreatedOffset: CONCIERGE_RESPONSE_DELAY_MS(4000ms) — the same constant used for the visual reveal delay:App/src/libs/actions/Report/SuggestedFollowup.ts
Lines 18 to 19 in 6d2f215
App/src/libs/actions/Report/SuggestedFollowup.ts
Lines 90 to 124 in 6d2f215
That offset is baked directly into the sort key:
App/src/libs/ReportUtils.ts
Lines 6386 to 6388 in 6d2f215
Meanwhile the user’s follow-up question is stamped later inside
addActionswith no offset (a separateDate.now()read):App/src/libs/actions/Report/index.ts
Lines 873 to 876 in 6d2f215
The 4-second reveal is already handled independently by
displayAfteronPENDING_CONCIERGE_RESPONSE(consumed byusePendingConciergeResponse);createdis not needed for that delay:App/src/libs/actions/Report/SuggestedFollowup.ts
Lines 133 to 140 in 6d2f215
Race timeline (why consecutive messages break):
T0→ question stampscreated ≈ T0.created = T0 + 4000msand is held out of the list untildisplayAfter.T0 + ~2s→ that message stampscreated ≈ T0 + 2s.createdyieldsQ1 (T0) → Q2 (T0+2s) → A1 (T0+4s).That future
createdis also sent to the API asoptimisticConciergeCreated(added by PR #95002), so the backend is asked to persist the reply at the same incorrect position:App/src/libs/API/parameters/AddCommentOrAttachmentParams.ts
Lines 15 to 17 in 6d2f215
App/src/libs/actions/Report/index.ts
Lines 994 to 999 in 6d2f215
How we got here historically:
createdOffsetwas first used to keep A1 after Q1, with reveal delay left todisplayAfter(commit9e54be51cc94).addCommentstamps the question), so PR #86382 widened the offset to the full 4s reveal delay — fixing the single-message case but opening this consecutive-message window.createdthroughAddCommentso reconciliation doesn’t reposition the reply, but it still transports the future-dated value from the 4s offset. This issue was filed from QA of that PR (#95002in the issue body;jponikarchukconfirmed it on the PR).#95002is the incomplete fix under test, not a separate PR that newly introduced the local race.MelvinBot’s “backend half not deployed” diagnosis is incomplete: even perfect server persistence of
T0 + 4000msstill sorts A1 after any Q2 sent inside the 4s window. The App chooses the wrong anchor.What changes do you think we should make in order to solve the problem?
Decouple the sort key from the reveal delay. Keep
#95002’soptimisticConciergeCreatedplumbing; only make the value it carries correct. Follow the existing Hold/Reject pattern of one shared base timestamp + 1ms for the paired action:App/src/libs/actions/IOU/Hold.ts
Lines 63 to 66 in 6d2f215
1. In
resolveSuggestedFollowup, take one clock read and derive both timestamps from itRemove the stale comment that claims the 4s offset is required for sort order. Leave
addOptimisticConciergeActionWithDelay/displayAfter: Date.now() + CONCIERGE_RESPONSE_DELAY_MSuntouched so the thinking/trickle reveal pacing is unchanged.2. Optional
created?: stringonbuildOptimisticAddCommentReportActionToday’s params only expose
createdOffset(an offset from a freshDate.now()):App/src/libs/ReportUtils.ts
Lines 337 to 350 in 6d2f215
Optional fallback keeps every other caller byte-for-byte unchanged.
3. Thread the same optional
createdthroughaddComment→addActionsSame pass-through pattern already used for
reportActionID:clientCreatedTimealready readsreportCommentAction?.created, so the API stays consistent automatically.Resulting order:
Q1 (T) → A1 (T+1ms) → Q2 (later wall clock). Both optimistic and persisted positions stay correct becauseoptimisticConciergeCreatedstill carries A1’screated. Why 1ms works now but failed historically: the old 1ms offset was measured from an earlier independentDate.now()than the question’s stamp insideaddActions; deriving A1 from the question’s owncreatedremoves that race by construction.Blast radius: Suggested-followup pregenerated path + a defaulted optional param on shared builders. Ordinary composer sends, attachments, onboarding, and non-pregenerated Concierge replies are unchanged.
displayAfter/ trickle / thinking indicator unchanged.#95002’s reconciliation contract is preserved — only the timestamp value becomes adjacent to its question.What alternative solutions did you explore? (Optional)
T0 + 4000msstill places A1 after any Q2 sent in the delay window. The App must stop choosing that future anchor.createdOffsetto 1ms / 50ms with two independent clock reads: reopens the original Q1/A1 race that PR #86382 documented; a small window also still breaks for a fast second message. Shared base + 1ms is required.createdtoDate.now()insideapplyPendingConciergeAction: that pushes A1 to the end of the chat (after Q2), which is the reported wrong order, and desyncs from theoptimisticConciergeCreatedalready sent at click time — undoing#95002.getSortedReportActions: touches the global sort path for every report list to mask one bad timestamp written in one place. Prefer fixing the value at its source.optimisticConciergeCreatedwrong on the server, and kills the intentional delayed reveal.What specific scenarios should we cover in automated tests?
createdfalls between Q1 and the oldT0+4000msConcierge stamp, apply the pending Concierge action, and assertgetSortedReportActionsorder is chronologically[Q1, A1, Q2](and never[Q1, Q2, A1]).ADD_COMMENTcarriesoptimisticConciergeCreatedequal to the pending action’screated, and that value is exactly 1ms after the user comment’screated/clientCreatedTime(update the existing “strictly after user comment” test intests/actions/ReportTest.tsso it no longer encodes a ~4s gap as the success criterion).PENDING_CONCIERGE_RESPONSE.displayAfteris still approximatelynow + CONCIERGE_RESPONSE_DELAY_MS, so the reveal delay is unaffected by the sort-key change.response) still only posts the user comment and does not invent Concierge timestamps.wildan-m commentedon Jul 14, 2026
Proposal updated — added compare branch with implementation.
FitseTLT commentedon Jul 14, 2026
Proposal
What is the root cause of that problem?
Report actions are ordered purely by
created(getSortedReportActions). There are three separate defects that together produce the reported behaviour.1. The 4-second display delay is being used as the sort key.
When a suggested follow-up has a pre-generated reply, the reply is built with the reveal delay as its timestamp offset (
SuggestedFollowup.ts:90-96), and that offset lands directly increated(ReportUtils.ts:6389). So the reply is stamped 4 seconds in the future. Any message the user sends inside that window is stamped with the real current time and therefore sorts between the question and its reply — the reported symptom.The reply never needed a future timestamp. The 4-second reveal is already owned entirely by
displayAfter(SuggestedFollowup.ts:139), which is what holds the action out ofREPORT_ACTIONSuntil the timer fires (usePendingConciergeResponse.ts:138). Nothing in the reveal path readscreated.2. The reply's timestamp is client-authored; the question's is server-authored. This is why no offset works.
This is the part that matters, and it is why simply shrinking the offset fails.
The reply is stamped by the client, at click time, as an absolute value. The question is not:
AddCommentre-stamps it with the server'screated, and — I confirmed this — theAddCommentresponse does not include the Concierge reply. So the moment the request lands, the client is holding a server-stamped question next to a client-stamped reply, and nothing ever reconciles the reply.The gap between those two clocks is unbounded:
This also explains the history that the in-code comment gets wrong.
createdOffset: 1was tried in9e54be51cc9and abandoned;83358d1cbd9widened it to the full 4s, blaming "both actions queued to Onyx near-simultaneously". That diagnosis is incorrect. 1ms did not fail because of an Onyx race — it failed because 1ms cannot bridge two clocks. The 4000ms was never a race guard; it was a latency cushion. Any fixed number is guessing at a delay it has no way to bound.3. The reply has two render paths, and only one of them reads the corrected timestamp.
After the reveal, the reply renders from
REPORT_ACTIONS. During the reveal, a long reply renders as a synthetic draft whichReportActionsList.tsx:223splices into the list by its copiedcreated— and that value is read from a snapshot taken when the effect started (usePendingConciergeResponse.ts:181). So even with a correct timestamp in Onyx, the trickling bubble still renders at the stale slot. Any fix that only correctscreatedleaves this path broken.Separately, the short-reply path applies the optimistic copy on a bare timer with no
persistedActioncheck (usePendingConciergeResponse.ts:152), unlike the trickle path which guards against exactly this (:213). So a stale optimistic reply can overwrite the server's correct one.What changes do you think we should make in order to solve the problem?
1. Take the display delay out of the sort key. Stop passing
createdOffset: CONCIERGE_RESPONSE_DELAY_MS. Stamp the question and the reply from a single clock read, with the reply 1ms after the question.displayAfterkeeps owning the 4-second reveal and the trickle, unchanged. This requires an optional explicitcreatedonbuildOptimisticAddCommentReportAction(ReportUtils.ts:6389) threaded throughaddComment/addActions(index.ts:874); it defaults to today's expression so every other caller is unchanged.2. Keep the reply anchored to its question instead of snapshotting it. This is the core of the fix, and what makes the offline and clock-skew cases correct.
Pin the question's
reportActionIDwhen the follow-up is clicked (addCommentalready accepts one), store it onPENDING_CONCIERGE_RESPONSE, and carry it intoCONCIERGE_PENDING_FOLLOWUP_LISTinapplyPendingConciergeActionso the link survives the reveal. Then, inusePendingConciergeResponse, watch the question'screatedand re-derive the reply's toquestion + 1msevery time the question moves — writing to the pending key before the reveal, and intoREPORT_ACTIONSafter it.The client cannot predict what timestamp the server will give the question, so it must not try. Re-deriving is the only stamp it can be sure of. When
AddCommentfinally lands — 200ms later or 2 minutes later — the reply follows the question down instead of being stranded above it.3. Make the trickling draft read the live
createdrather than the click-time snapshot, so the synthetic bubble renders in the same slot the action will land in.4. Give the short-reply path the same
persistedActionguard the trickle path already has, so a stale optimistic reply can never clobber the canonical one.The result: the reply sits directly beneath the question it answers, whatever timestamp the server assigns that question, online or offline — and the "Concierge is thinking…" pause and trickle animation are untouched.
What alternative solutions did you explore? (Optional)
Date.now()or from a stored click time. Still a snapshot — the question moves after the reveal when the request was queued offline, so the reply is stranded again.optimisticConciergeCreated. Unnecessary: the server already persists the pair in the correct order (clearing the cache after every repro shows the right order). The defect is entirely in the client's optimistic copy.getSortedReportActions. That changes a hot path used by every report in the app to compensate for one bad timestamp written in one place.godzillaxbox19982014-lgtm commentedon Jul 14, 2026
A small clarification to my earlier comment: the Workspace component paths I cited are not involved in this flow.
One additional verified detail in the actual pending-response path: correcting
PENDING_CONCIERGE_RESPONSE.reportAction.createdwithout changing the action ID will not reach a short reply.usePendingConciergeResponsesnapshotsreportActionanddisplayAfter, then its binary branch schedules that captured object (usePendingConciergeResponse.ts:125-153). Although later Onyx values refreshtrickleInputsRef(lines 57-60), this effect only depends onreportIDandreportActionID(lines 274-283), so a same-IDcreatedchange neither restarts the timer nor changes the object it will merge.Therefore, timestamp reconciliation must also make the binary timer read the latest pending action (or rerun when
createdchanges); a persisted-action guard alone does not cover this case. Add a regression that queues a short reply at T, updates the same pending ID to T′ beforedisplayAfter, advances the timer, and assertsREPORT_ACTIONS[id].created === T′. Otherwise the short path can restore the stale order even after pending state was corrected.Dip-G-Git commentedon Jul 15, 2026
🚫 Duplicated proposal withdrawn by 🤖 ProposalPolice.
github-actions commentedon Jul 15, 2026
bernhardoj commentedon Jul 15, 2026
@inimaga I don't think this is a bug.
I can't reproduce the "Concierge is thinking..." message when selecting the follow-up options, but I do see it when sending a normal message. "Concierge is thinking..." is not a real message, it's technically a header, an indicator that concierge is processing the message, so it's always shown at the bottom of the chat (list is inverted).
App/src/pages/inbox/report/ReportActionsListHeader.tsx
Lines 13 to 19 in 8e44135
So, when we send more messages before the processing is done, it makes sense that the concierge responses will be at the end.
inimaga commentedon Jul 15, 2026
@bernhardoj Yeah, I agree with your assessment. I am able to reproduce but this behaviour is as intended. We just recently had a couple of PRs merged for this current order. Closing.