SkillsSkill for Claude

FAT witness evidence table

Give Claude the recordings of a remotely witnessed factory acceptance test, the meeting transcript and the protocol's step list. It cuts only the witnessed steps, prices them against your Vivu plan, indexes them in a private project, runs one search per step and one for alarm pop ups, reads the HMI page, values and alarm text from full frames, copies the vendor's pass or deviation words from the transcript, and writes a table with blank sign off and deviation columns for the validation engineer.

Maintained by Vivu. Updated 2026-11-19.

Download

fat-witness-evidence-table.zip

10 KB. Unzips to fat-witness-evidence-table/SKILL.md. Upload the zip as it is in the Claude app, or unzip it into your skills folder for Claude Code.

SHA-256 c041cf32e7914b4e889641300984bd6b14b2dd52d2a24953e225e16d3ce1c304

At a glance

What the FAT witness evidence table skill does, where it runs, what it needs, and when it asks
Looks forThe stretch where the vendor runs each protocol step, what the HMI showed while it ran, and alarm pop ups nobody mentioned. The transcript only says it passed; the values and alarms are only on screen. Every hit is checked against the recording before it reaches the table.
Runs onClaude Code on your computer (terminal or the Code tab of Claude Desktop), because it cuts the recordings and reads frames with ffmpeg from local files. No residential IP and no scheduler are needed.
Needs
  • The Vivu connector with write access, to create a private project, upload and search
  • ffmpeg and ffprobe, to cut the step segments, measure minutes and extract frames
  • The FAT call recordings on local disk, because frames and cuts come from the originals
  • The meeting tool's transcript for each recording, for step times and verdict quotes
  • The FAT protocol step list, for one search per step and the step column
  • Confirmation that both parties agreed to the recording and that it may go to a cloud service
  • A browser that can open the Vivu upload page
Your Vivu planIndex minutes are only the cut step segments, not the whole FAT. Searches are one precise search per step plus one for alarms, for example about 55 credits for ten steps as an estimate. The skill shows the minutes and credits against your plan and waits for approval before uploading.
Asks you firstRecording consent and NDA clearance before upload; the cut list and the minutes and credit estimate before indexing; two sample rows and the field mapping before writing the full table; any sending or filing, which it does not do on its own.

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

  • Use only recordings both the vendor and the buyer agreed to, and that the NDA allows to be processed by a cloud service.
  • The verdict column copies the vendor's words; the skill does not decide whether a test passed or complies with GMP, and sign off stays with the validation engineer.
  • HMI values are read by Claude from full frames, never from Vivu's reason text; small or angled numbers that cannot be read with confidence are marked UNCERTAIN.
  • Step windows are wider than the step and can start in the previous one, so times come from the transcript.
  • Tested on a small synthetic corpus plus one short public video; long real calls with crosstalk were not tested.
  • Clips stay in your private Vivu project until you delete them.
  • Claude in Chrome uploads at most 10 MB per call; larger clips are added in the Vivu web app, never split or recompressed.
  • Nothing is sent or filed on your behalf without your explicit approval.

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:

Build the FAT evidence table from yesterday's witness call. Recordings and transcripts are in ~/FAT/filler-line, and these are the protocol steps we witnessed:
4.1 Line speed verification
4.2 Fill weight accuracy
4.3 Emergency stop

In Claude Code you can also type /fat-witness-evidence-table. 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: Cut the step segments and price the indexing
  8. Step 3: Upload and index
  9. Step 4: Search each step and the alarms, then check every hit
  10. Step 5: Set times, read the HMI and take the verdict quotes
  11. Step 6: Assemble the table and confirm the sample
  12. Compliance
  13. Known failure modes

The full skill

This is fat-witness-evidence-table/SKILL.md from the download, as Claude reads it: the frontmatter first, then the instructions.

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

  1. Report measured numbers, not estimates. When a number is an estimate, say so.
  2. Nothing goes into the table until it has been checked against the recording. Search results are candidates; a rejected candidate is counted, not written.
  3. 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.
  4. 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.
  5. 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.
  6. 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.

  1. The recordings folder and the transcripts. Required.
  2. The protocol steps to witness, with number and name. Required. Default: every step in the list the user pastes.
  3. 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.
  4. 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.
  5. 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.

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

  1. 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
  1. Call vivu_get_usage for the plan and what remains this month.
  2. 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.
  3. 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.

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

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

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

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

  1. 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.
  2. Keep the Vivu project private: the footage shows the vendor's machine, process parameters and staff. The default visibility is the whole organization.
  3. 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.
  4. The table describes the machine and the test, never the vendor's people. The skill does no face, voice or identity recognition.
  5. 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.
  6. 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

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.