---
name: broadcast-pause-log
description: "Turn your own tournament broadcast recording into a technical pause log with Vivu: start, end, duration, on screen card and caster reason per pause. Use for post event reviews."
---Technical pause log from tournament broadcasts
This skill takes the parts of a match day broadcast that the user's own organization recorded and where the referee log or schedule says play stopped, and returns a pause log for the post event review. Claude prices the segments against the user's Vivu plan, indexes them in a private Vivu project, runs one precise search for the broadcast's pause screen, one for the casters calling the pause and one for the casters announcing the resume, checks every window against frames or the transcript, sets each pause's start and end from contact sheets of the recording, reads the pause card text off a full frame, and writes a CSV with one row per pause. Tournament operations fills in the official reason.
The duration and what viewers saw are what a referee log does not hold. It says "pause in game 2", not that play stopped for seven minutes or that the card read "OFFICIALS INVESTIGATING HARDWARE ISSUE". A transcript hears "we have a pause", but casters often say it after the freeze and rarely say when play resumes, and a planned break, an ad block or the analyst desk is also time without play. The broadcast shows the difference on screen: a greyed out game, player cams under a pause banner, then the first moving gameplay frame. Vivu narrows a long recording to a few windows inside each pause, Claude steps out from them frame by frame, and nothing reaches the log until a frame shows it.
When to use
Use when a tournament admin, league operations lead or broadcast producer says "how long were the pauses in yesterday's final?", "log every tech pause in this broadcast for the post event review", "what card was on screen during the second pause?" or "match our pause times against the referee log".
Not for these:
- Whole match days uploaded in one piece. They usually exceed a monthly plan; cut the games the referee log names (Step 2).
- VOD chapters for map starts and scores: use the tournament-map-chapter-sheet skill.
- Deciding who caused a pause, rating players, referees or crew, or live monitoring during the event. This skill records what the broadcast showed.
- A broadcast the user's organization does not own, or someone else's channel.
- A one off question about one moment in one video: search Vivu directly.
Working principles
- Report measured numbers, not estimates. When a number is an estimate, say so.
- Nothing is verified until it has been checked against the source. A Vivu window is a candidate until a frame inside it shows the pause screen or the transcript has the casters on the pause. Start, end and duration come from contact sheets, never from the window, because a window covers a slice of a pause.
- 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 (indexing the segments) and before anything that acts on their behalf (sharing the log; show the rendered text first).
- Report the real count. A pause in the referee log that the broadcast does not show stays in the log as NOT FOUND, so ops sees the gap instead of a guessed time.
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 on the user's computer with ffmpeg and ffprobe | measure the recording, cut segments, cut frames and contact sheets | ffmpeg -version, ffprobe -version |
| The broadcast recording as a local file, from the organization's own production | it is uploaded to Vivu and the frames come from it | ffprobe -v error -show_entries format=duration -of csv=p=0 RECORDING prints a duration |
| The referee log or schedule for the day | it names the games with pauses, so only those are indexed | the user pastes it |
| A timestamped transcript (.vtt or .srt), optional: a captioning file, or a local speech to text tool such as whisper.cpp | supplies the caster_reason column; without it that column comes from Vivu summary segments and is marked NOT VERIFIED | grep -c " --> " TRANSCRIPT prints a count above zero |
| An upload path | move the segments 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. Claude on the web and cloud sessions cannot reach the files. It downloads nothing, so it needs no residential IP. Nothing recurs, so no scheduler is involved; run it again after the next event.
Inputs to collect
Ask for anything missing, most important first.
- RECORDING: the local broadcast file. Required.
- REF_LOG: the referee log or schedule lines for games with pauses. Required; without it the whole day would have to be indexed.
- EVENT_NAME: a short name for the working folder and the Vivu project. Default: EVENT-DATE.
- TEAM_NAMES: the team tags the pause banner may show. Default: none; the card text is read from frames.
- TRANSCRIPT: a timestamped transcript. Default: none; caster_reason is NOT VERIFIED.
- LOG_OFFSET: seconds to add to every time so the log matches the referee log clock or the posted VOD. Default: 0.
Files and state
Keep everything in one working folder:
pauses-EVENT_NAME/
config.json event, referee log lines, recording, segment cuts and offsets, Vivu project id
video/ one file per indexed segment (.mp4)
subs/ the transcript, if there is one
results/ search results as JSON, without the result page link
frames/ frames cut inside each window and at each boundary
sheets/ contact sheets
candidates.csv every window Vivu returned, what the frame or transcript showed, and the label
pause_log.csv one row per pause
state.json steps done, video_ids, job ids, windows checked, boundaries set, share status
Run the commands from inside pauses-EVENT_NAME/ so the relative paths resolve.
A rerun reads state.json first and skips finished steps: a segment marked uploaded is not uploaded again, a search with a saved result is not run again, a window with a label is not checked again, and a log marked shared is not shared again.
Step 1: Check the Vivu connector and the setup
Goal: confirm every requirement before spending anything.
- Call vivu_get_account. If the tool does not exist, tell the user to add the Vivu connector in Claude (
https://mcp.vivu.ai/mcp) and stop. If the account does not showcan_create_projects: true, 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, then create the folders:mkdir -p pauses-EVENT_NAME/video pauses-EVENT_NAME/subs pauses-EVENT_NAME/results pauses-EVENT_NAME/frames pauses-EVENT_NAME/sheets. - Ask for the recording and the referee log if they are not in the request. Ask whether any player is a minor (Compliance).
In our test run vivu_get_account returned can_create_projects: true, and ffmpeg and ffprobe ran in the later steps. Our test recording had adult professional players, so the minors question did not apply.
Done when vivu_get_account shows can_create_projects: true, both tools print their versions, and the user has given the recording and the referee log and answered the minors question.
Step 2: Pick the segments and look at the pause graphics
Goal: one file per game with a logged pause, and proof of how this production shows a pause.
- Measure the file:
ffprobe -v error -show_entries format=duration -of csv=p=0 RECORDING. - For each game the referee log marks with a pause, pick a range from the schedule with generous margins and check its edges with a one frame per minute sheet:
ffmpeg -v error -i RECORDING -vf "fps=1/60,scale=240:-1,tile=8x6" -q:v 3 sheets/day_%02d.png
Cut without re-encoding (START and END are HH:MM:SS, GAME names the file):
ffmpeg -v error -ss START -to END -i RECORDING -c copy video/GAME.mp4
Record START in config.json so log times can be added back. Stream copy cuts on keyframes, so measure the offset from a frame when a time must line up with the referee log.
- Build a ten second overview of each segment and look at it. It shows how this production marks a pause (a greyed out game, player cams, a banner and its second line) and what fills long pauses (stage shots, packages, stat cards):
ffmpeg -v error -i video/GAME.mp4 -vf "fps=1/10,scale=240:-1,tile=8x8" -q:v 3 sheets/overview_GAME_%02d.png
If the production shows no pause banner at all, tell the user the pause_screen search rests on the look of the frozen game and player cams alone, which was not tested.
In our test run the segments came from a public full day broadcast and were cut at download time, so cutting with ffmpeg from a local match day file was not exercised in our test run. The overview showed this production's pause look: the game frame turns grey, the broadcast cuts to player cams, and a banner in the top left reads GAME PAUSE with the team tag and a second line such as OFFICIALS INVESTIGATING, RESTARTING PC or VERIFYING AUDIO SETTINGS. Long pauses were filled with stage shots, a fan message package, stat cards and a replay of the last fight.
Done when video/ holds one file per game with a logged pause and the user has seen which pause graphics this production uses.
Step 3: Price, upload and index
Goal: the segments indexed in a private Vivu project, with the user's approval of the cost.
- Call vivu_get_usage and show one table:
| These segments | Plan allowance | Remaining this month | |
|---|---|---|---|
| Index minutes | total duration / 60 | from vivu_get_usage | from vivu_get_usage |
| Search credits | 15 for the three searches in Step 4 (estimate) | from vivu_get_usage | from vivu_get_usage |
Plan facts: Free is $0 a month with 20 index minutes a month and 50 search credits a month; Premium is $30 a month with 180 index minutes and 500 search credits. A precise search uses 5 credits in total. A match day of six to eight hours is more than a Premium month by itself, which is why this skill indexes only the games with pauses.
- If the segments do not fit, offer levers in this order: index only the games the referee log marks, trim each game to the stretch around the logged pause time with margins on both sides (record each cut so times can be added back), then move to a larger plan. Never drop a logged pause without telling the user which one, and never recompress a file to save minutes.
- Wait for the user to approve the index minutes and credits before you create a project or upload. In the same message confirm that the organization owns or may index this recording and that its participant and broadcast terms allow it to go to a third party processor (Compliance 1 and 3).
- Call vivu_list_projects and reuse a project named "Pauses EVENT_NAME" if one exists; otherwise call vivu_create_project with that name and visibility "private". The default visibility is organization, which shows the project to everyone in the user's Vivu organization.
- Call vivu_open_upload_page with the project ID immediately before uploading. The link expires in 180 seconds and works once, so never post or store it. Give it to the user to open in their own browser and select the files, 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 broadcast segment is far larger, so it normally goes through the user's own browser or the Vivu web app. Never split or recompress a file to fit.
- Poll vivu_list_videos until every file shows ready. Vivu replaces spaces and punctuation in file names with underscores; keep segment names simple and match on them. Record each video_id in state.json.
In our test run the 52.0 minute segment was ready about 22 minutes after the upload started (an upper bound, measured from polls). The account used in our test run returns no allowance figures, so the plan comparison and the user's approval were not exercised in our test run, and the files went through the upload page with an automated browser, so opening the link in the user's own browser was not exercised in our test run.
Done when the user approved the cost and the rights before the upload, and every segment shows ready with a video_id in state.json.
Step 4: Search for pause screens, caster calls and resumes
Goal: saved lists of candidate windows inside each pause and at each resume.
Run these in precise mode on the whole project. Precise is the only mode that returns a time window; fast returns the whole file with an empty reason, which says nothing inside a recording. The chain: the pause_screen search finds windows inside each pause, on screen; the pause_called search flips from what is shown to what is said, confirms that a stretch without play is a pause and not a planned break, and gives the casters' reason; the pause_resume search gives a short window on the resume line, which is where Step 6 looks for the first moving gameplay frame.
| Field | Query | Mode | maximum_results |
|---|---|---|---|
| pause_screen | a technical pause: live play has stopped and the broadcast shows the players waiting at their desks or a frozen, greyed out game screen, with a GAME PAUSE banner in the top left corner | precise | 20 |
| pause_called | the casters say the game has been paused and talk about why play has stopped and when it might resume | precise | 20 |
| pause_resume | the casters say the pause is over and the game is about to resume | precise | 20 |
Adapt pause_screen to what the Step 2 overview shows: name the banner text and where it sits. We wrote it after seeing our test production's banner, so on a production with a different pause look, describe that look instead and treat the search as untested until the Step 5 frames show it working. None of the wordings above was reworded on our test corpus.
maximum_results is the ceiling on how many windows come back, so it is also the most pause slices a search can find. 20 leaves room for several windows on one long pause; raise it for a long day with many pauses.
For each search, run vivu_search_videos (project_id, query, mode "precise", maximum_results 20). It returns a job ID; call vivu_get_search_results until complete is true. Each status call can wait up to 45 seconds, so a pending search is not a stalled one. Save the results to results/FIELD.json without the result page link, and show the result page link only in the live reply: it expires after four hours, so it never goes into the log.
Done when results/pause_screen.json, results/pause_called.json and results/pause_resume.json exist and their job ids are in state.json.
Step 5: Check every window
Goal: each window labeled, and each pause tied to at least one checked window.
- For each pause_screen window, cut frames at the start, middle and end (start_ms, the midpoint and end_ms converted to seconds) and look at all three (SECONDS is the second to cut, NAME names the window):
ffmpeg -v error -ss SECONDS -i video/GAME.mp4 -frames:v 1 -q:v 3 frames/NAME.png
- A pause_screen window counts when a frame shows the pause: a greyed out game, or player cams, stage shots or filler under the pause banner. Live play, a planned break, an ad block, the analyst desk or a replay during live play does not count. A later window on a pause already found is labeled "duplicate"; it still helps Step 6 as an anchor.
- Read each pause_called and pause_resume window in the transcript. Without a transcript, read the summary segments for the window with vivu_get_video_summary (include_segments, start_ms and end_ms around the window). The reason text is a paraphrase, not a transcript, so the caster_reason column quotes the transcript, briefly.
- Group windows into pauses: windows on the same pause sit inside one stretch without live play. A pause_called window with no pause_screen window near it is a pause the screen search missed; check its frames the same way.
- Write every window to candidates.csv with the label, what the frame or transcript showed and Vivu's reason. The reason never decides the label. Count false windows and tell the user.
Worked example from our test run
The test corpus was 2 videos, 59.5 minutes, from a public full day broadcast on a professional esports league's official channel, with adult professional players: a 52.0 minute segment holding one game with four technical pauses on one team's side, and a 7.5 minute planned break between games (analyst desk, an ad block, a countdown screen and player cams before the next game) as a distractor. It stands in for an organizer's own recording. Before searching we wrote each pause's start and end from contact sheets and captions, plus the rule that a window counts when it overlaps a pause and a frame shows it. This is four pauses from one production and one game title, so treat every number below as one small sample.
The pause_screen search returned 15 windows, 15 real and 0 false, with 0 missed: every one of the 4 pauses had at least one window, and 11 windows were duplicates on a pause already found. Nothing came back from the planned break, the ads, the analyst desk, the pre game player cams or a replay during live play. The typical window was 34 seconds wide, a slice of a pause that ran several minutes; a single window started at a pause start and another ended at a resume. Player cams before the next game, without the banner, did not come back, so the banner text likely carried this search; Vivu's reading of a frozen game or a waiting player on its own is a weaker signal (visual meaning is rated weak in our tests), which is why every window is checked in frames.
The pause_called search returned 7 windows, 7 real and 0 false, covering all 4 pauses with 0 missed. A single window sat on the casters' first line at the freeze; the rest were updates minutes into a pause. The pause_resume search returned 4 windows, 3 real and 1 false, with 1 missed: the false one was an update that the issue was almost resolved, and the resume after it was the one missed. A control search for a postponement that never happened returned 0 windows. A vivu_get_video_summary call on the first pause had segments titled as a pause and a resume that matched the contact sheets.
Done when every window has a label in candidates.csv and every pause found has at least one checked window.
Step 6: Set the start and end of each pause
Goal: a start and an end second for every pause, from frames.
- Start: from the earliest checked window of a pause (or the pause_called window at the freeze), step back with a ten second sheet until live play shows, then cut a half second sheet across the change (START_S is the first second, LENGTH the seconds covered):
ffmpeg -v error -ss START_S -t LENGTH -i video/GAME.mp4 -vf "fps=2,scale=320:-1,tile=8x4" -q:v 3 sheets/NAME_%02d.png
The start is the first frame where the game is frozen or greyed out. If the broadcast cuts away from live play (to a replay) and the game is next shown paused, the start is the cut; note the first paused frame in the row. 2. End: from the pause_resume window, or the latest checked window, step forward the same way. The end is the first frame of moving gameplay. A few seconds of play followed by another freeze is a new pause; give it its own row. 3. duration_s is end minus start. Read card_text from a full frame of the banner, every distinct second line in order.
In our test run we stepped out from the windows for the last pause's end and the second pause's start, and the half second sheets put both within a few seconds of our truth sheets; the other boundaries came from the same truth sheets, so they were not set independently.
Done when every pause has a start and an end second set from a half second sheet, or NOT FOUND.
Step 7: Write the pause log and check it with the user
Goal: pause_log.csv, checked before anything is shared.
- Show one sample row and the field mapping, and wait for a yes before writing the rest:
seq,game,file,pause_start,pause_end,duration_s,card_text,caster_reason,start_frame,end_frame,start_source,end_source,ops_reason
1,Game 2,GAME.mp4,05:20,12:24,424,"GAME PAUSE TEAM / OFFICIALS INVESTIGATING","hardware issue on the TEAM side",frames/p1_start.png,sheets/p1_end_01.png,half second sheet,half second sheet,
| Field | Source | If unavailable |
|---|---|---|
| seq, game, file | order of play, the referee log, the segment file name | none |
| pause_start, pause_end | half second sheet, plus LOG_OFFSET | NOT FOUND |
| duration_s | pause_end minus pause_start | blank |
| card_text | full frame of the banner | NONE if no banner |
| caster_reason | the transcript, a short quote | NOT VERIFIED |
| start_frame, end_frame | the frames that were read | blank |
| start_source, end_source | which sheet set the time | none |
| ops_reason | left blank for tournament operations | blank |
- Write pause_log.csv in order of play. Add a row with NOT FOUND for every pause in the referee log that no window or sheet found. Do not include player names.
- Tell the user the counts: pauses found, NOT FOUND, windows labeled false, duplicate windows, and boundaries set from a half second sheet.
In our test run the log has 4 rows and no NOT FOUND, the standing searches came to 15 credits (estimate), and the user's approval of the sample row was not exercised in our test run.
Done when pause_log.csv exists with one row per pause, the user has approved the sample row, and the counts are reported.
Step 8: Hand the log to ops
Goal: the approved log in the ops team's review document, shared once.
- Name the destination (a shared drive, the review doc, a ticket) and show the full rendered table. Writing there acts as the user, so wait for an explicit yes. When no connected tool can write to the destination, give the user the file.
- Use times in the recording or the referee log clock, never a Vivu result page link (it expires after four hours) or a local file path the team cannot open.
- Record the share in state.json so a rerun does not share it again.
Sharing was not exercised in our test run; Step 8 rendered the review table as a file and shared nothing.
Done when the user has approved the rendered table and it is in the named place, or the user has the file, and state.json records which.
Compliance
- Use only recordings the user's organization produced or has the right to index; do not pull a live platform link or someone else's channel. Confirm before Step 3.
- Campus and youth leagues can include minors. Uploading a recording of minors needs guardian consent; without it, this skill does not run on that recording. Ask before Step 3.
- Casters, players, officials and audience are on camera. Confirm the organization's participant and broadcast terms allow the recording to go to a third party processor before Step 3.
- The log records what the broadcast showed. It does not decide who caused a pause, does not rate players, referees or crew, does not name players and does not identify anyone from faces or logos. The ops_reason column is for tournament operations.
- The recording stays in the user's Vivu project until the user deletes it. The project is created private because the default visibility shows it to the whole Vivu organization. Delete a project or video only when the user asks, and confirm first.
- Sharing the log acts as the user and needs an approved rendering first (Step 8).
Known failure modes
| Symptom | Cause | Fix |
|---|---|---|
| (observed) every pause has windows, but no window covers a whole pause | a window is a slice of a pause, and long pauses get several short windows | set start and end from sheets (Step 6); never add up window lengths |
| (observed) a resume window sits on an update that the issue is "almost resolved", and play resumes later | casters say the fix is close before it is done | step forward from the window until moving gameplay shows |
| (observed) most caster windows land minutes into a pause | casters give updates during the pause more often than they call the freeze | use caster windows to confirm and explain a pause, not to set its start |
| (observed) the broadcast cuts to a replay and the game is next shown paused | the production covered the freeze with a replay | start the pause at the cut and note the first paused frame |
| (observed) the reason text says more than the window's words, "reporting an inability to purchase items" | reason text paraphrases | quote caster_reason from the transcript |
| a planned break or ad block is taken for a pause | both are stretches without play | a pause has the pause banner or a frozen game; a break has a countdown, ads or the desk |
| a pause with no banner is missed | the screen search leans on the banner | read pause_called windows and check their frames |
| empty search on a new production | its pause look differs from the wording | adapt the wording to the Step 2 overview; an empty result does not prove there was no pause |
| 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 |
| the recording is rejected by the browser upload tool | Claude in Chrome accepts at most 10 MB per upload call | the user opens the upload link in their own browser or adds the file in the Vivu web app |
| "has not granted vivu.write" | Vivu connected read only | the user reconnects Vivu with write access |