Prompt library

Give every clip a punchy 2-4 word excerpt title and a one-line context note explaining why it lands, so the running order reads as chapter beats.

Plan a speed-ramp / timewarp pass for the running order — where to compress dead air between beats and where to let a reaction breathe — and report the plan before applying.

Two passes, in this order. (1) Call `snap_to_word_boundaries(list_id, dry_run:true)` to preview edge moves from Parakeet word timings, then `dry_run:false` to commit — expect 0 moves on segments born from create_supercut_list, and do NOT re-snap after any tail extension. (2) Call `extend_to_speech_boundary(list_id, direction:'tail', threshold_s:2.5, dry_run:true)` — it walks word-by-word past the TranscriptLine boundary until an inter-word gap ≥ 2.5s and returns proposed bounds + the words each tail pulls in; review, then re-run with `dry_run:false`. It resizes segments in place (capped at max_extend_s, default 6s — runaways land in `skipped`). Report extended vs skipped counts.

Per-segment precision pass — unlike `extend_to_speech_boundary`, which resizes a segment in place, `widen_segment` creates a NEW wider segment with pinned playback bounds and reset trims; use it when a tail needs explicit control or exceeds the extend cap. Call `get_list(list_id)` to enumerate segments; for each target, call `get_transcript_context(at_time_s=segment.tEnd, before:0, after:3)`, walk the post-anchor TranscriptLines while the inter-line gap is ≤2.5s (same beat), then call `widen_segment(list_id, segment_id, expand_end_s)` with expand_end_s = last continuing word's `.e` − segment.tEnd + 0.1s (line.tEnd if no word timings).

Call `tighten_list_to_silence(list_id)` — it reads Parakeet word timings from the DB and returns `wordPatch` (edge moves to the nearest inter-word gap) plus `unresolved`. Apply each `wordPatch` entry via `trim_segment_in_list`. Report any `unresolved` rows and the `remedy` each carries.

Call `snap_to_word_boundaries(list_id, dry_run:true)` to preview the planned edge moves from Parakeet word timings, then call again with `dry_run:false` to commit. Pass `segment_ids` to scope to specific clips; `snap_start`/`snap_end` to limit which edges move.

Call `analyze_list_edge_gaps(list_id)` — it measures the silence gap between each clip's effective playback window and the nearest transcript word outside each edge, and returns a per-segment report plus two problem buckets; list the `midWordCuts` (edge lands mid-word) and `tightEdges` (cut hugs speech) rows so I can decide which clips need a snap, widen, or trim.

Find the most recurring lines across the clips in this list and propose 3-5 catchphrase seeds I could mine for more.

Distill this list into a reusable INCLUDE/EXCLUDE search query so every new VOD gets mined for the same kind of moment, and add a note on each query explaining its intent.

Find a sibling list of mine that fits the same theme and propose a merge plan (which list folds into which, what to dedupe) before doing it.

Suggest collab partners whose VODs overlap with the clips in this list so I can pull in a second POV for the reaction beats.

Once the list reads end-to-end, request public visibility so it shows up in the public gallery.

Split the clip at the natural conversational pause, keeping each half a clean cut.

Trim a dead or off-topic span out of the clip by cutting that range — keep the lead-in and the payoff, drop the middle.

Weld two clips so the dialogue runs with no pause: read each side's words via `get_segment_transcript`, then call `splice_segments(list_id, from_segment_id, to_segment_id, dry_run:true)` — it cuts A's tail to its last word and B's head to its first word at raw word boundaries (stripping the baked pad) and moves B directly after A; review the resolved ranges, then re-run with `dry_run:false`.

Skip a span inside a single clip (a swear, a name-drop) with no pause left behind: read the beat's `words[]` via `get_segment_transcript`, then call `skip_span(list_id, segment_id, word)` (add `to_word` for a run) with `dry_run:true` — it splits the beat around the span, both inner edges snapped to raw word boundaries; review the dropped text, then re-run with `dry_run:false`.

For any clip that was just split, write a one-line excerpt on each half so the two beats read as distinct moments instead of half-clips of the same line.

Call `place_emote_at_words(list_id, words:[...], dry_run:true)` with the trigger words I name — it reads each segment's own source-VOD transcript and schedules one overlay per spoken occurrence (match:'stem' to catch inflections, `occurrence` for a single hit, budget 24 overlays per list with overflow reported in `dropped`); show me the schedule, then re-run with `dry_run:false`. Placed emotes are source-anchored, so they ride their word through later trims and reorders.

Find a co-streamer whose VOD overlaps this creator's on this list, so we have a second POV available to swap to on the reaction beats.

Align the two creators' VODs and verify the offset before any POV swap.

Call `measure_lipsync_offset(listId, segmentId, pov)` on a beat where both creators talk — it matches utterances present on BOTH transcripts and proposes the partner-spoken cluster's median offset (the Discord-delay-inclusive value wall-clock alignment misses, so the other creator's mouth lands on the bed's copy of their voice); report matched pairs and current vs proposed offset, then re-run with `apply:true` to pin the proposal as an alignment knot.

On the reaction beat, show the other creator's POV on the back half so we see their face when the joke lands.

For beats that carry mid-beat POV swaps, call `snap_segment_pov_swaps(listId, allEnabled:true, dryRun:true)` — it snaps every swap boundary to the nearest word edge in the heard transcript (mode 'heard', the fix for a return-to-base camera replaying a line we just heard); report the proposed moves per beat, then re-run with `dryRun:false`.

Call `list_copresence(creator)` for this creator — it sweeps their VODs against the global wall clock and returns every partner whose stream overlapped, each with `seedLiveFromS`/`seedLiveToS`: the partner's live window expressed on the seed VOD's own clock, i.e. the range a beat can actually take their camera. Use it to pick which partner's facecam to cast. Read-only.

Call `list_collab_gaps(creator)` for this creator — it returns the partners their stream titles NAME (e.g. "w/ Gingy") but who have no ingested VOD overlapping that night, so there is nothing to align or crop a cam from. Each gap carries the seed VOD and the wall-clock window a partner VOD must overlap to unlock the cast — the ingestion worklist. Read-only.

Call `scope_partner_cam_beats(list_id, partner)` for the other creator — for every beat it returns either `castable` (with the resolved partner VOD, the partner-VOD second, and the wall-clock offset) or `skipped` with a reason (`before-partner-live`, `after-partner-live`, or `no-overlapping-partner-vod`). Read this plan before casting so you know how many beats their cam will land on. Read-only.

Call `cast_partner_cam(list_id, partner, dry_run:true)` for the other creator — it scopes the castable beats (as scope_partner_cam_beats does), auto-creates a wall-clock alignment for any unaligned pair (publishedAt-delta, ±1-2s — right for a facecam; an existing dialogue-grade alignment is preferred when present), and returns the plan WITHOUT writing. Review which VODs/beats it covers and which it skips, then re-run with `dry_run:false` to place ONE persistent facecam inset per partner VOD that rides the whole cut and shows over exactly the alignable beats. Optional `crop_rect` (fractions [0..1] of the 16:9 frame; default whole frame) tightens the source to just their cam, `dest` places the inset (default top-right), and `fit`/`circle`/`opacity` style it. Render to see the camera. Owner-scoped.

Call `estimate_render(list_id)` — read-only, never invokes Lambda, costs nothing. It returns the dollar estimate (low/high band + basis), staged-source seconds, output length, Lambda fan-out, `cacheHit` (a finished render with this exact content hash means a re-render is FREE), the staging-budget verdict (and why, if it's blocked), recent real bills, and — for a cast list — the cast render-truth: per partner cam, which beats actually render the inset vs skip (the same resolution the render uses, so it can't diverge). Use it to confirm the cast covers the beats you expect and that the spend is what you think before paying for anything. Pass `beats:[...]` (segment ids, the same vocabulary as cast_partner_cam) to quote just a probe subset, and `format:'vertical'` / `high_quality:true` to match the render you intend. Owner-scoped (or admin).

Call `render_list_on_lambda(list_id, beats:[...])` with a handful of segment ids — it renders only that subset as one continuous mp4 (the same `beats` ids estimate_render and cast_partner_cam use), a cheap ~1¢ probe so you can eyeball the cast inset and the cuts before committing the whole list. The subset carries its own content hash and caches independently of the full render. Poll `get_render_status` for the output URL. Owner-scoped.

Once the estimate and the probe look right, call `render_list_on_lambda(list_id)` with no `beats` to render the full list at full resolution, then poll `get_render_status` for the output URL. Pass `format:'vertical'` for a 9:16 Short or `high_quality:true` to stage the source at 1080p — match whatever you quoted. Owner-scoped.

Create a search list for this creator that INCLUDEs "<phrase>" and EXCLUDEs recaps and black screens, with a note on each query explaining its intent.

Run the search list and materialize the hits into a List.

Run the search list, read each hit's transcript text against the query's intent note, and for occurrences that don't match the intent call `mute_search_list_hits(search_list_id, hit_keys)` using each hit's `<vodId>:<lineIdx>` key from the run_search_list result — it drops those single occurrences from the merged result without excluding other lines that share their text, and returns the updated mute set. (To exclude EVERY line matching a phrase, add an EXCLUDE query instead.)

When one hit is worth chasing, call `clone_query_from_hit` with that hit's `segment_id` (it derives the phrase + creator from the hit's sourceQuery) — or an explicit `phrase` — targeting `target_search_list_id` to append the clone here or `new_list_name` to start a fresh search list; set `note` to record why the query exists, then run the target list with `run_search_list` and report what else it caught.

Enable auto-run on this search list so it runs against my own channel's new VODs as they finish transcribing and appends the hits to its List. (Requires the list be scoped to my own creator login.)

Show recent auto-run activity for my search lists — what each of my latest VODs added across all my auto-run lists.

Search this creator's transcripts for "<phrase>", cluster consecutive hits into chains, and pull the setup context for each so I can pick the best ones.

Queue VOD <vodId> (this creator) for transcription.

Call `costream_network(focus)` for this creator — it builds the archive-wide co-streaming graph from the global wall clock: creators as nodes (streamed hours + community cluster) and every co-streaming pair as an edge scored by LIFT = observed overlap ÷ base-rate expectation, so a deliberate duo outranks two people who merely both stream a lot. Pass `focus` for one creator's lift-ranked neighbourhood or omit for the global top pairs; `min_lift`/`min_overlap_s` filter and `community_min_lift` tunes cluster granularity. Use it to spot which two POVs are worth aligning. Read-only.

Align this creator's VOD <vodA> with the other creator's VOD <vodB>, verify the offset, and report whether it passed.

Refine an existing alignment for on-camera sync: call `measure_lipsync_offset(listId, segmentId, pov)` on a list beat where both creators talk — it matches utterances present on BOTH transcripts and proposes the partner-spoken cluster's median offset (the Discord-delay-inclusive value wall-clock alignment misses); report matched pairs and current vs proposed offset, then re-run with `apply:true` to pin the proposal as an alignment knot.

Call `set_list_layout(list_id, preset:'vertical_gameplay')` — one owner-scoped call that sets every beat to the 9:16 gameplay-only layout (full 16:9 contained over a blurred fill, no crop, facecam off; use preset 'vertical_cam_top' to keep the cam band, 'clear' to revert). Confirm via the `renderLayout` summary on `get_list`, and pass `format:'vertical'` on the subsequent render.

Call `estimate_render(list_id)` before spending — read-only, never invokes Lambda. It returns the dollar estimate (low/high band + basis), staged-source seconds, output length, Lambda fan-out, `cacheHit` (a finished render with this exact content hash re-renders FREE), the staging-budget verdict (and why, if it's blocked), and recent real bills for this list. Pass `beats:[...]` (segment ids) to quote a probe subset, and `format`/`high_quality` to match the render you intend. Owner-scoped (or admin).

Render this list on Remotion Lambda at full resolution and report the output URL when it finishes. Pass `beats:[...]` (segment ids) to render only a subset as one continuous mp4 — a cheap ~1¢ probe render that caches independently of the full render — to verify a cast or layout before committing the whole list. KNOWN ISSUE (2026-05-27): the Vercel staging step throws `spawn yt-dlp ENOENT` because Vercel has no yt-dlp on PATH — when that happens the run fails before any Lambda is invoked. If it fails for that reason, surface the error and point the user at the Export menu (export_list_clips + download_vod_window) so they can pull the segment mp4s themselves and edit them in their NLE of choice.

Fetch the export-bundle runbook for this list and follow its instructions: materialise data.files into ./<bundleDirname>/, save data.segments + script.body, preflight yt-dlp/ffmpeg/jq/curl, then run the script to produce one mp4 per clip matched to its SRT.

Also export the list's full transcript as one document with export_transcript, for show notes or a description.

Make a scribble-style thumbnail for this creator with a punchy 2-3 word title bubble.

Draft a YouTube upload plan for the finished cut using the @LaughingWhales title/description template.

Search this creator's transcripts for the phrases this board is about, cluster the best hits, and pin each as a research card (vodId + timestamp + line text) so the moments survive outside chat.

Read this board's cards and set the storyboard order so it reads as a tight beat sheet — hook first, payoff last — then report the running order.

Turn this board's research cards into a real List (each becomes a segment), then report the new list id so I can open it in the studio.

Once the board reads well, request public visibility so it shows up in the public planning gallery.