SkillsSkill for Claude

Config handoff table from onboarding calls

Give Claude the implementation calls you held with one new customer and the configuration items support needs to know about, and it returns a handoff table: for each setting, the call file, the minute and second, the settings page title and the values read from a full frame, the decision as said on the call from your transcript, and an empty column for support to tick. Claude cuts only the admin screen share stretches out of each call, prices them against your Vivu plan, indexes them in a private project, searches each item on screen and in speech, and checks every window on a contact sheet before a value goes in the table, because call notes say "SSO configured" while the option picked and the boxes ticked are only on the shared screen.

Maintained by Vivu. Updated 2026-11-19.

Download

implementation-config-handoff-sheet.zip

10 KB. Unzips to implementation-config-handoff-sheet/SKILL.md. Upload the zip as it is in the Claude app, or unzip it into your skills folder for Claude Code.

SHA-256 fa110baf1ff6ed04f0fd9e5f725167e31a2594cc35c37bb5d498e7ccde6b6b70

At a glance

What the Config handoff table from onboarding calls skill does, where it runs, what it needs, and when it asks
Looks forThe moments on a call when a settings page is on the shared screen and someone sets or saves it: which option, which boxes, what a dropdown ended on. Notes and transcripts miss these, and what is said can differ from what is saved. Every window is checked against the original recording on a contact sheet, and each value is read from a full frame before it reaches the table.
Runs onClaude Code on your computer (the terminal or the Code tab of Claude Desktop), because it cuts and reads frames from your local recordings with ffmpeg. It downloads nothing, so no residential IP is needed, and nothing recurs, so no scheduler is involved.
Needs
  • The Vivu connector with write access, to create a private project, open its upload page and search.
  • A shell with ffmpeg and ffprobe, to cut segments and read frames from the local recordings.
  • The call recordings as local mp4 files with their call notes or chapters, so only the admin screen share stretches get indexed.
  • A transcript per call, because decision quotes come from it and Vivu's reason text is a paraphrase.
  • The customer's consent to the recording and to processing in a cloud service.
  • An upload path: the Vivu upload page opened in your own browser, or a browser tool that can attach local files.
  • Optionally a Notion or Confluence connector, only if you want Claude to write the table into the handoff page.
Your Vivu planIndex minutes are the length of the cut screen share segments, not the whole calls, and each item uses a screen search and a speech search in precise mode. Claude measures the segments, calls vivu_get_usage and shows minutes and credits against your plan before anything is uploaded. In our test run we ran 8 precise searches, 40 credits by our estimate.
Asks you firstConfirming the customer's consent, the item list and the segments before cutting; the index minutes and credits before upload; the first rows and the field mapping before the table is final; and the destination plus a rendered sample before any write to Notion, Confluence or a shared drive.

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

Before you run it

  • The recordings show the customer's staff: confirm they agreed to the recording and to cloud processing before anything is uploaded.
  • Admin screens show secrets and personal data; they are written as present, not copied, and frames that show them stay in your working folder.
  • Writing the table to Notion or Confluence acts as you; Claude names the page, shows the rendered table and waits for a yes.
  • Claude in Chrome uploads at most 10 MB per call; larger segments go through your own browser or the Vivu web app, never split or recompressed.
  • The segments stay in your Vivu project until you delete them; create it as private, since the default is visible to your whole Vivu organization.
  • Vivu can confuse neighboring blocks on the same settings page, so search results are candidates that Claude checks one by one on a contact sheet.
  • Values come only from frames; rows where the frame and the spoken decision differ are marked CHECK, and rows whose result is not on screen are marked UNCERTAIN.
  • A missing row does not prove nothing was configured; brief page visits can be missed.

Start it

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

Make a config handoff table from the onboarding calls with ACME in ~/Calls/acme-onboarding. Support needs SSO, roles and permissions, and notification rules.

In Claude Code you can also type /implementation-config-handoff-sheet. Claude asks for anything the request leaves out, most important first.

What is inside

  1. When to use
  2. Working principles
  3. What you need before starting
  4. Inputs to collect
  5. Files and state
  6. Step 1: Check the Vivu connector and the setup
  7. Step 2: Confirm consent, items and segments
  8. Step 3: Cut, measure and price
  9. Step 4: Upload and index
  10. Step 5: Search each item on screen and in speech
  11. Step 6: Check every window and read the values
  12. Step 7: Assemble the table and get approval
  13. Worked example from our test run
  14. Compliance
  15. Known failure modes

The full skill

This is implementation-config-handoff-sheet/SKILL.md from the download, as Claude reads it: the frontmatter first, then the instructions.

---
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:

  1. A single question about one call ("when did we turn on SAML?"): search Vivu directly and look at the frames.
  2. Generic how to steps for a product (a runbook or training guide): that output does not depend on one customer's values.
  3. Feature requests or complaints from the customer: those are what the customer asked for, not what was configured.
  4. Rating the consultant's or the customer's performance on the call. The table records settings only.
  5. Calls without screen sharing. With no admin screen in the recording there is nothing to read values from; use the call notes.

Working principles

  1. Report measured numbers, not estimates. When a number is an estimate, say so.
  2. 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.
  3. Stop and tell the user when a required capability or tool is missing. Do not guess around it.
  4. 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.
  5. 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".
  6. 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.

  1. CALLS_DIR: the folder with the customer's call recordings (mp4) and, next to each, its notes or chapters and its transcript. Required.
  2. 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.
  3. CUSTOMER_KEY: a short internal code for the customer (not the full name) for the folder and project name. Required; ask.
  4. Where the table goes. Default: a local CSV the consultant pastes into the handoff page.
  5. 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

  1. 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 show can_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.
  2. Run ffmpeg -version and ffprobe -version, create config-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).

  1. 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.
  2. 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.
  3. 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

  1. 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"
  1. 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).

  1. 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

  1. 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.
  2. 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.
  3. 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.

  1. 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

  1. 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,
  1. 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.
  2. 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

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. If the screen share shows something personal or unrelated (an inbox, a chat), leave that stretch out of the segments.
  6. 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

Connect Vivu, then add the skill.

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