SkillsSkill for Claude

Shopper FAQ log from replays

Give Claude your last two live selling replays, the comment export and the product list. It groups the comments into question types, cuts the stretches where questions cluster, prices the indexing, searches each type in a private Vivu project, checks every window against the transcript, and writes a CSV with the host's words, the product, reply or volunteered, and the color or size shown. The comment export has only the question, and the transcript often stops at "this one", so which piece she meant and what it looked like is only in the picture.

Maintained by Vivu. Updated 2026-11-19.

Download

shopper-faq-replay-log.zip

10 KB. Unzips to shopper-faq-replay-log/SKILL.md. Upload the zip as it is in the Claude app, or unzip it into your skills folder for Claude Code.

SHA-256 f002afab4f38b81126cbb646b9c5e39c0123d5d11005ace25c593a2623830907

At a glance

What the Shopper FAQ log from replays skill does, where it runs, what it needs, and when it asks
Looks forMoments where the host answers a shopper question such as sizing, shipping, color or stock, and what she was showing at that moment. The answer is often a few words, and the color and fit are only on camera. Every window is checked against the transcript before it reaches the log, and frames decide what was shown.
Runs onClaude Code on your computer (terminal or the Code tab of Claude Desktop), because it needs a shell and local replay files. No residential IP is needed and nothing is scheduled.
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 windows, measure minutes and extract frames.
  • Your replays as local mp4 files, because windows and frames come from the local files.
  • A comment export with times, which says what people asked and where to cut.
  • A transcript with timestamps, because quotes come from it and never from Vivu's reason text.
  • The product list, so product names come from your listing.
  • A browser that can open the Vivu upload page, because the connector has no direct upload tool.
Your Vivu planIndex minutes go to the cuts you approve, and each question type uses one precise search at 5 credits. The skill shows the cost against your plan in Step 5, before anything is uploaded. Two replays at 45 minutes each and eight question types are an estimated 90 index minutes and 40 search credits, which fits Premium but not Free.
Asks you firstUsing the replays and the people in them, the question types and cuts, the indexing cost, and the sample rows before the full log.

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 your own replays. Check that host and guest contracts cover this use; a replay with minors needs a guardian's consent or the skill does not process it.
  • Viewer nicknames stay out of the table and abuse in the comment export is not copied.
  • Speech search was tested on two French replays from one host; English streams, background music and several hosts were not tested. Short replies can be missed and an empty result does not prove a question was never answered.
  • Search results are candidates. Stock and ordering searches returned false windows in the test run, so read the rejected counts.
  • Color on a phone stream is not the product's true color, and the piece in frame can differ from the piece being discussed. Those rows say not shown, and support checks every row.
  • Material, care and health statements are the host's words. Check them against product data before they reach an FAQ.
  • The skill never writes outside the working folder. Claude in Chrome takes at most 10 MB per upload call, so larger cuts are added in the Vivu web app.
  • Cuts stay in your private Vivu project until you delete them.

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 a shopper FAQ log from last week's two live replays in this folder. The comment exports and product list are next to them. Our support team needs sizing, shipping, color and stock answers.

In Claude Code you can also type /shopper-faq-replay-log. 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 and collect the files
  8. Step 3: Turn the comment log into question categories
  9. Step 4: Cut the windows
  10. Step 5: Price the windows and get approval
  11. Step 6: Upload and index
  12. Step 7: Search each question category
  13. Step 8: Check each window against the transcript
  14. Step 9: Look at what the host is showing
  15. Step 10: Assemble the FAQ log
  16. Compliance
  17. Known failure modes

The full skill

This is shopper-faq-replay-log/SKILL.md from the download, as Claude reads it: the frontmatter first, then the instructions.

---
name: shopper-faq-replay-log
description: "Build a shopper FAQ log from your live selling replays with Vivu: the host's answers by question type, her words, the color or size shown, as a CSV for support. Use after streams."
---

Shopper FAQ log from selling stream replays

This skill takes the last couple of replays from the user's own live selling channel, the comment export and the product list, and returns one table that customer service can write FAQs from. Claude groups the comments into six to eight question types (which size to pick, shipping, color, stock), cuts the stretches where questions cluster, prices the indexing against the user's Vivu plan, indexes the cuts in a private Vivu project, runs one search per question type, checks every window against the transcript, looks at frames to note which color or size the host had on, and writes a CSV: question type, product, replay file, start and end, reply or volunteered, the host's words, the color or size shown, the frame path, and an empty "cs_checked" column. Support staff turn the rows into FAQ text.

The value is in the half of the conversation that nothing else records. The comment export holds only the question. The transcript holds the answer, but the host rarely repeats the question ("yes, we ship worldwide"), and her words often stop at "this one" or "here, as you can see". Which piece she means, what color it is, and how it sits on her are only in the picture. The picture can also mislead on its own: the host may answer about a blazer from earlier while wearing the next jacket, so a frame without the transcript hangs the answer on the wrong product. So the search finds the reply, the transcript supplies the words and the product, and the frames supply what was shown, and only when the piece in frame is the piece being discussed.

When to use

Use when a live selling operator or support lead says "pull what the host already answered in last week's lives", "we keep getting the same size questions, what did she say on stream", "make an FAQ sheet from the replays", or "what color was she wearing when she answered that". For one question about one replay, search Vivu directly. To index where each product was pitched for an editor, use the live-shopping-product-index skill. For webinar or course questions, use webinar-qa-answer-sheet or lecture-faq-answer-sheet. This skill works after the stream on the user's own downloaded replays; it does not process a live stream, cut or publish clips, score conversion, or import platform links.

Working principles

  1. Report measured numbers, not estimates. When a number is an estimate, say so.
  2. A Vivu window is a candidate. A row is verified only after the transcript shows the host saying something that answers this question type. Rejected candidates are counted and kept in rejected.csv with the reason.
  3. Stop and tell the user when a required capability or file is missing (no replay, no transcript, 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 question types and windows before upload, the indexing cost, and the sample rows before the full log.
  5. Viewer nicknames never enter the table. Hosts say names aloud, so replace each one in a quote with [viewer]. Abuse in the comment export is not copied anywhere.
  6. Material, care and health claims are left for support to check against product data. The host's words are what she said, not what is true of the product.

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 replays cut the windows, measure minutes, extract frames ffmpeg -version and ffprobe -version
The replays as local mp4 files from the stream back office windows and frames come from the local files; Vivu has no export tool, and this skill never imports platform links ls REPLAY_FOLDER
A comment export for each replay, with times it says what people asked and where to cut ask the user to paste or point to the export
A transcript with timestamps (platform captions, or the output of a local speech to text tool) quotes come from it, never from Vivu's reason text ls REPLAY_FOLDER for a .vtt or .srt
The product list from the back office product names in the table come from the listing, not from guesses ask the user to paste or export it
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

The skill needs a shell and local files, so it runs in Claude Code on the user's computer (terminal or the Code tab of Claude Desktop). It downloads nothing from YouTube, so no residential IP is needed. Nothing is scheduled and nothing is written outside the working folder.

Inputs to collect

Ask for anything missing, most important first.

  1. The replay files, with their transcripts and comment exports (REPLAY_FOLDER). Required.
  2. The product list. Required.
  3. How many replays. Default: the last 2.
  4. Minutes to cut per replay. Default: about 45, chosen from where questions cluster.
  5. Extra question types the support team cares about. Default: the six to eight most common in the comments.
  6. The Vivu project name. Default: "Shopper FAQ MONTH", private.

Files and state

Keep everything in one working folder next to the replays:

faq-log/
  categories.csv        question type, example comment shape, count, time ranges per replay
  windows.csv           replay file, CUT_START, CUT_END, minutes, cut file
  cut/                  the files that get uploaded
  results/              raw search results, one JSON file per question type
  frames/               contact sheets and full frames
  shopper_faq_log.csv   one row per checked answer
  rejected.csv          windows that failed a check, with the reason
  state.json            uploaded files and video ids, searches with job ids, every window with its verdict, rows written

state.json is updated after every step. A rerun reads it first: uploaded cuts are not uploaded again, searches already run are not rerun, and checked windows keep their verdicts, so an interrupted run resumes where it stopped.

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, and list REPLAY_FOLDER.
  3. Create the working folders; ffmpeg does not create an output folder:
mkdir -p faq-log/cut faq-log/results faq-log/frames

Run every later command from inside faq-log/ (cd faq-log).

Done when vivu_get_account shows can_create_projects: true, ffmpeg and ffprobe print versions, and the folders exist.

Goal: the user has confirmed the replays may be used, and Claude has every file.

  1. Ask Compliance items 1 to 3 before anything else in this step. Stop if a replay fails them.
  2. Confirm the transcript's times are offsets into the same file (the first caption should fall near the host's first words), and that the comment export's times are offsets too. If the export shows clock times, ask for the stream start and subtract it.

Our test run used public replays, so this step was not exercised in our test run.

Done when the user has confirmed Compliance items 1 to 3 and each replay has a transcript and a comment export.

Step 3: Turn the comment log into question categories

Goal: six to eight question types and the stretches of each replay where they cluster.

  1. Read the comment export. Ignore greetings and chatter, and do not copy nicknames or abuse. Group the real questions into six to eight types in the support team's words: sizing, shipping, color, stock, ordering, care, returns.
  2. For each type, note the time ranges with the most questions. A reply can come seconds later or much later, because hosts batch them, so extend each range a few minutes forward.
  3. If the export is thin, add ranges from a keyword search of the transcript (size words, "ship", "deliver", "left", "sold out", and the same in the stream's language).
  4. Choose cuts adding up to about 45 minutes per replay. Show the user categories.csv and the cuts, and say which types have few or no questions; those will produce few rows, and that is a true result. Never pad a type.

In our test run the public chat replays were thin and partly abusive, so the cuts came mostly from caption keywords.

Done when the user has approved categories.csv and the cut list.

Step 4: Cut the windows

Goal: one short file per cut, so index minutes go only where the questions are.

Cut with re-encoding, so each file starts exactly at CUT_START and every Vivu time maps back to the replay by adding CUT_START. CUT_START and CUT_END are in seconds in the original replay, REPLAY_FILE is the original file, and N numbers the cut:

ffmpeg -v error -ss CUT_START -to CUT_END -i REPLAY_FILE -c:v libx264 -c:a aac cut/window_N.mp4

A stream copy (-c copy) is faster but starts at the nearest keyframe, and then every time in the table is off by an unknown amount.

Done when cut/ holds every cut, ffprobe durations match windows.csv, and windows.csv records each CUT_START.

Step 5: Price the windows and get approval

Goal: the user sees the cost before anything is uploaded.

  1. Measure each file and sum the minutes (ffprobe takes one input per call):
ffprobe -v error -show_entries format=duration -of csv=p=0 cut/window_N.mp4
  1. Call vivu_get_usage for the plan and what remains this month.
  2. Search credits: one precise search per question type at 5 credits, plus 5 for each rewording. Label the total as an estimate.
  3. Show one table and wait for approval:
This batch Remaining on the plan
Index minutes measured sum from vivu_get_usage
Search credits estimate from vivu_get_usage

For reference, the Free plan has 20 index minutes a month and 50 search credits a month; Premium is $30 a month with 180 index minutes and 500 search credits. As an estimate, two replays at 45 minutes each are 90 index minutes, and eight question types are 40 search credits, which fits Premium but not Free. Indexing two whole three hour replays would need 360 minutes. If the cuts do not fit, offer these levers in order: shorter cuts around the densest question ranges, one replay now and one next month, and only then a larger plan. Say which questions the smaller set leaves out.

Our account has no plan limit, so the comparison and the approval were not exercised in our test run.

Done when the user has approved the minutes and the credit estimate.

Step 6: Upload and index

Goal: every cut is ready in a private Vivu project.

  1. Call vivu_list_projects and reuse the project named in the inputs if it exists. Otherwise call vivu_create_project with that name and visibility "private". The default visibility is the whole organization, and replays can show unreleased products and prices.
  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, so never paste it into a file. Give it to the user to open in their own browser and choose the files in cut/, or attach them with a browser tool that can upload local files. Claude in Chrome accepts at most 10 MB per upload call; these cuts are usually larger, so the user adds them in the Vivu web app. Never split or recompress a cut to fit.
  3. Poll vivu_list_videos about every 30 seconds until every file shows ready. Match each video back to windows.csv by file name; Vivu turns spaces and punctuation in names into "_". Record the video IDs in state.json.

In our test run the files went up through a script, so the browser upload path was not exercised in our test run.

Done when vivu_list_videos shows every cut in windows.csv as ready.

Step 7: Search each question category

Goal: one raw result file per question type.

Run one search per question type with vivu_search_videos (project_id, query, mode "precise", maximum_results 20). Each call 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 result as results/TYPE.json without the result_page_url field. Show the result page link in the live reply only, and say there that it expires in 4 hours; for that reason it never goes into the log or any file.

Field Query Mode maximum_results
sizing the host answers a viewer's question about which size to pick or how a piece fits precise 20
shipping the host answers a viewer's question about delivery, shipping or when an item will arrive precise 20
color the host answers a viewer about which colors a piece comes in or which color to pick precise 20
stock the host says a size or piece is sold out, that only some sizes are left, or that it is still in stock precise 20
ordering the host explains to a viewer how to place an order precise 20
care or another type the host answers a viewer's question about TOPIC precise 20

All searches are precise because the log needs time ranges; a fast search returns whole files with no reason, and the cuts are already chosen. One search per type keeps a common type from using up the places in a mixed list. maximum_results 20 is above what these cuts returned, and it is the ceiling: a list that stops at exactly 20 means the cap was hit, so raise it and rerun.

Write queries in English, and name the type in the support team's words. In our test run English queries found French speech; queries written in the stream's language were not exercised in our test run, so treat them as candidates. The care query is also a control: if nobody asked about care, it should return nothing. If the first page has several wrong windows, reword once by saying what the host literally says ("sold out", "only some sizes left") rather than who she is talking to.

Why this chain: the search finds a moment the comments ask about, the transcript turns it into the host's words, and the frames flip from what was said to what was shown.

Done when results/ holds one file per question type and state.json records the job IDs.

Step 8: Check each window against the transcript

Goal: every window has a verdict and every row has the host's words.

Vivu returns a time range that contains the moment, not the exact second, and the reason text is a paraphrase that can get the point wrong, so it never goes into the log.

  1. Read the transcript lines inside the window, plus a few lines before it, because the question may be answered mid sentence.
  2. Keep the window if the host says something that answers this question type. Set answer_type to reply when she is responding to a viewer (she uses a name, says "you", or answers something nobody on stream raised) and volunteered when it is part of her routine for the product. Both are useful to support; the column lets them tell advice to one viewer from a standing rule. When the host says when new stock reaches the shop, file the row under stock, not shipping, and say so in notes.
  3. Set the row's start and end to the first and last transcript line of the answer, not the window edges. Add CUT_START to get replay time.
  4. Copy the words exactly into host_quote, in the stream's language, with names replaced by [viewer]. Auto captions garble sizes and product words; when a quote holds a size, run a local speech to text tool on that moment if one is available; otherwise write "size from captions, listen before use" in notes, because Claude cannot hear the audio.
  5. Work out the subject: which product the words are about, from the transcript and the product list. If she is answering about something shown earlier, write that product, not the one in the picture. Write "all products" for general answers.
  6. Read vivu_get_video_summary with include_segments, start_ms and end_ms around a window only as a second signal. Its segments can run for minutes and skip short replies.
  7. Windows that fail go into rejected.csv with the reason. They are counted, not dropped silently. An empty result does not prove the host never answered: say so for that type.
Worked example from our test run

In our test run we used 4 cuts from 2 public Creative Commons replays of a plus size clothing live sale in French, 40 minutes in total, in one continuous voice with the host reading comments aloud. We wrote down the answers we found in the captions before searching; that list later proved incomplete, and hits on the lines it lacked still count as false here. The queries were in English against French speech. The cuts were ready within 11.8 minutes of the start of the upload, and the run used an estimated 35 search credits.

The sizing search returned 9 windows: 9 real, 0 false, 1 missed reply (a question about wearing a sweater under a blazer). Some of the sizing windows were volunteered lines rather than replies. The shipping search returned 2 windows: 2 real, 0 false, 1 missed. Most of the shipping replies in the cuts, including the second hit, said when new stock would reach the shop rather than anything about delivery to a shopper, so delivery answers were barely tested (the delivery reply was "bonsoir oui on livre dans le monde entier", where the question is never repeated). The color search returned 9 windows: 9 real, 0 false, 2 missed. Sizing windows were 17 to 46 seconds wide. These queries were the first wording on this corpus. The stock query took 1 rewording on the same corpus: the first wording returned 8 windows, 3 real and 5 false, mostly the host reading out a price and size range, and the final wording returned 5 windows, 4 real and 1 false, 1 missed. The ordering search returned 5 windows, 3 real and 2 false, with 4 missed, and none of its windows came from the first stream, so treat ordering as the weakest type here. The care control returned 0. The sizing, shipping and color windows went on to Steps 9 and 10; stock and ordering windows were checked against the transcript but not logged. A small corpus and one host cannot promise these rates. English language streams, background music and streams with several hosts were not exercised in our test run.

Done when every window has a verdict in state.json and the user has seen the real and rejected counts per question type.

Step 9: Look at what the host is showing

Goal: shown_color_or_size is filled from frames, or marked as not shown.

  1. Make a sheet of one frame every half second across the answer. START and DURATION are in seconds inside the cut, TYPE is the question type and ROW the row number, and ROWS is DURATION divided by 4, rounded up (8 frames per sheet row at 2 frames a second):
ffmpeg -v error -ss START -t DURATION -i cut/window_N.mp4 -vf "fps=2,scale=192:-2,tile=8xROWS" -frames:v 1 frames/TYPE_ROW_sheet.png

Keep the quotes around the filter. Look at the sheet. Hosts walk off camera and swap pieces inside a window, so one frame is not enough. 2. Pull one full frame at the clearest moment and read it (SECONDS is the moment inside the cut):

ffmpeg -v error -ss SECONDS -i cut/window_N.mp4 -frames:v 1 -q:v 3 frames/TYPE_ROW_read.png
  1. Compare the piece in frame with the subject from Step 8. If they match, write the color, and the size only if she says it or a label is legible, for example "yellow T-shirt worn, size from her words". If they differ, write "not shown" and name what is on screen. Never fill the column from the piece that merely happens to be in frame.
  2. When the color is uncertain under the lights, write UNCERTAIN. Color rendering on a phone stream is not the product's true color, which is why support sees the frame path and decides. If the sheet shows several colorways in turn, list them in the order shown.

In our test run we made this sheet for each of the 9 color windows, including a 360p vertical stream, where a 37 second sheet was tall but readable. At most of the places we compared, the frame showed the colors the host named, in the order she named them. On a long printed shirt the colorways were hard to name from the sheet, so that row says UNCERTAIN, and on a reply the piece she meant was not in frame. The "not shown" rows came in two kinds: the host talking about a different piece from the one in frame (the tweed blazer answer), and general answers where no piece was involved (the worldwide shipping reply).

Done when every verified row has a frame path, and shown_color_or_size holds a color, "not shown" or UNCERTAIN.

Step 10: Assemble the FAQ log

Goal: one CSV that support can write from.

  1. Write the rows sorted by question type, then product:
question_category,product,replay_file,start,end,answer_type,host_quote,quote_source,shown_color_or_size,frame_path,notes,cs_checked
sizing,faux leather skirt,replay_b.mp4,01:14:55,01:15:06,reply,"pour la jupe ... je porte la taille en dessous ... la taille 48 voilà comme ça tu te fais ton idée",platform captions,brown skirt worn with black jacket,frames/sizing_h8_sheet.png,,
  1. Field mapping:
Field Source If unavailable
question_category categories.csv none
product transcript subject, named as in the product list "all products", or UNCERTAIN
replay_file windows.csv none
start, end CUT_START + first and last transcript line window edges, marked UNCERTAIN
answer_type Step 8 none
host_quote transcript, word for word, names as [viewer] NOT VERIFIED
quote_source platform captions or local speech to text none
shown_color_or_size Step 9 "not shown" or UNCERTAIN
frame_path Step 9 blank
notes "check against product data" for material, care and health claims; caption problems blank
cs_checked left empty for support blank
  1. Show two or three sample rows and the mapping, and wait for a yes before writing the full log. Say which parts are inferred: the product is Claude's reading of the transcript, and reply versus volunteered is a judgment.
  2. Write shopper_faq_log.csv and rejected.csv. Give the counts per question type, and list the types with few or no rows, so support knows what the replays do not answer. The file stays in the working folder; sending it on is the user's step.

In our test run the log had 20 rows, one for each sizing, shipping and color window that passed the transcript check, with the second shipping window filed under stock; most of the volunteered sizing lines in the cuts were never returned. The user's approval of the sample rows was not exercised in our test run.

Done when shopper_faq_log.csv exists with a row for every checked answer, cs_checked is empty, and the user has approved the sample rows.

Compliance

  1. Use only the user's own stream replays (their store or brand, or a stream they have rights to). Do not process another seller's recording, and do not import platform links. Ask before Step 2.
  2. Hosts and guests on camera: check that their contracts or releases cover this use. If minors appear (kids' clothing try ons, family guests), the skill needs a guardian's consent or it does not process that replay. Ask before Step 2.
  3. Viewers: nicknames and comment text stay out of the table, and the user confirms the replays and comments may be processed by a third party service. Ask before Step 2.
  4. The cuts stay in the user's Vivu project until the user deletes them. Create the project as private. The skill never calls vivu_delete_video or vivu_delete_project unless the user asks, and confirms first.
  5. A host's words are not a product claim that support can reuse as is. Material, care and health statements are checked against product data before they reach an FAQ. Advice given to one viewer is marked reply so it is not published as a rule.
  6. The skill does not process live streams, cut or publish clips, or measure conversion. No face, logo or body recognition: a product is identified only by what the host says and the product list.

Known failure modes

Symptom Cause Fix
(observed) the frame shows a jacket while the answer is about a tweed blazer: "frame shows a different product from the answer" the host answers about an earlier piece while wearing the next one take the product from the transcript and mark the column as not shown
(observed) the reason says "when their order will arrive" but the host means stock reaching the shop the reason paraphrases and fills in the subject read the transcript lines before the window; never copy the reason
(observed) the first stock wording returned 5 false of 8 windows the host reads out sizes and prices for each piece, which sounds like availability reword with what she literally says (sold out, only some sizes left)
(observed) a short reply is missed: 1 in sizing, 1 in shipping replies of a few seconds sit in the middle of selling talk grep the transcript for that type's keywords inside the cuts as a second pass
(observed) the video summary says nothing about a sizing reply segments run for minutes and summarize the product use segments only as a second signal; rows come from the transcript
(observed) the reason says the host answers a viewer when she is reading her own color list the reason guesses from the query wording set answer_type from the transcript
(observed) the ordering search stayed pending for 656 seconds and returned nothing from the first stream a slow job and a low recall type keep polling; a pending search is not a stalled one; add a keyword pass for ordering
(observed) a care search returned 0 nobody asked about it in those cuts report the type as unanswered; an empty result does not prove it was never said
a quote has a wrong size or product word auto captions garble numbers and names run a local speech to text tool on that moment if one is available; otherwise write "size from captions, listen before use" in notes for a person to check
a list stops at exactly maximum_results the cap cut the list short raise maximum_results and rerun that search
table times are off by a few seconds the window was cut with -c copy cut with re-encoding
"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 file 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.