---
name: implementation-config-handoff-sheet
description: "Turn a new customer's recorded onboarding calls into a configuration handoff table with Vivu: each setting changed on the shared admin screen, its value read from a frame, and the minute."
---Configuration handoff table from onboarding call recordings
This skill takes the recorded implementation calls an implementation consultant or onboarding CSM held with one new customer (Zoom, Teams or Meet exports where someone shared the product's admin console) plus the list of configuration items the support team needs to know about (single sign-on, roles and permissions, notification rules, data retention, integration field mapping), and returns a configuration handoff table. Each row names the item, the call file, the start and end minute and second, the settings page title and the values read from a full frame, the decision as said on the call (from a local transcript), the frame file, a status, and an empty "support checked" column. Claude cuts the admin screen share stretches out of each call using the call notes or chapters, prices them against the user's Vivu plan, uploads them to a private Vivu project, runs one screen search and one speech search per configuration item, checks every returned window on a half second contact sheet, reads the page title and values from a full frame, and writes the table for the internal handoff page.
The value is in what only the screen share shows. Call notes say "SSO configured" or "permissions set up"; which option was picked, which boxes were ticked and what a dropdown ended on is only on the shared screen, and "tick this one" in the audio does not say which box. What people say and what they save also drift apart: someone says "full access" and leaves two boxes off. Vivu finds where a settings page was on screen and where someone said how to set it, but its reason text is a paraphrase that can name values that are not on screen, so every value in the table is read from a full frame and every quote comes from the transcript.
When to use
Use when someone says "make a config handoff from the onboarding calls with CUSTOMER", "what did we set up for this account during implementation?", "pull the settings we changed on the calls into a table for support", or "document the SSO and permission settings from the kickoff recordings".
Not for these:
- A single question about one call ("when did we turn on SAML?"): search Vivu directly and look at the frames.
- Generic how to steps for a product (a runbook or training guide): that output does not depend on one customer's values.
- Feature requests or complaints from the customer: those are what the customer asked for, not what was configured.
- Rating the consultant's or the customer's performance on the call. The table records settings only.
- Calls without screen sharing. With no admin screen in the recording there is nothing to read values from; use the call notes.
Working principles
- Report measured numbers, not estimates. When a number is an estimate, say so.
- A window from Vivu is a candidate until a contact sheet and a full frame show the settings page. Values come from the frame, never from the reason text.
- Stop and tell the user when a required capability or tool is missing. Do not guess around it.
- Ask before anything that is expensive to redo (the cut segments and their index minutes, before upload) and before anything that acts on the user's behalf (a write to Notion, Confluence or a shared drive). Show one sample row first.
- Secrets stay out. Client secrets, tokens, certificates, API keys and personal email addresses visible in a frame are never copied into the table; write "present, not copied".
- A missing row is not proof that nothing was configured. Brief page visits and settings changed off screen can be missed.
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 and a folder it can write | cut segments, contact sheets and frames from the local recordings | create the working folder in Step 1 |
| ffmpeg and ffprobe | measure, cut, make contact sheets and full frames | ffmpeg -version, ffprobe -version |
| The call recordings as local mp4 files, and the call notes or chapters | the notes say which stretches show the admin screen, so only those get indexed | the user names the folder; list it with ls |
| A transcript per call | decision quotes come from it, because Vivu's reason is a paraphrase | the meeting tool's transcript (VTT or text) next to each recording; if there is none, ask the user before the speech step |
| The customer's consent to recording and to cloud processing | the calls are recordings of the customer's staff | asked in Step 2 |
| 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 |
| Optional: a Notion or Confluence connector | only if the user wants Claude to write the table into the handoff page | read the target page once |
This skill needs Claude Code on the user's computer (the terminal or the Code tab of Claude Desktop), because it cuts and reads frames from local recordings with ffmpeg. Claude on the web and cloud sessions cannot reach the files. It downloads nothing from the internet, so no residential IP is needed. Nothing recurs, so no scheduler is involved; run it once per customer, after the last implementation call.
Inputs to collect
Ask for anything missing, most important first.
- CALLS_DIR: the folder with the customer's call recordings (mp4) and, next to each, its notes or chapters and its transcript. Required.
- ITEMS: the configuration items the support team needs. Default: sso, roles_permissions, notifications, data_retention, field_mapping. Each item gets a short field key, the page title the admin console uses for it if the user knows it, and the controls on that page.
- CUSTOMER_KEY: a short internal code for the customer (not the full name) for the folder and project name. Required; ask.
- Where the table goes. Default: a local CSV the consultant pastes into the handoff page.
- Segment rule. Default: from the notes or chapters, keep every stretch where the admin console is shared, with 30 seconds of margin on each side.
Files and state
Keep everything in one working folder:
config-handoff-CUSTOMER_KEY/
calls.csv call_file, date, notes_file, transcript_file, duration_s
segments.csv segment_file, call_file, seg_start_s, seg_end_s, duration_s, video_id
segments/ the cut mp4 segments, the only files uploaded
results/ one JSON per query field, saved without the result page link
sheets/ contact sheets per window
read/ full frames and crops the titles and values were read from
candidates.csv every window Vivu returned, with its check outcome
config_handoff.csv one row per checked setting
coverage.md item by call grid: rows found, no row
state.json steps done, segments cut and uploaded, fields searched with job ids, windows checked
A rerun reads state.json first and skips finished steps: a cut segment is not cut again, an uploaded segment is not uploaded again, a field with a saved result is not searched again, and a window with a recorded outcome is not checked again. Update state.json at the end of every step.
Step 1: Check the Vivu connector and the setup
- 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, createconfig-handoff-CUSTOMER_KEY/, list CALLS_DIR, and check that each recording has its notes and transcript next to it.
Done when vivu_get_account shows can_create_projects: true, both tools print their versions, and calls.csv lists every recording with its notes and transcript (or a note that one is missing).
Step 2: Confirm consent, items and segments
- Confirm the Compliance items below with the user, above all that the customer agreed to the recording and to processing in a cloud service, before anything is cut or uploaded.
- Confirm ITEMS. For each item write the field key, the words the admin console uses for the page title, and the controls on it (checkboxes, dropdowns, a mapping table). These go into the search wording in Step 5.
- From each call's notes or chapters, list the stretches where the admin console is on screen. A 50 minute call often has 15 to 20 minutes of settings screen share (estimate); intros, slides and Q and A do not need to be indexed. Write them into segments.csv with 30 seconds of margin on each side.
This step was not exercised in our test run: the test corpus was public vendor tutorials, with no customer, no call notes and no consent to collect.
Done when the user has confirmed consent, the item list with page titles and controls, and segments.csv.
Step 3: Cut, measure and price
- Cut each segment from its call, re-encoding so the cut points are exact:
mkdir -p "config-handoff-CUSTOMER_KEY/segments"
ffmpeg -v error -ss SEG_START -to SEG_END -i "CALLS_DIR/CALL_FILE" -c:v libx264 -c:a aac "config-handoff-CUSTOMER_KEY/segments/CALLKEY_SEGSTART.mp4"
SEG_START and SEG_END are seconds in the call, CALL_FILE the recording, CALLKEY a short name for the call such as call02, SEGSTART the start second. Keep SEG_START in segments.csv: every time Vivu returns is relative to the segment, and the table reports call time, which is SEG_START plus the segment time. 2. Measure each segment, one file per command (ffprobe refuses a second input file):
ffprobe -v error -show_entries format=duration -of csv=p=0 "config-handoff-CUSTOMER_KEY/segments/FILE"
- Call vivu_get_usage and show one table:
| This handoff | Plan allowance | Remaining this month | |
|---|---|---|---|
| Index minutes | sum of segment durations / 60 | from vivu_get_usage | from vivu_get_usage |
| Search credits | 2 precise searches per item at 5 credits each, so 50 for five items (estimate), plus 5 per rewording | 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. Four calls cut to about 18 minutes of screen share each come to about 72 minutes, which fits Premium but not Free (estimate).
- If it does not fit, offer levers in this order: trim the margins, drop segments the notes say only demo features the customer did not buy, drop items support does not need this round, and only then move to a larger plan. Never drop a call or item the user asked for without saying which, and never recompress a file to save minutes.
In our test run the cut and the duration check ran on a tutorial; the factory account returns no allowance figures, so the plan comparison and the user's approval were not exercised in our test run.
Done when every segment in segments.csv exists with a duration_s, and the user approves the index minutes and credits.
Step 4: Upload and index
- Call vivu_list_projects and reuse a project named "Config handoff CUSTOMER_KEY" 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; customer calls should not be.
- 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 in segments/, or open it in a browser tool that can attach local files. Claude in Chrome accepts at most 10 MB per upload call; a cut segment is often larger, so those go 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 segment shows ready. Vivu replaces spaces and punctuation in file names with underscores, so match each listed name to segments.csv by the CALLKEY_SEGSTART part; if that fails, match duration_ms against duration_s. Record each video_id in segments.csv and state.json.
This step was not exercised in our test run: the test corpus had been indexed before the run, so the user's browser upload and the wait for ready were not timed.
Done when every segment in segments.csv shows ready and has a video_id.
Step 5: Search each item on screen and in speech
Run two precise searches per item with vivu_search_videos, mode "precise" and maximum_results 10, written explicitly. One item's settings page usually shows up a handful of times across three or four calls; 10 leaves room for repeat visits and for the false windows you will reject, and it is also the ceiling on what can come back. Do not use fast here: fast returns whole files with an empty reason, and the segments are already the relevant files.
| Field | Query | Mode | maximum_results | What it feeds |
|---|---|---|---|---|
| ITEM_screen | the ITEM_PLAIN settings screens in the admin console: a page titled PAGE_TITLE, with CONTROLS | precise | 10 | the window and the page; values are read from frames in Step 6 |
| ITEM_screen for permission tables | a permission set's or role's settings edit page titled with one object name, where the CHECKBOX_NAMES checkboxes are being ticked or unticked and then saved, one object after another | precise | 10 | same, for pages that repeat one table per object |
| ITEM_said | someone explains which ITEM_PLAIN option to turn on or what value to choose, for example EXAMPLE_CHOICES | precise | 10 | the window where the decision was said; the quote comes from the transcript |
ITEM_PLAIN is the item in plain words ("single sign-on"), PAGE_TITLE the page title from Step 2 ("Single Sign-On Settings, Identity Provider, or a connected app's SAML settings"), CONTROLS the visible controls ("fields such as Entity ID, ACS URL and Subject Type, with checkboxes and dropdowns"), CHECKBOX_NAMES the column of boxes ("Read, Create, Edit and Delete"), EXAMPLE_CHOICES two or three decisions in buyer words ("enabling SAML, choosing the subject type").
Name the page title and the controls, never the value you hope to find. When a query names a value, the reason text tends to repeat it whether or not it is on screen. For tables that repeat per object (permissions, field mappings), say that boxes are being ticked and saved: the plain "page showing the permissions table" wording also returns neighboring blocks on the same page that nobody was deciding.
The chain: the screen search gives the window and the page; Step 6 reads the values from frames inside that window; the speech search gives the window where someone said how to set it, and the transcript gives the exact words; the two are joined by time. Each search returns a job_id; call vivu_get_search_results with it until complete is true. Each call waits up to 45 seconds; a pending search is still running, not stalled. Save each completed result to results/FIELD.json without result_page_url. The result page link expires after four hours, so show it in the live reply only and never put it in the table, a doc or a file. If the first page of a screen search has wrong windows, reword once along the lines above and record both wordings and their counts in state.json.
Done when every item has a saved screen result and speech result in results/ and state.json lists their job ids.
Step 6: Check every window and read the values
Vivu returns a time range that contains the moment, not an exact frame, and one window can span several settings pages. Treat each window as a candidate.
- Make a half second contact sheet for every screen window (times in the segment):
ffmpeg -v error -ss WIN_START -to WIN_END -i "config-handoff-CUSTOMER_KEY/segments/SEGMENT_FILE" -vf "fps=2,scale=320:-1,tile=6x4" "config-handoff-CUSTOMER_KEY/sheets/FIELD_SEGSTART_WINSTART_%02d.png"
WIN_START and WIN_END are start_ms and end_ms divided by 1000, SEGMENT_FILE the segment, FIELD the field key. Each sheet covers 12 seconds, left to right, top to bottom. 2. Look at the sheets. A window is true when the item's settings page is on screen and something is set or saved there; it is false when the page is a neighbor (a different block on the same page, a list page, a slide). Write each window's outcome and reason into candidates.csv. 3. For each true window, find on the sheet the frame where the page is saved or the last frame before the page changes, and pull it full size:
ffmpeg -v error -ss SECONDS -i "config-handoff-CUSTOMER_KEY/segments/SEGMENT_FILE" -frames:v 1 -q:v 3 "config-handoff-CUSTOMER_KEY/read/FIELD_SECONDS.png"
Read the page title and each value from that frame. Do not read values from the middle of the window: the frame there can show the value before it was changed. When saved checkboxes are greyed and small, crop the settings block and enlarge it:
ffmpeg -v error -ss SECONDS -i "config-handoff-CUSTOMER_KEY/segments/SEGMENT_FILE" -frames:v 1 -vf "crop=CROP_W:CROP_H:CROP_X:CROP_Y,scale=iw*2:-1" "config-handoff-CUSTOMER_KEY/read/FIELD_SECONDS_crop.png"
CROP_W and CROP_H are the size of the block in pixels and CROP_X and CROP_Y its top left corner on the full frame. 4. For each speech window, open the call's transcript at call time SEG_START + WIN_START to SEG_START + WIN_END and copy the sentence that states the decision, word for word. If there is no transcript, call vivu_get_video_summary with include_segments true and start_ms and end_ms around the window to confirm the topic, and leave the quote column empty with "no transcript". 5. Set the status per row: VERIFIED when the frame shows the saved value; CHECK when the frame and the quote disagree (write both, the frame wins for the value); UNCERTAIN when the result state is not on screen inside the window (a button was clicked and the page changed). Never fill a value from the reason text or from the quote alone.
Done when every window in candidates.csv has an outcome and every true window has a read frame path and a status.
Step 7: Assemble the table and get approval
- Write config_handoff.csv with these columns: config_item, call_file, start_mm_ss, end_mm_ss, page_title_read_from_frame, setting_values_read_from_frame, decision_quote_from_transcript, frame_path, status, support_checked (left empty for the support engineer). Times are call times in MM:SS. One sample row:
sso_connected_app,call02_admin.mp4,01:55,02:20,"Manage Connected Apps > Web App Settings","Subject Type: Federation ID; Signing Algorithm: SHA1; Entity Id / ACS URL / Issuer: present, not copied","The service provider requires us to set the Subject Type to Federation ID.",read/sso_140.png,VERIFIED,
- Write coverage.md: one line per item and call, with the rows found or "no row". Add the windows rejected as false and any item with no row at all, so support knows what to ask the customer.
- Show the user the first rows and the field mapping, plus the counts: windows returned, true, false, rows CHECK and UNCERTAIN. Ask before writing anything outside the working folder. If they want it in Notion or Confluence, name the page, show the fully rendered table as it will appear, and write only after an explicit yes. Frames stay in the working folder; the handoff page gets file names and call times, not result page links.
Done when config_handoff.csv and coverage.md exist and the user has approved the table, or has approved and seen it written to the handoff page they named.
Worked example from our test run
In our test run the test corpus was six public admin console tutorials from one CRM vendor's official channel, 26 minutes in all: single sign-on with the org as identity provider, restricting login to single sign-on, object permissions in permission sets, field level security on the same permission set pages (a look-alike), email deliverability, and a slide explainer with no settings pages. Each tutorial stood in for one cut screen share segment. A presenter, not a consultant and a customer, says each decision. Ground truth for every item was written from contact sheets and subtitles before any search.
The single sign-on screen search returned 3 windows: 3 real, 0 false, 1 missed (a brief first visit to the settings page). The look-alike pages (domain settings, a system permission checkbox for single sign-on, a user's federation field) did not come back. The single sign-on screen wording was chosen after 1 rewording on the same corpus: an earlier session ran this same wording (2 windows, 2 real, 2 missed), tried an alternative (3 windows, 3 real, 1 missed) and kept the original. The same wording on the same footage returned different windows on different runs.
The first object permission wording returned 4 windows, 1 real and 3 false; all 3 false windows were the field permission table on the same page type. In the earlier session the same first wording returned 5 windows, 2 real and 3 false, and a first rewording (someone ticking boxes, with the field permission table excluded) returned 1 real, 0 false, 1 missed. After 2 rewordings on the same corpus (checkboxes being ticked and saved, one object after another) it returned 1 real, 0 false, 1 missed (a later edit in a second permission set). That one window was 48 seconds and spanned the pages of every object edited in that permission set, so the values for each object came from separate frames picked on the contact sheet.
The speech search for single sign-on returned 3 real windows and missed 1. In the permissions window the transcript said "full access to contacts" while the frame showed View All and Modify All off, and said leads need "create and view" while Edit was also on: both rows went to CHECK. In the identity provider window the button click is on screen but the enabled state is not, so that row is UNCERTAIN. In the SAML window (01:55 to 02:20) the middle frame shows the subject type before it was changed, and the saved page at the end shows Federation ID.
Both screen wordings were tuned on this same corpus across sessions, so these counts may be better than a first try on new footage. We ran 8 precise searches, 40 credits by our estimate, not counting the earlier session's searches. The upload, the user approvals and the write to a handoff page were not part of the run.
Compliance
- The calls are recordings of the customer's staff. Before Step 3, confirm that the customer agreed to the recording and that uploading it to a cloud video service for internal processing is covered by that agreement or by the contract. If not, stop.
- Admin screens show secrets and personal data: client secrets, API keys, tokens, certificates, user email addresses. They stay out of the table ("present, not copied"), and frames that show them stay in the working folder and do not go into the handoff page.
- The videos stay in the user's Vivu project until the user deletes them. Create the project as private; the default is visible to the whole Vivu organization. Delete segments or the project only when the user asks, and confirm first.
- The table records settings, not people. It does not rate the consultant or the customer's staff, and the skill does no face, voice or identity recognition. Quotes are attributed by role ("consultant", "customer admin") only if the transcript labels the speaker; otherwise leave the speaker blank.
- If the screen share shows something personal or unrelated (an inbox, a chat), leave that stretch out of the segments.
- Any write outside the working folder goes through the approval in Step 7.
Known failure modes
| Symptom | Cause | Fix |
|---|---|---|
| (observed) a permissions search returned 4 windows, 3 false, all on the field permission table | the object and field blocks sit on the same settings page | reword to boxes being ticked and saved, one object after another; reject neighbors on the contact sheet |
| (observed) the middle frame of a true window shows the old value | the window covers the edit, not only the saved state | read values from the saved page or the last frame before the page changes |
| (observed) the start and middle frames show a loading page and a slide, and the settings page is missed | the window is wider than the page visit | judge from the half second contact sheet, not from three frames |
| (observed) the transcript says "full access to contacts" but View All and Modify All are off on screen | what is said and what is saved differ | the frame sets the value; mark the row CHECK and show both |
| (observed) a brief visit to a settings page has no window | short visits can be missed | say so in coverage.md; ask the consultant if an item has no row |
| (observed) ffprobe stops with "provided as input filename, but" | ffprobe takes one input file per command | run one ffprobe per segment |
| (observed) a button click is on screen but not its result | the page changed after the window ended | mark the row UNCERTAIN and ask support to check the live setting |
| saved checkboxes are greyed and hard to read | low contrast on read only pages | crop the block and enlarge it before reading |
| the reason text names a value that is not on screen | the reason is a paraphrase | never copy values from the reason; read the frame |
| "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 expired (it expires in 180 seconds) | request a new link right before opening it |
| a segment is rejected by the browser upload tool | the file is above the tool's limit (at most 10 MB for Claude in Chrome) | the user adds that file in the Vivu web app; do not split or recompress |
| a listed file name does not match segments.csv | Vivu normalized the file name | match on the CALLKEY_SEGSTART part or on duration |
| an empty search for an item | the page title words differ from the console's own, or the item was not on screen | check the notes; retry once with the console's exact page title; otherwise report no row |