fix vari

.gitattributes

@@ -36,3 +36,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.sqlite3 filter=lfs diff=lfs merge=lfs -text
 *.faiss filter=lfs diff=lfs merge=lfs -text
 *.db filter=lfs diff=lfs merge=lfs -text
+data/leafsnap_*.faiss filter=lfs diff=lfs merge=lfs -text
+data/leafsnap_*.pt filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -7,4 +7,5 @@ client_secret*
 pwa-app/.env
 missing_species_alias.csv
 unique_species_labels.csv
-data/images/
+data/images/
+missing_species.csv

api.py

@@ -28,6 +28,8 @@ load_dotenv()
 INDEX_PATH = os.getenv("PLANCLEF_INDEX_PATH", "data/planclef.faiss")
 CACHE_PATH = os.getenv("PLANCLEF_CACHE_PATH", "data/planclef_cache.pt")
 MODEL_NAME = os.getenv("PLANCLEF_MODEL_NAME", "ViT-B-32")
+LEAFSNAP_INDEX_PATH = os.getenv("LEAFSNAP_INDEX_PATH", "data/leafsnap_field.faiss")
+LEAFSNAP_CACHE_PATH = os.getenv("LEAFSNAP_CACHE_PATH", "data/leafsnap_cache.pt")
 RAG_DB_PATH = os.getenv("RAG_DB_PATH", "data/plant_rag")
 WIKI_USER_AGENT = os.getenv(
     "WIKI_USER_AGENT",
@@ -170,6 +172,20 @@ def _species_to_folder_name(species_name: str) -> str:
 
 
 def _get_species_preview_image_url(species_name: str) -> str:
+    image_paths = _get_species_images_from_db(species_name)
+    for raw_path in image_paths:
+        if isinstance(raw_path, str) and raw_path.startswith(("http://", "https://")):
+            return raw_path
+
+        normalized_path = _normalize_image_path(str(raw_path or ""))
+        if not normalized_path:
+            continue
+
+        local_path = Path("data") / "images" / normalized_path
+        if local_path.exists():
+            return f"/images/{normalized_path}"
+
+    # Backward compatibility: read from legacy RAG metadata if DB is empty.
     try:
         collection = get_rag_collection()
         res = collection.get(
@@ -265,9 +281,37 @@ def get_plants_db_connection() -> sqlite3.Connection:
 
     conn = sqlite3.connect(db_path)
     conn.row_factory = sqlite3.Row
+    try:
+        conn.execute("ALTER TABLE plants ADD COLUMN image_paths TEXT")
+        conn.commit()
+    except Exception:
+        pass
     return conn
 
 
+def _get_species_images_from_db(species_name: str) -> list[str]:
+    query = "SELECT image_paths FROM plants WHERE lower(species_name) = lower(?) LIMIT 1"
+    with get_plants_db_connection() as conn:
+        row = conn.execute(query, (species_name.strip(),)).fetchone()
+
+    if row is None:
+        return []
+
+    raw = row["image_paths"] if "image_paths" in row.keys() else None
+    if not raw:
+        return []
+
+    try:
+        parsed = json.loads(raw)
+    except (json.JSONDecodeError, TypeError):
+        return []
+
+    if not isinstance(parsed, list):
+        return []
+
+    return [str(v).strip() for v in parsed if str(v).strip()]
+
+
 def _sqlite_table_exists(conn: sqlite3.Connection, table_name: str) -> bool:
     row = conn.execute(
         "SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ? LIMIT 1",
@@ -790,10 +834,23 @@ def get_index():
         try:
             from plentclef import PlentClefIndex
 
+            leafsnap_aliases: dict[str, str] = {}
+            try:
+                with sqlite3.connect(PLANTS_SQLITE_PATH) as _conn:
+                    rows = _conn.execute(
+                        "SELECT leafsnap_label, db_species_name FROM leafsnap_aliases"
+                    ).fetchall()
+                    leafsnap_aliases = {r[0]: r[1] for r in rows}
+            except Exception:
+                pass  # table may not exist yet; aliases simply won't be applied
+
             index = PlentClefIndex(
                 model_name=MODEL_NAME,
                 index_path=INDEX_PATH,
                 index_cache=CACHE_PATH,
+                leafsnap_index_path=LEAFSNAP_INDEX_PATH,
+                leafsnap_cache_path=LEAFSNAP_CACHE_PATH,
+                leafsnap_aliases=leafsnap_aliases,
             )
         except Exception as e:
             cause = f"{type(e).__name__}: {e}"
@@ -1179,12 +1236,14 @@ def plant_info(
             
             title = first_meta.get("species_name", name)
             common_name = first_meta.get("common_name", "")
-            image_paths_json = first_meta.get("image_paths", "[]")
-            
-            try:
-                image_paths = json.loads(image_paths_json)
-            except (json.JSONDecodeError, TypeError):
-                image_paths = []
+            image_paths = _get_species_images_from_db(name)
+            if not image_paths:
+                # Backward compatibility with old RAG metadata layout.
+                image_paths_json = first_meta.get("image_paths", "[]")
+                try:
+                    image_paths = json.loads(image_paths_json)
+                except (json.JSONDecodeError, TypeError):
+                    image_paths = []
             
             # Combine chunks for OpenAI context (up to 6000 chars)
             documents = results.get("documents", [])

build_plant_rag.py

@@ -13,7 +13,8 @@ Notes
 - Tries Italian Wikipedia first, falls back to English.
 - Skips sections: Note, Bibliografia, Voci correlate, Altri progetti,
   Collegamenti esterni (and their English equivalents).
-- Metadata per chunk: species_name, common_name, image_paths (JSON list of URLs), lang.
+- Metadata per chunk: species_name, common_name, lang.
+- Image paths per species are stored in plants.db (plants.image_paths JSON).
 """
 
 import csv
@@ -25,6 +26,7 @@ import sqlite3
 import sys
 import time
 import urllib.parse
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Optional
 
@@ -407,6 +409,46 @@ def collect_images(species_name: str, lang: str) -> list[str]:
     return fetch_wiki_image_urls(species_name, lang)[:MAX_IMAGES]
 
 
+def save_species_images_to_sqlite(sqlite_path: Path, species_name: str, image_paths: list[str]) -> None:
+    """Store per-species image paths in plants.db for API/UI consumption.
+
+    Uses JSON string in plants.image_paths and preserves existing profile fields.
+    """
+    sqlite_path.parent.mkdir(parents=True, exist_ok=True)
+    now_iso = datetime.now(timezone.utc).isoformat()
+    payload = json.dumps(image_paths, ensure_ascii=False)
+
+    if not sqlite_path.exists():
+        return
+
+    conn = sqlite3.connect(sqlite_path)
+    try:
+        row = conn.execute(
+            "SELECT 1 FROM sqlite_master WHERE type='table' AND name='plants' LIMIT 1"
+        ).fetchone()
+        if row is None:
+            return
+
+        try:
+            conn.execute("ALTER TABLE plants ADD COLUMN image_paths TEXT")
+        except Exception:
+            pass
+
+        conn.execute(
+            """
+            INSERT INTO plants (species_name, image_paths, updated_at)
+            VALUES (?, ?, ?)
+            ON CONFLICT(species_name) DO UPDATE SET
+                image_paths=excluded.image_paths,
+                updated_at=excluded.updated_at
+            """,
+            (species_name, payload, now_iso),
+        )
+        conn.commit()
+    finally:
+        conn.close()
+
+
 # ---------------------------------------------------------------------------
 # Core processing
 # ---------------------------------------------------------------------------
@@ -419,6 +461,7 @@ def process_species(
     translator_client: OpenAI | None,
     translation_model: str,
     translate_non_italian: bool,
+    sqlite_path: Path,
 ) -> dict:
     slug = slugify(species_name)
 
@@ -481,6 +524,7 @@ def process_species(
 
     # --- Images ---
     image_paths = collect_images(resolved_title, lang)
+    save_species_images_to_sqlite(sqlite_path, species_name, image_paths)
 
     # --- Chunk & upsert into ChromaDB ---
     chunks = chunk_by_words(full_text)
@@ -492,7 +536,6 @@ def process_species(
         {
             "species_name": species_name,
             "common_name": common_name,
-            "image_paths": json.dumps(image_paths),
             "chunk_index": i,
             "lang": lang,
             "source_lang": lang,
@@ -643,6 +686,7 @@ def main() -> None:
                 translator_client=translator_client,
                 translation_model=args.translation_model,
                 translate_non_italian=args.translate_non_italian,
+                sqlite_path=Path(args.sqlite_path),
             )
             progress[species] = result
         except Exception as exc:
@@ -669,7 +713,7 @@ def main() -> None:
     print(f"  Errors     : {errors}")
     print(f"  Total docs : {collection.count()}")
     print(f"  ChromaDB   : {RAG_DIR}")
-    print("  Images     : stored as remote URLs in Chroma metadata")
+    print("  Images     : stored in plants.db (plants.image_paths JSON)")
 
 
 if __name__ == "__main__":

build_plants_sqlite.py

@@ -58,6 +58,7 @@ def init_db(conn: sqlite3.Connection) -> None:
             id INTEGER PRIMARY KEY AUTOINCREMENT,
             species_name TEXT NOT NULL UNIQUE,
             indexed INTEGER NOT NULL DEFAULT 0,
+            image_paths TEXT,
             annaffiatura_gg INTEGER,
             annaffiatura_time TEXT,
             luce TEXT,
@@ -72,6 +73,20 @@ def init_db(conn: sqlite3.Connection) -> None:
         )
         """
     )
+    # Migration for existing DBs created before image_paths support.
+    try:
+        conn.execute("ALTER TABLE plants ADD COLUMN image_paths TEXT")
+        conn.commit()
+    except Exception:
+        pass
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS leafsnap_aliases (
+            leafsnap_label TEXT PRIMARY KEY,
+            db_species_name TEXT NOT NULL
+        )
+        """
+    )
     conn.commit()
 
 
@@ -324,6 +339,7 @@ def upsert_plant(
     species_name: str,
     indexed: bool,
     profile: dict | None,
+    image_paths: str | None = None,
 ) -> None:
     now_iso = datetime.now(timezone.utc).isoformat()
     profile = profile or {}
@@ -333,6 +349,7 @@ def upsert_plant(
         INSERT INTO plants (
             species_name,
             indexed,
+            image_paths,
             annaffiatura_gg,
             annaffiatura_time,
             luce,
@@ -345,9 +362,10 @@ def upsert_plant(
             prevenzione,
             updated_at
         )
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
         ON CONFLICT(species_name) DO UPDATE SET
             indexed=excluded.indexed,
+            image_paths=COALESCE(excluded.image_paths, plants.image_paths),
             annaffiatura_gg=excluded.annaffiatura_gg,
             annaffiatura_time=excluded.annaffiatura_time,
             luce=excluded.luce,
@@ -363,6 +381,7 @@ def upsert_plant(
         (
             species_name,
             1 if indexed else 0,
+            image_paths,
             profile.get("annaffiatura_gg"),
             profile.get("annaffiatura_time"),
             profile.get("luce"),

data/plants.db

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0b8e1d245671aa0b28d4f00e9b8ff41dd709e81de9110935124a6526ff24a0be
-size 294912
+oid sha256:be66035a5e96a147ec7c9859bdf91e40c8fe9e13b383d76b858b2c2a39b0f34e
+size 2465792

plentclef.py

@@ -27,8 +27,28 @@ def _load_plantclef_cache(cache_path):
             with open(cache_path, "rb") as f:
                 return pickle.load(f)
 
+def _rrf_merge(results_list: list[list], k: int = 60) -> list[tuple]:
+    """Reciprocal Rank Fusion across multiple ranked result lists.
+
+    Each element of *results_list* is a list of (species, score, image_paths)
+    tuples already sorted by descending score.  Returns a merged list sorted
+    by descending RRF score, same tuple format (image_paths will be empty).
+    """
+    combined: dict[str, float] = defaultdict(float)
+    for ranked in results_list:
+        for rank, (species, _score, _paths) in enumerate(ranked):
+            combined[species] += 1.0 / (k + rank + 1)
+    return sorted(
+        [(species, rrf_score, []) for species, rrf_score in combined.items()],
+        key=lambda x: x[1],
+        reverse=True,
+    )
+
+
 class PlentClefIndex():
-    def __init__(self, model_name, index_path,index_cache):
+    def __init__(self, model_name, index_path, index_cache,
+                 leafsnap_index_path=None, leafsnap_cache_path=None,
+                 leafsnap_aliases: dict | None = None):
         self.model, self.preprocess, self.tokenizer = open_clip.create_model_and_transforms(
             model_name=model_name,
             pretrained="laion2b_s34b_b79k"
@@ -43,29 +63,48 @@ class PlentClefIndex():
             raise KeyError("Missing 'labels' in PlantCLEF cache")
         self.plantclef_labels = data["labels"]
 
-    def embed_image(self,path):
-        img = self.preprocess(Image.open(path).convert("RGB")).unsqueeze(0)# Move image to the same device as the model
+        # Optional LeafSnap index (leaf-only images, same embedding space)
+        self.leafsnap_index = None
+        self.leafsnap_labels: list = []
+        if leafsnap_index_path and os.path.exists(leafsnap_index_path):
+            self.leafsnap_index = faiss.read_index(leafsnap_index_path)
+            if leafsnap_cache_path and os.path.exists(leafsnap_cache_path):
+                ls_data = _load_plantclef_cache(leafsnap_cache_path)
+                if not isinstance(ls_data, dict) or "labels" not in ls_data:
+                    raise KeyError("Missing 'labels' in LeafSnap cache")
+                self.leafsnap_labels = ls_data["labels"]
+        # Dict mapping LeafSnap label -> canonical DB species name
+        self.leafsnap_aliases: dict[str, str] = leafsnap_aliases or {}
+
+    def embed_image(self, path):
+        img = self.preprocess(Image.open(path).convert("RGB")).unsqueeze(0)
         with torch.no_grad():
             e = self.model.encode_image(img)
             e = e / e.norm(dim=-1, keepdim=True)
         return e.cpu().numpy().astype("float32")
 
-    def search(self,path, labels, k=5):
-        q = self.embed_image(path)
-        sims, idxs = self.index.search(q, k)  # [1, k]
-
-        aggregated_results = defaultdict(lambda: {'score_sum': 0.0, 'image_paths': []})
-
+    def _search_index(self, q, index, labels, k):
+        """Search a single FAISS index and aggregate scores by species."""
+        sims, idxs = index.search(q, k)
+        aggregated: dict = defaultdict(lambda: {'score_sum': 0.0, 'image_paths': []})
         for score, idx in zip(sims[0], idxs[0]):
             species_label = labels[idx]
-            aggregated_results[species_label]['score_sum'] += score # Append the image path
+            species_label = self.leafsnap_aliases.get(species_label, species_label)
+            aggregated[species_label]['score_sum'] += score
+        results = [
+            (cat, d['score_sum'], d['image_paths'])
+            for cat, d in aggregated.items()
+        ]
+        results.sort(key=lambda x: x[1], reverse=True)
+        return results
+
+    def search(self, path, labels, k=5):
+        q = self.embed_image(path)
 
-        # Convert aggregated results to a list of (category, total_score, image_paths_list) tuples
-        final_results = []
-        for category, data in aggregated_results.items():
-            final_results.append((category, data['score_sum'], data['image_paths']))
+        planclef_results = self._search_index(q, self.index, labels, k)
 
-        # Sort by total score in descending order
-        final_results.sort(key=lambda x: x[1], reverse=True)
+        if self.leafsnap_index is not None and self.leafsnap_labels:
+            leafsnap_results = self._search_index(q, self.leafsnap_index, self.leafsnap_labels, k)
+            return _rrf_merge([planclef_results, leafsnap_results])[:k]
 
-        return final_results
+        return planclef_results[:k]

pwa-app/src/App.jsx

@@ -16,6 +16,7 @@ import {
   updateMyPlantFirstWaterDate,
   uploadMyPlantPhoto,
   verifyGoogleToken,
+  setUnauthorizedHandler,
   toAbsoluteImage,
   toOptimizedImage
 } from "./api";
@@ -111,6 +112,21 @@ function formatISOToInputDate(value) {
   return `${year}-${month}-${day}`;
 }
 
+function parseJwtPayload(token) {
+  try {
+    const parts = String(token || "").split(".");
+    if (parts.length < 2) {
+      return null;
+    }
+    const base64 = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+    const padded = base64 + "=".repeat((4 - (base64.length % 4)) % 4);
+    const json = window.atob(padded);
+    return JSON.parse(json);
+  } catch {
+    return null;
+  }
+}
+
 export default function App({ googleClientIdConfigured = false }) {
   const [auth, setAuth] = useState(null);
   const [authBusy, setAuthBusy] = useState(false);
@@ -149,6 +165,7 @@ export default function App({ googleClientIdConfigured = false }) {
   const [uploadingPhotoId, setUploadingPhotoId] = useState(null);
   const plantPhotoInputRef = useRef(null);
   const plantPhotoTargetIdRef = useRef(null);
+  const refreshPromiseRef = useRef(null);
 
   const [busy, setBusy] = useState({
     search: false,
@@ -260,6 +277,83 @@ export default function App({ googleClientIdConfigured = false }) {
       .filter((entry) => entry.value !== null && entry.value !== "");
   }, [myPlantProfile]);
 
+  async function refreshGoogleSessionSilently() {
+    if (refreshPromiseRef.current) {
+      return refreshPromiseRef.current;
+    }
+
+    const currentToken = auth?.idToken || "";
+    const payload = parseJwtPayload(currentToken);
+    const clientId = String(payload?.aud || "").trim();
+
+    if (!clientId || !window.google?.accounts?.id) {
+      return false;
+    }
+
+    const refreshPromise = new Promise((resolve) => {
+      let done = false;
+      const finish = (ok) => {
+        if (done) {
+          return;
+        }
+        done = true;
+        resolve(ok);
+      };
+
+      const timeoutId = window.setTimeout(() => finish(false), 8000);
+
+      try {
+        window.google.accounts.id.initialize({
+          client_id: clientId,
+          auto_select: true,
+          cancel_on_tap_outside: false,
+          callback: async (credentialResponse) => {
+            const idToken = credentialResponse?.credential || "";
+            if (!idToken) {
+              window.clearTimeout(timeoutId);
+              finish(false);
+              return;
+            }
+
+            try {
+              const data = await verifyGoogleToken(idToken);
+              const nextAuth = {
+                idToken,
+                user: data.user || auth?.user || null,
+                expiresAt: data.expires_at || null
+              };
+              setAuth(nextAuth);
+              setAuthToken(idToken);
+              window.localStorage.setItem(AUTH_STORAGE_KEY, JSON.stringify(nextAuth));
+              window.clearTimeout(timeoutId);
+              finish(true);
+            } catch {
+              window.clearTimeout(timeoutId);
+              finish(false);
+            }
+          }
+        });
+
+        window.google.accounts.id.prompt((notification) => {
+          if (notification.isNotDisplayed() || notification.isSkippedMoment()) {
+            window.clearTimeout(timeoutId);
+            finish(false);
+          }
+        });
+      } catch {
+        window.clearTimeout(timeoutId);
+        finish(false);
+      }
+    });
+
+    refreshPromiseRef.current = refreshPromise;
+    try {
+      return await refreshPromise;
+    } finally {
+      refreshPromiseRef.current = null;
+    }
+  }
+
   useEffect(() => {
     const raw = window.localStorage.getItem(AUTH_STORAGE_KEY);
     if (!raw) {
@@ -281,6 +375,37 @@ export default function App({ googleClientIdConfigured = false }) {
     }
   }, []);
 
+  useEffect(() => {
+    setUnauthorizedHandler(async () => {
+      const refreshed = await refreshGoogleSessionSilently();
+      if (!refreshed) {
+        setError("Sessione Google scaduta. Tocca Accedi per rinnovarla.");
+      }
+      return refreshed;
+    });
+
+    return () => setUnauthorizedHandler(null);
+  }, [auth?.idToken]);
+
+  useEffect(() => {
+    const exp = Number(auth?.expiresAt || 0);
+    if (!exp) {
+      return undefined;
+    }
+
+    const refreshBeforeMs = 2 * 60 * 1000;
+    const delayMs = (exp * 1000) - Date.now() - refreshBeforeMs;
+    if (delayMs <= 0) {
+      return undefined;
+    }
+
+    const timerId = window.setTimeout(() => {
+      refreshGoogleSessionSilently();
+    }, delayMs);
+
+    return () => window.clearTimeout(timerId);
+  }, [auth?.expiresAt, auth?.idToken]);
+
   useEffect(() => {
     setExpandedProfileKey("");
   }, [plantProfile]);
@@ -550,7 +675,25 @@ export default function App({ googleClientIdConfigured = false }) {
     try {
       const data = await saveMyPlant(selectedSpecies, trimmed);
       const saved = data.saved || null;
-      setSaveStatus(saved ? `Salvata: ${saved.user_given_name}` : "Pianta salvata.");
+      let photoUploaded = false;
+      if (saved?.id && file) {
+        try {
+          await uploadMyPlantPhoto(saved.id, file);
+          photoUploaded = true;
+        } catch {
+          photoUploaded = false;
+        }
+      }
+
+      if (saved) {
+        setSaveStatus(
+          photoUploaded
+            ? `Salvata: ${saved.user_given_name} (foto associata)`
+            : `Salvata: ${saved.user_given_name}`
+        );
+      } else {
+        setSaveStatus("Pianta salvata.");
+      }
       setUserPlantName("");
       await loadMyPlants();
     } catch (err) {

pwa-app/src/api.js

@@ -10,6 +10,7 @@ function getApiBase() {
 
 const API_BASE = getApiBase();
 let authToken = "";
+let unauthorizedHandler = null;
 
 function buildUrl(path) {
   return `${API_BASE}${path}`;
@@ -19,16 +20,37 @@ export function setAuthToken(token) {
   authToken = token || "";
 }
 
+export function setUnauthorizedHandler(handler) {
+  unauthorizedHandler = typeof handler === "function" ? handler : null;
+}
+
 async function apiFetch(path, options = {}) {
-  const headers = new Headers(options.headers || {});
-  if (authToken) {
-    headers.set("Authorization", `Bearer ${authToken}`);
+  async function doFetch() {
+    const headers = new Headers(options.headers || {});
+    if (authToken) {
+      headers.set("Authorization", `Bearer ${authToken}`);
+    }
+
+    return fetch(buildUrl(path), {
+      ...options,
+      headers
+    });
   }
 
-  return fetch(buildUrl(path), {
-    ...options,
-    headers
-  });
+  const response = await doFetch();
+
+  if (
+    response.status === 401
+    && !options.__skipAuthRefresh
+    && unauthorizedHandler
+  ) {
+    const refreshed = await unauthorizedHandler();
+    if (refreshed) {
+      return doFetch();
+    }
+  }
+
+  return response;
 }
 
 async function parseResponse(response) {

sync_leafsnap_aliases.py

@@ -0,0 +1,181 @@
+#!/usr/bin/env python3
+"""
+Populate leafsnap_aliases table in plants.db and update missing_species.csv.
+
+For each LeafSnap species not in the DB:
+  - If a DB species with the same genus has an epithet edit-distance <= EDIT_THRESHOLD
+    (or the full name edit-distance <= EDIT_THRESHOLD), it is saved as an alias.
+  - Otherwise it is appended to missing_species.csv for manual review.
+
+Run:
+    python sync_leafsnap_aliases.py [--db data/plants.db] [--cache data/leafsnap_cache.pt]
+                                    [--missing missing_species.csv] [--threshold 3] [--dry-run]
+"""
+
+import argparse
+import csv
+import os
+import sqlite3
+from collections import defaultdict
+from pathlib import Path
+
+
+def _edit_distance(a: str, b: str) -> int:
+    """Simple Levenshtein distance."""
+    a, b = a.lower(), b.lower()
+    if a == b:
+        return 0
+    m, n = len(a), len(b)
+    dp = list(range(n + 1))
+    for i in range(1, m + 1):
+        prev = dp[:]
+        dp[0] = i
+        for j in range(1, n + 1):
+            cost = 0 if a[i - 1] == b[j - 1] else 1
+            dp[j] = min(dp[j] + 1, dp[j - 1] + 1, prev[j - 1] + cost)
+    return dp[n]
+
+
+def find_best_alias(
+    leafsnap_label: str,
+    db_species: set[str],
+    db_by_genus: dict[str, list[str]],
+    threshold: int,
+) -> str | None:
+    """Return the best-matching DB species within *threshold* edit distance, or None."""
+    genus = leafsnap_label.split()[0]
+    epithet = " ".join(leafsnap_label.split()[1:])
+
+    candidates = db_by_genus.get(genus, [])
+    if not candidates:
+        return None
+
+    best_label: str | None = None
+    best_dist = threshold + 1
+
+    for db_sp in candidates:
+        db_epithet = " ".join(db_sp.split()[1:])
+        # Compare epithet only (genus already matches)
+        d = _edit_distance(epithet, db_epithet)
+        if d < best_dist:
+            best_dist = d
+            best_label = db_sp
+
+    return best_label if best_dist <= threshold else None
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Sync LeafSnap aliases into plants.db")
+    parser.add_argument("--db", default=os.getenv("PLANTS_SQLITE_PATH", "data/plants.db"))
+    parser.add_argument("--cache", default=os.getenv("LEAFSNAP_CACHE_PATH", "data/leafsnap_cache.pt"))
+    parser.add_argument("--missing", default="missing_species.csv")
+    parser.add_argument("--threshold", type=int, default=2,
+                        help="Max Levenshtein distance on epithet to consider an alias (default: 2)")
+    parser.add_argument("--dry-run", action="store_true",
+                        help="Print results without writing to DB or CSV")
+    args = parser.parse_args()
+
+    import torch
+
+    print(f"Loading LeafSnap cache from {args.cache} ...")
+    ls_data = torch.load(args.cache, map_location="cpu", weights_only=False)
+    leafsnap_species = set(ls_data["labels"])
+
+    print(f"Loading DB species from {args.db} ...")
+    conn = sqlite3.connect(args.db)
+
+    # Ensure table exists
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS leafsnap_aliases (
+            leafsnap_label TEXT PRIMARY KEY,
+            db_species_name TEXT NOT NULL
+        )
+        """
+    )
+    conn.commit()
+
+    db_species = set(row[0] for row in conn.execute("SELECT species_name FROM plants"))
+    existing_aliases = dict(conn.execute("SELECT leafsnap_label, db_species_name FROM leafsnap_aliases"))
+
+    db_by_genus: dict[str, list[str]] = defaultdict(list)
+    for s in db_species:
+        db_by_genus[s.split()[0]].append(s)
+
+    # Classify each LeafSnap species
+    to_alias: list[tuple[str, str]] = []   # (leafsnap_label, db_species_name)
+    to_missing: list[str] = []
+
+    # Hardcoded typo overrides (edit distance > threshold but unambiguously same species)
+    TYPO_OVERRIDES: dict[str, str] = {
+        "Aesculus hippocastamon": "Aesculus hippocastanum",
+    }
+
+    for sp in sorted(leafsnap_species):
+        if sp in db_species:
+            continue  # already in DB, no alias needed
+        if sp in existing_aliases:
+            print(f"  [skip] {sp} -> {existing_aliases[sp]}  (already in aliases)")
+            continue
+
+        if sp in TYPO_OVERRIDES:
+            target = TYPO_OVERRIDES[sp]
+            if target in db_species:
+                to_alias.append((sp, target))
+                continue
+
+        match = find_best_alias(sp, db_species, db_by_genus, args.threshold)
+        if match:
+            to_alias.append((sp, match))
+        else:
+            to_missing.append(sp)
+
+    print(f"\nNew aliases found:   {len(to_alias)}")
+    for ls_lbl, db_lbl in to_alias:
+        print(f"  {ls_lbl}  ->  {db_lbl}")
+
+    print(f"\nUnresolvable (-> missing_species.csv): {len(to_missing)}")
+    for sp in to_missing:
+        print(f"  {sp}")
+
+    if args.dry_run:
+        print("\n[dry-run] No changes written.")
+        conn.close()
+        return
+
+    # Write aliases to DB
+    if to_alias:
+        conn.executemany(
+            "INSERT OR REPLACE INTO leafsnap_aliases (leafsnap_label, db_species_name) VALUES (?, ?)",
+            to_alias,
+        )
+        conn.commit()
+        print(f"\nSaved {len(to_alias)} aliases to leafsnap_aliases table.")
+
+    conn.close()
+
+    # Append to missing_species.csv (avoid duplicates)
+    missing_path = Path(args.missing)
+    existing_missing: set[str] = set()
+    if missing_path.exists():
+        with open(missing_path, newline="", encoding="utf-8") as f:
+            reader = csv.DictReader(f)
+            for row in reader:
+                existing_missing.add(row["species_name"])
+
+    new_missing = [sp for sp in to_missing if sp not in existing_missing]
+    if new_missing:
+        write_header = not missing_path.exists() or missing_path.stat().st_size == 0
+        with open(missing_path, "a", newline="", encoding="utf-8") as f:
+            writer = csv.DictWriter(f, fieldnames=["species_name"])
+            if write_header:
+                writer.writeheader()
+            for sp in new_missing:
+                writer.writerow({"species_name": sp})
+        print(f"Appended {len(new_missing)} species to {missing_path}.")
+    else:
+        print("No new missing species to append.")
+
+
+if __name__ == "__main__":
+    main()