Skip to content

fix(chat): draw the first send into an empty chat at once - #37533

Merged
KiroCrewCaptain merged 1 commit into
mainfrom
crew/kiro-crew-rust/empty-first-send
Nov 15, 2026
Merged

KiroCrewCaptain merged 1 commit into
mainfrom
crew/kiro-crew-rust/empty-first-send

Conversation

@buluoray

@buluoray buluoray commented Nov 15, 2026 •

Copy link
Copy Markdown
Contributor

Problem / Motivation

Goal: The first message a user sends into an empty chat, and the reply to it, show up as they arrive on a slow device.

On a slow device the first send into an empty chat leaves the transcript blank. With the CPU throttled 4x, the prompt reached the screen 3.6 to 8.6 s after Enter in 11 runs on main, and not within the 12 s reply in a twelfth. The reply waits with it. The store holds the prompt about 0.1 s after Enter, the composer has cleared and the stop button is lit, so the user looks at an empty chat that is working.

Those runs use a simulated backend whose reply starts as soon as the request returns, under 1 s after Enter. A real model starts later; Manual verification says what main does then.

#37414 made rows added at the tail of a transcript render at once, and named this case as the one it left.

Why it matters

The first send is the first thing every new chat does. On a slow laptop or phone the user sends, the welcome screen goes away, and nothing replaces it for five seconds or more. They cannot tell whether the message went out.

Not a goal

  • A send made while an empty chat's page is still being fetched (a chat reopened from the cache, before its fetch lands). The transcript is not known to be empty yet, so its first rows stay deferred as before.
  • A change that reaches a row before the tail: a landed page of history, an edit, a regroup of earlier rows. It stays deferred.
  • Smooth frames on the throttled device. The reply is on screen; the main thread is still full.
  • The time from Enter to POST /api/chat.

What changed (motivation → approach → change)

Symptom. Blank transcript for 5 s or more after the first send, at 4x CPU throttle, when the reply starts within a second of the send.

Where the time goes. Profiled on main with the React profiling build and the scheduler's own hooks (render started, yielded, committed, each with its lanes), the store subscribed, and the DOM watched. One run on main:

Event ms after Enter
Prompt in the store 98
POST /api/chat leaves 438
First reply chunk in the store 515
Prompt and reply on screen 5455

Between the send and the prompt reaching the screen React made 264 urgent commits. It started the background render that holds the prompt 19 times and threw it away 18 times. The one that committed, at 5.2 s, ran without yielding: its lane had expired. So the wait is not the network, the request, or the session being set up. It is React's five-second limit on a starved background render. A second run gave 6038 ms with 303 urgent commits and 24 thrown-away renders.

With no reply at all the same build shows the prompt at 0.86 s, after 6 thrown-away renders. With the reply held back 1.5 s the prompt shows at 0.87 s and the reply 0.15 s after its first chunk. So the long wait needs the reply to start before that first background render commits.

Cause. useTranscriptRows hands the transcript to the virtualizer through useSlotDeferredValue. The first rows of an empty transcript go to the deferral, because for a chat that is still loading they are its page landing, which is what the deferral exists for. The first send into an empty chat has the same shape, so it waits too. Every streaming flush then re-renders the chat page at urgent priority and restarts the background render the prompt waits for.

Change. Two parts.

  1. useSlotDeferredValue takes a second rule, drawnAtOnce(committed, next). It is judged against the value the deferral last committed, which is what the deferred path would otherwise keep on screen. When it holds, the value renders in this commit while its deferred render is still pending. It does not hold the deferral's input back, so the deferral is handed the value as before.
  2. isFirstTurnOfEmptyChat is that rule for the transcript. It holds when the committed transcript is loaded and empty and the new one holds a single turn. The transcript frame carries loaded for this (!slotLoading && slotSwitchTarget !== activeSlot, the test the page already uses for its busy-turn controls).
Transcript the deferral last committed Next transcript main this branch
Empty, still loading Its page deferred deferred
Empty, loaded The first send and its reply (one turn) deferred drawn at once
Empty, loaded Rows that hold a second turn (a page of history) deferred deferred
Not empty Any unchanged unchanged

grewOnlyAtTail is the same as on main, so the deferral is handed the same frames as on main and what it holds moves on with the first rows. The first version of this PR changed grewOnlyAtTail instead; the deferral then kept the empty frame for the whole visit, which the Opus review blocked. That change is gone.

The visit key that keeps a session switch from showing the session the user left (the #8526 note in the hook) is unchanged. A switch still renders the incoming transcript in its first commit, and drawnAtOnce is only consulted when the committed value belongs to the current visit.

While the first turn's deferred render is pending, a value that does not pass the rule (a second turn starting) keeps the last value drawn on screen, not the empty chat: the hook now records every value it renders live, not only the ones the deferral has caught up with.

One thing a maintainer should know, about main and not changed here: in a new chat the frame the deferral holds after the first send is the one-row prompt. grewOnlyAtTail checks the rows before the held frame's last row, and a one-row frame has none, so on main a page landing in front or an edit of an earlier row in such a chat already counts as "tail only" (checked on main's grewOnlyAtTail: both return true). This PR leaves that as it is.

Backwards compatibility

Compatible: useSlotDeferredValue gains an optional fourth argument and has one caller. grewOnlyAtTail is unchanged. useTranscriptRows gains a required transcriptLoaded option and has one caller, ChatPage, which passes it.

Removes nothing: no export, prop, setting or deferral path is removed.

Tests

  • hooks/useSlotDeferredValue.test.ts, drawnAtOnce, with useDeferredValue held at its first frame: a value that passes renders at once and is still handed to the deferral; a later value that does not pass keeps the last value drawn at once, not the committed one; the rule is judged against the committed value, not the pending one.
  • pages/chat/page/transcriptRows.test.ts, isFirstTurnOfEmptyChat: holds for the first send, its first chunk and a tool row, and when the running turn takes a steer or a parked send; fails for rows that hold a second turn, while the empty transcript is still loading, when rows are already on screen, and when there is nothing to draw. The grewOnlyAtTail cases are main's, unchanged.
  • pages/chat/page/transcriptRows.deferral.test.ts, useTranscriptRows with the deferral held the same way: the first send and its reply are in the render that brings them, and the deferral is handed the first rows once (two inputs for the turn: the empty chat and the prompt); a chat that loads empty and then gets its first send draws it at once; a page stays deferred when it lands in a chat still loading, when it holds several turns and lands in a loaded empty chat, and when it lands after an empty chat started loading again; a second turn that starts before the first rows committed keeps the first turn on screen and shows once they commit; the first send of a new chat opened from another session never shows that session's rows.
  • Red on main: against origin/main's two source files the new cases fail 10 of 39. Against this PR's first version they also fail 10 of 39, among them the page of several turns landing in a loaded empty chat and the count of inputs handed to the deferral.
  • Each guard removed in turn: recording only caught-up values as live fails 2 cases; dropping the loaded test fails 3; dropping the second-turn test fails 3.
  • Determinism: the three files ran 5 times in shuffled order (seeds 11, 23, 37, 41, 59), 39 of 39 passing each run. No timer, clock or sleep in any of them.
  • 416 website test files that name the chat page, the transcript or the deferral pass (7744 tests), with tsc -p tsconfig.app.json and eslint src/ --max-warnings 0.

Proof: not provable -- frontend test (prove.py runs Python only)

Manual verification

What these numbers are. The backend is simulated: /api/** is answered by stub-dashboard-api and the websocket is mocked. In the table below the reply starts as soon as POST /api/chat returns, under 1 s after Enter, where a real model takes longer. The numbers are the time the dashboard takes to draw, not model latency. A reply that starts later is covered under the table.

Gateway-free rig, the one #37414 used: the production build behind scripts/lib/serve-dist.mjs. An empty pinned chat is open, the prompt is typed in the composer and sent with Enter, and a reply streams at 540 characters per second, 1440x900. Main and the branch alternate in one script with main run twice per round (A/A), 6 rounds. Every run started under host load 13. Before any number was read, the DOM was checked for the prompt and the reply's first words in a transcript row.

The table was measured on this PR's first version, ab65ac9c946. The current head draws the first turn in the same commit as that version did and differs in what it hands the deferral. The current head is being measured again, together with replies that start 1.5 s and 3 s after the send, and this section will be replaced with those runs. So far the current head has one run of the profiling build at 4x: the prompt and the reply were on screen (DOM checked) after 7 urgent commits and no background commit; the host was loaded, so no time is quoted from it.

First send into an empty chat, reply starts with the request main (12 runs) first version (6 runs)
CPU 4x slower: prompt on screen, from Enter 3.6 to 8.6 s in 11 runs, not within 12 s in 1 0.31 to 0.48 s
CPU 4x slower: reply on screen, from Enter same as the prompt 0.56 to 0.77 s
No throttle: prompt on screen 92 to 128 ms 72 to 192 ms
No throttle: reply on screen 139 to 223 ms 149 to 291 ms
No throttle: frame interval p95 16.7 to 16.8 ms 16.7 to 16.8 ms

Per pair at 4x, prompt on screen: -5.4, -5.3, -5.3, -3.1, -5.3 s (in the other pair main never showed it). Without throttle the median pair is -20 ms for the prompt and +10 ms for the reply; main run twice differs by 5 ms and 1 ms.

A reply that starts later. On the profiling build at 4x, one run each on main: with no reply the prompt shows at 0.86 s; with the reply held back 1.5 s the prompt shows at 0.87 s and the reply 0.15 s after its first chunk. So with a model that takes more than about a second to start, main already shows the prompt in under a second, and what this PR saves is the part of that second the prompt spends waiting. The paired runs for 1.5 s and 3 s will put a number on it.

An open 100-row chat, 3 rounds, was unchanged on the first version: at 4x the prompt shows after 0.28 to 0.33 s on main and 0.29 to 0.30 s on the branch; without throttle 104 to 123 ms and 117 to 133 ms.

Not shown by these runs:

  • Whether the POST leaves later. At 4x it left 336 to 603 ms after Enter on main and 431 to 616 ms on the first version. Pairs differ by -133 to +261 ms and main run twice differs as much, so no change is established. Without throttle the median pair is +3 ms against +4 ms for main run twice.
  • More frames at 4x. During the 12 s reply main drew 246 frames (median) and the first version 141. Main draws nothing until the prompt shows; the branch spends that time drawing the reply. Main-thread task time is 12.3 to 12.7 s for the 12 s reply on both.

Host: a shared 32-core Xeon; the throttle is Chromium's CPU throttling, not a real slow device.

Screenshots / video

Recorded against the simulated backend, on this PR's first version ab65ac9c946: the reply starts under 1 s after the send, so the timer shows the time the dashboard takes to draw, not model latency.

Both at 4x CPU throttle, 3 s after the first send into an empty chat. Main shows a blank transcript with the stop button lit; this branch shows the prompt and the reply.

Before (main):

main at 4x CPU throttle, 3 s after the send: the transcript is blank

After (this branch):

this branch at 4x CPU throttle, 3 s after the send: the prompt and the streaming reply are on screen

Side by side, with a timer from the send. Three takes of main gave 5.4, 6.9 and 8.5 s; this is the 5.4 s one.

before and after at 4x CPU throttle, side by side with a timer

Related Issues

Part of #31704

Builds on #37414 and #31719.

Sibling sweep

Swept: git grep -n "useDeferredValue(" -- website/src
Sibling: website/src/components/PromptLengthNotice.tsx:44 -- not affected -- it defers the composer's own typed text, which no streaming flush restarts

Pattern harvest

Rule candidate: review-prompt
Pattern: a rule that defers "the first content of an empty list" also catches the first item the user adds themselves, so it needs to know whether the list is still loading.

Checklist

  • At most two commits (one is the norm), with a Conventional Commits title (feat|fix|docs|style|refactor|perf|test|chore|ci|build|revert: ...)
  • Existing tests pass and new tests added for new functionality
  • Self-review completed; code follows project style guidelines
  • Documentation updated (if applicable)
  • No secrets, credentials, or internal references in the diff

Contribution License Agreement

Contributions are accepted under the project's Apache-2.0 license; see the Licensing section of CONTRIBUTING.md.

@buluoray
buluoray requested review from a team and KiroCrewCaptain as code owners November 15, 2026 06:25
@github-actions github-actions Bot added the readiness: checking Automated validation is still running label Nov 15, 2026
@buluoray

buluoray commented Nov 15, 2026 •

Copy link
Copy Markdown
Contributor Author

Before / after at 4x CPU throttle, side by side, with a timer that starts at the send. The chat is empty and this is its first message. Left is main: the transcript stays blank and the prompt and the reply show after 5.37 s. Right is this branch: the prompt shows after 0.35 s and the reply after 0.59 s.

The backend is simulated. /api/** is answered by a stub and the websocket is mocked, and the reply starts as soon as the request returns, under 1 s after the send. The timer shows the time the dashboard takes to draw, not model latency. With a real model the reply starts later; the PR description says what main does then.

before and after at 4x CPU throttle, first send into an empty chat

Recorded from main 932e28e and the first version of this branch, ab65ac9. Three takes of main gave 5.4, 6.9 and 8.5 s; the GIF uses the 5.4 s one.

@github-actions

github-actions Bot commented Nov 15, 2026 •

Copy link
Copy Markdown
Contributor

First Principles Review (Opus 5.5) — ✅ PASS

Premise-level review of 177ae6617136f8e14ee77f2cfeb9d4bcb3cd3f93 — why this exists and whether the shipped surface is the smallest honest version. Updated in place on each push. A BLOCK verdict blocks PR readiness; PASS does not.

First-Principles-Verdict: PASS

Nothing blocks. The fix works at the level of the cause: the first rows of an empty chat that has finished loading no longer wait on the starved background render. It reuses opensRunTurn from groupDisplayItems.ts and adds no new state.

What this change ships

Inventory (4 items) — 4 justified

Intent: the first message a user sends into an empty chat, and the reply to it, appear right away on a slow device. FIX.

  1. The first send into an empty chat that has finished loading, and its reply, now appear in the same render that brings them, not 5 s or more later. — justified
  2. A chat that is still loading, or a page of several turns landing in an empty chat, is still deferred as before. — justified
  3. If a second turn starts before the first turn has committed, the screen keeps the first turn instead of going back to the empty chat. — justified
  4. useSlotDeferredValue takes an optional drawnAtOnce rule, and the transcript frame now carries a loaded flag from ChatPage. — justified

[FIRST-PRINCIPLES-REVIEWED] 177ae66

Description read

[DESCRIPTION-READ] b9dcf72aa8b1880195cbc5cbe4af7f2e6623ea376faf7a0a5b3ed54cca4bc375

That sha256 names the PR description this verdict read. Recompute it with .github/scripts/pr-description-capture.sh; if it differs, the description changed after this verdict was formed and any finding drawn from the description is unproven.

@github-actions

github-actions Bot commented Nov 15, 2026 •

Copy link
Copy Markdown
Contributor

Design Review (Opus 5.5) — ✅ PASS

Design-level review of 177ae6617136f8e14ee77f2cfeb9d4bcb3cd3f93 — updated in place on each push. A BLOCK verdict blocks PR readiness; PASS does not.

Design-Verdict: PASS

No design-level concerns: the change fixes the cause (React starving the deferred render of an empty chat's first rows) by adding one narrow, reversible bypass rule. The tail-deferral contract and the session-switch guard are left alone.

Notes

  • loaded is now part of the memo key for liveTranscript, so when loaded flips the deferral gets a new frame even if the messages haven't changed. That costs one extra deferred input per load. The behaviour is correct.

[DESIGN-REVIEWED] 177ae66

Description read

[DESCRIPTION-READ] 19f0ab92a460d73f71d8fbe180c7306f9f08c9c792d778b31a77b30d2f0bf26b

That sha256 names everything this verdict read: the PR description, plus the 1 evidence file(s) the workflow collected from it and handed this review. It covers that evidence because the media strip replaces every attachment URL with the same placeholder, so an edit swapping one attachment for another would leave the description's captured text identical while what this review judged changed. Recompute it with .github/scripts/pr-description-capture.sh over the same inputs; if it differs, the description or that evidence changed after this verdict was formed and any finding drawn from either is unproven.

@github-actions

github-actions Bot commented Nov 15, 2026 •

Copy link
Copy Markdown
Contributor

UX Review (Opus 5.5) — ✅ PASS

UX-level review of 177ae6617136f8e14ee77f2cfeb9d4bcb3cd3f93 — updated in place on each push. A BLOCK verdict blocks PR readiness; PASS does not.

UX-Verdict: PASS

Nothing blocks: no control, label or copy is added or changed. Only when the existing transcript rows render changes, and a before/after recording and stills of both states are attached.

[UX-REVIEWED] 177ae66

Description read

[DESCRIPTION-READ] e12a450487af25469076c6b7c8e977f3c144dc89df10eeeccec11805b750ca14

That sha256 names everything this verdict read: the PR description, plus the 6 evidence file(s) the workflow collected from it and handed this review. It covers that evidence because the media strip replaces every attachment URL with the same placeholder, so an edit swapping one attachment for another would leave the description's captured text identical while what this review judged changed. Recompute it with .github/scripts/pr-description-capture.sh over the same inputs; if it differs, the description or that evidence changed after this verdict was formed and any finding drawn from either is unproven.

@github-actions

github-actions Bot commented Nov 15, 2026 •

Copy link
Copy Markdown
Contributor

GPT 6.1 Review — ✅ no blocking findings

GPT 6.1 completed its review of 177ae6617136f8e14ee77f2cfeb9d4bcb3cd3f93 and found no blocking issues.

This comment is updated in place on each push.

Review details

No findings.
[GPT-REVIEWED] 177ae66

False positive or not applicable? A repository writer can comment:
/ai-review override gpt 177ae6617136f8e14ee77f2cfeb9d4bcb3cd3f93 false-positive: <reason, 20 to 500 characters>

@github-actions

github-actions Bot commented Nov 15, 2026 •

Copy link
Copy Markdown
Contributor

Opus 5.5 Review — ✅ no blocking findings

Reviewed 177ae6617136f8e14ee77f2cfeb9d4bcb3cd3f93 — this comment is updated in place on each push.

Review details

No findings.

[OPUS-REVIEWED] 177ae66

Verdict parsed from the review's SHA-scoped output markers for commit 177ae6617136f8e14ee77f2cfeb9d4bcb3cd3f93.

False positive or not applicable? A repository writer can comment:
/ai-review override fable 177ae6617136f8e14ee77f2cfeb9d4bcb3cd3f93 false-positive: <reason, 20 to 500 characters>

@KiroCrewCaptain

KiroCrewCaptain commented Nov 15, 2026 •

Copy link
Copy Markdown
Collaborator

Code change approver recommendation: Approve

Why: the decider estimates a 12% chance that this change introduces a defect, within the 12% limit for approving on its own, and every check passes.

The change is narrow. useSlotDeferredValue gets an optional drawnAtOnce(committed, next) bypass. It is only consulted when the committed deferred frame belongs to the current visit, so the #8526 session-switch guard still works the same way.

isFirstTurnOfEmptyChat passes only when the committed frame is empty and loaded and the new rows hold one run turn, using opensRunTurn, which already exempts steers and parked sends.

transcriptLoaded is !slotLoading && slotSwitchTarget !== activeSlot, the same expression ChatPage already passes as transcriptAuthoritative. In the store, switchSlot.pending sets slotLoading and the messages in one reducer, and so does fulfilled. So a page that lands always pairs with the loading flag it arrived under, and the committed frame stays "empty, loading". That path is still deferred.

The new loaded field means a frame is created each time the flag flips. It costs nothing extra: when the messages are unchanged, grewOnlyAtTail hands the deferral its earlier frame again, and an empty chat's deferred render is trivial.

The hook now records every value it renders live, not only the ones the deferral has caught up with. Where the tw

An automated recommendation, not a review: a maintainer still decides. It approves on its own only when the estimated chance of a defect is at most 12% and the change has at most 400 changed lines. Decider v3c (217fe607) · commit 177ae66171 · 224 changed lines. If this recommendation is wrong, reply here: replies are how the approver is evaluated.

@buluoray
buluoray force-pushed the crew/kiro-crew-rust/empty-first-send branch from ab65ac9 to aa358b6 Compare November 15, 2026 07:19
@buluoray

Copy link
Copy Markdown
Contributor Author
  • span=c2a41c6555c5 The deferral keeps the empty frame for the whole visit once a chat starts out loaded and empty

fixed in aa358b6: the mechanism holds. With the loaded empty frame held, the changed branch of grewOnlyAtTail returned true for every non-empty transcript, so fedRef never moved and a page landing in a loaded empty chat rendered at urgent priority.
grewOnlyAtTail is back to the text on main. The deferral is handed the same frames as on main, so what it holds moves on with the first rows.
The first turn is drawn through a second rule on the hook, drawnAtOnce, judged against the value the deferral last committed. isFirstTurnOfEmptyChat holds only when that value is loaded and empty and the new transcript holds one turn, so a page of several turns stays deferred.
Tests: in transcriptRows.deferral.test.ts, "keeps a page of several turns deferred when it lands in a loaded empty chat" and the count of inputs handed to the deferral both fail on ab65ac9.
Not changed, and the same on main: after the first send the held frame is the one-row prompt, and grewOnlyAtTail checks only the rows before the held frame's last row. In a new chat a later page in front, or an edit of an earlier row, therefore counts as tail-only on main too (checked on the function as it is on main). That is outside this PR.

The repair was made in the PR's own session, not by a model-pinned subagent: this host reaps subagents mid-run.

@buluoray

buluoray commented Nov 15, 2026 •

Copy link
Copy Markdown
Contributor Author

On the earlier head aa358b6, Backend Tests (3.12, 6) and Backend Tests (Windows) (6) were red for a reason on main, and Coverage Gate failed closed on them. The annotations of both shards name the same three cases of test/metrics/test_kiro_export_destination.py::TestOffOffer (#37546).

#37545 fixed them on main and merged. This PR is rebased onto main at 2e56b3b as 177ae66, with the six changed files byte-identical to aa358b6. No override was used.

@buluoray

Copy link
Copy Markdown
Contributor Author

Reply to the code change approver recommendation above, which read commit ab65ac9c94.

Both points were true of that commit and are fixed in aa358b6. grewOnlyAtTail is the same as on main again, so the deferral is handed the first rows and what it holds moves on from the empty frame. The first turn is drawn through a separate rule, isFirstTurnOfEmptyChat, which holds only for one turn in a loaded empty chat.

Tests that fail on ab65ac9c94 and pass now, in transcriptRows.deferral.test.ts: "keeps a page of several turns deferred when it lands in a loaded empty chat", and the count of inputs handed to the deferral in "draws the first send into an empty chat, and its reply, in the render that brings them".

@github-actions github-actions Bot added readiness: action required A blocking check or review needs attention and removed readiness: checking Automated validation is still running labels Nov 15, 2026
On a slow device the first prompt sent into an empty chat, and the reply
to it, stayed off screen for five seconds or more when the reply began
within a second of the send. The store held both and the composer had
cleared, but the transcript was blank.

The transcript reaches the virtualizer through useSlotDeferredValue.
The first rows of an empty transcript are handed to the deferral,
because for a chat that is still loading they are its page landing. The
first send into an empty chat goes the same way, so the prompt waits
for a background render. Each streaming flush re-renders the page at
urgent priority and restarts that render. React commits it only when
the lane expires, five seconds after the send.

The transcript frame now carries whether the session's transcript has
loaded, and useSlotDeferredValue takes a second rule, drawnAtOnce. It
is judged against the value the deferral last committed and lets a
value render in this commit while its deferred render is pending.
isFirstTurnOfEmptyChat is that rule for the transcript: the committed
transcript is loaded and empty, and the new one holds a single turn.

grewOnlyAtTail is unchanged, so the deferral is handed the same frames
as before and what it holds moves on with the first rows. A transcript
that is still loading keeps its page deferred, so does a page of
several turns that lands in an empty chat, and a session switch still
renders the incoming session in its first commit.

Part of #31704
@buluoray
buluoray force-pushed the crew/kiro-crew-rust/empty-first-send branch from aa358b6 to 177ae66 Compare November 15, 2026 08:39
@github-actions github-actions Bot added readiness: checking Automated validation is still running readiness: passed Eligible automated validation passed for the current revision and removed readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running labels Nov 15, 2026
@KiroCrewCaptain
KiroCrewCaptain enabled auto-merge (squash) November 15, 2026 09:52

@KiroCrewCaptain KiroCrewCaptain left a comment

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Approving. On head 177ae66 the review ran the three touched test files: 39 of 39 pass. With main's useSlotDeferredValue.ts and transcriptRows.ts swapped in, 10 of 39 fail. Removing each guard (the loaded check, the second-turn loop, recording only caught-up values) turns tests red. Shuffled runs stayed green. The deferral still gets the same inputs as on main, grewOnlyAtTail is unchanged, and the session-switch visit check is still evaluated first.
Done well: drawnAtOnce only widens the live-render decision, and the new Set(inputs).size === 2 assertion proves the deferral no longer keeps the empty frame.
Optional:

  • The timing table and recordings come from ab65ac9c946, not this head. Please replace them as the body promises, and add the typing-latency check that #31704 asks for.
  • !slotLoading && slotSwitchTarget !== activeSlot now appears three times in ChatPage.tsx (lines 908, 954, 1213). One shared const would keep them from drifting apart.

@KiroCrewCaptain
KiroCrewCaptain merged commit 8cf1b00 into main Nov 15, 2026
99 checks passed
@KiroCrewCaptain
KiroCrewCaptain deleted the crew/kiro-crew-rust/empty-first-send branch November 15, 2026 09:53
@github-actions github-actions Bot removed the readiness: passed Eligible automated validation passed for the current revision label Nov 15, 2026
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants