Skip to content
Skills Library
Data & analytics · Conversion & formats

map-reports

/map-reports

Show the owner where things are and what covers what: one generated Leaflet page per site from records (never hand-edited), KML truth that round-trips through Google Earth, 1080x1350 PNGs for the phone thread, install photos filed as evidence, and the Fix-GPS correction loop back into the records. Use when: mapping device positions or coverage, rendering a setup sheet or annotated map image, filing install photos, or accepting a location correction from the owner.

Licence
MIT
Last repository change
04.11.2026

Assessment and security

90/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
9
Scripts
4
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 04.11.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What to check before installing
  • 4 scripts in this package. Review them before installing, as Claude may execute them.

Scripts: references/build-map.ts, references/check-png.py, references/test.sh, references/vendor/leaflet.js

What it does and when to use it

Show the owner where things are and what covers what: one generated Leaflet page per site from records (never hand-edited), KML truth that round-trips through Google Earth, 1080x1350 PNGs for the phone thread, install photos filed as evidence, and the Fix-GPS correction loop back into the records. Use when: mapping device positions or coverage, rendering a setup sheet or annotated map image, filing install photos, or accepting a location correction from the owner.

Original author description

Show the owner where things are and what covers what: one generated Leaflet page per site from records (never hand-edited), KML truth that round-trips through Google Earth, 1080x1350 PNGs for the phone thread, install photos filed as evidence, and the Fix-GPS correction loop back into the records. Use when: mapping device positions or coverage, rendering a setup sheet or annotated map image, filing install photos, or accepting a location correction from the owner.

How it works

  1. Part 1 — The checklist (generated from records, never hand-edited)
  2. Part 2 — Skill doc
Original SKILL.md headings · 332 lines, 2,327 words
SKILL.md preview
---
name: map-reports
description: "Show the owner where things are and what covers what: one generated Leaflet page per site from records (never hand-edited), KML truth that round-trips through Google Earth, 1080x1350 PNGs for the phone thread, install photos filed as evidence, and the Fix-GPS correction loop back into the records. Use when: mapping device positions or coverage, rendering a setup sheet or annotated map image, filing install photos, or accepting a location correction from the owner."
topics: [reports, maps]
tested: self-test
---

# `map-reports` skill (records → map → image → evidence → correction) [template v1 draft]

The owner never reads TOML or a RouterOS command —
about half the physical-world work (siting, aim, power, install)
ended as something to *show* the owner: a map, a marked photo, a
sheet for the person on the pole (collected: earlier field runs).
This skill holds the MAP halves of the presentation
work: site-map generation plus the map halves of
setup-sheet-png-render, install-photo-evidence, and
human-correction-roundtrip. The FIELD halves (device jobs,
expected-result/stop-condition sheets, hands-work artifacts)
belong to pending field-sheets — that boundary is marked in
every step below, and field-sheets stays listed, never absorbed silently.
Geo maps live here (where sites sit); logical topology lives in
truthful-topology-graphviz (links/paths/neighbors, DOT→SVG).
No secrets below; fixtures are synthetic, never a real place.

## Part 1 — The checklist (generated from records, never hand-edited)

Run top to bottom. Every artifact regenerates from the records
after any correction — hand-editing a generated page or map is
forgery of evidence, not a shortcut.

1. Source positions from records (§0): KML truth in, `gis`
   block per site, public-data layers named with source labels.
2. Generate the map page (§1): one Leaflet page per site —
   backgrounds, GIS overlays, records on top, honesty labels.
3. Render the image artifacts (§2): 1080×1350 PNG path via
   headless browser (map half of setup-sheet-png-render).
4. File image→data evidence (§3): install photos unchanged +
   hashed + EXIF-indexed, never used as precise pins (map
   half of install-photo-evidence).
5. Close the correction loop (§4): Fix-GPS page emits
   structured corrections; agent applies, regenerates,
   publishes (map half of human-correction-roundtrip).

### 0. Source (KML truth + the `gis` block)

- The architect's Google Earth KML is the source of truth for
  positions: the map reads it, and Fix GPS writes corrections
  back in the same format. KML means the owner can also open
  it in Google Earth on a phone, with no new app (collected:
  earlier field runs).
- The template carries a `gis` block per site: layer URLs,
  fields to keep, and a source label per layer (inferred
  shape, collected proposal from earlier field runs).
  `references/fixtures/gis.json` shows the
  shape; operators bring their own layer URLs.
- There is no Meta maps API — no public tiles/geocoding SDK
  under a Meta brand. Geographic site maps render via
  OSM/MapLibre or the Muse app's own map widgets (geocoding
  tool, Places connector); Meta's footprint is open-data, not
  API (collected: the platform tooling explainer). If
  street-level context ever matters, Mapillary is the one
  speculative Meta asset — not planned.
- Fetched features cache by bounding box; a cached box that
  already contains the requested one is reused, so a small
  GPS correction does not refetch everything (collected:
  earlier field runs).
- Privacy is load-bearing: the map is the most
  location-revealing thing the workspace makes. Choose
  parcel fields so no owner names come through; never show
  it in public video without blurring; keep the GIS cache
  out of any public repo (collected: earlier field runs).

### 1. Generate (one Leaflet page per site)

- One generated HTML page per site (Leaflet, no build step),
  regenerated from the records, never hand-edited. Layers
  (collected: earlier field runs):
  - Backgrounds: satellite, topographic, and USGS 3DEP
    LiDAR hillshade — the hillshade shows ridges, gullies,
    and tree lines that satellite hides, and that is what
    decides where a radio link works.
  - Public GIS overlays from county ArcGIS REST
    FeatureServers (parcels with NO owner names, roads)
    and USGS NHD (streams).
  - Records drawn on top: each device at its location;
    radio links coloured by clear-air link budget;
    estimated Wi-Fi coverage; planned cameras.
- The coverage estimate says what it is: free-space loss
  plus a flat clutter margin, limited by the phone's
  uplink, antenna gain from what each radio reports. "A
  sketch, not a survey" is written into the model AND the
  page — that label is what made it safe to show a
  non-expert (collected: earlier field runs).
- Present-it rule for this artifact (from earlier field runs):
  owner asking "where / what covers
  what" gets the site map (page or single image) with
  source labels per layer, "estimate" on coverage, and a
  capture date.
- Observed (this skill's self-test): `references/build-map.ts`
  generates a self-contained Leaflet page from synthetic
  fixtures — vendored Leaflet 1.9.4 inlined, devices as SVG
  markers coloured by budget, link polyline, dashed coverage
  circle with the honesty label, per-layer source footer,
  revision id + generated time. Fixture mode uses no tile
  layer and zero page-initiated network requests, so the
  test renders fully offline.
- Pending: first render against real records + live tile/GIS
  endpoints (needs sandbox egress probes: ArcGIS, USGS
  hillshade, OSM tiles through the proxy — collected probe
  list from earlier field runs).

### 2. Render (the 1080×1350 PNG path — MAP half of setup-sheet-png-render)

- The owner looks at things on a phone, in a text thread —
  the useful output is often a PNG/JPEG, not a web page
  (from earlier field runs). The render primitive:
  a `?p=N` query renders a single page, and a headless
  browser screenshots each page to its own PNG, ready for
  iMessage/RCS. The same records give an HTML version for
  printing. Page size is 1080×1350, phone portrait.
- One-off annotated maps (satellite tile + proposed link
  drawn and labelled, sent as a single JPEG) were composed
  by a small tile/line/label program on macOS; on Linux
  the equivalent is a headless Chromium screenshot of the
  map page, or a small canvas render (from earlier
  field runs). Whiteboards screenshot the same
  way (boards themselves are decision-board-lifecycle).
- Observed (this skill's self-test): headless Chromium
  renders the fixture page to an exact 1080×1350 PNG
  (`references/test.sh` asserts dimensions + non-blank via
  `references/check-png.py`; 564 unique sampled colors on
  the proving run). The PNG-path mechanism is proven; only
  real-record content is pending.
- Pending (collected day-0 probes from earlier field runs):
  sandbox-generated PNG shown inline in the Muse phone app;
  headless browser available in the sandbox (its browser
  cannot reach loopback, but a file render may still work).
- Boundary with field-sheets (still pending): the
  sheet CONTENT for hands work — IKEA-style per-location
  pages, what-plugs-into-what, compass-words aiming, "how
  to tell it worked", "if not, stop and send a photo" —
  belongs to field-sheets. This skill owns only the render
  primitive (`?p=N` + headless screenshot + print HTML from
  the same records). field-sheets stays listed.

### 3. File (image→data evidence — MAP half of install-photo-evidence)

- Pictures also flow into the records (collected:
  earlier field runs): phone panoramas fitted to a LiDAR
  skyline (recovered position/heading when phone GPS was
  ~90 m stale and compass ~95° off; same fit gave
  winter-sun hours); antenna patterns read off vendor PDFs
  into the coverage model, labelled as read by eye.
- Install photos are filed as evidence: kept UNCHANGED,
  with sha256 and EXIF provenance in an index file. Camera
  GPS error (12–15 m) is recorded, and the photos are NOT
  used as precise equipment pins (collected:
  earlier field runs). Photos say what the records
  cannot: "the wAP is at the window, facing the street"
  settled a coverage question no router reading could.
- Prescribed but pending: U2 install-photo check (photo of
  the wiring checked against the install sheet — a natural
  SAM job with no credentials in frame, DESIGN); U3 siting
  from a panorama (hand-written skyline mask JOURNALED,
  SAM segmentation DESIGN; keep GPS out of public frames);
  vendor-PDF digitizing done carefully — cite the page,
  keep variants separate, never digitize a curve into false
  precision (collected: earlier field runs).
- Demo rules for every published frame: no names, places,
  addresses, or serials; strip EXIF GPS from photos
  (collected: presentation rules from earlier field runs). pre-publish-scrub
  gates any public step.
- Boundary with field-sheets: the install SHEET the photo is checked
  against, and any field checklist the photo completes,
  belong to field-sheets. This skill owns filing (unchanged bytes +
  hash + EXIF index + recorded GPS error) and the
  photos-are-not-pins rule.

### 4. Correct (Fix GPS — MAP half of human-correction-roundtrip)

- Fix-GPS mode: the owner drags existing pins or adds
  points; edits persist in browser localStorage; the page
  copies structured TOML-like corrections (original
  position + movement distance) to paste to the agent, and
  exports KML for Google Earth inspection. When
  regenerated data already contains a correction, the page
  clears the corresponding local edit within a small
  tolerance (collected: an earlier design review and field runs).
- This is the human → artifact → agent → structured-record
  loop: the human supplies spatial judgment through a map;
  the agent handles file editing and propagation — no
  TOML, no paragraphs-of-chat location descriptions
  (collected: the concept review). Demo beat O3: a
  correction flows back (Fix-GPS loop JOURNALED; needs the
  portable "copy for your agent" wording — it names a specific agent
  today).
- Limits, all load-bearing (collected: the concept review):
  browser-local edits are NOT synchronized inventory
  updates; copying a correction is NOT proof the agent
  applied it. Required additions: a revision identifier
  and a visible proposed / applied-to-inventory / published
  distinction, especially when old pages remain open.
- Observed (self-test fixture): draggable SVG markers,
  localStorage keyed by revision, "Copy correction for
  your agent" button emitting `device=… original_lat=…
  original_lon=… new_lat=… new_lon=… moved_m=…
  status=proposed revision=…` lines, corrections-KML
  download, and sub-meter-drag tolerance clearing. The
  page pattern is proven; a live owner round-trip is
  pending.
- Boundary with field-sheets: generalizing the pattern to
  port-label corrections, "this device is in the other
  room", proposed cable routes, and field-observation
  checklists (collected proposal: the concept review) is
  field-sheets' content design. This skill owns the map-loop
  mechanics: drag → structured proposal → agent applies →
  regenerate → published. field-sheets stays listed.

## Part 2 — Skill doc

### Trigger

Load when: mapping device positions or RF coverage; rendering
a setup sheet or annotated-map image; filing install or site
photos as evidence; accepting a location/label correction
from the owner; asking which artifact fits the person looking
(present-it table: the presentation rules). (Entry-skill +
capability-probe pattern.)

### Prereqs

- Records with positions (KML truth or site records) + a
  `gis` block per site (layer URLs, fields, source labels).
- A render machine with a headless browser for the PNG path
  (`chromium` observed on a Linux host; `test.sh` also accepts
  `google-chrome` / `chromium-browser`).
- Bun + python3 for the reference generator and self-test.
- Know which harness the artifact must suit (harness-capability-inventory
  → presentation-layer keying, both pending): phone-thread
  PNG, printable HTML, live page, or chat-inline image.

### Access

- Pure local render: NO twin, NO box writes, NO router
  contact. Safe anywhere, including beside production.
- Maps are the most location-revealing workspace artifact:
  parcel fields exclude owner names; GIS cache stays
  local-only (never a public repo); blur maps in public
  video; strip EXIF GPS before any public frame.
- Photos filed as evidence keep original bytes + sha256 +
  EXIF index; the index, not the photo, carries the
  provenance claims.

### Envs

| Name | Use |
|---|---|
| `CHROME` | Optional override for the headless browser binary (`test.sh` probes `chromium`, `google-chrome`, `chromium-browser` when unset) |

No secrets, tokens, or API keys in env for this skill — map
and GIS sources here are public-data endpoints, and no
credentialed door is part of the render path.

### Outputs

- Generated site-map page (one per site, revisioned,
  source-labelled, never hand-edited).
- KML truth (round-trips through Google Earth; corrections
  back in the same format).
- 1080×1350 PNG pages (phone thread) + print HTML from the
  same records.
- Photo evidence index (sha256 + EXIF provenance +
  recorded GPS error per photo).
- Structured corrections (`device/original/new/moved_m/
  status=proposed/revision`) + applied/published status.

### Verification

- Regeneration check: same records → same page (revision
  id stable); a correction applied + regenerated clears
  the matching local edit within tolerance.
- Honesty labels present: "A sketch, not a survey" on
  coverage; source label per layer; capture/generated
  date; proposed vs applied vs published on corrections.
- KML round-trip: parses as XML; Placemark count and
  coordinates match the records (self-test asserts this).
- PNG check: exactly 1080×1350 and non-blank (self-test
  asserts via `check-png.py`).
- Privacy audit: no owner names in parcel fields, no
  EXIF GPS in published frames, no real places in
  fixtures, GIS cache outside any public tree.
- Claim audit: each map claim carries command + output or
  an honest collected/inferred/pending label.

### Recovery

- Render disagrees with the records → re-generate first
  (stale render is the common case); the records win.
- Correction disputed → it stays `proposed` until the
  agent applies or rejects it with a reason; downgrade
  beats deletion (the question stays visible).
- Tile/GIS endpoint unreachable → show last-good cached
  box with its capture date + source error; never swap in
  a different area silently (last-good-data rule:
  the concept review).
- Secret or real location leaked into a shared artifact →
  delete the artifact, scrub per pre-publish-scrub, record as an
  anomaly (evidence-ledger precedent).
- Browser missing on a new machine → install Chromium or
  equivalent; the `?p=N` + screenshot primitive does not
  change.

### Limits

- No live-record render has been exercised in this lane
  yet: the self-test proves the pipeline on synthetic
  fixtures; first real-records map + live tile/GIS fetch
  is pending (sandbox egress probes open).
- No live owner round-trip yet: Fix-GPS page mechanics are
  proven in the fixture; a real drag → paste → apply →
  regenerate → publish cycle is pending.
- U2/U3 vision steps (SAM install-photo check, SAM skyline
  segmentation) are DESIGN, not proven; the journaled
  panorama fit used a hand-written mask.
- This skill covers GEO maps (positions, coverage, GIS,
  KML, PNGs). Logical topology is truthful-topology-graphviz (DOT→SVG,
  observed/inferred marking) — neither geo nor RF
  coverage graduates through that pipeline. Topology views
  of multi-AP sites are site-plan-multi-ap (Leaflet is
  NOT the useful view there). Outdoor link data (Starlink,
  LiDAR beyond hillshade, property lines, solar) extends
  via pending maps-outdoor. Whiteboard content is decision-board-lifecycle;
  WebFig deep links are webfig-handoff; harness keying is harness-capability-inventory/presentation-layer.
- Field-sheets content (field-sheets, pending) is the standing
  companion: device jobs, aiming, expected-result and
  stop-condition sheets. This skill's render/file/loop
  halves plug into it; they do not replace it.
Files in this package (9)
  • SKILL.md 16 KB
  • references/build-map.ts 9 KB
  • references/check-png.py 3 KB
  • references/test.sh 4 KB
  • references/fixtures/gis.json 1 KB
  • references/fixtures/sites.json 1 KB
  • references/vendor/README.md 1 KB
  • references/vendor/leaflet.css 14 KB
  • references/vendor/leaflet.js 144 KB

Versions

The database has no other skills named map-reports.

Database snapshot: 13.11.2026 · package version ac4328809bc3 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100travel-map
    Generate an interactive map showing every location where photos were taken, clustered by city/region with photo counts, date ranges, and album links. Outputs a standalone HTML file with Leaflet.js that can be hosted or viewed locally. Use when the user says "travel map", "show…
  • 100bangalore-drives
    Analyse a Google Maps Timeline export (Timeline.json from the phone, or a zip of it) for driving in Bangalore - clean the GPS, snap car and motorbike trips to the road network, and produce speed statistics, a glow map image, an interactive speed map and a time-lapse video. Use…
  • 100baidu-maps-footprint-export
    Export and recover personal Baidu Maps footprints and historical location tracks (百度地图足迹/历史轨迹) from a user-owned Android device or emulator, then convert cached CSV tracks to WGS84 GeoJSON, GPX, or KML for QGIS. Use for interrupted ADB collection recovery and optional StepLife-compatible GPX export.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.