---
name: session-recording-trim-sheet
description: "Check a conference track's session recordings with Vivu before they go on demand: trim points, off the record remarks and screen shares that jump to email or chat, in one trim sheet."
---Pre-publish trim sheet for session recordings
This skill turns a folder of breakout session recordings (one mp4 per session, exported by the AV crew or the meeting tool) into a trim sheet for the editor and the speakers. Claude measures the recordings, prices them against the user's Vivu plan, indexes them in a private Vivu project, runs five standing searches (where the talk starts, where it ends, where the speaker asks the room not to share something, where the screen share leaves the slides for an inbox, a chat app or the desktop, and where a pop-up notification appears over a slide), checks every hit on frames and the local transcript, and writes trim_sheet.csv: a suggested in point and out point per session, plus one row per flagged moment with time range, frame, the words said and an empty "action" column (cut, blur or keep) for the speaker to fill in.
The value is in what the transcript does not show. While the speaker keeps talking about the slide, the screen share can sit on their inbox with subject lines readable, or a chat notification can slide in over the slide; a transcript reads as a clean talk. The first title slide after a waiting screen and a sound check is also a picture, not a sentence. Every row on the sheet has been looked at on a frame or read in the transcript before it is written, and the screen share search, the weakest one, is backed by a contact sheet of the whole talk so a missed switch can still be caught by eye.
When to use
Use when an event or webinar producer says "check the breakout recordings before we post them", "find where each session starts and ends so we can trim the waiting screens", "did anyone share their inbox or Slack during the talks?", or "make a trim list for the editor and the speakers". For a single question about one recording ("where does she talk about pricing?"), search Vivu directly instead. For picking highlight clips for social or a recap, use a selects workflow; this skill finds what to cut, not what to show.
Working principles
- Report measured numbers, not estimates. When a number is an estimate, say so.
- Nothing goes on the sheet as a flag until it has been checked against the frames or the local transcript. Everything else stays a candidate, labeled as one.
- Stop and tell the user when a required capability or file is missing (no transcript, no ffmpeg, no write access in Vivu). Do not guess around it.
- Ask the user before anything that is expensive to redo or that acts on their behalf: the indexing cost before upload, the sample rows before the full sheet.
- Claude suggests; the speaker and the event team decide. The action column stays empty until a person fills it.
- Describe a private window by kind ("mail inbox with subject lines visible"), never copy its content into the sheet.
What you need before starting
Check each item at the start of the run and tell the user plainly what is missing.
| 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 connection is read only; the user reconnects Vivu and allows write access |
| A shell with ffmpeg and ffprobe on the machine that holds the recordings | measure minutes, extract frames, build contact sheets | ffmpeg -version and ffprobe -version |
| The session recordings on local disk, one mp4 per session | frames and the trim points come from the originals; Vivu has no export tool | ls RECORDINGS_FOLDER |
| A transcript with timestamps (VTT or SRT) per recording | quotes on the sheet come from it, never from Vivu's reason text | ls RECORDINGS_FOLDER for one .vtt or .srt per .mp4; the meeting tool's transcript export or any local speech to text tool can make it |
| The speakers' slide files as PDF, and pdftotext, when the user wants footer labels checked | "Confidential" footers are small text that Vivu reads unreliably, so the skill checks the slide files instead | ls SLIDES_FOLDER and pdftotext -v; without them the footer check is skipped and the sheet says so |
| A browser that can open the Vivu upload page | the connector has no direct upload tool | the user opens the link, or Claude in Chrome is connected |
No residential IP is needed (nothing is downloaded from YouTube) and nothing is scheduled.
Inputs to collect
Ask for anything missing, most important first.
- The recordings folder and the track or event name. Required.
- Which sessions go on demand. Default: every mp4 in the folder.
- The slide files folder. Default: none, and the footer check is skipped.
- Extra private window kinds to look for (a CRM, a password manager, a calendar). Default: email, chat, desktop and pop-up notifications.
- The Vivu project name. Default: "EVENT_NAME pre-publish check", private.
Files and state
Keep everything in one working folder next to the recordings:
trim-check/
config.json event name, session list, vivu project id, standing queries
sessions.csv one row per recording: file, duration seconds, vivu video id
results/ raw search results, one JSON file per query
frames/ extracted frames and contact sheets
trim_sheet.csv the sheet
state.json uploaded files and video ids, queries run with job ids, hits checked with verdicts, rows written
state.json is updated after every step. A rerun reads it first: recordings already uploaded are not uploaded again, queries already run are not rerun, and hits already checked keep their verdicts, so an interrupted run picks up where it stopped and no moment is written twice.
Step 1: Check the Vivu connector and the setup
Goal: every row of What you need is confirmed before anything is uploaded.
- 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 can_create_projects is not true, or a write call later fails with "has not granted vivu.write", ask the user to reconnect Vivu with write access and stop until they have.
- Run ffmpeg -version and ffprobe -version. List the recordings folder and match each mp4 to its transcript.
- Rename files to letters, digits and "" only (for example track2_session_a.mp4). Vivu replaces spaces and punctuation with "", and plain names match back without guessing.
Done when vivu_get_account shows can_create_projects: true, ffmpeg and ffprobe print versions, and sessions.csv has one row per recording with its transcript.
Step 2: Price the indexing and get approval
Goal: the user sees what the recordings cost before anything is uploaded.
- Measure each recording and sum the minutes:
ffprobe -v error -show_entries format=duration -of csv=p=0 RECORDINGS_FOLDER/SESSION.mp4
- Call vivu_get_usage for the plan and what remains this month.
- Estimate search credits: five standing queries per project (Step 4), each precise, so one pass is 25 credits as an estimate. A precise search uses 5 credits in total and a fast search uses 1 credit. Label this as an estimate, since rewording a query adds to it.
- Show one table and wait for approval:
| This track | Remaining on the plan | |
|---|---|---|
| Index minutes | measured sum | from vivu_get_usage |
| Search credits | estimate | from vivu_get_usage |
For reference, the Free plan has 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 track of four 30 minute sessions fits Premium but not Free. If it does not fit, offer these levers in order: index only the sessions that go on demand first, leave out sessions the speaker already reviewed themselves, and only then a larger plan. Never skip a session the user asked for without saying so.
In our test run the account was an admin account whose vivu_get_usage shows no remaining allowance, so the comparison against a real plan and the approval were not exercised in our test run.
Done when the user has approved the minutes and the credit estimate.
Step 3: Upload and index
Goal: every approved recording is ready in a private Vivu project.
- Call vivu_list_projects and reuse the project named in config.json if it exists. Otherwise call vivu_create_project with that name and visibility "private". Unedited session recordings can hold exactly the private windows this skill looks for; the default visibility is the whole organization.
- Call vivu_open_upload_page with the project ID right before the upload. The link expires in 180 seconds and is a sign in link: do not paste it into any message or file. Give it to the user to open in their own browser and choose the files, or attach the files with a browser tool that can upload local files. Claude in Chrome accepts at most 10 MB per upload call, and a 30 minute session is usually larger; the user adds those in the Vivu web app. Never split or recompress a recording to fit a tool limit.
- Poll vivu_list_videos about every 30 seconds until every recording shows ready. Match each video back to sessions.csv by file name. Record the video IDs in state.json.
In our test run the files went in through a scripted upload of the same upload page, not a user's browser or Claude in Chrome; that path was not exercised in our test run. A file sat in "queued" for several minutes before indexing started, so keep polling instead of re-uploading.
Done when vivu_list_videos shows every recording in sessions.csv as ready.
Step 4: Run the standing searches and check every hit
Goal: five lists of checked moments, one per standing query.
| Field | Query | Mode | maximum_results |
|---|---|---|---|
| talk_start | the host introduces the speaker or the speaker's title slide appears and the talk begins | precise | 30 |
| talk_end | the speaker thanks the audience and wraps up the session, or the Q&A ends | precise | 30 |
| off_record | the speaker asks the audience not to share something outside the session because it is not public yet | precise | 30 |
| window_switch | the shared screen leaves the slides and shows a private window instead: an email inbox, a chat app, a computer desktop with files, or a pop-up notification | precise | 30 |
| notification_popup | a small pop-up notification or message preview appears in a corner of the screen on top of a slide | precise | 30 |
If the user named extra window kinds in the inputs (a CRM, a calendar), add them to the window_switch wording; that change was not exercised in our test run.
Why this chain: it has three links. talk_start and talk_end are one pair that gives each session its publish range, and only flags inside that range need a decision. off_record is what the speaker said; window_switch and notification_popup are what the screen showed, the same "should not go public" question moved from speech to picture. window_switch finds full window switches but can miss a small pop-up over a slide, so notification_popup runs as a second wording of the same screen share link, its checked hits go on the sheet as window_switch rows, and the Step 5 sweep backs up both. All five are precise because the sheet needs time ranges; fast only returns whole files. maximum_results 30 is far above the handful of flags a track usually has, so a list that stops at exactly 30 means the cap was hit: raise it and rerun that query.
Run each query with vivu_search_videos (project_id, query, mode, maximum_results). 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 each completed result as results/FIELD.json. Show the result page link in the live reply only; it expires after four hours, so it never goes into trim_sheet.csv or any file.
Check every hit before it goes anywhere:
- Extract three frames inside the window (start, middle, end):
mkdir -p trim-check/frames trim-check/results
ffmpeg -v error -ss SECONDS -i RECORDINGS_FOLDER/SESSION.mp4 -frames:v 1 -q:v 3 trim-check/frames/FIELD_hN_POS.png
SECONDS is start_ms / 1000, the midpoint, or end_ms / 1000 minus 0.5; N is the hit number; POS is start, mid or end. 2. For talk_start, talk_end and off_record, read the transcript lines inside the window. The reason text is a paraphrase, not a transcript: the words on the sheet come from the .vtt or .srt. An off_record hit is real only if the speaker asks the audience to keep something out of public (keep it in the room, between us, not announced, under NDA). A roadmap line such as "coming soon, it's on our public roadmap" is not. 3. For window_switch and notification_popup, the hit is real only if the frames show a window that is not the talk: a mail inbox, a chat app, a file desktop, or a notification over the slide. A product demo the speaker meant to show is not a private window; leave it off the sheet. 4. Record every verdict in state.json. Rejected hits stay in results/ and are counted, not written to the sheet.
Vivu returns a time range that contains the moment, not an exact frame. Switch windows tend to start a couple of seconds before the switch, so the start frame often shows the slide or demo before it; look at the middle frame and set exact seconds in Step 5. Spotting a private window is a judgment about what the picture shows (visual semantics), which capabilities testing rates as weak in general, so a returned switch is a candidate until Claude has looked at its frames, and an empty list does not prove the screen share stayed on the slides.
Worked example from our test run
In our test run we used 3 synthetic breakout session recordings, 6.65 minutes in total, made as screen shares with a speaker tile and a synthetic voice. Between them they held 3 talk starts, 3 talk ends, 3 spoken off the record requests and 4 switches away from the slides (a mail inbox, a chat app, a desktop with files, and a chat pop-up over a slide), plus distractors: an intended product demo in a browser, a slide styled like chat bubbles, two "coming soon, it's on our roadmap" lines and one "feel free to share the recording" line. From the first upload to the last file ready took 10 minutes, with the three uploads spread over that time.
The window_switch query returned 3 moments, 3 real and 0 false, and missed 1 of 4 switches: the chat pop-up over a slide. The notification_popup query returned 1 moment, 1 real, which was that pop-up. We wrote the notification_popup query after window_switch missed that pop-up, on the same corpus, and the corpus held only one pop-up, so its 1 of 1 is not an independent test. Neither returned the product demo or the chat bubble slide. The median window was 13.5 seconds, a few seconds wider than the switches themselves.
The off_record query returned 2 moments, 2 real and 0 false, and missed 1 of 3: a speaker asking to keep a customer story "under wraps" because of an NDA. A wording that named NDA and "off the record" outright, our 1 rewording on the same corpus, returned the same 2 and also missed it, so SKILL.md keeps the first wording. The roadmap and "feel free to share" lines were not returned.
talk_start returned 3 moments, 3 real, and talk_end returned 3 moments, 3 real, one per session. Their windows were wide (median 23 and 16 seconds), and two of the end windows ran past the end of the talk into the "up next" or break slide, which is why Step 5 sets the trim points on a contact sheet.
The test corpus was clean synthetic footage with one voice per session; full length real recordings, accents, cross talk and busy screens were not tested.
Done when every hit of every standing query has a verdict in state.json and the user has seen the true and false counts per query.
Step 5: Set exact in and out points and sweep for missed switches
Goal: each session has an in point and an out point to the half second, and every screen share stretch has been looked at once by eye.
- For the talk_start window, make a two frames a second contact sheet from 10 seconds before the window to its end (START is start_ms / 1000 minus 10, at least 0; DURATION is the window length plus 10):
ffmpeg -v error -ss START -t DURATION -i RECORDINGS_FOLDER/SESSION.mp4 -vf "fps=2,scale=320:-2,tile=8x6" trim-check/frames/SESSION_in_%02d.png
Each sheet holds 48 tiles (24 seconds); sheet S, tile K (counting from 0) is at START + ((S - 1) * 48 + K) / 2 seconds. When a host introduces the speaker, the in point is the host's first line in the transcript, because the host often speaks over the same holding slide that ran before, and the picture does not change until the title slide. Without a host, the in point is the first tile with the title slide. For the talk_end window, make a separate set of sheets from the window start to 10 seconds past its end, written to SESSION_out_*.png so they do not overwrite the in point sheets (START is the talk_end start_ms / 1000; DURATION is the window length plus 10):
ffmpeg -v error -ss START -t DURATION -i RECORDINGS_FOLDER/SESSION.mp4 -vf "fps=2,scale=320:-2,tile=8x6" trim-check/frames/SESSION_out_%02d.png
Tile times follow the same formula with this START. Take the last tile before the "up next" or break screen as the out point and put that sheet's file name in the trim_out row; end_ms alone can run into that screen. 2. Sweep the whole talk for screen share switches the search missed, one frame every 2 seconds, eight by eight tiles per sheet (128 seconds a sheet):
ffmpeg -v error -i RECORDINGS_FOLDER/SESSION.mp4 -vf "fps=1/2,scale=240:-2,tile=8x8" trim-check/frames/SESSION_sweep_%02d.png
Sheet S, tile K is at (S - 1) * 128 + K * 2 seconds. Any tile that is not a slide or the meeting tool's own screen goes on the sheet as window_switch with status "found on sweep", after a full frame at that second confirms it. A notification can sit on screen for only a few seconds, so this sweep is the backstop for the weakest search, not a replacement for it. 3. If the user gave slide files, check footers and labels in the files rather than on video; small footer text is where reading text on screen is least reliable. A .pptx is compressed, so export each deck to PDF first (the user can do this from PowerPoint or Keynote), then extract its text with pdftotext (from poppler) and search it:
pdftotext SLIDES_FOLDER/DECK.pdf trim-check/DECK.txt
grep -n -i -E "confidential|internal only|do not distribute|under nda" trim-check/DECK.txt
DECK is each deck's file name without the extension. Add one row per matching deck with mark_type slide_label and the matching line in what_is_on_screen.
In our test run the half second sheets and the sweep sheets were run on all three recordings, and every switch, including the pop-up the window_switch query missed, was visible on the sweep. The corpus had no slide files, so the slide label check was not exercised in our test run.
Done when every session has trim_in and trim_out rows and every sweep sheet has been looked at.
Step 6: Assemble trim_sheet.csv and confirm the sample
Goal: the editor and the speakers get one sheet in session order.
- Build one row per checked moment, ordered by session and then time:
session_file,mark_type,in_mmss,out_mmss,frame,said_local,what_is_on_screen,status,action,confirmed_by
track2_session_a.mp4,trim_in,00:10,,frames/track2_session_a_in_01.png,"Welcome back to track two. Our next speaker runs the data platform team",holding slide while the host introduces the speaker,checked,,
track2_session_a.mp4,window_switch,00:56,01:05,frames/window_switch_h3_mid.png,,mail inbox with sender names and subject lines readable,checked,,
track2_session_a.mp4,off_record,01:26,01:38,frames/off_record_h1_mid.png,"Please don't share it outside this session, it has not been made public yet.",bar chart slide,checked,,
- Field mapping:
| Field | Source | If unavailable |
|---|---|---|
| session_file | the original recording | none |
| mark_type | trim_in, trim_out, off_record, window_switch (also used for notification_popup hits), slide_label | none |
| in_mmss, out_mmss | the checked start and end (contact sheet for trim points and switches, transcript line for off_record), MM:SS in the recording | none |
| frame | path of the checked frame | blank for slide_label |
| said_local | transcript lines inside the window | blank for window_switch |
| what_is_on_screen | what Claude saw on the frame, by kind of window, not its content | UNCERTAIN |
| status | checked, found on sweep, or candidate | candidate |
| action, confirmed_by | left empty for the speaker and the event team | blank |
- Show the user one sample row per mark type and the mapping, and wait for a yes before writing the full sheet. Say which fields are inferred (what_is_on_screen) and what changes if Claude read the frame wrong: the editor looks at the wrong seconds and the speaker sees a flag that is not there.
- Write trim_sheet.csv. Add a short note under it with the counts: checked flags per type, candidates rejected per type, and sessions where a type returned nothing. An empty result does not prove the recording has no such moment; say so for those sessions.
In our test run the sheet was built from the checked hits and the sweep (trim_in and trim_out for every recording, one row per checked flag); the user's approval of sample rows was not exercised in our test run. The off the record line the search missed is absent from that sheet, which is the reason the note under the sheet names sessions with no off_record rows: the speaker should still be asked.
Hand the sheet to the user. Sending it to the editor or the speakers (email, chat, a shared drive) is the user's step; if they ask Claude to send it, name the destination, show the message, and wait for a yes. Sending was not exercised in our test run.
Done when trim_sheet.csv exists with trim_in and trim_out for every session plus one row per checked flag, and the user has approved the sample rows.
Compliance
- Use only recordings the event owns or the speakers agreed to have recorded and published. Confirm this before Step 3.
- People on camera: attendees asking questions are covered only by the event's recording notice. Ask the user before Step 6 whether anyone asked not to appear, and add those spots as rows to cut.
- Third party information on screen (mail subjects, chat messages, names in a notification) is described by kind on the sheet, never copied. Frames stay in the working folder.
- Minors: if a session shows minors, use it only with guardian consent; otherwise leave it out.
- The recordings stay in the user's Vivu project until the user deletes them. The skill never calls vivu_delete_video or vivu_delete_project unless the user asks, and confirms first.
- The skill does no face, logo or identity recognition and does not judge what is legally confidential; it lists candidate moments and the speaker decides.
- Nothing is posted or sent. trim_sheet.csv stays in the working folder until the user hands it on.
Known failure modes
| Symptom | Cause | Fix |
|---|---|---|
| (observed) a chat pop-up over a slide is not in the window_switch results; in our test run 1 missed of 4 switches | the slide stays on screen and the pop-up covers a corner, so the frame still reads as a slide | run notification_popup as its own search and look at the Step 5 sweep sheets |
| (observed) a spoken request is not returned; in our test run off_record missed 1 of 3, a line about keeping a customer story under wraps because of an NDA | the speaker framed it as an NDA, not as something unannounced; a rewording that named the NDA still missed it | tell the user which sessions have no off_record rows and ask the speaker; search the transcript text for NDA, between us and off the record before signing off |
| (observed) the first frame of a window_switch hit shows a slide or the demo, not the private window | the window starts a couple of seconds before the switch | judge on the middle frame and set seconds on the half second sheet |
| (observed) the talk_end window runs into the up next or break screen | windows are wider than the moment; in our test run the median talk_end window was 16 seconds | take the out point from the half second sheet, not from end_ms |
| (observed) a recording sits in "queued" for several minutes after upload | indexing waits in a queue | keep polling vivu_list_videos; do not upload the file again, a duplicate doubles every count |
| the speaker's intended product demo shows up as a switch | the query matches any window that is not a slide | leave intended demos off the sheet; flag only private windows |
| a quote on the sheet does not match what was said | it was copied from the reason text, which paraphrases | take every quote from the transcript |
| a Confidential footer was never flagged | small footer text on video is read unreliably | check the slide files with pdftotext and grep |
| "has not granted vivu.write" | Vivu connected read only | the user reconnects Vivu with write access |
| 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 |
| a recording is rejected by the browser upload tool | Claude in Chrome takes at most 10 MB per upload call | the user adds that file in the Vivu web app; never split or recompress it |
| a result's file name does not match sessions.csv | Vivu replaced spaces or punctuation in the name | rename to letters, digits and "_" before upload, and match on the name |
| a list stops at exactly maximum_results | the cap cut the list short | raise maximum_results and rerun that query |