openmapstack 0.2.0__py3-none-any.whl

openmapstack/verify.py

@@ -0,0 +1,386 @@
+"""Verify a produced project without requiring a golden answer.
+
+`validate` audits the manifest and its bookkeeping. `verify` runs the check
+library in `openmapstack.checks` against what the pipeline actually produced:
+geometry read back through DuckDB Spatial, dataset CRS read from real
+coordinates rather than the manifest's claim, validation evidence recomputed
+from the geodata it summarises, the QGIS project loaded, and -- with
+`--rerun` -- the whole project rebuilt from source in an empty workspace.
+
+The checks planned here do not require a repository-owned golden answer, so
+they transfer to data this package has never seen. They establish bounded
+structural, provenance, artifact, and reproducibility predicates; they do not
+claim to prove every project-specific analytical answer.
+
+The plan is derived from the manifest rather than configured, so a project
+cannot quietly opt out of a check by omitting it: an output declared in
+`outputs` is an output that gets checked.
+"""
+
+from __future__ import annotations
+
+import re
+import shutil
+import tempfile
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from .checks import AssertionResult, not_testable
+from .checks import geodata as geodata_checks
+from .checks import overrides as overrides_checks
+from .checks import presentation as presentation_checks
+from .checks import project as project_checks
+from .checks import provenance as provenance_checks
+from .checks import qgis as qgis_checks
+from .checks import rerun as rerun_checks
+from .checks import validation as validation_checks
+from .expectations import evaluate_expectation
+from .project import load_project
+from .rerun import perform_clean_rerun
+
+SCHEMA = "openmapstack-verify-result/v1"
+
+# Formats DuckDB Spatial can read back. A declared output in some other
+# format is reported as unchecked rather than silently skipped.
+GEODATA_SUFFIXES = {".parquet", ".gpkg", ".geojson", ".json", ".fgb", ".shp"}
+
+_EPSG = re.compile(r"\bEPSG:\s*(\d{4,6})\b", re.IGNORECASE)
+
+
+@dataclass
+class CheckRun:
+    """One executed check, named the way an eval case would name it."""
+
+    name: str
+    result: AssertionResult
+    args: dict[str, Any] = field(default_factory=dict)
+    evidence: dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        payload: dict[str, Any] = {
+            "check": self.name,
+            "status": self.result.status,
+            "message": self.result.detail,
+        }
+        if self.args:
+            payload["args"] = self.args
+        if self.evidence:
+            payload["evidence"] = self.evidence
+        code = (self.result.data or {}).get("code")
+        if code:
+            payload["code"] = code
+        return payload
+
+
+@dataclass
+class VerifyResult:
+    project_file: Path
+    checks: list[CheckRun] = field(default_factory=list)
+    rerun_evidence: dict[str, Any] | None = None
+
+    @property
+    def counts(self) -> dict[str, int]:
+        totals = {"passed": 0, "warning": 0, "not_testable": 0, "failed": 0}
+        for run in self.checks:
+            totals[run.result.status] = totals.get(run.result.status, 0) + 1
+        return totals
+
+    @property
+    def coverage(self) -> dict[str, int | float | None]:
+        """Describe how much of the applicable plan actually executed.
+
+        ``verify_project`` only adds checks that apply to the manifest: QGIS
+        checks, for example, are absent when no QGIS project is declared.
+        Every added check is therefore applicable. A ``not_testable`` result
+        means that applicable check could not execute its predicate because
+        an environmental dependency, supported artifact, or required
+        addressing information was unavailable.
+        """
+        applicable = len(self.checks)
+        not_testable_count = self.counts["not_testable"]
+        executed = applicable - not_testable_count
+        return {
+            "applicable": applicable,
+            "executed": executed,
+            "not_testable": not_testable_count,
+            "execution_rate": executed / applicable if applicable else None,
+        }
+
+    @property
+    def status(self) -> str:
+        counts = self.counts
+        if counts["failed"]:
+            return "failed"
+        if counts["warning"]:
+            return "warning"
+        if counts["not_testable"]:
+            # A completely unavailable plan is not testable. A partially
+            # executed plan is a warning: the successful checks remain useful,
+            # but the report must not present incomplete evidence as passed.
+            return "not_testable" if self.coverage["executed"] == 0 else "warning"
+        if not self.checks:
+            return "not_testable"
+        return "passed"
+
+    def ok(self, *, strict: bool = False) -> bool:
+        return self.status == "passed" if strict else self.status != "failed"
+
+    def to_dict(self) -> dict[str, Any]:
+        payload: dict[str, Any] = {
+            "schema": SCHEMA,
+            "project_file": str(self.project_file),
+            "status": self.status,
+            "counts": self.counts,
+            "coverage": self.coverage,
+            "checks": [run.to_dict() for run in self.checks],
+        }
+        if self.rerun_evidence is not None:
+            payload["clean_rerun"] = self.rerun_evidence
+        return payload
+
+
+def _declared_output_paths(project: dict[str, Any]) -> list[tuple[str, str, str | None]]:
+    """Return (output id, project-relative path, declared EPSG or None)."""
+    outputs = project.get("outputs")
+    if not isinstance(outputs, dict):
+        return []
+    found: list[tuple[str, str, str | None]] = []
+    for name, spec in outputs.items():
+        if not isinstance(spec, dict):
+            continue
+        path = spec.get("path")
+        if not isinstance(path, str) or not path.strip():
+            continue
+        match = _EPSG.search(str(spec.get("format", "")))
+        found.append((str(name), path, f"EPSG:{match.group(1)}" if match else None))
+    return found
+
+
+def _immutable_input_paths(root: Path) -> list[str]:
+    paths: list[str] = []
+    for directory in ("data/source", "data/overrides"):
+        base = root / directory
+        if not base.is_dir():
+            continue
+        for item in sorted(base.rglob("*")):
+            if item.is_file():
+                paths.append(item.relative_to(root).as_posix())
+    return paths
+
+
+def _run(
+    runs: list[CheckRun],
+    name: str,
+    fn: Callable[..., AssertionResult],
+    root: Path,
+    **kwargs: Any,
+) -> None:
+    try:
+        result = fn(root, **kwargs)
+    except Exception as exc:  # noqa: BLE001 - a check must never take the command down
+        result = not_testable(f"{type(exc).__name__}: {exc}", code="check_error")
+    runs.append(CheckRun(name, result, dict(kwargs)))
+
+
+def verify_project(
+    project: str | Path,
+    *,
+    rerun: bool = False,
+    rerun_timeout_s: float = 1800,
+    forbidden_fragments: Sequence[str] = (),
+) -> VerifyResult:
+    """Run every applicable no-golden-answer check the environment supports."""
+    project_file, manifest = load_project(project)
+    root = project_file.parent
+    result = VerifyResult(project_file=project_file)
+    runs = result.checks
+
+    # -- contract: the manifest describes a resolvable, single-entrypoint project
+    _run(runs, "project.parses", project_checks.parses, root)
+    _run(runs, "project.conforms_to_schema", project_checks.conforms_to_schema, root)
+    _run(runs, "project.graph_resolves", project_checks.graph_resolves, root)
+    _run(runs, "project.one_canonical_pipeline", project_checks.one_canonical_pipeline, root)
+    _run(runs, "project.assumptions_have_rationale", project_checks.assumptions_have_rationale, root)
+    _run(
+        runs,
+        "project.status_agrees_with_validation_report",
+        project_checks.status_agrees_with_validation_report,
+        root,
+    )
+    declared = [path for _, path, _ in _declared_output_paths(manifest)]
+    if declared:
+        _run(runs, "project.declared_files_exist", project_checks.declared_files_exist, root, files=declared)
+
+    # -- provenance: sources are attributed, pinned, and licensed
+    for name, fn in (
+        ("every_source_has_provider_and_access", provenance_checks.every_source_has_provider_and_access),
+        ("every_source_pinned", provenance_checks.every_source_pinned),
+        ("license_present_where_required", provenance_checks.license_present_where_required),
+        ("rationale_present", provenance_checks.rationale_present),
+    ):
+        _run(runs, f"provenance.{name}", fn, root)
+
+    # -- overrides: declared, evidenced, and verified against the real source
+    _run(runs, "overrides.every_override_has_provenance", overrides_checks.every_override_has_provenance, root)
+    _run(runs, "overrides.evidence_not_placeholder", overrides_checks.evidence_not_placeholder, root)
+
+    # -- validation: the report is complete, explicit, and matches the run record
+    for name, fn in (
+        ("required_all_present", validation_checks.required_all_present),
+        ("no_implicit_pass", validation_checks.no_implicit_pass),
+        ("warning_or_failed_propagates_to_status", validation_checks.warning_or_failed_propagates_to_status),
+        ("run_record_matches", validation_checks.run_record_matches),
+    ):
+        _run(runs, f"validation.{name}", fn, root)
+
+    # -- project-specific answers: execute only when independently attested
+    expectations = (manifest.get("validation") or {}).get("expectations", [])
+    if isinstance(expectations, list):
+        seen_expectation_ids: set[str] = set()
+        for index, expectation in enumerate(expectations):
+            expectation_id = expectation.get("id") if isinstance(expectation, dict) else index
+            if isinstance(expectation_id, str) and expectation_id in seen_expectation_ids:
+                result_value = AssertionResult(
+                    "failed",
+                    f"expectation id {expectation_id!r} is duplicated",
+                    {"code": "expectation_id_duplicate"},
+                )
+                evidence = {"class": "invalid"}
+            else:
+                result_value, evidence = evaluate_expectation(root, manifest, expectation)
+            if isinstance(expectation_id, str):
+                seen_expectation_ids.add(expectation_id)
+            check = expectation.get("check") if isinstance(expectation, dict) else None
+            args = expectation.get("args") if isinstance(expectation, dict) else None
+            report_args = {"check": check, **args} if isinstance(args, dict) else {"check": check}
+            runs.append(
+                CheckRun(
+                    f"expectation.{expectation_id}",
+                    result_value,
+                    report_args,
+                    evidence,
+                )
+            )
+
+    # -- geodata: read the produced files, do not trust what the manifest says
+    _run(runs, "geodata.crs_not_used_for_metrics", geodata_checks.crs_not_used_for_metrics, root)
+    for name, path, epsg in _declared_output_paths(manifest):
+        if Path(path).suffix.lower() not in GEODATA_SUFFIXES:
+            runs.append(
+                CheckRun(
+                    "geodata.geometry_all_valid",
+                    not_testable(
+                        f"output {name!r} is {Path(path).suffix or 'extensionless'}, "
+                        "which DuckDB Spatial does not read back",
+                        code="unsupported_format",
+                    ),
+                    {"path": path},
+                )
+            )
+            continue
+        _run(runs, "geodata.geometry_all_valid", geodata_checks.geometry_all_valid, root, path=path)
+        if epsg:
+            _run(runs, "geodata.dataset_crs_is", geodata_checks.dataset_crs_is, root, path=path, expected=epsg)
+        else:
+            runs.append(
+                CheckRun(
+                    "geodata.dataset_crs_is",
+                    not_testable(
+                        f"output {name!r} declares no EPSG code in its format string, "
+                        "so its real CRS cannot be cross-checked",
+                        code="crs_undeclared",
+                    ),
+                    {"path": path},
+                )
+            )
+
+    # -- presentation and QGIS: the product matches what the manifest claims
+    for name, fn in (
+        ("layers_use_semantic_roles", presentation_checks.layers_use_semantic_roles),
+        ("controls_match_pipeline", presentation_checks.controls_match_pipeline),
+        ("edit_targets_reference_real_sources", presentation_checks.edit_targets_reference_real_sources),
+    ):
+        _run(runs, f"presentation.{name}", fn, root)
+    if (root / "project.qgz").is_file():
+        for name, fn in (
+            ("static_valid", qgis_checks.static_valid),
+            ("styles_declared", qgis_checks.styles_declared),
+            ("groups_match_manifest", qgis_checks.groups_match_manifest),
+            ("every_layer_declares_crs", qgis_checks.every_layer_declares_crs),
+            ("runtime_load", qgis_checks.runtime_load),
+            ("layers_match_manifest", qgis_checks.layers_match_manifest),
+            ("every_declared_layer_renders", qgis_checks.every_declared_layer_renders),
+        ):
+            _run(runs, f"qgis.{name}", fn, root)
+
+    # -- reproducibility
+    _run(runs, "rerun.no_chat_dependency", rerun_checks.no_chat_dependency, root)
+    if rerun:
+        _verify_clean_rerun(
+            result,
+            root,
+            manifest,
+            timeout_s=rerun_timeout_s,
+            forbidden_fragments=forbidden_fragments,
+        )
+
+    return result
+
+
+def _verify_clean_rerun(
+    result: VerifyResult,
+    root: Path,
+    manifest: dict[str, Any],
+    *,
+    timeout_s: float,
+    forbidden_fragments: Sequence[str],
+) -> None:
+    """Rebuild the project from source and compare, then discard the copy."""
+    rerun_root = Path(tempfile.mkdtemp(prefix="openmapstack-verify-rerun-"))
+    try:
+        result.rerun_evidence = perform_clean_rerun(
+            root, rerun_root, timeout_s, forbidden_fragments=forbidden_fragments
+        )
+        runs = result.checks
+        _run(
+            runs,
+            "rerun.clean_execution_succeeded",
+            rerun_checks.clean_execution_succeeded,
+            root,
+            rerun_workspace=str(rerun_root),
+        )
+        outputs = [
+            path
+            for _, path, _ in _declared_output_paths(manifest)
+            if Path(path).suffix.lower() in GEODATA_SUFFIXES
+        ]
+        if outputs:
+            _run(
+                runs,
+                "rerun.outputs_semantically_equal",
+                rerun_checks.outputs_semantically_equal,
+                root,
+                rerun_workspace=str(rerun_root),
+                paths=outputs,
+            )
+        _run(
+            runs,
+            "rerun.validation_report_reproducible",
+            rerun_checks.validation_report_reproducible,
+            root,
+            rerun_workspace=str(rerun_root),
+        )
+        immutable = _immutable_input_paths(root)
+        if immutable:
+            _run(
+                runs,
+                "overrides.source_files_byte_identical",
+                overrides_checks.source_files_byte_identical,
+                root,
+                rerun_workspace=str(rerun_root),
+                paths=immutable,
+            )
+    finally:
+        shutil.rmtree(rerun_root, ignore_errors=True)

openmapstack-0.2.0.dist-info/METADATA

@@ -0,0 +1,268 @@
+Metadata-Version: 2.4
+Name: openmapstack
+Version: 0.2.0
+Summary: Validate, run, and inspect reproducible OpenMapStack projects
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: jsonschema<5,>=4
+Requires-Dist: PyYAML<7,>=6
+Provides-Extra: geo
+Requires-Dist: duckdb>=1.2; extra == "geo"
+Provides-Extra: visual
+Requires-Dist: playwright>=1.40; extra == "visual"
+Provides-Extra: all
+Requires-Dist: openmapstack[geo,visual]; extra == "all"
+Dynamic: license-file
+
+# openmapstack
+
+**Geospatial questions →  reproducible, validated GIS analysis project (with very nice interactive map).**
+
+Install:
+```bash
+npx skills add jaakla/openmapstack -g
+```
+
+OpenMapStack gives your favorite AI agent: Claude Code, Codex, Cursor, OpenCode, and 50+ other agents a production workflow from **authoritative data discovery** through analysis to interactive web and GIS deliverables. Material workflows become inspectable and repeatable well-defined projects in a `yaml` file with pinned sources, explicit assumptions and CRS choices, deterministic processing, isolated overrides, machine-readable validation, and surfaced provenance.
+
+It is open-first and cloud-native by default, built on shoulders of the awesome Open GIS stack: STAC for discovery; GeoParquet, COG, and PMTiles for storage and delivery; DuckDB and PostGIS for compute; and QGIS, MapLibre, and Martin for presentation. It also uses GDAL/OGR, GeoPandas, xarray/rioxarray, PDAL, routing engines, spatial SQL, and pragmatic hosted services when scale or reliability requires them.
+
+## What's in this repo
+
+- [SKILL.md](SKILL.md) — the skill entry point: triggers, global defaults, format and compute decision matrices, anti-patterns, and a quick triage guide.
+- [references/data-sources.md](references/data-sources.md) - lists OSM, Overture, Sentinel/Landsat, regional portals, STAC catalogs and others.
+- [references/services-and-scale.md](references/services-and-scale.md) - depending on case use local installs or hosted/SaaS services for global-scale basemaps, elevation, routing, geocoding, place search, and postcodes.
+- [references/formats-and-crs.md](references/formats-and-crs.md) - how to choose formats, conversions, projections, EPSG codes.
+- [references/processing.md](references/processing.md) - when and how to use GDAL/OGR, GeoPandas, xarray, DuckDB, PostGIS, PDAL and other open geo processing tools.
+- [references/analytics.md](references/analytics.md) — do vector/raster analytics, terrain, hydrology, network, point clouds, geocoding etc.
+- [references/web-delivery.md](references/web-delivery.md) — renderer selection for maps, PMTiles, MVT, Martin, TiTiler, MapLibre, deck.gl, kepler.gl, and lonboard formats and engines.
+- [references/qgis.md](references/qgis.md) — QGIS desktop, plugins, PyQGIS, Processing, QGIS MCP.
+- [references/validation-and-ops.md](references/validation-and-ops.md) — validation, manifests, attribution, and deployment checks, including the machine-readable reproducible-project contract.
+- [references/project-spec.md](references/project-spec.md) — the specific`openmapstack-project/v1` schema: compiling any material analysis into a reproducible GIS project (`project.yaml`, pipeline, source provenance, overrides, validation, semantic presentation, QGIS output).
+- [templates/](templates/) — ready scaffolds (`project.yaml`, `pipeline.py`, `presentation.yaml`, `validation.yaml`) for new projects.
+- [examples/tartu-development/](examples/tartu-development/) — a fully-worked reproducible project matching the acceptance scenario: source provenance + timestamps, explicit assumptions, two verified project overrides (a scenario attribute change with prior-value verification, and hypothetical scenario geometry), deterministic pipeline, machine-readable validation, and semantic presentation.
+- [evals/](evals/) — the eval suite grading whether an agent reaches the right analytical answer, respects the GIS-method guardrails, and reruns reproducibly, with the `openmapstack-project/v1` contract as the substrate that makes those independently checkable: `python evals/run.py --mode fixture` runs deterministic, no-LLM checks against real generated artifacts (analytical correctness against known geospatial truth, metric CRS, source immutability, schema, overrides, validation integrity, presentation contract, and clean reruns), plus adversarial cases and a pluggable live-agent benchmark (Claude Code, Codex, and any OpenAI-compatible API such as OpenRouter — URL and model via `OPENAI_COMPATIBLE_*` env, API key as a secret).
+- [`openmapstack/`](openmapstack/) — the installable `openmapstack validate/run/inspect` CLI for auditing and executing `openmapstack-project/v1` projects, plus [`openmapstack/checks/`](openmapstack/checks/): the reusable, semantic check library. All but five of its checks are oracle-free, so the same functions that grade the eval suite also grade a user's own project on data this repository has never seen.
+- [`.claude-plugin/`](.claude-plugin/) — Claude Code plugin and marketplace manifests, so the repository can also be installed with `/plugin install`. Validated in CI by [`.github/workflows/plugin.yml`](.github/workflows/plugin.yml).
+
+My local Estonia-specific guidance (Maa- ja Ruumiamet, ETAK, EPSG:3301 / L-EST97) is included for convenience. But all the global sources are incuded for world-wide coverage.
+
+## Install
+
+The recommended way is the [skills CLI](https://github.com/vercel-labs/skills), which works for Claude Code, Cursor, OpenCode, Codex, and 50+ other agents.
+
+### Recommended: skills CLI
+
+Install globally (available in every project):
+
+```bash
+npx skills add jaakla/openmapstack -g
+```
+
+Update later with `npx skills update open-map-stack`. Remove with `npx skills remove open-map-stack`.
+
+### Claude Code plugin (optional)
+
+Claude Code users can install the same repository as a plugin instead. This adds
+versioned installs, `/plugin update`, and project-scoped installs that a team
+picks up from a repository's `.claude/settings.json`:
+
+```bash
+/plugin marketplace add jaakla/openmapstack
+/plugin install open-map-stack@open-map-stack
+```
+
+The repository is its own marketplace, so no separate marketplace repo is
+needed. The plugin wraps the same root `SKILL.md` — nothing is duplicated, and
+the skills-CLI install path above keeps working unchanged.
+
+### Install the project CLI
+
+The skills installer loads the agent instructions; the Python package provides
+the project commands. From a clone of this repository:
+
+```bash
+python3 -m pip install .
+openmapstack --version
+```
+
+For development, the commands can also run directly without installation:
+
+```bash
+python3 -m openmapstack --help
+```
+
+### Manual install (fallback)
+
+If you'd rather not use the CLI, clone directly into your agent's skills directory. For Claude Code:
+
+```bash
+# User-level (every project)
+git clone https://github.com/jaakla/openmapstack.git ~/.claude/skills/open-map-stack
+
+# Project-level (one repo)
+git clone https://github.com/jaakla/openmapstack.git .claude/skills/open-map-stack
+```
+
+### Verify
+
+Start Claude Code and run `/skills open-map-stack` should appear in the list. The expected layout is:
+
+```
+<skills-dir>/open-map-stack/
+├── SKILL.md
+├── references/
+│   ├── analytics.md
+│   ├── data-sources.md
+│   ├── formats-and-crs.md
+│   ├── processing.md
+│   ├── project-spec.md
+│   ├── qgis.md
+│   ├── services-and-scale.md
+│   ├── spatial-sql.md
+│   ├── validation-and-ops.md
+│   └── web-delivery.md
+├── templates/
+│   ├── project.yaml
+│   ├── pipeline.py
+│   ├── presentation.yaml
+│   └── validation.yaml
+├── examples/
+│   └── tartu-development/
+└── .claude-plugin/          # Claude Code plugin + marketplace manifests
+    ├── plugin.json
+    └── marketplace.json
+```
+
+## Use
+
+The skill auto-activates when you ask Claude about geospatial work — terms like GIS, OpenStreetMap, Overture, Sentinel, Landsat, LiDAR, GeoTIFF, shapefile, GeoPackage, raster/vector tiles, isochrones, spatial joins, EPSG codes, and projections will all trigger it. You don't need to invoke it manually, but sometimes hinting "use open-map-stack skills" helps.
+
+Example prompts that engage the skill:
+
+- "Pull all buildings in Tartu from Overture and publish them as a PMTiles layer."
+- "Compute average NDVI for these polygons from Sentinel-2 over the last 12 months."
+- "Reproject this GeoTIFF from EPSG:3301 to EPSG:3857 as a COG."
+- "Set up an OSRM routing server from a Estonia OSM extract."
+- "Build an isochrone API around these points."
+
+If you want to force the skill to load, you can reference it explicitly:
+
+> Use the open-map-stack skill to convert this shapefile to GeoParquet.
+
+## Project CLI
+
+The CLI operates on an `openmapstack-project/v1` manifest. A project directory may
+be supplied in place of its `project.yaml` file.
+
+```bash
+# Audit the complete artifact, including outputs, report, and run record.
+openmapstack validate path/to/project.yaml
+
+# Check the produced artifacts without requiring a golden answer.
+openmapstack verify path/to/project.yaml
+
+# Run the one canonical pipeline, then validate what it produced.
+openmapstack run path/to/project.yaml
+
+# Review sources, versions, overrides, ordered steps, outputs, and latest run.
+openmapstack inspect path/to/project.yaml
+```
+
+Useful automation options:
+
+```bash
+openmapstack validate project.yaml --json --output validation/cli-report.json
+openmapstack validate project.yaml --strict       # warnings also return non-zero
+openmapstack validate project.yaml --preflight    # skip not-yet-generated artifacts
+openmapstack run project.yaml --dry-run
+openmapstack run project.yaml --json
+openmapstack inspect project.yaml --json
+```
+
+### `openmapstack verify` — check the analysis, not just the paperwork
+
+`validate` audits the manifest and its bookkeeping. `verify` runs the check
+library in `openmapstack/checks/` against what the pipeline actually produced:
+geometry read back through DuckDB Spatial, dataset CRS read from the artifact
+rather than the manifest's claim, validation evidence recomputed from the
+geodata it summarises, and QGIS project structure and runtime loading where
+PyQGIS is available.
+
+```bash
+openmapstack verify path/to/project.yaml
+openmapstack verify path/to/project.yaml --rerun     # + rebuild from source and compare
+openmapstack verify path/to/project.yaml --json --output validation/verify-report.json
+openmapstack verify path/to/project.yaml --strict    # warnings and not-testable also return 1
+```
+
+These checks require no repository-owned golden answer, so they work on data
+neither this repository nor the model has seen. They establish bounded
+structural, provenance, artifact, and reproducibility predicates; they do not
+prove every project-specific analytical answer.
+
+`--rerun` is the strongest signal available without a known answer. It rebuilds
+the project in an empty workspace from only the manifest, the declared
+immutable inputs, and the declared dependencies, runs the one canonical
+entrypoint, re-hashes the sources, and compares the outputs semantically. A
+pipeline that cannot reproduce itself, or that mutates its own declared
+immutable inputs, is not trustworthy whatever its numbers say.
+
+The check plan is derived from the manifest rather than configured, so a
+project cannot opt out of a check by omitting it: a declared output is a
+checked output. A check whose dependency is missing reports `not_testable` and
+is counted separately — never a silent pass. A mixture of executed and
+`not_testable` checks has aggregate status `warning`, and every report includes
+`applicable`, `executed`, and `execution_rate` coverage. Install
+`openmapstack[geo]` for the DuckDB-backed geodata checks; PyQGIS comes from a
+system QGIS install.
+
+See [the applicability reference](docs/verify-applicability.md) for the exact
+plan conditions, dependencies, current regression evidence, and deliberate
+exclusions. In particular, browser/dashboard checks are not yet part of the
+automatic `verify` plan.
+
+Project-specific known answers can be declared under
+`validation.expectations[]`. The five allowlisted checks cover row count,
+feature presence/absence, one feature-field value, and field range. New
+expectations start as `attestation.status: unverified`; they produce a warning
+and are not executed. The JSON report supplies the exact
+`expected_expectation_sha256` an independent reviewer must bind, together with
+the current `runs.latest.inputs_hash`. Changing the expected check, arguments,
+inputs, or a retained local evidence file invalidates the attestation and
+returns it to warning status. See
+[the project contract](references/project-spec.md#26-validation).
+
+`validate` checks manifest structure, source retrieval/version/licensing data,
+CRS declarations, processing graph resolution, override provenance and files,
+output existence, validation-report parity/status propagation, override
+application results, and run-record identity/hashes. GIS-specific checks such as
+geometry validity remain the pipeline's responsibility; the CLI verifies that
+each declared check appears exactly once with an explicit result.
+
+Normal validation warnings return exit code 0 so known limitations remain
+representable. Failures return 1; malformed invocation or an unstartable runtime
+returns 2. `--strict` makes warnings return 1.
+
+## What this skill will and won't do
+
+**Will:**
+- Recommend modern, cloud-native formats (GeoParquet, COG, PMTiles) and flag legacy patterns (Shapefile output, MBTiles for new deployments).
+- Push spatial joins to DuckDB / PostGIS instead of Python loops.
+- Discover data via STAC before downloading.
+- Preserve license metadata (OSM ODbL, Overture per-source, Sentinel attribution).
+- Pin dataset versions for reproducibility (Overture releases, STAC item IDs, OSM extract dates).
+- Compile material multi-stage analysis into a reproducible GIS project (`project.yaml` + pipeline + overrides + validation), deriving the final map/dashboard from it.
+
+**Won't:**
+- Trigger on simple location lookups ("what city is this?") or casual map references with no analytical work.
+- Default to proprietary services when an open/self-hosted option fits the scale, quality, privacy, and budget.
+
+## License
+
+Licensed under the [MIT License](LICENSE).
+
+## Contributing
+
+Issues and PRs welcome at [github.com/jaakla/openmapstack](https://github.com/jaakla/openmapstack). When adding a new tool or workflow, place it in the matching reference file and add a one-row entry to the relevant decision matrix in [SKILL.md](SKILL.md).

openmapstack-0.2.0.dist-info/RECORD

@@ -0,0 +1,29 @@
+openmapstack/__init__.py,sha256=WThDw9BtH52ssdkKMhoZMFMhzsKwkIhqIe10M6EkPvo,217
+openmapstack/__main__.py,sha256=k1ocEWawweo1qCJWNFAAvyxz3tcY13dzvCenHszij30,48
+openmapstack/cli.py,sha256=rNHA3_yHSiTVlQb66KBPk3T54TmACFWdSMNxMQQZGB4,18254
+openmapstack/expectations.py,sha256=EW6RvMOwMGs8Z_XQnqdZIsHZTtdSUC6nnYCSkiu7oWM,11411
+openmapstack/integrity.py,sha256=PNbX0JlZbcTXf0JjqqrWo9AzMfQpqEdCVoGPn7QmBvM,5289
+openmapstack/project.py,sha256=9etwwdDE-gg-meiAPaFXMKqoigj7-DULkY0aj7DQV-k,2526
+openmapstack/rerun.py,sha256=XhYG-rakU3DfCk_m2nZJ1mwkEEiJA0W4uMnUDJu3VIw,13875
+openmapstack/schema.py,sha256=O3JbWN-pHGhYwB4wsLXEeNwoMnUuT2R1KWclX76Bc7Y,1313
+openmapstack/validation.py,sha256=FD0ecrDc-4qTMN3Rhymt6AuQj3IbuicwsyFT88ycT_s,50307
+openmapstack/verify.py,sha256=kaKGHNhBt6t1ufc5S5ousMEnb72XP7bxGo2IS3-C0ME,15493
+openmapstack/checks/__init__.py,sha256=tp12swLm3JlXT6LWLDyERA8VJQrqujaqbiwV_NOYeBg,3974
+openmapstack/checks/geodata.py,sha256=R1xOZiB4xBzePxmkIZc-5ONOmUZTXqYFXYieyR6dYbw,14374
+openmapstack/checks/overrides.py,sha256=A6kYKp-l9lqULhnKXUd8u3LzDM1d76cA5CLZ3ApwniE,10816
+openmapstack/checks/presentation.py,sha256=f4usu-VOufJg3pyQA2XjvCuUR-l3uPSK3LPpSQAzVUk,8167
+openmapstack/checks/project.py,sha256=lcmjiOx57xRYHxYW2hI7uW4u8pkRp3CTATJ0gDV_US0,11121
+openmapstack/checks/provenance.py,sha256=KAqg4WkXPVH4N32jBt2gDhwkBfZzvz7gngy19AA2Mc4,6049
+openmapstack/checks/qgis.py,sha256=lM0JFYOQd40PiMbsC-Y3LbIWBsIWSjciMYm33vNkJqk,36363
+openmapstack/checks/rerun.py,sha256=sVZjWfIZMb_ETLjs0h6yMGmUZvjSFyFiHOnZKv6xxV4,14059
+openmapstack/checks/spatial.py,sha256=4gmso0sfelkWaqVjiA7MnNUO-p3RAFgMhRiZHtCOzuE,2060
+openmapstack/checks/validation.py,sha256=ofjFccvz_PlhuZQyPGwU56Q4Ns0kg9CBm929AHojJJ4,12925
+openmapstack/checks/visual.py,sha256=K9NAkvYW9IcNE5ukbm6xgWiU9y8GymtMarkWCASNG0c,29074
+openmapstack/schemas/__init__.py,sha256=TMmxU-wMXRk2wx9E8Qa8jmGZnDUUxbvGSdFzUckXNjo,51
+openmapstack/schemas/project-v1.schema.json,sha256=pvKq2jaTo9yUgoiJUHszNUWnDdy5ZhJEcrjQ1fbJREQ,8615
+openmapstack-0.2.0.dist-info/licenses/LICENSE,sha256=1VX6fZbdvQREb_ybu1xwivIw82HB5cQbDChwNADPJ-0,1070
+openmapstack-0.2.0.dist-info/METADATA,sha256=LOhI3z0ebW-CvBvujJspRibxqV-RWmVF1vBkc68j4ag,14729
+openmapstack-0.2.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+openmapstack-0.2.0.dist-info/entry_points.txt,sha256=2vTunbyTwb17cjl-n0JidVBjIL3P_0j1p729squzUXQ,55
+openmapstack-0.2.0.dist-info/top_level.txt,sha256=b9wNEcuTS-e5TJfRhtC6plL30a8NYJXugmx18ngXaDI,13
+openmapstack-0.2.0.dist-info/RECORD,,