---
name: line-patrol-vegetation-work-list
description: "Turn line patrol drone video into a vegetation trim work list CSV with Vivu: trees on the line, crowns grown into the wires, with SRT coordinates. Use before scheduling trim crews."
---Vegetation work list from line patrol drone video with Vivu
This skill turns the drone video a line patrol crew flies along distribution feeders into a trim work list for a vegetation management planner. The user gives Claude the folder of drone MP4 files with their matching SRT flight logs, the outage or trip records, and this year's trim plan. Claude picks only the spans on the two or three feeders those records point to, prices them against the user's Vivu plan, uploads them to a private Vivu project, runs one precise search per condition (a tree or limb down on the line, tree crowns grown up into the wires, and two optional ones: leaning or broken poles, vines on poles), cuts a half second contact sheet for every window Vivu returns, labels each window from its frames, reads the latitude and longitude for the window from the SRT file, and writes work_list.csv with empty patrol_verified and trim_grade columns. The planner checks the list and enters the real jobs in the work order system.
The value is in what only the picture and the flight log hold. A patrol note says "heavy vegetation, poles 12 to 18" and a trip record names a feeder and a time. Neither says which tree is leaning on which span, whether the crown is into the wires or only near them, or where the drone was at that second. Drone audio is propeller noise and the files are named DJI_0001 and so on, so a text tool has nothing to search. Vivu's search is only the first pass, and conductors are one or two pixels wide against sky or leaves, so contact with the wire is often not visible. Every row is labeled from its frames, rejected candidates stay in the CSV, and a short list never means a feeder is clear.
When to use
Use when a vegetation planner or forestry coordinator asks to "go through the patrol flights on the feeders that tripped and list the trees into the line", "make a trim list from last week's drone patrol", "find the spans where trees are down on the wires after the storm", or "turn these DJI flights into work orders for the trim contractor".
Not for these:
- A one off question about one flight ("is the tree at pole 14 still on the line?"): search Vivu directly and look at the frames.
- Clearance distances, hazard ratings or trim priority. The skill lists what the camera saw; a qualified line clearance arborist or the utility's engineer sets the trim grade and decides what is dangerous.
- Small hardware: insulators, cotter pins, cracked crossarms, hot spots. They are too small for this search; use the inspection team's close up imagery and thermal tools.
- People, vehicles and homes. The skill never searches for or lists them.
- A whole year of patrol video. Pick the spans the trip records and trim plan point to; one run is sized for about 30 to 50 minutes of footage.
- Vines on poles and guy wires: untested. Our test footage had none, so the vine search could only show that it does not invent them.
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 patrol crew's check and the arborist's trim grade are 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 spans to index and their index minutes, before upload) and before writing the full CSV (one sample row first). The skill posts and sends nothing; if the user asks Claude to put the list somewhere, ask again before each write.
- Labels come from frames, never from Vivu's reason text, which describes the condition it was asked for even when the frame shows something else.
- The list keeps every candidate and carries no recall figure. A search misses some trees and caps how many come back, so a short list does not prove a feeder is clear.
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 drone videos as MP4 files on the user's computer | Vivu indexes video files, and every clip and sheet is cut from the local file | ffprobe -v error -show_entries format=duration -of csv=p=0 FILE prints a length for each file |
| The matching SRT flight log for each video (same name, .SRT) | the latitude and longitude for each moment | open one SRT and find a line with latitude and longitude |
| A shell on that computer with ffmpeg and ffprobe | cut spans, measure them, make contact sheets and zoomed frames | ffmpeg -version, ffprobe -version |
| python3 on that computer | the SRT helper in Step 7 | python3 --version |
| The trip records and the trim plan, as text | choose which feeders and spans to index | ask for them; a list of feeder names and pole ranges is enough |
| 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 |
| Someone who checks the list | Claude's labels are a first pass; patrol and the arborist decide | ask who fills patrol_verified and trim_grade; 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 patrol batch.
Inputs to collect
Ask for anything missing, most important first.
- FLIGHT_DIR: the folder that holds the MP4 and SRT files. Required.
- The feeders and spans to check, from the trip records and the trim plan. Required; the default is two or three feeders, cut into spans of 3 to 5 minutes each.
- BATCH_NAME: a short name such as a district and a month. It names the working folder and the Vivu project. Default: the name of FLIGHT_DIR.
- The conditions. Default: tree_on_line and canopy_into_line, plus pole_leaning and vines_on_pole only if the user wants them (Step 5 says what each costs in false rows).
- Who checks the list. Default: the user.
Files and state
Keep everything in one working folder next to FLIGHT_DIR:
vegetation-BATCH_NAME/
config.json FLIGHT_DIR, feeders and pole ranges, conditions with query and label rules, Vivu project id
spans.csv clip_file, source_file, source_start_s, source_end_s, duration_s, listed_name, feeder, video_id
clips/ the cut spans that get uploaded
results/ search results without the result page link, one JSON per condition
sheets/ one folder per condition with contact sheets and zoomed frames
locations.csv output of the SRT helper, one row per candidate
work_list.csv every candidate, Claude's label, coordinates, empty patrol_verified and trim_grade
state.json steps done, clips uploaded, conditions searched with job ids, candidate keys labeled
The commands in Steps 2 to 7 run from the folder that holds both FLIGHT_DIR and vegetation-BATCH_NAME/, so the relative paths in them resolve.
A rerun reads state.json first and skips finished steps. A clip already marked uploaded is never uploaded again, a condition with a saved result is not searched again, and a candidate key (video_id, start_ms and condition) 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 month'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 FLIGHT_DIR, run the ffprobe length command on one MP4, and open its SRT to confirm it has latitude and longitude lines.
Done when vivu_get_account shows can_create_projects: true, the three tools print their versions, and one MP4 in FLIGHT_DIR has a length and a matching SRT with coordinates.
Step 2: Pick the spans and cut them
Goal: short clips that cover only the spans that need a look, so the index minutes go where the trips and the trim plan point.
- From the trip records and the trim plan, list the feeders and pole ranges to check. For each, find the flight files that cover it (the patrol crew's flight notes, or the SRT coordinates against the feeder map) and the seconds in each file where the drone passes that range. Show the list (feeder, file, start, end, why) and let the user add or drop spans.
- Cut each span with a re-encode, so the cut lands on the requested second rather than the nearest keyframe:
mkdir -p vegetation-BATCH_NAME/clips
ffmpeg -v error -ss START -to END -i FLIGHT_DIR/SOURCE_FILE -an -c:v libx264 -crf 22 vegetation-BATCH_NAME/clips/CLIP_NAME.mp4
START and END are seconds in the source file, SOURCE_FILE is the drone MP4, and CLIP_NAME is a short name with no spaces such as f12_p12-18_0915 (feeder, pole range, clock time), so it survives Vivu's file name rules. -an drops the propeller noise. A whole file that is already a few minutes long can be uploaded uncut; then START is 0.
- Write one row per clip to spans.csv with source_file and source_start_s. Step 7 adds source_start_s to every Vivu time to find the right SRT line.
Picking spans from trip records and the trim plan was not exercised in our test run: public footage comes with no trip records or feeder map, so the test clips were cut at fixed offsets.
Done when every clip the user approved exists in clips/ and has a row with source_file and source_start_s in spans.csv.
Step 3: Measure the spans and price them
Goal: an indexed set the user's plan can pay for, approved before upload.
- Run
ffprobe -v error -show_entries format=duration -of csv=p=0 vegetation-BATCH_NAME/clips/CLIP_NAME.mp4for every clip and record duration_s. Add listed_name: the file name with each space, bracket, plus sign and percent 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 condition, 10 for the two default conditions (estimate), 20 with all four, 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. Twelve spans of four minutes each are 48 index minutes (estimate), more than Free covers in a month and inside Premium; Free fits about five such spans.
- If the batch does not fit, offer levers in this order: shorter spans around the pole ranges in the records, fewer feeders (the ones with the most trips first), split the batch across two runs or two months, and only then a larger plan. Never drop a span the user asked for without saying which one.
- 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 clip list and its index minutes, and config.json records both.
Step 4: Upload and index
Goal: every clip indexed in a private Vivu project for this batch.
- Call vivu_list_projects and reuse a project named "Vegetation 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 patrol footage shows homes, yards and people.
- 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 clips/, 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 four minute drone clip is usually larger, so clips normally go through the user's own browser or the Vivu web app. Never split or recompress a clip to fit.
- Poll vivu_list_videos until every clip shows ready. Match each Vivu file name to spans.csv by listed_name and record its video_id there and in state.json.
In our test run the 9 clips (21 minutes) were all ready 655 seconds after the upload started; all of them sat in the queue for most of that time before indexing began, so a pending status is normal. They 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.
Done when every clip in spans.csv shows ready and has a video_id.
Step 5: Search each condition
Goal: a saved list of candidate windows for every condition.
| Field | Query | Mode | maximum_results |
|---|---|---|---|
| tree_on_line | a fallen or broken tree, or a large broken limb, lying on the overhead power lines or hung up in the wires, or storm-downed tree crowns piled against a wooden utility pole that carries wires | precise | 40 |
| canopy_into_line | a row of tall living trees whose crowns reach up to the height of the overhead power lines, so the wires run along the edge of the tree crowns or disappear into the leaves, seen from a drone flying along the line | precise | 40 |
| pole_leaning (optional) | a wooden utility pole that is snapped, lying on the ground or across a road, or standing in the ground clearly tilted far from vertical | precise | 40 |
| vines_on_pole (optional, untested) | vines or climbing plants growing up a wooden utility pole or its guy wire, covering part of the pole with leaves | precise | 40 |
The searches run side by side, one per condition, because each condition is its own group in the work list. Within a condition the chain is: the precise search finds candidate windows, the contact sheet shows what the drone passed in each window, Claude labels it, the SRT gives the drone position, and the patrol crew decides. Every search is precise because only precise returns a time window; fast returns whole files with an empty reason, and the clips are already a chosen subset. Drone audio is propeller noise and there is no on screen text about the line, so there is no second modality to switch to; the second signal is the SRT log, read locally.
The two default wordings ran once each on our test footage, with no rewording. They describe what the line and the trees look like from the drone, not a clearance distance, because Vivu cannot measure one.
pole_leaning is a low precision list: in our test run most of its false rows were upright poles whose reason text said they were tilted. vines_on_pole is untested: our footage had no vines on poles, and the search still returned windows of bare poles described as covered in vines. Offer both only if the user wants them, and say that every row needs a look.
maximum_results is also the ceiling on how many candidates come back. 40 is an estimate of headroom, not a measured capacity: in our test run the most any condition returned from 21 minutes of footage was 11. A search that returns exactly 40 was cut off. Then tell the user, mark the condition cut off in state.json, and offer to split the batch into two smaller batches with their own projects (quote the index minutes again and wait for approval as in Step 3).
A cut off search was not exercised in our test run, because no search there came close to its maximum_results.
Run each query with vivu_search_videos (project_id, query, mode, maximum_results). It returns a job ID. Call vivu_get_search_results until complete is true; each status call can wait up to 45 seconds, so a pending search is not a stalled one. Save each completed result as results/FIELD.json 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 the CSV.
Done when every chosen condition has a completed result saved in results/, and every condition whose search returned exactly its maximum_results is marked cut off in state.json.
Step 6: Make contact sheets and label every candidate
Goal: every candidate labeled looks right, looks wrong or can't tell from what its frames show.
For each result in results/FIELD.json, cut one contact sheet of its window from the local clip:
mkdir -p vegetation-BATCH_NAME/sheets/FIELD
ffmpeg -v error -y -ss START -to END -i vegetation-BATCH_NAME/clips/CLIP_NAME.mp4 -vf "fps=RATE,scale=320:-2,tile=6x5" -frames:v 1 vegetation-BATCH_NAME/sheets/FIELD/rRANK_CLIP_NAME_STARTMS.png
FIELD is the condition, CLIP_NAME the clip the result points to (from Step 2, without .mp4, so LP_02 for LP_02.mp4), RANK the result_number written with two digits (r01, r09), STARTMS the result's start_ms, START and END the result's start_ms and end_ms divided by 1000. RATE is 2 for windows up to 15 seconds, 1 up to 30 seconds and 0.5 beyond, so the 30 tiles cover the window; tile k (counted from 0, left to right and top to bottom) is at START + k / RATE seconds. For windows longer than 60 seconds use 0.4.
Conductors are one or two pixels on a tile, and top down storm footage is often dark. When a tile shows a tree near a pole or the wire run, or the sheet looks empty but the reason names a tree on the line, extract a zoomed frame at that tile's second:
ffmpeg -v error -y -ss SECONDS -i vegetation-BATCH_NAME/clips/CLIP_NAME.mp4 -frames:v 1 -vf "scale=iw*2:-2" vegetation-BATCH_NAME/sheets/FIELD/rRANK_CLIP_NAME_SECMS_zoom.png
SECONDS is the time of the tile and SECMS the same time in milliseconds.
Label rules (defaults; the utility's own definitions win):
- tree_on_line looks right for a fallen, uprooted or broken tree or a large limb lying on or hung in the wires, or crowns piled against a pole that carries wires. It looks wrong for cut debris on the ground under the wires and for trees that lie beside the line without reaching it.
- canopy_into_line looks right when living crowns reach the wire height beside the line or the wire run disappears into or under the crowns. It looks wrong for trees well below the wires (a park under a transmission line) and for trees with no line in frame. Seen straight down, height cannot be read; label it looks right only when the crowns cover the wire run, and say borderline in the note.
- pole_leaning looks right for a pole lying down, snapped, or clearly off vertical against the horizon or the road edge. It looks wrong for upright poles, poles hanging from a truck crane during work, and a tree leaning on an upright pole.
- vines_on_pole looks right only when leaves visibly climb the pole or guy wire on a zoomed frame.
- can't tell when the zoomed frame still does not settle it. The patrol crew looks on site.
Write a note of what the frames show for every candidate, such as "broken crown lying across a pole with crossarm and its wires, 00:00 to 00:20" or "debris on the ground under the wires; nothing rests on them". Never copy the reason into the note, and never record people, homes or plates. Record each candidate key and its label in state.json.
Worked example from our test run
The test corpus was public Creative Commons drone footage, used in place of a utility's own patrol flights: 9 clips (21 minutes) cut from a city's flight along a storm damaged road, an electric cooperative's flight over a crew trimming pines along a distribution line, a top down flight over a storm damaged neighbourhood, two cooperative flights over line work in open fields, a flight under transmission towers in a park, and a canyon flight with no line at all. The audio was removed and the files renamed so the names said nothing about content. Only a low resolution copy could be downloaded, which is softer than a real patrol export, and none of the clips came with an SRT log. Items were marked by hand on contact sheets before any search. One clear tree on the line with a leaning pole, which we had placed at the wrong time on those sheets, was added to the marks after the search from a zoomed frame.
- tree_on_line: 7 returned, 6 real and 1 false, and 0 missed. Some windows were long enough to cover more than one marked event. The false one was cut debris on the ground at a driveway under the wires, with a reason that said the branches lay across the lines.
- canopy_into_line: 4 returned, 4 real and 0 false, and 0 missed. All but one of the real ones came from the single trimming flight, so this rests on a small sample; the other was a dark top down window where the wire run disappears under large crowns, which we counted as real and which is borderline. Lines over open fields, trees under the transmission wires and the canyon trees were not returned.
- pole_leaning: 11 returned, 4 real, 4 false and 3 can't tell, and 0 missed. The false ones were upright poles.
- vines_on_pole: 3 returned, 0 real and 3 false. The footage had no vines on poles.
- A control search for a bird nest on a crossarm, which the footage did not contain, returned 2 results, both false: bare crossarms in a field, with a reason that described a nest of sticks.
- The work list for the two default conditions held 11 rows.
Done when every candidate in results/ has a contact sheet in sheets/ and a label in state.json.
Step 7: Read the coordinates from the SRT flight log
Goal: a latitude and longitude for every candidate, so the planner can find the span on the feeder map.
The moment in the source file is the clip's source_start_s plus start_ms / 1000 seconds. DJI style SRT files hold one block per frame or per second with a time range and a line that carries either [latitude: 41.12345] [longitude: -85.12345] or GPS(-85.12345,41.12345,30). Save this helper as srt_locate.py and run it once per condition:
import csv, json, re, sys
spans_path, results_path, field, flight_dir = sys.argv[1:5]
spans = {r["listed_name"]: r for r in csv.DictReader(open(spans_path))}
def t2s(t):
h, m, s = t.replace(",", ".").split(":")
return int(h) * 3600 + int(m) * 60 + float(s)
def load(srt):
rows = []
for block in open(srt, encoding="utf-8", errors="replace").read().split("\n\n"):
tm = re.search(r"(\d+:\d+:\d+[,.]\d+)\s*-->", block)
la = re.search(r"latitude\s*:\s*(-?\d+\.\d+)", block)
lo = re.search(r"longitude\s*:\s*(-?\d+\.\d+)", block)
g = re.search(r"GPS\s*\(\s*(-?\d+\.\d+)\s*,\s*(-?\d+\.\d+)", block)
if tm and la and lo:
rows.append((t2s(tm.group(1)), la.group(1), lo.group(1)))
elif tm and g:
rows.append((t2s(tm.group(1)), g.group(2), g.group(1)))
return rows
out = csv.writer(sys.stdout)
for res in json.load(open(results_path))["results"]:
span = spans.get(res["file_name"])
if not span:
out.writerow([field, res["result_number"], res["file_name"], "", "", "NOT VERIFIED: no span row"])
continue
srt = flight_dir + "/" + re.sub(r"\.mp4quot;, ".SRT", span["source_file"], flags=re.I)
try:
pts = load(srt)
except OSError:
pts = []
if not pts:
out.writerow([field, res["result_number"], res["file_name"], "", "", "NOT VERIFIED: no SRT coordinates"])
continue
t = float(span["source_start_s"]) + res["start_ms"] / 1000
best = min(pts, key=lambda p: abs(p[0] - t))
gap = abs(best[0] - t)
note = "" if gap <= 2 else f"UNCERTAIN: nearest SRT line {gap:.0f}s away"
out.writerow([field, res["result_number"], res["file_name"], best[1], best[2], note])
python3 srt_locate.py vegetation-BATCH_NAME/spans.csv vegetation-BATCH_NAME/results/FIELD.json FIELD FLIGHT_DIR >> vegetation-BATCH_NAME/locations.csv
The coordinate is where the drone was at the start of the window, not where the tree is: the camera looks ahead or to the side, often tens of meters from the drone. Write it as the drone position in location_note, and let the planner match it to the nearest pole on the feeder map. A Vivu window is several seconds wide, so the patrol crew finds the tree within that stretch of the span.
Step 7 was not exercised in our test run: the public test footage came without SRT files, and the helper was not run on a real flight log, so every row in the test CSV says NOT VERIFIED. Run it on one known flight first and compare one coordinate with the patrol crew's notes before trusting the column.
Done when every candidate has a latitude and longitude, UNCERTAIN, or NOT VERIFIED with the reason in locations.csv.
Step 8: Write the work list and hand it over
Goal: one CSV the planner can check and copy into the work order system without opening Vivu.
Show the user one sample row and the field mapping, and wait for an OK before writing the rest:
clip_file,rank,start_mmss,end_mmss,category,lat,lon,location_note,search_reason,contact_sheets,claude_label,claude_note,patrol_verified,trim_grade
LP_02.mp4,1,00:00,00:25,tree_on_line,,,NOT VERIFIED: no SRT coordinates (public test footage),"Aerial drone view of a broken tree and large limbs lying directly on and tangled in overhead power lines.",sheets/tree_on_line/r01_LP_02_0.png,looks right,"top down: broken crown lying across a pole with crossarm and its wires, 00:00 to 00:20",,
The row above is from our test run, with contact_sheets written in the Step 6 naming (the test run's own sheet files used different names); the user's rows carry their own clip names and coordinates.
| Column | Source | If unavailable |
|---|---|---|
| clip_file | spans.csv, matched by listed_name | keep Vivu's file name, label the row can't tell with "no local clip matched", and tell the user |
| rank | result_number in results/FIELD.json | none |
| start_mmss, end_mmss | start_ms and end_ms, written MM:SS | none |
| category | the condition searched (the label decides whether it holds) | none |
| lat, lon, location_note | Step 7, the drone position at the window start | blank, with UNCERTAIN or NOT VERIFIED and the reason in location_note |
| search_reason | the result's reason, copied as is; Vivu's description, not evidence | blank |
| contact_sheets | the sheets 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 |
| patrol_verified | left empty for the patrol crew | empty |
| trim_grade | left empty for the qualified arborist | empty |
claude_label and claude_note are Claude's reading of a drone frame, not a field inspection or a clearance measurement. The patrol crew checks every row, the looks right ones included, and a qualified arborist sets trim_grade before a work order is opened.
Write work_list.csv with one row per result, grouped by condition and sorted by rank, including the rows labeled looks wrong: the planner may disagree with a label, and the rejected rows show what the search confuses. The CSV uses the user's own clip names, times and coordinates, never a Vivu result page link, so it stays usable after the link expires.
Then tell the user, per condition, 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 a short list does not mean a feeder is clear, that contact with a thin wire often cannot be seen at drone resolution, and that pole and vine rows are mostly looks wrong. Do not add recall or precision figures: the hand marks needed to measure them do not exist for the user's batch.
The CSV stays in the working folder. Entering jobs into the work order system is the user's step. If the user asks Claude to upload or post the list (a shared drive, a tracker, a chat with the contractor), name the destination, show the rendered first rows and wait for a yes before each write.
In our test run the CSV was written from the dry run's results and sheets; showing the sample row to a user and handing the list over were not exercised in our test run.
Done when work_list.csv has as many rows as the results in results/, the user approved the sample row and the mapping, and state.json marks the batch done.
Compliance
- Use footage the utility or its contractor flew under the local aviation rules (in the US, FAA Part 107 and any waiver the flight needed). Public videos used for testing need a license that allows it, kept for internal analysis only. Have the user confirm this before Step 4.
- Homes, yards, residents and vehicles appear in patrol footage along a distribution line. The skill lists vegetation and poles only; it does no face, plate or identity recognition, never searches for people, and leaves people, homes and plates out of every note. Do not use it to look at particular properties or people. Confirm the utility's policy for people in frame before Step 4.
- The skill does not measure clearance, judge whether a tree is dangerous, or set a trim grade. A qualified line clearance arborist or the utility's engineer decides, and only qualified workers go near energized lines.
- The clips 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 clips or the project only when the user asks, and confirm first.
- The skill writes only local files. Any upload or post of the list goes through the approval in Step 8.
Known failure modes
| Symptom | Cause | Fix |
|---|---|---|
| (observed) cut up debris on the ground at a driveway came back as "fallen tree branches and debris lying across overhead power lines" | the reason names what was asked for; from above, debris under the wires and a tree on the wires look alike | label from the zoomed frame; debris that does not rest on the wires looks wrong |
| (observed) bare new poles in a field came back as "Vines and climbing plants are visibly growing up" the pole | the footage had no vines, and the search filled the empty class with the nearest poles | treat vine rows as untested; label only from a zoomed frame that shows leaves on the pole |
| (observed) a control search for a nest returned bare crossarms with "a large bird nest constructed of sticks is clearly visible" | a class missing from the footage is not reliably answered with zero results | never take a result as proof a thing exists; an empty class can still return rows |
| (observed) pole search: 11 returned, 4 real, 4 false and 3 can't tell; an upright pole came back as "A snapped wooden utility pole remains standing" | lean and breakage are geometry the search does not judge well, and dark top down frames hide the pole | keep pole_leaning optional; judge lean against the horizon or road edge on a zoomed frame |
| (observed) a dark top down window where the wire run disappears under crowns was hard to call | height above the wires cannot be read from straight above, and the test clip was low resolution | label it borderline in claude_note; ask for oblique passes or higher resolution exports on the next patrol |
| (observed) every clip sat in the queue for most of the time before indexing started | the account's indexing queue was busy | keep polling vivu_list_videos; a queued status is not an error |
| contact between a limb and a wire cannot be seen in any frame | conductors are one or two pixels against sky or leaves | label can't tell and leave it to the patrol crew; never infer contact from the reason |
| 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 spans.csv | Vivu replaced a space, bracket, plus or percent sign in the name | match on listed_name |
| a search returns exactly its maximum_results | the batch holds more candidates than one search returns | mark the condition cut off, say so, and offer to split the batch |
| a condition comes back empty | none in the batch, or the search missed them | an empty result does not prove the feeder has none; say so in the summary |
| coordinates land on the wrong span | the camera looks ahead or sideways of the drone, or the SRT has gaps | treat lat and lon as the drone position, check the UNCERTAIN note, and match to the nearest pole on the feeder map |