Decide whether to keep free-text technical preferences or have the user pick models directly to
guarantee a few are chosen. Separate text defers the "scary" model-picker UI; either way AI should
help go from text to an initial model selection, perhaps via a short chat.

Technical Preferences <-> Models integration

On Music tastes the AI proposed pasting its own "consider adding 2-3 reference tracks" guidance
verbatim into the value. Advice is not field content. See the general rule under x/ai: review
criteria compare artifacts, they do not echo content.

AI must not inject advice text into a field

Make width/height first-class on the project with a landscape (1280x720) / portrait (720x1280)
orientation default that propagates to location generation, scene composite dims, WAN I2V target,
and the upscaler; per-shot override; all dims multiples of 64; workflows read the default instead of
hardcoding. Per-entity defaults: character/prop 1024x1024, location matches project.

Project resolution & orientation default

Proposed new Project Foundation step that gets the user's rendering environment, accounts, and API
keys set up before asset generation. Almost all of it is ACCOUNT-level (per machine/user), not
project-level, so the data home is the existing `/settings` page extended with "API Keys" and
"Hardware / Environment" sections; the pipeline step is a thin gateway that checks readiness and
links (`->`) there. Collects: rendering approach (cloud/local/both), Comfy Cloud key, local ComfyUI
via the comfyui-connector Chrome extension with a real "is it working?" verification, hardware specs
(RAM, spare disk, CPU, GPU + VRAM), a single API-keys page (Comfy Cloud + ElevenLabs today; check
Typecast), and AI-assisted model selection that uses the hardware. Absorbs the `foundation/identity`
"Technical Preferences <-> Models integration" item: move Technical Preferences out of Project
Identity into this step so the model recommendation runs after hardware is known. Placement decided:
step 2, right after Project Identity (early, but after the fun identity questions). Much of the
plumbing already exists (generic
encrypted key vault keyed by serviceId, Comfy Cloud key + local-connection test, the extension). See
Detail for the full capture and open questions.

Environment & account setup step

Rework like the major-character step: pick existing characters as minors (excluding selected
majors), allow adding new, and on exit produce a list of characters/locations/props to iterate. Or
restructure as select/define minors -> iterate -> locations -> iterate -> props -> iterate.

Episode & World Instantiations -- redo acceptance criteria

Characters get an ordered list of character beats (name + description) describing the stages they go
through, shown spreadsheet-style with drag up/down reordering (order held as ids in `_order`). No
code yet. Feeds narrative beats.

Character beats (ordered list, drag-reorder)

Two character selectors side by side at the top create a swimlane named from the pair; the user adds
relationship events inline (find the swimlane by name). Supports 2 or more characters. Currently
unbuilt.

Relationship row per important pairing

Episodes get an ordered `narrativeBeatList` of beats as a discriminated union: story (name +
description), character (references a character-beat instance), or idea (references an idea). Panels
already have a beat selector and may map several panels per beat; let the user enter a run of beats
quickly. No code yet.

Narrative beats (episode beat list)

Confirm minor characters expose the right reduced property set. Decided stance: lean toward exposing
all properties and letting the user skip the ones they don't want yet, applied consistently across
character/location/prop steps, rather than a curated subset.

Minor Characters property-subset audit

Split First Draft -> Review & Editorial -> Analysis into a dedicated Screenplay phase. It is the
hinge between non-visual narrative planning and visual production (visuals do not matter until Asset
Readiness), and the current narrative phase is over-long.

Pull screenplay steps into their own phase

Make clear we recommend a *human* review against the listed points, take notes, then rework into a
final draft in one pass. General rule (also x/ai): AI-review criteria must COMPARE the artifact
against known content + metadata and give feedback, never echo the screenplay back; consolidate the
several screenplay checks into one general AI review.

Screenplay review is human-first

This page is the AI review: run it and show + execute results inline rather than navigating to the
Analysis page, and merge the separate Detected Characters/Locations/Props feedback loops onto one
screen. Built: two-phase Analyze (one LLM call -> `screenplayAnalysis`) + Apply. Deferred: per-field
AI buttons reading the analysis, and a View-analysis panel.

Inline AI screenplay analysis (no navigate-away)

Flagged as "the missing gap": a pipeline turning screenplay text into image style, pose, camera
instructions, and 3x3 prompts. Big Tier 1 item with no implementation; feeds Scene Planning and
Storyboarding.

Screenplay -> camera/pose/3x3 instruction pipeline

A per-project blocked-model list that filters the operation/workflow picker; workflows with no model
dependency stay always visible. Has an active plan.

Project model blocking (filter the operation picker)

Verify the readiness fields cover the visual properties the renderer needs (see the expose-all-and-
skip stance under Minor Characters).

Character visual-property coverage audit

Export a depth buffer from OA's existing Three.js tool (~20 lines) and build a
`depth-controlnet-sdxl-character` workflow (checkpoint + IP-Adapter FaceID for identity + depth map
for posing). Camera-angle changes become camera transforms -> a new depth map. Key clarification:
IP-Adapter is identity-only, ControlNet Depth/OpenPose is the posing tool; they run together.

Pose pipeline: Three.js depth map -> ControlNet Depth

No solution yet for posing multiple characters (cap ~4) in one shot -- the biggest unresolved pose
gap. Recommended stack: Multi-ControlNet (OpenPose + Depth/Canny), character LoRAs or IPAdapter
embeddings for identity, pose source from photo/3D render/sketch. Text-only prompting is unreliable
for spatial relationships. Also surfaces as the storyboarding data-model gap (no shot-character-
properties).

Multi-character blocking / posing strategy

Let the user pick/tag base environment images for a location from the step. The inline
`ReadinessImageStrip` (reads entity starred thumbnails, with a "->" to the gallery when empty) is
partly built for Location/Prop/Character; the open decision is whether starring/tagging happens
inline or in the gallery.

Location base-environment images inline

Track a location across variants (spring -> summer -> autumn -> snow) for visual consistency,
extending the character continuity-swimlane model to non-character entities.

Location consistency swimlane (seasons)

Track a prop across states (e.g. intact -> broken) for continuity, extending the continuity-swimlane
model.

Prop consistency swimlane

The criterion currently shows the screenplay, not the per-character dialog. Show each dialogue line
with whether a render exists, plus a page-level play button. (Audio-performance ACs were repaired
2026-06-11: panels now flag unknown-speaker / no-voice / needs-recording.)

Per-character dialogue lines with render + play

Once the screenplay is parsed, pick a rendering approach: TTS first for a pacing check, then later
recorded audio + voice changer, with the ability to redo it. Connects to the audio-only timeline.

Dialogue-to-audio rendering approach (TTS early, record later)

A single op-voice-changer with a per-engine dropdown (Chatterbox/comfy now; ElevenLabs speech-to-
speech and Gemini later) taking a source recording. Needs a comfy-dispatch hook on the built-in
executor (built-ins cannot queue ComfyUI jobs today). VC output must be tagged to the character so
Assemble routes it.

Voice-changer recipe (op-voice-changer, engine dropdown)

Capture/import UI for op-record: reuse MediaRecorderPanel / DialogLineRecordPanel and show the
shot's dialogue so the actor reads lines while recording the whole-shot performance. Treat four
input sources as equal (upload audio, upload video+audio, record audio, record video+audio). Until
built, recordings are imported/tagged by hand. Later: video+audio feeds pose extraction.

Record/import whole-shot performance (op-record)

One actor often reads several characters in a sitting; the user marks which spans belong to which
character and it emits one per-character file. The pure routing core exists (splitRouting.ts); the
missing piece is the editor UI (waveform, playback, drag-select regions) -- a mode of the shared
timeline editor.

Splitter editor UI (one recording -> per-character tracks)

The MusicCue model + cue editor + timeline blocks are built; actually picking or generating audio
per cue (setting `resourcePath`) is not. Build a music recipe (e.g. Civitai ACE-Step 1.5: text +
lyrics -> 30-190s MP3, no ComfyUI workflow) or library upload. Select/generate music BEFORE shot
durations lock so pacing and emotional arc set scene lengths.

Music selection / generation (set cue resourcePath)

The audio-only timeline renders cue/dialogue blocks but has no playback engine that mixes them with
per-cue fade-in/out and `duckForDialog` (lower music under dialogue). Music also wants anchored start
points and an episode list of music + SFX alongside dialog.

Timeline audio mix/playback (fade + ducking)

An audio-only cut playable in the timeline early -- suggested shot lengths, time-to-music, music
starting at particular scenes, interspersed with dialog -- so pacing is felt before any visuals.
Depends on the mix engine; connects music, dialog-audio, and shot-duration locking.

Audio-only timeline early (pacing pass)

Several criteria reference concepts that are not stored, so the check ticks an unrelated field:
scene objectives, scene emotional beats, and shot-count estimate (text, not required numeric) need
new metadata properties and corrected checks. Remove scene name (derived from heading) and scene
notes (human-only) from the workflow; review purpose/summary/description overlap (keep description
for findability); make emotionalTone single-line.

Scene-field cleanup + backing properties

A first cut of shots comes from screenplay analysis; add a step to review that list (add/remove
shots as text, with name and camera framing). "Shot list created" moves here out of Storyboarding.
Also: "Shot Planning" is mis-named -- clarify it iterates per scene while Storyboarding iterates per
shot.

Shot-list review step

`cameraDirections` ("rising shot, low angle, dolly in") and `actionDirections` ("Venn turns head
left then right") exist on shots but the UI does not surface them prominently. Make them prominent
and offer AI-generated suggestions derived from scene text + story beat before image generation.

Shot camera/action-direction UI + AI suggestions

Per-character performance and look in a shot are done (D5). Remaining: props and locations as inline
shot entities (today props live in the blocking text and location is just `locationId`), plus the
properties -> media-gallery handover. Characters here must include the look.

Characters-in-shot inline (incl. look; props/locations)

A shot's composition prompt has six inputs -- subject, action, location, camera_control, lighting,
style -- each fillable from a shot property and mapped to the workflow's App inputs. Five already map
(action/location/camera/lighting/style); `subject` was added (no longer `framingComposition`).
Remaining: verify the composition recipe/workflow maps all six.

Verify shot composition supports the six structured inputs

Add a per-shot readiness criterion that flags shots with no preferred/usable image, so episode-focus
detects "this shot has no image" during the animatic walk instead of letting it pass silently.

Per-shot image readiness criterion

When a shot's media is generated, persist the execution plan used (ordered steps, workflow per step,
inputs/field values, upstream media refs) so the user can see exactly how it was produced, visualise
the recipe DAG, and re-run from any point (e.g. regenerate just dialog audio). The Actions tab has no
memory -- a core reason it is being retired.

Shot memory & replay (provenance + re-run)

Hold a hand-drawn paper storyboard to the webcam; the existing tool corrects perspective distortion,
then extracts each drawn panel as a separate image to feed Nano Banana / ControlNet scribble. Verify
the perspective-correction tool works and is findable; build frame extraction.

Perspective-correction storyboard scan + frame extraction

Fold the separate Shot Strategy group into Storyboarding (its only unique field is `panelType`).
Reframe Composition as "compose your storyboard into the first image + consistency review" -- the
property-level analysis showed Composition re-checks Storyboarding fields; the only genuinely new
artifact is the composed image `storyboardMediaId` + 5 review criteria.

Merge Shot Strategy into Storyboarding

Generate a scene-level 3x3 contact sheet first (backgrounds stay coherent when generated together),
then distribute the 9 cells to shots as starting points. The crop/distribute op
(bw-grid-distribute-to-shots, sets each shot's `storyboardMediaId`) is built; remaining: the generate
side, a scene-level media gallery holding storyboard frames, and drag/drop to link a starter frame.

Scene-level media gallery + 3x3 storyboard distribution

Cleanly transition the user from a readiness/shot step into the media gallery to run a recipe and
back. The produce step exists (ProduceBridgeBanner); needs in-app verification and to apply to every
readiness step (recommended-recipe proposals inline, then navigate to the gallery).

Workflow execution -> media gallery handover

Decide if Composition is a distinct stage or "your storyboard is your first frame -- compose it".
Decision detail captured under Merge Shot Strategy. Render-engine note: Flux Kontext for one-off hero
composites (strong identity from refs, no memory); WAN 2.2 + LoRA + ControlNet for multi-pose
production; run ControlNet OpenPose first if a needed pose is not in references.

Composition vs Storyboarding analysis

AI review checking visual consistency (likeness, lighting, scale) across all shots in a scene,
surfaced as a scene-scope review criterion. Pairs with the multi-angle sheet recipe class.

Scene-level continuity review (AI across shots)

Confirm shot durations and dialogue placement (via the shared resolveShotDuration, also used by
MediaTimeline) drive the episode preview so assembled timing is right before export.

Episode preview / timing verification

The single biggest hole on the golden path: there is no phase/step for assembling shots + dialogue on
the timeline and exporting the video. Add an episode-focus surface that assembles, flags shots
missing image/dialogue, and exports via the existing MovieExporter. May warrant its own step.

Episode assembly + export phase

Assemble shots in order and play the video inline (reusing the render buttons, hiding extra UI so the
image is large) rather than sending the user to the timeline preview.

Inline episode playback on assembly

The pipeline captures `transitionType` (cut / dip-to-black / cross-fade + duration) and episode
opening/closing fades, but nothing renders them: the timeline applies only cross-fade timing and
MovieExporter does audio fades only. Build (1) open/close fades + dip-to-black via a shared black-
overlay alpha ramp in both TimelinePlayer and exporter; (2) cross-fade (two clips, opposing alpha).

Transition & fade visual render (preview + export)

Cross-fade requires clip overlap, which changes render lengths and throws off music timing, so
transitions are picked during shot composition, not at assembly; dip-to-black is trivial. The data
model (shotTransitions.ts) is built; the visual render is the open part (see above).

Shot transitions, decided early

Ship one-click "upscale to delivery" recipes wiring the existing 4x upscaler to standard pairs
(1280x720 -> 1920x1080, 720x1280 -> 1080x1920).

Built-in upscale-to-delivery recipes

Reduce late sign-off stages; make the fields editable review notes (notes-as-metadata, never a
value-edit field, never [object Object]).

Merge Color Grading & Polish into Final Review

Let the user track findings on the final page (notes-as-metadata).

Editable Publish & Archive notes

Reuse the character-profile propose/accept UI everywhere -- it must be the SAME component, not merely
similar -- and it must work with look (variant) inherit/override/unspecified flags.

Shared accept/reject property-change UI

Replace the flat Actions tab with operations grouped by the entity worked on: Character (pick model,
expression, posing, multi-angle, change clothes, reference sheet), Shot (composite character, multi-
character, relight, i2v), Location, Prop, Scene. Open question: store character reference sheets as
per-angle images with a "view as sheet" mode.

Recipe catalog reorganised by entity type

Focus inlines only the major-characters picker; generalise SelectSurface into one picker keyed by
entity kind (each has a `*InReviewIds` list), needing create-location/create-prop helpers and the
matching steps marked `select`. Same mechanic, low risk.

Generalise SelectSurface to minors / locations / props

The Board has per-section Approve All / Skip All; Focus has none. Add a section-level bulk
disposition control to the Focus header for when a whole page is fine.

Section bulk Approve-All / Skip-All in Focus

At least two recorder surfaces exist (DialogLineRecordPanel with no device picker, plus one with
camera/mic selection). Audit all MediaRecorder/getUserMedia entry points and unify into one shared
component (or simple/advanced tiers) before scaling the dialog pipeline.

Webcam recorder consolidation

Inline field editing on Focus reuses the shared inherit/override editor (scene/shot now editable).
Remaining nav-parity bug: several scene properties (continuity notes etc.) still do not link to
scene-properties.tsx.

Inline-edit UI parity on Focus

Replace filter chips (e.g. Character Voice) with segmented button groups; extract a shared
filter-choice component that captures the filter's purpose.

Segmented controls instead of filter chips

When a gallery entry's tags include `spherical`, append "360" to the corner dimension/format label,
and mirror the white-on-dark corner annotation (today grid-only) onto graph-view media nodes.

Spherical "360" media label

Audit the pipeline so the user is not asked to sign off the same thing in adjacent steps.

Do not ask the user to review things twice

Double-clicking the value should start editing the field; appears unwired in the Focus PlanFieldRow.

Double-click displayed text to edit

The shot-level block (ShotLookPicker + per-character Performance + "Pull starred media into this
shot") and the produce banner are gated only on isScene && shot && scene, with no step check, so they
leak onto the scene-level Storyboarding step. Gate each shot-level surface to its iterating step and
convert them into hosted criteria so the AI walker can sign them off.

Top-of-page shot surfaces leak onto the wrong step

Returning to Focus can land on the wrong stage and the URL does not match the displayed step. A class
of recurring bugs in this area.

URL <-> selected-step mismatch on return

For criteria whose work lives on a specific page (media, voice, screenplay, arcs), add a small "Open
page" affordance in Focus that carries queryParams + plan position, instead of switching to Board.

Per-criterion "Open page" context-aware navigation

A step that iterates per scene/shot/character should show a finer progress bar below the phase bar,
segmented by the number of "Next" clicks the group holds, so the user sees they are in a repeating
group and how far through they are. Pair with per-iteration intro text.

Sub-progress bar for repeating steps

The delete control disappears at one swimlane, so you cannot clear them all and start fresh.

Delete-swimlane hidden when only one remains

A "Run all" button runs every recipe step in order, gating on a pre-flight check (auto-linked inputs
populated) and a completion barrier (output registered in galleryPathIndex) before advancing -- so
async ComfyUI steps are safe. Auto-cancels on manual edit/run/navigate-away. Phase 1 (TTS path) done
2026-06-13, needs live testing; the ComfyUI-step path is unproven.

Recipe "Run all" sequential runner

An episode-focus button that walks every scene/shot, skips no-dialogue shots, resolves each speaker's
preferred voice (TTS vs voice-changer), checks freshness, builds the shot-dialogue recipe and Runs
All -- unattended, with a progress panel, per-shot status, continue-past-failure policy, and per-step
timeouts. Resumable for free via the content-addressed TTS cache.

Unattended episode "Regenerate all speech" walker

A step can produce many outputs (run it 4 times tweaking the prompt); flag one as preferred and have
it auto-flow into downstream steps' wired inputs without overwriting manual fields. Show all outputs
(no cap), click-to-fullscreen, one preferred flag per step. The key missing Execution-tab piece.
Reconcile with the exclusive "preferred-dialog" tag and the existing star=approved model -- one
model, not three.

Preferred-output flag + downstream auto-population

On scene start, link all starred media of the scene's referenced entities into the scene; per shot,
link the relevant starred entity media into the shot; on new-look creation, link the parent's starred
media down to the look. Pure cores exist (buildStarredMediaReferences, buildLookInheritedReferences);
the missing piece is the trigger/call-site that runs them and writes the gallery entries.

Starred-media propagation (entity -> scene -> shot, looks)

A pure isOutputStale(output, inputs) using lastGeneratedTimestamp + generatedByInputsJson provenance
to decide regenerate-vs-skip. Matters most for voice-changer (source re-recorded after a VC output)
and merged/assembled tracks (a line regenerated after the merge), where content-addressing alone
misses staleness.

Freshness helper (input-newer-than-output -> regenerate)

Four data-integrity issues: deleting media does not prune `_starred` (dangling "UNKNOWN" refs --
fix in the delete handler); duplicate red-flag is filename-basename based (false positives pre-
content-hashing -- make it content-hash-aware); link de-dup matches entry fileName while the gallery
dedups on resolved path basename; two reference formats and two delete markers coexist -- normalise.

Media reference / starred-list hygiene

Under content hashing a copy does not duplicate bytes and tags are per-entry, so a reference link may
earn nothing except provenance. Decide: keep links purely for provenance, or collapse to copies and
retire the reference machinery.

Reconsider reference-links vs copies under content hashing

An in-shot agent reading the shot's full context + available workflows/models (filtered by trust,
defaults to working+) that proposes 2-3 ranked recipes with plain-language reasoning, flags gaps
("you'd need to download Wan 2.2"), and scaffolds the chosen recipe into the Execution tab. Surfaces
on the shot page as a "Make suggestions" do/dismiss card set (stub in mediaGalleryRecipeSuggestions.ts;
blocked on preferred-output). Also queries the user's saved cookbook recipes once the editor lands.

Recipe Planning Agent (ranks recipes for a shot)

Extract input helpers into a shared component used by Actions and Execution: image inputs suggest the
intended upstream output (preferred output first, not the whole gallery); text/prompt inputs get
model-appropriate LLM prompt generation from workflow type + project context (characters, scene,
location, dialog) + the semantic input role. A Tier-0 end-to-end blocker.

Input helpers: upstream suggestions + LLM prompt generation

Pipeline tasks and AI proposals must respect look (variant) inherit/override/unspecified flags,
including accept/reject.

AI understands look inherit/override

Offer AI-suggested defaults for inline plan fields based on other information already provided.

AI defaults for inline plan fields

Extend the agent->client command queue (proven by navigate_to) with "perform plan operation X"
commands the browser executes using its loaded TS helpers (canDeleteShot, shot-order rewrites) + live
DB, so the text agent can do the ~58 non-trivial criteria with zero Python port, zero drift, and
invariants preserved. Keystone decision for text-chat skills.

Text-chat client-command channel for surface operations

Surface each property's allowed enum values into the criterion context so the text agent (and Mode A
edits across the 130 pure propertyIsSet criteria) stops guessing valid values. Cheap, high-value,
first in the skill build.

Enum-value surfacing into criterion context

Build 11 ConditionalSkill entries so text chat can drive every criterion the UI can (arcs, casting,
screenplay, models-and-looks, voice, reference-media, dialogue-audio, music, shot-list, composition,
assembly). ~34 net-new tools, mostly light writes via the client-command channel; ~4 heavy or
gallery-bound handoffs.

Text-chat skill library (11 skills / ~34 tools)

ComfyUI image/video generation lives only in the media gallery. Provide an open_gallery_with_recipe
tool (navigate + preset recipe) so the chat agent picks the right recipe and deep-links the user into
the gallery; it does not run ComfyUI headless. Highest-demand handoff.

Image/video generation handoff from chat

The Planning Agent generates disposable, context-aware Plans (workItems with description / assetType
/ assetId / recommendedAgentId / completed; status active|completed|abandoned) from project status +
schedule, rendered as an actionable list and discarded after the session.

AI-generated ephemeral Plans ("what to do next")

Treat GLB (models and animation clips) as another media type; render 3D to video clips via a recipe
so it mixes with AI shots; full-screen preview. Organise the code now so 3D slots in as another
recipe-driven render pipeline, even before it is fully built.

3D / GLB as a media type + render-to-video pipeline

Add an optional timeoutMs to the workflow definition / OA Metadata Note so each workflow declares its
ceiling (a quick crop vs a multi-minute render). The completion barrier and manual single runs read
it to kill hung jobs.

Per-workflow timeoutMs metadata

Let an input be marked mandatory. Copy-to-clipboard stays lenient; Run validates mandatory inputs and
fails fast with a clear message ("Source Audio is empty -- record the line first") instead of
ComfyUI's cryptic "No such file or directory".

Mandatory-input validation: lenient Copy vs strict Run

Graceful user-facing messages for out-of-credits, API unavailable, local ComfyUI OOM mid-generation,
and Comfy Cloud timeouts, with an obvious retry path and cleanup of incomplete jobs rather than
dangling them.

Cloud error-handling UX

13 operation categories have no workflow: inpainting, outpainting, variation, layer_compose,
face_detailer, text_to_video, reference_to_video, video_to_image, video_to_audio, music_generation,
audio_to_text, entity_to_prompt, image_transform. Highest-leverage now: composite-character and
relight (referenced by built-in recipes but missing), outpaint + image stitch/crop + layer_compose
(block Location templates), entity_to_prompt, text_to_video (LTX2), inpainting (Qwen edit). Tracked
by report-operation-coverage.

Operation-tag gap workflows (13 categories, zero coverage)

wan22-fl and wan-22-animate have linearData wiring but are missing from the workflow manifest, so
they never appear in the UI (multitalk is already registered).

I2V workflow manifest registration

Three workflows referenced by built-in recipes are not in the catalog: oa-catalog-i2i-crop (also
needed for scene reframe / first-last-frame crop), oa-catalog-i2t-qwen-vl, and
oa-catalog-dialog-voice-profile-training (a voice-model training step, distinct from cloning).

Missing built-in recipe workflows

A guided in-app agent (and Claude Code skill) that builds OA-compatible ComfyUI workflows from a
requirements conversation: search trusted existing workflows first, adapt a source by adding
OaWorkflowMetadata + wiring linearData, verify node compatibility against local ComfyUI
/object_info, run a test prompt, output JSON for approval. Removes the per-user hand-authoring tax.

Workflow Creation Agent (/workflow-create, /workflow-adapt)

The auto-plan button works on location/prop/character galleries but picks the first matching workflow
per tag. Add quality-ranked selection driven by the discovery model-advisory markdown (per-model
strengths/weaknesses, regenerated ~weekly to GCS) so the agent recommends the best model for a
template and can suggest enabling a new model when the current pick is suboptimal.

Auto-plan agent: dynamic catalog + model recommendation

A structured per-model record (family, render-task types, strengths/weaknesses, prompt-format notes,
OA workflow files, trust, source). Today "My Models" is UI-only and the agent cannot read it. Expose
My Models + cloud + locally-detected models as a queryable agent entity, and let the agent suggest
(user-confirmed) preference changes. This is the quality signal the auto-plan picker lacks.

Model capability catalogue (agent-readable My Models)

Per-workflow trust earned through use: new -> tested (passes a ComfyUI test run) -> working (output
kept/starred on a real shot) -> recommended (5+ shots or 2+ projects) -> deprecated. Drives candidate
filtering in the planning/creation agents; a model can be recommended in t2i but only tested in i2v.

Trust model for workflows and models

Cookbook grouped by action; saving a structurally-identical recipe increments a preferenceCount
instead of duplicating. Feeds the Recipe Planning Agent's quality signal.

Recipe cookbook redesign + preference counting

A daily offline platform agent (scheduled Cloud Run job) scanning curated trusted sources (Hugging
Face, Comfy Cloud library, ComfyUI Manager registry, curated GitHub, r/comfyui, Civitai) producing a
structured feed of new models/workflows/nodes. Must extract summaries from source text (not LLM-
invented) to avoid hallucinated capabilities. Feeds the catalogue, creation agent, and an in-app
news feed.

Discovery & AI News Agent

Productionise the harvested-workflow path so workflows from reference sites flow into
web/public/data/ after auto-conversion. Today the discovery agent reports candidates but nothing
imports at scale.

Workflow harvesting / import pipeline

Invalid workflows are rejected at ComfyUI execution time, not OA submission. Run
collectOaRenderTaskIssuesForWorkflowText before the job hits the queue and show a blocking dialog
with specific issues.

Workflow validation at submission time

Distinct from the recipe-ranking agent: reads the workflow library + shot context + model catalogue,
drafts a new multi-step recipe graph, and hands off to the recipe editor for human review.

Recipe composition agent

text_to_image (4 workflows) and image_to_image (2, general-purpose) would benefit from style variants
(photoreal, hand-drawn, anime, stylised) and domain I2I (time-of-day, weather, style transfer) so the
picker and model advisory can rank by style. Raises quality; unblocks nothing.

Style-specialised T2I / domain-specific I2I variety

The agent-service /ws WebSocket trusts the client-sent userId with no Firebase ID-token verification
(HTTP endpoints are verified). Hard blocker before any external-user deployment. Also add a start-up
guard that raises if MCP_DEV_UID is set while ENVIRONMENT=production.

WebSocket endpoint authentication

Migrate db.updatePath() -> updateEntity() with a change log enabling user/agent undo. A git-like
model: Change (fieldPath, old/new, undone) grouped into atomic ChangeSets, plus a FieldSchema
classifying fields (undoable/dependent/reference/path/computed); undo runs a safety check (direct
conflict, dependency conflict, existence, reference validity) before reverting or rejects with an
explanation. Lets agents make bolder moves. A change-log page exists; the data model does not.

Undo / change log (updateEntity migration)

Time-boxed, user-granted access (RTDB popup allow/deny, admin grants page) so an admin can follow the
user's navigation in a tab, logged in as them, for support/debugging. Keep it minimal; lean on
screen-share for the rest.