SPB Git

Repository Public

README.md 57.2 KB

VQuant logo



VQuant icon

# VQuant pour iPhone et iPad

Client natif (Swift 6, SwiftUI, iOS 18+) de vquant.spboucher.ai : marchés et graphiques interactifs, analyses de l'agent suivies en direct, calculs quantitatifs exécutés sur le serveur, portefeuille, mémoire et veilles. Aucune vue web, aucune dépendance tierce. Même compte et mêmes clés d'accès que le site.

Author: Simon-Pierre Boucher

vquant.spboucher.ai version plateforme langue licence author

Swift SwiftUI Swift Charts PencilKit WidgetKit App Intents CryptoKit Passkeys LocalAuthentication Swift Package XcodeGen Xcode dépendances

commits last commit activity language languages size branches tags clones

fichiers Swift lignes Swift routes utilisées événements SSE moteurs quantitatifs widgets tests socle tests app tests d'interface fixtures accessibilité

bundle groupe d'apps signature TestFlight App Store Connect backend


# Sommaire


# 🆕 2.0 « VQuant Next » (branche next, non publiée)

VQuant devient d'abord l'agent de recherche quantitative autonome ; marchés, Quant Lab, portefeuilles et studio sont des surfaces autour de lui. 2.0 est une mise à niveau de 1.0 — tout ce que 1.0 faisait reste en place — pour le backend 6 et avec le paquet partagé VQuantKit (dépendance locale, aussi utilisée par le client macOS).

Domaine Ce que 2.0 apporte
Un compte, synchronisé Listes de suivi, portefeuilles (main = celui de l'agent), tracés de graphique, projets, notes, espaces de travail et préférences sont des objets du compte : réplique chiffrée sur l'appareil, file d'écritures hors ligne, fusion des conflits, état visible. La liste de suivi locale de 1.0 est migrée une fois, sans perte ni doublon.
Recherche autonome Mode recherche, jeu de données depuis Fichiers avec carte d'inspection, budget, modèle du registre du serveur (logos, Auto), vue d'étude Rapport · Activité · Code · Expériences · Figures · Fichiers, demandes d'autorisation (carte + notification locale avec Autoriser / Refuser), reprise d'une étude lancée sur le Mac ou le web.
Terminal Vue des marchés par section avec pastilles de fraîcheur, courbe des taux, calendrier économique, recherche universelle, états financiers avec ratios, croissance et formules.
Quant Lab 19 moteurs par catégorie, formulaires tactiles générés depuis la description du serveur (listes natives pour les paramètres JSON), progression, annulation, résultats lab/1 ; calculs rapides (option, VaR, taille de position).
Portefeuilles et Studio Plusieurs portefeuilles, analyse et proposition de rééquilibrage par les moteurs ; projets, hypothèses, notes, revues automatisées, export.
iPad Trois colonnes par destination, cockpit de recherche avec inspecteur, espaces de travail à séparateurs déplaçables, tracés au Pencil ancrés au temps et au prix, raccourcis clavier, glisser-déposer, Quick Look, fenêtres multiples.
Identité Jetons VQTokens : titres en New York, nombres en SF Mono, filets, accent Ember réservé aux aplats.

Ce qui n'est pas fait ou jamais vérifié sur un appareil : docs/IOS_TEST_PLAN.md §7. Les sections ci-dessous décrivent 1.0 et restent valables sauf mention ; l'architecture, les routes et la parité de 2.0 sont dans docs/.


# 📖 Aperçu

VQuant pour iPhone et iPad est l'interface mobile native de vquant.spboucher.ai : application 100 % native (Swift 6, SwiftUI, concurrence stricte complete), sans vue web, sans dépendance tierce (2.0 : une seule dépendance, le paquet maison VQuantKit). Elle partage le compte, les clés d'accès, l'historique, la mémoire, le portefeuille et les veilles du site.

Trois règles gouvernent l'app :

  • Aucune donnée fabriquée. Chaque nombre affiché vient d'une réponse du serveur ou d'un calcul descriptif documenté sur ces réponses. Une valeur manquante s'affiche « — », jamais 0. Un échec s'affiche comme un échec.
  • Provenance visible. Tout chargement renvoie Loaded<T> (réseau ou copie locale, avec l'heure) ; l'interface affiche un badge Interrogé / Différé / Clôture / Copie locale / Indisponible (DataFreshness.classify) ou, pour les données de la couche de données du backend 6, la pastille de provenance du serveur (jamais « en direct » : il n'y a pas de flux).
  • Le serveur calcule. L'appareil ne fait que des statistiques descriptives légères sur les observations reçues (moyennes mobiles, RSI, MACD, Bollinger, drawdown, corrélations). Les modèles restent côté serveur.
Identifiants ai.spboucher.vquant (le même que le client macOS), extension ai.spboucher.vquant.widgets, groupe d'apps group.ai.spboucher.vquant, équipe 3YM54G49SN
Cible iOS / iPadOS 18.0 et plus, iPhone + iPad
Version 2.0.0 (2) sur la branche next, non publiée ; 1.0.0 (1) sur TestFlight depuis le 2026-11-18 (build VALID, test interne)
Fiche App Store Connect 6836574364 (SKU vquant-ios-001, fr-CA)
Langue français
Code 58 fichiers Swift, environ 17 700 lignes (dont VQuant/Next/, 11 fichiers, environ 5 100 lignes) ; plus le paquet partagé VQuantKit

# Documentation du dépôt

Fichier Contenu
docs/IOS_ARCHITECTURE.md ce qu'est réellement le backend, organisation du code, iPhone / iPad, cycle de vie
docs/IOS_AUTHENTICATION.md clés d'accès, sessions d'appareil, Trousseau, verrou biométrique
docs/IOS_API_MAPPING.md chaque route du serveur et l'écran qui l'utilise
docs/IOS_FEATURE_PARITY.md matrice Web / macOS / iPhone / iPad
docs/IOS_TEST_PLAN.md tests, résultats mesurés, ce qui reste à valider sur appareil

# Famille VQuant

Dépôt Rôle Plateforme
vquant Backend (Node / Express, SQLite, moteurs Python) + site web, vquant.spboucher.ai web
vquant-macos Client natif macOS macOS
vquant-ios Client natif iPhone et iPad (ce dépôt) iOS / iPadOS

# Ce qu'est réellement VQuant

Le cahier des charges décrivait un écosystème générique (« Pyrus », WebSocket, courtage). L'inspection du dépôt vquant (v5.8.0) donne ceci, et l'app s'y conforme :

Élément du cahier des charges Réalité du backend Conséquence dans l'app
« Pyrus » N'existe pas. Les calculs lourds sont les moteurs Python du serveur, exposés par /api/quant/* (GARCH, VaR, Monte Carlo, options, optimisation, métriques de risque). L'espace « Calculs » pilote ces moteurs : formulaire généré depuis la description du serveur, tâches persistantes, résultats avec paramètres et code.
Recherche / agents IA Agent d'analyse (POST /api/chat) exécuté comme tâche serveur (/api/generations), flux SSE rejouable. Onglet Recherche : lancement, suivi en direct, reprise après coupure, historique, rapports rendus en natif.
Flux WebSocket de marché Aucun. Données FMP via un proxy REST (/api/fmp/*). Interrogation périodique, adaptée à l'état du marché et de la batterie.
Portefeuille, ordres, courtage Positions déclaratives (/api/workspace/portfolio). Aucun ordre, aucun courtier. Portefeuille valorisé avec les cours réels ; aucune interface d'ordre.
Notifications push (APNs) Le serveur n'a aucune intégration APNs. Notifications locales, émises quand l'app constate la fin d'une tâche.

# ✨ Fonctions

# Marchés

  • Indices, cotations, hausses / baisses / titres actifs du jour, heures de marché.
  • Recherche de symbole et liste de suivi (locale à l'appareil, partagée avec les widgets).
  • Fiche d'actif : société, actualités, 12 tableaux de fondamentaux (compte de résultat, bilan, flux de trésorerie, indicateurs clés, ratios, estimations d'analystes, surprises de résultats, dividendes, détenteurs institutionnels, transactions d'initiés, révisions de recommandations, objectif de cours) — tableau générique : tous les champs renvoyés, aucun inventé.

# Graphiques

  • PriceChartView dessine dans un Canvas SwiftUI : seule la fenêtre visible est tracée, au plus une marque par pixel horizontal.
  • 4 types : chandeliers, OHLC, ligne, aire. Périodes 1J, 5J, 1M (5 min, 15 min, 1 h) et 3M → Max (quotidien).
  • Superpositions : MM 20, MM 50, MM 200, MME 21, Bollinger 20·2. Panneaux : volume, RSI 14, MACD 12·26·9.
  • Pincer, glisser, réticule ; plein écran en paysage ; export image et CSV ; annotations (PencilKit).
  • Quand la période contient plus de barres que de pixels, le graphique trace des agrégats OHLC exacts (Indicators.aggregate) et l'écrit (« Agrégé ×N pour l'affichage »). Aucune interpolation, aucun lissage.

# Recherche (agent d'analyse)

  • Lancer une analyse (4 modes), avec image jointe depuis la photothèque.
  • Suivi en direct par SSE : plan, outils, sous-analystes, chronologie repliable ; arrêt ; reprise après coupure à l'index du dernier événement reçu.
  • Rapports rendus en natif : Markdown, tableaux, figures, marqueurs ; sources, données et code (piste d'audit complète) ; questions de suivi.
  • Historique : recherche, épingler, renommer, supprimer ; bibliothèque des rapports partagés ; export PDF (mis en page par le serveur).

# Calculs quantitatifs

  • 6 moteurs du serveur : garch, var, monte_carlo, options, portfolio_optimization, risk_metrics.
  • Formulaire construit depuis la description des paramètres (type, défaut, bornes, choix) ; le serveur revalide et renvoie les paramètres effectivement appliqués.
  • Tâches persistantes ; résultat avec paramètres, code et graphiques (Swift Charts).

# Portefeuille et agent

  • Portefeuille déclaratif (confirmation explicite avant écriture), valorisation, répartition, corrélations, drawdown ; tableau triable des positions sur iPad (Table).
  • Mémoire de l'agent ; veilles planifiées (exécutées par le serveur).

# Intégration au système

Fonction Détail
Widgets (WidgetKit) 4 : marchés (MarketsWidget), liste de suivi (WatchlistWidget), actif favori (FavouriteAssetWidget), tâches (JobsWidget) — ils lisent un instantané déposé par l'app, sans réseau ni jeton
Siri / Raccourcis (App Intents) « État des calculs », « Ouvre ma liste de suivi », « Ouvre la recherche », « Voir un actif »
Spotlight actifs consultés (ai.spboucher.vquant.asset)
Liens profonds vquant:// asset, conversation, analysis, quant, research, portfolio, markets
Notifications locales fin d'une tâche suivie par l'appareil
Arrière-plan BGAppRefreshTask (ai.spboucher.vquant.refresh) : relève les tâches, notifie, met à jour les widgets
Verrou Face ID / Touch ID, délai réglable, contenu masqué dans le sélecteur d'apps

# iPhone et iPad

  • iPhone : TabView à cinq onglets (Accueil, Marchés, Recherche, Portefeuille, Plus), un NavigationStack par onglet, feuilles pour la composition et l'édition, graphique plein écran en paysage.
  • iPad : NavigationSplitView (barre latérale à trois groupes), fiche d'actif en deux colonnes (graphique et analyse à gauche, inspecteur à droite), tableau triable des positions, fenêtres multiples (WindowGroup(for: String.self), Stage Manager et écran externe par le système), survol au trackpad sur le graphique, annotations au Pencil.
  • Le choix se fait sur la classe de taille horizontale : un iPad en Slide Over étroit reçoit l'interface iPhone.
Raccourci (iPad) Action
⌘N Nouvelle analyse
⌘K Rechercher un actif
⌘R Actualiser
⌘1 … ⌘8 Sections

Différences d'interface voulues. Le site ouvre sur la conversation ; l'iPhone ouvre sur un tableau de bord (marchés, portefeuille, tâches en cours, liste de suivi, analyses récentes). Une conversation web devient une liste de tâches et de rapports ; chaque rapport est un écran. Sur le site les calculs passent par l'agent ; l'app offre un formulaire par moteur, sans coût de modèle. Sur iPad : inspecteur latéral, tableau, fenêtres — la même fonction avec plus de densité, pas un iPhone étiré.


# 🧭 Architecture

flowchart TB
  subgraph Device["iPhone / iPad"]
    subgraph AppProc["App VQuant"]
      UI["Features (SwiftUI)<br/>Home, Markets, Research, Quant, Portfolio, Agent, Settings"]
      CH["Charts<br/>Canvas · Swift Charts · PencilKit"]
      MODEL["AppModel + Stores (@Observable)"]
      AUTH["Auth<br/>PasskeyService · AppLock · Keychain"]
      PLAT["Platform<br/>notifications, BackgroundTasks, Spotlight, App Intents"]
    end
    subgraph CoreLib["Core (paquet VQuantCore)"]
      API["APIClient + VQuantAPI<br/>Bearer, erreurs typées, SSE"]
      STR["SSEParser · AnalysisRun (réducteur pur)"]
      CACHE["DiskCache (acteur)<br/>AES-256-GCM"]
      Q["Indicators · PortfolioMath · ChartViewport"]
    end
    SNAP[("instantané JSON<br/>conteneur du groupe d'apps")]
    W["VQuantWidgets<br/>4 widgets, aucun réseau"]
  end
  subgraph Cluster["MacLustr"]
    TUN["MacLustr Tunnel<br/>Caddy + WireGuard"]
    BE["vquant · Node / Express · SQLite<br/>M2U64:5000"]
    PY["moteurs Python<br/>/api/quant/*"]
    FMP["FMP (proxy /api/fmp/*)"]
  end
  UI --> MODEL --> API
  UI --> CH --> Q
  MODEL --> STR
  MODEL --> CACHE
  MODEL --> AUTH
  MODEL --> PLAT
  MODEL --> SNAP --> W
  API -- "HTTPS · Bearer · SSE" --> TUN --> BE
  BE --> PY
  BE --> FMP

Réseau, décodage JSON, lecture SSE, chiffrement du cache et décodage d'images se font hors de l'acteur principal (APIClient est Sendable, DiskCache et FigureStore sont des acteurs).

# Une analyse suivie en direct, avec reprise

sequenceDiagram
  autonumber
  participant A as App (Recherche)
  participant S as vquant
  A->>S: POST /api/chat {query, history, mode}
  S-->>A: SSE job (identifiant de la tâche serveur)
  S-->>A: SSE status · plan · tool_start · tool_complete · agent_start · text…
  Note over A,S: passage en arrière-plan ou coupure — la tâche continue sur le serveur
  A->>S: GET /api/generations/:id/stream?from=N
  S-->>A: SSE (rejeu à partir de l'événement N, sans doublon)
  S-->>A: SSE sources · followups · done
  A->>A: AnalysisRun (réducteur) → rapport rendu en natif

# Opération sensible et vérification fraîche

sequenceDiagram
  autonumber
  participant A as App (Réglages › Appareils)
  participant S as vquant
  A->>S: DELETE /api/native/devices/:id
  S-->>A: 403 reauth_required
  A->>S: POST /api/native/reauth/options
  S-->>A: défi
  A->>A: assertion de clé d'accès (Face ID)
  A->>S: POST /api/native/reauth/verify
  S-->>A: ok, valable 5 minutes
  A->>S: DELETE /api/native/devices/:id (rejoué)
  S-->>A: session révoquée

# Cycle de vie

  • Passage en arrière-plan : arrêt des interrogations et des flux SSE ; les tâches continuent sur le serveur.
  • Retour au premier plan : verrou biométrique selon le délai choisi, vérification de la session, reprise des flux à partir du dernier événement reçu (?from=N), rafraîchissement.
  • Notifications locales seulement. Sans APNs côté serveur, une fin de tâche peut n'être annoncée qu'à la prochaine actualisation ou ouverture. L'app le dit dans Réglages › Notifications.
  • Live Activities : non implémentées. Sans jetons push, une activité figerait dès la suspension de l'app et afficherait un état périmé comme s'il était actuel.
  • Metal n'a pas été retenu pour les graphiques : avec le fenêtrage, le coût par image est borné par la largeur de l'écran, pas par la longueur de la série.

# 🧰 Pile technique

Couche Technologie Version Rôle
Langage Swift 6.0, SWIFT_STRICT_CONCURRENCY: complete tout le code
Interface SwiftUI système tous les écrans, aucune vue web
Cible iOS / iPadOS 18.0 et plus, familles 1,2 iPhone + iPad ; ni Catalyst, ni « Designed for iPad » sur Mac, ni visionOS
Graphique des prix SwiftUI Canvas système chandeliers, OHLC, ligne, aire
Graphiques analytiques Swift Charts système résultats de calculs, portefeuille
Annotations PencilKit système calque d'annotations
Widgets WidgetKit + App Intents système 4 widgets
Authentification AuthenticationServices système clés d'accès WebAuthn
Verrou LocalAuthentication système biométrie puis code de l'appareil
Chiffrement CryptoKit système cache AES-256-GCM
Arrière-plan BackgroundTasks système BGAppRefreshTask
Paquet Swift Package Manager tools 6.0 ; iOS 18, macOS 15 VQuantCore (Core/) pour les tests sur Mac
Projet XcodeGen project.yml génère VQuant.xcodeproj (non versionné)
Outils Xcode 27.2 ; simulateurs iOS 26.5 build et tests
Tests Swift Testing + XCTest / XCUITest — socle, app hébergée, interface, mesures

# 📁 Arborescence du dépôt

text
vquant-ios/
├── project.yml              XcodeGen : app (iPhone + iPad), extension de widgets, tests unitaires, tests d'interface
├── Package.swift            paquet VQuantCore (Core/ + CoreTests/)
├── Core/               (13) socle sans interface (Foundation, CryptoKit) — compilé dans l'app et les widgets
│   ├── Models/              Market, Research (conversations, tâches, espace de travail, appareils, calculs), JSONValue
│   ├── Networking/          APIClient (Bearer, erreurs typées, SSE), VQuantAPI (une fonction par route réelle)
│   ├── Streaming/           SSEParser, AnalysisEvent, AnalysisRun (réducteur pur, rejouable)
│   ├── Cache/               DiskCache (AES-256-GCM), CachedFetcher (réseau d'abord), DataFreshness
│   ├── Quant/               Indicators, PortfolioMath, QuantResult, ChartViewport
│   ├── Markdown/            MarkdownParser, ReportText (figures, marqueurs, CSV)
│   └── Stores/              WatchlistFile, WidgetSnapshot, SharedContainer
├── VQuant/             (26)
│   ├── App/            (4)  VQuantApp (scènes), AppModel (racine de composition), Stores (@Observable), AppSupport
│   ├── Auth/           (4)  Keychain, PasskeyService, AppLock, SignInView
│   ├── DesignSystem/   (2)  Theme (palette Onyx, formats), Components
│   ├── Charts/         (5)  PriceChartView + PriceChartScene (Canvas), AnalyticsCharts (Swift Charts), ChartAnnotationLayer (PencilKit), ChartTypes
│   ├── Features/       (9)  Home, Markets (+ AssetView), Research (+ ReportViews), Quant, Portfolio, Agent, Settings
│   ├── Platform/       (2)  notifications locales, BackgroundTasks, Spotlight, App Intents
│   └── Resources/           Info.plist, droits, PrivacyInfo, Assets.xcassets (icône 1024 px)
├── VQuantWidgets/      (1)  quatre widgets (WidgetKit + App Intents)
├── CoreTests/          (2)  tests du socle + Fixtures/ (20 réponses réelles du backend, tronquées)
├── VQuantTests/        (2)  tests hébergés dans l'app + mesures de performance
├── VQuantUITests/      (1)  tests d'interface
├── Scripts/                 build.sh, test-live.sh, release.sh, asc.py, make-icon.swift, ExportOptions.plist
└── docs/                    IOS_ARCHITECTURE, IOS_AUTHENTICATION, IOS_API_MAPPING, IOS_FEATURE_PARITY, IOS_TEST_PLAN, brand/

Lignes Swift : Core 2 592 · VQuant 6 785 (App 1 238, Auth 519, Charts 1 388, DesignSystem 384, Features 2 972, Platform 284) · VQuantWidgets 297 · CoreTests 640 · VQuantTests 469 · VQuantUITests 375.

Scripts/make-icon.swift dessine l'icône (l'étincelle VQuant sur fond Onyx) en PNG de 1024 px.


# 🚀 Construire et tester

bash
Scripts/build.sh generate          # projet Xcode (xcodegen) + Info-Debug.plist
Scripts/build.sh core              # tests du socle sur le Mac (swift test)
Scripts/build.sh debug             # build simulateur « VQuant iPhone »
Scripts/build.sh release           # build Release pour simulateur générique, sans signature
Scripts/test-live.sh test          # tests unitaires hébergés + backend de test (tunnel vers M2U64:5058)
Scripts/shot.sh <nom> [vquant://…] [--dark] [--pad]   # capture d'un écran pour relecture visuelle
Scripts/test-live.sh uitest        # tests d'interface iPhone ; VQUANT_SIM="VQuant iPad" pour l'iPad
Scripts/release.sh archive         # archive Release signée (compte Apple de Xcode)
Scripts/release.sh export          # IPA App Store Connect ; puis validate ; upload seulement sur demande
Scripts/release.sh device <nom>    # build de développement installé sur un appareil branché
  • Simulateurs dédiés, créés au besoin par build.sh : « VQuant iPhone » (iPhone 17 Pro) et « VQuant iPad » (iPad Pro 13 pouces M5).
  • Le backend de test est le backend 6 figé sur M2U64:~/dev/vquant-next-api (port 5058, copie des données de production avec toutes les routes /api/v2). Les tests n'écrivent jamais sur la production et n'y créent que des objets préfixés ios-test- (liste, portefeuille, projet, espace de travail, graphiques ios-test-sym-…).
  • VQUANTKIT=<dossier> Scripts/build.sh generate construit contre une copie figée du paquet partagé (il est modifié par d'autres sessions) ; le project.yml versionné pointe toujours sur ../VQuantKit.
  • Scripts/test-live.sh tunnel ouvre le tunnel ; Scripts/test-live.sh token renouvelle le jeton de test (session d'appareil créée dans la base de la copie ; le script du serveur refuse de tourner dans le dossier de production).
  • L'analyse réelle de bout en bout (coût d'API) ne tourne qu'avec TEST_RUNNER_VQUANT_LIVE_ANALYSIS=1 ; l'étude autonome réelle (modèle claude-sonnet-5-5, plafond 3 USD) avec TEST_RUNNER_VQUANT_LIVE_RESEARCH=1.
  • La sortie de xcodebuild est filtrée ; journaux complets dans build/logs/, captures dans build/shots/<simulateur>/.

# 🔧 Configuration

Aucune clé d'API, aucun secret dans le dépôt ni dans le binaire. Noms seulement :

Nom Où Rôle
VQuantBaseURL Info.plist origine du backend (production : https://vquant.spboucher.ai)
VQUANT_SIM Scripts/build.sh simulateur utilisé
VQUANT_BASE_URL, VQUANT_TEST_TOKEN environnement du lanceur de tests (préfixe TEST_RUNNER_) adresse et jeton de la copie de test
VQUANT_UITEST environnement (XCUITest) lance l'app en mode test d'interface
VQUANT_LIVE_ANALYSIS environnement (préfixe TEST_RUNNER_) active le test optionnel d'analyse réelle
ASC_KEY_ID, ASC_ISSUER_ID Scripts/release.sh clé d'API App Store Connect (fichier .p8 hors dépôt)

Info-Debug.plist = Info.plist + réseau local autorisé (copie de test par tunnel SSH) ; généré par Scripts/build.sh generate, non versionné. Réglages du bundle : schéma d'URL vquant, domaine associé webcredentials:vquant.spboucher.ai, tâche d'arrière-plan ai.spboucher.vquant.refresh, mode fetch.


# 🔌 API consommée

Source : vquant v5.8.0, vérifié contre la copie de test. Client : Core/Networking/VQuantAPI.swift. Aucune route n'a été inventée ; les réponses de référence sont dans CoreTests/Fixtures/. Détail route par route et écran par écran : docs/IOS_API_MAPPING.md.

Session et appareils (13)
Route Fonction Écran
POST /api/native/login/options, …/login/verify PasskeyService.signIn Connexion
POST /api/native/register/options, …/register/verify PasskeyService.enrol Connexion › lien d'invitation
POST /api/native/reauth/options, …/reauth/verify PasskeyService.reauthenticate Avant révocation
GET /api/native/session session() Lancement, diagnostic
POST /api/native/logout logout() Réglages › Se déconnecter
GET /api/native/devices devices() Réglages › Appareils
DELETE /api/native/devices/:id revokeDevice idem
DELETE /api/native/passkeys/:ref revokePasskey idem
GET /api/me me() tests
GET /api/health health() Diagnostic
Données de marché — proxy FMP (23)
Route Fonction Écran
GET /api/fmp/indices indices() Accueil, Marchés, widgets
GET /api/fmp/quote/:symbol quote() Fiche d'actif, liste de suivi, portefeuille
GET /api/fmp/gainers · losers · actives movers() Marchés
GET /api/fmp/market-hours marketHours() Marchés, calcul de la fraîcheur
GET /api/fmp/search?q=&limit= search() Recherche de symbole
GET /api/fmp/chart/full/:symbol?from=&to= bars() (quotidien) Graphique 3M → Max
GET /api/fmp/chart/intraday/:symbol?interval=&from=&to= bars() (5 min, 15 min, 1 h) Graphique 1J, 5J, 1M
GET /api/fmp/company-profile/:symbol profile() Fiche › Société
GET /api/fmp/financial-news/:symbol news() Fiche › Actualités
GET /api/fmp/{income-statement, balance-sheet, cash-flow, key-metrics, financial-ratios, analyst-estimates, earnings-surprises, dividend-history, institutional-holders, insider-trading, upgrades-downgrades, price-target-summary}/:symbol fundamentals() Fiche › Fondamentaux

Non utilisées : stock-quote (doublon de quote), historical-price et chart/light (couvertes par chart/full), intraday (couverte par chart/intraday), price-target, esg-score.

Analyses, conversations et rapports (12)
Route Fonction Écran
POST /api/chat {query, history, sessionId?, mode, imageData?, imageMimeType?} → SSE startAnalysis Composition
GET /api/generations generations() Recherche, Accueil, widget, Raccourci
GET /api/generations/:id/stream?from=N → SSE streamGeneration Suivi en direct, reprise
POST /api/generations/:id/cancel cancelGeneration Bouton Arrêter
GET /api/sessions[?q=] conversations() Recherche › Historique
GET /api/sessions/:id conversation() Conversation
PATCH /api/sessions/:id {title} / {pinned} renameConversation, pinConversation balayage
DELETE /api/sessions/:id deleteConversation balayage + confirmation
GET /api/shared-reports, GET /api/share/:shareId sharedReports, sharedReport Bibliothèque
POST /api/generate-pdf {question, answer} pdf() Conversation › PDF
GET /figures/…, /plots/… file() Figures des rapports

Non utilisées : POST /api/share, POST /api/generate-docx, POST /api/convert-to-slides, POST /api/speech-to-text, GET /api/download/:filename, /api/admin/*, /api/analytics/*.

Calculs quantitatifs (5) et espace de travail (9)
Route Fonction Écran
GET /api/quant/tools quantTools() Calculs, formulaire
POST /api/quant/jobs {tool, params} → 202 startQuantJob Formulaire
GET /api/quant/jobs quantJobs() Calculs, Accueil, Raccourci
GET /api/quant/jobs/:id quantJob() Résultat (paramètres, code, résultat)
DELETE /api/quant/jobs/:id deleteQuantJob balayage
GET /api/workspace workspace() Portefeuille, Agent, Accueil
PUT /api/workspace/portfolio/:symbol {quantity, costBasis?, note?} upsertPosition Portefeuille
DELETE /api/workspace/portfolio/:symbol removePosition Portefeuille
POST /api/workspace/memories, DELETE …/:id addMemory, deleteMemory Agent › Mémoire
POST /api/workspace/watches, PATCH …/:id, DELETE …/:id, POST …/:id/run createWatch, updateWatch, deleteWatch, runWatch Agent › Veilles

Événements SSE décodés (AnalysisEvent, 18) : job, status, text, thinking, plan, tool_start, tool_complete, tool_error, tool_result, python_code, custom_python_figures, agent_start, agent_tool, agent_done, sources, followups, error, done. tools et workspace sont ignorés sciemment ; tout autre type est conservé et signalé dans l'écran de suivi. Le champ model n'est pas envoyé : le serveur applique son modèle par défaut.

Limites appliquées par le serveur, restituées telles quelles : 4 analyses simultanées par personne (429), une par conversation (409), rejeu 20 minutes après la fin, liste 24 heures ; au plus 3 calculs simultanés par personne, pas de route d'annulation d'un calcul. Un redémarrage du serveur interrompt les analyses en cours.

Ce qui n'existe pas côté serveur : liste de suivi (locale à l'appareil), flux WebSocket, ordres ou courtage, push APNs, liste des modèles, sessions web par appareil.


# 📱 Écrans

Sections de la navigation (VQuant/App/AppSupport.swift) : Accueil, Marchés, Recherche, Portefeuille, Plus sur iPhone ; la barre latérale de l'iPad ajoute Calculs, Agent, Bibliothèque et Réglages.

Écran Fichier Contenu
Connexion VQuant/Auth/SignInView.swift clé d'accès, lien d'invitation à coller
Accueil VQuant/Features/Home/HomeView.swift marchés, portefeuille, tâches en cours, liste de suivi, analyses récentes
Marchés VQuant/Features/Markets/MarketsView.swift indices, mouvements du jour, recherche de symbole
Fiche d'actif VQuant/Features/Markets/AssetView.swift graphique, société, actualités, fondamentaux
Recherche VQuant/Features/Research/ResearchView.swift, ReportViews.swift composition, suivi en direct, historique, rapports, bibliothèque
Calculs VQuant/Features/Quant/QuantViews.swift moteurs, formulaire, tâches, résultats
Portefeuille VQuant/Features/Portfolio/PortfolioView.swift positions, valorisation, répartition, corrélations
Agent VQuant/Features/Agent/AgentView.swift mémoire, veilles
Réglages VQuant/Features/Settings/SettingsView.swift clés d'accès et appareils autorisés, verrou, notifications, diagnostic

# 💾 Données locales et hors ligne

Il n'y a pas de base de données locale : le serveur est la source de vérité.

Donnée Où Protection
Jeton de session d'appareil Trousseau AfterFirstUnlockThisDeviceOnly, non synchronisé
Clé du cache (256 bits aléatoires) Trousseau mêmes attributs
Cache des réponses consultées DiskCache AES-256-GCM (l'heure d'enregistrement est authentifiée), Data Protection, exclu des sauvegardes
Liste de suivi WatchlistFile, conteneur du groupe d'apps locale à l'appareil, partagée avec les widgets
Instantané des widgets WidgetSnapshot, conteneur du groupe d'apps JSON sans identifiant

Hors ligne. Ce qui a été consulté reste lisible (cours, graphiques, conversations, résultats de calculs, figures), chiffré sur l'appareil et marqué « Copie locale » avec sa date. Toute action qui modifie le compte ou lance un travail demande le serveur : les boutons sont désactivés hors ligne et rien n'est mis en file d'attente. CachedFetcher essaie le réseau d'abord et ne retombe sur la copie locale que sur un échec de transport.


# 🔒 Sécurité et authentification

Le serveur ne fait confiance qu'à une clé d'accès WebAuthn. Face ID / Touch ID n'authentifient jamais auprès du serveur : ils autorisent l'appareil à utiliser la clé privée et, séparément, déverrouillent l'app en local. Il n'y a ni mot de passe, ni seconde base de comptes. Détail : docs/IOS_AUTHENTICATION.md.

Couche Mécanisme Vérifié par
Identité Clé d'accès, AuthenticationServices (clé de sécurité acceptée aussi) Serveur (@simplewebauthn/server, vérification de l'utilisateur exigée)
Session Jeton d'appareil opaque (Authorization: Bearer), Trousseau Serveur (empreinte SHA-256, révocable, 90 jours d'inactivité)
Opérations sensibles Nouvelle assertion de clé d'accès (/api/native/reauth/*), valable 5 minutes Serveur
Verrou de l'app LocalAuthentication (deviceOwnerAuthentication : biométrie, puis code de l'appareil) Appareil seulement
  • Partie de confiance : vquant.spboucher.ai, la même que le site. Une clé d'accès créée sur le site et synchronisée par le Trousseau iCloud est proposée telle quelle par iOS.
  • Enrôlement d'un appareil sans clé : lien d'invitation à usage unique (npm run access:invite invite <personne> sur le serveur). L'app accepte le lien collé (/setup/<jeton>) ou le jeton seul ; 410 si le lien a expiré ou déjà servi.
  • Contrat natif : chaque requête porte X-VQ-Client: vquant-ios/<version> (<build>) et aucun en-tête Origin (le pont natif refuse les navigateurs).
  • Appareils autorisés : révoquer une autre session ou supprimer une clé répond 403 reauth_required sans vérification récente ; l'app déclenche la cérémonie puis rejoue l'opération. La dernière clé ne peut pas être supprimée (409).
  • Verrou biométrique : activé par défaut après la première connexion (si l'appareil a un code), réglable — immédiatement, 1, 5 ou 15 minutes. L'activer comme le désactiver exige de réussir la vérification. Sans code configuré, le verrou est indisponible et l'app le dit.
  • Widgets : aucun identifiant, aucun réseau.
  • Personnes, historique, mémoire, portefeuille et veilles sont cloisonnés par personne, côté serveur.
Événement Comportement
Déconnexion volontaire Révocation serveur, puis effacement : jeton, clé du cache, cache, préférence de verrou, instantané des widgets, index Spotlight.
401 avec x-vq-locked: 1 (session révoquée ailleurs, 90 jours d'inactivité, rotation de la clé d'accès du serveur) Même effacement, retour à l'écran de connexion avec l'explication.
401 sans cet en-tête (assertion refusée) La session reste valide ; l'erreur est affichée.
Hors ligne au lancement La session est conservée, non vérifiée ; l'app ouvre ses copies locales. La première requête aboutie la confirme ou la ferme.
Autorisation Texte affiché
Face ID « VQuant utilise Face ID pour déverrouiller l'application et confirmer les opérations sensibles sur cet appareil. »
Appareil photo « VQuant utilise l'appareil photo uniquement pour lire le code QR d'un lien d'invitation. »

# 🧪 Tests

Résultats du 2026-11-18 (Xcode 27.2, simulateurs iOS 26.5), lus dans les journaux de build/logs/ ; rien n'est estimé. Plan complet et couverture par exigence : docs/IOS_TEST_PLAN.md.

Suite Commande Tests Résultat Ce qu'elle couvre
Socle (Mac) Scripts/build.sh core 55 55 / 55 décodage des réponses réelles, SSE et réducteur, indicateurs, portefeuille, cache chiffré, fraîcheur, liste de suivi, client HTTP, fenêtre du graphique
App (hébergée, simulateur) Scripts/test-live.sh test 29 + 4 mesures 29 / 29 verrou biométrique, invitation, liens profonds, formulaires de calcul, détection de fin de tâche, résumé Raccourcis, reprise de flux, rendu des graphiques, backend réel
Interface iPhone Scripts/test-live.sh uitest 14 (+1 optionnel) 14 / 14 parcours de bout en bout avec données réelles
Interface iPad VQUANT_SIM="VQuant iPad" Scripts/test-live.sh uitest 14 (+1 optionnel) 14 / 14 mêmes parcours en disposition à colonnes
Environnement Usage Écritures
Fixtures (CoreTests/Fixtures/, 20 fichiers) réponses réelles du backend, tronquées, capturées le 2026-11-18 aucune
Copie de test M2U64:~/dev/vquant-native (port 5056, tunnel SSH) tests « backend réel » et tests d'interface oui, dans la copie seulement
Production vquant.spboucher.ai trois requêtes de lecture sans session (fichier d'association, accueil du client iOS par le pont natif) aucune

Les doublures (URLProtocol) ne servent qu'aux tests unitaires isolés ; l'application livrée n'en contient aucune.

Les 15 tests d'interface — VQuantUITests/VQuantUITests.swift

testSignedOutScreenOffersPasskeyAndInvitation · testDashboardShowsRealMarketData · testAssetChartRangesFullScreenAndFundamentals · testSearchFindsAndFollowsASymbol · testQuantComputationRunsOnTheServer · testQuantValidationErrorIsShown · testPortfolioPositionLifecycle · testResearchHistoryOpensAStoredReport · testLiveAnalysisStreamsFromTheServer (optionnel, coût d'API) · testSettingsDevicesAndDiagnostics · testUnreachableServerIsReportedNotFaked · testLargestAccessibilityTextSizeStaysUsable · testAccessibilityAudit · testLaunchPerformance · testRotationKeepsTheSelectedScreen

Le test optionnel a été exécuté une fois sur iPhone le 2026-11-18 : réussi en 22,8 s (tâche créée, flux suivi, rapport rendu, questions de suivi affichées).

Couverture par exigence
Exigence Tests
Authentification, session LiveBackendTests.sessionAndAccount, revokedOrUnknownTokenIsRefused, ClientTests.revokedSessionSignsOutLocally, errorMapping
Clés d'accès AppLogicTests.passkeyAssertionShape, invitationParsing, UI testSignedOutScreenOffersPasskeyAndInvitation
Face ID / Touch ID AppLockTests (4) : activation et désactivation exigent la vérification, délai de grâce, annulation, remise à zéro
Opérations sensibles LiveBackendTests.sensitiveOperationsRequireFreshPasskeyVerification
Révocation d'appareil 401 x-vq-locked → effacement local ; liste des appareils (UI testSettingsDevicesAndDiagnostics)
Pannes réseau CacheTests.fetcherFallsBackOnlyOnTransportFailure, UI testUnreachableServerIsReportedNotFaked
Reprise de flux RunControllerTests (4), StreamTests.replayAfterReconnectionDoesNotDuplicate
Décodage DecodingTests (12) sur réponses réelles
Rendu des graphiques ChartTests (3) : image en clair et en sombre, 12 000 barres dans les quatre types ; ChartViewportTests (13)
Calculs de portefeuille QuantTests.portfolioTotals, portfolioHistoryKeepsOnlyCommonDates ; UI testPortfolioPositionLifecycle
Soumission et résultat d'un calcul LiveBackendTests.quantJobLifecycle, quantValidationErrorsComeFromTheServer ; UI testQuantComputationRunsOnTheServer, testQuantValidationErrorIsShown
Cache hors ligne CacheTests (chiffrement constaté sur disque, altération rejetée, clé étrangère rejetée)
Notifications AppLogicTests.backgroundCompletionDetection (seules les tâches suivies par l'appareil sont annoncées)
Rotation testRotationKeepsTheSelectedScreen, rotation du graphique plein écran
Dynamic Type testLargestAccessibilityTextSizeStaysUsable (taille Accessibilité XL)
Garde-fous d'écriture confirmation explicite avant d'enregistrer une position, soumission refusée jamais rejouée (refusedSubmissionIsNotRetried), symbole inconnu refusé (unknownSymbolIsAnErrorNotAZero)
Aucune donnée fabriquée quoteWithoutPriceIsRejectedNotZeroed, portfolioTotals (positions sans cours exclues et signalées), testUnreachableServerIsReportedNotFaked

# ♿ Accessibilité et performance

Accessibilité. testAccessibilityAudit exécute performAccessibilityAudit d'Apple (description des éléments, contraste, zones tactiles, traits, texte tronqué) sur Accueil, Marchés, fiche d'actif, Recherche et Portefeuille.

  • Premier passage : 59 constats. Corrigés : orange d'accent trop clair sur fond clair (2,9:1 → 5,2:1, teinte dédiée au mode clair), verts, rouges et gris secondaires renforcés, zones tactiles du graphique portées à 44 pt, badges marqués comme texte statique, noms d'indices sur plusieurs lignes, ligne d'analyse qui s'empile aux grandes tailles.
  • Sur iPad, 7 constats de plus, corrigés (en-têtes de la barre latérale, lien du site de la société).
  • État final : 0 constat bloquant sur iPhone comme sur iPad. Des constats restent consignés sans faire échouer le test, avec leur motif dans la pièce jointe accessibility-findings (38 sur iPhone, 33 sur iPad) : contraste mesuré à travers le flou des barres du système ou la barre latérale translucide, styles système, texte tronqué aux plus grandes tailles sur des lignes volontairement uniques. Ce classement est un jugement écrit dans le test, à revoir lors du passage VoiceOver sur appareil.
  • La direction d'une variation n'est jamais portée par la couleur seule (signe et flèche). Chaque graphique est un élément d'accessibilité avec un résumé en français.

Performance (mesures XCTest, simulateur, build Debug) :

Mesure Résultat
Lancement à froid jusqu'à la première image (XCTApplicationLaunchMetric, 3 itérations) iPhone 0,90 s · iPad 1,00 s
Une image complète du graphique, 12 000 barres quotidiennes, 5 indicateurs, 3 panneaux, encodage PNG compris 35 ms
Six indicateurs sur 12 000 clôtures 44 ms
Analyse Markdown d'un rapport de 60 sections 5 ms
Cache : 10 × (chiffrer, écrire, lire, déchiffrer 1 Mo) 15 ms
Taille de l'IPA de distribution 3,8 Mo

Ces chiffres viennent d'un simulateur sur Mac, en configuration Debug : ils situent des ordres de grandeur et servent de garde-fou contre les régressions. Ils ne disent rien de l'énergie, de la mémoire ni de la fluidité sur un iPhone. Instruments n'a pas été exécuté : il faut un appareil physique.


# 📦 Publication

Distribution TestFlight (App Store Connect). Une app iOS est signée et provisionnée ; il n'y a pas d'étape de notarisation.

bash
# incrémenter CURRENT_PROJECT_VERSION dans project.yml, puis :
Scripts/release.sh archive     # archive Release, signature automatique (compte Apple de Xcode), affiche identité et droits
Scripts/release.sh export      # IPA (Scripts/ExportOptions.plist) → dist/export/VQuant.ipa
Scripts/release.sh validate    # validation par Apple
Scripts/release.sh upload      # envoi à TestFlight — seulement sur demande : c'est une action tournée vers l'extérieur
Élément Valeur
Équipe 3YM54G49SN
Signature automatique ; l'archive est signée avec le compte Apple de Xcode (requis par le groupe d'apps)
Fiche VQuant, 6836574364, SKU vquant-ios-001, fr-CA
État 1.0.0 (1) : archive et IPA « Apple Distribution » produites, codesign --verify --deep --strict réussi, validation « VERIFY SUCCEEDED », build VALID sur TestFlight en test interne (2026-11-18)

Le backend ne se déploie pas depuis ce dépôt : il vit dans vquant, sur le nœud M2U64 (port 5000, orchestrateur mld, PM2), exposé par le MacLustr Tunnel (Caddy + WireGuard) sous vquant.spboucher.ai.


# 📊 Parité web, macOS, iPhone, iPad

✅ disponible · ◐ partiel · — absent · n/v non vérifié. La colonne macOS décrit un projet qui était en construction par une autre session au moment de l'inspection : ses fonctions sont « n/v ». Vérifié : T test automatisé contre le backend de test, U test d'interface, M observé à la main sur simulateur, — non vérifié sur appareil. Source : docs/IOS_FEATURE_PARITY.md.

Matrice complète
Fonction Web macOS iPhone iPad Vérifié Remarque
Connexion par clé d'accès ✅ n/v ✅ ✅ T (forme des messages) ; cérémonie réelle — même partie de confiance, mêmes clés
Enrôlement par lien d'invitation ✅ n/v ✅ ✅ U (validation du lien) ; cérémonie — lien à coller (pas d'applinks)
Verrou Face ID / Touch ID — n/v ✅ ✅ T (logique) ; matériel — propre aux apps
Appareils autorisés, révocation — (CLI serveur) n/v ✅ ✅ T, U vérification fraîche exigée par le serveur
Lancer une analyse (4 modes) ✅ n/v ✅ ✅ T (flux simulé), U optionnel (réel) modèle par défaut du serveur
Choix du modèle ✅ n/v — — aucune route n'expose la liste en production
Image jointe à une question ✅ n/v ✅ ✅ M photothèque
Dictée (transcription serveur) ✅ n/v — — dictée du clavier iOS à la place
Suivi en direct, reprise après coupure ✅ n/v ✅ ✅ T reprise à l'index du dernier événement
Arrêter une analyse ✅ n/v ✅ ✅ M
Plan, outils, sous-analystes ✅ n/v ✅ ✅ T chronologie repliable
Rapport : Markdown, tableaux, figures, marqueurs ✅ n/v ✅ ✅ T, U rendu natif, pas de vue web
Formules LaTeX ✅ n/v ◐ ◐ affichées en texte à chasse fixe
Sources, données et code du rapport ✅ n/v ✅ ✅ T piste d'audit complète
Questions de suivi ✅ n/v ✅ ✅ T
Historique : recherche, épingler, renommer, supprimer ✅ n/v ✅ ✅ T, U
Export PDF (mis en page par le serveur) ✅ n/v ✅ ✅ M
Export DOCX, diapositives Beamer ✅ n/v — — non porté
Partager un rapport (lien public) ✅ n/v — — partage système du texte à la place
Bibliothèque de rapports partagés ✅ n/v ✅ ✅ T
Mémoire de l'agent ✅ n/v ✅ ✅ T
Veilles planifiées ✅ n/v ✅ ✅ M exécutées par le serveur
Portefeuille déclaratif ✅ n/v ✅ ✅ T, U confirmation explicite avant écriture
Valorisation, répartition, corrélations, drawdown — n/v ✅ ✅ T (calculs), U calculs descriptifs sur l'appareil
Tableau triable des positions — n/v — ✅ U Table iPad
Indices, cotations, mouvements du jour ◐ (bandeau) n/v ✅ ✅ T, U
Recherche de symbole — n/v ✅ ✅ T, U route ajoutée pour les clients natifs
Graphique interactif (chandeliers, OHLC, ligne, aire) — n/v ✅ ✅ T (rendu), U pincer, glisser, réticule
Indicateurs (SMA, EMA, Bollinger, RSI, MACD, volume) — n/v ✅ ✅ T
Plein écran paysage, export image et CSV — n/v ✅ ✅ U (plein écran, rotation) ; export M
Annotations Apple Pencil — n/v ◐ (doigt) ✅ — ancrées à l'écran, pas au prix
Fondamentaux (12 tableaux) — (via l'agent) n/v ✅ ✅ T, U
Actualités — (via l'agent) n/v ✅ ✅ T
Liste de suivi — n/v ✅ ✅ T, U locale à l'appareil
Calculs quantitatifs directs (6 moteurs) — (via l'agent) n/v ✅ ✅ T, U /api/quant/*
Fenêtres multiples, raccourcis clavier n/a n/v — ✅ M (compilation) ; usage —
Widgets (marchés, suivi, favori, analyses) n/a n/v ✅ ✅ M (compilation) ; écran d'accueil —
Siri / Raccourcis / Spotlight n/a n/v ✅ ✅ T (résumé parlé) ; Siri —
Notifications de fin de tâche — n/v ◐ ◐ T (détection) locales, pas de push
Lecture hors ligne — n/v ✅ ✅ T, U (serveur injoignable) copies chiffrées
Thème clair / sombre, Dynamic Type, VoiceOver ◐ n/v ✅ ✅ U (taille XL) ; VoiceOver —
Console d'administration, statistiques d'usage ✅ n/v — — hors périmètre mobile
Ordres, courtage — — — — n'existe nulle part dans VQuant

# 🩺 Points à connaître et pièges

  • Identifiant partagé : ai.spboucher.vquant est aussi celui du client macOS ; c'est celui que publie le fichier apple-app-site-association du serveur. Le changer casse les clés d'accès.
  • Le serveur n'appartient pas à ce dépôt : il relève du dépôt vquant sur son nœud et de la session du client macOS. Toute évolution d'API passe par là (règle « remote-first »). Rien n'a été ajouté au serveur par ce projet ; la branche native-clients du backend (GET /api/config, script de jeton de test) n'est pas fusionnée et l'app n'en dépend pas.
  • Groupe d'apps : l'archive doit être signée avec le compte Apple de Xcode (-allowProvisioningUpdates seul).
  • Numéro de build : incrémenter CURRENT_PROJECT_VERSION dans project.yml avant chaque envoi.
  • Pas d'applinks dans le fichier d'association : un lien d'invitation touché dans Safari ouvre le site, pas l'app ; il faut le coller.
  • Association de domaine : le fichier est mis en cache par le CDN d'Apple ; la première connexion peut échouer quelques minutes après l'installation (message explicite dans l'app).
  • 401 à deux sens : avec x-vq-locked: 1 la session est morte (effacement local) ; sans cet en-tête, seule la cérémonie est refusée et la session reste valide.
  • Copie de test injoignable : test-live.sh l'annonce et renvoie à M2U64:~/dev/vquant-native/run-test-copy.sh.
  • Simulateurs : deux fois le simulateur a refusé de lancer le processus de test (FBSOpenApplicationServiceErrorDomain) pendant que cinq simulateurs d'autres projets tournaient ; relancer la suite.
  • Orange de marque : #FF6A1A ne fait que 2,9:1 sur fond clair ; Theme utilise une teinte dédiée au mode clair.
  • Fichiers générés : VQuant.xcodeproj et Info-Debug.plist ne sont pas versionnés → Scripts/build.sh generate.

# 🚧 Limites connues et reste à valider

# Non porté (reste sur le web)

Choix du modèle, dictée par transcription serveur, export DOCX et diapositives Beamer, partage d'un rapport par lien public, console d'administration et statistiques d'usage. Formules LaTeX : affichées en texte à chasse fixe. Live Activities et notifications push : non implémentées (pas d'APNs côté serveur). Annotations : ancrées à l'écran, pas au prix.

# À valider sur un appareil physique

Aucun iPhone ni iPad n'était branché au Mac pendant ce travail.

  1. Connexion par clé d'accès réelle (domaine associé, feuille système, Face ID), enrôlement par invitation, vérification fraîche avant une révocation.
  2. Verrou Face ID / Touch ID matériel, masquage dans le sélecteur d'apps.
  3. Gestes du graphique au doigt (pincer, glisser, appui long), survol au trackpad, Apple Pencil.
  4. Widgets sur l'écran d'accueil et l'écran verrouillé, Raccourcis et Siri, Spotlight.
  5. Actualisation en arrière-plan et notification de fin de tâche (dépend d'iOS).
  6. Mode avion (le test automatisé simule un serveur injoignable, pas la coupure de la radio).
  7. Fenêtres multiples, Stage Manager, écran externe, raccourcis clavier matériels.
  8. Profilage Instruments.
  9. Passage complet à VoiceOver par une personne.
  10. Installation du build sur du matériel (le build est sur TestFlight ; rien n'a encore été installé sur un appareil).

# 👤 Auteur


Simon-Pierre Boucher — conception, développement, exploitation
www.spboucher.ai · git.spboucher.ai · contact@spboucher.ai


# 📄 Licence

Logiciel privé. Tous droits réservés © 2026 Simon-Pierre Boucher.

Files main
Menu

Theme