SkillsSkill for Claude

Dev stream announcement sheet

This skill takes your studio's own dev stream recordings, the run of show and the topics for your recap post, trims the waiting screen and giveaways, indexes the rest in a private Vivu project, runs one search per topic and one for on-screen dates and numbers, checks every window against the transcript and frames, and writes an announcement sheet (topic, time, the developer's words, the value read from a frame, a replay link, an empty dev_confirmed column) plus a recap draft. The value is in what only the stream shows: developers say "look, this is what it does now", and what changed, what the new zone looks like and the day on a date card are on screen, while auto captions mangle game names that a search by meaning still finds.

Maintained by Vivu. Updated 2026-11-19.

Download

devstream-announcement-sheet.zip

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

SHA-256 5e3325f59e0feac5162793a5592f52264926e82f518af80559911a51a9af0e64

At a glance

What the Dev stream announcement sheet skill does, where it runs, what it needs, and when it asks
Looks forThe stretch where the developers talk about each topic on your list, and the date cards and stat cards shown on screen. Every window is checked against the transcript and frames from the trimmed recording before it reaches the sheet, and quotes, dates and numbers never come from Vivu's summary text.
Runs onClaude Code on your computer (the terminal or the Code tab of Claude Desktop), because it reads local recording files and runs ffmpeg and a small Python helper. No residential IP and no scheduler: run it once per stream.
Needs
  • The Vivu connector with write access, to create a private project, upload and search.
  • A shell with ffmpeg, ffprobe and python3, to trim the streams, measure them, pull frames and print transcript lines.
  • A transcript per recording (captions from your own channel or local speech to text), because quotes come from it.
  • The recording files and the run of show, so the waiting screen and giveaways are left out.
  • The topic list for the recap, each with one or two details only that topic has.
  • An upload path: the Vivu upload page in your own browser, or a browser tool that can attach local files.
Your Vivu planIndexing uses Vivu index minutes equal to the trimmed stream length; each topic is one precise search, plus one search for on-screen dates and numbers. The skill shows minutes and credits against your plan before uploading. In our test run, 30.3 minutes of dev stream video was indexed.
Asks you firstApproval of the index minutes and search credits before upload, of the topic wording before searching, of one sample sheet row and field mapping before writing the rest, and of the destination and full post before the recap goes anywhere. It also asks you to confirm the recordings are your studio's 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 your studio's own recordings, not replays pulled from a streaming platform; leave out viewer call-ins and any minors.
  • The skill does not identify people by face or voice; it names only what the stream's name cards or run of show show.
  • Dates and numbers are read from frames and stay unconfirmed until your dev team fills dev_confirmed; small in-game numbers are often left for a person to read.
  • Topic searches were tested only with details taken from the streams' own captions; searches with only a topic name were not tested.
  • Search windows can start after a topic begins or run past a card, so the skill reads the transcript around each window and picks frames inside it.
  • The recordings stay in a private Vivu project in your account until you delete them.
  • Browser upload tools such as Claude in Chrome take at most 10 MB per call, so streams are usually added in the Vivu web app; files are never split or recompressed.
  • Posting the recap acts as you, so the skill shows the full post and waits for your yes first.

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 announcement sheet and recap draft for yesterday's dev stream. The recording and run of show are in ~/Streams/devstream-nov, and here are the topics we want covered.

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

What is inside

  1. When to use
  2. Working principles
  3. What you need before starting
  4. Inputs to collect
  5. Files and state
  6. Step 1: Check the Vivu connector and the setup
  7. Step 2: Trim each stream with the run of show and price the job
  8. Step 3: Upload and index
  9. Step 4: Search each topic and the on screen values
  10. Step 5: Check every window against the transcript and frames
  11. Step 6: Build the announcement sheet and the recap draft
  12. Step 7: Dev team check and hand off
  13. Compliance
  14. Known failure modes

The full skill

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

---
name: devstream-announcement-sheet
description: "Turn your studio's dev stream recordings into a topic by topic announcement sheet with Vivu: when each topic was said, the dev's words, and dates or numbers read from frames. Use before a recap post."
---

Dev stream announcement sheet

This skill takes the recording files of your studio's own dev streams, the run of show, and the list of topics you want in the recap post (a new map, a balance change, new cosmetics, a release date, a known bug fix), and returns an announcement sheet: one row per topic window with the start and end time, the developer's own words copied from a transcript, any date or number read from a full frame, the frame it was read from, a link to the official replay at that second, and an empty dev_confirmed column for the dev team. Claude trims the waiting screen and giveaway segments using the run of show, prices the job against your Vivu plan, uploads the trimmed files to a private Vivu project, runs one search per topic and one search for on-screen dates and numbers, checks every window against the transcript and frames from that window, and writes the sheet and a recap draft.

The value is in what only the stream shows. Developers say "look, this is what it does now" or "here's the map": what changed, what the new zone or outfit looks like, and the day written on a date card are on screen, and the transcript only has "this" and "here". Auto captions also mangle game names (in our test run they wrote a hero's heirloom skin as "Nea Air Loom", the next update as "towel" and a new zone as "Forex"), so a keyword search of the transcript misses topics that a search by meaning finds. Vivu's windows stay candidates until the transcript inside the window shows the developers talking about that topic, and every quote, date and number comes from the transcript or a frame, never from Vivu's reason text.

When to use

Use when a community manager asks "what did we announce on yesterday's dev stream, with timestamps?", "build the recap post for the dev stream from these two recordings", "find where the devs talked about the release date, the new map and the balance changes", or "make the FAQ for the stream and link each answer to the replay".

Not for these:

  1. One question about one stream ("when did they say the date?"): search Vivu directly and look at the window.
  2. Finding funny or hype moments to cut into short clips. The stream-vod-clip-shortlist skill (https://vivu.ai/skills/stream-vod-clip-shortlist) is built for that; this skill does not cut clips or rank highlights.
  3. Live highlights while the stream is running. This skill works on the finished recording.
  4. Recordings your studio does not own, or replays pulled from a streaming platform. Use your own recording files.
  5. Internal sprint demos for a B2B release note. The release-notes-screenshot-sheet skill (https://vivu.ai/skills/release-notes-screenshot-sheet) is built for that.

Working principles

  1. Report measured numbers, not estimates. When a number is an estimate, say so.
  2. Nothing is verified until it has been checked against the source. A topic window is a candidate until the transcript inside it shows the developers on that topic; a date or number is a candidate until a full frame shows it. Vivu's reason text paraphrases and can describe numbers that are not on screen, so it never fills a cell.
  3. Stop and tell the user when a required capability or tool is missing. Do not guess around it.
  4. Ask the user before anything that is expensive to redo (the indexed minutes, before upload) and before anything that acts on their behalf (posting the recap or putting the sheet anywhere outside the working folder).
  5. A topic with no kept row is reported as "not found in the indexed segments", which is a finding about the search and the trim, not proof that the developers never mentioned it.

What you need before starting

Check each item at the start of the run and tell the user plainly what is missing before doing anything else.

Requirement Why How to check
Vivu connector with write access create a private project, open its upload page, search vivu_get_account shows can_create_projects: true (tool names may carry a server prefix). A write call failing with "has not granted vivu.write" means the user reconnects Vivu and allows write access
A shell with ffmpeg, ffprobe and python3, on the computer that holds the recordings trim segments, measure lengths, extract frames, print transcript lines ffmpeg -version, ffprobe -version, python3 --version
A transcript for each recording: captions exported from the stream platform for your own channel, or a local speech to text tool such as whisper.cpp quotes come from the transcript, never from the reason text open the .vtt or .srt file, or run whisper-cli --help
The recording files and the run of show the run of show says which parts to leave out (waiting screen, giveaways, breaks) the user names the folder; Step 2 lists the files
The topic list for the recap each topic becomes one search the user pastes it; Step 2 confirms it
An upload path move the files into Vivu vivu_open_upload_page plus the user's own browser, or a browser tool that can attach local files

This skill needs Claude Code on the user's computer (the terminal or the Code tab of Claude Desktop), because it reads local recording files and runs ffmpeg. Claude on the web and cloud sessions cannot do that. It downloads nothing, so no residential IP is needed. Nothing recurs, so no scheduler is involved; run it once per stream. The only connector it needs is Vivu; posting the recap anywhere uses whichever connector the user names, after approval.

Inputs to collect

Ask for anything missing, most important first.

  1. The recording files: one file per stream, from the recording machine or the shared drive. Required.
  2. TOPICS: the topics for the recap, each with one or two details only that topic has (a name, a place, a weapon, a mechanic, the date if the team already knows it). Required. Six to eight per stream is typical. The details are what keep a topic search off the neighboring topic. In our test run the details came from the captions of the same streams; searches with only a topic name were not tested.
  3. The run of show for each stream, or the start and end of the waiting screen, giveaways and breaks. Default: ask the user to name them; without it, index the whole file and say so in the price table.
  4. REPLAY_URL for each stream: the official replay link the community will use. Default: leave replay_link blank.
  5. Where the recap goes. Default: local files only; anything else waits for approval in Step 7.
  6. WORK_NAME: a short name for the working folder and the Vivu project. Default: stream and date, for example devstream-2026-11.

Files and state

Keep everything in one working folder:

devstream-WORK_NAME/
  config.json              topics with their details, REPLAY_URLs, Vivu project id, query wording, destination
  segments.csv             nn, stream, file, keep_start_s, keep_end_s, duration_s, video_id
  source/                  the original recordings and their transcripts (.vtt or .srt)
  segments/                the trimmed files, named NN_STREAM.mp4
  results/                 one JSON per search, without the result page link
  frames/                  window frames, half second contact sheets, the full frames values were read from
  candidates.csv           every window Vivu returned, with the verdict and a one line reason
  announcement_sheet.csv   one row per kept topic window
  recap_draft.md           the recap post draft
  srt_window.py            the transcript helper from Step 5
  state.json               steps done, files uploaded, searches run with job ids, windows checked

Run every command from the folder that contains devstream-WORK_NAME/. A rerun reads state.json first: a file marked uploaded is not uploaded again, a search with a saved result is not run again, and a window with a verdict in candidates.csv is not checked again.

Step 1: Check the Vivu connector and the setup

Goal: confirm every requirement before spending anything.

  1. Call vivu_get_account. If the tool does not exist, tell the user to add the Vivu connector in Claude (https://mcp.vivu.ai/mcp) and stop. If the account does not show can_create_projects: true, or a later write call fails with "has not granted vivu.write", ask the user to reconnect Vivu and allow write access, then stop until they have.
  2. Run ffmpeg -version, ffprobe -version and python3 --version, and open one transcript file.

Done when vivu_get_account shows can_create_projects: true, the three commands print a version, and every recording has a transcript.

Step 2: Trim each stream with the run of show and price the job

Goal: one trimmed file per stream, with its length and price approved before upload.

  1. Confirm the Compliance items with the user before touching the files.
  2. Read the run of show and write segments.csv: for each stream, the part to keep (KEEP_START_S to KEEP_END_S, in seconds of the original recording). Leave out the waiting screen, giveaways, sponsor reads and breaks; keep everything where developers talk about the game. When a topic sits inside a giveaway block, keep that block.
  3. Cut each kept part with a re-encode, so the cut points are exact and the file's time plus KEEP_START_S is the time in the original recording. STREAM is a short lowercase name with no spaces, so Vivu keeps the file name:
ffmpeg -v error -y -ss KEEP_START_S -to KEEP_END_S -i devstream-WORK_NAME/source/RECORDING.mp4 -vf "scale=-2:720" -c:v libx264 -preset veryfast -crf 23 -c:a aac devstream-WORK_NAME/segments/NN_STREAM.mp4

720p keeps date cards and stat numbers readable at a fraction of the original size. 4. Measure each file and write duration_s:

ffprobe -v error -show_entries format=duration -of csv=p=0 devstream-WORK_NAME/segments/NN_STREAM.mp4
  1. Call vivu_get_usage and show one table:
This job Plan allowance Remaining this month
Index minutes sum of duration_s / 60 from vivu_get_usage from vivu_get_usage
Search credits one precise search per topic plus one screen search per stream, 5 credits each, plus 5 for each rewording (estimate) from vivu_get_usage from vivu_get_usage

Plan facts: Free is $0 a month with 20 index minutes a month and 50 search credits a month; Premium is $30 a month with 180 index minutes and 500 search credits. A precise search uses 5 credits in total. For example, a 90 minute stream with 20 minutes of waiting screen and giveaways trims to about 70 minutes, so Premium covers about two streams a month on minutes (estimate); eight topics and one screen search are 45 credits (estimate).

  1. If the job does not fit, offer levers in this order: trim further to the topic blocks in the run of show, index one stream this month and the next one later, and only then move to a larger plan. Never drop a topic block without naming it, and never recompress a file to save minutes.

In our test run the trim was done with the official replay chapters standing in for the run of show; there was no user to approve the price table, so that approval was not exercised in our test run.

Done when every stream has a file in segments/ with a duration_s, and the user has approved the minutes and credits.

Step 3: Upload and index

Goal: every trimmed file indexed in a private Vivu project.

  1. Call vivu_list_projects and reuse a project named "Dev stream WORK_NAME" if one exists. Otherwise call vivu_create_project with that name and visibility "private". The default visibility is organization, which shows the project to everyone in the user's Vivu organization, and unannounced content shown on a stream before a patch is out usually should not be.
  2. Call vivu_open_upload_page with the project ID immediately before uploading. The link expires in 180 seconds and works once, so never post or store it. Give it to the user to open in their own browser and select every file in segments/, or open it in a browser tool that can attach local files. Claude in Chrome accepts at most 10 MB per upload call, and a trimmed stream is far larger, so the user's own browser or the Vivu web app is the usual path. Never split or recompress a file to fit.
  3. Poll vivu_list_videos until every file shows ready. Vivu replaces spaces and punctuation in file names with "_", which is why the files are named NN_STREAM.mp4; match each listed name to segments.csv and record the video_id. When a name does not match, match by length (duration_ms against duration_s).

In our test run the files reached the project through a different upload path, so the upload page in a user's browser was not exercised in our test run, and time to ready was not measured (the session ended while both files were indexing; they were ready when work resumed).

Done when every row of segments.csv has a video_id and every file shows ready.

Step 4: Search each topic and the on screen values

Goal: one saved result per topic, plus one result for on-screen dates and numbers.

Show the user the wording for every topic before running anything; a topic search costs 5 credits.

Field Query Mode maximum_results
one row per topic the developers talk about TOPIC: DETAILS precise 5
screen values a card or slide on screen showing a release date, or numbers comparing a stat before and after a change precise 20

TOPIC is the topic's name as the team says it, and DETAILS are the one or two things only that topic has, for example "the developers talk about new hairstyles for the Operator, the Drifter and NPC looks". Write them in the community's words, not internal ticket names. maximum_results is 5 for a topic because a topic is usually one block of talk and sometimes two or three windows when it runs long; 5 is also the ceiling on what the search can return, so raise it for a topic the run of show says comes back several times. The screen search uses 20 because cards can appear anywhere in the stream.

The chain: the topic search finds where it was said; inside that window the transcript gives the quote and the frames give what was shown; the screen search goes the other way, from what was shown, and catches date cards and stat cards outside the topic windows. Use precise for everything: fast returns whole files with no times and is no use with one file per stream.

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 to results/FIELD.json without result_page_url. Show the Vivu result page link in the reply only; it expires after four hours, so it never goes into the sheet, the recap or any file.

Done when every topic and the screen search have a saved result in results/ and a job id in state.json.

Step 5: Check every window against the transcript and frames

Goal: a verdict for every window, a quote from the transcript, and any date or number read from a full frame.

Save this helper as devstream-WORK_NAME/srt_window.py. It prints the transcript lines between two times of the original recording, without the repeated lines that rolling captions produce:

import sys

def sec(t):
    parts = t.strip().split(" ")[0].replace(",", ".").split(":")
    parts = [float(p) for p in parts]
    while len(parts) < 3:
        parts.insert(0, 0.0)
    return parts[0] * 3600 + parts[1] * 60 + parts[2]

path, start, end = sys.argv[1], float(sys.argv[2]), float(sys.argv[3])
text = open(path, encoding="utf-8").read().replace("\r", "")
seen = set()
for block in text.split("\n\n"):
    lines = [l for l in block.split("\n") if l.strip()]
    cue = next((l for l in lines if "-->" in l), None)
    if cue is None:
        continue
    a, b = [sec(x) for x in cue.split("-->")]
    if b < start or a > end:
        continue
    for line in lines[lines.index(cue) + 1:]:
        if line not in seen:
            seen.add(line)
            print(f"{int(a) // 60:02d}:{int(a) % 60:02d}  {line}")

For each window, with START and END in seconds of the trimmed file (start_ms / 1000 and end_ms / 1000) and KEEP_START_S from segments.csv:

  1. Read the transcript from 60 seconds before the window to the end of it, in original recording time. A topic window can start well after the developers start on the topic, and the first line is often the clearest quote:
python3 devstream-WORK_NAME/srt_window.py devstream-WORK_NAME/source/TRANSCRIPT.srt FROM_S TO_S

FROM_S is KEEP_START_S + START - 60 and TO_S is KEEP_START_S + END. If the transcript was made from the trimmed file instead of the original, leave KEEP_START_S out. 2. Decide. Keep the window when the developers talk about that topic inside it. Reject it when they are on another topic, reading chat, or only asking a question nobody answers. When two windows land in the same block of talk, keep both rows; the recap uses the earlier one. Count rejected windows as false positives and tell the user the count. 3. Take the frame from the middle of every kept window and look at it:

ffmpeg -v error -ss MID_S -i devstream-WORK_NAME/segments/NN_STREAM.mp4 -frames:v 1 -q:v 3 devstream-WORK_NAME/frames/FIELD_NN_mid.png
  1. For a window where a date or a number is said, and for every screen window, make a half second contact sheet of the window and look for the card. When the card is there, take that frame alone at full size and read the value from it:
ffmpeg -v error -y -ss START -to END -i devstream-WORK_NAME/segments/NN_STREAM.mp4 -vf "fps=2,scale=240:-1,tile=8x10" -frames:v 1 devstream-WORK_NAME/frames/FIELD_NN_halfsec.png

One sheet holds 40 seconds at two frames a second; make a second sheet from START + 40 for a longer window. Small in-game numbers (HUD stats, menu values) are hard to read; when you cannot read a value with certainty from the full frame, write the frame path and UNCERTAIN, and let a person fill the value. 5. When a date or number is spoken but no frame shows it, write the spoken value in dev_quote and "spoken only, no card" as UNCERTAIN in on_screen_value. 6. Write each window to candidates.csv: field, file, start, end, verdict, reason in one line.

Vivu reason text is a summary, not a transcript and not a reading of the screen. Never copy a quote, a date or a number from it.

Worked example from our test run

In our test run we used two windows of two official dev stream replays from a game studio's own channel, cut to about 15 minutes each with the replay chapters standing in for the run of show, 30.3 minutes in total, with eight announcement topics and one control topic the streams never covered, all written down before searching.

The eight topic searches returned nine windows, all nine real and zero false positives, and every topic segment was found (zero missed). The control topic returned zero windows. A heirloom skin topic sat right before a second skin of a different kind, and the window stopped where the first one ended. Each topic query carried the topic name plus details we took from the auto captions of the same streams (for example the month the update ships), so these numbers show what happens when the query names what was actually said; searches with only a topic name were not tested. There were no rewordings.

The screen search returned one window, a title card with the release month and year, and the full frame read the same value as the card; the window ran 43 seconds, past the end of the card. A release date in the other stream was said out loud with no card, and the screen search returned nothing there, so on_screen_value for it was "spoken only, no card".

Captions wrote names wrong ("Nea Air Loom", "towel", "Forex"), and the searches by meaning still found those topics; the zone names in the sheet came from the map labels in the frame. Searches used 50 credits (estimate from search counts).

Done when every window in results/ has a verdict in candidates.csv, every kept window has a quote and a frame, and the user has seen the false positive count.

Step 6: Build the announcement sheet and the recap draft

Goal: announcement_sheet.csv and recap_draft.md in the working folder, approved on one sample row first.

Show the user one sample row and this field mapping, and wait for a yes before writing the rest:

topic,stream_file,start_mmss,end_mmss,dev_quote,on_screen_value,frame,replay_link,source_check,dev_confirmed
New damage types,01_stream.mp4,13:41,14:45,"we're adding uh some brand new damage types","card: NEW COMBINED DAMAGE TYPES (icons only, no numbers)",frames/damage_types_01_mid.png,REPLAY_URL&t=2661,transcript+frame,
Field Source If unavailable
topic the user's topic list none
stream_file, start_mmss, end_mmss segments.csv and the window's start_ms / end_ms none
dev_quote the transcript, copied as written NOT VERIFIED and the window time
on_screen_value Claude reading the full frame UNCERTAIN, or "spoken only, no card"
frame frames/ blank
replay_link REPLAY_URL plus a time parameter of KEEP_START_S + start (for YouTube, &t=SECONDS) blank
source_check transcript, frame, or both none
dev_confirmed left empty for the dev team empty

Auto captions misspell names, so fix only the spelling of names from the topic list or from on-screen labels, and say so in source_check (for example "transcript, name spelling fixed from frame"). Never fix anything else in a quote.

recap_draft.md has one section per topic: what was announced in one or two plain sentences, the quote, the on-screen value with "unconfirmed" until dev_confirmed is filled, and the replay link with its time. End it with "Not found in the indexed segments": every topic with no kept row, and what was trimmed out of each stream, so the user can check whether the topic was in a cut part.

Done when announcement_sheet.csv has one row per kept window, recap_draft.md exists with a section per found topic and the not found list, and the user approved the sample row.

Step 7: Dev team check and hand off

Goal: the sheet goes to the dev team for dev_confirmed, and the recap goes where the user said, only after approval.

  1. Give the user the sheet and point out every UNCERTAIN cell and every value that is only spoken. The dev team fills dev_confirmed; a number or date stays out of the post until it is confirmed.
  2. Posting the recap, sending the sheet, or putting either in a shared drive, Discord, a forum or a doc acts as the user. Name the destination, show the full rendered post, and wait for an explicit yes. With email, create a draft unless the user asks to send.

This step was not exercised in our test run: there was no dev team or community manager, and the files were rendered locally and not sent anywhere.

Done when the user has the sheet and the recap draft, and either the user approved one destination and the post went there, or the user chose to post it themselves.

Compliance

  1. Use only your studio's own recordings. Do not pull replays from a streaming platform or use another studio's stream. Confirm this with the user before Step 2.
  2. The people on the stream are your developers and invited guests who agreed to a public broadcast, but the sheet and the recap name only what the stream already shows (on-screen name cards or the run of show). Do not identify anyone by face or voice. If a viewer call-in or a minor appears, leave that part out in Step 2.
  3. The recap repeats what developers said; numbers and dates are taken from frames and stay unconfirmed until the dev team fills dev_confirmed. Do not publish a number the dev team has not confirmed.
  4. The videos stay in the user's Vivu project until the user deletes them. Create the project as private, because streams can show unreleased content before a patch ships. Delete a project or video only when the user asks, and confirm first.
  5. Posting the recap or putting the sheet anywhere outside the working folder acts as the user; Step 7 asks first.

Known failure modes

Symptom Cause Fix
(observed) the transcript has a name wrong, such as "Nea Air Loom", "towel" or "Forex" auto captions do not know game names search by meaning with the topic details, not by keyword; spell names from the topic list or the on-screen label and say so in source_check
(observed) the first line on a topic falls outside the window: the window started 32 seconds after the developers first mentioned the new damage types, after a digression the window covers the densest part of the talk, not the whole topic read the transcript from a minute before the window, as in Step 5
(observed) one topic comes back as two windows the topic ran long, with other talk in between keep both rows; the recap uses the earlier one
(observed) a release date was said but the screen search returned nothing for it the date was spoken with no card on screen write the spoken value in dev_quote and "spoken only, no card" in on_screen_value; the dev team confirms it
(observed) the end frame of a screen window shows a different screen the window runs past the card read the value from the start or middle frame or the half second sheet, never the end frame alone
reason text names a number or date that no frame shows reason text paraphrases and can describe on-screen text that is not there read every value from a full frame; when no frame shows it, leave on_screen_value UNCERTAIN
small HUD or menu numbers cannot be read in-game text is small, and Vivu reads small screen text less reliably than large cards give the frame path and UNCERTAIN; a person fills the value
a topic has no window it was in a trimmed part, it was mentioned in passing, or the details in the query fit another topic check the run of show for cut parts, reword with details only that topic has, and report "not found in the indexed segments"
"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 the file is above the tool's size limit the user adds that file in the Vivu web app; never split or recompress it
a listed file name does not match segments.csv Vivu normalized the file name match on NN_STREAM, or on the length
the allowance runs out before the second stream the trimmed minutes exceed the plan apply the Step 2 levers in order: trim to topic blocks, index the next stream later, then a larger plan

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.