SkillsSkill for Claude

Act index for recital videos

This skill takes the full recording of a dance, music or drama school's recital or end of term concert and the printed program, indexes the recording in a private Vivu project, searches once for the moments someone announces the next act and once for the moments a new act starts on stage, checks every window against the transcript and a half second contact sheet, lines the confirmed starts up with the program, and writes an act chapter list (act name, start and end time, opening frame, announcement line, jump link) plus chapter lines for the video description. The value is in what the program and the audio leave out: the program has no times, announcements get buried in applause or name three acts at once, some acts have none, and the real start is when the lights come up and the first beat lands.

Maintained by Vivu. Updated 2026-11-19.

Download

recital-act-index.zip

10 KB. Unzips to recital-act-index/SKILL.md. Upload the zip as it is in the Claude app, or unzip it into your skills folder for Claude Code.

SHA-256 4b6dae636b6a4be82e05ed5d99dea081ddbc28f4f0e91bfe999718acf8a9e43c

At a glance

What the Act index for recital videos skill does, where it runs, what it needs, and when it asks
Looks forAnnouncements of the next act and the moment each act starts on stage (lights up on performers in place, the first beat or step), including acts nobody announces. Each window is checked against the transcript and a contact sheet from the original recording before it reaches the list, and acts that cannot be placed are listed as NOT PLACED.
Runs onClaude Code on your computer (the terminal or the Code tab of Claude Desktop), because it reads the local recording and runs ffmpeg. No residential IP and no scheduler: run it once per show.
Needs
  • The Vivu connector with write access, to create a private project, upload and search.
  • A shell with ffmpeg and ffprobe, to measure the recording, make contact sheets and pull opening frames.
  • The recording as a local file, the same edit parents will watch, so the times match.
  • A transcript of the recording (.srt or .vtt from your own upload's captions, or local speech to text), to check announcements and copy them word for word.
  • The printed program with act names in running order, which is where every act name comes from.
  • An upload path: the Vivu upload page in your own browser, or a browser tool that can attach local files.
  • Optionally, the link to your video page and how it takes a start time.
Your Vivu planIndexing uses Vivu index minutes equal to the length of the recording, so a full show usually does not fit the Free plan. Searching uses a precise search for announcements and another for stage openings, plus a few retries. The skill measures the recording and shows minutes and credits against your plan before uploading. In our test run, 54.1 minutes of concert video was indexed and the searches used 15 credits (estimate).
Asks you firstApproval of the index minutes and search credits before upload, confirmation that the school owns the recording and has written guardian consent for every child on stage before anything is uploaded, and approval of one sample row and field mapping before writing the rest of the list.

The skill does its video work through the Vivu connector. If the connector is not in your Claude yet, add it first; the skill checks that it is connected before it does anything else.

Before you run it

  • Use only your school's own recording; children on stage need written guardian consent before the video is uploaded, or the skill does not upload it.
  • The skill does not recognize faces, look for a named child, or judge any performance, and it does not cut clips.
  • The recording stays in a private Vivu project in your account until you delete it.
  • Browser upload tools such as Claude in Chrome take at most 10 MB per call, so a show recording is added through the upload page in your own browser or the Vivu web app; files are never split or recompressed.
  • Finding acts nobody announces relies on visual search, which is weak: it returns lighting changes and bows as false starts and misses pieces played back to back, so every window is checked on a contact sheet and unplaced acts are listed as NOT PLACED or UNCERTAIN.
  • Announcement windows hold the announcement, not the act start, so starts are set from contact sheets and the school reviews the list before families see it.
  • Nothing is sent for you: the skill writes the chapter list and a sample note to parents as local files, and you send them yourself.

Start it

Once the skill is installed, ask for the task in your own words. Naming the skill is the most reliable way to have Claude use it. For example:

Make an act chapter list for our spring recital video at ~/Videos/spring-recital.mp4 so parents can jump to their child's act. Here is the program.

In Claude Code you can also type /recital-act-index. Claude asks for anything the request leaves out, most important first.

What is inside

  1. When to use
  2. Working principles
  3. What you need before starting
  4. Inputs to collect
  5. Files and state
  6. Step 1: Check the Vivu connector and the setup
  7. Step 2: Measure the recording and price the run
  8. Step 3: Create the project and upload
  9. Step 4: Search for announcements and stage openings
  10. Step 5: Check each window and set the act start
  11. Step 6: Line the acts up with the program
  12. Step 7: Pick the opening frames and write the chapter list
  13. Step 8: Review with the school and hand off
  14. Compliance
  15. Known failure modes

The full skill

This is recital-act-index/SKILL.md from the download, as Claude reads it: the frontmatter first, then the instructions.

---
name: recital-act-index
description: "Turn your studio's full recital or concert recording and its printed program into an act chapter list with Vivu: start times, jump links and chapter lines. Use before sending the video to parents."
---

Act index for recorded recitals and concerts

This skill takes the full recording of a dance, music or drama school's recital or end of term concert (one long video file, usually one to two and a half hours) and the printed program (the act names in running order, no times), and returns an act chapter list: one row per act with the act name from the program, the start and end time as MM:SS, an opening frame, the announcement line copied from a transcript, a link to the school's own video page with a time parameter, and a chapter line ready to paste into the video description. Claude prices the indexing against the user's Vivu plan, indexes the recording in a private Vivu project, runs one search for the moments someone announces the next act and one for the moments a new act starts on stage, checks every window against the transcript and a half second contact sheet, lines the confirmed starts up with the program, and writes act_index.csv, chapters.txt and a list of acts it could not place.

The value is in what the program and the audio leave out. The program has the order but no times. Announcements get buried under applause, one announcement can name the next three pieces at once, the opening act and pieces played back to back often have none, and between an announcement and the first beat there can be minutes of moving drums or chairs. Where an act really starts is something you see on stage: the lights come up, the performers are on their marks, the first beat or step lands. Parents want to jump to their child's act, so every start in the list comes from a frame, and an act that cannot be placed is listed as NOT PLACED for a person to fill instead of guessed.

When to use

Use when a studio owner or arts teacher asks "make chapters for our spring recital video so parents can find their kid's dance", "here is the end of term show recording and the program, I need timestamps for each act", or "add chapter markers to the concert video before we send it to families".

Not for these:

  1. Finding one child or making a highlight reel of one performer. This skill finds where acts start; it does not look for a person. The youth-game-highlight-reel skill (https://vivu.ai/skills/youth-game-highlight-reel) covers player highlights for sports.
  2. Meetings, lectures or ceremonies with an agenda of speeches. The searches here look for performances starting on a stage, not for agenda items.
  3. One question about one video ("when does the tap number start?"): search Vivu directly or scrub the video.
  4. Judging, ranking or commenting on performances. The skill never assesses anyone.
  5. Cutting the video into separate clips per act. The skill writes times and links only.

Working principles

  1. Report measured numbers, not estimates. When a number is an estimate, say so.
  2. Nothing is verified until it has been checked against the video. A search window is a candidate until the transcript shows the announcement and the contact sheet shows the act starting. Vivu's reason text paraphrases, so it never fills the announcement cell.
  3. Act names come from the program, never from the search or the reason text. An act that cannot be placed stays NOT PLACED; it is not given the nearest window.
  4. Stop and tell the user when a required capability or tool is missing. Do not guess around it.
  5. Ask the user before anything that is expensive to redo (the indexing minutes, before upload). The skill writes local files only; the school sends the list to parents itself, so nothing is posted or emailed on the user's behalf.

What you need before starting

Check each item at the start of the run and tell the user plainly what is missing before doing anything else.

Requirement Why How to check
Vivu connector with write access create a private project, open its upload page, search vivu_get_account shows can_create_projects: true (tool names may carry a server prefix). A write call failing with "has not granted vivu.write" means the user reconnects Vivu and allows write access
A shell with ffmpeg and ffprobe measure the recording, make contact sheets, extract opening frames ffmpeg -version, ffprobe -version
The recording as a local file, the same edit parents will watch Vivu indexes the upload, frames come from this copy, and the times must match the published video ls SHOW_DIR shows the file; the user confirms it is the version they will publish
A transcript of the recording: an .srt or .vtt from the video platform's captions on the school's own upload, or a local speech to text tool such as whisper.cpp announcements are checked against it and the announcement line is copied from it an .srt or .vtt next to the video, or whisper-cli --help
The printed program, act names in running order act names and order come from it; the search never names an act the user pastes it or gives the file
The link to the school's video page (optional) each row links to the act's start the user pastes it and says how the platform takes a start time (YouTube and Vimeo: ?t=SECONDS or #t=SECONDS)
An upload path move the recording into Vivu vivu_open_upload_page plus the user's own browser, or a browser tool that can attach local files

This skill needs Claude Code on the user's computer (the terminal or the Code tab of Claude Desktop), because it reads a local video file and runs ffmpeg. It downloads nothing from YouTube or other sites, so no residential IP is needed. Nothing recurs, so no scheduler is involved; run it once per show. The only connector it needs is Vivu.

Inputs to collect

Ask for anything missing, most important first.

  1. SHOW_FILE: the path to the full recording. Required. If the show was recorded as several files (a camera that splits at 4 GB, or two halves), list them in order.
  2. The program: act names in running order, one per line. Required. Mark acts that run back to back without a break if the user knows.
  3. The transcript file. Default: look for an .srt or .vtt next to the video with the same name; otherwise ask whether to run the local speech to text tool.
  4. VIDEO_LINK: the school's video page and its time parameter. Default: leave the link column empty and keep MM:SS only.
  5. SHOW_NAME: a short name for the working folder and the Vivu project. Default: the season and year, for example spring-2026.
  6. Whether to run the stage opening search for acts with no announcement. Default: yes.

Files and state

Keep everything in one working folder:

recital-SHOW_NAME/
  config.json        program, video link, Vivu project id, query wording
  upload/            the recording to index (the published edit)
  transcript.vtt     the transcript (or .srt)
  results/           one JSON per search, without the result page link
  sheets/            contact sheets for each window
  frames/            one opening frame per act
  candidates.csv     every window Vivu returned, with the verdict and the reason
  act_index.csv      the chapter list: one row per act
  chapters.txt       chapter lines for the video description
  unplaced.txt       program acts with no confirmed start
  state.json         steps done, video id, searches run with job ids, windows checked

Run every command from inside recital-SHOW_NAME/. A rerun reads state.json first: an uploaded file is not uploaded again, a search with a saved result is not run again, and a window with a verdict in candidates.csv is not checked again, so an interrupted run picks up where it stopped and no act gets two rows.

Step 1: Check the Vivu connector and the setup

Goal: confirm every requirement before touching any file.

  1. Call vivu_get_account. If the tool is missing, tell the user to add the Vivu connector in Claude (https://mcp.vivu.ai/mcp) and stop. If it shows can_create_projects: false, or a later write call fails with "has not granted vivu.write", ask the user to reconnect Vivu and allow write access, then stop until they have.
  2. Run ffmpeg -version and ffprobe -version. If either is missing, say so and stop.
  3. Check the rest of the What you need table: the recording, the transcript, the program. Say plainly what is missing.

Done when vivu_get_account shows can_create_projects: true, both ffmpeg commands print a version, and the recording, transcript and program are in hand.

Step 2: Measure the recording and price the run

Goal: the user sees what indexing and searching will use before anything is uploaded.

  1. Measure the recording (SHOW_FILE is the path from Inputs):
ffprobe -v error -show_entries format=duration -of csv=p=0 "SHOW_FILE"

Divide the seconds by 60: that is the index minutes. Copy the file to recital-SHOW_NAME/upload/. 2. Count the searches: two precise searches (announcements and stage openings), plus at most one reworded search for each. A precise search uses 5 credits in total and a fast search uses 1 credit. This skill uses only precise searches, because only precise returns a time range, and the whole show is one known file. 3. Call vivu_get_usage and show one table:

This show Plan allowance Remaining this month
Index minutes measured from vivu_get_usage from vivu_get_usage
Search credits estimate: searches x 5 from vivu_get_usage from vivu_get_usage

The plans for reference: Free is 20 indexing minutes a month and 50 search credits a month; Premium is $30 a month with 180 indexing minutes and 500 search credits. A two hour show does not fit the Free plan. 4. If the show does not fit, offer these levers in order: index only the half of the show the families asked about first (for example the second half after the interval), skip the stage opening search and mark unannounced acts for manual placement, and only then move to a larger plan. Never drop part of the show without telling the user which acts that leaves out.

Done when the user has approved the minutes and credits in the table.

Step 3: Create the project and upload

Goal: the recording is ready in a private Vivu project.

  1. Ask the user to confirm the consent points in Compliance (who recorded the show, and written guardian consent for any minors on stage). Do not upload before they confirm.
  2. Call vivu_list_projects and reuse a project named "Recital SHOW_NAME" if it exists. Otherwise call vivu_create_project with that name and visibility "private". The default visibility is the whole organization, and a recital shows students, so private is the right choice. Record the project ID in config.json.
  3. Call vivu_open_upload_page with the project ID. It returns upload_url, a one time link that expires in 180 seconds, so request it right before use and never paste it into a file or a message. Either give it to the user to open in their own browser and pick the file from upload/, or open it in a browser tool that can attach local files. Claude in Chrome accepts at most 10 MB per upload call, and a show recording is far larger, so in practice the user adds it through the upload page in their own browser or the Vivu web app. Do not split or recompress the recording to fit.
  4. Poll vivu_list_videos every 30 seconds or so until the recording shows status ready. A long show takes a while to index; a pending status is not an error. Vivu replaces spaces and punctuation in file names with underscores, so match the video back by the name with those characters replaced, and record video_id in state.json.

Done when vivu_list_videos shows the recording as ready and its video_id is in state.json.

Step 4: Search for announcements and stage openings

Goal: two saved searches that give candidate windows for every act.

The standing queries, one per output field:

Field Query Mode maximum_results
start of each announced act, announcement_quote between pieces, a performer or host talks to the audience and introduces the next piece by name, telling them what it is called before the group plays it precise 40
start of acts with no announcement (candidates) the very beginning of a new piece after a break: the stage was dark or quiet with nobody playing (after applause, a speech or a stage change), then the lights come up on performers waiting in their places and they play the first beat or make the first movement. Not a lighting change or a solo spotlight in the middle of a piece that is already being played precise 40

The chain: the announcement search finds the windows where someone says what comes next; the transcript turns each window into the act name and the exact line, and the contact sheet after it shows where the act really starts. Acts the announcements never reach (the opener, pieces played back to back) are looked for by what the stage shows when a piece begins, which flips the search from what is said to what is seen. fast mode is not used, because it returns whole files with no time range, and the show is one known file.

These searches rest on different capabilities. Finding what is said works well in Vivu. Finding what the stage looks like is visual search, which is weak: it confuses lighting changes and bows with a new start and misses pieces that run into each other, so its windows are only candidates, and an empty result does not prove an act has no visible start. The numbers from our test run are under Step 5.

  1. Call vivu_search_videos with project_id, the announcement query, mode "precise" and maximum_results 40. Forty leaves room for every gap between acts in a two hour show of 20 to 30 acts plus speeches; it is also the most windows a search can return, so raise it toward 100 for a longer show.
  2. Call vivu_get_search_results with the job ID until complete is true. Each status call can wait up to 45 seconds, so a pending search is not a stalled one.
  3. Do the same for the stage opening query, unless the user turned it off in Inputs.
  4. Save each results array to results/FIELD.json without the result page link, and record the job IDs in state.json. Show the result page link in the live reply only: it expires after four hours, so it never goes into the chapter list, the chapter lines or any file.

Done when both result files exist in results/ and their job IDs are in state.json.

Step 5: Check each window and set the act start

Goal: every window is judged real or false, and every real one gives an act name from the program and a start the school can trust.

  1. For each announcement window, read the transcript from 10 seconds before START to 10 seconds after the window end (START and END in seconds from start_ms and end_ms). The window is real only if someone says what comes next ("this next song is called ...", "here is ..."). Talk about the piece that just ended ("that last song was called ..."), a recap, thank-yous, or a welcome speech are false: write them to candidates.csv as false with the line that shows it. Copy the announcement line word for word as announcement_quote; for a speech check without a transcript, call vivu_get_video_summary with include_segments true and start_ms and end_ms around the window, which confirms the topic but never fills the quote.
  2. Match the announced name to the program by meaning, not spelling: transcripts mangle names of pieces in other languages, so "yubing kyoku" is the program's "Yuubinkyoku Enotabi". One announcement can name two or three acts ("here is Waterbender followed by Ouichi followed by Biscuits in Danger"); it gives the first act's start and tells you the next two follow without a break, but not where they start.
  3. Find where the act starts on stage. Make a contact sheet from the end of the announcement, one tile every half second for 60 seconds (START here is the announcement end in seconds):
ffmpeg -v error -ss START -t 60 -i "upload/SHOW_FILE_NAME" -vf "fps=2,scale=320:-2,tile=10x12" -frames:v 1 "sheets/after_START.png"

Look at it. The act starts where the lights come up on performers in place, or at the first beat or step, whichever is first. If the stage is still being reset after 60 seconds, make the next sheet from START plus 60. There can be minutes between an announcement and the first beat. 4. For each stage opening window, make the same kind of sheet across the window (START from start_ms, DURATION from end_ms minus start_ms):

ffmpeg -v error -ss START -t DURATION -i "upload/SHOW_FILE_NAME" -vf "fps=2,scale=320:-2,tile=10x12" -frames:v 1 "sheets/open_START.png"

For windows longer than 60 seconds, raise the tile rows or make two sheets. The window is real only if a new act starts inside it. Playing in the middle of a piece, a bow, applause, chairs or drums being moved, a solo pose held still, or an empty stage are false, even when the reason text says a piece begins.

Done when every window in candidates.csv has a verdict of real or false, and every real one has a program act name and a start in seconds.

Worked example from our test run

In our test run we used one public concert by a college taiko ensemble (adult performers, a live stream edit with wide and close cameras), recorded as 2 files, 54.1 minutes in total, with a program of 9 pieces. Before searching we wrote down every announcement and every act start from the captions and contact sheets. Both files were ready about 11 minutes after the upload started. The upload went through a script instead of the upload page in a user's browser, and nobody approved the cost table or the consent questions, so those parts of Steps 2 and 3 were not exercised in our test run.

The announcement search returned 6 windows: 6 real, 0 false and 0 missed against the 6 announcements we had written down. No window landed on only the line that named the piece just played, the recap of earlier pieces, or the thank-you speeches, though the window at the start of the second file also covered the recap that came just before the Raku announcement. One window held a single announcement of three pieces in a row. The windows were 48.5 seconds wide at the median and each held all or nearly all of the announcement (two windows began or ended a few seconds inside it, which is why Step 5 reads the transcript from 10 seconds before to 10 seconds after), but the act start was always later: after some announcements the stage went dark first, after others came minutes of drum moving or a thank-you speech before the first beat.

The stage opening search was weaker. The first wording returned 11 windows, 5 real and 6 false: the false ones were lighting changes and a solo spotlight inside pieces already being played, and drum moving after the last piece, and every one of their reason texts said a new piece begins. The wording in the table came after 1 rewording on the same corpus and returned 6 windows, 5 real and 1 false (the bow at the end of a piece), and it found 5 of the 9 act starts. It found the opener, which had no announcement, but missed both pieces inside the medley that one announcement had named in advance. Those two were placed from the gap sheet in Step 6, and one of them is marked UNCERTAIN because a solo began before it and the announcement said the solo belongs to that piece. The run used 3 precise searches, 15 credits (estimate).

Step 6: Line the acts up with the program

Goal: every program act has either a confirmed start or a NOT PLACED mark.

  1. Walk the program in order. Give each act the earliest confirmed start that is later than the previous act's start. A confirmed start that matches no act on the program (an encore, a speech, an unlisted solo) goes into act_index.csv with the act_name UNLISTED and what the sheet shows, for the user to name or drop.
  2. Acts still without a start, but with known neighbors, are searched for in the gap between them: make a 2 second contact sheet of the gap (ffmpeg -v error -ss GAP_START -t GAP_LENGTH -i "upload/SHOW_FILE_NAME" -vf "fps=1/2,scale=256:-2,tile=10x10" -frames:v 1 "sheets/gap_GAP_START.png") and look for lights changing, applause and a new formation. For a gap longer than about 10 minutes, use one tile every 4 seconds (fps=1/4) and more rows. If the gap shows exactly one change per missing act, use them in program order and mark the rows found_by "gap sheet". If it shows more changes than missing acts (solos, interludes, lighting cues), place each act on the change that fits the program and the announcements best and set its status to UNCERTAIN with the other candidate time. If it shows no change, the act stays NOT PLACED.
  3. Write unplaced.txt with every NOT PLACED act and the time range it must sit in, and every UNCERTAIN act with both candidate times.

Done when every program act is in act_index.csv with a start or in unplaced.txt with a range.

Step 7: Pick the opening frames and write the chapter list

Goal: act_index.csv, chapters.txt and a sample note to parents, with a frame for every placed act.

  1. For each placed act, extract one frame a few seconds after the start, where the performers are in place (FRAME_SECONDS is that time, NN the act's order number):
ffmpeg -v error -ss FRAME_SECONDS -i "upload/SHOW_FILE_NAME" -frames:v 1 -q:v 3 "frames/actNN_FRAME_SECONDS.png"

Look at the frame. A live stream edit cuts and dissolves between cameras, so a frame can land in the middle of a dissolve with two pictures on top of each other; pick a time a second or two away and extract again. 2. If the show was recorded in several files but is published as one video, add the length of every earlier file (from Step 2) to the times from a later file before writing MM:SS and links. If it is published as several videos, keep each file's own times and link. 3. Show the user one sample row and the field mapping before writing the rest:

order,act_name,start_mmss,end_mmss,found_by,announcement_quote,opening_frame,video_link,chapter_line,status
2,Yuubinkyoku Enotabi,10:20,14:40,both,"this next song ... it is called yubing kyoku enotabi",frames/act02_625.png,https://VIDEO_PAGE?t=620,10:20 Yuubinkyoku Enotabi,checked; name matched by meaning
Field Source If unavailable
order, act_name the program none
start_mmss Step 5 sheet, or Step 6 gap sheet NOT PLACED
end_mmss the next act's start, or the last applause blank
found_by announcement, stage opening, both, or gap sheet none
announcement_quote the transcript line, verbatim blank, with "no announcement" in status
opening_frame Step 7 frame NOT VERIFIED, no picture
video_link VIDEO_LINK plus the time parameter blank
chapter_line MM:SS plus the act name none
status checked, plus any note (start set after a stage reset, name matched by meaning) none
  1. Write chapters.txt. YouTube needs the first chapter at 00:00 and at least three chapters, each at least 10 seconds long, so start with "00:00 Welcome" (or the first act if it starts at 00:00). Leave NOT PLACED acts out of chapters.txt and list them at the top of the reply.
  2. Write a sample note to parents (email or newsletter text with the video link and the chapter lines) to a local file. Do not send it.

Done when act_index.csv has one row per program act, every placed row has a frame in frames/, and chapters.txt and the sample note exist.

Step 8: Review with the school and hand off

Goal: the school checks the list before families see it.

  1. Give the user act_index.csv, chapters.txt, unplaced.txt, the frames folder and candidates.csv. Say how many windows were checked and how many were rejected as false, with what each rejected one showed, and point out every row whose start came from a gap sheet or a stage opening only, and every UNCERTAIN row with both candidate times.
  2. Report the real count: if some acts are NOT PLACED, say how many and which; do not fill them with a guess.
  3. The school pastes the chapter lines into its video description and sends its own note to families. Claude does not post or send anything.

This step was not exercised in our test run: there was no school to review the list, and the chapter list and the note to parents were rendered locally and not sent anywhere.

Done when the user has the files, has seen the count of rejected windows, and has confirmed or corrected every row and placed or dropped every NOT PLACED act.

Compliance

  1. Only the school's own recording. Ask the user to confirm before Step 3 that the school recorded the show (or holds the rights to the recording) and may publish it to families.
  2. Minors on stage. Most recitals feature children. The recording goes to a cloud service in Step 3, so before Step 3 the user confirms that a parent or guardian of every child on stage agreed in writing to the show being recorded and shared (often a media release in the enrollment form). Without that, do not upload; offer to work from the program and the user's own notes instead.
  3. The skill finds where acts start. It does not recognize faces, look for a named child, or judge, rank or comment on any performance, and it does not cut or publish clips.
  4. The recording stays in the Vivu project in the user's account until the user deletes it. The project is created private. Claude never deletes a project or a video unless the user asks, and confirms first.
  5. Sending the list to parents is the school's own action. Claude writes local files and a sample email; it does not post or send anything.

Known failure modes

Symptom Cause Fix
(observed) the stage search returns a window inside a piece that is already playing: "lighting change inside Bakuhatsu"; the first wording had 6 false of 11 lighting cues and solo spotlights look like a new start, and the reason text says a piece begins use the Step 4 wording (a new piece after a break, not a change in the middle); check every window on a contact sheet
(observed) the stage search returns the bow at the end of a piece: "lights come back up on performers standing for the bow" lights up on performers in place looks the same at the end as at the start reject it when the sheet shows bowing or applause and no first beat
(observed) one announcement names the next three pieces: "three titles announced together" medleys and pieces played without a break are announced once the announcement gives only the first start; place the others from the stage search or the Step 6 gap sheet
(observed) the sheet after an announcement shows no start: "showed only drum moving" a stage reset or a speech sits between the announcement and the first beat make the next sheet from where the last one ended, until the lights come up or the first beat lands
(observed) the stage search misses unannounced pieces inside a medley visual search is weak and one piece runs into the next without a dark stage place them from the Step 6 gap sheet; if the sheet is ambiguous, mark the row UNCERTAIN
(observed) the gap sheet shows more changes than missing acts: "a solo begins before Ouichi and before Biscuits in Danger" solos, interludes and lighting changes between pieces place the act on the change that matches the program and mark it UNCERTAIN; the school decides
(observed) the opening frame is two pictures on top of each other: "landed in a camera dissolve" the live stream edit dissolves between cameras extract the frame a second or two earlier or later and look again
upload page asks to sign in or shows an error the one time upload link expires after 180 seconds request a new link right before opening it
"has not granted vivu.write" Vivu was connected read only the user reconnects Vivu with write access
the recording is rejected by the browser upload tool the file is above the tool's size limit the user adds the recording in the Vivu web app; do not split or recompress it
a result's file name does not match the recording Vivu replaced spaces and punctuation with underscores match on the name with those characters replaced
chapter times are off on the published video the uploaded file is not the published edit (a pre-show slate was trimmed later) index the exact file parents will watch, or shift every time by the trimmed length and say so
the stage search returns nothing for an act visual search is weak; an empty result does not prove the footage has no such moment mark the act NOT PLACED and let the user scrub to it
the reason text names an act or a cue the transcript does not contain the reason is a paraphrase written from picture and sound copy names from the program and quotes from the transcript only
the allowance runs out partway the show is longer than the plan covers apply the Step 2 levers, or move to a larger plan

Connect Vivu, then add the skill.

The skill runs through the Vivu connector. Add it to Claude from the connector directory, then install the skill.