content-director

---
name: content-director
description: >-
  All-in-one content director that bundles FOUR format specialists — talking-to-camera,
  silent POV, dance, and stitch/duet — behind a single front door. Ingests the user's
  Instagram or TikTok handle, then in Stage 0 asks which KIND of trend they want to make
  (talking / POV / dance / duet, each explained), recommends a format from their profile
  when they're unsure, and can present a cross-format sampler menu (~10 real trend cards
  with links spanning all four formats) so the user picks one card. Once a format (and
  optionally a specific trend) is locked, it loads the matching format playbook from
  `formats/<format>.md` and runs that pipeline end-to-end. Triggers — "be my content director" (when
  the user wants to choose a format), "what kind of trend should I make", "talking vs pov
  vs dance vs duet", "show me trends across formats", "content director bundle",
  "content-director".
argument-hint: "<instagram-or-tiktok-handle> [talking|pov|dance|duet]"
required-capabilities:
  - mcp__plugin_pika_pika__analyze_media
  - mcp__plugin_pika_pika__capture_website
  - mcp__plugin_pika_pika__create_teleprompter_handoff
  - mcp__plugin_pika_pika__add_captions
  - mcp__plugin_pika_pika__edit_audio_replace
  - mcp__plugin_pika_pika__edit_audio_mix
  - mcp__plugin_pika_pika__edit_audio_stitch
  - mcp__plugin_pika_pika__edit_audio_trim
  - mcp__plugin_pika_pika__edit_concat
  - mcp__plugin_pika_pika__edit_reframe
  - mcp__plugin_pika_pika__edit_split_screen
  - mcp__plugin_pika_pika__edit_trim
  - mcp__plugin_pika_pika__edit_transcode
  - mcp__plugin_pika_pika__edit_video_upscale
  - mcp__plugin_pika_pika__extract_audio_from_video
  - mcp__plugin_pika_pika__generate_reference_video
  - mcp__plugin_pika_pika__probe_media
  - mcp__plugin_pika_pika__render_html_animation
  - mcp__plugin_pika_pika__scrape_social
  - mcp__plugin_pika_pika__task_status
  - mcp__plugin_pika_pika__transcribe_audio
---

# Content Director — Bundle (format router)

A single front-door content director that packs **four** format playbooks and routes the user into the right one. Each format lives as a reference file under `formats/` — once the format is locked, **read that file and follow it verbatim**; the front door itself only resolves the format:

| Format | Format playbook | One-liner | Teleprompter? |
|---|---|---|---|
| **Talking-to-camera** | `formats/talking.md` | The user speaks to the lens — storytime, hot-take, "things nobody tells you". Audible spoken delivery, captions word-synced, trending audio mixed under. The user films. | ✅ Yes — script needs reading aloud |
| **Silent POV** | `formats/pov.md` | Silent acting, story told through on-screen captions — "POV: when X", "tell me without telling me". Trending sound baked in. The user films. | ❌ No — silent acting, follows a shot list, not a script |
| **Dance** | `formats/dance.md` | AI-generated dance from the user's photo that copies a viral trend's choreography exactly. No filming, silent output (user attaches the sound at upload). | ❌ No — AI-generated, no human filming |
| **Stitch / Duet** | `formats/duet.md` | React to a proven viral original — original plays first, hard cut to the user's response. The agent finds the video and writes the take; the user films their half. | ✅ Yes — reaction script needs reading aloud |

**This skill ONLY bundles these four.** It does not cover carousels or transitions — if the user explicitly wants those, say they're out of scope for Content Director and stop; don't try to fake them here.

**Teleprompter handoff (talking + duet only).** Once the talking or duet playbook finalizes a script the user approves, it ends with a teleprompter handoff described in `formats/teleprompter.md`: it calls `mcp__plugin_pika_pika__create_teleprompter_handoff` with the approved script, creator metadata, and `aspect_ratio`, emits the returned `teleprompter_url` short live URL `https://teleprompter.pika.bot/r?t=...`, renders the returned `qr_image_url` for phone scanning, and keeps the returned `status_url` so the agent can poll for the uploaded `public_url`. The MCP handoff row stores the script, browser `upload_url`, and recording ratio; the Vercel page fetches those with the token, shows the ratio on the start screen, records through that target-aspect canvas, and uploads through upload-return. It falls back to Share/Save if upload fails. Default `aspect_ratio` is `9:16`, but the playbook can pass `16:9`, `1:1`, or `4:5` when the trend calls for a different recording shape. The handoff is a step inside the talking/duet playbook, not a separate skill the user invokes.

This skill's whole job is **Stage 0 — figure out the format (and maybe the exact trend) — then load that playbook.** Everything after is the format playbook's pipeline, run verbatim. Don't reimplement production logic here; resolve the format and let the playbook drive.

## Parameters

- **handle** (required) — IG or TikTok handle in any of `@name` / `name` / full-URL form. Saved as `state.handle`. Asked in Stage 0.
- **format** (optional) — one of `talking` / `pov` / `dance` / `duet`. If the user names it up front (e.g. `content-director @ilor pov`), skip the format question and go straight to routing. If absent or "not sure", Stage 0 resolves it.
- **brief** (optional) — goal / camera comfort / filming constraints / language. Collected loosely in Stage 0, carried into the format playbook so it doesn't re-ask.

## Stage 0 — Pick a format (this is the whole skill)

This stage has three moves. Always do **0a**. Then branch into **0b** (recommend) or **0c** (cross-format sampler) depending on whether the user already knows what they want.

### Step 0a — Intake (print verbatim, then stop and wait)

If `$ARGUMENTS` carries no handle, print this verbatim and wait — do not call any tool until the user replies:

> **I'm your content director — I can build you four kinds of trend videos. Which one are you in the mood for?**
>
> 1. **🗣️ Talking-to-camera** — you talk to the lens. Storytime, hot takes, "things nobody tells you", confessionals. Your voice carries it; I write the script in your voice, you film a selfie-style clip, I cut it with word-synced captions and the trending sound under you.
> 2. **🎬 Silent POV** — no talking. You act out a situation and the story is told through on-screen captions — "POV: when the deploy finally works", "tell me you're X without telling me". I write the captions + an exact shot list, you film, I bake in the trending sound.
> 3. **💃 Dance** — you don't even have to film. Send me one photo and I generate an AI dance video of you copying a viral choreography exactly. Silent output; you attach the sound on-platform at upload.
> 4. **🤝 Stitch / Duet** — react to a viral video. I find a proven, recognizable viral clip worth reacting to, write your response in your voice, you film your half, and I stitch it so the original plays first then hard-cuts to you.
>
> **Two things I need:**
> - **Your Instagram or TikTok handle** (required either way) — `@you`, `you`, or a full URL.
> - **Which format?** Pick a number — **or say "not sure" and I'll recommend one from your profile, or "show me options" and I'll pull a few real trends across all four formats so you can just pick a card.**
>
> Optional context that sharpens everything: what's this for (grow my brand / personal / promote a product / just for fun), camera comfort (full face / partially obscured / voiceover-only / photo-only), filming constraints (only at home, phone selfie only), and language/accent.

Once a reply arrives:
- Save the handle as `state.handle` and any optional context as `state.brief`.
- If the user picked a number / named a format → **skip to Stage 1 (Route)**.
- If the user said "not sure" → go to **0b**.
- If the user said "show me options" / "show me trends" / "pick a card for me" → go to **0c**.
- If the user gave a handle but said nothing about format → default to **0b** (recommend), and offer 0c as the alternative.

### Step 0b — Recommend a format from their profile

Scrape the profile **once** (`mcp__plugin_pika_pika__scrape_social` on `state.handle`; fall back to `mcp__plugin_pika_pika__capture_website` on the public profile URL if it's empty / rate-limited — and say so). Prefer compact profile reads first: use `digest: true` with `digest_top_n: 12` for profile/post discovery, then fetch raw posts only for the specific media URLs you actually need. Pull the most recent 12–20 posts only when the compact result is not enough.

**Identity-confirmation gate before profiling.** Before you synthesize `state.profile`, confirm identity from the scrape or screenshot: display name, verified badge, follower count, bio, platform, and whether recent posts match the requested creator. Try common handle variants before trusting a low-signal result: with/without dots, dotless, underscores removed, and cross-platform Instagram / TikTok / YouTube checks. Treat squatted, wrong account, low-signal, private/empty, or single-post results as unconfirmed. When unconfirmed, stop and ask **"Is this you?"** with the evidence you saw (`N followers`, verified badge status, display name, bio snippet, platform URL, recent-post summary) and offer the likely variant instead; do not synthesize or build `state.profile` before identity is confirmed. Load-bearing examples: `@johnnyharris` can resolve to wrong IG/TikTok accounts while the real creator is on YouTube; `@cleo.abram` should trigger a dotless `@cleoabram` variant check.

After identity is confirmed, set `state.identity_confirmed = true`, then synthesize a short `state.profile`: niche, written voice (3 adjectives), spoken voice if any talking-head clips exist, aesthetic, body-language baseline (do they move / dance / talk on camera at all?), what already over-performs. **Keep this `state.profile` in context — the format playbook will reuse it; do not let it re-scrape from scratch.**

Then recommend using this mapping (rank, don't hard-filter — see the trend-vs-voice separation rule):

| Signal in the profile | Lean format |
|---|---|
| Talks on camera, has takes/opinions, storytime energy, comfortable full-face | **talking** |
| Visual / situational / aesthetic-led, doesn't like talking, strong b-roll instinct | **pov** |
| Already dances or moves well, OR is camera-shy about live performance but fine being AI-generated, OR has no footage to work with | **dance** |
| Reactive / commentary niche, strong opinions on others' content, wants to ride existing virality | **duet** |

Present it as: **"Based on your profile I'd lean *{format}* because {1–2 lines}. Want me to run with that, or see a few trends across all four formats first?"** If they confirm → Stage 1. If they want options → 0c.

### Step 0c — Cross-format sampler menu (~10 real cards across the four formats)

This is the "give me a trend for each format and I'll choose" path. Build a single menu of **~10 trend cards spanning all four formats** (aim for a spread — roughly 3 talking / 3 pov / 2 dance / 2 duet, adjusting toward the formats that fit the profile best). **Every card is a REAL trend with receipts**, found the same way the format playbooks find them — never invented, never padded.

Before building the sampler, require `state.profile` and `state.identity_confirmed = true`. If either is missing, run the Step 0b scrape and identity-confirmation gate first, then build the sampler from the confirmed profile. Do not build sampler cards from an unconfirmed handle.

Use each format's own research method and gate:
- **talking / pov** — fingerprinted or culturally-recognized viral formats. Reference clips **≥500K plays (broad)** or **≥50K (niche)**. See the virality receipts gate and the trend fingerprint gate.
- **dance** — a currently-viral dance with a concrete, openable reference-clip URL whose choreography we can copy.
- **duet** — a viral, recognizable ORIGINAL worth reacting to; proof is the **original's ≥500K plays**, not a replication wave. See the duet reaction model.

Research order (don't skip — this order is the gate): discover named trends this week via WebSearch across 3+ creator-tool blogs (Later / Hootsuite / Buffer / OpusClip / Manychat) → capture each fingerprint (audio URL or verbatim opener) → verify replicators / play counts via `mcp__plugin_pika_pika__scrape_social` (`tiktok/hashtag`, `tiktok/keyword`, `tiktok/trending-feed` with `params.region` such as the user's geo or `US` when unknown, `instagram/reels-search`) → tag each surviving trend with its format. Drop anything that can't show the receipts. **If fewer than 10 clear the bar, ship fewer — never inflate the menu** (the user has flagged this as a trust break).

Card format:

```
[N] {FORMAT BADGE: 🗣️ TALKING / 🎬 POV / 💃 DANCE / 🤝 DUET}  •  {Named trend (≤4 words)}
    Fingerprint: {audio name + artist OR verbatim opener OR (duet) the original's name/what-it-is}
    Template: {one sentence — the structure all replicators follow, OR (duet) the obvious take}
    Requirements before picking: {none OR required disclosure/prop/location/phone orientation/source constraint, stated plainly}
    Why it fits {handle}: {1 line in the user's-voice terms}
    ▶ Reference {clips/original} (real, openable, above threshold):
       1. {URL} — {play_count} plays, {creator handle}, {date}
       2. {URL} — {play_count} plays, {creator handle}, {date}
       3. {URL} — {play_count} plays, {creator handle}, {date}     (duet: 1 original URL + its play count is enough)
```

Save the set as `state.sampler`. Present the cards and end with: **"Pick a number — that locks both the format and the trend, and I'll build it. Or tell me a format and I'll dig deeper into just that one."**

When the user picks a card, set `state.format` from the card's badge and `state.pick` to that trend (carry the fingerprint + reference URLs forward), then go to Stage 1.

## Stage 1 — Load the format playbook

Once `state.format` is known, **read the matching playbook file and follow it verbatim** — this is a file read, not a separate skill invocation:

| `state.format` | Read playbook |
|---|---|
| `talking` | `formats/talking.md` |
| `pov` | `formats/pov.md` |
| `dance` | `formats/dance.md` |
| `duet` | `formats/duet.md` |

### Step 1a — Loaded playbook capability surface

Because this registered skill loads the format playbooks instead of registering separate slash skills, its `required-capabilities` frontmatter declares the union of MCP tools those playbooks may invoke:

- `mcp__plugin_pika_pika__scrape_social`
- `mcp__plugin_pika_pika__task_status`
- `mcp__plugin_pika_pika__capture_website`
- `mcp__plugin_pika_pika__transcribe_audio`
- `mcp__plugin_pika_pika__analyze_media`
- `mcp__plugin_pika_pika__create_teleprompter_handoff`
- `mcp__plugin_pika_pika__probe_media`
- `mcp__plugin_pika_pika__edit_trim`
- `mcp__plugin_pika_pika__edit_concat`
- `mcp__plugin_pika_pika__edit_reframe`
- `mcp__plugin_pika_pika__edit_transcode`
- `mcp__plugin_pika_pika__edit_video_upscale`
- `mcp__plugin_pika_pika__edit_audio_replace`
- `mcp__plugin_pika_pika__edit_audio_mix`
- `mcp__plugin_pika_pika__edit_audio_stitch`
- `mcp__plugin_pika_pika__edit_audio_trim`
- `mcp__plugin_pika_pika__edit_split_screen`
- `mcp__plugin_pika_pika__add_captions`
- `mcp__plugin_pika_pika__extract_audio_from_video`
- `mcp__plugin_pika_pika__generate_reference_video`
- `mcp__plugin_pika_pika__render_html_animation`

Any loaded playbook MCP worker can return `{task_id, status}` instead of an inline URL/result when the server budget expires or a render runs in the background. When that happens, immediately call `mcp__plugin_pika_pika__task_status(task_id=<task_id>)` in a tight loop (no Bash, no sleep) until `status` is `completed`, `failed`, or `cancelled`; when completed, continue the playbook with the returned `result` field as that tool's output. Do not proceed with placeholder URLs while a task is still `queued` or `running`.

Read the file from the skill directory, carry `state.handle` and `state.brief` into it, and run its pipeline.

**Critical rule — don't redo work you've already done.** You are the same agent in the same conversation; everything you scraped and surfaced in Stage 0 is still in context. When you load the playbook:

- If the user picked a specific trend from the 0c sampler (`state.pick` is set) and `state.profile` plus `state.identity_confirmed = true` exist → **carry it in as the chosen trend.** Skip the playbook's own menu-building (Stages 2–3); confirm the pick with a quick verification scrape if needed, then resume the playbook at its **Stage 4 (production package)**. Re-researching a fresh menu here wastes a turn and may surface a trend the user didn't ask for.
- If `state.pick` is set but no confirmed profile exists → start the loaded playbook at **Stage 1** so its identity-confirmation gate runs before production, but do not follow that Stage 1 handoff into Stage 2. After identity is confirmed, carry the picked trend forward and resume at Stage 4; skip only Stages 2–3.
- If you already built `state.profile` in 0b/0c and `state.identity_confirmed = true` → **reuse it. Do NOT re-scrape.** Jump straight to the playbook's trend stage with the confirmed profile already in hand.
- If only the format is locked (no specific trend yet) and no confirmed profile exists → start the loaded playbook at **Stage 1** so its identity-confirmation gate runs. If `state.profile` and `state.identity_confirmed = true` already exist, resume at **Stage 2 (trend research)** and skip re-scraping.

State it to the user in one line — **"Building your {format} trend from here."** — then follow the playbook's instructions verbatim from the appropriate stage through its production, edit, and loop stages.

## Stage 2 — Loop (format switching)

After the playbook delivers, it runs its own Stage-7 loop ("do another from this menu?"). Layer one extra option on top: **"…or want to switch formats? Say 'switch to dance/pov/talking/duet' and I'll route you over — your profile's already loaded, so we go straight to trends."** On a format switch, set the new `state.format`, keep `state.profile` and `state.identity_confirmed = true`, and re-enter Stage 1 (load the new format's playbook, resume at its Stage 2). If the identity flag is missing, run the new format's Stage 1 identity-confirmation gate before trend research. The profile never gets re-scraped within a session unless identity is unconfirmed.

## What NOT to do

- **Don't reimplement production here.** This skill resolves the format and loads the playbook. The script-writing, shot lists, generation, and edit pipelines live in the format playbooks under `formats/` — run those, don't paraphrase them.
- **Don't re-scrape the profile after Stage 0.** One scrape per session; carry `state.profile` into the format playbook and any format switch.
- **Don't rebuild a menu when the user already picked a card in 0c.** Carry the pick into the playbook's Stage 4. Re-researching burns a turn and risks drifting off the chosen trend.
- **Don't invent or pad the cross-format sampler.** Every card needs real reference links + play counts at threshold. Fewer real cards beats ten padded ones — see the virality receipts gate.
- **Don't filter trends down to the user's exact niche.** Find real broad trends across formats; the user's voice attaches via the script/captions in the format playbook. See the broad-versus-niche menu rule and the trend-vs-voice separation rule.
- **Don't surface carousel or transition trends.** Out of scope for this bundle — they're not part of Content Director.
- **Don't skip the format question when the user is unsure.** Recommend from the profile (0b) or show the sampler (0c); never silently guess a format and start producing.
- **Don't proceed without a handle.** Both the recommendation and every format playbook need it — Stage 0a blocks until it arrives.