SkillsSkill for Claude

Vegetation work list from line patrol drone video

This skill turns the drone video a line patrol crew flies along distribution feeders into a trim work list for a vegetation management planner. Claude picks only the spans the trip records and trim plan point to, prices them against your Vivu plan, uploads them to a private project, runs one precise search per condition (a tree or limb down on the line, crowns grown up into the wires, and optional leaning poles and vines), checks every window on a contact sheet, reads the drone position from the SRT flight log, and writes work_list.csv with empty patrol_verified and trim_grade columns. A patrol note says which poles have heavy vegetation; only the picture shows which tree is on which span, so every row is labeled from its frames and rejected candidates stay in the list.

Maintained by Vivu. Updated 2026-11-19.

Download

line-patrol-vegetation-work-list.zip

12 KB. Unzips to line-patrol-vegetation-work-list/SKILL.md. Upload the zip as it is in the Claude app, or unzip it into your skills folder for Claude Code.

SHA-256 a820a236e281be323a4e5bd0ff6ad9ab8df50e71ee7ac5bda643620f19275329

At a glance

What the Vegetation work list from line patrol drone video skill does, where it runs, what it needs, and when it asks
Looks forVegetation problems big enough to see from a patrol drone: fallen or broken trees and limbs lying on the wires or piled against a pole, and living crowns grown up to the wires so the line runs into the leaves. Drone audio is propeller noise and the files have numbered names, so only the video shows them. Every candidate is checked against frames from the original clip before it is labeled, and contact with a thin wire is often not visible, so the patrol crew verifies every row.
Runs onClaude Code on your computer (the terminal or the Code tab of Claude Desktop), with a shell, ffmpeg, ffprobe and python3, and the drone MP4 files and their SRT flight logs as local files. No residential IP and no scheduler are needed; it runs once per patrol batch. Claude on the web and cloud sessions cannot reach the local files.
Needs
  • The Vivu connector with write access, to create a private project, open its upload page and search.
  • The drone videos as MP4 files on your computer, because every clip and contact sheet is cut from the local file.
  • The matching SRT flight log for each video, for the latitude and longitude of each moment.
  • A shell with ffmpeg and ffprobe, to cut spans, measure them and make contact sheets and zoomed frames.
  • python3, for the helper that reads coordinates from the SRT files.
  • The trip records and this year's trim plan as text, to choose which feeders and spans to index.
  • A way to upload: the Vivu upload page in your own browser, or a browser tool that can attach local files.
  • Someone who checks the list, because Claude's labels are a first pass and patrol and the arborist decide.
Your Vivu planIndex minutes equal the total length of the spans you choose, and each condition is one precise search at 5 credits, so the two default conditions use 10 credits per batch and all four use 20 (estimate). The skill measures the clips with ffprobe, reads your allowance with vivu_get_usage and shows the cost before anything is uploaded. Twelve four minute spans fit inside Premium; Free covers about five such spans a month.
Asks you firstApproving the list of spans to cut, approving the clip list and its index minutes before upload, confirming the footage rights, the flight rules and the policy for people in frame before upload, approving one sample row and the field mapping before the full CSV is written, and any upload or post of the list somewhere outside the working folder.

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 footage your utility or its contractor flew under the local aviation rules; public test footage needs a license that allows internal analysis.
  • Patrol footage shows homes, yards and people; the skill does no face, plate or identity recognition and leaves people and properties out of every note.
  • Vivu's results are candidates: each one is checked on a contact sheet and labeled looks right, looks wrong or can't tell, and the patrol crew verifies every row.
  • Visual search for trees on or into the wires misses some and its reason text overstates what the frame shows; a short list does not mean a feeder is clear.
  • The leaning pole search is low precision, and vines on poles are untested: the search returned bare poles described as covered in vines.
  • The skill measures no clearance and sets no trim grade or hazard rating; a qualified arborist or the utility's engineer decides.
  • The SRT coordinate step was not tested on a real flight log, and the coordinates are the drone position, not the tree's.
  • Browser upload tools may cap file size (Claude in Chrome accepts at most 10 MB per call); larger clips go through your own browser or the Vivu web app.
  • Clips stay in your Vivu project until you delete them; the project is created as private because the default is visible to your whole organization.
  • The skill writes only local files; any upload or post of the list waits for your approval.

Start it

Once the skill is installed, ask for the task in your own words. Naming the skill is the most reliable way to have Claude use it. For example:

Here is last week's patrol flight folder with the SRT files, the trip log for feeders 12 and 31, and our trim plan. Make a vegetation work list for the trim contractor.

In Claude Code you can also type /line-patrol-vegetation-work-list. 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: Pick the spans and cut them
  8. Step 3: Measure the spans and price them
  9. Step 4: Upload and index
  10. Step 5: Search each condition
  11. Step 6: Make contact sheets and label every candidate
  12. Step 7: Read the coordinates from the SRT flight log
  13. Step 8: Write the work list and hand it over
  14. Compliance
  15. Known failure modes

The full skill

This is line-patrol-vegetation-work-list/SKILL.md from the download, as Claude reads it: the frontmatter first, then the instructions.

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

  1. 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.
  2. 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.
  3. 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.
  4. People, vehicles and homes. The skill never searches for or lists them.
  5. 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.
  6. 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

  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 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.
  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 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.
  5. 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.
  6. 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.

  1. FLIGHT_DIR: the folder that holds the MP4 and SRT files. Required.
  2. 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.
  3. 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.
  4. 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).
  5. 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.

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

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

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

  1. Run ffprobe -v error -show_entries format=duration -of csv=p=0 vegetation-BATCH_NAME/clips/CLIP_NAME.mp4 for 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.
  2. 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.

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

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

  1. 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.
  2. 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.
  3. 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.
  4. vines_on_pole looks right only when leaves visibly climb the pole or guy wire on a zoomed frame.
  5. 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.

  1. 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.
  2. 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.
  3. pole_leaning: 11 returned, 4 real, 4 false and 3 can't tell, and 0 missed. The false ones were upright poles.
  4. vines_on_pole: 3 returned, 0 real and 3 false. The footage had no vines on poles.
  5. 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.
  6. 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"\.mp4
quot;, ".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

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

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.