Baz API for Agents

# Install the CLI
npm install -g bazaar.it

# Authenticate
baz auth login <your-api-key>

# Create a project
baz project create --name "Product Launch"

# Generate scenes with AI
baz prompt "Create a hero section with gradient background and bold headline"

# Check what was created, then export
baz scenes list
baz export start --wait

# baz CLI — Mandatory Video Generation Workflow

Use this skill when the user wants to create, edit, or export videos using the baz.studio CLI (`baz`).

**This is a GATED workflow.** You MUST complete each phase in order. Do NOT skip phases. Do NOT declare "done" until the completion checklist at the bottom passes.

---

## Two Ways To Make Scenes (read this first)

A baz project is a timeline of Remotion scenes stored on baz.studio. There are two supported ways to put scenes on that timeline. Both are first-class. Pick per user intent.

| Path | Command | Who writes the code | Baz balance |
|------|---------|---------------------|-------------|
| **A. AI composer** | `baz prompt "..."` | baz's own agent (server side) | **Paid** per agent call |
| **B. Hand-authored TSX** | `baz scenes create --file` / `baz scenes set-code --file` | **You** (Claude, Codex, or the human) | **Free**. No balance is spent. |

**Decision rule:**

- The user wants baz's AI to design and compose the video → Path A.
- The user says any of "use your own tokens", "don't spend my balance", "write the code yourself", "I have no credits", or they want exact deterministic control → Path B.
- Editing an existing scene where you can see the exact code change → always Path B (`set-code`).
- A workflow or skill that says "manual TSX only" → Path B for every scene in that project, never `baz prompt`.

**Never tell the user there is no way to use baz without spending balance.** Path B is that way. Scene creation, code replacement, preview frames, review, and validation do not draw on the account balance. See "What Costs Balance" below.

---

## What Costs Balance

Run `baz balance --pricing --json` for the live catalog. The stable split:

**Free (never touches the balance):**

- `baz project create`, `baz project use`, `baz project validate`
- `baz context add`, `baz context list`
- `baz scenes create --file`, `baz scenes set-code --file`, `baz scenes code`, `baz scenes list`, `baz scenes positions`, `baz scenes move`, `baz scenes reorder`, `baz scenes delete`
- `baz preview` (free, capped per day per account; the cap is generous for normal review loops)
- `baz review`, `baz status`, `baz state`, `baz verify`
- `baz template apply`
- `baz media upload`, `baz font upload`, `baz share create`

**Paid (billed to the baz balance, prices in the live catalog):**

- `baz prompt` — every agent call. `--budget <dollars>` caps one run; use it only when the user asks for a cap. A low cap is a stop condition and can leave a partial video.
- `baz export start` — rendering. `baz balance` shows whether the account exports `watermark-free` or `watermarked`.
- Voiceover/TTS, music, image generation, video generation, brand extraction, and other utilities the agent may call inside `baz prompt`.

**Claude/Codex tokens and baz balance are separate.** Your own model tokens pay for your reasoning and for any TSX you write. They never substitute for `baz prompt` billing, and `baz prompt` billing is never needed for Path B.

**Harness permission blocks.** Some agent harnesses classify every `baz` command as a financial action because the CLI is tied to a billing-linked account. Do not work around such a block. Tell the human exactly which command you need, whether it is free or paid, and that a Claude Code user can allow it with the permission rule `Bash(baz *)` in their settings. Then continue with local work (writing TSX, planning) while you wait.

---

## Getting Started (New Agents)

Install the published CLI first. Then register without opening the web app:

```bash
# 1. Discover what baz can do.
curl https://baz.studio/api/v1/capabilities

# 2. Install the CLI and create an account. The CLI stores the API key.
npm install -g bazaar.it@latest
baz auth register --email <account-email> --name "My Agent"

# 3. Switch to compact machine output and install public video skills.
export BAZ_AGENT=1
baz agent init --skills all-free --agent auto

# 4. Check live balance and pricing.
baz balance --pricing --json
```

**Shortcut:** If your human already has a baz.studio account, ask them for an API key and run `baz auth login <your-api-key>` instead of registering.

**Funding is only needed before the first paid operation.** New accounts start at $0. Path B (hand-authored TSX), preview, review, and validation all work at $0. When the user wants Path A or an export, run `baz balance topup 5` to get the minimum $5 Stripe checkout URL. A human must approve that payment. After checkout, run `baz balance --json` and retry the same command.

Already have an API key? Skip to Phase 1.

### One-line cold-agent requests

When the user gives only a request such as `make a launch video for X`, do not stop to ask for creative preferences that can be inferred safely.

1. Identify `X` from the user's text and any public URL they supplied.
2. Default to a 15-second landscape product launch video unless the request implies another format or duration.
3. State the assumptions in the run context. Infer a restrained brand system when no assets or brand rules are available.
4. Add one `goal`, one `requirement`, one `brand`, and one `instructions` context entry before generation.
5. Run the normal generate, preview, review, validate, repair, and export gates below.
6. Ask the user only when identity, rights, payment, or a destructive action needs human authority.

The one-line request reduces user input. It does not remove the quality gates.

---

## When to Use

- User asks to create, edit, or export videos via CLI
- User wants to automate video generation
- User mentions "baz", "baz.studio", "bazaar CLI", or "video generation from terminal"

## Report CLI Feedback

Submit one feedback item when baz behavior differs from its documented contract, an error gives no actionable recovery, or a required capability is missing:

```bash
baz feedback "Expected timing to remain unchanged, but the scene moved" \
  --kind unexpected-behavior \
  --command "baz scenes set-code <scene-id> --file ./scene.tsx"
```

Use `--kind bug`, `friction`, `unexpected-behavior`, `missing-capability`, `docs`, or `idea`. Do not include API keys, credentials, private file contents, or other secrets. The command sends the explicit message, feedback category, displayed command, CLI version, agent type, and active project ID to the baz.studio team. Do not submit expected validation failures or duplicate feedback.

## `baz prompt` modes

- **`baz prompt "..."`** — Path A scene creation, edits, full agent orchestration (paid)
- **`baz prompt "..." --spar`** — planning-only conversation, no timeline mutations (paid agent call, no scenes written)
- **`baz prompt "..." --max`** — more thorough generation (`--mode agent-max`)
- **`baz run status <run-id>`** / **`baz run cancel <run-id>`** — inspect or cancel a running generation (free)

---

## Phase 1: Context (REQUIRED — do NOT skip)

You MUST set project context BEFORE generating any scenes. On Path A it is what the composition agent reads. On Path B it is your own brief and it is what `baz review` compares the timeline against.

### Minimum context required:
1. **Goal** — What is this video for? Who is the audience? What should they feel/do?
2. **Requirements** — Specific, verifiable things the video must contain
3. **Brand** — Colors, fonts, logo placement, visual style
4. **Director's treatment** — The non-generic creative idea: core metaphor, point of view, pacing shape, visual grammar, and anti-patterns

**Shippable quality warning:** "World-class", "premium", "Bloomberg-grade", "cinematic", "editorial", and "not generic" are aspirations, not direction. Do not rely on those words as the prompt. Convert them into a concrete treatment first:

- **Core metaphor:** receipt, dossier, pressure gauge, courtroom exhibit, operating-room monitor, teardown, map, timeline, market microstructure, etc.
- **Point of view:** the one sentence the video argues, not just the topic it covers.
- **Visual grammar:** what kinds of frames repeat, how data is represented, what is deliberately avoided.
- **Pacing shape:** where tension rises, where proof lands, where the ending resolves.
- **Anti-patterns:** generic KPI cards, interchangeable stock chart panels, decorative data, one-track slideshow pacing, vague finance filler.

**Parallel sessions:** If multiple agents share the same machine, do NOT use `baz project use` — it writes to a shared config file and agents will stomp each other. Instead, set the env var for your session:
```bash
export BAZ_PROJECT_ID=<id>   # Session-scoped, no file contention
```

```bash
# Create or select project (--format landscape | portrait | square)
baz project create --name "Descriptive Name - Date/Purpose" --format landscape --json
# OR (single-agent only — see parallel sessions note above)
baz project use <id>

# Set goal (be specific — audience, purpose, desired outcome)
baz context add "Create 45-60 second feature announcement for [Product]. \
Audience: [who]. Key value: [what they get]." --label "goal"

# Add requirements (each one should be independently verifiable)
baz context add "Show [specific feature interaction]" --label "requirement"
baz context add "Include CTA: '[specific text]'" --label "requirement"
baz context add "Total duration: [range]" --label "requirement"

# Set brand guidelines
baz context add "Brand: [Name]. Primary [hex], accent [hex]. Font: [name]. \
[Logo placement]. [Visual style notes]." --label "brand"

baz context add "DIRECTOR TREATMENT: [specific visual thesis]. \
Core metaphor: [not a style adjective]. Point of view: [argument]. \
Visual grammar: [repeatable frame system]. Pacing: [tension/proof/resolution]. \
Avoid: generic KPI cards, interchangeable chart panels, decorative data." --label "instructions"

# Attach reference files when the user supplies them (PDF, image, video)
baz context add --file ./brief.pdf --label "reference"
```

### Verify context is set:
```bash
baz context list --json
```

**Gate:** Do NOT proceed to Phase 2 until `baz context list` shows at least one goal, one requirement, one brand entry, and one director-treatment/instructions entry.

---

## Phase 2: Generate

Choose Path A or Path B per the decision rule at the top. Do not mix them inside one scene: a hand-authored scene is repaired with `set-code`, never with `baz prompt "fix ..."`.

### Path A: `baz prompt` (paid, AI composes)

```bash
# Option A1: One comprehensive prompt
baz prompt "Create a video with: [scene 1 description], [scene 2], ..." --stream-json

# Option A2: Scene-by-scene (more control)
baz prompt "Scene 1 (5s): Dark gradient intro, logo top-left, title slides up" --stream-json
baz prompt "Scene 2 (7s): Problem statement with mock UI..." --stream-json
baz prompt "Scene 3 (18s): Feature walkthrough..." --stream-json
```

Tips:
- Include duration in each prompt
- Be specific about animations, colors, layout
- Reference brand context set in Phase 1
- `--image ./mock.png` and `--url https://...` attach references; `--save-context` persists them

#### Choreography (REQUIRED for 3+ scene videos)

For videos with 3 or more scenes, plan choreography BEFORE generating. This prevents the "lockstep slideshow" pattern where all layers swap at the same frame boundary. The same plan applies to Path B: it is the track and lifetime map you author against.

##### Actor Planning Template

Before prompting, plan your actors:

| Actor | Track | Lifetime | Role |
|-------|-------|----------|------|
| Background | 0 | Full duration | Evolving gradient, particles |
| Hero | 1 | 60-80% | Main UI, enters, demotes to corner, returns |
| Supporting | 1-2 | 20-40% | Cards/charts, appear during hero demotion |
| Text | 2+ | 10-30% | Headlines, arrive at beat points, explicit exits |

##### 5 Prompt Enrichment Rules

1. **Every content prompt includes exit instructions** (exempt: persistent backgrounds, final CTA)
2. **Prefer ONE background** on Track 0 for the full video duration
3. **Every overlay prompt includes position and size** — scenes that share screen time must not share screen space
4. **Specify spring animation** for hero elements (`spring() for hero entrance`)
5. **Include energy level hints** in prompts ("high energy entrance", "calm sustained section")

##### Landscape Occupancy Rule (REQUIRED for 16:9)

If the project is landscape, do not let the scene collapse into a small claim floating in a giant matte.

- Main proof beats should usually use roughly `60-80%` of the frame width, or resolve as a deliberate two-zone composition
- Prefer wide proof rails, claim-left / proof-right layouts, split fields, and full-width chart bands
- Tiny centered headlines, short decorative lines, or small chart islands are only acceptable as very brief punctuation beats
- If a landscape frame feels empty, fix scale and composition first before adding more text

##### GOOD Example — context injection + one natural prompt:
```bash
baz context add "CHOREOGRAPHY: Every overlay scene must specify its position and size. \
  Use spring() for hero elements. Every non-final scene must have exit animations. \
  Prefer one continuous background. In landscape, main proof beats should occupy roughly 60-80% of width or resolve as a wide split-field layout — avoid tiny centered claim clusters." --label "instructions"

baz prompt "Create a 15-second product demo: dark theme intro with logo, \
  feature showcase with 3 cards, area chart showing growth, and a CTA. \
  Brand: #6366f1 purple, #10b981 green, Inter font." --stream-json
```

ONE natural prompt. The composition agent handles decomposition into tracks + spatial layout internally based on choreography context.

### Path B: Hand-authored TSX (free, you write the code)

You author each scene as a Remotion component in a local `.tsx` file and push it. baz compiles it server side, stores it, and reports any compilation error back on the command output and in `baz project validate`. No AI call happens and no balance is spent.

```bash
# 1. Write ./scenes/01-background.tsx (contract below)

# 2. Create the scene. --duration is frames at the project fps (30 fps default).
baz scenes create --name "Background" --file ./scenes/01-background.tsx --duration 450 --track 0 --json

# 3. Overlays go on higher tracks with an explicit start frame
baz scenes create --name "Hero card" --file ./scenes/02-hero.tsx --duration 240 --track 1 --start 60 --json

# 4. Repair or revise an existing scene
baz scenes code <scene-id> --output ./scenes/02-hero.tsx
#    ...edit the file deterministically...
baz scenes set-code <scene-id> --file ./scenes/02-hero.tsx --overwrite-duration --json
```

**Track-0 order is creation order.** For track 0 the renderer derives start frames from scene `order` via cumulative durations, so `--start` is metadata there. Create track-0 scenes in playback order, or fix with `baz scenes reorder --ids <id1>,<id2>,...`. `--start` is respected on tracks above 0.

#### Scene code contract

Every scene is one self-contained component. This is the shape the preview player, the export renderer, and the server compiler expect:

```tsx
const { AbsoluteFill, Sequence, spring, interpolate, interpolateColors, useCurrentFrame, useVideoConfig, Img, Video, Easing } = window.Remotion;

const totalFrames_k3f9a2m1 = 450;
export const durationInFrames_k3f9a2m1 = totalFrames_k3f9a2m1;

export default function Scene_k3f9a2m1() {
  const frame = useCurrentFrame();
  const { fps, width, height } = useVideoConfig();
  const enter = spring({ frame, fps, config: { damping: 200 } });
  const opacity = interpolate(frame, [0, 20], [0, 1], { extrapolateLeft: 'clamp', extrapolateRight: 'clamp' });
  return (
    <AbsoluteFill style={{ backgroundColor: '#0B0B0F', fontFamily: 'Inter, sans-serif' }}>
      <div style={{ opacity, transform: `translateY(${(1 - enter) * 24}px)` }}>...</div>
    </AbsoluteFill>
  );
}
```

Rules the compiler and renderer enforce or that break exports when ignored:

- **No `import`, `require`, or dynamic import.** Everything comes from globals. `React` is a bare global (`React.useState`, `React.useMemo`), not `window.React`.
- **Destructure from `window.Remotion`** at the top. Available: `AbsoluteFill, useCurrentFrame, useVideoConfig, interpolate, interpolateColors, spring, Easing, Sequence, Series, Loop, Freeze, Img, Audio, Video, OffthreadVideo, staticFile, random`. Nothing else from Remotion is exposed.
- **Export a default component and `durationInFrames_<suffix>`.** Use one unique 8-character suffix per scene on `Scene_`, `totalFrames_`, and `durationInFrames_` so identifiers never collide across scenes.
- **Pass `--duration` equal to your `durationInFrames`** on create, or `--overwrite-duration` on set-code, so the timeline length matches the code.
- **Icons:** `<window.IconifyIcon icon="mdi:star-four-points" style={{ fontSize: '24px' }} />`. Never emoji as visual elements, never `@iconify/react`.
- **Avatars:** `<img src={window.BazaarAvatars['asian-woman']} />`.
- **Motion helpers:** `window.BazaarMotion.reveal`, `.cascade`, `.springPresets` for staged reveals.
- **Fonts:** Google families (Inter, Montserrat, Nunito, ...) or fonts uploaded with `baz font upload`. Never `new FontFace(...)` or `@font-face` for remote URLs; the export strips unresolved families.
- **Media URLs:** copy asset URLs from `baz media list --json` character for character. A retyped or invented URL renders nothing and breaks the export.
- **Clamp every `interpolate`** with `extrapolateLeft: 'clamp', extrapolateRight: 'clamp'`. Use literal frame numbers inside `interpolate`, not the duration variable.
- **Frame 0 is the thumbnail.** Key elements must be at least partially visible on frame 0, never a blank screen.
- Apply the same choreography, occupancy, and quality rules as Path A. Hand-authored does not mean static.

---

## Phase 3: Preview, Review & Validate (REQUIRED — NEVER skip)

After generation, you MUST visually inspect the output and run structural validation. This is not optional, and none of it spends balance.

### Step 1: Preview
```bash
baz preview --frames 0,150,300 --output ./frames --json
```

`--output <dir>` downloads each frame to `<dir>/frame-<N>.png` and adds a `path` to every entry in `frames`. Read the PNGs from those paths. Without `--output` you get S3 URLs only.

Use preview for visual and semantic checks:
- Is the logo actually visible?
- Is the CTA on screen?
- Does the style feel on-brand?
- Are screenshots being used as reference/recreated UI or charts instead of raw webpage collage?
- Are self-claims attributed with small source labels/footers rather than ugly headline copy like "Ramp says..."?
- What is the specific visual thesis only this video has?
- Could these scenes be reused for any other topic with only text swaps? If yes, fail it.
- Are charts and diagrams semantically tied to the story, or just decorative finance motion?
- Does the reel feel directed, with a shape and point of view, or like a one-prompt AI slideshow?

**Do not accept generic AI slop.** A video can pass validation and still be a 4/10. If the preview reads as generic KPI cards, stock editorial styling, or interchangeable finance graphics, mark it unshippable and return to Phase 1/2 with a stronger treatment. Do not declare done.

**Do not accept static infographics.** A still dashboard frame with one glowing line, one receipt/card, and small labels is not a motion-graphics video. Audio timing, word anchors, and a compiled export do not make it shippable. If most preview frames show the same layout with only tiny changes, fail the video as 0-3/10. Require visible choreography: changing composition, object transformations, depth, camera/scale moves, foreground/background interaction, kinetic evidence reveals, and meaningful motion throughout the run.

### Step 2: Review
```bash
baz review --summary --json
```

Read the project summary. Compare scenes, timing, and context against what Phase 1 asked for.

### Step 3: Validate
```bash
baz project validate --json
```

This is the authoritative machine check for compilation errors, invalid durations, overlaps, and other structural issues. On Path B, a compilation error here means your TSX broke the contract above; fix the file and `set-code` again.

### Optional: Deterministic Verify
```bash
baz verify --criteria "duration <= 60s,scenes >= 5,portrait" --json
```

`baz verify` is only for deterministic checks like duration, scene count, and format. Do NOT use it for visual/content/style questions.

**Gate:** If preview/review reveal problems, or `baz project validate` returns errors, or deterministic `baz verify` fails, you MUST proceed to Phase 4. Do NOT export. Do NOT declare done.

---

## Phase 4: Iterate (REQUIRED if Phase 3 fails)

Fix the issues. Then re-preview, re-review, and re-validate.

```
LOOP:
  1. Read the visual/content/structural issues from Phase 3
  2. Fix:
       - exact code change you can see → baz scenes code + edit + baz scenes set-code  (free)
       - creative redesign on a Path A project → baz prompt "Fix: [specific issue]" --stream-json  (paid)
       - Path B project → always set-code, never baz prompt
  3. Re-run: baz preview --frames 0,150,300 --json
  4. Re-run: baz review --summary --json
  5. Re-run: baz project validate --json
  6. Optional: baz verify --criteria "duration <= 60s,scenes >= 5,portrait" --json
  7. If issues remain → GOTO 1
  8. If clean enough → proceed to Phase 5
```

Do NOT exit this loop until the video looks right and structural validation passes.

### Deterministic Edits (skip the AI, save balance)

When you know exactly what code change to make — fixing a color, adjusting timing, replacing text, swapping an emoji for an SVG — use `set-code` instead of `baz prompt`. This bypasses the AI agent entirely: you write the code, CLI pushes it to the server. No balance spent, no prompt randomness.

```bash
# 1. Read current scene code
baz scenes code <scene-id> --output /tmp/scene.tsx

# 2. Edit the file locally (your edits, deterministic)

# 3. Push it back
baz scenes set-code <scene-id> --file /tmp/scene.tsx
```

**When to use `set-code` vs `baz prompt`:**
- `set-code` — You can see the exact code change needed (wrong color, broken animation, timing fix, text update)
- `baz prompt` — You need baz's AI to design something new or make a creative decision, and the user accepts the cost

Timeline moves are also deterministic and free:

```bash
baz scenes positions --updates-json '[{"sceneId":"<uuid>","start":17,"duration":8}]' --units seconds --fps 30
baz scenes positions --updates-json '[...]' --units seconds --fps 30 --apply
```

After a batch of edits, run `baz review --json` to sanity-check the composition before asking the user.

---

## Phase 5: Export (only if requested)

Only export if the user explicitly asked for a rendered video AND Phase 3/4 passed. Export is a paid operation.

```bash
baz export start --wait --format mp4 --quality high --json
# Non-blocking alternative
baz export start --json
baz export status <render-id> --json
```

Give the user the output URL from the export result. `baz share create --json` produces a share page link for the project.

---

## Command Reference

| Command | Purpose | Balance |
|---------|---------|---------|
| `baz auth register --email <e> --name <n>` / `baz auth login <key>` | Create or attach an account | free |
| `baz agent init --skills all-free --agent auto` | Install public video skills for this runtime | free |
| `baz balance --pricing --json` | Live balance and pricing catalog | free |
| `baz balance topup <dollars>` | Stripe checkout URL (min $5); a human pays | free to call |
| `baz project create --name <n> --format <landscape\|portrait\|square> --json` | Create project | free |
| `baz project use <id>` / `BAZ_PROJECT_ID=<id>` | Select project | free |
| `baz context add "<text>" --label <goal\|requirement\|brand\|instructions\|reference>` | Add context | free |
| `baz context add --file <path> --label reference` | Attach a PDF, image, or video as context | free |
| `baz context list --json` | Verify context | free |
| `baz prompt "<text>" --stream-json` | AI composes or edits scenes | **paid** |
| `baz prompt "<text>" --spar` | Planning only, no timeline changes | **paid** |
| `baz run status <run-id>` / `baz run cancel <run-id>` | Inspect or cancel a generation run | free |
| `baz scenes create --name <n> --file <f> --duration <frames> [--track N] [--start F]` | Add a hand-authored scene | free |
| `baz scenes set-code <id> --file <f> [--overwrite-duration]` | Replace scene code | free |
| `baz scenes code <id> --output <f>` / `--all` | Read scene TSX | free |
| `baz scenes list --json` | List scenes with ids, tracks, timing | free |
| `baz scenes positions --updates-json '...' [--apply]` | Preview or apply timeline moves | free |
| `baz scenes move` / `reorder --ids` / `delete` / `history` / `undo` | Timeline and history ops | free |
| `baz preview --frames 0,150,300 --output ./frames --json` | Render spot-check frames to `./frames/frame-<N>.png` | free, daily cap |
| `baz review --summary --json` | Project state for evaluation | free |
| `baz project validate --json` | Structural and compile validation | free |
| `baz verify --criteria "..." --json` | Deterministic checks only | free |
| `baz template list` / `baz template apply <id>` | Reuse catalog scenes | free |
| `baz media upload <file>` / `baz media list --json` | Project assets and their exact URLs | free |
| `baz font upload <file>` | Brand font for preview and export | free |
| `baz model list` / `baz model set` | Inspect or change which models `baz prompt` uses | free to call |
| `baz export start --wait --json` | Render final video | **paid** |
| `baz share create --json` | Public share link | free |
| `baz feedback "<msg>" --kind <k>` | Report CLI friction to the team | free |

Global flags: `--json`, `--compact`, `--project-id <id>`, `--api-url <url>`. `BAZ_AGENT=1` gives compact machine output and semantic non-zero exit codes. With `--json`, errors arrive as a JSON envelope with `code`, `category`, `message`, `retryable`, `exitCode`, and when available `suggestion` and `retryAfter` (seconds).

## Error Handling

| Category | Action |
|----------|--------|
| `transient` | Retry with backoff (wait `retryAfter` seconds) |
| `validation` | Fix input, do not retry same request |
| `auth` | Check API key with `baz auth status` |
| `fatal` | Stop and report to user |

Insufficient balance on a paid command is not a reason to abandon the task. Switch to Path B for scene work, tell the user what the paid step would cost, and let them decide on funding.

---

## Completion Checklist

You are NOT done until ALL of these are true:

- [ ] Phase 1: `baz context list` shows goal + requirements + brand + director treatment/instructions
- [ ] Phase 2: Scenes exist on the timeline, via `baz prompt` (Path A) or `baz scenes create --file` (Path B), matching what the user asked for and what they agreed to spend
- [ ] Phase 3: `baz preview --frames ...`, `baz review --summary --json`, and `baz project validate --json` run
- [ ] Phase 4: No blocking structural errors remain; optional deterministic `baz verify` passes if used
- [ ] Phase 5: Export started (only if user requested it)
- [ ] Visual quality: no raw screenshot filler, no random color palette, no attribution legalese in hero/body copy

**If you skipped preview/review/validate, you are not done. Go back and run them.**

---

## External Endpoints

| URL | Method | Data Sent | Purpose |
|-----|--------|-----------|---------|
| `baz.studio/api/v1/capabilities` | GET | None | Discover available tools |
| `baz.studio/api/v1/register` | POST | email, name | Create agent account |
| `baz.studio/api/v1/pricing` | GET | None | View operation costs |
| `baz.studio/api/v1/estimate` | POST | operation keys + quantities | Pre-execution cost estimate |
| `baz.studio/api/v1/top-up` | POST | amount in cents | Get Stripe checkout URL |
| `baz.studio/api/generate-stream` | POST | prompt, projectId | Generate video scenes (SSE) |
| `baz.studio/api/trpc/*` | POST | varies | Project CRUD, scene management |

## Security & Privacy

- **Authentication**: All non-discovery endpoints require `x-api-key` header
- **Data sent**: Your prompts, project metadata, and scene code are sent to baz.studio servers for storage, compilation, and (on Path A) AI processing
- **Data stored**: Projects, scenes, and generated assets are stored on baz.studio infrastructure (Neon DB + Cloudflare R2)
- **No local file access**: This skill only uses the `baz` CLI binary — it does not read or modify local files beyond CLI config at `~/.bazaar/config.json` and the TSX files you author
- **Balance**: Only `baz prompt`, `baz export`, and the media or audio generators it invokes consume dollar balance. Scene writes, previews, review, and validation are free. Check `baz balance --pricing` for the live catalog before large paid jobs
- **Exports**: Rendered videos are stored on the baz.studio CDN and accessible via URL

## Web UI Access

Your human can also edit the project directly in the browser at:
`https://baz.studio/projects/<project-id>/generate`

After creating a project, share this link so they can preview scenes, tweak code, or make manual edits alongside your CLI workflow.