1. Model load/unload (and every is_admin-gated front action) returned 401: is_admin
   probed prim.url + /admin/api/status on the engine, but that route is front-only
   (removed from the engine in def78c18), so it 404'd → never 200 → Unauthorized. Add
   an engine-side admin-gated /admin/api/whoami and point is_admin at it.

2. Township reference generation (characters/environments pages — _run_regen_job and
   _run_create_profile_job) hardcoded 768x512/512x512 + 28 steps, ignoring the Run
   page. Add _ref_gen_res_steps(args) (honors keyframe_size/keyframe_steps, re-read
   from the saved config so edits apply without restart) and use it at the reference
   generators; generate_character/generate_environment now forward `steps` (the
   server already accepts it). Keyframes/match videos already honored the config.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RdMufYvtTbtGDWsiZVoXce

The post-delete redirect used `(window.ROOT_PATH||'') + '/matches'`, but
window.ROOT_PATH was never defined, so behind the nginx /township mount it
redirected to the bare /matches — which hits the coderai front, not the township
tool → 404. The mount shim wraps fetch()/EventSource() to add the prefix but not
location.href assignments. Define window.ROOT_PATH=P in the shim so the redirect
(and any future ROOT_PATH use) resolves to /township/matches; with no prefix
(direct access) it stays unset and the bare /matches path is correct.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RdMufYvtTbtGDWsiZVoXce

* coderai-docker (run_oci.sh): new --tool-arg TOOL VAL (one token) and
  --tool-args TOOL STR (whitespace string), repeatable, for video-editor |
  videogen | township | parler. They accumulate into CODERAI_<TOOL>_ARGS env vars
  that supervisord appends to each tool's command line. Documented in --help
  (plus the --map dir-or-file note and bring-your-config examples), and shown on
  the startup banner (tool-args:).
* entrypoint: default+export the four CODERAI_*_ARGS (empty) so supervisord's
  %(ENV_...)s never fails on an undefined var; pre-create /cache/video_editor/sessions.
* supervisord: append %(ENV_CODERAI_*_ARGS)s to all four tool launchers; the video
  editor now runs with --session --session-dir /cache/video_editor/sessions so
  editor-state recovery is ON by default and persists on the cache volume.
* video_editor.py: new --session-dir to place session state/assets at a
  persistent/mapped path (defaults to ~/.cache/... when omitted).

Bump version to 0.1.6.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RdMufYvtTbtGDWsiZVoXce

Mirror the township config fix for the bundled video editor:
* supervisord: pass --config /cache/video_editor/video_editor.config.json so a
  bind-mounted (or cache-persisted) config auto-loads — previously it only
  auto-loaded video_editor.config.json from the baked cwd, which isn't mappable.
* video_editor.py: a MISSING --config file is no longer fatal (was raise
  SystemExit) — start with defaults; the web UI Save creates it.
* entrypoint: pre-create /cache/video_editor so the config dir exists for
  auto-load + web-UI Save (persists on the standard /cache volume by default).
* run_oci.sh (coderai-docker): --map now accepts a single FILE, not just a dir,
  so a tool config that lives loose on the host can be linked directly, e.g.
  --map /host/video_editor.config.json:/cache/video_editor/video_editor.config.json

Bump version to 0.1.5.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RdMufYvtTbtGDWsiZVoXce

The bundled township tool (supervisord [program:township]) launched without
-c/--config, so a township_config.json bind-mounted via --map into
/cache/township_output was never read — the web UI came up with blank API key /
league upload credentials / options every restart.

* supervisord: pass --config /cache/township_output/township_config.json so a
  mapped config auto-loads. Map the bare-metal dir with
    coderai-docker --map /path/to/township_output:/cache/township_output
  and the saved settings + credentials come up automatically.
* gen_township_fighters.py: a MISSING --config file is no longer fatal (fresh
  install with no mapped dir) — fall back to defaults and start normally; a
  malformed config still errors. The web UI's Save already writes back to
  <out-dir>/township_config.json, so first-run saves persist into the mapped dir.

Bump version to 0.1.4.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RdMufYvtTbtGDWsiZVoXce

- frontproxy: torch-free front proxy + per-vendor engine supervisor with auth,
  localhost binding, model routing; Ctrl-C now force-kills engines (own session +
  PDEATHSIG, SIGKILL of engine process groups, watchdog on hung drain)
- gemma-4 tool calling: prompt via native tools= template, parse call:NAME{...}
  into tool_calls, honour generation_config EOS so it stops instead of looping
- ds4 external worker, parler/expressive TTS backends, video editor tooling
- --debug-requests: full client<->API request/response logging + live snapshots
- stop tracking runtime artifacts (video_editor/sessions/, tools/coderai_media/)

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Fold tools/township_upload.py back into gen_township_fighters.py to match the
project's single-file convention. Odds generation, anti-arbitrage checks, ZIP
packing and the chunked upload now live alongside the other township helpers;
_best_variant reuses the existing _video_variants. Behaviour is unchanged.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Add ZIP packing, anti-arbitrage odds generation, and chunked upload of a
rendered match to the Township Combat League server (mbetterd 3-step API).

- New tools/township_upload.py: generate_odds (constraint-aware, retries up
  to 10x, verified with the server's exact sure-bet checks), check_arbitrage,
  build_match_zip (OVER/UNDER/WIN1-2/KO1-2/RET1-2/DRAW, best enhanced variant),
  upload_match (create -> chunked zip -> finalize, proxy-safe, progress_cb),
  and a content signature for upload-state invalidation.
- Run page: server endpoint/token/fixture-id, "upload after render" checkbox,
  and configurable odds ranges; persisted via /save-config + load_config.
- Match page: generate/regenerate odds & ZIP, upload with a progress bar
  (polls /job/<id>), and an "Uploaded" badge that clears when the match is
  re-rendered, enhanced, edited or deleted.
- Auto-upload after a full render when configured; skips (keeps local) any
  match whose odds fail the arbitrage check after 10 tries.

KO/RET odds are coupled to wins by the product cap, so high maxima are not
reachable in a no-arbitrage book; the generator samples wins first then bounds
KO/RET accordingly.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Entrances no longer roar/snarl/glare; they walk out composed and in-character.
Fights now default to realistic human MMA exchanges with acrobatic/scenery
moves demoted to an occasional minority accent.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Auto-collapse a match's draw outcome(s) to a single canonical draw owned by
f1 with f2 as opponent (representing both fighters), preferring an existing
f1-owned draw so its rendered files survive. Fixes legacy per-fighter draws
and the lone-f2 self-opponent case; lets the draw be regenerated on its own.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Old matches stored a DRAW per fighter, but a draw concerns both fighters so
there must be exactly one per match. _run_match_job now dedupes the match's
draws (keeping the first) and persists prompts.json on ANY operation, so a
legacy match self-heals the moment it's touched — regen no longer rewrites a
draw per fighter, and the per-outcome prompt regen targets the single draw.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

township: camera-motion clips, cancel-whole-queue, queue UI, per-outcome prompt regen, 3-person draw

- Camera motion: add CAMERA_MOVES and flag every other fight clip as a
  camera-motion shot whose prompt LEADS with a bold moving-camera directive
  (front position = strongest weight) so the I2V model moves the camera through
  the environment instead of locking off. Legacy clips get a camera decision
  assigned + persisted on prompt regen. The directive is stripped from the
  keyframe prompt so the still anchor stays sharp.
- Cancel whole queue: new /job/cancel-all endpoint flags the running job AND
  every queued job (worker skips them); the progress cancel button now reads
  "Cancel all (N)" and empties the queue instead of just the active job.
- Queue visibility: detail monitor renders a "Queued (N)" list of the waiting
  jobs (by friendly scope label), not just a count; matches-list page uses ONE
  monitor per card (no more blinking between running job and its queued ones).
- Per-outcome prompt regen: "prompt↻" on every outcome tile + new
  outcome-prompt scope rewrites a single outcome's finish+victory shots only.
- Draw outcome: strengthen prompts so the victory shot shows all THREE in frame
  (both fighters + referee) with the referee thrusting BOTH fighters' fists high.
- Entrance clips: more explosive/threatening, galvanized, shadow-boxing the air.
- "win" outcome is now a POINTS decision by the referee, not a KO.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Legacy matches (created before the intro-clips feature) have no role on their
clips, so per-clip prompt regen wrote fight prompts for clips 0-2 instead of
the entrance/entrance/face-off intro. Add _clip_role_fighters() which honours an
explicit role/fighters or infers from position (clip 0 = f1 entrance, clip 1 =
f2 entrance, clip 2 = referee face-off, rest = fight). _fill_clip_prompt() now
uses it and PERSISTS the resolved role/fighters onto the clip so the subsequent
keyframe regen and render apply the correct profiles + LoRAs.

Also make a regenerated prompt authoritative for keyframe generation: clear any
stale kf_prompt override when (re)writing a clip prompt (keyframes compose from
the clip prompt unless an override exists, which would silently win). Same for
outcomes — _plan_outcome_shots now drops o['kf_prompt'] so regenerated outcome
prompts feed the outcome keyframes.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

The outcome video render applied one fighter list (both match fighters) to the
whole clip, so the referee LoRA and winner-only identity only existed in the
keyframe, not at video-generation time. Thread per-segment fighters through
_render: segments are now (prompt, frames, seg_stem, seg_fighters) and each
segment (and each chained part) applies exactly its own character_profiles +
LoRAs, overriding the clip-level list.

Outcome segments now load: FINISH = both fighters; VICTORY = winner + referee
(decisive) or both fighters + referee (draw). Referee resolution matches the
keyframe path. Backward compatible — shorter segment tuples and legacy clips
without role/fighters fall back to the clip-level fighters.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

- Every match now opens with 3 intro clips before the fight: a bold solo
  entrance for each fighter, then a referee-officiated face-off stare-down
  with the start signal. The real fight begins at clip 4. New intro prompt
  templates + LLM system prompt + PromptGenerator.intro_shot().
- Factor out _build_match_clip_specs() and _fill_clip_prompt() so all four
  clip-building paths (stage_videos Phase A, new-match, replan, full regen)
  build intros consistently; intro clips attach only their own participants
  (solo entrance = one fighter; face-off = both + match referee).
- New "clip-prompt" job scope + per-clip "prompt↻" link: rewrite ONLY one
  clip's prompt in place (role-aware), steering fight clips away from the
  match's other shots; renders nothing.
- "Create whole match" and "Regenerate whole match" (scope "full") now finish
  with a 2x AI upscale + 2x frame interpolation pass over the final short/long
  assemblies and outcome videos, reusing the existing enhance machinery.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Township tool (tools/gen_township_fighters.py):
- Outcome videos now generate TWO keyframes per outcome (finish + victory),
  each anchoring its own clip; victory clip uses a dedicated referee shot.
- Referee characters: new role on create form, kept out of fighter pools,
  dressed as officials, attachable per-match and used in victory keyframes.
- Per-match referee selection (new-match form + match editor, persisted).
- Autogenerate buttons on character/referee, environment and new-match forms
  (LLM-filled, editable before create) via /profile/autogen + /matches/autogen.
- Single-worker generation queue: all coderai-bound jobs (create/regen/train/
  match/process) are serialised and surfaced as "queued", with one persistent
  match-detail monitor replacing the competing per-job pollers (fixes the
  blinking progress when two jobs were launched at once).

coderai: favicon.ico served at /favicon.ico + linked in admin/login templates;
bundled township favicon served at /favicon.ico.

Also gitignore large packaging/runtime artifact dirs (.packaging-cache/, tmp/).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Make video enhancement fully AI-on-CoderAI and rework township outcomes.

Upscaling (Real-ESRGAN / SD upscalers):
- Support diffusers-style .safetensors weights + config.json (e.g.
  hlky/RealESRGAN_*), not just classic .pth; infer RRDBNet arch/scale from
  config. fp16 + tiling for performance.
- AI-or-fail: no ffmpeg fallback. Auto-select a configured upscaler when the
  request omits a model (find_capable_model).
- Fix a registry-pollution bug: cache upscalers in a private dict, never under
  a synthetic 'upscale:<id>' key in multi_model_manager.models (which made a
  later request_model() resolve/reload the bogus key -> 400).
- Per-frame progress + a first-class "upscale" task (pause/cancel/thermal),
  with a periodic thermal re-check through the frame loop.

Interpolation (RIFE):
- AI-or-fail: removed the ffmpeg minterpolate fallback. Resolve the
  rife-ncnn-vulkan binary + bundled model robustly, pass exact -n frame count,
  and pin -g to the SAME GPU CoderAI uses (matched by CUDA device name, not a
  hardcoded index). Progress + "interpolate" task + thermal guard.

Township generator:
- One draw per match (not per fighter); longer, configurable outcome videos
  built as a finish -> victory two-shot sequence; richer, more brutal,
  camera-aware prompts (finish/victory templates editable on the Prompts page).
- Stream large results via response_format=url instead of base64-in-JSON;
  per-frame progress for both upscale and interpolate.

Configurable temp dir:
- New --tmp CLI flag and config.tmp_dir (+ admin Settings field, applied live).
  Sets tempfile.tempdir and TMPDIR/TMP/TEMP so all scratch (frame extraction,
  upscaling, interpolation) and child processes use it — fixes
  "[Errno 28] No space left on device" when /tmp is small.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

The 'full' match-regen scope now (1) removes this match's existing
keyframes, clip videos, outcome videos and finals up front, so a re-plan
that changes the clip count can't leave orphaned files that would get
globbed into the reassembled finals; and (2) runs strictly in order —
prompts -> keyframes -> clips + outcomes (assemble_finals=False) ->
assemble finals as the explicit last phase (4/4) via _reassemble_finals.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Adds a `full` scope to the per-match action handler that rebuilds one
match in order: re-plan all fight-clip + outcome prompts (text model) →
regenerate every keyframe (image model) → re-render all clips + outcomes
and reassemble finals (video model), with live per-phase progress. Other
matches are untouched. Wires the confirm dialog, the match-detail button,
and the /matches/render scope allowlist.

Fix: the `full` confirm label used an apostrophe (match's) inside the
single-quoted JS string of the plain triple-quoted _match_js block, which
collapsed to a real quote and broke the whole script (reMatch undefined).
Reworded to avoid it; verified the rendered JS parses with node --check.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Downloads: run each model download in a clean `python -m
codai.admin.download_worker` subprocess streaming JSON progress, so the
Stop button reliably cancels by terminating the process (HF parallel/Xet
chunk transfers ignore in-thread flags). Adds download-cancel-all. Avoids
multiprocessing spawn, which re-imports the server launcher as __main__.

VACE extension: detect WanVACEPipeline; new 'extend' mode + cond_frames
request field condition on the previous chained part's frame tail (real
motion -> forward continuation, fixing the single-frame boomerang).
_build_vace_conditioning builds the (video, mask) pair; _snap_wan_frames
enforces 4k+1; only the freshly generated frames are returned. VACE also
serves keyframe i2v / t2v via masking; i2v/t2v fallbacks skipped for it.
Township auto-uses extend for chained parts when the model is VACE.

Fight prompts: full-MMA system prompt + rotating per-clip action focus
(kicks/knees/elbows/takedowns/ground/submissions) and occasional blood,
rebalanced fallback templates, keyframe wardrobe enforcement.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

- township: new playback_fps (0 = same as generation fps). coderai uses fps only
  for the mp4 encode (Wan generates a fixed frame count), so a higher playback
  fps plays the same frames faster (less slow-motion). The planner counts clip
  duration as nf/playback_fps so the finals reach their target length at the real
  play speed. Wired through config/CLI (--playback-fps)/web form/all call sites.
- main.py: suppress /v1/{video,images,audio}/progress access-log lines unless
  --debug-web is set (matching the existing /v1/loras/progress filter).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

- ratelimit.py: exempt /v1/video, /v1/audio and /v1/loras progress polls from
  BOTH auth and rate limiting (shared _PROGRESS_PATHS), matching /v1/images.
  The township script polls /v1/video/progress ~1/s during a clip; being
  rate-limited, those polls ate the budget so the generation POST got 429'd
  (clip failed) and the polls themselves 429'd (stuck step bar).
- township _render_once: a 429 now backs off and retries the same render (up to
  40 attempts, capped 60s) instead of abandoning the clip; covers clips,
  chained parts and outcomes. Genuine errors still fail fast.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

coderai:
- Thermal: configurable proactive CPU soft-throttle (engage temp + max
  per-step sleep) that gently slows generation in a warm band so it rarely hits
  the hard pause; CPU-only, hard pause always takes precedence. Tasks page shows
  a soft-throttle banner + per-task badge (live, gated on a running task).
- Acceleration hot-swap: toggling/changing a model's acceleration now evicts the
  loaded model (manager.unload_model) so the next request reloads with the new
  setting — no restart. (acceleration is fused at load time.)
- Models UI: cascading distill-LoRA pickers — new /admin/api/accel-loras scans
  the cache for distill repos; pick the distill model, then its high/low (or
  single) LoRA from dropdowns. Presets now also fill the high/low fields.
- Tasks queue summary now reflects ALL model activity (derived from the unified
  task list), not just queue-manager requests — fixes the stuck "0 active".
- images.py: proactive eviction no longer skipped by a NameError (model_key).

township (tools/gen_township_fighters.py):
- Per-clip/outcome/keyframe progress now shows real diffusion-step progress
  (polls /v1/{images,video}/progress) on the CLI spinner and the web step bars,
  including "shot part N/total" for chained single shots.
- Chained-shot concat re-encodes (CFR) instead of stream-copy, fixing the
  "first half is a static image" freeze at the part boundary.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Township fight-video generator (tools/gen_township_fighters.py):
- 16:9 native resolution: default 832x480 video + matching keyframes
  (configurable video_size); square 512 was off-distribution for Wan2.2.
- Split-and-chain rendering: single-render cap (default 50f); clips/outcomes
  longer than the cap render as chained sub-renders (last frame seeds the next)
  concatenated into one continuous shot, parts discarded — Matches page unchanged.
  Planned-clip ceiling raised to 480f.
- Separate outcome min/max frames (default 40/70), same split-chain path.
- Configurable short/long final-assembly intervals; clip count derives from the
  long target + fps so the long cut always fills.
- Prompt continuity: deterministic wardrobe+environment clause on every clip,
  replan clip and outcome; stronger LLM system prompts; updated default suffix.
- Run page: configurable fighter/environment counts + reference-image counts;
  moved "Include female fighters" into the Characters card; suggested
  steps/rank/weight guide table; per-profile LoRA train defaults now mirror the
  run-page config (lora_* for characters, env_lora_* for environments).
- Matches: "Remove match completely" (files + keyframes + prompts.json entry).
- Renamed the prompts step to "Generate matches prompts"; removed the gallery page.

coderai:
- images.py: fix NameError ('model_key' undefined) that silently skipped
  proactive VRAM eviction before every image load.
- thermal.py: cross-worker cooldown — when one generation pauses for heat, all
  parallel generations now back off until the resume threshold; add process-tree
  CPU% reader (100%/core).
- video.py/manager.py/main.py: offload ref-leak fix, offloaded-load VRAM guard,
  wire --pipeline-cache flags.
- Tasks page CPU tile shows process-tree CPU% scaled to cores.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Wan2.2 A14B (dual-expert) generation fixes:
- Fuse the Lightning distill LoRA into BOTH experts (transformer +
  transformer_2); diffusers' fuse_lora defaults to ["transformer"] only, which
  left the low-noise expert undistilled → 4-step clips collapsed to a solid
  colour. Also load per-request fighter/env LoRAs into both experts.
- Pre-configure the wan22_lightning_4step preset with the local high/low-noise
  LoRAs (lora_high/lora_low), used when acceleration is enabled, ignored when
  not; surfaced in the Acceleration UI.
- Safety net: only apply the preset's low step count when the distill LoRA
  actually fused, else fall back to safe steps.
- Skip bitsandbytes/quanto quant for the VAE (conv-only → "no linear modules").

VRAM / offload:
- Strategy auto-selection actually fires now ('auto' is normalised, not passed
  through as a no-op) and no longer double-counts the runtime/accel reserve.
- Graceful OOM degrade ladder: full-GPU → balanced @ configured% → 80 → 60 →
  40 → sequential → disk, respecting the model's balanced_gpu_percent as the
  starting cap. Expose 'balanced' as a selectable offload strategy.

Pipeline disk cache (--pipeline-cache / --rebuild-pipeline-cache):
- Cache the quantized base pipeline to disk and reload it on later starts,
  skipping re-download/re-quantization; accel LoRA re-fused per load. Fail-safe
  with self-healing invalidate-and-rebuild.

Tasks / misc:
- Show model loading as a (non-cancellable, non-pausable) Tasks entry.
- Filter the Tasks-page pollers from the access log unless --debug-web.
- Township gen script: per-image keyframe progress (no longer all-or-nothing).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Previously a per-request LoRA could only be a local path or HF id, which
assumed the client shared the server's filesystem. Add a content-addressed
store so remote clients can supply LoRAs by value or handle.

Request `loras` spec now accepts (resolved server-side, in priority):
  id "name:<registered>"  -> a LoRA trained on this server (path-independent)
  id "sha256:<hex>"       -> a previously uploaded blob
  file/data (base64)      -> inline weights, cached in the blob store
  url                     -> server downloads (cached by content hash)
  model/path              -> legacy local path / HF id (unchanged)

- loras.py: blob store (save_lora_blob / lora_blob_exists / _lora_blob_path),
  resolve_lora_ref(), resolve_request_loras() (in-place -> clean 400 on a
  missing blob / unknown name). New POST /v1/loras/upload (multipart / JSON
  base64 / raw, dedup) and GET /v1/loras/blob/{hash} existence check.
- LoraConfig / VideoLoraConfig: model now optional; add id/url/file/data/path.
- image + video handlers resolve_request_loras() before model work, so
  signature dedup / VRAM reserve / load_lora_weights read lora.model as before.
- gen_township_fighters.py: reference trained LoRAs by id "name:<registered>"
  (derived from the server path) with the raw path kept as a co-located
  fallback, so the script works client/server-split.

Also harden video load: float(cfg.get('balanced_gpu_percent', 80)) crashed on
an explicit null (admin UI writes null for blank fields); use `or 80`.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Outcome scenes belong to a match, so their keyframe (image model) and video
clip (video model) now attach the environment + BOTH match fighters' LoRAs,
matching the fight clips — previously they sent only the single named
fighter. Resolves the match pair from the in-memory fight_plan, falling back
to the saved prompts.json so a single-outcome regen (fight_plan == []) still
gets both. Legacy outcomes with no resolvable match keep the single fighter.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

New keyframes-missing render scope fills in only the keyframes that don't
exist yet for a whole match (clips + outcomes) — existing ones are kept and
nothing is re-rendered. Buttons added on the keyframes page and the match
detail action row; finishes immediately when none are missing.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

- New /match/keyframes page (🖼

 Keyframes ▸ from the match page): thumbnail
  grid of every clip + planned-outcome keyframe, each with per-tile
  regenerate (image model) and delete, plus match-level Regenerate all /
  Clear all. Live progress bars; reloads on completion with mtime
  cache-bust.
- Regenerate all (whole match) now also covers this match's OUTCOME
  keyframes, not just clips.
- Clear all now removes planned outcome keyframes too (not only ones with a
  rendered video), keeping it symmetric with Regenerate all.
- Fix outcome keyframe stem on the page: use the plan entry's actual
  match_name (None → legacy "<fighter>_<outcome>") so it matches the file
  the generator writes, instead of a "<match>_<fighter>_<outcome>" that is
  never created (outcome keyframes were showing "no keyframe" after a
  successful regen).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

The render endpoint's scope allowlist rejected the new keyframe-regen
scopes with a 400 before reaching the handler. Add them so the
"Regenerate keyframes" / per-clip kf↻ buttons work.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Server (codai/api/loras.py):
- /v1/loras/train gains wait (default True) + session; wait=false detaches
  the job and returns a job_id, avoiding HTTP read-timeouts on multi-hour
  video trainings.
- Disk-persisted job registry keyed by job_id (carries session). Progress
  endpoint serves ?job=<id> / ?session=<tok> so a client only ever sees its
  own job — no cross-user spillover. Jobs left mid-flight at startup are
  marked interrupted.
- Mid-training PEFT checkpoints (SD1.5/SDXL/Wan) + train_state.json; a
  resubmit resumes from the last step when base/target/rank (and session)
  match, so a reboot no longer throws away hours of Wan training.

Township (tools/gen_township_fighters.py):
- Async training: per-run session token + persisted per-LoRA job_id; polls
  by job_id, re-attaches to a running server job after a restart, resubmits
  an interrupted one (server resumes from checkpoint).
- Dedicated train timeouts (24h video / 4h image).
- Match page: regenerate/clear keyframes (match-level + per-clip/outcome)
  via new keyframes/keyframe render + delete scopes.

tools/videogen.py: mirror the session-token + job-id recovery helpers.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

- cuda/vulkan backend improvements and config plumbing
- API updates across characters, text, environments, audio, embeddings, tts
- admin chat/settings template updates
- add hf_loading helper, video request fields, platform paths
- new docs (CODERAI_API_DOCUMENTATION.md) and tools (review_outputs, video_dubber)
- ignore generated township_output/

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

The server exposes one global training progress (jobs run one at a time via the
queue), so every queued card was mirroring the active job's progress. Restore the
name match: a card shows real progress only when the global progress reports ITS
LoRA; otherwise it shows "queued — '<other>' training first… (elapsed)". Keeps the
elapsed-timer handling so a long model load still looks alive rather than frozen.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

- Match detail page: Fighter 1/2 and Environment are now dropdowns of saved
  profiles + the built-in pools, so a match's fighters/location can be switched
  before re-rendering (Save match persists; env_desc updated with env).
- Video LoRA status on profile cards: resolve the active video model the same
  way training/generation do (configured, else auto-picked, cached), and show
  "trained for: <slug>" even when the active model can't be resolved so a trained
  LoRA never looks untrained.
- Video LoRA training progress: show a ticking elapsed timer during the long
  model-load/preparing phase (the progress endpoint is starved while a large
  model loads), drop the strict name filter that could freeze the bar at 6%, and
  use step-based % once training begins.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Several related changes accumulated in this session:

Wan video LoRAs (additive — image LoRAs kept for keyframes):
- New per-model maps video_loras.json/env_video_loras.json keyed
  name -> {model_slug: path}; on-disk names tagged with the video model slug.
- Video requests attach the video LoRA matching the current video model's slug;
  image LoRAs stay on the keyframe path only.
- Per-profile "Train video LoRA" button + step button + full-run checkbox +
  --video-loras/--only-video-loras; batch + CLI wiring; client target="video".

Final/outcome enhance (upscale 2x/4x + raise FPS):
- _enhance_video_file + Phase C stage; --upscale-factor/--fps-multiplier and
  Run-page selects; match-page Enhance card with live progress bars.

Match page UX:
- Video previews enlarge + center on play (video lightbox).
- Match render shows global + per-clip progress bars, surviving reload.

Outcome fixes:
- Re-rendering a match's outcomes now resolves legacy per-fighter outcomes
  (no match_name) by fighter membership, and forces them into the match's
  environment so a match stays in one location.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Match re-render previously showed only a frozen text status. Now:
- _stage_videos_render reports per-clip start/end via clip_cb and overall
  done/total via progress_cb.
- _run_match_job seeds an items list and maps clip state into the job record.
- The match detail page renders a global progress bar plus one bar per
  clip/output (pending/rendering/done/failed), and these survive a reload
  via /active-jobs + resumeMatchJobs.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Tag regen/train jobs with kind/name/jtype and add a /active-jobs endpoint listing
running ones. On Characters/Environments page load, resumeActiveJobs() re-attaches
the live progress display to any in-flight job for the matching card, so a reload
(or reopening the tab) keeps showing progress until completion.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Add a shared image lightbox (injected into every page via _page) and make the
reference-image thumbnails on the Characters/Environments pages clickable to view
them full-size. Click the backdrop or press Escape to close. Delete button still
works independently.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>