@erclx/canon 5.76.0 → 5.78.0

package/claude/skills/ui-craft/references/capture.md

@@ -9,8 +9,24 @@
 
 - Run the project's capture command against a preview server, never a dev server, after changing a surface. Report a project with none.
 - Capture every theme the surface ships, and again after fixing a defect found.
+- Add a case for every rendered state the change adds or alters, on a new surface or an already captured one. Proof is the default.
+- Count a focus ring, an outline, a toast, a tooltip, a size change from server-written markup, and a state reachable only by interaction as visible states.
 - Read your capture against the `canon:ui-checklist` boxes before opening the pull request, reporting a skill that does not resolve.
 
+### The exemption
+
+Only a change with no visible result in any reachable state is exempt, such as a keyboard order that moves no ring. A capture costs one command and a missing one costs a review round, so the worker never judges the exemption alone.
+
+- State it in the pull request body as a line naming the path and why nothing shows.
+- A reviewer accepts it by writing a ``- **Waived capture:** `<path>`: <reason>`` line in a review.
+- A painted path with neither a case nor that line keeps the pull request in draft.
+
+## When the fixture cannot reach a state
+
+- Extend the drive fixture in the same branch when a box or a case needs a state it lacks, and commit the added state under a path the fixture declares, since the throwaway copy wipes anything else.
+- Never record the missing state as a skip, since the next pull request meets the same fixture and skips again.
+- State the setup inline when the project has no `canon/config/app-drive.toml`, since the drive there starts from the served root and a fixture file is not owed.
+
 ## What a capture covers
 
 - Capture the full page, never a component in isolation.

package/claude/skills/ui-film/REQUIREMENT.md

@@ -14,14 +14,14 @@ A session that does reach `canon take` writes the plan from its own reading of t
 ## Must
 
 - The operator approves the beats in plain words before anything is filmed
-- Each beat films one action from a fresh start state, with a hold before and after it
+- Each beat films one action from a fresh start state, with a hold before and after it, and a harness beat has its known faults named before it films
 - Every take carries its clip, its click log, and its camera track, and no clip carries a drawn cursor
 - The session looks at a still of each take before handing it off, and names a beat that fell back to the real-time route
 - HyperFrames receives the takes with what it needs to apply the camera and draw the cursor
 
 One video keeps its plan, takes, and composition in one workspace the operator can find, backed up without its media. A README there records how to re-film the takes, and the composing session adds how to re-render. It keeps what a re-film and a re-render need and clears the rest.
 
-A session composing the takes finds the footage guidance HyperFrames lacks, being captions over app UI, other shapes, a README loop, and sped-up clips. A machine without HyperFrames keeps its takes and stops at the handoff naming the install, which the session never runs itself.
+A session composing the takes finds the footage guidance HyperFrames lacks, being captions over app UI, other shapes, a README loop, sped-up clips, pacing, transitions, and the review of a cut's motion. A machine without HyperFrames keeps its takes and stops at the handoff naming the install, which the session never runs itself.
 
 ## Must not
 

package/claude/skills/ui-film/SKILL.md

@@ -59,6 +59,8 @@ Wait for the operator's approval or edits before Step 3. Read silence as no appr
 
 Read `${CLAUDE_SKILL_DIR}/references/take-craft.md` before writing the first beat. It holds the filming rules and the plan's step kinds.
 
+Read `${CLAUDE_SKILL_DIR}/references/harness.md` beside it when a beat takes the harness route, since a harness fault films as a flaky take and a refilm on a guess repeats it.
+
 - Write one beat per approved line to `.canon/video/<slug>/plan.json`, named as the operator approved it
 - Find each target on the served page before writing it, through `canon browser` or the source, rather than guessing a selector
 
@@ -101,7 +103,10 @@ Check that the `hyperframes` skill resolves before handing anything to it, as `h
 ❌ HyperFrames is not installed, so nothing can compose .canon/video/<slug>/takes/. Run /plugin install canon-media@canon, or install hyperframes@hyperframes alone, then load hyperframes to compose.
 ```
 
-Read `${CLAUDE_SKILL_DIR}/references/handoff.md` on reaching this step, for what HyperFrames receives, where each composition lives, and how one applies the camera track and draws the cursor. Read `${CLAUDE_SKILL_DIR}/references/compose-craft.md` beside it, for the footage rules the HyperFrames skills lack.
+Read `${CLAUDE_SKILL_DIR}/references/handoff.md` on reaching this step, for what HyperFrames receives, where each composition lives, and how one applies the camera track and draws the cursor.
+
+- Read `${CLAUDE_SKILL_DIR}/references/compose-craft.md` beside it, for the footage rules the HyperFrames skills lack
+- Hold each cut to its motion review before the operator sees it, since a still at a beat's midpoint passes a cut whose motion is wrong
 
 Close the throwaway copy per `isolate.md` when Step 1 built one, after the stills are read.
 

package/claude/skills/ui-film/references/compose-craft.md

@@ -1,6 +1,6 @@
 ---
 title: Compose craft
-description: The footage rules a session composing ui-film takes follows where the HyperFrames skills say nothing, being captions over app UI, other shapes, the README loop, sped-up clips, storyboard headings, and the workspace README
+description: The footage rules a session composing ui-film takes follows where the HyperFrames skills say nothing, being captions over app UI, other shapes, the README loop, pacing, sped-up clips, transitions, reviewing a cut, music, storyboard headings, and the workspace README
 ---
 
 # Compose craft
@@ -14,7 +14,11 @@ Each rule states the principle. Where a number appears, it is the case measured
 - [Captions over app footage](#captions-over-app-footage)
 - [Other shapes](#other-shapes)
 - [The README loop](#the-readme-loop)
+- [Pacing](#pacing)
 - [Sped-up clips](#sped-up-clips)
+- [Transitions](#transitions)
+- [Reviewing a cut](#reviewing-a-cut)
+- [Music](#music)
 - [Storyboard headings](#storyboard-headings)
 - [The workspace README](#the-workspace-readme)
 - [Sources](#sources)
@@ -46,14 +50,56 @@ Cut a README loop only when the operator asks for one. A README hero plays inlin
 - End it on the finished state, held long enough to read before the loop restarts
 - Export an animated WebP under about 2 MB, since a README renders one inline where a video needs a player. Frameboard's loop played inline at 1.72 MB.
 
+## Pacing
+
+A cut paced at one rate throughout reads rushed where the viewer reads and slow where an agent works. Frameboard's launch film read rushed with hand actions at 1.25x to 1.42x, read slow at about 1x everywhere, and landed at about 78 s with the rates split by beat kind.
+
+### Rates by beat kind
+
+Set each beat's playback rate by what the viewer does during it.
+
+- Play an agent replay montage faster than a hand action, since the viewer follows its result rather than each step. Frameboard's ran up to about 2x.
+- Play hand actions and anything read near real time, as Frameboard's did at about 1.0x to 1.2x
+- Hold a typing beat to the rate `## Sped-up clips` gives, whatever rate the rest of its scene takes
+
+### Holds
+
+Every result and every line of text holds still long enough to land before the cut.
+
+- Hold each result on screen before the cut, such as a recolored button or an agent's reply. About 1 to 2 s fit Frameboard's film.
+- Hold text by its length, with HyperFrames' `line_unread` warning as the floor. One short terminal line fit at about 1.5 s on Frameboard's film, where 0.75 s was missed and 2.9 s dragged.
+- Pause after a mode switch, such as arming a tool, before the next action, or the switch does not register. About 1 s fit Frameboard's film.
+
+### Windows from marks
+
+Read each scene's window off the take's `log.json`, from its first event less a lead to its last result plus that result's hold, then set the rate from the scene's length. Reusing an old cut's offsets against a new take lands the camera on moments that moved.
+
 ## Sped-up clips
 
 A clip the edit plays faster runs its zoom faster too, so a push that settled in real time pumps several times a beat.
 
 - Rebuild the beat's track for the playback rate with `canon take camera <dir>/log.json --rate <n> --out <file>`, and drive the wrapper from that file rather than from `camera.json`
-- Never scale `camera.json`'s times by hand, since the rebuilt track also keeps each push inside the 1 s ceiling at the new speed
+- Never scale `camera.json`'s times by hand, since the rebuilt track also times each push to its glide on the new clock
 - Keep a typing beat at a rate where each word still reads, since a viewer cannot read a fill that finishes in a few frames
 
+## Transitions
+
+HyperFrames owns transitions in general. App footage changes one thing, since only canon's camera zooms the footage under a dissolve.
+
+- Settle a zoomed scene back to the whole page before a dissolve into another shot of the same app, so the dissolve blends two matching wide shots rather than ghosting one app at two scales
+- Ease the camera wrapper out over the scene's last stretch rather than cutting its scale, as Frameboard's film did over about 0.8 s ahead of a 0.45 s dissolve
+
+## Reviewing a cut
+
+Stills at beat midpoints pass a cut whose motion is wrong, as they passed every cut on Frameboard's film that the operator then rejected for its motion. Review motion before showing the cut, beside the review HyperFrames' `review.md` runs.
+
+- Step a dense frame strip with `snapshot --range START,END --frames 8` around every take's action and every transition, rather than only the hero move `review.md` names
+- Check the drawn cursor against the element it acts on in each strip, since the cursor is drawn from the log and nothing but a look shows it leaving what the page moved
+
+## Music
+
+HyperFrames owns the soundtrack, so score the film by its `sound.md` and `film.md`. On Frameboard's launch film the music faults hid in the first 2 s and the last 10 s, being a silent lead and a drop that landed early, which is one film's case rather than a rule.
+
 ## Storyboard headings
 
 - Write each frame heading as `## Frame N: title`, since the dash form in HyperFrames' `storyboard-format.md` example fails the markdown audit
@@ -71,12 +117,23 @@ Step 5 writes the filming half of `.canon/video/<slug>/README.md`. The composing
 
 ## Sources
 
-| Rule                        | Source                                                                                                   |
-| --------------------------- | -------------------------------------------------------------------------------------------------------- |
-| Caption placement and scrim | HyperFrames' `captions.md`, adjusted for footage with chrome along its bottom edge                       |
-| A new project per shape     | The `hyperframes` skill's `types/vertical.md`, which recomposes a vertical film rather than squeezing it |
-| The 1080x1080 window        | Frameboard's launch film, cut square from stepped takes                                                  |
-| The 2 MB WebP loop          | Frameboard's README hero, an animated WebP cut from a raw take, which played inline at 1.72 MB           |
-| Rebuilding a sped-up track  | `canon take camera --help`, whose `--rate` divides every time in the log                                 |
-| Storyboard heading form     | HyperFrames' `storyboard-format.md` and the markdown audit's character bans, with the colon read assumed |
-| The README's two halves     | Frameboard's workspace, whose README recorded how to re-film and re-render after a session ended         |
+The rules measured on Frameboard's launch film carry its case beside them rather than a default.
+
+| Rule                      | Source                                                                                              |
+| ------------------------- | --------------------------------------------------------------------------------------------------- |
+| The 1080x1080 window      | Frameboard's launch film, cut square from stepped takes                                             |
+| Rates, holds, and windows | Frameboard's launch film, cut at three paces before about 78 s landed                               |
+| Settling wide             | Frameboard's launch film, whose dissolves ghosted two boards at different scales until each settled |
+| Where music faults hide   | Frameboard's launch film, which opened silent and ended over near silence                           |
+
+The rest come from HyperFrames, the verb, or Frameboard's other deliverables.
+
+| Rule                        | Source                                                                                                    |
+| --------------------------- | --------------------------------------------------------------------------------------------------------- |
+| Caption placement and scrim | HyperFrames' `captions.md`, adjusted for footage with chrome along its bottom edge                        |
+| A new project per shape     | The `hyperframes` skill's `types/vertical.md`, which recomposes a vertical film rather than squeezing it  |
+| The 2 MB WebP loop          | Frameboard's README hero, an animated WebP cut from a raw take, which played inline at 1.72 MB            |
+| Reviewing motion            | HyperFrames' `review.md`, widened to every action after midpoint stills passed cuts the operator rejected |
+| Rebuilding a sped-up track  | `canon take camera --help`, whose `--rate` divides every time in the log                                  |
+| Storyboard heading form     | HyperFrames' `storyboard-format.md` and the markdown audit's character bans, with the colon read assumed  |
+| The README's two halves     | Frameboard's workspace, whose README recorded how to re-film and re-render after a session ended          |

package/claude/skills/ui-film/references/config.md

@@ -1,6 +1,6 @@
 ---
 title: UI film config
-description: What a take reads from canon/config/app-drive.toml, the access key it adds, and what to ask when the file is absent
+description: What a take reads from canon/config/app-drive.toml, the access key it shares with review-ui, and what to ask when the file is absent
 ---
 
 # UI film config
@@ -21,7 +21,7 @@ access = "/write?token=demo"
 | `data`   | A fixture path inside the worktree to load before serving, if any      |
 | `access` | The path or address that opens the app in the state a take starts from |
 
-`access` is optional and belongs to the take alone. A drive ignores it.
+`access` is optional. A take joins it, and so does a `review-ui` pass, which opens its chosen address behind it. `app-drive` ignores it.
 
 - Join a path value, one starting with `/`, to the served address. Take a full address as it stands.
 - Use it for whatever the app needs before its start state shows, such as a write link, a signed-in route, or a demo token

package/claude/skills/ui-film/references/handoff.md

@@ -29,7 +29,7 @@ Each frame carries `scale`, the view's top-left `x` and `y`, the `cursor`, and `
 - `cursor` is the pointer's position on the page
 - `ring` runs from 0 to 1 across the 450 ms after a click and is `null` otherwise. On a drag it grows to 0.3, holds there from press to release, and runs on to 1 from the release.
 
-The track is final. It already carries the easing, the spring, and the hold, so a composition sets each frame's values and never tweens between them.
+The track is final. It already carries the easing and the hold, so a composition sets each frame's values and never tweens between them.
 
 ## Where the composition lives
 

package/claude/skills/ui-film/references/harness.md

@@ -0,0 +1,71 @@
+---
+title: Harness
+description: The route a beat takes when canon take cannot drive it, and the harness faults that cost a launch film most of its refilms, each with its source
+---
+
+# Harness
+
+Read at Step 3 of `ui-film` when a beat takes the harness route. A harness fault looks like a flaky take, so a session that has not read these refilms on a guess instead of fixing the cause.
+
+Each rule states the principle. Where a number appears, it is the case measured on one app's launch film, not a default for the next app.
+
+## Contents
+
+- [The route](#the-route)
+- [The script](#the-script)
+- [The server](#the-server)
+- [The steps](#the-steps)
+- [The log](#the-log)
+- [Sources](#sources)
+
+## The route
+
+A beat driven from outside the page, such as a drag between two windows or an input the step kinds lack, cannot run as `canon take` steps. Until the verb can run an outside script itself, film it through a harness.
+
+- Keep each script in the workspace's `harness/` folder and write its output into the take's own folder, never at the workspace root
+- Drive the beat from a Playwright script that records the page and writes a log in the shape of a take's `log.json`
+- Build its camera track from that log with `canon take camera <log> --out <file>`, so the composition applies it like any other take
+- Tell the operator which beats ran this way, since their clips carry the harness's resolution rather than the stepper's
+
+## The script
+
+A harness runs the page and whatever acts on it in one script, so anything that blocks the script freezes the take wherever it lands.
+
+- Run a scripted agent's calls, such as a CLI it shells out to, asynchronously, since a synchronous call blocks the process driving Playwright and freezes the take mid-typing or between two clicks
+- Type one character at a time on a fixed clock rather than through `locator.pressSequentially`, which stalled 3.6 s mid-note on Frameboard's launch film while a fixed clock held at 7 ms or less a key
+- Hold a clip's last frame with FFmpeg's `tpad` when a long take ends before its scene needs it, since a held frame is invisible only while nothing on screen moves
+
+## The server
+
+A harness beat often starts its own server or restores the app's state, and both race the beat when the order is wrong.
+
+- Restore the app's state before a fresh serve, never while the server runs, since a running app logs the restore as a change and can show it on camera, as a stray change notice did on Frameboard's film
+- Wait until the fresh server answers before the beat's setup writes anything, since a server that misses the setup write never shows the control under test
+- Keep a local helper the harness calls, such as one that mints edit links, up across server restarts, answering 503 while no server runs rather than crashing on the next request
+
+## The steps
+
+A recorded harness step goes stale when the app changes under it, and nothing refuses it the way `canon take` refuses `target-missing`.
+
+- Target each control by its name, such as its role and label, never by its position, since a position finds whatever sits there after a change
+- Re-check each recorded step against the current build before filming, since a token list that began closing on pick made Frameboard's old closing click reopen it
+
+## The log
+
+The edit draws the cursor and aims the camera from the log alone, so a harness log carries the fields the stepper writes for the same events.
+
+- Write `ms` on each `type` event as the measured length of the burst, since a camera guessing at 45 ms a character released its zoom halfway through a 5.7 s note on Frameboard's film
+- Write `points` on each `move` event, being every position sent with its clip time, so the drawn cursor matches what the page received rather than an eased curve the page never saw
+- Pace a drag in small steps, wait on each, and log each step as its own linear move, since easing each step stutters. About 30 steps a second kept Frameboard's divider within 2 px of the cursor.
+
+## Sources
+
+| Rule                           | Source                                                                                                 |
+| ------------------------------ | ------------------------------------------------------------------------------------------------------ |
+| The route                      | `canon take --help` and `canon take camera --help`, whose log shape a harness writes                   |
+| Agent calls and typing clock   | Frameboard's launch film, whose harness froze on a synchronous call and stalled on `pressSequentially` |
+| Restore, readiness, and helper | Frameboard's launch film, refilmed for a stray change notice, a missing control, and a crashed helper  |
+| Targets and re-checked steps   | Frameboard's launch film, whose recorded steps broke when a token list changed between versions        |
+| `ms` and `points` on the log   | The `type` and `move` events `canon take` writes, which the camera and the drawn cursor read           |
+| Paced drags                    | Frameboard's split compare, whose divider lagged a burst of moves until each step was paced and logged |
+| Holding a last frame           | FFmpeg's [`tpad` filter](https://ffmpeg.org/ffmpeg-filters.html#tpad), used on Frameboard's film       |

package/claude/skills/ui-film/references/take-craft.md

@@ -1,6 +1,6 @@
 ---
 title: Take craft
-description: The filming rules a take plan follows, the frame-stepping limits, and the pointer and zoom rules the camera relies on, each with its source
+description: The filming rules a take plan follows, the frame-stepping limits, the pointer and zoom rules the camera relies on, and how a beat is framed, each with its source
 ---
 
 # Take craft
@@ -15,6 +15,7 @@ Read at Step 3 of `ui-film`, before writing the first beat. `canon take --help`
 - [Targets](#targets)
 - [The pointer](#the-pointer)
 - [The zoom](#the-zoom)
+- [Framing](#framing)
 - [One source for on-camera content](#one-source-for-on-camera-content)
 - [The harness route](#the-harness-route)
 - [Sources](#sources)
@@ -41,7 +42,7 @@ A plan holds the approved beats in order. Each beat names its setup, which runs
 ## One action per take
 
 - Film one action per beat, such as one click, one fill, or one scroll, so the edit can cut, reorder, or drop a beat without re-filming its neighbors
-- Keep a take as long as its beat. The verb opens and closes each one on a 0.6 s hold, which gives the edit a still to cut on, so add no hold of your own around the action.
+- Keep a take as long as its beat. The verb holds still at each end and paces each press and its result, at the timings `canon take --help` prints, so add no hold of your own around the action.
 - Add a `wait` after an action whose result animates, loads, or settles, long enough for the result to finish on screen
 - Reach the beat's start state through `setup`, since every beat opens the page fresh and nothing a setup step does is filmed
 - Write the beat's `name` as the operator approved it, since it names the clip's folder
@@ -92,10 +93,11 @@ Two rules hold once a beat is filmed.
 
 The camera track already carries the zoom, so these rules decide what to film for it to aim at.
 
-- Earn a zoom with an action. The camera aims only at clicks and typing, and a wait, a move, or a scroll aims nowhere, so a result too small to read needs a click on it.
+- Earn a zoom with an action. The camera aims at a press, typing, and a `move` carrying `hold`, so a result too small to read needs one of those on it.
+- Expect a wait, a plain move, or a scroll to aim nowhere
 - Expect a scroll to end a zoom, since the content moves under the camera
 - Expect a target filling most of the view to get less zoom, and one filling the page to get none
-- The push reaches 90% of its depth in about 633 ms, inside the 1 s ceiling a push onto an action keeps
+- The push rides the glide onto its target and lands as the cursor arrives, so it lasts as long as that glide, between 300 ms and 1.2 s
 
 ### Depth, opt-out, and speed
 
@@ -105,6 +107,32 @@ Three controls change the push itself.
 - Set `"push": false` on a beat the edit holds wide, such as one showing a whole layout change. Its track keeps the cursor and the click ring and drops the zoom.
 - Rebuild a beat's track with `canon take camera <dir>/log.json --rate <n> --out <file>` for a clip the edit plays `n` times faster, so the zoom settles on the clock a viewer sees
 
+### The cursor leads the camera
+
+The viewer follows the cursor, so the camera zooms where the cursor acts and never anywhere the cursor is not.
+
+- Film a look-back at a changed element as a `move` to it carrying `hold`, so the cursor glides there and the camera holds on its arrival
+- Never aim the camera at a point the cursor left behind, since a push onto a button while the drawn cursor sits elsewhere reads as broken
+- End a hold when the cursor leaves. A glide onto the next target plus about 1 s of hold fit Frameboard's launch film, where a 3.2 s camera-only hold read as too long.
+
+### One track per take
+
+A camera track is read off one take's log and is true of that take alone.
+
+- Rebuild every camera track from the new log after a re-film, each `--rate` track included, since a track left from the old take aims at moments that no longer happen
+- Never hand-tune a track, since the next re-film overwrites the log under it and leaves the tuning aimed at the old clock
+
+## Framing
+
+A beat's view is part of what it shows, so set it before filming rather than letting the app move it.
+
+- Film a beat that builds several elements into one fixed view fitted to its end state, so each element lands where it finishes and the next beat opens on the same view
+- Reach that view by opening the page on the finished state, letting the app fit to it, then emptying it in `setup`, rather than following the app's own view as each element lands
+- Film the selection a hand edit acts on, since `setup` is never filmed and a viewer who missed the selection cannot tell what changed
+- End a hand edit on the edited element rather than a wide view, where neighbors that already looked the same suggest several things changed
+
+Frameboard's launch film followed the board's own view in its first cut, which centered each frame as it landed and left a tall frame cut off below a short one.
+
 ## One source for on-camera content
 
 A take shows content the app loads or a script writes, such as a fixture, a snapshot, or copy typed into a field. Keep one source for it, naming whatever the take reads on camera.
@@ -115,21 +143,18 @@ A take shows content the app loads or a script writes, such as a fixture, a snap
 
 ## The harness route
 
-A beat driven from outside the page, such as a drag between two windows or an input the step kinds lack, cannot run as `canon take` steps. Until the verb can run an outside script itself, film it through a harness.
-
-- Keep each script in the workspace's `harness/` folder and write its output into the take's own folder, never at the workspace root
-- Drive the beat from a Playwright script that records the page and writes a log in the shape of a take's `log.json`
-- Build its camera track from that log with `canon take camera <log> --out <file>`, so the composition applies it like any other take
-- Tell the operator which beats ran this way, since their clips carry the harness's resolution rather than the stepper's
+A beat driven from outside the page, such as a drag between two windows or an input the step kinds lack, runs through a Playwright harness rather than as `canon take` steps. Read `harness.md` beside this file before writing one, since it holds the route and the faults that cost a reshoot most of its refilms.
 
 ## Sources
 
-| Rule                       | Source                                                                                                                                                   |
-| -------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Zoom on a click            | Screen Studio's [auto zoom guide](https://screen.studio/guide/auto-zoom) keys its zoom on click positions                                                |
-| The 1 s ceiling            | Material Design 3's [duration tokens](https://m3.material.io/styles/motion/easing-and-duration/tokens-specs) end at 1000 ms, the top of the ambient band |
-| The 633 ms push            | Twelve moves in a Screen Studio clip reached 90% in a median of 667 ms, measured when the camera was tuned                                               |
-| The typing and scroll risk | Takes of a canvas design board filmed while the stepper was built                                                                                        |
-| Jumping scrolls and GIFs   | [hasuwini77/demo-reel#28](https://github.com/hasuwini77/demo-reel/pull/28), read through a search summary rather than the page                           |
+| Rule                          | Source                                                                                                                         |
+| ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------ |
+| Zoom on a click               | Screen Studio's [auto zoom guide](https://screen.studio/guide/auto-zoom) keys its zoom on click positions                      |
+| The push riding the glide     | The operator judged renders of a fixture page by eye and kept a zoom landing with the cursor over one leading it               |
+| The typing and scroll risk    | Takes of a canvas design board filmed while the stepper was built                                                              |
+| The cursor leading the camera | Frameboard's launch film, whose operator flagged every push the drawn cursor did not lead                                      |
+| One track per take            | Frameboard's launch film, where tracks left from an earlier take drove two beats off sync                                      |
+| Framing                       | Frameboard's launch film, refilmed into a fixed view fitted to its finished frames                                             |
+| Jumping scrolls and GIFs      | [hasuwini77/demo-reel#28](https://github.com/hasuwini77/demo-reel/pull/28), read through a search summary rather than the page |
 
 The pointer rules carry no number. One pointer and a click inside its box follow from the log recording each target's box.

package/docs/agents/targets.md

@@ -9,7 +9,9 @@ kind: reference
 `canon targets list` reports the projects this toolkit installed into. `canon targets pulls [paths…]` reports each target's open pull requests, or every target's when none is named. Both take `--json`. Read the record's fields, since a wrapping shell function can flatten the exit.
 
 - `list` takes `--sweep <path…>`, `--depth <n>` (default 4), and `--record`, which seeds the index from swept stamps and needs `--sweep`
-- Each stamping sync records its target in `$XDG_STATE_HOME/canon/targets.json`, and no row is removed
+- Each stamping sync records its target in `$XDG_STATE_HOME/canon/targets.json`, except a folder under the OS temp folder, the state folder, `~/.claude/jobs/`, or any `.canon/tmp/`
+- Every write drops a row whose folder is gone or sits under one of those, and `list` leaves the same rows out. A target on an unmounted drive drops until its next sync records it again.
+- `--record` counts a swept checkout under one of those folders as skipped, not failed
 - A sweep finds installs the index never held
 
 `canon changelog` prints the releases a target has not seen, from the `CHANGELOG.md` the installed package ships. It reads no registry and needs no `gh`.

package/docs/workflow/operating-model.md

@@ -30,11 +30,12 @@ Each role keeps to its own writes, and five rules cover how the roles meet.
 1. Plan the next feature with `plan-feature` into `.canon/plans/`. Run it warm when the row turns on a contract other rows consume, and dispatch a planner otherwise.
 2. Check the plan waits on nobody, the branch is unclaimed, and no track in flight conflicts. Dispatch a background worker with `claude --bg`, naming the branch and the model.
 3. The worker enters its own worktree, builds, self-checks, opens a PR, and stops there.
-4. Dispatch a reviewer under `role-reviewer` for every PR but a release one, or one pair per batch of small contract-free PRs. It posts `review-pr` findings per PR, and `review-ui` drives any checklist.
-5. The reviewer tells the session holding the branch to run `review-address`, found with `canon sessions list --branch`, once a pass posts a finding at any severity.
-6. The worker addresses the findings, rebases onto `origin/main` if a sibling landed on its files, pushes, and asks that reviewer for a re-review of the added commits.
-7. A pass posts `## Review` while anything is open and `## Review closed` when nothing is. The reviewer then runs `canon pr lift`.
-8. The human merges with `canon pr merge <number>`, a batch as each pass closes. The orchestrator tells any trailing worker whose files the merge touched to run `review-address`, which rebases.
+4. The orchestrator reads `canon pr evidence --check` and sends a painted PR with no capture or evidence comment back to its worker.
+5. Dispatch a reviewer under `role-reviewer` for every PR but a release one, or one pair per batch of small contract-free PRs. It posts `review-pr` findings, and `review-ui` drives any non-taste box.
+6. The reviewer tells the session holding the branch to run `review-address`, found with `canon sessions list --branch`, once a pass posts a finding at any severity.
+7. The worker addresses the findings, rebases onto `origin/main` if a sibling landed on its files, pushes, and asks that reviewer for a re-review of the added commits.
+8. A pass posts `## Review` while anything is open and `## Review closed` when nothing is. The reviewer then runs `canon pr lift`.
+9. The human merges with `canon pr merge <number>`, a batch as each pass closes. The orchestrator tells any trailing worker whose files the merge touched to run `review-address`, which rebases.
 
 Each worker halts at the PR, and the merge stays a human gate. `canon pr merge` squashes with the body's Summary, Key changes, and Technical context as the message, and the seeded deny rule covers the forms an agent writes by default. A release-please or Dependabot pull request merges the same way, from the bot's own body.
 

package/docs/workflow/visual-design-workflow.md

@@ -45,6 +45,7 @@ Two reviews run beside each other and finish on their own clocks.
 - `canon:review-pr` reads the code and the stills in the evidence comment, and posts under `## Review`.
 - `canon:review-ui` never reads the diff. It drives each checklist box in the running app through `canon browser`, which runs the pinned `@playwright/cli`, and posts under `## UI review`.
 - Every box gets one verdict, being pass, fail, needs eyes, or not driven.
+- A page that shows its start state only behind a token or a signed-in route names that path as `access` in `canon/config/app-drive.toml`, and the pass opens its address behind it.
 - The pass refuses rather than download a browser. Install it once per machine with `canon browser install-browser chromium`.
 
 After the boxes, `review-ui` sweeps every route they reached:
@@ -63,7 +64,7 @@ A UI review stays open while the branch owes a fix. Three things owe one:
 
 Two kinds of result report without holding the review open.
 
-- A taste box needs eyes, so the pass captures both themes and leaves the call to you.
+- A taste box needs eyes, so the pass captures both themes and leaves the call to you. A checklist holding only taste boxes gets no UI reviewer at all, and the lift does not wait for one.
 - Every other probe result, and every axe `incomplete`, is a reading to confirm, since each probe carries a known class of false finding.
 
 At the time of writing, the gated axe classes are contrast, target size, accessible names, labels, alt text, document title and language, valid ARIA, and nested interactive controls. A rule leaves the list on its first false finding, so `canon drive --help` and the `review-ui` skill carry the current one.

package/governance/ledger/skills/code-craft/SKILL.md

@@ -42,6 +42,15 @@ Parnas's paper refused a read at its ACM DOI, `10.1145/361598.361623`, so the ro
 | Rules free of transport and storage       | [Cockburn, Hexagonal Architecture](https://alistair.cockburn.us/hexagonal-architecture/): an application "developed and tested in isolation from its eventual run-time devices and databases"                                                                           | 2026-10-24 |
 | No ports and adapters for record CRUD     | [Microsoft, Design a DDD-oriented microservice](https://learn.microsoft.com/en-us/dotnet/architecture/microservices/microservice-ddd-cqrs-patterns/ddd-oriented-microservice): "Simpler responsibilities, like a CRUD service, can be managed with simpler approaches." | 2026-10-24 |
 
+## Give another language its own file
+
+| Bullet                                  | Source                                                                                                                                                                                        | Read       |
+| --------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
+| A long page, stylesheet, or script out  | [Meszaros, Inline Resource](http://xunitpatterns.com/Inline%20Resource.html): "If the contents of the resource are large, chances are high that you are also suffering from Eager Test"       | 2026-11-03 |
+| A branching script out at any length    | House choice: the `ci-workflow` skill already moves a `run:` step past one guard to a script, and a fake that branches is shared by many tests, so no test reads it as its own input          | 2026-11-03 |
+| An interpolating template stays in code | House choice: a template built from data is code generating output, and a file holding it would carry placeholders no linter for its language reads either                                    | 2026-11-03 |
+| Short input under test stays inline     | [Meszaros, Obscure Test](http://xunitpatterns.com/Obscure%20Test.html): with a Mystery Guest "the test reader is not able to see the cause and effect between fixture and verification logic" | 2026-11-03 |
+
 ## Check your own diff
 
 | Bullet                                  | Source                                                                                                                                                                                                                                                        | Read       |

package/governance/ledger/skills/test-craft/SKILL.md

@@ -44,6 +44,7 @@ The field is software testing practice. Software Engineering at Google carries t
 | Test data through a factory or builder  | [Pryce, Test Data Builders](http://www.natpryce.com/articles/000714.html): "For each class you want to use in a test, create a Builder for that class", one that "Initialises its instance variables to commonly used or safe values"                | 2026-10-24 |
 | Assert through the public surface       | [Software Engineering at Google, ch. 12](https://abseil.io/resources/swe-book/html/ch12.html): tests should "make calls against its public API rather than its implementation details"                                                               | 2026-10-24 |
 | Real, then fake, then stub, mock last   | [addyosmani/agent-skills, Test-Driven Development](https://github.com/addyosmani/agent-skills/blob/c004a74/skills/test-driven-development/SKILL.md): "Preference order (most to least preferred): 1. Real implementation", then fake, stub, and mock | 2026-10-24 |
+| A long fixture in its own file          | [Meszaros, Inline Resource](http://xunitpatterns.com/Inline%20Resource.html): "If the contents of the resource are large, chances are high that you are also suffering from Eager Test"                                                              | 2026-11-03 |
 
 ## Hold the structure floors
 

package/governance/ledger/skills/ui-craft/capture.md

@@ -16,11 +16,24 @@ The rule states canon's own evidence procedure for a rendered change, so most ro
 
 ## When to capture
 
-| Bullet                                   | Source                                                                                                                                                                                                                                                                                                                           | Read       |
-| ---------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
-| Preview, not dev server                  | House choice: a dev server injects overlays and skips the production build's transforms, so its frame differs from what ships                                                                                                                                                                                                    | 2026-10-18 |
-| Every theme, and again                   | House choice: a defect in the dark theme passes a light-only capture, and a repair inside a shared stylesheet can cancel a rule written earlier in the same file                                                                                                                                                                 | 2026-10-18 |
-| Read the capture before the pull request | House choice: a defect visible in the worker's own capture, such as a 20px target under the 24px bullet in `pointer.md`, reached review because nobody read the frame against the checklist first, and each review round re-runs both reviews. The skill ships with the plugin, so the bullet carries a report-if-missing clause | 2026-10-23 |
+| Bullet                                    | Source                                                                                                                                                                                                                                                                                                                           | Read       |
+| ----------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
+| Preview, not dev server                   | House choice: a dev server injects overlays and skips the production build's transforms, so its frame differs from what ships                                                                                                                                                                                                    | 2026-10-18 |
+| Every theme, and again                    | House choice: a defect in the dark theme passes a light-only capture, and a repair inside a shared stylesheet can cancel a rule written earlier in the same file                                                                                                                                                                 | 2026-10-18 |
+| Read the capture before the pull request  | House choice: a defect visible in the worker's own capture, such as a 20px target under the 24px bullet in `pointer.md`, reached review because nobody read the frame against the checklist first, and each review round re-runs both reviews. The skill ships with the plugin, so the bullet carries a report-if-missing clause | 2026-10-23 |
+| A case per added or altered state         | House choice: workers read the old rule as covering new surfaces only, so new states of captured surfaces shipped with no case and the next pull request met the same thin fixture. Proof is owed by default.                                                                                                                    | 2026-11-03 |
+| States that count as visible              | House choice: a focus ring, an outline, a toast, a tooltip, a size change from server-written markup, and a state reachable only by interaction each show on a page, and workers filed them as behavior with nothing to capture                                                                                                  | 2026-11-03 |
+| Exemption stated in the pull request body | House choice: the reviewer needs the path and the reason in front of them to accept it, and a line in the body is the one place both reviewers read                                                                                                                                                                              | 2026-11-03 |
+| Reviewer accepts through the waiver line  | House choice: the lift reads waivers from the newest review pass alone, so only that line holds the draft mark open to a painted path with no case                                                                                                                                                                               | 2026-11-03 |
+| Uncovered painted path stays in draft     | House choice: a painted path with neither a case nor a waiver is the gap the lift refuses, so the rule names the outcome a worker meets                                                                                                                                                                                          | 2026-11-03 |
+
+## When the fixture cannot reach a state
+
+| Bullet                                      | Source                                                                                                                                                                            | Read       |
+| ------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
+| Extend the fixture in the same branch       | House choice: a drive fixture lacking a state made a box or reel skip and close, and only the building session can add the state before the pull request opens                    | 2026-11-03 |
+| Never record the state as a skip            | House choice: a skip leaves the fixture as thin as it was, so the next pull request meets the same gap and skips again                                                            | 2026-11-03 |
+| State the setup inline with no fixture file | House choice: a project with no `canon/config/app-drive.toml` drives the served root, so a fixture file is not owed and the setup goes on the box, as `(local only)` already does | 2026-11-03 |
 
 ## What a capture covers
 

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@erclx/canon",
   "type": "module",
-  "version": "5.76.0",
+  "version": "5.78.0",
   "description": "Runs your agent's work and keeps its code good, on one setup for every repo.",
   "license": "MIT",
   "bin": {
-    "canon": "./src/cli.ts"
+    "canon": "src/cli.ts"
   },
   "files": [
     "src",
@@ -18,6 +18,7 @@
     "tsconfig.json",
     "assets/brand/mark.svg",
     "!scripts/eval",
+    "!src/**/fixtures/**",
     "!**/*.test.ts",
     "!**/*.test.tsx"
   ],
@@ -74,8 +75,8 @@
     "astro": "^6.1.9",
     "husky": "^9.1.7",
     "micromatch": "^4.0.8",
-    "oxfmt": "0.74.0",
-    "oxlint": "1.89.0",
+    "oxfmt": "0.75.0",
+    "oxlint": "1.90.0",
     "prettier": "^3.8.1",
     "prettier-plugin-astro": "^0.14.1",
     "prettier-plugin-tailwindcss": "^0.8.1",