Astria

View saved version →

---
name: artboard
description: Legacy alias for the storyboard skill. Use when someone invokes /artboard or asks for the former artboard workflow; explain that it is now Storyboard, then create a text-only cinematic video storyboard in video_prompt and clear the image prompt without generating a grid image.
---

# Artboard is now Storyboard

Tell the user briefly that Artboard is now called Storyboard, then fulfill the
request directly. Do not ask them to restart with another command.

Create a text-only cinematic storyboard from the current draft and references.
Never generate a 4x4 artboard, storyboard image, contact sheet, or first-frame
image.

Write 16 numbered cinematic shots, varying camera scale and angle while keeping
the same references, subject, wardrobe, location, lighting, and grade. Preserve
every `<lora:...>` and `<faceid:...>` token exactly. Give each shot one filmable
action and do not repeat a camera scale twice in a row.

Call `present_generation` exactly once with the complete current generation
draft. Put the completed sequence in `video_prompt`, set `text` to the empty
string, and preserve every other current field, including ordered
`image_reference_urls`. If the current prompt already
contains the completed storyboard or the user asks to generate video from it,
copy that prompt into the video prompt verbatim and omit image prompt text
entirely. Do not emit an `ASTRIA_PROMPT` or `ASTRIA_VIDEO_PROMPT` command.

When the user explicitly asks to generate, use `astria video` with the exact
approved content as `--video-prompt`, omit `--text`, and never create or pass an
artboard image. If the content is still in `prompt.text`, move it byte-for-byte
into `video_prompt` and clear `prompt.text`; do not rewrite it during the
generation step. Pass each raw reference as a repeated `--image-reference` in
its original order.

View saved version →

---
name: astria-api
description: Use when making API calls to Astria for tunes, prompts, packs, image/video generation (Gemini/Seedream), inspecting or variating videos, handing an external agent session into Astria, or estimating generation and pack pricing. The reference for the `astria` CLI.
allowed-tools: Bash(astria:*)
---

# Astria CLI Reference

All Astria operations go through the bundled **`astria`** command-line tool. It
handles authentication, the API base URL, and workspace scoping for you — never
build raw `curl` calls and never read API tokens from environment variables.

Output is JSON on stdout, so you can parse ids and image URLs directly.

## Authentication

`astria` resolves credentials automatically:
1. Environment variables, if present (the Astria web app injects these).
2. `~/.astria/config.json`, written by `astria login`.

If a command fails with *"not authenticated"*, tell the user to run:

```bash
astria login          # prompts for an API key (astria.ai/users/edit/api)
```

Check the active account any time with `astria whoami`.

## Profiles

Profiles work like the AWS CLI — keep separate credentials, base URL and
workspace per profile (e.g. production vs a local dev server):

```bash
astria --profile localhost login --base-url http://localhost:3000
astria --profile localhost generate --text "..."
ASTRIA_PROFILE=localhost astria tunes list       # env-var form
```

`--profile <name>` (before the subcommand) or the `ASTRIA_PROFILE` env var
selects it. Each profile is its own file — `~/.astria/config.<name>.json`; the
default profile stays at `~/.astria/config.json`.

## Tune reference syntax

The core concept. A **tune** is a fine-tuned model trained on user images —
"tune" and "reference" mean the same thing. Reference a tune inside prompt text
with `<model_type:id:1> name`:

- `model_type` and `id` come from the tune JSON (`astria tunes get <id>`)
- `name` is the tune's class name and MUST appear right after the `<...>` token
- the trailing `:1` is a fixed part of the token syntax — it is NOT a weight or strength. Always write `:1`; never vary it and never suggest changing it.
- Combine freely: `<faceid:123:1> woman wearing <faceid:456:1> dress, white studio background`

`<faceid:123:1> woman` is correct; `John` (a bare name the model never trained on) is wrong.

## Workspace scoping

Add `-w/--workspace` to any command:
- `-w <id>` — target a specific workspace
- `-w all` — query across every workspace
- omit it — uses `WORKSPACE_ID`/config default, or personal scope

## Models

`--model` accepts a model name or a raw tune id. **Don't hardcode model
names — discover the current catalog at runtime:**

```bash
astria models              # image + video models — name, title, tune id, resolutions
astria models --refresh    # force-refresh (otherwise cached for a day)
```

The catalog is fetched from the Astria server, so it stays current as models
are added or retired and the tune ids never go stale. The output marks the
`default` model (used when `--model` is omitted) and lists each model's
supported `--resolution` values — a model with no resolutions listed doesn't
accept `--resolution`. It also lists the `video_models` catalog and the
`default_video_model` used by `astria video`.

`astria generate` / `astria video` `--help` print the current model,
resolution and video-model names inline — they read the same cached catalog.

---

## Tunes / references

```bash
astria tunes list                              # all tunes
astria tunes list --title "brown dress"        # by title / product name / SKU
astria tunes list --name shoes --name sandals  # by class name (repeatable)
astria tunes list --gallery --model-type faceid --limit 200   # public gallery
astria tunes get 123
astria tunes create --title "Brown dress" --name dress \
  --description "satin brown dress" \
  --image-url https://example.com/a.jpg --image-url https://example.com/b.jpg
astria tunes create --title "Studio shot" --name woman --image ./face1.jpg --image ./face2.jpg
astria tunes update 123 --name ring --title "Gold ring"
```

`tunes create` takes `--image-url` (remote) and/or `--image` (local file),
both repeatable. `--name` is the subject class (man, woman, dress, shoes,
sandals, pose, …). `--model-type` defaults to `faceid`.

## Prompts

```bash
astria prompts list                            # recent prompts
astria prompts list --pack-id 88               # a pack's template prompts
astria prompts list --tune-id 123              # prompts for one tune
astria prompts list --liked --is-video         # liked video prompts
astria prompts list --today --limit 100        # prompts created today
astria prompts list --text "white background" --limit 100 --offset 0
astria prompts get 555 --model nano-banana-pro       # one prompt (needs its tune/model)
astria prompts update 555 --model nano-banana-pro --pack-id 88   # assign a prompt to a pack
astria prompts update 555 --model nano-banana-pro --base-pack-id 88   # bind as a pack one-off (board frame)
```

- `prompts list` filters: `--pack-id`, `--base-pack-id`, `--tune-id`,
  `--user-id`, `--orig-prompt-id`, `--text`, and the flags `--liked`,
  `--today`, `--is-video`, `--is-api`.

## Generate images

```bash
astria generate --text "<faceid:123:1> woman, clean white studio background"
astria generate --model nano-banana-pro --text "..." --num-images 4 --aspect-ratio 3:4 --resolution 2K
astria generate --model seedream --text "product photo of headphones on marble" --num-images 2
astria generate --text "cinematic portrait" --film-grain
astria generate --text "recreate this in 4K" --input-image https://example.com/photo.jpg
astria generate --text "<faceid:123:1> woman, white bg" --pack-id 88 --wait   # author a pack template prompt
astria generate --text "..." --base-pack-id 88       # one-off bound to pack 88 — lands in its board frame
```

- `--input-image` accepts a URL or a local file path (used for image editing/upscaling).
- `--film-grain` sends film grain as a separate prompt attribute and leaves
  `--text` unchanged. `--film_grain` is an alias; `--no-film-grain` explicitly
  disables it.
- `--pack-id` authors the prompt as a pack **template** prompt; `--base-pack-id`
  records pack provenance only (a one-off). On the board, `--base-pack-id`
  generations appear as free rows inside that pack's frame.
- A `--pack-id` template prompt must **reference a fine-tuned tune** — embed a
  `<faceid:ID:1>` (or `<lora:ID:1>` …) token in `--text`. A plain foundation-model
  prompt with no reference is rejected (HTTP 422, "Prompt is not using a fine-tuned
  model"). `--base-pack-id` one-offs have no such requirement.
- `--wait` polls until the images are ready and prints the finished prompt JSON.
  Without it, the command returns immediately — images render asynchronously.
- `aspect_ratio` values: `1:1 16:9 9:16 21:9 9:21 3:2 2:3 5:4 4:5 4:3`.
- `--seed` sets the generation seed. Astria dedups prompts by `(text, seed)`
  within a tune, so the same prompt text reused on different input images
  collapses onto one prompt — pass a distinct `--seed` per call to keep them
  separate without altering the prompt text.

## Generate video

Video runs through the same prompt: the image stage renders the first frame
from `--text`, then the video model animates it from `--video-prompt`.

```bash
# Existing reference: use the same token + tune-name syntax as image generation.
# Put Seedance 2 references in --video-prompt so their images condition the video.
astria video --video-model seedance2_fast_720p \
  --video-prompt "<faceid:1234:1> woman walks down a runway as the camera tracks her" \
  --duration 5 --aspect-ratio 16:9 --wait

# New references: create them from local files or URLs and use them immediately.
astria video --video-model seedance2_fast_720p \
  --video-prompt "woman wearing a dress walks down a runway" \
  --reference woman=./model.jpg --reference dress=https://example.com/dress.jpg \
  --duration 5 --aspect-ratio 16:9 --wait

# Ordered raw references: attach the images directly without creating tunes.
astria video --video-model seedance2_fast_720p \
  --video-prompt "transition through these looks in order" \
  --image-reference ./look-1.jpg --image-reference ./look-2.jpg \
  --duration 15 --aspect-ratio 16:9 --wait

astria video --text "zwx man <faceid:123:1> in a dance arena" \
  --video-model kling30_motion_control_pro --video-prompt "match the dance moves" \
  --duration 10 --input-video ./reference.mp4
```

- Seedance 2 references use `<faceid:TUNE_ID:1> TUNE_NAME`, exactly like image
  prompts. The tune's class name must immediately follow the token. A bare
  `<faceid:1234:1>` token is incomplete.
- Put existing reference mentions in `--video-prompt`; Seedance 2 resolves the
  referenced tunes' images and sends them as video reference images.
- `--reference NAME=PATH_OR_URL` creates an instant `faceid` reference and
  prepends `<faceid:NEW_ID:1> NAME` to both `--text` (when present) and
  `--video-prompt`. Repeat it for multiple references. `--images` is an alias.
- `--image-reference PATH_OR_URL` attaches a raw image directly to the video
  prompt without creating a tune. Repeat it in storyboard order. Use either
  all local files or all URLs in one request so that ordering remains exact.
- `--first-frame` / `--last-frame` / `--input-video` accept a URL or local file.
- Motion-control models (`*_motion_control*`, `wan_animate_*`, `dreamactor_m2`,
  `happyhorse_motion_control`) require `--input-video`.

### `video_model` values and cost

Costs are per 5-second base (per 10s for motion-control / fixed-duration
models) and scale linearly with duration. `_audio` models include a soundtrack.

| video_model                     | cost (¢)    | duration options |
|----------------------------------|------------:|------------------|
| seedance_480p                    |          10 | 2–12             |
| seedance_v15_720p                |          14 | 4–12             |
| seedance_v15_audio_720p          |          29 | 4–12             |
| cinematic_video                  |          84 | 5, 10, 15        |
| wan25_720p                       |          53 | 5, 10            |
| wan26_720p / wan26_1080p         |       53/79 | 5, 10, 15        |
| wan27_720p / wan27_1080p         |       55/83 | 5, 10, 15        |
| wan_animate_720p                 |          44 | 10               |
| ltx23_720p / ltx23_1080p         |       17/22 | 5, 10, 15, 20    |
| happyhorse_720p / _1080p         |      77/132 | 3–10             |
| happyhorse_motion_control        |         154 | 10               |
| dreamactor_m2                    |          29 | 10               |
| seedance2_fast_480p / _720p      |      60/140 | 4–15             |
| seedance2_480p / _720p / _1080p  | 120/280/450 | 4–15             |
| veo31_fast_720p / _1080p         |          85 | 4, 6, 8          |
| veo31_fast_4k                    |         264 | 8                |
| veo31_lite_720p / _1080p         |       44/71 | 4, 6, 8          |
| kling30_standard / _pro          |      92/123 | 3–15             |
| kling30_4k                       |         263 | 3–15             |
| kling30_motion_control / _pro    |     277/370 | 10               |

Video output is delivered in the prompt's `images[]` with `content_type=video/mp4`.

## Inspect video

Turn a local video or public HTTPS video URL into timestamped text-to-video
prompt text. Local files are direct-uploaded to Astria automatically; do not
upload them separately or build raw API requests.

```bash
astria inspect-video ./clip.mp4
astria inspect-video https://example.com/clip.mp4
astria inspect-video ./clip.mp4 --tune-id 123 --tune-id 456
```

The output uses one `SS-SS - description` line per cut for videos up to 30
seconds. `--tune-id` is repeatable: use it when the resulting generation will
carry those references, so inspection removes their appearance details and
inserts the exact Astria reference tokens. There is intentionally no custom
prompt option; use the returned `description` as the video prompt.

## Variate video

Use `astria variate` when the user wants to preserve a source video's timing,
performance, camera, transitions, and audio while changing its content. The
command runs the Variate mini-app workflow end to end: source inspection,
replacement-reference creation, structured prompt writing, and fixed-model
Seedance 2.5 generation.

```bash
# Edit from a written brief
astria variate ./source.mp4 \
  --brief 'Change the text on the final card to say "Astria"' --wait

# Mix existing references with new local or remote images
astria variate ./source.mp4 \
  --tune-id 123 \
  --reference ./dress.jpg \
  --reference woman=https://example.com/model.jpg \
  --brief 'Replace the presenter and wardrobe' --wait

# Reuse an existing source description and avoid another inspection charge
astria variate https://example.com/source.mp4 \
  --description-file ./source-description.txt \
  --brief 'Use a warmer end-card treatment'
```

- `SOURCE` is a local MP4/MOV or public HTTPS URL.
- Repeat `--tune-id ID` for existing replacement references.
- Repeat `--reference [NAME=]PATH_OR_URL` to create replacement references.
  Without `NAME=`, the CLI detects the image class. With it, detection is
  skipped. References preserve command order within the existing/new groups.
- At least one reference or a non-empty `--brief` is required.
- `--description` / `--description-file` bypass source inspection.
- The command intentionally fixes `video_model=seedance25_720p`, enables
  generated audio, and omits duration/aspect ratio so the source drives them.
- Local source and reference files are direct-uploaded in one parallel batch.
- The JSON result contains `description`, `references`, `video_prompt`, and
  `prompt`; add `--wait` to receive the settled generation in `prompt`.

## Download

`astria download` saves a prompt's rendered assets (images, or `video/mp4`) to a
local directory. It works from a **prompt id alone** — no tune id needed — and
fetches each prompt fresh from the API, so newly rendered assets are included.

```bash
astria download 555 556 557                       # ids as arguments
astria download 555 --out ./shoot                  # custom target directory
astria download --prompts-file ids.txt             # one id per line (or whitespace)
astria prompts list --pack-id 88 | \
  python3 -c 'import sys,json; [print(p["id"]) for p in json.load(sys.stdin)]' | \
  astria download                                  # ids piped on stdin
```

- Prompt ids come from positional args, `--prompts-file`, and/or stdin; they are
  deduped with original order preserved.
- `--out` defaults to `./astria-downloads` and is created if missing.
- Each asset is saved as `prompt-<id>-<NN><ext>` — `<NN>` is a zero-padded
  index, `<ext>` is derived from the URL (`.jpg`/`.png`/`.webp`/`.mp4`/…).
- Downloads run in parallel (~6 at a time).
- A prompt that 404s, errors, or has no images yet is reported in the JSON
  output (`error` field) and does not abort the run.
- The JSON summary lists per prompt `{id, images, saved[], error?}` plus
  `totals {prompts, downloaded, failed}`.

## Packs

Packs are surfaced in the Astria GUI as **Templates** — "pack" and "template" are interchangeable terms for the same object.

```bash
astria packs list
astria packs get spring-lookbook
astria packs create --title "Spring Lookbook"
astria prompts update 555 --model nano-banana-pro --pack-id 88   # add a prompt to the pack
```

## Pricing

`cost_mc` is an integer number of **millicents** (one thousandth of a US cent):

- 1,000 `cost_mc` = $0.01
- 100,000 `cost_mc` = $1.00
- Convert to dollars with `cost_mc / 100_000`.

A prompt's `cost_mc` already includes its `num_images`; never multiply by
`num_images` again. Sum `cost_mc` across prompt records to price a prompt batch.
For example, prompts priced at 12,500 and 25,000 `cost_mc` total 37,500
millicents, or **$0.375**.

Use `astria packs get <slug|id>` before running a pack:

- `template_prompts[].cost_mc` is each stored template prompt's baseline. Sum
  all entries for the full stored baseline, or selected entries for a
  `--prompt-ids` subset.
- `costs.<class>.cost_mc` estimates a fresh reference tune of that class plus
  that class's prompt group. For multi-class packs it is not necessarily the
  cost of the entire pack.

These are estimates, not personalized quotes. Generated prompts recalculate
cost after prompt overrides; creator discounts, the payer's ecommerce pricing,
workspace rules, and Cartesian tune variants can change the result.

After `astria packs run`, use `order.total_cost_mc` as the authoritative amount
charged when an order is returned. If no order is returned, the generated
prompts' `cost_mc` values describe their individual base costs.

### Run a pack

`astria packs run <slug|id>` fires a pack's template prompts —
`POST /p/:slug/tunes`. This is the canonical "run a template": the pack
generates its whole prompt set, either against **tunes you already have** or
against a **fresh tune trained from photos**. The positional accepts either the
pack **slug** or its numeric **id** — `astria packs run zara-pants …` and
`astria packs run 3893 …` are equivalent.

```bash
# multi packs — run against existing tunes (tune_ids), with overrides
astria packs run spring-lookbook --tune-id 123 --tune-id 456 \
  --brief "golden hour, Lisbon" --aspect-ratio 3:4 --inpaint-faces

# only a subset of the pack's template prompts
astria packs run spring-lookbook --tune-id 123 --prompt-ids 501,502

# regular packs — train a fresh tune from photos, then generate
astria packs run my-pack --title Jane --name woman \
  --image ./a.jpg --image ./b.jpg          # or --image-url https://…
```

- **Who the pack runs on** — pass either `--tune-id ID` (repeatable, or a
  comma-separated list) to reuse existing tunes, **or** a training set
  (`--title` + `--name` + `--image`/`--image-url`) to train a new tune first.
  **Multi packs require at least one `--tune-id`** (the server routes tune_ids
  to its multi handler; omitting them on a multi pack is a 422).
- `--prompt-ids 501,502` runs only that subset of the pack's template prompts;
  omit it to run them all.
- `--brief` is an art-direction brief applied to the generated prompts.
- **Overrides** ride along as `prompt_attributes`: `--num-images`,
  `--aspect-ratio`, `--resolution`, `--inpaint-faces/--no-inpaint-faces`, and
  `--attr KEY=VALUE` (repeatable) for any other prompt attribute, e.g.
  `--attr super_resolution=true`.
- The positional is the pack **slug or numeric id** — both resolve to the same
  `/p/:slug/tunes` endpoint. On a multi pack the JSON response includes the new
  `order` and its `prompt_ids` — feed those to `astria prompts wait` and
  `astria download` to fetch the images.

#### Worked example — a multi pack, step by step

`zara-boot-test` (id `4001`) is a **multi pack** that composes two references —
a `dress` and a `shoes` (Footwear) — into one shoot. Create a reference per
garment, then run the pack against both by id. Scope every step to a workspace
with `-w` (find yours with `astria workspaces list`).

```bash
# 1. Create a reference for the dress (Gemini branch — instant, no training wait)
astria tunes create -w 679 --name dress --title "Zara dress" --image ./dress.jpg
# → { "id": 5234832, "branch": "gemini-2", "trained_at": "..." }

# 2. Create a SEPARATE reference for the boots.
#    Use a class the pack's slot recognizes: 'boots' (like 'shoes'/'sandals')
#    resolves to the Footwear cube, so it fills the pack's shoes slot.
astria tunes create -w 679 --name boots --title "Zara boots" --image ./boot.jpg
# → { "id": 5234834, "branch": "gemini-2", "trained_at": "..." }

# 3. Run the pack against both references — one --tune-id each.
#    'zara-boot-test' or its id '4001' are interchangeable here.
astria packs run zara-boot-test -w 679 \
  --tune-id 5234832 --tune-id 5234834 --num-images 1 --aspect-ratio 3:4
# → { "status": 201, "order": { "id": 37345, "tune_ids": [5234834, 5234832] },
#     "prompt_ids": [45042524, 45042523] }

# 4. Fetch the results (the order hands back the prompt ids)
astria prompts wait -w 679 45042524 45042523              # block until rendered (or user_error)
astria download 45042524 45042523 --out ./zara-boot-shoot
```

The pack swaps each reference into the matching template slot by lookbook cube,
so the generated prompts come back with both tokens recorded, e.g.
`a model wearing <faceid:5234832:1> dress and <faceid:5234834:1> boots, …`
(and the shoes-only template gets just the boots token). The overrides land as
prompt attributes (`aspect_ratio: 3:4`, `num_images: 1`).

Gemini-branch references (step 1–2) are ready instantly; a pack built on trained
tunes queues its prompts and renders them once the tunes finish training. Pass
one `--tune-id` per reference slot the pack defines — a multi pack needs at
least one, and rejects the run (422) if you send none.

## Board (infinite canvas)

The board (`/boards/:id` in the GUI) organizes work as **frames** (a pack-bound working context), **order rows** (one Order = a line of prompts sharing one reference set) and **reference cards** (tunes with lookbook roles: Pose, Face, Accessories, Jacket, Top, Bags & Belts, Footwear, Bottom, Background). There is no board API and no `board` verb — you act on the regular domain objects with the verbs above, and the canvas updates live (new rows land via the `order.created` broadcast, cells re-render as prompts finish).

```bash
astria packs run 88 --tune-id 123 --tune-id 456 \
    --prompt-ids 501,502 --brief "golden hour, Lisbon"  # new row: clone the pack's templates with swapped refs
astria prompts wait 7001 7002 && astria download 7001 7002   # wait for the row's cells, fetch images
astria generate --text "..." --base-pack-id 88       # one-off into pack 88's frame (free row, not a template)
# variant with edited text (stacks as a version on its cell; order_id from `astria prompts get`):
astria api POST /prompts/7001/duplicate --query view=board --data '{"prompt":{"text":"...","order_id":901}}'
# promote a prompt into the pack template / demote a template back out (confirm with the user first):
astria api PATCH /prompts/7001 --query view=board --data '{"prompt":{"pack_id":88,"base_pack_id":null,"orig_prompt_id":null}}'
astria api PATCH /prompts/7001 --query view=board --data '{"prompt":{"pack_id":null,"base_pack_id":88}}'
```

For an ordered raw-image video, pass the selected images directly with repeated
`astria video --image-reference PATH_OR_URL` options. Do not create temporary
tunes for those images.

## Workspaces & landing pages

```bash
astria workspaces list
astria workspaces create --title "Acme Store"   # new workspace → returns its id/slug
astria landing get -w 42                        # workspace JSON incl. landing_page_html
astria landing set -w 42 --html-file ./edited.html
```

## Hand work into Astria’s embedded agent

When the user asks to continue the current ChatGPT, Codex, Claude, or Cursor
session in Astria, write a concise UTF-8 `HANDOFF.md` containing the objective,
completed work, important decisions, artifact paths, unresolved issues, and the
recommended next action. Do not include credentials or hidden reasoning.

Attach only files needed to continue. Include a custom skill only when it was
actually used or is needed for the remaining work; never export credential
files or an entire agent configuration directory.

```bash
astria agent handoff -w 42 \
  --handoff ./HANDOFF.md \
  --attach ./deliverables \
  --skill ~/.claude/skills/relevant-skill \
  --source claude-code \
  --open
```

`--attach` and `--skill` are repeatable. A skill path must be a directory with
`SKILL.md`. The command uploads the versioned bundle, creates a dedicated chat
session, prints its HTTPS deep link, and opens it with `--open`. Imported skills
are reviewable session-scoped references; Astria does not silently install them
into the shared workspace skill directory.

## Raw API escape hatch

For anything without a dedicated verb:

```bash
astria api GET /prompts --query limit=5 --query offset=0
astria api POST /tunes --form 'tune[title]=Hat' --form 'tune[images][]=@./hat.jpg'
```

## Pagination

List commands accept `--limit N` and `--offset Y`. Default sort is id
descending, so `--offset` walks backwards through history.

## Errors

A non-zero exit prints `astria: <METHOD> <PATH> → HTTP <code>: <message>` on
stderr. Surface the message to the user and suggest a fix. HTTP 422 means a
validation error (missing/invalid fields).

View saved version →

---
name: landing-page-editor
description: Use when editing, updating, or iterating on a workspace's landing page HTML (the magazine-style /w/:slug page). Supports incremental edits — fetch the current HTML, make targeted changes, then write it back. NOT for initial generation — that comes from the `brief` field which runs the server-side LANDING_PAGE_PROMPT against Gemini.
allowed-tools: Bash(astria:*), Read, Write, Edit
---

# Workspace Landing Page Editor

The workspace landing page (rendered at `/w/:slug`) is a single self-contained
HTML blob stored on `workspace.landing_page_html`. It is generated from scratch
by the server-side `LANDING_PAGE_PROMPT` whenever a `brief` is submitted — that
path overwrites the HTML wholesale.

For ANY change that should not regenerate the whole page (typography tweaks,
layout edits, adding a section, changing copy, swapping an image, fixing a
tagline), edit the HTML directly and write it back. Do NOT send a `brief`
unless the user wants a full regeneration.

All commands use the `astria` CLI (see the `astria-api` skill). Pass
`-w <workspace_id>` to target the workspace.

## Constraints carried over from `LANDING_PAGE_PROMPT`

When editing, preserve these invariants (the live `/w/:slug` page depends on them):

- The output is **inner body HTML** — no `<html>`, `<head>`, `<body>`, or `<!DOCTYPE>` tags
- Styling uses **Tailwind utility classes** (already loaded on the page). Use `<style>` only for hover/animation effects Tailwind can't express
- Pack links are exactly `/p/{slug}`; model/reference links use the `link` field from the tunes JSON verbatim (do NOT re-encode `%5B`/`%5D`)
- Every image / video is wrapped in an `<a>` tag
- Image and video URLs must be ones that already exist — do not invent URLs
- Videos use `<video autoplay muted loop playsinline poster="POSTER_URL"><source src="VIDEO_URL" type="video/mp4"></video>`
- The string `__TUNES_JSON_PAYLOAD__` inside `<script type="application/json" id="tunes-data">…</script>` is a server-side placeholder. The server substitutes it at render time with the live tunes JSON. **Never replace it with literal JSON** — that freezes the cast and newly added tunes won't appear
- Editorial styling: serif headlines, generous whitespace, hairline rules, `object-cover object-[center_top]` on portrait images, `max-h-[70vh]` on hero spreads, `aspect-[4/5]` or `aspect-[3/4]` on portrait containers

## Workflow

### 1. Fetch the current landing page HTML

```bash
astria landing get -w <workspace_id> --html > /tmp/landing_page.html
```

`astria landing get -w <workspace_id>` (without `--html`) returns the full
workspace JSON — `title`, `slug`, `brief`, `url`, `public_at`, `unlisted_at` —
when you need those. Preview the rendered page at `/w/{slug}`.

### 2. Pull workspace data (when an edit needs to reference real packs / prompts / tunes)

```bash
astria packs list -w <workspace_id> --limit 100
astria tunes list -w <workspace_id> --limit 200            # the "cast" rendered on the page
astria prompts list -w <workspace_id> --limit 100 --offset 0   # page with --offset until empty
astria prompts list -w <workspace_id> --pack-id <pack_id>      # cheaper, one section at a time
```

List endpoints paginate via `--limit`/`--offset` (default sort id desc). Loop
with `--offset` until a page comes back empty.

### 3. Make the incremental edit

Edit `/tmp/landing_page.html` locally. Keep changes surgical — the generator
produced thousands of bytes of layout and most of it should stay verbatim.
Re-read the constraints section above before saving.

### 4. Write the page back

```bash
astria landing set -w <workspace_id> --html-file /tmp/landing_page.html
```

Do NOT pass `--brief` here — that discards your edits and regenerates from
scratch via Gemini.

### 5. Verify

Open `/w/{slug}` and visually confirm the change. The `__TUNES_JSON_PAYLOAD__`
placeholder is replaced server-side at render time — if a JSON-shaped string
still shows on the rendered page, the placeholder was accidentally deleted or
renamed.

## Regenerating from scratch

Only when the user explicitly asks for a full redesign — submit a `brief` and
the server runs `LANDING_PAGE_PROMPT` against Gemini, overwriting the HTML:

```bash
astria landing set -w <workspace_id> \
  --brief "Editorial fashion lookbook, AW26, dark moody palette, emphasize the womenswear packs"
```

View saved version →

---
name: navigation
description: Use when answering where things are in the Astria app — the sitemap of pages and routes.
---

# Astria Sitemap

A map of the Astria web app, for answering "where is X" and pointing users to
the right page.

Note: "tune" and "reference" are used interchangeably — they both mean a
fine-tuned model created from user-uploaded images.

## Main Pages (Authenticated)

### Tunes (Fine-tuned models)
- `/tunes` — List all references/tunes. Filters: `name=man/woman/shirt`
- `/tunes/:id/prompts` — All prompts for a reference/tune. Filters: text, base_pack_id, pack_id, user_id
- `/tunes/new` — Set up a reusable model of a person (or product) from 10-20
  uploaded photos. This is the starting point for "I want AI headshots of
  myself" when the user does not want a ready-made pack. Requires credit —
  accounts with none are redirected to the purchase page.

To add a reference to a prompt the user is *already writing*, they stay on
`/prompts` (Generate tab) and drag a reference image into the prompt box, or
click the Plus icon — do not send them to `/tunes/new` for that.

### Prompts (Image generation)
- `/prompts` — List all prompts. Filters: text, base_pack_id (prompts generated by a pack), pack_id (template prompts owned by a pack), user_id

### Packs (Themed prompt collections)
- `/packs` — Browse all packs
- `/p/:slug` — Create prompts from a pack template. Example: `/p/corporate-headshots`

### Gallery (Public/shared images)
- `/w` — Ecommerce branding gallery
- `/w/zara` — Zara demo page for fashion / e-commerce photography
- `/gallery/packs` — Gallery of headshot packs. The starting point for anyone
  who wants AI headshots or a personal photoshoot without setting anything up:
  the pack page walks them through uploading their own photos.
  - `/p/corporate-headshots` — Corporate Headshots (business, LinkedIn)
  - `/p/natural-headshots` — Natural looks (relaxed everyday portraits)

### Workspaces
- `/workspaces` — List workspaces
- `/workspaces/new` — Create workspace
- `/workspaces/:id` — Workspace detail

### User Settings
- `/users/edit/profile` — Profile settings
- `/users/edit/company` — Company settings and tax info
- `/users/edit/account` — Change email/password. If the user signed up with Google and wants a password, they use the "Forgot password" flow to create one.
- `/users/edit/api` — API keys, idempotency flag
- `/users/edit/billing` — Billing email, auto-extend model storage, auto top-off
- `/users/invoices` — Invoice history and details

### Orders & Billing
- `/pricing` — Pricing overview
- `/pricing/flux` — Cost of training a face / LoRA model. Use this (NOT `/pricing`) for any "how much to train a tune/LoRA/face" question.

View saved version →

---
name: packs-guide
description: Use when the user asks about packs, how automating AI photoshoots works or help about creating photoshoots. This product has two different target personas — Creative artists and directors who create packs and are AI savvy, and end users who want to use packs to create images but are not AI savvy. For the first group, focus on how to create packs, how to write good prompt templates, and how to create references. For the second group, focus on how to choose packs, how to upload reference images, and how to generate images from packs.
---

# Astria Packs Guide

## What Are Packs?
Packs are themed collections of prompt templates for generating consistent, professional images. Each pack contains curated prompts for a specific use case (headshots, fashion, products, etc.).

> **"Pack" = "Template".** "Template" is the label used in the GUI; "pack" is the term used in the API, CLI, and URLs (`/p/:pack-slug`). They are interchangeable — when a user says "template" they mean a pack. (Not to be confused with the *prompt templates* — the individual prompts — that a pack contains.)

Users upload reference images, then the pack's prompt templates generate images in the pack's theme using that reference.

## How Packs are used
1. User selects a pack (e.g. "Corporate Headshots")
2. User uploads reference images (shirt, shoes, dress, photos of themselves, product, pet, etc.)
3. A reference is created
4. The pack's prompt templates are automatically filled in with the reference
5. Generated images appear automatically


## How to create packs
1. Generate a few prompts with the same references (i.e: same man/woman or same shirt/shoes/dress) 
2. Once the user is happy about them - add them to a pack with a clear name and description
3. Once added - suggest navigation to the pack page /p/:pack-slug so the user can easily find it and use it again

## Publicly Available Packs by Category
Used for recommending users packs based on their needs and guiding them to the right pack for their use case.

### Fashion — Apparel
| Pack Slug | Category | Gender Support |
|-----------|----------|---------------|
| basic-shirt | Shirts | girl |
| sport-shirt-2 | Shirts | man |
| sweater-lookbook | Shirts/Sweaters | woman, product |
| basic-pants2 | Pants | woman |
| basic-jacket-men | Jackets | man |
| sport-jacket | Jackets | — |

### Fashion — Footwear
| Pack Slug | Category | Gender Support |
|-----------|----------|---------------|
| shoes-pack-shots | Shoes (product only) | product |
| casual-shoes | Casual Shoes | woman, product |
| studio-shoes-collection | Studio Shoes | woman, product |
| sport-shoes | Sport Shoes | boy |
| outdoors-trekking | Boots/Trekking | man, product |
| modern-flats | Flats | — |
| men-s-leather-shoes | Leather Shoes | — |
| sandals | Sandals | woman, product |

### Fashion — Jewelry & Accessories
| Pack Slug | Category | Gender Support |
|-----------|----------|---------------|
| jewelry-ring | Rings | product/hand |
| jewelry-necklace | Necklaces | woman, product |
| necklace | Necklaces | product |
| jewelry-earring | Earrings | woman, product |
| glasses | Glasses | woman, man |
| sunglasses | Sunglasses | woman, man |
| womens-bag | Bags | — |

### Portrait — Professional
| Pack Slug | Category | Gender Support |
|-----------|----------|---------------|
| corporate-headshots | Corporate | woman, man |
| partners-headshots | Partners/Team | woman, man |
| realtor | Real Estate | woman, man |
| md-doctor | Medical | woman, man |
| speaker | Speaker/Events | — |

### Portrait — Personal
| Pack Slug | Category | Gender Support |
|-----------|----------|---------------|
| natural-headshots | Natural | woman |
| dating | Dating Profile | woman, man |
| photoshoot | General Photo | woman, man, girl, boy |
| glamour-shot | Glamour | woman, man |

### Portrait — Events
| Pack Slug | Category | Gender Support |
|-----------|----------|---------------|
| birthday-party-save-the-date | Birthday (adults) | woman, man |
| kids-bday | Birthday (kids) | girl, boy |
| halloween | Halloween | — |
| halloween-2024 | Halloween 2024 | — |
| kids-halloween | Kids Halloween | — |
| christmas-sweater | Christmas | — |

### Creative & Themed
| Pack Slug | Category |
|-----------|----------|
| cyberpunk | Cyberpunk style |
| vikings | Viking themed |
| barbie | Barbie themed |
| game-of-thrones-style | GoT themed |
| wednesday-adams | Wednesday Addams |
| mythical-creatures | Fantasy creatures |
| wrestlemania | Wrestling themed |
| red-carpet | Red carpet style |
| annie-leibovitz | Annie Leibovitz style |
| famous-photographers | Photographer styles |
| americana | Americana style |
| botanical-illustration | Botanical art |
| whimsical-wes-anderson | Wes Anderson style |
| korean-chic-han | Korean fashion |
| tattoos | Tattoo designs |
| eurovision | Eurovision themed |
| j-crew | J.Crew style |
| youtube-thumbnail-reaction | YouTube thumbnails |
| inspiration-board | Mood/inspiration boards |

### Pets
| Pack Slug | Category |
|-----------|----------|
| dog-art | Dog portraits/art |
| cat-meowgic | Cat portraits/art |
| everyday-onesies | Pet onesies |

View saved version →

---
name: prompt-writing
description: Use when writing, improving, or debugging image generation prompts or choosing prompt parameters.
allowed-tools: Bash(astria:*)
---

# Prompt Writing

Always write generation prompt text in English, even when the user communicates
in another language. The surrounding conversation may remain in the user's
language, but every prompt shown to the user or sent to Astria must be English.

Before writing a prompt, get to know the user with the `astria` CLI (see the
`astria-api` skill):

- `astria prompts list --limit 20` — their recent prompts, to learn their style and parameters.
- `astria packs list` — their packs. If the request is about a specific subject (e.g. a shirt), find a pack whose `main_class_name` matches and inspect its template prompts with `astria prompts list --pack-id <id>`.
- `astria tunes list` — their references/tunes. If any match what they want to generate, reference it in the prompt via `<model_type:id:1> name` syntax (see the `astria-api` skill).

Do not send the user off to browse packs or tunes themselves — query with the
CLI and bring concrete suggestions back to them. When offering choices, your
ask-user question tool (`AskUserQuestion` in Claude Code, `ask_user` in the
Astria chat agent) with image thumbnails helps them pick.

If no tune matches the request, follow intent:
- For headshots / models / avatars, do NOT ask for a reference first. Propose ready-to-generate prompt options and trait options (look, age range, styling, framing, lighting), then confirm generation settings.
- For product or person-specific identity requests where likeness matters, ask the user to provide a reference image (upload it as a tune with `astria tunes create`, or drag it into the prompt box in the web app).
- Do not suggest web search for this flow.

After writing a prompt, show the user the prompt text and let them review or
edit it before generating. Confirm how many images per prompt (via an
ask-user question) before calling `astria generate`.

# Types of request

1. **E-commerce / product shots** — reference tunes to create a new image.
2. **Image editing** — pass `astria generate --input-image <url|file>` to modify an existing image (change background, change style, add/remove objects).
3. **Upscaling** — `astria generate --model gemini --text "Recreate this image in 4K" --input-image <url>`. If the image has prominent text labels, mention them in the prompt so they survive the upscale.

# Prompt Writing Guide

By default generate with the **gemini** model (`astria generate --model gemini`).
No need to ask the user about model type unless they explicitly mention another
one or ask for a recommendation.

## Default intent mapping

If the user asks to create "models", "avatars", or "headshots", interpret this
as a request for realistic, unique face headshots on a clean white studio
background:
- Do not use any reference tune for this request type.
- Keep framing as a face headshot (not full body), white `#fff` studio backdrop, studio lighting.
- Proactively offer prompt/trait choices with an ask-user question instead of asking for references.
- Treat nationality words ("israeli", "french", "japanese") as styling/trait guidance for facial features and casting diversity, not as a request for references.
- Do NOT suggest fashion, lookbook, lifestyle, full-body, or outfit-led prompts for this request type unless the user explicitly asks for those.

See the `unique-headshot` skill for the detailed face-trait template.

## Interaction rule (strict)

Never ask a question and suggest prompt text in the same response.
- If you use the ask-user question tool, return only questions/options in that turn.
- After the user answers, return the prompt suggestion(s) in the next turn.

## References

For a reference tune always use `<model_type:tune.id:1> tune.name` to reference
the trained subject:
- `portrait of <faceid:123:1> woman in a garden wearing <faceid:124:1> dress` — CORRECT
- `portrait of John in a garden` — WRONG (the model doesn't know "John")

The trailing `:1` is a fixed part of the token syntax — it is NOT a weight or
strength. Always write `:1`; never vary it, and never tell a user to change it.

## Reviewing bad results

If the user says results are bad, figure out what went wrong:
1. Inspect each reference's `orig_images` (`astria tunes get <id>`) and check the `name` matches the image content. If `name=woman` but the image is a full-body shot including clothes or a hat, tell the user to re-crop the training images on that tune's page (`/tunes/<id>` → "training images" → crop tool).
2. The `name` must represent the main subject. "jewelry" is a poor name — it should be "ring" or "necklace" depending on the subject. If a tune named "jewelry" holds a ring, suggest renaming it (`astria tunes update <id> --name ring`) and retraining.
3. Distorted or competing faces (e.g. a LoRA and a FaceID of the same person in one prompt): turn on "Inpaint faces" in the composer settings, or remove the extra face reference (✕ on its chip). Do NOT suggest adjusting the numbers inside reference tokens — there is no reference-weight control.

## Key parameters

| Parameter | CLI flag | Common values |
|-----------|----------|---------------|
| Prompt text | `--text` | Required |
| Number of images | `--num-images` | 1–4 |
| Aspect ratio | `--aspect-ratio` | `1:1 16:9 9:16 21:9 9:21 3:2 2:3 5:4 4:5 4:3` |
| Resolution (gemini only) | `--resolution` | `1K`, `2K` (default), `4K` |

## Tips for better results

- Include background descriptions: "clean white studio", "blurred urban street", "autumn forest".
- For product shots, describe the surface and arrangement.

## Keeping the background identical across generations

Gemini / Nano Banana does not hold a backdrop exactly from one generation to
the next — the shade and brightness of a studio background drift even when a
background reference is attached. Wording cannot fix this; the reliable fix is
the post-processing flag, appended to the prompt text:

```
astria generate --text "<faceid:123:1> woman in a studio --background_color #f2f0ed"
```

`--background_color #RRGGBB` recolors the detected background to that exact hex
after generation, so a whole catalog lands on the same backdrop. It runs on
Gemini / Nano Banana, partner models and Kontext — not on Flux. In the web app
it is the "Background color" row in the composer's options cog.

Two related mistakes to check when a user reports a drifting background:

- Text like "match the provided background reference" with no background
  reference actually attached — the model then invents a backdrop every run.
  Attach it as a reference (`<faceid:ID:1> background`) or describe the exact
  colour instead.
- Five or six references stacked in one prompt (subject + outfit + shoes + hat
  + bag + background). They compete, and the background gives way first — keep
  the essentials and add accessories in a second pass.

# Fashion and garments

1. Always work with a consistent face reference. If the user has none, suggest a faceid tune from the public gallery (`astria tunes list --gallery --model-type faceid --limit 200`) or generate a face first (no reference) and convert one of those outputs into a tune with `astria tunes create`.
2. Figure out the intent — a lookbook (e.g. prompt `look book plain white background #fff`) or a campaign shot. Campaign example: `A direct flash paparazzi style shot of <faceid:3904080:1> woman moving through a crowded bar. She looks straight into the lens with an intense expression. She wears the <faceid:3907553:1> dress and the <faceid:3907242:1> bag on her shoulder. The background is dark and out of focus. High contrast, sharp flash.`

View saved version →

---
name: store-photoshoot
description: Use when turning a brand's whole online store (Shopify or WooCommerce) into a reusable Astria AI photoshoot — crawl the catalog, extract the brand's DNA, cast avatars, and build packs that re-shoot the entire collection (and every future drop) in the brand's own look. Trigger phrases — "build a photoshoot from my store", "crawl STORE_URL and make packs", "AI product photography for BRAND", "re-shoot our catalog".
allowed-tools: Bash(astria:*), Bash(python3:*), Bash(curl:*), Read, Write, AskUserQuestion
---

# Store Photoshoot Builder

Given a brand's storefront URL, crawl the shop, extract its brand DNA, and build
a complete, reusable AI photoshoot system in an Astria workspace: a casting
board of brand avatars (when on-model shots are needed), product reference
tunes, and a set of **packs** (prompt templates) that can re-shoot the brand's
entire catalog — and every future collection — in the brand's own visual
language.

All Astria operations go through the `astria` CLI (see the **astria-api**
skill) — never raw API calls, never tokens in skill text. Scope every command
with `-w <workspace_id>`. Everything you register in Astria — faces, garments,
shoes, jewels, poses, backgrounds, props, logo lockups — is a **single-image
faceid reference tune** whose `name` is a controlled class noun (`woman`, `man`,
`boy`, `girl`, `dress`, `shirt`, `pants`, `shoes`, `ring`, `necklace`, `chain`,
`earrings`, `bracelet`, `pose`, `background`, `outfit`, `bottle`, …) and whose
`title` is the human/SKU label. Prompts address them as `<faceid:ID:1>
<class-noun>` — the class noun immediately after the token is the routing
mechanism that tells the model what to take from that reference.

**Deliverable of a full run:** a workspace containing (1) a confirmed Brand DNA
brief, (2) a 2–5 avatar casting board (on-model only), (3) product reference
tunes, (4) one pack per item-type / outfit formula with a fixed shot battery,
(5) a QA'd pilot render, then the scaled catalog, and (6) a workspace landing
page.

Related skills: **astria-api** (the CLI), **unique-headshot** (avatar casting),
**prompt-writing** (prompt grammar & parameters), **packs-guide** (packs),
**landing-page-editor** (the `/w/:slug` page).

---

## Phase 1 — Crawl the store

**Detect the platform first**, then use its public JSON endpoints. Crawl
politely: sequential requests, a normal browser User-Agent.

**Shopify** — `{store}/products.json` returns JSON:
```
GET {store}/products.json?limit=250&page=N     # loop N=1,2,3… until "products" is empty
GET {store}/collections.json?limit=250          # collections + products_count
GET {store}/collections/{handle}/products.json  # per-collection membership
GET {store}/pages.json?limit=100                # About / editorial / brand-story pages
```
Per product capture: `title`, `product_type`, `tags`, `vendor`, `body_html`
(strip HTML), `variants[].price`, `images[].src` (CDN URLs — the tune training
source), `options` (sizes → audience signal).

**WooCommerce** — `{store}/products.json` returns the homepage, not JSON. Use
the Store API instead:
```
GET {store}/wp-json/wc/store/v1/products?per_page=100&page=N   # loop until empty
GET {store}/wp-json/wc/store/v1/products/categories?per_page=100
```
Per product: `id`, `name`, `sku`, `type` (`simple`|`variable`),
`prices.price` (÷ 10^`currency_minor_unit`), `images[].src`, `categories[].name`,
`variations`. Homepage `og:` meta and `/product-sitemap.xml` give the brand
name, logo, and a full product-URL list if the Store API is disabled.

**Fallbacks** — if JSON is gated (password/B2B): `{store}/sitemap.xml` →
`sitemap_products_*.xml`, or ask the customer for a product-export CSV, or for
direct image URLs.

**Image audit (critical).** Download 20–40 product images across categories and
*look at them* (actually view each image). Record, per category: shot style (on-model vs
packshot vs flat-lay vs atmosphere); angle coverage (front/back/side/detail);
the house background hex (sample corner pixels); model casting (age, gender mix,
ethnicity, styling); lighting fingerprint (softbox-even vs flash vs daylight).
The photoshoot you build must be recognizably *the same brand* — these
observations become the pack defaults. Front+back product photos also decide
which items can support back-view templates.

## Phase 2 — Extract the Brand DNA brief

Synthesize a structured brief and **confirm it with the customer before
building** — one round with your ask-user question tool (`AskUserQuestion` in
Claude Code, `ask_user` in the Astria chat agent): brand read, shoot register,
casting direction. Capture:

- `brand`, `vertical` (fashion | footwear | jewelry | beauty | supplements | home-decor | mixed)
- `categories`: product_type histogram → tune classes, SKU counts, back-photo availability
- `sku_scale`: boutique(<100) | catalog(100–1K) | factory(1K–10K) | enterprise(10K+)
- `audience`: gender (women/men/both/kids/family), age band (from sizes, copy, collection names), a **body-guard** line for prompts (see Phase 5)
- `positioning`: mass/family | contemporary | premium | luxury — from price stats (median/max variant price) and About/collection copy tone
- `aesthetic`: `background_hex` (from the image audit), lighting, brand comps
- `shoot_plan`: which registers (Phase 3), how many avatars
- `pilot_skus`: 8–15 products spanning the top categories

**SKU scale drives the architecture:** boutique → hand-picked hero looks, richer
editorial per look; catalog → pack-per-outfit-formula factory, `--create_crops`
for detail shots, one avatar per pack; factory+ → hardened templates run as
named batches (3 angles/look, per-colorway tunes) — prioritize best-sellers and
the newest collection, never try to shoot the whole 10K in the pilot.

## Phase 3 — Choose the photoshoot registers

A brand usually gets one primary register + one or two supporting. Ask the
customer which they want as the lead when the vertical supports several
(a single ask-user question). Avatars are cast **only** for on-model registers.

| Vertical | Primary | Supporting |
|---|---|---|
| Fashion (garments) | Studio lookbook on-model (front/45°/back battery) | Ghost/3D packshots; location campaign |
| Footwear | Product packshot 5-angle battery | On-model legs-down crops; atmosphere still-life |
| Jewelry | Still-life on tactile surfaces + worn close-ups | Extreme macro; hand-model for rings |
| Beauty (bottles/cremes/sprays) | Packshots on seamless + atmosphere (marble, stone, water, botanicals) | Texture macro; application close-ups |
| Supplements | Clean packshots + kitchen/gym lifestyle | Ingredient still-life; hand-holding product |
| Home decor | In-room styled atmosphere | Detail/texture macro; ghost packshot |

## Phase 4 — Create / target the workspace

Use the customer's existing workspace when they name one (`astria workspaces
list` → target with `-w <id>`); otherwise create one named after the brand
(via the workspace UI, or `astria api POST /workspaces` if available — confirm
the id with `astria workspaces list`). Note the house background hex — every
studio template pins it twice (in prose and via `--background_color`).

Two-greys convention: packshots on `#F2F2F2` (luminance-flattened), on-model
studio on `#F5F5F5`/`#e9e9e9`-family off-whites, luxury lookbooks on pure
`#FFFFFF` + flash — unless the brand's own photography says otherwise.

## Phase 5 — Cast the avatars (on-model registers only)

Avatars are synthetic faces generated from trait-dense prompts, **no reference
tune** — the **unique-headshot** method. Generate with
`astria generate --model recraft-4-1 --num-images 2 --aspect-ratio 1:1`, bare
shoulders, hair pulled back, **no jewelry on the face ref** (critical for
jewelry brands — earrings on a face ref contaminate every render), ≥1 unique
distinguishing feature, never repeat an ethnicity in a batch. Match casting to
the Brand DNA (audience age, ethnicity mix, positioning). Present a candidate
board (ask-user question with thumbnails), then register each winner:

```
astria tunes create -w <id> --title "<Name> — <brand>" --name woman|man|boy|girl --image-url <winner.jpg>
```

**Casting board size: 2–5 faces.** Production brands run one avatar per
ethnicity and hold **one avatar constant across all shots of a pack** —
consistency beats variety. Attach the brand's **body-guard** text (rides after
the person token in every prompt):
- kids/tween: `boy 1.30 high` / `girl 1.30 high`; toddler: `girl 1.5 yo toddler, proportional head`
- womenswear luxury: `tall supermodel proportions, elongated legs, long neck, narrow waist` + `sleek, low, slicked-back bun`
- menswear premium: `tall male supermodel proportions, elongated athletic body, broad shoulders narrow waist, masculine confident posture`
- explicit age when relevant: `11 y o teen girl`, `teen 15 y o man`

Footwear legs-down crops, pure packshot, and atmosphere plans skip avatars —
the model (if any) is described verbally and the face is cropped out.

## Phase 6 — Ingest product references

For each pilot SKU, create a faceid tune from the shop's CDN images:

```
astria tunes create -w <id> --title "<SKU or product title>" --name <class> \
  --image-url <front.jpg> [--image-url <back.jpg>]
```

- Map `product_type` → tune class with a controlled vocabulary. The class must
  be the *actual subject* — "jewelry" is a poor name; use `ring`/`necklace`/
  `chain`/`earrings`. Rename + retrain if wrong (`astria tunes update <id> --name ring`).
- **Variant products (`type: variable`):** do NOT blindly take `images[0]` — it
  is often the wrong colorway/variant. Match the chosen image to the intended
  variant (or ingest one tune per variant). A mismatch trains a faithful render
  of the *wrong* product.
- **Non-ASCII image URLs** (Hebrew/RTL/Cyrillic paths) must be
  **percent-encoded** before `--image-url`, or Astria returns HTTP 422 "could
  not download".
- Prefer clean product-only images over on-model shots for garment fidelity.
  Include the back photo only when the battery has back views. One tune per
  colorway. Keep the SKU code in the title — it's the join key back to the shop.
- Optionally register support tunes: a `background` set plate, `pose` refs
  (OpenPose skeletons or black product silhouettes),
  brand `label`/`text` lockups for print fidelity, props (`chair`, `car`).

## Phase 7 — Author the packs (the core)

**A pack = one item-type or outfit formula × a fixed shot battery.** Shot
variety lives in the templates; per-SKU variety comes from swapping the
reference tokens. Create with `astria packs create --title "<Brand> — <Formula>"`
and author each template into the pack (see **astria-api** for pack-authoring).
Iterate until the pilot passes QA.

### 7.1 House prompt grammar (studio lookbook)

```
<shot/pose line: framing + angle + stance>
<faceid:AVATAR:1> woman <body-guard text>
<faceid:GARMENT_TOP:1> shirt <fit & layering directives>
<faceid:GARMENT_BOTTOM:1> pants <coverage directives>
<faceid:SHOES:1> shoes
[<faceid:BACKGROUND:1> background] plain background {HEX} softbox --background_color {HEX} [--create_crops 70]
```

- Weight is always `1.0`.
- Free text after each garment's class noun does the **fit/layering** work:
  `shirt over size, sleeves reach just past the elbow, shirt out of the pants`,
  `front shirt half tucked inside the pants`, `pants cover the shoes`,
  `buttoned shirt worn open over the shirt, top two buttons open, untucked hem`,
  `pants reach the shoes, no socks visible`.
- **Layer-visibility clauses** control partial garments: `visible hem of`,
  `visible waistband of`, `only the bottom hem is visible at the top of the frame`,
  `Absolutely no part of the dress fabric is visible` (for shoe macros).
- **Fidelity guards** where reference photos are messy: `ignore back label`,
  `don't change the color of the pants`, `Use the outfit reference only for the
  clothing: garment shape, fabric, color, print, trims, sleeve length…`,
  `Model identity, face, body, hands, nails and hair come from the model
  reference`, plus a negative tail (`Avoid hair down, bangs, copied room
  background, rug, carpet, barefoot, missing shoes; no plastic skin, no beauty
  filter, no extra limbs`).
- Params: **3:4, 4K, num_images 1** (2–4 for the hero front shot). Discover the
  default model with `astria models`. Detail shots come free via
  `--create_crops 66–72` (full frame + 2 crops) instead of separate prompts.

### 7.2 Shot batteries per item type

Author one pack per formula the shop actually sells; each bullet = one template.

- **Tops (shirt/polo/tee/sweater)** — front full · 35–45° front-side · back full · half-body front · waist/tuck detail · optional walking / left profile.
- **Coat / jacket / blazer** — front closed · front open over inner top · 45° · back (highlight structure) · half-body back over-shoulder · collar/shoulder macro.
- **Pants / jeans / shorts** — front · 45° · back · waistline crop · lower-half at 45° (`weight shifted to back leg, showcasing drape`) · walking.
- **Dress / skirt** — front · 45° · back · walking/movement (`fabric swishes`) · half-body · fabric macro · optional seated.
- **Footwear — packshots (no model):** strict side elevation (toe right, heel left, camera level with centerline) · straight-on front from low camera · rear three-quarter · overhead flat-lay · pair at 3/4 one shoe staggered · tight macro on stitching. Every template carries `no foot, no model, no extra objects, seamless light neutral grey studio background, realistic contact shadow beneath the product, natural scale, no compression or squashing` + `--background_color`.
- **Footwear — on-model:** lower-half 45° · legs-down crop (`close shot from the knees down, always focus on the shoes`) · low-angle shoe close-up (`see only hem of pants above the footwear`) · seated with shoes in foreground.
- **Bags & accessories** — 3-framing trio: front centered with negative space · three-quarter for depth · tight macro on hardware · plus one on-model hold/wear. Eyewear: `45 degree side-profile fully open, showing the temple arms` + front + worn close-up.
- **Jewelry** — three families (1:1): *still life* on smooth white fabric / silk / matte stone / sculpted ceramic, `not a close-up, medium distance framing` for negative space; *worn close-ups* `<faceid:WOMAN:1> woman wearing <faceid:JEWEL:1> earrings` with strict crops — necklace bust `upper chest and neck` or `cropped just below the eyes`; earrings `tight close-up, crop from ear to collarbone, side profile`; ring on a hand model (`hand resting on a stone tray beside an espresso`, always `manicured nails`); chain worn on bare chest/neck; *macro* 100mm. House stanza: `soft neutral-warm studio lighting, diffused directional light from front-side, very soft highlights, no yellow cast, balanced white tones, natural beige palette slightly warm but desaturated`. Rotate skin tone across templates.
- **Beauty (cremes/bottles/sprays/lotions)** — *packshot* front label-centered · 45° · back (label legible — register a `label` text tune if type fidelity matters) · line family shot; *atmosphere* product on marble/travertine/wet stone with droplets · botanical styling · backlit translucency · texture macro (cream smear, spray mist); optional application close-ups (hands/cheek/collarbone, no face identity). Surfaces & lighting borrow the jewelry vocabulary (`no yellow cast` for golds/ambers).
- **Supplements** — packshot battery + lifestyle atmosphere (morning kitchen with citrus and water; gym-bag still life; hand holding the jar label-forward) + ingredient flat-lay.
- **Home decor** — in-room atmosphere (one coherent interior per collection, palette-matched) · straight-on packshot on seamless · texture/detail macro · scale shot with a human element (hand on ceramic, figure near the lamp — face optional).

### 7.3 Campaign register (hero content, optional)

Not pack templates first — long-form prompts in the brand's language, promoted
to a pack once a scene wins. Structure with labeled sections
(`LOCATION / FOREGROUND / SUBJECT / BACKGROUND / CAMERA / LIGHTING / MOOD / STYLE`),
one coherent location vocabulary per campaign (reuse the same scene description
verbatim across the set; pin it with a `background`/`location` tune). Film/camera
vocabulary is the realism lever matched to positioning: luxury `85mm, shallow
depth of field, Kodak Portra 400 film grain`; street-cool `35mm, f/8, hard
direct on-camera flash, ISO 400`; family-candid `soft diffused overcast
daylight`. For premium work add an anti-CGI block (`visible pores, no smoothing,
natural fabric behavior, imperfect drape, soft analog 35mm grain`). Formats
9:16 / 16:9, 4K, num_images 2–3.

### 7.4 Pose control ladder

1. **Text first** (default): terse angle line, escalate to full photographic
   paragraphs (weight distribution, gaze, camera height, 20–30° body angle) when
   stances drift.
2. **Skeleton pose tunes**: train OpenPose stick-figure renders as `pose` tunes
   (front / 45° / back), lead the prompt with `<faceid:POSE:1> pose`, refine verbally.
3. **Silhouette lock** (to clone the brand's *existing* photography stance-for-
   stance): threshold a real catalog photo to a black silhouette, register as
   `pose`, prompt `replace the <faceid:POSE:1> pose … Keep the pose exactly as
   in the silhouette. Ignore the pose from the outfit.`

### 7.5 Video add-on (optional)

- Runway loop per look: Seedance, 16:9, 8–9s, three timestamped beats — walk in
  from left → stop center & pose → walk past camera and exit; `Static camera,
  continuous motion, no cuts`.
- Product turntable: one storyboard prompt, `slow smooth 360-degree rotation over
  8 seconds`, per-second angle checkpoints, a negative block (`avoid fast
  spinning, deformation, extra objects, text, logo`).

## Phase 8 — Pilot, QA, scale

1. Render the pilot: each pack × 2–3 SKUs of its category, one avatar held
   constant per pack. Keep it modest (≤ ~40 images).
2. QA each render: garment/jewel shape·color·print fidelity; layering (tucks,
   hems, waistbands); face = avatar (no drift); background exactly the house hex;
   anatomy (hands, feet); no leaked artifacts (room backgrounds, mannequin
   stands, care labels); `no yellow cast` on golds; brand text/logos legible.
3. **Stop and get sign-off before scaling** — mass generation is real spend.
   Fix by tightening the responsible clause (add a guard or negative), not by
   rerolling blindly. If an item renders wrong repeatedly, inspect the tune's
   training images (bad crops / wrong class / wrong variant are the usual cause).
4. Scale in phases: best-sellers/newest first for sign-off, then the rest.
   Iterate over the crawled product list — `tunes create` per SKU, one generate
   per template with the SKU's tokens swapped in. Name batches
   (`<BRAND> BATCH1 LOOK 1–N`).
5. Post-production at volume: background-removal passes for cutouts, 16:9
   recrops for banners, upscale passes for hero shots.

## Phase 9 — Landing page & handoff

Generate the workspace landing page from the brief (see **landing-page-editor**):
`astria landing set -w <id> --brief "<positioning, palette, collections, packs to feature>"`.
Report to the customer: workspace link, the casting board, each pack (`/p/<slug>`)
with its battery, pilot images, and the one-step instruction for future
collections — *point us at the new products; the packs re-shoot the whole drop
automatically.*

---

## Appendix — Style presets by positioning

| Positioning | Background | Lighting | Body / styling | Suffix vocabulary |
|---|---|---|---|---|
| Kids / family mass | `#e9e9e9` softbox | even softbox, `small smile` | height guard, playful poses | clean e-com, `--create_crops` |
| Contemporary basics | `#F5F5F5` seamless | soft studio light | natural relaxed stance | `Kodak film 400 grain` |
| Premium menswear | `#E7E7E7` / light gray | professional fashion editorial lighting | tall supermodel proportions | quiet-luxury comps (`COS / ARKET… Minimal. Architectural. Retail-ready.`) |
| Luxury womenswear | pure `#FFFFFF`, no floor | **direct on-camera flash** | sleek slicked-back bun, elongated legs | sharp e-commerce catalog image |
| Street / cool | dark or night urban | hard flash, underexposed bg, ISO 400 grain | candid mid-stride, `not posing` | `by William Eggleston` / Tillmans |
| Jewelry / beauty | cream-beige, tactile surfaces | soft neutral-warm, **no yellow cast** | manicured hands, rotated skin tones | quiet luxury product photography, 4K clarity |

Keep the preset reasoning inside the Brand DNA brief — the customer confirms it
once, and every template inherits it.

View saved version →

---
name: storyboard
description: Turn a rough scene, image prompt, or reference-led visual idea into a text-only cinematic video storyboard. Use for /storyboard, "turn this into a cinematic scene", "storyboard this video", or direct text-to-video planning. Write the finished shot sequence into video_prompt and clear the image prompt; never generate a storyboard-grid image.
---

# Video Storyboard

Turn the current draft into a cinematic shot sequence written directly in the
video prompt. Never generate a 4x4 artboard, storyboard image, contact sheet, or
first-frame image.

Always write the finished storyboard and all generation prompt text in English,
even when the user communicates or supplies the draft in another language. The
surrounding conversation may remain in the user's language. Translate
non-English draft content into English while preserving its meaning and all
reference tokens exactly.

## Use the current draft

Read the current image prompt, reference tokens, aspect ratio, and any existing
video prompt from page context. Also read `image_reference_urls` as an ordered
sequence of raw visual waypoints. Treat a handoff such as "Turn this into a
cinematic scene" as permission to make the missing creative choices when the
draft already contains a reference, scene, and general idea of the frame. Do
not ask the user to repeat those details.

Discard every reference whose tune `name` is `pose`, including its complete
`<lora:...> pose` or `<faceid:...> pose` mention. Never copy a `pose` tune into
the storyboard or use its reference image for the video. This applies even when
copying an otherwise completed prompt verbatim. Do not remove ordinary prose
that describes a subject's pose, stance, or movement.

Preserve every other `<lora:...>` and `<faceid:...>` token exactly. Keep the
same character, products, wardrobe, location, time of day, lighting, and grade
throughout the sequence unless the requested story deliberately changes one.
Preserve every raw image reference exactly and in the same order. Do not turn
raw references into tunes or embed their URLs in the storyboard text. A raw
reference may be a public HTTP(S) URL or an absolute `/workspace/...` path from
an attached file; keep either form unchanged and never rewrite a workspace path
as `file://` or invent a public URL for it.

## Write the storyboard

Default to 16 numbered shots for a 15-second video unless the user explicitly
requests another supported duration:

- Give each shot one camera scale, one subject, and one filmable action.
- Do not repeat a camera scale twice in a row. Rotate among extreme close-up,
  close-up, medium, long, and extreme long shots.
- Vary angles with front, back, profile, low-angle, top-down, and
  over-the-shoulder views where useful.
- Use shots 1-3 to establish the hero, environment, and motion; shots 4-13 for
  the action montage; and shots 14-16 for a product/detail beat and a closing
  wide shot.
- Put the global light, color grade, grain, and atmosphere in shot 1, then keep
  them continuous.
- Use the identical reference token whenever its subject appears. Chain
  continuity with phrases such as "the same woman", "she", and "her".
- When ordered raw image references are present, make the action progress from
  reference 1 through the final reference in order, describing filmable visual
  transitions between them rather than treating them as unrelated examples.

Write only the numbered shots in the finished video prompt. Do not add a grid
header or describe storyboard tiles.

## Apply it to the composer

Choose the video model before calling `present_generation`:

- Preserve an explicit video model already selected in the current draft.
- Otherwise, reuse the Seedance 2.5 or Seedance 2 model and resolution established
  by the user's prior videos.
- If prior videos do not establish either default, ask the user to choose between
  Seedance 2.5 and Seedance 2. Do not silently use the composer's global default.

Call `present_generation` exactly once with the complete current generation
draft. Put the completed sequence in `video_prompt`, set `text` to the empty
string, discard all `pose` tune references, and preserve the remaining fields
from Current generation draft JSON, including the ordered
`image_reference_urls` array. Set `video_duration` to `15` unless the user
explicitly requested another supported duration. Set `video_model` to the
explicit, established, or user-selected model from the rules above. This writes
the sequence directly to video mode with no image/first-frame prompt. Do not
repeat the storyboard in assistant text and do not emit an `ASTRIA_PROMPT` or
`ASTRIA_VIDEO_PROMPT` command.

If the current image prompt already contains the completed storyboard or the
user asks to move the current prompt into video mode, remove any `pose` tune
reference, then put everything else into the `present_generation`
`video_prompt` field and set `text` to the empty string. Preserve English
content verbatim. If the content is not in English, translate it faithfully
into English without summarizing, prefixing, trimming, or otherwise rewriting
it beyond translation.

## Generate video

When the user explicitly asks to generate, pass the exact approved, pose-tune-
free storyboard as `--video-prompt`, omit `--text` entirely, and default to a
15-second duration unless the user explicitly requested another supported
duration:

- If `prompt.text` still contains the content and `video_prompt` is empty,
  discard any `pose` tune reference, move the remaining `prompt.text` into
  `video_prompt`, and clear `prompt.text` before generation. Preserve English
  content byte-for-byte. Translate non-English content faithfully into English;
  do not expand, summarize, prefix, trim, or otherwise rewrite it beyond
  translation during this generation step.
- If `video_prompt` is already populated, discard any `pose` tune reference and
  use English content as-is; translate non-English content faithfully into
  English before generation.

```bash
astria video --video-model "<the chosen Seedance 2.5 or Seedance 2 model>" \
  --duration 15 --num-images 1 \
  --image-reference "<reference 1>" --image-reference "<reference 2>" \
  --video-prompt "<the exact approved storyboard>"
```

Include one `--image-reference` for every raw reference, in its original order.
Omit those options when the draft has no raw image references. Use either all
local paths or all URLs in a single command.

Replace `15` only when the user explicitly requested another supported
duration.

Use the current aspect ratio when it is available. Raw `--image-reference`
waypoints are not first-frame prompts. Do not create or pass an artboard image,
an input image, or an image/first-frame prompt unless the user explicitly asks
for one.

View saved version →

---
name: unique-headshot
description: Use when generating unique AI headshot/model faces without a reference tune. Creates diverse, realistic casting-style headshots with detailed facial trait descriptions.
allowed-tools: Bash(astria:*)
---

# Unique Headshot Generator

Generate realistic, unique face headshots for AI model creation. No reference tune needed — the prompt itself defines the face through detailed physical trait descriptions.

## Prompt Template

```
Close-up studio headshot of a [age]-year-old [ethnicity/heritage] [gender] with [skin_tone] skin, [skin_details], [eye_description], [nose_description], [face_structure], [unique_feature], [hair_description]. Bare shoulders, no clothing visible, no jewelry. [expression], looking at the camera. Clean white background #fff, [lighting], fine natural skin texture and an even, unmarked complexion, beauty headshot
```

## Slot Definitions

### Age
- Range: 18–35 for young models, 35–55 for mature
- Always specify exact age (e.g., "22-year-old")

### Ethnicity / Heritage
Describe a specific heritage because it guides realistic facial features — it is a
casting choice, never a default. Rules:
- **Derive it from what is asked or seen.** When the brief comes from a brand's own
  photos, read the heritage off the visible skin tone, hair and features. Never infer
  it from the brand's country, language, store name or currency: an Israeli shoe store,
  a French label or a Japanese marketplace does not make its models Israeli, French or
  Japanese.
- **No house default.** With no visual or written cue, spread a batch across regions
  (East Asia, South Asia, Southeast Asia, West/East/Southern Africa, North Africa and
  the Middle East, Northern/Southern/Eastern Europe, Latin America, Indigenous and
  mixed heritage) and never repeat a region within the batch.
- Single origin: "Nigerian", "Korean", "Irish", "Mexican", "Filipina", "Norwegian",
  "Egyptian", "Peruvian", "Punjabi", "Vietnamese"
- Hyphenated heritage: "Brazilian-Japanese", "Ghanaian-British", "Lebanese-Italian",
  "Maori-Polynesian", "Colombian-Korean", "Turkish-German", "Somali-Swedish"
- Regional descent: "of Eastern European descent", "of West African descent",
  "of Andean descent", "of Han Chinese descent"

### Skin
Pair a **tone** with subtle **texture/detail**. Default to an even complexion with fine natural pore texture; distinctive skin markings are optional and only included when requested:
- **Tones**: porcelain, fair, light olive, olive-tan, warm golden-tan, cinnamon-brown, warm caramel, olive-bronze, coppery-bronze, warm umber, deep dark, dark mahogany, ebony
- **Undertones**: pink flush, cool blue-black undertone, warm golden undertone, cool undertone
- **Default details** (pick 1): fine natural pore texture, subtle natural sheen, soft peach fuzz on jawline
- **Optional markings** (only when requested): freckles, beauty marks, moles, scars, hyperpigmentation

### Eyes
Combine **shape**, **color**, and **distinguishing trait**:
- **Shapes**: almond-shaped, deep-set, round, wide-set, monolid, hooded, large expressive, doe eyes, heavy-lidded
- **Colors**: steel-blue, hazel, green-hazel, dark brown, dark walnut, amber, blue-grey, rose-tinted
- **Traits**: slight upward tilt at outer corners, thick lashes, heavily-lashed, barely-there pale lashes, set close together, spaced wide apart

### Nose
- narrow straight nose, petite button nose with flared nostrils, prominent Roman nose with defined bridge bump, aquiline nose, aquiline hooked nose, broad flat nose, long narrow nose turning slightly downward at tip, small upturned nose, strong nose, narrow bridge nose

### Face Structure
Combine **shape** with **defining bone structure**:
- **Shapes**: angular, heart-shaped tapering to pointed chin, round, narrow, oval, elongated
- **Bones**: sharp cheekbones casting slight shadows, high rounded forehead, strong square jaw, sharp defined jawline wider than forehead, prominent cheekbones, soft jawline, strong angular jawline, delicate pointed chin, small rounded chin

### Unique Features (pick 1-2 for distinctiveness)
These are critical for making each face unique:
- pronounced dimple on left cheek only
- one eyebrow set slightly higher than the other
- thick arched eyebrows that nearly meet
- asymmetric face with one slightly higher cheekbone
- slightly asymmetric smile
- a pronounced cupid's bow
- thin elegant neck / long neck / impossibly high forehead / elongated swan neck
- visible peach fuzz on jawline

### Hair
Always pulled back to keep face clear. Vary the style:
- sandy-blonde fine hair brushed back flat behind ears into a low knot
- black hair smoothed back into a neat low chignon
- dark curly hair tamed back into a tight bun
- dark espresso hair slicked back into a sleek low ponytail
- jet-black coarse hair pulled tightly into a high sculptural bun
- auburn red hair slicked back into a neat low chignon
- ash blonde hair brushed back behind ears
- straight black hair pulled back into a sleek tight ponytail
- glossy black hair swept back into a sleek twisted bun at the nape
- dark brown hair in a clean slicked-back low chignon
- dark hair slicked back into a tight oiled ballerina bun
- hair braided flat against scalp into a sleek gathered bun at nape
- hair in a severe slicked-back low knot

### Expression
- Poised neutral expression
- Gentle closed-mouth smile
- Calm direct gaze
- Natural relaxed expression
- Direct confident gaze
- Slight closed-mouth smile
- Composed knowing expression
- Soft parted lips, steady gaze
- Relaxed self-assured expression
- Quiet intensity, lips slightly pressed
- Unblinking confrontational stare
- Defiant half-squint

### Lighting
Vary lighting for natural diversity:
- soft ring light
- soft butterfly lighting
- soft diffused studio lighting
- soft even studio lighting
- flat diffused studio lighting
- even soft studio lighting

## Generation Rules

1. **No reference tunes** — these prompts generate entirely new faces (no `<faceid:...>` tokens)
2. **Always generate with Recraft 4.1 Pro**. Before generating, run `astria models` and resolve the current Recraft 4.1 Pro entry by its name/title (the catalog may expose a CLI name such as `recraft-4-1` or a display title such as `Recraft V4.1`). Never hard-code or infer a numeric tune ID, never use the composer default, and never silently substitute another model. Use the discovered model name for `astria generate`; in chat, use the discovered tune ID in `present_generation` — its detailed skin rendering suits beauty headshots
3. **Default parameters**: `--num-images 2 --aspect-ratio 1:1` (Recraft has no `--resolution` — that flag is Gemini-only)
4. **Never repeat the same ethnicity/heritage** in a batch, and never lean on one
   region across batches — check your last few prompts and move on
5. **Every prompt must have at least one unique distinguishing feature** in facial geometry or expression (dimple, brow shape, asymmetric smile, cupid's bow, etc.). Do not use a skin mark to satisfy this rule. Unless the user requests one, omit moles, beauty marks, freckles, and other localized pigmentation from the prompt. Describe natural texture with pores or sheen without implying pigmented spots. If a skin marking is explicitly requested, adapt the default suffix to accommodate it.
6. **Hair is always pulled back** — no hair framing or covering the face
7. **Default suffix**: `Bare shoulders, no clothing visible, no jewelry. [expression], looking at the camera. Clean white background #fff, [lighting], fine natural skin texture and an even, unmarked complexion, beauty headshot`
8. **No photographer references or magazine names** in the prompt — keep it clean and generic

## Batch Generation

When generating multiple unique headshots, maximize diversity:
- Vary ethnicity, skin tone, eye color, face shape, and unique features across the batch
- Alternate between single-origin and mixed-heritage backgrounds
- Mix age range (don't make them all the same age)
- Vary expressions and lighting setups
- Each face should be immediately distinguishable from the others

## Example Prompts

**Prompt 1:**
Close-up studio headshot of a 25-year-old Irish woman with cool-toned fair skin and fine natural pore texture, deep-set hazel eyes, strong square jaw and a pronounced cupid's bow, auburn red hair slicked back into a neat low chignon. Bare shoulders, no clothing visible, no jewelry. Composed knowing expression, looking at the camera. Clean white background #fff, soft diffused studio lighting, fine natural skin texture and an even, unmarked complexion, beauty headshot

**Prompt 2:**
Close-up studio headshot of a 22-year-old Ethiopian woman with warm umber skin, large expressive round eyes, narrow bridge nose, defined cupid's bow, long neck, dark hair pulled into a smooth high ballerina bun. Bare shoulders, no clothing visible, no jewelry. Soft parted lips, steady gaze, looking at the camera. Clean white background #fff, even soft studio lighting, fine natural skin texture and an even, unmarked complexion, beauty headshot

**Prompt 3:**
Close-up studio headshot of a 27-year-old Mexican woman of Zapotec descent with warm caramel skin and fine natural pore texture, wide-set dark brown almond eyes with thick lashes, a strong straight nose, an oval face with high rounded cheekbones and a small rounded chin, a pronounced dimple on the left cheek only, glossy black hair swept back into a sleek twisted bun at the nape. Bare shoulders, no clothing visible, no jewelry. Poised neutral expression, looking at the camera. Clean white background #fff, soft ring light, fine natural skin texture and an even, unmarked complexion, beauty headshot

**Prompt 4:**
Close-up studio headshot of a 24-year-old Korean woman with pale milky skin and subtle natural sheen, small monolid eyes, round face, soft jawline and naturally arched eyebrows, straight black hair pulled back into a sleek tight ponytail. Bare shoulders, no clothing visible, no jewelry. Slight closed-mouth smile, looking at the camera. Clean white background #fff, flat diffused studio lighting, fine natural skin texture and an even, unmarked complexion, beauty headshot

**Prompt 5:**
Close-up studio headshot of a 31-year-old Norwegian man with cool-toned fair skin and light stubble, hooded blue-grey eyes with pale lashes, a prominent Roman nose with a defined bridge bump, an angular face with a strong square jaw, one eyebrow set slightly higher than the other, ash-blonde hair brushed back flat. Bare shoulders, no clothing visible, no jewelry. Calm direct gaze, looking at the camera. Clean white background #fff, soft butterfly lighting, fine natural skin texture and an even, unmarked complexion, beauty headshot