SCENEGOD/logs/laneB.md

Lane B log — append-only, newest at bottom

Format per session:

## <date> session N
DONE: …
DECISIONS: …
BLOCKED/REQUESTS: …
NEXT: …

2026-07-18 session 1

DONE: M1 complete. All files under scenegod/web/.

• timeline.js — model + clock, no DOM, no three import (self-contained quat/euler/slerp math so node can run it). load/toJSON lossless round-trip (unknown entity fields preserved via structuredClone + a WeakMap for cached quats). evaluate(t): transform (pos/scale lerp, rot slerp→euler, easing incl. step-hold), params (num lerp, color sRGB lerp), clip blocks (set-time exact scrubbing, fade-out ramp), camera cuts (fires only on change). Clock: play() rAF deltas, seek clamp, step(frame) pure/deterministic for Lane C render. Mutators addKey/moveKey/deleteKey/ addClipBlock/moveClipBlock/trimClipBlock/addCut + undo stack (undo() wired; Ctrl+Z hooked in tlui). capturekey window listener present. Clips need await tl.preload() before evaluate (prepareClip is async).
• tlui.js — canvas panel into #timeline. Ruler scrub, drag playhead, space=play/pause, dblclick lane=add key from stage state, drag key (snap to frame, Alt=free), right-click=delete, drag clip block/edge, Home/End, Ctrl+Z. Scene bar name/dur + Save/Load (POST/GET /scenes/{name}, localStorage fallback). Names column auto-syncs to stage.entities() via onChange.
• stagestub.js — full §4.2 Stage as plain objects; records effects into stage.applied[]. Dev-only, delete at SYNC 1.
• timeline_test.mjs — node scenegod/web/timeline_test.mjs → green (midpoint interp, step-ease hold, clip local time @3 frames, camera flip, lossless round-trip, unknown-field preservation).
• tldev.html — dev-only browser harness. Verified in browser: scrub moves entities (interp live in log), play runs to duration + auto-stops, camera cut flips camA→camB at t=3, keys/clips/cuts render. Delete at SYNC 1. DECISIONS:
• Timeline imports NO three.js — inlined euler↔quat + slerp (~30 lines) so the node self-check needs zero deps (there is no node_modules/three in this stack). setTransform rot is euler (matches entityTransform format).
• One <canvas> for all lanes (not canvas-per-lane); hit-testing via a hitbox list rebuilt each draw. Simpler, fast enough at this scale.
• CSS injected from tlui.js via a <style id=laneB-tl-css> rather than creating web/style.css — that file is Lane A's and didn't exist yet. Move into a /* === LANE B === */ block at SYNC if John wants it centralized. (See REQUEST below.)
• M1 crossfade = fade-OUT only; cross-block fade-IN is M2 "crossfade polish" per the milestone list. Marked with a ponytail comment in timeline.js. BLOCKED/REQUESTS:
• None blocking. Note for orchestrator/Lane A: my timeline styles live in an injected <style> in tlui.js. If you'd rather they sit in style.css, say so and I'll emit a /* === LANE B === */ block for Lane A to paste (I won't edit style.css directly — ownership).
• Lane A's files (index.html, stage.js, room3d.js, dock.js, style.css) are present untracked in the shared working dir but uncommitted — I staged ONLY my 5 files, left theirs alone. NEXT: Hold at M1 boundary. At SYNC 1 the stub swaps for the real Stage (one-line change in the page import) and tldev.html/stagestub.js get deleted. M2 (locked): clip crossfade polish, params/cut lane UI, snapping config, undo Ctrl+Z already stubbed, box-select multi-drag.

2026-07-18 session 2 (M2)

DONE: M2 per orchestrator update. SYNC findings fixed first, then polish.

• SYNC1 #3a/#3b: added Timeline.onLoad(cb); load() fires it → TimelineUI rebuilds rows + refreshes name/duration fields. Verified with the exact repro (UI built against empty stage, then load() a 2-entity scene → rows now appear, scene bar updates).
• SYNC1 #4 clipdrop: scenegod:clipdrop {id,path,clipIndex} → addClipDrop drops a block at the playhead, out = clip.duration (from preload), auto fade:0.25 where it abuts a neighbour. Verified via dispatched event.
• Crossfade fade-IN (was fade-OUT only): a predecessor's fade pre-rolls the successor's playback start earlier by pred.fade so local time is continuous across the boundary; weights ramp 1→0 / 0→1 and sum to 1 (asserted in test).
• Params lanes (per-key hue), camera-cut lane add via dblclick on Cameras row (uses active cam / first camera), snap toggle in scene bar (Alt still = free), box-select + multi-drag + Delete of keys, selection highlight, fade wedge drawn on clip blocks, panel grows to content height (was fixed 200px → clipped the Cameras row once params rows were added).
• timeline_test.mjs extended: onLoad fires once, addClipDrop out=duration, crossfade weights sum to 1. All green. DECISIONS / BUG:
• tlui reads tracks from the TIMELINE, not the stage entity. Found mid- verify: load() structuredClones the scene, so timeline.scene.entities and stage entities are SEPARATE objects. Drawing from stage meant clipdrop/ addKey (which mutate the timeline copy) never appeared. Repointed all draw methods to _te(id) = tl.scene.entities.find(id). Rows now built from the timeline list merged with any stage-only (dock-added, not-yet-keyframed) entities. Per PLAN the timeline owns tracks — this is the correct source.
• Grow-to-content height, no scroll yet (ponytail: add max-height+scroll only if a scene ever has enough entities to dominate the viewport). BLOCKED/REQUESTS:
• Gap for the orchestrator/Lane A to note: there's no bridge for a dock-added stage entity to enter timeline.scene.entities, so a freshly dropped character can't be keyframed until a scene load. tlui shows it as a row (empty tracks) but mutators need the entity present. If Lane A's dock should register new entities with the timeline, we need a timeline.addEntity(desc) (or the dock calls stage.captureState() → timeline.load). Flagging for SYNC 2 — not building it uninvited.
• Verified with a throwaway harness (_check.html) served on :8099; deleted, NOT committed (orchestrator removed the M1 tldev.html deliberately). NEXT: Hold at M2. Remaining M2 polish if a session 3 is granted: undo already wired to Ctrl+Z; could add snapping increment config + keyable-param add UI (currently params keys come from Lane A capture/inspector). Await SYNC 2.

2026-07-18 session 3 (M2 polish)

DONE: All three orchestrator session-3 items.

1. Absorbed _mirror (orchestrator's seam) — reviewed; it upserts dock-added stage entities into scene.entities with empty tracks and drops them when stage.getEntity(id)===null. Fixed the STUB to make removal testable: removeEntity now fires onChange WITH the removed entity object (was firing null, so _mirror(null) early-returned and never removed). Added timeline_test.mjs lifecycle case: dock-add → keyframe → remove, asserting entity+empty-tracks appear then vanish.
2. setDuration(x) mutator: clamps the playhead into range, KEEPS keys past the new end (lossless), notifies the UI (reuses onLoad → syncRows + refreshBar). Wired the dur field to it — plain scene.duration = x skipped the bar refresh. Test asserts clamp + key retention + notify.
3. Snap-increment select (frame / 0.1 / 0.25 / 1s) in the scene bar; _snap rounds to the chosen step (Alt still = free). Keyable-param add: dblclick a params lane captures the entity's current param values as keys (skips type/boolean descriptors) — mirrors the transform-capture dblclick. DECISIONS:

• params lane now shows only when the entity has ≥1 param key OR kind is camera/light. _mirror seeds tracks.params=[] (truthy), which was giving every mirrored character an empty params lane; tightened to tracks?.params?.length > 0 || camera|light.
• setDuration reuses the onLoad callback list as its "refresh UI chrome" hook rather than adding a second callback channel (lazy; onLoad handler already does syncRows+refreshBar+draw). BLOCKED/REQUESTS: none. Verified with a throwaway harness (_check.html, served :8099, deleted, NOT committed). timeline_test.mjs green. NEXT: M2 polish complete. Undo already wired (Ctrl+Z). Open for M4 timeline work when unlocked (audio tracks on the timeline UI + Web Audio sync, per PLAN §5 M4) or any SYNC 3 fixes. Holding until orchestrator flips M4.

2026-07-18 session 4 (M4-B: audio + visemes)

DONE: M4-B all three items.

1. Audio rows in tlui from scene.audio[]: one lane per clip below Cameras, green block at the DECODED buffer width (fallback width until decoded), gain in the name column, drag = offset (moveAudio), right-click = delete. 🎵 button reads /assets/tree audio category into a small floating menu → addAudio at the playhead.
2. Web Audio draft playback synced to the master clock: lazy AudioContext, decode+cache buffers (/assets/file), _audioStart schedules AudioBufferSourceNodes at (start - time) with per-clip gain, _audioStop on pause/natural-end, user seeks reschedule (_seek helper). step()/render never touch audio — server muxes from scene.audio.
3. morphs track kind: _evalMorphs lerps per viseme name → stage.setMorph; importRhubarb(id, json, t0) maps mouthCues → morph keys; tlui shows a "↳ visemes" lane guarded by stage.visemeTargets(id).length > 0. Model (timeline.js, stagestub.js, timeline_test.mjs) committed ba29d0c; tests cover morph lerp, rhubarb keys, audio mutators+undo. All green. VERIFIED (real server :8020, real assets): 🎵 picker listed + added audio/test/tone.wav, buffer decoded (8s), green block drawn, Web Audio scheduled/rescheduled/stopped (ctx running), viseme lane rendered importRhubarb keys, setMorph fired while scrubbing. Contract match confirmed: real stage.js ships setMorph(id,name,weight) + visemeTargets(id) (returns Object.keys(visemes)) — my .length>0 guard works against both. DECISIONS:

• Audio duration is a client draw concern (decode+cache in tlui), NOT stored in the {path,start,gain} schema — server already knows durations at mux.
• importRhubarb = simple per-cue ramp (shape 1 at cue start → 0 at end); hold/crossfade tuning deferred (ponytail marker in timeline.js) until it looks wrong on a real blendshape character.
• Audio blocks can extend past scene.duration (tone.wav is 8s in a 6s scene) — left as-is; the ruler just clips visually. Trim is a later nicety. BLOCKED/REQUESTS:
• Ownership note for orchestrator: my tlui.js M4-B changes (+146 lines) were committed inside Lane A's df4e06f [laneA] M4-A ..., not a [laneB] commit — Lane A's commit swept my then-uncommitted tlui.js working changes along with their dock.js/stage.js. Code is intact + verified; only the attribution is off. Heads-up that our git hygiene let a cross-lane file ride in on another lane's commit; a git add <own files> (not -A) avoids it. Nothing for me to fix. NEXT: M4-B complete. Open items if a session 5 lands: audio block trim/clip to duration, viseme import UI button (currently importRhubarb is API-only; Lane C has a /rhubarb endpoint — could wire a "lip-sync from audio" button that POSTs the clip and feeds the result to importRhubarb). Holding for SYNC/next orchestrator update.

2026-07-20 session 5 (M5 director-mode B + backlog, M6 video-follow)

DONE: All three M5 items + the M6 item, headless-verified.

1. scenegod:direct listener (timeline.js ctor) → applyDirect(detail): shot → transform+fov keys on the camera at playhead + addCut; light → param keys; mark → transform key (walkTo → current/prevPos key at playhead + mark key at playhead+2s). New group(fn) collapses every mutator push inside one op into ONE undo entry — one Ctrl+Z reverts a whole preset. importRhubarb is now grouped too. Payload coordination: presets.js landed mid-session (untracked, Lane A in flight), so I read it — Lane A's REAL payloads differ from the PLAN-stated contract: values are spread at TOP level ({op:'shot', camId, pos, rot, fov,…} — no transform:{} wrapper), and light is {sun:{color,intensity}, ambient:{…}, bg, sunId, ambientId} (per-entity values, not a flat params map; bg keys onto the ambient entity; applyDirect ALSO captures the sun-boom transform from the stage since the payload lacks sunPos rot). applyDirect accepts BOTH shapes (contract + live); tests cover both.
2. 🗣 button on every audio row (tlui) → GET /rhubarb?path= → importRhubarb(charId, json, clip.start). Character picker (_choose promise-menu) when >1 viseme-bearing character, guard toast when 0, _toast shows the 503 install hint from FastAPI detail. Viseme lane resyncs after import.
3. Backlog: (a) wheel fix — plain wheel is NOT captured (page scrolls); Cmd/Ctrl+wheel (incl. trackpad pinch) zooms 1–64× around the cursor, horizontal wheel pans when zoomed; all geometry through _t2x/_x2t so keys/blocks/playhead/hitboxes just work. (b) audio trim: drag the block's right edge → trimAudio(clip, {in,out}) (source-relative, like clip blocks; absent = untrimmed so the {path,start,gain} schema is unchanged for untouched clips); draft Web Audio playback honors in/out; ✂ badge on trimmed blocks; undo restores pristine (fields deleted, not undefined).
4. M6: _evalVideo in evaluate for backdrop/screen entities via new nullable stage seam entityVideo(id): currentTime = max(0, t-videoStart) % duration ONLY when drift >50ms; play/pause follows the clock (pause() now re-evaluates so videos freeze); play() promise .catch()ed, never awaited — step() stays sync (render determinism is stage.syncVideos, Lane A/C). Files: timeline.js, tlui.js, stagestub.js (StubVideo records currentTime sets; entityVideo null for image backdrops — honest-nullable), timeline_test.mjs. node scenegod/web/timeline_test.mjs → all green (shot-via-real-EventTarget-dispatch + one-undo revert, generic + Lane A light shapes, walkTo 2 keys, Lane A mark shape, rhubarb group undo, trim undo, video drift-gate/modulo/videoStart-clamp/play-pause, nullable video). DECISIONS:

• group() splices the undo stack rather than a begin/end transaction API — mutators stay dumb, nesting works, zero cost when fn pushes ≤1 entry.
• Sun transform key on light presets comes from stage.entityTransform at event time (Lane A setTransforms before firing) — payload has sunPos but no rot; reading the stage gets both without a payload change.
• Video seek target clamps negative (t < videoStart → hold frame 0); wrap uses plain % (t-videoStart ≥ 0 after clamp).
• StubVideo lives in a stage-side Map, NOT on the entity object, so captureState/clone stays clean. BLOCKED/REQUESTS:
• Lane A: walk-to-mark can't work from the current payload — applyMark setTransforms the subject BEFORE firing, so "current pos" at event time is already the mark. When you add a walk mark, either include prevPos (+ walkTo:true) in the detail (applyDirect already honors both) or skip the pre-apply for walk marks. Also: no walk mark exists in grammar.js MARKS yet.
• Lane C: audio trim adds optional in/out (source-relative seconds) to scene.audio clips — mux should honor them (ffmpeg -ss/-t per clip); absent = whole file (schema unchanged for untrimmed clips). Client draft playback already honors them.
• Orchestrator: PLAN §4.1 audio schema + §4.2 Stage API could gain the two seams now in live use: audio {in?, out?} and entityVideo(id) -> HTMLVideoElement|null (Lane A implements on real Stage for M6-A). NEXT: SYNC — browser-verify DIRECT panel button → keys+cut land + single undo; 🗣 on real vo.wav → viseme keys on a blendshape character (and the 503 toast with rhubarb absent); Cmd+wheel zoom feel; video backdrop scrub-follow once Lane A ships entityVideo. Holding at M6-B boundary.

2026-07-25 session 6 (M7-B: the way in — templates + shortcuts overlay)

DONE: both required items + one backlog item, all headless-verified.

1. New from template (scene bar, left of Save/Load — tlui.js:122). _pickTemplate() (tlui.js:585) — GET templates → floating .tl-menu.tmpl (same pattern as the 🎵 picker) with title + description + thumb (assets/file?path=, img.onerror → text-only row). All URLs RELATIVE. newFromTemplate(name) (tlui.js:616): warn-before-clobber via tl.hasContent() → confirm(), then GET templates/{name} → tl.applyScene(json), _decodeAll(), draw(). Any failure (fetch, !ok, apply) toasts through _toast (window.sgToast still points at it).
2. ? shortcuts overlay (tlui.js:633 _toggleHelp / _helpClose, CSS .tl-help at tlui.js:48). Opens with ? or the ? button (tlui.js:121), closes on Escape / click-outside / ✕. Three columns — STAGE, TIMELINE, SCENE BAR — written by READING the code, not from memory: stage.js:118-122 (W/E/R gizmo, selection-gated), dock.js drops, and every binding in my _key/_down/_dbl/_ctx/_wheel. Deliberately NOT listed: right-click on a clip block (only keys/cuts/audio blocks delete), left-edge trim on animation clip blocks (only the right edge is a hit target).
3. Backlog: audio HEAD trim — dragging an audio block's LEFT edge now eats into the source (in and start move together so the audible part stays put) instead of being dead space. timeline.js:trimAudioIn (grouped: one undo for the pair, clamps at the file head, at t=0, and 0.05s before out); tlui aedge hits now carry side ('in' | 'out'). Model seams added to timeline.js: applyScene(json) (timeline.js:173) — stage.applyState → load → preload, the ONE apply path now shared by Load and New-from-template; and hasContent() (timeline.js:185). TEST: node scenegod/web/timeline_test.mjs → green, +5 new blocks: hasContent (empty / cuts-only / audio-only / dock-added entity), applyScene happy path (entities on stage, tracks in the model, onLoad once, camera live, clip preloaded and playing at t=1, template key stripped, caller's json not mutated), a loop that applies EVERY shipped templates/*.json through applyScene against the stub ("3 shipped templates applied clean"), and head-trim (pair + single undo + both clamps). node --check clean on timeline.js, tlui.js, stagestub.js, timeline_test.mjs. DECISIONS:

• tlui.load() now routes through tl.applyScene too, so Load and templates cannot drift apart (the ask was "apply it the same way Load does" — made it literally the same code rather than a copy).
• applyScene deletes the template key before loading. server.py:264 claims that metadata "never survives a Timeline round-trip" — it WOULD have, since load() structuredClones unknown fields on purpose (lossless round-trip is a tested feature). Stripping it in one place makes Lane C's comment true and keeps saved scenes plain scene JSON.
• hasContent() counts ANY entity, cut or audio clip — a dock-added, not-yet-keyframed character is still work worth a confirm. A fresh page has zero entities (Stage creates none in its ctor), so the first New… never nags. Used plain confirm() — a modal I'd have to build is not more honest than the browser's.
• _key now also ignores SELECT + contentEditable targets, so ? (and Space) can't be hijacked while the snap dropdown or any text field has focus.
• The ? button is excluded from the overlay's click-outside handler, otherwise mousedown closed it and the click reopened it. BLOCKED/REQUESTS:
• Lane C / orchestrator (nit): GET /templates returns thumbs that are ASSET-relative (backdrops/video/scenegod_plates/*.jpg) — I render them via assets/file?path=. If a future template ever ships a thumb that lives outside SCENEGOD_ASSETS, the picker will show a broken (auto-removed) image; keep thumbs inside the assets root.
• Lane C (still open from session 5): audio in/out at ffmpeg mux. Head trim makes it much easier to hit — a head-trimmed clip now renders from the file start server-side while the draft playback starts at in. NEXT: nothing required. Remaining polish if a session 7 lands: box-select multi-drag refinements (marquee currently only selects keys — clip/audio blocks and cuts are not box-selectable), and a per-drag undo coalesce (a mousemove drag pushes one undo entry per frame; Ctrl+Z walks it back a pixel at a time). Holding at the M7-B boundary.

2026-07-26 session 7 (M9-B: snap to the beat + the FILM panel)

DONE: both features, headless-verified. No git run this session (orchestrator's instruction) — timeline.js, tlui.js, timeline_test.mjs and this log are edited in place, uncommitted. stagestub.js needed no change this time.

M9-B1 — SNAP TO THE BEAT.

• Model (timeline.js:578-673): setBeatGrid/clearBeatGrid (:593), beatOffset() (:600), gridTimes(kind) (:616), snapToGrid(t, kind) (:635), plus the pure beatGridFrom(res, offset) export (:678) that maps Lane C's /beats response into the stored shape.
• UI (tlui.js): ♪ button on every audio row next to 🗣 (:~250, _detectBeats at :775) — GET beats?path= → cache per path (this._beatCache) → setBeatGrid → snap flips to beat and the toast says the BPM, the beat count and the confidence. beat + bar added to the snap-increment select (:156); _snap() (:477) routes those two through tl.snapToGrid and falls back to frames when no grid exists (plus a toast if you pick beat/bar with nothing detected). Grid drawing: _drawBeatGrid (:365) — beats rgba(146,180,232,0.13), downbeats rgba(224,175,104,0.34), over the lanes, suppressed below ~7px spacing (beats drop out first, then bars, then nothing — never a solid wash).
• Because _snap was already the ONE snapping funnel, keys, clip blocks, audio blocks, both trim edges, camera cuts and the playhead all became musical for free. That was the whole bet in the M2 design and it paid.

M9-B2 — FILM panel (tlui.js:848-1130): collapsible .tl-film section mounted INSIDE #timeline (_buildFilm :854, toggled by 🎬 in the scene bar :158). Sequence dropdown + New…/Rename/Delete, computed runtime, size picker, Save, Render film. Shot rows (_filmRow :960): scene <select> from GET scenes (with /Ns scene length shown), in/out numbers, transition cut|dissolve (+ seconds, only where a next shot exists), ↑ ↓ ✕. All server talk goes through Lane C's film.js helpers (listSequences/getSequence/ saveSequence/deleteSequence/renderSequence) — no hand-rolled URLs. _filmRender (:1100): hasContent() + a confirm that says plainly that every shot loads its own scene and the open scene will be REPLACED; then it SAVES first (the server renders the saved shot list, not the editor), disables the whole panel for the duration (_filmBusySet :1045, so no second render), shows shot 2/3 — sync2-sunset — frame 45/120 live, and ends with a link to films/{id}/out.mp4 + a note that the stage now holds the last shot's scene. 422s from plan_sequence are unwrapped by _errText and shown in red.

TEST: node scenegod/web/timeline_test.mjs → green, +2 blocks (:394, :482). Beat block runs against the REAL captured /beats payload for audio/test/house128.wav (bpm 128.02, 35 beats, 8 downbeats, conf 0.865), and asserts: no grid → snapToGrid null + nothing to draw; nearest beat over 9 time points and nearest downbeat over 6; the 0.24/0.25s midpoint flip; bars use Lane C's downbeat COSET (first downbeat is beats[3], not beats[0]); extrapolation past the last beat; never snapping below 0; grid follows moveAudio and survives trimAudioIn unmoved (start and in move together); gridTimes covers a longer scene and stays sorted; bar lines are a subset of beat lines; a 0.12-confidence grid still snaps and a grid alone does NOT make hasContent() true; toJSON → load → identical snapping; clearBeatGrid leaves plain scene JSON. Film block asserts filmRuntime equals the server's arithmetic on the shipped demo-two-shot (11.50s), plus the last-shot-dissolve and cut-transitionDur edge cases. node --check clean on all four files. SERVER-SIDE CHECKS (read-only against the running :8020, nothing restarted):

• validate_scene (server.py:235) inspects only version/entities/tracks/ cameraCuts — verified by calling it directly with a beatGrid scene (violations: []), so the new top-level key is legal, not merely tolerated.
• Full round-trip proven live: POST a scene carrying beatGrid → 200, GET it back → grid intact byte-for-byte. Test scene file deleted again (scenes/ holds the same four it did before). DECISIONS:
• Field shape — ONE top-level scene.beatGrid, not per-audio-clip: {path, bpm, confidence, meter, period, offset, beats[], downbeats[]}. A music video has one tempo, and "which grid am I snapping to" must have exactly one answer; per-clip grids would need a picker for a question nobody asks. beats/downbeats stay in FILE seconds exactly as Lane C returns them (so the stored grid is comparable with a re-fetch) and offset records where the file's t=0 sat. The EFFECTIVE offset is re-derived from the audio clip with the same path whenever one is still on the timeline — drag the audio block and the grid comes with it; delete the clip and the stored offset keeps it working.
• The grid extrapolates at constant tempo outside the analysed range, in BOTH gridTimes (drawing) and snapToGrid, so the lines you see and the snap you get agree everywhere. Without it, an 8s track under a 30s scene drags every late key back onto the last real beat — a trap, not a feature. Lane C's grid is explicitly constant-tempo, so this invents nothing.
• Low confidence warns, never refuses (Lane C: >0.5 solid, <0.2 mush). The UI toasts "LOW confidence (0.12) — this grid may be mush" at <0.35 and snaps anyway; the model has no opinion about confidence at all.
• The fetch + per-path cache live in tlui, like every other server call in this lane (/rhubarb, /templates, /assets/tree); timeline.js got the pure beatGridFrom instead, so the response→storage contract is testable headless without stubbing fetch for a three-line call.
• hasContent() deliberately ignores beatGrid: it is one button press to rebuild, so it is not work worth a confirm.
• film.js is imported lazily (_filmMod(), first 🎬 press) rather than at the top of tlui.js: the timeline must still mount if Lane C's client files are missing or broken, and nobody who never opens FILM should pay for render.js.
• filmRuntime(shots) is exported from tlui.js as a pure function so the number on screen can be pinned to the server's own formula in the node test — tlui.js touches no DOM at module scope, and the test's import('./tlui.js') now fails loudly the day that changes.
• Rename is save-then-delete (a failed save leaves the original untouched); the slug the server returns becomes the working name. BLOCKED/REQUESTS:
• Lane C / orchestrator (nice-to-have, not blocking): /beats on a DJ mix assumes one tempo for the whole hour — Lane C already has ?from=&to= windowing on its own backlog. When it lands I'd store one grid per window, or at minimum re-detect from the playhead; the current shape can grow a range:[from,to] field without breaking anything.
• Lane C (still open, third session running): nothing new — audio in/out at the mux is CLOSED as of C session 7, thanks.
• Orchestrator: PLAN §4.1 could gain the two fields now in live use — scene.beatGrid (shape above) and the already-shipped audio {in?, out?}. NEXT: nothing required. Backlog if a session 8 lands: (1) a "nudge to grid" action that re-snaps EXISTING keys/cuts to the nearest beat (today only new drags snap); (2) box-select still only grabs keys, not clip/audio blocks or cuts; (3) per-drag undo coalesce (a mousemove drag still pushes one undo entry per frame); (4) film-level audio[] has no UI — a sequence's soundtrack must still be edited by hand, and it is the obvious partner to beat-snapping.

2026-07-26 session 8 (M10-B: AUTO-CUT + align a film to the beat)

DONE: both, headless-verified. No git run (standing instruction) — timeline.js, tlui.js, timeline_test.mjs and this log edited in place. stagestub.js needed no change again. The running :8020 already serves the edits (checked with a read-only curl: /web/timeline.js carries autoCutPlan, nothing restarted).

M10-B1 — AUTO-CUT (timeline.js:635-700, UI tlui.js:823-910).

• cameraIds() (:635) — cameras in scene order, merged with any stage camera not yet mirrored (the same merge tlui's _rows uses).
• autoCutPlan(opts) (:647) — PURE preview: {ok, cuts, replaced, kept, cameras, cadence, barPeriod, confidence, bpm, from, to} or {ok:false,error}. Cuts come straight out of gridTimes('bar') (so a placed t IS a grid downbeat, not a rounded neighbour); bars.filter((_,i)=>i%cadence===0); cameras cycle cams[(i+phase)%n].
• autoCut(opts) (:687) — applies inside group() → ONE undo; throws the plan's error rather than half-applying; seek(time) so the new cut goes live.
• removeCut(cut) (:459) — new undo-able mutator (replacements had to be undoable too; tlui's right-click delete still splices directly, unchanged).
• UI: ✂ in the scene bar → popover with cadence (1/2/4/8 bars, default 2), range (whole scene | from the playhead), a checkbox per camera, and a live "will place N cuts · one every 3.75s" line that is literally autoCutPlan() — the previewed count and the applied count are the same call. Refusals render in that line in red with Apply disabled. Escape / click-outside close. The count re-runs on every tick, so scrubbing with "from the playhead" selected keeps it honest. TEST: node scenegod/web/timeline_test.mjs → green, +2 blocks (:498, :646). Auto-cut block asserts against the same real house128.wav payload: 8 downbeats in a 16s scene → cadence 1/2/4/8 gives 8/4/2/1 cuts; every placed t is === a member of gridTimes('bar'); 2 cameras strictly alternate A/B/A/B; 3 cameras cycle A/B/C/A/B/C/A/B; no camera lands twice in a row; ONE undo restores the exact prior cameraCuts (deepEqual against a pre-snapshot) and the stack grows by exactly 1; re-running replaces its own cuts (4 cuts stay 4, all t unique, same positions); a hand cut ON a downbeat is replaced, one BETWEEN downbeats is kept untouched and reported; no-grid and one-camera both throw with a clear message AND leave cameraCuts and the undo stack empty; an empty range refuses; the plan follows the audio when the block is dragged. Also run against the REAL scenes/music-video.json (4 cams, saved 128.02 BPM grid): cadence 2 → 1.416:cam2 5.165:cam3 8.915:cam4 12.664:cam1, undo restores the file's original two cuts exactly.

M10-B2 — align a film's shots to the beat (timeline.js:772-793 pure, tlui.js:1213-1252 panel). ♪ align button in the FILM head row.

• WHICH GRID: the open scene's if it has one, else the first shot scene (in shot order) with a saved beatGrid, fetched via scenes/{name}. The status line always names the source ("from the open scene "music-video"" / "from shot scene "x"") — "why did it snap there" must have a visible answer.
• alignShotsToGrid(shots, grid, off, durations) snaps each in/out to the nearest downbeat, never reorders, and returns {shots, skipped}. A shot that would collapse is returned BYTE-IDENTICAL and listed in skipped; the panel prints "left alone: #3 (would collapse)". Runtime redraws via _filmRows(); nothing is sent to the server until the user presses Save. TEST: order preserved, both boundaries land on real grid lines, out > in for every surviving shot, the collapsing shot is untouched + reported, the caller's array is not mutated, transitions ride along, aligning twice is a no-op, and an offset grid shifts the whole alignment. Verified against both shipped sequences with the music-video grid: demo-two-shot 0-4.5|4.5-8|0-4 becomes 1.4161-5.1654|5.1654-7.04|1.4161-3.2907, 0 skipped. DECISIONS:
• Pure grid helpers extracted (beatOffsetOf, beatPeriodOf, gridTimesOf, snapToGridWith, timeline.js:716-770); beatOffset/gridTimes/snapToGrid are now one-line delegates. B2 aligns shots of scenes that are NOT loaded — it has a grid and a shot list, no Timeline — and it must get bit-identical arithmetic to what the user saw while cutting. Behaviour unchanged: the whole M9 beat block still passes untouched.
• Replace ON a position, keep everything else. An existing cut within half a frame of a placed time is replaced (a duplicate 15ms away is a flash frame); cuts elsewhere in the range are the user's edit and are NOT deleted. But they interleave and one can repeat a camera, so the plan returns kept and the popover says "1 of your own cuts left in place between them". Disclosure beats either silently stuttering or silently deleting. Flip to "clear the range" if you'd rather, it's a one-line change — but I'd want John to ask.
• Phase offset so the run doesn't open on the camera already live. With "from the playhead", the last cut before the range is checked; if it holds cams[0] the cycle starts at cams[1]. Otherwise a beat-perfect run can still open with the same angle twice, which is the one thing a cut must never do. Verified live on music-video.json (cut at 0 = cam1 → run opens cam2).
• No cleverness, as instructed: no random order, no energy analysis, no variation. Every knob is on the popover and the output is ordinary cameraCuts the user hand-edits after.
• B2 clamps by walking back a whole bar and RE-SNAPPING (timeline.js:786), not by subtracting the bar period: Lane C rounds beats to 4dp and the period to 6dp, so b - bar lands 48µs off a real downbeat. "Lands on a downbeat" has to mean the real one, and the test asserts membership at 1e-6.
• autoCut THROWS on refusal instead of returning a flag: the caller already has autoCutPlan() to check, so a thrown error can't be ignored into a half-applied edit. The popover never lets you press Apply on a bad plan anyway.
• FILM align has no undo (the panel has none by design — the server doc is the state and Save is the gate); the status line says "Save to keep it". BLOCKED/REQUESTS:
• Orchestrator: PLAN §4.1 still doesn't list scene.beatGrid or audio {in?, out?}, both in live use since M9 (carried from last session).
• Lane C (nice-to-have): GET scenes returns {name, duration} but not whether a scene HAS a beatGrid. B2 has to fetch whole scene JSONs one at a time to find one. A hasGrid/bpm field on the list would make the FILM panel's grid hunt one request instead of N. NEXT: nothing required. Backlog if a session 9 lands, in order: (1) "nudge to grid" for EXISTING keys/cuts (today only new drags and auto-cut are musical); (2) box-select still only grabs keys, not clip/audio blocks or cuts; (3) per-drag undo coalesce (a mousemove drag still pushes one entry per frame); (4) film-level audio[] has no UI — the obvious partner to ♪ align.

2026-07-26 session 8b (SYNC13 follow-up: drop no-op kept cuts)

DONE: orchestrator's M10-B acceptance note actioned — a kept cut that selects the camera already live is now DROPPED, not preserved. autoCutPlan (timeline.js:668-690) no longer filters kept positionally; it merges the surviving existing cuts with the about-to-be-placed ones, sorts by t, walks the merged list tracking the EFFECTIVE camera, and splits in-range user cuts into kept (changes the angle) vs dropped (camera === eff — cuts cam2→cam2, i.e. nothing). autoCut (:704) removes dropped alongside replaced, inside the same group(), so it is still ONE undo. Popover line now reads "… · 2 of your cuts kept · 1 dropped (no camera change)"; the apply toast says which and why. Walking the MERGED list (not comparing to the previous array element) is the point: the duplicate only exists once the auto cuts are in — 4.5:cam2 is a perfectly good cut in the file as saved, and only becomes a no-op because auto-cut puts cam2 at 1.4161. TEST: +3 cases (timeline_test.mjs:566-598): a cut that changes the angle is kept (unchanged behaviour, still asserted), a cut duplicating the incoming auto camera is dropped and ONE undo restores it with everything else, and a mixed pair (2.0:camA redundant after the 1.4161 auto camA / 6.0:camA real after the 5.1654 auto camB) drops exactly one and keeps exactly one. Also asserts the final list has no consecutive camera repeat AT ALL, which is the property that was missing. Replayed the orchestrator's own case on scenes/music-video.json: file cuts 0:cam1, 4.5:cam2 → auto-cut cadence 2 → 0:cam1 1.42:cam2 5.17:cam3 8.91:cam4 12.66:cam1, the 4.5 no-op gone, no repeats, one undo byte-identical to the file. node scenegod/web/timeline_test.mjs green; node --check clean on all four. DECISIONS:

• The drop is limited to cuts INSIDE the placed range and only when the camera is genuinely unchanged. A user cut before the first or after the last placed cut is still never touched — auto-cut has no business outside its own range.
• Noted for whoever picks up ♪ align: the "name the grid source in the status line" pattern is endorsed by the orchestrator; shot lists can in principle span scenes with different grids, and saying which one was used is the honest answer rather than silently picking. Keep that pattern for anything similar. BLOCKED/REQUESTS: unchanged from session 8. NEXT: unchanged from session 8 (nudge-to-grid, box-select beyond keys, per-drag undo coalesce, film-level audio[] UI).

2026-07-26 session 9 (M11-B: land Lane A's camera moves on the timeline)

DONE: op:'move' is handled — the END now exists as a key instead of only in the event, so 🎬 move animates. Headless-verified; no git (standing instruction), no browser, :8020 untouched (read-only curl confirms it already serves the edits: /web/timeline.js carries applyMove/snapMove, /web/tlui.js the snap accessors). Files: timeline.js, tlui.js, timeline_test.mjs, this log. stagestub.js needed no change (the camera path only uses entityTransform/setTransform/setParam).

M11-B1 — the move handler (timeline.js:553-655).

• applyDirect (:505) early-returns into applyMove(d) — the existing shot/ light/mark branches are untouched, so nothing that worked yesterday moved.
• applyMove(d) (:573): one group() ⇒ ONE undo containing _clearMoveWindow → transform key at t0 (from) → transform key at t0+dur (to) → fov param keys at BOTH times → optional cut. ease (inout|linear, anything else → inout) goes on both keys of each pair; the FIRST is the load-bearing one (a segment reads its ease off its left key). scale comes from the live camera (cameras are 1) so a key is never partial.
• fov is keyed even when it doesn't change — required, not belt-and-braces: it is the only thing a zoom moves, and an unkeyed fov gets dragged around by whatever fov keys sit either side of the move.
• _clearMoveWindow (:615): transform keys and fov param keys inside [t0, t0+dur] (endpoints included, eps 1e-6) are deleted first and returned, so a second move over the same span REPLACES rather than interleaving into jitter, and the count is reported. Non-fov params in the window (a dof key) are left alone — a move owns position, aim and lens, nothing else.
• Toast (:603), e.g. 🎬 push in · 6.0s on cam2 · 2 transform + 2 fov keys · replaced 4 · snapped to bar. Refusals throw with a message and land in the existing _fail → toast path (no camera id / needs from/to camera states / needs a duration > 0); a half-applied move is impossible because the throw happens before the group.
• Returns {camId, t0, dur, ease, keys, replaced, snapped, live} — the toast is built from the same object the caller gets, so screen and report can't drift.

M11-B2 — moves on the beat (snapMove, timeline.js:639; UI seam tlui.js:145-153). Snap config now lives on the MODEL (tl.snap = {on, step}, timeline.js:94); tlui's _snapOn/_snapStep became accessors over it, so every existing read/write in the panel is unchanged and an op that arrives WITHOUT a mouse can snap exactly like a drag. With a grid loaded and snap = beat/bar, t0 snaps like everything else; on bar the END snaps to a downbeat too (walk back whole bars re-snapping each step if it would leave the scene — same trick as alignShotsToGrid). Guards: never dur <= 0, never t0+dur > duration, and if snapping can't satisfy both, the RAW Lane A numbers are returned untouched. snap = frame (the default) leaves moves exactly where Lane A put them. TEST: node scenegod/web/timeline_test.mjs → green, +2 blocks (:714, :830). Asserts: two transform keys at EXACTLY t0 and t0+dur carrying from/to (incl. rot), fov keyed at both times with the ease, a zoom producing two transform keys whose pos AND rot are deepEqual while fov differs (and a mid-zoom sample that doesn't drift a millimetre while fov reads 32.425 — strictly between the ends), a mid-move pose strictly between the two ends for a dolly (5.0 at the midpoint, and an early sample still up near the start for inout), ONE undo restoring the prior tracks deepEqual + the stack depth, a second move over the same window reporting replaced: 4 and leaving 2+2 keys sorted by t (not 4+4 interleaved), strays inside the window absorbed (6) while a key at t=12 and a dof param key survive, cut:true placing exactly one cut that comes off with the same undo, all three refusals throwing, and the snap block: bar → 1.4161 → 7.04 (both real downbeats), beat → t0 on a beat with dur untouched, snap off = off, plus the three guards near the end of the scene. Real material scenes/music-video.json (4 cams, saved 128.02 BPM grid), read from disk like the templates block: playhead 4.2 + bar snap → keys at 3.2907 and 8.9146 — both gridTimes('bar') members, exactly 3 bars apart — the file's two cameraCuts untouched, live reported as cam1, ONE undo deepEqual to the file. Also ran END-TO-END against Lane A's REAL solver in a scratch script (not committed — importing presets.js into my suite would make a Lane A break turn Lane B red): solveMove push_in/zoom_in/truck_L/orbit_L/crane_up → the exact event payload → keys → mid-pose. push in travels 0.496m with fov fixed; zoom in travels 0.000m with fov 37.85→26.99 (mid 32.42); truck 0.540m; orbit 0.698m; crane 0.663m. Lane A's presets_test.mjs, stage_test.mjs, room3d_test.mjs all still ALL PASS; node --check clean on all four files I touched. DECISIONS:

• No cut, per the orchestrator's call — but the silence is disclosed. Since nothing cuts to the moved camera, a move on a camera the edit never selects renders as nothing. cutCameraAt(t) (timeline.js:404, extracted from _evalCameraCuts so there is one definition of "which camera is live") lets the toast add "note: cam1 is live here — no cut selects this one". Disclosure, not a decision — same instinct as auto-cut's kept/dropped line.
• The cut IS available, as an explicit opt-in: cut: true on the payload adds addCut(t0, camId) inside the same undo. No default, no checkbox in my UI because the MOVE segment is Lane A's — see BLOCKED/REQUESTS.
• Double-clicking the Cameras row now cuts to the camera you are LOOKING THROUGH (tlui.js:597, stage.activeCamera() first, old cut-derived fallback kept). Without it the obvious "I moved cam2, now cut to it" gesture silently cut to the camera the OLD edit had live — the one mistake a cut must not make. This is the hand-affordance that makes "no automatic cut" liveable.
• t0 = d.t0 ?? this.time. Lane A offered "prefer your own playhead if they ever disagree", but index.html:62 wires window.timeline, so Lane A's _playhead() IS my playhead; honouring the field also keeps an explicit /director t0 working. If the wiring ever breaks, moves would pile up at 0 — that's the symptom to look for.
• Bar snaps the END, beat does not. A bar is where an edit lands; quantising every move length to ~0.47s would be noise, not music. Both snap t0.
• The playhead follows the snap (seek(t0)): the viewport then shows the move's real first frame (Lane A already put the camera on from), and "why did it land there" has a visible answer instead of a silent 0.6s shift.
• Endpoints are inside the replace window. Pressing the same move twice must land on its own keys, not beside them — addKey's same-t replacement would have covered the exact case, but not a key 3ms away from a re-snapped t0.
• ponytail (noted in code, :569): two keys ⇒ position LERPS, so an orbit travels the chord, not the arc. Measured 3.8cm short of the 1.611m radius at the midpoint of Lane A's ±25° default (invisible), 47cm on a 90° orbit (visible corner-cutting). Intermediate keys only if wide orbits are asked for. BLOCKED/REQUESTS:
• @Lane A (small): a cut checkbox in the MOVE segment of the DIRECT bar → put cut: true on the move payload. The model already honours it (one undo, cut at t0). Default OFF, per the orchestrator's call.
• @Lane A (nice-to-have): moveDuration() caps at MOVE_MAX_DUR 6s; a bar-snapped end can extend a move up to half a bar past that (max ~+0.94s at 128 BPM) so it lands on a downbeat. The hard clamp (never past scene.duration) is re-applied here at the snapped start. Say if 6s is meant to be a hard ceiling and I'll clamp the snap down a bar instead of up.
• @orchestrator: PLAN §4.1 still doesn't list scene.beatGrid or audio {in?, out?} (carried from sessions 7-8). Nothing new needed for moves — they are ordinary transform/params keys, exactly as Lane A predicted. NEXT: nothing required. Backlog, in order: (1) "nudge to grid" for EXISTING keys/cuts (moves and new drags are musical, old keys still aren't); (2) a move is only editable as two keys — dragging the pair together (or a "move block" overlay on the transform lane) is the obvious next UX step; (3) box-select still only grabs keys, not clip/audio blocks or cuts; (4) per-drag undo coalesce; (5) film-level audio[] has no UI.

2026-07-28 session 10 (make the app usable: render button, save truth, cut model, outliner)

DONE: all five items. No git (standing instruction), no browser (instructed), :8020 untouched — read-only curl confirms it already serves the edits (/web/tlui.js carries renderPlan/syncFromStage). Files: timeline.js, tlui.js, stagestub.js, timeline_test.mjs, this log.

1 — ⏺ Render in the scene bar (tlui.js:214-220 bar markup, render() at tlui.js:1414, pure renderPlan(tl, sizeStr) at tlui.js:113). finalRender() had ZERO callers; the only render control was inside the collapsed 🎬 panel (needs Save → New… sequence → + shot, renders SILENT, clobbers the open scene). Now: size select (verbatim copy of the FILM head's three options) + ⏺ Render → pause + remember tl.time → lazy import('./render.js') (same shape as _filmMod()) → finalRender(stage, tl, {...renderPlan(size), onProgress}). Button reads rendering 41/600 while it runs, both controls disabled, _rendering refuses a second click; success puts a persistent relative <a target=_blank rel=noopener> in .rstat AND toasts; failure toasts _errText(e); finally re-enables and seek(saved). Chrome hiding untouched — Lane C moved it INTO captureFrames (render.js:76, stage.pause?.()) mid-session, so it now happens for free on this path too. renderPlan throws too long: N frames (max 20000) (server.py:439's cap) and falls back to 1920×1080 on an unparseable size.

2 — save the stage you actually built (Timeline.syncFromStage() timeline.js:175, called at the top of tlui.save() tlui.js:1456). _mirror copies transform+params ONCE and early-returns forever (timeline.js:145), so a prop dragged into place, a key light dialled to 0.8 and a backdrop's fitDist all reverted to their drop-time values on save/reload; Stage.captureState() (stage.js:682), which exists for exactly this, had zero callers. Merge takes ONLY transform and params (structuredClone), never adds, never removes, never touches tracks — the stub's captureState clones whole entities INCLUDING tracks, so a naive merge would have overwritten live keys with a stale copy. params.fit === 'frustum' backdrops keep their authored transform (that wrapper is the lens's, stage.js:485) and take their params.

3 — save/load stop lying (tlui.js:1450-1560, pure uploadEntities/saveMessage at tlui.js:133/145). A 422 from validate_scene used to be indistinguishable from success (silent localStorage write), and since load() prefers the server copy the next Load restored the last good version and ate everything since. Now the response is awaited: !res.ok → console.error + toast NOT saved — <server's own errors> and NO localStorage; only a thrown fetch falls back, toasting server unreachable — kept a local copy in this browser only; success toasts saved "name" · N entities. Upload entities are collected and confirmed before the POST (PLAN.md:72-73, never built). Load is now a tl-menu popover of GET scenes (name · duration · mtime), gated on hasContent() → confirm like the other two clobbering actions, with applyScene wrapped in try/catch so one missing clip can't kill _decodeAll() and leave the audio row dead.

4 — cameras go live at a cut (timeline.js:156-163, addCut :527, moveCut :549, _evalCameraCuts :471, tlui.js _drawCuts/_ctx/_move). (a) _mirror gives the FIRST camera in a cutless scene a cut at 0 + a toast — dock _addRig sets it active for the PiP and the very next evaluate used to snap the view back to the orbit cam. Guarded by tl._applying (set around stage.applyState in applyScene) so scene loads don't toast. (b) addCut REPLACES any cut within half a frame (autoCutPlan's own rule), in one undo entry — three "+ angle"s at the playhead used to stack three overprinted cuts, two of them dead. (c) the Cameras lane prints the camera's LABEL (was the raw id, so it read e3 e5 e7 next to a names column saying cam2 / cam3). (d) right-click delete routes through tl.removeCut and the drag through the new tl.moveCut — both were raw mutations, so Ctrl+Z after either reverted an unrelated earlier keyframe. (e) _evalCameraCuts compares against stage.activeCamera() (added to stagestub) so nothing can desync the cached value permanently.

5 — the names column is the outliner (tlui.js _syncRows, _stageChanged, _markSel, CSS block; pure rowFlags(entity) at tlui.js:157). Every row with an entity gets .pick, a title, onclick → stage.select(id) (guarded by getEntity) and a .sel left-border highlight driven by stage.onSelect. This is the ONLY way to reach an ambient light: its wrapper holds a HemisphereLight with no geometry, so Stage._pick can never hit it, and every DIRECT lighting preset creates one (intensity/colour/bg/fog were devtools-only). Rows whose entity has ≥1 transform key carry a ⏺ glyph, and stage.onChange (gizmo mouseUp, stage.js:116 — never from setTransform, so no feedback loop) toasts that the pose will revert on the next scrub. No auto-keying.

TEST: node scenegod/web/timeline_test.mjs → OK — all assertions passed; node --check clean on timeline.js, tlui.js, stagestub.js, timeline_test.mjs; Lane A's presets_test.mjs / stage_test.mjs / room3d_test.mjs all still ALL PASS. New blocks: renderPlan (1280x720 → 1280/720, garbage → 1080p, 1920×1080 glyph form, 20s@30 → 600, audio passed through incl. gain, empty scene renders, 700s@30 throws with 'max 20000' AND '21000 frames'); syncFromStage (gizmo pos [-3,0,1] and fov 28 land in toJSON(), e1 keeps BOTH original keys and its clip block, the frustum plate takes fitDist: 20 but keeps its transform byte-identical, an entity unknown to the model is skipped not adopted, synced scene still round-trips); uploadEntities/saveMessage (all four message cases); the cut model (0.01s replace at 30fps → length stays 1 / camera c2, 1.0s appends, undo restores the replaced cut, removeCut+moveCut undo, and a seek re-asserting the cut camera after an out-of-band setActiveCamera); rowFlags. Three EXISTING blocks were adapted, not deleted, because behaviour changed on purpose: the DIRECT block now asserts the auto first cut (timeline_test.mjs:237-244) and that a second camera adds none; the MOVE block removes that cut explicitly to test moves in isolation; the 3-camera auto-cut case asserts + removes it. Each adaptation FAILED first on the new code and was checked, not silenced. DECISIONS:

• _evalCameraCuts does NOT use ?? this._activeCam as the brief wrote it: a stage sitting on the director cam reports null, and null ?? staleId would fall back to the stale id — reintroducing the exact desync the change fixes. It prefers the stage's answer whenever the accessor exists, keeping _activeCam only as the fallback for a Stage that predates it.
• Known consequence of that: adding a SECOND camera (dock sets it active for the PiP) now loses the preview at the next scrub, because the edit still cuts to the first. That is the intended "the edit wins" reading, and the M11 gesture (double-click the Cameras row = cut to the camera you're looking through) is the documented way to make it stick. Flagging it because it is a visible behaviour change.
• _applying flag rather than the brief's stage.getEntity() guard: during applyScene the entity IS on the stage, so that guard can't tell a load from a live add. The flag also silences the "is keyed" toast during a load. film.js's per-shot applyScene gets it for free.
• Toast wording: press ⏺ key in the inspector, or double-click its lane — the brief's bare "⏺" now collides with the new ⏺ Render button in the scene bar.
• stagestub honesty (two fixes): select() now hands listeners the ENTITY, not the id (real Stage: stage.js:458 — an outliner reading en.id would have passed here and broken live), and activeCamera() was added to match stage.js:587.
• saveMessage treats absent status as the network case — that is the only state where no response exists, so the local-copy claim can't be made by mistake.
• renderPlan returns total (unused by finalRender, which recomputes it) so the refusal and the count on screen come from one place. BLOCKED/REQUESTS:
• @orchestrator — browser verification owed for item 5. I am instructed not to use browser tools this session, so the click/highlight/toast behaviour of the outliner is headless-verified only (rowFlags + code review). Please check live: click a names row → the stage selects it and the row grows a blue left border; add an ambient light via a DIRECT lighting preset and confirm its row is now reachable; drag a KEYED entity with W and confirm the toast; and that ⏺ Render produces an mp4 with audio.
• @orchestrator: PLAN §4.1 still doesn't list scene.beatGrid or audio {in?, out?} (carried from sessions 7-9).
• @Lane C (nit): GET scenes gives {name, mtime, duration} — the Load picker shows all three. Nothing needed unless you want a scene's entity count in the list. NEXT: nothing required. Backlog unchanged and still in order: (1) "nudge to grid" for EXISTING keys/cuts; (2) a camera move is only editable as two keys — dragging the pair together; (3) box-select still only grabs keys, not clip/audio blocks or cuts; (4) per-drag undo coalesce (a mousemove drag still pushes one entry per frame — now true of moveCut too); (5) film-level audio[] has no UI.

2026-07-28 session 11 (adversarial review of session 10 — 4 majors + 4 minors)

DONE: every blocker/major from the reviewer's verdict, plus all four minors. Each was REPRODUCED headlessly first (scratch node scripts, not in the repo), fixed at the root, and given a regression test that was checked RED against the old behaviour and green after. No git, no browser, :8020 untouched (read-only curl confirms it already serves the edits — /web/tlui.js carries renderRefusal/cutAction).

BLOCKER — syncFromStage() rewrote the AUTHORED rest pose of keyed entities (timeline.js, the syncFromStage() body). Repro: e1 keyed [0,0,0]@0 → [5,0,0]@5, sun intensity keyed 0→8; scrub to 5 + save → rest becomes [5,0,0]/8; scrub to 2.5 + save → [2.5,0,0]/4. Root cause: Stage.captureState() returns entityTransform(id), i.e. the pose the TIMELINE just wrote through setTransform/setParam on the last evaluate — so the merge copied the timeline's own output back over the source of truth, and PLAN §4.1's "rest pose (used when no keys)" plus save idempotence both died. FIX: the sync is now per CHANNEL — an entity with ≥1 transform key keeps its authored transform; a param NAME that appears in tracks.params keeps its authored value while every other param on the same entity still syncs. Unkeyed props/lights/plates are unchanged (that was the point of session 10's item 2 and it still works). MAJOR — no way to cut to a second camera from the timeline (tlui.js _dbl → new _cutPick/_cutTo, pure cutAction()). Repro: add cam1 (auto cut at 0), add cam2 (dock sets it active), seek(1.0) → stage.activeCamera() is back to cam1, so the M11 gesture appended {t:4, camera:'cam1'} — a literal no-op cut, the artefact the M10 amendment asked to be dropped. Root cause: the gesture read stage.activeCamera(), but _evalCameraCuts drives that value at every seek, so it can only ever echo the edit. FIX: the row ASKS. _cutPick opens a tl-menu of the scene's cameras (the one live at t marked "(live here)"), one camera = no menu, none = a toast. _cutTo routes through pure cutAction(cuts, t, camId, fps) → add | replace (addCut's half-frame rule) | remove (a cut here that changes nothing is deleted rather than re-stacked) | noop (says so). _evalCameraCuts itself is unchanged — "the edit wins" is still the model; there is now an honest way to author the edit. The dock's ◉ preview is still transient by design. MAJOR — ⏺ Render and 🎬 Render film were not mutually exclusive (tlui.js renderRefusal(), render(), _filmRender(), _filmBusySet(), new _busy()/ _barBusySet()). Repro (fake this, no DOM): with _filmBusy true, render() reached the plan; with _rendering true, _filmRender() reached the save+render. Two capture loops on one timeline.step(), and whichever finished first called stage.resume() and un-hid the gizmo for the rest of the other one's frames (SYNC7, again). FIX: one gate both entry points consult, plus the whole scene bar goes dead during EITHER render (Save, New…, Load, ▶ and the size select), _toggle/_down/_dbl/_ctx/_key refuse while busy (? and Escape still work), and _rendering is claimed BEFORE the first await so two fast clicks can't both pass. MAJOR — the cut lane's camera label was invisible (tlui.js: exported LANE_BG, CUT_COLOR, LABEL_COLOR, used by draw() and _drawCuts). It was painted in #161a20 — the odd lane's own fill (1.00:1), #13171d on the even one (1.03:1). So session 10's claim "the lane prints the camera's LABEL" was not observable. FIX: the label is the cut's own amber #e0af68; the colours are exported constants so the fill and the text can't drift apart again, and the test holds them to ≥3:1 WCAG contrast against BOTH lane fills. MINOR — moveCut had no half-frame rule and one undo entry per mousemove (timeline.js settleCut() + collapseUndo(), wired in tlui.js _down/_up). Repro: 50 synthetic mousemoves left 50 undo entries and two cuts 4e-16s apart, one of which cutCameraAt can never reach. FIX: _down marks the undo depth, _up settles the dropped cut (absorbing anything inside half a frame, reported in a toast) and collapses the whole drag to ONE entry — which also closes backlog item (4) for keys, blocks and audio drags. group() now delegates to collapseUndo, one definition of the collapse. MINOR — save() reported a filename the server did not use (tlui.js save()). Repro: POST scenes/My%20Scene → server writes my-scene.json, answers {"name": "my-scene"}, toast said saved "My Scene". FIX: the stem from the response body is what the toast reports, and it is written back into the name field + scene.name, so the bar matches the Load picker and the next save writes the same file. MINOR — audio was validated only after every PNG had been uploaded (tlui.js pure audioProblems() + _audioMissing(), called by render()). FIX: everything resolve_audio refuses without the filesystem (missing/non-string path, non-numeric start/gain/in/out, negative start/in, out ≤ in) is refused client-side like the frame cap, and a HEAD per distinct path against assets/file?path= catches a moved/deleted file before frame 1. Fails OPEN on a network error — the server keeps the last word. MINOR — stale file:line pointers in comments: every cross-lane citation in my files now names a SYMBOL instead of a line (stage.js setTransform, stage.js select(), server.py render_frame, server.py validate_scene, PLAN §4.1). Lines drift when another lane edits; symbols don't. Same rule applied to this log entry. TEST: node scenegod/web/timeline_test.mjs → OK — all assertions passed (exit 0); node --check clean on timeline.js / tlui.js / stagestub.js / timeline_test.mjs; Lane A's presets_test / stage_test / room3d_test and Lane C's scripts/test_render_client.mjs all still pass. New/changed blocks: playhead-independent save (two saves at different times byte-identical, keyed transform + keyed param preserved, unkeyed colour on the same light still synced); the syncFromStage block was RE-POINTED at a new unkeyed crate prop — the old assertion "the gizmo pose is what gets saved" was made on e1, which HAS two keys, i.e. the suite encoded the bug as intended behaviour; renderRefusal + both wiring directions through the prototype + _filmBusySet taking the bar out; audioProblems (8 cases) + the two refusal wirings incl. the gate being released; cutAction (8 branches), _cutTo end-to-end after a scrub, _cutPick's one-camera and no-camera branches; the contrast check; settleCut/collapseUndo + the _up drag it exists for. DISCRIMINATION PROVEN — each fix was temporarily reverted and the suite went red on the intended assertion: rest-pose sync → "a keyed entity keeps the AUTHORED rest pose"; keyed-param sync → "two saves … byte-identical"; render gate → "⏺ Render never even plans while a film render runs"; bar lockout → "a film render disables the whole scene bar"; audio pre-flight → "the render must not start"; _cutTo guard → "asking for the camera already live adds NO dead cut"; label colour → "must read against lane fill #13171d (got 1.03:1)"; settleCut/collapseUndo → "head trim is a single undo entry" (an EXISTING assertion, via group()); _up wiring → "mouseup settles the dropped cut"; save name → "the toast names the file the server actually wrote". All restored green afterwards. DECISIONS:

• Per-channel, not per-entity, sync. Skipping a whole entity that has any keys would have thrown away the unkeyed inspector edits on the same object (a keyed light's colour, a keyed camera's non-animated params). The keyed CHANNEL is the thing the timeline owns.
• A keyed param with no authored rest value is DELETED from params, not frozen at the live lerp. Freezing would invent a rest value the user never typed; deleting keeps the file honest and the key still drives it at evaluate time.
• Ask, don't guess, for the cut camera. Any "smart" reading of intent here is a guess about which camera the director means; the menu is one extra click and can't be wrong. The remove branch exists because a cut that changes nothing is not an edit.
• The bar dies during a render, the canvas gate is separate. Disabling DOM controls can't stop Space or a canvas drag, so _busy() guards the handlers as well.
• The audio existence check fails OPEN. A wobbling network must never block a render that would have worked; the server still validates.
• Colours are exported constants. The bug was a literal duplicated between the fill and the text; the test asserts a contrast ratio, not a hex, so a future palette change is free but an invisible one is not. BLOCKED/REQUESTS:
• @orchestrator — browser verification still owed (same as session 10, plus this round): the Cameras-row picker (double-click with 2+ cameras → menu → cut lands and the label is now READABLE amber), ⏺ Render and 🎬 Render film refusing each other with the scene bar greyed out, and the outliner items from session 10. All headless here.
• @orchestrator — logs/laneB.md session 10 claims "double-click the Cameras row is the documented way to make [a second camera] stick". That was wrong after any scrub; this session replaces it with the picker. Flagging it since the log is append-only.
• @orchestrator — PLAN §4.1 still doesn't list scene.beatGrid or audio {in?, out?} (carried from sessions 7-10). NEXT: nothing required. Backlog: (1) "nudge to grid" for EXISTING keys/cuts; (2) a camera move is only editable as two keys — dragging the pair together; (3) box-select still only grabs keys, not clip/audio blocks or cuts; (4) film-level audio[] has no UI; (5) the _cutPick menu is the only untested-by-node path in the new work (needs DOM) — worth a look at SYNC.

2026-07-28 session 12 (round-2 adversarial review — 2 majors + 6 minors)

DONE: both remaining MAJORs and ALL SIX remaining minors. Every one was REPRODUCED first — the two majors against a real uvicorn I started on port 8097 (my own, killed afterwards; :8020 never touched, read-only curl confirms it already serves these edits) and headless node repros in scratch, none in the repo. No git, no browser.

MAJOR — the audio existence pre-flight could never fire (tlui.js _audioMissing). REPRO, live, against this repo's server.py: HEAD /assets/file?path=audio/test/vo.wav → 405, allow: GET; HEAD …nope.wav → 405; GET → 404; the previous implementation run verbatim against that server returned [] for a file that does not exist. ROOT CAUSE: FastAPI's APIRoute registers ONLY the methods you decorate — unlike starlette's own Route it does not add HEAD to a GET route — so @app.get("/assets/file") answers every HEAD with 405 and r.status === 404 was unreachable. The session-11 claim "a HEAD per distinct path catches a moved/deleted file" was false in production. FIX: a real GET with Range: bytes=0-0 — the method the route answers — and the body is cancelled instead of streamed, so proving a 40MB stem exists costs one byte (measured: 206, content-length 1). Still fails OPEN. Same function against the live server now returns ['audio/nope.wav'] and passes the file that is there. MAJOR — the render mutex still raced (tlui.js _filmRender, render). REPRO (scratchpad, both real prototypes on a fake this, _filmSave held open): 🎬 ran its gate, awaited the save, and during that round-trip _rendering/ _filmBusy were both false and the bar was live — a ⏺ click passed renderRefusal, called tl.pause() and started capturing; the film then set its flag and started a second capture on the same clock. ROOT CAUSE: the flag was claimed two awaits late. FIX: _filmBusySet(true) is now claimed SYNCHRONOUSLY before the first await and released in a finally that covers every exit (including "the save failed", which used to return with the gate held in the new shape); _filmRender's gate now reads BOTH flags through renderRefusal and says which render is in the way instead of returning silently; render()'s release moved out of a hand-written early-return into the same finally, and its two synchronous reads (tl.time, the button label) now happen BEFORE the claim so a throw there cannot strand a permanently-"rendering" app. MINOR — the saved FILE still carried the un-slugged name (tlui.js save). REPRO live: POST scenes/My%20Scene → {"name":"my-scene"} and my-scene.json containing "name": "My Scene" (server.py scene_save stores the body verbatim), so every Load put the mismatch back. FIX: when the server's stem differs from what we sent, the stem goes into the model/field AND one corrective re-POST rewrites the file. Idempotent (slugify(slug) === slug) so it converges in exactly one extra request, and only when the name needed slugging. Verified live: bar, picker and stored name all read round-two-scene. MINOR — a keyed param with no authored rest value was DELETED, and an inspector edit to one vanished in silence (timeline.js syncFromStage, _evalParams). FIX (reverses last session's DECISION, which was wrong): the rest value falls back to the FIRST KEY's value — that is exactly what evaluate holds for t before it, so it is authored, playhead-independent and invents nothing, and a keyed camera no longer saves with no fov in params at all. For the silence: _evalParams now records what the timeline itself last wrote per id::key (_drove), so syncFromStage can tell its own lerp (say nothing) from a human's inspector edit (say that it will not stick, and where to key it). dock.js _param calls syncFromStage directly, so this is the exact line where the edit dies. MINOR — cutAction could MANUFACTURE the dead cut it exists to prevent (tlui.js cutAction, _cutTo). REPRO: cuts [{0,cam1},{4,cam2}], cut at 0 to cam2 → 'replace' → [{0,cam2},{4,cam2}]; it only ever looked BEFORE t. FIX: after every branch the effective camera from t onward is camId, so the next cut is dead iff it names camId — reported as dead, but only when it was a real angle change BEFORE the edit (wasEff), so a pre-existing dead cut is left alone rather than silently deleted. _cutTo drops it inside ONE group() with the cut itself and names it in the toast. Same rule now covers add/replace/remove. MINOR — the camera picker was invisible to Escape and leaked its listener (tlui.js _cutPick, new _pickClose, _key). The menu was a local const; _cutMenuClose closes this._cutMenu, the ✂ AUTO-CUT panel — a different menu. FIX: tracked on this, one close path that also removes the document mousedown listener, Escape wired to it, and opening a second picker closes the first. MINOR — two claimed wirings were asserted nowhere (_undoMark in _down, the _busy() gates). FIX: the drag test now goes through the REAL _down instead of hand-setting _undoMark, so deleting that line takes the "one undo entry per drag" assertion down with it; _down/_dbl/_ctx are called with a _local that throws. MINOR — director/clip-drop events mutated the scene mid-capture (timeline.js new _locked, tlui.js _barBusySet). _barBusySet can only disable controls inside $bar; Lane A's DIRECT panel and the dock dispatch window events straight at timeline.js. FIX: _barBusySet — the one choke point BOTH render paths go through — sets tl.locked, and scenegod:direct, scenegod:clipdrop and scenegod:capturekey refuse (out loud) while it is set. TEST: node scenegod/web/timeline_test.mjs → OK — all assertions passed (exit 0); node --check clean on timeline.js / tlui.js / stagestub.js / timeline_test.mjs; Lane A's presets/room3d/stage tests and Lane C's test_render_client.mjs still pass. DISCRIMINATION PROVEN, mechanically: scratchpad/rr2/discriminate.py copies web/ + templates/ + scenes/ to a scratch tree, breaks ONE fix at a time (17 of them) and runs the suite. Baseline GREEN → all 17 RED on the intended assertion → restored GREEN. e.g. HEAD restored → "a moved/deleted audio file is actually DETECTED"; claim moved back after the save → "the film claims the gate BEFORE its first await"; dead forced null → "the 4s cut is now dead and is named"; _undoMark line deleted → "mousedown marks the undo depth"; delete next[k] restored → "an unauthored keyed param rests at its FIRST key". DECISIONS:

• A one-byte ranged GET, not "drop the pre-flight". The check is worth keeping (a moved VO otherwise costs a whole render), it just has to speak a method the route answers. Asking for bytes=0-0 and cancelling the body keeps it as cheap as the HEAD was meant to be.
• Claim synchronously, release in finally. Every "reset the flag on this early-return" line is a future leak; there is now exactly one release per render path and no exit that skips it.
• The first key is the rest value. Last session I argued deletion "keeps the file honest" — it doesn't, it drops the only fallback the entity has if the keys are later removed. The first key is authored data and does not move with the playhead, which was the actual property worth protecting.
• Only drop a dead cut MY edit killed. Cleaning up cuts that were already redundant would be deleting something the user never asked me to touch.
• locked lives on the model. DOM disabling stops at $bar; anything that can mutate the scene from outside it has to be able to ask. BLOCKED/REQUESTS:
• @orchestrator — browser verification still owed (carried from sessions 10-11, plus this round): the Cameras-row picker closing on Escape and dropping a dead following cut; ⏺ vs 🎬 refusing each other with the bar greyed; a DIRECT preset clicked mid-render toasting instead of keying; a render refused up front when an audio file has been moved.
• @Lane C (nit, not a blocker): @app.get("/assets/file") 405s on HEAD. My check no longer needs it, but a plain @app.head (or methods=["GET","HEAD"]) would be the conventional shape for a static-file route if you ever want it.
• @orchestrator — PLAN §4.1 still doesn't list scene.beatGrid or audio {in?, out?} (carried from sessions 7-11). NEXT: nothing required. Backlog: (1) "nudge to grid" for EXISTING keys/cuts; (2) a camera move is only editable as two keys — dragging the pair together; (3) box-select still only grabs keys, not clip/audio blocks or cuts; (4) film-level audio[] has no UI.