---
tier: hero
reliability: 3.6 # same render risk as the manual reel (3.7) − 0.1 until Wire Graph Phase 1 ships + E2E proven; raise to 4.0 once the graph engine is live and the showcase renders
status: forward-looking # requires Wire Graph Phase 1 (docs/superpowers/specs/2026-06-18-wire-graph-design.md). Renders after the engine ships.
---

# 端午 · 龙舟小波 — Dragon Boat reel via **Wire Graph** ⭐

> Paste this whole file (with the BRIEF filled in) into Claude cowork, chat, or Code with the Storyboard MCP attached. **Same reel as `dragon-boat-festival.md` — but you wire Bo's node into every shot once, instead of hand-passing his image into each step.** This is the VibePaper-style authoring path. Requires the Wire Graph feature (Phase 1).

## What you'll get

The **identical** ~60-second 9:16 cartoon reel as the manual playbook — chibi dragon spirit **小波 (Bo)** starring in the same 6-beat dragon-boat race — produced from **one Creation Graph**:

- **One `asset` node** = Bo's character sheet (the only identity input).
- **One `asset` node** = the style/palette reference.
- **Six `gen` nodes** = the 6 beats.
- **Wires**: Bo's node → all 6 beats (`role: character`); style node → all 6 beats (`role: style`); each beat's keyframe → its own animate node (`role: first_frame`).
- **One submit.** The engine resolves every wire and runs the beats in dependency order. Re-running one beat re-pulls only its wires — the other five are untouched.

**Why do it this way:** the character lock is **declared once on the graph**, not repeated per step. Add a second character later (a rival captain) and you wire one more node into the beats it appears in — multi-character consistency becomes "draw another line," exactly VibePaper's model. See `docs/wire-graph-vs-manual-comparison.md`.

**Time**: ~12–15 minutes wall clock. **Your attention**: ~3 minutes (one sheet approval + one cost gate). **Cost**: $2.00 – $4.00 (same model spend as the manual reel).

## Tell the agent about the reel

Same BRIEF as the manual playbook — the only difference is *how it's authored*, not *what it produces*:

```yaml
reel_title:          # e.g. "小波的龙舟赛 / Bo's Dragon Boat Race"
hero_name:           # 小波 (Bo)
hero_look:           # 1-2 sentences (see dragon-boat-festival.md for the canonical Bo description)
crew_look:           # the rowers, e.g. "four cheerful cartoon animal rowers in red headbands"
art_style:           # pixar-3d-cartoon | flat-2d-festival | watercolor-storybook | chibi-anime
hero_color:          # one hex, e.g. #E63946
language:            # zh | en | bilingual
video_tier:          # premium (seedance-i2v) | fast (seedance-i2v-fast)
launch_slug:         # e.g. bo-dragon-boat-wired
```

The 6 beats are the canonical arc from `dragon-boat-festival.md` (Dawn → Light the drum → Start → Falling behind → Climax → Victory).

## The graph the agent builds

After Bo's sheet and the style reference exist (Steps 1–2), the agent assembles **one Creation Graph** and submits it:

```jsonc
{
  "project_id": "<dragon boat project>",
  "nodes": [
    { "id": "bo",    "type": "asset", "kind": "image", "url": "<Bo character sheet>", "label": "小波 Bo" },
    { "id": "style", "type": "asset", "kind": "image", "url": "<style reference>",    "label": "festival look" },

    { "id": "kf1", "type": "gen", "action": "generate", "prompt": "Beat 1 — dawn mist, lanterns; Bo yawns awake on the dragon-head prow" },
    { "id": "kf2", "type": "gen", "action": "generate", "prompt": "Beat 2 — crew boards; Bo puffs a spark to light the drum" },
    { "id": "kf3", "type": "gen", "action": "generate", "prompt": "Beat 3 — gong; paddles bite, spray; Bo zips alongside cheering" },
    { "id": "kf4", "type": "gen", "action": "generate", "prompt": "Beat 4 — rival boat surges ahead; crew strains; Bo waves them on" },
    { "id": "kf5", "type": "gen", "action": "generate", "prompt": "Beat 5 — final stroke; Bo breathes a rainbow gust; boat lunges to the line" },
    { "id": "kf6", "type": "gen", "action": "generate", "prompt": "Beat 6 — zongzi tossed, fireworks; Bo beams on the prow" },

    { "id": "v1", "type": "gen", "action": "animate", "prompt": "slow dawn drift, Bo stretches" },
    { "id": "v2", "type": "gen", "action": "animate", "prompt": "spark lights the drum, crew grins" },
    { "id": "v3", "type": "gen", "action": "animate", "prompt": "paddles bite, water sprays, Bo zips past" },
    { "id": "v4", "type": "gen", "action": "animate", "prompt": "rival pulls ahead, Bo waves furiously" },
    { "id": "v5", "type": "gen", "action": "animate", "prompt": "rainbow gust, boat lunges across the finish" },
    { "id": "v6", "type": "gen", "action": "animate", "prompt": "fireworks bloom, Bo beams" }
  ],
  "edges": [
    // Bo locked into every keyframe (the character wire) + style into every keyframe
    { "from": "bo",    "to": "kf1", "role": "character" }, { "from": "style", "to": "kf1", "role": "style" },
    { "from": "bo",    "to": "kf2", "role": "character" }, { "from": "style", "to": "kf2", "role": "style" },
    { "from": "bo",    "to": "kf3", "role": "character" }, { "from": "style", "to": "kf3", "role": "style" },
    { "from": "bo",    "to": "kf4", "role": "character" }, { "from": "style", "to": "kf4", "role": "style" },
    { "from": "bo",    "to": "kf5", "role": "character" }, { "from": "style", "to": "kf5", "role": "style" },
    { "from": "bo",    "to": "kf6", "role": "character" }, { "from": "style", "to": "kf6", "role": "style" },
    // each keyframe is the first frame of its beat's video
    { "from": "kf1", "to": "v1", "role": "first_frame" },
    { "from": "kf2", "to": "v2", "role": "first_frame" },
    { "from": "kf3", "to": "v3", "role": "first_frame" },
    { "from": "kf4", "to": "v4", "role": "first_frame" },
    { "from": "kf5", "to": "v5", "role": "first_frame" },
    { "from": "kf6", "to": "v6", "role": "first_frame" }
  ]
}
```

The agent never writes this by hand in chat — it describes the wiring in natural language and lets the graph tools build it. The JSON above is what the engine receives.

## How the agent should run this (interaction contract)

1. **CONFIRM (one message, ≤1 question).** Same as the manual playbook: 1-line restate + video tier + music on/off. Mention this is the **wired** path (one graph, one submit).
2. **PREVIEW CHECKPOINT — Bo's sheet still gates everything.** The wire only carries identity if the identity is right. Approve Bo before wiring.
3. **SHOW THE WIRING (1 line, no JSON dump).** "Wiring Bo into all 6 beats (character) + the festival look into all 6 (style) + each keyframe into its beat's video (first frame). One submit runs the lot." Then the cost gate.
4. **RUN THE GRAPH (gated spend).** Submit with `confirm:false` first → show cost + step plan → on approval, submit `confirm:true`. The engine runs keyframes, then videos in dependency order.
5. **NARRATE per node.** Poll the graph; one line per transition ("keyframes 6/6 resolved with Bo wire · animating beats 3/6").
6. **RE-RUN IS SURGICAL.** If beat 4 drifts, re-run only node `kf4`/`v4` — its wires re-pull, the other five stay frozen. State this explicitly so the user knows a fix is cheap and isolated.
7. **DELIVER.** Same as the manual playbook: reel + share page + one honest line + ONE next step.

## Quality controls (auto-applied)

Same closed-loop controls as the manual playbook (cost-preview gate via `confirm:false`, `quality_anchor_url` = Bo's sheet, auto-retry on hero beats, critic verdict, scorecard) — but the anchor is now **structural**: the `character` wire IS the anchor, so the cross-asset critic checks Bo against the wired source automatically on every node.

## The steps

### Step 0 — Confirm and pick the look
Same palette suggestions as `dragon-boat-festival.md` Step 0.
**STOP**: "Brief and look right? (approve / style [name] / palette [4 hexes] / edit [field] [value])"

### Step 1 — Lock the hero: Bo's character sheet (~30s, ~$0.04)
Draw Bo's sheet from `hero_look` (stylization-strong model). This becomes the `bo` asset node.
**STOP**: "Here's <hero_name> — every beat will be wired to this. Approve, or refine? (approve / refine [direction])"

### Step 2 — Make the style reference (~20s, ~$0.02)
One reference plate establishing the festival palette + art style. This becomes the `style` asset node. (Optional: skip and let the palette ride in the prompt — but a style node makes the look stick harder across beats.)
**STOP**: "Style reference look right? (approve / refine [direction] / skip)"

### Step 3 — Wire + submit the graph (gated spend, ~6–8 min total, $0.90–$2.16 video + ~$0.06 keyframes)
The agent builds the Creation Graph (Bo → all 6 keyframes as `character`, style → all 6 as `style`, each keyframe → its video as `first_frame`), submits with `confirm:false` to preview cost, then on approval runs it. Keyframes resolve first (each with Bo's wire applied), then the 6 videos animate from their keyframes.

**STOP** (before the un-gated run): "Graph wired: Bo locked into all 6 beats, each beat animated from its keyframe. Total ~$X.XX, ~6–8 min. Run it? (run / fast-tier / music off / edit [beat#])"

### Step 4 — Music bed (optional, ~30s, ~$0.10)
Same festive instrumental as the manual playbook. Add it as one more node if you like, or mux in finishing.
**STOP**: "Music bed — approve, or different mood? (approve / try [bigger drums | gentler | faster])"

### Step 5 — Stitch + end-card (no gate, ~1 min, ~$0.02)
Stitch the 6 resolved video nodes in beat order, mux music, append the **"端午安康"** HTML/text end-card, export 1080×1920.

### Step 6 — Write the share page
Same 9:16 share page as the manual playbook. Saved to `public/launches/{launch_slug}-reel.html`.

### Final step — scorecard wrap-up
`get_scorecard({ project_id })` → print the report card. Note in the wrap-up that the reel was produced from a single graph submit (cite the node count + wire count).

## When you're done

```
✅ Dragon Boat reel (wired): public/launches/{launch_slug}-reel.html
✅ Bo character sheet (asset node): <URL>
✅ Creation Graph: <graph_id> — 14 nodes, 18 wires
✅ Reel MP4 (9:16): <URL>

Total spent: $X.XX
Total wall-clock: MM:SS

Re-run any single beat by re-running its node — its wires re-pull, the others stay frozen.
```

## What to do next

1. **Post it** — identical 9:16 deliverable to the manual reel.
2. **Add a second character** — wire a rival-captain `asset` node into beats 4–5 (`role: character`). One line, and the rival is consistent too. Multi-character is where this path pulls ahead of manual.
3. **Fork the graph** — change the style node, re-run; Bo stays locked, the whole reel re-skins.
4. **Read the comparison** — `docs/wire-graph-vs-manual-comparison.md` for when to use this path vs the manual one.

---

## Notes for the agent (only read if a step fails)

**This playbook requires Wire Graph Phase 1** (`submit_graph` / `get_graph` / `wire`, MCP + CLI). If those tools aren't available yet, fall back to `dragon-boat-festival.md` (manual reference-passing) — it produces the identical reel with today's primitives — and tell the user the wired path ships with Wire Graph.

**Wire resolution recap.** `role:"character"` → Bo's url as identity-preserving `source_url` + subject-preservation preamble. `role:"style"` → the style node as a style reference. `role:"first_frame"` → the keyframe as the i2v `source_url` (forces `action:"animate"`). A `gen` node runs only when all its wired inputs have a resolved url (assets are instant; `kfN → vN` waits for `kfN` to finish).

**Surgical re-run.** Re-running a node re-pulls only its current wires and marks downstream `stale`; never auto-re-run downstream — offer it.

**Same finishing-envelope notes** as `dragon-boat-festival.md` (ffmpeg-concat / ffmpeg-mux direct-SDK fallback, `audio_fill:"loop"`, poll cadence, Bearer handling).