EDITOR.md: Pressing Plant editor/assembler spec + BEYONDMORP.md concept

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

BEYONDMORP.md

@@ -0,0 +1,42 @@
+# BEYOND MORP: THE MOVIE: THE GAME — concept (second title, shares engine + editor)
+
+The meta-parody FMV game. Source chain (all real, on ultra):
+**Beyond Morp** (`GAMES/beyondmorp`) — Zork-flavoured text adventure, static JS+JSON →
+**MorpQuest: Record Store Day** (`morpquest`) — Sierra-AGI graphical adaptation, 14 EGA
+rooms, cat-food run, Uncle's list, the BeckyWall (door blocked by Taylor Swift
+superfans), the white label, "Morp is not cruel; Morp is accurate" →
+**The Morping Horror** (`morpinghorror`, `themorpinghorror`) — the sequel. It sucked. Canon.
+
+This game is: *the game of the movie of the book of the game.* An FMV QTE adaptation
+of a (nonexistent, big-budget, wildly unfaithful) Hollywood movie of Beyond Morp.
+The comedy engine is fidelity-rage:
+
+- **Barry** (comic-book-guy archetype, aggrieved superfan) is IN the game — a
+  picture-in-picture heckler who pauses the action to complain: "In the ORIGINAL,
+  the alley was called Scenic Rim and it was TEXT. This is an insult." Barry's
+  interruptions are themselves QTEs (input to un-pause before he finishes a rant =
+  bonus; fail = he reads the original room description aloud in full while you die).
+- **Canon-error deaths**: some hazards kill you *because the movie got it wrong* —
+  the vine to the roof ("Above the Rim") snaps because "in the game it was load-
+  bearing dialogue"; death card cites the source file (`rooms/room6.json`) like a
+  wronged wiki citation.
+- The movie "improved" things: Morp is now a CGI explosion-god voiced by a celeb;
+  the cat-food run is a car chase (Room 0: Your Car → actual FMV car chase); the
+  BeckyWall is a slow-mo crowd-surf setpiece; the white label is a glowing MacGuffin
+  in a briefcase.
+- **Sequel-bait stinger**: post-credits trailer for THE MORPING HORROR 2: MORP
+  HARDER — deliberately awful, 1 clip, everyone agrees it looks worse than the game
+  of the book of the movie, which was good, kinda.
+- Structure: the 14 MorpQuest rooms ARE the level list (map already drawn in
+  `morpquest/DESIGN.md`); each room gets the "$200M adaptation" treatment. Uncle's
+  list = the score system (items ticked off). Five words, one white label.
+
+Production: identical pipeline to Record Store Guy — same engine, same look system
+(cel80s canonical; a "morpinghorror" bonus look = gritty 2000s horror-reboot grade),
+same Flow credit discipline. Built as a second project in the editor (see EDITOR.md);
+its blocks.json characters (Guy-with-list, Barry, Morp, Becky the superfan chief,
+the cat) and 14 location blocks get seeded from the morpquest room JSONs — the
+adaptation is *procedurally unfaithful*: we literally feed the faithful data in and
+prompt the movie-version out.
+
+Status: concept only. Record Store Guy ships first; this reuses everything RSG proves.

EDITOR.md

@@ -0,0 +1,104 @@
+# PRESSING PLANT — the engine editor / prompt assembler (spec for build)
+
+The tool that turns "describe an idea" into consistent Flow clips wired into a
+playable game. One editor, many game projects (Record Store Guy, Beyond Morp:
+The Movie: The Game, ...). Name: a pressing plant is where records get made.
+
+## Architecture (match house style: zero-build, stdlib only)
+- `editor/server.py` — python3 stdlib HTTP server. Static-serves `editor/` UI +
+  the active project dir, plus JSON API:
+  - `GET  /api/projects` — list projects (see registry below)
+  - `GET  /api/project/<name>/<path>` / `POST .../save` — read/write JSON + files
+    inside that project only (path-traversal guarded, `.json`/`.md`/media only)
+  - `POST /api/llm` — proxy to LLM for the assistant (see LLM section; keeps keys
+    server-side, avoids CORS)
+  - `POST /api/flux` — submit a still to MODELBEAST `flux_local` and poll (uses
+    MB_TOKEN from env/.env on disk; concept art + ingredient stills stay free)
+  - `POST /api/clip` — accept an uploaded/downloaded Flow clip, run ffmpeg
+    normalize (tools/postprocess.sh behaviour inline: 1280x720/24fps/h264+aac,
+    +faststart), store to `engine/clips/<scene>_<kind>.mp4`, return duration
+- `editor/index.html` + `editor.js` + `editor.css` — vanilla SPA, tabs below.
+  Reuses the game's arcade styling language so it feels like one product.
+
+## Project registry
+`projects.json` at repo root: `{ "recordstoreguy": ".", "beyondmorp": "../beyondmorp" }`.
+A project dir must contain: `production/prompts/{blocks.json,looks/,shots/}`,
+`engine/scenes.json`, `engine/clips/`, `bible/concept/`. `POST /api/projects/new`
+scaffolds that tree (this is how beyondmorp gets born; its seeder — see BEYONDMORP.md
+— imports morpquest room JSONs into location blocks).
+
+## Tabs (build in this order — each is independently useful)
+
+### 1. Cast & Places (blocks.json editor)
+Card grid of characters and locations/sets. Each card: name, the verbatim prompt
+block (textarea), and attached reference images (from `bible/concept/`, displayed;
+"Generate still" button → `/api/flux` with the block + chosen look via promptc
+logic; "this is the Flow ingredient" checkbox per look — tracks which ingredient
+stills exist per look, warns when a shot uses a character with no ingredient for
+the active look). Images can also be dragged IN (John's own refs/sketches) — they
+become inputs: "Describe this into a block" button sends the image to the LLM
+(vision-capable route) to draft the prompt block.
+
+### 2. Map (story graph)
+Node canvas (drag boxes, draw arrows — SVG, no lib): nodes = scenes, arrows =
+onSuccess flow; death branches implicit. Node color = status: idea → shot-spec'd →
+generated → inserted → tuned. This IS the game's structure editor: saving writes
+both `map.json` (positions) and the scene skeletons into `engine/scenes.json`.
+Adventure-game projects (beyondmorp) can import an existing room map as the
+starting graph.
+
+### 3. Shot desk (the assembler — the heart)
+Left: shot list (from `production/prompts/shots/`). Middle: the shot JSON as a
+form (world, set, characters, action sentence, camera, duration, qte windows,
+kind action|death, notes). Right, live-updating:
+- **Compiled Flow prompt** for the active look (port promptc.py's compile to JS —
+  same blocks, identical output; keep promptc.py the CLI twin)
+- **Flow checklist**: which ingredient stills to attach (by name, with thumbnails),
+  Veo tier to use (fast/quality per shot flag), "copy prompt" button, and a
+  "log gen" mini-form that appends to `production/SHOTLOG.csv` (scene, take,
+  credits, verdict) so the budget ledger stays honest without leaving the editor.
+- Alt-look preview: dropdown re-compiles the same shot in any look.
+
+### 4. Ingest & QTE tuner
+Drop a downloaded Flow clip onto a shot → `/api/clip` normalizes + names + wires it
+into scenes.json → embedded `<video>` opens with the SAME debug timeline the engine
+has (share that code): scrub, frame-step, then *click-drag on the timeline to
+paint each QTE window*; pick input direction per window; set per-scene `cueLead`
+(the flash-before-window; engine default CUE_LEAD, expose 0–0.5s) and per-window
+`cue` on/off. "Test" button opens the real engine at that scene (`?debug=1&scene=`
+— add that query param to player.js). This tab is where "insert the clips" happens.
+
+### 5. Writers' room (LLM assist)
+Chat panel with the project loaded as context (blocks.json + WORLDS/BEYONDMORP doc
++ shot list). Modes, each returning STRICT JSON the UI applies as a diff-preview
+(nothing auto-saves; John approves each):
+- "draft shots for this beat" → shot JSONs (action sentence, camera, windows guess)
+- "draft a character/location block" (from text OR an attached image)
+- "punch up deaths" → death-shot variants for a scene
+LLM routing in server.py: default tailnet Ollama `http://100.69.21.128:11434/v1`
+(qwen2.5:7b, free, fine for drafts); optional `ANTHROPIC_API_KEY` from .env for a
+"quality pass" button (claude-sonnet-5; vision for image→block). Prompt templates
+live in `editor/prompts/*.md` so John can tune the assistant's taste without code.
+
+## Consistency contract (why this produces coherent video)
+Shots never contain style or character text — only ids. The compiler injects the
+verbatim blocks; the checklist pins which ingredient stills accompany the prompt
+into Flow. One place to edit a character; every future prompt inherits it. Looks
+stay swappable per RSG's system. The editor enforces: no compile if a referenced
+character/set id is missing; warn if ingredient still absent for active look.
+
+## Flow reality check (no API)
+Google Flow has no public API — generation stays manual in the browser. The editor
+optimizes the human loop to: copy prompt → attach listed ingredients → gen →
+download → drop file on shot. Everything else (spec, compile, log, normalize,
+insert, tune, test) is automated. If Flow ever exposes an API, `/api/flow` slots in
+next to `/api/flux`.
+
+## Build order for Opus
+1. server.py (static + save + project registry) — 2h
+2. Shot desk with JS compiler + copy button (immediately useful for Phase 3 style test) — first
+3. Cast & Places (+ /api/flux once MB_TOKEN is sorted)
+4. Ingest & QTE tuner (share engine debug code; add ?scene= to player.js)
+5. Map; 6. Writers' room (Ollama first, Claude optional)
+Definition of done per tab: round-trips real recordstoreguy project files with no
+hand-editing needed for the Phase 3 style test and Phase 5 production loop.