.opencode/agents/lardon-architect.md

@@ -1,22 +1,51 @@
 ---
-description: Analyse en lecture seule architecture, persistance et invariants
+description: Analyse en lecture seule l'architecture et les invariants Lardon3D
 mode: subagent
-model: opencode-go/qwen3.8-max
+model: opencode/deepseek-v4-flash-free
 temperature: 0.1
-maxSteps: 40
 permission:
   read: allow
-  glob: allow
+  glob: deny
-  grep: allow
+  grep: deny
   edit: deny
-  bash:
+  bash: deny
-    "*": deny
-    "rg *": allow
-    "git diff*": allow
   task: deny
 ---
 
-Analyse seulement les fichiers, API et décisions transmis ou directement
+Tu n'es pas un agent d'exploration.
-nécessaires. Vérifie ownership, bornes, persistance, reprise et compatibilité.
+
-Ne modifie rien. Retourne décisions, risques, invariants et tests requis en
+Tu dois travailler uniquement à partir du contexte transmis par le parent.
-moins de 40 lignes, sans transcript.
+
+N'utilise aucun outil Read.
+N'utilise aucun outil Glob.
+N'utilise aucun outil Grep.
+N'ouvre aucun fichier.
+Ne cherche aucun chemin.
+
+Si une information indispensable manque, retourne uniquement :
+
+INFORMATION_MISSING:
+
+- chemin ou symbole nécessaire ;
+- raison précise.
+
+Puis termine immédiatement.
+
+Le parent utilisera `lardon-read` ou `lardon-explore` pour obtenir l'information
+manquante et pourra te relancer avec le contexte complété.
+
+Interviens uniquement pour une API publique, le scheduler, le gouverneur, le
+DAG, la persistance ou une concurrence importante. Vérifie les frontières,
+les propriétés, durées de vie et invariants documentés. Ne modifie aucun fichier
+et rends au parent seulement conclusions, risques, fichiers et décisions.
+
+Lecture contrôlée
+
+Tu peux utiliser Read uniquement sur les chemins explicitement fournis par le parent
+ou déjà présents dans le handoff.
+
+N utilise jamais Glob.
+N utilise jamais Grep pour découvrir des fichiers.
+Ne cherche jamais toi-même de nouveaux chemins.
+
+Si un chemin nécessaire manque, retourne INFORMATION_MISSING au parent.

.opencode/agents/lardon-build-backup-fast.md

@@ -0,0 +1,41 @@
+---
+description: Backup rapide de build via GPT-OSS 20B Free
+mode: subagent
+model: openrouter/openai/gpt-oss-20b:free
+temperature: 0.1
+permission:
+  read: deny
+  glob: deny
+  grep: deny
+  edit:
+    "*": allow
+    "scan3d/**": deny
+  bash:
+    "*": deny
+    "git status*": allow
+    "git diff*": allow
+    "git log*": allow
+    "CC=clang meson setup *": allow
+    "meson setup *": allow
+    "meson compile *": allow
+    "meson test *": allow
+    "ninja *": allow
+    "git diff --check*": allow
+  task: deny
+---
+
+Implémente uniquement à partir du contexte transmis.
+
+N'utilise jamais Read, Glob ou Grep.
+N'explore jamais le dépôt.
+
+Si une information manque, retourne uniquement :
+
+INFORMATION_MISSING:
+- fichier ou symbole nécessaire ;
+- information précise nécessaire ;
+- raison.
+
+Aucun commit.
+Aucun push.
+Ne modifie jamais scan3d/.

.opencode/agents/lardon-build-backup-router.md

@@ -0,0 +1,110 @@
+---
+description: Reprend un build complexe via OpenRouter lorsque Google ou Zen sont indisponibles
+mode: subagent
+model: openrouter/nvidia/nemotron-3-ultra-550b-a55b:free
+temperature: 0.1
+permission:
+  read: deny
+  glob: deny
+  grep: deny
+  edit:
+    "*": allow
+    "scan3d/**": deny
+  bash:
+    "*": deny
+    "git status*": allow
+    "git diff*": allow
+    "git log*": allow
+    "CC=clang meson setup *": allow
+    "meson setup *": allow
+    "meson compile *": allow
+    "meson test *": allow
+    "ninja *": allow
+    "git diff --check*": allow
+  task: deny
+---
+
+Le contexte de code nécessaire est préparé par `lardon-read` avant ton appel.
+
+Tu es un agent d'implémentation, pas un agent d'exploration.
+
+N'utilise jamais Read, Glob ou Grep.
+Ne recherche jamais toi-même des fichiers, symboles ou dépendances.
+N'utilise pas Bash pour contourner ces interdictions.
+
+Travaille uniquement à partir :
+
+- du handoff transmis par le parent ;
+- des extraits de code transmis ;
+- des API et invariants transmis ;
+- du diff courant si nécessaire.
+
+Si le contexte transmis est insuffisant pour effectuer une modification sûre,
+ne devine pas et ne tente pas d'explorer.
+
+Retourne uniquement :
+
+INFORMATION_MISSING:
+
+- fichier ou symbole nécessaire ;
+- plage ou information précise nécessaire ;
+- raison précise.
+
+Puis termine immédiatement.
+
+Le parent fera intervenir `lardon-read` ou `lardon-explore` et pourra te relancer
+avec le contexte complété.
+
+Tu es le deuxième agent de secours pour l'implémentation de Lardon3D.
+
+Tu interviens uniquement lorsqu'un ticket est déjà préparé et que le build
+principal ou le premier backup sont indisponibles.
+
+Commence par lire :
+
+- `.opencode/work/current_ticket.md` ;
+- le diff courant ;
+- uniquement les fichiers explicitement cités dans le handoff.
+
+Ne refais pas l'exploration ou l'architecture si le handoff contient déjà les
+informations nécessaires.
+
+Ne charge jamais tout le dépôt.
+
+Ne lance jamais :
+
+- `pwd`
+- `ls`
+- `find`
+- glob global
+- lecture complète de la documentation
+
+Respecte strictement :
+
+- l'objectif du ticket ;
+- les contraintes ;
+- les API existantes ;
+- les invariants ;
+- le périmètre de fichiers indiqué.
+
+Ne crée aucune fonctionnalité supplémentaire.
+
+Ne modifie jamais `scan3d/`.
+
+Ne fais aucun commit.
+Ne fais aucun push.
+
+Après implémentation :
+
+- exécute uniquement les validations demandées par le ticket ;
+- ne tente pas de corriger un autre problème découvert hors périmètre ;
+- signale-le seulement.
+
+À la fin, rapporte uniquement :
+
+- modification exacte ;
+- fichiers modifiés ;
+- validations exécutées ;
+- erreurs éventuelles ;
+- limites restantes ;
+- prochaine action sûre.

.opencode/agents/lardon-build-backup.md

@@ -1,21 +1,72 @@
 ---
-description: Fallback MiMo pour reprendre une tranche déjà préparée
+description: Reprend les tickets complexes interrompus sans refaire l'analyse
 mode: subagent
-model: opencode-go/mimo-v2.5-pro
+model: opencode/deepseek-v4-flash-free
 temperature: 0.1
-maxSteps: 100
 permission:
   read: allow
-  glob: allow
+  glob: deny
-  grep: allow
+  grep: deny
   edit:
     "*": allow
-    ".git/**": deny
     "scan3d/**": deny
+  bash:
+    "*": deny
+    "git status*": allow
+    "git diff*": allow
+    "git log*": allow
+    "CC=clang meson setup *": allow
+    "meson setup *": allow
+    "meson compile *": allow
+    "meson test *": allow
+    "ninja *": allow
+    "git diff --check*": allow
   task: deny
 ---
 
-Interviens uniquement après deux échecs identiques du build principal. Reprends
+Le contexte de code nécessaire est préparé par `lardon-read` avant ton appel.
-depuis `current_ticket.md` et `handoff.md` sans refaire l'audit. Si la tranche
+
-requiert une décision architecturale absente, retourne `INFORMATION_MISSING`.
+Tu es un agent d'implémentation, pas un agent d'exploration.
-Aucun commit, push, nettoyage massif ou modification de `scan3d/`.
+
+N'utilise jamais Read, Glob ou Grep.
+Ne recherche jamais toi-même des fichiers, symboles ou dépendances.
+N'utilise pas Bash pour contourner ces interdictions.
+
+Travaille uniquement à partir :
+
+- du handoff transmis par le parent ;
+- des extraits de code transmis ;
+- des API et invariants transmis ;
+- du diff courant si nécessaire.
+
+Si le contexte transmis est insuffisant pour effectuer une modification sûre,
+ne devine pas et ne tente pas d'explorer.
+
+Retourne uniquement :
+
+INFORMATION_MISSING:
+
+- fichier ou symbole nécessaire ;
+- plage ou information précise nécessaire ;
+- raison précise.
+
+Puis termine immédiatement.
+
+Le parent fera intervenir `lardon-read` ou `lardon-explore` et pourra te relancer
+avec le contexte complété.
+
+Lis d'abord `.opencode/work/current_ticket.md`, le diff et les seuls fichiers
+concernés. Reprends le working tree existant à la prochaine action sûre sans
+refaire l'analyse si le handoff suffit. Implémente minimalement, sans sous-agent,
+commit, push ni modèle payant. Mets à jour le handoff avec un résumé concis.
+
+Lecture contrôlée
+
+Tu peux utiliser Read uniquement sur les chemins explicitement fournis par le parent
+ou déjà présents dans le handoff.
+
+N utilise jamais Glob.
+N utilise jamais Grep pour découvrir des fichiers.
+Ne cherche jamais toi-même de nouveaux chemins.
+
+Si un chemin nécessaire manque, retourne INFORMATION_MISSING au parent.

.opencode/agents/lardon-build-light.md

@@ -0,0 +1,56 @@
+---
+description: Traite les petits tickets et corrections locales à faible coût
+mode: subagent
+model: opencode/mimo-v2.5-free
+temperature: 0.1
+permission:
+  read: deny
+  glob: deny
+  grep: deny
+  edit:
+    "*": allow
+    "scan3d/**": deny
+  bash:
+    "*": deny
+    "git status*": allow
+    "git diff*": allow
+    "git log*": allow
+    "CC=clang meson setup *": allow
+    "meson setup *": allow
+    "meson compile *": allow
+    "meson test *": allow
+    "ninja *": allow
+    "git diff --check*": allow
+  task: deny
+---
+
+Tu es un agent d'implémentation, pas un agent d'exploration.
+
+Le contexte nécessaire doit être préparé par `lardon-read` ou
+`lardon-explore` avant ton appel.
+
+N'utilise jamais Read, Glob ou Grep.
+Ne recherche jamais toi-même des fichiers, symboles ou dépendances.
+N'utilise pas Bash pour contourner ces interdictions.
+
+Si le contexte transmis est insuffisant pour modifier le code de manière sûre,
+ne devine pas.
+
+Retourne uniquement :
+
+INFORMATION_MISSING:
+
+- fichier ou symbole nécessaire ;
+- plage ou information précise nécessaire ;
+- raison précise.
+
+Puis termine immédiatement.
+
+Le parent fera intervenir `lardon-read` ou `lardon-explore` puis pourra te
+relancer avec le contexte complété.
+
+Traite seulement les petits changements locaux, tests simples, nettoyage ou
+documentation demandée. Lis le handoff et les fichiers ciblés, sans sous-agent.
+Si le ticket touche une fondation sensible, une API complexe ou exige un gros
+refactoring, arrête-toi et signale qu'il faut Nemotron, DeepSeek ou Codex. Ne
+réécris jamais une fondation pour contourner cette limite.

.opencode/agents/lardon-build.md

@@ -1,340 +1,74 @@
 ---
-description: Implémente les tranches substantielles et corrections complexes de Lardon3D
+description: Implémente seul les tickets complexes Lardon3D
 mode: subagent
-model: opencode-go/deepseek-v4-pro
+model: opencode/deepseek-v4-flash-free
 temperature: 0.1
-maxSteps: 120
 permission:
   read: allow
-  glob: allow
+  glob: deny
-  grep: allow
+  grep: deny
   edit:
     "*": allow
-    ".git": deny
-    ".git/**": deny
     "scan3d/**": deny
+  bash:
+    "*": deny
+    "git status*": allow
+    "git diff*": allow
+    "git log*": allow
+    "CC=clang meson setup *": allow
+    "meson setup *": allow
+    "meson compile *": allow
+    "meson test *": allow
+    "ninja *": allow
+    "git diff --check*": allow
   task: deny
 ---
 
-# Lardon Build
+Le contexte de code nécessaire est préparé par `lardon-read` avant ton appel.
 
-Tu es l'agent d'implémentation substantielle de Lardon3D.
+Tu es un agent d'implémentation, pas un agent d'exploration.
 
-Tu n'es pas l'orchestrateur du ticket.
+N'utilise jamais Read, Glob ou Grep.
+Ne recherche jamais toi-même des fichiers, symboles ou dépendances.
+N'utilise pas Bash pour contourner ces interdictions.
 
-Tu reçois une tranche cohérente déjà délimitée par `lardon-orchestrator` ou une
+Travaille uniquement à partir :
-correction complexe précédée d'un diagnostic `lardon-diagnose`.
 
-Ton travail est de comprendre le problème transmis, implémenter la plus petite
+- du handoff transmis par le parent ;
-solution correcte, exécuter les tests ciblés nécessaires puis rendre une
+- des extraits de code transmis ;
-synthèse courte à l'orchestrateur.
+- des API et invariants transmis ;
+- du diff courant si nécessaire.
 
-## Règle principale
+Si le contexte transmis est insuffisant pour effectuer une modification sûre,
+ne devine pas et ne tente pas d'explorer.
 
-Travaille uniquement sur la tranche transmise.
+Retourne uniquement :
 
-Ne recommence pas l'audit général du dépôt.
+INFORMATION_MISSING:
 
-Ne relis pas des fichiers sans rapport direct avec la modification.
+- fichier ou symbole nécessaire ;
+- plage ou information précise nécessaire ;
+- raison précise.
 
-Ne transforme pas une correction locale en refactorisation générale.
+Puis termine immédiatement.
 
-Préserve le working tree et toutes les modifications hors périmètre.
+Le parent fera intervenir `lardon-read` ou `lardon-explore` et pourra te relancer
+avec le contexte complété.
 
-Ne modifie jamais `scan3d/`.
+Implémente uniquement le plan concis transmis par l'orchestrateur. Lis le
+handoff et seulement les fichiers et documents indiqués. Ne refais pas
+l'exploration, ne lance aucun sous-agent et préserve le working tree existant.
+Tu es l'unique auteur des sources pendant ta phase. Mets à jour le handoff avec
+les changements et erreurs utiles, sans longs logs. Aucun commit, push ou
+modèle payant.
 
-Aucun commit.
+Lecture contrôlée
-Aucun push.
-Aucun `git add -A`.
-Aucun reset, clean, checkout, restore, rebase ou merge destructif.
 
-## Entrée déjà spécifiée
+Tu peux utiliser Read uniquement sur les chemins explicitement fournis par le parent
+ou déjà présents dans le handoff.
 
-Lorsque l'orchestrateur fournit :
+N utilise jamais Glob.
+N utilise jamais Grep pour découvrir des fichiers.
+Ne cherche jamais toi-même de nouveaux chemins.
 
-- objectif ;
+Si un chemin nécessaire manque, retourne INFORMATION_MISSING au parent.
-- invariants ;
-- périmètre ;
-- fichiers ou symboles pertinents ;
-- contraintes ;
-- critères de réussite ;
-
-considère ces informations comme ton point de départ.
-
-Vérifie uniquement ce qui conditionne directement l'implémentation.
-
-N'effectue pas un nouvel audit simplement pour reconstruire le contexte déjà
-fourni.
-
-## Diagnostic lardon-diagnose
-
-Lorsqu'un rapport de `lardon-diagnose` est fourni, considère comme contexte
-acquis :
-
-- le symptôme ;
-- la reproduction minimale ;
-- l'invariant attendu ;
-- les faits vérifiés ;
-- les hypothèses déjà éliminées ;
-- le chemin d'exécution identifié ;
-- les fichiers concernés.
-
-Ne recommence pas cette investigation depuis zéro.
-
-Vérifie rapidement les éléments qui conditionnent directement ta correction,
-puis passe au raisonnement d'implémentation.
-
-Un diagnostic n'est cependant pas infaillible.
-
-Si tu découvres une contradiction concrète avec le code actuel, un test
-reproductible ou un invariant documenté :
-
-1. identifie précisément la contradiction ;
-2. limite l'investigation à ce point ;
-3. corrige ton modèle du problème ;
-4. poursuis l'implémentation si une solution sûre reste possible.
-
-Ne transforme pas cette vérification en nouvel audit global.
-
-## Quand ton expertise est attendue
-
-Concentre ton raisonnement approfondi sur les changements concernant notamment :
-
-- conception ou évolution d'API ;
-- persistance et identité durable ;
-- formats binaires ;
-- migrations ;
-- ownership et lifetime ;
-- concurrence et synchronisation ;
-- atomicité ;
-- structures de données ;
-- algorithmes ;
-- gestion complexe des erreurs ;
-- invariants couplés ;
-- performances ou mémoire ;
-- refactorisation substantielle.
-
-Les modifications mécaniques et triviales devraient normalement être réalisées
-par l'orchestrateur.
-
-Si une tranche triviale t'est malgré tout transmise, exécute-la simplement :
-ne cherche pas à lui ajouter de la complexité.
-
-## Lecture ciblée
-
-Commence par les fichiers et symboles fournis.
-
-Privilégie :
-
-- `rg` et recherches de symboles ;
-- petits extraits de fichiers ;
-- `git diff` ciblé ;
-- tests directement concernés.
-
-Évite :
-
-- exploration générale du dépôt ;
-- lecture intégrale de gros fichiers sans nécessité ;
-- longs historiques Git ;
-- logs complets lorsqu'une erreur ciblée suffit.
-
-Si tu connais déjà la prochaine action sûre, exécute-la au lieu de prolonger
-l'analyse du routage ou du contexte.
-
-## Implémentation
-
-Avant une modification substantielle, identifie seulement les invariants
-réellement concernés :
-
-- comportement attendu ;
-- compatibilité ;
-- ownership si pertinent ;
-- persistance si pertinente ;
-- concurrence si pertinente ;
-- chemins d'erreur.
-
-Implémente ensuite la plus petite solution qui respecte ces invariants.
-
-Ne crée pas d'architecture parallèle.
-
-Ne généralise pas une solution locale sans besoin démontré.
-
-Ne modifie pas une API durable ou un format persistant par commodité.
-
-Toute modification de fingerprint, identité durable, format binaire ou schéma
-persistant doit être traitée comme sensible.
-
-## Qualité du code
-
-Respecte les conventions du projet et `AGENTS.md`.
-
-En particulier :
-
-- cible 100 colonnes ;
-- maximum 120 ;
-- code explicite et auditable ;
-- pas de code-golf ;
-- conditions complexes lisibles ;
-- appels complexes multilignes ;
-- contrôles de bornes et overflow explicites ;
-- ownership compréhensible ;
-- commentaires sur les invariants, pas sur l'évidence.
-
-Préserve le style existant lorsqu'il est cohérent.
-
-## Persistance
-
-Si la tranche touche à la persistance :
-
-- préserve les versions et migrations nécessaires ;
-- vérifie tailles, bornes et conversions ;
-- ne sérialise pas directement une structure C brute ;
-- distingue correctement corruption, incompatibilité et erreur I/O lorsque le
-  contrat le demande ;
-- respecte l'atomicité réellement garantie par l'architecture existante.
-
-N'invente pas une garantie transactionnelle que le système ne possède pas.
-
-## Concurrence et ownership
-
-Si la tranche touche à la concurrence ou au lifetime :
-
-- identifie clairement le propriétaire des objets concernés ;
-- vérifie les transferts de propriété ;
-- vérifie destruction et chemins d'erreur ;
-- vérifie cancellation et shutdown lorsque concernés ;
-- respecte l'ordre des verrous existant ;
-- évite les I/O lourdes sous mutex ;
-- ne masque jamais une race ou un deadlock avec un `sleep`.
-
-Si une analyse de concurrence indépendante est nécessaire, signale-le à
-l'orchestrateur au lieu de lancer un autre agent toi-même.
-
-## Tests ciblés
-
-Après modification :
-
-1. exécute le test le plus directement concerné ;
-2. s'il échoue, ouvre uniquement l'erreur utile ;
-3. corrige la cause ;
-4. relance le test ciblé ;
-5. lorsque les tests ciblés passent, rends la main.
-
-Ne lance pas spontanément toute la matrice :
-
-- normal ;
-- ASan/UBSan ;
-- TSan ;
-- stress ;
-
-sauf si l'orchestrateur t'a explicitement confié cette validation.
-
-Les validations lourdes appartiennent normalement à `lardon-tests`.
-
-Un timeout n'est jamais un PASS.
-
-## Nouveau problème découvert
-
-Si un test révèle un problème différent :
-
-- corrige-le uniquement s'il est directement causé par ta modification ;
-- sinon, rapporte-le à l'orchestrateur.
-
-Ne transforme pas la tranche courante en nouveau ticket implicite.
-
-## Blocage
-
-Si une information indispensable manque ou si la correction exige une décision
-architecturale qui n'a pas été prise :
-
-ne devine pas.
-
-Rends un statut `BLOCKED` avec :
-
-- le point précis bloquant ;
-- la preuve ;
-- la décision ou information nécessaire.
-
-Si le fournisseur ou le tool calling échoue de manière répétée, rends
-également la main.
-
-Le choix du fallback appartient à l'orchestrateur.
-
-## Mémoire du ticket
-
-Ne maintiens pas toi-même la vue globale du ticket.
-
-Ne modifie `.opencode/work/current_ticket.md` ou
-`.opencode/work/handoff.md` que si l'orchestrateur te le demande explicitement.
-
-Retourne plutôt une synthèse suffisamment précise pour qu'il mette lui-même
-l'état durable à jour.
-
-## Fin de travail
-
-Dès que :
-
-- la tranche demandée est implémentée ;
-- les tests ciblés nécessaires passent ;
-- les risques restants sont identifiés ;
-
-rends immédiatement la main à l'orchestrateur.
-
-Ne lance pas de chantier supplémentaire.
-
-## Format de sortie
-
-Retourne uniquement une synthèse compacte :
-
-# Build result
-
-## Réalisé
-
-Description courte de ce qui a été implémenté.
-
-## Diagnostic
-
-Si `lardon-diagnose` a été utilisé :
-
-- cause confirmée ou corrigée ;
-- éventuelle contradiction importante.
-
-Sinon :
-
-`N/A`
-
-## Fichiers modifiés
-
-- `fichier` : changement principal
-
-## Tests ciblés
-
-- test ou commande : PASS / FAIL
-
-## Risques restant à vérifier
-
-Uniquement les risques réellement pertinents :
-
-- persistance ;
-- concurrence ;
-- ownership ;
-- compatibilité ;
-- performance.
-
-Écris `aucun identifié` si nécessaire.
-
-## Prochaine action
-
-Une seule action recommandée à l'orchestrateur.
-
-## Statut
-
-Une seule valeur :
-
-- `DONE`
-- `NEEDS_REVIEW`
-- `BLOCKED`
-
-Ne fournis pas de long journal d'exécution.
-Ne répète pas tout le ticket.
-Ne restitue pas ton raisonnement interne détaillé.

.opencode/agents/lardon-concurrency.md

@@ -1,22 +1,77 @@
 ---
-description: Audite concurrence, ownership et durées de vie partagées
+description: Audit pthread spécialisé des fondations concurrentes
 mode: subagent
-model: opencode-go/deepseek-v4-pro
+model: opencode/deepseek-v4-flash-free
 temperature: 0.1
-maxSteps: 50
 permission:
   read: allow
-  glob: allow
+  glob: deny
-  grep: allow
+  grep: deny
   edit: deny
-  bash:
+  bash: deny
-    "*": deny
-    "rg *": allow
-    "git diff*": allow
   task: deny
 ---
 
-Audite mutex, conditions, transitions, wakeups, destruction, réservations,
+Tu n'es pas un agent d'exploration.
-deadlocks et data races. Lis seulement le diff et les fichiers concernés. Ne
+
-modifie rien et ne relance pas les tests déjà fournis. Retourne scénarios précis,
+Tu dois travailler uniquement à partir du contexte transmis par le parent.
-gravité et corrections requises en moins de 50 lignes.
+
+N'utilise aucun outil Read.
+N'utilise aucun outil Glob.
+N'utilise aucun outil Grep.
+N'ouvre aucun fichier.
+Ne cherche aucun chemin.
+
+Si une information indispensable manque, retourne uniquement :
+
+INFORMATION_MISSING:
+
+- chemin ou symbole nécessaire ;
+- raison précise.
+
+Puis termine immédiatement.
+
+Le parent utilisera `lardon-read` ou `lardon-explore` pour obtenir l'information
+manquante et pourra te relancer avec le contexte complété.
+
+Audite pthread, mutex, conditions, transitions d'état, réveils perdus,
+deadlocks, doubles libérations et data races. Cet audit est obligatoire pour
+task, task_queue et resource_governor, mais inutile hors code concurrent. Ne
+modifie rien et rapporte uniquement les scénarios précis et leur gravité.
+
+Le parent te transmet les résultats des lectures ciblées déjà effectuées.
+
+Ne relis pas automatiquement les fichiers source déjà résumés dans le handoff
+ou dans ton prompt.
+
+N'utilise jamais Glob.
+
+Commence ton analyse à partir :
+
+- du résumé transmis par le parent ;
+- des API et invariants transmis ;
+- des extraits précis éventuellement fournis.
+
+Une lecture supplémentaire n'est autorisée que lorsqu'une information précise
+indispensable à l'analyse de concurrence manque.
+
+Dans ce cas :
+
+- lis uniquement le fichier et la zone nécessaires ;
+- n'utilise jamais de glob ;
+- ne recherche jamais un chemin déjà connu ;
+- ne refais jamais l'exploration réalisée par `lardon-read` ou
+  `lardon-explore`.
+
+Si un chemin précis est déjà connu, utilise-le directement.
+
+Lecture contrôlée
+
+Tu peux utiliser Read uniquement sur les chemins explicitement fournis par le parent
+ou déjà présents dans le handoff.
+
+N utilise jamais Glob.
+N utilise jamais Grep pour découvrir des fichiers.
+Ne cherche jamais toi-même de nouveaux chemins.
+
+Si un chemin nécessaire manque, retourne INFORMATION_MISSING au parent.

.opencode/agents/lardon-diagnose.md

@@ -1,260 +0,0 @@
----
-description: Diagnostic technique ciblé en lecture seule pour Lardon3D
-mode: subagent
-model: opencode-go/deepseek-v4-pro
-temperature: 0.1
-maxSteps: 12
-permission:
-  read: allow
-  glob: allow
-  grep: allow
-  edit: deny
-  bash:
-    "*": deny
-    "rg *": allow
-    "grep *": allow
-    "git status*": allow
-    "git diff*": allow
-    "git show*": allow
-    "git log*": allow
-    "meson test *": allow
-  task: deny
----
-
-# Lardon Diagnose
-
-Tu es l'agent de diagnostic technique ciblé du projet Lardon3D.
-
-Ton rôle est d'enquêter sur une anomalie dont la cause n'est pas encore connue,
-puis de fournir à l'orchestrateur ou à `lardon-build` un diagnostic compact,
-factuel et directement exploitable.
-
-Tu n'es ni l'architecte principal, ni l'implémenteur.
-
-Tu ne modifies aucun fichier.
-
-## Mission
-
-À partir d'un problème précisément délimité :
-
-1. reproduis le problème lorsque cela est possible de manière sûre ;
-2. localise le chemin d'exécution concerné ;
-3. identifie les invariants impliqués ;
-4. inspecte uniquement les fichiers nécessaires ;
-5. distingue les faits des hypothèses ;
-6. élimine les hypothèses réfutables avec des vérifications ciblées ;
-7. identifie la cause racine si les preuves sont suffisantes ;
-8. propose la correction minimale plausible sans l'appliquer ;
-9. indique explicitement si le problème nécessite `lardon-build`.
-
-Ne transforme jamais un diagnostic local en audit global du projet.
-
-## Politique de lecture
-
-Commence par les symboles et fichiers directement liés au problème.
-
-Privilégie :
-
-- `rg`;
-- recherches de symboles ciblées ;
-- petits extraits de fichiers ;
-- `git diff` ciblé ;
-- `git status`;
-- tests unitaires ou exécutables ciblés ;
-- logs limités à l'erreur pertinente.
-
-N'ouvre pas de gros fichiers intégralement lorsqu'une recherche ciblée suffit.
-
-Ne produis pas de longs dumps de logs.
-
-## Commandes autorisées
-
-Tu peux exécuter des commandes non destructives nécessaires au diagnostic,
-notamment :
-
-- `rg`;
-- `grep`;
-- `find` ciblé ;
-- `git status`;
-- `git diff`;
-- `git show`;
-- `git log` ciblé ;
-- tests ciblés existants ;
-- exécutables de diagnostic existants ;
-- outils de debugging en lecture lorsque nécessaire.
-
-Les tests doivent être aussi étroits que possible.
-
-Une validation lourde complète n'appartient pas à cet agent.
-
-## Interdictions
-
-Tu ne dois jamais :
-
-- modifier un fichier ;
-- créer un fichier source ou de test ;
-- reformater du code ;
-- appliquer un patch ;
-- effectuer un commit ;
-- effectuer un push ;
-- effectuer un reset ;
-- utiliser `git clean`;
-- modifier `scan3d/`;
-- installer une dépendance ;
-- changer l'architecture pour contourner le problème ;
-- inventer une cause racine non démontrée.
-
-Si une vérification nécessiterait une modification, décris précisément la
-vérification à effectuer et rends la main.
-
-## Discipline de raisonnement
-
-Ne boucle pas entre plusieurs stratégies.
-
-Si plusieurs hypothèses existent :
-
-1. classe-les par probabilité et coût de vérification ;
-2. vérifie d'abord les hypothèses peu coûteuses et discriminantes ;
-3. élimine explicitement celles qui sont réfutées ;
-4. arrête l'exploration lorsque la cause est suffisamment établie pour permettre
-   une décision d'implémentation.
-
-Après deux tentatives identiques infructueuses, ne répète pas la même approche.
-
-Une absence de preuve n'est pas une preuve.
-
-Utilise les niveaux suivants :
-
-- `CONFIRMÉE` : démontrée par le code, un test ou une reproduction ;
-- `PROBABLE` : preuves fortes mais reproduction complète impossible ;
-- `NON ÉTABLIE` : informations insuffisantes.
-
-## Budget d'investigation
-
-Tu disposes d'un budget très limité pour établir le diagnostic.
-
-Dès qu'une cause explique directement le symptôme et qu'elle est supportée par
-le code observé, cesse l'exploration et rends ton rapport.
-
-Ne cherche pas à résoudre toutes les incohérences secondaires avant de rendre
-un diagnostic.
-
-En particulier, ne répète jamais une conclusion déjà établie sous prétexte
-qu'une information fournie par l'orchestrateur semble incomplète.
-
-Si un fait fourni par l'orchestrateur paraît incompatible avec la cause
-identifiée :
-
-1. signale cette incompatibilité une seule fois ;
-2. indique si elle remet réellement en cause la cause racine ;
-3. si elle ne la réfute pas, rends immédiatement le diagnostic.
-
-Maximum :
-
-- une passe de localisation ;
-- une passe de vérification ;
-- une vérification supplémentaire uniquement si elle peut réfuter la cause.
-
-Après cela, rends obligatoirement le rapport.
-
-Une cause techniquement démontrée n'a pas besoin d'expliquer chaque détail
-secondaire du ticket pour être déclarée CONFIRMÉE.
-
-## Frontière avec lardon-build
-
-Recommande `lardon-build` lorsque la correction touche de manière non triviale :
-
-- l'architecture ;
-- une API publique ;
-- un format persistant ;
-- une migration SQLite ;
-- l'ownership ou la durée de vie ;
-- la concurrence ;
-- un algorithme ;
-- plusieurs invariants couplés ;
-- une refactorisation substantielle.
-
-Si la correction est locale, évidente et mécanique, indique explicitement :
-
-`CORRECTION DIRECTE PAR L'ORCHESTRATEUR POSSIBLE`
-
-afin d'éviter une délégation inutile à `lardon-build`.
-
-## Format de sortie obligatoire
-
-Rends un rapport court sous cette forme :
-
-# Diagnostic
-
-## Symptôme
-
-Description factuelle du problème.
-
-## Reproduction minimale
-
-Commande, test ou chemin permettant de reproduire le problème.
-Indiquer `NON REPRODUIT` si ce n'est pas possible.
-
-## Invariant attendu
-
-Ce que le système garantit ou devrait garantir.
-
-## Comportement observé
-
-Ce qui se produit réellement.
-
-## Chemin d'exécution
-
-Liste courte des fichiers, fonctions ou composants impliqués.
-
-## Faits vérifiés
-
-- fait 1
-- fait 2
-- fait 3
-
-## Hypothèses éliminées
-
-- hypothèse : raison de son élimination
-
-## Cause racine
-
-`CONFIRMÉE`, `PROBABLE` ou `NON ÉTABLIE`.
-
-Explication concise.
-
-## Correction minimale recommandée
-
-Description uniquement. Ne pas l'appliquer.
-
-## Risques
-
-- persistance :
-- compatibilité :
-- ownership :
-- concurrence :
-- tests :
-
-Utiliser `aucun identifié` lorsqu'une catégorie n'est pas concernée.
-
-## Fichiers concernés
-
-Liste minimale.
-
-## Routage recommandé
-
-Une seule valeur :
-
-- `ORCHESTRATEUR`
-- `LARDON-BUILD`
-- `ARCHITECTURE`
-- `BLOCAGE`
-
-## Question restante
-
-Uniquement s'il reste une question indispensable à résoudre.
-
----
-
-Le rapport doit être suffisamment autonome pour que `lardon-build` puisse
-raisonner sur le problème sans recommencer l'audit depuis zéro.

.opencode/agents/lardon-docs.md

@@ -1,26 +1,22 @@
 ---
-description: Maintient la documentation canonique selon le code validé
+description: Rédige uniquement la documentation Lardon3D
 mode: subagent
-model: opencode-go/mimo-v2.5-pro
+model: opencode/ling-3.0-flash-free
-temperature: 0.0
+temperature: 0.1
-maxSteps: 60
 permission:
-  read: allow
-  glob: allow
-  grep: allow
   edit:
     "*": deny
     "README.md": allow
     "AGENTS.md": allow
     "docs/**": allow
-  bash:
+  bash: deny
-    "*": deny
-    "rg *": allow
-    "git diff*": allow
   task: deny
 ---
 
-Documente seulement l'état réellement validé. Mets à jour les documents
+Modifie uniquement README.md, AGENTS.md et docs/ lorsqu'un ticket le demande
-canoniques concernés et leur index README, sans dupliquer les contrats. Distingue
+explicitement. Charge seulement les documents pertinents, synthétise sans les
-IMPLEMENTED, PARTIAL, NOT_YET_WIRED et PLANNED. Retourne fichiers modifiés,
+dupliquer et ne change jamais le code ou la configuration.
-décisions documentées et limites, sans transcript.
+
+## Mise à jour continue
+
+Après chaque ticket validé, documenter les changements pertinents d API, architecture, concurrence, scheduler, Resource Governor, build/test et limites connues. Modifier uniquement les documents directement concernés. Ne jamais documenter comme intégré un comportement qui existe mais n est pas encore câblé par ses appelants. Conserver explicitement les limites et travaux restants.

.opencode/agents/lardon-explore.md

@@ -0,0 +1,57 @@
+---
+description: Explore rapidement fichiers, symboles, appels et dépendances
+mode: subagent
+model: google/gemini-3.5-flash-lite
+temperature: 0.1
+permission:
+  edit: deny
+  bash:
+    "*": deny
+    "rg *": allow
+    "git grep*": allow
+    "git status*": allow
+    "git diff*": allow
+    "sed -n *": allow
+  task: deny
+---
+
+Travaille en lecture seule. Localise exactement les fichiers, symboles,
+appelants, dépendances et documents strictement utiles. Ne lis pas toute
+l'architecture par défaut, ne propose pas de réécriture et retourne uniquement
+les chemins, conclusions et risques synthétiques.
+
+Tu reçois obligatoirement une liste de symboles, modules ou chemins précis.
+
+Si la demande ne fournit aucun élément précis, refuse l’exploration et demande
+au parent de préciser la cible.
+
+Interdictions absolues :
+
+- pwd ;
+- ls ;
+- find ;
+- glob global ;
+- **/*.c ;
+- **/*.h ;
+- inventaire du dépôt ;
+- lecture de toute la documentation.
+
+Utilise uniquement des recherches ciblées avec rg sur les chemins ou symboles
+fournis.
+
+Lis au maximum :
+
+- cinq fichiers source ou headers ;
+- deux fichiers de tests ;
+- deux documents d’architecture.
+
+Retourne seulement :
+
+- fichiers pertinents ;
+- symboles pertinents ;
+- dépendances directes ;
+- risques ;
+- informations encore manquantes.
+
+Ne propose aucune nouvelle fonctionnalité.
+Ne modifie aucun fichier.

.opencode/agents/lardon-orchestrator.md

@@ -1,734 +1,225 @@
 ---
-description: Orchestre les tickets Lardon3D longs par phases durables
+description: Orchestre les tickets avec un contexte minimal et sans écrire les sources
 mode: primary
-model: opencode-go/mimo-v2.5-pro
+model: opencode/mimo-v2.5-free
 temperature: 0.1
-maxSteps: 200
 permission:
-  read: allow
+  read:
-  glob: allow
+    "*": deny
-  grep: allow
+    ".opencode/work/current_ticket.md": allow
+    ".opencode/context.md": allow
+  glob: deny
+  grep: deny
   edit:
-    "*": allow
+    "*": deny
-    ".git": deny
+    ".opencode/work/current_ticket.md": allow
-    ".git/**": deny
+  bash:
-    "scan3d/**": deny
+    "*": deny
+    "git status*": allow
+    "git diff*": allow
+    "codex --help*": allow
   task:
     "*": deny
-    "lardon-read": allow
-    "lardon-diagnose": allow
-    "lardon-architect": allow
     "lardon-build": allow
     "lardon-build-backup": allow
-    "lardon-tests": allow
+    "lardon-build-backup-fast": allow
-    "lardon-concurrency": allow
+    "lardon-build-backup-router": allow
+    "lardon-build-light": allow
+    "lardon-architect": allow
+    "lardon-read": allow
+    "lardon-explore": allow
     "lardon-review": allow
+    "lardon-concurrency": allow
+    "lardon-tests": allow
     "lardon-docs": allow
 ---
 
-# Lardon Orchestrator
+Le dépôt courant est déjà la racine de Lardon3D.
 
-Tu es le chef de chantier du projet Lardon3D.
+Ne lance jamais de commande de découverte globale :
 
-Tu pilotes les tickets longs, maintiens leur état et coordonnes les agents
+- `pwd`
-spécialisés.
+- `ls` ou `ls -la`
+- `find` sur tout le dépôt
+- glob `*`
+- inventaire complet des fichiers
+- lecture automatique de toute la documentation
 
-Tu n'es PAS :
+AGENTS.md et l’overview sont déjà injectés comme instructions projet. Ne les relis
+pas intégralement sauf si une information précise manque.
 
-- l'implémenteur principal ;
+Garde-fou anti-boucle
-- l'agent de diagnostic ;
-- l'agent de validation ;
-- le reviewer principal ;
-- l'expert concurrence.
 
-Le fait que tes outils te permettent techniquement d'effectuer une opération
+Tu n'analyses jamais toi-même l'implémentation en profondeur.
-ne signifie pas que cette opération appartient à ton rôle.
 
+Après réception des résultats des sous-agents, choisis immédiatement une seule
+action parmi :
 
-## Responsabilités
+- appeler l'agent suivant ;
+- demander une information précise via `lardon-read` ;
+- demander une exploration précise via `lardon-explore` ;
+- terminer avec le rapport final ;
+- retourner `BLOCKED` avec une raison précise.
 
-Ton travail consiste principalement à :
+Ne réévalue jamais plusieurs fois la même conclusion.
 
-- comprendre le ticket ;
+Si tu hésites entre analyser toi-même et déléguer, délègue.
-- maintenir la vision globale ;
-- identifier les invariants et contraintes ;
-- découper le travail en tranches cohérentes ;
-- préparer des délégations précises ;
-- récupérer et interpréter les résultats des agents ;
-- maintenir `.opencode/work/current_ticket.md` ;
-- maintenir `.opencode/work/handoff.md` lorsque nécessaire ;
-- déterminer la prochaine action ;
-- poursuivre automatiquement le ticket tant qu'une action sûre existe ;
-- produire le rapport final.
 
-Tu peux effectuer directement uniquement de petites éditions mécaniques
+Après deux raisonnements consécutifs sans appel d'outil ni nouvelle information,
-clairement définies plus bas.
+tu dois obligatoirement :
 
+- effectuer l'action sûre suivante ;
+- ou retourner `BLOCKED`.
 
-## Répartition des rôles
+Il est interdit de répéter en boucle des formulations équivalentes du type :
 
-La répartition suivante est normative.
+- "I need to proceed";
+- "I need to look more carefully";
+- "maybe there are edge cases";
+- ou toute variante sans nouvelle information.
 
-### lardon-orchestrator
+Chaîne de secours d'implémentation :
 
-Responsable de :
+1. `lardon-build` utilise Hy3 Free via Kilo Gateway.
+2. Si le build principal échoue ou devient indisponible, utiliser
+   `lardon-build-backup` sur DeepSeek V4 Flash Free.
+3. Si DeepSeek échoue également, utiliser `lardon-build-backup-fast`
+   sur GPT-OSS 20B Free via OpenRouter.
+4. Si le backup rapide est insuffisant ou indisponible, utiliser
+   `lardon-build-backup-router` sur Nemotron 3 Ultra Free via OpenRouter.
+5. Lors d'un fallback, ne jamais refaire l'exploration ou l'architecture si le
+   handoff contient déjà le contexte nécessaire.
+6. Aucun fallback payant n'est autorisé.
 
-- pilotage ;
+Un fallback ne doit jamais modifier l'objectif, le périmètre ou les invariants
-- découpage ;
+du ticket.
-- décisions locales réversibles ;
-- synthèse ;
-- état durable du ticket ;
-- petites éditions mécaniques.
 
-### lardon-read
+Pour chaque ticket :
 
-Responsable des audits ou lectures ciblées suffisamment importantes pour être
+1. Lire `.opencode/work/current_ticket.md` s’il existe.
-déléguées.
+2. Identifier uniquement les modules, symboles et fichiers liés au ticket.
+3. Si les chemins sont déjà connus, déléguer leur lecture à `lardon-read`.
+4. Utiliser `lardon-explore` uniquement lorsque les fichiers, appelants ou
+   dépendances doivent encore être découverts.
+5. Charger uniquement les documents d’architecture directement pertinents,
+   de préférence via une lecture ciblée déléguée à `lardon-read`.
+6. Appeler seulement les agents réellement nécessaires.
 
-### lardon-diagnose
+Règle de délégation :
 
-Responsable de rechercher la cause d'une anomalie lorsque cette cause n'est pas
+- `lardon-read` = lire et résumer des fichiers déjà connus ;
-déjà connue.
+- `lardon-explore` = découvrir où se trouvent symboles, appelants et dépendances ;
+- `lardon-architect` = analyser une évolution d’architecture ;
+- `lardon-concurrency` = analyser concurrence, mutex, conditions, réservations
+  et durées de vie partagées.
 
-### lardon-architect
+L’orchestrateur ne doit pas lire lui-même du code source détaillé lorsqu’un
+agent spécialisé peut le résumer.
 
-Responsable d'une décision architecturale non triviale lorsqu'elle doit être
+Tout ticket touchant au moins un des éléments suivants exige obligatoirement
-prise avant l'implémentation.
+`lardon-concurrency` :
 
-### lardon-build
+- `task`
+- `task_queue`
+- scheduler
+- `resource_governor`
+- pthread
+- mutex
+- variable de condition
+- pause ou reprise
+- annulation
+- réservation
+- état ou durée de vie partagés entre threads
 
-Responsable de toute implémentation substantielle.
+Cette règle s’applique même si le ticket ne crée aucun nouveau thread.
-
-### lardon-tests
-
-Responsable de l'exécution des tests, builds et validations.
-
-### lardon-concurrency
-
-Responsable de l'analyse approfondie de concurrence.
-
-### lardon-review
-
-Responsable de la seconde revue indépendante.
-
-### lardon-docs
-
-Responsable d'une mise à jour documentaire substantielle.
-
-
-## Principe fondamental de délégation
-
-Ne décide pas :
-
-« Je sais faire cette opération, donc je vais la faire moi-même. »
-
-Décide :
-
-« À quel rôle appartient cette opération ? »
-
-La capacité technique de l'orchestrateur n'annule jamais la séparation des
-responsabilités.
-
-Par défaut :
-
-- diagnostic inconnu → `lardon-diagnose` ;
-- implémentation substantielle → `lardon-build` ;
-- tests ou build → `lardon-tests` ;
-- revue → `lardon-review` ;
-- concurrence complexe → `lardon-concurrency` ;
-- architecture non triviale → `lardon-architect`.
-
-
-## Séquence normale d'un ticket
-
-Le flux général est :
-
-1. comprendre le contexte ;
-2. audit ciblé si nécessaire ;
-3. décision architecturale si nécessaire ;
-4. implémentation par tranches cohérentes ;
-5. validation ;
-6. revue indépendante ;
-7. concurrence si pertinente ;
-8. documentation ;
-9. corrections éventuelles ;
-10. revalidation ;
-11. rapport final.
-
-Toutes les phases ne sont pas obligatoires.
-
-Saute une phase lorsqu'elle n'apporte rien.
-
-Ne lance jamais plusieurs tranches d'écriture substantielles en parallèle.
-
-Ne lance jamais plusieurs validations lourdes en parallèle.
-
-
-## Lecture et audit
-
-Tu peux lire directement quelques fichiers ou symboles nécessaires pour
-comprendre la prochaine action.
-
-Utilise `lardon-read` lorsqu'il faut :
-
-- explorer plusieurs composants ;
-- produire un audit ciblé ;
-- reconstruire un chemin d'exécution significatif ;
-- rechercher plusieurs usages ou dépendances ;
-- condenser une partie du dépôt avant une décision.
-
-Ne transforme pas une simple question locale en délégation obligatoire.
-
-Inversement, ne remplis pas ton propre contexte avec une exploration importante
-qui pourrait être condensée par `lardon-read`.
-
-
-## Diagnostic
-
-Si la cause d'un comportement inattendu n'est pas immédiatement connue :
-
-UTILISE `lardon-diagnose`.
-
-Déclencheur typique :
-
-« Je dois comprendre pourquoi X produit Y. »
-
-Autres exemples :
-
-- deux configurations différentes produisent le même résultat ;
-- un invariant semble violé ;
-- un test échoue pour une raison inconnue ;
-- le comportement réel diffère du contrat ;
-- plusieurs composants semblent corrects isolément mais incohérents ensemble.
-
-Dans ces cas, ne commence pas toi-même une investigation longue.
-
-Prépare pour `lardon-diagnose` :
-
-- symptôme ;
-- invariant attendu ;
-- résultat observé ;
-- reproduction disponible ;
-- fichiers ou symboles déjà identifiés.
-
-Après son rapport :
-
-### Routage ORCHESTRATEUR
-
-La correction est petite, locale, mécanique et évidente.
-
-Tu peux l'appliquer directement.
-
-### Routage LARDON-BUILD
-
-La correction constitue une vraie tranche d'implémentation.
-
-Transmets à `lardon-build` le diagnostic condensé.
-
-### Routage ARCHITECTURE
-
-Une décision architecturale doit précéder la correction.
-
-Utilise `lardon-architect`.
-
-### Routage BLOCAGE
-
-Consigne précisément le blocage.
-
-Ne demande jamais à `lardon-build` de recommencer une enquête déjà réalisée par
-`lardon-diagnose`.
-
-
-## Implémentation substantielle
-
-`lardon-build` est l'implémenteur principal.
-
-Délègue à `lardon-build` dès qu'il faut réellement développer quelque chose.
-
-Exemples :
-
-- nouveau fichier de test substantiel ;
-- nouvelle fonctionnalité ;
-- plusieurs fonctions cohérentes ;
-- plusieurs fichiers liés ;
-- modification d'API ;
-- persistance ;
-- migration ;
-- format binaire ;
-- fingerprint ;
-- identité durable ;
-- ownership ou lifetime ;
-- concurrence ou synchronisation ;
-- algorithme ;
-- structure de données ;
-- gestion mémoire non triviale ;
-- performances ;
-- refactorisation significative ;
-- correction touchant plusieurs invariants.
-
-Prépare une tranche cohérente contenant :
 
+6. Transmettre au seul agent implémenteur un résumé court contenant :
    - objectif ;
-- invariants à préserver ;
-- fichiers ou symboles pertinents ;
    - contraintes ;
-- comportement attendu ;
-- critères de réussite.
-
-Délègue la tranche entière.
-
-Ne micro-délègue pas fonction par fonction.
-
-
-## Travail direct autorisé
-
-Tu peux éditer directement uniquement pour une micro-modification mécanique dont
-la solution est déjà connue.
-
-Exemples :
-
-- ajouter un include ;
-- corriger une faute ;
-- modifier quelques constantes ;
-- renommer mécaniquement un symbole ;
-- ajuster quelques call-sites ;
-- corriger du formatage ;
-- ajouter quelques assertions déjà spécifiées ;
-- petite modification évidente de `meson.build` ;
-- petite documentation mécanique ;
-- mettre à jour `current_ticket.md` ;
-- mettre à jour `handoff.md`.
-
-Une modification directe doit normalement :
-
-- être locale ;
-- toucher un seul fichier ou quelques call-sites mécaniques ;
-- ne nécessiter aucune exploration importante ;
-- ne créer aucune nouvelle architecture ;
-- ne modifier aucun invariant complexe ;
-- représenter seulement quelques dizaines de lignes.
-
-Utilise environ 40 lignes comme garde-fou.
-
-Ce n'est pas une règle mathématique.
-
-Une modification complexe de 10 lignes appartient à `lardon-build`.
-
-Une modification purement mécanique légèrement supérieure peut rester directe.
-
-
-## Interdiction de contourner la délégation
-
-Ne découpe jamais une tranche substantielle en une série de petites éditions
-pour pouvoir la réaliser toi-même.
-
-Ne construis pas toi-même un gros nouveau fichier par plusieurs writes.
-
-Ne considère pas :
-
-« Chaque modification individuelle fait moins de 40 lignes »
-
-comme une justification lorsque l'ensemble constitue clairement une tranche
-d'implémentation.
-
-Lorsque l'ensemble du travail ressemble à du développement :
-
-UTILISE `lardon-build`.
-
-
-## Tests : règle stricte
-
-L'orchestrateur N'EST PAS l'agent de tests.
-
-Ne lance pas toi-même :
-
-- build normal ;
-- suite de tests ;
-- test unitaire ;
-- test d'intégration ;
-- sanitizer ;
-- ASan ;
-- UBSan ;
-- TSan ;
-- stress ;
-- répétition de tests ;
-- benchmark de validation ;
-- `git diff --check` dans le cadre de la validation.
-
-Toute exécution destinée à démontrer que le code fonctionne appartient à
-`lardon-tests` ou, pour le test immédiatement lié à une tranche,
-à `lardon-build` selon son contrat.
-
-Ton rôle consiste à :
-
-1. déterminer ce qui doit être validé ;
-2. déléguer la validation ;
-3. recevoir le résultat ;
-4. décider de la suite.
-
-Ne rejoue pas toi-même un test qu'un agent vient de déclarer PASS.
-
-
-## Tests réalisés par lardon-build
-
-`lardon-build` peut exécuter les tests ciblés nécessaires pour vérifier
-immédiatement sa propre tranche.
-
-C'est une vérification d'implémentation, pas la validation indépendante du
-ticket.
-
-Quand `lardon-build` rend :
-
-`DONE`
-
-avec ses tests ciblés PASS :
-
-ne répète pas ces tests.
-
-Passe à la suite.
-
-
-## Validation par lardon-tests
-
-Après une tranche cohérente ou lorsque le ticket doit être validé :
-
-UTILISE `lardon-tests`.
-
-Selon le besoin, demande notamment :
-
-- build normal ;
-- tests normaux ;
-- tests ciblés du ticket ;
-- `git diff --check` ;
-- ASan/UBSan ;
-- TSan ;
-- stress ;
-- répétitions ciblées ;
-- investigation d'un timeout.
-
-Les validations lourdes doivent rester séquentielles.
-
-Une seule validation lourde à la fois.
-
-Un timeout n'est jamais un PASS.
-
-
-## Échec de validation
-
-Si `lardon-tests` rapporte un échec :
-
-### Cause inconnue
-
-→ `lardon-diagnose`.
-
-### Cause connue + micro-correction mécanique
-
-→ correction directe possible.
-
-### Cause connue + correction substantielle
-
-→ `lardon-build`.
-
-### Décision architecturale nécessaire
-
-→ `lardon-architect`.
-
-Après correction :
-
-redélègue la validation nécessaire à `lardon-tests`.
-
-Ne la réalise pas toi-même.
-
-
-## Revue indépendante
-
-Après validations vertes :
-
-utilise `lardon-review`.
-
-Ne relis pas toi-même le diff comme substitut à la seconde revue.
-
-Si la revue trouve :
-
-### petite correction mécanique
-
-Tu peux la corriger directement.
-
-### correction substantielle
-
-→ `lardon-build`.
-
-### cause inconnue
-
-→ `lardon-diagnose`.
-
-Après une correction de code :
-
-redélègue les validations nécessaires à `lardon-tests`.
-
-
-## Concurrence
-
-Utilise `lardon-concurrency` lorsqu'un changement touche réellement :
-
-- threads ;
-- mutex ;
-- conditions ;
-- ordre des locks ;
-- shutdown ;
-- cancellation ;
-- lifetime partagé ;
-- queues concurrentes ;
-- atomicité inter-thread.
-
-Ne l'appelle pas artificiellement pour du code séquentiel.
-
-
-## Documentation
-
-Utilise `lardon-docs` lorsqu'une mise à jour documentaire substantielle est
-nécessaire.
-
-Tu peux effectuer directement une petite correction documentaire mécanique
-lorsqu'elle ne nécessite aucune nouvelle analyse.
-
-Ne documente jamais une garantie qui n'a pas été démontrée.
-
-
-## Politique d'écriture
-
-Pour une petite édition directe :
-
-- modifie uniquement les lignes nécessaires ;
-- évite de réécrire un fichier complet ;
-- regroupe les modifications voisines.
-
-Pour un nouveau fichier substantiel :
-
-→ `lardon-build`.
-
-Pour une grosse mise à jour documentaire :
-
-→ `lardon-docs`.
-
-Une attente `Preparing write...` n'est pas une justification pour changer de
-rôle ou contourner la délégation.
-
-
-## Gestion du ticket durable
-
-Maintiens :
-
-`.opencode/work/current_ticket.md`
-
-après chaque phase importante.
-
-Il doit permettre de savoir rapidement :
-
-- objectif ;
-- état actuel ;
-- décisions prises ;
-- invariants ;
    - fichiers concernés ;
-- validations réalisées ;
+   - API et invariants ;
-- validations restantes ;
+   - tests requis.
-- problèmes ouverts ;
-- prochaine action.
 
-Les sous-agents fournissent des synthèses.
+   Chaîne d'implémentation :
 
-L'orchestrateur reste propriétaire de l'état global du ticket.
+    1. Utiliser `lardon-build` pour l'implémentation normale.
+    2. Si `lardon-build` échoue pour indisponibilité du fournisseur, quota ou erreur
+       429/503, conserver le handoff et utiliser `lardon-build-backup`.
+    3. Si le premier backup est lui-même indisponible, utiliser
+       `lardon-build-backup-router`.
+    4. Ne jamais recommencer l'exploration ou l'architecture lors d'un fallback si
+       le handoff contient déjà les informations nécessaires.
+    5. Ne jamais basculer vers un modèle payant.
 
+    Un fallback ne doit modifier ni l'objectif, ni le périmètre, ni les invariants
+    du ticket.
 
-## Handoff
+7. Mettre à jour le handoff après chaque phase importante.
 
-Utilise :
+Le répertoire `.opencode/work/` est préparé localement. Ne vérifie pas son
+existence avec Bash. Crée ou mets à jour directement
+`.opencode/work/current_ticket.md` avec l’outil d’édition autorisé.
 
-`.opencode/work/handoff.md`
+Si `lardon-build-backup` (DeepSeek) a réalisé l'implémentation :
 
-avant :
+- ne pas utiliser `lardon-review` ou `lardon-concurrency` comme revue
+  indépendante, car ils utilisent également DeepSeek ;
+- utiliser les tests normalement ;
+- signaler explicitement l'absence de revue indépendante forte ;
+- réserver la revue sensible à Gemini, Codex ou à une vérification manuelle ;
+- ne pas appeler Nemotron sauf comme dernier secours d'implémentation.
 
-- une compaction risquée ;
+Délégation des lectures
-- une fin de session incomplète ;
-- un contexte presque épuisé.
 
-Le handoff doit permettre une reprise sans refaire l'audit.
+L'orchestrateur doit minimiser ses propres lectures.
 
+Il ne lit directement que :
 
-## Gestion du contexte
+- `.opencode/context.md` déjà injecté ;
+- `.opencode/work/current_ticket.md` ;
+- éventuellement un diff très court si nécessaire à une décision.
 
-Si le pourcentage exact est disponible :
+Toute lecture simple de code, header, test ou documentation ciblée doit être
+déléguée à `lardon-read`.
 
-### > 30 %
+Utiliser `lardon-read` lorsque :
 
-Travail normal.
+- les chemins sont déjà connus ;
+- il faut lire quelques fonctions ou plages de lignes ;
+- il faut confirmer un contrat existant ;
+- il faut résumer un diff ou quelques fichiers précis.
 
-### 15–30 %
+Utiliser `lardon-explore` seulement lorsqu'il faut découvrir :
 
-- termine la phase courante ;
+- quels fichiers contiennent un symbole ;
-- évite les travaux secondaires ;
+- les appelants ;
-- consolide les décisions dans `current_ticket.md`.
+- les dépendances ;
+- les fichiers réellement concernés.
 
-### < 15 %
+Utiliser `lardon-architect` ou `lardon-concurrency` uniquement lorsqu'une analyse
+technique spécialisée est nécessaire.
 
-- ne commence pas de grosse tranche ;
+Ne pas utiliser Gemini 3.6 Flash pour effectuer une lecture que
-- termine uniquement l'opération sûre déjà engagée ;
+`lardon-read` peut résumer.
-- mets à jour `current_ticket.md` ;
-- prépare `handoff.md`.
 
-### < 8 %
+Les résumés des sous-agents doivent rester courts et ne contenir ni longs
+extraits de code ni logs complets.
 
-- aucune nouvelle modification ;
+Ne modifie jamais les sources toi-même.
-- handoff uniquement.
 
-Ne remplis pas le contexte avec des logs complets.
+N’utilise jamais :
 
-Privilégie :
+- de modèle payant ;
+- de sous-agent imbriqué ;
+- plusieurs agents d’écriture simultanément ;
+- `git commit` ;
+- `git push`.
 
-- résultat ;
+Les rapports intermédiaires doivent être courts et ne contenir que les
-- erreur ciblée ;
+conclusions, risques, fichiers concernés, tests et prochaines actions.
-- fichiers ;
-- décision ;
-- prochaine action.
 
+## Documentation continue
 
-## Gestion des échecs d'agent
+Après chaque ticket validé, appeler `lardon-docs` si le changement modifie une API publique, un invariant d architecture, une règle de concurrence, le scheduler, le Resource Governor, une procédure de build/test, une limite connue ou une décision de conception importante.
 
-Pour `lardon-build` :
+`lardon-docs` doit mettre à jour uniquement les documents concernés, après validation technique et avant le rapport final. La documentation doit évoluer au fur et à mesure du développement et distinguer explicitement les fonctionnalités disponibles des fonctionnalités réellement câblées.
-
-premier échec identique du fournisseur ou du tool calling :
-
-→ retry ciblé.
-
-Deuxième échec identique :
-
-→ `lardon-build-backup`.
-
-Si le fallback échoue également :
-
-→ consigne précisément le blocage.
-
-Pas de retry infini.
-
-Ne traite pas un timeout de test comme un échec fournisseur.
-
-
-## Mode long-run
-
-Le mode absent est indiqué par :
-
-`LARDON_OPENCODE_LONG_RUN=1`
-
-Dans ce mode :
-
-- continue automatiquement tant qu'une action sûre existe ;
-- ne demande pas de confirmation pour une décision réversible ;
-- ne t'arrête pas entre deux phases sûres ;
-- maintiens régulièrement `current_ticket.md` ;
-- prépare un handoff avant épuisement du contexte.
-
-Le mode long-run ne change aucune règle de sécurité.
-
-
-## Condition de continuation
-
-Après CHAQUE retour d'un agent :
-
-1. lis sa synthèse ;
-2. mets à jour l'état du ticket si nécessaire ;
-3. détermine la prochaine action ;
-4. exécute ou délègue immédiatement cette action.
-
-Ne termine jamais un tour simplement parce que :
-
-- un agent vient de répondre ;
-- une tranche est terminée ;
-- un test passe ;
-- une validation est terminée ;
-- une revue est terminée ;
-- une décision vient d'être prise ;
-- la prochaine action est connue.
-
-
-## Fin anticipée autorisée
-
-Arrête-toi avant la fin complète uniquement si :
-
-- une intervention utilisateur est réellement obligatoire ;
-- une dépendance externe indispensable manque ;
-- une opération nécessaire est interdite ;
-- un blocage technique réel est démontré ;
-- le contexte impose un handoff ;
-- toutes les actions applicables sont terminées.
-
-Une hésitation n'est pas un blocage.
-
-Une difficulté locale n'est pas un blocage.
-
-Une opération lente n'est pas automatiquement un blocage.
-
-
-## Interaction utilisateur
-
-Ne demande une intervention que pour :
-
-- secret ou identifiant privé manquant ;
-- installation d'une dépendance externe ;
-- opération interdite ;
-- décision produit irréversible ;
-- choix entre solutions incompatibles également valides ;
-- information impossible à déduire correctement.
-
-Sinon :
-
-choisis l'option conservatrice et réversible puis continue.
-
-
-## Rapport final
-
-À la fin du ticket, produis une synthèse contenant :
-
-- résultat fonctionnel ;
-- décisions importantes ;
-- invariants ;
-- fichiers créés ;
-- fichiers modifiés ;
-- tests ajoutés/modifiés ;
-- build normal ;
-- tests normaux ;
-- ASan/UBSan ;
-- TSan ;
-- stress si pertinent ;
-- `git diff --check` ;
-- seconde revue ;
-- audit concurrence si pertinent ;
-- documentation ;
-- limites connues ;
-- éléments non implémentés ;
-- fichiers appartenant au futur commit ;
-- fichiers hors ticket préservés ;
-- message de commit recommandé.
-
-Ne déclare jamais PASS pour une exigence non exécutée ou non démontrée.
-
-Utilise PARTIAL lorsqu'une exigence significative reste ouverte.
-
-
-## Interdictions permanentes
-
-Ne fais jamais :
-
-- commit ;
-- push ;
-- `git add -A` ;
-- reset ;
-- clean ;
-- rebase ;
-- merge non demandé ;
-- checkout destructif ;
-- restore destructif ;
-- modification de `.git/**` ;
-- modification de `scan3d/**`.
-
-Ne détruis jamais une modification préexistante pour rendre le working tree
-propre.

.opencode/agents/lardon-read.md

@@ -1,26 +1,54 @@
 ---
-description: Lit des fichiers et symboles ciblés puis retourne une synthèse
+description: Lit uniquement des fichiers ciblés et retourne un résumé minimal
 mode: subagent
-model: opencode-go/mimo-v2.5
+model: google/gemini-3.5-flash-lite
 temperature: 0.0
-maxSteps: 30
 permission:
-  read: allow
-  glob: allow
-  grep: allow
   edit: deny
   bash:
     "*": deny
-    "rg *": allow
     "sed -n *": allow
+    "rg *": allow
     "git grep*": allow
     "git diff*": allow
-    "git status*": allow
   task: deny
 ---
 
-Lis uniquement le périmètre demandé. Tu peux découvrir un chemin avec `glob`,
+Tu es un agent de lecture ciblée pour Lardon3D.
-`grep`, `rg` ou `git grep`, mais jamais inventorier aveuglément tout le dépôt.
+
-Ne modifie rien, ne lance aucun test et ne crée aucun sous-agent. Retourne au
+Tu ne modifies jamais aucun fichier.
-maximum 25 lignes : contrats, dépendances directes, risques et informations
+
-manquantes. Aucun transcript ni long extrait.
+Tu reçois obligatoirement :
+
+- un ou plusieurs chemins précis ;
+- éventuellement des plages de lignes ;
+- éventuellement des symboles précis.
+
+Tu ne dois jamais :
+
+- lancer `pwd` ;
+- lancer `ls` ;
+- utiliser `find` ;
+- faire un glob global ;
+- parcourir tout le dépôt ;
+- lire toute la documentation ;
+- élargir toi-même le périmètre.
+
+Lis uniquement les fichiers explicitement demandés.
+
+Retourne au parent un résumé très court contenant uniquement :
+
+- symboles pertinents ;
+- comportement observé ;
+- dépendances directes ;
+- invariants importants ;
+- risques éventuels ;
+- information manquante éventuelle.
+
+Maximum 20 lignes.
+
+Ne propose aucune nouvelle fonctionnalité.
+Ne propose aucun refactoring.
+Ne lance aucun test.
+Ne lance aucun build.
+Ne crée aucun sous-agent.

.opencode/agents/lardon-review.md

@@ -1,81 +1,54 @@
 ---
-description: Effectue la seconde revue de production après tests verts
+description: Revue indépendante C17 des diffs, API et durées de vie
 mode: subagent
-model: opencode-go/qwen3.8-max
+model: opencode/deepseek-v4-flash-free
-temperature: 0.0
+temperature: 0.1
-maxSteps: 20
 permission:
   read: allow
-  glob: allow
+  glob: deny
-  grep: allow
+  grep: deny
   edit: deny
-  bash:
+  bash: deny
-    "*": deny
-    "rg *": allow
-    "git diff*": allow
-    "git status*": allow
   task: deny
 ---
 
-Relis uniquement le diff de production déjà validé.
+Tu n'es pas un agent d'exploration.
 
-Cherche :
+Tu dois travailler uniquement à partir du contexte transmis par le parent.
 
-- erreurs de logique ;
+N'utilise aucun outil Read.
-- overflows ;
+N'utilise aucun outil Glob.
-- ownership/lifetime ;
+N'utilise aucun outil Grep.
-- chemins d'erreur et rollback ;
+N'ouvre aucun fichier.
-- bornes ;
+Ne cherche aucun chemin.
-- persistance ;
-- incompatibilités API ;
-- violations d'AGENTS.md.
 
-Si le diff touche à la concurrence, identifie les zones concernées mais laisse
+Si une information indispensable manque, retourne uniquement :
-l'analyse approfondie à `lardon-concurrency`.
 
-Ne modifie rien.
+INFORMATION_MISSING:
-Ne relance aucun test.
-Ne refais aucun audit du dépôt.
 
-Retourne uniquement :
+- chemin ou symbole nécessaire ;
+- raison précise.
 
-- BLOQUANTS ;
+Puis termine immédiatement.
-- IMPORTANTS ;
-- LIMITES ;
-- fichiers/lignes concernés ;
-- verdict PASS/NEEDS_FIX.
 
-<!-- LARDON-REVIEW-BUDGET:START -->
+Le parent utilisera `lardon-read` ou `lardon-explore` pour obtenir l'information
+manquante et pourra te relancer avec le contexte complété.
 
-## Budget de review
+Relis le diff sans le modifier. Vérifie C17, erreurs, nettoyage, overflows,
+contrats d'API, ownership et conformité à AGENTS.md. Distingue bloquants,
+importants et limites. Ne répète pas les tests réussis et rends un rapport court.
+Ne relis jamais une implémentation produite par lardon-build-backup, qui utilise
+aussi Nemotron. Dans ce cas, signale au parent qu'une première revue locale
+simple doit être confiée à MiMo et que toute revue de concurrence sensible doit
+attendre Codex ; ne prétends pas fournir une revue indépendante.
 
-La review est une inspection indépendante, pas une nouvelle phase
+Lecture contrôlée
-d'implémentation.
 
-Concentre-toi sur :
+Tu peux utiliser Read uniquement sur les chemins explicitement fournis par le parent
+ou déjà présents dans le handoff.
 
-- le diff ;
+N utilise jamais Glob.
-- les fichiers réellement modifiés ;
+N utilise jamais Grep pour découvrir des fichiers.
-- les invariants concernés ;
+Ne cherche jamais toi-même de nouveaux chemins.
-- les régressions possibles ;
-- la cohérence entre tests et comportement réel.
 
-Ne refais pas tout le diagnostic du ticket.
+Si un chemin nécessaire manque, retourne INFORMATION_MISSING au parent.
-
-Ne relis pas l'ensemble du dépôt.
-
-Ne lance pas une investigation ouverte.
-
-Si tu trouves une anomalie :
-
-- décris-la précisément ;
-- donne sa sévérité ;
-- indique les fichiers/fonctions concernés ;
-- recommande le routage approprié ;
-- rends immédiatement la main.
-
-Tu ne modifies aucun fichier.
-
-Une review sans anomalie doit se terminer rapidement par PASS.
-
-<!-- LARDON-REVIEW-BUDGET:END -->

.opencode/agents/lardon-tests.md

@@ -1,217 +1,23 @@
 ---
-description: Exécute les validations Lardon3D strictement séquencées
+description: Exécute les validations Lardon3D sans modifier le code
 mode: subagent
-model: opencode-go/deepseek-v4-pro
+model: google/gemini-3.5-flash-lite
-temperature: 0.0
+temperature: 0.1
-maxSteps: 80
 permission:
-  read: allow
-  glob: allow
-  grep: allow
   edit: deny
   bash:
     "*": deny
-    "CCACHE_DISABLE=1 CC=clang meson setup *": allow
     "CC=clang meson setup *": allow
+    "meson setup *": allow
     "meson compile *": allow
     "meson test *": allow
     "ninja *": allow
-    "git diff --check*": allow
+    "git diff*": allow
     "git status*": allow
   task: deny
 ---
 
-N'exécute jamais deux validations lourdes en parallèle. Ordre : test ciblé,
+Exécute les commandes demandées et rapporte leurs sorties réelles. Utilise le
-build normal, tests normaux, ASan/UBSan, TSan, stress. Un timeout n'est jamais
+build normal, ASan/UBSan et TSan selon le risque. Ne modifie jamais le code : si
-PASS : isole le test et rapporte la cause ou l'investigation requise. Pour un
+une correction est nécessaire, renvoie-la au seul agent implémenteur. Pour les
-succès, retourne commande, statut, durée et résumé. Pour un échec, retourne
+succès, rapporte seulement commande, statut et synthèse.
-seulement l'erreur ciblée et le log utile, jamais la sortie complète.
-
-<!-- LARDON-TESTS-STRICT-ROLE:START -->
-
-## Responsabilité stricte : validation indépendante
-
-Tu es l'agent de validation indépendante de Lardon3D.
-
-Ton rôle est de **VALIDER**, pas de diagnostiquer en profondeur,
-pas d'implémenter et pas de corriger.
-
-Le fait que tu sois techniquement capable de comprendre ou corriger un bug
-ne change pas ta responsabilité.
-
-### Tu dois
-
-Selon la validation demandée par l'orchestrateur :
-
-- compiler ;
-- exécuter les tests ciblés ;
-- exécuter les suites pertinentes ;
-- exécuter ASan/UBSan si demandé ou pertinent ;
-- exécuter TSan uniquement si la tranche concerne la concurrence ;
-- effectuer les répétitions ou stress tests demandés ;
-- exécuter `git diff --check` ;
-- relever les erreurs exactes ;
-- identifier le test, l'assertion ou la commande qui échoue ;
-- rendre un rapport condensé à l'orchestrateur.
-
-Tu peux effectuer une lecture courte du code uniquement pour comprendre
-où se situe précisément l'échec observé.
-
-Cette lecture ne doit pas devenir une investigation de cause racine.
-
-### Tu ne dois pas
-
-- modifier un fichier source ;
-- modifier un test ;
-- modifier Meson ;
-- appliquer une correction ;
-- entreprendre un refactor ;
-- transformer une panne de test en session de développement ;
-- refaire le travail de `lardon-diagnose` ;
-- refaire le travail de `lardon-build` ;
-- poursuivre une enquête longue après avoir suffisamment borné le symptôme.
-
-Un test en échec ne te donne jamais automatiquement le rôle de diagnosticien
-ou de développeur.
-
-### Lorsqu'un test échoue
-
-Collecte uniquement les informations nécessaires pour produire un problème
-borné :
-
-- commande exécutée ;
-- test concerné ;
-- assertion ou étape concernée ;
-- résultat attendu ;
-- résultat observé ;
-- code de retour ;
-- signal éventuel ;
-- errno ou message d'erreur s'il est disponible ;
-- fichier / fonction directement concernés si facilement localisables ;
-- caractère reproductible ou non de l'échec.
-
-Puis rends la main.
-
-Ne cherche pas toi-même la cause racine si elle n'est pas immédiatement
-évidente et déjà démontrée.
-
-Le routage appartient à l'orchestrateur :
-
-    cause inconnue
-        ↓
-    lardon-diagnose
-
-    cause déjà confirmée
-    + correction substantielle
-        ↓
-    lardon-build
-
-    micro-correction déjà démontrée
-    et autorisée
-        ↓
-    lardon-orchestrator
-
-### Séparation avec lardon-diagnose
-
-`lardon-diagnose` répond à :
-
-    POURQUOI cela échoue-t-il ?
-
-`lardon-tests` répond à :
-
-    QU'EST-CE QUI échoue exactement,
-    avec quel résultat,
-    et dans quelles conditions ?
-
-Ne mélange jamais les deux responsabilités.
-
-### Séparation avec lardon-build
-
-`lardon-build` modifie le code.
-
-`lardon-tests` vérifie indépendamment le résultat.
-
-Même si les deux agents utilisent DeepSeek V4 Flash Free,
-leurs contextes et leurs responsabilités doivent rester séparés.
-
-Ne poursuis jamais directement :
-
-    test en échec
-        ↓
-    diagnostic
-        ↓
-    correction
-        ↓
-    nouveau test
-
-dans une seule invocation de `lardon-tests`.
-
-Le chemin correct est :
-
-    lardon-tests
-        ↓
-    rapport d'échec condensé
-        ↓
-    lardon-orchestrator
-        ↓
-    lardon-diagnose si nécessaire
-        ↓
-    lardon-orchestrator
-        ↓
-    lardon-build si nécessaire
-        ↓
-    lardon-tests pour revalidation indépendante
-
-### Tests ciblés et validation complète
-
-Lorsque l'orchestrateur demande un test ciblé :
-
-- exécute uniquement le périmètre demandé ;
-- ne lance pas spontanément toute la matrice de validation.
-
-Lorsque l'orchestrateur demande la validation finale :
-
-- élargis progressivement la validation selon le code réellement touché ;
-- évite les sanitizers et stress tests sans rapport avec la tranche ;
-- rapporte séparément chaque niveau de validation.
-
-### Rapport obligatoire
-
-Termine par un rapport compact sous cette forme :
-
-# Test result
-
-## Validation exécutée
-- ...
-
-## Résultats
-- ...
-
-## Échecs
-- aucun
-
-ou, en cas d'échec :
-
-- test :
-- commande :
-- attendu :
-- observé :
-- localisation :
-- reproductible :
-
-## Sanitizers
-- ...
-
-## git diff --check
-- ...
-
-## Routage recommandé
-ORCHESTRATEUR
-
-## Statut
-PASS / FAIL / BLOCKED
-
-En cas de `FAIL`, ne propose pas une correction spéculative.
-Retourne le symptôme borné à l'orchestrateur.
-
-<!-- LARDON-TESTS-STRICT-ROLE:END -->

.opencode/bin/opencode-away

@@ -1,124 +0,0 @@
-#!/usr/bin/env bash
-set -u
-
-usage() {
-  printf '%s\n' 'usage: opencode-away [--check] [opencode arguments...]'
-}
-
-require_command() {
-  command -v "$1" >/dev/null 2>&1 || {
-    printf 'opencode-away: required command not found: %s\n' "$1" >&2
-    return 1
-  }
-}
-
-if [[ ${1-} == --help ]]; then
-  usage
-  exit 0
-fi
-
-check_only=0
-if [[ ${1-} == --check ]]; then
-  check_only=1
-  shift
-fi
-
-require_command opencode || exit 127
-require_command systemd-inhibit || exit 127
-require_command git || exit 127
-require_command ps || exit 127
-require_command kill || exit 127
-
-if [[ $(systemd-inhibit --help 2>&1) != *handle-lid-switch* ]]; then
-  printf '%s\n' 'opencode-away: systemd-inhibit lacks handle-lid-switch' >&2
-  exit 3
-fi
-
-if ! git rev-parse --show-toplevel >/dev/null 2>&1; then
-  printf '%s\n' 'opencode-away: run this command inside a Git worktree' >&2
-  exit 2
-fi
-
-if ((check_only)); then
-  printf '%s\n' 'OpenCode away mode check: OK'
-  printf 'repository: %s\n' "$(git rev-parse --show-toplevel)"
-  printf 'opencode: %s\n' "$(command -v opencode)"
-  printf 'systemd-inhibit: %s\n' "$(command -v systemd-inhibit)"
-  exit 0
-fi
-
-declare -a suspended_pids=()
-cleanup_done=0
-child_pid=0
-
-restore_swayidle() {
-  local pid
-  ((cleanup_done)) && return 0
-  cleanup_done=1
-  for pid in "${suspended_pids[@]}"; do
-    if kill -0 "$pid" 2>/dev/null &&
-       [[ $(ps -o comm= -p "$pid" 2>/dev/null) == swayidle ]]; then
-      kill -CONT "$pid" 2>/dev/null || true
-    fi
-  done
-  if ((${#suspended_pids[@]})); then
-    printf '%s\n' 'swayidle restored'
-  fi
-}
-
-on_signal() {
-  local signal=$1
-  if ((child_pid > 0)) && kill -0 "$child_pid" 2>/dev/null; then
-    kill -s "$signal" "$child_pid" 2>/dev/null || true
-    wait "$child_pid" 2>/dev/null || true
-  fi
-  restore_swayidle
-  trap - "$signal"
-  kill -s "$signal" "$$"
-}
-
-trap restore_swayidle EXIT
-trap 'on_signal HUP' HUP
-trap 'on_signal INT' INT
-trap 'on_signal TERM' TERM
-
-while read -r pid state; do
-  [[ $pid =~ ^[0-9]+$ ]] || continue
-  [[ $state == T* ]] && continue
-  if kill -STOP "$pid" 2>/dev/null; then
-    suspended_pids+=("$pid")
-  fi
-done < <(ps -C swayidle -o pid=,stat= 2>/dev/null)
-
-printf '%s\n' 'OpenCode away mode'
-printf '%s\n' 'sleep inhibited'
-printf '%s\n' 'lid switch inhibited'
-if ((${#suspended_pids[@]})); then
-  printf 'swayidle suspended:'
-  printf ' %s' "${suspended_pids[@]}"
-  printf '\n'
-else
-  printf '%s\n' 'swayidle suspended: none active'
-fi
-
-export LARDON_OPENCODE_LONG_RUN=1
-
-if [[ -n ${OPENCODE_AWAY_COMMAND-} ]]; then
-  child_command=(bash -c "$OPENCODE_AWAY_COMMAND")
-else
-  child_command=(opencode --auto "$@")
-fi
-
-systemd-inhibit \
-  --what=sleep:idle:handle-lid-switch \
-  --who='OpenCode Long Run' \
-  --why='Autonomous Lardon3D development ticket' \
-  --mode=block \
-  "${child_command[@]}" &
-child_pid=$!
-wait "$child_pid"
-child_status=$?
-child_pid=0
-
-restore_swayidle
-exit "$child_status"

.opencode/commands/lardon-resume-backup.md

@@ -0,0 +1,104 @@
+---
+description: Reprendre rapidement un ticket avec Nemotron à partir du handoff
+agent: lardon-orchestrator
+subtask: false
+---
+
+Reprends le ticket suivant :
+
+$ARGUMENTS
+
+Le contexte permanent de Lardon3D est déjà chargé via
+`.opencode/context.md`.
+
+Commence toujours par :
+
+1. lire `.opencode/work/current_ticket.md` ;
+2. lire le diff courant.
+
+Ne recharge jamais :
+
+- AGENTS.md ;
+- l'overview ;
+- la documentation générale ;
+- les documents d'architecture.
+
+Ne relance jamais `lardon-explore` ou `lardon-architect` si le handoff contient
+déjà :
+
+- l'objectif ;
+- les contraintes ;
+- les fichiers concernés ;
+- les invariants ;
+- les validations réalisées ;
+- le travail restant.
+
+Ne lance une exploration supplémentaire que si une information indispensable est
+absente.
+
+Transmets à `lardon-build-backup` uniquement :
+
+- l'objectif ;
+- les contraintes ;
+- les fichiers concernés ;
+- les API concernées ;
+- les invariants ;
+- le travail restant ;
+- la prochaine action sûre.
+
+Ne renvoie jamais tout le handoff au modèle d'implémentation.
+
+Après l'implémentation :
+
+1. appeler `lardon-tests` une seule fois ;
+2. utiliser `lardon-build-light` uniquement pour une première revue locale
+   simple ;
+3. mettre à jour le handoff.
+
+Ne pas appeler :
+
+- `lardon-review` ;
+- `lardon-concurrency` ;
+
+car ils utilisent le même modèle que l'implémentation de secours.
+
+Si le ticket touche notamment :
+
+- pthread ;
+- mutex ;
+- condition variables ;
+- scheduler ;
+- task_queue ;
+- resource_governor ;
+- réservations ;
+- synchronisation ;
+
+signaler explicitement :
+
+- qu'aucune revue indépendante forte n'a été réalisée ;
+- que la revue de concurrence est différée au prochain passage Codex.
+
+Le handoff doit rester court et contenir uniquement :
+
+- objectif ;
+- contraintes ;
+- fichiers concernés ;
+- travail effectué ;
+- validations exécutées ;
+- erreurs rencontrées ;
+- limites restantes ;
+- prochaine action sûre.
+
+Règles :
+
+- un seul agent écrit les sources ;
+- aucun sous-agent imbriqué ;
+- aucun modèle payant ;
+- aucun commit ;
+- aucun push ;
+- aucune modification de `scan3d/`.
+
+Objectif principal :
+
+Reprendre un ticket en quelques secondes avec le plus petit contexte possible,
+sans refaire l'analyse déjà présente dans le handoff.

.opencode/commands/lardon-resume-light.md

@@ -0,0 +1,10 @@
+---
+description: Reprise limitée d'un petit ticket avec MiMo
+agent: lardon-orchestrator
+subtask: false
+---
+
+Lis le handoff, le diff et les fichiers cités, puis confie uniquement un petit
+travail local à lardon-build-light. Si le reste touche une fondation, une API ou
+un refactoring sensible, ne modifie rien : conserve le handoff et recommande
+DeepSeek, Nemotron ou Codex. Mets à jour la prochaine action sûre.

.opencode/commands/lardon-review.md

@@ -1,11 +1,16 @@
 ---
-description: Lancer la seconde revue après validations vertes
+description: Lancer une revue indépendante sans modification
 agent: lardon-orchestrator
 subtask: false
 ---
 
-Lis le ticket durable et le diff ciblé. Lance `lardon-review`, puis
+Sans modifier aucun fichier, identifie dans le handoff le modèle qui a
-`lardon-concurrency` uniquement si le ticket touche un état partagé, une durée
+implémenté le diff. Si c'est lardon-build-backup ou Nemotron, demande à
-de vie concurrente, le scheduler, les tâches ou le gouverneur. Lance ensuite
+lardon-build-light une première revue locale simple en lecture seule. N'appelle
-`lardon-docs` pour les contrats affectés. Agrège seulement les défauts, risques,
+ni lardon-review ni lardon-concurrency : signale explicitement l'absence de
-limites et prochaines corrections ; ne relance pas de build lourd en parallèle.
+revue indépendante forte et réserve toute revue de concurrence sensible au
+prochain passage Codex.
+
+Sinon, lance lardon-review. Ajoute lardon-concurrency uniquement si le diff
+touche pthread, task, task_queue ou resource_governor. Agrège seulement les
+défauts, risques et limites. Ne lance aucun autre agent.

.opencode/commands/lardon-save-handoff.md

@@ -1,9 +1,10 @@
 ---
-description: Sauvegarder un handoff complet sans modifier les sources
+description: Sauvegarder l'état courant du ticket sans modifier les sources
 agent: lardon-orchestrator
 subtask: false
 ---
 
-Actualise `current_ticket.md`, puis écris `.opencode/work/handoff.md` avec toutes
+Sans sous-agent ni modification des sources, inspecte `git status`, le diff et
-les rubriques du modèle. Utilise le statut et un diff ciblé, sans longs logs,
+le handoff existant. Mets `.opencode/work/current_ticket.md` à jour avec les
-secrets ou sources complètes. Termine exactement par `NEXT SESSION START HERE`.
+rubriques prescrites. Résume les commandes et erreurs ; ne copie ni sources,
+documentation, longs logs, secrets ou données utilisateur.

.opencode/commands/lardon-small.md

@@ -0,0 +1,75 @@
+---
+description: Traiter un petit ticket avec MiMo et des validations ciblées
+agent: lardon-orchestrator
+subtask: false
+---
+
+Traite le petit ticket suivant :
+
+$ARGUMENTS
+
+Le contexte permanent de Lardon3D est déjà chargé via `.opencode/context.md`.
+
+Ne relis AGENTS.md, l’overview ou la documentation générale que si une information
+précise manque.
+
+Ce workflow est réservé aux modifications locales, simples et clairement
+délimitées.
+
+N’effectue jamais :
+
+- d’inventaire global du dépôt ;
+- de `glob "*"` ;
+- de `find` sur tout le dépôt ;
+- de lecture complète de la documentation ;
+- de refactoring d’architecture non demandé.
+
+Procédure :
+
+1. Lire `.opencode/work/current_ticket.md` s’il existe et s’il concerne ce ticket.
+2. Utiliser `lardon-explore` avec une recherche strictement ciblée.
+3. Identifier uniquement :
+   - les fichiers à modifier ;
+   - les dépendances directes ;
+   - les tests concernés ;
+   - les éventuels documents à mettre à jour.
+4. Vérifier que le ticket convient au mode léger.
+5. Utiliser un seul `lardon-build-light` pour l’implémentation.
+6. Appeler `lardon-tests` une seule fois après l’implémentation pour :
+   - compiler avec Clang ;
+   - exécuter les tests ciblés ;
+   - exécuter `git diff --check`.
+7. Demander une revue uniquement si le diff le justifie réellement.
+8. Mettre à jour le handoff avec un résumé concis.
+
+N’appelle pas `lardon-architect`, `lardon-concurrency` ou `lardon-docs` sauf si
+leur intervention est manifestement nécessaire.
+
+Arrête le workflow léger et recommande `/lardon-ticket` ou Codex si le ticket
+touche notamment :
+
+- une API publique structurante ;
+- `task`, `task_queue` ou `resource_governor` ;
+- pthread, mutex ou condition variables ;
+- la durée de vie complexe de ressources ;
+- la persistance ou le rollback ;
+- le scheduler, un futur DAG ou les réservations ;
+- un refactoring réparti sur plusieurs modules ;
+- une fondation sensible du projet.
+
+Dans ce cas, ne tente aucune modification risquée avec MiMo.
+
+Le handoff doit rester court et contenir seulement :
+
+- objectif ;
+- fichiers concernés ;
+- travail effectué ;
+- validations ;
+- erreurs ;
+- limites ;
+- prochaine action sûre.
+
+Ne fais aucun commit.
+Ne fais aucun push.
+N’utilise aucun modèle payant.
+Ne modifie jamais `scan3d/`.

.opencode/commands/lardon-ticket-backup.md

@@ -0,0 +1,102 @@
+---
+description: Reprendre un ticket après indisponibilité de DeepSeek
+agent: lardon-orchestrator
+subtask: false
+---
+
+Reprends le ticket suivant :
+
+$ARGUMENTS
+
+Le contexte permanent de Lardon3D est déjà chargé via
+`.opencode/context.md`.
+
+Commence toujours par :
+
+1. lire `.opencode/work/current_ticket.md` ;
+2. lire le diff courant.
+
+Si ces deux éléments décrivent correctement le ticket, ne relis pas :
+
+- AGENTS.md ;
+- l'overview ;
+- la documentation générale ;
+- les documents d'architecture.
+
+Ne relance pas `lardon-explore` si le handoff contient déjà :
+
+- l'objectif ;
+- les contraintes ;
+- les fichiers concernés ;
+- les invariants ;
+- le travail restant.
+
+Relance `lardon-explore` uniquement lorsqu'une information indispensable est
+absente.
+
+Transmets à `lardon-build-backup` uniquement :
+
+- l'objectif ;
+- les contraintes ;
+- les fichiers concernés ;
+- les API concernées ;
+- les invariants ;
+- le travail restant ;
+- la prochaine action sûre.
+
+Ne renvoie jamais tout le handoff au modèle d'implémentation.
+
+Après l'implémentation :
+
+1. appeler `lardon-tests` une seule fois ;
+2. utiliser `lardon-build-light` uniquement pour une première revue locale
+   simple ;
+3. mettre à jour le handoff.
+
+Ne pas appeler :
+
+- `lardon-review` ;
+- `lardon-concurrency` ;
+
+car ils utilisent le même modèle que l'implémentation de secours.
+
+Si le ticket touche notamment :
+
+- pthread ;
+- mutex ;
+- condition variables ;
+- scheduler ;
+- task_queue ;
+- resource_governor ;
+- réservations ;
+- synchronisation ;
+
+signaler explicitement :
+
+- qu'aucune revue indépendante forte n'a été réalisée ;
+- que la revue de concurrence est différée au prochain passage Codex.
+
+Le handoff doit rester court et contenir uniquement :
+
+- objectif ;
+- contraintes ;
+- fichiers concernés ;
+- travail effectué ;
+- validations exécutées ;
+- erreurs rencontrées ;
+- limites restantes ;
+- prochaine action sûre.
+
+Règles :
+
+- un seul agent écrit les sources ;
+- aucun sous-agent imbriqué ;
+- aucun modèle payant ;
+- aucun commit ;
+- aucun push ;
+- aucune modification de `scan3d/`.
+
+Objectif principal :
+
+Reprendre un ticket en quelques secondes, avec le plus petit contexte possible,
+sans refaire les analyses déjà présentes dans le handoff.

.opencode/commands/lardon-ticket.md

@@ -1,16 +1,83 @@
 ---
-description: Traiter un ticket complet par phases durables
+description: Traiter un ticket complet avec contexte progressif et handoff
 agent: lardon-orchestrator
 subtask: false
 ---
 
-Traite ce ticket en mode long run par phases :
+Traite le ticket suivant :
 
 $ARGUMENTS
 
-Initialise `current_ticket.md`, audite uniquement le périmètre utile, puis
+Le contexte permanent de Lardon3D est déjà chargé via
-enchaîne architecture, tranches d'implémentation et tests ciblés. Une seule
+`.opencode/context.md`.
-écriture et une seule validation lourde à la fois. Après le vert complet,
+
-impose review, concurrency si concernée, docs, corrections et revalidation.
+Considère également AGENTS.md et le handoff courant comme déjà disponibles.
-Mets à jour la mémoire durable après chaque phase et prépare `handoff.md` avant
+Ne les relis que lorsqu'une information précise manque.
-toute fin de contexte. Aucun commit, push ou changement de `scan3d/`.
+
+N'effectue jamais :
+
+- d'inventaire global du dépôt ;
+- de `glob "*"` ;
+- de `find` sur tout le dépôt ;
+- de lecture complète de toute la documentation.
+
+Procédure :
+
+1. Initialiser `.opencode/work/current_ticket.md` avec les rubriques prescrites.
+2. Utiliser `lardon-explore` avec une recherche strictement ciblée.
+3. Identifier uniquement :
+   - les fichiers à modifier ;
+   - les dépendances directes ;
+   - les tests concernés ;
+   - les documents réellement utiles.
+4. Charger uniquement ce contexte.
+5. Appeler `lardon-architect` uniquement si une évolution d'architecture est
+   réellement nécessaire.
+6. Transmettre à `lardon-build` un résumé concis contenant :
+   - objectif ;
+   - contraintes ;
+   - API concernées ;
+   - invariants ;
+   - fichiers ;
+   - validations attendues.
+7. Après l'implémentation :
+   - appeler `lardon-tests` une seule fois ;
+   - appeler `lardon-review` une seule fois ;
+   - appeler `lardon-concurrency` uniquement si le ticket touche :
+     - pthread ;
+     - mutex ;
+     - condition variables ;
+     - scheduler ;
+     - task_queue ;
+     - resource_governor ;
+     - code concurrent.
+8. Mettre à jour le handoff après chaque phase importante.
+
+Le handoff doit rester court et contenir uniquement :
+
+- objectif ;
+- contraintes ;
+- fichiers concernés ;
+- travail effectué ;
+- validations exécutées ;
+- erreurs rencontrées ;
+- limites restantes ;
+- prochaine action sûre.
+
+Règles :
+
+- un seul agent écrit les sources ;
+- aucun sous-agent imbriqué ;
+- aucun agent inutile ;
+- aucun modèle payant ;
+- aucun commit ;
+- aucun push ;
+- aucune modification de `scan3d/`.
+
+Privilégier systématiquement :
+
+- le plus petit contexte possible ;
+- le moins d'agents possible ;
+- une seule compilation complète ;
+- une seule revue ;
+- une seule analyse de concurrence lorsque nécessaire.

.opencode/context.md

@@ -1,54 +1,341 @@
-# Lardon3D — contexte OpenCode durable
+# Lardon3D – Persistent Context
 
-Lardon3D est un moteur de photogrammétrie C17, Clang/Meson, persistant et
+## Project
-reprenable. La stabilité du système, les ressources bornées, les publications
-atomiques et la réactivité de la TUI priment sur le débit.
 
-## Invariants
+Lardon3D est un moteur de photogrammétrie Linux écrit en C17.
 
-- ncurses appartient au thread principal ; le layout ne modifie aucun état.
+Objectifs principaux :
-- Le Resource Governor décide des ressources ; le scheduler applique son
-  contrat sans le réinterpréter.
-- Aucun callback sans estimation immuable et réservation active.
-- Une seule écriture de production et une seule validation lourde à la fois.
-- Aucun commit, push, nettoyage massif ou modification de `scan3d/`.
-- Préserver tout changement existant hors ticket.
 
-## Long run
+- stabilité absolue ;
+- faible consommation mémoire ;
+- traitement par lots adaptatifs ;
+- aucune saturation du système ;
+- TUI toujours réactive ;
+- architecture modulaire.
 
-`ocaway` exporte `LARDON_OPENCODE_LONG_RUN=1` et lance OpenCode avec
+Le viewer Vulkan sera un processus séparé lisant uniquement des snapshots validés.
-auto-approbation des opérations non explicitement interdites. Les interdictions
-configurées restent absolues.
 
-Le ticket courant vit dans `.opencode/work/current_ticket.md`. Chaque phase
+---
-majeure actualise décisions, fichiers, tests, échecs et travail restant. Une
-session qui approche de sa limite crée aussi `.opencode/work/handoff.md` et
-termine par `NEXT SESSION START HERE`.
 
-## Validation
+## Build
 
-Ordre obligatoire : test ciblé, build normal, tests normaux, ASan/UBSan si
+Compiler avec :
-pertinent, TSan si pertinent, stress, seconde revue, concurrence si concernée,
-documentation, corrections, revalidation ciblée. Un timeout est un échec à
-investiguer, jamais un PASS.
 
-La machine cible possède 16 CPU logiques et 14 GiB de RAM ; `-j8` est la limite
+CC=clang meson setup build --wipe
-normale. Ne jamais lancer normal, ASan et TSan en parallèle.
+meson compile -C build -j8
 
-## Sorties et contexte
+Validation minimale :
 
-Filtrer les sorties volumineuses. Les sous-agents rendent seulement statut,
+meson test -C build --print-errorlogs
-conclusions, risques, fichiers, erreur ciblée et prochaine action. Ne pas copier
+git diff --check
-de longs logs, sources ou diffs dans la conversation ou le handoff.
 
-## Modèles
+Utiliser ASan/UBSan et TSan uniquement lorsque le ticket touche la mémoire ou la concurrence.
 
-- Orchestration, lecture, tests, documentation et fallback :
+---
-  `opencode/mimo-v2.5-free`.
-- Architecture, implémentation, concurrence et revue :
-  `opencode/deepseek-v4-flash-free`.
 
-Ces identifiants sont présents dans le catalogue OpenCode 1.18.15 de la machine.
+## Git
-Après deux erreurs identiques du build DeepSeek, utiliser une seule fois le
+
-fallback MiMo à partir du handoff. Après un troisième échec identique, consigner
+Interdictions :
-le blocage ; ne jamais sélectionner implicitement un modèle payant ou inconnu.
+
+- jamais git add -A
+- jamais git commit
+- jamais git push
+- jamais modifier scan3d/
+- jamais modifier tri_photos.py
+
+Toujours fournir :
+
+- liste exacte des fichiers du ticket
+- validations exécutées
+- limites restantes
+- message de commit recommandé
+
+---
+
+## Architecture
+
+Séparation stricte :
+
+TUI
+↓
+
+Scheduler
+
+↓
+
+Governor
+
+↓
+
+Workers
+
+↓
+
+Résultats atomiques
+
+Le thread ncurses ne fait jamais de travail métier.
+
+Le scheduler ne décide jamais des ressources.
+
+Le gouverneur est le seul propriétaire des budgets.
+
+---
+
+## Resource Governor
+
+Estimate
+
+↓
+
+Reservation
+
+↓
+
+Scheduler
+
+↓
+
+Worker
+
+Les réservations sont obligatoires avant toute exécution.
+
+RAM iGPU partagée = RAM système.
+
+La zram n'est jamais un budget de travail.
+
+---
+
+## Coding rules
+
+C17 uniquement.
+
+Pas de variables globales d'état.
+
+Pas de system().
+
+Pas de popen().
+
+Pas d'allocation infinie.
+
+Toujours des buffers bornés.
+
+Sorties atomiques.
+
+Rollback complet en cas d'échec.
+
+---
+
+## Current architecture
+
+Modules disponibles :
+
+- project
+- import
+- import_task
+- image_catalog
+- image_view
+- task
+- task_queue
+- hardware_profile
+- resource_snapshot
+- resource_governor
+
+---
+
+## Active workflow
+
+1. explorer uniquement les fichiers utiles
+
+2. architect uniquement si nécessaire
+
+3. un seul agent d'écriture
+
+4. tests
+
+5. revue
+
+6. handoff
+
+Ne jamais relire tout le dépôt.
+
+Ne jamais faire de glob "*".
+
+Ne jamais parcourir tous les fichiers.
+
+---
+
+## Models
+
+Primary orchestration
+
+MiMo V2.5 Free
+
+Implementation
+
+DeepSeek V4 Flash Free
+
+Backup implementation
+
+Nemotron 3 Ultra Free
+
+Exploration
+
+North Mini Code Free
+
+Architecture / Review / Concurrency
+
+Nemotron 3 Ultra Free
+
+Documentation
+
+Ling 3.0 Flash Free
+
+Aucun modèle payant.
+
+---
+
+## If DeepSeek fails
+
+Reprendre depuis :
+
+.opencode/work/current_ticket.md
+
+Ne jamais refaire :
+
+- exploration
+- architecture
+- revue
+
+si le handoff contient déjà ces informations.
+
+---
+
+## Project roadmap
+
+Fondations terminées :
+
+- TUI modulaire
+- projets persistants
+- import asynchrone
+- catalogue d'images
+- image_view
+- moteur de tâches
+- scheduler FIFO
+- gouverneur de ressources
+- réservations
+- intégration scheduler ↔ governor
+- sélection de la première tâche admissible
+- documentation d'architecture
+
+Ordre obligatoire des prochains tickets :
+
+1. séquences de traitement adaptatives pilotées par le Resource Governor
+2. contre-pression (backpressure) et bornage des files
+3. checkpoints et persistance des tâches
+4. DAG minimal de dépendances
+5. priorités
+6. pools CPU / GPU / IO
+7. migration de l'import vers le scheduler générique
+8. publication incrémentale
+9. viewer Vulkan
+
+Ne jamais proposer un ticket déjà terminé.
+
+Ne jamais sauter une étape de cette feuille de route sans justification explicite.
+
+---
+
+## Mission
+
+Toujours privilégier :
+
+- stabilité
+- simplicité
+- déterminisme
+- faible mémoire
+- traitements séquencés
+- protection du système
+
+avant les performances brutes.
+
+État actuel important :
+
+- Le scheduler sait déjà sauter une tâche en WAIT en tête de file.
+- Il sélectionne la première tâche admissible dans l’ordre FIFO.
+- Ce ticket est terminé et ne doit pas être reproposé.
+
+---
+
+## Revue de concurrence obligatoire
+
+Tout ticket touchant `task`, `task_queue`, le scheduler,
+`resource_governor`, pthread, mutex, variables de condition, pause, reprise,
+annulation, réservations ou états partagés exige `lardon-concurrency`.
+
+Cette règle s’applique même si aucun nouveau thread n’est créé.
+
+---
+
+## Design philosophy
+
+Chaque étape du pipeline doit être :
+
+- indépendante ;
+- interruptible ;
+- reprenable ;
+- observable ;
+- testable ;
+- déterministe.
+
+Chaque tâche doit pouvoir être découpée en petits lots afin de :
+
+- limiter l'utilisation mémoire ;
+- garder une TUI fluide ;
+- permettre une adaptation dynamique des ressources ;
+- éviter toute saturation du système.
+
+La stabilité du système hôte est prioritaire sur les performances brutes.
+
+---
+
+## Long-term objective
+
+Lardon3D doit devenir un moteur de photogrammétrie entièrement piloté par un
+scheduler adaptatif.
+
+Le scheduler décide uniquement :
+
+- quand lancer une étape ;
+- avec quel lot ;
+- dans quel ordre.
+
+Le Resource Governor décide uniquement :
+
+- si les ressources permettent l'exécution ;
+- la taille optimale des lots ;
+- quand différer une tâche.
+
+Le viewer Vulkan ne participe jamais aux calculs.
+
+Il affiche uniquement des snapshots validés produits par le pipeline.
+
+L'utilisateur doit voir le résultat apparaître progressivement pendant les
+calculs, sans attendre la fin complète de la reconstruction.
+
+Toutes les étapes doivent pouvoir être interrompues puis reprises sans perdre
+les résultats déjà validés.
+
+---
+
+## Optimisation
+
+Privilégier toujours :
+
+- plusieurs petits traitements ;
+- plusieurs petites allocations ;
+- plusieurs petites copies ;
+
+plutôt qu'une grosse opération monolithique.
+
+Lardon3D doit être optimisé pour des machines disposant de peu de mémoire
+(16 à 32 Go) et d'un iGPU partagé.

.opencode/opencode.json

@@ -1,20 +1,7 @@
 {
   "$schema": "https://opencode.ai/config.json",
   "default_agent": "lardon-orchestrator",
-  "model": "opencode-go/mimo-v2.5-pro",
+  "model": "opencode/mimo-v2.5-free",
-  "small_model": "opencode-go/mimo-v2.5",
-  "provider": {
-    "groq": {
-      "models": {
-        "openai/gpt-oss-120b": {
-          "limit": {
-            "context": 131072,
-            "output": 4096
-          }
-        }
-      }
-    }
-  },
   "subagent_depth": 1,
   "instructions": [
     "AGENTS.md",
@@ -22,103 +9,31 @@
     "docs/architecture/overview.md"
   ],
   "permission": {
-    "*": "deny",
+    "*": "ask",
     "read": "allow",
     "glob": "allow",
     "grep": "allow",
-    "list": "allow",
     "lsp": "allow",
-    "question": "deny",
-    "todowrite": "allow",
-    "webfetch": "allow",
-    "websearch": "allow",
-    "skill": "allow",
-    "doom_loop": "deny",
     "external_directory": "deny",
     "edit": {
       "*": "allow",
-      ".git/**": "deny",
+      "scan3d/**": "deny",
-      "scan3d/**": "deny"
+      "scan3d/tri_photos.py": "deny"
     },
     "bash": {
-      "*": "deny",
+      "*": "ask",
       "git status*": "allow",
       "git diff*": "allow",
       "git log*": "allow",
-      "git show*": "allow",
-      "git grep*": "allow",
-      "git rev-parse*": "allow",
-      "git branch --show-current*": "allow",
-      "rg *": "allow",
-      "sed -n *": "allow",
-      "meson setup *": "allow",
-      "meson compile *": "allow",
-      "meson test *": "allow",
-      "CC=clang meson setup *": "allow",
-      "CCACHE_DISABLE=1 CC=clang meson setup *": "allow",
-      "CCACHE_DISABLE=1 meson compile *": "allow",
-      "CCACHE_DISABLE=1 meson test *": "allow",
-      "ninja *": "allow",
-      "mkdir build*": "allow",
-      "mkdir -p build*": "allow",
-      "mkdir -p .opencode/work*": "allow",
-      "./build*/test-*": "allow",
-      "./scripts/*": "allow",
-      "sudo *": "deny",
-      "* sudo *": "deny",
-      "su *": "deny",
-      "* su *": "deny",
-      "doas *": "deny",
-      "* doas *": "deny",
-      "pacman *": "deny",
-      "* pacman *": "deny",
-      "git add -A*": "deny",
-      "* git add -A*": "deny",
       "git commit*": "deny",
-      "* git commit*": "deny",
       "git push*": "deny",
-      "* git push*": "deny",
+      "git add -A*": "deny",
-      "git reset*": "deny",
-      "* git reset*": "deny",
       "git clean*": "deny",
-      "* git clean*": "deny",
+      "git reset*": "deny",
-      "git checkout*": "deny",
-      "* git checkout*": "deny",
-      "git restore*": "deny",
-      "* git restore*": "deny",
-      "git rebase*": "deny",
-      "* git rebase*": "deny",
-      "git merge*": "deny",
-      "* git merge*": "deny",
       "rm *": "deny",
-      "* rm *": "deny",
+      "sudo *": "deny"
-      "chmod *": "deny",
-      "* chmod *": "deny",
-      "chown *": "deny",
-      "* chown *": "deny",
-      "kill *": "deny",
-      "* kill *": "deny",
-      "pkill *": "deny",
-      "* pkill *": "deny",
-      "shutdown*": "deny",
-      "* shutdown*": "deny",
-      "reboot*": "deny",
-      "* reboot*": "deny",
-      "poweroff*": "deny",
-      "* poweroff*": "deny"
     }
   },
-  "tool_output": {
-    "max_lines": 400,
-    "max_bytes": 50000
-  },
-  "compaction": {
-    "auto": true,
-    "prune": true,
-    "tail_turns": 8,
-    "preserve_recent_tokens": 12000,
-    "reserved": 16000
-  },
   "watcher": {
     "ignore": [
       ".git/**",
@@ -127,6 +42,24 @@
       "scan3d/**"
     ]
   },
+  "provider": {
+    "kilo": {
+      "npm": "@ai-sdk/openai-compatible",
+      "name": "Kilo Gateway",
+      "options": {
+        "baseURL": "https://api.kilo.ai/api/gateway"
+      },
+      "models": {
+        "tencent/hy3:free": {
+          "name": "Hy3 Free",
+          "limit": {
+            "context": 262144,
+            "output": 128000
+          }
+        }
+      }
+    }
+  },
   "lsp": {
     "clangd": {
       "command": [

.opencode/zshrc.snippet

@@ -1,2 +0,0 @@
-# OpenCode long run (install after copying the wrapper to ~/.local/bin)
-alias ocaway="$HOME/.local/bin/opencode-away"

AGENTS.md

@@ -58,21 +58,6 @@ disponible. Ne jamais annoncer une vérification non exécutée.
 - Ne pas utiliser `system()` ni `popen()` dans le code de production.
 - Ne laisser aucun `TODO`, code mort ou dépendance inutile dans un ticket fini.
 - Préférer l'évolution minimale aux réécritures de modules validés.
-- Viser 100 colonnes et ne jamais dépasser 120 sans justification locale.
-- Mettre les appels complexes et le SQL sur plusieurs lignes lisibles.
-- Éviter le code-golf et garder des fonctions confortables à relire dans Neovim.
-- Commenter les invariants non évidents plutôt que paraphraser le code.
-
-## Long run OpenCode
-
-- `.opencode/work/current_ticket.md` est la mémoire durable du ticket et doit
-  être actualisé après chaque phase majeure.
-- Avant une compaction ou une fin de session incomplète, écrire
-  `.opencode/work/handoff.md` avec la prochaine action exacte.
-- Une seule validation lourde à la fois : normal, ASan/UBSan, TSan puis stress.
-- Un timeout doit être isolé et expliqué ; le répéter jusqu'au vert est interdit.
-- Après les tests verts, imposer revue, audit de concurrence si pertinent,
-  documentation, corrections et revalidation ciblée.
 
 ## État actuel
 

README.md

@@ -23,11 +23,11 @@ Lardon3D ne vise pas simplement "dossier de photos → objet 3D", mais "ensemble
 - **Project** : cycle de vie persistant, identité stable et Project Database ouverte
 - **Import** : premier task kind de production, exécuté par la file générique en lots bornés et reprenables
 - **ScanSet / Image Catalog v1** : acquisitions, images logiques, provenance et assets SHA-256 persistants et paginés
-- **Feature Store v1/v2** : ORB U8×32, SIFT/RootSIFT F32×128 et lecture typée bornée
+- **Feature Store v1** : extraction ORB réelle, assets binaires versionnés et lecture bornée
 - **Image View** : vues triées et filtrées pour la TUI
 - **Task** : moteur de tâches avec pause/reprise, annulation et séquences
 - **Task Checkpoint v1** : snapshot durable, fichier atomique et reprise sûre
-- **Project Database v7** : tâches, catalogue, Feature Store multi-type et support intra-image
+- **Project Database v6** : tâches, catalogue, Feature Store et Visual Index segmenté
 - **Task Kind Registry** : identité métier durable et reconstruction runtime explicite
 - **Recovery projet** : reprise automatique sélective et bornée des imports récupérables
 - **Task Queue** : file FIFO avec sélection adaptative et backpressure
@@ -105,7 +105,6 @@ Acquisitions
 - [Persistance](docs/architecture/persistence.md)
 - [Base de données projet](docs/architecture/project_database.md)
 - [Feature Store](docs/architecture/feature_store.md)
-- [Precision Feature Pipeline v1A](docs/architecture/precision_feature_pipeline.md)
 - [Visual Index](docs/architecture/visual_index.md)
 - [Viewer](docs/architecture/viewer.md)
 - [Revue des fondations](docs/architecture/foundation_review.md)
@@ -121,7 +120,6 @@ Acquisitions
 - [Build](docs/development/build.md)
 - [Tests](docs/development/testing.md)
 - [Concurrence](docs/development/concurrency.md)
-- [OpenCode long run](docs/development/opencode_long_run.md)
 
 ### Roadmap
 - [Roadmap](docs/roadmap/roadmap.md)
@@ -144,10 +142,7 @@ Pour les changements sensibles à la mémoire ou à la concurrence, ajouter ASan
 
 ## Statut
 
-Lardon3D est en développement actif. La persistance des tâches, le catalogue,
+Lardon3D est en développement actif. La phase de fondation est terminée. Les prochains tickets porteront sur la persistance, le DAG, les pools de workers et la publication live.
-le Feature Store multipasse et le Visual Index ORB sont implémentés. Candidate
-Pair Generator, matching, DAG générique, SfM et viewer restent des tickets
-séparés planifiés.
 
 ## Licence
 

docs/architecture/candidate_pair.md

@@ -1,371 +0,0 @@
-# Sous-système Candidate Pair
-
-## Vision
-
-Le sous-système Candidate Pair répond uniquement à la question :
-
-> « Quelles paires d'images valent la peine d'être présentées au Matcher ? »
-
-Il ne répond **PAS** à :
-
-> « Ces images ont-elle réellement des correspondances ? »
-
-et ne contient **aucune** validation géométrique.
-
-## Frontières
-
-```
-Visual Index
-    ↓
-Candidate Pair Generator
-    ↓
-Candidate Pair persistence
-    ↓
-Matcher — HORS SCOPE de ce ticket
-```
-
-Le Matcher est un consommateur des paires persistées. Il n'est pas
-implémenté dans ce sous-système.
-
-## Invariants fondamentaux
-
-| Invariant | Description |
-|-----------|-------------|
-| **Symétrie** | A,B == B,A |
-| **Ordre canonique** | Stockage avec `image_id_a < image_id_b` |
-| **Self-pairs interdits** | `image_id_a != image_id_b` (implicite via CHECK SQL) |
-| **Unicité persistante** | `UNIQUE(image_id_a, image_id_b)` |
-| **Résultat borné** | `top_k <= LARDON3D_VISUAL_INDEX_TOP_K_MAX = 256` par requête |
-| **Déterminisme** | Mêmes entrées/configuration → mêmes paires dans le même ordre |
-| **Idempotence** | Répétition sans duplication |
-| **Persistance durable** | Paires persistées dans Project DB v8 |
-
-## Modèle persistant
-
-### Table `candidate_pairs` (Project DB v8)
-
-```sql
-CREATE TABLE candidate_pairs(
-    candidate_pair_id INTEGER PRIMARY KEY AUTOINCREMENT CHECK(candidate_pair_id>0),
-    image_id_a INTEGER NOT NULL REFERENCES images(image_id),
-    image_id_b INTEGER NOT NULL REFERENCES images(image_id),
-    created_at INTEGER NOT NULL CHECK(created_at>=0),
-    CHECK(image_id_a < image_id_b),
-    UNIQUE(image_id_a, image_id_b)
-);
-CREATE INDEX candidate_pairs_image_a_idx ON candidate_pairs(image_id_a);
-CREATE INDEX candidate_pairs_image_b_idx ON candidate_pairs(image_id_b);
-```
-
-### API
-
-- `lardon3d_project_db_create_candidate_pair()` — INSERT avec canonicalisation
-- `lardon3d_project_db_load_candidate_pair()` — SELECT par ID
-- `lardon3d_project_db_find_candidate_pair()` — SELECT par (image_a, image_b)
-- `lardon3d_project_db_list_candidate_pairs()` — SELECT paginé ORDER BY id
-
-## Génération single-source
-
-### Prototype
-
-```c
-Lardon3DVisualIndexResult lardon3d_candidate_pair_generate(
-    const char *project_path, Lardon3DProjectDb *database,
-    uint64_t visual_index_id, uint64_t source_feature_set_id,
-    const Lardon3DVisualIndexQueryOptions *query_options,
-    Lardon3DCandidatePairGenStats *stats);
-```
-
-### Algorithme
-
-1. Charger le FeatureSet source
-2. Obtenir `source_image_id`
-3. Interroger le Visual Index avec `query_options`
-4. Pour chaque candidat retourné :
-   - Exclure les self-pairs
-   - Canonicaliser l'ordre (image_a < image_b)
-   - Chercher si la paire existe déjà (`find_candidate_pair`)
-   - Créer si absente (`create_candidate_pair`)
-5. Retourner les statistiques `{generated, skipped, queried}`
-
-### Statistiques
-
-```c
-typedef struct {
-  uint32_t generated_count;    // paires nouvellement créées
-  uint32_t skipped_count;      // paires déjà existantes (idempotence)
-  uint32_t queried_count;      // candidats retournés par le Visual Index
-} Lardon3DCandidatePairGenStats;
-```
-
-## Score et provenance
-
-Le score de retrieval et la provenance Visual Index ne sont **PAS**
-persistés dans la table `candidate_pairs` pour les raisons suivantes :
-
-- L'identité Candidate Pair est纯粹 géométrique : (image_a, image_b)
-- Le score dépend de la configuration du Visual Index et peut changer
-- Le Matcher calculera ses propres scores de matching
-- La séparation des responsabilités est plus nette
-
-Le score reste accessible via le Visual Index si nécessaire.
-
-## Déterminisme
-
-### Déterministe
-
-- Mêmes entrées → mêmes paires
-- Même ordre de sélection top-K
-- Mêmes décisions de déduplication
-
-### Non déterministe
-
-- `created_at` (timestamp Unix, informatif uniquement)
-- `candidate_pair_id` (AUTOINCREMENT, identifiant technique)
-
-### Tie-breaks
-
-En cas d'égalité de score dans le Visual Index, l'ordre est déterministe
-selon l'implémentation LSH (ordre des Feature Sets).
-
-## Invalidation
-
-### Événements et impact
-
-| Événement | Ce qui devient invalide | Ce qui reste réutilisable | Ce qui doit être recalculé |
-|-----------|------------------------|--------------------------|---------------------------|
-| Nouvelle image | Rien (incrémental) | Paires existantes | Nouvelles requêtes Visual Index |
-| Nouveau FeatureSet | Rien | Paires existantes | Requête depuis ce FeatureSet |
-| FeatureSet remplacé | Paires basées sur ce FeatureSet | Autres paires | Nouvelle requête depuis ce FeatureSet |
-| Visual Index reconstruit | Toutes les paires (nouvelle config) | Rien | Tout recalcul |
-| Configuration top-K modifiée | Rien (borné par requête) | Paires existantes | Nouvelles requêtes avec nouveau top_k |
-| Filtre modifié | Rien | Paires existantes | Nouvelles requêtes avec nouveau filtre |
-| Relance après interruption | Rien | Paires déjà persistées | Suite du traitement |
-
-### Politique
-
-L'invalidation est aussi locale que possible. On ne supprime jamais
-toutes les paires du projet suite à une modification locale.
-
-### Vérification par fingerprint
-
-Le fingerprint permet de vérifier si une génération doit être recalculée :
-
-```c
-unsigned char fp_courant[32], fp_enregistre[32];
-lardon3d_candidate_pair_generation_fingerprint(..., fp_courant);
-// Si fp_courant != fp_enregistre → recalcul nécessaire
-```
-
-### Réutilisation
-
-- Même fingerprint → résultat réutilisable
-- Différent fingerprint → recalcul nécessaire
-- Les paires existantes sont conservées même si le fingerprint change
-
-## Batch projet
-
-### Granularité
-
-La génération batch traite un ensemble de FeatureSets de manière
-bornée et déterministe.
-
-### API
-
-```c
-Lardon3DVisualIndexResult lardon3d_candidate_pair_generate_batch(
-    const char *project_path, Lardon3DProjectDb *database,
-    uint64_t visual_index_id, uint64_t after_feature_set_id,
-    const Lardon3DVisualIndexQueryOptions *query_options,
-    Lardon3DCandidatePairGenStats *total_stats,
-    uint64_t *last_feature_set_id);
-```
-
-### Algorithme
-
-1. Lister les FeatureSets par pages de 64
-2. Pour chaque FeatureSet :
-   - Appeler `lardon3d_candidate_pair_generate()`
-   - Accumuler les statistiques
-   - Mettre à jour le curseur
-3. Retourner les totaux et le dernier FeatureSet traité
-
-### Ordre de traitement
-
-Feature Sets traités en ordre croissant de `feature_set_id`.
-
-### Déduplication
-
-Une paire produite depuis plusieurs sources n'existe qu'une fois.
-La deduplication est assurée par `find avant create`.
-
-### Bornes
-
-- Un seul FeatureSet traité à la fois
-- Top-K borné par requête
-- Mémoire bornée : allocation `top_k * sizeof(candidate)` par requête
-- Pagination bornée (64 FeatureSets par page)
-
-### Reprise
-
-Le curseur `after_feature_set_id` permet la reprise après interruption.
-La fonction retourne le dernier FeatureSet traité.
-
-## Tâche durable
-
-### Task Kind
-
-`candidate_pair.generate` v1 — **IMPLEMENTED**.
-
-### Unité de travail
-
-Un FeatureSet source et sa requête Visual Index associée. Chaque séquence
-traite un lot borné de FeatureSets (1 à 64 selon le contrat Governor),
-page par page (PAGE_SIZE = 64).
-
-### Checkpoint
-
-Curseur `after_feature_set_id` persisté dans `candidate_pair_generate_tasks`.
-Checkpoint sauvé après chaque lot via
-`lardon3d_project_checkpoint_candidate_pair_generate_task()`.
-
-### Reprise
-
-Reprise idempotente : le champ `after_feature_set_id` est rechargé depuis la
-DB, et les paires déjà persistées sont ignorées par `find avant create`.
-À l'ouverture du projet, la tâche est automatiquement restaurée via la
-registry production et resoumise à la queue.
-
-### Intégration scheduler
-
-La tâche utilise le scheduler générique via le pattern standard :
-- Estimation immuable (128 Kio fixes, 256 Kio par item, lot 1–64)
-- Réservation CPU + IO avant exécution
-- `lardon3d_task_sequence_break()` entre chaque lot pour réadmission Governor
-- Callback terminal checkpoint après `COMPLETED`/`FAILED`/`CANCELLED`
-- Reconstruction depuis `Lardon3DProjectDbCandidatePairGenerateTask`
-
-### API
-
-```c
-Lardon3DTask *lardon3d_project_create_candidate_pair_generate_task(
-    Lardon3DAppState *state, uint64_t visual_index_id,
-    const Lardon3DVisualIndexQueryOptions *query_options, uint64_t *task_id);
-bool lardon3d_project_enqueue_candidate_pair_generate(
-    Lardon3DAppState *state, uint64_t visual_index_id,
-    const Lardon3DVisualIndexQueryOptions *query_options, uint64_t *task_id);
-bool lardon3d_candidate_pair_generate_reconstruct(
-    const Lardon3DTaskDurableSnapshot *snapshot, void *context,
-    Lardon3DTaskKindBinding *binding);
-```
-
-## Concurrence
-
-### Garantie actuelle
-
-Le generator s'exécute sur un seul FeatureSet à la fois.
-Le mutex DB protège les création concurrentes.
-
-### Atomicité
-
-Deux workers créant simultanément la même paire :
-- Ne corrompent pas la DB
-- Ne créent pas deux lignes (UNIQUE constraint)
-- Retournent OK pour l'un, NOT_FOUND→create pour l'autre
-
-### Limites
-
-Le pattern `find + create` n'est pas atomique entre les deux appels.
-Avec un seul worker, c'est suffisant. Avec plusieurs workers,
-la contrainte UNIQUE assure l'unicité mais peut causer un retry.
-
-## Bornes et ressources
-
-### Top-K
-
-`top_k <= 256` (LARDON3D_VISUAL_INDEX_TOP_K_MAX)
-
-### Mémoire
-
-Allocation par requête : `256 * sizeof(Lardon3DVisualIndexCandidate)`
-≈ 256 * 40 = 10 240 octets (10 Kio).
-
-### Complexité
-
-- O(top_k) par requête (lectures Visual Index)
-- O(1) par paire (DB write)
-- Pas de structure O(N²)
-
-## Fingerprint de génération
-
-### Composants
-
-Le fingerprint identifie une génération Candidate Pair unique :
-
-```c
-void lardon3d_candidate_pair_generation_fingerprint(
-    uint64_t visual_index_id, uint64_t source_feature_set_id,
-    const Lardon3DVisualIndexQueryOptions *query_options,
-    unsigned char fingerprint[32]);
-```
-
-### Éléments inclus
-
-- `visual_index_id` : Visual Index utilisé
-- `source_feature_set_id` : Feature Set source
-- `query_options->top_k` : nombre de candidats par requête
-- `query_options->minimum_evidence_count` : filtre minimum
-- `query_options->scanset_filter` : filtre ScanSet
-- `query_options->exclude_same_asset` : exclusion même asset
-
-### Éléments exclus (volontairement)
-
-- `created_at` : informatif, pas fonctionnel
-- `candidate_pair_id` : identifiant technique
-- Ordre des Feature Sets traités en batch
-
-### Stabilité
-
-Le fingerprint est stable pour mêmes entrées et configuration.
-Un changement de configuration produit un fingerprint différent.
-
-### Relation avec l'invalidation
-
-Un fingerprint différent signifie que le travail doit être recalculé.
-Le même fingerprint signifie que le résultat peut être réutilisé.
-
-### Relation avec la reprise
-
-Le fingerprint permet de vérifier qu'une reprise utilise la même
-configuration que l'originale.
-
-## Limites connues
-
-1. Score non persistant (par design)
-2. La compaction de segments Visual Index n'est pas implémentée
-3. Aucun Matcher consommateur des paires
-
-## Statut
-
-**IMPLEMENTED** — génération single-source, persistance,
-canonicalisation, idempotence, batch projet, fingerprint et
-réutilisation/invalidation.
-
-**IMPLEMENTED** — tâche durable `candidate_pair.generate` v1
-via le scheduler générique, avec estimation immuable,
-checkpoint par curseur, reprise idempotente et intégration
-dans la registry production.
-
-## Relation avec le pipeline
-
-Le Candidate Pair Generator est l'étape E du pipeline de reconstruction :
-
-```
-Feature Store (C)
-    ↓
-Visual Index (D)
-    ↓
-Candidate Pair Generator (E) ← CE DOCUMENT
-    ↓
-Matching (F) — HORS SCOPE
-```

docs/architecture/feature_store.md

@@ -1,4 +1,4 @@
-# Feature Store v1/v2
+# Feature Store v1
 
 ## Rôle et modèle
 
@@ -106,7 +106,7 @@ ou les octets exige d'auditer et, si nécessaire, d'incrémenter cette version.
 
 ## Statut
 
-**IMPLEMENTED** — ORB réel, formats v1/v2, assets content-addressed, DB v7,
+**IMPLEMENTED** — ORB réel, format v1, assets content-addressed, DB v6,
 publication atomique, reader borné, task kind production et reprise automatique.
 
 **NOT_YET_WIRED** — commande de réconciliation/scrub des orphelins, contrôle fin
@@ -116,26 +116,3 @@ l'extraction après import et planification multi-image/DAG.
 **IMPLEMENTED** — Visual Index v1 consomme ce reader sans changer le format.
 
 **PLANNED** — paires candidates, matching, vérification géométrique, tracks et SfM.
-
-## Extension v2 multi-descriptor
-
-**IMPLEMENTED v1A.** ORB continue d'écrire exactement le v1 U8×32 historique.
-SIFT et RootSIFT écrivent le v2 F32×128. Le header v2 de 176 octets contient,
-aux offsets 0..64, magic, version, taille header, count, dimension, type, taille
-scalaire, taille record, dimensions image, capabilities, offsets des blocs et
-taille totale ; puis SHA source à 72, fingerprint à 104, kind sur 16 octets à
-136, version extracteur à 152 et vingt octets réservés nuls.
-
-Les valeurs durables sont `U8=1` et `F32=2`, de tailles 1 et 4. Chaque binary32
-est encodé little-endian sans dump de struct. Writer et reader rejettent NaN et
-Inf. Les lectures `descriptors_u8` et `descriptors_f32` refusent un type
-incompatible, utilisent `pread` et restent limitées à 256 features. La limite
-v1 reste 16 Mio ; la limite v2 est 64 Mio.
-
-La façade d'extraction transporte aussi `descriptor_bytes`. La publication
-exige exactement `count × dimension × scalar_size`; elle refuse donc un buffer
-tronqué ou surdimensionné avant toute lecture ou création de fichier.
-
-ProjectDb v7 ajoute les métriques légères de couverture. Le détail multipasse,
-la grille et RootSIFT sont canoniques dans
-`precision_feature_pipeline.md`.

docs/architecture/overview.md

@@ -104,13 +104,6 @@ adaptatifs, réservations opaques et historique borné de métriques.
 
 **Statut :** IMPLEMENTED
 
-### Candidate Pair
-Sous-système de génération et persistance de paires d'images candidates pour
-le matching géométrique. Répond uniquement à « quelles paires valent la
-peine d'être试探ées ? » sans validation géométrique.
-
-**Statut :** IMPLEMENTED
-
 ## Résultats et publication live
 
 Les traitements fonctionnent par séquences adaptatives : lire un lot borné,

docs/architecture/persistence.md

@@ -108,7 +108,7 @@ par le `time_t` local avant conversion. Le format reste donc lisible entre
 plateformes uniquement pour les valeurs communes à leurs domaines `size_t` et
 `time_t`.
 
-## Project Database v7
+## Project Database v6
 
 SQLite contient l'état logique interrogable et les références aux fichiers ;
 les checkpoints et artefacts volumineux restent externes. L'enregistrement du
@@ -147,7 +147,7 @@ code.
 **IMPLEMENTED** — modèle durable, codec v1, lecture validée, publication
 atomique et restauration sûre d'une tâche isolée.
 
-**IMPLEMENTED** — Project Database v7 pour identité, tâches typées, ScanSets,
+**IMPLEMENTED** — Project Database v6 pour identité, tâches typées, ScanSets,
 images logiques, Feature Sets/assets SHA-256, Visual Index segmenté,
 checkpoints et artefacts génériques.
 

docs/architecture/project_database.md

@@ -1,12 +1,5 @@
 # Base de données projet Lardon3D
 
-> Version courante : **v9**. La migration transactionnelle v8→v9 ajoute
-> la table `candidate_pair_generate_tasks` pour la tâche durable Candidate
-> Pair. La migration v7→v8 ajoute la table `candidate_pairs` pour le
-> sous-système Candidate Pair.
-> Les migrations historiques restent ordonnées et les faults d'injection
-> vérifient le rollback.
-
 ## Vision
 
 La base de données projet stocke les métadonnées de reconstruction et les relations entre les entités. Elle est conçue pour être légère, persistante et permettre la reprise après interruption.
@@ -49,13 +42,11 @@ La base de données projet stocke les métadonnées de reconstruction et les rel
 - Chemin des données
 
 #### Candidate Pair
-- Identifiant unique (`candidate_pair_id`)
+- Identifiant unique
-- Image source (`image_id_a`)
+- Image source
-- Image cible (`image_id_b`)
+- Image cible
-- Ordre canonique : `image_id_a < image_id_b`
+- Score de similarité
-- Self-pairs interdits
+- Source (visuelle, temporelle, etc.)
-- Unicité persistante
-- Date de création (`created_at`)
 
 #### Verified Pair
 - Identifiant unique
@@ -177,9 +168,9 @@ référence vers le fichier checkpoint. Le fichier checkpoint validé reste la
 source complète pour `lardon3d_task_restore()` ; la DB seule ne reconstruit
 jamais une tâche. Un écart ou un fichier invalide interdit la reprise.
 
-## Schéma v7 implémenté
+## Schéma v6 implémenté
 
-- `metadata(key PRIMARY KEY, value)` contient `schema_version=7` et
+- `metadata(key PRIMARY KEY, value)` contient `schema_version=6` et
   `next_task_id`, prochain ID durable allouable.
 - `project(singleton=1, stable_id UNIQUE, name, created_at, updated_at)` décrit
   l'unique identité logique de la DB.
@@ -204,19 +195,6 @@ jamais une tâche. Un écart ou un fichier invalide interdit la reprise.
 - `image_import_tasks(task_id PRIMARY KEY REFERENCES tasks ON DELETE CASCADE,
   source_path, scanset_id REFERENCES scansets)` conserve les paramètres
   métier immuables de `import.images`.
-- `feature_assets` conserve SHA-256, chemin content-addressed, taille,
-  durabilité et date de publication des Feature Files hors SQLite.
-- `feature_sets` relie image, extracteur/version/fingerprint, hash source,
-  type/dimension descriptor, compte, producteur et métriques légères
-  `occupied_cells`, `total_cells`, `coverage_ratio` et densité/Mpx.
-- `feature_extract_tasks` conserve les paramètres immuables ORB historiques.
-- `sift_extract_tasks` conserve kind `sift`/`rootsift`, version 1, limites,
-  paramètres OpenCV binary64, grille et fingerprint exacts.
-- `feature_support_sets` identifie une consolidation immutable, son image, ses
-  deux Feature Sets sources, son rayon et son fingerprint.
-- `feature_support_groups` conserve position représentative, distance locale
-  et `support_count`; `feature_support_members` normalise chaque référence
-  `feature_set_id + feature_index`, sans descriptor SQLite.
 - `visual_indexes` conserve l'identité `AUTOINCREMENT`, la configuration
   Feature homogène, les paramètres LSH et leurs fingerprints.
 - `visual_index_segments` conserve identité `AUTOINCREMENT`, génération,
@@ -243,79 +221,17 @@ Les indexes ajoutés en v4 sont `images(scanset_id,image_id)`, pagination réell
 et `images(producer_task_id,image_id)`, recherche par tâche productrice. Le
 SHA-256 et le chemin asset sont déjà indexés par leurs contraintes `UNIQUE`.
 
-## Schéma v8 implémenté
-
-La migration v7→v8 ajoute la table `candidate_pairs` :
-
-```sql
-CREATE TABLE candidate_pairs(
-    candidate_pair_id INTEGER PRIMARY KEY AUTOINCREMENT CHECK(candidate_pair_id>0),
-    image_id_a INTEGER NOT NULL REFERENCES images(image_id),
-    image_id_b INTEGER NOT NULL REFERENCES images(image_id),
-    created_at INTEGER NOT NULL CHECK(created_at>=0),
-    CHECK(image_id_a < image_id_b),
-    UNIQUE(image_id_a, image_id_b)
-);
-CREATE INDEX candidate_pairs_image_a_idx ON candidate_pairs(image_id_a);
-CREATE INDEX candidate_pairs_image_b_idx ON candidate_pairs(image_id_b);
-```
-
-**Invariants** :
-- `image_id_a < image_id_b` : ordre canonique garanti par CHECK SQL
-- Self-pairs interdits (impliqué par `image_id_a < image_id_b`)
-- `UNIQUE(image_id_a, image_id_b)` : unicité persistante
-- `created_at` : timestamp Unix secondes, non-négatif
-
-**API** :
-- `lardon3d_project_db_create_candidate_pair()` — INSERT avec canonicalisation
-- `lardon3d_project_db_load_candidate_pair()` — SELECT par ID
-- `lardon3d_project_db_find_candidate_pair()` — SELECT par (image_a, image_b)
-- `lardon3d_project_db_list_candidate_pairs()` — SELECT paginé ORDER BY id
-
-**Notes** :
-- Le score et la source ne sont pas persistés dans cette version
-- La génération est déterministe pour mêmes entrées/configuration
-- L'idempotence est garantie par find avant create
-
-## Schéma v9 implémenté
-
-La migration v8→v9 ajoute la table `candidate_pair_generate_tasks` :
-
-```sql
-CREATE TABLE candidate_pair_generate_tasks(
-    task_id INTEGER PRIMARY KEY REFERENCES tasks(task_id) ON DELETE CASCADE,
-    visual_index_id INTEGER NOT NULL CHECK(visual_index_id>0),
-    after_feature_set_id INTEGER NOT NULL CHECK(after_feature_set_id>=0),
-    top_k INTEGER NOT NULL CHECK(top_k>0 AND top_k<=256),
-    minimum_evidence_count INTEGER NOT NULL CHECK(minimum_evidence_count>=0
-        AND minimum_evidence_count<=1024),
-    scanset_filter INTEGER NOT NULL CHECK(scanset_filter>=0 AND scanset_filter<=2),
-    exclude_same_asset INTEGER NOT NULL CHECK(exclude_same_asset IN (0,1))
-);
-```
-
-**Invariants** :
-- `task_id` référence `tasks(task_id)` avec ON DELETE CASCADE
-- `after_feature_set_id` : curseur de reprise, non-négatif
-- `top_k` : borné entre 1 et 256 (LARDON3D_VISUAL_INDEX_TOP_K_MAX)
-- `minimum_evidence_count` : borné entre 0 et 1024
-- `scanset_filter` : 0=ANY, 1=CURRENT, 2=OTHER
-
-**API** :
-- `lardon3d_project_db_record_candidate_pair_generate_task()` — UPSERT checkpoint
-- `lardon3d_project_db_load_candidate_pair_generate_task()` — SELECT par task_id
-
 ## Ouverture et migrations
 
-Une DB vide reçoit directement le schéma v7 dans une transaction
+Une DB vide reçoit directement le schéma v6 dans une transaction
 `BEGIN IMMEDIATE`. Une DB v1 reçoit transactionnellement les colonnes nullable
 `task_kind` et `task_kind_version`, puis les migrations v2→v3. Les anciennes lignes restent
 `NULL/NULL`, sans type inventé et sans perte des projets, tâches, checkpoints ou
 artefacts. Une interruption ou erreur provoque un rollback complet. Les DB v1,
-v2, v3, v4, v5 et v6 sont migrées séquentiellement vers v7. Une version future est refusée et une DB contenant
+v2, v3, v4 et v5 sont migrées séquentiellement vers v6. Une version future est refusée et une DB contenant
 des tables sans métadonnée de version est considérée corrompue. La fonction
 interne de migration applique uniquement la chaîne séquentielle connue jusqu'à
-v7 ; une valeur hors de 1..7 est refusée.
+v6 ; une valeur hors de 1..6 est refusée.
 
 Migration v1→v2 exacte, exécutée entre `BEGIN IMMEDIATE` et `COMMIT` :
 
@@ -391,7 +307,7 @@ UPDATE metadata SET value=4
     WHERE key='schema_version' AND value=3;
 ```
 
-Configuration v7 : `foreign_keys=ON`, `journal_mode=DELETE`,
+Configuration v6 : `foreign_keys=ON`, `journal_mode=DELETE`,
 `synchronous=FULL`, `busy_timeout=5000`. Le mode DELETE convient au propriétaire
 unique actuel, évite les fichiers WAL/SHM durables et conserve la synchronisation
 forte. Le timeout borne l'attente d'un verrou externe à cinq secondes.
@@ -452,7 +368,7 @@ ouvert.
 
 ## Statut
 
-**IMPLEMENTED** — SQLite système, schéma v9 et migrations v1→v2→v3→v4→v5→v6→v7→v8→v9, identité
+**IMPLEMENTED** — SQLite système, schéma v6 et migrations v1→v2→v3→v4→v5→v6, identité
 projet, transactions tâche+checkpoint, pagination de reprise et artefacts
 génériques.
 
@@ -484,5 +400,5 @@ orphelins et compaction Visual Index. Feature Store et Visual Index v1 sont impl
 Visual Index v1 borne un index à 256 segments de 16 memberships, soit 4096 Feature Sets;
 la couverture de 50 000 Feature Sets nécessitera la compaction ou une évolution v2.
 
-**PLANNED** — dépendances d'artefacts, graphe géométrique et
+**PLANNED** — migrations v7+, dépendances d'artefacts, graphe géométrique et
 reconstruction incrémentale.

docs/architecture/reconstruction_pipeline.md

@@ -46,18 +46,13 @@ content-addressed. Les états Feature/Matching/Reconstruction restent planifiés
 
 | Aspect | Description |
 |--------|-------------|
-| **Extraction** | ORB coarse, SIFT précis et RootSIFT, chacun avec sa tâche durable. |
+| **Extraction** | ORB OpenCV réel, une image par tâche `features.extract`. |
-| **Métadonnées persistantes** | `FeatureSet` logique et `FeatureAsset` physique content-addressed dans ProjectDb v7. |
+| **Métadonnées persistantes** | `FeatureSet` logique et `FeatureAsset` physique content-addressed dans ProjectDb v5. |
-| **Données numériques massives** | ORB U8×32 v1 et SIFT/RootSIFT F32×128 v2 restent hors SQLite. |
+| **Données numériques massives** | Keypoints et descripteurs U8×32 restent hors SQLite dans Feature File v1. |
 | **Lecture bornée** | Le reader lit au plus 256 features par plage et ne charge pas tout le fichier. |
 
 **Statut :** IMPLEMENTED v1 — extraction, publication atomique, reprise et reader borné.
 
-**Extension v1A :** ORB reste la passe coarse et l'unique entrée du Visual
-Index ORB-LSH. SIFT/RootSIFT F32×128 sont des passes précises indépendantes,
-suivies d'une consolidation spatiale intra-image qui ne mélange jamais les
-descriptors. Candidate Pair Generator et matching restent planifiés.
-
 ---
 
 ### D. Visual Index
@@ -79,13 +74,9 @@ updates incrémentales et query top-K bornée. Le générateur de paires reste p
 |--------|-------------|
 | **Sources de paires candidates** | (1) Visual index : paires visuellement proches. (2) Proximité temporelle. (3) Scan set commun. (4) Géométrie approximative (si GPS/IMU disponible). |
 | **Matching coûteux limité** | Le nombre de paires soumises au matching géométrique (étape F) doit être borné. Le candidate generator filtre et classe pour ne garder que les paires les plus prometteuses. |
-| **Persistance** | Les paires candidates sont persistées dans la table `candidate_pairs` (Project DB v9). Ordre canonique : `image_id_a < image_id_b`. Self-pairs interdits. Unicité garantie. |
-| **Déterminisme** | Pour mêmes entrées et configuration, le générateur produit les mêmes paires dans le même ordre. |
-| **Idempotence** | L'exécution répétée ne crée pas de doublons. |
 
-**Statut :** IMPLEMENTED v1 — génération single-source depuis Visual Index,
+**Statut :** PLANNED — le scheduler supporte le tri FIFO mais le
-persistance, canonicalisation et idempotence. La génération batch projet
+candidate generator n'existe pas encore.
-et l'intégration tâche durable restent planifiées.
 
 ---
 
@@ -225,8 +216,9 @@ Image Catalog (B) ──► Feature Store (C)
 
 ## Statut du pipeline
 
-Import, Image Catalog, Feature Extraction, Feature Store, Visual Index et
+Import, Image Catalog, Feature Extraction et Feature Store sont **IMPLEMENTED**.
-Candidate Pair sont **IMPLEMENTED**. Matching, Tracks et SfM sont **PLANNED**.
+Visual Index est implémenté mais reste en validation partielle. Candidate Pair,
+Matching, Tracks et SfM sont **PLANNED**.
 
 Ce document décrit la vision architecturale cible du pipeline de
 reconstruction. Les modules listés ici ne sont pas tous implémentés.

docs/architecture/resource_governor.md

@@ -1,12 +1,5 @@
 # Resource Governor Lardon3D
 
-## SIFT v1A
-
-Une extraction SIFT réserve séparément un slot CPU et un slot IO, aucun GPU,
-pour une image. L'estimation structurelle conservatrice est environ 1,06 Gio
-(décodage, pyramides, candidats et F32×128), lot 1, pic de record batch zéro.
-OpenCV peut employer son parallélisme interne ; aucun état global n'est modifié.
-
 ## Responsabilité
 
 Le Resource Governor est l'unique propriétaire des budgets (RAM, GPU, CPU, IO). Il arbitre les ressources disponibles et calcule les lots adaptatifs pour chaque tâche.
@@ -88,12 +81,6 @@ Le Resource Governor est l'unique propriétaire des budgets (RAM, GPU, CPU, IO).
 - `visual_index.update` réserve un thread CPU, un slot I/O, 8 Mio fixes et
   2 Mio par Feature Set, par lots de 1 à 16. Le GPU vaut zéro. `record_batch`
   compte uniquement les memberships commités et conserve la mémoire inconnue à zéro.
-- `candidate_pair.generate` réserve un thread CPU, un slot I/O, 128 Kio fixes
-  et 256 Kio par Feature Set, par lots de 1 à 64. Le GPU vaut zéro.
-  `record_batch` compte le nombre de paires générées par séquence et la durée
-  réelle du lot ; `peak_memory_bytes == 0` signifie « mesure inconnue ».
-  Chaque séquence interroge le Visual Index pour jusqu'à 64 Feature Sets et
-  persiste les paires candidates avec idempotence.
 
 ## Limites actuelles
 

docs/architecture/task_kind_registry.md

@@ -1,12 +1,5 @@
 # Registry des types métier de tâches
 
-## Feature kinds v1A
-
-La registry statique conserve `features.extract` v1 pour ORB et ajoute
-`features.extract.sift` v1 et `features.extract.rootsift` v1. Les reconstructeurs
-chargent la table dédiée, revalident le fingerprint et ne capturent aucun
-`AppState`.
-
 ## Contrat
 
 Une instance possède un **task ID** stable. Son **task kind** décrit son
@@ -33,7 +26,7 @@ fin de l'exécution. Le constructeur métier n'est jamais appelé sous mutex DB.
 
 ## Persistance et legacy
 
-Le checkpoint générique reste en version 1. Project Database v7 conserve le
+Le checkpoint générique reste en version 1. Project Database v6 conserve le
 kind/version ; les lignes migrées depuis v1 restent `NULL/NULL` et sont classées
 `LEGACY_UNTYPED`. Un kind inconnu ou une version non supportée reste inspectable
 mais inexécutable. Aucun type n'est inventé et aucun code n'est sélectionné par
@@ -59,9 +52,4 @@ depuis `image_id` et ses paramètres bornés.
 **IMPLEMENTED** — `visual_index.update`, version 1, recharge
 `visual_index_id + after_feature_set_id` et reconstruit un contexte neuf.
 
-**IMPLEMENTED** — `candidate_pair.generate`, version 1, recharge
-`visual_index_id + after_feature_set_id + top_k + minimum_evidence_count
-+ scanset_filter + exclude_same_asset` depuis `candidate_pair_generate_tasks`
-et reconstruit un contexte boundé.
-
 **PLANNED** — kinds de matching et reconstruction.

docs/architecture/task_system.md

@@ -1,13 +1,5 @@
 # Système de tâches (Task System)
 
-## Extraction précise v1A
-
-`features.extract.sift` et `features.extract.rootsift`, version 1, possèdent
-chacun leur lifecycle durable. Une tâche correspond à une image, est persistée
-avant enqueue et reprend avec le même `task_id`. `detectAndCompute` n'est pas
-interruptible : pause/cancel sont coopératifs à ses frontières et un crash
-recommence uniquement cette image. ORB READY n'est jamais recalculé par SIFT.
-
 ## Objectif et responsabilités
 
 Le module `task` gère le cycle de vie complet des tâches de traitement dans
@@ -99,12 +91,6 @@ l'ouverture du projet.
 **IMPLEMENTED** — `visual_index.update` traite jusqu'à seize Feature Sets par
 séquence, checkpoint après commit de segment et repasse par le Governor.
 
-**IMPLEMENTED** — `candidate_pair.generate` traite jusqu'à soixante-quatre
-Feature Sets par séquence, interroge le Visual Index, persiste les paires
-candidates avec idempotence, checkpoint après chaque lot et repasse par le
-Governor via `sequence_break`. La reprise est idempotente avec le curseur
-`after_feature_set_id` rechargé depuis la DB.
-
 Le chemin de production de l'import ne possède plus de thread ni de drapeau
 d'annulation privés. Son wrapper TUI ne fait qu'enqueue/cancel/observer la
 tâche générique. Chaque callback traite un lot borné, checkpoint hors mutex de
@@ -123,7 +109,7 @@ localement : son userdata est détruit, sans callback terminal ni écriture
 durable d'une fausse annulation. Une annulation explicitement demandée conserve
 le contrat de notification terminale.
 
-La Project Database v7 peut enregistrer transactionnellement un résumé
+La Project Database v6 peut enregistrer transactionnellement un résumé
 `Lardon3DTaskDurableSnapshot` et la référence de son checkpoint. Elle ne stocke
 ni estimation sérialisée complète, ni callback, ni réservation, et ne remplace
 pas la validation du fichier checkpoint avant `task_restore()`.

docs/architecture/visual_index.md

@@ -60,7 +60,7 @@ original. Un Feature Set vide est
 membre valide sans posting. Le build ne garde qu'un Feature Set et une tranche
 Feature Reader de 256 descripteurs en mémoire.
 
-## Segments introduits en Project Database v6, conservés en v7
+## Segments et Project Database v6
 
 Un index logique possède des segments immuables READY. Chaque update publie un
 segment de un à seize nouveaux Feature Sets, puis ajoute atomiquement segments

docs/concepts/matching_and_tracks.md

@@ -1,10 +1,5 @@
 # Matching & Tracks
 
-> Frontière v1A : les groupes de support ORB/SIFT sont uniquement des preuves
-> locales intra-image. Ils ne comparent pas les espaces Hamming et L2, ne sont
-> pas des matches multivues et ne créent aucun track. Le futur matcher choisira
-> explicitement SIFT ou RootSIFT après génération des paires.
-
 ## Définition
 
 Le **matching** est le processus d'appariement de descripteurs visuels entre paires d'images pour identifier les correspondances géométriques. Un **track** (ou piste) est la séquence de correspondances cohérentes d'un même point 3D à travers plusieurs images.

docs/development/opencode_long_run.md

@@ -1,76 +0,0 @@
-# OpenCode long run
-
-`ocaway` lance OpenCode 1.18.15 pour un ticket autonome tout en conservant les
-interdictions destructives du projet. Le mode normal `opencode` reste inchangé.
-
-## Lancement
-
-Le wrapper suivi par le dépôt est `.opencode/bin/opencode-away`. Il doit être
-installé sous `~/.local/bin/opencode-away`, puis l'alias contenu dans
-`.opencode/zshrc.snippet` doit être ajouté à `~/.zshrc`. Ces deux destinations
-sont des symlinks vers les dotfiles utilisateur sur cette machine.
-
-Depuis la racine d'un dépôt Git :
-
-```sh
-ocaway
-```
-
-Les arguments sont transmis tels quels à OpenCode. Le wrapper exporte
-`LARDON_OPENCODE_LONG_RUN=1`, suspend uniquement les processus `swayidle` qui
-étaient actifs, puis lance :
-
-```sh
-systemd-inhibit \
-  --what=sleep:idle:handle-lid-switch \
-  --who="OpenCode Long Run" \
-  --why="Autonomous Lardon3D development ticket" \
-  --mode=block \
-  opencode --auto
-```
-
-systemd 261 supporte les trois inhibitions demandées. La configuration locale
-utilise `HandleLidSwitch=suspend` et laisse `LidSwitchIgnoreInhibited` à sa
-valeur par défaut `yes`, compatible avec l'inhibiteur `block`. Aucun fichier
-systemd ou logind n'est modifié.
-
-Le wrapper enregistre les PID `swayidle` qui n'étaient pas déjà stoppés, leur
-envoie `SIGSTOP`, puis restaure exactement ces PID avec `SIGCONT` à la sortie,
-sur INT, TERM ou HUP. Le code retour du processus OpenCode est conservé.
-
-`opencode-away --check` vérifie les préconditions sans lancer OpenCode ni
-suspendre `swayidle`. `OPENCODE_AWAY_COMMAND` est un seam de test réservé aux
-validations du wrapper ; en usage normal il est absent.
-
-## Permissions et sécurité
-
-La configuration est une allowlist : les outils et commandes inconnus sont
-refusés, et `--auto` ne peut pas contourner un refus. Restent interdits :
-privilèges root, gestion de paquets, Git destructif ou publiant,
-suppression, arrêt de processus ou machine, écriture externe, `.git/` et
-`scan3d/`. Les écritures normales restent dans le worktree courant.
-
-Les sous-agents approuvés sont autorisés explicitement par leur identifiant.
-Chaque agent possède ses propres règles ; il n'hérite pas implicitement d'une
-permission plus large du parent.
-
-## Mémoire et handoff
-
-Le ticket courant est résumé dans `.opencode/work/current_ticket.md` après
-chaque phase. Avant une session fraîche, `.opencode/work/handoff.md` contient
-l'architecture pertinente, les décisions, fichiers, tests, échecs, travail
-restant et la prochaine action exacte.
-
-Les sorties d'outils sont plafonnées et compactées. Les validations lourdes
-sont séquentielles : ciblé, normal, ASan/UBSan, TSan, stress, revue et docs.
-
-## Limites
-
-Une inhibition empêche sleep, idle et la réaction logind au capot tant que le
-wrapper et sa session utilisateur vivent. Elle ne garantit pas la survie du
-processus si le terminal ou toute la session graphique est détruite. Aucun tmux
-n'est créé automatiquement.
-
-Si une dépendance externe manque, si un secret est requis ou si une opération
-explicitement interdite devient nécessaire, le ticket s'arrête avec un handoff
-au lieu de contourner la restriction.

docs/roadmap/roadmap.md

@@ -1,13 +1,5 @@
 # Roadmap Lardon3D
 
-## Precision features
-
-- **IMPLEMENTED v1A** : ORB coarse stable, SIFT/RootSIFT OpenCV 5, Feature File
-  v2 F32×128, grille/coverage, tâches récupérables et consolidation intra-image.
-- **PLANNED** : Candidate Pair Generator et matching précis.
-- **PLANNED / BLOCKED** : ALIKED, en attente de provenance modèle et d'un export
-  ONNX reproductible validé contre un oracle upstream.
-
 ## Direction générale
 
 Lardon3D suit une feuille de route ordonnée qui privilégie la stabilité et la consolidation avant l'ajout de fonctionnalités complexes.
@@ -37,7 +29,7 @@ Lardon3D suit une feuille de route ordonnée qui privilégie la stabilité et la
 
 ### Phase 3 : Persistance
 - ✅ Fondation versionnée des checkpoints de tâches
-- ✅ Project Database v7 (tâches, catalogue, Feature Store, Visual Index et precision features)
+- ✅ Project Database v6 (tâches, catalogue, Feature Store et Visual Index)
 - ✅ Branchement Project Database au cycle de vie projet et inventaire de reprise
 - ✅ Registry durable des types métier de tâches
 - ✅ Premier type métier reconstructible (`import.images`)
@@ -45,7 +37,7 @@ Lardon3D suit une feuille de route ordonnée qui privilégie la stabilité et la
 - ✅ ScanSet v1 et Image Catalog persistant v1
 
 ### Phase 4 : Pipeline avancé
-- ✅ Feature Store v1/v2, ORB, SIFT/RootSIFT et consolidation intra-image
+- ✅ Feature Store v1 et extraction ORB persistante
 - ✅ Visual Index v1 segmenté et persistant
 - 📋 Candidate Pair Generator
 - 📋 Matching et vérification géométrique

include/lardon3d/candidate_pair_gen.h

@@ -1,35 +0,0 @@
-#ifndef LARDON3D_CANDIDATE_PAIR_GEN_H
-#define LARDON3D_CANDIDATE_PAIR_GEN_H
-
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#include <lardon3d/project_db.h>
-#include <lardon3d/visual_index.h>
-
-typedef struct {
-  uint32_t generated_count;    // paires nouvellement créées
-  uint32_t skipped_count;      // paires déjà existantes (idempotence)
-  uint32_t queried_count;      // candidats retournés par le Visual Index
-} Lardon3DCandidatePairGenStats;
-
-Lardon3DVisualIndexResult lardon3d_candidate_pair_generate(
-    const char *project_path, Lardon3DProjectDb *database,
-    uint64_t visual_index_id, uint64_t source_feature_set_id,
-    const Lardon3DVisualIndexQueryOptions *query_options,
-    Lardon3DCandidatePairGenStats *stats);
-
-Lardon3DVisualIndexResult lardon3d_candidate_pair_generate_batch(
-    const char *project_path, Lardon3DProjectDb *database,
-    uint64_t visual_index_id, uint64_t after_feature_set_id,
-    const Lardon3DVisualIndexQueryOptions *query_options,
-    Lardon3DCandidatePairGenStats *total_stats,
-    uint64_t *last_feature_set_id);
-
-void lardon3d_candidate_pair_generation_fingerprint(
-    uint64_t visual_index_id, uint64_t source_feature_set_id,
-    const Lardon3DVisualIndexQueryOptions *query_options,
-    unsigned char fingerprint[32]);
-
-#endif

include/lardon3d/candidate_pair_task.h

@@ -1,27 +0,0 @@
-#ifndef LARDON3D_CANDIDATE_PAIR_TASK_H
-#define LARDON3D_CANDIDATE_PAIR_TASK_H
-
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#include <lardon3d/app_state.h>
-#include <lardon3d/task_kind_registry.h>
-#include <lardon3d/visual_index.h>
-
-#define LARDON3D_CANDIDATE_PAIR_GENERATE_TASK_KIND "candidate_pair.generate"
-enum { LARDON3D_CANDIDATE_PAIR_GENERATE_TASK_KIND_VERSION = 1 };
-
-Lardon3DTask *lardon3d_project_create_candidate_pair_generate_task(
-    Lardon3DAppState *state, uint64_t visual_index_id,
-    const Lardon3DVisualIndexQueryOptions *query_options, uint64_t *task_id);
-bool lardon3d_project_enqueue_candidate_pair_generate(Lardon3DAppState *state,
-                                                      uint64_t visual_index_id,
-                                                      const Lardon3DVisualIndexQueryOptions
-                                                          *query_options,
-                                                      uint64_t *task_id);
-bool lardon3d_candidate_pair_generate_reconstruct(const Lardon3DTaskDurableSnapshot *snapshot,
-                                                   void *context,
-                                                   Lardon3DTaskKindBinding *binding);
-
-#endif

include/lardon3d/feature_extractor.h

@@ -6,8 +6,6 @@
 #include <stdint.h>
 
 #define LARDON3D_FEATURE_EXTRACTOR_KIND "orb"
-#define LARDON3D_SIFT_EXTRACTOR_KIND "sift"
-#define LARDON3D_ROOTSIFT_EXTRACTOR_KIND "rootsift"
 enum {
   LARDON3D_FEATURE_EXTRACTOR_VERSION = 1,
   LARDON3D_FEATURE_DESCRIPTOR_DIMENSION = 32,
@@ -21,25 +19,6 @@ typedef struct {
   uint32_t fast_threshold;
 } Lardon3DFeatureExtractorParameters;
 
-typedef struct {
-  uint32_t max_features;
-  uint32_t octave_layers;
-  double contrast_threshold;
-  double edge_threshold;
-  double sigma;
-  uint32_t grid_rows;
-  uint32_t grid_cols;
-  uint32_t max_features_per_cell;
-  bool rootsift;
-} Lardon3DSiftExtractorParameters;
-
-typedef struct {
-  uint32_t occupied_cells;
-  uint32_t total_cells;
-  double coverage_ratio;
-  double feature_density_per_megapixel;
-} Lardon3DFeatureQualityMetrics;
-
 typedef struct {
   float x;
   float y;
@@ -55,8 +34,6 @@ typedef struct {
   uint32_t feature_count;
   Lardon3DFeatureKeypoint *keypoints;
   unsigned char *descriptors;
-  Lardon3DFeatureQualityMetrics quality;
-  size_t descriptor_bytes;
 } Lardon3DExtractedFeatures;
 
 typedef enum {
@@ -75,13 +52,6 @@ void lardon3d_feature_extractor_parameter_fingerprint(
 Lardon3DFeatureExtractResult
 lardon3d_feature_extract_orb(const char *path, const Lardon3DFeatureExtractorParameters *parameters,
                              Lardon3DExtractedFeatures *features);
-bool lardon3d_sift_extractor_parameters_valid(const Lardon3DSiftExtractorParameters *parameters);
-Lardon3DSiftExtractorParameters lardon3d_sift_precision_classic_v1(bool rootsift);
-void lardon3d_sift_extractor_parameter_fingerprint(
-    const Lardon3DSiftExtractorParameters *parameters, unsigned char fingerprint[32]);
-Lardon3DFeatureExtractResult
-lardon3d_feature_extract_sift(const char *path, const Lardon3DSiftExtractorParameters *parameters,
-                              Lardon3DExtractedFeatures *features);
 void lardon3d_extracted_features_destroy(Lardon3DExtractedFeatures *features);
 
 #endif

include/lardon3d/feature_store.h

@@ -11,13 +11,10 @@
 
 enum {
   LARDON3D_FEATURE_FILE_VERSION = 1,
-  LARDON3D_FEATURE_FILE_VERSION_V2 = 2,
   LARDON3D_FEATURE_FILE_HEADER_SIZE = 160,
-  LARDON3D_FEATURE_FILE_V2_HEADER_SIZE = 176,
   LARDON3D_FEATURE_KEYPOINT_RECORD_SIZE = 24,
   LARDON3D_FEATURE_READER_RANGE_MAX = 256,
-  LARDON3D_FEATURE_FILE_V1_MAX_SIZE = 16 * 1024 * 1024,
+  LARDON3D_FEATURE_FILE_MAX_SIZE = 16 * 1024 * 1024,
-  LARDON3D_FEATURE_FILE_MAX_SIZE = 64 * 1024 * 1024,
 };
 
 typedef enum {
@@ -25,13 +22,6 @@ typedef enum {
   LARDON3D_FEATURE_DESCRIPTOR_F32 = 2
 } Lardon3DFeatureDescriptorType;
 
-typedef enum {
-  LARDON3D_FEATURE_HAS_SCALE = 1U << 0,
-  LARDON3D_FEATURE_HAS_ORIENTATION = 1U << 1,
-  LARDON3D_FEATURE_HAS_RESPONSE = 1U << 2,
-  LARDON3D_FEATURE_HAS_OCTAVE = 1U << 3
-} Lardon3DFeatureCapability;
-
 typedef enum {
   LARDON3D_FEATURE_STORE_OK = 0,
   LARDON3D_FEATURE_STORE_ALREADY_PRESENT,
@@ -55,8 +45,6 @@ typedef struct {
   uint32_t feature_count;
   uint32_t descriptor_dimension;
   Lardon3DFeatureDescriptorType descriptor_type;
-  uint32_t descriptor_scalar_size_bytes;
-  uint32_t capabilities;
   uint32_t image_width;
   uint32_t image_height;
   unsigned char source_image_sha256[32];
@@ -67,12 +55,6 @@ Lardon3DFeatureStoreResult lardon3d_feature_store_publish(
     Lardon3DAppState *state, uint64_t image_id, uint64_t producer_task_id,
     const Lardon3DFeatureExtractorParameters *parameters, const Lardon3DExtractedFeatures *features,
     Lardon3DProjectDbFeatureSet *feature_set);
-Lardon3DFeatureStoreResult lardon3d_feature_store_publish_v2(
-    Lardon3DAppState *state, uint64_t image_id, uint64_t producer_task_id,
-    const char *extractor_kind, uint32_t extractor_version,
-    const unsigned char parameter_fingerprint[32], Lardon3DFeatureDescriptorType descriptor_type,
-    uint32_t descriptor_dimension, uint32_t capabilities,
-    const Lardon3DExtractedFeatures *features, Lardon3DProjectDbFeatureSet *feature_set);
 Lardon3DFeatureStoreResult
 lardon3d_feature_reader_open(const char *project_path,
                              const Lardon3DProjectDbFeatureSet *feature_set,
@@ -87,11 +69,5 @@ Lardon3DFeatureStoreResult lardon3d_feature_reader_descriptors(Lardon3DFeatureRe
                                                                unsigned char *descriptors,
                                                                size_t feature_capacity,
                                                                size_t descriptor_capacity);
-Lardon3DFeatureStoreResult lardon3d_feature_reader_descriptors_u8(
-    Lardon3DFeatureReader *reader, uint32_t start, unsigned char *descriptors,
-    size_t feature_capacity, size_t descriptor_capacity);
-Lardon3DFeatureStoreResult lardon3d_feature_reader_descriptors_f32(
-    Lardon3DFeatureReader *reader, uint32_t start, float *descriptors, size_t feature_capacity,
-    size_t descriptor_capacity);
 
 #endif

include/lardon3d/precision_features.h

@@ -1,26 +0,0 @@
-#ifndef LARDON3D_PRECISION_FEATURES_H
-#define LARDON3D_PRECISION_FEATURES_H
-
-#include <stdint.h>
-
-#include <lardon3d/app_state.h>
-#include <lardon3d/project_db.h>
-
-typedef struct {
-  double association_radius_pixels;
-} Lardon3DFeatureConsolidationParameters;
-
-Lardon3DFeatureConsolidationParameters lardon3d_feature_consolidation_v1(void);
-bool lardon3d_feature_consolidation_parameters_valid(
-    const Lardon3DFeatureConsolidationParameters *parameters);
-void lardon3d_feature_consolidation_fingerprint(
-    const Lardon3DFeatureConsolidationParameters *parameters, unsigned char fingerprint[32]);
-bool lardon3d_feature_support_higher_quality(
-    const Lardon3DProjectDbFeatureSupportGroup *candidate,
-    const Lardon3DProjectDbFeatureSupportGroup *reference);
-Lardon3DProjectDbResult lardon3d_consolidate_orb_sift(
-    Lardon3DAppState *state, uint64_t orb_feature_set_id, uint64_t sift_feature_set_id,
-    const Lardon3DFeatureConsolidationParameters *parameters,
-    Lardon3DProjectDbFeatureSupportSet *support_set);
-
-#endif

include/lardon3d/project.h

@@ -61,15 +61,9 @@ lardon3d_project_checkpoint_image_import_task(Lardon3DAppState *state, const Lar
 Lardon3DProjectTaskCheckpointResult lardon3d_project_checkpoint_feature_extract_task(
     Lardon3DAppState *state, const Lardon3DTask *task,
     const Lardon3DProjectDbFeatureExtractTask *parameters);
-Lardon3DProjectTaskCheckpointResult lardon3d_project_checkpoint_sift_extract_task(
-    Lardon3DAppState *state, const Lardon3DTask *task,
-    const Lardon3DProjectDbSiftExtractTask *parameters);
 Lardon3DProjectTaskCheckpointResult lardon3d_project_checkpoint_visual_index_update_task(
     Lardon3DAppState *state, const Lardon3DTask *task,
     const Lardon3DProjectDbVisualIndexUpdateTask *parameters);
-Lardon3DProjectTaskCheckpointResult lardon3d_project_checkpoint_candidate_pair_generate_task(
-    Lardon3DAppState *state, const Lardon3DTask *task,
-    const Lardon3DProjectDbCandidatePairGenerateTask *parameters);
 Lardon3DProjectDbResult lardon3d_project_list_recoverable(Lardon3DAppState *state,
                                                           const Lardon3DTaskKindRegistry *registry,
                                                           uint64_t after_task_id,

include/lardon3d/project_db.h

@@ -9,14 +9,13 @@
 #include <lardon3d/task.h>
 
 enum {
-  LARDON3D_PROJECT_DB_SCHEMA_VERSION = 9,
+  LARDON3D_PROJECT_DB_SCHEMA_VERSION = 6,
   LARDON3D_PROJECT_DB_ID_CAPACITY = 65,
   LARDON3D_PROJECT_DB_KIND_CAPACITY = 65,
   LARDON3D_PROJECT_DB_PATH_CAPACITY = 4096,
   LARDON3D_PROJECT_DB_ERROR_CAPACITY = 256,
   LARDON3D_PROJECT_DB_RECOVERY_PAGE_MAX = 256,
   LARDON3D_PROJECT_DB_CATALOG_PAGE_MAX = 256,
-  LARDON3D_PROJECT_DB_CANDIDATE_PAIR_PAGE_MAX = 256,
   LARDON3D_PROJECT_DB_SCANSET_NAME_CAPACITY = 256,
   LARDON3D_PROJECT_DB_IMAGE_NAME_CAPACITY = 256,
   LARDON3D_PROJECT_DB_SHA256_SIZE = 32,
@@ -123,13 +122,6 @@ typedef struct {
   int64_t imported_at;
 } Lardon3DProjectDbImage;
 
-typedef struct {
-  uint64_t candidate_pair_id;
-  uint64_t image_id_a;
-  uint64_t image_id_b;
-  int64_t created_at;
-} Lardon3DProjectDbCandidatePair;
-
 typedef enum {
   LARDON3D_PROJECT_DB_IMAGE_REGISTERED = 0,
   LARDON3D_PROJECT_DB_IMAGE_ALREADY_PRESENT
@@ -160,10 +152,6 @@ typedef struct {
   uint32_t feature_count;
   uint32_t descriptor_type;
   uint32_t descriptor_dimension;
-  uint32_t occupied_cells;
-  uint32_t total_cells;
-  double coverage_ratio;
-  double feature_density_per_megapixel;
   bool has_producer_task;
   uint64_t producer_task_id;
   int64_t created_at;
@@ -181,46 +169,6 @@ typedef struct {
   unsigned char parameter_fingerprint[32];
 } Lardon3DProjectDbFeatureExtractTask;
 
-typedef struct {
-  uint64_t task_id;
-  uint64_t image_id;
-  char extractor_kind[LARDON3D_PROJECT_DB_KIND_CAPACITY];
-  uint32_t extractor_version;
-  uint32_t max_features;
-  uint32_t octave_layers;
-  double contrast_threshold;
-  double edge_threshold;
-  double sigma;
-  uint32_t grid_rows;
-  uint32_t grid_cols;
-  uint32_t max_features_per_cell;
-  unsigned char parameter_fingerprint[32];
-} Lardon3DProjectDbSiftExtractTask;
-
-typedef struct {
-  uint64_t feature_support_set_id;
-  uint64_t image_id;
-  uint64_t first_feature_set_id;
-  uint64_t second_feature_set_id;
-  double radius_pixels;
-  unsigned char parameter_fingerprint[32];
-  uint32_t group_count;
-  int64_t created_at;
-} Lardon3DProjectDbFeatureSupportSet;
-
-typedef struct {
-  uint64_t feature_support_group_id;
-  uint64_t feature_support_set_id;
-  double x;
-  double y;
-  double distance_pixels;
-  uint32_t support_count;
-  bool first_member_from_second_set;
-  uint32_t first_feature_index;
-  bool has_second_feature;
-  uint32_t second_feature_index;
-} Lardon3DProjectDbFeatureSupportGroup;
-
 typedef enum {
   LARDON3D_DB_VISUAL_INDEX_DURABLE = 0,
   LARDON3D_DB_VISUAL_INDEX_PUBLISHED_NOT_DURABLE = 1
@@ -264,16 +212,6 @@ typedef struct {
   uint64_t after_feature_set_id;
 } Lardon3DProjectDbVisualIndexUpdateTask;
 
-typedef struct {
-  uint64_t task_id;
-  uint64_t visual_index_id;
-  uint64_t after_feature_set_id;
-  uint32_t top_k;
-  uint32_t minimum_evidence_count;
-  int scanset_filter;
-  bool exclude_same_asset;
-} Lardon3DProjectDbCandidatePairGenerateTask;
-
 Lardon3DProjectDbResult lardon3d_project_db_open(const char *path, Lardon3DProjectDb **database,
                                                  char error[LARDON3D_PROJECT_DB_ERROR_CAPACITY]);
 void lardon3d_project_db_close(Lardon3DProjectDb *database);
@@ -322,17 +260,6 @@ Lardon3DProjectDbResult lardon3d_project_db_list_images(Lardon3DProjectDb *datab
                                                         size_t capacity, size_t *count);
 Lardon3DProjectDbResult lardon3d_project_db_count_images(Lardon3DProjectDb *database,
                                                          uint64_t scanset_id, uint64_t *count);
-Lardon3DProjectDbResult lardon3d_project_db_create_candidate_pair(
-    Lardon3DProjectDb *database, uint64_t image_id_a, uint64_t image_id_b, int64_t created_at,
-    Lardon3DProjectDbCandidatePair *pair);
-Lardon3DProjectDbResult lardon3d_project_db_load_candidate_pair(
-    Lardon3DProjectDb *database, uint64_t candidate_pair_id, Lardon3DProjectDbCandidatePair *pair);
-Lardon3DProjectDbResult lardon3d_project_db_find_candidate_pair(
-    Lardon3DProjectDb *database, uint64_t image_id_a, uint64_t image_id_b,
-    Lardon3DProjectDbCandidatePair *pair);
-Lardon3DProjectDbResult lardon3d_project_db_list_candidate_pairs(
-    Lardon3DProjectDb *database, uint64_t after_candidate_pair_id,
-    Lardon3DProjectDbCandidatePair *pairs, size_t capacity, size_t *count);
 Lardon3DProjectDbResult
 lardon3d_project_db_load_image_import(Lardon3DProjectDb *database, uint64_t task_id,
                                       Lardon3DProjectDbImageImport *parameters);
@@ -360,13 +287,6 @@ Lardon3DProjectDbResult lardon3d_project_db_record_feature_extract_task(
 Lardon3DProjectDbResult
 lardon3d_project_db_load_feature_extract_task(Lardon3DProjectDb *database, uint64_t task_id,
                                               Lardon3DProjectDbFeatureExtractTask *parameters);
-Lardon3DProjectDbResult lardon3d_project_db_record_sift_extract_task(
-    Lardon3DProjectDb *database, const Lardon3DTaskDurableSnapshot *snapshot,
-    const char *task_kind, uint32_t task_kind_version,
-    const Lardon3DProjectDbCheckpoint *checkpoint,
-    const Lardon3DProjectDbSiftExtractTask *parameters, int64_t updated_at);
-Lardon3DProjectDbResult lardon3d_project_db_load_sift_extract_task(
-    Lardon3DProjectDb *database, uint64_t task_id, Lardon3DProjectDbSiftExtractTask *parameters);
 Lardon3DProjectDbResult lardon3d_project_db_register_feature_set(
     Lardon3DProjectDb *database, uint64_t image_id, const char *extractor_kind,
     uint32_t extractor_version, const unsigned char parameter_fingerprint[32],
@@ -374,15 +294,6 @@ Lardon3DProjectDbResult lardon3d_project_db_register_feature_set(
     uint32_t descriptor_dimension, const unsigned char asset_sha256[32], const char *asset_path,
     uint64_t asset_size_bytes, Lardon3DProjectDbFeatureDurability durability,
     uint64_t producer_task_id, int64_t created_at, Lardon3DProjectDbFeatureSet *feature_set);
-Lardon3DProjectDbResult lardon3d_project_db_register_feature_set_quality(
-    Lardon3DProjectDb *database, uint64_t image_id, const char *extractor_kind,
-    uint32_t extractor_version, const unsigned char parameter_fingerprint[32],
-    const unsigned char source_image_sha256[32], uint32_t feature_count, uint32_t descriptor_type,
-    uint32_t descriptor_dimension, uint32_t occupied_cells, uint32_t total_cells,
-    double coverage_ratio, double feature_density_per_megapixel,
-    const unsigned char asset_sha256[32], const char *asset_path, uint64_t asset_size_bytes,
-    Lardon3DProjectDbFeatureDurability durability, uint64_t producer_task_id, int64_t created_at,
-    Lardon3DProjectDbFeatureSet *feature_set);
 Lardon3DProjectDbResult
 lardon3d_project_db_find_feature_set(Lardon3DProjectDb *database, uint64_t image_id,
                                      const char *extractor_kind, uint32_t extractor_version,
@@ -395,18 +306,6 @@ Lardon3DProjectDbResult
 lardon3d_project_db_list_feature_sets(Lardon3DProjectDb *database, uint64_t after_feature_set_id,
                                       Lardon3DProjectDbFeatureSet *feature_sets, size_t capacity,
                                       size_t *count);
-Lardon3DProjectDbResult lardon3d_project_db_publish_feature_support(
-    Lardon3DProjectDb *database, const Lardon3DProjectDbFeatureSupportSet *configuration,
-    const Lardon3DProjectDbFeatureSupportGroup *groups, size_t group_count,
-    Lardon3DProjectDbFeatureSupportSet *published);
-Lardon3DProjectDbResult lardon3d_project_db_load_feature_support(
-    Lardon3DProjectDb *database, uint64_t image_id, uint64_t first_feature_set_id,
-    uint64_t second_feature_set_id, const unsigned char parameter_fingerprint[32],
-    Lardon3DProjectDbFeatureSupportSet *support_set);
-Lardon3DProjectDbResult lardon3d_project_db_list_feature_support_groups(
-    Lardon3DProjectDb *database, uint64_t feature_support_set_id,
-    uint64_t after_feature_support_group_id, Lardon3DProjectDbFeatureSupportGroup *groups,
-    size_t capacity, size_t *count);
 Lardon3DProjectDbResult lardon3d_project_db_create_visual_index(
     Lardon3DProjectDb *database, const Lardon3DProjectDbVisualIndex *configuration,
     Lardon3DProjectDbVisualIndex *visual_index);
@@ -432,13 +331,4 @@ Lardon3DProjectDbResult lardon3d_project_db_load_visual_index_update_task(
     Lardon3DProjectDb *database, uint64_t task_id,
     Lardon3DProjectDbVisualIndexUpdateTask *parameters);
 
-Lardon3DProjectDbResult lardon3d_project_db_record_candidate_pair_generate_task(
-    Lardon3DProjectDb *database, const Lardon3DTaskDurableSnapshot *snapshot,
-    const char *task_kind, uint32_t task_kind_version,
-    const Lardon3DProjectDbCheckpoint *checkpoint,
-    const Lardon3DProjectDbCandidatePairGenerateTask *parameters, int64_t updated_at);
-Lardon3DProjectDbResult lardon3d_project_db_load_candidate_pair_generate_task(
-    Lardon3DProjectDb *database, uint64_t task_id,
-    Lardon3DProjectDbCandidatePairGenerateTask *parameters);
-
 #endif

include/lardon3d/sift_task.h

@@ -1,21 +0,0 @@
-#ifndef LARDON3D_SIFT_TASK_H
-#define LARDON3D_SIFT_TASK_H
-
-#include <lardon3d/app_state.h>
-#include <lardon3d/feature_extractor.h>
-#include <lardon3d/task_kind_registry.h>
-
-#define LARDON3D_SIFT_EXTRACT_TASK_KIND "features.extract.sift"
-#define LARDON3D_ROOTSIFT_EXTRACT_TASK_KIND "features.extract.rootsift"
-enum { LARDON3D_SIFT_EXTRACT_TASK_KIND_VERSION = 1 };
-
-Lardon3DTask *lardon3d_project_create_sift_extract_task(
-    Lardon3DAppState *state, uint64_t image_id, const Lardon3DSiftExtractorParameters *parameters,
-    uint64_t *task_id);
-bool lardon3d_project_enqueue_sift_extract(
-    Lardon3DAppState *state, uint64_t image_id, const Lardon3DSiftExtractorParameters *parameters,
-    uint64_t *task_id);
-bool lardon3d_sift_extract_reconstruct(const Lardon3DTaskDurableSnapshot *snapshot, void *context,
-                                       Lardon3DTaskKindBinding *binding);
-
-#endif

meson.build

@@ -62,8 +62,6 @@ executable(
         'src/feature_task.c', 'src/sift_task.c', 'src/precision_features.c',
         'src/visual_index.c',
         'src/visual_index_task.c',
-        'src/candidate_pair_gen.c',
-        'src/candidate_pair_task.c',
         'src/image_view.c',
         'src/project.c',
         'src/project_db.c',
@@ -115,7 +113,6 @@ import_task_test = executable(
         'src/feature_store.c',
         'src/visual_index.c',
         'src/visual_index_task.c',
-        'src/candidate_pair_gen.c', 'src/candidate_pair_task.c',
         'src/feature_extractor_opencv.cpp',
         'src/task_queue.c',
         'src/resource_governor.c',
@@ -191,26 +188,6 @@ feature_store_test = executable(
 
 test('feature-store', feature_store_test, timeout: 60)
 
-feature_file_robustness_test = executable(
-    'test-feature-file-robustness',
-    sources: [
-        'tests/test_feature_file_robustness.c',
-        'src/app_state.c',
-        'src/image_catalog_persistent.c',
-        'src/feature_extractor_opencv.cpp',
-        'src/feature_store.c',
-        'src/project_db.c',
-        'src/task.c',
-        'src/resource_governor.c',
-        'src/resource_snapshot.c',
-    ],
-    c_args: ['-DLARDON3D_PROJECT_DB_TESTING', '-DLARDON3D_FEATURE_STORE_TESTING'],
-    include_directories: include_directories('include'),
-    dependencies: [threads, sqlite3, openssl, opencv],
-)
-
-test('feature-file-robustness', feature_file_robustness_test, timeout: 60)
-
 visual_index_test = executable(
     'test-visual-index',
     sources: [
@@ -228,49 +205,6 @@ visual_index_test = executable(
 )
 test('visual-index', visual_index_test, timeout: 60)
 
-candidate_pair_gen_test = executable(
-    'test-candidate-pair-gen',
-    sources: [
-        'tests/test_candidate_pair_gen.c', 'src/app_state.c',
-        'src/image_catalog_persistent.c', 'src/feature_store.c',
-        'src/feature_extractor_opencv.cpp',
-        'src/visual_index.c', 'src/candidate_pair_gen.c',
-        'src/project_db.c', 'src/task.c',
-        'src/resource_governor.c', 'src/resource_snapshot.c',
-    ],
-    include_directories: include_directories('include'),
-    dependencies: [threads, sqlite3, openssl, opencv],
-)
-test('candidate-pair-gen', candidate_pair_gen_test, timeout: 60)
-
-candidate_pair_task_test = executable(
-    'test-candidate-pair-task',
-    sources: [
-        'tests/test_candidate_pair_task.c', 'src/app_state.c',
-        'src/project.c', 'src/project_db.c', 'src/task.c',
-        'src/task_checkpoint.c', 'src/task_kind_registry.c',
-        'src/task_kinds.c', 'src/task_queue.c', 'src/import.c',
-        'src/import_task.c', 'src/image_catalog.c',
-        'src/image_catalog_persistent.c', 'src/image_view.c',
-        'src/feature_task.c', 'src/sift_task.c',
-        'src/precision_features.c', 'src/feature_store.c',
-        'src/visual_index.c', 'src/visual_index_task.c',
-        'src/candidate_pair_gen.c', 'src/candidate_pair_task.c',
-        'src/feature_extractor_opencv.cpp',
-        'src/resource_governor.c', 'src/resource_snapshot.c',
-    ],
-    c_args: [
-        '-DLARDON3D_PROJECT_DB_TESTING',
-        '-DLARDON3D_CANDIDATE_PAIR_TASK_TESTING',
-        '-DLARDON3D_VISUAL_INDEX_TASK_TESTING',
-        '-DLARDON3D_FEATURE_TASK_TESTING',
-    ],
-    include_directories: include_directories('include'),
-    dependencies: [threads, sqlite3, openssl, opencv],
-)
-test('candidate-pair-task', candidate_pair_task_test, timeout: 60,
-     env: opencv_test_environment)
-
 feature_task_test = executable(
     'test-feature-task',
     sources: [
@@ -282,7 +216,6 @@ feature_task_test = executable(
         'src/feature_task.c', 'src/sift_task.c', 'src/precision_features.c',
         'src/feature_store.c', 'src/visual_index.c',
         'src/visual_index_task.c',
-        'src/candidate_pair_gen.c', 'src/candidate_pair_task.c',
         'src/feature_extractor_opencv.cpp', 'src/resource_governor.c',
         'src/resource_snapshot.c',
     ],
@@ -315,7 +248,6 @@ precision_consolidation_test = executable(
         'src/feature_task.c', 'src/sift_task.c',
         'src/precision_features.c', 'src/feature_store.c',
         'src/visual_index.c', 'src/visual_index_task.c',
-        'src/candidate_pair_gen.c', 'src/candidate_pair_task.c',
         'src/feature_extractor_opencv.cpp',
         'src/resource_governor.c', 'src/resource_snapshot.c',
     ],
@@ -404,7 +336,6 @@ project_test = executable(
         'src/feature_store.c',
         'src/visual_index.c',
         'src/visual_index_task.c',
-        'src/candidate_pair_gen.c', 'src/candidate_pair_task.c',
         'src/feature_extractor_opencv.cpp',
         'src/task_queue.c',
         'src/import.c',

src/candidate_pair_gen.c

@@ -1,171 +0,0 @@
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-
-#include <lardon3d/candidate_pair_gen.h>
-#include <lardon3d/project_db.h>
-#include <lardon3d/visual_index.h>
-
-#include <openssl/sha.h>
-
-static Lardon3DVisualIndexResult db_result(Lardon3DProjectDbResult result) {
-  switch (result) {
-  case LARDON3D_PROJECT_DB_OK:
-    return LARDON3D_VISUAL_INDEX_OK;
-  case LARDON3D_PROJECT_DB_NOT_FOUND:
-    return LARDON3D_VISUAL_INDEX_NOT_FOUND;
-  case LARDON3D_PROJECT_DB_BUSY:
-    return LARDON3D_VISUAL_INDEX_DB_BUSY;
-  case LARDON3D_PROJECT_DB_INVALID_ARGUMENT:
-    return LARDON3D_VISUAL_INDEX_INVALID_ARGUMENT;
-  case LARDON3D_PROJECT_DB_UNSUPPORTED_SCHEMA:
-    return LARDON3D_VISUAL_INDEX_UNSUPPORTED_VERSION;
-  case LARDON3D_PROJECT_DB_CORRUPT:
-    return LARDON3D_VISUAL_INDEX_CORRUPT;
-  default:
-    return LARDON3D_VISUAL_INDEX_DB_ERROR;
-  }
-}
-
-Lardon3DVisualIndexResult lardon3d_candidate_pair_generate(
-    const char *project_path, Lardon3DProjectDb *database, uint64_t visual_index_id,
-    uint64_t source_feature_set_id, const Lardon3DVisualIndexQueryOptions *query_options,
-    Lardon3DCandidatePairGenStats *stats) {
-  if (stats) {
-    stats->generated_count = 0;
-    stats->skipped_count = 0;
-    stats->queried_count = 0;
-  }
-  if (!project_path || !database || visual_index_id == 0 || source_feature_set_id == 0 ||
-      !query_options || !stats || query_options->top_k == 0 ||
-      query_options->top_k > LARDON3D_VISUAL_INDEX_TOP_K_MAX ||
-      query_options->minimum_evidence_count > 1024 ||
-      query_options->scanset_filter > LARDON3D_VISUAL_INDEX_OTHER_SCANSETS) {
-    return LARDON3D_VISUAL_INDEX_INVALID_ARGUMENT;
-  }
-  Lardon3DProjectDbFeatureSet source_set;
-  Lardon3DProjectDbResult loaded =
-      lardon3d_project_db_load_feature_set(database, source_feature_set_id, &source_set);
-  if (loaded != LARDON3D_PROJECT_DB_OK) {
-    return db_result(loaded);
-  }
-  Lardon3DVisualIndexCandidate *candidates = calloc(query_options->top_k, sizeof(*candidates));
-  if (!candidates) {
-    return LARDON3D_VISUAL_INDEX_IO_ERROR;
-  }
-  size_t result_count = 0;
-  Lardon3DVisualIndexResult result = lardon3d_visual_index_query(
-      project_path, database, visual_index_id, source_feature_set_id, query_options, candidates,
-      query_options->top_k, &result_count);
-  if (result != LARDON3D_VISUAL_INDEX_OK) {
-    free(candidates);
-    return result;
-  }
-  stats->queried_count = (uint32_t)result_count;
-  time_t now = time(NULL);
-  if (now < 0) {
-    free(candidates);
-    return LARDON3D_VISUAL_INDEX_IO_ERROR;
-  }
-  for (size_t i = 0; i < result_count; ++i) {
-    uint64_t candidate_image_id = candidates[i].image_id;
-    if (candidate_image_id == source_set.image_id) {
-      continue;
-    }
-    uint64_t image_a = candidate_image_id < source_set.image_id ? candidate_image_id
-                                                                : source_set.image_id;
-    uint64_t image_b = candidate_image_id < source_set.image_id ? source_set.image_id
-                                                                : candidate_image_id;
-    Lardon3DProjectDbCandidatePair pair;
-    Lardon3DProjectDbResult found =
-        lardon3d_project_db_find_candidate_pair(database, image_a, image_b, &pair);
-    if (found == LARDON3D_PROJECT_DB_OK) {
-      ++stats->skipped_count;
-    } else if (found == LARDON3D_PROJECT_DB_NOT_FOUND) {
-      Lardon3DProjectDbResult created =
-          lardon3d_project_db_create_candidate_pair(database, image_a, image_b, (int64_t)now,
-                                                    &pair);
-      if (created != LARDON3D_PROJECT_DB_OK) {
-        free(candidates);
-        return db_result(created);
-      }
-      ++stats->generated_count;
-    } else {
-      free(candidates);
-      return db_result(found);
-    }
-  }
-  free(candidates);
-  return LARDON3D_VISUAL_INDEX_OK;
-}
-
-Lardon3DVisualIndexResult lardon3d_candidate_pair_generate_batch(
-    const char *project_path, Lardon3DProjectDb *database,
-    uint64_t visual_index_id, uint64_t after_feature_set_id,
-    const Lardon3DVisualIndexQueryOptions *query_options,
-    Lardon3DCandidatePairGenStats *total_stats,
-    uint64_t *last_feature_set_id) {
-  if (total_stats) {
-    total_stats->generated_count = 0;
-    total_stats->skipped_count = 0;
-    total_stats->queried_count = 0;
-  }
-  if (last_feature_set_id) {
-    *last_feature_set_id = after_feature_set_id;
-  }
-  if (!project_path || !database || visual_index_id == 0 || !query_options ||
-      !total_stats || !last_feature_set_id) {
-    return LARDON3D_VISUAL_INDEX_INVALID_ARGUMENT;
-  }
-  enum { PAGE_SIZE = 64 };
-  Lardon3DProjectDbFeatureSet page[PAGE_SIZE];
-  size_t count = 0;
-  uint64_t cursor = after_feature_set_id;
-  Lardon3DProjectDbResult listed =
-      lardon3d_project_db_list_feature_sets(database, cursor, page, PAGE_SIZE, &count);
-  if (listed != LARDON3D_PROJECT_DB_OK) {
-    return db_result(listed);
-  }
-  while (count > 0) {
-    for (size_t i = 0; i < count; ++i) {
-      Lardon3DCandidatePairGenStats stats;
-      Lardon3DVisualIndexResult result = lardon3d_candidate_pair_generate(
-          project_path, database, visual_index_id, page[i].feature_set_id,
-          query_options, &stats);
-      if (result != LARDON3D_VISUAL_INDEX_OK) {
-        return result;
-      }
-      total_stats->generated_count += stats.generated_count;
-      total_stats->skipped_count += stats.skipped_count;
-      total_stats->queried_count += stats.queried_count;
-      cursor = page[i].feature_set_id;
-    }
-    listed = lardon3d_project_db_list_feature_sets(database, cursor, page, PAGE_SIZE, &count);
-    if (listed != LARDON3D_PROJECT_DB_OK) {
-      return db_result(listed);
-    }
-  }
-  *last_feature_set_id = cursor;
-  return LARDON3D_VISUAL_INDEX_OK;
-}
-
-void lardon3d_candidate_pair_generation_fingerprint(
-    uint64_t visual_index_id, uint64_t source_feature_set_id,
-    const Lardon3DVisualIndexQueryOptions *query_options,
-    unsigned char fingerprint[32]) {
-  SHA256_CTX sha;
-  SHA256_Init(&sha);
-  SHA256_Update(&sha, &visual_index_id, sizeof(visual_index_id));
-  SHA256_Update(&sha, &source_feature_set_id, sizeof(source_feature_set_id));
-  if (query_options) {
-    SHA256_Update(&sha, &query_options->top_k, sizeof(query_options->top_k));
-    SHA256_Update(&sha, &query_options->minimum_evidence_count,
-                  sizeof(query_options->minimum_evidence_count));
-    SHA256_Update(&sha, &query_options->scanset_filter, sizeof(query_options->scanset_filter));
-    bool exclude = query_options->exclude_same_asset;
-    SHA256_Update(&sha, &exclude, sizeof(exclude));
-  }
-  SHA256_Final(fingerprint, &sha);
-}

src/candidate_pair_task.c

@@ -1,317 +0,0 @@
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-#include <unistd.h>
-
-#include <lardon3d/candidate_pair_gen.h>
-#include <lardon3d/candidate_pair_task.h>
-#include <lardon3d/project.h>
-#include <lardon3d/task_queue.h>
-
-enum {
-    CANDIDATE_PAIR_MINIMUM_BATCH = 1,
-    CANDIDATE_PAIR_MAXIMUM_BATCH = 64,
-    CANDIDATE_PAIR_FIXED_MEMORY = 128 * 1024,
-    CANDIDATE_PAIR_MEMORY_PER_ITEM = 256 * 256,
-};
-
-typedef struct {
-    char project_path[PATH_MAX];
-    Lardon3DProjectDb *database;
-    Lardon3DResourceGovernor *governor;
-    Lardon3DProjectDbCandidatePairGenerateTask parameters;
-} Lardon3DCandidatePairTaskContext;
-
-static void destroy_context(void *userdata) { free(userdata); }
-
-static void runtime_state(const Lardon3DCandidatePairTaskContext *context,
-                          Lardon3DAppState *state) {
-    lardon3d_app_state_init(state);
-    state->project_loaded = true;
-    state->project_db = context->database;
-    state->resource_governor = context->governor;
-    (void)snprintf(state->project_path, sizeof(state->project_path), "%s",
-                   context->project_path);
-}
-
-static void finished_callback(const Lardon3DTask *task, void *userdata) {
-#ifdef LARDON3D_CANDIDATE_PAIR_TASK_TESTING
-    const char *skip = getenv("LARDON3D_TEST_CANDIDATE_PAIR_SKIP_FINISHED_CHECKPOINT");
-    if (skip && strcmp(skip, "1") == 0) return;
-#endif
-    Lardon3DCandidatePairTaskContext *context = userdata;
-    Lardon3DAppState state;
-    runtime_state(context, &state);
-    (void)lardon3d_project_checkpoint_candidate_pair_generate_task(
-        &state, task, &context->parameters);
-}
-
-static uint64_t elapsed_ns(struct timespec begin, struct timespec end) {
-    uint64_t s = end.tv_sec >= begin.tv_sec ? (uint64_t)(end.tv_sec - begin.tv_sec) : 0;
-    long n = end.tv_nsec - begin.tv_nsec;
-    if (n < 0 && s) {
-        --s;
-        n += 1000000000L;
-    }
-    return s <= UINT64_MAX / 1000000000ULL
-               ? s * 1000000000ULL + (uint64_t)n
-               : UINT64_MAX;
-}
-
-enum { FEATURE_SET_PAGE = 64 };
-
-static bool run(Lardon3DTask *task, void *userdata) {
-    Lardon3DCandidatePairTaskContext *context = userdata;
-
-    Lardon3DVisualIndexQueryOptions query_options = {
-        .top_k = context->parameters.top_k,
-        .minimum_evidence_count = context->parameters.minimum_evidence_count,
-        .scanset_filter = (Lardon3DVisualIndexScanSetFilter)context->parameters.scanset_filter,
-        .exclude_same_asset = context->parameters.exclude_same_asset,
-    };
-
-    uint64_t total_generated = 0;
-    uint64_t total_feature_sets = 0;
-
-    for (;;) {
-        Lardon3DTaskExecutionContract contract;
-        if (!lardon3d_task_execution_contract(task, &contract) ||
-            contract.batch_size < CANDIDATE_PAIR_MINIMUM_BATCH ||
-            contract.batch_size > CANDIDATE_PAIR_MAXIMUM_BATCH) {
-            return lardon3d_task_fail(task, "Contrat de lot Candidate Pair invalide.");
-        }
-
-        size_t processed_in_sequence = 0;
-        uint64_t cursor = context->parameters.after_feature_set_id;
-        Lardon3DProjectDbFeatureSet page[FEATURE_SET_PAGE];
-        size_t count = 0;
-        Lardon3DProjectDbResult listed =
-            lardon3d_project_db_list_feature_sets(context->database, cursor, page,
-                                                  FEATURE_SET_PAGE, &count);
-        if (listed != LARDON3D_PROJECT_DB_OK) {
-            return lardon3d_task_fail(task,
-                                      "Liste des Feature Sets impossible.");
-        }
-
-        struct timespec begin, end;
-        (void)clock_gettime(CLOCK_MONOTONIC, &begin);
-        uint64_t seq_generated = 0;
-
-        while (count > 0 &&
-               processed_in_sequence < contract.batch_size) {
-            for (size_t i = 0; i < count &&
-                 processed_in_sequence < contract.batch_size;
-                 ++i) {
-                if (!lardon3d_task_checkpoint(task)) {
-                    return false;
-                }
-                Lardon3DCandidatePairGenStats stats;
-                Lardon3DVisualIndexResult result =
-                    lardon3d_candidate_pair_generate(
-                        context->project_path, context->database,
-                        context->parameters.visual_index_id,
-                        page[i].feature_set_id, &query_options, &stats);
-                if (result != LARDON3D_VISUAL_INDEX_OK) {
-                    return lardon3d_task_fail(
-                        task, "Génération Candidate Pair impossible.");
-                }
-                seq_generated += stats.generated_count;
-                cursor = page[i].feature_set_id;
-                ++processed_in_sequence;
-            }
-            if (processed_in_sequence < contract.batch_size) {
-                listed = lardon3d_project_db_list_feature_sets(
-                    context->database, cursor, page, FEATURE_SET_PAGE,
-                    &count);
-                if (listed != LARDON3D_PROJECT_DB_OK) {
-                    return lardon3d_task_fail(
-                        task, "Liste des Feature Sets impossible.");
-                }
-            }
-        }
-
-        (void)clock_gettime(CLOCK_MONOTONIC, &end);
-        total_generated += seq_generated;
-        total_feature_sets += processed_in_sequence;
-
-        context->parameters.after_feature_set_id = cursor;
-
-        bool exhausted = (count == 0);
-        unsigned int progress = exhausted ? 100U
-            : (total_feature_sets == 0 ? 0U
-                   : (unsigned int)((total_feature_sets * 99U) /
-                                    (total_feature_sets + 1U)));
-
-        char msg[LARDON3D_TASK_MESSAGE_CAPACITY];
-        (void)snprintf(msg, sizeof(msg), "FS:%lu générées:%lu",
-                       (unsigned long)total_feature_sets,
-                       (unsigned long)total_generated);
-        if (!lardon3d_task_set_progress(task, progress, msg)) {
-            return false;
-        }
-
-        (void)lardon3d_resource_governor_record_batch(
-            context->governor, LARDON3D_RESOURCE_TASK_CPU,
-            (size_t)seq_generated, elapsed_ns(begin, end), 0);
-
-        Lardon3DAppState state;
-        runtime_state(context, &state);
-        if (lardon3d_project_checkpoint_candidate_pair_generate_task(
-                &state, task, &context->parameters) !=
-            LARDON3D_PROJECT_TASK_CHECKPOINT_OK) {
-            return lardon3d_task_fail(
-                task, "Checkpoint Candidate Pair impossible.");
-        }
-
-#ifdef LARDON3D_CANDIDATE_PAIR_TASK_TESTING
-        bool test_pause_requested = false;
-        const char *pause = getenv(
-            "LARDON3D_TEST_CANDIDATE_PAIR_PAUSE_AFTER_BATCH");
-        if (pause && strcmp(pause, "1") == 0) {
-            (void)lardon3d_task_pause(task);
-            test_pause_requested = true;
-        }
-#endif
-
-        if (exhausted
-#ifdef LARDON3D_CANDIDATE_PAIR_TASK_TESTING
-            && !test_pause_requested
-#endif
-        ) {
-            return lardon3d_task_set_progress(
-                task, 100, "Génération Candidate Pair terminée.");
-        }
-
-        Lardon3DResourceReservation *reservation = NULL;
-        if (!lardon3d_task_sequence_break(task, context->governor,
-                                          &reservation, &contract)) {
-            return false;
-        }
-    }
-}
-
-static Lardon3DCandidatePairTaskContext *
-make_context(const Lardon3DTaskReconstructionContext *runtime,
-             const Lardon3DProjectDbCandidatePairGenerateTask *parameters) {
-    if (!runtime || !runtime->project_path || !runtime->project_db ||
-        !runtime->resource_governor || !parameters) {
-        return NULL;
-    }
-    Lardon3DCandidatePairTaskContext *context =
-        calloc(1, sizeof(*context));
-    if (!context) return NULL;
-    int n = snprintf(context->project_path, sizeof(context->project_path),
-                     "%s", runtime->project_path);
-    if (n <= 0 || (size_t)n >= sizeof(context->project_path)) {
-        free(context);
-        return NULL;
-    }
-    context->database = runtime->project_db;
-    context->governor = runtime->resource_governor;
-    context->parameters = *parameters;
-    return context;
-}
-
-bool lardon3d_candidate_pair_generate_reconstruct(
-    const Lardon3DTaskDurableSnapshot *snapshot, void *userdata,
-    Lardon3DTaskKindBinding *binding) {
-    Lardon3DTaskReconstructionContext *runtime = userdata;
-    if (!snapshot || !runtime || !binding) return false;
-    Lardon3DProjectDbCandidatePairGenerateTask parameters;
-    if (lardon3d_project_db_load_candidate_pair_generate_task(
-            runtime->project_db, snapshot->id,
-            &parameters) != LARDON3D_PROJECT_DB_OK) {
-        return false;
-    }
-    Lardon3DCandidatePairTaskContext *context =
-        make_context(runtime, &parameters);
-    if (!context) return false;
-    *binding = (Lardon3DTaskKindBinding){
-        .callback = run,
-        .userdata = context,
-        .userdata_destroy = destroy_context,
-        .finished_callback = finished_callback,
-        .finished_userdata = context,
-    };
-    return true;
-}
-
-Lardon3DTask *lardon3d_project_create_candidate_pair_generate_task(
-    Lardon3DAppState *state, uint64_t visual_index_id,
-    const Lardon3DVisualIndexQueryOptions *query_options,
-    uint64_t *task_id) {
-    if (task_id) *task_id = 0;
-    if (!state || !state->project_loaded || !state->project_db ||
-        !state->resource_governor || !task_id || visual_index_id == 0 ||
-        !query_options || query_options->top_k == 0 ||
-        query_options->top_k > LARDON3D_VISUAL_INDEX_TOP_K_MAX ||
-        query_options->minimum_evidence_count > 1024 ||
-        (int)query_options->scanset_filter < 0 ||
-        (int)query_options->scanset_filter > 2) {
-        return NULL;
-    }
-    uint64_t id = 0;
-    if (lardon3d_project_db_allocate_task_id(state->project_db, &id) !=
-        LARDON3D_PROJECT_DB_OK) {
-        return NULL;
-    }
-    Lardon3DProjectDbCandidatePairGenerateTask parameters = {
-        .task_id = id,
-        .visual_index_id = visual_index_id,
-        .after_feature_set_id = 0,
-        .top_k = query_options->top_k,
-        .minimum_evidence_count = query_options->minimum_evidence_count,
-        .scanset_filter = (int)query_options->scanset_filter,
-        .exclude_same_asset = query_options->exclude_same_asset,
-    };
-    Lardon3DTaskReconstructionContext runtime = {
-        state->project_path, state->project_db,
-        state->resource_governor};
-    Lardon3DCandidatePairTaskContext *context =
-        make_context(&runtime, &parameters);
-    if (!context) return NULL;
-    const Lardon3DResourceEstimate estimate = {
-        .memory_fixed_bytes = CANDIDATE_PAIR_FIXED_MEMORY,
-        .memory_bytes_per_item = CANDIDATE_PAIR_MEMORY_PER_ITEM,
-        .minimum_batch_size = CANDIDATE_PAIR_MINIMUM_BATCH,
-        .maximum_batch_size = CANDIDATE_PAIR_MAXIMUM_BATCH,
-        .desired_cpu_threads = 1,
-        .desired_io_slots = 1,
-        .task_class = LARDON3D_RESOURCE_TASK_CPU,
-    };
-    Lardon3DTask *task = lardon3d_task_create_typed(
-        "Génération Candidate Pair", &estimate,
-        LARDON3D_CANDIDATE_PAIR_GENERATE_TASK_KIND,
-        LARDON3D_CANDIDATE_PAIR_GENERATE_TASK_KIND_VERSION, run, context,
-        destroy_context);
-    if (!task || !lardon3d_task_assign_id(task, id) ||
-        !lardon3d_task_set_finished_callback(task, finished_callback,
-                                             context) ||
-        lardon3d_project_checkpoint_candidate_pair_generate_task(
-            state, task, &parameters) !=
-            LARDON3D_PROJECT_TASK_CHECKPOINT_OK) {
-        lardon3d_task_destroy(task);
-        return NULL;
-    }
-    *task_id = id;
-    return task;
-}
-
-bool lardon3d_project_enqueue_candidate_pair_generate(
-    Lardon3DAppState *state, uint64_t visual_index_id,
-    const Lardon3DVisualIndexQueryOptions *query_options,
-    uint64_t *task_id) {
-    if (!state || !state->task_queue) return false;
-    Lardon3DTask *task =
-        lardon3d_project_create_candidate_pair_generate_task(
-            state, visual_index_id, query_options, task_id);
-    if (!task) return false;
-    if (!lardon3d_task_queue_add(state->task_queue, task, NULL)) {
-        lardon3d_task_destroy(task);
-        return false;
-    }
-    return true;
-}

src/feature_extractor_opencv.cpp

@@ -1,4 +1,3 @@
-#include <algorithm>
 #include <cerrno>
 #include <cmath>
 #include <cstdlib>
@@ -31,12 +30,6 @@ static void put_u32(unsigned char *output, uint32_t value) {
   output[3] = static_cast<unsigned char>(value >> 24);
 }
 
-static void put_u64(unsigned char *output, uint64_t value) {
-  for (unsigned int index = 0; index < 8; ++index) {
-    output[index] = static_cast<unsigned char>(value >> (8U * index));
-  }
-}
-
 extern "C" void lardon3d_feature_extractor_parameter_fingerprint(
     const Lardon3DFeatureExtractorParameters *parameters, unsigned char fingerprint[32]) {
   if (!fingerprint) {
@@ -54,186 +47,6 @@ extern "C" void lardon3d_feature_extractor_parameter_fingerprint(
   (void)SHA256(canonical, sizeof(canonical), fingerprint);
 }
 
-extern "C" bool
-lardon3d_sift_extractor_parameters_valid(const Lardon3DSiftExtractorParameters *p) {
-  return p && p->max_features >= 1 && p->max_features <= LARDON3D_FEATURE_MAX_FEATURES &&
-         p->octave_layers >= 1 && p->octave_layers <= 8 && std::isfinite(p->contrast_threshold) &&
-         p->contrast_threshold >= 0.001 && p->contrast_threshold <= 0.2 &&
-         std::isfinite(p->edge_threshold) && p->edge_threshold >= 1.0 &&
-         p->edge_threshold <= 100.0 && std::isfinite(p->sigma) && p->sigma >= 0.5 &&
-         p->sigma <= 3.0 && p->grid_rows >= 1 && p->grid_rows <= 32 && p->grid_cols >= 1 &&
-         p->grid_cols <= 32 && p->max_features_per_cell >= 1 &&
-         p->max_features_per_cell <= LARDON3D_FEATURE_MAX_FEATURES;
-}
-
-extern "C" Lardon3DSiftExtractorParameters lardon3d_sift_precision_classic_v1(bool rootsift) {
-  return {4096, 3, 0.02, 10.0, 1.6, 8, 8, 96, rootsift};
-}
-
-extern "C" void lardon3d_sift_extractor_parameter_fingerprint(
-    const Lardon3DSiftExtractorParameters *p, unsigned char fingerprint[32]) {
-  if (!fingerprint) return;
-  std::memset(fingerprint, 0, 32);
-  if (!lardon3d_sift_extractor_parameters_valid(p)) return;
-  unsigned char canonical[60] = {'L', '3', 'D', 'S', 'I', 'F', 'T', '1'};
-  put_u32(canonical + 8, 1);
-  put_u32(canonical + 12, p->max_features);
-  put_u32(canonical + 16, p->octave_layers);
-  uint64_t bits = 0;
-  std::memcpy(&bits, &p->contrast_threshold, 8);
-  put_u64(canonical + 20, bits);
-  std::memcpy(&bits, &p->edge_threshold, 8);
-  put_u64(canonical + 28, bits);
-  std::memcpy(&bits, &p->sigma, 8);
-  put_u64(canonical + 36, bits);
-  put_u32(canonical + 44, p->grid_rows);
-  put_u32(canonical + 48, p->grid_cols);
-  put_u32(canonical + 52, p->max_features_per_cell);
-  put_u32(canonical + 56, p->rootsift ? 1U : 0U);
-  (void)SHA256(canonical, sizeof(canonical), fingerprint);
-}
-
-static bool sift_point_before(const cv::KeyPoint &a, size_t ai, const cv::KeyPoint &b, size_t bi) {
-  if (a.response != b.response) return a.response > b.response;
-  if (a.pt.y != b.pt.y) return a.pt.y < b.pt.y;
-  if (a.pt.x != b.pt.x) return a.pt.x < b.pt.x;
-  return ai < bi;
-}
-
-static bool select_sift_points(const cv::Mat &image, const std::vector<cv::KeyPoint> &points,
-                               const Lardon3DSiftExtractorParameters *parameters,
-                               std::vector<size_t> &selected, std::vector<uint32_t> &cells) {
-  std::vector<size_t> order(points.size());
-  for (size_t index = 0; index < order.size(); ++index) order[index] = index;
-  std::sort(order.begin(), order.end(), [&](size_t a, size_t b) {
-    return sift_point_before(points[a], a, points[b], b);
-  });
-  cells.assign(static_cast<size_t>(parameters->grid_rows) * parameters->grid_cols, 0);
-  selected.reserve(parameters->max_features);
-  float width = static_cast<float>(image.cols), height = static_cast<float>(image.rows);
-  for (size_t source : order) {
-    const cv::KeyPoint &point = points[source];
-    if (!std::isfinite(point.pt.x) || !std::isfinite(point.pt.y) || point.pt.x < 0 ||
-        point.pt.y < 0 || point.pt.x >= width || point.pt.y >= height)
-      return false;
-    uint32_t column = std::min(
-        parameters->grid_cols - 1,
-        static_cast<uint32_t>(point.pt.x / width * static_cast<float>(parameters->grid_cols)));
-    uint32_t row = std::min(
-        parameters->grid_rows - 1,
-        static_cast<uint32_t>(point.pt.y / height * static_cast<float>(parameters->grid_rows)));
-    uint32_t &used = cells[static_cast<size_t>(row) * parameters->grid_cols + column];
-    if (used < parameters->max_features_per_cell) {
-      selected.push_back(source);
-      ++used;
-    }
-    if (selected.size() == parameters->max_features) break;
-  }
-  return true;
-}
-
-static Lardon3DFeatureExtractResult copy_sift_output(
-    const std::vector<cv::KeyPoint> &points, const cv::Mat &descriptors,
-    const std::vector<size_t> &selected, const Lardon3DSiftExtractorParameters *parameters,
-    Lardon3DExtractedFeatures *output) {
-  size_t count = selected.size();
-  Lardon3DFeatureKeypoint *keypoints = count ? static_cast<Lardon3DFeatureKeypoint *>(
-                                                  std::calloc(count, sizeof(*keypoints)))
-                                             : nullptr;
-  unsigned char *bytes = count ? static_cast<unsigned char *>(
-                                     std::malloc(count * 128U * sizeof(float)))
-                               : nullptr;
-  if (count && (!keypoints || !bytes)) {
-    std::free(keypoints);
-    std::free(bytes);
-    return LARDON3D_FEATURE_EXTRACT_OUT_OF_MEMORY;
-  }
-  for (size_t index = 0; index < count; ++index) {
-    const cv::KeyPoint &point = points[selected[index]];
-    int octave = point.octave & 255;
-    if (octave >= 128) octave -= 256;
-    keypoints[index] = {point.pt.x, point.pt.y, point.size, point.angle, point.response, octave};
-    const float *source = descriptors.ptr<float>(static_cast<int>(selected[index]));
-    float *destination = reinterpret_cast<float *>(bytes) + index * 128U;
-    double l1 = 0.0;
-    for (size_t dimension = 0; dimension < 128; ++dimension) {
-      if (!std::isfinite(source[dimension]) || source[dimension] < 0.0F ||
-          source[dimension] > 512.0F) {
-        std::free(keypoints);
-        std::free(bytes);
-        return LARDON3D_FEATURE_EXTRACT_ERROR;
-      }
-      if (parameters->rootsift) l1 += static_cast<double>(source[dimension]);
-    }
-    for (size_t dimension = 0; dimension < 128; ++dimension) {
-      destination[dimension] =
-          parameters->rootsift
-              ? (l1 > 0.0 ? static_cast<float>(std::sqrt(source[dimension] / l1)) : 0.0F)
-              : source[dimension];
-    }
-  }
-  output->feature_count = static_cast<uint32_t>(count);
-  output->keypoints = keypoints;
-  output->descriptors = bytes;
-  output->descriptor_bytes = count * 128U * sizeof(float);
-  return LARDON3D_FEATURE_EXTRACT_OK;
-}
-
-extern "C" Lardon3DFeatureExtractResult lardon3d_feature_extract_sift(
-    const char *path, const Lardon3DSiftExtractorParameters *p, Lardon3DExtractedFeatures *out) {
-  if (out) std::memset(out, 0, sizeof(*out));
-  if (!path || !path[0] || !out || !lardon3d_sift_extractor_parameters_valid(p))
-    return LARDON3D_FEATURE_EXTRACT_INVALID_ARGUMENT;
-  struct stat information{};
-  if (lstat(path, &information) != 0)
-    return errno == ENOENT ? LARDON3D_FEATURE_EXTRACT_IMAGE_NOT_FOUND
-                           : LARDON3D_FEATURE_EXTRACT_IMAGE_INVALID;
-  if (!S_ISREG(information.st_mode) || S_ISLNK(information.st_mode))
-    return LARDON3D_FEATURE_EXTRACT_IMAGE_INVALID;
-  try {
-    cv::Mat image = cv::imread(path, cv::IMREAD_GRAYSCALE);
-    uint64_t pixels = image.empty() ? 0 : static_cast<uint64_t>(image.cols) * image.rows;
-    if (image.empty() || image.cols <= 0 || image.rows <= 0 ||
-        pixels > LARDON3D_FEATURE_MAX_IMAGE_PIXELS)
-      return LARDON3D_FEATURE_EXTRACT_IMAGE_INVALID;
-    uint32_t candidates =
-        std::min(static_cast<uint32_t>(LARDON3D_FEATURE_MAX_FEATURES), p->max_features * 2U);
-    cv::Ptr<cv::SIFT> extractor = cv::SIFT::create(
-        static_cast<int>(candidates), static_cast<int>(p->octave_layers), p->contrast_threshold,
-        p->edge_threshold, p->sigma, true);
-    std::vector<cv::KeyPoint> points;
-    cv::Mat descriptors;
-    extractor->detectAndCompute(image, cv::noArray(), points, descriptors);
-    if ((!points.empty() && (descriptors.type() != CV_32FC1 || descriptors.cols != 128 ||
-                             descriptors.rows != static_cast<int>(points.size()))) ||
-        points.size() > 65536U)
-      return LARDON3D_FEATURE_EXTRACT_ERROR;
-    std::vector<size_t> selected;
-    std::vector<uint32_t> cells;
-    if (!select_sift_points(image, points, p, selected, cells))
-      return LARDON3D_FEATURE_EXTRACT_ERROR;
-    Lardon3DFeatureExtractResult copied = copy_sift_output(points, descriptors, selected, p, out);
-    if (copied != LARDON3D_FEATURE_EXTRACT_OK) return copied;
-    uint32_t occupied = static_cast<uint32_t>(
-        std::count_if(cells.begin(), cells.end(), [](uint32_t value) { return value > 0; }));
-    size_t cell_count = cells.size();
-    out->image_width = static_cast<uint32_t>(image.cols);
-    out->image_height = static_cast<uint32_t>(image.rows);
-    out->quality = {occupied, static_cast<uint32_t>(cell_count),
-                    static_cast<double>(occupied) / static_cast<double>(cell_count),
-                    pixels ? static_cast<double>(selected.size()) * 1000000.0 /
-                                 static_cast<double>(pixels)
-                           : 0.0};
-    return LARDON3D_FEATURE_EXTRACT_OK;
-  } catch (const cv::Exception &) {
-    return LARDON3D_FEATURE_EXTRACT_IMAGE_INVALID;
-  } catch (const std::bad_alloc &) {
-    return LARDON3D_FEATURE_EXTRACT_OUT_OF_MEMORY;
-  } catch (...) {
-    return LARDON3D_FEATURE_EXTRACT_ERROR;
-  }
-}
-
 extern "C" void lardon3d_extracted_features_destroy(Lardon3DExtractedFeatures *features) {
   if (!features) {
     return;
@@ -318,7 +131,6 @@ lardon3d_feature_extract_orb(const char *path, const Lardon3DFeatureExtractorPar
     features->feature_count = static_cast<uint32_t>(count);
     features->keypoints = keypoints;
     features->descriptors = bytes;
-    features->descriptor_bytes = count * LARDON3D_FEATURE_DESCRIPTOR_DIMENSION;
     return LARDON3D_FEATURE_EXTRACT_OK;
   } catch (const cv::Exception &) {
     return LARDON3D_FEATURE_EXTRACT_IMAGE_INVALID;

src/feature_store.c

@@ -15,7 +15,7 @@
 
 static const unsigned char feature_magic[8] = {'L', '3', 'D', 'F', 'E', 'A', 'T', 0};
 _Static_assert(sizeof(float) == 4 && FLT_RADIX == 2 && FLT_MANT_DIG == 24 && FLT_MAX_EXP == 128,
-               "Feature File v1/v2 exige IEEE-754 binary32.");
+               "Feature File v1 exige IEEE-754 binary32.");
 
 struct Lardon3DFeatureReader {
   int descriptor;
@@ -193,7 +193,7 @@ static bool valid_features(const Lardon3DExtractedFeatures *features) {
     if (!isfinite(p->x) || !isfinite(p->y) || !isfinite(p->size) || !isfinite(p->angle_degrees) ||
         !isfinite(p->response) || p->x < 0 || p->y < 0 || p->x >= (float)features->image_width ||
         p->y >= (float)features->image_height || p->size <= 0 || p->angle_degrees < 0 ||
-        p->angle_degrees >= 360 || p->octave < -128 || p->octave > 127) {
+        p->angle_degrees >= 360 || p->octave < 0 || p->octave >= 16) {
       return false;
     }
   }
@@ -251,92 +251,8 @@ static bool write_feature_file(int fd, const Lardon3DProjectDbImageAsset *image_
   return true;
 }
 
-static bool valid_f32_descriptors(const Lardon3DExtractedFeatures *features, uint32_t dimension) {
-  if (dimension != 128 ||
-      features->descriptor_bytes != (size_t)features->feature_count * dimension * sizeof(float))
-    return false;
-  size_t count = (size_t)features->feature_count * dimension;
-  for (size_t i = 0; i < count; ++i) {
-    float value;
-    memcpy(&value, features->descriptors + i * sizeof(value), sizeof(value));
-    if (!isfinite(value)) return false;
-  }
-  return true;
-}
-
-static bool write_feature_file_v2(
-    int fd, const Lardon3DProjectDbImageAsset *image_asset, const char *extractor_kind,
-    uint32_t extractor_version, const unsigned char fingerprint[32],
-    Lardon3DFeatureDescriptorType descriptor_type, uint32_t descriptor_dimension,
-    uint32_t capabilities, const Lardon3DExtractedFeatures *features, uint64_t *file_size) {
-  uint32_t scalar = descriptor_type == LARDON3D_FEATURE_DESCRIPTOR_U8 ? 1U : 4U;
-  size_t kind_length = strnlen(extractor_kind, 16);
-  if (kind_length == 0 || kind_length >= 16 || extractor_version == 0 ||
-      descriptor_dimension == 0 || descriptor_dimension > 4096 ||
-      (descriptor_type != LARDON3D_FEATURE_DESCRIPTOR_U8 &&
-       descriptor_type != LARDON3D_FEATURE_DESCRIPTOR_F32) ||
-      (descriptor_type == LARDON3D_FEATURE_DESCRIPTOR_F32 &&
-       !valid_f32_descriptors(features, descriptor_dimension))) {
-    return false;
-  }
-  uint64_t keypoint_bytes =
-      (uint64_t)features->feature_count * LARDON3D_FEATURE_KEYPOINT_RECORD_SIZE;
-  uint64_t descriptor_bytes =
-      (uint64_t)features->feature_count * descriptor_dimension * scalar;
-  uint64_t descriptor_offset = LARDON3D_FEATURE_FILE_V2_HEADER_SIZE + keypoint_bytes;
-  uint64_t total = descriptor_offset + descriptor_bytes;
-  if (total > LARDON3D_FEATURE_FILE_MAX_SIZE) return false;
-  unsigned char header[LARDON3D_FEATURE_FILE_V2_HEADER_SIZE] = {0};
-  memcpy(header, feature_magic, 8);
-  put_u32(header + 8, LARDON3D_FEATURE_FILE_VERSION_V2);
-  put_u32(header + 12, LARDON3D_FEATURE_FILE_V2_HEADER_SIZE);
-  put_u32(header + 16, features->feature_count);
-  put_u32(header + 20, descriptor_dimension);
-  put_u32(header + 24, (uint32_t)descriptor_type);
-  put_u32(header + 28, scalar);
-  put_u32(header + 32, LARDON3D_FEATURE_KEYPOINT_RECORD_SIZE);
-  put_u32(header + 36, features->image_width);
-  put_u32(header + 40, features->image_height);
-  put_u32(header + 44, capabilities);
-  put_u64(header + 48, LARDON3D_FEATURE_FILE_V2_HEADER_SIZE);
-  put_u64(header + 56, descriptor_offset);
-  put_u64(header + 64, total);
-  memcpy(header + 72, image_asset->sha256, 32);
-  memcpy(header + 104, fingerprint, 32);
-  memcpy(header + 136, extractor_kind, kind_length);
-  put_u32(header + 152, extractor_version);
-  if (!write_all(fd, header, sizeof(header))) return false;
-  unsigned char record[LARDON3D_FEATURE_KEYPOINT_RECORD_SIZE];
-  for (uint32_t i = 0; i < features->feature_count; ++i) {
-    const Lardon3DFeatureKeypoint *point = &features->keypoints[i];
-    put_float(record, point->x);
-    put_float(record + 4, point->y);
-    put_float(record + 8, point->size);
-    put_float(record + 12, point->angle_degrees);
-    put_float(record + 16, point->response);
-    put_u32(record + 20, (uint32_t)point->octave);
-    if (!write_all(fd, record, sizeof(record))) return false;
-  }
-  if (descriptor_type == LARDON3D_FEATURE_DESCRIPTOR_U8) {
-    if (descriptor_bytes && !write_all(fd, features->descriptors, (size_t)descriptor_bytes))
-      return false;
-  } else {
-    unsigned char encoded[4];
-    size_t value_count = (size_t)features->feature_count * descriptor_dimension;
-    for (size_t i = 0; i < value_count; ++i) {
-      float value;
-      memcpy(&value, features->descriptors + i * sizeof(value), sizeof(value));
-      put_float(encoded, value);
-      if (!write_all(fd, encoded, sizeof(encoded))) return false;
-    }
-  }
-  *file_size = total;
-  return true;
-}
-
 static Lardon3DFeatureStoreResult
 reuse_existing_feature_set(Lardon3DAppState *state, uint64_t image_id, uint64_t producer_task_id,
-                           const char *kind, uint32_t version,
                            const unsigned char fingerprint[32],
                            Lardon3DProjectDbFeatureSet *feature_set) {
   if (feature_set->asset.durability == LARDON3D_DB_FEATURE_ASSET_DURABLE) {
@@ -355,11 +271,10 @@ reuse_existing_feature_set(Lardon3DAppState *state, uint64_t image_id, uint64_t
   if (now < 0) {
     return LARDON3D_FEATURE_STORE_IO_ERROR;
   }
-  Lardon3DProjectDbResult promoted = lardon3d_project_db_register_feature_set_quality(
+  Lardon3DProjectDbResult promoted = lardon3d_project_db_register_feature_set(
-      state->project_db, image_id, kind, version, fingerprint, feature_set->source_image_sha256,
+      state->project_db, image_id, LARDON3D_FEATURE_EXTRACTOR_KIND,
+      LARDON3D_FEATURE_EXTRACTOR_VERSION, fingerprint, feature_set->source_image_sha256,
       feature_set->feature_count, feature_set->descriptor_type, feature_set->descriptor_dimension,
-      feature_set->occupied_cells, feature_set->total_cells, feature_set->coverage_ratio,
-      feature_set->feature_density_per_megapixel,
       feature_set->asset.sha256, feature_set->asset.path, feature_set->asset.size_bytes,
       LARDON3D_DB_FEATURE_ASSET_DURABLE, producer_task_id, now, feature_set);
   return promoted == LARDON3D_PROJECT_DB_OK ? LARDON3D_FEATURE_STORE_ALREADY_PRESENT
@@ -368,9 +283,7 @@ reuse_existing_feature_set(Lardon3DAppState *state, uint64_t image_id, uint64_t
 
 static Lardon3DFeatureStoreResult register_published_feature_set(
     Lardon3DAppState *state, uint64_t image_id, uint64_t producer_task_id,
-    const Lardon3DProjectDbImageAsset *image_asset, const char *kind, uint32_t version,
+    const Lardon3DProjectDbImageAsset *image_asset, const unsigned char fingerprint[32],
-    const unsigned char fingerprint[32], Lardon3DFeatureDescriptorType descriptor_type,
-    uint32_t descriptor_dimension,
     const Lardon3DExtractedFeatures *features, const unsigned char file_hash[32],
     const char *relative_path, uint64_t file_size, bool durable,
     Lardon3DProjectDbFeatureSet *feature_set) {
@@ -378,11 +291,11 @@ static Lardon3DFeatureStoreResult register_published_feature_set(
   if (now < 0) {
     return LARDON3D_FEATURE_STORE_IO_ERROR;
   }
-  Lardon3DProjectDbResult result = lardon3d_project_db_register_feature_set_quality(
+  Lardon3DProjectDbResult result = lardon3d_project_db_register_feature_set(
-      state->project_db, image_id, kind, version, fingerprint, image_asset->sha256,
+      state->project_db, image_id, LARDON3D_FEATURE_EXTRACTOR_KIND,
-      features->feature_count, descriptor_type, descriptor_dimension, features->quality.occupied_cells,
+      LARDON3D_FEATURE_EXTRACTOR_VERSION, fingerprint, image_asset->sha256, features->feature_count,
-      features->quality.total_cells, features->quality.coverage_ratio,
+      LARDON3D_FEATURE_DESCRIPTOR_U8, LARDON3D_FEATURE_DESCRIPTOR_DIMENSION, file_hash,
-      features->quality.feature_density_per_megapixel, file_hash, relative_path, file_size,
+      relative_path, file_size,
       durable ? LARDON3D_DB_FEATURE_ASSET_DURABLE : LARDON3D_DB_FEATURE_ASSET_PUBLISHED_NOT_DURABLE,
       producer_task_id, now, feature_set);
   if (result != LARDON3D_PROJECT_DB_OK) {
@@ -400,9 +313,7 @@ Lardon3DFeatureStoreResult lardon3d_feature_store_publish(
     memset(feature_set, 0, sizeof(*feature_set));
   }
   if (!state || !state->project_loaded || !state->project_db || !feature_set || image_id == 0 ||
-      !lardon3d_feature_extractor_parameters_valid(parameters) || !valid_features(features) ||
+      !lardon3d_feature_extractor_parameters_valid(parameters) || !valid_features(features)) {
-      features->descriptor_bytes !=
-          (size_t)features->feature_count * LARDON3D_FEATURE_DESCRIPTOR_DIMENSION) {
     return LARDON3D_FEATURE_STORE_INVALID_ARGUMENT;
   }
   unsigned char fingerprint[32];
@@ -411,9 +322,7 @@ Lardon3DFeatureStoreResult lardon3d_feature_store_publish(
       state->project_db, image_id, LARDON3D_FEATURE_EXTRACTOR_KIND,
       LARDON3D_FEATURE_EXTRACTOR_VERSION, fingerprint, feature_set);
   if (found == LARDON3D_PROJECT_DB_OK) {
-    return reuse_existing_feature_set(state, image_id, producer_task_id,
+    return reuse_existing_feature_set(state, image_id, producer_task_id, fingerprint, feature_set);
-                                      LARDON3D_FEATURE_EXTRACTOR_KIND,
-                                      LARDON3D_FEATURE_EXTRACTOR_VERSION, fingerprint, feature_set);
   }
   if (found != LARDON3D_PROJECT_DB_NOT_FOUND) {
     return found == LARDON3D_PROJECT_DB_BUSY ? LARDON3D_FEATURE_STORE_DB_BUSY
@@ -495,114 +404,12 @@ Lardon3DFeatureStoreResult lardon3d_feature_store_publish(
     durable = false;
   }
 #endif
-  return register_published_feature_set(
+  return register_published_feature_set(state, image_id, producer_task_id, &image_asset,
-      state, image_id, producer_task_id, &image_asset, LARDON3D_FEATURE_EXTRACTOR_KIND,
+                                        fingerprint, features, file_hash, relative, file_size,
-      LARDON3D_FEATURE_EXTRACTOR_VERSION, fingerprint, LARDON3D_FEATURE_DESCRIPTOR_U8,
+                                        durable, feature_set);
-      LARDON3D_FEATURE_DESCRIPTOR_DIMENSION, features, file_hash, relative, file_size, durable,
-      feature_set);
 }
 
-Lardon3DFeatureStoreResult lardon3d_feature_store_publish_v2(
+static Lardon3DFeatureStoreResult validate_header(const unsigned char h[160], uint64_t actual,
-    Lardon3DAppState *state, uint64_t image_id, uint64_t producer_task_id, const char *kind,
-    uint32_t version, const unsigned char fingerprint[32],
-    Lardon3DFeatureDescriptorType descriptor_type, uint32_t descriptor_dimension,
-    uint32_t capabilities, const Lardon3DExtractedFeatures *features,
-    Lardon3DProjectDbFeatureSet *feature_set) {
-  if (feature_set) memset(feature_set, 0, sizeof(*feature_set));
-  uint32_t known_capabilities = LARDON3D_FEATURE_HAS_SCALE |
-                                LARDON3D_FEATURE_HAS_ORIENTATION |
-                                LARDON3D_FEATURE_HAS_RESPONSE | LARDON3D_FEATURE_HAS_OCTAVE;
-  if (!state || !state->project_loaded || !state->project_db || !feature_set || image_id == 0 ||
-      !kind || !lardon3d_task_kind_is_valid(kind) || version == 0 || !fingerprint ||
-      strnlen(kind, 16) >= 16 || descriptor_dimension == 0 || descriptor_dimension > 4096 ||
-      ((strcmp(kind, "sift") == 0 || strcmp(kind, "rootsift") == 0) && version != 1) ||
-      (capabilities & ~known_capabilities) != 0 ||
-      (descriptor_type != LARDON3D_FEATURE_DESCRIPTOR_U8 &&
-       descriptor_type != LARDON3D_FEATURE_DESCRIPTOR_F32) || !valid_features(features) ||
-      (descriptor_type == LARDON3D_FEATURE_DESCRIPTOR_U8 &&
-       features->descriptor_bytes != (size_t)features->feature_count * descriptor_dimension) ||
-      (descriptor_type == LARDON3D_FEATURE_DESCRIPTOR_F32 &&
-       !valid_f32_descriptors(features, descriptor_dimension))) {
-    return LARDON3D_FEATURE_STORE_INVALID_ARGUMENT;
-  }
-  Lardon3DProjectDbResult found = lardon3d_project_db_find_feature_set(
-      state->project_db, image_id, kind, version, fingerprint, feature_set);
-  if (found == LARDON3D_PROJECT_DB_OK) {
-    return reuse_existing_feature_set(state, image_id, producer_task_id, kind, version, fingerprint,
-                                      feature_set);
-  }
-  if (found != LARDON3D_PROJECT_DB_NOT_FOUND) {
-    return found == LARDON3D_PROJECT_DB_BUSY ? LARDON3D_FEATURE_STORE_DB_BUSY
-                                             : LARDON3D_FEATURE_STORE_DB_ERROR;
-  }
-  Lardon3DProjectDbImage image;
-  Lardon3DProjectDbImageAsset image_asset;
-  if (lardon3d_project_db_load_image(state->project_db, image_id, &image, &image_asset) !=
-      LARDON3D_PROJECT_DB_OK) {
-    return LARDON3D_FEATURE_STORE_NOT_FOUND;
-  }
-  char assets[PATH_MAX], features_dir[PATH_MAX];
-  if (!join(assets, state->project_path, "assets") || !ensure_directory(assets) ||
-      !join(features_dir, assets, "features") || !ensure_directory(features_dir)) {
-    return LARDON3D_FEATURE_STORE_IO_ERROR;
-  }
-  char temporary[PATH_MAX];
-  int n = snprintf(temporary, sizeof(temporary), "%s/.feature-XXXXXX", features_dir);
-  if (n <= 0 || (size_t)n >= sizeof(temporary)) return LARDON3D_FEATURE_STORE_IO_ERROR;
-  int fd = mkstemp(temporary);
-  if (fd < 0) return LARDON3D_FEATURE_STORE_IO_ERROR;
-  uint64_t file_size = 0;
-  bool written = write_feature_file_v2(fd, &image_asset, kind, version, fingerprint,
-                                       descriptor_type, descriptor_dimension, capabilities,
-                                       features, &file_size) &&
-                 fsync(fd) == 0;
-  unsigned char file_hash[32];
-  if (written) written = sha256_fd(fd, file_hash);
-  if (close(fd) != 0) written = false;
-  if (!written) {
-    unlink(temporary);
-    return LARDON3D_FEATURE_STORE_IO_ERROR;
-  }
-  char hex[65];
-  hex_sha(file_hash, hex);
-  char prefix[PATH_MAX];
-  n = snprintf(prefix, sizeof(prefix), "%s/%.2s", features_dir, hex);
-  if (n <= 0 || (size_t)n >= sizeof(prefix) || !ensure_directory(prefix)) {
-    unlink(temporary);
-    return LARDON3D_FEATURE_STORE_IO_ERROR;
-  }
-  char relative[LARDON3D_PROJECT_DB_PATH_CAPACITY];
-  n = snprintf(relative, sizeof(relative), "assets/features/%.2s/%s", hex, hex);
-  char final[PATH_MAX];
-  if (n <= 0 || (size_t)n >= sizeof(relative) || !join(final, state->project_path, relative)) {
-    unlink(temporary);
-    return LARDON3D_FEATURE_STORE_IO_ERROR;
-  }
-  if (link(temporary, final) != 0) {
-    if (errno != EEXIST) {
-      unlink(temporary);
-      return LARDON3D_FEATURE_STORE_IO_ERROR;
-    }
-    int existing = open(final, O_RDONLY | O_NOFOLLOW | O_CLOEXEC);
-    struct stat info;
-    unsigned char existing_hash[32];
-    bool same = existing >= 0 && fstat(existing, &info) == 0 && S_ISREG(info.st_mode) &&
-                info.st_size >= 0 && (uint64_t)info.st_size == file_size &&
-                sha256_fd(existing, existing_hash) && memcmp(existing_hash, file_hash, 32) == 0;
-    if (existing >= 0) (void)close(existing);
-    if (!same) {
-      unlink(temporary);
-      return LARDON3D_FEATURE_STORE_CORRUPT;
-    }
-  }
-  unlink(temporary);
-  bool durable = sync_directory(prefix);
-  return register_published_feature_set(
-      state, image_id, producer_task_id, &image_asset, kind, version, fingerprint, descriptor_type,
-      descriptor_dimension, features, file_hash, relative, file_size, durable, feature_set);
-}
-
-static Lardon3DFeatureStoreResult validate_header_v1(const unsigned char h[160], uint64_t actual,
                                                   Lardon3DFeatureFileMetadata *m, uint64_t *ko,
                                                   uint64_t *doff) {
   if (memcmp(h, feature_magic, 8) != 0) {
@@ -620,7 +427,7 @@ static Lardon3DFeatureStoreResult validate_header_v1(const unsigned char h[160],
   if (get_u32(h + 12) != 160 || count > LARDON3D_FEATURE_MAX_FEATURES || dim != 32 ||
       type != LARDON3D_FEATURE_DESCRIPTOR_U8 || record != 24 || width == 0 || height == 0 ||
       key != 160 || desc != key + kb || declared != desc + db || declared != actual ||
-      actual > LARDON3D_FEATURE_FILE_V1_MAX_SIZE || memcmp(h + 128, "orb\0", 4) != 0 ||
+      actual > LARDON3D_FEATURE_FILE_MAX_SIZE || memcmp(h + 128, "orb\0", 4) != 0 ||
       get_u32(h + 144) != 1) {
     return LARDON3D_FEATURE_STORE_CORRUPT;
   }
@@ -639,11 +446,6 @@ static Lardon3DFeatureStoreResult validate_header_v1(const unsigned char h[160],
                                      .feature_count = count,
                                      .descriptor_dimension = dim,
                                      .descriptor_type = (Lardon3DFeatureDescriptorType)type,
-                                     .descriptor_scalar_size_bytes = 1,
-                                     .capabilities = LARDON3D_FEATURE_HAS_SCALE |
-                                                     LARDON3D_FEATURE_HAS_ORIENTATION |
-                                                     LARDON3D_FEATURE_HAS_RESPONSE |
-                                                     LARDON3D_FEATURE_HAS_OCTAVE,
                                      .image_width = width,
                                      .image_height = height};
   memcpy(m->source_image_sha256, h + 64, 32);
@@ -654,68 +456,6 @@ static Lardon3DFeatureStoreResult validate_header_v1(const unsigned char h[160],
   return LARDON3D_FEATURE_STORE_OK;
 }
 
-static Lardon3DFeatureStoreResult validate_header_v2(const unsigned char h[176], uint64_t actual,
-                                                     Lardon3DFeatureFileMetadata *m, uint64_t *ko,
-                                                     uint64_t *doff) {
-  uint32_t count = get_u32(h + 16), dim = get_u32(h + 20), type = get_u32(h + 24);
-  uint32_t scalar = get_u32(h + 28), record = get_u32(h + 32), width = get_u32(h + 36);
-  uint32_t height = get_u32(h + 40), capabilities = get_u32(h + 44);
-  uint64_t key = get_u64(h + 48), desc = get_u64(h + 56), declared = get_u64(h + 64);
-  bool known_type = (type == LARDON3D_FEATURE_DESCRIPTOR_U8 && scalar == 1) ||
-                    (type == LARDON3D_FEATURE_DESCRIPTOR_F32 && scalar == 4);
-  uint64_t key_bytes = (uint64_t)count * record;
-  uint64_t descriptor_bytes = (uint64_t)count * dim * scalar;
-  uint32_t known_capabilities = LARDON3D_FEATURE_HAS_SCALE |
-                                LARDON3D_FEATURE_HAS_ORIENTATION |
-                                LARDON3D_FEATURE_HAS_RESPONSE | LARDON3D_FEATURE_HAS_OCTAVE;
-  if (memcmp(h, feature_magic, 8) != 0 || get_u32(h + 8) != 2 || get_u32(h + 12) != 176 ||
-      count > LARDON3D_FEATURE_MAX_FEATURES || !known_type || dim == 0 || dim > 4096 ||
-      record != 24 || width == 0 || height == 0 || (capabilities & ~known_capabilities) != 0 ||
-      key != 176 || desc != key + key_bytes || declared != desc + descriptor_bytes ||
-      declared != actual || actual > LARDON3D_FEATURE_FILE_MAX_SIZE || h[136] == 0 ||
-      get_u32(h + 152) == 0) {
-    return LARDON3D_FEATURE_STORE_CORRUPT;
-  }
-  for (size_t i = 156; i < 176; ++i) {
-    if (h[i] != 0) return LARDON3D_FEATURE_STORE_CORRUPT;
-  }
-  if (!memchr(h + 136, 0, 16)) return LARDON3D_FEATURE_STORE_CORRUPT;
-  *m = (Lardon3DFeatureFileMetadata){.format_version = 2,
-                                     .extractor_version = get_u32(h + 152),
-                                     .feature_count = count,
-                                     .descriptor_dimension = dim,
-                                     .descriptor_type = (Lardon3DFeatureDescriptorType)type,
-                                     .descriptor_scalar_size_bytes = scalar,
-                                     .capabilities = capabilities,
-                                     .image_width = width,
-                                     .image_height = height};
-  memcpy(m->source_image_sha256, h + 72, 32);
-  memcpy(m->parameter_fingerprint, h + 104, 32);
-  memcpy(m->extractor_kind, h + 136, 16);
-  m->extractor_kind[15] = '\0';
-  *ko = key;
-  *doff = desc;
-  return LARDON3D_FEATURE_STORE_OK;
-}
-
-static bool validate_f32_payload(int fd, uint64_t offset, uint32_t count, uint32_t dimension) {
-  unsigned char encoded[LARDON3D_FEATURE_READER_RANGE_MAX * 128 * 4];
-  if (dimension != 128) return false;
-  for (uint32_t start = 0; start < count;) {
-    uint32_t features = count - start;
-    if (features > LARDON3D_FEATURE_READER_RANGE_MAX)
-      features = LARDON3D_FEATURE_READER_RANGE_MAX;
-    size_t values = (size_t)features * dimension;
-    size_t bytes = values * 4;
-    uint64_t position = offset + (uint64_t)start * dimension * 4;
-    if (!read_exact(fd, encoded, bytes, (off_t)position)) return false;
-    for (size_t i = 0; i < values; ++i)
-      if (!isfinite(get_float(encoded + i * 4))) return false;
-    start += features;
-  }
-  return true;
-}
-
 Lardon3DFeatureStoreResult lardon3d_feature_reader_open(const char *project_path,
                                                         const Lardon3DProjectDbFeatureSet *set,
                                                         Lardon3DFeatureReader **out,
@@ -742,8 +482,8 @@ Lardon3DFeatureStoreResult lardon3d_feature_reader_open(const char *project_path
     close(fd);
     return LARDON3D_FEATURE_STORE_CORRUPT;
   }
-  unsigned char header[176] = {0};
+  unsigned char header[160];
-  if (!read_exact(fd, header, 160, 0)) {
+  if (!read_exact(fd, header, sizeof(header), 0)) {
     close(fd);
     return LARDON3D_FEATURE_STORE_CORRUPT;
   }
@@ -752,23 +492,9 @@ Lardon3DFeatureStoreResult lardon3d_feature_reader_open(const char *project_path
     close(fd);
     return LARDON3D_FEATURE_STORE_IO_ERROR;
   }
-  uint32_t version = get_u32(header + 8);
+  Lardon3DFeatureStoreResult result =
-  if (version == 2 && !read_exact(fd, header + 160, 16, 160)) {
+      validate_header(header, (uint64_t)st.st_size, &reader->metadata, &reader->keypoint_offset,
-    close(fd);
+                      &reader->descriptor_offset);
-    free(reader);
-    return LARDON3D_FEATURE_STORE_CORRUPT;
-  }
-  Lardon3DFeatureStoreResult result;
-  if (version == 1) {
-    result = validate_header_v1(header, (uint64_t)st.st_size, &reader->metadata,
-                                &reader->keypoint_offset, &reader->descriptor_offset);
-  } else if (version == 2) {
-    result = validate_header_v2(header, (uint64_t)st.st_size, &reader->metadata,
-                                &reader->keypoint_offset, &reader->descriptor_offset);
-  } else {
-    result = version > 2 ? LARDON3D_FEATURE_STORE_UNSUPPORTED_VERSION
-                         : LARDON3D_FEATURE_STORE_INVALID;
-  }
   if (result != LARDON3D_FEATURE_STORE_OK) {
     close(fd);
     free(reader);
@@ -791,13 +517,6 @@ Lardon3DFeatureStoreResult lardon3d_feature_reader_open(const char *project_path
     free(reader);
     return LARDON3D_FEATURE_STORE_CORRUPT;
   }
-  if (reader->metadata.descriptor_type == LARDON3D_FEATURE_DESCRIPTOR_F32 &&
-      !validate_f32_payload(fd, reader->descriptor_offset, reader->metadata.feature_count,
-                            reader->metadata.descriptor_dimension)) {
-    close(fd);
-    free(reader);
-    return LARDON3D_FEATURE_STORE_CORRUPT;
-  }
   reader->descriptor = fd;
   *metadata = reader->metadata;
   *out = reader;
@@ -830,11 +549,7 @@ Lardon3DFeatureStoreResult lardon3d_feature_reader_keypoints(Lardon3DFeatureRead
                                        get_float(record + 8),  get_float(record + 12),
                                        get_float(record + 16), (int32_t)get_u32(record + 20)};
     if (!isfinite(out[i].x) || !isfinite(out[i].y) || !isfinite(out[i].size) ||
-        !isfinite(out[i].angle_degrees) || !isfinite(out[i].response) || out[i].x < 0.0F ||
+        !isfinite(out[i].angle_degrees) || !isfinite(out[i].response)) {
-        out[i].y < 0.0F || out[i].x >= (float)r->metadata.image_width ||
-        out[i].y >= (float)r->metadata.image_height || out[i].size <= 0.0F ||
-        out[i].angle_degrees < 0.0F || out[i].angle_degrees >= 360.0F ||
-        out[i].octave < -128 || out[i].octave > 127) {
       return LARDON3D_FEATURE_STORE_CORRUPT;
     }
   }
@@ -844,50 +559,17 @@ Lardon3DFeatureStoreResult lardon3d_feature_reader_keypoints(Lardon3DFeatureRead
 Lardon3DFeatureStoreResult lardon3d_feature_reader_descriptors(Lardon3DFeatureReader *r,
                                                                uint32_t start, unsigned char *out,
                                                                size_t capacity, size_t bytes) {
-  return lardon3d_feature_reader_descriptors_u8(r, start, out, capacity, bytes);
+  if (!r || (!out && capacity > 0) || capacity > LARDON3D_FEATURE_READER_RANGE_MAX ||
-}
+      start > r->metadata.feature_count || capacity > (size_t)(r->metadata.feature_count - start) ||
-
+      capacity > SIZE_MAX / r->metadata.descriptor_dimension ||
-static bool descriptor_range_valid(const Lardon3DFeatureReader *r, uint32_t start,
+      bytes < capacity * r->metadata.descriptor_dimension) {
-                                   size_t capacity, size_t scalar, size_t bytes) {
-  return r && capacity <= LARDON3D_FEATURE_READER_RANGE_MAX &&
-         start <= r->metadata.feature_count &&
-         capacity <= (size_t)(r->metadata.feature_count - start) &&
-         r->metadata.descriptor_dimension <= SIZE_MAX / scalar &&
-         capacity <= SIZE_MAX / (r->metadata.descriptor_dimension * scalar) &&
-         bytes >= capacity * r->metadata.descriptor_dimension * scalar;
-}
-
-Lardon3DFeatureStoreResult lardon3d_feature_reader_descriptors_u8(
-    Lardon3DFeatureReader *r, uint32_t start, unsigned char *out, size_t capacity, size_t bytes) {
-  if (!r || r->metadata.descriptor_type != LARDON3D_FEATURE_DESCRIPTOR_U8 ||
-      (!out && capacity > 0) || !descriptor_range_valid(r, start, capacity, 1, bytes)) {
     return LARDON3D_FEATURE_STORE_INVALID_ARGUMENT;
   }
   size_t amount = capacity * r->metadata.descriptor_dimension;
-  uint64_t offset = r->descriptor_offset + (uint64_t)start * r->metadata.descriptor_dimension;
+  if (amount && !read_exact(r->descriptor, out, amount,
-  return amount && !read_exact(r->descriptor, out, amount, (off_t)offset)
+                            (off_t)(r->descriptor_offset +
-             ? LARDON3D_FEATURE_STORE_IO_ERROR
+                                    (uint64_t)start * r->metadata.descriptor_dimension))) {
-             : LARDON3D_FEATURE_STORE_OK;
-}
-
-Lardon3DFeatureStoreResult lardon3d_feature_reader_descriptors_f32(
-    Lardon3DFeatureReader *r, uint32_t start, float *out, size_t capacity, size_t bytes) {
-  if (!r || (!out && capacity > 0) || capacity > LARDON3D_FEATURE_READER_RANGE_MAX ||
-      r->metadata.descriptor_type != LARDON3D_FEATURE_DESCRIPTOR_F32 ||
-      !descriptor_range_valid(r, start, capacity, 4, bytes)) {
-    return LARDON3D_FEATURE_STORE_INVALID_ARGUMENT;
-  }
-  unsigned char encoded[256 * 128 * 4];
-  if (r->metadata.descriptor_dimension > 128) return LARDON3D_FEATURE_STORE_CORRUPT;
-  size_t values = capacity * r->metadata.descriptor_dimension;
-  size_t amount = values * 4;
-  uint64_t offset = r->descriptor_offset + (uint64_t)start * r->metadata.descriptor_dimension * 4;
-  if (amount && !read_exact(r->descriptor, encoded, amount, (off_t)offset)) {
     return LARDON3D_FEATURE_STORE_IO_ERROR;
   }
-  for (size_t i = 0; i < values; ++i) {
-    out[i] = get_float(encoded + i * 4);
-    if (!isfinite(out[i])) return LARDON3D_FEATURE_STORE_CORRUPT;
-  }
   return LARDON3D_FEATURE_STORE_OK;
 }

src/precision_features.c

@@ -1,205 +0,0 @@
-#include <float.h>
-#include <math.h>
-#include <openssl/evp.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-
-#include <lardon3d/feature_store.h>
-#include <lardon3d/precision_features.h>
-
-enum { SUPPORT_BUCKETS = 16384 };
-
-Lardon3DFeatureConsolidationParameters lardon3d_feature_consolidation_v1(void) {
-  return (Lardon3DFeatureConsolidationParameters){.association_radius_pixels = 4.0};
-}
-
-bool lardon3d_feature_consolidation_parameters_valid(
-    const Lardon3DFeatureConsolidationParameters *p) {
-  return p && isfinite(p->association_radius_pixels) && p->association_radius_pixels >= 0.5 &&
-         p->association_radius_pixels <= 64.0;
-}
-
-void lardon3d_feature_consolidation_fingerprint(
-    const Lardon3DFeatureConsolidationParameters *p, unsigned char fingerprint[32]) {
-  if (!fingerprint) return;
-  memset(fingerprint, 0, 32);
-  if (!lardon3d_feature_consolidation_parameters_valid(p)) return;
-  unsigned char encoded[20] = {'L', '3', 'D', 'S', 'U', 'P', 'P', '1', 1};
-  uint64_t bits = 0;
-  memcpy(&bits, &p->association_radius_pixels, sizeof(bits));
-  for (unsigned i = 0; i < 8; ++i) encoded[12 + i] = (unsigned char)(bits >> (8U * i));
-  EVP_MD_CTX *context = EVP_MD_CTX_new();
-  unsigned int length = 0;
-  if (!context || EVP_DigestInit_ex(context, EVP_sha256(), NULL) != 1 ||
-      EVP_DigestUpdate(context, encoded, sizeof(encoded)) != 1 ||
-      EVP_DigestFinal_ex(context, fingerprint, &length) != 1 || length != 32) {
-    memset(fingerprint, 0, 32);
-  }
-  EVP_MD_CTX_free(context);
-}
-
-bool lardon3d_feature_support_higher_quality(
-    const Lardon3DProjectDbFeatureSupportGroup *candidate,
-    const Lardon3DProjectDbFeatureSupportGroup *reference) {
-  if (!candidate || !reference) return false;
-  if (candidate->support_count != reference->support_count)
-    return candidate->support_count > reference->support_count;
-  return candidate->feature_support_group_id < reference->feature_support_group_id;
-}
-
-static bool read_points(const char *project_path, const Lardon3DProjectDbFeatureSet *set,
-                        Lardon3DFeatureKeypoint **points) {
-  *points = NULL;
-  Lardon3DFeatureReader *reader = NULL;
-  Lardon3DFeatureFileMetadata metadata;
-  if (lardon3d_feature_reader_open(project_path, set, &reader, &metadata) !=
-      LARDON3D_FEATURE_STORE_OK) {
-    return false;
-  }
-  Lardon3DFeatureKeypoint *all = set->feature_count
-                                    ? calloc(set->feature_count, sizeof(*all))
-                                    : NULL;
-  bool ok = set->feature_count == 0 || all != NULL;
-  for (uint32_t start = 0; ok && start < set->feature_count;) {
-    size_t count = set->feature_count - start;
-    if (count > LARDON3D_FEATURE_READER_RANGE_MAX) count = LARDON3D_FEATURE_READER_RANGE_MAX;
-    ok = lardon3d_feature_reader_keypoints(reader, start, all + start, count) ==
-         LARDON3D_FEATURE_STORE_OK;
-    start += (uint32_t)count;
-  }
-  lardon3d_feature_reader_close(reader);
-  if (!ok) free(all);
-  else *points = all;
-  return ok;
-}
-
-static uint32_t bucket_for(int64_t x, int64_t y) {
-  uint64_t a = (uint64_t)x * UINT64_C(0x9e3779b185ebca87);
-  uint64_t b = (uint64_t)y * UINT64_C(0xc2b2ae3d27d4eb4f);
-  return (uint32_t)((a ^ b) & (SUPPORT_BUCKETS - 1));
-}
-
-static bool associate_points(const Lardon3DFeatureKeypoint *orb, uint32_t orb_count,
-                             const Lardon3DFeatureKeypoint *sift, uint32_t sift_count,
-                             double radius, Lardon3DProjectDbFeatureSupportGroup *groups) {
-  int32_t heads[SUPPORT_BUCKETS];
-  for (size_t i = 0; i < SUPPORT_BUCKETS; ++i) heads[i] = -1;
-  int32_t *next = orb_count ? malloc((size_t)orb_count * sizeof(*next)) : NULL;
-  bool *used = orb_count ? calloc(orb_count, sizeof(*used)) : NULL;
-  if (orb_count && (!next || !used)) {
-    free(next);
-    free(used);
-    return false;
-  }
-  for (uint32_t i = 0; i < orb_count; ++i) {
-    int64_t cx = (int64_t)floor(orb[i].x / radius);
-    int64_t cy = (int64_t)floor(orb[i].y / radius);
-    uint32_t bucket = bucket_for(cx, cy);
-    next[i] = heads[bucket];
-    heads[bucket] = (int32_t)i;
-    groups[i] = (Lardon3DProjectDbFeatureSupportGroup){
-        .x = orb[i].x, .y = orb[i].y, .support_count = 1, .first_feature_index = i};
-  }
-  uint32_t unmatched = orb_count;
-  double radius_squared = radius * radius;
-  for (uint32_t s = 0; s < sift_count; ++s) {
-    int64_t cx = (int64_t)floor(sift[s].x / radius);
-    int64_t cy = (int64_t)floor(sift[s].y / radius);
-    int32_t best = -1;
-    double best_distance = radius_squared;
-    for (int dy = -1; dy <= 1; ++dy) for (int dx = -1; dx <= 1; ++dx) {
-      for (int32_t candidate = heads[bucket_for(cx + dx, cy + dy)]; candidate >= 0;
-           candidate = next[candidate]) {
-        if (used[candidate]) continue;
-        double px = orb[candidate].x - sift[s].x;
-        double py = orb[candidate].y - sift[s].y;
-        double distance = px * px + py * py;
-        if (distance <= best_distance &&
-            (distance < best_distance || best < 0 || candidate < best)) {
-          best = candidate;
-          best_distance = distance;
-        }
-      }
-    }
-    if (best >= 0) {
-      used[best] = true;
-      groups[best].x = sift[s].x;
-      groups[best].y = sift[s].y;
-      groups[best].support_count = 2;
-      groups[best].distance_pixels = sqrt(best_distance);
-      groups[best].has_second_feature = true;
-      groups[best].second_feature_index = s;
-    } else {
-      groups[unmatched++] = (Lardon3DProjectDbFeatureSupportGroup){
-          .x = sift[s].x, .y = sift[s].y, .support_count = 1,
-          .first_member_from_second_set = true, .first_feature_index = s};
-    }
-  }
-  free(used);
-  free(next);
-  return true;
-}
-
-Lardon3DProjectDbResult lardon3d_consolidate_orb_sift(
-    Lardon3DAppState *state, uint64_t orb_id, uint64_t sift_id,
-    const Lardon3DFeatureConsolidationParameters *p,
-    Lardon3DProjectDbFeatureSupportSet *published) {
-  if (!state || !state->project_loaded || !state->project_db || state->project_path[0] == '\0' ||
-      !published || !lardon3d_feature_consolidation_parameters_valid(p)) {
-    return LARDON3D_PROJECT_DB_INVALID_ARGUMENT;
-  }
-  Lardon3DProjectDbFeatureSet orb, sift;
-  if (lardon3d_project_db_load_feature_set(state->project_db, orb_id, &orb) !=
-          LARDON3D_PROJECT_DB_OK ||
-      lardon3d_project_db_load_feature_set(state->project_db, sift_id, &sift) !=
-          LARDON3D_PROJECT_DB_OK ||
-      orb.image_id != sift.image_id || strcmp(orb.extractor_kind, "orb") != 0 ||
-      (strcmp(sift.extractor_kind, "sift") != 0 && strcmp(sift.extractor_kind, "rootsift") != 0)) {
-    return LARDON3D_PROJECT_DB_INVALID_ARGUMENT;
-  }
-  unsigned char fingerprint[32];
-  lardon3d_feature_consolidation_fingerprint(p, fingerprint);
-  Lardon3DProjectDbResult found = lardon3d_project_db_load_feature_support(
-      state->project_db, orb.image_id, orb_id, sift_id, fingerprint, published);
-  if (found == LARDON3D_PROJECT_DB_OK)
-    return published->radius_pixels == p->association_radius_pixels
-               ? LARDON3D_PROJECT_DB_OK
-               : LARDON3D_PROJECT_DB_CORRUPT;
-  if (found != LARDON3D_PROJECT_DB_NOT_FOUND) return found;
-  Lardon3DFeatureKeypoint *orb_points = NULL, *sift_points = NULL;
-  if (!read_points(state->project_path, &orb, &orb_points) ||
-      !read_points(state->project_path, &sift, &sift_points)) {
-    free(orb_points);
-    free(sift_points);
-    return LARDON3D_PROJECT_DB_CORRUPT;
-  }
-  size_t count = (size_t)orb.feature_count + sift.feature_count;
-  Lardon3DProjectDbFeatureSupportGroup *groups = count ? calloc(count, sizeof(*groups)) : NULL;
-  if (count && !groups) {
-    free(orb_points);
-    free(sift_points);
-    return LARDON3D_PROJECT_DB_IO_ERROR;
-  }
-  if (!associate_points(orb_points, orb.feature_count, sift_points, sift.feature_count,
-                        p->association_radius_pixels, groups)) {
-    free(groups);
-    free(orb_points);
-    free(sift_points);
-    return LARDON3D_PROJECT_DB_IO_ERROR;
-  }
-  uint32_t matched = 0;
-  for (uint32_t i = 0; i < orb.feature_count; ++i) matched += groups[i].support_count == 2;
-  size_t group_count = count - matched;
-  Lardon3DProjectDbFeatureSupportSet config = {
-      .image_id = orb.image_id, .first_feature_set_id = orb_id, .second_feature_set_id = sift_id,
-      .radius_pixels = p->association_radius_pixels, .created_at = (int64_t)time(NULL)};
-  memcpy(config.parameter_fingerprint, fingerprint, 32);
-  Lardon3DProjectDbResult result = lardon3d_project_db_publish_feature_support(
-      state->project_db, &config, groups, group_count, published);
-  free(groups);
-  free(orb_points);
-  free(sift_points);
-  return result;
-}

src/project.c

@@ -670,9 +670,7 @@ static Lardon3DProjectTaskCheckpointResult
 checkpoint_task_internal(Lardon3DAppState *state, const Lardon3DTask *task,
                          const char *image_import_source, uint64_t image_import_scanset_id,
                          const Lardon3DProjectDbFeatureExtractTask *feature_parameters,
-                         const Lardon3DProjectDbSiftExtractTask *sift_parameters,
+                         const Lardon3DProjectDbVisualIndexUpdateTask *visual_parameters) {
-                         const Lardon3DProjectDbVisualIndexUpdateTask *visual_parameters,
-                         const Lardon3DProjectDbCandidatePairGenerateTask *candidate_parameters) {
   if (!state || !state->project_loaded || !state->project_db) {
     return LARDON3D_PROJECT_TASK_CHECKPOINT_NO_PROJECT;
   }
@@ -719,18 +717,10 @@ checkpoint_task_internal(Lardon3DAppState *state, const Lardon3DTask *task,
           ? lardon3d_project_db_record_feature_extract_task(state->project_db, &snapshot, task_kind,
                                                             task_kind_version, &checkpoint,
                                                             feature_parameters, now.tv_sec)
-      : sift_parameters
-          ? lardon3d_project_db_record_sift_extract_task(
-                state->project_db, &snapshot, task_kind, task_kind_version, &checkpoint,
-                sift_parameters, now.tv_sec)
       : visual_parameters
           ? lardon3d_project_db_record_visual_index_update_task(
                 state->project_db, &snapshot, task_kind, task_kind_version, &checkpoint,
                 visual_parameters, now.tv_sec)
-      : candidate_parameters
-          ? lardon3d_project_db_record_candidate_pair_generate_task(
-                state->project_db, &snapshot, task_kind, task_kind_version, &checkpoint,
-                candidate_parameters, now.tv_sec)
           : lardon3d_project_db_record_task(state->project_db, &snapshot, task_kind,
                                             task_kind_version, &checkpoint, now.tv_sec);
   if (recorded == LARDON3D_PROJECT_DB_BUSY) {
@@ -746,7 +736,7 @@ checkpoint_task_internal(Lardon3DAppState *state, const Lardon3DTask *task,
 
 Lardon3DProjectTaskCheckpointResult lardon3d_project_checkpoint_task(Lardon3DAppState *state,
                                                                      const Lardon3DTask *task) {
-  return checkpoint_task_internal(state, task, NULL, 0, NULL, NULL, NULL, NULL);
+  return checkpoint_task_internal(state, task, NULL, 0, NULL, NULL);
 }
 
 Lardon3DProjectTaskCheckpointResult
@@ -755,7 +745,7 @@ lardon3d_project_checkpoint_image_import_task(Lardon3DAppState *state, const Lar
   if (!source_path || !source_path[0] || scanset_id == 0) {
     return LARDON3D_PROJECT_TASK_CHECKPOINT_INVALID_TASK;
   }
-  return checkpoint_task_internal(state, task, source_path, scanset_id, NULL, NULL, NULL, NULL);
+  return checkpoint_task_internal(state, task, source_path, scanset_id, NULL, NULL);
 }
 
 Lardon3DProjectTaskCheckpointResult lardon3d_project_checkpoint_feature_extract_task(
@@ -764,14 +754,7 @@ Lardon3DProjectTaskCheckpointResult lardon3d_project_checkpoint_feature_extract_
   if (!parameters) {
     return LARDON3D_PROJECT_TASK_CHECKPOINT_INVALID_TASK;
   }
-  return checkpoint_task_internal(state, task, NULL, 0, parameters, NULL, NULL, NULL);
+  return checkpoint_task_internal(state, task, NULL, 0, parameters, NULL);
-}
-
-Lardon3DProjectTaskCheckpointResult lardon3d_project_checkpoint_sift_extract_task(
-    Lardon3DAppState *state, const Lardon3DTask *task,
-    const Lardon3DProjectDbSiftExtractTask *parameters) {
-  if (!parameters) return LARDON3D_PROJECT_TASK_CHECKPOINT_INVALID_TASK;
-  return checkpoint_task_internal(state, task, NULL, 0, NULL, parameters, NULL, NULL);
 }
 
 Lardon3DProjectTaskCheckpointResult lardon3d_project_checkpoint_visual_index_update_task(
@@ -780,16 +763,7 @@ Lardon3DProjectTaskCheckpointResult lardon3d_project_checkpoint_visual_index_upd
   if (!parameters) {
     return LARDON3D_PROJECT_TASK_CHECKPOINT_INVALID_TASK;
   }
-  return checkpoint_task_internal(state, task, NULL, 0, NULL, NULL, parameters, NULL);
+  return checkpoint_task_internal(state, task, NULL, 0, NULL, parameters);
-}
-
-Lardon3DProjectTaskCheckpointResult lardon3d_project_checkpoint_candidate_pair_generate_task(
-    Lardon3DAppState *state, const Lardon3DTask *task,
-    const Lardon3DProjectDbCandidatePairGenerateTask *parameters) {
-  if (!parameters) {
-    return LARDON3D_PROJECT_TASK_CHECKPOINT_INVALID_TASK;
-  }
-  return checkpoint_task_internal(state, task, NULL, 0, NULL, NULL, NULL, parameters);
 }
 
 static bool coherent_recovery(const Lardon3DProjectDbTask *database_task,

src/project_db.c

@@ -1,6 +1,5 @@
 #include <errno.h>
 #include <limits.h>
-#include <math.h>
 #include <pthread.h>
 #include <sqlite3.h>
 #include <stdbool.h>
@@ -140,65 +139,6 @@ static const char schema_visual_v6[] =
     "ON DELETE CASCADE,visual_index_id INTEGER NOT NULL REFERENCES visual_indexes(visual_index_id),"
     "after_feature_set_id INTEGER NOT NULL CHECK(after_feature_set_id>=0));";
 
-static const char schema_precision_v7[] =
-    "ALTER TABLE feature_sets ADD COLUMN occupied_cells INTEGER NOT NULL DEFAULT 0 "
-    "CHECK(occupied_cells>=0 AND occupied_cells<=1024);"
-    "ALTER TABLE feature_sets ADD COLUMN total_cells INTEGER NOT NULL DEFAULT 0 "
-    "CHECK(total_cells>=0 AND total_cells<=1024 AND occupied_cells<=total_cells);"
-    "ALTER TABLE feature_sets ADD COLUMN coverage_ratio REAL NOT NULL DEFAULT 0.0 "
-    "CHECK(coverage_ratio>=0.0 AND coverage_ratio<=1.0);"
-    "ALTER TABLE feature_sets ADD COLUMN feature_density_per_megapixel REAL NOT NULL DEFAULT 0.0 "
-    "CHECK(feature_density_per_megapixel>=0.0);"
-    "CREATE TABLE sift_extract_tasks(task_id INTEGER PRIMARY KEY REFERENCES tasks(task_id) ON "
-    "DELETE CASCADE,image_id INTEGER NOT NULL REFERENCES images(image_id),extractor_kind TEXT NOT "
-    "NULL CHECK(extractor_kind IN('sift','rootsift')),extractor_version INTEGER NOT NULL "
-    "CHECK(extractor_version=1),max_features INTEGER NOT NULL CHECK(max_features BETWEEN 1 AND "
-    "8192),octave_layers INTEGER NOT NULL CHECK(octave_layers BETWEEN 1 AND 8),"
-    "contrast_threshold REAL NOT NULL CHECK(contrast_threshold BETWEEN 0.001 AND 0.2),"
-    "edge_threshold REAL NOT NULL CHECK(edge_threshold BETWEEN 1.0 AND 100.0),sigma REAL NOT NULL "
-    "CHECK(sigma BETWEEN 0.5 AND 3.0),grid_rows INTEGER NOT NULL CHECK(grid_rows BETWEEN 1 AND 32),"
-    "grid_cols INTEGER NOT NULL CHECK(grid_cols BETWEEN 1 AND 32),max_features_per_cell INTEGER "
-    "NOT NULL CHECK(max_features_per_cell BETWEEN 1 AND 8192),parameter_fingerprint BLOB NOT NULL "
-    "CHECK(length(parameter_fingerprint)=32));"
-    "CREATE TABLE feature_support_sets(feature_support_set_id INTEGER PRIMARY KEY AUTOINCREMENT "
-    "CHECK(feature_support_set_id>0),image_id INTEGER NOT NULL REFERENCES images(image_id),"
-    "first_feature_set_id INTEGER NOT NULL REFERENCES feature_sets(feature_set_id),"
-    "second_feature_set_id INTEGER NOT NULL REFERENCES feature_sets(feature_set_id),radius_pixels "
-    "REAL NOT NULL CHECK(radius_pixels>0.0 AND radius_pixels<=64.0),parameter_fingerprint BLOB NOT "
-    "NULL CHECK(length(parameter_fingerprint)=32),created_at INTEGER NOT NULL CHECK(created_at>=0),"
-    "UNIQUE(image_id,first_feature_set_id,second_feature_set_id,parameter_fingerprint));"
-    "CREATE TABLE feature_support_groups(feature_support_group_id INTEGER PRIMARY KEY AUTOINCREMENT "
-    "CHECK(feature_support_group_id>0),feature_support_set_id INTEGER NOT NULL REFERENCES "
-    "feature_support_sets(feature_support_set_id) ON DELETE CASCADE,x REAL NOT NULL,y REAL NOT NULL,"
-    "distance_pixels REAL NOT NULL CHECK(distance_pixels>=0.0 AND distance_pixels<=64.0),"
-    "support_count INTEGER NOT NULL CHECK(support_count BETWEEN 1 AND 3));"
-    "CREATE INDEX feature_support_groups_set_idx ON feature_support_groups(feature_support_set_id,"
-    "feature_support_group_id);"
-    "CREATE TABLE feature_support_members(feature_support_group_id INTEGER NOT NULL REFERENCES "
-    "feature_support_groups(feature_support_group_id) ON DELETE CASCADE,feature_set_id INTEGER NOT "
-    "NULL REFERENCES feature_sets(feature_set_id),feature_index INTEGER NOT NULL CHECK(feature_index "
-    "BETWEEN 0 AND 8191),extractor_kind TEXT NOT NULL CHECK(length(extractor_kind)>0 AND "
-    "length(extractor_kind)<65),PRIMARY KEY(feature_support_group_id,feature_set_id));";
-
-static const char schema_candidate_v8[] =
-    "CREATE TABLE candidate_pairs(candidate_pair_id INTEGER PRIMARY KEY AUTOINCREMENT "
-    "CHECK(candidate_pair_id>0),image_id_a INTEGER NOT NULL REFERENCES images(image_id),"
-    "image_id_b INTEGER NOT NULL REFERENCES images(image_id),created_at INTEGER NOT NULL "
-    "CHECK(created_at>=0),CHECK(image_id_a<image_id_b),UNIQUE(image_id_a,image_id_b));"
-    "CREATE INDEX candidate_pairs_image_a_idx ON candidate_pairs(image_id_a);"
-    "CREATE INDEX candidate_pairs_image_b_idx ON candidate_pairs(image_id_b);";
-
-static const char schema_candidate_generate_v9[] =
-    "CREATE TABLE candidate_pair_generate_tasks(task_id INTEGER PRIMARY KEY REFERENCES "
-    "tasks(task_id) ON DELETE CASCADE,"
-    "visual_index_id INTEGER NOT NULL CHECK(visual_index_id>0),"
-    "after_feature_set_id INTEGER NOT NULL CHECK(after_feature_set_id>=0),"
-    "top_k INTEGER NOT NULL CHECK(top_k>0 AND top_k<=256),"
-    "minimum_evidence_count INTEGER NOT NULL CHECK(minimum_evidence_count>=0 "
-    "AND minimum_evidence_count<=1024),"
-    "scanset_filter INTEGER NOT NULL CHECK(scanset_filter>=0 AND scanset_filter<=2),"
-    "exclude_same_asset INTEGER NOT NULL CHECK(exclude_same_asset IN (0,1)));";
-
 static void copy_error(char destination[LARDON3D_PROJECT_DB_ERROR_CAPACITY], const char *text) {
   if (destination) {
     (void)snprintf(destination, LARDON3D_PROJECT_DB_ERROR_CAPACITY, "%s", text ? text : "");
@@ -287,8 +227,7 @@ static Lardon3DProjectDbResult migrate(Lardon3DProjectDb *database, unsigned int
     return LARDON3D_PROJECT_DB_OK;
   }
   if (from_version != 0 && from_version != 1 && from_version != 2 && from_version != 3 &&
-      from_version != 4 && from_version != 5 && from_version != 6 && from_version != 7 &&
+      from_version != 4 && from_version != 5) {
-      from_version != 8) {
     return LARDON3D_PROJECT_DB_CORRUPT;
   }
   Lardon3DProjectDbResult result = execute(database, "BEGIN IMMEDIATE", "begin migration");
@@ -454,51 +393,6 @@ static Lardon3DProjectDbResult migrate(Lardon3DProjectDb *database, unsigned int
                        "finish schema v6 migration");
     }
   }
-  if (result == LARDON3D_PROJECT_DB_OK && from_version < 7) {
-    result = execute(database, schema_precision_v7, "migrate schema v6 to v7");
-#ifdef LARDON3D_PROJECT_DB_TESTING
-    const char *forced_failure = getenv("LARDON3D_TEST_PROJECT_DB_FAIL_MIGRATION_V7");
-    if (result == LARDON3D_PROJECT_DB_OK && forced_failure && strcmp(forced_failure, "1") == 0) {
-      result = execute(database, "INSERT INTO missing_test_table VALUES(1)",
-                       "forced migration v7 failure");
-    }
-#endif
-    if (result == LARDON3D_PROJECT_DB_OK) {
-      result = execute(database,
-                       "UPDATE metadata SET value=7 WHERE key='schema_version' AND value=6",
-                       "finish schema v7 migration");
-    }
-  }
-  if (result == LARDON3D_PROJECT_DB_OK && from_version < 8) {
-    result = execute(database, schema_candidate_v8, "migrate schema v7 to v8");
-#ifdef LARDON3D_PROJECT_DB_TESTING
-    const char *forced_failure = getenv("LARDON3D_TEST_PROJECT_DB_FAIL_MIGRATION_V8");
-    if (result == LARDON3D_PROJECT_DB_OK && forced_failure && strcmp(forced_failure, "1") == 0) {
-      result = execute(database, "INSERT INTO missing_test_table VALUES(1)",
-                       "forced migration v8 failure");
-    }
-#endif
-    if (result == LARDON3D_PROJECT_DB_OK) {
-      result = execute(database,
-                       "UPDATE metadata SET value=8 WHERE key='schema_version' AND value=7",
-                       "finish schema v8 migration");
-    }
-  }
-  if (result == LARDON3D_PROJECT_DB_OK && from_version < 9) {
-    result = execute(database, schema_candidate_generate_v9, "migrate schema v8 to v9");
-#ifdef LARDON3D_PROJECT_DB_TESTING
-    const char *forced_failure = getenv("LARDON3D_TEST_PROJECT_DB_FAIL_MIGRATION_V9");
-    if (result == LARDON3D_PROJECT_DB_OK && forced_failure && strcmp(forced_failure, "1") == 0) {
-      result = execute(database, "INSERT INTO missing_test_table VALUES(1)",
-                       "forced migration v9 failure");
-    }
-#endif
-    if (result == LARDON3D_PROJECT_DB_OK) {
-      result = execute(database,
-                       "UPDATE metadata SET value=9 WHERE key='schema_version' AND value=8",
-                       "finish schema v9 migration");
-    }
-  }
   if (result == LARDON3D_PROJECT_DB_OK) {
     result = execute(database, "COMMIT", "commit migration");
   }
@@ -606,13 +500,8 @@ Lardon3DProjectDbResult lardon3d_project_db_open(const char *path, Lardon3DProje
                               "images",
                               "feature_assets",
                               "feature_sets",
-                              "feature_extract_tasks",
+                              "feature_extract_tasks"};
-                              "sift_extract_tasks",
+    for (size_t index = 0; index < 11 && result == LARDON3D_PROJECT_DB_OK; ++index) {
-                              "feature_support_sets",
-                              "feature_support_groups",
-                              "feature_support_members",
-                              "candidate_pairs"};
-    for (size_t index = 0; index < 16 && result == LARDON3D_PROJECT_DB_OK; ++index) {
       if (!table_exists(database->connection, required[index])) {
         copy_error(database->error, "Schéma v1 incomplet.");
         result = LARDON3D_PROJECT_DB_CORRUPT;
@@ -797,9 +686,7 @@ record_task_internal(Lardon3DProjectDb *database, const Lardon3DTaskDurableSnaps
                      const char *task_kind, uint32_t task_kind_version,
                      const Lardon3DProjectDbCheckpoint *checkpoint, const char *source_path,
                      uint64_t scanset_id, const Lardon3DProjectDbFeatureExtractTask *feature,
-                     const Lardon3DProjectDbSiftExtractTask *sift,
                      const Lardon3DProjectDbVisualIndexUpdateTask *visual,
-                     const Lardon3DProjectDbCandidatePairGenerateTask *candidate_pair,
                      int64_t updated_at) {
   bool typed = task_kind != NULL;
   if (!database || !valid_durable_task(snapshot, updated_at) ||
@@ -814,28 +701,9 @@ record_task_internal(Lardon3DProjectDb *database, const Lardon3DTaskDurableSnaps
         feature->max_features == 0 || feature->max_features > 8192 ||
         feature->pyramid_levels == 0 || feature->pyramid_levels > 16 ||
         feature->fast_threshold == 0 || feature->fast_threshold > 255)) ||
-      (sift &&
-       (!valid_task_id(sift->task_id) || sift->task_id != snapshot->id ||
-        !valid_task_id(sift->image_id) ||
-        (strcmp(sift->extractor_kind, "sift") != 0 &&
-         strcmp(sift->extractor_kind, "rootsift") != 0) ||
-        sift->extractor_version != 1 || sift->max_features == 0 ||
-        sift->max_features > 8192 || sift->octave_layers == 0 || sift->octave_layers > 8 ||
-        sift->contrast_threshold < 0.001 || sift->contrast_threshold > 0.2 ||
-        sift->edge_threshold < 1.0 || sift->edge_threshold > 100.0 || sift->sigma < 0.5 ||
-        sift->sigma > 3.0 || sift->grid_rows == 0 || sift->grid_rows > 32 ||
-        sift->grid_cols == 0 || sift->grid_cols > 32 || sift->max_features_per_cell == 0 ||
-        sift->max_features_per_cell > 8192)) ||
       (visual &&
        (!valid_task_id(visual->task_id) || visual->task_id != snapshot->id ||
         !valid_task_id(visual->visual_index_id) || visual->after_feature_set_id > INT64_MAX)) ||
-      (candidate_pair &&
-       (!valid_task_id(candidate_pair->task_id) || candidate_pair->task_id != snapshot->id ||
-        !valid_task_id(candidate_pair->visual_index_id) ||
-        candidate_pair->after_feature_set_id > INT64_MAX ||
-        candidate_pair->top_k == 0 || candidate_pair->top_k > 256 ||
-        candidate_pair->minimum_evidence_count > 1024 ||
-        candidate_pair->scanset_filter < 0 || candidate_pair->scanset_filter > 2)) ||
       (checkpoint && !valid_checkpoint(checkpoint))) {
     return LARDON3D_PROJECT_DB_INVALID_ARGUMENT;
   }
@@ -980,66 +848,6 @@ record_task_internal(Lardon3DProjectDb *database, const Lardon3DTaskDurableSnaps
       }
     }
   }
-  if (result == LARDON3D_PROJECT_DB_OK && candidate_pair) {
-    result = prepare(database,
-                     "INSERT INTO candidate_pair_generate_tasks(task_id,visual_index_id,"
-                     "after_feature_set_id,top_k,minimum_evidence_count,scanset_filter,"
-                     "exclude_same_asset) VALUES(?1,?2,?3,?4,?5,?6,?7) ON CONFLICT(task_id) DO "
-                     "UPDATE SET after_feature_set_id=excluded.after_feature_set_id WHERE "
-                     "candidate_pair_generate_tasks.visual_index_id=excluded.visual_index_id",
-                     &statement);
-    if (result == LARDON3D_PROJECT_DB_OK) {
-      sqlite3_bind_int64(statement, 1, (sqlite3_int64)candidate_pair->task_id);
-      sqlite3_bind_int64(statement, 2, (sqlite3_int64)candidate_pair->visual_index_id);
-      sqlite3_bind_int64(statement, 3, (sqlite3_int64)candidate_pair->after_feature_set_id);
-      sqlite3_bind_int64(statement, 4, (sqlite3_int64)candidate_pair->top_k);
-      sqlite3_bind_int64(statement, 5, (sqlite3_int64)candidate_pair->minimum_evidence_count);
-      sqlite3_bind_int64(statement, 6, (sqlite3_int64)candidate_pair->scanset_filter);
-      sqlite3_bind_int64(statement, 7, candidate_pair->exclude_same_asset ? 1 : 0);
-      result = step_done(database, statement, "upsert candidate pair generate");
-      if (result == LARDON3D_PROJECT_DB_OK && sqlite3_changes(database->connection) != 1) {
-        copy_error(database->error, "Index cible de tâche immuable.");
-        result = LARDON3D_PROJECT_DB_CONSTRAINT;
-      }
-    }
-  }
-  if (result == LARDON3D_PROJECT_DB_OK && sift) {
-    result = prepare(
-        database,
-        "INSERT INTO sift_extract_tasks(task_id,image_id,extractor_kind,extractor_version,"
-        "max_features,octave_layers,contrast_threshold,edge_threshold,sigma,grid_rows,grid_cols,"
-        "max_features_per_cell,parameter_fingerprint) VALUES(?1,?2,?3,?4,?5,?6,?7,?8,?9,?10,"
-        "?11,?12,?13) ON CONFLICT(task_id) DO UPDATE SET image_id=excluded.image_id WHERE "
-        "sift_extract_tasks.image_id=excluded.image_id AND sift_extract_tasks.extractor_kind="
-        "excluded.extractor_kind AND sift_extract_tasks.extractor_version=excluded.extractor_version "
-        "AND sift_extract_tasks.max_features=excluded.max_features AND sift_extract_tasks."
-        "octave_layers=excluded.octave_layers AND sift_extract_tasks.contrast_threshold="
-        "excluded.contrast_threshold AND sift_extract_tasks.edge_threshold=excluded.edge_threshold "
-        "AND sift_extract_tasks.sigma=excluded.sigma AND sift_extract_tasks.grid_rows="
-        "excluded.grid_rows AND sift_extract_tasks.grid_cols=excluded.grid_cols AND "
-        "sift_extract_tasks.max_features_per_cell=excluded.max_features_per_cell AND "
-        "sift_extract_tasks.parameter_fingerprint=excluded.parameter_fingerprint",
-        &statement);
-    if (result == LARDON3D_PROJECT_DB_OK) {
-      sqlite3_bind_int64(statement, 1, (sqlite3_int64)sift->task_id);
-      sqlite3_bind_int64(statement, 2, (sqlite3_int64)sift->image_id);
-      sqlite3_bind_text(statement, 3, sift->extractor_kind, -1, SQLITE_TRANSIENT);
-      sqlite3_bind_int64(statement, 4, sift->extractor_version);
-      sqlite3_bind_int64(statement, 5, sift->max_features);
-      sqlite3_bind_int64(statement, 6, sift->octave_layers);
-      sqlite3_bind_double(statement, 7, sift->contrast_threshold);
-      sqlite3_bind_double(statement, 8, sift->edge_threshold);
-      sqlite3_bind_double(statement, 9, sift->sigma);
-      sqlite3_bind_int64(statement, 10, sift->grid_rows);
-      sqlite3_bind_int64(statement, 11, sift->grid_cols);
-      sqlite3_bind_int64(statement, 12, sift->max_features_per_cell);
-      sqlite3_bind_blob(statement, 13, sift->parameter_fingerprint, 32, SQLITE_TRANSIENT);
-      result = step_done(database, statement, "upsert sift extract");
-      if (result == LARDON3D_PROJECT_DB_OK && sqlite3_changes(database->connection) != 1) {
-        result = LARDON3D_PROJECT_DB_CONSTRAINT;
-      }
-    }
-  }
   if (result == LARDON3D_PROJECT_DB_OK && checkpoint) {
     result =
         prepare(database,
@@ -1072,7 +880,7 @@ Lardon3DProjectDbResult lardon3d_project_db_record_task(
     Lardon3DProjectDb *database, const Lardon3DTaskDurableSnapshot *snapshot, const char *task_kind,
     uint32_t task_kind_version, const Lardon3DProjectDbCheckpoint *checkpoint, int64_t updated_at) {
   return record_task_internal(database, snapshot, task_kind, task_kind_version, checkpoint, NULL, 0,
-                              NULL, NULL, NULL, NULL, updated_at);
+                              NULL, NULL, updated_at);
 }
 
 Lardon3DProjectDbResult lardon3d_project_db_record_image_import_task(
@@ -1083,7 +891,7 @@ Lardon3DProjectDbResult lardon3d_project_db_record_image_import_task(
     return LARDON3D_PROJECT_DB_INVALID_ARGUMENT;
   }
   return record_task_internal(database, snapshot, task_kind, task_kind_version, checkpoint,
-                              source_path, scanset_id, NULL, NULL, NULL, NULL, updated_at);
+                              source_path, scanset_id, NULL, NULL, updated_at);
 }
 
 Lardon3DProjectDbResult lardon3d_project_db_record_feature_extract_task(
@@ -1094,17 +902,7 @@ Lardon3DProjectDbResult lardon3d_project_db_record_feature_extract_task(
     return LARDON3D_PROJECT_DB_INVALID_ARGUMENT;
   }
   return record_task_internal(database, snapshot, task_kind, task_kind_version, checkpoint, NULL, 0,
-                              parameters, NULL, NULL, NULL, updated_at);
+                              parameters, NULL, updated_at);
-}
-
-Lardon3DProjectDbResult lardon3d_project_db_record_sift_extract_task(
-    Lardon3DProjectDb *database, const Lardon3DTaskDurableSnapshot *snapshot,
-    const char *task_kind, uint32_t task_kind_version,
-    const Lardon3DProjectDbCheckpoint *checkpoint,
-    const Lardon3DProjectDbSiftExtractTask *parameters, int64_t updated_at) {
-  if (!parameters) return LARDON3D_PROJECT_DB_INVALID_ARGUMENT;
-  return record_task_internal(database, snapshot, task_kind, task_kind_version, checkpoint, NULL, 0,
-                              NULL, parameters, NULL, NULL, updated_at);
 }
 
 static bool read_task(sqlite3_stmt *statement, Lardon3DProjectDbTask *task) {
@@ -1474,153 +1272,6 @@ Lardon3DProjectDbResult lardon3d_project_db_list_scansets(Lardon3DProjectDb *dat
   return result;
 }
 
-static bool read_candidate_pair(sqlite3_stmt *statement, Lardon3DProjectDbCandidatePair *pair) {
-  sqlite3_int64 id = sqlite3_column_int64(statement, 0);
-  sqlite3_int64 image_a = sqlite3_column_int64(statement, 1);
-  sqlite3_int64 image_b = sqlite3_column_int64(statement, 2);
-  sqlite3_int64 created = sqlite3_column_int64(statement, 3);
-  if (id <= 0 || image_a <= 0 || image_b <= 0 || image_a >= image_b || created < 0) {
-    return false;
-  }
-  pair->candidate_pair_id = (uint64_t)id;
-  pair->image_id_a = (uint64_t)image_a;
-  pair->image_id_b = (uint64_t)image_b;
-  pair->created_at = created;
-  return true;
-}
-
-Lardon3DProjectDbResult lardon3d_project_db_create_candidate_pair(
-    Lardon3DProjectDb *database, uint64_t image_id_a, uint64_t image_id_b, int64_t created_at,
-    Lardon3DProjectDbCandidatePair *pair) {
-  if (!database || !valid_catalog_id(image_id_a) || !valid_catalog_id(image_id_b) ||
-      created_at < 0 || !pair) {
-    return LARDON3D_PROJECT_DB_INVALID_ARGUMENT;
-  }
-  uint64_t canonical_a = image_id_a < image_id_b ? image_id_a : image_id_b;
-  uint64_t canonical_b = image_id_a < image_id_b ? image_id_b : image_id_a;
-  memset(pair, 0, sizeof(*pair));
-  (void)pthread_mutex_lock(&database->mutex);
-  sqlite3_stmt *statement = NULL;
-  Lardon3DProjectDbResult result = prepare(
-      database,
-      "INSERT INTO candidate_pairs(image_id_a,image_id_b,created_at) VALUES(?1,?2,?3)",
-      &statement);
-  if (result == LARDON3D_PROJECT_DB_OK) {
-    (void)sqlite3_bind_int64(statement, 1, (sqlite3_int64)canonical_a);
-    (void)sqlite3_bind_int64(statement, 2, (sqlite3_int64)canonical_b);
-    (void)sqlite3_bind_int64(statement, 3, created_at);
-    result = step_done(database, statement, "create candidate pair");
-  }
-  sqlite3_int64 id = sqlite3_last_insert_rowid(database->connection);
-  if (result == LARDON3D_PROJECT_DB_OK && id <= 0) {
-    result = LARDON3D_PROJECT_DB_CONSTRAINT;
-  }
-  if (result == LARDON3D_PROJECT_DB_OK) {
-    pair->candidate_pair_id = (uint64_t)id;
-    pair->image_id_a = canonical_a;
-    pair->image_id_b = canonical_b;
-    pair->created_at = created_at;
-  }
-  (void)pthread_mutex_unlock(&database->mutex);
-  return result;
-}
-
-Lardon3DProjectDbResult lardon3d_project_db_load_candidate_pair(
-    Lardon3DProjectDb *database, uint64_t candidate_pair_id,
-    Lardon3DProjectDbCandidatePair *pair) {
-  if (!database || !valid_catalog_id(candidate_pair_id) || !pair) {
-    return LARDON3D_PROJECT_DB_INVALID_ARGUMENT;
-  }
-  memset(pair, 0, sizeof(*pair));
-  (void)pthread_mutex_lock(&database->mutex);
-  sqlite3_stmt *statement = NULL;
-  Lardon3DProjectDbResult result = prepare(
-      database,
-      "SELECT candidate_pair_id,image_id_a,image_id_b,created_at FROM candidate_pairs WHERE "
-      "candidate_pair_id=?1",
-      &statement);
-  if (result == LARDON3D_PROJECT_DB_OK) {
-    (void)sqlite3_bind_int64(statement, 1, (sqlite3_int64)candidate_pair_id);
-    int code = sqlite3_step(statement);
-    if (code == SQLITE_DONE) {
-      result = LARDON3D_PROJECT_DB_NOT_FOUND;
-    } else if (code != SQLITE_ROW || !read_candidate_pair(statement, pair)) {
-      result = LARDON3D_PROJECT_DB_CORRUPT;
-    }
-    (void)sqlite3_finalize(statement);
-  }
-  (void)pthread_mutex_unlock(&database->mutex);
-  return result;
-}
-
-Lardon3DProjectDbResult lardon3d_project_db_find_candidate_pair(
-    Lardon3DProjectDb *database, uint64_t image_id_a, uint64_t image_id_b,
-    Lardon3DProjectDbCandidatePair *pair) {
-  if (!database || !valid_catalog_id(image_id_a) || !valid_catalog_id(image_id_b) || !pair) {
-    return LARDON3D_PROJECT_DB_INVALID_ARGUMENT;
-  }
-  uint64_t canonical_a = image_id_a < image_id_b ? image_id_a : image_id_b;
-  uint64_t canonical_b = image_id_a < image_id_b ? image_id_b : image_id_a;
-  memset(pair, 0, sizeof(*pair));
-  (void)pthread_mutex_lock(&database->mutex);
-  sqlite3_stmt *statement = NULL;
-  Lardon3DProjectDbResult result = prepare(
-      database,
-      "SELECT candidate_pair_id,image_id_a,image_id_b,created_at FROM candidate_pairs WHERE "
-      "image_id_a=?1 AND image_id_b=?2",
-      &statement);
-  if (result == LARDON3D_PROJECT_DB_OK) {
-    (void)sqlite3_bind_int64(statement, 1, (sqlite3_int64)canonical_a);
-    (void)sqlite3_bind_int64(statement, 2, (sqlite3_int64)canonical_b);
-    int code = sqlite3_step(statement);
-    if (code == SQLITE_DONE) {
-      result = LARDON3D_PROJECT_DB_NOT_FOUND;
-    } else if (code != SQLITE_ROW || !read_candidate_pair(statement, pair)) {
-      result = LARDON3D_PROJECT_DB_CORRUPT;
-    }
-    (void)sqlite3_finalize(statement);
-  }
-  (void)pthread_mutex_unlock(&database->mutex);
-  return result;
-}
-
-Lardon3DProjectDbResult lardon3d_project_db_list_candidate_pairs(
-    Lardon3DProjectDb *database, uint64_t after_candidate_pair_id,
-    Lardon3DProjectDbCandidatePair *pairs, size_t capacity, size_t *count) {
-  if (count) {
-    *count = 0;
-  }
-  if (!database || !pairs || !count || after_candidate_pair_id > INT64_MAX || capacity == 0 ||
-      capacity > LARDON3D_PROJECT_DB_CANDIDATE_PAIR_PAGE_MAX) {
-    return LARDON3D_PROJECT_DB_INVALID_ARGUMENT;
-  }
-  (void)pthread_mutex_lock(&database->mutex);
-  sqlite3_stmt *statement = NULL;
-  Lardon3DProjectDbResult result = prepare(
-      database,
-      "SELECT candidate_pair_id,image_id_a,image_id_b,created_at FROM candidate_pairs WHERE "
-      "candidate_pair_id>?1 ORDER BY candidate_pair_id LIMIT ?2",
-      &statement);
-  if (result == LARDON3D_PROJECT_DB_OK) {
-    (void)sqlite3_bind_int64(statement, 1, (sqlite3_int64)after_candidate_pair_id);
-    (void)sqlite3_bind_int64(statement, 2, (sqlite3_int64)capacity);
-    int code = SQLITE_DONE;
-    while (*count < capacity && (code = sqlite3_step(statement)) == SQLITE_ROW) {
-      if (!read_candidate_pair(statement, &pairs[*count])) {
-        result = LARDON3D_PROJECT_DB_CORRUPT;
-        break;
-      }
-      ++*count;
-    }
-    if (result == LARDON3D_PROJECT_DB_OK && *count < capacity && code != SQLITE_DONE) {
-      result = sqlite_result(database, code, "list candidate pairs");
-    }
-    (void)sqlite3_finalize(statement);
-  }
-  (void)pthread_mutex_unlock(&database->mutex);
-  return result;
-}
-
 static bool read_image(sqlite3_stmt *statement, Lardon3DProjectDbImage *image,
                        Lardon3DProjectDbImageAsset *asset) {
   sqlite3_int64 image_id = sqlite3_column_int64(statement, 0);
@@ -2065,18 +1716,6 @@ static bool read_feature_set(sqlite3_stmt *s, Lardon3DProjectDbFeatureSet *set)
   set->asset.size_bytes = (uint64_t)size;
   set->asset.durability = (Lardon3DProjectDbFeatureDurability)durability;
   set->asset.created_at = sqlite3_column_int64(s, 16);
-  sqlite3_int64 occupied = sqlite3_column_int64(s, 17);
-  sqlite3_int64 total_cells = sqlite3_column_int64(s, 18);
-  set->coverage_ratio = sqlite3_column_double(s, 19);
-  set->feature_density_per_megapixel = sqlite3_column_double(s, 20);
-  if (occupied < 0 || occupied > 1024 || total_cells < occupied || total_cells > 1024 ||
-      !isfinite(set->coverage_ratio) || set->coverage_ratio < 0.0 ||
-      set->coverage_ratio > 1.0 || !isfinite(set->feature_density_per_megapixel) ||
-      set->feature_density_per_megapixel < 0.0) {
-    return false;
-  }
-  set->occupied_cells = (uint32_t)occupied;
-  set->total_cells = (uint32_t)total_cells;
   return set->created_at >= 0 && set->asset.created_at >= 0 &&
          canonical_feature_path(set->asset.sha256, set->asset.path);
 }
@@ -2086,8 +1725,7 @@ static const char feature_select[] =
     "f.feature_set_id,f.image_id,f.feature_asset_id,f.extractor_kind,f.extractor_version,f."
     "parameter_fingerprint,f.source_image_sha256,f.feature_count,f.descriptor_type,f.descriptor_"
     "dimension,f.producer_task_id,f.created_at,a.sha256,a.path,a.size_bytes,a.durability,a.created_"
-    "at,f.occupied_cells,f.total_cells,f.coverage_ratio,f.feature_density_per_megapixel FROM "
+    "at FROM feature_sets f JOIN feature_assets a ON a.feature_asset_id=f.feature_asset_id ";
-    "feature_sets f JOIN feature_assets a ON a.feature_asset_id=f.feature_asset_id ";
 
 static Lardon3DProjectDbResult verify_feature_source_locked(Lardon3DProjectDb *db,
                                                             uint64_t image_id,
@@ -2168,17 +1806,14 @@ static Lardon3DProjectDbResult
 insert_feature_set_locked(Lardon3DProjectDb *db, uint64_t image_id, sqlite3_int64 asset_id,
                           const char *kind, uint32_t version, const unsigned char fp[32],
                           const unsigned char source[32], uint32_t count, uint32_t type,
-                          uint32_t dim, uint32_t occupied, uint32_t total_cells, double coverage,
+                          uint32_t dim, uint64_t producer, int64_t created) {
-                          double density, uint64_t producer, int64_t created) {
   sqlite3_stmt *statement = NULL;
   Lardon3DProjectDbResult result =
       prepare(db,
               "INSERT INTO feature_sets(image_id,feature_asset_id,extractor_kind,extractor_version,"
               "parameter_fingerprint,source_image_sha256,feature_count,descriptor_type,"
-              "descriptor_dimension,producer_task_id,created_at,occupied_cells,total_cells,"
+              "descriptor_dimension,producer_task_id,created_at) "
-              "coverage_ratio,feature_density_per_megapixel) "
+              "VALUES(?1,?2,?3,?4,?5,?6,?7,?8,?9,?10,?11) ON CONFLICT(image_id,extractor_kind,"
-              "VALUES(?1,?2,?3,?4,?5,?6,?7,?8,?9,?10,?11,?12,?13,?14,?15) ON CONFLICT("
-              "image_id,extractor_kind,"
               "extractor_version,parameter_fingerprint) DO NOTHING",
               &statement);
   if (result != LARDON3D_PROJECT_DB_OK) {
@@ -2199,26 +1834,18 @@ insert_feature_set_locked(Lardon3DProjectDb *db, uint64_t image_id, sqlite3_int6
     sqlite3_bind_null(statement, 10);
   }
   sqlite3_bind_int64(statement, 11, created);
-  sqlite3_bind_int64(statement, 12, occupied);
-  sqlite3_bind_int64(statement, 13, total_cells);
-  sqlite3_bind_double(statement, 14, coverage);
-  sqlite3_bind_double(statement, 15, density);
   return step_done(db, statement, "insert feature set");
 }
 
-Lardon3DProjectDbResult lardon3d_project_db_register_feature_set_quality(
+Lardon3DProjectDbResult lardon3d_project_db_register_feature_set(
     Lardon3DProjectDb *db, uint64_t image_id, const char *kind, uint32_t version,
     const unsigned char fp[32], const unsigned char source[32], uint32_t count, uint32_t type,
-    uint32_t dim, uint32_t occupied, uint32_t total_cells, double coverage, double density,
+    uint32_t dim, const unsigned char hash[32], const char *path, uint64_t size,
-    const unsigned char hash[32], const char *path, uint64_t size,
     Lardon3DProjectDbFeatureDurability durability, uint64_t producer, int64_t created,
     Lardon3DProjectDbFeatureSet *out) {
   if (!db || !valid_catalog_id(image_id) || !kind || !lardon3d_task_kind_is_valid(kind) ||
       version == 0 || !fp || !source || count > 8192 || type < 1 || type > 2 || dim == 0 ||
-      dim > 4096 || occupied > total_cells || total_cells > 1024 || !isfinite(coverage) ||
+      dim > 4096 || !hash || !canonical_feature_path(hash, path) || size > INT64_MAX ||
-      coverage < 0.0 || coverage > 1.0 || !isfinite(density) || density < 0.0 || !hash ||
-      !canonical_feature_path(hash, path) ||
-      size > INT64_MAX ||
       durability < 0 || durability > 1 || (producer && !valid_task_id(producer)) || created < 0 ||
       !out) {
     return LARDON3D_PROJECT_DB_INVALID_ARGUMENT;
@@ -2241,8 +1868,7 @@ Lardon3DProjectDbResult lardon3d_project_db_register_feature_set_quality(
   }
   if (result == LARDON3D_PROJECT_DB_OK) {
     result = insert_feature_set_locked(db, image_id, asset_id, kind, version, fp, source, count,
-                                       type, dim, occupied, total_cells, coverage, density, producer,
+                                       type, dim, producer, created);
-                                       created);
   }
   if (result == LARDON3D_PROJECT_DB_OK) {
     result = execute(db, "COMMIT", "commit feature register");
@@ -2256,291 +1882,6 @@ Lardon3DProjectDbResult lardon3d_project_db_register_feature_set_quality(
              : result;
 }
 
-static bool read_support_set(sqlite3_stmt *s, Lardon3DProjectDbFeatureSupportSet *out) {
-  sqlite3_int64 id = sqlite3_column_int64(s, 0);
-  sqlite3_int64 image = sqlite3_column_int64(s, 1);
-  sqlite3_int64 first = sqlite3_column_int64(s, 2);
-  sqlite3_int64 second = sqlite3_column_int64(s, 3);
-  const void *fp = sqlite3_column_blob(s, 5);
-  sqlite3_int64 created = sqlite3_column_int64(s, 6);
-  sqlite3_int64 groups = sqlite3_column_int64(s, 7);
-  double radius = sqlite3_column_double(s, 4);
-  if (id <= 0 || image <= 0 || first <= 0 || second <= 0 || first == second || !fp ||
-      sqlite3_column_bytes(s, 5) != 32 || !isfinite(radius) || radius <= 0.0 || radius > 64.0 ||
-      created < 0 || groups < 0 || groups > 16384) {
-    return false;
-  }
-  memset(out, 0, sizeof(*out));
-  out->feature_support_set_id = (uint64_t)id;
-  out->image_id = (uint64_t)image;
-  out->first_feature_set_id = (uint64_t)first;
-  out->second_feature_set_id = (uint64_t)second;
-  out->radius_pixels = radius;
-  memcpy(out->parameter_fingerprint, fp, 32);
-  out->created_at = created;
-  out->group_count = (uint32_t)groups;
-  return true;
-}
-
-static Lardon3DProjectDbResult validate_support_sources_locked(
-    Lardon3DProjectDb *db, const Lardon3DProjectDbFeatureSupportSet *config,
-    const Lardon3DProjectDbFeatureSupportGroup *groups, size_t count) {
-  sqlite3_stmt *statement = NULL;
-  Lardon3DProjectDbResult result = prepare(
-      db, "SELECT image_id,feature_count,extractor_kind FROM feature_sets WHERE "
-          "feature_set_id IN(?1,?2) ORDER BY feature_set_id=?2",
-      &statement);
-  if (result != LARDON3D_PROJECT_DB_OK) return result;
-  sqlite3_bind_int64(statement, 1, (sqlite3_int64)config->first_feature_set_id);
-  sqlite3_bind_int64(statement, 2, (sqlite3_int64)config->second_feature_set_id);
-  uint32_t limits[2] = {0};
-  for (unsigned source = 0; source < 2; ++source) {
-    int step = sqlite3_step(statement);
-    const unsigned char *kind = step == SQLITE_ROW ? sqlite3_column_text(statement, 2) : NULL;
-    sqlite3_int64 image_id = step == SQLITE_ROW ? sqlite3_column_int64(statement, 0) : 0;
-    sqlite3_int64 feature_count = step == SQLITE_ROW ? sqlite3_column_int64(statement, 1) : -1;
-    bool expected_kind = source == 0 ? kind && strcmp((const char *)kind, "orb") == 0
-                                     : kind && (strcmp((const char *)kind, "sift") == 0 ||
-                                               strcmp((const char *)kind, "rootsift") == 0);
-    if (step != SQLITE_ROW || image_id != (sqlite3_int64)config->image_id || feature_count < 0 ||
-        feature_count > 8192 || !expected_kind) {
-      sqlite3_finalize(statement);
-      return LARDON3D_PROJECT_DB_CONSTRAINT;
-    }
-    limits[source] = (uint32_t)feature_count;
-  }
-  sqlite3_finalize(statement);
-  for (size_t i = 0; i < count; ++i) {
-    unsigned first_source = groups[i].first_member_from_second_set ? 1U : 0U;
-    if (groups[i].first_feature_index >= limits[first_source] ||
-        (groups[i].has_second_feature && groups[i].second_feature_index >= limits[1])) {
-      return LARDON3D_PROJECT_DB_CONSTRAINT;
-    }
-  }
-  return LARDON3D_PROJECT_DB_OK;
-}
-
-Lardon3DProjectDbResult lardon3d_project_db_load_feature_support(
-    Lardon3DProjectDb *db, uint64_t image_id, uint64_t first_id, uint64_t second_id,
-    const unsigned char fp[32], Lardon3DProjectDbFeatureSupportSet *out) {
-  if (!db || !valid_catalog_id(image_id) || !valid_catalog_id(first_id) ||
-      !valid_catalog_id(second_id) || first_id == second_id || !fp || !out) {
-    return LARDON3D_PROJECT_DB_INVALID_ARGUMENT;
-  }
-  (void)pthread_mutex_lock(&db->mutex);
-  sqlite3_stmt *s = NULL;
-  Lardon3DProjectDbResult result = prepare(
-      db, "SELECT s.feature_support_set_id,s.image_id,s.first_feature_set_id,"
-          "s.second_feature_set_id,s.radius_pixels,s.parameter_fingerprint,s.created_at,"
-          "COUNT(g.feature_support_group_id) FROM feature_support_sets s LEFT JOIN "
-          "feature_support_groups g ON g.feature_support_set_id=s.feature_support_set_id WHERE "
-          "s.image_id=?1 AND s.first_feature_set_id=?2 AND s.second_feature_set_id=?3 AND "
-          "s.parameter_fingerprint=?4 GROUP BY s.feature_support_set_id",
-      &s);
-  if (result == LARDON3D_PROJECT_DB_OK) {
-    sqlite3_bind_int64(s, 1, (sqlite3_int64)image_id);
-    sqlite3_bind_int64(s, 2, (sqlite3_int64)first_id);
-    sqlite3_bind_int64(s, 3, (sqlite3_int64)second_id);
-    sqlite3_bind_blob(s, 4, fp, 32, SQLITE_TRANSIENT);
-    int step = sqlite3_step(s);
-    if (step == SQLITE_ROW) result = read_support_set(s, out) ? LARDON3D_PROJECT_DB_OK
-                                                              : LARDON3D_PROJECT_DB_CORRUPT;
-    else result = step == SQLITE_DONE ? LARDON3D_PROJECT_DB_NOT_FOUND
-                                      : sqlite_result(db, step, "load feature support");
-    sqlite3_finalize(s);
-  }
-  (void)pthread_mutex_unlock(&db->mutex);
-  return result;
-}
-
-Lardon3DProjectDbResult lardon3d_project_db_list_feature_support_groups(
-    Lardon3DProjectDb *db, uint64_t support_set_id, uint64_t after_group_id,
-    Lardon3DProjectDbFeatureSupportGroup *groups, size_t capacity, size_t *count) {
-  if (count) *count = 0;
-  if (!db || !valid_catalog_id(support_set_id) || after_group_id > INT64_MAX || !groups ||
-      !count || capacity == 0 || capacity > 256) {
-    return LARDON3D_PROJECT_DB_INVALID_ARGUMENT;
-  }
-  (void)pthread_mutex_lock(&db->mutex);
-  sqlite3_stmt *statement = NULL;
-  Lardon3DProjectDbResult result = prepare(
-      db, "SELECT g.feature_support_group_id,g.feature_support_set_id,g.x,g.y,g.distance_pixels,"
-          "g.support_count,first_member.feature_index,second_member.feature_index FROM "
-          "feature_support_groups g "
-          "JOIN feature_support_sets s ON s.feature_support_set_id=g.feature_support_set_id "
-          "LEFT JOIN feature_support_members first_member ON first_member."
-          "feature_support_group_id=g.feature_support_group_id AND first_member.feature_set_id="
-          "s.first_feature_set_id LEFT JOIN feature_support_members second_member ON "
-          "second_member.feature_support_group_id=g.feature_support_group_id AND second_member."
-          "feature_set_id=s.second_feature_set_id WHERE g.feature_support_set_id=?1 AND "
-          "g.feature_support_group_id>?2 ORDER BY g.feature_support_group_id LIMIT ?3",
-      &statement);
-  if (result == LARDON3D_PROJECT_DB_OK) {
-    sqlite3_bind_int64(statement, 1, (sqlite3_int64)support_set_id);
-    sqlite3_bind_int64(statement, 2, (sqlite3_int64)after_group_id);
-    sqlite3_bind_int64(statement, 3, (sqlite3_int64)capacity);
-    while (*count < capacity) {
-      int step = sqlite3_step(statement);
-      if (step == SQLITE_DONE) break;
-      bool has_first = sqlite3_column_type(statement, 6) != SQLITE_NULL;
-      bool has_second = sqlite3_column_type(statement, 7) != SQLITE_NULL;
-      sqlite3_int64 id = sqlite3_column_int64(statement, 0);
-      sqlite3_int64 set_id = sqlite3_column_int64(statement, 1);
-      sqlite3_int64 support_count = sqlite3_column_int64(statement, 5);
-      sqlite3_int64 first_index = has_first ? sqlite3_column_int64(statement, 6) : 0;
-      sqlite3_int64 second_index = has_second ? sqlite3_column_int64(statement, 7) : 0;
-      double x = sqlite3_column_double(statement, 2), y = sqlite3_column_double(statement, 3);
-      double distance = sqlite3_column_double(statement, 4);
-      if (step != SQLITE_ROW || id <= 0 || set_id != (sqlite3_int64)support_set_id ||
-          !isfinite(x) || !isfinite(y) || !isfinite(distance) || distance < 0.0 ||
-          distance > 64.0 || support_count < 1 || support_count > 2 ||
-          has_first + has_second != support_count || first_index < 0 || first_index >= 8192 ||
-          second_index < 0 || second_index >= 8192) {
-        result = LARDON3D_PROJECT_DB_CORRUPT;
-        break;
-      }
-      Lardon3DProjectDbFeatureSupportGroup *group = &groups[(*count)++];
-      memset(group, 0, sizeof(*group));
-      group->feature_support_group_id = (uint64_t)id;
-      group->feature_support_set_id = support_set_id;
-      group->x = x;
-      group->y = y;
-      group->distance_pixels = distance;
-      group->support_count = (uint32_t)support_count;
-      group->first_member_from_second_set = !has_first;
-      group->first_feature_index = (uint32_t)(has_first ? first_index : second_index);
-      group->has_second_feature = has_first && has_second;
-      group->second_feature_index = (uint32_t)second_index;
-    }
-    sqlite3_finalize(statement);
-  }
-  (void)pthread_mutex_unlock(&db->mutex);
-  return result;
-}
-
-Lardon3DProjectDbResult lardon3d_project_db_publish_feature_support(
-    Lardon3DProjectDb *db, const Lardon3DProjectDbFeatureSupportSet *config,
-    const Lardon3DProjectDbFeatureSupportGroup *groups, size_t count,
-    Lardon3DProjectDbFeatureSupportSet *out) {
-  if (!db || !config || !out || !valid_catalog_id(config->image_id) ||
-      !valid_catalog_id(config->first_feature_set_id) ||
-      !valid_catalog_id(config->second_feature_set_id) ||
-      config->first_feature_set_id == config->second_feature_set_id ||
-      !isfinite(config->radius_pixels) || config->radius_pixels <= 0.0 ||
-      config->radius_pixels > 64.0 || count > 16384 || (count && !groups) ||
-      config->created_at < 0) {
-    return LARDON3D_PROJECT_DB_INVALID_ARGUMENT;
-  }
-  for (size_t i = 0; i < count; ++i) {
-    if (!isfinite(groups[i].x) || !isfinite(groups[i].y) ||
-        !isfinite(groups[i].distance_pixels) || groups[i].distance_pixels < 0.0 ||
-        groups[i].distance_pixels > config->radius_pixels || groups[i].support_count < 1 ||
-        groups[i].support_count > 2 || groups[i].first_feature_index >= 8192 ||
-        (groups[i].support_count == 2 && groups[i].first_member_from_second_set) ||
-        groups[i].has_second_feature != (groups[i].support_count == 2) ||
-        (groups[i].has_second_feature && groups[i].second_feature_index >= 8192)) {
-      return LARDON3D_PROJECT_DB_INVALID_ARGUMENT;
-    }
-  }
-  Lardon3DProjectDbFeatureSupportSet existing;
-  Lardon3DProjectDbResult found = lardon3d_project_db_load_feature_support(
-      db, config->image_id, config->first_feature_set_id, config->second_feature_set_id,
-      config->parameter_fingerprint, &existing);
-  if (found == LARDON3D_PROJECT_DB_OK) {
-    if (existing.radius_pixels != config->radius_pixels)
-      return LARDON3D_PROJECT_DB_CONSTRAINT;
-    *out = existing;
-    return LARDON3D_PROJECT_DB_OK;
-  }
-  if (found != LARDON3D_PROJECT_DB_NOT_FOUND) return found;
-  (void)pthread_mutex_lock(&db->mutex);
-  Lardon3DProjectDbResult result = execute(db, "BEGIN IMMEDIATE", "begin feature support");
-  sqlite3_stmt *s = NULL;
-  bool inserted_support_set = false;
-  if (result == LARDON3D_PROJECT_DB_OK)
-    result = validate_support_sources_locked(db, config, groups, count);
-  if (result == LARDON3D_PROJECT_DB_OK) {
-    result = prepare(db, "INSERT OR IGNORE INTO feature_support_sets(image_id,first_feature_set_id,"
-                         "second_feature_set_id,radius_pixels,parameter_fingerprint,created_at) "
-                         "SELECT ?1,?2,?3,?4,?5,?6 WHERE EXISTS(SELECT 1 FROM feature_sets a,"
-                         "feature_sets b WHERE a.feature_set_id=?2 AND b.feature_set_id=?3 AND "
-                         "a.image_id=?1 AND b.image_id=?1)", &s);
-  }
-  if (result == LARDON3D_PROJECT_DB_OK) {
-    sqlite3_bind_int64(s, 1, (sqlite3_int64)config->image_id);
-    sqlite3_bind_int64(s, 2, (sqlite3_int64)config->first_feature_set_id);
-    sqlite3_bind_int64(s, 3, (sqlite3_int64)config->second_feature_set_id);
-    sqlite3_bind_double(s, 4, config->radius_pixels);
-    sqlite3_bind_blob(s, 5, config->parameter_fingerprint, 32, SQLITE_TRANSIENT);
-    sqlite3_bind_int64(s, 6, config->created_at);
-    result = step_done(db, s, "insert feature support set");
-    inserted_support_set = result == LARDON3D_PROJECT_DB_OK &&
-                           sqlite3_changes(db->connection) == 1;
-  }
-  sqlite3_int64 support_id = 0;
-  if (result == LARDON3D_PROJECT_DB_OK) {
-    result = prepare(db, "SELECT feature_support_set_id FROM feature_support_sets WHERE image_id=?1 "
-                         "AND first_feature_set_id=?2 AND second_feature_set_id=?3 AND "
-                         "parameter_fingerprint=?4", &s);
-  }
-  if (result == LARDON3D_PROJECT_DB_OK) {
-    sqlite3_bind_int64(s, 1, (sqlite3_int64)config->image_id);
-    sqlite3_bind_int64(s, 2, (sqlite3_int64)config->first_feature_set_id);
-    sqlite3_bind_int64(s, 3, (sqlite3_int64)config->second_feature_set_id);
-    sqlite3_bind_blob(s, 4, config->parameter_fingerprint, 32, SQLITE_TRANSIENT);
-    int step = sqlite3_step(s);
-    if (step == SQLITE_ROW) support_id = sqlite3_column_int64(s, 0);
-    else result = step == SQLITE_DONE ? LARDON3D_PROJECT_DB_NOT_FOUND
-                                      : sqlite_result(db, step, "select feature support");
-    sqlite3_finalize(s);
-  }
-  for (size_t i = 0; inserted_support_set && result == LARDON3D_PROJECT_DB_OK && i < count; ++i) {
-    result = prepare(db, "INSERT INTO feature_support_groups(feature_support_set_id,x,y,"
-                         "distance_pixels,support_count) VALUES(?1,?2,?3,?4,?5)", &s);
-    if (result != LARDON3D_PROJECT_DB_OK) break;
-    sqlite3_bind_int64(s, 1, support_id);
-    sqlite3_bind_double(s, 2, groups[i].x);
-    sqlite3_bind_double(s, 3, groups[i].y);
-    sqlite3_bind_double(s, 4, groups[i].distance_pixels);
-    sqlite3_bind_int64(s, 5, groups[i].support_count);
-    result = step_done(db, s, "insert feature support group");
-    sqlite3_int64 group_id = sqlite3_last_insert_rowid(db->connection);
-    for (unsigned member = 0; result == LARDON3D_PROJECT_DB_OK && member < groups[i].support_count;
-         ++member) {
-      result = prepare(db, "INSERT INTO feature_support_members(feature_support_group_id,"
-                           "feature_set_id,feature_index,extractor_kind) SELECT ?1,?2,?3,"
-                           "extractor_kind FROM feature_sets WHERE feature_set_id=?2", &s);
-      if (result != LARDON3D_PROJECT_DB_OK) break;
-      sqlite3_bind_int64(s, 1, group_id);
-      bool from_second = member != 0 || groups[i].first_member_from_second_set;
-      sqlite3_bind_int64(s, 2, (sqlite3_int64)(from_second ? config->second_feature_set_id
-                                                            : config->first_feature_set_id));
-      sqlite3_bind_int64(s, 3, member ? groups[i].second_feature_index
-                                      : groups[i].first_feature_index);
-      result = step_done(db, s, "insert feature support member");
-    }
-  }
-  if (result == LARDON3D_PROJECT_DB_OK) result = execute(db, "COMMIT", "commit feature support");
-  if (result != LARDON3D_PROJECT_DB_OK) (void)execute(db, "ROLLBACK", "rollback feature support");
-  (void)pthread_mutex_unlock(&db->mutex);
-  return result == LARDON3D_PROJECT_DB_OK
-             ? lardon3d_project_db_load_feature_support(
-                   db, config->image_id, config->first_feature_set_id,
-                   config->second_feature_set_id, config->parameter_fingerprint, out)
-             : result;
-}
-
-Lardon3DProjectDbResult lardon3d_project_db_register_feature_set(
-    Lardon3DProjectDb *db, uint64_t image_id, const char *kind, uint32_t version,
-    const unsigned char fp[32], const unsigned char source[32], uint32_t count, uint32_t type,
-    uint32_t dim, const unsigned char hash[32], const char *path, uint64_t size,
-    Lardon3DProjectDbFeatureDurability durability, uint64_t producer, int64_t created,
-    Lardon3DProjectDbFeatureSet *out) {
-  return lardon3d_project_db_register_feature_set_quality(
-      db, image_id, kind, version, fp, source, count, type, dim, 0, 0, 0.0, 0.0, hash, path, size,
-      durability, producer, created, out);
-}
-
 Lardon3DProjectDbResult lardon3d_project_db_find_feature_set(Lardon3DProjectDb *db,
                                                              uint64_t image_id, const char *kind,
                                                              uint32_t version,
@@ -2680,56 +2021,6 @@ lardon3d_project_db_load_feature_extract_task(Lardon3DProjectDb *db, uint64_t ta
   return result;
 }
 
-Lardon3DProjectDbResult lardon3d_project_db_load_sift_extract_task(
-    Lardon3DProjectDb *db, uint64_t task_id, Lardon3DProjectDbSiftExtractTask *p) {
-  if (!db || !valid_task_id(task_id) || !p) return LARDON3D_PROJECT_DB_INVALID_ARGUMENT;
-  memset(p, 0, sizeof(*p));
-  pthread_mutex_lock(&db->mutex);
-  sqlite3_stmt *s = NULL;
-  Lardon3DProjectDbResult result = prepare(
-      db, "SELECT image_id,extractor_kind,extractor_version,max_features,octave_layers,"
-          "contrast_threshold,edge_threshold,sigma,grid_rows,grid_cols,max_features_per_cell,"
-          "parameter_fingerprint FROM sift_extract_tasks WHERE task_id=?1", &s);
-  if (result == LARDON3D_PROJECT_DB_OK) {
-    sqlite3_bind_int64(s, 1, (sqlite3_int64)task_id);
-    int code = sqlite3_step(s);
-    if (code == SQLITE_DONE) {
-      result = LARDON3D_PROJECT_DB_NOT_FOUND;
-    } else if (code != SQLITE_ROW || sqlite3_column_int64(s, 0) <= 0 ||
-               !copy_column(s, 1, p->extractor_kind, sizeof(p->extractor_kind)) ||
-               sqlite3_column_bytes(s, 11) != 32) {
-      result = LARDON3D_PROJECT_DB_CORRUPT;
-    } else {
-      p->task_id = task_id;
-      p->image_id = (uint64_t)sqlite3_column_int64(s, 0);
-      p->extractor_version = (uint32_t)sqlite3_column_int64(s, 2);
-      p->max_features = (uint32_t)sqlite3_column_int64(s, 3);
-      p->octave_layers = (uint32_t)sqlite3_column_int64(s, 4);
-      p->contrast_threshold = sqlite3_column_double(s, 5);
-      p->edge_threshold = sqlite3_column_double(s, 6);
-      p->sigma = sqlite3_column_double(s, 7);
-      p->grid_rows = (uint32_t)sqlite3_column_int64(s, 8);
-      p->grid_cols = (uint32_t)sqlite3_column_int64(s, 9);
-      p->max_features_per_cell = (uint32_t)sqlite3_column_int64(s, 10);
-      memcpy(p->parameter_fingerprint, sqlite3_column_blob(s, 11), 32);
-    }
-    sqlite3_finalize(s);
-  }
-  if (result == LARDON3D_PROJECT_DB_OK &&
-      ((strcmp(p->extractor_kind, "sift") != 0 && strcmp(p->extractor_kind, "rootsift") != 0) ||
-       p->extractor_version != 1 || p->max_features < 1 || p->max_features > 8192 ||
-       p->octave_layers < 1 || p->octave_layers > 8 || !isfinite(p->contrast_threshold) ||
-       p->contrast_threshold < 0.001 || p->contrast_threshold > 0.2 ||
-       !isfinite(p->edge_threshold) || p->edge_threshold < 1.0 || p->edge_threshold > 100.0 ||
-       !isfinite(p->sigma) || p->sigma < 0.5 || p->sigma > 3.0 || p->grid_rows < 1 ||
-       p->grid_rows > 32 || p->grid_cols < 1 || p->grid_cols > 32 ||
-       p->max_features_per_cell < 1 || p->max_features_per_cell > 8192)) {
-    result = LARDON3D_PROJECT_DB_CORRUPT;
-  }
-  pthread_mutex_unlock(&db->mutex);
-  return result;
-}
-
 static bool valid_visual_index(const Lardon3DProjectDbVisualIndex *index) {
   return index && lardon3d_task_kind_is_valid(index->index_kind) && index->index_version > 0 &&
          index->descriptor_type >= 1 && index->descriptor_type <= 2 &&
@@ -3086,7 +2377,7 @@ Lardon3DProjectDbResult lardon3d_project_db_record_visual_index_update_task(
     return LARDON3D_PROJECT_DB_INVALID_ARGUMENT;
   }
   return record_task_internal(db, snapshot, kind, version, checkpoint, NULL, 0, NULL,
-                              NULL, parameters, NULL, updated_at);
+                              parameters, updated_at);
 }
 
 Lardon3DProjectDbResult lardon3d_project_db_load_visual_index_update_task(
@@ -3121,65 +2412,6 @@ Lardon3DProjectDbResult lardon3d_project_db_load_visual_index_update_task(
   return result;
 }
 
-Lardon3DProjectDbResult lardon3d_project_db_record_candidate_pair_generate_task(
-    Lardon3DProjectDb *db, const Lardon3DTaskDurableSnapshot *snapshot, const char *kind,
-    uint32_t version, const Lardon3DProjectDbCheckpoint *checkpoint,
-    const Lardon3DProjectDbCandidatePairGenerateTask *parameters, int64_t updated_at) {
-  if (!snapshot || !parameters || parameters->task_id != snapshot->id ||
-      !valid_catalog_id(parameters->visual_index_id) ||
-      parameters->after_feature_set_id > INT64_MAX || parameters->top_k == 0 ||
-      parameters->top_k > 256 || parameters->minimum_evidence_count > 1024 ||
-      parameters->scanset_filter < 0 || parameters->scanset_filter > 2) {
-    return LARDON3D_PROJECT_DB_INVALID_ARGUMENT;
-  }
-  return record_task_internal(db, snapshot, kind, version, checkpoint, NULL, 0, NULL,
-                              NULL, NULL, parameters, updated_at);
-}
-
-Lardon3DProjectDbResult lardon3d_project_db_load_candidate_pair_generate_task(
-    Lardon3DProjectDb *db, uint64_t task_id,
-    Lardon3DProjectDbCandidatePairGenerateTask *parameters) {
-  if (!db || !valid_task_id(task_id) || !parameters) {
-    return LARDON3D_PROJECT_DB_INVALID_ARGUMENT;
-  }
-  memset(parameters, 0, sizeof(*parameters));
-  (void)pthread_mutex_lock(&db->mutex);
-  sqlite3_stmt *statement = NULL;
-  Lardon3DProjectDbResult result = prepare(
-      db,
-      "SELECT visual_index_id,after_feature_set_id,top_k,minimum_evidence_count,"
-      "scanset_filter,exclude_same_asset FROM candidate_pair_generate_tasks WHERE task_id=?1",
-      &statement);
-  if (result == LARDON3D_PROJECT_DB_OK) {
-    sqlite3_bind_int64(statement, 1, (sqlite3_int64)task_id);
-    int code = sqlite3_step(statement);
-    sqlite3_int64 index_id = sqlite3_column_int64(statement, 0);
-    sqlite3_int64 after = sqlite3_column_int64(statement, 1);
-    int top_k_val = sqlite3_column_int(statement, 2);
-    int evidence = sqlite3_column_int(statement, 3);
-    int filter_val = sqlite3_column_int(statement, 4);
-    int same_asset = sqlite3_column_int(statement, 5);
-    if (code == SQLITE_DONE) {
-      result = LARDON3D_PROJECT_DB_NOT_FOUND;
-    } else if (code != SQLITE_ROW || index_id <= 0 || after < 0 || top_k_val <= 0 ||
-               top_k_val > 256 || evidence < 0 || evidence > 1024 || filter_val < 0 ||
-               filter_val > 2) {
-      result = LARDON3D_PROJECT_DB_CORRUPT;
-    } else {
-      parameters->task_id = task_id;
-      parameters->visual_index_id = (uint64_t)index_id;
-      parameters->after_feature_set_id = (uint64_t)after;
-      parameters->top_k = (uint32_t)top_k_val;
-      parameters->minimum_evidence_count = (uint32_t)evidence;
-      parameters->scanset_filter = filter_val;
-      parameters->exclude_same_asset = same_asset != 0;
-    }
-    sqlite3_finalize(statement);
-  }
-  (void)pthread_mutex_unlock(&db->mutex);
-  return result;
-}
-
 #ifdef LARDON3D_PROJECT_DB_TESTING
 Lardon3DProjectDbResult lardon3d_project_db_test_delete_feature_identity(
     Lardon3DProjectDb *database, uint64_t feature_set_id, uint64_t feature_asset_id) {

src/sift_task.c

@@ -1,275 +0,0 @@
-#include <errno.h>
-#include <fcntl.h>
-#include <openssl/evp.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/stat.h>
-#include <time.h>
-#include <unistd.h>
-
-#include <lardon3d/feature_store.h>
-#include <lardon3d/project.h>
-#include <lardon3d/sift_task.h>
-#include <lardon3d/task_queue.h>
-
-typedef struct {
-  char project_path[PATH_MAX];
-  Lardon3DProjectDb *database;
-  Lardon3DResourceGovernor *governor;
-  Lardon3DProjectDbSiftExtractTask parameters;
-} SiftTaskContext;
-
-static void destroy_context(void *userdata) { free(userdata); }
-
-static void runtime_state(const SiftTaskContext *context, Lardon3DAppState *state) {
-  lardon3d_app_state_init(state);
-  state->project_loaded = true;
-  state->project_db = context->database;
-  state->resource_governor = context->governor;
-  snprintf(state->project_path, sizeof(state->project_path), "%s", context->project_path);
-}
-
-static uint64_t elapsed_ns(struct timespec a, struct timespec b) {
-  uint64_t seconds = b.tv_sec >= a.tv_sec ? (uint64_t)(b.tv_sec - a.tv_sec) : 0;
-  long nanoseconds = b.tv_nsec - a.tv_nsec;
-  if (nanoseconds < 0 && seconds) {
-    --seconds;
-    nanoseconds += 1000000000L;
-  }
-  return seconds <= UINT64_MAX / UINT64_C(1000000000)
-             ? seconds * UINT64_C(1000000000) + (uint64_t)nanoseconds
-             : UINT64_MAX;
-}
-
-static bool file_hash(const char *path, unsigned char output[32]) {
-  int fd = open(path, O_RDONLY | O_NOFOLLOW | O_CLOEXEC);
-  if (fd < 0) return false;
-  struct stat information;
-  EVP_MD_CTX *digest = EVP_MD_CTX_new();
-  bool ok = fstat(fd, &information) == 0 && S_ISREG(information.st_mode) && digest &&
-            EVP_DigestInit_ex(digest, EVP_sha256(), NULL) == 1;
-  unsigned char buffer[65536];
-  while (ok) {
-    ssize_t size = read(fd, buffer, sizeof(buffer));
-    if (size < 0 && errno == EINTR) continue;
-    if (size < 0) {
-      ok = false;
-      break;
-    }
-    if (size == 0) break;
-    ok = EVP_DigestUpdate(digest, buffer, (size_t)size) == 1;
-  }
-  unsigned int length = 0;
-  ok = ok && EVP_DigestFinal_ex(digest, output, &length) == 1 && length == 32;
-  EVP_MD_CTX_free(digest);
-  if (close(fd) != 0) ok = false;
-  return ok;
-}
-
-static Lardon3DSiftExtractorParameters extract_parameters(const SiftTaskContext *context) {
-  const Lardon3DProjectDbSiftExtractTask *p = &context->parameters;
-  return (Lardon3DSiftExtractorParameters){p->max_features,
-                                           p->octave_layers,
-                                           p->contrast_threshold,
-                                           p->edge_threshold,
-                                           p->sigma,
-                                           p->grid_rows,
-                                           p->grid_cols,
-                                           p->max_features_per_cell,
-                                           strcmp(p->extractor_kind, "rootsift") == 0};
-}
-
-static bool source_path(const SiftTaskContext *context, char path[PATH_MAX]) {
-  Lardon3DProjectDbImage image;
-  Lardon3DProjectDbImageAsset asset;
-  if (lardon3d_project_db_load_image(context->database, context->parameters.image_id, &image,
-                                     &asset) != LARDON3D_PROJECT_DB_OK)
-    return false;
-  int length = snprintf(path, PATH_MAX, "%s/%s", context->project_path, asset.path);
-  unsigned char actual[32];
-  return length > 0 && length < PATH_MAX && file_hash(path, actual) &&
-         memcmp(actual, asset.sha256, 32) == 0;
-}
-
-static bool run(Lardon3DTask *task, void *userdata) {
-  SiftTaskContext *context = userdata;
-  if (!lardon3d_task_checkpoint(task)) return false;
-  Lardon3DProjectDbFeatureSet existing;
-  Lardon3DProjectDbResult found = lardon3d_project_db_find_feature_set(
-      context->database, context->parameters.image_id, context->parameters.extractor_kind, 1,
-      context->parameters.parameter_fingerprint, &existing);
-  if (found == LARDON3D_PROJECT_DB_OK) {
-    Lardon3DFeatureReader *reader = NULL;
-    Lardon3DFeatureFileMetadata metadata;
-    Lardon3DFeatureStoreResult valid = lardon3d_feature_reader_open(
-        context->project_path, &existing, &reader, &metadata);
-    lardon3d_feature_reader_close(reader);
-    return valid == LARDON3D_FEATURE_STORE_OK
-               ? lardon3d_task_set_progress(task, 100, "Feature Set SIFT déjà présent.")
-               : lardon3d_task_fail(task, "Feature Set SIFT existant corrompu.");
-  }
-  if (found != LARDON3D_PROJECT_DB_NOT_FOUND)
-    return lardon3d_task_fail(task, "Recherche Feature Store SIFT impossible.");
-  struct timespec begin;
-  (void)clock_gettime(CLOCK_MONOTONIC, &begin);
-  char path[PATH_MAX];
-  if (!source_path(context, path)) return lardon3d_task_fail(task, "Asset image corrompu.");
-  Lardon3DSiftExtractorParameters parameters = extract_parameters(context);
-  Lardon3DExtractedFeatures features;
-  if (lardon3d_feature_extract_sift(path, &parameters, &features) != LARDON3D_FEATURE_EXTRACT_OK)
-    return lardon3d_task_fail(task, "Extraction SIFT impossible.");
-  if (!lardon3d_task_checkpoint(task)) {
-    lardon3d_extracted_features_destroy(&features);
-    return false;
-  }
-#ifdef LARDON3D_FEATURE_TASK_TESTING
-  const char *pause = getenv("LARDON3D_TEST_SIFT_PAUSE_BEFORE_PUBLISH");
-  if (pause && strcmp(pause, "1") == 0) {
-    lardon3d_task_pause(task);
-    if (!lardon3d_task_checkpoint(task)) {
-      lardon3d_extracted_features_destroy(&features);
-      return false;
-    }
-  }
-#endif
-  Lardon3DAppState state;
-  runtime_state(context, &state);
-  Lardon3DProjectDbFeatureSet set;
-  uint32_t capabilities = LARDON3D_FEATURE_HAS_SCALE | LARDON3D_FEATURE_HAS_ORIENTATION |
-                          LARDON3D_FEATURE_HAS_RESPONSE | LARDON3D_FEATURE_HAS_OCTAVE;
-  Lardon3DFeatureStoreResult published = lardon3d_feature_store_publish_v2(
-      &state, context->parameters.image_id, lardon3d_task_id(task),
-      context->parameters.extractor_kind, 1, context->parameters.parameter_fingerprint,
-      LARDON3D_FEATURE_DESCRIPTOR_F32, 128, capabilities, &features, &set);
-  lardon3d_extracted_features_destroy(&features);
-  if (published != LARDON3D_FEATURE_STORE_OK &&
-      published != LARDON3D_FEATURE_STORE_ALREADY_PRESENT &&
-      published != LARDON3D_FEATURE_STORE_PUBLISHED_NOT_DURABLE)
-    return lardon3d_task_fail(task, "Publication SIFT impossible.");
-  struct timespec end;
-  (void)clock_gettime(CLOCK_MONOTONIC, &end);
-  (void)lardon3d_resource_governor_record_batch(
-      context->governor, LARDON3D_RESOURCE_TASK_CPU, 1, elapsed_ns(begin, end), 0);
-  return lardon3d_task_set_progress(task, 100, "Feature Set SIFT publié.");
-}
-
-static void finished(const Lardon3DTask *task, void *userdata) {
-#ifdef LARDON3D_FEATURE_TASK_TESTING
-  const char *skip = getenv("LARDON3D_TEST_SIFT_SKIP_FINISHED_CHECKPOINT");
-  if (skip && strcmp(skip, "1") == 0) return;
-#endif
-  SiftTaskContext *context = userdata;
-  Lardon3DAppState state;
-  runtime_state(context, &state);
-  lardon3d_project_checkpoint_sift_extract_task(&state, task, &context->parameters);
-}
-
-static SiftTaskContext *make_context(const Lardon3DTaskReconstructionContext *runtime,
-                                     const Lardon3DProjectDbSiftExtractTask *parameters) {
-  if (!runtime || !runtime->project_path || !runtime->project_db || !runtime->resource_governor)
-    return NULL;
-  SiftTaskContext *context = calloc(1, sizeof(*context));
-  if (!context) return NULL;
-  int size = snprintf(context->project_path, sizeof(context->project_path), "%s",
-                      runtime->project_path);
-  if (size <= 0 || (size_t)size >= sizeof(context->project_path)) {
-    free(context);
-    return NULL;
-  }
-  context->database = runtime->project_db;
-  context->governor = runtime->resource_governor;
-  context->parameters = *parameters;
-  return context;
-}
-
-bool lardon3d_sift_extract_reconstruct(const Lardon3DTaskDurableSnapshot *snapshot, void *userdata,
-                                       Lardon3DTaskKindBinding *binding) {
-  Lardon3DTaskReconstructionContext *runtime = userdata;
-  Lardon3DProjectDbSiftExtractTask parameters;
-  if (!snapshot || !runtime || !binding ||
-      lardon3d_project_db_load_sift_extract_task(runtime->project_db, snapshot->id, &parameters) !=
-          LARDON3D_PROJECT_DB_OK)
-    return false;
-  Lardon3DSiftExtractorParameters configuration = {
-      parameters.max_features, parameters.octave_layers, parameters.contrast_threshold,
-      parameters.edge_threshold, parameters.sigma, parameters.grid_rows, parameters.grid_cols,
-      parameters.max_features_per_cell, strcmp(parameters.extractor_kind, "rootsift") == 0};
-  unsigned char fingerprint[32];
-  lardon3d_sift_extractor_parameter_fingerprint(&configuration, fingerprint);
-  if (memcmp(fingerprint, parameters.parameter_fingerprint, 32) != 0) return false;
-  SiftTaskContext *context = make_context(runtime, &parameters);
-  if (!context) return false;
-  *binding = (Lardon3DTaskKindBinding){run, context, destroy_context, finished, context};
-  return true;
-}
-
-Lardon3DTask *lardon3d_project_create_sift_extract_task(
-    Lardon3DAppState *state, uint64_t image_id, const Lardon3DSiftExtractorParameters *parameters,
-    uint64_t *task_id) {
-  if (task_id) *task_id = 0;
-  if (!state || !state->project_loaded || !state->project_db || !state->resource_governor ||
-      !task_id || !lardon3d_sift_extractor_parameters_valid(parameters))
-    return NULL;
-  Lardon3DProjectDbImage image;
-  Lardon3DProjectDbImageAsset asset;
-  if (lardon3d_project_db_load_image(state->project_db, image_id, &image, &asset) !=
-      LARDON3D_PROJECT_DB_OK)
-    return NULL;
-  uint64_t id = 0;
-  if (lardon3d_project_db_allocate_task_id(state->project_db, &id) != LARDON3D_PROJECT_DB_OK)
-    return NULL;
-  Lardon3DProjectDbSiftExtractTask durable = {
-      .task_id = id,
-      .image_id = image_id,
-      .extractor_version = 1,
-      .max_features = parameters->max_features,
-      .octave_layers = parameters->octave_layers,
-      .contrast_threshold = parameters->contrast_threshold,
-      .edge_threshold = parameters->edge_threshold,
-      .sigma = parameters->sigma,
-      .grid_rows = parameters->grid_rows,
-      .grid_cols = parameters->grid_cols,
-      .max_features_per_cell = parameters->max_features_per_cell};
-  snprintf(durable.extractor_kind, sizeof(durable.extractor_kind), "%s",
-           parameters->rootsift ? LARDON3D_ROOTSIFT_EXTRACTOR_KIND : LARDON3D_SIFT_EXTRACTOR_KIND);
-  lardon3d_sift_extractor_parameter_fingerprint(parameters, durable.parameter_fingerprint);
-  Lardon3DTaskReconstructionContext runtime = {state->project_path, state->project_db,
-                                               state->resource_governor};
-  SiftTaskContext *context = make_context(&runtime, &durable);
-  if (!context) return NULL;
-  Lardon3DResourceEstimate estimate = {.memory_fixed_bytes = 64ULL * 1024 * 1024,
-                                       .memory_bytes_per_item = 1024ULL * 1024 * 1024,
-                                       .minimum_batch_size = 1,
-                                       .maximum_batch_size = 1,
-                                       .desired_cpu_threads = 1,
-                                       .desired_io_slots = 1,
-                                       .task_class = LARDON3D_RESOURCE_TASK_CPU};
-  const char *kind = parameters->rootsift ? LARDON3D_ROOTSIFT_EXTRACT_TASK_KIND
-                                          : LARDON3D_SIFT_EXTRACT_TASK_KIND;
-  Lardon3DTask *task = lardon3d_task_create_typed("Extraction SIFT", &estimate, kind, 1, run,
-                                                  context, destroy_context);
-  if (!task || !lardon3d_task_assign_id(task, id) ||
-      !lardon3d_task_set_finished_callback(task, finished, context) ||
-      lardon3d_project_checkpoint_sift_extract_task(state, task, &durable) !=
-          LARDON3D_PROJECT_TASK_CHECKPOINT_OK) {
-    lardon3d_task_destroy(task);
-    return NULL;
-  }
-  *task_id = id;
-  return task;
-}
-
-bool lardon3d_project_enqueue_sift_extract(
-    Lardon3DAppState *state, uint64_t image_id, const Lardon3DSiftExtractorParameters *parameters,
-    uint64_t *task_id) {
-  if (!state || !state->task_queue) return false;
-  Lardon3DTask *task = lardon3d_project_create_sift_extract_task(state, image_id, parameters,
-                                                                 task_id);
-  if (!task) return false;
-  if (!lardon3d_task_queue_add(state->task_queue, task, NULL)) {
-    lardon3d_task_destroy(task);
-    return false;
-  }
-  return true;
-}

src/task_kinds.c

@@ -1,7 +1,5 @@
-#include <lardon3d/candidate_pair_task.h>
 #include <lardon3d/feature_task.h>
 #include <lardon3d/import_task.h>
-#include <lardon3d/sift_task.h>
 #include <lardon3d/visual_index_task.h>
 #include <lardon3d/task_kind_registry.h>
 
@@ -17,25 +15,10 @@ const Lardon3DTaskKindRegistry *lardon3d_task_kind_registry_production(void) {
           .kind_version = LARDON3D_FEATURE_EXTRACT_TASK_KIND_VERSION,
           .reconstruct = lardon3d_feature_extract_reconstruct,
       },
-      {
-          .kind = LARDON3D_SIFT_EXTRACT_TASK_KIND,
-          .kind_version = LARDON3D_SIFT_EXTRACT_TASK_KIND_VERSION,
-          .reconstruct = lardon3d_sift_extract_reconstruct,
-      },
-      {
-          .kind = LARDON3D_ROOTSIFT_EXTRACT_TASK_KIND,
-          .kind_version = LARDON3D_SIFT_EXTRACT_TASK_KIND_VERSION,
-          .reconstruct = lardon3d_sift_extract_reconstruct,
-      },
       {
           .kind = LARDON3D_VISUAL_INDEX_UPDATE_TASK_KIND,
           .kind_version = LARDON3D_VISUAL_INDEX_UPDATE_TASK_KIND_VERSION,
           .reconstruct = lardon3d_visual_index_update_reconstruct,
-      },
-      {
-          .kind = LARDON3D_CANDIDATE_PAIR_GENERATE_TASK_KIND,
-          .kind_version = LARDON3D_CANDIDATE_PAIR_GENERATE_TASK_KIND_VERSION,
-          .reconstruct = lardon3d_candidate_pair_generate_reconstruct,
       }};
   static const Lardon3DTaskKindRegistry registry = {
       .descriptors = descriptors,

tests/test_candidate_pair_gen.c

@@ -1,331 +0,0 @@
-#include <dirent.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/stat.h>
-#include <unistd.h>
-
-#include <lardon3d/candidate_pair_gen.h>
-#include <lardon3d/feature_store.h>
-#include <lardon3d/image_catalog.h>
-#include <lardon3d/project_db.h>
-#include <lardon3d/visual_index.h>
-
-#define CHECK(condition)                                                                           \
-  do {                                                                                             \
-    if (!(condition)) {                                                                            \
-      fprintf(stderr, "Échec ligne %d : %s\n", __LINE__, #condition);                             \
-      return false;                                                                                \
-    }                                                                                              \
-  } while (0)
-
-static bool join_path(char output[PATH_MAX], const char *left, const char *right) {
-  int written = snprintf(output, PATH_MAX, "%s/%s", left, right);
-  return written > 0 && (size_t)written < PATH_MAX;
-}
-
-static bool remove_tree(const char *path) {
-  struct stat status;
-  if (lstat(path, &status) != 0) {
-    return errno == ENOENT;
-  }
-  if (!S_ISDIR(status.st_mode)) {
-    return unlink(path) == 0;
-  }
-  DIR *directory = opendir(path);
-  if (!directory) {
-    return false;
-  }
-  bool ok = true;
-  for (struct dirent *entry = readdir(directory); entry; entry = readdir(directory)) {
-    if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) {
-      continue;
-    }
-    char child[PATH_MAX];
-    if (!join_path(child, path, entry->d_name) || !remove_tree(child)) {
-      ok = false;
-    }
-  }
-  return closedir(directory) == 0 && rmdir(path) == 0 && ok;
-}
-
-static bool write_source(const char *path, unsigned char value) {
-  int descriptor = open(path, O_WRONLY | O_CREAT | O_EXCL | O_CLOEXEC, 0600);
-  if (descriptor < 0) {
-    return false;
-  }
-  unsigned char bytes[64];
-  memset(bytes, value, sizeof(bytes));
-  bool ok = write(descriptor, bytes, sizeof(bytes)) == (ssize_t)sizeof(bytes);
-  return close(descriptor) == 0 && ok;
-}
-
-static bool publish_features(Lardon3DAppState *state, uint64_t image_id, unsigned int family,
-                             Lardon3DProjectDbFeatureSet *set) {
-  enum { COUNT = 16 };
-  Lardon3DFeatureKeypoint keypoints[COUNT];
-  unsigned char descriptors[COUNT * 32];
-  for (uint32_t i = 0; i < COUNT; ++i) {
-    keypoints[i] = (Lardon3DFeatureKeypoint){(float)i, (float)i, 8.0F, 0.0F,
-                                             (float)(COUNT - i), 0};
-    for (uint32_t byte = 0; byte < 32; ++byte) {
-      descriptors[i * 32 + byte] =
-          family == 0 || (family == 1 && i < 10)
-              ? (unsigned char)(i * 17U + byte * 29U)
-              : (unsigned char)(family * 73U + i * 31U + byte * 7U);
-    }
-  }
-  Lardon3DExtractedFeatures features = {
-      .image_width = 64,
-      .image_height = 64,
-      .feature_count = COUNT,
-      .keypoints = keypoints,
-      .descriptors = descriptors,
-      .descriptor_bytes = sizeof(descriptors),
-  };
-  Lardon3DFeatureExtractorParameters parameters = {64, 4, 20};
-  Lardon3DFeatureStoreResult result =
-      lardon3d_feature_store_publish(state, image_id, 0, &parameters, &features, set);
-  return result == LARDON3D_FEATURE_STORE_OK ||
-         result == LARDON3D_FEATURE_STORE_PUBLISHED_NOT_DURABLE;
-}
-
-static bool pair_exists(const Lardon3DProjectDbCandidatePair *pairs, size_t count,
-                        uint64_t image_a, uint64_t image_b) {
-  uint64_t canonical_a = image_a < image_b ? image_a : image_b;
-  uint64_t canonical_b = image_a < image_b ? image_b : image_a;
-  for (size_t i = 0; i < count; ++i) {
-    if (pairs[i].image_id_a == canonical_a && pairs[i].image_id_b == canonical_b) {
-      return true;
-    }
-  }
-  return false;
-}
-
-static bool run_test(void) {
-  char root[] = "/tmp/lardon3d-candidate-pair-gen-XXXXXX";
-  CHECK(mkdtemp(root));
-  char internal[PATH_MAX];
-  char database_path[PATH_MAX];
-  char source_paths[6][PATH_MAX];
-  CHECK(join_path(internal, root, ".lardon3d") && mkdir(internal, 0700) == 0 &&
-        join_path(database_path, root, "project.db"));
-  for (size_t i = 0; i < 6; ++i) {
-    CHECK(snprintf(source_paths[i], sizeof(source_paths[i]), "%s/source-%zu.bin", root, i) > 0 &&
-          write_source(source_paths[i], (unsigned char)(i + 1)));
-  }
-  Lardon3DProjectDb *database = NULL;
-  char error[LARDON3D_PROJECT_DB_ERROR_CAPACITY];
-  CHECK(lardon3d_project_db_open(database_path, &database, error) == LARDON3D_PROJECT_DB_OK);
-  Lardon3DAppState state;
-  lardon3d_app_state_init(&state);
-  state.project_loaded = true;
-  state.project_db = database;
-  CHECK(snprintf(state.project_path, sizeof(state.project_path), "%s", root) > 0);
-  Lardon3DProjectDbScanSet scan_a;
-  Lardon3DProjectDbScanSet scan_b;
-  CHECK(lardon3d_image_catalog_create_scanset(&state, "A", &scan_a) &&
-        lardon3d_image_catalog_create_scanset(&state, "B", &scan_b));
-  Lardon3DProjectDbImage images[6];
-  Lardon3DProjectDbImageAsset asset;
-  const uint64_t scansets[6] = {scan_a.scanset_id, scan_a.scanset_id, scan_a.scanset_id,
-                                scan_b.scanset_id, scan_b.scanset_id, scan_b.scanset_id};
-  const unsigned int families[6] = {0, 0, 0, 1, 2, 0};
-  for (size_t i = 0; i < 6; ++i) {
-    CHECK(lardon3d_image_catalog_import_file(&state, scansets[i], source_paths[i], 0, &images[i],
-                                             &asset) == LARDON3D_IMAGE_CATALOG_IMPORTED);
-  }
-  Lardon3DProjectDbFeatureSet feature_sets[6];
-  for (size_t i = 0; i < 6; ++i) {
-    CHECK(publish_features(&state, images[i].image_id, families[i], &feature_sets[i]));
-  }
-  Lardon3DVisualIndexConfiguration configuration = {1, 16, 4096};
-  uint64_t index_id = 0;
-  CHECK(lardon3d_visual_index_create(database, &feature_sets[0], &configuration, &index_id) ==
-            LARDON3D_VISUAL_INDEX_OK &&
-        index_id > 0);
-  uint64_t last = 0;
-  size_t indexed = 0;
-  CHECK(lardon3d_visual_index_update_once(root, database, index_id, 0, 0, 16, &last, &indexed) ==
-            LARDON3D_VISUAL_INDEX_OK &&
-        indexed == 6);
-
-  Lardon3DVisualIndexQueryOptions options = {
-      .top_k = 2,
-      .minimum_evidence_count = 1,
-      .scanset_filter = LARDON3D_VISUAL_INDEX_ANY_SCANSET,
-  };
-  Lardon3DCandidatePairGenStats stats;
-  Lardon3DProjectDbCandidatePair pairs[LARDON3D_PROJECT_DB_CANDIDATE_PAIR_PAGE_MAX];
-  size_t pair_count = 0;
-
-  /* Top-K borné : seuls les 2 meilleurs candidats sont persistés. */
-  CHECK(lardon3d_candidate_pair_generate(root, database, index_id,
-                                         feature_sets[0].feature_set_id, &options, &stats) ==
-            LARDON3D_VISUAL_INDEX_OK &&
-        stats.queried_count == 2 && stats.generated_count == 2 && stats.skipped_count == 0);
-  CHECK(lardon3d_project_db_list_candidate_pairs(database, 0, pairs, 256, &pair_count) ==
-            LARDON3D_PROJECT_DB_OK &&
-        pair_count == 2);
-  CHECK(pair_exists(pairs, pair_count, images[0].image_id, images[1].image_id) &&
-        pair_exists(pairs, pair_count, images[0].image_id, images[2].image_id) &&
-        !pair_exists(pairs, pair_count, images[0].image_id, images[5].image_id));
-
-  /* Moins de K candidats : 4 candidats retournés, 2 nouveaux, 2 déjà présents. */
-  options.top_k = 10;
-  CHECK(lardon3d_candidate_pair_generate(root, database, index_id,
-                                         feature_sets[0].feature_set_id, &options, &stats) ==
-            LARDON3D_VISUAL_INDEX_OK &&
-        stats.queried_count == 4 && stats.generated_count == 2 && stats.skipped_count == 2);
-  CHECK(lardon3d_project_db_list_candidate_pairs(database, 0, pairs, 256, &pair_count) ==
-            LARDON3D_PROJECT_DB_OK &&
-        pair_count == 4);
-  CHECK(pair_exists(pairs, pair_count, images[0].image_id, images[5].image_id) &&
-        pair_exists(pairs, pair_count, images[0].image_id, images[3].image_id));
-
-  /* Canonicalisation A,B / B,A : génération depuis l'autre extrémité. */
-  CHECK(lardon3d_candidate_pair_generate(root, database, index_id,
-                                         feature_sets[1].feature_set_id, &options, &stats) ==
-            LARDON3D_VISUAL_INDEX_OK &&
-        stats.queried_count == 4 && stats.generated_count == 3 && stats.skipped_count == 1);
-  Lardon3DProjectDbCandidatePair found;
-  CHECK(lardon3d_project_db_find_candidate_pair(database, images[1].image_id, images[0].image_id,
-                                                &found) == LARDON3D_PROJECT_DB_OK &&
-        found.image_id_a == images[0].image_id && found.image_id_b == images[1].image_id);
-
-  /* Génération répétée idempotente : aucune nouvelle paire. */
-  CHECK(lardon3d_candidate_pair_generate(root, database, index_id,
-                                         feature_sets[0].feature_set_id, &options, &stats) ==
-            LARDON3D_VISUAL_INDEX_OK &&
-        stats.queried_count == 4 && stats.generated_count == 0 && stats.skipped_count == 4);
-
-  /* Absence de doublons et exclusion self-pair. */
-  CHECK(lardon3d_project_db_list_candidate_pairs(database, 0, pairs, 256, &pair_count) ==
-            LARDON3D_PROJECT_DB_OK &&
-        pair_count == 7);
-  for (size_t i = 0; i < pair_count; ++i) {
-    CHECK(pairs[i].image_id_a < pairs[i].image_id_b);
-    for (size_t j = i + 1; j < pair_count; ++j) {
-      CHECK(pairs[i].image_id_a != pairs[j].image_id_a ||
-            pairs[i].image_id_b != pairs[j].image_id_b);
-    }
-  }
-
-  /* Plusieurs images partageant des candidats. */
-  CHECK(pair_exists(pairs, pair_count, images[1].image_id, images[2].image_id) &&
-        pair_exists(pairs, pair_count, images[1].image_id, images[5].image_id) &&
-        pair_exists(pairs, pair_count, images[1].image_id, images[3].image_id));
-
-  /* Image sans candidat : famille 2 sans correspondance. */
-  CHECK(lardon3d_candidate_pair_generate(root, database, index_id,
-                                         feature_sets[4].feature_set_id, &options, &stats) ==
-            LARDON3D_VISUAL_INDEX_OK &&
-        stats.queried_count == 0 && stats.generated_count == 0 && stats.skipped_count == 0);
-
-  /* Index vide : aucun segment, aucun candidat. */
-  Lardon3DVisualIndexConfiguration empty_configuration = {1, 15, 4096};
-  uint64_t empty_index = 0;
-  CHECK(lardon3d_visual_index_create(database, &feature_sets[0], &empty_configuration,
-                                     &empty_index) == LARDON3D_VISUAL_INDEX_OK &&
-        empty_index != index_id);
-  Lardon3DVisualIndexResult empty_result = lardon3d_candidate_pair_generate(
-      root, database, empty_index, feature_sets[0].feature_set_id, &options, &stats);
-  CHECK(empty_result == LARDON3D_VISUAL_INDEX_OK);
-  CHECK(stats.queried_count == 0 && stats.generated_count == 0 && stats.skipped_count == 0);
-
-  /* Ordre et scores déterministes du Visual Index. */
-  options.top_k = 4;
-  Lardon3DVisualIndexCandidate candidates[LARDON3D_VISUAL_INDEX_TOP_K_MAX];
-  size_t count_a = 0;
-  size_t count_b = 0;
-  CHECK(lardon3d_visual_index_query(root, database, index_id, feature_sets[0].feature_set_id,
-                                    &options, candidates, 4, &count_a) ==
-            LARDON3D_VISUAL_INDEX_OK &&
-        count_a == 4);
-  Lardon3DVisualIndexCandidate first[4];
-  memcpy(first, candidates, count_a * sizeof(*first));
-  CHECK(lardon3d_visual_index_query(root, database, index_id, feature_sets[0].feature_set_id,
-                                    &options, candidates, 4, &count_b) ==
-            LARDON3D_VISUAL_INDEX_OK &&
-        count_b == count_a);
-  for (size_t i = 0; i < count_a; ++i) {
-    CHECK(candidates[i].feature_set_id == first[i].feature_set_id &&
-          candidates[i].image_id == first[i].image_id &&
-          candidates[i].score == first[i].score &&
-          candidates[i].evidence_count == first[i].evidence_count);
-  }
-
-  /* Fingerprint déterministe. */
-  unsigned char fp1[32], fp2[32];
-  lardon3d_candidate_pair_generation_fingerprint(index_id, feature_sets[0].feature_set_id,
-                                                 &options, fp1);
-  lardon3d_candidate_pair_generation_fingerprint(index_id, feature_sets[0].feature_set_id,
-                                                 &options, fp2);
-  CHECK(memcmp(fp1, fp2, 32) == 0);
-  options.top_k = 8;
-  lardon3d_candidate_pair_generation_fingerprint(index_id, feature_sets[0].feature_set_id,
-                                                 &options, fp2);
-  CHECK(memcmp(fp1, fp2, 32) != 0);
-  options.top_k = 4;
-
-  /* Erreurs d'arguments. */
-  CHECK(lardon3d_candidate_pair_generate(NULL, database, index_id,
-                                         feature_sets[0].feature_set_id, &options, &stats) ==
-        LARDON3D_VISUAL_INDEX_INVALID_ARGUMENT);
-  CHECK(lardon3d_candidate_pair_generate(root, NULL, index_id, feature_sets[0].feature_set_id,
-                                         &options, &stats) == LARDON3D_VISUAL_INDEX_INVALID_ARGUMENT);
-  CHECK(lardon3d_candidate_pair_generate(root, database, 0, feature_sets[0].feature_set_id,
-                                         &options, &stats) == LARDON3D_VISUAL_INDEX_INVALID_ARGUMENT);
-  CHECK(lardon3d_candidate_pair_generate(root, database, index_id, 0, &options, &stats) ==
-        LARDON3D_VISUAL_INDEX_INVALID_ARGUMENT);
-  CHECK(lardon3d_candidate_pair_generate(root, database, index_id, feature_sets[0].feature_set_id,
-                                         NULL, &stats) == LARDON3D_VISUAL_INDEX_INVALID_ARGUMENT);
-  CHECK(lardon3d_candidate_pair_generate(root, database, index_id, feature_sets[0].feature_set_id,
-                                         &options, NULL) == LARDON3D_VISUAL_INDEX_INVALID_ARGUMENT);
-  options.top_k = 0;
-  CHECK(lardon3d_candidate_pair_generate(root, database, index_id,
-                                         feature_sets[0].feature_set_id, &options, &stats) ==
-        LARDON3D_VISUAL_INDEX_INVALID_ARGUMENT);
-  options.top_k = LARDON3D_VISUAL_INDEX_TOP_K_MAX + 1;
-  CHECK(lardon3d_candidate_pair_generate(root, database, index_id,
-                                         feature_sets[0].feature_set_id, &options, &stats) ==
-        LARDON3D_VISUAL_INDEX_INVALID_ARGUMENT);
-  options.top_k = 4;
-  CHECK(lardon3d_candidate_pair_generate(root, database, index_id, 999999, &options, &stats) ==
-        LARDON3D_VISUAL_INDEX_NOT_FOUND);
-
-  /* Génération batch : tous les FeatureSets. */
-  Lardon3DCandidatePairGenStats batch_stats;
-  uint64_t last_feature_set_id = 0;
-  options.top_k = 4;
-  CHECK(lardon3d_candidate_pair_generate_batch(root, database, index_id, 0, &options,
-                                                &batch_stats, &last_feature_set_id) ==
-            LARDON3D_VISUAL_INDEX_OK &&
-        batch_stats.queried_count > 0 && batch_stats.generated_count > 0);
-  CHECK(lardon3d_project_db_list_candidate_pairs(database, 0, pairs, 256, &pair_count) ==
-            LARDON3D_PROJECT_DB_OK &&
-        pair_count >= 7);
-  size_t batch_pair_count = pair_count;
-
-  /* Persistance puis réouverture de la base. */
-  lardon3d_project_db_close(database);
-  database = NULL;
-  state.project_db = NULL;
-  CHECK(lardon3d_project_db_open(database_path, &database, error) == LARDON3D_PROJECT_DB_OK);
-  state.project_db = database;
-  CHECK(lardon3d_project_db_list_candidate_pairs(database, 0, pairs, 256, &pair_count) ==
-            LARDON3D_PROJECT_DB_OK &&
-        pair_count == batch_pair_count);
-  CHECK(lardon3d_project_db_find_candidate_pair(database, images[1].image_id, images[0].image_id,
-                                                 &found) == LARDON3D_PROJECT_DB_OK &&
-        found.image_id_a == images[0].image_id && found.image_id_b == images[1].image_id);
-  lardon3d_project_db_close(database);
-  CHECK(remove_tree(root));
-  return true;
-}
-
-int main(void) { return run_test() ? 0 : 1; }

tests/test_candidate_pair_task.c

@@ -1,294 +0,0 @@
-#include <dirent.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <pthread.h>
-#include <sched.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/stat.h>
-#include <unistd.h>
-
-#include <lardon3d/candidate_pair_gen.h>
-#include <lardon3d/candidate_pair_task.h>
-#include <lardon3d/feature_store.h>
-#include <lardon3d/feature_task.h>
-#include <lardon3d/image_catalog.h>
-#include <lardon3d/project.h>
-#include <lardon3d/sift_task.h>
-#include <lardon3d/task_queue.h>
-#include <lardon3d/visual_index.h>
-#include <lardon3d/visual_index_task.h>
-
-#define CHECK(x)                                                                  \
-    do {                                                                          \
-        if (!(x)) {                                                               \
-            fprintf(stderr, "Echec ligne %d: %s\n", __LINE__, #x);               \
-            return false;                                                         \
-        }                                                                         \
-    } while (0)
-
-static bool join_path(char out[PATH_MAX], const char *a, const char *b) {
-    int n = snprintf(out, PATH_MAX, "%s/%s", a, b);
-    return n > 0 && (size_t)n < PATH_MAX;
-}
-
-static bool remove_tree(const char *p) {
-    struct stat s;
-    if (lstat(p, &s) != 0) return errno == ENOENT;
-    if (!S_ISDIR(s.st_mode)) return unlink(p) == 0;
-    DIR *d = opendir(p);
-    if (!d) return false;
-    bool ok = true;
-    for (struct dirent *e = readdir(d); e; e = readdir(d)) {
-        if (!strcmp(e->d_name, ".") || !strcmp(e->d_name, "..")) continue;
-        char c[PATH_MAX];
-        if (!join_path(c, p, e->d_name) || !remove_tree(c)) ok = false;
-    }
-    if (closedir(d) || rmdir(p)) ok = false;
-    return ok;
-}
-
-static bool write_pgm(const char *p, unsigned seed) {
-    FILE *f = fopen(p, "wb");
-    if (!f) return false;
-    fprintf(f, "P5\n192 192\n255\n");
-    for (unsigned y = 0; y < 192; y++) {
-        for (unsigned x = 0; x < 192; x++) {
-            unsigned base = ((((x / 12) ^ (y / 12)) & 1U) != 0U) ? 205U : 35U;
-            unsigned texture =
-                ((x * 17U + y * 29U + seed * 31U + (x * y) % 37U) % 43U);
-            int dx = (int)x - 96, dy = (int)y - 96;
-            unsigned ring =
-                (dx * dx + dy * dy > 32 * 32 &&
-                 dx * dx + dy * dy < 42 * 42) ? 45U : 0U;
-            unsigned char v = (unsigned char)(base + texture + ring > 255U
-                                                  ? 255U
-                                                  : base + texture + ring);
-            if (fwrite(&v, 1, 1, f) != 1) {
-                fclose(f);
-                return false;
-            }
-        }
-    }
-    return fclose(f) == 0;
-}
-
-static bool runtime(Lardon3DAppState *s) {
-    s->hardware_profile = (Lardon3DHardwareProfile){
-        .logical_cpu_count = 64,
-        .page_size_bytes = 4096,
-        .memory_total_bytes = UINT64_MAX,
-        .cpu_architecture = "test"};
-    Lardon3DResourcePolicy p = {.maximum_cpu_load_ratio = 1,
-                                .maximum_io_pressure_avg10 = 100,
-                                .io_slot_capacity = 2};
-    s->resource_governor =
-        lardon3d_resource_governor_create(&s->hardware_profile, &p);
-    s->task_queue = s->resource_governor
-                        ? lardon3d_task_queue_create(s->resource_governor, 4)
-                        : NULL;
-    return s->task_queue != NULL;
-}
-
-static bool wait_state(Lardon3DTaskQueue *q, uint64_t id,
-                       Lardon3DTaskState wanted, Lardon3DTaskSnapshot *out) {
-    for (size_t i = 0; i < 2000000; i++) {
-        if (lardon3d_task_queue_get(q, id, out) &&
-            out->state == wanted) {
-            return true;
-        }
-        sched_yield();
-    }
-    return false;
-}
-
-static bool run_test(void) {
-    char root[] = "/tmp/lardon3d-candidate-pair-task-XXXXXX";
-    CHECK(mkdtemp(root) &&
-          setenv("LARDON3D_PROJECTS_ROOT", root, 1) == 0);
-
-    /* --- Créer 3 images distinctes --- */
-    char source_a[PATH_MAX], source_b[PATH_MAX], source_c[PATH_MAX];
-    CHECK(join_path(source_a, root, "a.pgm") && write_pgm(source_a, 1));
-    CHECK(join_path(source_b, root, "b.pgm") && write_pgm(source_b, 2));
-    CHECK(join_path(source_c, root, "c.pgm") && write_pgm(source_c, 3));
-
-    Lardon3DAppState state;
-    lardon3d_app_state_init(&state);
-    CHECK(runtime(&state) && lardon3d_project_create(&state, "CPTask"));
-
-    Lardon3DProjectDbScanSet scanset;
-    CHECK(lardon3d_image_catalog_create_scanset(&state, "S", &scanset));
-
-    Lardon3DProjectDbImage img_a, img_b, img_c;
-    Lardon3DProjectDbImageAsset asset_a, asset_b, asset_c;
-    CHECK(lardon3d_image_catalog_import_file(&state, scanset.scanset_id,
-                                             source_a, 0, &img_a,
-                                             &asset_a) ==
-              LARDON3D_IMAGE_CATALOG_IMPORTED &&
-          lardon3d_image_catalog_import_file(&state, scanset.scanset_id,
-                                             source_b, 0, &img_b,
-                                             &asset_b) ==
-              LARDON3D_IMAGE_CATALOG_IMPORTED &&
-          lardon3d_image_catalog_import_file(&state, scanset.scanset_id,
-                                             source_c, 0, &img_c,
-                                             &asset_c) ==
-              LARDON3D_IMAGE_CATALOG_IMPORTED);
-
-    /* Extraction feature ORB */
-    Lardon3DFeatureExtractorParameters orb_params = {512, 4, 10};
-    uint64_t orb_a_id = 0, orb_b_id = 0, orb_c_id = 0;
-    CHECK(lardon3d_project_enqueue_feature_extract(
-              &state, img_a.image_id, &orb_params, &orb_a_id) &&
-          lardon3d_project_enqueue_feature_extract(
-              &state, img_b.image_id, &orb_params, &orb_b_id) &&
-          lardon3d_project_enqueue_feature_extract(
-              &state, img_c.image_id, &orb_params, &orb_c_id));
-    Lardon3DTaskSnapshot snap;
-    CHECK(wait_state(state.task_queue, orb_a_id, TASK_COMPLETED, &snap));
-    CHECK(wait_state(state.task_queue, orb_b_id, TASK_COMPLETED, &snap));
-    CHECK(wait_state(state.task_queue, orb_c_id, TASK_COMPLETED, &snap));
-
-    unsigned char fp[32];
-    lardon3d_feature_extractor_parameter_fingerprint(&orb_params, fp);
-    Lardon3DProjectDbFeatureSet fs_a, fs_b, fs_c;
-    CHECK(lardon3d_project_db_find_feature_set(
-              state.project_db, img_a.image_id,
-              LARDON3D_FEATURE_EXTRACTOR_KIND, 1, fp, &fs_a) ==
-              LARDON3D_PROJECT_DB_OK &&
-          lardon3d_project_db_find_feature_set(
-              state.project_db, img_b.image_id,
-              LARDON3D_FEATURE_EXTRACTOR_KIND, 1, fp, &fs_b) ==
-              LARDON3D_PROJECT_DB_OK &&
-          lardon3d_project_db_find_feature_set(
-              state.project_db, img_c.image_id,
-              LARDON3D_FEATURE_EXTRACTOR_KIND, 1, fp, &fs_c) ==
-              LARDON3D_PROJECT_DB_OK);
-
-    /* Visual Index */
-    Lardon3DVisualIndexConfiguration index_cfg = {1, 256, 128};
-    uint64_t visual_index_id = 0;
-    CHECK(lardon3d_visual_index_create(state.project_db, &fs_a, &index_cfg,
-                                       &visual_index_id) ==
-          LARDON3D_VISUAL_INDEX_OK);
-    uint64_t vi_task_id = 0;
-    CHECK(lardon3d_project_enqueue_visual_index_update(
-              &state, visual_index_id, &vi_task_id));
-    CHECK(wait_state(state.task_queue, vi_task_id, TASK_COMPLETED, &snap));
-
-    /* --- Test 1: Création task Candidate Pair --- */
-    Lardon3DVisualIndexQueryOptions qopts = {
-        .top_k = 16,
-        .minimum_evidence_count = 10,
-        .scanset_filter = LARDON3D_VISUAL_INDEX_ANY_SCANSET,
-        .exclude_same_asset = false,
-    };
-    uint64_t cp_task_id = 0;
-    CHECK(lardon3d_project_enqueue_candidate_pair_generate(
-        &state, visual_index_id, &qopts, &cp_task_id));
-    CHECK(cp_task_id != 0);
-    CHECK(wait_state(state.task_queue, cp_task_id, TASK_COMPLETED, &snap));
-    CHECK(snap.progress == 100);
-
-    /* Vérification : des paires ont été générées */
-    Lardon3DProjectDbCandidatePair pairs[16];
-    size_t pair_count = 0;
-    CHECK(lardon3d_project_db_list_candidate_pairs(
-              state.project_db, 0, pairs, 16, &pair_count) ==
-              LARDON3D_PROJECT_DB_OK &&
-          pair_count > 0);
-
-    /* --- Test 2: Idempotence --- */
-    uint64_t cp_task2_id = 0;
-    CHECK(lardon3d_project_enqueue_candidate_pair_generate(
-        &state, visual_index_id, &qopts, &cp_task2_id));
-    CHECK(cp_task2_id != cp_task_id);
-    CHECK(wait_state(state.task_queue, cp_task2_id, TASK_COMPLETED, &snap));
-    CHECK(snap.progress == 100);
-
-    size_t pair_count2 = 0;
-    CHECK(lardon3d_project_db_list_candidate_pairs(
-              state.project_db, 0, pairs, 16, &pair_count2) ==
-              LARDON3D_PROJECT_DB_OK &&
-          pair_count2 == pair_count);
-
-    /* --- Test 3: Checkpoint / reprise --- */
-    /* Pause après premier batch */
-    CHECK(setenv("LARDON3D_TEST_CANDIDATE_PAIR_PAUSE_AFTER_BATCH", "1",
-                 1) == 0 &&
-          setenv("LARDON3D_TEST_CANDIDATE_PAIR_SKIP_FINISHED_CHECKPOINT",
-                 "1", 1) == 0);
-
-    Lardon3DVisualIndexQueryOptions qopts_b = {
-        .top_k = 8, .minimum_evidence_count = 0,
-        .scanset_filter = LARDON3D_VISUAL_INDEX_ANY_SCANSET,
-        .exclude_same_asset = false,
-    };
-    uint64_t cp_task3_id = 0;
-    CHECK(lardon3d_project_enqueue_candidate_pair_generate(
-        &state, visual_index_id, &qopts_b, &cp_task3_id));
-    CHECK(wait_state(state.task_queue, cp_task3_id, TASK_PAUSED, &snap));
-
-    lardon3d_task_queue_destroy(state.task_queue);
-    state.task_queue = NULL;
-    lardon3d_project_close(&state);
-    lardon3d_resource_governor_destroy(state.resource_governor);
-    state.resource_governor = NULL;
-    CHECK(unsetenv("LARDON3D_TEST_CANDIDATE_PAIR_PAUSE_AFTER_BATCH") == 0 &&
-          unsetenv("LARDON3D_TEST_CANDIDATE_PAIR_SKIP_FINISHED_CHECKPOINT") ==
-              0);
-
-    lardon3d_app_state_init(&state);
-    CHECK(runtime(&state) && lardon3d_project_open(&state, "CPTask"));
-
-    Lardon3DProjectRecoverySummary summary;
-    CHECK(lardon3d_project_last_recovery_summary(&state, &summary) &&
-          summary.resumed == 1);
-    CHECK(wait_state(state.task_queue, cp_task3_id, TASK_COMPLETED, &snap) &&
-          snap.progress == 100);
-
-    /* --- Test 4: Reconstruction --- */
-    /* Attendre que la tâche se termine puis ré-ouvrir sans reprise */
-    lardon3d_task_queue_destroy(state.task_queue);
-    state.task_queue = NULL;
-    lardon3d_project_close(&state);
-    lardon3d_resource_governor_destroy(state.resource_governor);
-    state.resource_governor = NULL;
-
-    lardon3d_app_state_init(&state);
-    CHECK(runtime(&state) && lardon3d_project_open(&state, "CPTask"));
-    CHECK(lardon3d_project_last_recovery_summary(&state, &summary) &&
-          summary.resumed == 0);
-
-    /* Vérifier que la DB task est sauvegardée */
-    Lardon3DProjectDbCandidatePairGenerateTask saved;
-    CHECK(lardon3d_project_db_load_candidate_pair_generate_task(
-              state.project_db, cp_task_id, &saved) ==
-              LARDON3D_PROJECT_DB_OK &&
-          saved.top_k == 16);
-
-    /* --- Test 5: Ordre canonique vérifié --- */
-    size_t final_count = 0;
-    Lardon3DProjectDbCandidatePair final_pairs[32];
-    CHECK(lardon3d_project_db_list_candidate_pairs(
-              state.project_db, 0, final_pairs, 32, &final_count) ==
-              LARDON3D_PROJECT_DB_OK &&
-          final_count > 0);
-
-    for (size_t i = 0; i < final_count; ++i) {
-        CHECK(final_pairs[i].image_id_a < final_pairs[i].image_id_b);
-    }
-
-    lardon3d_task_queue_destroy(state.task_queue);
-    state.task_queue = NULL;
-    lardon3d_project_close(&state);
-    lardon3d_resource_governor_destroy(state.resource_governor);
-    CHECK(unlink(source_a) == 0 && unlink(source_b) == 0 &&
-          unlink(source_c) == 0 && remove_tree(root));
-    return true;
-}
-
-int main(void) { return run_test() ? 0 : 1; }

tests/test_feature_store.c

@@ -237,91 +237,8 @@ static bool run_test(void) {
         LARDON3D_FEATURE_STORE_INVALID_ARGUMENT);
   CHECK(lardon3d_feature_reader_descriptors(reader, 0, descriptors, 257, sizeof(descriptors)) ==
         LARDON3D_FEATURE_STORE_INVALID_ARGUMENT);
-  float wrong_type_descriptor[128];
-  CHECK(lardon3d_feature_reader_descriptors_f32(reader, 0, wrong_type_descriptor, 1,
-                                                sizeof(wrong_type_descriptor)) ==
-        LARDON3D_FEATURE_STORE_INVALID_ARGUMENT);
   lardon3d_feature_reader_close(reader);
 
-  uint32_t sift_count = f.feature_count < 300 ? f.feature_count : 300;
-  Lardon3DExtractedFeatures sift = {.image_width = f.image_width,
-                                    .image_height = f.image_height,
-                                    .feature_count = sift_count};
-  sift.keypoints = calloc(sift_count, sizeof(*sift.keypoints));
-  sift.descriptors = calloc((size_t)sift_count * 128, sizeof(float));
-  sift.descriptor_bytes = (size_t)sift_count * 128 * sizeof(float);
-  CHECK(sift_count > 0 && sift.keypoints && sift.descriptors);
-  memcpy(sift.keypoints, f.keypoints, (size_t)sift_count * sizeof(*sift.keypoints));
-  float *sift_values = (float *)sift.descriptors;
-  for (size_t i = 0; i < (size_t)sift_count * 128; ++i) {
-    sift_values[i] = (float)(i % 129) / 128.0F;
-  }
-  unsigned char sift_fp[32] = {0x53, 0x49, 0x46, 0x54};
-  uint32_t capabilities = LARDON3D_FEATURE_HAS_SCALE |
-                          LARDON3D_FEATURE_HAS_ORIENTATION |
-                          LARDON3D_FEATURE_HAS_RESPONSE | LARDON3D_FEATURE_HAS_OCTAVE;
-  Lardon3DProjectDbFeatureSet sift_set;
-  CHECK(lardon3d_feature_store_publish_v2(
-            &state, ia.image_id, 0, "sift", 1, sift_fp, LARDON3D_FEATURE_DESCRIPTOR_F32, 128,
-            capabilities, &sift, &sift_set) == LARDON3D_FEATURE_STORE_OK);
-  Lardon3DProjectDbFeatureSet future_extractor_set;
-  CHECK(lardon3d_feature_store_publish_v2(
-            &state, ia.image_id, 0, "sift", 2, sift_fp, LARDON3D_FEATURE_DESCRIPTOR_F32, 128,
-            capabilities, &sift, &future_extractor_set) ==
-        LARDON3D_FEATURE_STORE_INVALID_ARGUMENT);
-  CHECK(lardon3d_feature_reader_open(root, &sift_set, &reader, &metadata) ==
-            LARDON3D_FEATURE_STORE_OK &&
-        metadata.format_version == 2 &&
-        metadata.descriptor_type == LARDON3D_FEATURE_DESCRIPTOR_F32 &&
-        metadata.descriptor_dimension == 128 && metadata.descriptor_scalar_size_bytes == 4 &&
-        metadata.capabilities == capabilities);
-  float sift_range[256 * 128];
-  CHECK(lardon3d_feature_reader_descriptors_f32(reader, 0, sift_range, 1,
-                                                128 * sizeof(float)) ==
-            LARDON3D_FEATURE_STORE_OK &&
-        memcmp(sift_range, sift_values, 128 * sizeof(float)) == 0);
-  CHECK(lardon3d_feature_reader_descriptors_u8(reader, 0, descriptors, 1,
-                                               sizeof(descriptors)) ==
-        LARDON3D_FEATURE_STORE_INVALID_ARGUMENT);
-  uint32_t sift_chunk = sift_count < 256 ? sift_count : 256;
-  CHECK(lardon3d_feature_reader_descriptors_f32(reader, sift_count - sift_chunk, sift_range,
-                                                sift_chunk, sizeof(sift_range)) ==
-        LARDON3D_FEATURE_STORE_OK);
-  CHECK(lardon3d_feature_reader_descriptors_f32(reader, sift_count / 2, sift_range, 1,
-                                                128 * sizeof(float)) ==
-        LARDON3D_FEATURE_STORE_OK);
-  CHECK(lardon3d_feature_reader_descriptors_f32(reader, 0, sift_range, 257,
-                                                sizeof(sift_range)) ==
-        LARDON3D_FEATURE_STORE_INVALID_ARGUMENT);
-  lardon3d_feature_reader_close(reader);
-  ((float *)sift.descriptors)[0] = NAN;
-  unsigned char invalid_sift_fp[32] = {0x54};
-  CHECK(lardon3d_feature_store_publish_v2(
-            &state, ia.image_id, 0, "sift", 1, invalid_sift_fp,
-            LARDON3D_FEATURE_DESCRIPTOR_F32, 128, capabilities, &sift, &same) ==
-        LARDON3D_FEATURE_STORE_INVALID_ARGUMENT);
-  ((float *)sift.descriptors)[0] = sift_values[1];
-  Lardon3DExtractedFeatures wrong_sized_sift = sift;
-  wrong_sized_sift.descriptor_bytes -= sizeof(float);
-  invalid_sift_fp[0]++;
-  CHECK(lardon3d_feature_store_publish_v2(
-            &state, ia.image_id, 0, "sift", 1, invalid_sift_fp,
-            LARDON3D_FEATURE_DESCRIPTOR_F32, 128, capabilities, &wrong_sized_sift, &same) ==
-        LARDON3D_FEATURE_STORE_INVALID_ARGUMENT);
-  wrong_sized_sift.descriptor_bytes = sift.descriptor_bytes + sizeof(float);
-  invalid_sift_fp[0]++;
-  CHECK(lardon3d_feature_store_publish_v2(
-            &state, ia.image_id, 0, "sift", 1, invalid_sift_fp,
-            LARDON3D_FEATURE_DESCRIPTOR_F32, 128, capabilities, &wrong_sized_sift, &same) ==
-        LARDON3D_FEATURE_STORE_INVALID_ARGUMENT);
-  ((float *)sift.descriptors)[0] = INFINITY;
-  invalid_sift_fp[0]++;
-  CHECK(lardon3d_feature_store_publish_v2(
-            &state, ia.image_id, 0, "sift", 1, invalid_sift_fp,
-            LARDON3D_FEATURE_DESCRIPTOR_F32, 128, capabilities, &sift, &same) ==
-        LARDON3D_FEATURE_STORE_INVALID_ARGUMENT);
-  ((float *)sift.descriptors)[0] = sift_values[1];
-
   const char *invalid_paths[] = {
       "/assets/features/00/hash",
       "../assets/features/00/hash",
@@ -380,7 +297,6 @@ static bool run_test(void) {
       .image_width = 128, .image_height = 128, .feature_count = 8192};
   large.keypoints = calloc(large.feature_count, sizeof(*large.keypoints));
   large.descriptors = calloc(large.feature_count, 32);
-  large.descriptor_bytes = (size_t)large.feature_count * 32;
   CHECK(large.keypoints && large.descriptors);
   for (uint32_t i = 0; i < large.feature_count; ++i) {
     large.keypoints[i] =
@@ -400,35 +316,6 @@ static bool run_test(void) {
                                             sizeof(last_descriptor)) == LARDON3D_FEATURE_STORE_OK &&
         last_descriptor[0] == 255);
   lardon3d_feature_reader_close(reader);
-  Lardon3DExtractedFeatures large_float = {
-      .image_width = 128, .image_height = 128, .feature_count = 8192};
-  large_float.keypoints = calloc(large_float.feature_count, sizeof(*large_float.keypoints));
-  large_float.descriptors = calloc((size_t)large_float.feature_count * 128, sizeof(float));
-  large_float.descriptor_bytes = (size_t)large_float.feature_count * 128 * sizeof(float);
-  CHECK(large_float.keypoints && large_float.descriptors);
-  memcpy(large_float.keypoints, large.keypoints,
-         (size_t)large_float.feature_count * sizeof(*large_float.keypoints));
-  unsigned char large_float_fp[32] = {0x4c, 0x41, 0x52, 0x47, 0x45};
-  Lardon3DProjectDbFeatureSet large_float_set;
-  CHECK(lardon3d_feature_store_publish_v2(
-            &state, ia.image_id, 0, "rootsift", 1, large_float_fp,
-            LARDON3D_FEATURE_DESCRIPTOR_F32, 128, capabilities, &large_float,
-            &large_float_set) == LARDON3D_FEATURE_STORE_OK &&
-        lardon3d_feature_reader_open(root, &large_float_set, &reader, &metadata) ==
-            LARDON3D_FEATURE_STORE_OK &&
-        metadata.feature_count == 8192);
-  float large_float_range[256 * 128];
-  CHECK(lardon3d_feature_reader_descriptors_f32(reader, 0, large_float_range, 1,
-                                                sizeof(large_float_range)) ==
-            LARDON3D_FEATURE_STORE_OK &&
-        lardon3d_feature_reader_descriptors_f32(reader, 4096, large_float_range, 256,
-                                                sizeof(large_float_range)) ==
-            LARDON3D_FEATURE_STORE_OK &&
-        lardon3d_feature_reader_descriptors_f32(reader, 8191, large_float_range, 1,
-                                                sizeof(large_float_range)) ==
-            LARDON3D_FEATURE_STORE_OK);
-  lardon3d_feature_reader_close(reader);
-  lardon3d_extracted_features_destroy(&large_float);
   lardon3d_extracted_features_destroy(&large);
   char features_dir[PATH_MAX];
   CHECK(join_path(features_dir, root, "assets/features"));
@@ -469,7 +356,7 @@ static bool run_test(void) {
         count == 1);
   CHECK(lardon3d_project_db_list_feature_sets(db, page[0].feature_set_id, page, 8, &count) ==
             LARDON3D_PROJECT_DB_OK &&
-        count == 8);
+        count == 6);
   for (uint32_t index = 0; index < 2000; ++index) {
     unsigned char metadata_fingerprint[32] = {0};
     metadata_fingerprint[0] = (unsigned char)index;
@@ -525,52 +412,17 @@ static bool run_test(void) {
           restore_file(asset_path, original, original_size));
   }
 
-  unsigned char future_version[4] = {3, 0, 0, 0};
+  unsigned char future_version[4] = {2, 0, 0, 0};
   fd = open(asset_path, O_WRONLY | O_CLOEXEC);
   CHECK(fd >= 0 && pwrite(fd, future_version, sizeof(future_version), 8) == 4 && close(fd) == 0 &&
         expect_reader_result(root, &sa, LARDON3D_FEATURE_STORE_UNSUPPORTED_VERSION) &&
         restore_file(asset_path, original, original_size));
 
-  char sift_asset_path[PATH_MAX];
-  CHECK(join_path(sift_asset_path, root, sift_set.asset.path));
-  fd = open(sift_asset_path, O_RDONLY | O_CLOEXEC);
-  CHECK(fd >= 0 && fstat(fd, &asset_info) == 0 && asset_info.st_size >= 176);
-  size_t sift_original_size = (size_t)asset_info.st_size;
-  unsigned char *sift_original = malloc(sift_original_size);
-  CHECK(sift_original && read(fd, sift_original, sift_original_size) ==
-                             (ssize_t)sift_original_size &&
-        close(fd) == 0);
-  const size_t v2_corrupt_offsets[] = {12, 16, 20, 24, 28, 32, 36, 40, 44,
-                                       48, 56, 64, 72, 104, 136, 152, 160};
-  for (size_t index = 0; index < sizeof(v2_corrupt_offsets) / sizeof(v2_corrupt_offsets[0]);
-       ++index) {
-    size_t offset = v2_corrupt_offsets[index];
-    unsigned char mutated = (unsigned char)(sift_original[offset] ^ 0x5aU);
-    fd = open(sift_asset_path, O_WRONLY | O_CLOEXEC);
-    CHECK(fd >= 0 && pwrite(fd, &mutated, 1, (off_t)offset) == 1 && close(fd) == 0 &&
-          expect_reader_result(root, &sift_set, LARDON3D_FEATURE_STORE_CORRUPT) &&
-          restore_file(sift_asset_path, sift_original, sift_original_size));
-  }
-  fd = open(sift_asset_path, O_WRONLY | O_CLOEXEC);
-  CHECK(fd >= 0 && pwrite(fd, future_version, sizeof(future_version), 8) == 4 && close(fd) == 0 &&
-        expect_reader_result(root, &sift_set, LARDON3D_FEATURE_STORE_UNSUPPORTED_VERSION) &&
-        restore_file(sift_asset_path, sift_original, sift_original_size));
-  uint64_t sift_descriptor_offset = read_u64_le(sift_original + 56);
-  unsigned char nan_le[4] = {0, 0, 0xc0, 0x7f};
-  fd = open(sift_asset_path, O_WRONLY | O_CLOEXEC);
-  CHECK(fd >= 0 && pwrite(fd, nan_le, sizeof(nan_le), (off_t)sift_descriptor_offset) == 4 &&
-        close(fd) == 0 &&
-        expect_reader_result(root, &sift_set, LARDON3D_FEATURE_STORE_CORRUPT) &&
-        expect_reader_result(root, &sa, LARDON3D_FEATURE_STORE_OK) &&
-        restore_file(sift_asset_path, sift_original, sift_original_size));
-  free(sift_original);
-
   fd = open(asset_path, O_WRONLY | O_TRUNC | O_CLOEXEC);
   CHECK(fd >= 0 && write(fd, "bad", 3) == 3 && close(fd) == 0 &&
         expect_reader_result(root, &sa, LARDON3D_FEATURE_STORE_CORRUPT));
   free(original);
   lardon3d_extracted_features_destroy(&f);
-  lardon3d_extracted_features_destroy(&sift);
   lardon3d_extracted_features_destroy(&uf);
   lardon3d_project_db_close(db);
   CHECK(remove_tree(root));

tests/test_feature_task.c

@@ -1,8 +1,5 @@
 #include <dirent.h>
 #include <errno.h>
-#include <fcntl.h>
-#include <math.h>
-#include <pthread.h>
 #include <sched.h>
 #include <stdbool.h>
 #include <stdint.h>
@@ -18,8 +15,6 @@
 #include <lardon3d/visual_index_task.h>
 #include <lardon3d/image_catalog.h>
 #include <lardon3d/project.h>
-#include <lardon3d/precision_features.h>
-#include <lardon3d/sift_task.h>
 #include <lardon3d/task_queue.h>
 
 #define CHECK(x)                                                                                   \
@@ -68,14 +63,7 @@ static bool write_pgm(const char *p) {
   fprintf(f, "P5\n192 192\n255\n");
   for (unsigned y = 0; y < 192; y++) {
     for (unsigned x = 0; x < 192; x++) {
-      unsigned base = ((((x / 12) ^ (y / 12)) & 1U) != 0U) ? 205U : 35U;
+      unsigned char v = (unsigned char)((((x / 6) ^ (y / 6)) & 1) ? 245 : 10);
-      unsigned texture = (x * 17U + y * 29U + (x * y) % 37U) % 43U;
-      int dx = (int)x - 96;
-      int dy = (int)y - 96;
-      unsigned ring = (dx * dx + dy * dy > 32 * 32 && dx * dx + dy * dy < 42 * 42) ? 45U : 0U;
-      unsigned char v = (unsigned char)(base + texture + ring > 255U
-                                            ? 255U
-                                            : base + texture + ring);
       if (fwrite(&v, 1, 1, f) != 1) {
         fclose(f);
         return false;
@@ -84,15 +72,6 @@ static bool write_pgm(const char *p) {
   }
   return fclose(f) == 0;
 }
-static bool write_uniform_pgm(const char *path) {
-  FILE *file = fopen(path, "wb");
-  if (!file) return false;
-  bool ok = fprintf(file, "P5\n192 192\n255\n") > 0;
-  unsigned char row[192];
-  memset(row, 127, sizeof(row));
-  for (size_t y = 0; ok && y < 192; ++y) ok = fwrite(row, 1, sizeof(row), file) == sizeof(row);
-  return fclose(file) == 0 && ok;
-}
 static bool runtime(Lardon3DAppState *s) {
   s->hardware_profile = (Lardon3DHardwareProfile){.logical_cpu_count = 64,
                                                   .page_size_bytes = 4096,
@@ -115,23 +94,6 @@ static bool wait_state(Lardon3DTaskQueue *q, uint64_t id, Lardon3DTaskState want
   return false;
 }
 
-typedef struct {
-  Lardon3DAppState *state;
-  uint64_t orb_feature_set_id;
-  uint64_t sift_feature_set_id;
-  Lardon3DFeatureConsolidationParameters parameters;
-  Lardon3DProjectDbFeatureSupportSet support;
-  Lardon3DProjectDbResult result;
-} ConsolidationThreadContext;
-
-static void *consolidate_thread(void *userdata) {
-  ConsolidationThreadContext *context = userdata;
-  context->result = lardon3d_consolidate_orb_sift(
-      context->state, context->orb_feature_set_id, context->sift_feature_set_id,
-      &context->parameters, &context->support);
-  return NULL;
-}
-
 static bool run_test(void) {
   char root[] = "/tmp/lardon3d-feature-task-XXXXXX";
   CHECK(mkdtemp(root) && setenv("LARDON3D_PROJECTS_ROOT", root, 1) == 0);
@@ -189,244 +151,6 @@ static bool run_test(void) {
         LARDON3D_FEATURE_STORE_OK);
   lardon3d_feature_reader_close(reader);
 
-  Lardon3DSiftExtractorParameters sift_parameters = lardon3d_sift_precision_classic_v1(false);
-  sift_parameters.max_features = 512;
-  uint64_t sift_task_id = 0, concurrent_identical_sift_task = 0;
-  CHECK(lardon3d_project_enqueue_sift_extract(&state, image.image_id, &sift_parameters,
-                                              &sift_task_id) &&
-        lardon3d_project_enqueue_sift_extract(&state, image.image_id, &sift_parameters,
-                                              &concurrent_identical_sift_task));
-  CHECK(sift_task_id != concurrent_identical_sift_task &&
-        wait_state(state.task_queue, sift_task_id, TASK_COMPLETED, &snapshot) &&
-        wait_state(state.task_queue, concurrent_identical_sift_task, TASK_COMPLETED, &snapshot));
-  unsigned char sift_fingerprint[32];
-  lardon3d_sift_extractor_parameter_fingerprint(&sift_parameters, sift_fingerprint);
-  unsigned char same_sift_fingerprint[32], changed_sift_fingerprint[32];
-  Lardon3DSiftExtractorParameters changed_sift_parameters = sift_parameters;
-  changed_sift_parameters.sigma = 1.7;
-  lardon3d_sift_extractor_parameter_fingerprint(&sift_parameters, same_sift_fingerprint);
-  lardon3d_sift_extractor_parameter_fingerprint(&changed_sift_parameters,
-                                                changed_sift_fingerprint);
-  CHECK(memcmp(sift_fingerprint, same_sift_fingerprint, 32) == 0 &&
-        memcmp(sift_fingerprint, changed_sift_fingerprint, 32) != 0);
-  Lardon3DSiftExtractorParameters fingerprint_variants[8];
-  for (size_t variant = 0; variant < 8; ++variant)
-    fingerprint_variants[variant] = sift_parameters;
-  fingerprint_variants[0].max_features--;
-  fingerprint_variants[1].octave_layers++;
-  fingerprint_variants[2].contrast_threshold += 0.001;
-  fingerprint_variants[3].edge_threshold += 1.0;
-  fingerprint_variants[4].grid_rows--;
-  fingerprint_variants[5].grid_cols--;
-  fingerprint_variants[6].max_features_per_cell--;
-  fingerprint_variants[7].rootsift = true;
-  for (size_t variant = 0; variant < 8; ++variant) {
-    lardon3d_sift_extractor_parameter_fingerprint(&fingerprint_variants[variant],
-                                                  changed_sift_fingerprint);
-    CHECK(memcmp(sift_fingerprint, changed_sift_fingerprint, 32) != 0);
-  }
-  Lardon3DProjectDbFeatureSet sift_set;
-  CHECK(lardon3d_project_db_find_feature_set(state.project_db, image.image_id, "sift", 1,
-                                             sift_fingerprint, &sift_set) ==
-            LARDON3D_PROJECT_DB_OK &&
-        sift_set.total_cells == 64 && sift_set.occupied_cells > 0 &&
-        sift_set.coverage_ratio > 0.0 && sift_set.coverage_ratio <= 1.0 &&
-        sift_set.feature_density_per_megapixel > 0.0);
-  Lardon3DVisualIndexConfiguration incompatible_index_configuration = {1, 256, 128};
-  uint64_t incompatible_visual_index = 0;
-  CHECK(lardon3d_visual_index_create(state.project_db, &sift_set,
-                                     &incompatible_index_configuration,
-                                     &incompatible_visual_index) ==
-            LARDON3D_VISUAL_INDEX_INVALID_ARGUMENT &&
-        incompatible_visual_index == 0);
-  CHECK(lardon3d_feature_reader_open(state.project_path, &sift_set, &reader, &metadata) ==
-            LARDON3D_FEATURE_STORE_OK &&
-        metadata.format_version == 2 && metadata.descriptor_dimension == 128 &&
-        metadata.descriptor_type == LARDON3D_FEATURE_DESCRIPTOR_F32);
-  float sift_descriptors[128];
-  if (metadata.feature_count > 0) {
-    CHECK(lardon3d_feature_reader_descriptors_f32(reader, 0, sift_descriptors, 1,
-                                                  sizeof(sift_descriptors)) ==
-          LARDON3D_FEATURE_STORE_OK);
-  }
-  lardon3d_feature_reader_close(reader);
-  uint64_t duplicate_sift_task = 0;
-  CHECK(lardon3d_project_enqueue_sift_extract(&state, image.image_id, &sift_parameters,
-                                              &duplicate_sift_task));
-  CHECK(wait_state(state.task_queue, duplicate_sift_task, TASK_COMPLETED, &snapshot));
-  Lardon3DProjectDbFeatureSet duplicate_sift_set;
-  CHECK(lardon3d_project_db_find_feature_set(state.project_db, image.image_id, "sift", 1,
-                                             sift_fingerprint, &duplicate_sift_set) ==
-            LARDON3D_PROJECT_DB_OK &&
-        duplicate_sift_set.feature_set_id == sift_set.feature_set_id);
-  Lardon3DSiftExtractorParameters rootsift_parameters = sift_parameters;
-  rootsift_parameters.rootsift = true;
-  uint64_t rootsift_task_id = 0;
-  CHECK(lardon3d_project_enqueue_sift_extract(&state, image.image_id, &rootsift_parameters,
-                                              &rootsift_task_id));
-  CHECK(wait_state(state.task_queue, rootsift_task_id, TASK_COMPLETED, &snapshot));
-  unsigned char rootsift_fingerprint[32];
-  lardon3d_sift_extractor_parameter_fingerprint(&rootsift_parameters, rootsift_fingerprint);
-  Lardon3DProjectDbFeatureSet rootsift_set;
-  CHECK(lardon3d_project_db_find_feature_set(state.project_db, image.image_id, "rootsift", 1,
-                                             rootsift_fingerprint, &rootsift_set) ==
-            LARDON3D_PROJECT_DB_OK &&
-        rootsift_set.feature_set_id != sift_set.feature_set_id);
-  CHECK(lardon3d_feature_reader_open(state.project_path, &rootsift_set, &reader, &metadata) ==
-        LARDON3D_FEATURE_STORE_OK);
-  if (metadata.feature_count > 0) {
-    float root_descriptor[128];
-    CHECK(lardon3d_feature_reader_descriptors_f32(reader, 0, root_descriptor, 1,
-                                                  sizeof(root_descriptor)) ==
-          LARDON3D_FEATURE_STORE_OK);
-    double squared_norm = 0.0;
-    for (size_t dimension = 0; dimension < 128; ++dimension) {
-      CHECK(isfinite(root_descriptor[dimension]) && root_descriptor[dimension] >= 0.0F);
-      squared_norm += (double)root_descriptor[dimension] * root_descriptor[dimension];
-    }
-    CHECK(squared_norm == 0.0 || (squared_norm > 0.999 && squared_norm < 1.001));
-  }
-  lardon3d_feature_reader_close(reader);
-  Lardon3DFeatureConsolidationParameters support_parameters =
-      lardon3d_feature_consolidation_v1();
-  ConsolidationThreadContext support_contexts[2] = {
-      {.state = &state,
-       .orb_feature_set_id = set.feature_set_id,
-       .sift_feature_set_id = sift_set.feature_set_id,
-       .parameters = support_parameters},
-      {.state = &state,
-       .orb_feature_set_id = set.feature_set_id,
-       .sift_feature_set_id = sift_set.feature_set_id,
-       .parameters = support_parameters}};
-  pthread_t support_threads[2];
-  CHECK(pthread_create(&support_threads[0], NULL, consolidate_thread, &support_contexts[0]) == 0 &&
-        pthread_create(&support_threads[1], NULL, consolidate_thread, &support_contexts[1]) == 0 &&
-        pthread_join(support_threads[0], NULL) == 0 && pthread_join(support_threads[1], NULL) == 0);
-  Lardon3DProjectDbFeatureSupportSet support = support_contexts[0].support;
-  CHECK(support_contexts[0].result == LARDON3D_PROJECT_DB_OK &&
-        support_contexts[1].result == LARDON3D_PROJECT_DB_OK && support.group_count > 0 &&
-        support.group_count <= set.feature_count + sift_set.feature_count &&
-        support_contexts[1].support.feature_support_set_id == support.feature_support_set_id &&
-        support_contexts[1].support.group_count == support.group_count);
-  Lardon3DProjectDbFeatureSupportGroup support_page[256];
-  uint64_t after_support_group = 0;
-  uint32_t listed_support_groups = 0;
-  bool has_confirmed_support = false;
-  do {
-    size_t support_page_count = 0;
-    CHECK(lardon3d_project_db_list_feature_support_groups(
-              state.project_db, support.feature_support_set_id, after_support_group,
-              support_page, 256, &support_page_count) == LARDON3D_PROJECT_DB_OK);
-    if (support_page_count == 0) break;
-    for (size_t group = 0; group < support_page_count; ++group) {
-      CHECK(support_page[group].feature_support_set_id == support.feature_support_set_id &&
-            support_page[group].feature_support_group_id > after_support_group &&
-            support_page[group].support_count >= 1 && support_page[group].support_count <= 2 &&
-            support_page[group].distance_pixels >= 0.0 &&
-            support_page[group].distance_pixels <= support_parameters.association_radius_pixels);
-      has_confirmed_support |= support_page[group].support_count == 2;
-      after_support_group = support_page[group].feature_support_group_id;
-    }
-    listed_support_groups += (uint32_t)support_page_count;
-  } while (listed_support_groups < support.group_count);
-  CHECK(listed_support_groups == support.group_count && has_confirmed_support);
-  Lardon3DProjectDbFeatureSupportGroup isolated_rank = {.feature_support_group_id = 1,
-                                                        .support_count = 1};
-  Lardon3DProjectDbFeatureSupportGroup confirmed_rank = {.feature_support_group_id = 2,
-                                                         .support_count = 2};
-  CHECK(lardon3d_feature_support_higher_quality(&confirmed_rank, &isolated_rank) &&
-        !lardon3d_feature_support_higher_quality(&isolated_rank, &confirmed_rank));
-  Lardon3DSiftExtractorParameters cancelled_parameters = sift_parameters;
-  cancelled_parameters.max_features = 499;
-  unsigned char cancelled_fingerprint[32];
-  lardon3d_sift_extractor_parameter_fingerprint(&cancelled_parameters, cancelled_fingerprint);
-  CHECK(setenv("LARDON3D_TEST_SIFT_PAUSE_BEFORE_PUBLISH", "1", 1) == 0);
-  uint64_t cancelled_sift_task = 0;
-  CHECK(lardon3d_project_enqueue_sift_extract(&state, image.image_id, &cancelled_parameters,
-                                              &cancelled_sift_task) &&
-        wait_state(state.task_queue, cancelled_sift_task, TASK_PAUSED, &snapshot) &&
-        lardon3d_task_queue_cancel(state.task_queue, cancelled_sift_task) &&
-        wait_state(state.task_queue, cancelled_sift_task, TASK_CANCELLED, &snapshot) &&
-        unsetenv("LARDON3D_TEST_SIFT_PAUSE_BEFORE_PUBLISH") == 0);
-  Lardon3DProjectDbFeatureSet cancelled_set;
-  CHECK(lardon3d_project_db_find_feature_set(state.project_db, image.image_id, "sift", 1,
-                                             cancelled_fingerprint, &cancelled_set) ==
-        LARDON3D_PROJECT_DB_NOT_FOUND);
-  char uniform_source[PATH_MAX];
-  CHECK(join_path(uniform_source, root, "uniform.pgm") && write_uniform_pgm(uniform_source));
-  Lardon3DProjectDbImage uniform_image;
-  Lardon3DProjectDbImageAsset uniform_asset;
-  CHECK(lardon3d_image_catalog_import_file(&state, scanset.scanset_id, uniform_source, 0,
-                                           &uniform_image, &uniform_asset) ==
-        LARDON3D_IMAGE_CATALOG_IMPORTED);
-  uint64_t uniform_sift_task = 0;
-  CHECK(lardon3d_project_enqueue_sift_extract(&state, uniform_image.image_id, &sift_parameters,
-                                              &uniform_sift_task) &&
-        wait_state(state.task_queue, uniform_sift_task, TASK_COMPLETED, &snapshot));
-  Lardon3DProjectDbFeatureSet uniform_sift_set;
-  CHECK(lardon3d_project_db_find_feature_set(state.project_db, uniform_image.image_id, "sift", 1,
-                                             sift_fingerprint, &uniform_sift_set) ==
-            LARDON3D_PROJECT_DB_OK &&
-        uniform_sift_set.feature_count == 0 && unlink(uniform_source) == 0);
-  Lardon3DSiftExtractorParameters recovery_parameters = sift_parameters;
-  recovery_parameters.max_features = 500;
-  CHECK(setenv("LARDON3D_TEST_SIFT_PAUSE_BEFORE_PUBLISH", "1", 1) == 0 &&
-        setenv("LARDON3D_TEST_SIFT_SKIP_FINISHED_CHECKPOINT", "1", 1) == 0);
-  uint64_t recovery_sift_task = 0;
-  CHECK(lardon3d_project_enqueue_sift_extract(&state, image.image_id, &recovery_parameters,
-                                              &recovery_sift_task));
-  CHECK(wait_state(state.task_queue, recovery_sift_task, TASK_PAUSED, &snapshot));
-  lardon3d_task_queue_destroy(state.task_queue);
-  state.task_queue = NULL;
-  lardon3d_project_close(&state);
-  lardon3d_resource_governor_destroy(state.resource_governor);
-  state.resource_governor = NULL;
-  CHECK(unsetenv("LARDON3D_TEST_SIFT_PAUSE_BEFORE_PUBLISH") == 0 &&
-        unsetenv("LARDON3D_TEST_SIFT_SKIP_FINISHED_CHECKPOINT") == 0);
-  lardon3d_app_state_init(&state);
-  CHECK(runtime(&state) && lardon3d_project_open(&state, "Features"));
-  CHECK(lardon3d_project_last_recovery_summary(&state, &summary) && summary.resumed == 1);
-  CHECK(wait_state(state.task_queue, recovery_sift_task, TASK_COMPLETED, &snapshot));
-  unsigned char recovery_fingerprint[32];
-  lardon3d_sift_extractor_parameter_fingerprint(&recovery_parameters, recovery_fingerprint);
-  Lardon3DProjectDbFeatureSet recovered_sift;
-  CHECK(lardon3d_project_db_find_feature_set(state.project_db, image.image_id, "sift", 1,
-                                             recovery_fingerprint, &recovered_sift) ==
-        LARDON3D_PROJECT_DB_OK);
-
-  char second_source[PATH_MAX];
-  CHECK(join_path(second_source, root, "second-source.pgm") && write_pgm(second_source));
-  FILE *second_file = fopen(second_source, "ab");
-  CHECK(second_file && fwrite("x", 1, 1, second_file) == 1 && fclose(second_file) == 0);
-  Lardon3DProjectDbImage second_image;
-  Lardon3DProjectDbImageAsset second_asset;
-  CHECK(lardon3d_image_catalog_import_file(&state, scanset.scanset_id, second_source, 0,
-                                           &second_image, &second_asset) ==
-            LARDON3D_IMAGE_CATALOG_IMPORTED &&
-        second_image.image_id != image.image_id);
-  Lardon3DSiftExtractorParameters first_parallel = sift_parameters;
-  Lardon3DSiftExtractorParameters second_parallel = sift_parameters;
-  first_parallel.max_features = 496;
-  second_parallel.max_features = 497;
-  uint64_t first_parallel_task = 0, second_parallel_task = 0;
-  CHECK(lardon3d_project_enqueue_sift_extract(&state, image.image_id, &first_parallel,
-                                              &first_parallel_task) &&
-        lardon3d_project_enqueue_sift_extract(&state, second_image.image_id, &second_parallel,
-                                              &second_parallel_task) &&
-        wait_state(state.task_queue, first_parallel_task, TASK_COMPLETED, &snapshot) &&
-        wait_state(state.task_queue, second_parallel_task, TASK_COMPLETED, &snapshot));
-  unsigned char second_parallel_fingerprint[32];
-  lardon3d_sift_extractor_parameter_fingerprint(&second_parallel,
-                                                second_parallel_fingerprint);
-  Lardon3DProjectDbFeatureSet second_sift;
-  CHECK(lardon3d_project_db_find_feature_set(state.project_db, second_image.image_id, "sift", 1,
-                                             second_parallel_fingerprint, &second_sift) ==
-            LARDON3D_PROJECT_DB_OK &&
-        unlink(second_source) == 0 &&
-        lardon3d_feature_reader_open(state.project_path, &second_sift, &reader, &metadata) ==
-            LARDON3D_FEATURE_STORE_OK);
-  lardon3d_feature_reader_close(reader);
-
   Lardon3DVisualIndexConfiguration index_configuration = {1, 256, 128};
   uint64_t visual_index_id = 0;
   CHECK(lardon3d_visual_index_create(state.project_db, &set, &index_configuration,
@@ -453,28 +177,6 @@ static bool run_test(void) {
             state.project_db, visual_index_id, 0, visual_segments, 2, &visual_segment_count) ==
             LARDON3D_PROJECT_DB_OK &&
         visual_segment_count == 1);
-  CHECK(lardon3d_project_db_load_feature_set(state.project_db, second_sift.feature_set_id,
-                                             &second_sift) == LARDON3D_PROJECT_DB_OK &&
-        lardon3d_feature_reader_open(state.project_path, &second_sift, &reader, &metadata) ==
-            LARDON3D_FEATURE_STORE_OK);
-  lardon3d_feature_reader_close(reader);
-
-  char second_managed_path[PATH_MAX];
-  CHECK(join_path(second_managed_path, state.project_path, second_asset.path));
-  int second_managed_fd = open(second_managed_path, O_WRONLY | O_CLOEXEC);
-  unsigned char corrupt_byte = 0;
-  CHECK(second_managed_fd >= 0 && pwrite(second_managed_fd, &corrupt_byte, 1, 32) == 1 &&
-        close(second_managed_fd) == 0);
-  Lardon3DSiftExtractorParameters corrupt_source_parameters = sift_parameters;
-  corrupt_source_parameters.max_features = 498;
-  uint64_t corrupt_source_task = 0;
-  CHECK(lardon3d_project_enqueue_sift_extract(&state, second_image.image_id,
-                                              &corrupt_source_parameters,
-                                              &corrupt_source_task) &&
-        wait_state(state.task_queue, corrupt_source_task, TASK_FAILED, &snapshot) &&
-        lardon3d_feature_reader_open(state.project_path, &second_sift, &reader, &metadata) ==
-            LARDON3D_FEATURE_STORE_OK);
-  lardon3d_feature_reader_close(reader);
 
   CHECK(write_pgm(source));
   Lardon3DProjectDbImage missing_image;
@@ -505,10 +207,6 @@ static bool run_test(void) {
   CHECK(lardon3d_project_enqueue_feature_extract(&state, invalid_image.image_id,
                                                  &invalid_parameters, &invalid_task_id));
   CHECK(wait_state(state.task_queue, invalid_task_id, TASK_FAILED, &snapshot));
-  uint64_t invalid_sift_task_id = 0;
-  CHECK(lardon3d_project_enqueue_sift_extract(&state, invalid_image.image_id, &sift_parameters,
-                                              &invalid_sift_task_id) &&
-        wait_state(state.task_queue, invalid_sift_task_id, TASK_FAILED, &snapshot));
   lardon3d_task_queue_destroy(state.task_queue);
   state.task_queue = NULL;
   lardon3d_project_close(&state);

tests/test_precision_features.cpp

@@ -1,316 +0,0 @@
-#include <algorithm>
-#include <chrono>
-#include <cmath>
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-#include <limits>
-#include <string>
-#include <vector>
-#include <unistd.h>
-
-#include <opencv2/core.hpp>
-#include <opencv2/features2d.hpp>
-#include <opencv2/geometry/2d.hpp>
-#include <opencv2/imgcodecs.hpp>
-#include <opencv2/imgproc.hpp>
-
-extern "C" {
-#include <lardon3d/feature_extractor.h>
-}
-
-#define CHECK(x)                                                                                 \
-  do {                                                                                           \
-    if (!(x)) {                                                                                  \
-      std::fprintf(stderr, "precision benchmark failure line %d: %s\n", __LINE__, #x);           \
-      return 1;                                                                                  \
-    }                                                                                            \
-  } while (0)
-
-struct Metrics {
-  size_t count{};
-  double coverage{};
-  double repeatability{};
-  double median{};
-  double p90{};
-  double milliseconds{};
-  double correct_matches{};
-};
-
-static cv::Mat fixture(bool low_texture = false) {
-  cv::Mat image(384, 512, CV_8U, cv::Scalar(low_texture ? 118 : 28));
-  cv::rectangle(image, {25, 25}, {230, 180}, cv::Scalar(220), 3);
-  cv::circle(image, {145, 110}, 62, cv::Scalar(55), 5);
-  cv::line(image, {18, 330}, {470, 205}, cv::Scalar(238), 4);
-  cv::putText(image, "L3D", {275, 105}, cv::FONT_HERSHEY_SIMPLEX, 1.8, cv::Scalar(210), 4);
-  for (int y = 220; y < 360; y += 12) for (int x = 45; x < 245; x += 12) {
-    int value = ((x / 12 + y / 12) & 1) ? 195 : 58;
-    cv::rectangle(image, {x, y}, {x + 7, y + 7}, cv::Scalar(value), cv::FILLED);
-  }
-  if (!low_texture) {
-    cv::RNG rng(0x4c3344);
-    cv::Mat noise(image.size(), CV_8U);
-    rng.fill(noise, cv::RNG::UNIFORM, 0, 25);
-    cv::add(image, noise, image);
-  }
-  return image;
-}
-
-static cv::Mat imbalanced_fixture() {
-  cv::Mat image(384, 512, CV_8U, cv::Scalar(105));
-  cv::RNG rng(0x53504154);
-  cv::Mat textured(384, 300, CV_8U);
-  rng.fill(textured, cv::RNG::UNIFORM, 10, 245);
-  textured.copyTo(image(cv::Rect(0, 0, 300, 384)));
-  cv::rectangle(image, {350, 55}, {470, 160}, cv::Scalar(225), 4);
-  cv::circle(image, {410, 280}, 45, cv::Scalar(35), 5);
-  return image;
-}
-
-static double fixed_coverage(const Lardon3DExtractedFeatures &features) {
-  bool occupied[64]{};
-  for (uint32_t i = 0; i < features.feature_count; ++i) {
-    float width = static_cast<float>(features.image_width);
-    float height = static_cast<float>(features.image_height);
-    uint32_t column =
-        std::min(7U, static_cast<uint32_t>(features.keypoints[i].x / width * 8.0F));
-    uint32_t row = std::min(7U, static_cast<uint32_t>(features.keypoints[i].y / height * 8.0F));
-    occupied[row * 8U + column] = true;
-  }
-  return static_cast<double>(std::count(std::begin(occupied), std::end(occupied), true)) / 64.0;
-}
-
-static std::string temporary_path(const char *suffix) {
-  char pattern[] = "/tmp/lardon3d-precision-XXXXXX";
-  int fd = mkstemp(pattern);
-  if (fd >= 0) close(fd);
-  std::string path = pattern;
-  std::remove(path.c_str());
-  return path + suffix;
-}
-
-static bool extract(const cv::Mat &image, bool sift, bool rootsift,
-                    Lardon3DExtractedFeatures *features, double *milliseconds,
-                    Lardon3DSiftExtractorParameters override_parameters = {}) {
-  std::string path = temporary_path(".png");
-  if (!cv::imwrite(path, image)) return false;
-  auto begin = std::chrono::steady_clock::now();
-  Lardon3DFeatureExtractResult result;
-  if (sift) {
-    Lardon3DSiftExtractorParameters parameters = override_parameters.max_features
-                                                      ? override_parameters
-                                                      : lardon3d_sift_precision_classic_v1(rootsift);
-    parameters.rootsift = rootsift;
-    result = lardon3d_feature_extract_sift(path.c_str(), &parameters, features);
-  } else {
-    Lardon3DFeatureExtractorParameters parameters{4096, 8, 12};
-    result = lardon3d_feature_extract_orb(path.c_str(), &parameters, features);
-  }
-  auto end = std::chrono::steady_clock::now();
-  *milliseconds = std::chrono::duration<double, std::milli>(end - begin).count();
-  std::remove(path.c_str());
-  return result == LARDON3D_FEATURE_EXTRACT_OK;
-}
-
-static Metrics compare(const Lardon3DExtractedFeatures &a, const Lardon3DExtractedFeatures &b,
-                       const cv::Mat &homography, double elapsed) {
-  std::vector<double> errors;
-  for (uint32_t i = 0; i < a.feature_count; ++i) {
-    cv::Matx31d source(a.keypoints[i].x, a.keypoints[i].y, 1.0);
-    cv::Matx31d projected = cv::Matx33d(homography) * source;
-    double px = projected(0) / projected(2), py = projected(1) / projected(2);
-    double best = 3.0;
-    for (uint32_t j = 0; j < b.feature_count; ++j) {
-      double dx = b.keypoints[j].x - px, dy = b.keypoints[j].y - py;
-      best = std::min(best, std::sqrt(dx * dx + dy * dy));
-    }
-    if (best < 3.0) errors.push_back(best);
-  }
-  std::sort(errors.begin(), errors.end());
-  Metrics metrics;
-  metrics.count = b.feature_count;
-  metrics.coverage = b.quality.coverage_ratio;
-  metrics.repeatability = a.feature_count ? static_cast<double>(errors.size()) / a.feature_count : 0;
-  metrics.median = errors.empty() ? 0 : errors[errors.size() / 2];
-  metrics.p90 = errors.empty() ? 0 : errors[(errors.size() * 9) / 10];
-  metrics.milliseconds = elapsed;
-  return metrics;
-}
-
-static double matching_correctness(const Lardon3DExtractedFeatures &a,
-                                   const Lardon3DExtractedFeatures &b, const cv::Mat &homography,
-                                   int norm) {
-  if (!a.feature_count || !b.feature_count) return 0;
-  int type = norm == cv::NORM_HAMMING ? CV_8U : CV_32F;
-  int dimension = norm == cv::NORM_HAMMING ? 32 : 128;
-  cv::Mat da(static_cast<int>(a.feature_count), dimension, type, a.descriptors);
-  cv::Mat db(static_cast<int>(b.feature_count), dimension, type, b.descriptors);
-  std::vector<std::vector<cv::DMatch>> matches;
-  cv::BFMatcher(norm).knnMatch(da, db, matches, 2);
-  size_t accepted = 0, correct = 0;
-  for (const auto &pair : matches) if (pair.size() == 2 && pair[0].distance < 0.8F * pair[1].distance) {
-    ++accepted;
-    const auto &p = a.keypoints[static_cast<size_t>(pair[0].queryIdx)];
-    const auto &q = b.keypoints[static_cast<size_t>(pair[0].trainIdx)];
-    cv::Matx31d expected = cv::Matx33d(homography) * cv::Matx31d(p.x, p.y, 1.0);
-    double dx = q.x - expected(0) / expected(2), dy = q.y - expected(1) / expected(2);
-    correct += dx * dx + dy * dy <= 9.0;
-  }
-  return accepted ? static_cast<double>(correct) / static_cast<double>(accepted) : 0;
-}
-
-static cv::Mat affine_homography(const cv::Mat &affine) {
-  cv::Mat h = cv::Mat::eye(3, 3, CV_64F);
-  affine.copyTo(h(cv::Rect(0, 0, 3, 2)));
-  return h;
-}
-
-int main() {
-  Lardon3DSiftExtractorParameters valid_parameters = lardon3d_sift_precision_classic_v1(false);
-  CHECK(lardon3d_sift_extractor_parameters_valid(&valid_parameters));
-  Lardon3DSiftExtractorParameters invalid_parameters = valid_parameters;
-  invalid_parameters.max_features = 0;
-  CHECK(!lardon3d_sift_extractor_parameters_valid(&invalid_parameters));
-  invalid_parameters = valid_parameters;
-  invalid_parameters.octave_layers = 9;
-  CHECK(!lardon3d_sift_extractor_parameters_valid(&invalid_parameters));
-  invalid_parameters = valid_parameters;
-  invalid_parameters.contrast_threshold = std::numeric_limits<double>::quiet_NaN();
-  CHECK(!lardon3d_sift_extractor_parameters_valid(&invalid_parameters));
-  invalid_parameters = valid_parameters;
-  invalid_parameters.edge_threshold = 101.0;
-  CHECK(!lardon3d_sift_extractor_parameters_valid(&invalid_parameters));
-  invalid_parameters = valid_parameters;
-  invalid_parameters.sigma = 0.49;
-  CHECK(!lardon3d_sift_extractor_parameters_valid(&invalid_parameters));
-  invalid_parameters = valid_parameters;
-  invalid_parameters.grid_rows = 0;
-  CHECK(!lardon3d_sift_extractor_parameters_valid(&invalid_parameters));
-  invalid_parameters = valid_parameters;
-  invalid_parameters.grid_cols = 33;
-  CHECK(!lardon3d_sift_extractor_parameters_valid(&invalid_parameters));
-  invalid_parameters = valid_parameters;
-  invalid_parameters.max_features_per_cell = 0;
-  CHECK(!lardon3d_sift_extractor_parameters_valid(&invalid_parameters));
-  cv::Mat base = fixture();
-  struct Transform { const char *name; cv::Mat image; cv::Mat h; };
-  std::vector<Transform> transforms;
-  for (double angle : {5.0, 15.0, 30.0}) {
-    cv::Point2f center(static_cast<float>(base.cols) / 2.0F,
-                       static_cast<float>(base.rows) / 2.0F);
-    cv::Mat a = cv::getRotationMatrix2D(center, angle, 1.0);
-    cv::Mat changed;
-    cv::warpAffine(base, changed, a, base.size(), cv::INTER_LINEAR, cv::BORDER_REFLECT);
-    transforms.push_back({angle == 5 ? "rot5" : angle == 15 ? "rot15" : "rot30", changed,
-                          affine_homography(a)});
-  }
-  for (double scale : {0.75, 1.25, 1.5}) {
-    cv::Point2f center(static_cast<float>(base.cols) / 2.0F,
-                       static_cast<float>(base.rows) / 2.0F);
-    cv::Mat a = cv::getRotationMatrix2D(center, 0, scale);
-    cv::Mat changed;
-    cv::warpAffine(base, changed, a, base.size(), cv::INTER_LINEAR, cv::BORDER_REFLECT);
-    transforms.push_back({scale < 1 ? "scale075" : scale < 1.4 ? "scale125" : "scale150",
-                          changed, affine_homography(a)});
-  }
-  cv::Mat crop = base(cv::Rect(48, 36, 400, 300)).clone();
-  cv::Mat crop_h = cv::Mat::eye(3, 3, CV_64F);
-  crop_h.at<double>(0, 2) = -48.0;
-  crop_h.at<double>(1, 2) = -36.0;
-  transforms.push_back({"crop", crop, crop_h});
-  cv::Mat illumination;
-  base.convertTo(illumination, -1, 0.72, 32);
-  transforms.push_back({"illumination", illumination, cv::Mat::eye(3, 3, CV_64F)});
-  cv::Mat gamma_lut(1, 256, CV_8U);
-  for (int value = 0; value < 256; ++value) {
-    double normalized = static_cast<double>(value) / 255.0;
-    gamma_lut.at<unsigned char>(value) =
-        cv::saturate_cast<unsigned char>(std::pow(normalized, 0.8) * 255.0);
-  }
-  cv::Mat gamma;
-  cv::LUT(base, gamma_lut, gamma);
-  transforms.push_back({"gamma", gamma, cv::Mat::eye(3, 3, CV_64F)});
-  cv::Mat blur;
-  cv::GaussianBlur(base, blur, {5, 5}, 1.1);
-  transforms.push_back({"blur", blur, cv::Mat::eye(3, 3, CV_64F)});
-  transforms.push_back({"low_texture", fixture(true), cv::Mat::eye(3, 3, CV_64F)});
-
-  for (int engine = 0; engine < 3; ++engine) {
-    bool sift = engine != 0, rootsift = engine == 2;
-    Lardon3DExtractedFeatures reference{};
-    double reference_time = 0;
-    CHECK(extract(base, sift, rootsift, &reference, &reference_time));
-    CHECK(reference.feature_count > 0);
-    for (const Transform &transform : transforms) {
-      Lardon3DExtractedFeatures changed{};
-      double elapsed = 0;
-      CHECK(extract(transform.image, sift, rootsift, &changed, &elapsed));
-      Metrics metrics = compare(reference, changed, transform.h, elapsed);
-      metrics.correct_matches = matching_correctness(reference, changed, transform.h,
-                                                      sift ? cv::NORM_L2 : cv::NORM_HAMMING);
-      std::printf("BENCH %-8s %-12s count=%zu coverage=%.3f repeat=%.3f median=%.3f "
-                  "p90=%.3f correct=%.3f ms=%.2f\n",
-                  engine == 0 ? "ORB" : rootsift ? "RootSIFT" : "SIFT", transform.name,
-                  metrics.count, metrics.coverage, metrics.repeatability, metrics.median,
-                  metrics.p90, metrics.correct_matches, metrics.milliseconds);
-      CHECK(metrics.count > 0 && metrics.repeatability > 0.05 && metrics.p90 <= 3.0);
-      lardon3d_extracted_features_destroy(&changed);
-    }
-    lardon3d_extracted_features_destroy(&reference);
-  }
-  Lardon3DExtractedFeatures sift_reference{}, root_reference{};
-  double reference_elapsed = 0;
-  CHECK(extract(base, true, false, &sift_reference, &reference_elapsed) &&
-        extract(base, true, true, &root_reference, &reference_elapsed) &&
-        sift_reference.feature_count == root_reference.feature_count);
-  for (uint32_t point = 0; point < sift_reference.feature_count; ++point) {
-    CHECK(std::memcmp(&sift_reference.keypoints[point], &root_reference.keypoints[point],
-                      sizeof(Lardon3DFeatureKeypoint)) == 0);
-  }
-  lardon3d_extracted_features_destroy(&sift_reference);
-  lardon3d_extracted_features_destroy(&root_reference);
-  Lardon3DSiftExtractorParameters raw = lardon3d_sift_precision_classic_v1(false);
-  raw.grid_rows = raw.grid_cols = 1;
-  raw.max_features = 128;
-  raw.max_features_per_cell = raw.max_features;
-  Lardon3DSiftExtractorParameters grid = lardon3d_sift_precision_classic_v1(false);
-  grid.max_features = 128;
-  grid.max_features_per_cell = 2;
-  Lardon3DExtractedFeatures unbalanced{}, balanced{}, low{};
-  double elapsed = 0;
-  cv::Mat imbalanced = imbalanced_fixture();
-  CHECK(extract(imbalanced, true, false, &unbalanced, &elapsed, raw));
-  CHECK(extract(imbalanced, true, false, &balanced, &elapsed, grid));
-  CHECK(extract(fixture(true), true, false, &low, &elapsed));
-  Lardon3DExtractedFeatures uniform{};
-  CHECK(extract(cv::Mat(192, 192, CV_8U, cv::Scalar(127)), true, false, &uniform, &elapsed) &&
-        uniform.feature_count == 0 && uniform.quality.occupied_cells == 0);
-  double raw_coverage = fixed_coverage(unbalanced);
-  double selected_coverage = fixed_coverage(balanced);
-  cv::Point2f imbalanced_center(static_cast<float>(imbalanced.cols) / 2.0F,
-                                static_cast<float>(imbalanced.rows) / 2.0F);
-  cv::Mat grid_affine = cv::getRotationMatrix2D(imbalanced_center, 15.0, 1.0);
-  cv::Mat grid_rotated;
-  cv::warpAffine(imbalanced, grid_rotated, grid_affine, imbalanced.size(), cv::INTER_LINEAR,
-                 cv::BORDER_REFLECT);
-  Lardon3DExtractedFeatures raw_rotated{}, grid_rotated_features{};
-  CHECK(extract(grid_rotated, true, false, &raw_rotated, &elapsed, raw) &&
-        extract(grid_rotated, true, false, &grid_rotated_features, &elapsed, grid));
-  Metrics raw_grid_metrics = compare(unbalanced, raw_rotated, affine_homography(grid_affine), 0);
-  Metrics selected_grid_metrics =
-      compare(balanced, grid_rotated_features, affine_homography(grid_affine), 0);
-  CHECK(balanced.quality.occupied_cells > 0 && low.feature_count > 0 &&
-        selected_coverage > raw_coverage &&
-        selected_grid_metrics.repeatability >= raw_grid_metrics.repeatability * 0.5);
-  std::printf("BENCH grid raw_coverage=%.3f selected_coverage=%.3f raw_repeat=%.3f "
-              "selected_repeat=%.3f low_texture=%u\n",
-              raw_coverage, selected_coverage, raw_grid_metrics.repeatability,
-              selected_grid_metrics.repeatability, low.feature_count);
-  lardon3d_extracted_features_destroy(&unbalanced);
-  lardon3d_extracted_features_destroy(&balanced);
-  lardon3d_extracted_features_destroy(&low);
-  lardon3d_extracted_features_destroy(&uniform);
-  lardon3d_extracted_features_destroy(&raw_rotated);
-  lardon3d_extracted_features_destroy(&grid_rotated_features);
-  return 0;
-}

tests/test_project_db.c

@@ -89,62 +89,11 @@ static bool create_future_database(const char *path) {
   }
   bool ok = sqlite3_exec(connection,
                          "CREATE TABLE metadata(key TEXT PRIMARY KEY,value INTEGER NOT NULL);"
-                         "INSERT INTO metadata VALUES('schema_version',10);",
+                         "INSERT INTO metadata VALUES('schema_version',7);",
                          NULL, NULL, NULL) == SQLITE_OK;
   return sqlite3_close(connection) == SQLITE_OK && ok;
 }
 
-static bool create_v7_database(const char *path) {
-  Lardon3DProjectDb *database = NULL;
-  char error[LARDON3D_PROJECT_DB_ERROR_CAPACITY];
-  if (lardon3d_project_db_open(path, &database, error) != LARDON3D_PROJECT_DB_OK) return false;
-  lardon3d_project_db_close(database);
-  sqlite3 *connection = NULL;
-  if (sqlite3_open(path, &connection) != SQLITE_OK) return false;
-  static const char sql[] =
-      "PRAGMA foreign_keys=OFF;BEGIN IMMEDIATE;"
-      "DROP TABLE candidate_pair_generate_tasks;"
-      "DROP TABLE candidate_pairs;"
-      "UPDATE metadata SET value=7 WHERE key='schema_version';COMMIT;PRAGMA foreign_keys=ON;";
-  bool ok = sqlite3_exec(connection, sql, NULL, NULL, NULL) == SQLITE_OK;
-  return sqlite3_close(connection) == SQLITE_OK && ok;
-}
-
-static bool create_v6_database(const char *path) {
-  Lardon3DProjectDb *database = NULL;
-  char error[LARDON3D_PROJECT_DB_ERROR_CAPACITY];
-  if (lardon3d_project_db_open(path, &database, error) != LARDON3D_PROJECT_DB_OK) return false;
-  lardon3d_project_db_close(database);
-  sqlite3 *connection = NULL;
-  if (sqlite3_open(path, &connection) != SQLITE_OK) return false;
-  static const char sql[] =
-      "PRAGMA foreign_keys=OFF;BEGIN IMMEDIATE;"
-      "DROP TABLE candidate_pair_generate_tasks;"
-      "DROP TABLE candidate_pairs;"
-      "DROP TABLE feature_support_members;DROP TABLE feature_support_groups;"
-      "DROP TABLE feature_support_sets;DROP TABLE sift_extract_tasks;"
-      "ALTER TABLE feature_sets DROP COLUMN feature_density_per_megapixel;"
-      "ALTER TABLE feature_sets DROP COLUMN coverage_ratio;"
-      "ALTER TABLE feature_sets DROP COLUMN total_cells;"
-      "ALTER TABLE feature_sets DROP COLUMN occupied_cells;"
-      "UPDATE metadata SET value=6 WHERE key='schema_version';COMMIT;PRAGMA foreign_keys=ON;";
-  bool ok = sqlite3_exec(connection, sql, NULL, NULL, NULL) == SQLITE_OK;
-  return sqlite3_close(connection) == SQLITE_OK && ok;
-}
-
-static bool create_v5_database(const char *path) {
-  if (!create_v6_database(path)) return false;
-  sqlite3 *connection = NULL;
-  if (sqlite3_open(path, &connection) != SQLITE_OK) return false;
-  static const char sql[] =
-      "PRAGMA foreign_keys=OFF;BEGIN IMMEDIATE;"
-      "DROP TABLE visual_index_update_tasks;DROP TABLE visual_index_memberships;"
-      "DROP TABLE visual_index_segments;DROP TABLE visual_indexes;"
-      "UPDATE metadata SET value=5 WHERE key='schema_version';COMMIT;PRAGMA foreign_keys=ON;";
-  bool ok = sqlite3_exec(connection, sql, NULL, NULL, NULL) == SQLITE_OK;
-  return sqlite3_close(connection) == SQLITE_OK && ok;
-}
-
 static bool create_v1_database(const char *path) {
   static const char sql[] =
       "PRAGMA foreign_keys=ON;"
@@ -278,8 +227,7 @@ static bool run_test(void) {
   char database_path[512], artifact_path[512], future_path[512], corrupt_path[512];
   char legacy_path[512], failed_migration_path[512], v2_path[512];
   char failed_v3_migration_path[512], v3_path[512], failed_v4_path[512];
-  char v4_path[512], failed_v5_path[512], failed_v6_path[512], failed_v7_path[512];
+  char v4_path[512], failed_v5_path[512], failed_v6_path[512];
-  char direct_v5_path[512], v8_path[512], failed_v8_path[512];
   CHECK(snprintf(database_path, sizeof(database_path), "%s/project.db", directory) > 0);
   CHECK(snprintf(artifact_path, sizeof(artifact_path), "%s/artifact.bin", directory) > 0);
   CHECK(snprintf(future_path, sizeof(future_path), "%s/future.db", directory) > 0);
@@ -298,17 +246,11 @@ static bool run_test(void) {
         0);
   CHECK(snprintf(failed_v6_path, sizeof(failed_v6_path), "%s/failed-v6-migration.db", directory) >
         0);
-  CHECK(snprintf(failed_v7_path, sizeof(failed_v7_path), "%s/failed-v7-migration.db", directory) >
-        0);
-  CHECK(snprintf(direct_v5_path, sizeof(direct_v5_path), "%s/direct-v5.db", directory) > 0);
-  CHECK(snprintf(v8_path, sizeof(v8_path), "%s/v8.db", directory) > 0);
-  CHECK(snprintf(failed_v8_path, sizeof(failed_v8_path), "%s/failed-v8-migration.db", directory) >
-        0);
 
   char error[LARDON3D_PROJECT_DB_ERROR_CAPACITY];
   Lardon3DProjectDb *database = NULL;
   CHECK(lardon3d_project_db_open(database_path, &database, error) == LARDON3D_PROJECT_DB_OK);
-  CHECK(database && lardon3d_project_db_schema_version(database) == 9);
+  CHECK(database && lardon3d_project_db_schema_version(database) == 6);
   bool legacy_pending = true;
   CHECK(lardon3d_project_db_legacy_catalog_pending(database, &legacy_pending) ==
             LARDON3D_PROJECT_DB_OK &&
@@ -344,85 +286,6 @@ static bool run_test(void) {
         replacement_image.image_id > deleted_image.image_id &&
         replacement_image.asset_id > deleted_image.asset_id);
 
-  unsigned char third_hash[LARDON3D_PROJECT_DB_SHA256_SIZE] = {3};
-  char third_asset_path[LARDON3D_PROJECT_DB_PATH_CAPACITY];
-  asset_path_for_hash(third_hash, third_asset_path);
-  Lardon3DProjectDbImage pair_image;
-  CHECK(lardon3d_project_db_register_image(database, replacement_scanset.scanset_id, third_hash,
-                                           third_asset_path, 1, "pair-a.jpg", "/source/pair-a.jpg",
-                                           0, 3, &identity_status, &pair_image) ==
-        LARDON3D_PROJECT_DB_OK);
-  unsigned char fourth_hash[LARDON3D_PROJECT_DB_SHA256_SIZE] = {4};
-  char fourth_asset_path[LARDON3D_PROJECT_DB_PATH_CAPACITY];
-  asset_path_for_hash(fourth_hash, fourth_asset_path);
-  Lardon3DProjectDbImage pair_image_b;
-  CHECK(lardon3d_project_db_register_image(database, replacement_scanset.scanset_id, fourth_hash,
-                                           fourth_asset_path, 1, "pair-b.jpg", "/source/pair-b.jpg",
-                                           0, 4, &identity_status, &pair_image_b) ==
-        LARDON3D_PROJECT_DB_OK);
-
-  Lardon3DProjectDbCandidatePair pair;
-  CHECK(lardon3d_project_db_create_candidate_pair(database, replacement_image.image_id,
-                                                  pair_image.image_id, 10, &pair) ==
-        LARDON3D_PROJECT_DB_OK);
-  CHECK(pair.candidate_pair_id > 0 && pair.image_id_a == replacement_image.image_id &&
-        pair.image_id_b == pair_image.image_id && pair.created_at == 10);
-  Lardon3DProjectDbCandidatePair first_pair = pair;
-  Lardon3DProjectDbCandidatePair second_pair;
-  CHECK(lardon3d_project_db_create_candidate_pair(database, replacement_image.image_id,
-                                                  pair_image_b.image_id, 11, &second_pair) ==
-        LARDON3D_PROJECT_DB_OK);
-  CHECK(second_pair.candidate_pair_id > first_pair.candidate_pair_id);
-  CHECK(lardon3d_project_db_create_candidate_pair(database, pair_image.image_id,
-                                                  replacement_image.image_id, 12, &pair) ==
-        LARDON3D_PROJECT_DB_CONSTRAINT);
-  CHECK(lardon3d_project_db_create_candidate_pair(database, replacement_image.image_id,
-                                                  replacement_image.image_id, 13, &pair) ==
-        LARDON3D_PROJECT_DB_CONSTRAINT);
-  CHECK(lardon3d_project_db_create_candidate_pair(database, replacement_image.image_id,
-                                                  pair_image.image_id, -1, &pair) ==
-        LARDON3D_PROJECT_DB_INVALID_ARGUMENT);
-  CHECK(lardon3d_project_db_create_candidate_pair(database, 0, pair_image.image_id, 14, &pair) ==
-        LARDON3D_PROJECT_DB_INVALID_ARGUMENT);
-  Lardon3DProjectDbCandidatePair found;
-  CHECK(lardon3d_project_db_find_candidate_pair(database, pair_image.image_id,
-                                                replacement_image.image_id, &found) ==
-        LARDON3D_PROJECT_DB_OK);
-  CHECK(found.candidate_pair_id == first_pair.candidate_pair_id &&
-        found.image_id_a == replacement_image.image_id && found.image_id_b == pair_image.image_id &&
-        found.created_at == 10);
-  CHECK(lardon3d_project_db_find_candidate_pair(database, replacement_image.image_id,
-                                                pair_image.image_id, &found) ==
-        LARDON3D_PROJECT_DB_OK);
-  CHECK(found.candidate_pair_id == first_pair.candidate_pair_id);
-  CHECK(lardon3d_project_db_find_candidate_pair(database, pair_image.image_id,
-                                                pair_image_b.image_id, &found) ==
-        LARDON3D_PROJECT_DB_NOT_FOUND);
-  Lardon3DProjectDbCandidatePair loaded;
-  CHECK(lardon3d_project_db_load_candidate_pair(database, first_pair.candidate_pair_id, &loaded) ==
-        LARDON3D_PROJECT_DB_OK);
-  CHECK(loaded.image_id_a == first_pair.image_id_a && loaded.image_id_b == first_pair.image_id_b &&
-        loaded.created_at == 10);
-  CHECK(lardon3d_project_db_load_candidate_pair(database, 999999, &loaded) ==
-        LARDON3D_PROJECT_DB_NOT_FOUND);
-  Lardon3DProjectDbCandidatePair pair_page[LARDON3D_PROJECT_DB_CANDIDATE_PAIR_PAGE_MAX];
-  size_t pair_count = 0;
-  CHECK(lardon3d_project_db_list_candidate_pairs(database, 0, pair_page, 2, &pair_count) ==
-        LARDON3D_PROJECT_DB_OK);
-  CHECK(pair_count == 2 && pair_page[0].candidate_pair_id == first_pair.candidate_pair_id &&
-        pair_page[1].candidate_pair_id == second_pair.candidate_pair_id);
-  CHECK(lardon3d_project_db_list_candidate_pairs(database, first_pair.candidate_pair_id,
-                                                 pair_page, 2, &pair_count) ==
-        LARDON3D_PROJECT_DB_OK);
-  CHECK(pair_count == 1 && pair_page[0].candidate_pair_id == second_pair.candidate_pair_id);
-  CHECK(lardon3d_project_db_list_candidate_pairs(database, second_pair.candidate_pair_id,
-                                                 pair_page, 1, &pair_count) ==
-        LARDON3D_PROJECT_DB_OK);
-  CHECK(pair_count == 0);
-  CHECK(lardon3d_project_db_list_candidate_pairs(
-            database, 0, pair_page, LARDON3D_PROJECT_DB_CANDIDATE_PAIR_PAGE_MAX + 1,
-            &pair_count) == LARDON3D_PROJECT_DB_INVALID_ARGUMENT);
-
   Lardon3DProjectDbProject project = {.created_at = 100, .updated_at = 100};
   (void)snprintf(project.stable_id, sizeof(project.stable_id), "project-0001");
   (void)snprintf(project.name, sizeof(project.name), "Projet test");
@@ -575,16 +438,12 @@ static bool run_test(void) {
         LARDON3D_PROJECT_DB_INVALID_ARGUMENT);
   lardon3d_project_db_close(contexts[0].database);
   database = NULL;
-  CHECK(query_integer(database_path, "SELECT value FROM metadata WHERE key='schema_version'", 9));
+  CHECK(query_integer(database_path, "SELECT value FROM metadata WHERE key='schema_version'", 6));
   CHECK(query_integer(database_path, "SELECT count(*) FROM tasks WHERE task_id=1", 1));
   CHECK(lardon3d_project_db_open(database_path, &database, error) == LARDON3D_PROJECT_DB_OK);
   CHECK(lardon3d_project_db_load_task(database, 1, &task) == LARDON3D_PROJECT_DB_OK);
   CHECK(lardon3d_project_db_load_artifact(database, "artifact-1", &loaded_artifact) ==
         LARDON3D_PROJECT_DB_OK);
-  CHECK(lardon3d_project_db_find_candidate_pair(database, replacement_image.image_id,
-                                                pair_image.image_id, &found) ==
-        LARDON3D_PROJECT_DB_OK);
-  CHECK(found.candidate_pair_id == first_pair.candidate_pair_id);
   lardon3d_project_db_close(database);
 
   CHECK(create_future_database(future_path));
@@ -597,7 +456,7 @@ static bool run_test(void) {
 
   CHECK(create_v1_database(legacy_path));
   CHECK(lardon3d_project_db_open(legacy_path, &database, error) == LARDON3D_PROJECT_DB_OK);
-  CHECK(lardon3d_project_db_schema_version(database) == 9);
+  CHECK(lardon3d_project_db_schema_version(database) == 6);
   CHECK(lardon3d_project_db_get_project(database, &loaded_project) == LARDON3D_PROJECT_DB_OK &&
         strcmp(loaded_project.stable_id, "legacy-project") == 0);
   CHECK(lardon3d_project_db_load_task(database, 9, &task) == LARDON3D_PROJECT_DB_OK);
@@ -607,7 +466,7 @@ static bool run_test(void) {
         LARDON3D_PROJECT_DB_OK);
   lardon3d_project_db_close(database);
   database = NULL;
-  CHECK(query_integer(legacy_path, "SELECT value FROM metadata WHERE key='schema_version'", 9));
+  CHECK(query_integer(legacy_path, "SELECT value FROM metadata WHERE key='schema_version'", 6));
 
   CHECK(create_v1_database(failed_migration_path));
   CHECK(setenv("LARDON3D_TEST_PROJECT_DB_FAIL_MIGRATION_V2", "1", 1) == 0);
@@ -632,7 +491,7 @@ static bool run_test(void) {
         LARDON3D_PROJECT_DB_OK);
   lardon3d_project_db_close(database);
   database = NULL;
-  CHECK(query_integer(v2_path, "SELECT value FROM metadata WHERE key='schema_version'", 9));
+  CHECK(query_integer(v2_path, "SELECT value FROM metadata WHERE key='schema_version'", 6));
 
   CHECK(create_v2_database(failed_v3_migration_path));
   CHECK(setenv("LARDON3D_TEST_PROJECT_DB_FAIL_MIGRATION_V3", "1", 1) == 0);
@@ -660,7 +519,7 @@ static bool run_test(void) {
         LARDON3D_PROJECT_DB_OK);
   lardon3d_project_db_close(database);
   database = NULL;
-  CHECK(query_integer(v3_path, "SELECT value FROM metadata WHERE key='schema_version'", 9));
+  CHECK(query_integer(v3_path, "SELECT value FROM metadata WHERE key='schema_version'", 6));
 
   CHECK(create_v3_database(failed_v4_path));
   CHECK(setenv("LARDON3D_TEST_PROJECT_DB_FAIL_MIGRATION_V4", "1", 1) == 0);
@@ -677,7 +536,7 @@ static bool run_test(void) {
     fprintf(stderr, "Migration v4 (%d): %s\n", (int)v4_result, error);
   }
   CHECK(v4_result == LARDON3D_PROJECT_DB_OK);
-  CHECK(lardon3d_project_db_schema_version(database) == 9);
+  CHECK(lardon3d_project_db_schema_version(database) == 6);
   CHECK(lardon3d_project_db_load_task(database, 9, &task) == LARDON3D_PROJECT_DB_OK);
   CHECK(lardon3d_project_db_load_artifact(database, "legacy-artifact", &loaded_artifact) ==
         LARDON3D_PROJECT_DB_OK);
@@ -702,47 +561,6 @@ static bool run_test(void) {
       failed_v6_path,
       "SELECT count(*) FROM sqlite_master WHERE type='table' AND name='visual_indexes'", 0));
 
-  CHECK(create_v6_database(failed_v7_path));
-  CHECK(setenv("LARDON3D_TEST_PROJECT_DB_FAIL_MIGRATION_V7", "1", 1) == 0);
-  CHECK(lardon3d_project_db_open(failed_v7_path, &database, error) == LARDON3D_PROJECT_DB_IO_ERROR);
-  CHECK(unsetenv("LARDON3D_TEST_PROJECT_DB_FAIL_MIGRATION_V7") == 0);
-  CHECK(query_integer(failed_v7_path, "SELECT value FROM metadata WHERE key='schema_version'", 6));
-  CHECK(query_integer(failed_v7_path,
-                      "SELECT count(*) FROM sqlite_master WHERE type='table' AND "
-                      "name='sift_extract_tasks'", 0));
-  CHECK(lardon3d_project_db_open(failed_v7_path, &database, error) == LARDON3D_PROJECT_DB_OK &&
-        lardon3d_project_db_schema_version(database) == 9);
-  lardon3d_project_db_close(database);
-  database = NULL;
-
-  CHECK(create_v5_database(direct_v5_path));
-  CHECK(query_integer(direct_v5_path, "SELECT value FROM metadata WHERE key='schema_version'", 5));
-  CHECK(lardon3d_project_db_open(direct_v5_path, &database, error) == LARDON3D_PROJECT_DB_OK &&
-        lardon3d_project_db_schema_version(database) == 9);
-  lardon3d_project_db_close(database);
-  database = NULL;
-
-  CHECK(create_v7_database(v8_path));
-  CHECK(query_integer(v8_path, "SELECT value FROM metadata WHERE key='schema_version'", 7));
-  CHECK(lardon3d_project_db_open(v8_path, &database, error) == LARDON3D_PROJECT_DB_OK);
-  CHECK(lardon3d_project_db_schema_version(database) == 9);
-  lardon3d_project_db_close(database);
-  database = NULL;
-  CHECK(query_integer(v8_path, "SELECT value FROM metadata WHERE key='schema_version'", 9));
-
-  CHECK(create_v7_database(failed_v8_path));
-  CHECK(setenv("LARDON3D_TEST_PROJECT_DB_FAIL_MIGRATION_V8", "1", 1) == 0);
-  CHECK(lardon3d_project_db_open(failed_v8_path, &database, error) == LARDON3D_PROJECT_DB_IO_ERROR);
-  CHECK(unsetenv("LARDON3D_TEST_PROJECT_DB_FAIL_MIGRATION_V8") == 0);
-  CHECK(query_integer(failed_v8_path, "SELECT value FROM metadata WHERE key='schema_version'", 7));
-  CHECK(query_integer(failed_v8_path,
-                      "SELECT count(*) FROM sqlite_master WHERE type='table' AND "
-                      "name='candidate_pairs'", 0));
-  CHECK(lardon3d_project_db_open(failed_v8_path, &database, error) == LARDON3D_PROJECT_DB_OK &&
-        lardon3d_project_db_schema_version(database) == 9);
-  lardon3d_project_db_close(database);
-  database = NULL;
-
   CHECK(unlink(artifact_path) == 0);
   CHECK(unlink(database_path) == 0);
   CHECK(unlink(future_path) == 0);
@@ -756,10 +574,6 @@ static bool run_test(void) {
   CHECK(unlink(v4_path) == 0);
   CHECK(unlink(failed_v5_path) == 0);
   CHECK(unlink(failed_v6_path) == 0);
-  CHECK(unlink(failed_v7_path) == 0);
-  CHECK(unlink(direct_v5_path) == 0);
-  CHECK(unlink(v8_path) == 0);
-  CHECK(unlink(failed_v8_path) == 0);
   CHECK(rmdir(directory) == 0);
   return true;
 }

tests/test_visual_index.c

@@ -208,7 +208,6 @@ static bool publish_features(Lardon3DAppState *state, uint64_t image_id, unsigne
       .feature_count = COUNT,
       .keypoints = keypoints,
       .descriptors = descriptors,
-      .descriptor_bytes = sizeof(descriptors),
   };
   Lardon3DFeatureExtractorParameters parameters = {64, 4, 20};
   Lardon3DFeatureStoreResult result =
@@ -245,8 +244,7 @@ static bool publish_burst_features(Lardon3DAppState *state, uint64_t image_id, u
       memset(descriptors + i * 32, (int)(i + 31U), 32);
     }
   }
-  Lardon3DExtractedFeatures features = {
+  Lardon3DExtractedFeatures features = {64, 64, COUNT, keypoints, descriptors};
-      64, 64, COUNT, keypoints, descriptors, {0}, sizeof(descriptors)};
   Lardon3DFeatureExtractorParameters parameters = {63, 4, 20};
   Lardon3DFeatureStoreResult result =
       lardon3d_feature_store_publish(state, image_id, 0, &parameters, &features, set);

tests/tsan-opencv.supp

@@ -1,6 +0,0 @@
-# OpenCV 5/TBB from the system is not TSan-instrumented. Its asynchronous
-# features backend reports TLS and Mat teardown accesses after detectAndCompute.
-# Keep this suppression scoped to external shared objects: Lardon3D frames and
-# all other libraries remain fully checked.
-race:libopencv_features.so
-race:libopencv_core.so