Repository navigation
Conversation
Quest-Claim: 9aca337475494867
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…e rest as quests A published source and a top-layer item cannot keep out of the way, so validation refuses them. The README covers the feature and its scene-file key, and the quest is rewritten to the per-app memory left, with a follow-up to live with it. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
|
Maintainer decision (taken on the orchestrator's recommendation, per the maintainer's standing instruction to take recommended decisions; the merge pick is still the maintainer's):
(Written by Claude Opus 5.5) |
# Conflicts: # rs/moq-studio/src/shots.rs # rs/moq-studio/src/ui/build.rs
The maintainer chose to share keep-clear's and the dark probe's readback once both land, so it is a follow-up quest on capture-health. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The placer no longer guesses a move by hand from the saved rect: BUILD's drag and nudge and the inspector's X and Y call Compositor::hold, which also drops a choice it was about to make. A resize or a crop of a placed layer keeps the saved position, so it stays free to move. A keeper follows its item when a layer added or removed under it shifts it, or its scene is renamed, and browser input maps the pointer to where the layer is drawn. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A keeper matches its item by source and saved rect before index, so two layers keeping clear of the same camera keep their own histories when a layer added under both shifts them. A saved position that changed, as a reload or an undo gives, holds the layer too, beside Compositor::hold; BUILD's resizes keep the saved position, so they never do. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
# Conflicts: # rs/moq-studio/src/shots.rs
|
Maintainer decision on the round-3 checkpoint (taken on the orchestrator's recommendation, per the maintainer's standing instruction): ✅ Option 1: drop the "changed saved x/y means a move by hand" check; reload and undo/redo call ✅ Option 2 becomes a follow-up quest in this PR: a runtime item ID that edits and undo keep and the scene file never saves, used to match placement state (and usable by auto-layout's slots), covering Duplicate, paste, and drop. Rejected: patching each finding (option 3), merging as is (option 4). (Written by Claude Opus 5.5) |
…clear Per the round-3 checkpoint, the placer no longer reads a changed saved x/y as a move by hand, so a resize from the top or left never holds it. Undo, redo, and reload hold each layer keeping clear whose saved x/y they change. A runtime identity for items, which ends matching placers by source and rect, is a follow-up quest. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
|
Design change: applying the round-3 checkpoint decision, option 1, in 61cce15.
The next review starts a new round count. (Written by Claude Opus 5.5) |
Placing the layers keeping clear runs before the slots reflow, on the collection as saved, so a keeper's index stays the item's; the reflow then arranges the slots around the placed layers. A layer in a slot cannot keep clear (validation refuses it; putting one in a slot switches it off), and BUILD's layers, drags, and browser input apply both placements. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Per decision 5, place.rs drops its own Glide for auto-layout's, keyed by how many times the layer moved: a move by hand or a change of glide length starts a new one, so the first place shows at once and the next glides from where it is. A Jump glides in no time. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…d more A layer keeping clear chooses only while its picture is read, its scene drawn and it shown, and looks again once it is; a resize part way along a glide lands at once; Keep always on top switches keeping clear off and keeps where it was drawn; BUILD's legend shortens its labels, then drops its note, in a narrow window, and the notes draw over the tags they name. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
|
Warning Review limit reachedYou've used all free OSS reviews for now. Wait for the free limit to reset to keep reviewing this public repository. Next included review available in 45 minutes. View limit details
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. |
kixelated
left a comment
There was a problem hiding this comment.
Automated review by review (OpenAI)
Reviewed 6ab2c58f3c9ed08ad04e4f6fc19ebf31aca66729. The bounded asynchronous readback is a sensible direction; I’d fix one placement bug before shipping:
- BUILD drag, lines 411–435: the gesture only holds the placer when a move changes x/y. A resize or crop can still auto-place while the pointer is down, and a stationary move can re-arm when the scene changes. Suspend auto-placement for the selected item until the gesture ends, then preserve the existing manual hold semantics.
Static review only; I didn’t run the GPU fixtures or gesture tests.
There was a problem hiding this comment.
Important
Two paths put a layer that keeps clear back on the rect it moved away from, on program, with nothing to move it off again: undoing a drag, and switching Keep out of the way off. Details inline.
Reviewed changes
I reviewed the full diff at 6ab2c58: the GPU look and the CPU placer in moq-scene, how the compositor stages placements, the engine's undo/reload hold, and the BUILD/inspector UI. I left out the drag-gesture finding the OpenAI review already raised on build.rs:411–435.
place.rs/place.wgsl: a compute shader turns the picture under a layer into 16×16 tiles of motion, edges, still edges, and brightness. The result is read back withmap_asyncat up to 4 Hz. APlacerturns the tiles into lingering Motion/Text/HUD heat and picks one of 8 corner or edge-middle slots, using settle, worst-place, and content-change rules, then glides there withglide::Glide.compositor.rs: keepers are keyed by(scene, index)and re-matched each render byfollow(source, then saved rect, then index).place()stages the placed rects beforereflow. Reads happen only while a scene is drawn on program, preview, an output, or nested in one of those. New public API:placementandhold.collection.rs: addsItem.keep_clear/KeepClear. Validation refuses it on the top layer, in a slot, on a published source, and with a glide over 5 s.engine.rs:seek(undo/redo) and reload callCompositor::holdfor each layer that keeps clear and whose saved x/y they change.- BUILD UI (
keep.rs,build.rs,inspector.rs,slots.rs): the overlay shows heat, slots, and where the layer was, with a legend. The inspector gets the toggle, chips, slot map, and glide. Drags and nudges start from the placed rect and callhold. Putting a layer in a slot or always on top turns keeping clear off. - Quests: rewrites
auto-place.mdto the remaining app-in-front work and addsauto-place-check,item-identity, andreadback.
quest context was not run: this review shell has no quest binary.
claude-opus-5-5 | 𝕏
BUILD tells the compositor which layer a drag holds, each frame of it, and a layer keeping clear neither chooses nor counts its place the worst while in hand: a resize or a crop no longer races a choice, and a move that has not yet moved is not re-armed. Let go, it goes on as the gesture left it. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
|
On the review of 6ab2c58: fixed in 795e450, 60b4dd5, and 442404b, head 5316d38.
(Written by Claude Opus 5.5) |
kixelated
left a comment
There was a problem hiding this comment.
Automated review by review (OpenAI)
Reviewed 5316d38104708196f9cfb8d2faf7e0661e475808. The lease and UI repaint now prevent new choices during a stationary drag, resize, or crop. One related case still moves the layer under the pointer: place.rs:593–608 skips choose while grabbed, but still advances an already-running glide. Start cropping during a glide: the crop gesture has captured the displayed rect, but the layer continues toward the new slot because a crop needn’t change the placement target. Pause or cancel the glide at the displayed rect when grabbed, and extend the regression to start a gesture partway through a glide.
Static inspection only; I didn’t run the reported GPU or UI tests.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
There was a problem hiding this comment.
✅ No new issues in the commits since
6ab2c58. The undo thread onengine.rs:231stays open for the maintainer's call. The OpenAI review's point that a glide keeps running while grabbed (place.rs:593–608) is not addressed yet, and I have not repeated it here.
Reviewed changes
This review covers the delta from 6ab2c58 to cb39347: the drag lease (795e450, 60b4dd5, 442404b), the merge of main (#199), and the switch-off fix (cb39347).
- Added a drag lease on a layer keeping clear.
Compositor::grabrecords(scene, index, source)with an expiry ofnow + GRAB(500 ms).place()matches it per keeper and callsPlacer::grab, which skipschooseand clearsworstwhile the layer is in hand. BUILD renews the lease every frame throughkeep::graband repaints atGRAB / 4, so a 1 fps canvas keeps it. A window hidden mid-drag lets go once the lease lapses. On release the layer carries on as the gesture left it, held after a move. This is covered byplace::tests::it_chooses_only_once_let_go. - Kept a layer where it is drawn when keeping clear is switched off. The inspector now saves
placement.rectwhenkeep_cleargoes toNone, matching Keep always on top. Turning it on, or changing the chips or the glide, still savesitem.rect. The README says so.place()runs for every keeper on every render, soplacement.rectis never the placer's initial zero rect by the time the inspector reads it.
claude-opus-5-5 | 𝕏
Taken in hand part way along a glide, as a crop started then is, a layer keeping clear stops where it is drawn, so it stays under the pointer, and glides on from there once let go. A move by hand still holds it at once. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
|
On the review of 5316d38: fixed in 3c0b485, head 07704f8.
(Written by Claude Opus 5.5) |
|
Maintainer decision on the undo question from #194 (comment) (taken on the orchestrator's recommendation, per the maintainer's standing instruction): ✅ Option 1: an undo that returns a layer to where it was saved before a hold restores the placement it had before that hold (such as the corner it had glided to). Every other undo, redo, or reload still holds. An undo puts back what the streamer saw. Rejected: letting it choose again after an undo (option 2), keeping decision 10 as built (option 3). (Written by Claude Opus 5.5) |
… was A move by hand remembers where the scene file put the layer and where it was meant to be, such as the corner it had glided to. An undo back to that saved rect puts that place back at once instead of holding there, so the undo shows what the streamer saw before the move. Every other undo, and every redo or reload, still holds. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…t was A layer that stops keeping clear parks its placer, held, for as long as it is there. An undo that turns keeping clear back on, saving the rect it had before, revives it, so it goes back to the slot it had glided to rather than starting over from its saved rect. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
|
Design change: an undo of switching Keep out of the way off now puts the layer back where it was, as decision 11 does for a move by hand (67d6446). Switching it off saves the drawn rect, and the layer's placer used to be dropped with it. Undoing the switch-off started a fresh placer at the old saved rect, which can be over the minimap, and a second later it glided away again. Now a layer that stops keeping clear parks its placer, held, for as long as the layer is there. An undo that turns keeping clear back on and saves the old rect revives the placer, so the layer returns to its corner at once. Switching it back on by hand still starts fresh and looks again. This follows from "an undo puts back what the streamer saw". It is recorded in the PR body under decision 11, and tested in (Written by Claude Opus 5.5) |
- Switching keeping clear off in the inspector holds the layer as it was, so an undo before the next render still finds where it was. - An undo that switches keeping clear back on tells the compositor even when the rect is unchanged, so a parked placer that was held stays held. - Undo and redo set the placer's saved rect at once, so an undo, redo, and undo between renders, as on a slow canvas, still puts the slot back. - item-identity: an undo of Keep always on top, whose layer leaves its scene, waits on the runtime identity. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
|
Design change: the review checkpoint at 67d6446 (round 9, 3 findings, score 7) is settled by continuing, with three fixes in 30c0f42. Stepping back. The problem is that an undo should put back what the streamer saw before the edit it undoes. From first principles, the most exact design snapshots each keep-clear layer's placement with every history entry. An undo would then restore that snapshot. It would cover every edit, including ones that move a layer between layers. But it couples the history to the compositor's runtime state. It would also have to merge snapshots across a drag's many steps, and it repeats the identity problem that The current design keeps a "held from" memory in each placer, and the engine tells the compositor which layers an undo moved. That stays inside the placer. All three findings were bookkeeping gaps in it, not a wrong approach:
The recommendation is to continue. That fits decision 11 ("an undo puts back what the streamer saw"). Still open, recorded in (Written by Claude Opus 5.5) |
- A move by hand marks the placement held at once, and a held layer is drawn where it is saved, so each nudge before the next render starts from the last one rather than the last rendered place. - The keep-clear legend's room under the picture holds for a drag, so a drag that selects a layer keeping clear does not resize the picture under the pointer. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
# Conflicts: # rs/moq-studio/src/shots.rs
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
kixelated
left a comment
There was a problem hiding this comment.
Automated review by review (OpenAI)
Reviewed commit: f5bedbc633e01b865190eea9fb073e39eaf1b739
Low, rs/moq-scene/src/place.rs:690–697: pause the last displayed glide position even if the nominal deadline passed since it was drawn. At a slow or skipped render, the user can begin cropping a visibly mid-glide layer, but the next place() can run after gliding expires. That first grabbed frame never sets paused and snaps the item to the slot under the pointer. The new regression starts the grab and renders before the deadline, so it misses this. Freeze from the last rendered rect when the gesture takes hold, and test a grab whose first render is after the deadline.
This closes the earlier case in the normal render cadence. The parked placer and explicit undo/redo tests are useful additions. Static review; I did not run GPU or gesture tests.
There was a problem hiding this comment.
✅ No new issues in the commits since
cb39347. Both earlier Pullfrog threads are resolved: the undo thread through decision 11, and the switch-off thread incb39347. I have not repeated the OpenAI review's low finding onf5bedbc, which is about a grab whose first render lands after the glide deadline (place.rs:690–697).
Reviewed changes
This pass covers the branch commits from cb39347 to f5bedbc (3c0b485, 6a538ce, 67d6446, 30c0f42, 94ceaeb, 827f503) and the merges of main (#192, #203). After the merges, place() still runs before reflow in Compositor::render.
- Pausing a glide while the layer is in hand. If a gesture grabs the layer part way through a glide, it stops at the last
placement.rect, taking its target size. Once let go, a fresh glide starts from that point toward the target. - Undoing a move by hand. The first
Placer::holdrecordsBefore { saved, at, looking }.Placer::undone(saved)puts back the old slot when the undo restores the saved rect from before the hold. Any other undo holds, and keepsbefore. A redo or a reload callsPlacer::redone, which holds and recordssavedstraight away, so several undos and redos between two renders still match. - Parked placers. A keeper whose item stops keeping clear is held and parked. It follows items that don't keep clear by source, then rect, then index.
Compositor::undonerevives it when an undo turns keeping clear back on.engine::movednow also lists items whosekeep_clearwent from off to on, so that undo reaches the compositor. I traced a redo of a switch-on with the placer still parked: it does nothing, and the next render starts a fresh keeper, which is what the original switch-on did. - The inspector's switch-off. It holds the layer with its old
keep_clearbefore the edit, so an undo that comes before the next render still finds the slot it should go back to. Placement::drawnand the held flag.hold()now marks the placement held at once, anddrawn(saved)returns the saved rect while it is held. Nudges made faster than renders therefore add up.Panels.legendkeeps the room for the legend fixed during a drag, so the picture under the pointer does not resize.- Quests.
item-identitynow includes undoing Keep always on top.readbackno longer requires capture-health, and its tile grids (64×36 for the probe, 32×18 for the look) matchdark.rsTILESandplace.rsSIDE/TILE.
claude-opus-5-5 | 𝕏
Whether a glide was under way when a gesture takes the layer now comes from the last render, which drew it short of where it aimed, rather than from when the glide would land, so a grab whose first render comes after that, as on a slow canvas, still stops it under the pointer. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
|
Fixed the low finding from the OpenAI review of f5bedbc in ad6568c. The pause no longer depends on the glide's deadline. A gesture now pauses the glide when the last render drew the layer short of where it was aiming. In that case the layer stops at its last drawn rect, however late the next render comes. A hold or an undo clears that aim, so a held layer still follows the pointer. The new test
(Written by Claude Opus 5.5) |
kixelated
left a comment
There was a problem hiding this comment.
Automated review by review (OpenAI)
Reviewed commit: ad6568c998fb7f30b72f1bb744029fd45761b60b
The slow-render grab case is fixed. rs/moq-scene/src/place.rs:688–693 now checks whether the last drawn rectangle reached its destination, rather than whether a timer expired. That freezes the visible position even if the first grabbed frame is late. The new regression exercises that timing, and manual holds and undo clear the old destination. No new actionable issue found by inspection; I did not run the tests.
There was a problem hiding this comment.
✅ No new issues found.
ad6568cfixes the OpenAI review's low finding onf5bedbc: the first grabbed render coming after the glide deadline.
Reviewed changes
This pass covers f5bedbc..ad6568c, a single commit in rs/moq-scene/src/place.rs.
- Replaced the glide timer with a drawn-rect check. The
Placer.glidingdeadline is gone. A glide now counts as under way when the last target inaimeddiffers from the last drawnplacement.rect. A grab therefore pauses where the layer was last drawn, however late the next render comes.Glide::showreturnstoexactly oncelinear >= 1, so a landed glide compares equal and never pauses by mistake.holdandundoneclearaimed, so neither leaves a stale target behind. - Added
place::tests::a_glide_pauses_where_last_drawn. It renders part way along a glide, grabs, and then renders well past where the glide would have landed. The layer stays at the rect drawn last.
claude-opus-5-5 | 𝕏

Implements most of quest/m1/auto-place.md. With Keep out of the way on, a camera layer watches the picture under it and glides to the corner or edge middle where it covers the least that matters: motion, text, and HUD. BUILD shows what it saw, where it could go, and where it was. The design is the
autoplaceframe ofmock/later.html. The decision is made locally and nothing is uploaded, as the Plan settled.The quest file is rewritten to what is left, the app-in-front trigger and per-app memory. Both need moq to report the app in front (
pin-capture-foreground).Approach
Looking, on the GPU (
rs/moq-scene/src/place.rs,place.wgsl)keep_clear, the compositor draws the scene's items under it into a small picture, with a long side of 512 px. It does this at most 4 times a second, and only while the scene is drawn somewhere (program, preview, an output, or nested in one of them).map_asyncand is read on a later frame, so the frame never waits for it.Deciding, on the CPU (
Sight,Placer)glide::Glide, 0.4 s by default with in-out easing, or jumps.reflowdoes.BUILD (
rs/moq-studio/src/ui/keep.rs)Sharing with #191 and #192
dark.rsfirst. This PR uses the same pattern: a compute reduction of 16x16 tiles, a 4 Hz cap, and amap_asyncreadback polled on a later frame. It does not share the code, because the inputs differ.dark.rsreads the capture texture alone. This PR draws the items under one layer, then compares that drawing with the previous read. The shader outputs differ too. Decision 6 settles one readback helper once both land, as a follow-up.glide::Glide, which this PR uses (decision 5): the placer keys it by how many times the layer moved, so each choice glides from where the layer is drawn, while a move by hand or a new glide length starts a fresh one, which shows its first place at once.Impact
keep_clear, an inline table:keep_clear = {}, orkeep_clear = { hud = false, glide = "1s" }. Its fields aremotion,text, andhud(bool, default true) andglide(a duration, default 400 ms). The key is omitted when off. Documented in the README.keep_clearon a top-layer item, which has no picture under it;keep_clearon an item showing a published source, since viewers place that layer where the scene file does.moq-scene:Item.keep_clear,KeepClearplace::{Slot, Signal, Heat, Placement, Left, INTERVAL, SETTLE, WORST, margin}Compositor::placement(scene, index, source) -> Option<&Placement>moq/.Screenshots
build_keep_clear)build_keep_clear_compact)The show is
rs/moq-studio/shots/keep.toml. A game overlay has a bobbing sun, a rolling road, an HP bar, a minimap, a score, and a lower third. A facecam is saved over the minimap at the top right. In both rows the camera has moved to the bottom right, away from the minimap the analysis marked as a HUD. The view follows the mock-up's layout, with two differences:Alternatives
Follow-ups
quest/m1/auto-place.mdis rewritten to the rest: choose again when another app comes to the front, and remember the slot per app, per user. It requirespin-capture-foreground.quest/m1/auto-place-check.md(new, XS) has the maintainer live with it on a real game and tune the numbers in decision 1.quest/m1/item-identity.md(new, M) gives each item a runtime identity that edits and undo keep and the scene file never saves, and keys keep-clear's placers by it (decision 10), so an undo of Keep always on top also puts a layer back where it was. No open decisions.quest/m1/readback.md(new, S) pulls one readback helper out ofplace.rsand feat: a capture that went black says so #192'sdark.rsonce this PR lands, feat: a capture that went black says so #192 having landed (decision 6). No open decisions.Validation
just cipasses on the merge of main (feat: drop and paste anything on the picture #193): fmt, clippy with and without the system features, and 397 tests.just render-swpasses on lavapipe (58 + 16 + 14 + 1). It includes the newcompositor::tests::a_camera_keeping_clear_glides_off_what_moves: a 320x180 scene with a checkerboard, lines, a moving block, and a camera saved over the block. The test checks that:place::tests(CPU, 9):slots_keep_inside_the_margina_rect_covers_the_tiles_under_it_by_areastill_edges_are_a_hud_only_while_the_rest_movesit_glides_off_a_hud_once_it_has_lookeda_busy_moment_does_not_move_ita_move_by_hand_holds_until_the_content_changesnew_content_is_a_new_choicea_signal_switched_off_does_not_matterthe_scene_going_on_again_looks_againcollection::tests::reads_and_writes_keep_clearandrefuses_keeping_clear_where_it_cannotpass.just shots build_keep_clear live build_droppasses. The new view waits until the camera has left and reached its slot.WLR_BACKENDS=headless, radv, 1440x900, the show above): the facecam moved off the minimap on the program (screenshot). Thread CPU was measured over 30 s, twice each:Compositor::holdfrom BUILD's drag and nudge and the inspector's X/Y, which also drops a choice about to be made; BUILD's resizes and crops of a placed layer keep the saved x/y. Keepers follow their item by source and saved rect, then index, across a layer added or removed under it and a scene rename. Browser input maps the pointer to where the layer is drawn. New tests:place::tests::a_move_by_hand_while_it_looks_drops_the_choice,a_resize_keeps_its_place,compositor::tests::keepers_follow_their_items, and the GPU test extended with an insert under the camera and a hold.just cipasses on the merge of main (feat: a multiview window with every scene and the sources picked #195, chore: bump quest to v0.17.1 #196): 405 tests.hold; a top-left resize leaves it in its slot (place::tests::a_rect_saved_elsewhere_is_no_move_by_hand); undo, redo, and reload hold what they move (engine::tests::an_undo_or_a_reload_moves_by_hand, and on lavapipean_undo_holds_a_layer_keeping_clear).just cipasses: 407 tests.just cipasses (426 tests);just render-swpasses on lavapipe (64 + 18 + 14 + 1);just shots build_keep_clearpasses. New tests:collection::tests::refuses_keeping_clear_where_it_cannotcovers a layer in a slot, andplace::tests::it_glides_as_long_as_it_is_set_tocovers a jump and a 1.5 s glide throughglide::Glide.place::tests::it_chooses_only_while_watched); a resize part way along a glide lands at once (a_resize_while_it_glides_lands_at_once); Keep always on top turns keeping clear off and keeps the layer where it was drawn; the legend fits a 711 px window (build_keep_clear_compact).just cipasses on the merge of main (chore: bump quest to v0.18.1 #198): 428 tests;just render-swpasses on lavapipe (64 + 18 + 14 + 1).place::tests::it_chooses_only_once_let_go). Two local rounds followed: a window hidden mid-drag lets go, and a 1 fps canvas keeps the lease.just cipasses on the merge of main (chore: bump quest to v0.20.0 #199): 429 tests;just render-swpasses on lavapipe (64 + 18 + 14 + 1).place::tests::a_glide_pauses_while_in_hand).just cipasses on the merge of main (chore: bump quest to v0.21.0 #201): 430 tests;just render-swpasses on lavapipe (64 + 18 + 14 + 1). The local review of 3c0b485 found nothing.place::tests::an_undo_of_a_move_by_hand_puts_back_its_place, and on lavapipeengine::tests::an_undo_puts_back_a_layer_keeping_clear, which also checks a redo holds and an undo of an edit that held nothing holds). A layer switched off parks its placer, and an undo that switches it back on returns it to its slot (compositor::tests::a_camera_keeping_clear_glides_off_what_moves).just cipasses: 431 tests; the compositor's GPU tests and the engine's undo test pass on lavapipe.place::tests::a_move_by_hand_is_held_at_once, extendedan_undo_of_a_move_by_hand_puts_back_its_placeandcompositor::tests::a_camera_keeping_clear_glides_off_what_moves). Two further fixes: nudges made faster than renders add up, and a drag that selects a layer keeping clear keeps the picture's size. The new session's round 2 and round 3 found nothing.just cipasses (446 tests);just render-swpasses on lavapipe (68 + 19 + 14 + 1);just shots build_keep_clear build_keep_clear_compact build_darkpasses.quest/m1/readback.mdno longer waits on capture-health, which landed.place::tests::a_glide_pauses_where_last_drawn). Pullfrog approved f5bedbc.just cipasses (447 tests); the GPU tests pass on lavapipe; the local review of ad6568c found nothing.Decisions
The Plan settled that the decision is made locally and nothing is uploaded. The maintainer settled the rest in this comment:
auto-place-check(rejected: tuning them in this PR without a real game).keep_clearin the scene file; "Keep out of the way" and "Stays clear of" in the inspector, with the chips Motion, Text, and HUD.glide::Glidein whichever PR merges second (rejected: keeping a privateGlideinplace.rs). feat: scenes that lay themselves out, by slots and roles #191 landed first, and c5157a7 switches to it.dark.rsonce both land, as the follow-upquest/m1/readback.md(rejected: sharing it in this PR before feat: a capture that went black says so #192 lands).quest/m1/auto-place.md, blocked onpin-capture-foreground;auto-place-checkstays (rejected: doing them here).Compositor::hold, and undo, redo, and reload hold each layer keeping clear whose saved x/y they change. Identity stays source, then saved rect, then index (rejected: a runtime item identity in this PR, which is the follow-upitem-identity; patching each finding; merging as is). Decision, applied.Models
Size: L
Implementer: Claude, claude-opus-5-5, unknown effort
Implementer: Claude Code, claude-opus-5-5, unknown effort (iterate, L)
🤖 Generated with Claude Code
(Written by Claude Opus 5.5)
Review
Rewritten by
quest reviewafter each round.Head: ad6568c
Base: origin/main at 7e75078
Risk: medium,
the base has no RISK.md to name what is always high or customer-facing, so every change is mediumClassified: medium by default
Reviewer: Codex, gpt-6.1-sol, xhigh effort
Session:
01a1e991-37bf-7fe2-92b9-f92f837a4db4, round 5Score: 10/10,
The glide pause now follows the last drawn position, with no new issues found by code inspection; builds and tests were not run under the review constraints.Rounds: 17; first round 3 (medium 3); findings 11 (medium 11): fixed 11, refuted 0, open 0
Findings: none
Reviewer: Codex, gpt-6.1-sol, high effort, shadow
Session:
01a1e991-37bf-7460-85bc-5ed9e65242bbRounds: 8; first round 4 (medium 4); findings 9 (medium 9): fixed 9, refuted 0, open 0