---
name: weigh-station-stop-shortlists
description: "Turn highway truck front camera runs into candidate CSVs of weigh station approaches, fuel stops and stopped enforcement vehicles with Vivu. Use when building eval subsets from slowdowns."
---Weigh station and roadside stop shortlists with Vivu
This skill turns a week of highway runs from an autonomous truck's front camera (mp4 files the team has exported from its logs, plus each run's speed log as a CSV) into one candidate CSV per stop event: approaching a weigh station, driving into a fuel stop, and passing an enforcement vehicle stopped on the shoulder with its lights on. Claude reads the speed logs, cuts only the stretches where the truck slowed off cruise speed or stopped, measures that batch and prices it against the user's Vivu plan, uploads it to a private Vivu project, runs one precise search per event class, cuts a contact sheet at half second steps for every window Vivu returns, labels each one looks right, looks wrong or can't tell, and writes every candidate into the class's CSV with an empty reviewer_verdict column for the person who builds the eval subset.
The value is in what only the pictures hold. A speed log shows that the truck slowed down or stopped, never why: a weigh station, a fuel stop, a rest area, an ordinary exit, a work zone and traffic all look alike in the speed trace, and run names carry only a date, a truck and a route. The split lane toward a scale house, the canopy over the diesel pumps and the patrol car on the shoulder are only in the video, and exported camera streams have no audio or captions to search. Vivu's search shortlists candidates; every candidate is labeled from its own frames, rejected candidates stay in the CSV with their label, and a short or empty list never proves the batch had no such stop.
When to use
Use when someone asks to pull weigh station approaches or fuel stops out of this week's highway runs, to find the stretches where a truck passed a patrol car on the shoulder, or to shortlist stop events from front camera video for an eval subset.
Not for these:
- A one off question about one clip ("is there a weigh station in this file?"): search Vivu directly and look at the frames.
- Whole runs at full length. A week of highway driving is far more video than a plan indexes in a month; this skill indexes only the slowdown stretches the speed log points to.
- Yard and terminal footage, pedestrians, cut ins or anything about people. The skill has no class for people and does not look for them.
- Judging whether the truck or anyone else drove correctly, whether a stop was an inspection or a violation, or anything about safety. The skill lists what is in the picture and nothing more.
- Reading sign text, license plates or vehicle markings. The searches describe classes and positions, not words, and the CSV carries no plate or sign text.
- Frame accurate labels or ground truth files: use the team's annotation tool. This skill makes review lists.
Working principles
- Report measured numbers, not estimates. When a number is an estimate, say so.
- Nothing is verified until it has been checked against the source video. Vivu's results are candidates, Claude's labels are a first pass, and the reviewer's verdict is the decision.
- Stop and tell the user when a required capability or tool is missing. Do not guess around it.
- Ask the user before anything that is expensive to redo (the cut list and its index minutes, before upload) and before writing the full CSVs (one sample row first). The skill posts and sends nothing; if the user asks Claude to put the CSVs somewhere, ask again before each write.
- Labels come from frames, never from Vivu's reason text, which can describe things that are not in the picture.
- The CSVs keep every candidate and carry no recall or precision figures: a search caps how many candidates come back and misses some.
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 |
| The front camera runs as mp4 files on the user's computer | Vivu indexes video files, and every stretch and sheet is cut from the local file | ffprobe -v error -show_entries format=duration -of csv=p=0 FILE prints a length; ROS bags or MCAP logs must be exported to video by the team's own tools first |
| A speed log per run as CSV, with seconds from the start of the video and speed | it picks the stretches worth indexing | open one file and find the two columns; ask which column is which when the header is unclear |
| A shell with ffmpeg, ffprobe and python3 | cut stretches, measure them, read the speed logs, cut contact sheets | ffmpeg -version, ffprobe -version, python3 --version |
| An upload path | move the stretches into Vivu | vivu_open_upload_page plus the user's own browser, or a browser tool that can attach local files |
| Someone who reviews the CSVs | Claude's labels are a first pass; the reviewer decides | ask who fills reviewer_verdict; the default is the user |
This skill needs Claude Code on the user's computer (the terminal or the Code tab of Claude Desktop), because it reads local files and runs ffmpeg and python3. Claude on the web and cloud sessions cannot reach the files. It downloads nothing, so no residential IP is needed. Nothing recurs, so no scheduler is involved; run it once per batch.
Inputs to collect
Ask for anything missing, most important first.
- RUNS_DIR: the folder with the exported mp4 runs and their speed logs (RUN.mp4 next to RUN.csv). Required.
- The speed log columns: which column is seconds from the start of the video and which is speed, and the unit. Required when the header does not say.
- The event classes and what counts for each. Default: the three classes in Step 5 with the label rules in Step 6. The reviewers' definitions win; write them into config.json before labeling.
- BATCH_NAME: a short name such as a week and a lane. It names the working folder and the Vivu project. Default: the name of RUNS_DIR.
- Slowdown rule. Default: speed falls from above 45 mph to below 15 mph; keep 150 seconds before and 90 seconds after the moment it falls below 15 mph, so each stretch is about 4 minutes and holds the approach.
- Batch size. Default: up to 40 minutes of stretches, or what remains of the plan this month, whichever is smaller.
- Who reviews the CSVs. Default: the user.
Files and state
Keep everything in one working folder next to RUNS_DIR:
stops-BATCH_NAME/
config.json RUNS_DIR, speed columns, slowdown rule, classes with query, maximum_results and label rules, Vivu project id
find_slowdowns.py the slowdown script from Step 2
slowdowns.csv source_run, start_in_run_s, end_in_run_s, low_at_s; one row per slowdown before approval
stretches.csv stretch_file, source_run, start_in_run_s, end_in_run_s, duration_s, listed_name, video_id
stretches/ the cut mp4 stretches, the only files uploaded
results/ search results without the result page link, one JSON per class
sheets/ one folder per class with contact sheets and zoomed frames
CLASS.csv one per class: every candidate, Claude's label, empty reviewer_verdict
state.json steps done, stretches uploaded, classes searched with job ids, candidate keys labeled
The commands below run from the folder that holds both RUNS_DIR and stops-BATCH_NAME/, so their relative paths resolve.
A rerun reads state.json first and skips finished steps. A stretch already marked uploaded is never uploaded again, a class with a saved result is not searched again, and a candidate key (video_id, start_ms and class) that already has a label is not labeled again. The next batch gets its own folder and its own Vivu project, so its searches do not return last week's candidates.
Step 1: Check the Vivu connector and the setup
Goal: confirm every requirement before spending anything.
- 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 showcan_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. - Run
ffmpeg -version,ffprobe -versionandpython3 --version. - List RUNS_DIR, run the ffprobe length command on one mp4 and show the first lines of its speed log.
Done when vivu_get_account shows can_create_projects: true, the three tools print their versions, and one run has both a length and a readable speed log.
Step 2: Cut the slowdown stretches from the speed logs
Goal: a short list of stretches where the truck left cruise speed, cut from the runs, approved by the user.
Save this as stops-BATCH_NAME/find_slowdowns.py and run python3 stops-BATCH_NAME/find_slowdowns.py RUNS_DIR TIME_COL SPEED_COL > stops-BATCH_NAME/slowdowns.csv, where TIME_COL and SPEED_COL are the column names from Inputs:
import csv, glob, os, sys
runs_dir, time_col, speed_col = sys.argv[1], sys.argv[2], sys.argv[3]
HIGH, LOW, BEFORE, AFTER = 45.0, 15.0, 150.0, 90.0 # mph and seconds; edit these to match the slowdown rule in config.json
print("source_run,start_in_run_s,end_in_run_s,low_at_s")
for log in sorted(glob.glob(os.path.join(runs_dir, "*.csv"))):
run = os.path.splitext(os.path.basename(log))[0] + ".mp4"
armed, last_end = False, -1.0
with open(log, newline="") as f:
for row in csv.DictReader(f):
t, v = float(row[time_col]), float(row[speed_col])
if v > HIGH:
armed = True
elif armed and v < LOW:
start, end = max(0.0, t - BEFORE), t + AFTER
if start > last_end:
print(f"{run},{start:.1f},{end:.1f},{t:.1f}")
last_end = end
armed = False
If the user changed the slowdown rule in Inputs, edit HIGH, LOW, BEFORE and AFTER in the script to match before running it.
Each row is one slowdown: the truck was above 45 mph and then fell below 15 mph. The script skips a slowdown that starts inside the previous stretch, so stop and go traffic gives one stretch, not ten. If the speed unit is km/h, change HIGH and LOW (for example 72 and 24). Show the user the rows per run and the total; traffic jams also produce rows, which is fine, because the pictures sort them out later.
Cut each approved row with the start and end it lists (re-encoding keeps the cut points exact):
mkdir -p stops-BATCH_NAME/stretches
ffmpeg -v error -ss START -to END -i RUNS_DIR/RUN.mp4 -an -c:v libx264 -crf 23 stops-BATCH_NAME/stretches/RUN_sSTART.mp4
START and END are start_in_run_s and end_in_run_s, RUN is the run's name. The name keeps the start in the run, so every CSV row can point back to the full run. Write stretches.csv with the stretch file, its run, start and end in the run, and its length from the ffprobe length command.
The footage in our test run was public and came with no speed log, so the slowdown script was not exercised in our test run. The stretches were cut with the ffmpeg command above at the times the publisher had marked as a scale, a crash, a fuel break and a rest area.
Done when stretches/ holds one mp4 per approved slowdown and stretches.csv lists each with its length.
Step 3: Measure the batch and price it
Goal: an indexed set the user's plan can pay for, approved before upload.
- Add listed_name to stretches.csv: the stretch file name with each space, bracket and plus sign replaced by an underscore, because that is how Vivu will list it.
- Call vivu_get_usage and show one table:
| This batch | Plan allowance | Remaining this month | |
|---|---|---|---|
| Index minutes | sum of duration_s / 60 | from vivu_get_usage | from vivu_get_usage |
| Search credits | 5 per class, 15 for the default three (estimate), plus 5 for each rewording | from vivu_get_usage | from vivu_get_usage |
Plan facts: Free is $0 a month with 20 index minutes a month and 50 search credits a month; Premium is $30 a month with 180 index minutes and 500 search credits. A precise search uses 5 credits in total.
- If the batch does not fit, offer levers in this order: tighten the slowdown rule (a lower LOW keeps only full stops), keep the runs on the lanes the eval set needs most, split the batch across two runs or two months, and only then a larger plan. Never drop stretches the user asked for without saying which ones.
- Confirm the Compliance items with the user.
The account used in our test run returns no allowance figures, so the comparison with a real plan and the user's approval were not exercised in our test run.
Done when the user approves the stretch list and its index minutes, and config.json records both.
Step 4: Upload and index
Goal: every stretch indexed in a private Vivu project for this batch.
- Call vivu_list_projects and reuse a project named "Highway stops BATCH_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 fleet camera footage is usually confidential.
- Call vivu_open_upload_page with the project ID immediately before uploading. The link expires in 180 seconds and works once, so never post or store it. Give it to the user to open in their own browser and select the files in stretches/, 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 4 minute stretch is usually larger, so stretches normally go through the user's own browser or the Vivu web app. Never split or recompress a stretch to fit.
- Poll vivu_list_videos until every stretch shows ready. Match each Vivu file name to stretches.csv by listed_name and record its video_id there and in state.json.
In our test run the 9 stretches (31.48 minutes) went through the same upload page with an automated browser, so opening the link in the user's own browser was not exercised in our test run. All of them were ready about 14 minutes after the upload started. One stretch still showed queued after all the others were ready and then turned ready on its own, so keep polling instead of uploading it again; a second copy would put duplicate candidates in every list.
Done when every stretch in stretches.csv shows ready and has a video_id.
Step 5: Search each event class
Goal: a saved list of candidate windows for every class.
| Field | Query | Mode | maximum_results |
|---|---|---|---|
| weigh_station | the truck approaches a weigh station: a large roadside or overhead sign announcing the station, a lane splitting off from the highway toward a scale, or a small scale house or inspection building beside a truck lane | precise | 40 |
| fuel_stop | the truck drives into a fuel station and pulls up under a wide canopy roof over the fuel islands, with diesel pumps right beside the truck | precise | 40 |
| shoulder_enforcement | a police patrol car parked and not moving at the right or left edge of the highway, outside the travel lanes, with red and blue emergency lights on, often next to another stopped vehicle | precise | 40 |
The chain is: the speed log (a number in a text file) picks the stretches, one precise search per class finds candidate windows inside them, the contact sheet shows what the truck's camera saw in each window, and the reviewer decides. The switch from the logged speed to what is on screen is the point of the skill: the log says the truck slowed, the picture says why. Every search is precise because only precise returns a time window; fast returns whole files with an empty reason, and the stretches are already a chosen subset. Exported camera streams have no audio, so there is no spoken signal to check against.
The queries describe each class by shape and position (a lane splitting off, a canopy over pumps, a car at the edge of the road with lights), never by the words on a sign. Sign wording differs from state to state, and words in a query tend to come back in the reason whether or not the sign is there.
How far to trust each list (numbers in the worked example after Step 6): weigh station and fuel stop candidates were mostly right in our test run; the shoulder_enforcement list is the weakest, its first wording returned patrol cars in the travel lanes and a work zone, and the wording in the table was tuned on the same few night and rain scenes. Daytime patrol cars on the shoulder, the small target the class is meant for, were not in the test corpus. Treat that list as candidates only and keep every row in front of the reviewer. More generally, Vivu's picture search is rated weak in our capability notes: it finds what is in view better than it judges what happened, its reason text can describe things that are not in the frames, and an empty result does not prove the footage has no such stop. That is why no row reaches the CSV without its frames and why the reviewer decides.
maximum_results is also the ceiling on how many candidates come back. A batch of up to 40 minutes of slowdown stretches holds a handful of stops per class, so 40 leaves room. A search that returns exactly its maximum_results was cut off: mark the class cut off in state.json and say so in the summary, and split the next batch into smaller ones.
In our test run the largest result was 5, against a maximum_results of 40.
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/CLASS.json without its result_page_url field, and record the job_id in state.json. Show the Vivu result page link in the live reply only; it expires after four hours, so it never goes into a saved file or a CSV.
If the team changes a wording or adds a class (for example a toll plaza or a rest area), the new wording is untested until its first candidates have been through Step 6.
Done when every class has a completed result saved in results/, and any class whose search returned exactly its maximum_results is marked cut off in state.json and in the summary.
Step 6: Make a contact sheet for every candidate and label it
Goal: every candidate labeled looks right, looks wrong or can't tell from what its frames show.
For each result in results/CLASS.json, cut contact sheets of its window from the local stretch at two frames a second:
mkdir -p stops-BATCH_NAME/sheets/CLASS
ffmpeg -v error -y -ss START -to END -i stops-BATCH_NAME/stretches/STRETCH.mp4 -vf "fps=2,scale=320:-2,tile=8x5" stops-BATCH_NAME/sheets/CLASS/rRANK_STRETCH_STARTMS_%02d.png
CLASS is the class, STRETCH the stretch file name without .mp4, RANK the result_number written with two digits (01, 09), so the files are named r01_…, r09_… and sort by rank, STARTMS the result's start_ms, and START and END the result's start_ms and end_ms divided by 1000. Each sheet holds 40 tiles covering 20 seconds of the window; the last sheet is padded with black tiles. Tile k on sheet n (both counted from 0, tiles left to right and top to bottom) is at START + 20 * n + k / 2 seconds, so the command needs no text overlay. A single frame is not enough: windows are wider than the events, and a roadside sign can be on screen for about 2 seconds anywhere in the window.
Far things are small on a tile. When a tile shows a sign, a building or flashing lights in the distance, extract a zoomed full size frame at that second:
ffmpeg -v error -y -ss SECONDS -i stops-BATCH_NAME/stretches/STRETCH.mp4 -frames:v 1 -vf "crop=iw/2:ih/3:X:ih/4,scale=iw*2:-2" stops-BATCH_NAME/sheets/CLASS/rRANK_STRETCH_SECMS_zoom_SIDE.png
SECONDS is the time from the tile, SECMS the same time in milliseconds, X picks the part of the picture (0 for the left half, iw/4 for the center, iw/2 for the right half), and SIDE is left, center or right to match X.
Label rules (defaults; the reviewers' definitions from Inputs win):
- weigh_station looks right when the window shows the truck approaching or passing through a weigh station: a weigh station sign beside or above the road, a lane splitting off toward a scale, a scale house or station building beside a truck lane. A sign the truck drives past without leaving the mainline still looks right; write "passed, did not enter" in the note. It looks wrong for an ordinary exit ramp, a rest area, a toll booth or a plain building beside the road.
- fuel_stop looks right when the truck drives up to or under a fuel canopy with pumps. It looks wrong for a gas station seen from the road that the truck does not enter, a truck stop parking lot without the canopy in the window, and a restaurant or rest area lot.
- shoulder_enforcement looks right when a police or enforcement vehicle with its emergency lights on is stopped on a shoulder or at the edge of the road in the window. It looks wrong for patrol cars moving in the travel lanes, a patrol car parked at a scale house, tow trucks or work vehicles with amber lights, and plain traffic.
- can't tell when the zoomed frame still does not settle it (dark, rain on the windshield, too far). The reviewer looks at the source.
Write a note of what the frames show for every candidate, such as "scale lane splits right, scale house on the right" or "canopy over pumps, truck stops at a pump". Never copy the reason into the note, and never write sign text or plates into it. Record each candidate key and its label in state.json.
Worked example from our test run
The test corpus was 9 public videos (31.48 minutes) from dashcam recordings published under a Creative Commons license: four stretches cut from one long interstate truck drive at the times its publisher marked as a scale, a crash, a fuel break and a rest area (standing in for a speed log, which public footage does not have), plus short clips of a port of entry, the inside of a weigh station, a truck stop with a fuel canopy, a patrol scene in heavy rain filmed from a car, and a truck passing a weigh station without entering. None of it is an autonomous truck's perception camera, and some of it carries overlays a team's export would not have (large town name captions, a timestamp, a speed readout, a watermark). Stops were marked by hand on contact sheets before any search, and stops first seen in search results were added to the hand marks afterwards, so the missed counts leave out anything neither the hand marks nor a search caught.
- weigh_station: 5 candidates, 4 real and 1 false, and 1 station in the hand marks was missed. The real ones covered three stations, one of them twice (its approach sign and its station lane). The false one was a rest area ramp with parked trucks, which the reason described as an open weigh station. The missed one was a station the truck drove past without leaving the mainline; its sign was on screen only briefly.
- fuel_stop: 2 candidates, 2 real and 0 false, and 0 missed. A gas station the truck drove past, truck stop parking lots and a restaurant lot were not returned. Two fuel stops is a small sample.
- shoulder_enforcement, first wording ("a police or highway patrol vehicle stopped on the shoulder or at the edge of the highway with its red and blue emergency lights flashing"): 5 candidates, 3 real and 2 false, and 0 missed. The false ones were a patrol car in the travel lanes during a traffic break and a dawn work zone with orange drums, where the reason described a law enforcement vehicle that is in none of the frames.
- shoulder_enforcement, with the wording in the table after 1 rewording on the same corpus: 3 candidates, 3 real and 0 false, and 0 missed. They are the same three scenes the first wording found, at night or in heavy rain, and the wording was tuned on them, so this clean result is optimistic. One of the three was first seen in search results and added to the hand marks afterwards.
- A control search for a toll plaza, which the corpus does not have, returned 0 results.
- Windows were wider than the events: the widest weigh station window was 52 seconds for a station pass that takes a few seconds on screen. Every search was complete at the first status call.
- The rain scenes needed zoomed frames: the patrol car beside a stopped pickup could only be told apart from traffic on a zoomed full size frame.
Claude labeled each window in a single pass, and the reviewer goes through every row.
Done when every candidate in results/ has at least one contact sheet in sheets/ and a label in state.json.
Step 7: Write one CSV per class and hand it over
Goal: a review list per class that a reviewer can work through without opening Vivu.
Show the user one sample row and the field mapping, and wait for an OK before writing the rest:
source_run,start_in_run,stretch_file,rank,start_mmss,end_mmss,search_reason,contact_sheets,claude_label,claude_note,reviewer_verdict
mw60zR2iqiM.mp4,00:13:42,WF_01.mp4,3,00:42,00:59,"The truck exits the highway onto a weigh station lane, approaching the roadside weigh station sign, scale house, and scale platform.",sheets/weigh_station/r03_WF_01_42000_01.png,looks right,"lane splits right past chevrons, truck passes a small scale house on the right and rejoins",
The row above is from our test run, where the source run was a public video; the user's rows carry their own run names.
| Column | Source | If unavailable |
|---|---|---|
| source_run | stretches.csv, matched by listed_name | keep the row with Vivu's file name, label it can't tell with the note "no local file matched", and tell the user |
| start_in_run | start_in_run_s from stretches.csv plus start_ms, written HH:MM:SS | blank |
| stretch_file | stretches.csv | none |
| rank | result_number in results/CLASS.json | none |
| start_mmss, end_mmss | start_ms and end_ms in the stretch, written MM:SS | none |
| search_reason | the result's reason, copied as is; it is Vivu's description, not evidence | blank |
| contact_sheets | the sheet files and zoomed frames from Step 6, separated by semicolons | none; the row cannot be labeled without them |
| claude_label | Step 6 (inferred from frames) | can't tell |
| claude_note | what the frames show, in Claude's words (inferred) | blank |
| reviewer_verdict | left empty for the reviewer | empty |
claude_label and claude_note are Claude's reading of the frames, not a measurement. If a label is wrong, a real stop sits among the looks wrong rows or a false one among the looks right rows, so the reviewer goes through every row before anything enters the eval set.
Write CLASS.csv for every class with one row per result, sorted by rank, including the rows labeled looks wrong: a reviewer may disagree, and the rejected rows show what the search confuses. The CSV uses the user's own run names and times, never a Vivu result page link, so it stays usable after the link expires.
Then tell the user, per class, how many candidates came back, how many Claude labeled looks right, looks wrong and can't tell, and whether the list was cut off at maximum_results. Say plainly that an empty or short list does not mean the batch has no such stop. The CSVs and this summary carry counts of candidates and labels only, no recall or precision figures.
The CSVs stay in the working folder. Passing them to the reviewers is the user's step. If the user asks Claude to upload or post them (a shared drive, a tracker, a chat), name the destination, show the rendered first rows and wait for a yes before each write.
In our test run the CSVs were written from the dry run's results and sheets; showing the sample row to a user and handing the CSVs to reviewers were not exercised in our test run.
Done when every class has a CSV whose row count equals the number of results in results/CLASS.json, the user approved the sample row and the mapping, and state.json marks the batch done.
Compliance
- Use fleet footage the team owns or has the rights to analyze. For public driving videos used as extra material, check the license and the platform's terms first and keep them for internal analysis only. Have the user confirm this before Step 4.
- Other drivers, officers and people at fuel stops did not agree to be filmed. The skill lists stop events by what is in the picture; it identifies no one, reads no license plates, does no face or identity recognition, has no class for people and never searches for anyone by appearance. Follow the team's privacy rules (some teams blur faces and plates before any upload), and confirm before Step 4.
- The skill does not judge whether anyone drove correctly, why a vehicle was stopped, whether a stop was an inspection or a violation, or anything about safety. The CSVs are review lists for people, not findings.
- The stretches stay in the user's Vivu project until the user deletes them. Create the project as private; the default is visible to the whole Vivu organization. Delete videos or the project only when the user asks, and confirm first.
- The skill writes only local files. Any upload or post of the CSVs goes through the approval in Step 7.
Known failure modes
| Symptom | Cause | Fix |
|---|---|---|
| (observed) a weigh station candidate is a rest area ramp with parked trucks: 5 returned, 4 real and 1 false | a ramp off the highway matches, and the reason adds "passing roadside signs announcing the open weigh station" | label from the frames: a station needs a scale lane, a scale house or a station building in the tiles |
| (observed) a station the truck drives past without leaving the mainline is missed: 1 missed | its sign is on screen only briefly and nothing else of the station is in view | the lists cover stops the truck makes; reviewers who need passed stations sweep the stretches on the sheets themselves |
| (observed) the same station comes back twice, once for its approach sign and once for its station lane | each window is a separate moment | keep both rows, name the earlier rank of the same station in claude_note, and let the reviewer count it once |
| (observed) a shoulder candidate is a patrol car in the travel lanes during a traffic break | a car with lights anywhere on the road matches | label it looks wrong unless it is stopped at the edge in the tiles |
| (observed) a reason says "A law enforcement vehicle is parked on the right shoulder of the highway" over a work zone with no police car | the reason describes what the query asked for | never copy the reason; label from the frames |
| (observed) a patrol car at the road edge in rain cannot be told apart from traffic on the contact sheet | rain on the windshield and small tiles | extract a zoomed full size frame (Step 6) |
| (observed) one stretch still shows "queued" after the others are ready | Vivu indexes uploads in turn | keep polling vivu_list_videos; do not upload it again |
| (observed) a window is far wider than the stop: 52 seconds for a station pass | windows are wider than events | look at every sheet of the window, not only the first |
| shoulder candidates on daytime footage look unreliable | daytime patrol cars were not in the test corpus | treat that list as unmeasured and have the reviewer check every row |
| 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 tool accepts at most 10 MB per call | the user adds the file in their own browser or the Vivu web app |
| "has not granted vivu.write" | Vivu connected read only | the user reconnects Vivu with write access |
| a result's file name does not match stretches.csv | Vivu replaced a space, bracket or plus sign in the name | match on listed_name in stretches.csv |
| a search returns exactly its maximum_results | the batch holds more candidates than one search returns | mark the class cut off, say so in the summary, and use smaller batches |
| a class comes back empty | none in the batch, or the search missed them | an empty result does not prove the footage has no such stop; say so in the summary |