---
name: fat-witness-evidence-table
description: "Turn remote factory acceptance test (FAT) call recordings into a witness evidence table with Vivu: per protocol step, the HMI page and values, alarms, and the verdict quote."
---FAT witness evidence table from test call recordings
This skill turns the recording of a remotely witnessed factory acceptance test (FAT) into an evidence table for the buyer's project or validation engineer. The user gives the meeting recordings (vendor camera on the machine plus a shared HMI screen), the transcript the meeting tool exported, and the FAT protocol's step list. Claude cuts only the protocol steps to be witnessed out of a day long recording, prices them against the user's Vivu plan, indexes them in a private Vivu project, runs one search per protocol step and one search for alarm pop ups, reads the HMI page title, parameter values and alarm text from full frames, takes the vendor's pass or deviation words from the transcript, and writes fat_evidence.csv with blank columns for the validation engineer's sign off and the deviation number.
The value is in what only the picture shows. The protocol has a tick box and the transcript says "OK, that passes"; the actual values on the HMI, the alarm that popped up while nobody mentioned it, and whether the screen even showed the step being tested are only in the video. Every row is checked on frames before it is written, values come from frames Claude has looked at and never from Vivu's reason text, and the verdict column only copies what the vendor said. The skill does not decide whether a test passed; the validation engineer does.
When to use
Use when a project, validation or qualification engineer says "build the FAT evidence table from yesterday's call", "pull the HMI readings for each protocol step we witnessed", "which steps had alarms during the FAT?", or "I need evidence for the FAT report before SAT". For one question about one step ("what did the HMI show at step 4.2?"), search Vivu directly or scrub the recording. For writing operating procedures from equipment videos, use an SOP workflow instead; for software configuration walkthroughs (SaaS admin settings), use a configuration handoff workflow. This skill does not judge compliance with GMP or any regulation, and it does not assess the vendor's people.
Working principles
- Report measured numbers, not estimates. When a number is an estimate, say so.
- Nothing goes into the table until it has been checked against the recording. Search results are candidates; a rejected candidate is counted, not written.
- Stop and tell the user when a required capability or file is missing (no transcript, no step list, 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 cut list and the indexing cost before upload, the sample rows before the full table.
- HMI values and alarm text come from a full frame Claude has looked at; verdict quotes come from the transcript. A value that cannot be read with confidence is written UNCERTAIN with the frame path, never guessed.
- The verdict column copies the vendor's words. Sign off and deviation numbers belong to the validation engineer and stay blank.
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 | cut the step segments, measure minutes, extract frames and contact sheets | ffmpeg -version and ffprobe -version |
| The FAT call recordings on local disk (mp4 from the meeting tool) | frames and cuts come from the originals; Vivu has no export tool | ls RECORDINGS_FOLDER lists the mp4 files |
| The meeting tool's transcript for each recording (VTT or SRT) | step start times, end times and verdict quotes come from it, never from Vivu's reason text | one .vtt or .srt next to each .mp4; Teams and Zoom both export one |
| The FAT protocol step list (step number and name) | one search per step, and the step column of the table | the user pastes the list or the protocol's table of contents |
| Confirmation that both parties agreed to the recording and that the footage may go to a cloud service | the recording shows the vendor's staff, machine and process parameters, often under an NDA | the user confirms |
| 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 transcripts. Required.
- The protocol steps to witness, with number and name. Required. Default: every step in the list the user pastes.
- For each step, roughly where it happened (from the transcript or the meeting chat time stamps). Default: Claude finds the transcript line where the vendor says the step number.
- Segment length. Default: from the line that starts the step to its verdict line, plus 30 seconds on each side, at most 10 minutes per step.
- The Vivu project name. Default: "FAT MACHINE_NAME witness", private.
Files and state
Keep everything in one working folder next to the recordings:
fat-evidence/
config.json machine name, protocol step list, queries, vivu project id
steps.csv one row per step: step_no, step_name, source recording, cut start and end seconds, clip file, vivu video id
clips/ one mp4 and one vtt per witnessed step
results/ raw search results, one JSON file per search
frames/ full frames and contact sheets
fat_evidence.csv the table
state.json clips uploaded with video ids, searches run with job ids, hits checked with verdicts, rows written
state.json is updated after every step. A rerun reads it first: clips already uploaded are not uploaded again, searches already run are not rerun, and checked hits keep their verdicts, so an interrupted run resumes where it stopped and no step is written twice.
Step 1: Check the Vivu connector and the setup
Goal: every row of What you need is confirmed before anything is cut or 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 pair each mp4 with its transcript. Rename files to letters, digits and "" only (FAT_day1_am.mp4); Vivu replaces spaces and punctuation with "", and plain names match back without guessing.
- Ask the user to confirm that both parties agreed to the recording and that the footage may be processed by a cloud service under the NDA with the vendor. Without that, stop. Asking for this confirmation was not exercised in our test run.
Done when vivu_get_account shows can_create_projects: true, ffmpeg and ffprobe print versions, the user has confirmed consent, and every recording has a transcript.
Step 2: Cut the step segments and price the indexing
Goal: only the witnessed protocol steps get indexed, and the user approves the cost first.
A two day FAT is often 12 to 16 hours of recording, several times a Premium month, while the steps that need evidence are a few minutes each. Cutting first is the main saving.
- For each protocol step, find where the vendor announces it in the transcript. Vendors say the number aloud ("step four point two") or the name, so search both:
grep -n -i -E "four point two|4\.2|fill weight" RECORDINGS_FOLDER/TRANSCRIPT
TRANSCRIPT is the recording's transcript file name with its extension (.vtt or .srt); replace the pattern with the step's spoken number, written number and a word from its name. The step runs from that line to the line where the vendor gives the verdict (pass, passed, deviation, accepted, failed). The meeting chat's time stamps help when the transcript is unclear. 2. Cut each step with 30 seconds on each side, at most 10 minutes, with a re-encode so the cut points are exact:
mkdir -p fat-evidence/clips fat-evidence/frames fat-evidence/results
ffmpeg -v error -ss START -to END -i RECORDINGS_FOLDER/RECORDING.mp4 -c:v libx264 -c:a aac fat-evidence/clips/step_STEPNO_RECORDING.mp4
START and END are seconds in the full recording; RECORDING is its file name without .mp4; STEPNO is the step number with "_" for "." (4_2). Shift the transcript lines by START so their times match the clip, and save them as fat-evidence/clips/step_STEPNO_RECORDING.vtt. Record START in steps.csv: times in the table are reported in the clip, and START converts them back to the full recording. 3. Measure each clip and sum the minutes:
ffprobe -v error -show_entries format=duration -of csv=p=0 fat-evidence/clips/step_STEPNO_RECORDING.mp4
- Call vivu_get_usage for the plan and what remains this month.
- Estimate search credits: one precise search per step plus one alarm search for the whole project. A precise search uses 5 credits in total and a fast search uses 1 credit. As an estimate, ten steps are 10 x 5 + 5 = 55 credits; each rewording adds 5.
- Show one table and wait for approval:
| This FAT | Remaining on the plan | |
|---|---|---|
| Index minutes | measured sum of the clips | 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. As an estimate, nine steps of eight minutes are about 72 minutes and fit Premium. If the job still does not fit, offer these levers in order: trim each clip closer to its announcement and verdict, index the steps with open questions first and the rest later, and only then a larger plan. Never drop a step the user asked for without saying so.
In our test run the recordings were already short, so the transcript search for step lines was not exercised in our test run; one cut was made and measured. The account was an admin account whose vivu_get_usage shows no remaining allowance, so the plan comparison and approval were not exercised in our test run either.
Done when every step has a clip and a shifted transcript in fat-evidence/clips, steps.csv lists them, and the user has approved the minutes and the credit estimate.
Step 3: Upload and index
Goal: every approved clip 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". The default visibility is the whole organization, and FAT footage shows the vendor's machine, process parameters and staff.
- 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 clips, or attach them with a browser tool that can upload local files. Claude in Chrome accepts at most 10 MB per upload call; most step clips are larger, and the user adds those in the Vivu web app. Never split or recompress a clip to fit a tool limit.
- Poll vivu_list_videos about every 30 seconds until every clip shows ready. Clips can sit in "queued" while another indexes; keep polling and do not upload them again, because a duplicate doubles every count. Match each video back to steps.csv by file name and record the video IDs in state.json.
In our test run the clips 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.
Done when vivu_list_videos shows every clip in steps.csv as ready.
Step 4: Search each step and the alarms, then check every hit
Goal: one checked window per protocol step, and a checked list of the alarm pop ups the search found.
| Field | Query | Mode | maximum_results |
|---|---|---|---|
| step window (one search per step) | the vendor's test engineer says they are starting protocol step STEPNO (SPOKEN_NUMBER), the STEP_NAME test, and then runs it | precise | 3 |
| alarm text | an alarm or fault message pops up on the machine's touch screen, a red or yellow box with an alarm code and text | precise | 20 |
STEPNO is the number as written (4.2), SPOKEN_NUMBER as said (four point two), STEP_NAME the protocol's name for the step (fill weight accuracy). Writing both forms of the number matters because transcripts and speech say it one way and the protocol another.
Why this chain: the step search finds where the vendor said it was starting the step (said); the frames inside that window then show what the HMI displayed while the step ran (shown), which is the evidence the table needs. The alarm search works the other way round. Pop ups are on screen and often not mentioned at all, so it starts from the picture, and the transcript at that time then says whether anyone remarked on it. All searches are precise because the table needs time ranges; fast only returns whole files. maximum_results 3 is above the one or two windows a step normally gets, and 20 is far above the alarms one FAT produces; a list that stops exactly at the cap means it was hit, so raise it and rerun.
If a step's first page is not clean (a window lands in a neighboring step), reword once with what is unique to the step: the parameter it measures or the device it uses ("checks the fill weight of ten samples per nozzle on the checkweigher"). Rewording was not needed in our test run, so a reworded search was not exercised in our test run.
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 with the result_page_url field removed; show the result page link in the live reply only. It expires after four hours, so it never goes into the table or any file.
Check every hit before it goes anywhere:
- Extract three frames inside the window (start, middle, end):
ffmpeg -v error -ss SECONDS -i fat-evidence/clips/CLIP.mp4 -frames:v 1 -q:v 3 fat-evidence/frames/FIELD_hN_POS.png
SECONDS is start_ms / 1000, the midpoint, or end_ms / 1000 minus 0.5; CLIP is the clip's file name without .mp4; N is the hit number; POS is start, mid or end. 2. A step hit is real only if the transcript inside the window has the vendor announcing that step number or name, and the window's midpoint lies between that line and the step's verdict line. A window that sits mostly on a neighboring step is false. Speech is the signal here; the frames are for Step 5. 3. An alarm hit is real only if a frame inside the window shows a pop up with an alarm or fault code. A normal information banner (batch started, recipe loaded) is not an alarm. The start and end frames often show no pop up at all, because the window is wider than the time the pop up is on screen; judge on the middle frame, and make the contact sheet from Step 5 when the middle frame misses it. 4. Map each alarm to the step whose segment contains it (same clip, between the announcement and the verdict). 5. Record every verdict in state.json. Rejected hits stay in results/ and are counted, not written to the table.
Vivu returns a time range that contains the moment, not an exact frame. vivu_get_video_summary (include_segments, start_ms and end_ms around the window) is a second signal at most: its segments follow topics, not protocol steps, and can fold one step into the next.
Worked example from our test run
In our test run we used three synthetic FAT call recordings (4.46 minutes) built as meeting recordings with a REC bar, participant tiles and one synthetic voice, plus one public equipment video (1.4 minutes, no speech, a hand held camera on a weighing machine's touch screen at 360p): four videos, 5.86 minutes in all. The first recording shared the HMI screen cleanly; the second filmed it with a camera at an angle, with glare, blur and small text; the third was a speech only control where the screen stayed on the line overview page. Steps ran back to back, one step was announced while the screen stayed on the previous step's page, each recording had one normal information banner as a distractor, and one alarm pop up came with narration about something else. From the start of the upload to the last video ready took 430 seconds.
The 8 step searches returned 8 windows in total: 8 real, 0 false, 0 missed, with 0 rewordings, including both steps on the speech only control. A control search for a step that was not in the corpus returned 0 moments. Step windows ran 23 to 46.5 seconds and several started inside the previous step's verdict line, so step start and end come from the transcript, not the window. The alarm search returned 2 moments, 2 real and 0 false, with 0 missed; neither information banner came back, and both reasons named the right alarm code. A non core search for the Calibration page on the public video returned 2 moments, 2 real.
The test corpus was small, clean and mostly synthetic: one voice, short steps, few distractors. Real calls of several hours with crosstalk, several cameras, and alarm pop ups that flash by and are acknowledged at once were not tested.
Done when every hit of every search has a verdict in state.json and the user has seen the true and false counts per search.
Step 5: Set times, read the HMI and take the verdict quotes
Goal: each checked step has exact times, the HMI page and values read from frames, any alarm text, and the vendor's words.
- Set start_mmss and end_mmss from the transcript: the announcement line and the verdict line, in MM:SS of the clip. Add START from steps.csv when the user wants times in the full recording.
- Make a two frames a second contact sheet of the step (START_S is the announcement time in seconds in the clip; DURATION is the step's length in seconds):
ffmpeg -v error -ss START_S -t DURATION -i fat-evidence/clips/CLIP.mp4 -vf "fps=2,scale=256:-2,tile=6x7" fat-evidence/frames/FIELD_hN_sheet_%02d.png
Each sheet holds 42 tiles (21 seconds); sheet S, tile K (counting from 0) is at START_S + ((S - 1) * 42 + K) / 2 seconds. Use it to find the frames where the HMI page and any pop up are fully in view. Tiles are too small to read values; they only point to the frame to extract. 3. Extract that frame at full resolution with the Step 4 frame command and read the page title and every parameter value from it. Read values from a frame after the step ran (near the verdict) rather than at its start, because values change during the test. Read the alarm text from the frame where the pop up is fully visible. Never take a value or alarm text from Vivu's reason text. 4. If a value is cut off, behind glare, too small, or blurred, write UNCERTAIN and the frame path. If the screen did not show the step at all (the page of the previous step, a line overview, the camera pointing at the machine), write NOT SHOWN rather than copying values that belong to another step. 5. Copy the verdict quote from the transcript line where the vendor gives it, word for word, and set verdict_word to the vendor's own word (pass, deviation, accepted). If no verdict was said, leave both blank and say so; never infer one from the values.
In our test run every page title and value Claude read from the full frames of the synthetic HMI pages matched the screen, including the angled camera view with glare. On the public 360p video the large weight readouts and the page title were readable, while the small numbers under each hopper key were not readable with confidence and went in as UNCERTAIN. On the Step 5 contact sheet, the first and last tiles with the camera view's pop up were the tiles nearest to when it appeared and disappeared, so the sheet is precise enough to set alarm times. Quotes were taken from transcripts built from the clips' own timing, so local speech to text was not exercised in our test run.
Done when every checked step has start_mmss, end_mmss, hmi_page_title, hmi_values (or UNCERTAIN or NOT SHOWN), alarm_text and verdict_quote in state.json.
Step 6: Assemble the table and confirm the sample
Goal: the validation engineer gets one table in protocol order.
- Build one row per protocol step, in protocol order:
step_no,step_name,meeting_file,start_mmss,end_mmss,hmi_page_title,hmi_values,alarm_text,verdict_quote,verdict_word,frames,status,validation_engineer_signoff,deviation_no
4.2,Fill weight accuracy,FAT_day1_am.mp4,00:49,01:24,DOSING - FILL WEIGHT,"Target weight 250.0 g; Average (10) 249.6 g; Minimum 247.9 g; Maximum 251.2 g",ALARM A-117 NOZZLE 3 LOW FILL 247.9 g below limit 248.5 g,"Nozzle three was out on two samples, so we have a deviation on step four point two.",deviation,frames/step_4_2_h1_end.png;frames/alarm_popup_h2_mid.png,checked,,
4.3,Emergency stop on infeed guard door,FAT_day1_am.mp4,01:30,01:47,DOSING - FILL WEIGHT (screen did not change),NOT SHOWN,,"The line stopped in under one second. Step four point three passes.",pass,frames/step_4_3_h1_mid.png,checked,,
- Field mapping:
| Field | Source | If unavailable |
|---|---|---|
| step_no, step_name | the protocol step list | none |
| meeting_file | the source recording in steps.csv | none |
| start_mmss, end_mmss | transcript announcement and verdict lines (Step 5) | the window start and end, marked approximate |
| hmi_page_title, hmi_values | the full frame Claude read | UNCERTAIN or NOT SHOWN |
| alarm_text | the full frame with the pop up | blank when the alarm search found none in this step; this does not prove no alarm appeared |
| verdict_quote, verdict_word | the transcript | blank |
| frames | paths of the frames read | none |
| status | checked, candidate when frames could not settle it, or NOT FOUND | candidate |
| validation_engineer_signoff, deviation_no | left empty for the validation engineer | blank |
- Show the user two sample rows and the mapping, and wait for a yes before writing the full table. Say which fields are read or inferred (values and alarm text are read from frames; the step mapping of an alarm is inferred from times) and what changes if a read is wrong: a value on the FAT report that the screen never showed.
- Write fat_evidence.csv. A step whose search found nothing gets a row with status NOT FOUND; it means the search did not find it in the clips, not that the step was skipped. Add a short note under it with the counts per search (checked and rejected) and every UNCERTAIN or NOT SHOWN cell. Say in the note that a blank alarm_text means the search found no pop up in that step, not that the machine raised none; pop ups that flash and are acknowledged at once were not tested.
In our test run the table had one checked row per step, two with alarm text, and a NOT FOUND row for the control step; the user's approval of the sample rows was not exercised in our test run.
Hand the table to the user. Attaching it to the FAT report, sending it to the vendor or filing deviations is the user's step; if they ask Claude to send or file anything, name the destination, show exactly what will be sent, and wait for a yes. Sending was not exercised in our test run.
Done when fat_evidence.csv exists with one row per protocol step plus the count note, and the user has approved the sample rows.
Compliance
- Use only recordings that both the vendor and the buyer agreed to record, and that the NDA allows to be processed by a cloud service. Confirm this in Step 1, before anything is uploaded.
- Keep the Vivu project private: the footage shows the vendor's machine, process parameters and staff. The default visibility is the whole organization.
- The table copies what the screen showed and what the vendor said. It does not decide whether a test passed, whether the machine meets the user requirement specification, or whether anything complies with GMP or other rules; sign off belongs to the validation engineer.
- The table describes the machine and the test, never the vendor's people. The skill does no face, voice or identity recognition.
- The clips 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.
- Nothing is posted or sent. The table and frames stay in the working folder until the user hands them on.
Known failure modes
| Symptom | Cause | Fix |
|---|---|---|
| (observed) a step window starts inside the previous step's verdict; in our test run the step 4.2 window began at 00:45, while step 4.1's verdict was still being spoken | the time range contains the moment but is wider than it | set start and end from the transcript lines, not the window |
| (observed) the screen never showed the step; in our test run the E-stop step ran while the HMI stayed on the dosing page, and the reason still said the vendor "opens the door to run the test, and confirms the line stopped" | the reason describes the spoken step, not what is on screen | write NOT SHOWN for the values; take the result only from the transcript |
| (observed) start and end frames of an alarm window show no pop up | the window is wider than the time the pop up is on screen | judge on the middle frame; use the Step 5 contact sheet to find the full pop up |
| (observed) a segment summary covers two steps; in our test run the segment "Fill Weight Accuracy Test (Step 4.2)" also covered step 4.3 | summary segments follow topics, not protocol steps | use segments only as a second signal; step boundaries come from the transcript |
| (observed) small numbers on a camera view of the HMI cannot be read with confidence | low resolution, glare or an angled shot | write UNCERTAIN with the frame path; ask the vendor for the screen export or batch report |
| (observed) clips stay "queued" while another indexes | indexing runs through a queue | keep polling vivu_list_videos; do not upload the file again |
| a number in the reason text differs from the screen | the reason is a model description; on small or distant text it can invent digits | read every value from the full frame |
| a normal information banner is listed as an alarm | banners and pop ups look alike at a glance | reject hits whose frames show no alarm or fault code; count them |
| a verdict quote does not match what was said | it was copied from the reason text, which paraphrases | take every quote from the transcript line |
| a step returns nothing | the vendor said the number differently, or the step was outside the cut | search the transcript for the step name; widen the cut and reindex only that step |
| a list stops at exactly maximum_results | the cap cut the list short | raise maximum_results and rerun that search |
| "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 clip 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 |