Repository navigation
Cancel pending cursor updates when a terminal closes - #24566
Merged
nwparker merged 1 commit intoOct 3, 2026
Merged
Conversation
Contributor
|
Navigate logical layers of code changes, visualize relationships, and explore their blast radius. No actionable comments were generated in the recent review. 🎉 ℹ️ Recent review info⚙️ Run configurationConfiguration used: Repository UI Review profile: CHILL Plan: Advanced Run ID: 📒 Files selected for processing (3)
Included review availability: This review used your included allowance. Your plan provides up to 10 included reviews per hour; 4 remain after this review. 📝 WalkthroughWalkthroughFocus synchronization now tracks scheduled animation frames and cancels pending frames during cleanup. Tests cover synchronization and disposal behavior, including pane disposal, queued callbacks, successor attachments, and synchronous frame shims. Priority: ➖ Normal Merge Risk: ⚪ Minimal · up to No merge-blocking issue was identified in the focus-sync cleanup change or its normal test workflow. Security Architecture ReviewSecurity architecture risk: ⚪ Minimal · up to Closing a terminal now cancels its pending visual updates without expanding access, privileges, or external interfaces. The reviewed lifecycle change introduces no material security risk, and no security findings remain. Retained concerns Security review detailsSecurity Blast Radius
Trust Boundaries and Controls
Resilience and Maintainability Implications
🚥 Pre-merge checks | ✅ 4 | ❌ 1❌ Failed checks (1 warning)
✅ Passed checks (4 passed)
✨ Finishing Touches 💡 2📝 Generate docstrings 💡
🛠️ Fix failing CI checks 💡
Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out. Comment |
![pullfrog[bot]](https://avatars.githubusercontent.com/in/1768019?s=60&v=4){kind=small}
Contributor
There was a problem hiding this comment.
ℹ️ No critical issues — one naming nit below.
Reviewed changes
- Track and cancel pending focus-sync frames —
attachDomRendererFocusClassSyncnow routes itsrequestAnimationFramethroughPaneReparentFrameTrackerand cancels pending frames in the returned cleanup, with adisposedguard covering both thescheduleSyncentry and the post-sync()re-schedule. - Dispose-path coverage —
pane-container-listener-lifecycle.test.tsasserts the frame is cancelled beforeterminal.disposeruns and thatfocusClassSyncCleanupis nulled. - Lifetime test suite — new
pane-dom-focus-class-sync-lifecycle.test.tscovers GC retention across 64 mount/close cycles, live ordering/coalescing, post-disposal delivery, reentrant disposal, successor attachments, synchronous rAF shims, and missing elements/rows.
The ordering guard in scheduleSync (if (!disposed) after sync()) correctly handles disposal triggered reentrantly during the synchronous sync() call, and cancelPending() runs before terminal.dispose() at pane-lifecycle.ts:202, so the frame no longer holds the terminal element past teardown. config/vitest.config.ts pins --expose-gc, so the retention test's globalThis.gc requirement holds.
ℹ️ Nitpicks
- Reusing
PaneReparentFrameTrackerinpane-dom-focus-class-sync.ts:11is a sound fit, but the class name and its doc comment (pane-reparent-frame-tracker.ts:1— "issued for drag-reparent work") now describe only one of its two callers. A generic name such asPaneAnimationFrameTrackerwould keep the shared abstraction from reading as reparent-specific.
deepseek-v4.1-flash (free via Pullfrog for OSS) ｜ 𝕏
Reuse the existing pane frame tracker to cancel owned deferred focus-class updates during existing cleanup, with disposed guards against late or reentrant delivery.
nwparker
force-pushed
the
nwparker/perf-terminal-focus-frame-cleanup-20261002
branch
from
October 2, 2026 14:55
b804923 to
2528546
Compare
nwparker
added a commit
that referenced
this pull request
Oct 4, 2026
* fix: preserve registered account credentials after enrollment errors * refactor(orchestration): one function for six agent-to-agent sends (#24901) * refactor(orchestration): send every agent-to-agent message through one sendAgentTurn The structured mail-pointer lane and the structured worker preamble each carried a copy of "send, wait out a pending start, read the verdict", and four dispatch-preamble sites typed into a terminal directly. They now share sendAgentTurn, built from host.send, the host's settlement waiter and sendTerminalAgentPrompt. Every caller passes delivery 'now', so nothing sends differently; a source-scan ratchet keeps new direct sends out. * test(orchestration): the refusal fixture uses a real wire refusal code * fix(orchestration): derive the send fingerprint inside sendAgentTurn and pair target with turn A `queue` send was refused by a real host: callers supplied a fingerprint over the body alone while the host digests body and delivery. sendAgentTurn now builds the envelope with the composer's own builder (extracted to structured-agent-session-send-mutation), so the fingerprint is always over exactly the fields sent; `now` sends keep the identical digest. The pointer lane no longer carries a fingerprint it cannot get right. sendAgentTurn takes one argument, a union on kind that carries its own target and turn, resolved by an exhaustive switch; the terminal turn names its purpose (only the dispatch preamble today) instead of every terminal send inheriting the task lead line. A queued outcome keeps the host's draft receipt, and both structured callers read outcomes exhaustively with unchanged behaviour. The boundary test now also fences direct structured host sends, catches optional, bracket and bound member uses, has a planted-offender self-test, and pins the unmoved terminal mail pointer and agent-teams tmux senders. * fix(orchestration): keep federation.ts under max-lines and satisfy prefer-template in the send ratchet * fix(orchestration): wait on the answered submission's id when a replayed queue turn was already handed off * test(orchestration): pin that a replayed queue turn waits for its hand-off to settle * test(orchestration): fence call-result and cast host sends, raw terminal writes and the launch-prompt helpers * feat(native-chat): a Claude subagent waiting on a permission prompt reads as waiting (#22634) * feat(native-chat): a Claude subagent waiting on a permission prompt reads as waiting A subagent's permission request reaches the parent session's callback naming the subagent that asked (agent_id) and the tool call it gates (tool_use_id). The pending request is recorded with the asking agent. On every drain the child-work producer re-derives which children a pending request blocks and hands that set to the Claude child decoder, the one owner of each child's live edges: a blocked child reads waiting on every live edge it reports, and a child that starts or stops waiting is a live edge of its own. Answering, denying or cancelling the request returns the child to its prior live state; nothing is stored beyond the pending requests. A live task_updated carrying an error now reaches the record as the child's last message, without an ending or a new state. The replay test drives a scrubbed capture of the real CLI (foreground allow, deny, interrupt, background allow, and the main agent's own request) through the real adapter into the host's child records. * test(native-chat): a subagent's request names it before its tool call is read * docs(agent-status): a subagent asking for approval waits in every lane; the parent row keeps the session's own attention * test(native-chat): hand canUseTool the asking agent without widening the helper's cast * test(native-chat): an interrupted Claude subagent settles cancelled, not failed A captured interrupt shows the spawn call's error result ("The user doesn't want to proceed…") arriving before the subagent's own `task_updated {status: killed}`. The spawn result ends nothing (the child ends only on its own terminal frame), so the child stays live until its `killed` status settles it cancelled. A genuine failure, captured with the subagent on a model that does not exist, sends its `failed` status before the error result and still ends failed. Both captures now replay through the real adapter into the host's records. * fix(native-chat): a Claude subagent's prompt makes the parent row wait, not block A subagent's pending prompt made the whole session `attention`, which reads as the main agent's own `blocked` and outranks the fold's waiting arm, so the parent row read blocked where a CLI Claude parent reads waiting. The main agent's state now reads only its own pending prompts. - A Claude prompt row carries the linkage of the agent that raised it: the one the permission request names, or the owner of the tool call it gates. The same join decides which child reads waiting, so the two cannot disagree. - The status summary projects the session's own status from root prompts only; every other reader (delivery gates, teardown, restart) still asks whether anyone is waiting on a human. - An answer keeps the prompt row's linkage by the journal's own rule: a revision that names no producer keeps the row's existing one. - The child-tool queries gain the prompt's producer, so a prompt row and a child record answer "which agent" from the same join. * test(native-chat): say which ids the permission capture scrubs and which are its own * fix(native-chat): the status clock dates attention by the session's own asks only The session's status is now `attention` only for its own pending prompt, so the clock's fallback to a subagent's ask could no longer be reached, and it read the journal by a different rule than the status it dates. Both now read root prompts. The journal also stamps a Codex subagent's prompt with its thread (#22532), so a Codex child's approval is that child's wait in the Codex lane too. Two tests written for the earlier rule are updated: a subagent's ask leaves a running session `working` on its turn's clock, and a Codex child's answered approval leaves the settled parent's Activity row done with nothing unread. * fix(native-chat): a completion still says the user is asked when a subagent asks The turn-completion feed marked a completion `awaitingUser` from the status summary's `attention`. The status now means the session's own agent is waiting, so a subagent's pending approval stopped reaching the completion. The projection now also says whether anyone is waiting on the user, as the delivery gates, teardown and restart ask it, and the completion reads that. The waiting-subagent replay answers its prompt with the adapter's current response shape. * revert(native-chat): a live Claude task's error stays out of the child's last message No capture shows a live task_updated carrying an error, and it is unrelated to a subagent waiting on a permission request; it leaves this PR. * test(native-chat): settle the Claude session's startup before replaying a subagent's request A startup frame drained child work during the first await, so answering a request freed the child even with the answer's own republish removed. * fix(native-chat): a Claude subagent's prompt row names it as its other rows do The prompt row stamped only the asking agent's id, so a nested subagent's request lost the agent that spawned it, its spawn call and its run. It now takes the linkage the asker's own rows take: the gated tool call's, when that names the same agent, else the one resolved through the agent's spawn call. The provider's agent id stays the asker's id. * fix(native-chat): a subagent's request makes the parent row wait without a child record The parent row learned that a subagent needed the user only from that subagent's child record, so a request no record carried (a Codex child the host never registered, a Claude task past the live cap) left the row working or done while the approval card sat in the chat. "Someone in this session must answer" is now one derived session fact. The projection names two facts instead of a mode flag: the main agent's own status (attention only for its own request) and structuredAgentSessionAwaitsUser (any pending prompt). The status summary publishes the second as an optional awaitsUser, and the shared fold reads it: the main agent's own ask is blocked, otherwise awaitsUser or a waiting child record makes the row wait. Every caller picks the fact it means: the completion edge's awaitingUser and the delivery gate read awaitsUser; the quit snapshot folds the same two inputs the sidebar does. * fix(native-chat): a client that predates awaitsUser still reads a subagent's request as attention A status summary's status is now the main agent's own, so a client built before the split would read a subagent's request as working (or idle) and fold it with code that has no awaitsUser input. Clients advertise agent-session.status-awaits-user.v1; at agentSession.subscribeStatus the host sends any client that does not the pre-split summary: attention whenever awaitsUser is set, without the main agent's own tool line, verdict and clock. The feed and every in-process reader keep the canonical summary. Transitional, like the turn-item downgrade. * test(native-chat): a Codex subagent's approval makes its settled parent's Activity row wait The test pinned the parent row done while a Codex child asked, through a harness that fed no child records, so it proved nothing about the ask. It now drives the ask twice through the real host status store: with no child record (the session's awaitsUser alone) and with the child's own record waiting from thread/status/changed. Both read waiting with needsAttention while the ask is open, then done with nothing unread. * docs(agent-status): a subagent's request reaches the parent row through awaitsUser in every structured lane The store reference said a Codex child's request still read as the main agent's blocked and that only the Codex hook lane fed a waiting child. Both structured lanes stamp the asking child and feed child records, and awaitsUser carries the request when no record does. The liveness comment goes back to main's: a child's blocked is a failed task on an older host's legacy rows. * fix(native-chat): the restart dialog still headlines a subagent's pending approval The quit snapshot now records the main agent's own state, so a subagent asking while the main agent worked recorded `working` and the dialog said "Was mid-reply" where it used to say "Waiting for your approval". The headline now comes from the snapshot's pending prompt, whoever raised it, with the existing copy; `state` stays the main agent's own. * test(orchestration): a subagent's pending approval holds structured mail delivery Scoping the delivery gate to the main agent's own request left every gate test green; a subagent's request now has its own case. * fix(native-chat): a subagent's request is dated by when it was raised, on every client Since the summary's clock became the main agent's own, nothing dated a wait that only a subagent's request held: a pre-split client was sent attention with no clock, where the old host dated it by the subagent's prompt, and a new client's waiting row fell back to the time it first saw it, so after a reload a request the user had already read could read unread again. The session fact is now when someone started being asked: awaitsUserSince, the oldest pending prompt whoever raised it, and its presence is what awaitsUser meant. A row waiting on someone else's request takes that as its clock; the downgrade for a client without the capability dates its attention by it, which is what the old host published. A cross-version test pinned to the last pre-split release runs the same journals through that release's projection and through this one plus the downgrade, and compares the whole summary. The Codex end-to-end test also reads the host's own status row, and keeps a read ask read through a later row and a reload. * test(native-chat): the pre-split parity check compares only the fields the split owns An additive summary field is safe for old clients, so comparing whole summaries against the pinned release would redden on one. The wire comment now says how the downgrade dates attention: the main agent's own oldest ask, else awaitsUserSince. * test(runtime): an aged host-held working summary states that nobody is asked The test built its working summary by overriding the status of a published approval summary, which still carried awaitsUserSince, so the row correctly read waiting. It now drops the request as its scenario says. * fix(native-chat): the chat's subagent block says waiting when the strip does While a Claude subagent's request was open, the sidebar and the composer strip read waiting but the subagent block in the chat history a few pixels above still read "Kicked off 1 subagent working": it shows the journal's roster state, and the journal records no wait. The structured chat now hands its transcript the subagents the strip shows waiting, read from the host's child records through the strip's own row model and matched by the provider id the roster names each one by. A running entry the host says is waiting reads waiting in the group row, its entry and its section head, with the strip's word and the question colour; it reads the journal's state again as soon as the host stops reporting the wait. * fix(native-chat): a collapsed subagent group shows a wait beside a failed sibling A failed sibling took the group row's one alert slot, so a group with a waiting, a working and a failed child read "1 working +1 failed" and hid the wait; it now reads "1 working +1 waiting +1 failed". The waiting set keeps its identity while a child frame changes no wait, so the transcript's subagent rows do not re-render on every frame, and the test of a wait ending now updates one mounted row instead of remounting it. * refactor(claude): one needs-input state on the parent; the asking subagent alone reads waiting Drop the split of the main agent's own status from a session-wide "someone must answer" fact: awaitsUserSince, the agent-session.status-awaits-user.v1 capability and its old-client downgrade, and every reader change that only consumed them (fold, equality, ingest, delivery gate, turn-completion feed, quit snapshot, resume headline, status clock, status bridge, attention dispatch) go back to main. The parent row again reads one needs-input state for a pending request whoever asked, dated as before. Kept: a request's owner recorded once on its prompt row with full producer linkage; the asking subagent's own record reads waiting, re-derived on every update; the chat history's subagent block reads that same state; an answered subagent request stays in its subagent's group. A subagent now waits only on a request the user can still answer (its card open, no answer underway), and the adapter frees it before the host records an answer or dismissal. So a waiting child record always sits beside the pending card, and main's fold never reads the parent as waiting on it: no window after an answer, and no ~3 s wait after a card dismissed by Stop. * fix(claude): a subagent waits only beside its committed card A subagent's wait was pushed to the host as soon as its request arrived, while the request's card row reached the journal at least a microtask later. So every subagent request published the parent row as waiting before blocked (the main agent's own fold reads a waiting child that way), and Activity got an extra unread "waiting" event that main never shows. The card is now the one record of an open request. The translator records the asker on the card once (its row's linkage) and counts the card open only after the sink confirms its rows landed, then publishes the wait; anything that closes the card (an answer underway, a dismissal handed to the host, Claude's own withdrawal, the session's end) frees the subagent first. So every publish that shows a subagent waiting also shows its pending card, and the parent reads one needs-input state, exactly as on main. This retires the registry's view of pending requests (unclaimed(), the asking-child join) and the translator's holdsOpen. The prompt row's linkage takes one rule: the agent the provider names, else the gated call's owner. The parent-row proof now runs through the real deferred sink, durable journal and status feed, publishing as production does, and checks at every publish that waiting subagents have pending cards and that the parent row matches a host fed no waits. * fix(native-chat): a closed sink's dropped writes never read as landed The sink's written() resolved ok when the sink was closed with writes still queued, so a subagent's prompt card could count as open with no row in the journal. written() now reports a close that dropped writes admitted so far as not landed; drained() and lifecycleBarrier() keep reading a closed sink as settled. Tests: a card never opens when its sink closes first; a card Claude withdraws while the sink holds the cancelled row back closes at once; two subagents asking at once, and the main agent asking beside a subagent, keep the parent row as before with each waiting subagent beside its own card; a process that dies mid-request leaves no subagent waiting. * fix(claude): a withdrawn subagent request frees its child before its card closes Main's sink now hands each write to the journal as it is submitted, and an idle journal commits it and runs the publication at once. Claude's own withdrawal of a subagent's request therefore closed the card and published the parent row before the child's wait was freed, so one publish showed the subagent waiting beside no pending card (fg-interrupt replay). The child's wait now also requires the request to still be open in the registry, and a withdrawal republishes child work before the journal takes the close. * refactor(claude): trim subagent request waiting to the common pattern and its essential tests The chat history no longer marks a subagent block as waiting: the approval card itself carries the request, and the asking subagent's row in the sidebar and composer strip reads waiting, as before. NativeChatWaitingSubagentsProvider, native-chat-waiting-subagents.ts and their renderer changes go. A subagent waits while its request is still open and unanswered in the prompt registry and its card has landed in the journal. The registry check also covers a withdrawal under backpressure, so the card list no longer filters pending cancellations itself. Tests: one integration file replays the captured CLI frames through the real adapter, sink, journal and status feed (renamed claude-subagent-permission-request.test.ts), with the asking subagent's state timeline, attribution, nested linkage and a card write that waits for the journal. The producer-harness waiting test, the redundant prompt-card cases, the harness reducer swap and three unused captures (deny, interrupt, main agent, failed subagent) are removed. * test(claude): pin the parent row's dating when a subagent asked first, and narrow the oracle's claim * Turn desktop notifications on or off per machine (#24518) * feat(notifications): turn desktop notifications on or off per machine Settings > Notifications lists each machine (this computer, SSH targets, paired Orca servers) with a switch. Muted machines are stored as an opt-out list so a newly added machine still notifies. Both notification senders now name the machine a workspace runs on, and main skips the desktop banner for a muted one; phone push is unchanged. * fix(notifications): preserve phone alerts and honor machine mutes * fix(notifications): bind machine mutes to configured sources * fix(notifications): preserve chat completion subscriptions on owner collisions * fix(notifications): reduce machine settings clutter with a collapsed section * fix(notifications): align machine disclosure with settings rows * fix(notifications): clarify machine switches affect only this computer * fix: distinguish unavailable account metadata from absence * fix(accounts): resolve registered profile UUIDs consistently * Replace agentArgsOverride with unified removeAgentArgs approach (#25091) Consolidate override detection and removal into removeAgentArgs. Previously catalogs used agentArgsOverride to detect conflicts and removeAgentArgs to strip them; now removeAgentArgs handles both by returning stripped tokens. This eliminates redundancy and makes the intent clearer. Enhance removeAgentArgOption with optional value filtering to support selective removal for complex cases like Codex config overrides. * Reuse the ancestor path while building mobile agent rows (#24539) Preserve traversal order and cycle guards using one call-local path Set rather than a copy at every depth. * Release waiting terminal output when a mobile subscription fails to start (#24547) Dispose the failed subscription record’s existing terminal backlog before rethrowing its original start error. * Avoid cloning terminal agent owners twice in relay listings (#24713) Capture the existing host-age expression at its original time, then use one call-local fresh owner clone for the length check and unchanged published owner field. * Reuse prepared statements for internal worker checks (#24573) * Reuse prepared statements across remaining Dispatch reads Use the existing schema-pinned complete Dispatch column list in five remaining read modules, enabling the existing bounded statement cache without caching results. * Reuse prepared statements for internal worker checks Use the existing complete Dispatch projection only for named-field internal consumers; preserve original wildcard reads for every returned failure snapshot. * Prepare the Activity search query once per filtered list (#24701) Lazily reuse a call-local search predicate inside the existing filter, using unchanged byte gates and thread text cache. * Avoid rescanning shared chunks in the plain Node build guard (#24717) Reuse a successful unchanged chunk-code verdict within one synchronous writeBundle invocation, while preserving traversal and current-code reads. * Select the latest stable release tag in one pass (#24786) Replace filter/sort/last selection with one traversal using the unchanged stable-tag regex and numeric comparator; update on equality to preserve the original last spelling. Both actual callers own private plain arrays from Git stdout. * Avoid Resource Manager renders when terminal removal leaves its inventory unchanged (#24806) Reuse the private React state object only when the existing single/bulk removal helper returns its identical inventory; keep every lifecycle revision, tombstone, known-ID write and helper invocation in its original order. * Cancel pending cursor updates when a terminal closes (#24566) Reuse the existing pane frame tracker to cancel owned deferred focus-class updates during existing cleanup, with disposed guards against late or reentrant delivery. * Cancel terminal preview fit frames when the preview closes (#24712) Reuse the existing frame tracker inside the box-fit owner, suppress scheduling after disposal and cancel pending frames at the start of the existing effect cleanup. * Skip new mobile toast work after feedback owner cleanup (#24759) Reuse the existing mobile mounted-ref lifecycle pattern at toast presentation entry, preserving admitted clipboard outcomes and every live animation/sequence/timer operation. * Release terminal side effects after they have been delivered (#24548) Clear consumed queue slots after successful apply or overflow carry; preserve backing identity across reentrant callbacks and report actual retained slots. * Release relay handshake timers when a host connection leaves (#24554) Reuse the existing first-frame finish pattern to remove stage-owned timer/message/close callbacks on receipt, timeout or close; check OPEN after successful async assignment verification. * Avoid restarting error timers on closed mobile relay links (#24567) Check the existing irreversible closed flag before scheduling the existing missing-close fallback timer. * Avoid restarting error timers after mobile relay pairing closes (#24568) Check the existing pairing owner closed flag before allocating its missing-close fallback alarm. * Delete unreturned clipboard cache files after a failed write (#24599) Reuse existing provider-copy best-effort deletion for a newly created clipboard cache file whose write fails before its URI reaches the caller. * Skip new legacy file inventories after mobile search cleanup (#24792) Reuse the existing mobile mounted-ref pattern only at legacy fallback entry after completed passive cleanup; preserve admitted work and all live search/authority/cache paths. Correct only the strict fully-unmounted inventory scenario and its sole golden. * Discard completed AI Vault cancellation IDs in the relay worker (#24820) Use the relay child's existing pending Set to ignore cancellation IDs after completion, matching its desktop sibling; preserve admitted active/queued cancellation and the bundled private sender's complete replies, errors and ownership. * Release completed updater setup timers and callbacks (#24920) Cancel completed deferred updater fallbacks in finally, clear only their exact pending callback, and drop the captured timer before the original fallback guard runs; preserve destroyed admission, successor ownership and updater/quit callbacks. * Check daemon idle state without building discarded terminal inventories (#24749) * Check daemon idle state without building discarded terminal inventories Replace the private idle predicate full public inventory with a host-local full pass that still reads every Session liveness getter in original order. * Remove overwritten daemon test mock assignment * Preserve the registered account ID when selecting UUID variants * fix(updater): keep macOS Orca open when background instances block updates (#24952) * fix(updater): guard macOS installs against running app instances * fix(updater): match native app blockers and preserve quit lifecycle * fix(updater): keep ordinary macOS quit on Squirrel's install-on-exit path Converting every quit with a staged update into quitAndInstall made Cmd+Q relaunch Orca, refused the quit when background instances existed, and hijacked app.relaunch()+app.quit() restart flows (profile switch, admin restart) into an update install racing the relaunched old app. Only Update & Restart runs the running-instance preflight now; the quit-without-install allowance is no longer reachable and is removed. * fix(updater): preserve quit intent through macOS staging * test(native-chat): explicitly model legacy published tab ownership --------- Co-authored-by: OrcaWin <293788423+OrcaWin@users.noreply.github.com> Co-authored-by: m4air <m4air@m4airs-Air.localdomain> --------- Co-authored-by: Brennan Benson <79079362+brennanb2025@users.noreply.github.com> Co-authored-by: Jinjing <6427696+AmethystLiang@users.noreply.github.com> Co-authored-by: OrcaWin <alpha-eng@stably.ai> Co-authored-by: OrcaWin <293788423+OrcaWin@users.noreply.github.com> Co-authored-by: m4air <m4air@m4airs-Air.localdomain>
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
ELI5
When a terminal closes, cancel its waiting cursor updates so they stop keeping its old screen in memory.
What Changed
Closing a terminal previously left pending animation callbacks holding its old screen until the browser delivered them. The existing focus-sync cleanup now uses the existing frame tracker to cancel those callbacks before terminal disposal. Every immediate and deferred update for a live terminal keeps its original order and timing.
Why
The pane frame tracker already handles completed callbacks, disposal and synchronous frame shims. Reusing it closes the ownership gap without adding another scheduler or combining live updates.
Linked Issue
Internal performance audit; no pre-existing issue.
Visual Proof
N/A — cleanup and internal work only; live UI, output and interaction behavior are unchanged.
Testing
Original reviewed-base checks (historical full typecheck/build results below apply to that earlier base):
64 suspended-frame mount/close cycles retain 64 callbacks and 64 DOM targets before, and zero of each after, using forced garbage collection. The actual disposePane integration checks cancellation before terminal.dispose. Author and independent reviewer each passed 47 tests in four suites; exact stock fails five ownership regressions and passes five compatibility controls. Live update ordering, completed callbacks, missing elements, late delivery, synchronous delivery, reentrant cleanup and replacement attachments are covered. Full root typecheck, changed-code quality and Electron Vite build pass on macOS.
All test launches used ORCA_BACKGROUND_LAUNCH=1.
Review
Root independently approved the frozen named-main integration, ran its owner/stock controls, and verified all original scope hashes and inherited main blobs.
Independent audit_mobile_cloud review approved the frozen file hashes and reproduced the original regression and final compatibility checks.
Agent skill upstream boundary
Notes
The original delta is now independently reviewed on named main
1fc24d311481a85d5b4ae596898ee072389f040c. Main itself fixes the three earlier unrelated terminal fixture failures; the old duplicate repair is unnecessary. Root verifies every inherited main source blob and the unchanged original scope. Independent integration: 66 controls/five suites, including exact main DOM block-fill and actual pane disposal; full supported renderer compiler passes. Exact main stock still reproduces the original regression and live controls. No fresh newer-lockfile install or full named-main build is claimed; new-head CI must pass before merging.No visual or interaction change for live terminals. This helper is shared by local, daemon, SSH, WSL and remote-client terminal panes, independent of git or folder workspace identity. No new polling, output, wire or host-status behavior. New experimental reliability-gate registration remains an explicit gap; native focus and visible-window tests stay paused on the user desktop. Real hidden Electron heap, physical Linux/Windows, IME and live SSH/WSL journeys remain untested.
Checklist
Final risk and review-bot follow-up
Final code risk: Low. Source-qualified current-main review and actual owner tests show this cleanup affects retired callbacks only; live DOM/cursor computation, preview geometry, parsed output/ACKs, and requested clipboard outcomes keep their existing behavior. No regression or negative user-facing trade-off was identified. Exact-head CI is green. The latest user authorized merging Low terminal PRs after final review. Physical/native validation above remains unclaimed; those primitives are unchanged.
The existing frame tracker is intentionally reused under AGENTS.md rather than renaming its module/export for this additional owner. The naming suggestion is declined to avoid unrelated churn. The generic docstring-coverage suggestion is declined under the rule requiring brief comments for non-obvious reasons only.
No actionable bot code finding or inline thread remains unresolved.