[Release] 2026-09-25: v2.7.0 — goal mode that pauses and asks, GPU-only render_page with VRAM lending, voxel path-tracing kit

[nibor1896]

Summary

24 commits on local main since origin/main (v2.6.0, 21d7505), 12 tickets, all released pending robin's live check. Head b3fc1dc.

• goal mode never skips a step on its own: environment/capability failures climb retry, reflect, fresh-context and split rungs, then PAUSE with a report and a question for robin; the step gets a 60 min budget and a no-progress timer (goal: a step that fails twice is skipped without asking -- 4 of 9 diorama steps auto-skipped on software-GL captures; failures need a class (environment vs capability), a ladder, a budget, and a PAUSE that reports and asks #294)
• the judge checks a frozen per-step yes/no/unknown checklist on frames or a contact sheet, after a pixel precheck, with a reference-image hook (judge: the rubric is picked at judge time and scored 1-10 on one frame with no 'unknown' and no precheck -- steps 5-8 were judged on software frames against model-written criteria; needs a frozen per-step yes/no/unknown checklist, frames, a precheck, and a reference hook #295)
• a skip is never stored as done, /goal redo, and skipped is violet with its own glyph, apart from the amber running step (goal: robin's skip of step 4 is stored as 'done' (counted 5/9), and the bar draws 'skipped' in the same amber as 'running' #296)
• render_page renders on the GPU only (ENVIRONMENT error + render: record instead of SwiftShader pixels), captures up to 4 frames at controlled page time with a 2x2 contact sheet, and returns pixel prechecks (render_page silently rasterised on SwiftShader and captured one still: a 16-hour diorama run was judged on 1-spp CPU noise (35 of 42 results software) -- GPU only with a renderer check, deterministic multi-frame capture, pixel prechecks #293)
• voxel dioramas path-traced with a vendored three-gpu-pathtracer kit (kits/pathtracer, skill voxel-diorama, build_bundle aliases crow-voxel-kit/crow-pathtracer); opt-in with install.sh --pathtracer / install.ps1 -PathTracer (Crow ships no renderer for the voxel-diorama task: agents hand-write a WebGL2 ray tracer (16 h of noise, #293-#295) -- vendor the proven three-gpu-pathtracer recipe as a kit with a skill, build_bundle aliases and an opt-in installer flag #298)
• render_page borrows the shortfall of VRAM from an idle local crow-nest serve for the capture (crow-nest#117), gives it back in a finally after the browser is gone, and the judge only asks after the return; llama.cpp/remote/refused lend keep the ENVIRONMENT error (render_page cannot render under crow-nest serve: 0.07-0.5 GiB free against the 512/1536 MiB bound, and Crow never borrows VRAM from the idle engine -- lend around the capture (crow-nest#117), return in a finally, judge after the return #297)
• voxel kit v2: animated LIVE preview (shadow maps, d.animate, parts, light rigs, orbit) + PHOTO mode (path tracer at t, key P / ?mode=photo&t=), g.prop registry and terrain coverage against empty scenes, kits/pathtracer/check_diorama.py as a goal check (voxel kit v2: animation, orbit, photo mode, props registry, diorama checker -- the kit renders stills only and nothing measures an 'empty' or static diorama #299)
• read_file refuses images and other binary files by content (NUL in the first 8,000 bytes or a PNG/JPEG/GIF/WebP/BMP/PDF signature) and names read_image; read_image on a missing -crop.png says a crop exists only under 50 % coverage and names the frame (read_file dumps an image's bytes as text: the lighthouse run read reference/island.png as 16,000 chars of mojibake, blamed read_image and saved that into MEMORY.md -- refuse binary files and name read_image #301)
• render_page lets pages built with the path-tracing kit ([crow-pt] marker) wait up to 120 s so the photo converges; all other pages keep 20 s; the skill asks for 60-120 s on dark scenes, never a smaller scene (render_page cut path-traced pages to 20 s like any other page: the lighthouse night photo stopped at ~295 samples, stayed grainy, and the goal paused offering to shrink the scene -- kit pages need a longer wait ceiling #302)
• a window started with --root DIR keeps DIR when it restores the last chat (was: roots.json active, the last chip pick) and makes DIR the next start's folder; a restored chat that recorded another folder moves to DIR with A working-area rebind is silent to the model #224's notice (A window started with --root loses it to roots.json 'active' when the last chat is restored: lighthouse-test run bound diorama-test, goal bar gone #303)
• the diorama checker (check_diorama.py, check.sh) borrows VRAM from the local serve like a Crow turn: --serve (default http://127.0.0.1:8099/v1, env CROW_SERVE_URL, none = never) (check_diorama.py runs outside a Crow turn, so render_page never borrows VRAM from serve: the lighthouse gate failed all 10 checks at 280 MiB free #304)
• scrollbars show only while their strip is scrolled (gone 0.8 s after the last scroll, kept while the pointer is held) or while a mouse pointer is over it; at rest no thumb in the chat, stats line, code blocks, panels, rail or menus; widths and gutter unchanged; phone without the hover part (Every scroll strip in the window and the phone mirror shows its scrollbar thumb at rest (stats line, Code panel, chat): scrollbars should appear only while scrolled or hovered #305)
• voxel kit live mode path-traces the static island and rasterises only the moving parts; ?mode=raster keeps the flat preview and carries the checker's motion/repeat captures; a person's page fills the window at devicePixelRatio (cap 2), ui=0 keeps the fixed canvas (9e4daa4)
• release chores: v2.7.0 in cli/crow.py, install.ps1, README badge, operating-point manifest; --root row in client-flags.md; pack-release.ps1 strips kits __pycache__ and requires check_diorama.py + scaffold; tools/test_pathtracer_kit.py now runs its check_diorama.py runs outside a Crow turn, so render_page never borrows VRAM from serve: the lighthouse gate failed all 10 checks at 280 MiB free #304 tests when invoked as a script (CI ran 38 of 41)

Scope

	count	issues
close on merge	0
resolved, pending live verification (closed after the release on robin's word)	12	#293 #294 #295 #296 #297 #298 #299 #301 #302 #303 #304 #305
already closed	0
total	12	not in this release: #300 (open, decision)

Resolved issues (close on merge)

Resolved, pending live verification

robin asked to close all of these after the release, each with a ## Released in v2.7.0 comment that says "live check pending".

Refs #293 — render_page silently rasterised on SwiftShader and captured one still: GPU only with a renderer check, deterministic multi-frame capture, pixel prechecks
Live check: N1 serve up + crow-nest#110 1024 MiB reserve, panel closed: render_page on a WebGL page -> renderer contains "NVIDIA", 64-sample accumulation frame < 5 s wall; N3 rotating cube frames=4, frame_ms=250 -> 4 pairwise different frames, identical_frames false, a second call byte-identical (sha256sum)
Refs #294 — goal: a step that fails twice is skipped without asking; failures need a class, a ladder, a budget and a PAUSE that reports and asks
Live check: N4 diorama goal while serve holds the GPU -> 2 environment retries 15 s apart, then "Paused · step N" + the model's report (found / why / 2-3 proposals / question) in window and phone; no step skipped without /goal skip; a typed line resumes
Refs #295 — judge: rubric picked at judge time, 1-10 on one frame, no 'unknown', no precheck
Live check: /goal … | accept: 5: puddles reflect the neon | reference: <robin's image> -- lighting mood -> goal.json step 5 has a frozen checklist, judge.checklist yes/no/unknown, judge.images = frames/contact sheet; a software/unavailable capture gives judge_called false, class environment
Refs #296 — goal: robin's skip of step 4 stored as 'done'; 'skipped' drawn in the running step's amber
Live check: window on localconf/testcases/diorama-test -> step 4 violet, dashed ring, "skipped", counter 4/9; running step amber; same on the phone; /goal redo 4 reopens it
Refs #297 — render_page cannot render under crow-nest serve (0.07-0.5 GiB free vs 512/1536 MiB) and never borrows VRAM from the idle engine: lend around the capture, return in a finally, judge after the return
Live check: serve with crow-nest#117 up, Crow session: render_page on a WebGL page -> render: {"render_mode": "gpu", ...} naming the NVIDIA renderer; crow.log one render: lent ... MiB + one render: returned ... MiB; engine.log one [lend] lent + one [lend] returned; the next model step starts without waiting out the TTL; a judge call afterwards answers normally
Refs #298 — Crow ships no renderer for the voxel-diorama task: vendor the proven three-gpu-pathtracer recipe as a kit with a skill, build_bundle aliases and an opt-in installer flag
Live check: install.sh --pathtracer -> kit matches kit.json, skill switched on, esbuild named; goal "path-traced isometric voxel bedroom as one offline index.html like " -> model reads skill voxel-diorama, writes src/scene.js from the scaffold (no own shaders), build_bundle -> index.html, render_page 20 s shows [crow-pt] renderer: ANGLE (NVIDIA ...), samples >= 200; robin judges the 6 M4 items vs the reference; within 2 h
Refs #299 — voxel kit v2: animation, orbit, photo mode, props registry, diorama checker -- the kit renders stills only and nothing measures an 'empty' or static diorama
Live check: open the built scaffold index.html -> fills the window sharp at the display's pixel ratio, the island path-traces and converges while the camera rests, the pinwheel turns on top, drag orbits, wheel zooms, P -> photo converges, P -> animation resumes at the paused t; ?mode=raster shows the flat preview; lighthouse goal with check: localconf/testcases/diorama-check/check.sh index.html -> exit 0 only on a dense (>= 40 props, >= 12 kinds, >= 60k voxels, coverage >= 0.5), animated, GPU-rendered page; robin judges the photo vs the references
Refs #301 — read_file dumps an image's bytes as text: the lighthouse run read reference/island.png as 16,000 chars of mojibake, blamed read_image and saved that into MEMORY.md
Live check: goal run whose brief names a reference PNG -> any read_file on a .png in session.json is answered error: … is a PNG image (WxH, N bytes) -- read_file returns text only; use read_image to see it and the next call is read_image on it; no new .crow/MEMORY.md line says read_image returns bytes
Refs #302 — render_page cut path-traced pages to 20 s like any other page: the lighthouse night photo stopped at ~295 samples and stayed grainy
Live check: lighthouse goal with check: localconf/testcases/diorama-check/check.sh index.html -> the photo render_page uses wait_ms 60000-120000, console [crow-pt] samples= >= 1,000 (was ~295), the check's samples row passes at --min-samples 1000, no proposal to shrink the scene for grain; robin judges the night photo's grain vs reference/island.png
Refs #303 — A window started with --root loses it to roots.json 'active' when the last chat is restored: lighthouse-test run bound diorama-test, goal bar gone
Live check: with roots.json active on another folder, crow --base-url http://127.0.0.1:8099/v1 --root <lighthouse-test> -> chip reads lighthouse-test, goal bar back (paused at step 2), ~/.config/crow/roots.json active = lighthouse-test
Refs #304 — check_diorama.py runs outside a Crow turn, so render_page never borrows VRAM from serve: the lighthouse gate failed all 10 checks at 280 MiB free
Live check: serve with crow-nest#117 up and holding the card, bash ~/Projects/localconf/testcases/diorama-check/check.sh index.html on a built diorama -> gpu row PASS (was FAIL at 280 MiB free); crow.log one render: lent ... MiB + one render: returned ... MiB per capture during the check (was: no render: line)
Refs #305 — Every scroll strip in the window and the phone mirror shows its scrollbar thumb at rest: scrollbars should appear only while scrolled or hovered
Live check: window, long chat with a code block: pointer outside -> no thumb in #flow, the stats line, the Code panel; pointer over each -> its thumb shows; PageDown with the pointer on the rail -> chat thumb shows and goes ~0.8 s after the last key; drag a thumb and hold -> stays until release; column does not shift. Phone: no bar at rest, iOS indicator only while swiping, none stuck after a tap

Issues shipped (already closed)

Checks

Head b3fc1dc (local main; suites run at 01008b6, code unchanged since except tools/test_pathtracer_kit.py re-run at 8d14456; CHANGELOG text after), 2026-09-25, runtime venv (~/.local/share/crow/venv, Python 3.14), Linux:

• cli/test_crow_core.py 1,529 OK (skipped 2) · cli/test_crow.py 476 OK (3) · cli/test_crow_gui.py 915 OK (2) · cli/test_crow_remote.py 53 OK (1): 2,973 tests, 0 failures
• tools/test_pathtracer_kit.py 41 OK (was 38 as a script before 8d14456) · ruff check . clean
• check_shared_core 83/83 · check_operating_point 10/10 (version 2.7.0 in all places) · check_pathtracer_kit PASS · check_routing_tables --selftest OK · check_chat_template check 4/4 (jinja2 in a throwaway venv; not in CI)
• bash install.sh --selftest 47 checks, 0 failed
• known red, not in CI, same at v2.6.0: check_gui_prereqs 2/3 (glyph coverage, 26 problems over the 2 shipped faces); tools/test_check_operating_point.py (flash-next-cnq45-m docs row) and tools/test_check_gui_prereqs.py (case 1 = the glyph baseline)
• not run: install.ps1 -Selftest, tools/pack-release.ps1 (no PowerShell on this machine); no GPU run for the path-traced live mode (9e4daa4)
• environment note: this shell exports FORCE_COLOR=3, which colours node's console.log and turns one gui test red (AStreamWithoutARoundTests); green with FORCE_COLOR unset, CI does not set it

2.7.0 — 2026-09-25

Goal runs stop skipping silently, render_page renders on the GPU only, and voxel dioramas get a path-tracing
kit. A failed goal step climbs a classified ladder and then pauses and asks robin; the judge answers a frozen
yes/no/unknown checklist on clock-stepped frames; a skip is never stored as done (#294–#296). render_page drops the
SwiftShader fallback, captures up to 4 frames at controlled page time with pixel prechecks, borrows VRAM from an
idle crow-nest serve around the capture, and lets path-traced kit pages converge for up to 120 s (#293, #297,
#302). The voxel kit vendors three-gpu-pathtracer with a skill, a scaffold, animation, a photo mode, a props
registry and a diorama checker, opt-in with install.sh --pathtracer / install.ps1 -PathTracer (#298, #299,
#304). Also: read_file refuses binary files and names read_image (#301), --root survives the restored chat
(#303), and scrollbars show only while used (#305).

Everything on local main since 2.6.0 (21d7505): 24 commits, 12 tickets (#293–#299, #301–#305), 2026-09-25.
Most numbers come from the 2026-09-24/25 diorama and lighthouse goal runs. #300 (image generation beside a live
session) is not in this release. Tickets are released pending robin's live check.

Added

• Voxel kit: path-traced voxel dioramas as one offline page (Crow ships no renderer for the voxel-diorama task: agents hand-write a WebGL2 ray tracer (16 h of noise, #293-#295) -- vendor the proven three-gpu-pathtracer recipe as a kit with a skill, build_bundle aliases and an opt-in installer flag #298, 2026-09-25).

  • kits/pathtracer/ ships in every install. It holds three 0.186.1 + three-mesh-bvh 0.9.15 + three-gpu-pathtracer 0.0.24 as one esbuild-minified ES module (958,266 bytes; sha256, npm integrity and licence hashes in kit.json; the MIT texts beside it; a NOTICE entry). Next to it: voxel-kit.js, a scaffold, and the skill voxel-diorama.
  • The kit provides a voxel grid; culled-face meshing with one MeshStandardMaterial per palette colour; a telephoto near-isometric camera with slight depth of field; a dome, a ground plane and a soft key light; lamps with the spot light below a solid shade; emission capped at 1; a despeckle pass; context-loss recovery; and window.__SCENE__ / __PT__ probes.
  • build_bundle resolves crow-voxel-kit and crow-pathtracer to the installed kit, so the library never passes through the model.
  • install.sh --pathtracer / install.ps1 -PathTracer verify the bundle, switch the skill on and name the esbuild. A kit skill is seeded once, switched off, through a skills/.seeded ledger: 0 prompt tokens until someone switches it on.
  • Measured on 2026-09-25, headless Chromium 152, ANGLE/Vulkan, RTX 5090, 1024×1024: the scaffold room (26,627 voxels, 46,168 triangles) ran at 13.0 samples/s at 10 s and 14.3 at 40 s, and lost and restored the context once. The rules come from the pt-proof runs: vertex colours rendered black in 1 of 3 starts, and a spot inside a hollow shade gave 30.6 dB where one below a solid shade gave 38.6 dB (PSNR 60 s vs 180 s).
  • Before: the 2026-09-24/25 goal run hand-wrote a WebGL2 ray tracer for ~16 h (render_page silently rasterised on SwiftShader and captured one still: a 16-hour diorama run was judged on 1-spp CPU noise (35 of 42 results software) -- GPU only with a renderer check, deterministic multi-frame capture, pixel prechecks #293–judge: the rubric is picked at judge time and scored 1-10 on one frame with no 'unknown' and no precheck -- steps 5-8 were judged on software frames against model-written criteria; needs a frozen per-step yes/no/unknown checklist, frames, a precheck, and a reference hook #295).
  • The model's use of the kit in a live goal run is not measured.

• Voxel kit v2: animated live preview, photo mode, orbit, props registry, diorama checker (voxel kit v2: animation, orbit, photo mode, props registry, diorama checker -- the kit renders stills only and nothing measures an 'empty' or static diorama #299, 2026-09-25).

  • The page opens in LIVE mode (since 9e4daa4 this flat preview is ?mode=raster; see Changed): a rasterised three.js preview of the same scene and materials, with real lights, soft shadow maps (PCFShadowMap + shadow.radius; PCFSoftShadowMap is gone in three r182+) and the scene's d.animate((t, dt, scene) => …) every frame. PHOTO mode pauses at t and path-traces as before (despeckle, context-loss restore). Switch with key P or a small Foto/Live button that shows only under the pointer. ?mode=photo&t=<s> opens the photo directly, ?mode=live the preview, &ui=0 hides the button. Drag orbits, wheel or pinch zooms; in photo mode a camera change restarts the accumulation.
  • New API: d.part(name, grid, {pivot}) returns a movable THREE.Group built from its own grid; d.addSpot({...}); addLamp / addAreaLight / addSpot return a light rig the callback can rotate (a lighthouse beam). Time comes only from the page clock, so render_page's 4 frames (render_page silently rasterised on SwiftShader and captured one still: a 16-hour diorama run was judged on 1-spp CPU noise (35 of 42 results software) -- GPU only with a renderer check, deterministic multi-frame capture, pixel prechecks #293) differ and repeat byte-identically.
  • Against empty scenes: g.prop(name, build) records the name, voxels and bbox of each prop. window.__SCENE__ and the console line [crow-scene] {json} report props, propKinds, coverage (terrain columns with a prop above their top cell, divided by all terrain columns), parts, animated, mode and errors. The skill sets the targets: ≥ 40 props of ≥ 12 kinds, ≥ 60,000 voxels, coverage ≥ 0.5.
  • kits/pathtracer/check_diorama.py <index.html> is a goal check: command. It renders through Crow's own render_page and prints PASS/FAIL for gpu, probe, samples, props, kinds, voxels, coverage, motion (all 6 frame pairs > 0.5 % changed), repeat, photo precheck and errors; it exits 0 only when all pass.
  • Measured on 2026-09-25, scaffold with its pinwheel part, headless Chromium, ANGLE/Vulkan, RTX 5090, 1024×1024: live 60 fps; photo 289 samples at 20 s (14.5 samples/s); live frame pairs changed 0.69–1.26 %; a second capture was byte-identical; 0 page errors. The scaffold fails the density targets by design (6 props, 26,751 voxels, coverage 0.118). A model-built dense scene is not measured yet.

• render_page captures frames at controlled page time (render_page silently rasterised on SwiftShader and captured one still: a 16-hour diorama run was judged on 1-spp CPU noise (35 of 42 results software) -- GPU only with a renderer check, deterministic multi-frame capture, pixel prechecks #293, 2026-09-25). frames (1–4) and frame_ms
  (16–5000, default 500): with more than one frame the page's clock is frozen from its first script
  (Date, performance.now, timers, requestAnimationFrame, a seeded Math.random), and each capture follows
  exactly frame_ms of page time. Also written: a 2×2 contact sheet at half size, render-<stamp>-sheet.png.
  No-GPU smoke on Chromium 152 (canvas 2D, --disable-gpu, 640×400, 4 frames × 250 ms): 1.6 s per call, 4
  pairwise different frames, a second call byte-identical (sha256). Not measured on the GPU; that is robin's live
  check.

• A structured render record (render_page silently rasterised on SwiftShader and captured one still: a 16-hour diorama run was judged on 1-spp CPU noise (35 of 42 results software) -- GPU only with a renderer check, deterministic multi-frame capture, pixel prechecks #293). Every capture and every ENVIRONMENT error carries one line,
  render: {render_mode, renderer, frames, contact_sheet, precheck}, and crow_core.last_render() returns the
  same dict. precheck holds uniform, distinct_colours, one_colour_pct, dark_pct and clipped_pct (last
  frame), plus max_frame_diff and identical_frames (all frame pairs; a pixel counts as changed when a channel
  moves by more than 25, and the frames count as moving from 0.5 % changed).

• render_page borrows VRAM from an idle crow-nest serve (render_page cannot render under crow-nest serve: 0.07-0.5 GiB free against the 512/1536 MiB bound, and Crow never borrows VRAM from the idle engine -- lend around the capture (crow-nest#117), return in a finally, judge after the return #297, crow-nest#117, 2026-09-25). Below the VRAM bound,
  when this turn's endpoint is local (loopback), render_page asks serve for the shortfall + 256 MiB
  (POST /v1/crow/vram/lend, TTL = the render's own ceiling + 30 s, at most 600 s), reads the free VRAM again, and
  renders on the GPU if it now clears the bound. The loan goes back (POST /v1/crow/vram/return, a 503 retried 3×)
  in a finally after the browser is closed or killed, on a capture, an error, a timeout or an exception, and before
  the result reaches the model, so judge only ever asks after the return. Still short after the loan: the
  ENVIRONMENT error says lending was tried and how much was lent. llama.cpp or an older serve (404), lending off
  (501), a loan already out (409), no answer (then the idempotent return is sent anyway), or a remote endpoint: the
  ENVIRONMENT error as before. Each loan and return is a render: line in crow.log with MiB and milliseconds.
  Before: under serve, 0.07–0.5 GiB free (render_page says 'software (swiftshader)' but not why: 49 of 49 captures fell back while serve held the RTX 5090, and the model concluded the machine has no GPU #271, render_page silently rasterised on SwiftShader and captured one still: a 16-hour diorama run was judged on 1-spp CPU noise (35 of 42 results software) -- GPU only with a renderer check, deterministic multi-frame capture, pixel prechecks #293, crow-nest#117) and every capture refused. Tested against a
  fake serve only; not measured live.

• Frozen per-step checklist for the judge, with yes/no/unknown, frames, a precheck and reference images
  (judge: the rubric is picked at judge time and scored 1-10 on one frame with no 'unknown' and no precheck -- steps 5-8 were judged on software frames against model-written criteria; needs a frozen per-step yes/no/unknown checklist, frames, a precheck, and a reference hook #295, 2026-09-25). Each visual step gets a checklist when it starts. It comes from accept: lines
  (accept: 5: <item> binds to step 5), or the model writes it once with goal_step(n, "running", checklist=[…]),
  or the first judge call writes it. A second write is refused, and a replan keeps it. The judge answers each item
  yes/no/unknown with one line of evidence. done needs every must-item "yes" (optional: items do not gate).
  "unknown" twice on one step pauses the goal. When the render recorded clock-stepped frames or a
  contact_sheet, the judge sees them. A capture that is software-rendered on a GPU step, uniform, black, under 16
  colours, or frozen on a step that needs motion never reaches the judge model: it is an environment failure.
  reference: <image> -- <criterion> in /goal sends robin's reference image for a pairwise item. These items are
  advisory until calibrated. Before, on 2026-09-25, 8 judge calls on steps 5–8 used criteria the model wrote at
  judge time, each scored 1–10 on one software frame. Not measured live.

• Step budget and no-progress timer (goal: a step that fails twice is skipped without asking -- 4 of 9 diorama steps auto-skipped on software-GL captures; failures need a class (environment vs capability), a ladder, a budget, and a PAUSE that reports and asks #294). A goal step gets 60 min of active wall clock (goal_step_minutes,
  CROW_GOAL_STEP_MINUTES). A step with a checklist pauses after 10 nudges with no item newly passed
  (goal_no_progress_turns, CROW_GOAL_NO_PROGRESS_TURNS). The clock stops while the goal is paused. On
  2026-09-24/25 step 5 carried 8 idle night hours (43,130 s). Not measured live.

Changed

• Voxel kit: live mode path-traces the island; a person's page fills the window (voxel kit v2: animation, orbit, photo mode, props registry, diorama checker -- the kit renders stills only and nothing measures an 'empty' or static diorama #299 follow-up, 9e4daa4,
  2026-09-25). LIVE (the default) now path-traces the static island, which keeps converging while the camera rests,
  and rasterises only the animated parts (d.part) on top, depth-tested against the island. ?mode=raster (alias
  preview) keeps voxel kit v2: animation, orbit, photo mode, props registry, diorama checker -- the kit renders stills only and nothing measures an 'empty' or static diorama #299's flat raster preview, and check_diorama.py takes its motion and repeat captures there,
  because the accumulating path tracer would make a still scene "move". A page opened by a person (ui not 0)
  fills the window at devicePixelRatio (cap 2) and follows resizes; ui=0 (Crow's captures, the checker) keeps
  the fixed width × height at pixel ratio 1. Before: robin opened the flat raster preview after a 6/6 run and it
  looked nothing like the photos, and the fixed 1024×1024 canvas at pixel ratio 1 looked pixelated on his scaled
  1440p screen. Node tests for the mode parser and the checker only; the live mode is not measured on the GPU.

• Scrollbars show only while their strip is scrolled or pointed at (Every scroll strip in the window and the phone mirror shows its scrollbar thumb at rest (stats line, Code panel, chat): scrollbars should appear only while scrolled or hovered #305, 2026-09-25). Every scroll container in
  the window and the phone mirror — the chat, the per-turn stats line ([24 rounds | … tok/s | prefill …]), code
  blocks, tables, the Code/Tool-Calls, git, goal and Subtasks panels, the rail, settings, menus — now draws a
  transparent thumb at rest. It appears on any scroll (wheel, keyboard, touch, drag) and goes 0.8 s after the last
  scroll event; a held pointer keeps it; a mouse pointer over the strip shows it (@media (hover:hover), so not on
  a phone). Only the colour changes: bar widths, the 10 px chat gutter and the column do not move. Before: the thumb
  was drawn permanently on every strip. Source and node-run tests only; not yet seen in WebKitGTK, WebView2 or on
  iOS (robin's live check).

• render_page renders on the GPU only (render_page silently rasterised on SwiftShader and captured one still: a 16-hour diorama run was judged on 1-spp CPU noise (35 of 42 results software) -- GPU only with a renderer check, deterministic multi-frame capture, pixel prechecks #293, 2026-09-25). The SwiftShader fallback is gone. Below the VRAM
  bound (512 MiB, or 1,536 MiB with the panel open), or when the browser's own UNMASKED_RENDERER_WEBGL is
  software (SwiftShader, llvmpipe, lavapipe) or not the NVIDIA card, the result is error: ENVIRONMENT -- ...
  naming the free VRAM or the renderer string, and no image comes back. The renderer is read before the page
  loads and again after the last capture. Before: in the 2026-09-24/25 diorama run, 35 of the 42 surviving
  results were software (swiftshader) captures taken at 51–317 MiB free. ANGLE runs on Vulkan first, with one
  retry on --use-gl=angle (CROW_RENDER_ANGLE pins one). CROW_RENDER_GL=swiftshader is now a refusal. Chromium
  152 still hands WebGL to SwiftShader under --disable-gpu, even without --enable-unsafe-swiftshader (measured,
  the smoke above); the renderer check is what caught it. On Windows the renderer cannot be read (no DevTools pipe),
  so it says unverified, and frames > 1 is refused there.

• render_page lets path-traced kit pages wait up to 120 s (render_page cut path-traced pages to 20 s like any other page: the lighthouse night photo stopped at ~295 samples, stayed grainy, and the goal paused offering to shrink the scene -- kit pages need a longer wait ceiling #302, 2026-09-25). A local page that carries the
  voxel kit's [crow-pt] marker gets a wait_ms ceiling of 120,000; every other page keeps 20,000 (render_page's software-WebGL renderer ran away to 54 GiB and froze the machine, and its blank captures left the model grading empty screens - the render subprocess needs a memory ceiling, GPU-when-free, and degenerate-capture detection #213). The
  pathtracer skill asks for 60,000–120,000 on night or dark scenes and says never to shrink the scene to fit a short
  capture. Before: the 2026-09-25 lighthouse goal run capped every photo at 20 s, which held ~295 samples (291.5,
  295.5, 298), stayed grainy, and paused step 2 with an offer to shrink the scene. At the measured ~15 samples/s at
  1024² (RTX 5090), 90 s holds ~1,350 samples. Not measured live.

• A failed goal step is never skipped by the engine; it climbs a ladder and then pauses and asks (goal: a step that fails twice is skipped without asking -- 4 of 9 diorama steps auto-skipped on software-GL captures; failures need a class (environment vs capability), a ladder, a budget, and a PAUSE that reports and asks #294,
  2026-09-25, replaces goal: a 'failed' step is sent back as the next step forever (step 4 looped ~40 min after the model failed it honestly), and robin has no /goal skip #289's skip). Each failure has a class. Environment (render_mode unavailable, software on a
  GPU step, blank or identical frames, no judge answered): two retries 15 s apart, then pause. Capability (a valid
  capture the judge does not pass): a written reflection, then attempt 3 in a fresh context, then a split into 2–3
  sub-steps (goal_step(n, "split", substeps=[…]), reported with sub), then pause. The 25-turn and 60-turn caps
  and the budget pause too. On every pause the model writes robin a report: what it found, why it cannot go on,
  2–3 proposals, and whether he has more input. The report is shown in the window and on the phone. Only a typed
  line resumes. Before: the 2026-09-24/25 diorama run ended "complete with 4 skipped", with steps 5–8 skipped on
  software-GL captures and nobody asked. After: 0 skips without /goal skip in the unit replay. Not measured live.

Fixed

• A skip stored as done, and skipped drawn in the running step's amber (goal: robin's skip of step 4 is stored as 'done' (counted 5/9), and the bar draws 'skipped' in the same amber as 'running' #296). A done step whose note starts
  with "skipped" loads as skipped, which repairs the 2026-09-24 hand edit of step 4 (counted 5/9, now 4/9). The
  model can no longer set a user-skipped step done or running; /goal redo <n> reopens it. In the goal bar
  (window and phone), skipped has its own colour (--skip, violet), a dashed ring with a skip glyph and the word
  "skipped". Running keeps amber with a dot. A paused step shows a red pause glyph, and the head reads
  "Paused · step N".
• read_file refuses images and other binary files, and names read_image (read_file dumps an image's bytes as text: the lighthouse run read reference/island.png as 16,000 chars of mojibake, blamed read_image and saved that into MEMORY.md -- refuse binary files and name read_image #301, 2026-09-25). A file whose
  first 8,000 bytes hold a NUL, or that starts with a PNG/JPEG/GIF/WebP/BMP/PDF signature, is detected by its
  content, not its extension. It gets one line instead of bytes decoded as text: error: …/island.png is a PNG image (543x768, 502,797 bytes) -- read_file returns text only; use read_image to see it. A PDF names pdftotext, other
  binaries file/xxd. Before: the 2026-09-25 lighthouse run got 16,056 characters (~5,946 tokens) of mojibake for
  reference/island.png, blamed read_image and saved "read_image returns raw bytes" into .crow/MEMORY.md.
  UTF-8 text reads as before, including a multi-byte character at the 8,000-byte edge. read_image on a missing
  -crop.png whose frame exists now says a crop is written only under 50 % coverage and names the frame. Before: a
  bare no such image, twice in the same run. Not measured live.
• A window started with --root keeps that folder when it restores the last chat (A window started with --root loses it to roots.json 'active' when the last chat is restored: lighthouse-test run bound diorama-test, goal bar gone #303, 2026-09-25).
  crow --root DIR now binds DIR for the restored chat and saves DIR as the folder the next start opens (active in
  roots.json), the same as a pick in the chip. Before: on 2026-09-25 15:19, --root …/lighthouse-test restored the
  chat "Voxel" (no folder of its own) into diorama-test, the last folder picked in the chip (09:45). The goal bar
  disappeared, and the next line ran in the wrong folder. A restored chat that recorded another folder is moved to DIR:
  the model gets A working-area rebind is silent to the model #224's notice, and the memory head is rebuilt only if it named the other folder. Without --root,
  nothing changes. The terminal already let --root win. Covered by 4 window tests, 2 of them red without the fix;
  not verified live.
• check_diorama.py borrows VRAM from serve like a Crow turn does (check_diorama.py runs outside a Crow turn, so render_page never borrows VRAM from serve: the lighthouse gate failed all 10 checks at 280 MiB free #304, 2026-09-25). The checker runs as its
  own process, outside any Crow turn, so render_page cannot render under crow-nest serve: 0.07-0.5 GiB free against the 512/1536 MiB bound, and Crow never borrows VRAM from the idle engine -- lend around the capture (crow-nest#117), return in a finally, judge after the return #297's lending had no endpoint and never asked serve. It now names the local
  serve before the first capture: --serve (default http://127.0.0.1:8099/v1, env CROW_SERVE_URL, none = never
  borrow). Before: on 2026-09-25 ~15:35 the lighthouse goal's check.sh failed all 10 checks with the ENVIRONMENT
  error at 280 MiB free while serve held the card, and crow.log had no render: line for it; render_page inside the
  same turn had borrowed 582 MiB twice minutes earlier. Covered by 3 tests, red without the fix; not verified live.

Known limitations

• Agent-built dioramas stay far below the references, and robin did not accept them. The voxel kit renders
  reference-grade stills: proven with a hand-built scene (2026-09-25, RTX 5090). In the 2026-09-25
  lighthouse goal run the agent-built diorama stayed far below robin's reference images: crude props, a flat
  pond, and a lighthouse beam that read as a windmill. robin did not accept the result.
• The diorama gates do not measure visual quality against references. check_diorama.py and the judge's
  checklist measure the GPU, sample counts, prop counts and kinds, voxels, coverage, motion, repeatability, a
  near-uniform/near-black precheck and page errors. A page can pass every gate and still look nothing like the
  reference; reference: items are advisory until calibrated, and --reference only prints luma/saturation.
• Live checks pending for every ticket in this release (render_page silently rasterised on SwiftShader and captured one still: a 16-hour diorama run was judged on 1-spp CPU noise (35 of 42 results software) -- GPU only with a renderer check, deterministic multi-frame capture, pixel prechecks #293–voxel kit v2: animation, orbit, photo mode, props registry, diorama checker -- the kit renders stills only and nothing measures an 'empty' or static diorama #299, read_file dumps an image's bytes as text: the lighthouse run read reference/island.png as 16,000 chars of mojibake, blamed read_image and saved that into MEMORY.md -- refuse binary files and name read_image #301–Every scroll strip in the window and the phone mirror shows its scrollbar thumb at rest (stats line, Code panel, chat): scrollbars should appear only while scrolled or hovered #305): unit tests, node runs, a fake
  serve and GPU smokes of the scaffold only. The lend (render_page cannot render under crow-nest serve: 0.07-0.5 GiB free against the 512/1536 MiB bound, and Crow never borrows VRAM from the idle engine -- lend around the capture (crow-nest#117), return in a finally, judge after the return #297, check_diorama.py runs outside a Crow turn, so render_page never borrows VRAM from serve: the lighthouse gate failed all 10 checks at 280 MiB free #304) was tested against a fake serve; the path-traced
  live mode (9e4daa4) and the 120 s wait (render_page cut path-traced pages to 20 s like any other page: the lighthouse night photo stopped at ~295 samples, stayed grainy, and the goal paused offering to shrink the scene -- kit pages need a longer wait ceiling #302) were not run on the GPU for this release.
• Windows: render_page cannot read the renderer there (no DevTools pipe), says unverified and refuses
  frames > 1 (render_page silently rasterised on SwiftShader and captured one still: a 16-hour diorama run was judged on 1-spp CPU noise (35 of 42 results software) -- GPU only with a renderer check, deterministic multi-frame capture, pixel prechecks #293). install.ps1 -PathTracer, install.ps1 -Selftest and tools/pack-release.ps1 were not run
  for this release (no PowerShell on the Linux release machine).
• check_gui_prereqs (not in CI) reports 2 of 3 prerequisites: point (ii), 26 glyph problems over the 2 shipped
  Google Sans Code faces, unchanged since 2.6.0.
• Not in this release: [meta] crow-nest toward a model-agnostic engine: 27B CNQ, images #300 (image generation beside a live session: decision open). Still open from 2.5.0: the
  Windows installer bundle (CrowSetup.exe: full-stack installer (Crow + crow-nest + CNQ) #196); sampling_no_thinking's presence_penalty 1.5 (presence_penalty 1.5 in the unused no-thinking sampling row #246).

🤖 Generated with Claude Code

https://claude.ai/code/session_01LyBV1tX2JWocGLTjFkNYMh