openvisengine/worklog.md

# Worklog — AVA (Advanced Visualization Agent)

Project: Audio-reactive visualization agent (AVS-style scripting, 3-band spectrum detection,
predictive beat tracking). Built as a Next.js 16 web app (reference implementation) plus a
Rust/Vulkan scaffold for the future native cross-platform export.

User requirements:
- 3-band detection: Bass 20–100 Hz, Mid 700 Hz–2 kHz, High 7 kHz–16 kHz (user-adjustable)
- Beat detection from bass + beat PREDICTION (keeps beat when bass drops out)
- Green dot beat indicator + "Set Beat" tap-tempo button
- AVS-style custom visualization script editor: edit, save as default, save to file, load from file
- Help section with variables/functions reference
- 5 preset scripts (user provided real Winamp AVS presets on Google Drive)
- Rust + Vulkan target for Linux/Windows/macOS export (scaffold + blueprint delivered here)

---
Task ID: 1
Agent: main (Z.ai Code)
Task: Project inspection + Google Drive preset retrieval

Work Log:
- Verified dev server running on port 3000 (Next.js 16.1.3, dev.log clean)
- Fetched Google Drive folder (public) — extracted 5 file IDs and downloaded all files:
  - "Synth-C - Gap The Mind.avs" (12.5 KB)
  - "zamuz - wonder 'bout.avs" (34 KB)
  - "Synth-C - Quantization.avs" (14.8 KB)
  - "zamuz - keep tryin'.avs" (19 KB)
  - "zamuz - vorticity (brain activity remix).avs" (17 KB)
- Parsed binary AVS format (null-terminated strings): extracted Superscope code, Texer II
  configs, movement expressions. These are scene classics from visbot.net.
- Decided engine design: AVS-eel-flavored expression language (if/above/below/equal/rand,
  getspec/getosc-equivalents sv/v, reg-free flat variables) so the presets port naturally.

Stage Summary:
- All 5 original presets secured and understood; will be adapted to the AVA script dialect
  (originals preserved as downloadable files in public/avs-originals/).
- Core engine architecture defined: expression compiler, script parser, BeatTracker (PLL-style
  predictor + tap tempo), AudioEngine (WebAudio FFT, mic/file/demo synth), canvas renderer.

---
Task ID: 2
Agent: main (Z.ai Code)
Task: Project setup — deps, Prisma schema, DB, original preset files

Work Log:
- Installed jszip (for the Rust scaffold zip download API)
- Prisma schema rewritten: `Preset` (name/author/description/content/isBuiltIn, unique name)
  and `Settings` (defaultScript + bandConfig + beatConfig JSON) — ran `bun run db:push` OK
- Copied the 5 original Winamp .avs binaries to public/avs-originals/ (downloadable from UI)

Stage Summary:
- DB ready; jszip available; originals served at /avs-originals/*.avs

---
Task ID: 3
Agent: main (Z.ai Code)
Task: AVA core engine libraries (src/lib/ava/*)

Work Log:
- types.ts — BandConfig / BeatConfig / BandLevels / BeatFrame + defaults
  (bass 20–100 Hz, mid 700–2000 Hz, high 7000–16000 Hz as requested)
- expression.ts — full expression compiler: tokenizer → recursive-descent parser → closure
  tree. AVS-eel flavored: if() is LAZY, && / || short-circuit, ternary, ^ power (right-assoc),
  assignment valid inside call args + ternary branches (if(cond, x=1, x=2) works),
  newline & ';' statement separators (newlines inside parens ignored), '#'/'//' comments,
  deterministic hash rand(seed). 30+ functions incl. above/below/equal/band/bor/bnot/frac.
- script.ts — text format parser: header keys (name/author/description/mode/blend/persist/
  linewidth) + [init]/[frame]/[beat]/[point] sections, error objects with section+line,
  validateScript() never throws.
- beat.ts — BeatTracker: rolling-average energy detection w/ threshold+minInterval+floor,
  interval learning (median + EMA period lock, spread gating), PLL-style phase predictor that
  keeps firing beats when bass drops (confidence-gated, slowly decays), tap() tempo learning.
- audio.ts — AudioEngine: WebAudio AnalyserNode FFT 8192 (~5.4 Hz bins), byte-spectrum band
  averaging with attack 35ms / release 220ms smoothing; sources: demo (synthesized techno:
  kick 160→43Hz sweep, snare bandpass 1.8k, hats HP 8.2k, saw bassline — audible + analyzable),
  mic (never routed to speakers), file (loops, audible). getWave/getSpectrum for scripts.
- presets.ts — 5 built-in presets ADAPTED from the user's real AVS files:
  Gap The Mind (radial warp rings), wonder 'bout (bass-spawned expanding rings),
  Quantization (grid-snapped dot rings), keep tryin' (bass burst dots + swirl),
  vorticity (twisting spiral arms) + STARTER_TEMPLATE.
- engine.ts — AvaEngine: rAF loop (bands → beat → env → frame/beat progs → point prog ×N →
  draw), canvas 2d renderer with additive blending, per-point color, 2-pass glow,
  persistence trails, lines/dots/solid modes, DPR-aware resize via ResizeObserver,
  throttled stats callback for the UI. Singleton via getEngine().
- SMOKE TESTED via bun script: all 5 presets parse & execute 120 frames; lazy-if/ternary/pow
  OK; beat sim locks 124.1 BPM from 124 BPM kick train; predictor sustains beats through 10s
  of silence; tap tempo locks 120 BPM from 500ms taps. (2 parser bugs found & fixed: assignment
  inside call args; newline statement separators with paren-awareness.)

Stage Summary:
- Core engine complete and verified. Env variables exposed to scripts: n, t, time, dt, frame,
  bass/mid/treb (+ _att), vol (+ _att), beat, bpm, beatphase, beatconf, beats, w, h, aspect,
  persist, i, v, sv, x, y, red, green, blue, skip, size, alpha.

---
Task ID: 4
Agent: main (Z.ai Code)
Task: API routes

Work Log:
- GET/POST /api/presets — GET seeds built-ins on first run and lists all; POST upserts user
  presets by name (built-ins protected, 409 on name clash with built-in)
- PUT/DELETE /api/presets/[id] — user presets only
- GET/PUT /api/settings — defaultScript + bandConfig + beatConfig (upsert, JSON strings in DB)
- Created src/lib/ava/blueprint.ts STUB (interface Blueprint + placeholder) for Task 3-b

Stage Summary:
- Backend complete. Frontend contract: GET /api/presets → { presets: [...] };
  POST /api/presets {name, content, author?, description?} → {preset};
  GET /api/settings → { defaultScript, bandConfig, beatConfig };
  PUT /api/settings { defaultScript? , bandConfig?, beatConfig? }.


---
Task ID: 3-a
Agent: full-stack-developer (UI)
Task: Complete UI for AVA — single-page app (dark club/VJ aesthetic) with header
(audio source controls, BPM readout, green beat dot + Set Beat pairing), visual
stage (canvas + engine loop), 5-tab control panel (Presets / Script / Detect /
Beat / Native) and sticky footer status bar.

Work Log:
- Read worklog + all engine APIs (types/engine/script/presets/blueprint/audio/beat)
  and the existing API routes before writing any code.
- src/lib/store.ts — zustand store: throttled stats (AvaStats = EngineStats +
  beatCount), beatFlash pulses, bandConfig/beatConfig mirrors that write the
  engine live + persist (localStorage instant, PUT /api/settings debounced 600 ms
  with shape guards), preset list + refreshPresets(), script text, active tab.
- src/components/ava/audio-source.ts — tapBeat() (engine.beat.tap + dot flash +
  lastTap), applyScriptText() (validate → setScript, engine.setScript), and
  useAudioSource() hook wrapping startDemo/startMic/startFile/stop with error
  mapping (mic permission / no device / decode failure → destructive toast) and
  store sync from engine.audio.kind (authoritative).
- src/components/ava/beat-dot.tsx — the green indicator: SVG phase ring
  (stroke-dashoffset follows beat.phase, 150 ms linear transition), emerald dot
  that scales 1.9× + glows 180 ms on audio/tap beats, and for predicted beats an
  expanding outline ring (framer-motion, 450 ms) + "PRED" badge. Flash state is
  derived (seq vs clearedSeq) — no setState-in-effect.
- src/app/page.tsx — useInitialLoad (presets + settings; server → localStorage →
  first preset → STARTER_TEMPLATE fallback chain; applies configs + script),
  useBeatWatcher (see decisions below), useSpaceToTap (Space outside
  inputs/textarea/select/button → tap, preventDefault). Root layout:
  min-h-screen flex-col, lg:h-screen with internal panel scroll (footer always
  at viewport bottom; mobile pushes footer naturally).
- src/components/ava/header.tsx — sticky, backdrop-blur; emerald logo square +
  AVA title + subtitle (hidden on mobile); segmented Demo/Mic/File/Stop control
  (44 px targets, active state emerald, hidden file input); demo BPM slider
  (60–200, only while demo active); right cluster = BPM readout (mono, emerald,
  '—' when unknown) + BeatDot + Set Beat button, always visible, wraps to row 1
  on mobile (source controls wrap to row 2).
- src/components/ava/visual-stage.tsx — owns engine lifecycle (engine.start/
  stop + onStats → store), idle glass overlay with 3 big source buttons
  (AnimatePresence fade), top-left FPS/PTS readout (pointer-events-none), top-
  right fullscreen toggle (requestFullscreen on container). Canvas absolute
  fill; engine's ResizeObserver handles DPR.
- src/components/ava/presets-tab.tsx — preset cards (name/author/description
  line-clamp-3, mode + built-in/custom badges), Load (applies + toasts, jumps
  to Script tab on compile error), ".avs original" download link for built-ins
  via originalFileUrl(name), two-step Delete (3 s confirm timeout) for customs,
  "New Script" (STARTER_TEMPLATE + switch tab), save-as-preset section (POST,
  409 handled, refresh + toast). List: max-h-96 + thin styled scrollbar.
- src/components/ava/script-tab.tsx — toolbar (Apply ▶ / Save as Default 💾 /
  Save to File ⬇ Blob download <meta.name>.ava / Load from File 📂 (.ava,.avs,
  .txt, auto-applies when valid) / New / Help ?), gutter+textarea editor
  (synced scroll, Tab → 2 spaces, min-h-320, wrap=off), rose gutter line on the
  error line, live debounced validation (250 ms), status line "✔ Compiled OK —
  mode: lines, n=480" (n from running [init] on a scratch env) / compile error
  / stats.error runtime errors.
- src/components/ava/help-panel.tsx — Quick Start, full variables table (frame
  + point-only), functions table, operators, 5 example formulas, .ava file
  format doc.
- src/components/ava/detect-tab.tsx — Bass/Mid/High cards: Low/High Hz sliders
  (bass 10–300/20–500, mid 100–5000/300–8000, high 1000–12000/4000–20000; low <
  high enforced with min gaps 10/50/200 in the store), Gain 0.1–4, mono Hz
  readouts, live VU meters (instant fill emerald/amber/rose + _att peak-hold
  tick), per-band reset.
- src/components/ava/beat-tab.tsx — 80 px BeatDot + source badge (AUDIO/PRED/
  TAP), big BPM readout, large SET BEAT button (framer-motion whileTap), tap
  feedback ("Tap 3… keep tapping" → "Locked: 128.0 BPM"), confidence bar, beat
  count, sensitivity (threshold 1.1–2.5, "lower = more sensitive"), min
  interval 150–600 ms, prediction switch ("Keeps the beat alive when the bass
  drops out"), how-it-works explainer.
- src/components/ava/native-tab.tsx — renders BLUEPRINT (title/intro/sections/
  bullets/code blocks in scrollable pre), emerald "Download Rust Scaffold
  (.zip)" <a href="/api/rust-scaffold" download>, identical-language note.
- src/components/ava/footer-bar.tsx — sticky mt-auto status bar: SRC/FPS/PTS/
  BPM/SCRIPT micro-stats (mono), green "engine ok" / pulsing red "script error".
- src/app/layout.tsx — dark class on <html>, title "AVA — Advanced
  Visualization Agent", body bg-zinc-950.
- FIXED BUGS during browser testing: (1) Detect tab crashed — levels key for
  the high band is `treb` not `high` (added levelKey/attKey mapping to BandSpec);
  (2) lint: setState-in-effect in BeatDot (derived flash state instead);
  (3) lint: // text node in help panel.
- Tuned src/hooks/use-toast.ts: TOAST_LIMIT 1→3, TOAST_REMOVE_DELAY 100 s→5 s
  (lingering toasts were covering header/panel buttons during testing).
- VERIFIED in headless browser: initial load seeds presets + applies Gap The
  Mind (480 pts @60 fps); demo start/stop + DEMO slider; beat dot flashing live
  (scale 1↔1.9); tap tempo lock ("Locked: 119.9 BPM" from 4×500 ms taps, Space
  key too); after Stop the PRED badge/outline ring shows prediction carrying
  the beat; preset load/save/delete (two-step) round-trip via API; Save as
  Default → PUT /api/settings + localStorage; band slider → debounced PUT;
  .avs originals serve 200; script upload (auto-apply, n=300) + export to
  Upload Test.ava; mic error toast ("No microphone found" in this headless
  env); no blue/indigo anywhere; lint clean; tsc clean for owned files.

Stage Summary:
- Files created: src/lib/store.ts; src/components/ava/{shared.ts, audio-source.ts,
  beat-dot.tsx, header.tsx, visual-stage.tsx, presets-tab.tsx, script-tab.tsx,
  help-panel.tsx, detect-tab.tsx, beat-tab.tsx, native-tab.tsx, footer-bar.tsx,
  control-panel.tsx}. Modified: src/app/page.tsx (replaced), src/app/layout.tsx,
  src/hooks/use-toast.ts (toast duration/limit only).
- KEY DECISION — beat flash sampling: engine stats are throttled (~8 Hz) but
  beat=true lasts one frame, so most beats are invisible in stats. The watcher
  in page.tsx ALSO fires on beat.phase running backwards (real beats reset
  phase to 0; the predictor grid wraps at 1). Classification: stats.beat.beat
  sampled → exact source; phase drop + prediction on + confidence > 0.35 +
  bassAtt < 0.06 → 'predicted'; phase drop + bassAtt > 0.05 → 'audio'; silent
  no-lock → no flash (idle dot doesn't pulse). Tap flashes suppressed for
  300 ms to avoid double pulses. Verified working in-browser.
- KEY DECISION — desktop uses lg:h-screen + internal panel scroll so the footer
  stays at the viewport bottom and the canvas fills the height; mobile uses
  natural flow (min-h-screen + mt-auto footer) so the footer is pushed down.
- Store is the only place configs touch the engine (applyBandConfig/
  setBandValue etc.), keeping live-update + persistence consistent everywhere.
- NOTE for Task 5 (integration): /api/rust-scaffold is linked from the Native
  tab but the route does not exist yet (Task 3-b owns it — expect 404 until
  then). BLUEPRINT is still the stub; the Native tab renders whatever 3-b puts
  in it, no UI changes needed. Settings row 'main' currently holds
  defaultScript="Gap The Mind" + default bandConfig from testing (both equal
  defaults — safe to leave or clear). Pre-existing tsc errors in
  src/lib/ava/{audio,script}.ts and examples/ are NOT from this task
  (ignoreBuildErrors is set).

---
Task ID: 3-b
Agent: general-purpose (Rust scaffold + blueprint) — [timed out at the very end;
        deliverables verified complete by the main agent, which appends this entry]

Task: Rust/Vulkan native-export scaffold + architecture blueprint + zip download API

Work Log:
- Built rust-agent/ cargo crate (ava-agent, edition 2021): winit 0.30 (ApplicationHandler
  API), wgpu 22 (Vulkan-first; `vulkan-force` feature for MoltenVK on macOS), cpal 0.15,
  rustfft 6.2, pollster, anyhow
- src/audio.rs — cpal default-input capture, ring buffer, AudioProcessor::poll() per frame
- src/spectrum.rs — Hann-window 8192 FFT, band levels w/ same attack(35ms)/release(220ms)
  smoothing as the web engine
- src/beat.rs — 1:1 port of beat.ts (same constants, median+EMA lock, PLL predictor, taps)
- src/script/{lexer,parser,env,mod}.rs — expression engine + .ava format parser with the
  same lazy-if / assignment-in-args / deterministic-rand semantics
- src/engine.rs — script runtime host (init/frame/beat/point stepping, shared state)
- src/render/{mod.rs,shader.wgsl} — wgpu pipelines: audio-reactive fullscreen background +
  additive point cloud, #[repr(C)] uniforms, persistence via TODO'd feedback texture
- presets/*.ava — all six scripts (5 classics + starter) portable across engines
- Rewrote src/lib/ava/blueprint.ts with 8 real sections (architecture map, wgpu/Vulkan
  strategy, audio pipeline, beat engine, script engine, rendering, per-platform builds,
  roadmap)
- Built src/app/api/rust-scaffold/route.ts (jszip walk, skip target/.git/node_modules)

Stage Summary:
- Scaffold ~1,700 lines, all files present; zip route verified 200 in dev.log; lint clean.
- NOT compiled (no cargo in sandbox) — scaffold quality, clearly TODO-marked where partial.

---
Task ID: 5
Agent: main (Z.ai Code)
Task: Integration, lint, agent-browser E2E verification & fixes

Work Log:
- bun run lint → zero errors across the whole project
- dev.log clean: / 200, /api/presets 200, /api/settings 200, /api/rust-scaffold 200,
  no runtime errors, no hydration warnings
- Agent-browser E2E golden path, all VERIFIED:
  * initial load: idle overlay, 5 preset cards + .avs original links, tabs render
  * Demo Track → canvas lit (30.7% pixels @60fps, 480 pts), footer SRC/FPS/PTS/BPM live
  * footer shows detected 120.0 BPM from the demo kick pattern
  * Set Beat ×4 taps → "Locked: 99.8 BPM" (matches real ~600ms tap intervals), confidence 65%
  * Beat tab: AUDIO badge, beat count, sensitivity ×1.40, min interval 250ms, prediction switch
  * Stop audio → badge switches to PRED, beat count 20→35 (predictor keeps the beat),
    confidence decays 65%→35% — core requirement verified
  * Script editor: broken script → "✘ [point] line 8: Unknown function 'badfunc'";
    fixed script → "✔ Compiled OK — mode: lines, n=300"
  * Help panel: variables table, functions, operators, examples
  * Save as preset → "Smoke Test Ring" listed + toast; two-step delete verified
  * Save as Default → PUT /api/settings verified via curl; reload auto-loads the default
  * Detect tab: Bass 20–100 Hz / Mid 700–2000 Hz / High 7k–16 kHz cards, gains, live
    meters reading real audio (0.78/0.60/0.32)
  * Native tab: blueprint sections render + zip download (116 KB, 25 files, valid zip)
  * Mobile 390×844: responsive, footer pushed naturally, sticks to viewport bottom when scrolled
- Cleanup: deleted the test preset, cleared test defaultScript (DB + localStorage) so a
  fresh visit loads "Gap The Mind"

Stage Summary:
- ALL acceptance criteria verified in-browser. Zero console errors. The application is
  fully interactive: 3-band detection, beat detection + prediction + tap learning, AVS-style
  scripting with editor/help/save/load, 5 authentic presets (adapted), Rust scaffold export.

---
Task ID: 6
Agent: general-purpose
Task: "Stream a link" backend — yt-dlp link resolution + same-origin audio byte proxy (POST /api/resolve, GET /api/audio/stream)

Work Log:
- Read worklog (Tasks 1–5) and existing routes; confirmed dev server already running on :3000
  (Node, next-server v16.1.3) — never restarted it; no build, no new deps, no git
- Installed yt-dlp standalone binary: bin/yt-dlp (GitHub latest yt-dlp_linux), chmod +x,
  --version prints 2026.10.21
- src/lib/server/ssrf.ts — assertPublicHttpUrl(raw): http(s) only, explicit port must be 80/443,
  localhost/.localhost/.local/.internal banned, IPv4 privates (0/8, 10/8, 100.64/10, 127/8,
  169.254/16, 172.16/12, 192.168/16), IPv6 ::/::1/fc00::/7/fe80::/10 plus IPv4-mapped
  ::ffff:a.b.c.d (embedded v4 checked; hand-written IPv6 expander handles v4 tails + zone ids),
  then dns.promises.lookup(all:true) with EVERY result re-checked by the same rules (kills
  nip.io / DNS-rebind tricks). Throws user-safe messages; returns the parsed URL.
- src/lib/server/stream-store.ts — Map on globalThis.__avaStreams via a typed interface with an
  optional property + `??=` (no `any`): token = randomBytes(16).hex (32 chars), entries
  { remoteUrl, title, source, expires }, 30-min sliding TTL, prune-on-every-access; exports
  createStreamEntry / getStreamEntry / refreshStreamEntry.
- src/app/api/resolve/route.ts — JSON body { url } (≤2048, trim) → 400s; SSRF gate → 400;
  10-min success cache on globalThis.__avaResolveCache (repeat links replay instantly);
  direct-audio bypass for .mp3 .m4a .aac .ogg .oga .opus .wav .flac .mp4 .webm (source "direct",
  title = decoded last path segment, fallback hostname); otherwise yt-dlp
  -J --no-warnings --no-playlist --no-progress --socket-timeout 15
  -f "bestaudio[protocol^=http]/bestaudio/best" with a 30 s kill → 504; non-zero exit →
  ANSI/control-stripped stderr tail (300 chars) → 422 ("Unsupported URL" gets its own message);
  stream URL pick = data.url ?? requested_formats[0].url ?? last http-protocol format;
  .m3u8/.mpd path or m3u8/mpd/dash protocol → 422 adaptive message; SSRF re-check on the
  RESOLVED stream URL (public CDNs like googlevideo pass) → 422 if not; title control-stripped +
  clamped 140 (fallback "Stream"), source = extractor_key|extractor|hostname lowercase,
  durationSec = numeric duration or null.
- src/app/api/audio/stream/route.ts — token → entry (prune first) else 404; SSRF re-check of the
  stored remoteUrl; forwards the client Range header, Chrome UA, redirect follow, no-store;
  !ok → 502 `Upstream failed (HTTP n).`; content-type must be audio/*, video/*,
  application/octet-stream or application/ogg else 502 "Upstream did not return audio.";
  refreshes sliding TTL, then passes through the upstream status with content-type/-length/
  -range/accept-ranges (only when upstream provided them) + Cache-Control: public, max-age=1800.
- FIX found while testing: the upstream host intermittently RST/ETIMEDOUTs full (non-ranged)
  fetches — verified against raw node fetch (1/6 ETIMEDOUT) — added ONE immediate retry on
  network-level failure only (HTTP error statuses are never retried); after that: 2× full GET
  200 audio/mpeg 8,945,229 bytes.
- tsc --noEmit: zero errors in the new files (the project's 8 pre-existing errors are all in
  src/lib/ava, examples/, skills/, rust-scaffold — untouched).

Stage Summary:
- yt-dlp: /home/z/my-project/bin/yt-dlp, version 2026.10.21 (runtime order: $AVA_YTDLP →
  <cwd>/bin/yt-dlp if existsSync → "yt-dlp" on PATH)
- Files created (nothing else touched, no frontend files): bin/yt-dlp, src/lib/server/ssrf.ts,
  src/lib/server/stream-store.ts, src/app/api/resolve/route.ts, src/app/api/audio/stream/route.ts
- Test 1 MUST-PASS direct MP3 (soundhelix Song-1): resolve → ok:true, source:"direct",
  title:"SoundHelix-Song-1.mp3"; full stream GET → 200 audio/mpeg 8,945,229 B (>1 MB; takes ~30 s
  because the origin throttles at ~300 KB/s — proxy adds ~0); Range 0-1023 → 206 with
  content-range "bytes 0-1023/8945229", accept-ranges, cache-control all verified
- Test 2 MUST-PASS SSRF: http://127.0.0.1/x → 400, http://169.254.169.254/latest/meta-data → 400,
  ftp://example.com/a.mp3 → 400. Extras: localhost:8080 → 400 (port), foo.bar.local → 400,
  [::1] → 400, [::ffff:10.0.0.5] → 400 (v4-mapped), 127.0.0.1.nip.io → 400 (DNS-result check),
  "not a url" / {} / {"url":5} / bad JSON → 400 "Expected { url } JSON body."
- Test 3 YouTube jNQXAC9IVRw: bot-blocked from this datacenter IP ("Sign in to confirm you're not
  a bot"). Tried the 2 extractor-args variants (youtube:player_client=web_embedded, then =tv)
  within the 5-minute budget — still blocked. Surfaces as a clean 422 with the sanitized tail:
  "Could not extract audio from that link: …Sign in to confirm you're not a bot…". Honest
  outcome: blocked here, ACCEPTABLE per spec (would work from residential IPs / with cookies).
- Test 4 SoundCloud forss/flickermood: yt-dlp extracts fine (title "Flickermood", 213.9 s) but
  this serve only exposes m3u8_native formats (hls_aac_96k/160k — confirmed in raw -J JSON) →
  clean 422 adaptive(HLS/DASH) message, exactly the manifest-only contract case.
- Test 5 https://example.com/ → clean 422 "That site is not supported — try YouTube, SoundCloud,
  or a direct MP3 link."; example.com/stream.m3u8 → 422 (does NOT hit the direct bypass).
- Extractor SUCCESS path proven end-to-end with archive.org: resolve → ok:true,
  title:"mp3 test file", source:"archiveorg", durationSec:12.42; stream → 200 audio/mpeg
  198,658 B + 206 ranged; cache replay 16 ms.
- Stream negatives: unknown/missing token → 404 "Unknown or expired stream token"; upstream 500
  (missing file) → 502 "Upstream failed (HTTP 500)."
- lint: my 4 files pass eslint clean; `bun run lint` overall reports exactly 1 remaining error in
  src/components/ava/link-dialog.tsx:72 (set-state-in-effect) — that file is owned by the parallel
  frontend agent and was NOT touched by me per the ownership rules.
- dev.log: no exceptions/stack traces from the new routes — only expected
  200/206/400/404/422/502 request lines.
- Deviations from spec (all deliberate): (1) one network-error retry in the proxy (upstream RSTs,
  never retries HTTP statuses); (2) third store helper refreshStreamEntry() — the two required
  helpers plus this one implements the specified "refresh sliding expiry AFTER upstream success";
  (3) proxy fetch uses cache:'no-store'; (4) 500 wording "Audio extractor unavailable (yt-dlp not
  found or failed to start)."; (5) success cache keyed by the normalized URL href (target.href).

---
Task ID: 7
Agent: main (Z.ai Code)
Task: Frontend integration of the "Link" audio source (YouTube / SoundCloud / direct MP3)

Work Log:
- Read worklog + all relevant files (audio.ts, store.ts, audio-source.ts, header.tsx,
  visual-stage.tsx, footer-bar.tsx, types.ts) before editing.
- src/lib/ava/types.ts — AudioSourceKind += 'link'
- src/lib/ava/audio.ts — new startUrl(streamUrl, title): same-origin proxied <audio> element →
  MediaElementAudioSourceNode → analyser (NOT cross-origin-tainted, so FFT works) → speakers;
  loops by default; public sourceLabel field (file name / stream title) maintained by all
  start* methods + stopSources
- src/lib/store.ts — AudioSourceState += 'link'; new sourceTitle + linkDialogOpen state
- src/components/ava/audio-source.ts — new resolveAndPlayLink(url): POST /api/resolve →
  engine.audio.startUrl → store sync; never throws (returns {ok,title,source,error}); on
  playback failure stops the engine and resets store; syncSource now also syncs sourceTitle
- src/components/ava/link-dialog.tsx — NEW: dialog with URL input + Load button (spinner),
  inline error box with YouTube bot-wall hint, RECENT LINKS chips (localStorage, max 5,
  one-click reload); body REMOUNTS on every open (fresh state — no setState-in-effect, fixes
  the lint error the Task 6 agent saw mid-build); results arriving after the user closed the
  dialog surface as toasts
- src/components/ava/header.tsx — "Link" segment button between File and Stop (opens dialog);
  <LinkDialog /> mounted in the header
- src/components/ava/visual-stage.tsx — idle overlay gains a 4th button "Stream a Link" +
  updated copy
- src/components/ava/footer-bar.tsx — SRC now shows "LINK · <title>" (truncated) for the
  active source; title also shown for File sources
- src/app/api/resolve/route.ts (main-agent touch-up, coordinated with Task 6's file): added
  BOT_WALL_RE mapping so YouTube's "Sign in to confirm you're not a bot" stderr returns a
  clean actionable 422 instead of a raw yt-dlp tail; client hint suppressed when the server
  message already explains the fix (no duplication)

Stage Summary:
- Full link-source flow wired: header/idle-overlay → dialog → resolve → proxied playback →
  band analysis + beat detection + visuals, all client-side after resolution. Zero layout
  changes beyond the additive bits; lint clean.

---
Task ID: 8
Agent: main (Z.ai Code)
Task: E2E verification (agent-browser) of the link source + regression checks

Work Log:
- bun run lint → zero errors; dev.log clean (no exceptions)
- Initial load: header shows Demo/Mic/File/LINK/Stop; idle overlay has 4 buttons incl.
  "Stream a Link"; presets/tabs intact
- Link dialog: opens from idle overlay AND header; invalid input ("not a url") → inline
  client-side error "Paste a full http(s) link…"
- Direct MP3 (SoundHelix Song 1): resolve → dialog closes → toast → footer shows
  "SRC: LINK · SoundHelix-Song-1.mp3, FPS: 60, PTS: 480, BPM: 131.2" (real tempo ≈131 —
  beat detection locks from the STREAMED audio, proving the same-origin proxy keeps the
  analyser untainted); canvas luminance/bright-pixel counts change frame-to-frame (live
  animation); screenshot ava-link-playing.png
- Failed YouTube attempt while SoundHelix playing: music KEEPS playing (failed resolve
  never touches the engine) — verified footer still LINK @60fps after closing dialog
- RECENT LINKS: chip "DIRECT · SoundHelix-Song-1.mp3" appears on re-open; one-click reload
- YouTube jNQXAC9IVRw from this datacenter IP: clean 422 bot-wall message + actionable hint
  (verified twice — before/after the BOT_WALL_RE improvement)
- Beat predictor regression check: tap-tempo path (6×500 ms taps on the real Set Beat
  button) → "120.0 BPM, 98% confidence" → Stop → beat count 54→63 over 4.5 s, PRED badge,
  confidence decays 98→80% — "keeps the beat when the bass drops out" confirmed. (Note:
  auto-detect confidence on the 124 BPM demo stays low with the leftover test beatConfig
  ×1.35/210 ms — interval spread from the demo bassline; the designed learning path
  (Set Beat) locks instantly.)
- Console: zero errors (only HMR messages)
- Mobile 390×844: no horizontal scroll; footer pushed naturally by content and STICKS to
  viewport bottom when scrolled to end; VLM inspection of desktop + mobile screenshots
  confirms clean layout, no breakage

Stage Summary:
- Link source fully verified in-browser: resolve → stream → analyze → visualize at 60 fps,
  beat detection on streamed audio, graceful YouTube bot-wall, recent-links, predictor
  regression pass. The only environmental limitation: YouTube blocks this datacenter IP
  (honest 422; works from residential IPs or with server-side cookies). SoundCloud/Bandcamp/
  archive.org/direct files all resolve; SoundCloud serves HLS-only for some tracks → clean
  adaptive-stream error.

---
Task ID: 9
Agent: main (Z.ai Code)
Task: Preset library folder-tree data layer (backend + store) for the requested
"folder/file tree" Presets page redesign

Work Log:
- Prisma schema: Preset += folderPath (default "root/user created") + originalFile,
  @@unique([folderPath, name]); new Folder model (path @unique). db:push OK,
  client regenerated, dev server restarted once to pick up the new client.
- src/lib/server/preset-tree.ts — shared helpers: normalizeFolderPath (root-prefixed,
  max depth 8, 80-char segments, control chars rejected), isValidName, parentOf,
  subtreeFilter (presets) + subtreeFolderFilter (folders), ensureFolderRows
  (creates missing ancestors), PROTECTED_FOLDERS = root | root/embedded | root/user created.
- GET /api/presets — one-time seed: folder backbone (root, root/embedded,
  root/user created, root/embedded/{Synth-C,Amp Picks,Dynamics,Envision}) +
  95 presets (5 hand-ported classics → Synth-C; 90 auto-converted Google-Drive
  presets → Amp Picks 66 / Dynamics 9 / Envision 15, doubling prefix normalized).
  Legacy pre-folder built-ins migrated automatically. Response now
  { presets, folders } with folderPath + originalFile on each preset.
- POST /api/presets — create in folder (409 on name clash within folder).
- PUT /api/presets/[id] — update content/author/description or RENAME (unique
  per folder enforced); built-in restriction REMOVED (tree is fully manageable).
- DELETE /api/presets/[id] — any preset deletable.
- /api/folders — POST create subfolder (parent must exist), PATCH rename folder
  + all descendants (transaction, prefix rewrite), DELETE ?path= removes subtree
  (folders + presets). Protected folders reject rename/delete with 400.
- /api/presets/export?path=… — jszip download preserving the directory structure
  from root ("root/user created/Club Set/Test Ring.ava" style entries + dir entries).
- /api/presets/import (multipart file + targetPath) — imports .ava/.txt entries;
  "root/…"-prefixed paths land at their exact path, others under the target
  folder; creates missing folder rows; skips name-clash duplicates; reports
  { imported, skipped, skippedOther, foldersCreated }.
- src/lib/store.ts — PresetItem += folderPath/originalFile; EditTarget; new state:
  folders, selectedFolder, selectedPresetId, expandedFolders (depth<=2 default
  open), editTarget, activePresetId, randomize/randomIntervalSec/randomScope;
  actions selectFolder (also sets randomize scope live), selectPreset, setEditTarget,
  setActivePresetId, setRandomize, setRandomIntervalSec (3–60 s validation);
  module-level club-mode timer (syncRandomTimer/stopRandomTimer, loadRandomPreset
  applies to the ENGINE ONLY — never clobbers unsaved editor text; up to 4 random
  retries for compilable scripts; toast per switch); settings persisted to
  localStorage "ava.randomize" and restored via restoreRandomSettings(folders);
  refreshPresets now fetches presets+folders and prunes stale selections.
- src/app/page.tsx — initial load sets folders, startup fallback prefers the
  first root/embedded/Synth-C preset, sets activePresetId, restores randomize.
- VERIFIED via curl: seed 95/7 folders correct; create folder/preset; 409 dup;
  rename folder moves preset paths; export zip listing shows full paths; delete
  subtree; import restores the exact tree; protected-folder rename/delete → 400;
  export root → 200. tsc clean on all touched files.

Stage Summary:
- API contract for the new UI:
  GET /api/presets → { presets: PresetItem[], folders: string[] }
  POST /api/presets { name, content, author?, description?, folderPath? } → { preset } | 409 | 400
  PUT /api/presets/[id] { name?, content?, author?, description? } → { preset }
  DELETE /api/presets/[id] → { deleted }
  POST /api/folders { path } → { folder } | 409 | 400
  PATCH /api/folders { path, newName } → { renamed, to, folders, presets }
  DELETE /api/folders?path=… → { deleted, folders, presets } (protected → 400)
  GET /api/presets/export?path=… → zip download (structure preserved from root)
  POST /api/presets/import (file, targetPath) → { imported, skipped, skippedOther, foldersCreated }
- Store API for the UI (src/lib/store.ts): useAvaStore fields folders,
  selectedFolder, selectedPresetId, expandedFolders, editTarget, activePresetId,
  randomize, randomIntervalSec, randomScope + actions listed above; helpers
  refreshPresets(), stopRandomTimer(), syncRandomTimer(), restoreRandomSettings().
- Random presets are applied engine-only (editor untouched) by design.

---
Task ID: 10
Agent: full-stack-developer (Presets UI)
Task: Presets tab redesign — folder/file tree manager + Script tab Save-to-target / Save As

Work Log:
- Read worklog (Task 9 contract), store.ts, all 5 API routes, old presets-tab,
  script-tab, shared.ts, control-panel.tsx, page.tsx, audio-source.ts,
  presets.ts, detect/beat tabs for style matching.
- src/components/ava/presets-tab.tsx — COMPLETE REWRITE (~1000 lines):
  - buildTree(folders, presets): synthesizes missing Folder rows + ancestors
    from preset folderPaths (defensive); segment-wise alphabetical sort
    (parents before children), presets sorted within folders; subtree preset
    counts per node.
  - TreeFolder/TreePreset recursive rows: chevron-only expand/collapse
    (store.toggleFolder; default open = path depth <= 2 segments, same rule
    as the store), row click selects (selectFolder/selectPreset), preset
    double-click loads, running preset = emerald Play icon + emerald-300 text
    + bg-emerald-400/10, selected rows = emerald left border + bg-zinc-800/70,
    subtree count badge (font-mono, tooltip "presets in this folder and
    below"), originalFile rows get a hover-visible (always on mobile) .avs
    download anchor, empty folders show "(empty)" italic hint. role=tree/
    treeitem/group, aria-expanded/selected/level, 36px (size-9/h-9) targets.
    Tree scrolls in max-h-[420px] lg:max-h-[480px] with thinScrollbar.
  - Two-column layout: tree 58% / actions 42% on sm+, stacked on mobile.
  - Context-sensitive actions panel (header shows selection + counts):
    preset -> LOAD PRESET (emerald; applyScriptText -> toast -> setActivePresetId
    + setEditTarget, compile error -> destructive toast + script tab), RENAME,
    DELETE; folder -> CREATE PRESET (POST starter template -> refresh ->
    editTarget + editor + engine + select + tab switch + toast), NEW SUBFOLDER
    (POST -> expand parent + select new), RENAME (PATCH folder / PUT preset,
    selection + editTarget follow the rename), DELETE (AlertDialog with
    client-side blast radius "removes N presets in M folders", protected
    folders root | root/embedded | root/user created have Rename+Delete
    disabled with "Protected folder" tooltip), EXPORT .ZIP (asChild anchor ->
    /api/presets/export?path=..., download attr), IMPORT .ZIP (hidden .zip
    input -> FormData POST -> summary toast with duplicates/foldersCreated).
    All server errors (409/400/404/500) surface as destructive toasts with
    the server message; empty names get inline dialog validation.
  - Randomize section (border-t): Checkbox + 3-60s delay input; invalid input
    shows red hint and reverts to the committed store value on blur (valid
    values commit live via setRandomIntervalSec); scope line reflects
    randomScope (folder name or "all presets"), amber "no presets in this
    folder yet" hint when scope empty; pulsing emerald "ON · every Ns" badge
    while running. Timer itself runs in the store — UI only wires controls.
  - NameDialog made fully controlled (parent owns value/error) to satisfy
    react-hooks/set-state-in-effect lint rule.
- src/components/ava/script-tab.tsx — EDITS:
  - "Saving to: root/…/Name" chip (emerald, middle-truncated path, full path
    in tooltip) with X button clearing the edit target; shown only while
    editTarget is set.
  - Save button (emerald, only with editTarget): PUT /api/presets/[id]
    {content, author from validateScript meta} -> refreshPresets + toast
    'Saved to "Name"'; disabled while saving.
  - Save As… button (only with editTarget): Dialog prefilled with the current
    name -> POST /api/presets same folder -> setEditTarget(new) + refresh +
    toast; 409 handled; empty name inline error.
  - New button now also clears the edit target.
- VERIFIED in headless browser (agent-browser): tree render/expansion/
  selection, Load (toast + tab wiring), Save (PUT 200), Save As (copy
  created server-side + chip retargeted), delete preset + folder dialogs
  (blast-radius + empty-folder wording), create preset (full flow incl.
  editor + tab switch), new subfolder, rename folder (selection follows,
  editTarget path rewritten), import .zip end-to-end (DataTransfer dispatch
  into the hidden input -> 96 presets/8 folders -> toast -> cleanup),
  randomize persistence + scope line + invalid-delay revert + ON badge.
  Library restored to pristine 95 presets / 7 folders after testing.
- bun run lint: clean. tsc: clean on both touched files (pre-existing errors
  elsewhere in examples/, skills/, audio.ts, script.ts untouched).
  dev.log: no runtime errors.

Stage Summary:
- Files modified: src/components/ava/presets-tab.tsx (full rewrite),
  src/components/ava/script-tab.tsx (chip + Save/Save As/New edits).
  No changes to page.tsx, store.ts, API routes, or other tabs.
- Key decisions: subtree (not direct) preset counts on folder badges
  (labeled via tooltip); NameDialog fully controlled to pass the new
  react-hooks lint rules; rename keeps editTarget/randomScope/selection
  pointing at the renamed paths client-side (refreshPresets prunes stale
  ones server-side); delay input commits valid values live but only reverts
  invalid text on blur so typing isn't fighted; export/import allowed on
  protected folders (rename/delete disabled) exactly per spec.
- Store/API notes for Task 11: none needed — the Task 9 contract covered
  everything. One cosmetic gap: setRandomIntervalSec is typed (sec: number)
  though the store handles numeric strings at runtime; UI converts with
  Number() before calling.
- Left for Task 11 verification: visual polish pass in a real browser
  (spacing at 420 vs 440px panel widths, mobile stacking), touch-device
  check of the hover-only .avs download button, and double-click-to-run
  ergonomics (agent-browser cannot dblclick, so that path was verified via
  the identical Load Preset code path).

---
Task ID: 11
Agent: main (Z.ai Code)
Task: E2E verification of the new folder-tree Presets page + final cleanup

Work Log:
- bun run lint: zero errors. tsc clean on all files touched by Tasks 9–10.
  dev.log: no runtime errors, no hydration warnings.
- Agent-browser E2E golden path, ALL VERIFIED:
  * Tree renders exactly as requested: root/ → embedded/ (Synth-C 5, Amp Picks 66,
    Dynamics 9, Envision 15) + user created/ 0; subtree count badges; depth≤2
    folders default-expanded; chevron-only expand/collapse; role=tree/treeitem.
  * Preset select → action panel switches to preset context (Load/Rename/Delete);
    folder select → full management set; protected folders (root/embedded/user
    created) have Rename+Delete disabled.
  * Load Preset: applied, toast, emerald Play-icon running indicator in tree,
    footer SCRIPT updated, engine running.
  * Create Preset: dialog → created in selected folder → auto-switch to Script
    tab with starter template → "Saving to: root/user created/…/Name" chip →
    edit → Save (PUT) persisted server-side (verified content round-trip) →
    Save As… created "Club Ring v2" in the same folder and retargeted the chip.
  * New Subfolder → "My Fav Presets" created + selected + toast.
  * Rename folder "My Fav Presets" → "Club Night": both presets' paths updated.
  * Delete folder: AlertDialog with blast radius ("removes 2 presets"), confirmed
    → folder + presets gone, library back to 95.
  * Export .zip: link href /api/presets/export?path=… correct; zip contains
    "root/user created/Round Trip/RT Preset.ava" (structure preserved from root).
  * Import .zip via the UI file input (DataTransfer dispatch): toast
    "Imported 1 presets — 1 folders created", tree restored at the exact path.
  * Randomize: invalid delay 2 and 61 both rejected with the "3 and 60 seconds"
    error + revert; 4 accepted; checkbox on → "ON · every 4s" badge; with Demo
    audio running, the timer switched to a random preset from the selected
    scope after ~4s (toast + footer PTS 333 matching the loaded script);
    scope line follows folder selection; settings persist to localStorage and
    do NOT auto-restart after reload unless enabled.
  * Mobile 390×844: no horizontal scroll, tree/actions stack, footer pushed
    naturally and sticks to viewport bottom when scrolled to the end.
  * Fresh reload: startup falls back to the first root/embedded/Synth-C preset
    (Gap The Mind), tree repopulates, zero console errors.
- Cleanup: deleted the Round Trip / Club Ring test data (library back to the
  pristine 95 presets / 7 folders); test artifacts in tool-results/.

Stage Summary:
- The requested Presets page redesign is COMPLETE and browser-verified:
  left folder/file tree (root → embedded {Synth-C, Amp Picks, Dynamics,
  Envision} + user created) with counts, expansion, selection, running
  indicator and .avs original downloads; right management panel (Load Preset,
  Create Preset → Script tab → Save/Save As, New Subfolder, Rename, Delete with
  confirmation + blast radius, Export .zip preserving the tree, Import .zip
  restoring the tree) and Randomize (3–60 s validated) scoped to the selected
  folder. All flows verified end-to-end with zero console errors.

---
Task ID: 12
Agent: main (Z.ai Code)
Task: LOST-WORK RECOVERY — restore the folder-tree Presets page (Tasks 9–11)
from the user's Google Drive project download after the sandbox was rebuilt
from an earlier snapshot

Context:
- The sandbox running Tasks 9–11 was replaced by a rebuilt environment whose
  git history ended at the "link source" commit (51e07079 → local 4caaa3e).
  The two commits containing the Google-Drive preset import (b33474e) and the
  folder-tree implementation (2a23db4) existed only in the user's downloaded
  copy of the project — which the user kindly re-hosted on Google Drive.

Work Log:
- Downloaded the user's archive (drive file 1yUmimOpLyz7l8BQO6keUHPCvLaV6TW5k,
  86 MB tar.gz, includes .git with the two lost commits) to /tmp/ava-restore.
- Verified the archive's base commit (fb12d97, subject 51e07079) is
  content-identical to the workspace HEAD 4caaa3e (git diff empty except
  .zscripts/tool-results) → archive HEAD is a strict superset, safe to restore.
- Stopped the dev server, then surgically checked out all 200 files changed
  between fb12d97 → 2a23db4 (excluding .zscripts/dev.pid, tool-results,
  dev.log): prisma/schema.prisma (Folder model + Preset.folderPath/originalFile),
  db/custom.db (pre-seeded 95 presets / 7 folders), src/lib/server/preset-tree.ts,
  src/lib/ava/embedded-presets.ts, src/lib/ava/{engine,expression,script}.ts
  (functions needed by the converted presets), src/app/api/{folders,presets/**
  export,import}/route.ts, presets-tab.tsx (full tree rewrite), script-tab.tsx
  (Save/Save As chip), store.ts (tree + randomize state), page.tsx, plus the
  95 .avs originals under public/avs-originals/… and tools/convert-avs.ts.
- Ran `bun run db:generate` to rebuild the Prisma client for the new schema
  (the restored db already matched it — no db:push needed, no data loss).
- Restarted the dev server (port 3000, single instance).
- VERIFIED via API: GET /api/presets → 95 presets / 7 folders
  (Synth-C 5, Amp Picks 66, Dynamics 9, Envision 15); export
  root/embedded/Synth-C → zip with full "root/embedded/Synth-C/*.ava" paths;
  import of the same zip → 0 imported / 5 skipped (duplicate paths) — round
  trip intact.
- VERIFIED in agent-browser (desktop 1440×900 + mobile 390×844): tree renders
  (root 95 → embedded {Amp Picks 66, Dynamics 9, Envision 15, Synth-C 5} +
  user created), preset select → Load Preset → engine running (footer
  "SRC: DEMO, FPS: 60, PTS: 480, BPM: 126.8, SCRIPT: Gap The Mind, engine ok"),
  New Subfolder ("My Fav Presets" created + selected), Rename (→ "Club Night",
  toast shows new path), Delete (alertdialog + server 200, tree cleaned),
  Randomize delay validation ("2" → red "Delay must be between 3 and 60
  seconds." hint; "4" commits), .avs original HEAD → 200, reload → startup
  fallback loads Gap The Mind, zero console/page errors, mobile: no horizontal
  scroll, footer pushed naturally and flush with the viewport bottom when
  scrolled to end. bun run lint: clean.
- Test data cleaned up (Club Night folder deleted; library back to 95/7).
- Committed the restoration to git and left the recovery remote/objects
  out of the repo (temp files remain in /tmp/ava-restore only).

Stage Summary:
- The folder-tree Presets page (Tasks 9–11) is fully restored and re-verified
  end-to-end. Root cause of the "revert": the environment was rebuilt from a
  snapshot predating the morning's commits; the work itself was never lost in
  the user's download. All state (schema, data, API, UI, presets, tooling)
  now matches the archive's HEAD (2a23db4) on top of the current workspace.
- NOTE for the future: commit snapshots are the source of truth when an
  environment rebuild is suspected — compare git log before re-implementing.

---
Task ID: 13
Agent: main (Z.ai Code)
Task: v6.0 — rename to "Open Visualization Engine" (AVA → OVE) + footer
version indicator (establishes the versioning convention)

Work Log:
- New src/lib/version.ts — single source of truth: APP_NAME
  "Open Visualization Engine", APP_SHORT "OVE", APP_VERSION "6.0" + a
  short version-history comment (6.0 rename+stamp, 5.0 folder-tree, 4.0
  link source) so future bumps are a one-line change.
- src/app/layout.tsx — document title now "OVE — Open Visualization Engine
  (v6.0)" (built from the constants); description + keywords updated
  (AVA→OVE, "agent"→"engine").
- src/components/ava/header.tsx — logo block h1 "AVA" → "OVE" (APP_SHORT),
  subtitle "ADVANCED VISUALIZATION AGENT" → "OPEN VISUALIZATION ENGINE"
  (APP_NAME.toUpperCase()), both imported from version.ts.
- src/components/ava/footer-bar.tsx — right cluster is now a ml-auto wrapper
  holding: "version 6.0" stamp (text-zinc-600, tooltip "Open Visualization
  Engine — version 6.0") immediately LEFT of the engine-ok dot + label,
  exactly as requested. Stamp is visible on mobile too (fits: no horizontal
  scroll at 390px).
- Internal code identifiers (ava store/lib/component paths, ava-agent rust
  crate) intentionally left unchanged — the rename is user-facing only.
- VERIFIED in agent-browser: title "OVE — Open Visualization Engine (v6.0)";
  header logo/subtitle; footer text "...version 6.0\nengine ok" with the
  stamp on the same row, right of the stats, left of the dot; mobile 390×844
  no horizontal scroll + stamp visible; zero console/page errors; lint clean.
- Committed as "v6.0 — rename to Open Visualization Engine + version stamp".

Stage Summary:
- Versioning convention established: bump APP_VERSION in src/lib/version.ts
  on every large change; the stamp renders bottom-right of the footer and the
  document title carries it too. Users can name local backups by the stamp
  (e.g. "OVE v6.0") and cross-check against z.ai Version History.