---
name: rehearsal-take-log
description: "Turn your band's rehearsal recordings into a take log with Vivu: each run found at each piece, start and stop times, the conductor's comments. Use before sending players what to listen back to."
---Rehearsal take log for instrumental ensembles
This skill takes the recordings of your own band's or orchestra's rehearsals (phone or camera video, instrumental music, usually one to two hours each) and the list of pieces rehearsed, and returns a take log: one row per run through a piece or passage, with the piece, the take number, the start and end as MM:SS, the bar or rehearsal mark it started from, whether the conductor stopped it, the conductor's comments word for word before and after it, and an empty "next focus" column for the conductor to fill. Claude prices the indexing against the user's Vivu plan, indexes the recordings in a private Vivu project, runs one search for the band playing and one for the conductor saying where to start, draws a spectrogram of the sound with ffmpeg to mark each take, and writes take_log.csv and a note the conductor can send to the players.
The value is in what a transcript cannot show. Instrumental music has no words, so a transcript of a rehearsal is talk with gaps: nothing in it says how many times the band played, where each run began and stopped, or how long it lasted. A long rehearsal holds dozens of runs, most of them short, and nobody scrubs through that to find the one good take. The log gives players a time to jump to. The skill does not ask Vivu to recognize a piece from its sound, because that failed in our test run (the numbers are under Step 4). Piece names come from what the conductor says and from the user's list, and a take that cannot be named is marked UNCERTAIN for the conductor.
When to use
Use when a conductor, assistant conductor or band officer asks "make a list of what we played at rehearsal so the section can listen back", "find every time we ran the second movement and what I said after it", or "here are this week's rehearsal videos, I need timestamps for the players".
Not for these:
- Finding moments in public concert recordings or comparing performances by other groups. This skill works on your own rehearsals.
- A one to one lesson. The conductor's stop and restart pattern is what this skill follows, and a lesson has no ensemble takes to log.
- A concert or recital with a printed program and spoken announcements. There the announcements mark each piece, and a plain Vivu search for them is enough.
- Telling which piece is playing from the sound alone, or naming a piece nobody says aloud. Vivu does not do that reliably.
- Judging who played well. The skill never assesses a player or a section.
- A single question ("when did we run bar 62?"): search Vivu directly.
Working principles
- Report measured numbers, not estimates. When a number is an estimate, say so.
- A Vivu window is a candidate until the spectrogram shows the band playing there and the transcript shows what was said. Vivu's reason text paraphrases and repeats the words of the query, so it never fills a cell in the log.
- Report the takes actually found. If a take has no piece name, mark it UNCERTAIN and leave the conductor to name it. Do not fill it from the nearest take.
- Stop and tell the user when a required capability or tool is missing. Do not guess around it.
- Ask the user before anything that is expensive to redo (the indexing minutes, before upload) or that acts on their behalf (sharing the log with players).
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 recordings, cut out long breaks, draw spectrograms | ffmpeg -version, ffprobe -version |
| The rehearsal recordings as local files | Vivu indexes the upload, and the spectrograms come from the same copy, so the times match | ls "FOLDER" shows the files, where FOLDER is the folder holding REHEARSAL_FILES |
| A transcript of each recording: an .srt or .vtt, or a local speech to text tool such as whisper.cpp | the conductor's comments are copied from it word for word | an .srt or .vtt next to the video, or whisper-cli --help |
| The list of pieces rehearsed, with bar ranges if the user has them | piece names come from this list and from what the conductor says | the user pastes it |
| An upload path | move the recordings 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 local video files and runs ffmpeg. It downloads nothing from YouTube or other sites, so no residential IP is needed. Run it once per batch of rehearsals; it sets up no scheduler. The only connector it needs is Vivu.
Inputs to collect
Ask for anything missing, most important first.
- REHEARSAL_FILES: the recordings, in date order. Required.
- The pieces rehearsed, in the order worked if the user remembers, with bar numbers or rehearsal letters for movements. Required.
- The transcript files. Default: look for an .srt or .vtt next to each video; otherwise ask whether to run the local speech to text tool.
- BATCH_NAME: a short name for the working folder and the Vivu project. Default: the month and year, for example march-2026.
- Shortest take to log. Default: 10 seconds, so two bar drills stay out of the log.
Files and state
Keep everything in one working folder:
rehearsal-BATCH_NAME/
config.json pieces, bar ranges, Vivu project id, query wording
upload/ the recordings to index
transcripts/ one .srt or .vtt per recording
results/ one JSON per search, without the result page link
summaries/ Vivu section summaries per recording
strips/ spectrogram strips
take_log.csv the log: one row per take
members_note.txt the note for the players, draft only
state.json steps done, video ids, searches run with job ids, strips checked
Run every command from inside rehearsal-BATCH_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 strip already marked is not marked again, so an interrupted run picks up where it stopped and no take gets two rows.
Step 1: Check the Vivu connector and the setup
Goal: confirm every requirement before touching any file.
- 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. - Run
ffmpeg -versionandffprobe -version. If either is missing, say so and stop. - Check the rest of the What you need table. Say plainly what is missing.
Done when vivu_get_account shows can_create_projects: true, both ffmpeg commands print a version, and the recordings, transcripts and piece list are in hand.
Step 2: Measure the rehearsal and price the run
Goal: the user sees what indexing and searching will use before anything is uploaded.
- Measure each recording (FILE is the path):
ffprobe -v error -show_entries format=duration -of csv=p=0 "FILE"
- Find long breaks, which cost index minutes and hold no takes. This writes each silence of 30 seconds or longer to a file (a coffee break with people chatting will not show as silence, so also ask the user when the break was):
ffmpeg -hide_banner -v error -i "FILE" -vn -af "silencedetect=noise=-35dB:d=30,ametadata=mode=print:key=lavfi.silence_start:file=breaks.txt" -f null -
- Cut a long break out only with the user's agreement. Copy each part into upload/ with a name that says which part it is, and record the offset of each part in config.json so times can be read back against the original file (START and END in seconds; DATE is the rehearsal date as YYYY-MM-DD):
ffmpeg -v error -ss START -to END -i "FILE" -c:v libx264 -c:a aac "upload/DATE_part1.mp4"
- Copy a recording with no break to cut into upload/ unchanged, so every file Step 5 reads is in upload/:
cp "FILE" "upload/DATE.mp4"
- Count the searches: two precise searches for the batch, plus at most one reworded search for each. A precise search uses 5 credits in total. This skill uses only precise searches, because only precise returns a time range.
- Call vivu_get_usage and show one table:
| This batch | 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 single rehearsal does not fit the Free plan. 7. If the batch does not fit, offer these levers in order: index only the rehearsal the players need first, index only the part of each rehearsal with the pieces the user cares about (ask which), and only then move to a larger plan. Never drop part of a rehearsal without telling the user which pieces that leaves out.
The break cut and the durations ran in our test run, on a recording with no long break inside it. The cost table and the user's approval were not exercised in our test run.
Done when the user has approved the minutes and credits in the table.
Step 3: Create the project and upload
Goal: the recordings are ready in a private Vivu project.
- Ask the user to confirm the points in Compliance (everyone agreed to being recorded, guardian consent for minors). Do not upload before they confirm.
- Call vivu_list_projects and reuse a project named "Rehearsals BATCH_NAME" if it exists. Otherwise call vivu_create_project with that name and visibility "private". The default visibility is the whole organization, and a rehearsal shows the players, so private is the right choice. Record the project ID in config.json.
- 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 files 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 rehearsal is far larger, so in practice the user adds the files through the upload page in their own browser or the Vivu web app. Do not split or recompress files to fit.
- Poll vivu_list_videos every 30 seconds or so until every file shows status ready. A pending status is not an error. Vivu replaces spaces and punctuation in file names with underscores, so match each video back by the name with those characters replaced, and record video_id in state.json.
Our test run uploaded through a script, so the upload page in a user's browser was not exercised in our test run.
Done when vivu_list_videos shows every file as ready and every video_id is in state.json.
Step 4: Run the searches
Goal: two saved searches and the section summaries for every recording.
The standing queries, one per output field:
| Field | Query | Mode | maximum_results |
|---|---|---|---|
| take candidates | the whole band is playing music together while the conductor beats time, nobody is talking to the group | precise | 40 |
| from_mark, piece | the conductor stops talking to the players and tells them where to start from: says a bar number or rehearsal mark such as "from 62" or "let's go again at 140", or names the next piece | precise | 40 |
The chain: the first search says roughly when the band was playing, and Step 5 checks and extends that on the spectrogram, because it misses takes. The second flips from what is heard to what is said: the conductor's own words say which bar a take started from and which piece it belongs to. fast mode is not used, because it returns whole files with no time range.
Finding talk works well in Vivu. Finding that a band is playing is usable but misses takes. In our test run the camera showed the conductor beating time, and the query names that, so the search may have matched the picture rather than the sound; with the conductor out of frame expect it to do worse. Telling one piece from another by its sound failed. So do not add a search that describes a piece by tempo, instruments or mood, and do not put a piece name on a take because a reason text sounds right. Audio performance search is otherwise untested beyond this one rehearsal, so every take rests on the spectrogram and the transcript, and the conductor checks the log.
- Call vivu_search_videos with project_id, the first query, mode "precise" and maximum_results 40. A rehearsal has many takes, so forty leaves room for them; it is also the most windows a search can return, so raise it toward 100 for a batch of several rehearsals, and do not treat the result as complete.
- 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.
- Do the same for the second query. If it finds fewer than half the restarts you can see in the transcript, reword it once with the words this conductor really uses, for example the language they rehearse in.
- Save the results array of the first search to results/playing.json and of the second to results/marks.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 log, the note or any file.
- For every video, call vivu_get_video_summary with include_segments true and save the sections to summaries/. Section titles often name the piece being worked, which gives a time range for each piece. Treat them as a lead: read the numbers against the transcript.
Worked example from our test run
In our test run we used one public working rehearsal of a video game music orchestra (a stream with a wide fixed camera, French speaking conductor on a close mic), cut into 2 files, 39.95 minutes in total, with three program entries: two movements of one medley with the same instruments, and a soft orchestral piece. Before searching we wrote down 21 takes of 10 seconds or longer and 22 spoken marks. Both files were ready about 10 minutes after the upload started. All numbers below come from that one small corpus.
The first test was the idea this skill started from: one search per piece, described by its sound. It failed. Across those queries the search returned 49 windows, 23 real and 26 false, 53% false. One rewording of each on the same corpus did not help: the fast movement got 8 real and 6 false and missed 7 of 13 takes, the second movement 2 real and 3 false, the soft piece 2 real and 14 false. Windows on the wrong piece, windows on pure talk, and windows on the silent gaps between takes all came back with a reason that repeated the query words. A control search for a Viennese waltz or a piano nocturne, which the rehearsal does not contain, returned 2 windows, both false, both with reasons saying that music was playing.
The searches in the table were not reworded. The search for the band playing returned 18 windows, 16 real and 2 false, and found 14 of the 21 takes; the 7 it missed were mostly short. It was written after we saw the piece searches fail, so its wording is not a blind test. Windows were 17 seconds wide at the median, shorter than some takes, so a window never gives a take's start or end. The search for spoken marks, in English against French speech, returned 15 windows, 12 real and 3 false under a strict rule written before the search, and found 12 of the 22 marks; two of the 3 false windows held a real instruction we had left off the list. Windows were 13 seconds wide at the median. The run used 10 precise searches, 50 credits (estimate).
Done when results/playing.json and results/marks.json exist, their job IDs are in state.json, and every video has a file in summaries/.
Step 5: Mark every take on the spectrogram
Goal: a start and end for every take, checked on the sound itself.
Loudness is the obvious way to split playing from talk, and it works only when the conductor is far from the microphone. In our test run the conductor wore a close mic and speech sat at the level of the full band, so loudness could not split them. A spectrogram can: the band is a solid block with horizontal lines, and talk is a row of short stacked curves with dark gaps. Soft passages are the exception: thin lines low in the strip, easy to miss.
- Draw one strip per five minutes (START in seconds, NAME the file name in upload/ without .mp4). The image has a time ruler in seconds from the start of the strip:
ffmpeg -hide_banner -v error -ss START -t 300 -i "upload/NAME.mp4" -vn -lavfi "aformat=channel_layouts=mono:sample_rates=12000,showspectrumpic=s=1800x240:legend=1:color=intensity:scale=log:gain=2" -frames:v 1 "strips/NAME_START.png"
- Look at each strip. Write down every block of playing as a start and an end, adding START to the ruler. Read the transcript beside it: a count in ("et 3 et", "one two") just before a block, and "thank you" or a comment just after it. Keep blocks at least as long as the shortest take from Inputs.
- Compare with the take candidates from Step 4. A Vivu window on a strip with no block is a false window: count it and say so. A block with no Vivu window is still a take; the search misses takes. Where the two disagree on a soft passage, redraw it with
stop=2500andgain=4added to showspectrumpic, and mark what you still cannot settle as UNCERTAIN. - Set stopped_early. A take that breaks off with talk within a few seconds was stopped by the conductor. A take that dies away, or that the conductor said would run to the end, is a full run. If the two look the same, ask the conductor.
Done when every strip is marked in state.json and every take has a start, an end and a stopped_early value, or UNCERTAIN.
Step 6: Name the piece and pull the comments
Goal: every take has a piece or an UNCERTAIN mark, and the comments are copied word for word.
- Find the mark for each take: the last spoken bar number or rehearsal letter before its count in. Start with the mark windows from Step 4, then search the transcript for numbers between takes, because the search finds only some of them. Read each window in the transcript from 10 seconds before it to 10 seconds after. A window with no mark in the transcript is false, even when the reason says one was called. Automatic transcripts write numbers and music words badly, so a mark that looks wrong stays UNCERTAIN.
- Give each take a piece, strongest evidence first: the conductor names the piece just before it; the bar number falls in a range from the user's list; a section title from Step 4 covers it, after you confirm that against the transcript; the takes on either side are the same piece and nothing in between says it changed. If none holds, the piece is UNCERTAIN.
- Copy comment_before (the last instruction before the count in) and comment_after (the first comment after the stop) from the transcript. Never use the reason text or a section summary for these. Automatic captions garble music words, so keep the line as written and let the conductor fix it.
The conductor named every piece aloud in our test run, and the takes were few enough to check by hand, so step 2 has only been tried on an easy case.
Done when every row has a piece or UNCERTAIN, a from_mark or a blank, and comments that appear word for word in the transcript.
Step 7: Write the take log and review it with the conductor
Goal: a log the conductor has checked, before any player sees it.
- Show the user one sample row and the field mapping before writing the rest:
piece,take,file,start_mmss,end_mmss,from_mark,stopped_early,comment_before,comment_after,next_focus,evidence
Movement 1,4,part1.mp4,06:26,06:50,bar 62,yes,"Partons ca 62 encore","Le shake doit vraiment ressortir",,strip + transcript + vivu playing + vivu mark
| Field | Source | If unavailable |
|---|---|---|
| piece | Step 6 | UNCERTAIN |
| take | count of takes of that piece, in time order | none |
| file, start_mmss, end_mmss | Step 5 strip, plus the offset from Step 2 if the file was cut | UNCERTAIN |
| from_mark | Step 6 | blank |
| stopped_early | Step 5 | UNCERTAIN |
| comment_before, comment_after | the transcript, verbatim | blank |
| next_focus | left empty for the conductor | none |
| evidence | which checks support the row | none |
- Write take_log.csv, sorted by file and time, then a draft of members_note.txt with the takes the conductor might want heard, as times in each file. The file name and MM:SS are the durable reference; a Vivu result page link would expire.
- Give the user the log and the count of false Vivu windows with what each one held, and point out every UNCERTAIN row. If the log has fewer takes than the conductor remembers, report the real number and ask which part of the rehearsal to redraw. Do not add rows from memory.
- The conductor fills next_focus and decides which takes go to the players. Sending the note to a group chat, an email list or a shared drive acts as the user, so show the destination and the rendered note and wait for a clear yes. By default the conductor sends it.
In our test run take_log.csv and the note were rendered locally with 21 rows; no conductor reviewed them and sharing was not exercised in our test run.
Done when the user has the log, has seen the count of false windows, and has confirmed or corrected every UNCERTAIN row.
Compliance
- Only your own group's rehearsals, recorded with the group's agreement. Ask the user to confirm before Step 3 that everyone in the room knew about the recording and agreed to it being uploaded to a cloud service.
- Minors. If anyone under 18 plays in the group, the user confirms before Step 3 that a parent or guardian agreed in writing. Without that, do not upload.
- The recording is for listening back inside the group. Do not publish it or the takes: arrangements under copyright may need a license for public use, and the players did not agree to it.
- The skill does not recognize faces or name who is playing, and it does not judge, rank or comment on a player or section. The comments in the log are the conductor's own words; if a comment names a player, ask the conductor whether to keep it before the log is shared.
- The videos stay in the Vivu project in the user's account until the user deletes them. The project is created private. Claude never deletes a project or a video unless the user asks, and confirms first.
Known failure modes
| Symptom | Cause | Fix |
|---|---|---|
| (observed) searches for a piece by its sound come back on another piece; first wording 26 false of 49 | same band, same instruments, and the reason text repeats the query | do not search by sound; name pieces from speech and the list in Step 6 |
| (observed) a search for music that is not there returns windows: "performs a Viennese waltz in triple meter" | the reason describes the query, not the sound | never use a reason as evidence; an answer from search does not prove that music was played |
| (observed) a window on pure talk says the band is playing: "plays a fast, rhythmic piece"; the playing search had 2 false of 18 | cause not known; the band is on camera the whole time | check every window on the strip; no block means false |
| (observed) the playing search misses takes: 7 of 21 | short takes and limited results | mark takes from strips; treat the search as a cross check |
| (observed) a window reason says a mark was called but the transcript has none: "calls out the rehearsal mark" | the mark came just before the window | read the transcript around the window; it stays blank if no mark is there |
| (observed) the spoken mark search finds some marks only: 10 of 22 missed | conductors give marks quickly and in passing | search the transcript for numbers between takes |
| (observed) a section summary reads a bar number as a speed: "at a tempo of 140 BPM" | section summaries paraphrase | read numbers from the transcript only |
| (observed) loudness cannot split talk from playing: "speech and band at the same level on per second RMS" | the conductor is on a close mic | use the spectrogram strips in Step 5 |
| no search returns anywhere near maximum_results | the search keeps only what it ranks as a match, and it is also a ceiling | do not read a short list as the full count of takes |
| a very soft take does not show on a strip | little energy high in the strip | redraw with stop and gain as in Step 5, or mark it UNCERTAIN |
| 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 file in the Vivu web app; do not split or recompress it to fit |
| a result's file name does not match the local file | Vivu replaced spaces and punctuation with underscores | match on the name with those characters replaced |
| log times are off against the original file | the part was cut in Step 2 | add the part's offset from config.json |
| the allowance runs out partway | the batch is longer than the plan covers | apply the Step 2 levers, or move to a larger plan |