MichaelScottsman--LiquidAss-Frame/docs/phase2/wp/P9.md

P9 glassd: evidence log

Status

• Maintenance sessions 5-6 (2026-10-07 16:07-16:25 EDT): REQ C2a->P8 #17 is closed. In live native sessions, glassd-out.json showed main cover: 0 and 18 plates, and fresh headset looks showed Home's glass discs with their art and no grey slab (wp/P8.md Status). The fixes were in P6's reporter and P8's daemon; glassd did not change. No open REQs to P9 (grep 16:22).
• Maintenance session (2026-10-07 10:45-, platform maintainer): REQ P7->P9 answered: contracts/glassd.md §6 now says the room dim's compositor side is built (glassd pieces, P8's pass-through, P7's roomdim placement, SG-ROOMDIM) and makes the cell-size guarantee P7 relies on part of the contract (a dim slab's cell spans its rect × backdropScale, feather inside); the report side (P6) is named as not built (C7's roomDim is off). No glassd code changed for it. REQ C2a->P8 #17 (FYI P9: native Home shows a grey slab): glassd's own handling of shapes: [] + plates is covered by GL-1 (shapes: [] draws no cover; 32 plates drawn on a windowless surface) and the bench scene home; the live investigation is in wp/P8.md.
• Round R1 review fixes: done (2026-10-07 07:15-08:10; review wp/P9-review-R1.md). Every major finding (M1, M2, M3) and every minor one (m1-m9) is fixed or recorded; see Evidence, round R1 and its finding-by-finding table. M1 reached, M3 reached, card complete apart from what is blocked below.
• Installed (2026-10-07 08:00, under native.lock): the shared ~/.local/share/glass-shell/native/glassd/glassd (+ build/glassd, md5 016835155d66…) and native/spike/fakeglassd (md5 ee5a3f70dc6e…) are the R1 builds of this tree (motion tokens ed4e044810). caps: plates, holes, tint, masks, coverDz, none, offset, dim, scaleFrom, unitM, roomDim, dimSlab, holeEdges. Native sessions with it come up in 2.6 s, healthy. If someone runs glass.py native-build from an older synced tree, the binary loses the R1 fixes: rebuild from this tree.
• Acceptance (R1): GL-1 PASS (now with a cover-without-slabs check that fails on the R0 binary, masks and coverDz); GL-2 PASS, now measured (tools/test_holes.py: dL of each hole's sliver against the art it hides) plus the plate-over-cover case; GL-3 PASS (worst median 1.93 ms at 903 MHz); GL-4 PASS; GL-6 PASS; MO-5 PASS. GL-5 UNVERIFIED (not passed): the default profile no longer has a wide thin slab (admission rule 2), so the GM §6.2 lower lip cannot be looked at live; the R0 half-resolution row is withdrawn.
• Blocked on others (recorded): the live hole tones need REQ P9->P6 (fill: "auto" → hole.edges) and REQ P9->P8 (pass edges through); until then pops over art use a flat fill (R0 look) and GP's over-art pops stay behind overArtPops (off). DESIGN2 §11's glassd-morph sentences need REQ P9->P4. A live look at plates and holes on real routes needs C2a / C5a / C3b content in native mode; the keyboard surface live (K-G1, K-G2 / C24, K-G3 / C16) needs C4b's fragment; the room-dim panel needs P7 placement + P8 pass-through (optional, flag off). GL-5 needs a wide thin slab (wearer profile).
• If a later session continues: when P6 and P8 land the REQs, run a native session on a game page with GP's cluster (overArtPops on for that session only, then off) and look at the sliver beside Play from hv --offaxis 20 --full --look; compare with shots/p2_glassd_holes-dl.png. When P6 reports Home plates, compare a native look at Home with shots/p2_home-apps_home.png.
• Build and test happen in a scratch copy on the Frame (/tmp/lgs/p9/, uploaded by the scratchpad script p9push.py: tar of native/glassd, native/shared, native/spike/fakeglassd.cpp + headers; build cd /tmp/lgs/p9/glassd && NOINSTALL=1 NOTOOLS=1 sh build.sh), never in the shared install, until the tests pass; then install -m755 under flock /tmp/lgs/native.lock. Test fixtures: /tmp/lgs/p9-fx/<test>/, removed by each test.
• History: M1 reached 2026-10-07 04:10 (contract v3); M3 reached 05:30 (G1-G7 built and installed; R0 evidence below).

Requests

• REQ P9->P10: three small glass.py hv additions for GL-5 / K-G3 / C16 (thin lines are 1-2 texels, so the half-resolution frame can hide them): (1) --full, i.e. hvgrab out.png 1 (full-resolution HeadsetView) instead of the fixed scale 2; (2) --look honoured for an hv step inside native-session (pass hv_opts through cmd_native_session's lab_fetch), so a native look does not need a parallel command; (3) the doubling score reports text as a doubled edge: on Steam's header it peaks at the smallest shift (4 px, score 0.63-0.76) because glyph strokes repeat, not because an edge doubles. Please count only a local maximum (c(s) > c(s-1) and c(s) > c(s+1)) at s ≥ 6, or measure along the edge row outside text.
  • P10 (2026-10-07 06:35): done: (1) hv … --full captures at scale 1; (2) an hv step inside native-session honours its own --look / --rect / --full (the device passes them with the frame); (3) doubling now takes the highest local maximum at a shift ≥ 6 px (c(s) > c(s−1) and c(s) > c(s+1)).
• REQ P9->P6: please add hole.fill: "auto" for pops over art, posters and media (GP's cluster, C5a's over-art depth): report it as glassd's new hole.edges (contracts/glassd.md §1.4, cap holeEdges): {top, right, bottom, left}, each the tone of a 2 CSS px strip just outside that edge of the crop, as one colour or a list of up to 8 samples along the edge (about one per 27 CSS px; left to right, top to bottom), CSS colour strings. Sampling idea: the <img> (or background-image) under the crop drawn into a canvas when it is same-origin (Steam's library art comes from steamloopback.host), then any translucent layers above it (dimming gradients) composited by their computed colours; when the art cannot be read, fall back to the nearest opaque ancestor's computed background colour as a flat fill. Why: one flat fill cannot match art that varies by 15-20 L across a crop, so off axis the sliver draws the crop's L-shaped outline (review R1 M2); with edge tones glassd's sliver matches the art within dL 2-4 (tools/test_holes.py, GL-2). Also let holeOf (device/lgs_layers.js) pass edges through when a fragment gives them literally. P6 (2026-10-07 08:40): done: a rule's "hole": {"fill": "auto"} reports hole.edges sampled per pop (stack under each point: colours, linear gradients, same-origin <img> art; flat ancestor fill when an edge has no sample) and literal edges pass through holeOf; contract reporter.md §3.4, test RP-RV in wp/P6.md.
• REQ P9->P8: please pass hole.edges through clean_hole (device/lgs_shell.py) when glassd's caps lists holeEdges: an object with up to four keys top, right, bottom, left, each a colour or a list of ≤ 8 colours (each through clean_color; drop unparsable ones; drop an empty edge). Today clean_hole whitelists shadow, y, blur, fill, clip, so edges would be lost.
  • P8 (2026-10-07 09:05): done as asked (clean_edges, only with the holeEdges cap; contract daemon.md §7). Live: DM-2 sends edges: {top: "rgb(80 52 37)", left: ["rgb(70 50 40)", <bad sample>, [0.3, 0.2, 0.15]], right: []} and glassd.json carries {top: "rgb(80 52 37)", left: ["rgb(70 50 40)", [0.3, 0.2, 0.15]]} with fakeglassd's v3 caps (wp/P8.md, R1 rows).
• REQ P9->P4: DESIGN2.md §11 (the in-page menu morph, line ~902) says "glassd draws the 1.5 % overshoot and the liquid neck in T5", and line ~913 lists a glassd "morph k". glassd v3 has no morph (PLAN 1.17 decision in wp/P9.md, Notes and decisions, R1; contracts/glassd.md §6; C1c D15): in T5 the menu's slab materializes in place while C1c's CSS clip-path draws the open morph, and glassd dematerializes it on close. Please amend those two sentences to say so (PLAN 1.18 list). P4 (2026-10-07, R1): done: §11's morph bullet now says the slab materializes in place while the CSS clip-path draws the open morph and glassd dematerializes it on close (no glassd morph, overshoot or neck); the glassd-springs bullet drops "morph k".

Evidence

Steam build 11094443 for every row. Binary: /tmp/lgs/p9/glassd/build/glassd (NOINSTALL=1 NOTOOLS=1 sh build.sh), sources identical to the working tree; installed after these rows passed.

Test	Command (on the Frame, in /tmp/lgs/p9/glassd)	Result	Files	Date
MO-5 selftest	./build/glassd --selftest phase	PASS: worst 0.0010 (limit 0.002); sheet-in settles 735 ms, sheet-out 515 ms, linear 250 / 350 ms, reduce 180 ms	(stdout)	2026-10-07 05:05
GL-1	GLASSD=build/glassd python3 tools/test_shapes.py	PASS: 32 plates drawn, pl32..pl34 dropped and listed; every plate opaque; gaps alpha 0; occluder / twin luma 0.55; dim plate alpha 77 (≈ .30); red hole fill inside the crop only; none cell 0 texels; green tint centre [53, 199, 87]; union, shapes: [], panel, window, big cases as Phase 1	(deleted by the test)	2026-10-07 05:06
GL-4	GLASSD=build/glassd sh tools/test_phase.sh	PASS: 40 values (window cover, thick slab and thick plate on sheet-in / sheet-out; liquid slab and liquid plate on 250 / 350 ms), worst 0.001	(stdout)	2026-10-07 05:06
GL-3	GLASSD=build/glassd sh tools/test_bench.sh 15	PASS: median GPU home (19 plates + 1 slab) 0.86 ms, library (cover + 3 slabs) 1.35 ms, ccm (4 plates) 0.96 ms, keyboard 1.59 ms; GPU clock median 903 MHz in every scene, so the idle-clock and 903 MHz numbers are the same; p90 ≤ 3.65 ms	(stdout)	2026-10-07 05:07
GL-2	GLASSD=build/glassd sh tools/test_material.sh /tmp/lgs/p9/mat (procedural room, --view-content hero for holes, --test-head 0.35,0.1,0 off axis)	PASS by look: off axis the sliver beside each popped circle and beside Play reads as a dark shadow over the art, the crop without hole shows the lighter glass sliver (the contrast case); Play green, Install blue; plates read as refracting glass discs, the occluder plate under the focused cell darker	shots/p2_glassd_holes_view.png, p2_glassd_holes-offaxis_view.png, p2_glassd_plates_view.png, p2_glassd_plates-offaxis_view.png, p2_glassd_room_view.png (no camera data)	2026-10-07 05:07
GL-6	FAKEGLASSD=/tmp/lgs/p9/spike/fakeglassd python3 tools/test_fake.py (new)	PASS: out version 3, all 10 caps, seq echoed; 32 plates listed, 3 dropped, counts right; holes 2, slabs 3; plates opaque, gaps 0, occluder 0.55, dim alpha 77, tinted plate green; red hole fill, default hole darkens; none cell empty; green and blue slabs	(deleted by the test)	2026-10-07 05:09
GL-2 (holes, re-run)	test_holes.json fills changed from a dark rgb(40 34 36 / .92) to the stand-in art's mean tone per crop (rgb(80 52 37 / .95) etc., computed from view.frag's art()), then the holes / holes-offaxis runs of test_material.sh	PASS by look, compared with GP's shots/p2_game-pages_pop_hole.png (b): off axis the sliver beside Play and the circles reads as their soft shadow over the art's tone, no bracket. With the dark fill (first run) the sliver was a crisp dark L-bracket along the crop rect's top and right edges, which reads as an outline: guidance added to the contract §1.4 (fill = the surroundings' mean tone). The input circle (hole: true, no fill, over art) keeps the lighter glass bracket: the case the depth rules forbid	shots/p2_glassd_holes_view.png, shots/p2_glassd_holes-offaxis_view.png (replaced)	2026-10-07 05:24
Regression	python3 tools/test_atlas.py	PASS: A → B keeps texture and UVs; churn 400: 0 moved, 0 overlaps, 0 outside; latency median 2.1 ms; no fd / dmabuf leak	(stdout)	2026-10-07 05:10
Regression	sh tools/test_locks.sh	PASS: (a)-(e) as Phase 1 (75 on a held lock, own out file, parent death, --orphan-ok)	(stdout)	2026-10-07 05:11
Install	flock -w 1800 /tmp/lgs/native.lock install -m755 … (glassd and fakeglassd into the shared install)	installed glassd prints selftest phase: PASS; fakeglassd has the v3 output		2026-10-07 05:12
Live smoke	python glass.py native-session --settle 75 (v3 binary installed), spec read from /dev/shm/lgs/glassd.json during it	native up in 2.6 s, lgs-native on main; glassd v3 healthy, dashboard on, gpu_ms 1.46, caps all 10; spec: main cover + 3 slabs (hdr-back 143×48, hdr-search 1741×48, footer), bar 2 shapes; back to CSS only: yes	(none kept)	2026-10-07 05:12
GL-5 (half res) superseded: UNVERIFIED (R1 review m6: the 0.068 is hv's window top-edge profile, not the slab's lower lip, and hvgrab's scale 2 is point-sampled, so it can hide or dash a 2-6 texel lip; see the R1 rows)	second native-session --settle 60; meanwhile python glass.py hv p9gl5b --look and a 4× zoom of the header band (scratchpad script), looked at, frame and zoom deleted at once	edge ratio 0.068 (first capture 0.326), ≤ 0.35 PASS; glass L 61 (G-HV 55-110), outside 5.7 (dark room). The wide hdr-search slab's lower edge reads as one continuous soft dark lip: no dashed line at hvgrab's half resolution (960 × 540). doubling 0.76 at shift 4 is the header text (see REQ P9->P10). Full-resolution recheck when hv --full exists	none kept (room imagery)	2026-10-07 05:16

| G7 build (05:28) | v3 + roomDim + dim slabs: NOINSTALL=1 NOTOOLS=1 sh build.sh; then --selftest phase, test_phase.sh, test_bench.sh 15, test_shapes.py, test_fake.py (fakeglassd rebuilt), test_atlas.py, test_locks.sh; installed under native.lock | all PASS: phase worst 0.001-0.003; bench medians home 0.92, library 1.39, ccm 1.06, keyboard 1.65 ms at 903 MHz; GL-1 adds: dim slab cell centre (0, 0, 0, 77), edge texel alpha 6, cover under it unchanged (75 vs 73 same row), roomDim .30 lowers the window glass mean luma 75.5 → 71.4, caps list roomDim, dimSlab; GL-6 adds the dim cell in fakeglassd | shots/p2_glassd_roomdim.png (test room, left roomDim 0, right .30) | 2026-10-07 05:28 | | G7 cost check | glassd --bench home and keyboard, new build against the installed one, alternating | A first version multiplied every room sample in the shader: keyboard min 1.65 vs 1.45 ms (+12 %). Replaced by folding roomDim into the existing uDim on the CPU (shader unchanged): keyboard min 1.46 vs 1.45 ms | (stdout) | 2026-10-07 05:26 | | Live regression | flock -w 1800 /tmp/lgs/native.lock env GLASSD=build/glassd sh tools/test_live.sh (feed, Steam's real overlays, test prefix, no dumps) | PASS: geometry main steam, bar and footer steam(rescaled), masks 5, feed live, healthy; SIGUSR2 recovery; exit 75 after 3 losses | (stdout) | 2026-10-07 05:19 |

Evidence, round R1 (review fixes)

Steam build 11094443 for every row. Binary: /tmp/lgs/p9/glassd/build/glassd, built from the working tree (NOINSTALL=1 NOTOOLS=1 sh build.sh, motion tokens ed4e044810), installed after the rows passed (final md5 01683515…). Analysis helpers lived in the scratchpad (p9an.py: black-texel count and luma steps in a slab cell); every image is the procedural test room (no camera) unless a row says otherwise.

Test	Command (on the Frame, in /tmp/lgs/p9/glassd)	Result	Files	Date
M1 repro	cover-only spec (main 1920 × 984 r 81, no slabs), glassd --spec S --once --warmup 0 --dump D --test-backdrop room, then opaque texels with R+G+B < 30 in D/main.png	R0 binary (installed 7660d896…): 92 (the reviewer's number). R1 (textureLod(uLow, …, 0.0) in pass 2): 0	(deleted)	2026-10-07 07:30
GL-1 (R1)	GLASSD=build/glassd python3 tools/test_shapes.py	PASS. v3 part unchanged (32 plates + 3 dropped, occluder .55, dim alpha 77, red hole, none empty, green [53, 199, 87], roomDim 75.5 → 71.4). New: cover without slabs 0 near-black texels over the grey room and over the test room, window surface 0; the R0 binary fails this check (92), so it catches M1. Masks (G4, room-hole, procedural): known 97.1 % of the map; a surface mask beside the window hides 577 more texels, a world mask quad 1108, none revealed. coverDz: a clear slab over a dark plate edge, 0.35 m off axis: mean cell change 0.83 at −0.027 (K-G6) and 5.65 at −0.2 against 0.001	(deleted by the test)	2026-10-07 07:58
GL-2 holes, measured (new)	GLASSD=build/glassd python3 tools/test_holes.py (renders test_holes.json with and without the cut-outs, head-on and 0.35 m off axis; dL = luma(view) − luma(art it hides), per hole: shape = beside the control, corner = beyond its rounded ends, rim = within 1.5 px of the crop rect's edge)	PASS with edge tones (hole.edges). Off axis: Play shape dL mean −3.7 (min −13.3, a soft shadow at its right end), corner abs-mean 2.6 (p95 7.3), rim 2.2; from shape −6.9 (min −16.5), corner 2.7, rim 1.6; manage shape −1.4, corner 2.3, rim 2.7. Head-on: every abs-mean ≤ 2.2. For comparison, one flat fill per crop (R0's test values) with the same shading: rim abs-mean 5.6-6.7, p95 up to 15.9 (the L-bracket); input (no fill, the contrast case): rim +21 to +28	shots/p2_glassd_holes-dl.png (3× crops: edges, flat fill, reference art)	2026-10-07 07:58
GL-2 views	GLASSD=build/glassd sh tools/test_material.sh /tmp/lgs/p9/mat	Holes: no bracket along the filled crops; the sliver darkens toward the control and meets the art with no step; input keeps the light bracket (contrast case) and install (no hole in the test spec) a thin glass line, as expected. Tints: the holes views paint each crop with a stand-in capsule in the tint colour (view.frag uPopCol), so green and blue there are not glassd's tinted glass; the tint itself is shown by GL-1/GL-6 numbers ([53, 199, 87]; blue slab [20, 152, 252]) and by the plates view (the blue name plate). Plates over a cover (new case, m1): raised, lighter window glass with a top crescent and a soft bezel, no closed rim; the R0 binary on the same spec shows coloured closed rims and the M1 corner dashes	shots/p2_glassd_{holes,holes-offaxis,plates,plates-offaxis,room,platecover,platecover-offaxis}_view.png, shots/p2_glassd_platecover_ab.png (R0 above, R1 below)	2026-10-07 07:58
M3 (glass over glass)	tools/test_plates.json dump; luma steps between neighbouring texels inside the focused cell's inner disc (radius .6), and a 3× crop of the view	R0: max step 3.0, p99 2.2, straight row and column steps (a square inside the disc). R1 (nine taps where a plate or a hole fill lies behind): max 2.0, p99 1.2, round. A five-tap variant (0.15 ms cheaper) left a visible X and was rejected	shots/p2_glassd_glassoverglass_cell.png	2026-10-07 07:40
GL-3 (R1)	GLASSD=build/glassd sh tools/test_bench.sh 15	PASS, worst median 1.93 ms at 903 MHz (another run: keyboard 2.43 ms at 680 MHz = 1.83 at 903). Home 1.03, library 1.60-1.78, CC-M 1.08-1.11, keyboard 1.93. A/B against R0, alternating: nine taps everywhere cost +0.3 ms (library min 1.24 → 1.56); with the taps only where a plate or hole fill lies behind, library min 1.46-1.47, keyboard 1.72; scenes with only slabs or only plates are as fast as R0 (library without the plate 1.38 vs 1.42; without slabs 1.00 vs 1.07). Drawing the cover copy instead of blitting it cost 0.1 ms more (rejected)	(stdout)	2026-10-07 08:00
GL-4 / MO-5	sh tools/test_phase.sh; ./build/glassd --selftest phase	PASS: 40 values, worst 0.001; selftest worst 0.0010. /tmp/lgs/glassd-dump/ is no longer written (the room dump goes to the test's own dir)	(stdout)	2026-10-07 07:58
GL-6 (R1)	FAKEGLASSD=/tmp/lgs/p9/spike/fakeglassd python3 tools/test_fake.py (fakeglassd rebuilt)	PASS: version 3, all 13 caps incl. holeEdges; a hole with magenta edge tones paints [252, 0, 252]; everything else as R0	(deleted by the test)	2026-10-07 07:58
Regression	tools/test_atlas.py; tools/test_locks.sh	PASS: 0 moved, 0 overlaps, 0 outside, latency median 2.1 ms, fds and dmabufs back to baseline; locks (a)-(e) as before	(stdout)	2026-10-07 07:58
m7 hostile spec	installed binary, a spec with 5000 plates, numeric ids 1e30 / −5 / 1.2e22, seq 1e40, tints "bogus", hole fill "rgb(1 2", odd edge entries	exit 0; each unparsable colour logged once ("bogus" twice in the spec, one line); glassd-out.json 1289 bytes (32 ids listed, counts.droppedPlates 4968); ids 1e+30, -5, 1.2345678901234568e+22; seq clamped to 9e18	(deleted)	2026-10-07 08:03
Fixtures (m3)	every test above, then ls /tmp/lgs/p9-fx /tmp/lgs/glassd-dump tools/__pycache__	none of them exists after the runs		2026-10-07 07:58
Install	flock -w 1800 /tmp/lgs/native.lock install -m755 … (glassd and build/glassd; fakeglassd at 07:52)	md5 glassd 016835155d66…, fakeglassd ee5a3f70dc6e…; the installed glassd prints selftest phase: PASS		2026-10-07 08:00
Live smoke (R1)	python glass.py native-session --settle 45 --step "hv … --look --full"; spec and out read from /dev/shm/lgs/ during it	native up in 2.6 s, lgs-native on main; glassd v3 healthy, caps incl. holeEdges; spec main: cover + hdr-back 151×90, tabs 826×96, two tab-arrow 120×120 (dz .012-.015), no plates, no holes; bar 2 shapes; gpu_ms 2.0-2.3 live (EMA at 6 fps, GPU clock not reported). Back to CSS only: yes	(the look file was removed by another agent's glass.py before it could be viewed)	2026-10-07 07:53
Live look (R1)	python glass.py native-session --settle 30 --step "hv p9r1b --look --full" (final build); frame viewed within its 120 s window, then deleted on the PC and the Frame	Full resolution 1920 × 1080: window glass L 71.8 (G-HV 55-110), outside 36.9, edge ratio 0.559 on the auto rect (verdict withheld by hv: auto rect), doubling 0.49 (not doubled). By look: the window and the bar read as soft grey glass with edges from light only; no dark dashes inside the visible window corners; the route was another agent's dev page. Seen but not P9's: the header's popped Back capsule shows Steam's title text under it (base mosaic, P6/P7); a bright L at the window's lower-right corner (not a glassd shape: glassd draws nothing opaque white there)	none kept (room imagery)	2026-10-07 08:05
GL-5	(none possible)	UNVERIFIED (recorded, not passed). The default profile has no wide thin slab any more: admission rule 2 caps a pop at 0.000521 × s units for its smallest focusable s (CSS px), so a 32 CSS px header field gets about 6 mm and is dropped below 10 mm (reporter contract §4); the live spec's widest slab is tabs 826 × 96. The wearer profile (interactivePops, off, needs a wearer) would bring the GM §6.2 case back; then rerun with hv --full --rect on the slab's lower edge		2026-10-07 08:05
Live regression	flock -w 1800 /tmp/lgs/native.lock env GLASSD=build/glassd sh tools/test_live.sh	PASS: healthy, geometry main steam, bar steam(rescaled x2.50), SIGUSR2 recovery, exit 75 after 3 losses. Today Steam's floating footer is not placed (fallback(quad at the origin)), so the room map waits (masks=3(incomplete), by design: it never integrates UI)	(stdout)	2026-10-07 08:08
m4 (P-48)	buildCasters offset = 0.3 × dz (metres)	10 / 15 / 25 mm → 3.9 / 5.9 / 9.8 CSS px (P-48: 4 / 6 / 10, ± 50 %); softness unchanged (inside its band)		2026-10-07 07:35

R1 findings, one by one

Finding	What changed	Evidence
M1 corner dashes	glass.frag pass 2 reads the quarter-resolution copy with textureLod(…, 0.0); GL-1 checks a cover without slabs	M1 repro, GL-1 (R1)
M2 hole band	New hole.edges (per-edge tones, cap holeEdges); the AO floor (now 30 %) lies only under the control's rounded shape; over an opaque tone the shadow follows the control and fades to nothing at the crop's edge; GL-2 judged with measured dL (tools/test_holes.py); REQ P9->P6 (fill: "auto") and P9->P8 (pass-through) for the live data	GL-2 holes, measured; shots/p2_glassd_holes-dl.png
M3 square in glass over glass	Nine-tap round read of the copy (centre + ring of 8, 1.5 mips finer) where a plate or hole fill lies behind; one tap elsewhere	M3 row, GL-3 (R1)
m1 plates over a cover	They sample a copy of the cover (glass over glass, optics 2 mm in front); new GL-2 case test_platecover.json	GL-2 views, p2_glassd_platecover_ab.png
m2 morph-close	Recorded as a PLAN 1.17 decision (Notes); contract §6 updated; REQ P9->P4 for DESIGN2 §11	Notes below
m3 fixtures	/tmp/lgs/p9-fx/<test>/, removed on any exit (trap / finally), no __pycache__, --dump-room in test_phase.sh; REQ P1->P9 answered	Fixtures row
m4 P-48	Slab shadow offset 0.3 × dz	m4 row
m5 masks, coverDz	GL-1 checks both	GL-1 (R1)
m6 GL-5	Recorded as UNVERIFIED with the reason	GL-5 row
m7 contract nits	Unparsable colours logged once per value; colour names in the contract; droppedPlates and dropped list ≤ 32 (counts have all); numeric ids beyond 2^53 printed with %.17g; seq clamped; GL-2 tint wording fixed	m7 row, GL-2 views
m8 tint stand-in	Said in the GL-2 views row	GL-2 views
m9 motion tokens	Rebuilt with ed4e044810 (values unchanged)	Install row

Notes and decisions (PLAN 1.17)

• G7 room dim (optional, decided without the user, PLAN 1.17): built as two glassd pieces behind the consumers' flags: top-level roomDim and a dim slab cell. Placement of the dim panel behind the window (P7) and the pass-through (P8) are not requested yet, because C7's roomDim flag is off by default and SM-D6 ships the window tint; the contract (§1.1, §1.4, §6) says how to use them.
• Hole fill (R0, superseded in R1): GL-2 showed that hole.fill must match the crop's surroundings, else the off-axis sliver is a crisp L-bracket. R0 tuned the test fills to the stand-in art's mean, a value the reporter cannot produce, and one flat tone still left a band (review M2); R1 replaces this with hole.edges and the shading below.
• Menu morph in glassd (morph-close, PLAN 1.5 row "Menu morph", decided without the user, PLAN 1.17, R1): not built in v3. Safe default: the menu's slab materializes in place on its phase while C1c's CSS clip-path draws the open morph from --sx --sy --sw --sh (C1c D15, built against this), and on close glassd dematerializes the slab (CSS close is instant, MO R4). Why not build it now: a glassd close morph is visible only if P8 keeps the closing slab with its source rect and P7 keeps drawing a slab whose pop has gone (contracts/sg.md §2: a listed slab without a sinking pop is not drawn), and no package requests it; a glassd-only morph would draw nothing on the headset. No flag (nothing to switch). To build later: a slab field morph: {x, y, w, h, r} (source rect, Steam px) that glassd interpolates the slab's drawn shape toward on phase → 0 with sheet-out, inside a cell sized to the union; REQs to P8 (pass it, keep the slab ≤ 514 ms) and P7 (draw it). DESIGN2 §11 still describes the glassd morph: REQ P9->P4.
• Hole tone over art (R1, M2): a flat hole.fill cannot match art; glassd now takes per-edge tones (hole.edges, cap holeEdges) and shades the hole so the shadow follows the control and fades out at the crop's edge. The data path is P6 (fill: "auto") and P8 (pass-through): REQs filed. Until they land, pops over art keep the flat fill, which is the R0 look; GP's over-art pops are behind the overArtPops rule flag (reporter contract §3), off by default.
• Plates over a cover (R1, m1): they now see the cover (glass over glass) with optics 2 mm in front of it, instead of the room behind the window. No flag: it only changes how a plate over a cover is shaded, and the old look (a closed rim of bent room) failed P-42/P-45.
• REQ P5->P9 (motion tokens) is done: glassd.cpp includes motion_tokens.h (-I../shared in build.sh), the phase ramps and springs come from it, and --selftest phase plus tools/test_phase.sh check them against the header.