v0.3.14-pre.016

CHANGELOG.md

@@ -1,8 +1,20 @@
 <!-- file: CHANGELOG.md -->
-<!-- version: 33 -->
+<!-- version: 34 -->
 
 # Changelog KSP
 
+## 0.3.14 — gap repair et hardening multi-source du Worker RawTransaction — 2026-09-12
+
+`0.3.14` ferme `ksp-worker-raw-transaction-ingest-lib` par une continuité run-local explicite au-dessus des cinq familles live de `0.3.13`, sans transformer le Worker en moteur historique. Le Worker distingue désormais reconnect, tentative de replay, delivery de replay et preuve de coverage ; il maintient des gaps bornés avec plage inclusive, `TargetCoverage` conservative et frontier de continuité distincte de la processing frontier. Une reprise live ou l'acceptation d'un `from_slot` ne vaut jamais à elle seule preuve de réparation.
+
+La réconciliation peut s'appuyer sur une coverage réellement prouvée d'une source redondante, un scan HTTP borné de blocs/slots ou l'hydration `getTransaction observed` des références connues. Les bornes finales restent 64 gaps ouverts, 4096 slots par plage, fenêtres de discovery de 512 slots, 4 `getBlock` logiques en vol et un seul gap activement réparé. Les matériaux de repair repassent par la même canonicalisation Common RAW, la même admission, la même hydration globale et le même Store ; aucun second pipeline, retry réseau Worker, Job Backfill automatique ou backend Store direct n'est introduit.
+
+La politique multi-source ne fault plus mécaniquement sur toute perte de source : la continuation n'est autorisée que lorsque les gaps concernés sont réconciliés et que la coverage présente/future requise est réellement démontrée. Les snapshots publics ajoutent une observabilité source-neutral et bornée des gaps avec états/raisons/méthodes et compteurs checked, sans source key, endpoint, token, signature, payload ou erreur provider arbitraire. La health policy reste conservative, la fairness alterne trafic nominal/repair sur les capacités existantes et le shutdown borne également le drain interne des sources avec abort+join des siblings non coopératifs.
+
+La fermeture cross-layer confirme le pipeline unique `Transport -> Worker -> ksp-raw-transaction-lib -> Store`, la non-régression Legacy/V0/V1, les dependency firewalls et l'indépendance Worker/Backfill. Le gate technique final passe fmt, audits Rust/Markdown, `cargo check --workspace`, Clippy workspace/all-targets/all-features avec `-D warnings`, `cargo test --workspace --all-targets --all-features` et les graphes Cargo : `1 931` tests passent, `0` échoue et `15` restent ignored opt-in/operator-only. Les smokes keyless Solana HTTP Devnet et WebSocket Devnet passent `1/1` chacun ; Yellowstone/provider-gated, Helius live, PostgreSQL live et Worker->Store end-to-end restent explicitement non exécutés lorsqu'aucune ressource correspondante n'a été provisionnée.
+
+`prompts/034-V0_3_15_START_PROMPT.md` ouvre `0.3.15` exclusivement depuis le futur tag stable `v0.3.14`. Cette release introduit `ksp-app-raw-transaction-ingest-desk` comme Desk Tauri de composition/supervision : une **route** est une stratégie complète pouvant nécessiter plusieurs capacités Config/Transport, elle n'est sélectionnable que si toutes ses requirements sont composables, puis une instance Worker réelle est démarrée par route sélectionnée et valide l'opérabilité runtime au Start. Le frontend reste une surface sûre ; Config, Transport, Store et Worker conservent leurs responsabilités.
+
 ## 0.3.13 — convergence live multi-source du Worker RawTransaction — 2026-09-10
 
 `0.3.13` généralise `ksp-worker-raw-transaction-ingest-lib` de la verticale Yellowstone de `0.3.12` vers une composition caller-owned de `1..32` sources logiques appartenant au même réseau. Cinq familles live convergent désormais vers le même pipeline Common RAW / admission / Store : Yellowstone, Standard Logs avec hydration `getTransaction observed`, Standard Block RAW-direct, Helius `transactionSubscribe` avec hydration et HTTP Block Polling run-local RAW-direct. Le Worker reste sans Config, Job Backfill, backend Store physique, client réseau direct ou SDK provider parallèle.

Cargo.toml

@@ -1,12 +1,12 @@
 # file: Cargo.toml
-# version: 591
+# version: 592
 
 [workspace]
 resolver = "3"
 members = ["crates/ksp-app-backfill-desk", "crates/ksp-app-config-desk", "crates/ksp-app-solprices-desk", "crates/ksp-app-store-desk", "crates/ksp-app-wallet-desk", "crates/ksp-config-lib", "crates/ksp-core-lib", "crates/ksp-interface-lib", "crates/ksp-job-api", "crates/ksp-job-backfill-lib", "crates/ksp-logging-lib", "crates/ksp-offchain-transport-lib", "crates/ksp-onchain-transport-lib", "crates/ksp-program-api", "crates/ksp-raw-transaction-lib", "crates/ksp-store-api", "crates/ksp-store-lib", "crates/ksp-store-postgres-lib", "crates/ksp-wallet-lib", "crates/ksp-worker-api", "crates/ksp-worker-raw-transaction-ingest-lib"]
 
 [workspace.package]
-version = "0.3.14-pre.15"
+version = "0.3.14-pre.16"
 edition = "2024"
 license = "MIT"
 repository = "https://git.sasedev.com/Sasedev/khadhroony-solana-project"

ROADMAP.md

@@ -1,5 +1,5 @@
 <!-- file: ROADMAP.md -->
-<!-- version: 111 -->
+<!-- version: 112 -->
 
 # Roadmap KSP
 
@@ -106,8 +106,8 @@ RAW -> STRUCTURAL -> DECODED -> DOMAIN
 - [X] `0.3.11` — Fondation runtime de `ksp-worker-raw-transaction-ingest-lib` livrée : crate/dependency firewall, settings source-neutral, handle/start-stop, lifecycle, snapshots, supervisor, admission bornée, canonicalisation Common RAW, persistence/déduplication Store déterministe, backpressure et shutdown/fault hardening. La release se ferme volontairement sans source réseau productive ; Yellowstone + hydration HTTP commencent en `0.3.12`.
 - [X] `0.3.12` — Première source live productive du Worker livrée : Yellowstone `Transaction`/`TransactionStatus`/`Block` vers signaux source-neutral, coalescence bornée puis hydration HTTP `getTransaction` observed avant Common RAW/Store ; `BlockMeta`/`Slot` restent continuity-only. Processing frontier run-local, reconnect/from_slot/ReplayInfo Transport-owned, compteurs source-neutral et fault sur gap de rétention prouvé sans Backfill automatique. Hardening duplicate/backpressure/stop/fault et canaris cross-layer fermés ; gate workspace complet vert, smokes live HTTP Devnet + WebSocket Devnet verts, Yellowstone token-gated/Worker end-to-end laissés explicitement non exécutés.
 - [X] `0.3.13` — Convergence live multi-source du Worker RAW livrée : composition caller-owned `1..32` sources d’un même réseau, cinq familles Yellowstone / Standard Logs / Standard Block / Helius Transaction / HTTP Block Polling, hydration globale des trois voies reference-bearing, RAW-direct Legacy/V0/V1 pour les deux voies blocs, observations multiples, content conflict explicite, coalescence cross-source, fairness/backpressure/health source-neutral et shutdown hardening sans second actor Transport. Gate workspace complet vert (`1 850` PASS / `0` échec / `15` ignored) et smokes keyless HTTP + WebSocket Devnet verts ; les preuves provider/resource-gated non exécutées restent explicitement non revendiquées.
-- [ ] `0.3.14` — Fermer le Worker par le **gap repair/hardening multi-source** : replay natif, source redondante, scan HTTP blocs, hydration de réparation, unresolved gaps visibles, politiques degraded/unhealthy/faulted, shutdown pendant repair, smokes provider accessibles et adapter EARLY seulement si réellement prouvé.
+- [X] `0.3.14` — Gap repair/hardening multi-source du Worker RAW livré : gaps run-local bornés, distinction reconnect/replay/delivery/coverage, TargetCoverage conservative, coverage redondante prouvée, discovery HTTP bornée, known-reference hydration, réconciliation source-loss, health gap-aware, fairness nominal/repair, snapshots publics source-neutral et shutdown/drain renforcé. Le pipeline Common RAW/Store reste unique, Worker/Backfill restent indépendants, EARLY n’est pas ajouté. Gate workspace complet vert (`1 931` PASS / `0` échec / `15` ignored) et smokes keyless HTTP + WebSocket Devnet verts ; preuves provider/resource-gated non provisionnées explicitement non revendiquées.
-- [ ] `0.3.15` — Introduire `ksp-app-raw-transaction-ingest-desk`, Desk Tauri KSP spécialisée qui choisit et supervise une ou plusieurs sources/méthodes réellement admises par le Worker finalisé : lifecycle, health, rates, backpressure, reconnect/recovery, gap state et compteurs sûrs. La Desk ne réimplémente ni discovery, hydration, déduplication, reprise ni persistence.
+- [ ] `0.3.15` — Introduire `ksp-app-raw-transaction-ingest-desk`, Desk Tauri KSP de composition/supervision des routes live `RawTransaction`. Une route est une stratégie complète pouvant nécessiter plusieurs capabilities/endpoints (par exemple gRPC + HTTP ou WS + HTTP) et n’est sélectionnable que si toutes ses requirements sont composables depuis Config sur le réseau choisi ; la présence d’un provider ne vaut jamais capability implicite. Au Start, la Config est revalidée et **une instance Worker est lancée par route sélectionnée** — pas par source physique — afin de valider l’opérabilité réelle puis exposer lifecycle, health, backpressure, reconnect/replay, gaps/repair et compteurs sûrs. Plusieurs Workers peuvent partager le même Store, sans coordination implicite de gaps entre routes. La Desk ne réimplémente ni Transport, discovery, hydration, déduplication, repair ni persistence.
 - [ ] `0.3.16` — Étendre `ksp-job-backfill-lib` et `ksp-app-backfill-desk` au **backfill multi-source/multi-stratégie** à partir de la même matrice d'acquisition auditée en `0.3.9`. Conserver la stratégie actuelle `getSignaturesForAddress + getTransaction` comme première voie HTTP valide, puis ajouter seulement les voies historiques/catch-up/gap-repair réellement pertinentes et sûres, sans supposer qu'une source live WS constitue un historique universel.
 
 ### TODO/IDEAS — applications spécialisées et control plane

deltas/0.3.14/pre.016.md

@@ -0,0 +1,203 @@
+<!-- file: deltas/0.3.14/pre.016.md -->
+<!-- version: 1 -->
+
+# Delta `0.3.14-pre.016` — préparation de publication
+
+## 1. Base requise
+
+```text
+0.3.14-pre.015
+workspace.package.version = 0.3.14-pre.15
+```
+
+Le gate opérateur communiqué le **12 septembre 2026 à 23:07** sur `pre.015` est vert pour toutes les commandes exécutées :
+
+```text
+cargo fmt --all -- --check : PASS
+General Rust rule audit : clean
+Rust export completeness audit : 0 candidate(s)
+KSP workspace Rust rule audit : clean
+Markdown table audit : clean, 340 tables / 883 files
+cargo check --workspace : PASS
+```
+
+Conformément à `pre.015`, aucun rerun Clippy/tests/smokes n'était requis pour cette tranche documentaire hors bump mécanique.
+
+## 2. Objectif
+
+`pre.016` est la dernière prerelease de préparation de publication de `0.3.14`.
+
+Conformément à `VER-LIFECYCLE-003` et `PROMPT_STRUCTURE.md`, elle modifie fonctionnellement uniquement :
+
+```text
+prompt de démarrage 0.3.15
+CHANGELOG.md
+ROADMAP.md
+```
+
+Les seuls fichiers mécaniques supplémentaires sont :
+
+```text
+Cargo.toml racine
+delta pre.016
+```
+
+Aucun README, USAGE, plan, validation, architecture, code, test, Config, schema, dépendance, feature ou manifest de crate n'est rouvert.
+
+## 3. Version workspace
+
+La prerelease non-fix synchronise Cargo :
+
+```text
+0.3.14-pre.15
+->
+0.3.14-pre.16
+```
+
+Le header de `Cargo.toml` passe de `591` à `592`.
+
+## 4. Prompt suivant
+
+Le nouveau prompt :
+
+```text
+prompts/034-V0_3_15_START_PROMPT.md
+```
+
+ouvre `0.3.15` exclusivement depuis le futur stable :
+
+```text
+v0.3.14
+```
+
+Sa mission est `ksp-app-raw-transaction-ingest-desk`, avec les décisions opératoires suivantes figées :
+
+```text
+route != source != endpoint
+route = stratégie d'acquisition complète + capabilities obligatoires
+une route peut nécessiter plusieurs ressources, par exemple gRPC + HTTP ou WS + HTTP
+route sélectionnable seulement si toutes ses requirements sont composables depuis Config sur le même réseau
+provider name seul ne vaut jamais capability
+composabilité Config déterministe != opérabilité runtime
+Config revalidée au Start
+1 route sélectionnée = 1 Worker réel
+pas de Worker créé par source physique
+plusieurs Workers/Routes peuvent partager le même Store
+pas de partage implicite de gap/TargetCoverage entre Workers distincts
+frontend Tauri = surface sûre ; endpoints/secrets/handles restent Rust-only
+Desk compose Config + Transport + Store + Worker sans réimplémenter l'ingestion
+```
+
+Le prompt impose un `pre.001` d'audit/sizing avant scaffold lourd et réserve :
+
+```text
+docs/plans/036-V0_3_15_RAW_TRANSACTION_INGEST_DESK_PLAN.md
+docs/validation/032-V0_3_15_RAW_TRANSACTION_INGEST_DESK.md
+```
+
+## 5. CHANGELOG
+
+`CHANGELOG.md` reçoit l'entrée stable `0.3.14` synthétisant :
+
+```text
+gaps run-local et bornes finales
+reconnect/replay/delivery/coverage distincts
+TargetCoverage et coverage redondante conservative
+scan HTTP + known-reference hydration
+réconciliation source-loss et health gap-aware
+fairness nominal/repair
+snapshots publics gap/repair source-neutral
+shutdown/drain hardening
+pipeline Common RAW/Store unique
+Worker/Backfill indépendants
+gate workspace 1 931 PASS / 0 échec / 15 ignored
+smokes keyless HTTP Devnet + WebSocket Devnet PASS
+preuves provider/resource-gated restantes NON EXÉCUTÉES
+handoff 0.3.15 via prompt 034
+```
+
+## 6. ROADMAP
+
+L'entrée `0.3.14` passe de `[ ]` à `[X]` et décrit l'état réellement livré.
+
+L'entrée `0.3.15` est précisée pour refléter la décision acquise avant ouverture de la release : **un Worker par route sélectionnée**, route complète composée de toutes les capabilities requises, sélection uniquement lorsque Config permet la composition, puis validation réelle au `Start`.
+
+## 7. Fichiers ajoutés
+
+```text
+prompts/034-V0_3_15_START_PROMPT.md
+deltas/0.3.14/pre.016.md
+```
+
+## 8. Fichiers modifiés
+
+```text
+Cargo.toml
+CHANGELOG.md
+ROADMAP.md
+```
+
+## 9. Fichiers supprimés
+
+```text
+aucun
+```
+
+## 10. Surfaces explicitement inchangées
+
+```text
+README.md
+RULES.md
+docs/**
+crates/**
+config/**
+tests/**
+prompts/001-* à prompts/033-*
+deltas/0.3.14/pre.001.md à pre.015.md et leurs fixes
+```
+
+Aucun delta publié antérieur n'est modifié.
+
+## 11. Validations exécutées localement
+
+Sur l'état exact `pre.016` avant packaging :
+
+```text
+General Rust rule audit : clean
+Rust export completeness audit : 0 candidate(s)
+KSP workspace Rust rule audit : clean
+Markdown table audit : clean, 340 tables / 885 files
+prompt 034 : 18 sections présentes, dont Première mission / Prévision souple / Validation / Instruction d'ouverture
+diff exact pre.015 -> pre.016 : 3 fichiers existants modifiés + 2 ajoutés + 0 supprimé
+Cargo.toml : hors header, seule workspace.package.version change
+aucun README/USAGE/plan/validation/architecture/code/test/config/schema/dependency/feature modifié
+```
+
+Le toolchain Cargo/Rustfmt n'est pas disponible dans l'environnement d'assemblage. Aucun nouveau PASS Cargo post-bump n'est revendiqué localement ; les PASS Cargo d'entrée proviennent exclusivement du gate opérateur `pre.015`.
+
+## 12. Gate opérateur avant `rel.001`
+
+Après application :
+
+```bash
+cargo fmt --all -- --check
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates deltas
+cargo check --workspace
+```
+
+Aucun rerun live n'est requis par cette tranche de publication minimale. Un défaut découvert dans un couloir antérieur ne doit pas être absorbé dans `rel.001`.
+
+## 13. Décisions prises
+
+- `0.3.14` est techniquement et documentairement fermé ; `pre.016` ne rouvre aucun comportement ;
+- `0.3.15` commence uniquement après `0.3.14-rel.001` validée et le tag stable `v0.3.14` ;
+- la Desk `0.3.15` gère des **routes complètes** et lance un Worker par route sélectionnée ;
+- la composabilité d'une route est déterminée depuis Config, l'opérabilité réelle est validée au Start ;
+- les preuves live non exécutées de `0.3.14` restent explicitement non revendiquées.
+
+## 14. Questions ouvertes
+
+```text
+aucune question bloquante pour la préparation de publication 0.3.14
+```

prompts/034-V0_3_15_START_PROMPT.md

@@ -0,0 +1,972 @@
+<!-- file: prompts/034-V0_3_15_START_PROMPT.md -->
+<!-- version: 1 -->
+
+# Prompt de démarrage `0.3.15` — Raw Transaction Ingest Desk / composition et supervision de routes live
+
+## 1. Identité de la release et base exacte requise
+
+Ouvrir **uniquement** `0.3.15` depuis la release stable/taggée :
+
+```text
+v0.3.14
+```
+
+La base fournie par l'opérateur est autoritaire sur les souvenirs, snippets, anciennes archives et deltas intermédiaires. Avant toute modification, vérifier au minimum :
+
+```text
+workspace.package.version = 0.3.14
+deltas/0.3.14/rel.001.md présent
+ksp-worker-raw-transaction-ingest-lib stable et consommable depuis sa crate root
+ksp-config-lib possède la résolution Transport HTTP / WS / Yellowstone gRPC
+ksp-onchain-transport-lib possède les façades réellement utilisées par le Worker
+ksp-store-lib reste l'unique façade Store du consumer
+cinq familles live Worker préservées : Yellowstone / Standard Logs / Standard Block / Helius Transaction / HTTP Block Polling
+gaps run-local, TargetCoverage, health, fairness et shutdown 0.3.14 présents
+snapshots publics gap/repair source-neutral présents
+aucun edge Worker -> Config / Job Backfill / backend Store physique
+```
+
+Release ouverte :
+
+```text
+0.3.15
+```
+
+Première livraison attendue :
+
+```text
+0.3.15-pre.001
+```
+
+`pre.001` est obligatoirement un gate de **lecture + audit de composition Config/Transport/Store/Worker + audit du gabarit Desk KSP + brainstorming + sizing + planification**. Il est interdit de commencer directement par l'UI, par des commandes Tauri Start/Stop ou par la copie d'une application Desk existante avant fermeture de ce gate.
+
+## 2. Mission et résultat attendu
+
+Créer :
+
+```text
+crates/ksp-app-raw-transaction-ingest-desk
+```
+
+comme application Tauri KSP spécialisée dans la **composition, le démarrage, l'arrêt et la supervision de routes live `RawTransaction` réellement supportées par la configuration et le Worker finalisé**.
+
+Le Desk doit permettre à l'opérateur de :
+
+```text
+charger/utiliser la configuration KSP
+choisir le réseau logique disponible
+voir les routes live composables pour ce réseau
+comprendre pourquoi une route non composable est désactivée
+sélectionner une ou plusieurs routes composables
+démarrer une instance Worker par route sélectionnée
+arrêter chaque Worker proprement
+observer lifecycle / health / activité / backpressure / reconnect / replay / gaps / repair via les snapshots Worker
+vérifier que les données convergent réellement vers le même Store RawTransaction
+```
+
+Le Desk ne devient pas une seconde implémentation de l'acquisition. La chaîne d'ownership cible est :
+
+```text
+Frontend Tauri
+    -> route_id / action Start-Stop / DTO sûrs
+    -> backend Rust de ksp-app-raw-transaction-ingest-desk
+         -> ksp-config-lib
+         -> ksp-onchain-transport-lib
+         -> ksp-store-lib
+         -> ksp-worker-raw-transaction-ingest-lib
+              -> ksp-raw-transaction-lib
+              -> même Store RawTransaction
+```
+
+### 2.1 Règle fondamentale : route != source != endpoint
+
+Une **route** est une stratégie d'acquisition complète. Elle peut nécessiter plusieurs ressources/capacités techniques pour devenir exécutable.
+
+Exemples conceptuels, à réauditer contre la base réelle :
+
+```text
+Yellowstone transaction stream + HTTP getTransaction hydration
+Standard WS logsSubscribe + HTTP getTransaction hydration
+Standard WS blockSubscribe RAW-direct
+Helius transactionSubscribe + HTTP getTransaction hydration
+HTTP Block Polling RAW-direct
+```
+
+Une route n'est pas sélectionnable parce qu'un seul endpoint portant le bon provider existe. Elle est sélectionnable uniquement si **toutes ses capacités obligatoires** peuvent être composées depuis la Config pour le même réseau logique.
+
+Exemple :
+
+```text
+route exige Yellowstone gRPC + HTTP getTransaction
+gRPC disponible = oui
+HTTP compatible = non
+=> route NON SÉLECTIONNABLE
+```
+
+Autre exemple :
+
+```text
+endpoint Helius disponible uniquement comme WS standard
+route Standard WS Logs compatible = potentiellement sélectionnable
+route exigeant Helius transactionSubscribe = NON sélectionnable si cette capability spécifique n'est pas disponible
+```
+
+Il est interdit de déduire une capability uniquement à partir du nom du provider.
+
+### 2.2 Une instance Worker par route sélectionnée
+
+Décision acquise :
+
+```text
+1 route sélectionnée = 1 instance ksp-worker-raw-transaction-ingest-lib
+N routes sélectionnées = N Workers indépendants
+```
+
+Ce n'est **pas** un Worker par source physique.
+
+Une même route peut composer plusieurs ressources internes nécessaires à sa stratégie : gRPC + HTTP, WS + HTTP, ou d'autres ressources réellement requises par les contrats Worker. Toutes ces ressources appartiennent au Worker de cette route.
+
+Plusieurs Workers de routes différentes peuvent écrire vers le même Store `RawTransaction`. Ils restent indépendants pour :
+
+```text
+lifecycle
+gaps / TargetCoverage
+health
+repair
+shutdown
+```
+
+Aucun partage implicite de gap ledger ou de preuve de coverage entre Workers distincts n'est introduit. La convergence durable passe par les contrats Store/idempotence/observations existants.
+
+### 2.3 Composable avant Start, opérationnelle après Start
+
+Deux niveaux sont obligatoirement distingués :
+
+```text
+COMPOSABLE
+    toutes les capacités/configurations requises existent et sont cohérentes
+    décision déterministe à partir de Config et des contrats connus
+
+OPÉRATIONNELLE
+    les ressources sélectionnées fonctionnent réellement au runtime
+    preuve obtenue lors du Start / runtime Worker-Transport-Store
+```
+
+La liste des routes ne doit pas lancer des probes réseau arbitraires pour fabriquer artificiellement une disponibilité. Le backend Desk détermine d'abord la composabilité à partir de la configuration résolue. Au `Start`, le Worker et les façades Transport/Store valident réellement les ressources, les réseaux, les connexions et les capacités runtime nécessaires.
+
+Une route peut donc rester visible comme `Configured/Composable` puis passer `Starting -> Running` ou `Starting -> Faulted` selon le runtime réel.
+
+## 3. Sources de vérité internes obligatoires — ordre de lecture
+
+### 3.1 Gouvernance générale
+
+Lire intégralement, dans cet ordre :
+
+```text
+RULES.md
+ROADMAP.md
+CHANGELOG.md
+docs/000-README.md
+
+docs/rules/RULES_GENERAL.md
+docs/rules/RULES_KSP.md
+docs/rules/RULES_RUST.md
+docs/rules/RULES_DEPENDENCIES.md
+docs/rules/RULES_DOCUMENTATION.md
+docs/rules/FILE_CONTRACTS.md
+docs/rules/VERSION_WORKFLOW.md
+docs/rules/PROMPT_STRUCTURE.md
+```
+
+Le prompt complète ces règles ; il ne les remplace pas.
+
+Rappels bloquants :
+
+```text
+Rust 2024
+unsafe interdit
+unwrap / expect / panic interdits selon les règles KSP
+? interdit en production
+retours explicites ; clippy::implicit_return deny
+#![warn(missing_docs)]
+#![deny(unreachable_pub)]
+#![forbid(unsafe_code)]
+
+pas de pub mod
+pub/pub(crate) partagés reexportés via crate root
+accès partagés via crate::Item, y compris intra-crate
+item strictement module-local => private
+unit tests sous unit_tests/
+integration tests sous tests/
+```
+
+Après toute modification Rust :
+
+```bash
+cargo fmt --all
+python3 scripts/audit_rust_workspace_rules.py
+cargo check --workspace
+cargo clippy --workspace --all-targets
+```
+
+Pour tout Markdown touché :
+
+```bash
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates deltas
+```
+
+Une commande non exécutée n'est jamais déclarée PASS.
+
+### 3.2 Handoff stable `0.3.14`
+
+Lire intégralement :
+
+```text
+prompts/033-V0_3_14_START_PROMPT.md
+docs/plans/035-V0_3_14_MULTI_SOURCE_GAP_REPAIR_HARDENING_PLAN.md
+docs/validation/031-V0_3_14_MULTI_SOURCE_GAP_REPAIR_HARDENING.md
+deltas/0.3.14/pre.014.md
+deltas/0.3.14/pre.015.md
+deltas/0.3.14/pre.016.md
+deltas/0.3.14/rel.001.md
+crates/ksp-worker-raw-transaction-ingest-lib/README.md
+crates/ksp-worker-raw-transaction-ingest-lib/USAGE.md
+```
+
+Puis auditer le code réel de :
+
+```text
+crates/ksp-worker-raw-transaction-ingest-lib/src/
+crates/ksp-worker-raw-transaction-ingest-lib/tests/
+crates/ksp-worker-raw-transaction-ingest-lib/unit_tests/
+```
+
+`0.3.15` consomme le Worker finalisé ; il ne le recode pas dans l'application.
+
+### 3.3 Config et composition
+
+Lire :
+
+```text
+crates/ksp-config-lib/README.md
+crates/ksp-config-lib/USAGE.md
+crates/ksp-config-lib/src/
+config/std.transport.json
+config/examples/std.transport.example.json
+config/schemas/std.transport.schema.json
+config/std.store.json
+config/schemas/std.store.schema.json
+config/composite.ksp-app-backfill-desk.json
+config/composite.ksp-app-store-desk.json
+.env.example
+```
+
+Inventorier réellement :
+
+```text
+profils HTTP configurés
+rôles HTTP et request_kinds
+profils WS et protocol kind
+profils Yellowstone gRPC
+réseaux logiques
+credentials/secrets requis
+Store targets et réseau associé
+mécanismes de composite/profil sélectionné
+```
+
+Ne pas confondre un exemple sous `config/examples/` avec un profil réellement actif dans `config/std.transport.json`.
+
+### 3.4 Transport et Worker runtime resources
+
+Lire :
+
+```text
+crates/ksp-onchain-transport-lib/README.md
+crates/ksp-onchain-transport-lib/USAGE.md
+crates/ksp-onchain-transport-lib/src/
+crates/ksp-onchain-transport-lib/tests/
+
+crates/ksp-worker-raw-transaction-ingest-lib/src/runtime.rs
+crates/ksp-worker-raw-transaction-ingest-lib/src/runtime_resources.rs
+crates/ksp-worker-raw-transaction-ingest-lib/src/snapshot.rs
+```
+
+Auditer précisément les constructeurs publics actuellement disponibles :
+
+```text
+RawTransactionIngestRuntimeResources
+RawTransactionIngestYellowstoneSource
+RawTransactionIngestStandardLogsSource
+RawTransactionIngestStandardBlockSource
+RawTransactionIngestHeliusTransactionSource
+RawTransactionIngestHttpBlockPollingSource
+RawTransactionIngestWorker::start_with_runtime_resources
+RawTransactionIngestHandle
+RawTransactionIngestSnapshotSource
+```
+
+Le résultat de cet audit doit montrer, route par route, quelles capacités Transport/Config sont nécessaires pour construire le Worker sans bypass.
+
+### 3.5 Store
+
+Lire :
+
+```text
+crates/ksp-store-lib/README.md
+crates/ksp-store-lib/USAGE.md
+crates/ksp-store-lib/src/
+crates/ksp-store-api/src/
+```
+
+Le Desk dépend de `ksp-store-lib`, jamais de `ksp-store-postgres-lib` ni d'un client SQL.
+
+Un run Worker et le Store doivent porter exactement le même réseau logique. `mainnet` reste l'identité KSP canonique ; `mainnet-beta` est uniquement un alias historique/externe lorsqu'il est accepté par une lower-layer.
+
+### 3.6 Gabarit Desktop KSP
+
+Le Desk doit reprendre le gabarit **KSP actuel**, jamais une application historique externe.
+
+Lire au minimum :
+
+```text
+crates/ksp-app-config-desk/
+crates/ksp-app-wallet-desk/
+crates/ksp-app-solprices-desk/
+crates/ksp-app-backfill-desk/
+crates/ksp-app-store-desk/
+```
+
+Préserver le pattern déjà décidé :
+
+```text
+même splash KSP, seul le titre change
+mêmes fonts
+même style général
+même discipline frontend/backend Tauri
+tracing TypeScript des clics, boutons, tabs, filtres, refresh et IPC
+aucun secret/endpoints sensibles dans les logs frontend
+```
+
+Le `package.json` doit au minimum partir du socle courant des Desk KSP, incluant lorsque toujours présent après audit :
+
+```text
+@fltsci/tauri-plugin-tracing
+@fortawesome/fontawesome-free
+@tauri-apps/api
+bootstrap
+resize-observer-polyfill
+simplebar
+```
+
+et les mêmes devDependencies de base compatibles que les Desk KSP actuelles. Ne pas lancer une mise à niveau opportuniste du workspace frontend sans justification de `pre.001`.
+
+## 4. Sources externes à réauditer en `pre.001`
+
+La Desk elle-même ne doit pas dépendre de connaissances provider codées depuis une page marketing. Néanmoins, si la construction d'une route dépend d'une capability Transport/provider dont la sémantique ou la disponibilité a changé, réauditer les sources primaires réellement actuelles :
+
+```text
+Solana JSON-RPC / WebSocket pour méthodes/subscriptions utilisées
+Yellowstone gRPC upstream pour Subscribe / replay réellement exposé
+Helius pour la distinction standard WS vs transactionSubscribe/provider-specific lorsque nécessaire
+PublicNode / OrbitFlare uniquement si un profil actif et un smoke réel les utilisent
+Tauri 2 / plugins réellement employés si une adaptation desktop est nécessaire
+```
+
+Les résultats externes servent à qualifier les capabilities. Ils ne doivent jamais rendre sélectionnable une route que la Config locale ne peut pas composer.
+
+## 5. État validé à préserver depuis `v0.3.14`
+
+### 5.1 Worker
+
+Préserver :
+
+```text
+une admission/persistence Common RAW unique par Worker
+five live source families existantes
+hydratation globale/coalescence interne au Worker
+idempotence et content conflict explicite
+processing frontier distinct de continuity frontier
+gaps run-local bornés
+TargetCoverage conservative
+reconnect != replay_attempt != replay_covered != repaired
+fairness nominal/repair
+shutdown/drain/abort+join borné
+snapshots source-neutral avec gap observability
+aucun Backfill automatique
+```
+
+### 5.2 Ownership
+
+Préserver :
+
+```text
+Config possède profiles/endpoints/secrets
+Transport possède clients/sessions/retry/reconnect/resubscribe/replay natif
+Worker possède logique continue RawTransaction, continuity et repair du run
+Store possède persistence/idempotence/observations
+Desk compose et supervise ; il ne réimplémente aucune de ces couches
+```
+
+### 5.3 Producteurs indépendants
+
+Préserver :
+
+```text
+ksp-worker-raw-transaction-ingest-lib = acquisition continue
+ksp-job-backfill-lib = acquisition historique bornée/paramétrée
+Worker -X-> Backfill
+Backfill -X-> Worker
+```
+
+`0.3.15` n'introduit aucune orchestration Backfill automatique depuis la Desk ingest.
+
+## 6. Décisions acquises — ne pas redébattre sans contradiction réelle
+
+```text
+release : 0.3.15
+application : ksp-app-raw-transaction-ingest-desk
+gabarit : Desk KSP courant
+frontend : UI/DTO/actions sûres uniquement
+backend Rust Tauri : composition Config + Transport + Store + Worker
+route != source != endpoint
+route = stratégie complète + ensemble de capabilities obligatoires
+route sélectionnable uniquement si toutes ses requirements sont composables depuis Config
+provider name seul != capability
+composabilité Config != opérabilité runtime
+validation réseau/connexion/capabilities réelles au Start
+1 route sélectionnée = 1 Worker
+pas 1 Worker par source physique
+une route peut nécessiter plusieurs ressources Transport internes
+plusieurs Workers/Routes peuvent écrire dans le même Store
+pas de partage implicite des gaps/TargetCoverage entre Workers distincts
+endpoints/secrets/handles restent Rust-only et hors IPC
+Store via ksp-store-lib uniquement
+aucun SQL/backend physique
+aucune logique Backfill
+```
+
+## 7. Questions réellement ouvertes à trancher pendant `pre.001`
+
+### 7.1 Catalogue exact des routes V1
+
+Construire une matrice à partir des contrats réellement existants :
+
+```text
+route_id stable
+objectif de la route
+network admissible
+capabilities obligatoires
+capabilities optionnelles
+ressources Worker construites
+source family interne
+RAW-direct ou reference-bearing
+hydration requirement
+repair capabilities internes
+raison de non-composabilité projetable en DTO sûr
+```
+
+Le catalogue V1 doit être borné aux routes réellement constructibles sans bypass.
+
+### 7.2 Lieu du catalogue de routes
+
+Auditer si le catalogue reste légitimement app-owned dans le backend Desk ou si un petit contrat réutilisable manque dans une lower-layer existante.
+
+Règle :
+
+```text
+ne pas créer une nouvelle crate intermédiaire par défaut
+ne pas déplacer de logique d'ingestion vers l'app
+si une extension lower-layer minimale est indispensable, la faire dans la crate propriétaire pendant 0.3.15 avec tests dédiés
+```
+
+### 7.3 Projection de capabilities Config
+
+Décider comment obtenir une vue déterministe et sûre des capabilities configurées sans exposer :
+
+```text
+URL
+credential
+secret metadata
+header sensible
+client Transport
+Store URI
+```
+
+Si les APIs publiques Config/Transport ne permettent pas de déterminer proprement la composabilité d'une route, identifier l'extension minimale backend-neutral au lieu de parser arbitrairement le JSON Config depuis le frontend.
+
+### 7.4 Sélection réseau
+
+Décider l'UX exacte : réseau explicitement choisi parmi les configurations disponibles, ou réseau dérivé d'un composite/Store target sélectionné.
+
+Dans tous les cas :
+
+```text
+route.network == Worker.settings.network == Store.network
+```
+
+est obligatoire avant Start.
+
+### 7.5 Multiples compositions pour une même route
+
+Si plusieurs endpoints/rôles peuvent satisfaire une même route, décider avant UI lourde si :
+
+```text
+Config/Transport choisit automatiquement selon priorités existantes
+ou
+le Desk expose plusieurs compositions logiques sûres
+```
+
+Le frontend ne doit pas devenir un éditeur de connexions physiques et ne reçoit pas les URLs.
+
+### 7.6 Lifecycle de plusieurs Workers
+
+Définir l'état applicatif pour :
+
+```text
+0..N routes sélectionnées
+0..N Workers actifs
+Start individuel / Stop individuel
+Start sélection globale éventuellement
+fermeture application
+route déjà Running
+Start concurrent de deux routes
+fault d'une route sans arrêt implicite des autres
+Store partagé
+```
+
+Chaque handle doit rester associé de façon non ambiguë à un `route_id` applicatif sûr.
+
+### 7.7 Validation finale réelle
+
+Planifier les scénarios live réellement accessibles. Le Desk doit servir de validation système des couches existantes, mais aucun provider non provisionné ne reçoit un faux PASS.
+
+## 8. Objectifs et livrables de `0.3.15`
+
+À la clôture, viser :
+
+```text
+crate Tauri ksp-app-raw-transaction-ingest-desk intégrée au workspace
+composite/config app dédié si réellement nécessaire
+inventaire de routes source-neutral et borné
+projection selectable / unavailable + raison sûre
+sélection réseau cohérente
+sélection d'une ou plusieurs routes
+1 Worker réel par route sélectionnée
+construction réelle des RawTransactionIngestRuntimeResources nécessaires
+Start / Stop réels via ksp-worker-raw-transaction-ingest-lib
+Store partagé via ksp-store-lib
+snapshots Worker projetés vers l'UI sans données sensibles
+lifecycle/health/activity/backpressure/reconnect/replay/gaps/repair visibles
+fermeture application arrêtant/joinant proprement les Workers détenus
+tracing frontend KSP
+README/USAGE de l'application
+plan + validation de release
+gates Rust/frontend/Tauri complets
+smokes live accessibles documentés
+```
+
+Une route marquée sélectionnable par l'UI doit être réellement constructible depuis la Config résolue ; une route incomplète reste désactivée avec une raison sûre.
+
+## 9. Hors périmètre explicite
+
+```text
+nouveau moteur Worker
+nouvelle campagne historique
+extension multi-stratégie Backfill 0.3.16
+Worker par endpoint/source physique
+partage de gap ledger entre Workers distincts
+orchestrateur global de failover cross-Worker
+scheduler durable de Workers
+persistance des sélections/runs au-delà de ce que pre.001 décide explicitement
+SQL/backend Store direct
+lecture directe .env depuis l'app
+saisie/édition de secrets dans le frontend
+éditeur arbitraire d'endpoints provider
+exposition URL/token/header/client handle via IPC
+réimplémentation retry/reconnect/replay/hydration/discovery/persistence dans la Desk
+nouveau provider SDK sans besoin prouvé
+```
+
+## 10. Contraintes sécurité, API et architecture spécifiques
+
+### 10.1 IPC
+
+Le frontend peut connaître des identifiants logiques sûrs, par exemple :
+
+```text
+route_id
+network
+label
+route family
+selectable
+unavailable reason code
+Worker lifecycle/health
+compteurs/snapshots déjà source-neutral
+```
+
+Il ne doit pas recevoir :
+
+```text
+endpoint URL
+API key/token
+secret metadata
+Store URI
+Transport client/session
+source key privée
+transaction payload brut par simple monitoring
+error text provider arbitraire
+```
+
+### 10.2 Availability
+
+La disponibilité affichée doit distinguer clairement :
+
+```text
+Unavailable / Not composable
+Configured / Composable
+Starting
+Running
+Stopping
+Stopped
+Faulted
+```
+
+Ne pas afficher `Running` ou `Ready` à partir de la seule présence d'une configuration.
+
+### 10.3 Composition et validation
+
+La composition affichée peut être calculée sans I/O réseau. Avant démarrage, le backend doit **revalider** la Config et reconstruire les ressources ; il ne fait jamais confiance à une sélection frontend obsolète.
+
+Le Start doit échouer proprement si la configuration a changé ou si une ressource n'est plus valide.
+
+### 10.4 Plusieurs Workers, même Store
+
+Les routes actives écrivent dans le même Store logique lorsque leur réseau correspond. Les règles existantes de canonical identity, idempotence, observation et content conflict restent autoritaires.
+
+Le Desk ne choisit jamais un « provider gagnant » et ne fusionne pas lui-même des RawTransactions.
+
+## 11. Première mission `0.3.15-pre.001` — gate obligatoire
+
+`pre.001` doit rester essentiellement audit/planification. Produire avant tout scaffold lourd :
+
+### 11.1 Inventaire réel
+
+```text
+API publique Worker exacte
+constructeurs RuntimeResources exacts
+capabilities exigées par chaque famille Worker
+APIs Config disponibles pour HTTP/WS/gRPC/Store
+profils réellement committed vs exemples uniquement
+mécanismes de rôles/priorités HTTP
+kinds WS et protocoles gRPC
+pattern de composition du Backfill Desk
+pattern lifecycle/handle/snapshot dans les apps existantes
+socle Tauri/TS/npm courant des Desk
+```
+
+### 11.2 Matrice route/capability
+
+Produire une table complète :
+
+```text
+Route
+Network
+Required capability
+Optional capability
+Config evidence
+Worker constructor/resource
+Composable aujourd'hui ?
+Missing contract éventuel
+Live-testable ?
+```
+
+Exiger au moins l'analyse de :
+
+```text
+Yellowstone + HTTP hydration
+Standard Logs + HTTP hydration
+Standard Block direct
+Helius transactionSubscribe + HTTP hydration
+HTTP Block Polling
+```
+
+et distinguer explicitement une utilisation Helius en WS standard d'une route Helius `transactionSubscribe` provider-specific.
+
+### 11.3 Audit gap
+
+Classer chaque gap :
+
+```text
+aucun gap
+adaptation app seulement
+extension Config minimale
+extension Transport minimale
+extension Worker minimale
+split de release nécessaire
+```
+
+Une extension lower-layer réellement nécessaire peut appartenir à `0.3.15`, mais elle doit rester minimale, propriétaire de sa sémantique et testée avant l'UI qui la consomme.
+
+### 11.4 Gabarit et UX
+
+Produire :
+
+```text
+screen map
+route list mock contract
+states selectable/unavailable/running/faulted
+Start/Stop flow
+snapshot mapping UI
+IPC DTO matrix
+frontend tracing matrix
+```
+
+sans encore implémenter toutes les vues.
+
+### 11.5 Sizing
+
+Chaque tranche intermédiaire doit viser environ 15–20 minutes de travail effectif. Si une extension Config/Transport/Worker ou l'UI prévue rend la session trop grande, rescinder `0.3.15` avant l'implémentation lourde.
+
+### 11.6 Livrables `pre.001`
+
+Préparer au minimum :
+
+```text
+docs/plans/036-V0_3_15_RAW_TRANSACTION_INGEST_DESK_PLAN.md
+docs/validation/032-V0_3_15_RAW_TRANSACTION_INGEST_DESK.md
+deltas/0.3.15/pre.001.md
+```
+
+Le plan doit fixer la prévision souple réelle après audit, et non recopier mécaniquement celle du présent prompt.
+
+## 12. Prévision souple initiale des prereleases
+
+Prévision de départ, à recalibrer en `pre.001` :
+
+### pre.001 — audit / route model / sizing
+
+Audit complet Config/Transport/Store/Worker/Desk, matrice route-capability, gaps, UX et plan.
+
+### pre.002 — contrats applicatifs de route et scaffold Desk
+
+Créer la crate/app Tauri sur le gabarit KSP, DTO sûrs, route IDs/states et composite minimal sans Start Worker.
+
+### pre.003 — Config -> route inventory
+
+Résoudre réseau/profils/capabilities et produire les routes composables/non composables avec raisons sûres ; aucune sonde réseau arbitraire.
+
+### pre.004 — composition RuntimeResources
+
+Mapper chaque route réellement supportée vers ses ressources Worker/Transport sans bypass et revalider au Start.
+
+### pre.005 — Store + Start/Stop mono-route
+
+Ouvrir Store via façade, lancer/arrêter un Worker réel pour une route et fermer proprement les ressources.
+
+### pre.006 — multi-route / un Worker par route
+
+Gérer plusieurs routes sélectionnées, handles indépendants et Store partagé sans cross-Worker gap coordination.
+
+### pre.007 — snapshots / monitoring
+
+Projeter lifecycle, health, activity, backpressure, reconnect/replay, gap/repair et compteurs sûrs.
+
+### pre.008 — frontend fonctionnel / tracing
+
+Finaliser choix réseau/routes, Start/Stop, états, feedback, tracing frontend et ergonomie KSP.
+
+### pre.009 — races/security/hardening
+
+Config change entre inventory et Start, double Start/Stop, fermeture app, fault isolé, secrets/IPC/redaction et bornes.
+
+### pre.010 — completeness / validation end-to-end
+
+Canaris cross-layer Desk -> Config/Transport/Worker/Store, routes V1 complètes et scénarios système sans fake provider success.
+
+### pre.011 — gate technique/live/Tauri
+
+Workspace complet, Clippy strict, tests all-targets/all-features, npm/tsc/vite/Tauri build et smokes live réellement accessibles.
+
+### pre.012 — réconciliation documentaire
+
+README/USAGE, plan, validation, architectures réellement affectées. Pas de CHANGELOG/ROADMAP/prompt suivant.
+
+### pre.013 — préparation publication
+
+Prompt `0.3.16`, CHANGELOG, ROADMAP et mécanique de version/delta uniquement.
+
+### rel.001
+
+Publication stable mécanique après gate validé.
+
+Cette numérotation est une prévision, pas une contrainte. Insérer/séparer des tranches si `pre.001` montre qu'un élément dépasse le budget ou appartient à une lower-layer.
+
+## 13. Versionnement, deltas, commits, archives et tags
+
+Appliquer `docs/rules/VERSION_WORKFLOW.md`.
+
+Rappels :
+
+```text
+prerelease Cargo : 0.3.15-pre.N
+livraison : 0.3.15-pre.NNN
+fix livraison : 0.3.15-pre.NNN-fix.NNN
+fix Cargo code/runtime : 0.3.15-pre.N.fix.N
+archive générale : ksp-general-<delivery-id>.zip
+archive doc-only : ksp-doc-<delivery-id>.zip seulement si réellement limitée à docs/prompts
+```
+
+À partir de `0.1.x`, chaque delta est commité. Aucun tag n'est requis pour prerelease/fix/rel. Après `rel.001` validée :
+
+```text
+commit : v0.3.15-rel.001
+tag    : v0.3.15
+```
+
+Le delta ZIP contient uniquement les fichiers ajoutés/modifiés de la livraison plus son delta ; aucun lockfile/cache/build output.
+
+## 14. Procédure d'application et validation opérateur
+
+Pour chaque delta :
+
+```text
+partir exactement de la base requise
+appliquer le ZIP à la racine du dépôt
+vérifier le diff avant exécution
+ne jamais recopier un worktree complet à la place du delta
+ne jamais modifier silencieusement un delta déjà livré
+```
+
+Gate Rust minimal après modification :
+
+```bash
+cargo fmt --all
+cargo fmt --all -- --check
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates deltas
+cargo check --workspace
+cargo clippy --workspace --all-targets --all-features -- -D warnings
+```
+
+Les tests ciblés suivent selon les crates modifiées.
+
+## 15. Validations frontend/Tauri/réseau attendues
+
+### 15.1 Rust/workspace
+
+Avant fermeture technique :
+
+```bash
+cargo test --workspace --all-targets --all-features
+cargo tree -p ksp-app-raw-transaction-ingest-desk --edges normal
+cargo tree -p ksp-app-raw-transaction-ingest-desk -e features
+cargo tree -p ksp-worker-raw-transaction-ingest-lib --edges normal
+cargo tree --duplicates
+```
+
+### 15.2 Frontend
+
+Depuis la crate Desk, exécuter réellement les commandes correspondant au package courant, typiquement :
+
+```bash
+npm run build
+```
+
+ou les commandes workspace réellement retenues après audit.
+
+Le build frontend doit démontrer `tsc`/Vite sans réseau direct frontend, storage secret ou imports hors gabarit.
+
+### 15.3 Tauri
+
+Le gate final inclut :
+
+```bash
+cargo tauri build
+```
+
+pour la nouvelle Desk, avec bundles réellement supportés par l'environnement opérateur.
+
+### 15.4 Live/system
+
+Prévoir des scénarios réellement accessibles, par exemple :
+
+```text
+route composable -> Start -> Running -> RawTransaction/observations progressent -> Stop propre
+route Config incomplète -> non sélectionnable sans I/O
+route composable mais endpoint runtime indisponible -> Start fault propre
+plusieurs routes -> plusieurs Workers -> même Store -> observations/idempotence cohérentes
+```
+
+Les profils/provider-gated ne sont PASS que si les credentials et capacités correspondantes sont réellement disponibles et le test a été exécuté.
+
+Un exemple PublicNode Mainnet ou Helius Devnet n'est jamais considéré prouvé uniquement parce qu'un profil/exemple Config existe.
+
+## 16. Critères de clôture de `0.3.15`
+
+`0.3.15` est clôturable seulement si :
+
+```text
+ksp-app-raw-transaction-ingest-desk existe et build
+route/source/endpoint sont distingués dans le modèle
+catalogue V1 borné et documenté
+toute route sélectionnable possède toutes ses capabilities Config obligatoires
+aucune capability n'est déduite du seul provider
+composabilité et opérabilité runtime sont distinguées
+Config est revalidée au Start
+1 route active = 1 Worker
+aucun Worker par source physique imposé par la Desk
+une route peut assembler plusieurs ressources Transport nécessaires
+plusieurs Workers peuvent partager le même Store sans coordination de gaps cross-Worker
+Start/Stop réel utilise ksp-worker-raw-transaction-ingest-lib
+Transport/Config/Store ownership restent respectés
+aucun endpoint/secret/Store URI ne traverse l'IPC
+snapshots Worker utiles sont visibles sans source key privée
+fault d'une route n'impose pas arbitrairement le fault des autres
+fermeture app draine/arrête proprement tous les Workers détenus
+aucun Backfill automatique
+aucune persistence/RAW canonicalization réimplémentée dans la Desk
+workspace/Clippy/tests/frontend/Tauri gates verts
+smokes accessibles exécutés ou explicitement NON EXÉCUTÉ
+README/USAGE/plan/validation réconciliés
+prompt 0.3.16 produit dans la dernière prerelease
+```
+
+## 17. Release/session suivante envisagée
+
+La trajectoire actuelle prévoit :
+
+```text
+0.3.16
+    étendre ksp-job-backfill-lib et ksp-app-backfill-desk vers les stratégies historiques/catch-up multi-source réellement pertinentes
+```
+
+`0.3.15` ne doit pas préimplémenter ce backfill. Le Desk ingest reste un gestionnaire de routes live continues.
+
+## 18. Instruction d'ouverture
+
+La prochaine session doit commencer par :
+
+```text
+1. vérifier la base stable v0.3.14 et workspace.package.version = 0.3.14
+2. lire les règles normatives dans l'ordre demandé
+3. lire le handoff 0.3.14 et le Worker final
+4. auditer Config HTTP/WS/gRPC + Store réellement committed
+5. auditer les constructeurs RuntimeResources Worker et le pattern Backfill Desk
+6. construire la matrice route -> capabilities -> Config evidence -> Worker resources
+7. vérifier les Desk KSP servant de gabarit
+8. brainstormer les gaps/frontières/risques
+9. recalibrer la prévision des prereleases
+10. produire plan 036 + validation 032 + delta pre.001
+```
+
+Ne pas commencer avant ce gate :
+
+```text
+scaffold UI lourd
+Start/Stop Worker
+nouvelle API Config/Transport/Worker
+nouveau provider
+nouvelle logique de retry/hydration/repair
+```
+
+sauf correction triviale indispensable pour rendre l'audit lui-même exécutable.