From 39b403992f377ba907c467f8529df5885e6ee378 Mon Sep 17 00:00:00 2001 From: roberttwang Date: Sat, 14 Nov 2026 02:49:22 +0800 Subject: [PATCH 1/4] fix(browser): capture a sharp frame when the settled screencast sends none Scrolling or dragging in the side browser restarts the screencast at half size, and 400 ms after input settles it restarts at full size. The view relied on Chromium re-sending the current page on each restart, but Chromium captures only on repaint and does not always do that. A page that stopped changing then left the panel on its last light frame, and TestBrowserScrollEndsOnASharpFrame failed in CI with "no frame" ten seconds after the wheel. When no frame arrives within 300 ms of the full-size restart, capture a screenshot and publish it, as attach already does for the first frame. The real-browser test no longer requires a light frame on a static page, which Chromium does not guarantee; it requires a sharp frame after the scroll settles. Also take the view lock in a fake-CDP test that cleared the session while a content-size read could be running. Co-authored-by: Cursor --- CHANGELOG.md | 1 + internal/runtime/browser_motion_test.go | 26 +++------ internal/runtime/browser_test.go | 72 +++++++++++++++++++++++++ internal/runtime/browser_view.go | 48 ++++++++++++++++- internal/runtime/core_cases_test.go | 2 + 5 files changed, 129 insertions(+), 20 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 57ed7c126..a0f16f774 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,6 +4,7 @@ Platform releases use `vX.Y.Z` tags and publish `ghcr.io/tencent/loopforge`. Loo ## Unreleased +- The side browser no longer stays on a blurry frame after a scroll or drag on a page that stops changing. Scrolling switches the screencast to half-size frames and it restarts at full size once input settles, but Chromium does not always re-send a page that is not repainting; the panel now captures the page when no frame arrives within 300 ms. - The platform image bundles DeepSeek Harness `@deepseek-ai/dsh@0.2.2-rc.1` next to Codex and CodeBuddy, so a DeepSeek key works in conversations and SOP roles without an install step. 0.3.8 had no `dsh` and answered a DeepSeek Harness chat with “AI 助手生成失败,请稍后重试”. The image download grows by about 180 MB. An installation without the image installs the same pinned version from the conversation: every dsh release is a prerelease requiring Node 24.9, and npm on Node 22 found no version for the bare package name. - A conversation workspace whose image lacks the chosen CLI installs Cursor CLI and Antigravity again. The sandbox drops every capability, so the installer's `tar` running as root could not restore the archive owner (`Cannot change ownership to uid 2000`), and the turn failed with “准备 cursor 原生CLI失败”. The workspace install of DeepSeek Harness uses the pinned `@deepseek-ai/dsh@0.2.2-rc.1` with relaxed engines, as the platform install already did; the bare package name resolved to no version. - A DeepSeek Harness reply longer than 8 KB (about 2,700 Chinese characters) is shown in full. `dsh --json` cuts every event string at 8 KiB and only its `final` event carries the whole answer, so the chat stopped mid-sentence while the saved reply was complete. diff --git a/internal/runtime/browser_motion_test.go b/internal/runtime/browser_motion_test.go index 3b0f13edd..1ef9fd264 100644 --- a/internal/runtime/browser_motion_test.go +++ b/internal/runtime/browser_motion_test.go @@ -14,8 +14,8 @@ import ( "agentflow/internal/domain" ) -// Chromium re-sends the current page when the screencast restarts, so a -// static page still ends on a sharp frame after a scroll. +// A static page still ends on a sharp frame after a scroll, whether or not +// Chromium re-sends it when the screencast restarts. func TestBrowserScrollEndsOnASharpFrame(t *testing.T) { if testing.Short() { t.Skip("short mode") @@ -68,26 +68,16 @@ func TestBrowserScrollEndsOnASharpFrame(t *testing.T) { for width < 700 { seq, width = nextWidth(seq) } + scrolled := time.Now() if _, err := HandleBrowser(ctx, runID, domain.BrowserRequest{Operation: "input", Events: []domain.BrowserInputEvent{{Type: "wheel", X: 0.5, Y: 0.5, DeltaY: 100}}}); err != nil { t.Fatal(err) } - // A full-width frame already in flight can arrive before the screencast - // restarts at the lighter size. Keep reading until a light frame shows up. - sawLight := false + // Light frames may arrive while the scroll is in motion, and a full-width + // frame already in flight can arrive right after the wheel; neither is + // guaranteed on a page that does not repaint. Once input settles a + // full-width frame arrives although nothing changed. for deadline := time.Now().Add(8 * time.Second); time.Now().Before(deadline); { - seq, width = nextWidth(seq) - if width <= 400 { - sawLight = true - break - } - } - if !sawLight { - t.Fatalf("no light frame while scrolling (last %dpx)", width) - } - // More light frames may follow while the scroll animates; once input - // settles a full-width frame arrives although nothing changed. - for deadline := time.Now().Add(5 * time.Second); time.Now().Before(deadline); { - if seq, width = nextWidth(seq); width >= 700 { + if seq, width = nextWidth(seq); width >= 700 && time.Since(scrolled) >= browserMotionSettle { return } } diff --git a/internal/runtime/browser_test.go b/internal/runtime/browser_test.go index 71b2676a9..e4427fd4d 100644 --- a/internal/runtime/browser_test.go +++ b/internal/runtime/browser_test.go @@ -310,3 +310,75 @@ func TestBrowserViewCapturesLighterFramesWhileScrolling(t *testing.T) { t.Fatalf("drag frames: %v", got) } } + +func TestBrowserViewCapturesASharpFrameWhenTheSettledScreencastSendsNone(t *testing.T) { + settle, wait := browserMotionSettle, browserSettledFrameWait + browserMotionSettle, browserSettledFrameWait = 30*time.Millisecond, 60*time.Millisecond + defer func() { browserMotionSettle, browserSettledFrameWait = settle, wait }() + wheel := []domain.BrowserInputEvent{{Type: "wheel", X: 0.5, Y: 0.5, DeltaY: 100}} + screenshots := func(transport *fakeCDPTransport) int { + transport.mu.Lock() + defer transport.mu.Unlock() + n := 0 + for _, msg := range transport.sent { + if msg.Method == "Page.captureScreenshot" { + n++ + } + } + return n + } + newView := func() (*browserView, *fakeCDPTransport) { + transport := newFakeCDPTransport() + transport.results = map[string]string{"Page.captureScreenshot": `{"data":"SHARP"}`} + view := &browserView{targets: map[string]*browserTarget{}, changed: make(chan struct{}), session: "page-1", active: "t1", width: 1000, height: 500, frameWidth: 1600, frame: "LIGHT", seq: 5} + view.client = newCDPClient(transport, view.onEvent) + return view, transport + } + + // Chromium sends nothing after the restart: the view captures the page. + view, transport := newView() + defer view.client.close() + if err := view.input(context.Background(), wheel); err != nil { + t.Fatal(err) + } + deadline := time.Now().Add(2 * time.Second) + for view.state(5).Frame != "SHARP" { + if time.Now().After(deadline) { + t.Fatalf("no sharp frame after the scroll settled: %+v", view.state(0)) + } + time.Sleep(10 * time.Millisecond) + } + if n := screenshots(transport); n != 1 { + t.Fatalf("screenshots: %d", n) + } + + // A frame that arrives in time is kept and no screenshot is taken. + view, transport = newView() + defer view.client.close() + if err := view.input(context.Background(), wheel); err != nil { + t.Fatal(err) + } + for deadline := time.Now().Add(2 * time.Second); ; time.Sleep(5 * time.Millisecond) { + transport.mu.Lock() + restarts := 0 + for _, msg := range transport.sent { + if msg.Method == "Page.startScreencast" { + restarts++ + } + } + transport.mu.Unlock() + if restarts == 2 { + break + } + if time.Now().After(deadline) { + t.Fatal("the screencast never returned to sharp frames") + } + } + time.Sleep(browserSettledFrameWait / 4) + frame, _ := json.Marshal(map[string]any{"data": "RESENT", "sessionId": 1, "metadata": map[string]any{"deviceWidth": 1000, "deviceHeight": 500}}) + view.onEvent(cdpMessage{Method: "Page.screencastFrame", SessionID: "page-1", Params: frame}) + time.Sleep(browserSettledFrameWait * 2) + if got := view.state(0).Frame; got != "RESENT" || screenshots(transport) != 0 { + t.Fatalf("frame %q, screenshots %d", got, screenshots(transport)) + } +} diff --git a/internal/runtime/browser_view.go b/internal/runtime/browser_view.go index 828969574..9a4ff7a6a 100644 --- a/internal/runtime/browser_view.go +++ b/internal/runtime/browser_view.go @@ -485,8 +485,9 @@ var browserMotionSettle = 400 * time.Millisecond // markMotion switches the screencast to light frames for scrolling and // dragging, and back once input has been quiet for browserMotionSettle. -// Restarting the screencast makes Chromium send the current page again, so -// the view ends on a sharp frame even when nothing moves afterwards. +// Restarting the screencast usually makes Chromium send the current page +// again; ensureSettledFrame covers the times it does not, so the view ends +// on a sharp frame even when nothing moves afterwards. func (v *browserView) markMotion(ctx context.Context) { v.mu.Lock() v.motionGen++ @@ -496,6 +497,7 @@ func (v *browserView) markMotion(ctx context.Context) { if start && session != "" { v.restartScreencast(ctx, session) } + frameWait := browserSettledFrameWait time.AfterFunc(browserMotionSettle, func() { v.mu.Lock() if gen != v.motionGen || !v.motion { @@ -511,9 +513,51 @@ func (v *browserView) markMotion(ctx context.Context) { ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() v.restartScreencast(ctx, session) + v.ensureSettledFrame(ctx, session, frameWait) }) } +// browserSettledFrameWait is how long a restarted screencast gets to send the +// current page before ensureSettledFrame captures it instead. +var browserSettledFrameWait = 300 * time.Millisecond + +// ensureSettledFrame publishes a sharp screenshot when Chromium sends no frame +// after the screencast returns to sharp. It captures only on repaint and does +// not always re-send a page that stopped changing, which would leave the panel +// on its last light frame. +func (v *browserView) ensureSettledFrame(ctx context.Context, session string, wait time.Duration) { + v.mu.Lock() + seq := v.seq + v.mu.Unlock() + select { + case <-time.After(wait): + case <-ctx.Done(): + return + } + stale := func() bool { + return v.session == session && v.seq == seq && !v.motion + } + v.mu.Lock() + ok := stale() + v.mu.Unlock() + if !ok { + return + } + var shot struct { + Data string `json:"data"` + } + if v.client.call(ctx, session, "Page.captureScreenshot", map[string]any{"format": "jpeg", "quality": 80}, &shot) != nil || shot.Data == "" { + return + } + v.mu.Lock() + if stale() { + v.frame = shot.Data + v.seq++ + v.notify() + } + v.mu.Unlock() +} + func (v *browserView) restartScreencast(ctx context.Context, session string) { _ = v.client.call(ctx, session, "Page.stopScreencast", nil, nil) _ = v.client.call(ctx, session, "Page.startScreencast", v.screencastParams(), nil) diff --git a/internal/runtime/core_cases_test.go b/internal/runtime/core_cases_test.go index 94df90ced..eb0ba5e2a 100644 --- a/internal/runtime/core_cases_test.go +++ b/internal/runtime/core_cases_test.go @@ -153,7 +153,9 @@ func TestBrowserViewOperationsWithFakeCDP(t *testing.T) { ctxDone, cancel := context.WithCancel(ctx) cancel() view.waitFrame(ctxDone, 99, 10) + view.mu.Lock() view.session = "" + view.mu.Unlock() if err := view.pageCall(ctx, "x", nil); err == nil { t.Fatal("page call without session") } From 50e7485c38321b6bbcacbecfbd8eb04889ed2900 Mon Sep 17 00:00:00 2001 From: fx-kurumi Date: Sat, 14 Nov 2026 03:33:26 +0800 Subject: [PATCH 2/4] test(browser): cover ensureSettledFrame skip, failure and race paths Cover the branches the settled-frame test leaves open: input resuming, a tab switch or a frame arriving during the wait, a cancelled context, a failed or empty screenshot, and a frame arriving while the screenshot is taken (the screenshot must be dropped). Co-Authored-By: Claude Code --- .../runtime/browser_settled_frame_test.go | 206 ++++++++++++++++++ 1 file changed, 206 insertions(+) create mode 100644 internal/runtime/browser_settled_frame_test.go diff --git a/internal/runtime/browser_settled_frame_test.go b/internal/runtime/browser_settled_frame_test.go new file mode 100644 index 000000000..6b7edcd32 --- /dev/null +++ b/internal/runtime/browser_settled_frame_test.go @@ -0,0 +1,206 @@ +package runtime + +import ( + "context" + "encoding/json" + "testing" + "time" +) + +// settledFrameTransport answers like fakeCDPTransport, except that +// Page.captureScreenshot can fail, or be preceded by a screencast frame that +// Chromium sends while the screenshot is being taken. +type settledFrameTransport struct { + *fakeCDPTransport + shotError string + frameDuringShot bool +} + +func (f *settledFrameTransport) write(body []byte) error { + var msg cdpMessage + if err := json.Unmarshal(body, &msg); err != nil { + return err + } + if msg.Method != "Page.captureScreenshot" { + return f.fakeCDPTransport.write(body) + } + f.mu.Lock() + f.sent = append(f.sent, msg) + f.mu.Unlock() + if f.frameDuringShot { + params, _ := json.Marshal(map[string]any{"data": "RESENT", "sessionId": 1, "metadata": map[string]any{"deviceWidth": 1000, "deviceHeight": 500}}) + event, _ := json.Marshal(cdpMessage{Method: "Page.screencastFrame", SessionID: msg.SessionID, Params: params}) + f.replies <- event + } + reply := cdpMessage{ID: msg.ID, Result: json.RawMessage(`{"data":"SHARP"}`)} + if f.shotError != "" { + reply.Result = nil + reply.Error = &struct { + Message string `json:"message"` + }{Message: f.shotError} + } + raw, _ := json.Marshal(reply) + f.replies <- raw + return nil +} + +func cdpCalls(f *fakeCDPTransport, method string) int { + f.mu.Lock() + defer f.mu.Unlock() + n := 0 + for _, msg := range f.sent { + if msg.Method == method { + n++ + } + } + return n +} + +// newSettledFrameView is a view showing a light frame at seq 5 on page-1. +// contentBusy keeps screencast frames from starting a layout metrics read. +func newSettledFrameView(t *testing.T, transport cdpTransport) *browserView { + t.Helper() + view := &browserView{targets: map[string]*browserTarget{}, changed: make(chan struct{}), session: "page-1", active: "t1", + width: 1000, height: 500, frame: "LIGHT", seq: 5, contentBusy: true} + view.client = newCDPClient(transport, view.onEvent) + t.Cleanup(func() { view.client.close() }) + return view +} + +func TestEnsureSettledFramePublishesTheScreenshot(t *testing.T) { + fake := newFakeCDPTransport() + fake.results = map[string]string{"Page.captureScreenshot": `{"data":"SHARP"}`} + view := newSettledFrameView(t, fake) + view.mu.Lock() + changed := view.changed + view.mu.Unlock() + + view.ensureSettledFrame(context.Background(), "page-1", time.Millisecond) + + if state := view.state(0); state.Frame != "SHARP" || state.Seq != 6 { + t.Fatalf("frame %q seq %d, want SHARP at 6", state.Frame, state.Seq) + } + select { + case <-changed: + default: + t.Fatal("watchers were not notified of the captured frame") + } + fake.mu.Lock() + defer fake.mu.Unlock() + if len(fake.sent) != 1 || fake.sent[0].SessionID != "page-1" { + t.Fatalf("sent %+v", fake.sent) + } + var params struct { + Format string `json:"format"` + Quality int `json:"quality"` + } + if err := json.Unmarshal(fake.sent[0].Params, ¶ms); err != nil || params.Format != "jpeg" || params.Quality != 80 { + t.Fatalf("screenshot params %s (%v)", fake.sent[0].Params, err) + } +} + +func TestEnsureSettledFrameKeepsTheViewWhenItShouldNotCapture(t *testing.T) { + cases := []struct { + name string + setup func(*browserView) + }{ + {"input moves again before the wait ends", func(v *browserView) { v.motion = true }}, + {"the panel switched to another tab", func(v *browserView) { v.session = "page-2" }}, + {"a frame already arrived", func(v *browserView) { v.seq = 7 }}, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + fake := newFakeCDPTransport() + fake.results = map[string]string{"Page.captureScreenshot": `{"data":"SHARP"}`} + view := newSettledFrameView(t, fake) + wait := 40 * time.Millisecond + go func() { + // Change the view during the wait, after seq was sampled. + time.Sleep(wait / 4) + view.mu.Lock() + tc.setup(view) + view.mu.Unlock() + }() + + view.ensureSettledFrame(context.Background(), "page-1", wait) + + if n := cdpCalls(fake, "Page.captureScreenshot"); n != 0 { + t.Fatalf("screenshots: %d", n) + } + if frame := view.state(0).Frame; frame != "LIGHT" { + t.Fatalf("frame %q", frame) + } + }) + } +} + +func TestEnsureSettledFrameStopsWhenTheContextEnds(t *testing.T) { + fake := newFakeCDPTransport() + view := newSettledFrameView(t, fake) + ctx, cancel := context.WithCancel(context.Background()) + cancel() + done := make(chan struct{}) + go func() { + view.ensureSettledFrame(ctx, "page-1", time.Hour) + close(done) + }() + select { + case <-done: + case <-time.After(2 * time.Second): + t.Fatal("ensureSettledFrame kept waiting after its context ended") + } + if n := cdpCalls(fake, "Page.captureScreenshot"); n != 0 { + t.Fatalf("screenshots: %d", n) + } + if state := view.state(0); state.Frame != "LIGHT" || state.Seq != 5 { + t.Fatalf("frame %q seq %d", state.Frame, state.Seq) + } +} + +func TestEnsureSettledFrameKeepsTheLightFrameWhenTheCaptureFails(t *testing.T) { + cases := []struct { + name string + transport func() (cdpTransport, *fakeCDPTransport) + }{ + {"cdp error", func() (cdpTransport, *fakeCDPTransport) { + f := &settledFrameTransport{fakeCDPTransport: newFakeCDPTransport(), shotError: "Unable to capture screenshot"} + return f, f.fakeCDPTransport + }}, + {"empty data", func() (cdpTransport, *fakeCDPTransport) { + f := newFakeCDPTransport() + f.results = map[string]string{"Page.captureScreenshot": `{"data":""}`} + return f, f + }}, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + transport, fake := tc.transport() + view := newSettledFrameView(t, transport) + + view.ensureSettledFrame(context.Background(), "page-1", time.Millisecond) + + if n := cdpCalls(fake, "Page.captureScreenshot"); n != 1 { + t.Fatalf("screenshots: %d", n) + } + if state := view.state(0); state.Frame != "LIGHT" || state.Seq != 5 { + t.Fatalf("frame %q seq %d, want LIGHT at 5", state.Frame, state.Seq) + } + }) + } +} + +// A frame Chromium sends while the screenshot is taken is newer than the +// screenshot request, so the screenshot is dropped. +func TestEnsureSettledFrameDropsTheScreenshotWhenAFrameArrivesMeanwhile(t *testing.T) { + transport := &settledFrameTransport{fakeCDPTransport: newFakeCDPTransport(), frameDuringShot: true} + view := newSettledFrameView(t, transport) + + view.ensureSettledFrame(context.Background(), "page-1", time.Millisecond) + + if n := cdpCalls(transport.fakeCDPTransport, "Page.captureScreenshot"); n != 1 { + t.Fatalf("screenshots: %d", n) + } + if state := view.state(0); state.Frame != "RESENT" || state.Seq != 6 { + t.Fatalf("frame %q seq %d, want RESENT at 6", state.Frame, state.Seq) + } +} From a526f7570f288316f06408cc05cb288f7d26a9ad Mon Sep 17 00:00:00 2001 From: cocofhu Date: Fri, 13 Nov 2026 22:56:41 +0000 Subject: [PATCH 3/4] test(browser): sync settled-frame tests on the seq sample instead of sleeps TestEnsureSettledFrameKeepsTheViewWhenItShouldNotCapture and the second half of TestBrowserViewCapturesASharpFrameWhenTheSettledScreencastSendsNone changed the view after a millisecond sleep, so a late goroutine under CPU load raced ensureSettledFrame and failed the screenshot assertions. Add a per-view settledFrameSampled hook (nil in production) that runs right after ensureSettledFrame records the seq it waits on, and change the view or deliver the resent frame from it. Co-Authored-By: Claude Code --- .../runtime/browser_settled_frame_test.go | 10 +++---- internal/runtime/browser_test.go | 29 +++++++------------ internal/runtime/browser_view.go | 8 ++++- 3 files changed, 22 insertions(+), 25 deletions(-) diff --git a/internal/runtime/browser_settled_frame_test.go b/internal/runtime/browser_settled_frame_test.go index 6b7edcd32..895cd847e 100644 --- a/internal/runtime/browser_settled_frame_test.go +++ b/internal/runtime/browser_settled_frame_test.go @@ -113,16 +113,14 @@ func TestEnsureSettledFrameKeepsTheViewWhenItShouldNotCapture(t *testing.T) { fake := newFakeCDPTransport() fake.results = map[string]string{"Page.captureScreenshot": `{"data":"SHARP"}`} view := newSettledFrameView(t, fake) - wait := 40 * time.Millisecond - go func() { - // Change the view during the wait, after seq was sampled. - time.Sleep(wait / 4) + // Change the view during the wait, right after seq was sampled. + view.settledFrameSampled = func() { view.mu.Lock() tc.setup(view) view.mu.Unlock() - }() + } - view.ensureSettledFrame(context.Background(), "page-1", wait) + view.ensureSettledFrame(context.Background(), "page-1", time.Millisecond) if n := cdpCalls(fake, "Page.captureScreenshot"); n != 0 { t.Fatalf("screenshots: %d", n) diff --git a/internal/runtime/browser_test.go b/internal/runtime/browser_test.go index e4427fd4d..6cde394cb 100644 --- a/internal/runtime/browser_test.go +++ b/internal/runtime/browser_test.go @@ -355,28 +355,21 @@ func TestBrowserViewCapturesASharpFrameWhenTheSettledScreencastSendsNone(t *test // A frame that arrives in time is kept and no screenshot is taken. view, transport = newView() defer view.client.close() + // Deliver the frame during the settle wait, right after seq was sampled. + resent := make(chan struct{}) + view.settledFrameSampled = func() { + frame, _ := json.Marshal(map[string]any{"data": "RESENT", "sessionId": 1, "metadata": map[string]any{"deviceWidth": 1000, "deviceHeight": 500}}) + view.onEvent(cdpMessage{Method: "Page.screencastFrame", SessionID: "page-1", Params: frame}) + close(resent) + } if err := view.input(context.Background(), wheel); err != nil { t.Fatal(err) } - for deadline := time.Now().Add(2 * time.Second); ; time.Sleep(5 * time.Millisecond) { - transport.mu.Lock() - restarts := 0 - for _, msg := range transport.sent { - if msg.Method == "Page.startScreencast" { - restarts++ - } - } - transport.mu.Unlock() - if restarts == 2 { - break - } - if time.Now().After(deadline) { - t.Fatal("the screencast never returned to sharp frames") - } + select { + case <-resent: + case <-time.After(2 * time.Second): + t.Fatal("the screencast never returned to sharp frames") } - time.Sleep(browserSettledFrameWait / 4) - frame, _ := json.Marshal(map[string]any{"data": "RESENT", "sessionId": 1, "metadata": map[string]any{"deviceWidth": 1000, "deviceHeight": 500}}) - view.onEvent(cdpMessage{Method: "Page.screencastFrame", SessionID: "page-1", Params: frame}) time.Sleep(browserSettledFrameWait * 2) if got := view.state(0).Frame; got != "RESENT" || screenshots(transport) != 0 { t.Fatalf("frame %q, screenshots %d", got, screenshots(transport)) diff --git a/internal/runtime/browser_view.go b/internal/runtime/browser_view.go index 9a4ff7a6a..55820b3eb 100644 --- a/internal/runtime/browser_view.go +++ b/internal/runtime/browser_view.go @@ -52,6 +52,9 @@ type browserView struct { // lighter until the input settles (see markMotion). motion bool motionGen int64 + // settledFrameSampled, when set (tests only), runs once ensureSettledFrame + // has recorded the frame seq it waits on. + settledFrameSampled func() // History flags are cached per active page URL: re-reading them on every // frame would add a CDP round trip to each one. historyKey string @@ -527,8 +530,11 @@ var browserSettledFrameWait = 300 * time.Millisecond // on its last light frame. func (v *browserView) ensureSettledFrame(ctx context.Context, session string, wait time.Duration) { v.mu.Lock() - seq := v.seq + seq, sampled := v.seq, v.settledFrameSampled v.mu.Unlock() + if sampled != nil { + sampled() + } select { case <-time.After(wait): case <-ctx.Done(): From 3d8908c5e6ca38fe9adc7e127af68dc82877f785 Mon Sep 17 00:00:00 2001 From: Robert0622 <53806540+Robert0622@users.noreply.github.com> Date: Fri, 20 Nov 2026 21:12:12 +0800 Subject: [PATCH 4/4] Use the test store when verifying conversation CLI version diagnostics --- internal/httpapi/assistant_diagnostics_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/internal/httpapi/assistant_diagnostics_test.go b/internal/httpapi/assistant_diagnostics_test.go index bb280d843..29cc65f69 100644 --- a/internal/httpapi/assistant_diagnostics_test.go +++ b/internal/httpapi/assistant_diagnostics_test.go @@ -85,7 +85,7 @@ func TestAssistantDiagnosticsReceiveVersionFromConversationProcess(t *testing.T) d := newAssistantDiagnosticsCollector(g) ctx := context.WithValue(context.Background(), assistantDiagnosticsKey{}, d) root := t.TempDir() - h := &assistantHandlers{deps: &deps{}} + h, _ := workbenchFixture(t) session := &AgentToolSession{ChatOwnerID: 1, ChatSessionID: "version-session", RuntimeMode: domain.AssistantModePlatform} req := assistantCLIRequest{Prompt: "test", SessionRoot: root, Execute: h.conversationExecutor(session, root)} if _, _, err := runAssistantCLI(ctx, req, domain.User{ID: 1, CodeBuddyAPIKey: "test-private-key"}, nil); err != nil {