diff --git a/README.md b/README.md
index da9efb7..5793894 100644
--- a/README.md
+++ b/README.md
@@ -54,8 +54,11 @@ Pas besoin de Python, de venv ni de terminal. Les
 [releases GitHub](https://github.com/SKOHscripts/Kairos/releases) proposent un exécutable
 autonome par OS (`kairos-linux-x86_64`, `kairos-windows-x86_64.exe`) et un APK Android
 (`kairos-android-arm64.apk`). Télécharge, double-clique (sous Linux, rends d'abord le
-fichier exécutable avec `chmod +x kairos-linux-x86_64`), et le navigateur s'ouvre tout
-seul sur Kairos. Les réglages et la base de tâches vivent dans le dossier de données
+fichier exécutable avec `chmod +x kairos-linux-x86_64`), et une fenêtre s'ouvre toute
+seule sur Kairos — sans barre d'adresse ni onglets, le ressenti d'une vraie application
+de bureau (si un navigateur de la famille Chromium — Chrome, Edge, Brave, Vivaldi... —
+est installé ; sinon repli automatique sur un onglet du navigateur par défaut, sans rien
+à configurer). Les réglages et la base de tâches vivent dans le dossier de données
 standard de ton système, entièrement éditables depuis la page **Réglages**. Aucun
 fichier `.env` à copier ou à éditer à la main.
 
@@ -108,6 +111,17 @@ make test      # venv + suite de tests complète
 
 ## Fonctionnalités
 
+### Notes (capture GTD)
+Une page dédiée (`/kairos/notes`, entre Accueil et Jour dans la navigation) pour se
+décharger l'esprit sans réfléchir à la structure : une seule zone de texte libre, aucune
+priorité ni échéance à choisir sur le moment (Ctrl/Cmd+Entrée pour capturer sans lâcher
+le clavier). Chaque note capturée apparaît immédiatement dans la liste, sans rechargement
+de page. Une fois qu'une idée est prête à devenir actionnable, un clic sur **« → Tâche »**
+la convertit en tâche titre-seul, qui atterrit directement dans la boîte de réception «
+À traiter » de la vue Jour — la note d'origine est archivée (jamais supprimée) avec un
+lien vers la tâche créée. Une note peut aussi être éditée sur place ou classée sans suite
+(archivée) si elle ne mène nulle part.
+
 ### Gestion des tâches
 - **Création rapide** en une ligne (le titre seul suffit). Édition complète ensuite :
   titre, description, priorité 0-2 (P0 = la plus forte), échéance, date programmée,
diff --git a/app/desktop_browser.py b/app/desktop_browser.py
new file mode 100644
index 0000000..66e4397
--- /dev/null
+++ b/app/desktop_browser.py
@@ -0,0 +1,153 @@
+"""Détection d'un navigateur Chromium et ouverture en « fenêtre d'application ».
+
+`webbrowser.open` (utilisé par défaut dans `app/launcher.py`) ouvre un onglet
+dans le navigateur système par défaut — barre d'adresse, onglets, tout
+l'attirail d'un navigateur généraliste, alors que Kairos se veut ressenti
+comme une application de bureau à part entière (voir `docs/spec/
+packaging-lancement.md`). Les navigateurs de la famille Chromium (Chrome,
+Chromium, Edge, Brave, Vivaldi — tous basés sur le même moteur et acceptant
+les mêmes indicateurs de ligne de commande) savent s'ouvrir en **fenêtre
+d'application** via `--app=URL` : pas de barre d'adresse, pas d'onglets, un
+ressenti de « web app installée ». Firefox et Safari n'ont pas d'équivalent
+strict à cet indicateur — ce module ne cible donc que la famille Chromium.
+
+Ce module reste volontairement séparé de `app/launcher.py` : sa logique
+(détection d'un binaire, construction des arguments) est pure et se teste
+sans toucher à uvicorn, aux threads ou au fichier de verrou. `app/launcher.py`
+l'appelle depuis `_open_browser`, avec un repli automatique et silencieux vers
+`webbrowser.open` si la détection ou le lancement échoue — voir le
+commentaire à l'appel pour le détail de cette décision.
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+
+from app.settings_store import data_dir
+from app.subprocess_env import external_process_env
+
+# Ordre de préférence indicatif seulement (le premier trouvé gagne) — pas de
+# hiérarchie qualitative entre ces navigateurs, juste une liste stable pour
+# un comportement déterministe d'un poste à l'autre.
+_LINUX_BROWSER_NAMES = (
+    "google-chrome-stable",
+    "google-chrome",
+    "chromium-browser",
+    "chromium",
+    "brave-browser",
+    "microsoft-edge",
+    "microsoft-edge-stable",
+    "vivaldi-stable",
+    "vivaldi",
+)
+
+# Chemins relatifs sous chacun des dossiers de base Windows testés (l'ordre des
+# bases ci-dessous est : Program Files, Program Files (x86), puis LocalAppData
+# — un même navigateur peut atterrir sous l'une ou l'autre selon qu'il a été
+# installé pour tous les utilisateurs ou seulement l'utilisateur courant ; on
+# ne présume pas laquelle pour ne pas rater une installation valide).
+_WINDOWS_BROWSER_RELATIVE_PATHS = (
+    r"Google\Chrome\Application\chrome.exe",
+    r"Microsoft\Edge\Application\msedge.exe",
+    r"BraveSoftware\Brave-Browser\Application\brave.exe",
+    r"Vivaldi\Application\vivaldi.exe",
+)
+
+_BROWSER_PROFILE_DIRNAME = "browser-profile"
+
+
+def _windows_base_dirs() -> list[str]:
+    bases = []
+    for env_var in ("ProgramFiles", "ProgramFiles(x86)", "LocalAppData"):
+        base = os.environ.get(env_var)
+        if base:
+            bases.append(base)
+    return bases
+
+
+def find_app_capable_browser() -> str | None:
+    """Cherche un navigateur de la famille Chromium installé sur ce poste.
+
+    Fonction pure (aucun effet de bord, pas d'impression) : ne fait que des
+    vérifications sur le système de fichiers / l'environnement, pour rester
+    facilement testable en monkeypatchant `shutil.which`, `os.environ` et
+    `os.path.exists`.
+    """
+    # `KAIROS_BROWSER` : échappatoire explicite pour les tests/CI (imposer un
+    # binaire précis sans dépendre de ce qui est réellement installé), et pour
+    # un utilisateur avancé qui voudrait forcer un navigateur particulier —
+    # prioritaire sur toute détection automatique.
+    override = os.environ.get("KAIROS_BROWSER")
+    if override:
+        if os.path.isfile(override) and os.access(override, os.X_OK):
+            return override
+        resolved = shutil.which(override)
+        if resolved:
+            return resolved
+        return None
+
+    if sys.platform == "linux":
+        for name in _LINUX_BROWSER_NAMES:
+            found = shutil.which(name)
+            if found:
+                return found
+        return None
+
+    if sys.platform == "win32":
+        base_dirs = _windows_base_dirs()
+        for relative_path in _WINDOWS_BROWSER_RELATIVE_PATHS:
+            for base_dir in base_dirs:
+                candidate = os.path.join(base_dir, relative_path)
+                if os.path.isfile(candidate):
+                    return candidate
+        return None
+
+    # macOS (et tout autre OS) : hors périmètre de Kairos, voir
+    # `docs/spec/packaging-lancement.md` § Hors périmètre. Pas de détection
+    # dédiée, repli automatique vers `webbrowser.open` côté appelant.
+    return None
+
+
+def launch_app_window(browser_path: str, url: str) -> bool:
+    """Lance ``browser_path`` en fenêtre d'application sur ``url``.
+
+    Retourne `True` si le processus a bien été lancé (pas de garantie que la
+    fenêtre s'affiche effectivement — fonctionnalité de confort, jamais
+    bloquante), `False` sur tout échec.
+    """
+    # Profil dédié, séparé du profil personnel de l'utilisateur : la fenêtre
+    # d'application ne doit pas se mêler à ses onglets/extensions/sessions du
+    # navigateur habituel, et un profil Chromium ne peut de toute façon pas
+    # être ouvert deux fois simultanément par deux processus distincts.
+    profile_dir = str(data_dir() / _BROWSER_PROFILE_DIRNAME)
+    argv = [browser_path, f"--user-data-dir={profile_dir}", f"--app={url}"]
+
+    kwargs: dict = {}
+    if sys.platform == "win32" and hasattr(subprocess, "DETACHED_PROCESS"):
+        kwargs["creationflags"] = subprocess.DETACHED_PROCESS
+
+    try:
+        # `external_process_env()` (pas la version context manager,
+        # `Popen` accepte un `env=` explicite) : évite qu'un navigateur lancé
+        # depuis l'exécutable PyInstaller onefile hérite du `LD_LIBRARY_PATH`
+        # détourné vers les bibliothèques embarquées — voir
+        # `app/subprocess_env.py`.
+        subprocess.Popen(
+            argv,
+            env=external_process_env(),
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            start_new_session=True,
+            **kwargs,
+        )
+    except Exception:
+        # Fonctionnalité de confort en arrière-plan : un binaire manquant
+        # malgré la détection, un droit refusé, ou toute autre surprise ne
+        # doit jamais faire planter ni bloquer le lancement de Kairos —
+        # l'appelant retombe sur `webbrowser.open`.
+        return False
+    return True
diff --git a/app/launcher.py b/app/launcher.py
index eb16d91..2a5ae28 100644
--- a/app/launcher.py
+++ b/app/launcher.py
@@ -43,6 +43,7 @@
 # fonctionnent dans les deux cas (script figé et `pip install -e .`), tant que
 # la racine du dépôt est sur `sys.path` (c'est le cas ici : `pathex` du spec,
 # ou le `.pth` du mode editable).
+from app.desktop_browser import find_app_capable_browser, launch_app_window
 from app.main import app
 from app.settings_store import data_dir
 from app.subprocess_env import external_process_environ
@@ -71,6 +72,16 @@ def _open_browser(url: str) -> None:
     # (processus fantôme sur un runner CI, effets de bord imprévisibles).
     if os.environ.get("KAIROS_NO_BROWSER"):
         return
+    # Fenêtre d'application (Chromium `--app=URL`, voir `app/desktop_browser.py`)
+    # imposée par défaut, sans réglage utilisateur : c'est le ressenti recherché
+    # pour l'exécutable de bureau (pas un onglet de navigateur généraliste), et
+    # ça se dégrade tout seul vers l'ancien comportement (onglet du navigateur
+    # par défaut) si aucun navigateur Chromium n'est trouvé ou si son lancement
+    # échoue pour n'importe quelle raison — jamais d'erreur remontée à
+    # l'utilisateur pour cette fonctionnalité de confort.
+    browser_path = find_app_capable_browser()
+    if browser_path and launch_app_window(browser_path, url):
+        return
     # `external_process_environ()` : voir `app/subprocess_env.py` — évite
     # qu'un navigateur/`xdg-open` lancé par PyInstaller (mode onefile) hérite
     # du `LD_LIBRARY_PATH` détourné vers ses bibliothèques embarquées.
diff --git a/app/main.py b/app/main.py
index 8741334..e36b215 100644
--- a/app/main.py
+++ b/app/main.py
@@ -49,6 +49,7 @@
 )
 from .tasks_models import (
     FIBONACCI_SCALE,
+    Note,
     Task,
     TaskDependency,
     TimeBlock,
@@ -1292,3 +1293,143 @@ def delete_manual_block(request: Request) -> RedirectResponse:
             tasks_session.commit()
     return RedirectResponse("/kairos", status_code=303)
 
+
+# --------------------------------------------------------------------------
+# Notes (capture GTD, en amont de l'inbox de la vue Jour) — voir
+# docs/spec/notes-capture.md. Même patron de rendu que « Kairos » (fragment
+# AJAX négocié sur `X-Requested-With: fetch`), mirroré ici avec son propre
+# contenu (`_notes_list.html`, id `#mj-notes-content`) plutôt que réutilisé.
+# --------------------------------------------------------------------------
+
+
+def _build_notes_context(request: Request, tasks_session: Session) -> dict:
+    """Contexte de rendu de la page Notes : notes ouvertes (capture active) et
+    notes archivées (converties ou classées sans suite), les deux triées de la
+    plus récente à la plus ancienne — symétrique de `_build_kairos_context`."""
+    open_notes = list(
+        tasks_session.scalars(
+            select(Note).where(Note.status == "open").order_by(Note.created_at.desc())
+        )
+    )
+    archived_notes = list(
+        tasks_session.scalars(
+            select(Note).where(Note.status == "archived").order_by(Note.created_at.desc())
+        )
+    )
+    return {
+        "page": "notes",
+        "open_notes": open_notes,
+        "archived_notes": archived_notes,
+    }
+
+
+def render_notes_response(request: Request, *, fragment: bool) -> Response:
+    """Point d'entrée unique de rendu de la page Notes, même contrat que
+    `render_kairos_response` : `fragment=False` rend la page pleine
+    (`notes.html`), `fragment=True` rend seulement `_notes_list.html`
+    (id `#mj-notes-content`), utilisé par les handlers d'action pour
+    l'amélioration progressive AJAX. Les handlers doivent avoir committé et
+    fermé leur propre session avant d'appeler cette fonction, qui rouvre une
+    session fraîche — jamais de session imbriquée (même invariant que Kairos)."""
+    with _request_session(get_tasks_session) as tasks_session:
+        context = _build_notes_context(request, tasks_session)
+        template_name = "_notes_list.html" if fragment else "notes.html"
+        return templates.TemplateResponse(request, template_name, context)
+
+
+@app.get("/kairos/notes")
+def notes_page(request: Request) -> HTMLResponse:
+    return render_notes_response(request, fragment=False)
+
+
+def _notes_action_response(request: Request) -> Response:
+    """Réponse commune des handlers d'action Notes : mêmes règles que
+    `_kairos_action_response` (fragment AJAX si `X-Requested-With: fetch`,
+    sinon redirection 303 complète — repli sans JS pour la WebView Android et
+    l'accessibilité)."""
+    if request.headers.get("X-Requested-With") == "fetch":
+        return render_notes_response(request, fragment=True)
+    return RedirectResponse("/kairos/notes", status_code=303)
+
+
+@app.post("/kairos/notes")
+async def create_note(request: Request) -> Response:
+    """Capture rapide : un corps de texte libre, rien d'autre — pas de priorité,
+    pas de points, pas d'échéance (c'est tout l'intérêt par rapport à la boîte
+    de réception de la vue Jour, qui porte déjà ces champs sur `Task`)."""
+    form = await request.form()
+    body = str(form.get("body", "")).strip()
+    with _request_session(get_tasks_session) as tasks_session:
+        if body:
+            tasks_session.add(Note(body=body))
+            tasks_session.commit()
+    return _notes_action_response(request)
+
+
+@app.post("/kairos/notes/{note_id:int}/edit")
+async def edit_note(request: Request) -> Response:
+    """Édite le corps d'une note existante. Note disparue entre-temps → no-op
+    silencieux (même tolérance que les handlers d'action de la vue Jour)."""
+    form = await request.form()
+    with _request_session(get_tasks_session) as tasks_session:
+        note = tasks_session.get(Note, request.path_params["note_id"])
+        if note is not None:
+            note.body = str(form.get("body", "")).strip()
+            tasks_session.commit()
+    return _notes_action_response(request)
+
+
+def _note_title_from_body(body: str) -> str:
+    """Titre de la tâche créée par conversion : première ligne non vide du corps
+    de la note, tronquée à 200 caractères (cohérent avec `Task.title`,
+    `String(512)`, mais une capture rapide n'a pas besoin d'approcher cette
+    limite)."""
+    first_line = next((line.strip() for line in body.splitlines() if line.strip()), "")
+    return first_line[:200]
+
+
+@app.post("/kairos/notes/{note_id:int}/convert")
+def convert_note_to_task(request: Request) -> Response:
+    """Le moment clé du flux : la note devient une tâche titre-seul (elle atterrit
+    dans l'inbox « À traiter » de la vue Jour, à qualifier comme n'importe quelle
+    autre capture), la note elle-même est **archivée et liée**, jamais supprimée —
+    préserve l'historique de la capture d'origine (voir `Note.converted_task_id`,
+    sans contrainte FK, cohérent avec le reste du schéma)."""
+    with _request_session(get_tasks_session) as tasks_session:
+        note = tasks_session.get(Note, request.path_params["note_id"])
+        if note is not None and note.status == "open":
+            title = _note_title_from_body(note.body)
+            if title:
+                task = Task(title=title, source="native")
+                tasks_session.add(task)
+                tasks_session.flush()  # attribue l'id avant de le référencer
+                note.status = "archived"
+                note.converted_task_id = task.id
+                tasks_session.commit()
+    return _notes_action_response(request)
+
+
+@app.post("/kairos/notes/{note_id:int}/archive")
+def archive_note(request: Request) -> Response:
+    """Classe une note sans suite : retirée de la liste de capture active, jamais
+    supprimée (même sémantique que la conversion, sans `converted_task_id`)."""
+    with _request_session(get_tasks_session) as tasks_session:
+        note = tasks_session.get(Note, request.path_params["note_id"])
+        if note is not None:
+            note.status = "archived"
+            tasks_session.commit()
+    return _notes_action_response(request)
+
+
+@app.post("/kairos/notes/{note_id:int}/delete")
+def delete_note(request: Request) -> Response:
+    """Suppression définitive — à la différence de l'archivage, retire la ligne en
+    base (une note n'a pas d'historique de priorisation à préserver, contrairement
+    à une tâche)."""
+    with _request_session(get_tasks_session) as tasks_session:
+        note = tasks_session.get(Note, request.path_params["note_id"])
+        if note is not None:
+            tasks_session.delete(note)
+            tasks_session.commit()
+    return _notes_action_response(request)
+
diff --git a/app/tasks_models.py b/app/tasks_models.py
index 42a034c..1925ce7 100644
--- a/app/tasks_models.py
+++ b/app/tasks_models.py
@@ -185,6 +185,35 @@ class WorkSession(TasksBase):
     created_at: Mapped[datetime] = mapped_column(DateTime, default=_now)
 
 
+class Note(TasksBase):
+    """Note libre (« brain dump » GTD), capturée sans friction avant qualification.
+
+    Étape de **capture** en amont de la boîte de réception de la vue Jour (qui ne
+    reçoit que des `Task` titre-seul, avec priorité/points à poser) : une note n'a
+    ni priorité, ni points, ni échéance — juste un corps de texte libre, posé le
+    plus vite possible, décidé plus tard. `converted_task_id` (nullable, **sans
+    contrainte FK**, même parti pris que `Task.parent_id`/`linked_ticket_id` — voir
+    docs/spec/modele-donnees.md) trace la tâche créée lors d'une conversion
+    note → tâche, en lecture seule (aucune synchro retour). `status='archived'` est
+    la façon dont une note convertie (ou classée sans suite) sort de la liste de
+    capture active **sans jamais être supprimée** : mêmes principes de non-perte
+    que `Task.status='archived'`.
+    """
+
+    __tablename__ = "note"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    body: Mapped[str] = mapped_column(Text, default="")
+    # 'open' | 'archived'.
+    status: Mapped[str] = mapped_column(String(16), default="open", index=True)
+    # Id local de la tâche créée par conversion, sans contrainte FK — référence
+    # « molle », cohérente avec le reste du schéma. None tant que la note n'a pas
+    # été convertie.
+    converted_task_id: Mapped[int | None] = mapped_column(Integer, nullable=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime, default=_now)
+    updated_at: Mapped[datetime] = mapped_column(DateTime, default=_now, onupdate=_now)
+
+
 class TaskSyncMeta(TasksBase):
     """Méta du dernier fetch réussi par source (mirror de `GitLabRefreshMeta`).
 
diff --git a/app/tasks_seed.py b/app/tasks_seed.py
index 062466e..a6edfd9 100644
--- a/app/tasks_seed.py
+++ b/app/tasks_seed.py
@@ -20,7 +20,7 @@
 
 from sqlalchemy.orm import Session
 
-from .tasks_models import Task, TaskDependency, TimeBlock
+from .tasks_models import Note, Task, TaskDependency, TimeBlock
 
 EXAMPLE_PROJECT_TAG = "Exemple"
 
@@ -179,3 +179,16 @@ def add_task(**kwargs) -> Task:
         ]
     )
     session.flush()
+
+    # Note d'exemple (capture GTD) : illustre l'étape en amont de l'inbox « À
+    # traiter » (page Notes) — une idée jetée sans friction, pas encore une tâche.
+    session.add(
+        Note(
+            body=(
+                "[Exemple] Idée en vrac : revoir le découpage des sprints ?\n"
+                "À développer avant d'en faire une tâche — ou à archiver si "
+                "ça ne mène nulle part."
+            )
+        )
+    )
+    session.flush()
diff --git a/docs/spec/accueil-navigation.md b/docs/spec/accueil-navigation.md
index 77d26e4..f8a3a45 100644
--- a/docs/spec/accueil-navigation.md
+++ b/docs/spec/accueil-navigation.md
@@ -12,7 +12,8 @@ ici que ce qui est commun à toutes les pages (topnav) ou spécifique à l'accue
 
 ### Objectif / problème
 
-Kairos comporte plusieurs vues (Accueil, Jour, Semaine, Statistiques, Réglages) qui
+Kairos comporte plusieurs vues (Accueil, Notes, Jour, Semaine, Statistiques,
+Réglages) qui
 doivent partager une identité visuelle et une navigation cohérentes, sans dupliquer
 le HTML de la barre de navigation dans chaque template. Il faut aussi une page
 d'accueil qui explique ce que fait l'outil à un nouvel utilisateur (collègue
@@ -34,9 +35,11 @@ est pénible sur une longue liste.
 
 - Une barre de navigation horizontale, fixe en haut de l'écran (sticky), présente sur
   toutes les pages : logo/nom Kairos (lien vers l'accueil), puis les entrées Accueil,
-  Jour, Semaine, Statistiques, Réglages. L'entrée correspondant à la page affichée
-  est mise en évidence.
-- **Exception, APK Android uniquement** : les cinq entrées sont déplacées vers une
+  Notes, Jour, Semaine, Statistiques, Réglages. L'entrée correspondant à la page
+  affichée est mise en évidence. « Notes » est placée entre Accueil et Jour : la
+  capture (page Notes) précède la triage/exécution (vue Jour) dans le flux GTD —
+  voir `docs/spec/notes-capture.md`.
+- **Exception, APK Android uniquement** : les six entrées sont déplacées vers une
   barre de navigation basse fixe (icône + libellé, cible tactile ≥ 44px), le logo
   Kairos restant seul dans la barre du haut. Cette bottom nav n'apparaît **jamais**
   sur un navigateur (dev, service, exécutable de bureau), quelle que soit la largeur
@@ -93,6 +96,9 @@ est pénible sur une longue liste.
   au profit de la topnav horizontale.
 - Contenu détaillé de la vue Jour/GTD (filtres, backlog, progression du jour...) :
   `docs/spec/vue-jour-gtd.md`.
+- Contenu détaillé de la page Notes (capture, conversion en tâche, archivage) :
+  `docs/spec/notes-capture.md` — cette spec ne couvre que l'entrée de navigation
+  elle-même (icône, position, condition `active`).
 - Authentification/comptes multiples : Kairos reste mono-utilisateur, la navigation
   n'a pas de notion de session utilisateur.
 
@@ -115,9 +121,17 @@ dans le template via le contexte de la route `/` (`app/main.py::home`).
 #### `templates/base.html` — gabarit commun
 
 - **`<head>`** : titre par bloc (`{% block title %}Kairos{% endblock %}`), favicon
-  SVG (`/static/favicon.svg?v={{ asset_version }}`), polices Google Fonts (IBM Plex
-  Sans 400/500/600/700 + Newsreader italique 500, voir `docs/DESIGN_SYSTEM.md`),
-  feuille de style unique `/static/style.css?v={{ asset_version }}`. Le suffixe
+  SVG (`/static/favicon.svg?v={{ asset_version }}`), manifest PWA
+  (`<link rel="manifest" href="/static/manifest.webmanifest">`) et icônes PNG
+  (192/512, `apple-touch-icon`, `?v={{ asset_version }}` sur les trois comme sur
+  `style.css`) + `<meta name="theme-color" content="#F3F5F8">` — le contenu de ces
+  fichiers `static/` eux-mêmes (manifest, PNG) est hors périmètre de ce document
+  (propriété/contenu d'un autre chantier), seules les balises `<link>`/`<meta>` de
+  `base.html` y sont couvertes ; le favicon SVG existant reste inchangé en plus de
+  ces icônes PNG (navigateurs qui préfèrent le SVG le gardent). Polices Google Fonts
+  (IBM Plex Sans 400/500/600/700 + Newsreader italique 500, voir
+  `docs/DESIGN_SYSTEM.md`), feuille de style unique
+  `/static/style.css?v={{ asset_version }}`. Le suffixe
   `?v=` (posé par `templates.env.globals["asset_version"]` dans `app/main.py`, valeur
   = horodatage de modification de `style.css`, ou `0` si illisible) est un
   anti-cache navigateur : sans lui, un navigateur peut continuer à servir un vieux
@@ -131,17 +145,18 @@ dans le template via le contexte de la route `/` (`app/main.py::home`).
     couleurs terracotta d'origine conservées volontairement — voir
     `docs/DESIGN_SYSTEM.md` § Identité) + nom « Kairos » + sous-titre
     « le bon moment, la bonne tâche » (masqué sous 720px, voir § Invariants).
-  - `.tn-nav` : cinq entrées (Accueil `/`, Jour `/kairos?view=day`, Semaine
-    `/kairos?view=week`, Statistiques `/kairos/stats`, Réglages
-    `/kairos/settings`), chacune avec une icône (`icon('home')`, `icon('clock')`,
-    `icon('calendar')`, `icon('trending_up')`, `icon('gear')`) et un libellé texte.
+  - `.tn-nav` : six entrées (Accueil `/`, Notes `/kairos/notes`, Jour
+    `/kairos?view=day`, Semaine `/kairos?view=week`, Statistiques
+    `/kairos/stats`, Réglages `/kairos/settings`), chacune avec une icône
+    (`icon('home')`, `icon('notes')`, `icon('clock')`, `icon('calendar')`,
+    `icon('trending_up')`, `icon('gear')`) et un libellé texte.
   - **Mise en évidence de l'entrée active** : classe `active` conditionnée sur les
     variables de contexte passées par chaque route — `page == 'home'`,
-    `page == 'kairos' and (view is not defined or view != 'week')` (Jour, y compris
-    quand `view` n'est pas défini — défaut jour), `page == 'kairos' and view ==
-    'week'` (Semaine), `page == 'kairos_stats'`, `page == 'settings'`. Ces variables
-    (`page`, `view`) sont posées par chaque route dans le contexte de rendu, pas
-    déduites de l'URL côté template.
+    `page == 'notes'` (Notes), `page == 'kairos' and (view is not defined or view
+    != 'week')` (Jour, y compris quand `view` n'est pas défini — défaut jour),
+    `page == 'kairos' and view == 'week'` (Semaine), `page == 'kairos_stats'`,
+    `page == 'settings'`. Ces variables (`page`, `view`) sont posées par chaque
+    route dans le contexte de rendu, pas déduites de l'URL côté template.
   - **Bouton Quitter (`.tn-quit`)** : bloc conditionné par `{% if is_frozen %}`.
     `is_frozen` est une variable globale Jinja2 posée une fois au chargement du
     module (`templates.env.globals["is_frozen"] = getattr(sys, "frozen", False)`,
@@ -155,7 +170,7 @@ dans le template via le contexte de la route `/` (`app/main.py::home`).
   is_android %}is-android{% endif %}">` porte la classe `is-android` sur la racine
   du gabarit ; un second bloc `{% if is_android %}<nav class="bn-nav">...{% endif
   %}</nav>` (dernier enfant de `.layout`, après `<main class="content">`) reprend
-  les cinq mêmes entrées et conditions `active` que `.tn-nav` (icône + libellé,
+  les six mêmes entrées et conditions `active` que `.tn-nav` (icône + libellé,
   cette fois visible — contrairement à `.tn-item .ico`), sans dupliquer
   `.tn-brand`/`.tn-quit`.
   - `is_android` : variable globale Jinja2 posée une fois au chargement du module
@@ -178,9 +193,11 @@ dans le template via le contexte de la route `/` (`app/main.py::home`).
     `static/style.css`.
   - `.bn-item { min-width: 0; }` : sans ce reset, le `min-width: auto` implicite
     d'un enfant flex (`flex: 1`) borne le rétrécissement à la taille de son
-    contenu (icône + libellé) — sur cinq entrées à largeur égale, la barre
+    contenu (icône + libellé) — sur six entrées à largeur égale, la barre
     déborderait du viewport sur un libellé un peu long (constaté avec
-    « Réglages » en développement de ce correctif).
+    « Réglages » en développement de ce correctif ; le nombre d'entrées est
+    passé de cinq à six avec l'ajout de « Notes », sans remettre en cause ce
+    correctif — voir `docs/spec/notes-capture.md`).
   - Voir § Décisions et pièges tracés pour la justification du déclenchement
     serveur plutôt que CSS.
 - **Topbar (`.topbar`)** : sous la topnav, dans `<main class="content">`. Titre par
@@ -223,7 +240,12 @@ dans le template via le contexte de la route `/` (`app/main.py::home`).
   pencil, save, trash, file_text, grid, share, blocked, comment, arrow_left,
   arrow_up_right, trending_up, chevron_down, chevron_right, export_up, import_down,
   dot, dot_empty, clock, calendar, layers, dashboard, gitlab, chevron_left, search,
-  home, gear — défaut : un simple cercle si `name` ne correspond à rien).
+  home, gear, notes — défaut : un simple cercle si `name` ne correspond à rien).
+  `notes` (rectangle arrondi + trois traits horizontaux, glyphe de bloc-notes) sert
+  à la sixième entrée de navigation, « Notes » (`docs/spec/notes-capture.md`) —
+  choisie plutôt que `file_text`/`clipboard` (existantes mais inutilisées ailleurs
+  dans l'app à ce jour) pour un glyphe visuellement distinct d'un document/d'un
+  presse-papier, plus proche d'un carnet de capture.
 - Accessibilité : `aria-hidden="true"` par défaut ; si `title` est fourni,
   `role="img" aria-label="{{ title }}"` à la place — jamais les deux, jamais aucun
   des deux.
@@ -367,7 +389,9 @@ dans le template via le contexte de la route `/` (`app/main.py::home`).
   bottom nav mobile », consignée dans `CLAUDE.md`/`docs/DESIGN_SYSTEM.md` §
   Navigation & mobile, mise à jour dans le même changement) : la nav horizontale
   qui passait sur deux lignes sous ~400px de large consommait jusqu'à ~25% de la
-  hauteur d'écran avant tout contenu, sur exactement les cinq destinations où
+  hauteur d'écran avant tout contenu, sur les cinq destinations d'alors (« Notes »
+  a rejoint la navigation ensuite, docs/spec/notes-capture.md, portant le total à
+  six sans remettre en cause ce choix) — exactement la fourchette où
   Material Design recommande une bottom nav. Un déclenchement purement CSS
   (`@media (max-width: 720px)`) aurait aussi affiché la bottom nav sur un
   navigateur desktop simplement rétréci sous ce seuil — comportement jugé
diff --git a/docs/spec/modele-donnees.md b/docs/spec/modele-donnees.md
index ba7357d..a32db8b 100644
--- a/docs/spec/modele-donnees.md
+++ b/docs/spec/modele-donnees.md
@@ -80,8 +80,8 @@ Android (Chaquopy + WebView). Il lui faut un stockage :
 Deux fichiers forment le socle de persistance :
 
 - `app/tasks_models.py` définit `TasksBase` (une `DeclarativeBase` SQLAlchemy 2
-  dédiée) et les cinq tables : `Task`, `TimeBlock`, `TaskDependency`,
-  `WorkSession`, `TaskSyncMeta`, plus la constante `FIBONACCI_SCALE`.
+  dédiée) et les six tables : `Task`, `TimeBlock`, `TaskDependency`,
+  `WorkSession`, `TaskSyncMeta`, `Note`, plus la constante `FIBONACCI_SCALE`.
 - `app/tasks_db.py` crée le moteur (`tasks_engine`) et la fabrique de sessions
   (`TasksSessionLocal`) pointant sur `Settings.tasks_database_url`
   (`sqlite:///{tasks_database_path}`), gère la migration additive légère
@@ -301,6 +301,31 @@ pas de scheduler en tâche de fond) et à l'affichage d'un avertissement quand l
 dernière synchro a échoué. La source historique `'superproductivity'` est
 purgée par la migration de retrait de l'intégration (voir plus bas).
 
+**`Note`** — table `note`. Note libre (« brain dump » GTD), capture en amont de
+la boîte de réception de la vue Jour — voir `docs/spec/notes-capture.md` pour
+le besoin métier et les routes ; ce document ne couvre que la forme des
+données.
+
+- `id: int` — clé primaire.
+- `body: str` (`Text`, défaut `""`) — corps de texte libre, multi-ligne.
+- `status: str` (`String(16)`, défaut `"open"`, **indexé**) — `'open'` |
+  `'archived'`. `'archived'` signifie que la note a été convertie en tâche
+  (voir `converted_task_id`) ou classée sans suite ; comme pour `Task.status`,
+  une note **n'est jamais supprimée** par ce passage à `'archived'` — seule
+  la route `DELETE`-like `POST /kairos/notes/{id}/delete` supprime réellement
+  la ligne.
+- `converted_task_id: int | None` (`Integer`, nullable) — référence locale
+  vers `Task.id`, posée uniquement par la conversion note → tâche, **sans
+  contrainte `ForeignKey`** déclarée : même parti pris que `Task.parent_id`/
+  `TaskDependency.blocker_id`/`Task.linked_ticket_id` (« référence molle »,
+  cohérente avec le reste du schéma — voir § Décisions et pièges tracés).
+  `None` tant que la note n'a pas été convertie.
+- `created_at: datetime` (`DateTime`, défaut `_now`).
+- `updated_at: datetime` (`DateTime`, défaut `_now`, `onupdate=_now`).
+
+Pas de `UniqueConstraint` sur `Note` : aucune notion de doublon appliquée côté
+base, une capture rapide peut légitimement dupliquer une idée déjà notée.
+
 #### `app/tasks_db.py`
 
 **Engine et session** — `tasks_engine = create_engine(_settings.
@@ -346,7 +371,11 @@ Note : les colonnes présentes **dès la création initiale** de `Task`
 (`title`…`external_id`, `created_at`, `updated_at`) et de `TimeBlock`
 (`title`…`external_id`, `created_at`) n'apparaissent **pas** dans ce dictionnaire
 — seules les colonnes ajoutées *après coup* y figurent, car `create_all()` ne
-modifie jamais une table existante (seulement les tables absentes).
+modifie jamais une table existante (seulement les tables absentes). Une table
+**entièrement nouvelle** (ex. `note`, ajoutée avec `Note`) n'a besoin d'aucune
+entrée non plus, pour la même raison à l'envers : `create_all()` la crée dans
+son intégralité (toutes ses colonnes déjà à jour) sur toute base où elle est
+absente, qu'elle soit vierge ou déjà peuplée par d'autres tables.
 
 **`_ensure_tasks_columns()`** — pour chaque table du dictionnaire présente dans
 la base (`inspector.get_table_names()`), calcule l'ensemble des colonnes
@@ -477,6 +506,12 @@ Trois créneaux (`TimeBlock`), ajoutés par un unique `session.add_all([...])` :
 `session.flush()` — le `flush()` est nécessaire pour obtenir l'`id` attribué
 avant de le référencer en `parent_id` (sous-tâches) ou dans un `TaskDependency`.
 
+Une **note** d'exemple (`Note`, préfixée `[Exemple]` comme le reste) est
+ajoutée à la suite, hors de `add_task` (elle n'a ni `source` ni `project_tag` —
+ces champs n'existent pas sur `Note`) : illustre l'étape de capture GTD en
+amont de la boîte de réception, pour qu'un nouvel utilisateur découvre aussi la
+page Notes dès le premier lancement.
+
 ### Décisions et pièges tracés
 
 - **`external_id` nullable et jamais `""` pour une tâche native.** Piège déjà
diff --git a/docs/spec/notes-capture.md b/docs/spec/notes-capture.md
new file mode 100644
index 0000000..da94f32
--- /dev/null
+++ b/docs/spec/notes-capture.md
@@ -0,0 +1,307 @@
+# Notes (capture GTD)
+
+_Rôle : une page de capture libre (« brain dump »), en amont de la boîte de
+réception de la vue Jour — jeter une idée par écrit sans avoir à décider tout de
+suite si c'est une tâche. Fichiers couverts : `app/tasks_models.py::Note`,
+`app/main.py` (`_build_notes_context`, `render_notes_response`,
+`_notes_action_response`, `notes_page`, `create_note`, `edit_note`,
+`convert_note_to_task`, `archive_note`, `delete_note`), `templates/notes.html`,
+`templates/_notes_list.html`. Le sixième item de navigation (icône `notes`,
+`templates/_icons.html`) et son entrée topnav/bottom-nav sont documentés dans
+`docs/spec/accueil-navigation.md` — repris ici seulement pour mémoire. Le schéma
+`Note` est documenté en détail (tous les champs) dans
+`docs/spec/modele-donnees.md`._
+
+**Hors de cette spec** : la boîte de réception de la vue Jour (`Task` sans
+priorité ni points), le flux GTD complet côté tâches → `docs/spec/vue-jour-gtd.md`
+(cette spec ne fait qu'y pointer, à l'étape qui précède). Le schéma exhaustif de
+`Note` (tous les champs, migration) → `docs/spec/modele-donnees.md`. La
+navigation/le gabarit commun (`base.html`, topnav, bottom nav) →
+`docs/spec/accueil-navigation.md`.
+
+---
+
+## 1. Besoin métier (cahier des charges)
+
+### Objectif / problème
+
+Kairos ne capturait jusqu'ici que des **tâches** : la boîte de réception de la
+vue Jour (`docs/spec/vue-jour-gtd.md` § 2) accueille bien des `Task` sans
+priorité ni points Fibonacci, mais une `Task` reste une tâche — un objet qu'on
+s'engage, plus ou moins, à faire. Or l'étape amont du cycle GTD (*Getting Things
+Done*) est la **capture** au sens le plus large : une idée, un rappel, un « il
+faudrait que… » qui n'est pas encore tranché comme actionnable. Forcer un titre
+de tâche à ce stade impose une décision prématurée (« est-ce que c'est vraiment
+une tâche ? quelle priorité ? ») qui freine la capture — exactement ce que le
+principe GTD « capturer sans friction » (déjà cité dans `vue-jour-gtd.md` pour la
+capture de tâche titre-seul) cherche à éviter, mais poussé un cran plus loin en
+amont.
+
+### Comportement attendu (utilisateur)
+
+- Une page dédiée, `/kairos/notes` (« Notes » dans la navigation), avec un
+  encart de capture toujours visible en tête, jamais replié : un seul champ,
+  le corps de la note (texte libre, plusieurs lignes possibles), un bouton
+  « Capturer ». Aucun autre champ à ce stade (pas de priorité, pas de points,
+  pas d'échéance) — c'est la différence avec la capture de tâche de la vue
+  Jour.
+- Juste sous la capture, la liste des notes non traitées (« Notes »), la plus
+  récente en tête, jamais masquée derrière un `<details>` — état vide explicite
+  (« Rien en attente ») si la liste est vide, même principe que la boîte de
+  réception de la vue Jour.
+- Chaque note affiche trois actions :
+  - **→ Tâche** : convertit la note en tâche titre-seul (elle atterrit dans la
+    boîte de réception de la vue Jour, à qualifier comme n'importe quelle autre
+    capture) ; la note elle-même est retirée de la liste active mais **jamais
+    supprimée** — retrouvable dans « Traité / archivé », avec un lien vers la
+    tâche créée.
+  - **Archiver** : classe la note sans suite (pas de tâche créée), même sort
+    que ci-dessus côté visibilité (retirée de la liste active, conservée en
+    historique).
+  - **Supprimer** : suppression définitive, avec confirmation.
+- Une section repliée par défaut, « Traité / archivé (N) », liste les notes
+  converties ou classées sans suite — chacune avec son texte (atténué) et, si
+  elle a été convertie, un lien « → voir la tâche créée » vers la boîte de
+  réception de la vue Jour.
+- La capture et les trois actions par note fonctionnent en amélioration
+  progressive (AJAX si JavaScript actif, requête POST classique + redirection
+  sinon) — même contrat que la vue Jour, JavaScript n'est jamais un prérequis.
+- Ctrl/Cmd+Entrée dans le champ de capture soumet directement le formulaire,
+  sans avoir à atteindre le bouton à la souris.
+- Une sixième entrée de navigation, « Notes », apparaît entre Accueil et Jour
+  (topnav desktop et bottom nav Android) — l'ordre reflète le flux GTD :
+  capturer avant de traiter.
+
+### Critères de succès
+
+- Une note créée (corps non vide) apparaît immédiatement dans la liste des
+  notes actives, sans rechargement de page si le JS est actif ; identique
+  après un rechargement complet sinon.
+- Convertir une note crée une tâche dont le titre est la **première ligne non
+  vide** du corps de la note (les lignes suivantes, s'il y en a, ne sont
+  reprises nulle part dans le titre) ; cette tâche apparaît dans la boîte de
+  réception de la vue Jour (`GET /kairos`), sans priorité ni points, comme
+  toute capture titre-seul.
+- Une note convertie ou archivée disparaît de la liste active et réapparaît
+  dans « Traité / archivé », jamais supprimée.
+- Une note supprimée ne réapparaît nulle part, y compris dans l'historique
+  archivé.
+- La page reste intégralement utilisable JavaScript désactivé.
+- L'entrée « Notes » de la navigation est mise en évidence uniquement sur
+  `/kairos/notes`, sur aucune autre page.
+
+### Hors périmètre / différé
+
+- Édition du corps d'une note existante depuis l'UI (la route `POST
+  /kairos/notes/{id}/edit` existe côté serveur, prête à être branchée, mais
+  aucun formulaire de `_notes_list.html` ne l'appelle à ce stade — pas de
+  bouton « éditer » dans cette première version).
+- Priorité, points Fibonacci, échéance, tag de projet sur une note : ces
+  champs n'existent que sur `Task`, posés **après** conversion, jamais avant.
+  Une note qui a besoin d'un de ces champs doit d'abord être convertie.
+- Recherche, filtres, tri autre que « plus récent d'abord » : périmètre
+  minimal, symétrique de la boîte de réception (elle-même sans recherche
+  dédiée, juste un état trié par urgence).
+- **Aucune synchronisation temps réel entre onglets, aucun polling, aucun
+  WebSocket, aucun push serveur.** Comme le reste de l'application — Kairos est
+  mono-utilisateur et local, la cohérence entre un swap AJAX et un rechargement
+  complet suffit (même contrainte que documentée pour la vue Jour, voir
+  `docs/spec/vue-jour-gtd.md` § Besoin métier : « l'app est mono-utilisateur et
+  locale : pas de sync temps réel entre onglets »). Deux onglets Notes ouverts
+  simultanément peuvent afficher un état divergent jusqu'au prochain
+  rechargement de chacun — ce n'est pas un défaut à corriger.
+- Notification, rappel, ou tout mécanisme qui pousserait une note non traitée
+  vers l'utilisateur : la page Notes est un lieu qu'on consulte, pas un canal
+  qui sollicite.
+
+---
+
+## 2. Solution technique
+
+### Modèle — `Note` (`app/tasks_models.py`)
+
+Table `note`, cinq champs propres (voir `docs/spec/modele-donnees.md` pour le
+détail exhaustif type par type) :
+
+- `id`, `body` (`Text`, défaut `""`),
+- `status` (`'open' | 'archived'`, défaut `'open'`, indexé),
+- `converted_task_id` (`int | None`, **sans contrainte `ForeignKey`** — même
+  parti pris que `Task.parent_id`/`Task.linked_ticket_id`),
+- `created_at`/`updated_at` (mêmes `_now`/`onupdate=_now` que `Task`).
+
+Nouvelle table : `TasksBase.metadata.create_all()` la crée sur toute base
+existante sans migration additive dédiée — vérifié dans
+`app/tasks_db.py::init_tasks_db` (`_TASKS_MIGRATION_COLUMNS` ne référence que
+des colonnes ajoutées à une table **déjà existante** ; une table entièrement
+nouvelle n'a besoin d'aucune entrée). Une note d'exemple est ajoutée par
+`app/tasks_seed.py::seed_example_data` (même garde-fou de première utilisation
+que le reste des exemples : posée une seule fois, sur base vierge).
+
+### Architecture de rendu (mirror du patron « Kairos »)
+
+Même contrat que `_build_kairos_context`/`render_kairos_response`/
+`_kairos_action_response` (`docs/spec/vue-jour-gtd.md` § Architecture de
+rendu), avec son propre jeu de fonctions, **jamais réutilisé/étendu** — deux
+patrons parallèles plutôt qu'un patron générique paramétré, pour rester lisible
+sans abstraction prématurée sur deux domaines qui n'ont en commun que la forme
+du contrat, pas les données :
+
+- `_build_notes_context(request, tasks_session)` — construit `open_notes`
+  (`status == 'open'`, triées `created_at` décroissant) et `archived_notes`
+  (`status == 'archived'`, même tri), plus `"page": "notes"`.
+- `render_notes_response(request, *, fragment)` — ouvre sa **propre** session
+  tâches via `_request_session(get_tasks_session)`, construit le contexte,
+  rend `notes.html` (`fragment=False`) ou `_notes_list.html`
+  (`fragment=True`).
+- `_notes_action_response(request)` — si `X-Requested-With: fetch`, renvoie
+  `render_notes_response(request, fragment=True)` ; sinon
+  `RedirectResponse("/kairos/notes", status_code=303)`.
+- `templates/notes.html` étend `base.html`, contient l'encart de capture
+  (`<form action="/kairos/notes" data-ajax>`) **hors** de `<div
+  id="mj-notes-content">{% include "_notes_list.html" %}</div>` — même
+  principe d'enveloppe unique que `#mj-day-content`
+  (`docs/spec/vue-jour-gtd.md`) : `#mj-notes-content` n'existe qu'à cet unique
+  endroit dans toute l'app, jamais posé par `_notes_list.html` lui-même (qui
+  doit rester rendable tel quel, en fragment autonome, par
+  `render_notes_response(fragment=True)`).
+
+### Routes (`app/main.py`)
+
+| Route | Handler | Effet |
+| --- | --- | --- |
+| `GET /kairos/notes` | `notes_page` | Page pleine (`render_notes_response(fragment=False)`). |
+| `POST /kairos/notes` | `create_note` | Corps strippé ; si non vide, crée une `Note`. Corps vide → no-op silencieux (pas d'erreur, juste rien créé), même tolérance que `create_native_task` sur un titre vide. |
+| `POST /kairos/notes/{id}/edit` | `edit_note` | Remplace `body`. Note disparue → no-op. Pas de formulaire client à ce stade (voir Hors périmètre). |
+| `POST /kairos/notes/{id}/convert` | `convert_note_to_task` | Si la note est `open` et que sa première ligne non vide n'est pas vide : crée `Task(title=<première ligne, ≤200 caractères>, source="native")`, `tasks_session.flush()` pour obtenir l'id, puis `note.status = "archived"` et `note.converted_task_id = task.id`. Une note déjà `archived` ou introuvable → no-op. |
+| `POST /kairos/notes/{id}/archive` | `archive_note` | `status = "archived"`, sans toucher à `converted_task_id` (reste `None`). |
+| `POST /kairos/notes/{id}/delete` | `delete_note` | Suppression définitive de la ligne — à la différence de `delete_task` (qui archive une tâche non native), une note n'a **aucun** historique de priorisation à préserver : la suppression est donc toujours dure, jamais un archivage déguisé. |
+
+Chaque handler POST ouvre sa **propre** session (`_request_session
+(get_tasks_session)`), committe, la ferme (fin du bloc `with`) avant d'appeler
+`_notes_action_response` — même invariant « jamais de session imbriquée » que
+la vue Jour.
+
+`_note_title_from_body(body)` — fonction pure : première ligne dont
+`.strip()` est non vide (une note commençant par des lignes blanches ne donne
+donc pas un titre vide tant qu'une ligne non blanche suit), tronquée à 200
+caractères. Choix de la limite : `Task.title` est `String(512)`, mais une
+capture rapide n'a structurellement pas besoin d'en approcher le quart — 200
+caractères couvre largement une phrase de titre sans jamais tronquer
+silencieusement un texte court.
+
+### Templates
+
+**`templates/notes.html`** — `{% extends "base.html" %}`, `{% block
+topbar_title %}Notes{% endblock %}`. Encart de capture en `.panel` (padding
+intégré, pas besoin d'une classe dédiée) : `<textarea name="body" required>` +
+`<button class="btn primary">`. Script `{% block scripts %}` **autonome**, ne
+réutilise ni ne modifie le script de `kairos.html` — deux pages indépendantes
+(voir « Décisions et pièges tracés » pour la justification) :
+- Écouteur `submit` délégué sur `document`, portée sur `form.matches
+  ('[data-ajax]')` **et** (le formulaire est la capture, identifiée par `id
+  ="mj-note-capture"`, **ou** il est un descendant de `#mj-notes-content`) —
+  condition nécessaire car la capture vit **hors** du conteneur qui est
+  remplacé par le swap (voir ci-dessus), contrairement aux trois
+  mini-formulaires par note.
+- Sur succès : remplace `#mj-notes-content`.innerHTML par le fragment reçu ;
+  si le formulaire intercepté était la capture, appelle en plus `form.reset()`
+  (le formulaire de capture n'étant pas remplacé par le swap, sa `<textarea>`
+  ne se vide pas toute seule — contrairement à un mini-formulaire de note, qui
+  disparaît avec le reste du fragment remplacé).
+- Sur échec (réseau, ou `#mj-notes-content` introuvable) : repli
+  `form.submit()`.
+- Écouteur `keydown` délégué : `Ctrl`/`Cmd`+`Entrée` dans la `<textarea>` de
+  capture (`#mj-note-capture textarea`) appelle `form.requestSubmit()` (repli
+  `form.submit()`).
+
+**`templates/_notes_list.html`** — fragment, deux sections :
+1. `<section class="card" id="mj-notes-open">` — liste `open_notes` en
+   `<ul class="kairos-list"><li class="kairos-item">`, corps de note en
+   `<p style="white-space:pre-wrap">{{ note.body }}</p>` (échappement Jinja
+   par défaut, **jamais** `| safe` — texte utilisateur brut, seuls les retours
+   à la ligne sont préservés visuellement via `white-space: pre-wrap`, pas de
+   rendu HTML/Markdown). État vide explicite (`.hint`) si `open_notes` est
+   vide.
+2. `<details class="card"><summary class="collapser">` — `archived_notes`,
+   repliée par défaut, même patron que `_kairos_backlog.html`/les sections
+   secondaires de `_kairos_day.html` (chevron `icon('chevron_right', '')` +
+   compte dans le `<summary>`). N'est rendue **que si** `archived_notes` est
+   non vide (contrairement à la section « Notes » actives, toujours rendue) —
+   cohérent avec le patron déjà en place pour le Backlog et les sections
+   condensées de la vue Jour, qui ne s'affichent elles aussi que si non vides.
+   Une note convertie affiche un lien `<a class="badge info"
+   href="/kairos#mj-inbox">→ voir la tâche créée</a>` — ancre vers `#mj-inbox`
+   (id déjà posé par `_kairos_day.html`, voir `vue-jour-gtd.md`), pas une
+   requête ni un identifiant de tâche direct : l'utilisateur atterrit sur la
+   boîte de réception de la vue Jour et repère la tâche par son titre (pas de
+   sur-ingénierie pour scroller/mettre en évidence la ligne exacte, la boîte
+   de réception reste courte par construction).
+
+### Décisions et pièges tracés
+
+- **Deux patrons de rendu parallèles (Notes / Kairos), pas un patron
+  générique partagé.** `_build_notes_context`/`render_notes_response`/
+  `_notes_action_response` reproduisent volontairement la forme de
+  `_build_kairos_context`/`render_kairos_response`/`_kairos_action_response`
+  sans jamais les appeler ni en dépendre : les deux domaines (notes, tâches)
+  n'ont en commun que le contrat HTTP (négociation `X-Requested-With`,
+  fragment vs page pleine), pas les données ni les règles métier. Factoriser
+  aurait introduit un paramètre générique (quel gabarit, quelle session,
+  quelle redirection) pour un gain de duplication minime (une dizaine de
+  lignes par fonction) — jugé net-négatif en lisibilité pour un dépôt qui
+  privilégie déjà la duplication explicite à l'abstraction prématurée
+  ailleurs (voir `_kairos_action_response`, commenté comme la réponse des
+  « handlers d'action » de son seul domaine).
+- **Script de `notes.html` autonome, jamais un import/une extension du script
+  de `kairos.html`.** Les deux pages n'ont qu'un seul point commun réel
+  (intercepter un `<form data-ajax>` et swapper un conteneur) : dupliquer ces
+  ~20 lignes reste plus simple à suivre que d'extraire une fonction partagée
+  qui devrait alors être paramétrée par l'id du conteneur cible et le
+  comportement de repli de la capture (qui n'existe que côté Notes, `kairos.
+  html` n'a pas de formulaire `data-ajax` hors de `#mj-day-content` — voir
+  `vue-jour-gtd.md` § Mises à jour AJAX : seules des actions rapides *à
+  l'intérieur* du fragment portent `data-ajax` côté Kairos).
+- **Suppression toujours dure pour une note, jamais un archivage déguisé.**
+  Contrairement à `delete_task` (qui archive une tâche non native pour ne pas
+  perdre l'historique de priorisation posé dessus), une note n'a par
+  construction aucune priorité, aucun point, aucun historique de tri à
+  préserver — la distinguer d'un archivage (qui reste, lui, la voie choisie
+  pour une conversion ou un classement sans suite) aurait ajouté une nuance
+  sans bénéfice utilisateur identifié.
+- **Pas de bouton d'édition câblé dans `_notes_list.html`, alors que la route
+  existe.** `POST /kairos/notes/{id}/edit` a été ajoutée pour rester
+  symétrique du contrat de base (et pour ne pas fermer la porte à un futur
+  bouton crayon, sur le modèle de `edit_panel` côté tâches), mais aucune
+  maquette n'exigeait l'édition en place pour cette première version — mieux
+  vaut une route prête et non branchée qu'une fonctionnalité UI à moitié
+  finie. Documenté explicitement en « Hors périmètre » plutôt que laissé
+  comme un oubli silencieux.
+- **`Note.converted_task_id` sans contrainte `ForeignKey`.** Même parti pris
+  que tout le reste du schéma tâches (`Task.parent_id`, `TaskDependency.
+  blocker_id`, `Task.linked_ticket_id`) — voir `docs/spec/modele-donnees.md`
+  § Décisions et pièges tracés pour la justification consolidée (référence
+  « molle », intégrité laissée au code applicatif). `convert_note_to_task` est
+  la seule route qui écrit ce champ ; aucune route ne le lit pour autre chose
+  qu'afficher le lien « → voir la tâche créée ».
+
+### Invariants et garde-fous
+
+- Un seul `id="mj-notes-content"` dans toute l'application, posé uniquement
+  par `notes.html` — jamais par `_notes_list.html`, qui doit rester rendable
+  tel quel, sans enveloppe, comme fragment AJAX autonome (même invariant que
+  `#mj-day-content`/`_kairos_day.html`).
+- Toute route d'action Notes ouvre sa **propre** session `tasks_session`,
+  committe, **ferme** cette session avant d'appeler `_notes_action_response`
+  (qui rouvre une session fraîche) — jamais de session imbriquée.
+- `create_note`/`edit_note` ne rejettent jamais un corps non vide, quelle que
+  soit sa longueur (pas de limite de caractères côté capture, contrairement au
+  titre tronqué à la conversion) — cohérent avec l'objectif « capturer sans
+  friction », aucune validation qui pourrait bloquer une capture rapide.
+- `convert_note_to_task` ne convertit jamais une note déjà `archived` une
+  deuxième fois (`note.status == "open"` est une condition explicite du
+  handler) — évite de créer une deuxième tâche à partir de la même note sur un
+  double clic ou une requête rejouée.
+- Aucune route Notes ne modifie jamais un objet `Task` en dehors de la
+  création titre-seul de `convert_note_to_task` — la conversion est un point
+  d'entrée à sens unique vers le domaine tâches, jamais l'inverse (aucune
+  route côté tâches ne référence `Note`).
diff --git a/docs/spec/packaging-lancement.md b/docs/spec/packaging-lancement.md
index 1bd55c8..dfc4d2d 100644
--- a/docs/spec/packaging-lancement.md
+++ b/docs/spec/packaging-lancement.md
@@ -2,10 +2,10 @@
 _Rôle : comment Kairos passe d'un dépôt Python à une application qu'on double-clique
 (exécutable Windows/Linux) ou qu'on installe (APK Android), et comment elle démarre
 proprement dans les deux cas. Fichiers couverts : `app/launcher.py`,
-`app/android_launcher.py`, `app/subprocess_env.py`, `packaging/` (`README.md`,
-`kairos.spec`, `smoke_test.py`, `make_icon.py`, `kairos.ico`,
-`android-requirements.txt`), `android/` (renvoi à `docs/ANDROID_PACKAGING.md` pour le
-détail technique)._
+`app/desktop_browser.py`, `app/android_launcher.py`, `app/subprocess_env.py`,
+`packaging/` (`README.md`, `kairos.spec`, `smoke_test.py`, `make_icon.py`,
+`kairos.ico`, `android-requirements.txt`), `android/` (renvoi à
+`docs/ANDROID_PACKAGING.md` pour le détail technique)._
 
 ## 1. Besoin métier (cahier des charges)
 
@@ -26,12 +26,15 @@ exposée sur le réseau par défaut, y compris pendant la phase de lancement.
 
 ### Comportement attendu (utilisateur)
 
-- **Bureau** : double-clic sur l'exécutable → le navigateur par défaut s'ouvre tout
-  seul sur Kairos, sans étape intermédiaire, sans terminal visible. Relancer
-  l'exécutable pendant qu'une instance tourne déjà rouvre simplement le navigateur
-  dessus (pas de deuxième instance, pas de port qui dérive). Un bouton « Quitter »
-  dans l'interface arrête le serveur proprement. En cas d'échec au démarrage, une
-  trace exploitable est disponible sans terminal.
+- **Bureau** : double-clic sur l'exécutable → une fenêtre s'ouvre toute seule sur
+  Kairos, sans étape intermédiaire, sans terminal visible, avec le ressenti d'une
+  application de bureau à part entière (pas de barre d'adresse ni d'onglets — voir
+  « fenêtre d'application » ci-dessous) si un navigateur de la famille Chromium est
+  installé, sinon un onglet du navigateur par défaut s'ouvre normalement. Relancer
+  l'exécutable pendant qu'une instance tourne déjà rouvre simplement cette fenêtre
+  (pas de deuxième instance, pas de port qui dérive). Un bouton « Quitter » dans
+  l'interface arrête le serveur proprement. En cas d'échec au démarrage, une trace
+  exploitable est disponible sans terminal.
 - **Android** : icône dans le tiroir d'applications comme n'importe quelle app. Au
   lancement, l'interface Kairos s'affiche dans l'application elle-même (pas de
   navigateur externe, pas d'onglet). On quitte par les mécanismes système standards
@@ -78,8 +81,9 @@ deux reposent sur un ré-exec du process, impossible dans un exécutable figé o
 app Android).
 
 - **Bureau** (`app/launcher.py`) : cible de `packaging/kairos.spec` (PyInstaller,
-  mode onefile). Choisit un port, pose un verrou d'instance unique, ouvre le
-  navigateur, journalise les crashs.
+  mode onefile). Choisit un port, pose un verrou d'instance unique, ouvre la
+  fenêtre d'application (repli onglet de navigateur si indisponible — voir
+  `app/desktop_browser.py`), journalise les crashs.
 - **Android** (`app/android_launcher.py`) : appelé par l'amorce Chaquopy
   (`android/app/src/main/python/kairos_boot.py`) elle-même pilotée par
   `MainActivity` (Java). Pas de navigateur (WebView), pas de verrou (bac à sable
@@ -133,12 +137,27 @@ spec n'en reprend que ce qui concerne le **lancement** et n'y duplique pas le re
   - `KAIROS_NO_BROWSER` (variable d'environnement) : échappatoire pour les
     lancements automatisés (`packaging/smoke_test.py`) où un vrai navigateur est
     indésirable (processus fantôme sur un runner CI, effets de bord imprévisibles).
+    Reste le tout premier contrôle de `_open_browser` : coupe court avant même la
+    recherche d'un navigateur d'application.
+  - **Fenêtre d'application forcée, avec repli automatique** : `_open_browser`
+    appelle d'abord `find_app_capable_browser()` puis, si un navigateur est trouvé,
+    `launch_app_window(browser_path, url)` (les deux dans `app/desktop_browser.py` —
+    voir détail ci-dessous). Si l'une des deux étapes échoue ou ne trouve rien
+    (aucun navigateur Chromium installé, permission refusée, binaire disparu entre
+    la détection et le lancement...), `_open_browser` retombe silencieusement sur
+    le comportement d'origine : `webbrowser.open` dans un onglet du navigateur par
+    défaut. Aucun réglage utilisateur ne pilote ce choix — voir « Décisions et
+    pièges tracés » pour le pourquoi.
   - `external_process_environ()` (voir `app/subprocess_env.py`) encadre l'appel à
-    `webbrowser.open` : évite qu'un navigateur ou `xdg-open` hérite du
-    `LD_LIBRARY_PATH` détourné par PyInstaller onefile.
-  - `_open_browser_later` : ouvre le navigateur après un délai (`threading.Timer`,
-    1.2 s par défaut) pour laisser le temps à uvicorn de démarrer avant la première
-    requête.
+    `webbrowser.open` du chemin de repli : évite qu'un navigateur ou `xdg-open`
+    hérite du `LD_LIBRARY_PATH` détourné par PyInstaller onefile. Le chemin fenêtre
+    d'application, lui, passe son propre `env=` assaini directement à `Popen` (voir
+    `app/desktop_browser.py::launch_app_window`) plutôt que par ce gestionnaire de
+    contexte, puisque `subprocess.Popen` accepte un `env=` explicite.
+  - `_open_browser_later` : ouvre le navigateur (fenêtre d'application ou onglet de
+    repli, indifféremment — la bascule est interne à `_open_browser`) après un
+    délai (`threading.Timer`, 1.2 s par défaut) pour laisser le temps à uvicorn de
+    démarrer avant la première requête.
 - **`_NullStream` et `_ensure_std_streams`** : sous Windows, un exécutable
   PyInstaller en mode fenêtré (`console=False`) n'a pas de console attachée —
   `sys.stdout`/`sys.stderr` valent `None` plutôt qu'un flux réel. uvicorn plante dès
@@ -164,6 +183,83 @@ spec n'en reprend que ce qui concerne le **lancement** et n'y duplique pas le re
   racine du dépôt est sur `sys.path` (`pathex` du spec, ou le `.pth` du mode
   editable).
 
+#### `app/desktop_browser.py` — fenêtre d'application (bureau uniquement)
+
+Module dédié, séparé de `launcher.py`, pour garder sa logique (détection d'un
+navigateur, construction des arguments de lancement) pure et testable sans toucher
+à uvicorn, aux threads ou au fichier de verrou. Non utilisé côté Android
+(`android_launcher.py` ne lance aucun navigateur externe).
+
+- **`find_app_capable_browser() -> str | None`** : cherche un navigateur de la
+  famille Chromium installé sur le poste (seuls ces navigateurs acceptent
+  l'indicateur `--app=URL` — voir « Décisions et pièges tracés »).
+  - `KAIROS_BROWSER` (variable d'environnement) : si posée, prioritaire sur toute
+    détection automatique. Accepte un chemin de fichier exécutable direct ou un nom
+    résoluble via `shutil.which` (ex. un nom de binaire déjà sur le `PATH`).
+    Échappatoire pour les tests/CI (imposer un binaire précis sans dépendre de
+    l'environnement réel) et pour un utilisateur avancé voulant forcer un
+    navigateur particulier. Documentée ici aux côtés de `KAIROS_NO_BROWSER` pour
+    garder les deux variables d'environnement du lancement bureau au même endroit.
+  - **Linux** (`sys.platform == "linux"`) : `shutil.which(name)` pour chaque nom de
+    la liste `_LINUX_BROWSER_NAMES`, dans l'ordre : `google-chrome-stable`,
+    `google-chrome`, `chromium-browser`, `chromium`, `brave-browser`,
+    `microsoft-edge`, `microsoft-edge-stable`, `vivaldi-stable`, `vivaldi`. Premier
+    trouvé retenu ; l'ordre est arbitraire (pas de hiérarchie qualitative), juste
+    stable pour un comportement déterministe d'un poste à l'autre.
+  - **Windows** (`sys.platform == "win32"`) : teste chaque chemin relatif de
+    `_WINDOWS_BROWSER_RELATIVE_PATHS` (`Google\Chrome\Application\chrome.exe`,
+    `Microsoft\Edge\Application\msedge.exe`,
+    `BraveSoftware\Brave-Browser\Application\brave.exe`,
+    `Vivaldi\Application\vivaldi.exe`) sous chacun des dossiers de base
+    `%ProgramFiles%`, `%ProgramFiles(x86)%`, `%LocalAppData%` (chacun peut être
+    absent de l'environnement — ignoré silencieusement dans ce cas). Les trois bases
+    sont testées pour chaque navigateur (pas de correspondance figée navigateur →
+    base) car une installation « pour tous les utilisateurs » vs « pour
+    l'utilisateur courant » détermine laquelle est utilisée, et ça varie d'un poste
+    à l'autre.
+  - **Autre OS (macOS compris)** : `None` sans détection dédiée — macOS est hors
+    périmètre de Kairos (voir § Hors périmètre plus haut) ; `_open_browser` retombe
+    alors automatiquement sur `webbrowser.open`.
+  - Fonction pure (aucun effet de bord, aucune impression) : testée en
+    monkeypatchant `shutil.which` et les variables d'environnement lues.
+- **`launch_app_window(browser_path: str, url: str) -> bool`** : construit
+  `[browser_path, f"--user-data-dir={profile_dir}", f"--app={url}"]` où
+  `profile_dir = str(data_dir() / "browser-profile")` (voir
+  `app/settings_store.py::data_dir` — même dossier de données que le verrou et le
+  journal de crash du launcher), puis lance ce process via `subprocess.Popen`
+  (`stdin`/`stdout`/`stderr` sur `DEVNULL`, `start_new_session=True`, et
+  `creationflags=subprocess.DETACHED_PROCESS` sous Windows quand cet attribut
+  existe) — détaché complètement, jamais attendu (`Popen` sans `.wait()`), pour ne
+  jamais bloquer ni retenir le process Kairos à la sortie de l'interpréteur.
+  - **Profil de navigateur dédié** (`browser-profile`, sous-dossier de
+    `data_dir()`) : isole la fenêtre d'application du profil personnel de
+    l'utilisateur (onglets, extensions, sessions, historique) — la fenêtre
+    d'application ne doit ni s'y mêler ni en dépendre, et un même profil Chromium
+    ne peut de toute façon pas être ouvert simultanément par deux processus
+    distincts (ce qui rentrerait en conflit avec une session normale déjà ouverte
+    dans ce navigateur).
+  - `env=external_process_env()` (voir `app/subprocess_env.py`, la fonction qui
+    retourne un dict, pas le gestionnaire de contexte `external_process_environ()`
+    utilisé par le chemin `webbrowser.open` — `Popen` accepte un `env=` explicite,
+    pas besoin de basculer temporairement `os.environ` du process courant) : même
+    protection que le chemin de repli contre l'héritage du `LD_LIBRARY_PATH`
+    détourné par PyInstaller onefile.
+  - **Tout l'appel est encadré d'un `try/except Exception`** : sur n'importe quel
+    échec (binaire disparu entre la détection et le lancement, permission refusée,
+    autre surprise), retourne `False` sans rien journaliser (fonctionnalité de
+    confort en arrière-plan, jamais bloquante) plutôt que de laisser l'exception
+    remonter — `_open_browser` retombe alors sur `webbrowser.open`.
+  - Retourne `True` sur un lancement réussi — sans garantie que la fenêtre
+    s'affiche effectivement (le process a démarré, rien de plus n'est vérifié).
+- **Icône de la fenêtre d'application** : `--app=URL` affiche l'icône déclarée par
+  la page elle-même (favicon / manifeste web), pas une icône générique de
+  navigateur. Le `<head>` des templates de bureau référence
+  `static/manifest.webmanifest` et les icônes `static/icon-192.png`,
+  `static/icon-512.png`, `static/apple-touch-icon.png` (générées par
+  `packaging/make_icon.py`, hors périmètre de ce module) — sans ces fichiers, la
+  fenêtre d'application s'affiche quand même (repli sur une icône générique de
+  Chromium), mais sans le rendu « app installée » complet recherché.
+
 #### `app/android_launcher.py` — lancement Android
 
 - Pendant Android de `launcher.py`, en plus simple : pas de navigateur (la WebView de
@@ -219,7 +315,8 @@ spec n'en reprend que ce qui concerne le **lancement** et n'y duplique pas le re
 - **`external_process_env()`** : copie de `os.environ` avec les chemins de
   bibliothèques dynamiques restaurés à leur valeur d'avant PyInstaller (dépile
   `..._ORIG`, ou retire la variable si elle n'existait pas avant) — à passer en
-  `env=` à `subprocess.run`/`Popen` pour un exécutable externe.
+  `env=` à `subprocess.run`/`Popen` pour un exécutable externe. Utilisé par
+  `app/desktop_browser.py::launch_app_window` (fenêtre d'application).
 - **`external_process_environ()`** (context manager) : bascule temporairement
   `os.environ` du process courant sur cet environnement assaini, pour les API qui ne
   permettent pas de passer un `env=` explicite (cas de `webbrowser.open`, utilisé par
@@ -368,6 +465,34 @@ cette spec (pas de duplication du reste) :
 - **`KAIROS_NO_BROWSER`** : échappatoire délibérée pour les lancements automatisés
   (smoke test, CI) — évite un navigateur fantôme sur un runner headless et les
   effets de bord d'un vrai navigateur ouvert pendant un test.
+- **`KAIROS_BROWSER`** : échappatoire similaire, pour imposer un binaire de
+  navigateur précis à `find_app_capable_browser()` plutôt que de dépendre de ce qui
+  est réellement installé sur la machine (tests, CI, ou utilisateur avancé voulant
+  forcer un navigateur particulier). Documentée aux côtés de `KAIROS_NO_BROWSER`
+  pour garder ensemble les deux variables d'environnement qui pilotent le
+  lancement du navigateur bureau.
+- **Fenêtre d'application forcée par défaut, sans réglage utilisateur** : pas de
+  case à cocher dans la page Réglages pour désactiver ce comportement — décision
+  de simplicité assumée. Le risque qu'un tel réglage couvrirait (aucun navigateur
+  Chromium disponible, ou son lancement échoue) est déjà couvert automatiquement
+  par le repli silencieux vers `webbrowser.open` : un réglage n'ajouterait qu'une
+  option de plus à maintenir et à expliquer, sans bénéfice utilisateur réel
+  (l'app se dégrade déjà proprement toute seule).
+- **Seule la famille Chromium est ciblée pour la fenêtre d'application** (pas
+  Firefox, pas Safari) : ces navigateurs n'ont pas d'indicateur de ligne de
+  commande strictement équivalent à `--app=URL` (mode sans barre d'adresse ni
+  onglets, fenêtre dédiée à une seule origine) — Firefox n'expose ce type de mode
+  qu'au travers d'extensions tierces ou d'un profil dédié bien plus lourd à
+  provisionner, hors périmètre pour ce gain de confort. Un poste sans navigateur
+  Chromium installé retombe simplement sur l'onglet de navigateur par défaut
+  (comportement d'origine), jamais une erreur.
+- **Profil de navigateur dédié (`data_dir() / "browser-profile"`)** pour la
+  fenêtre d'application (`app/desktop_browser.py::launch_app_window`) : isolation
+  du profil personnel de l'utilisateur (extensions, sessions, historique,
+  cookies) — la fenêtre d'application ne doit ni les lire ni les modifier, et
+  ouvrir le profil normal de l'utilisateur simultanément par un second process
+  Chromium échouerait de toute façon (un profil ne s'ouvre pas deux fois en
+  parallèle).
 - **Pas de `reload`/`workers>1` dans aucun des deux `uvicorn.run`** : ces options
   reposent toutes deux sur un ré-exec du process (rechargeur, workers multiples),
   incompatible avec un exécutable figé (PyInstaller) ou une application Android.
diff --git a/docs/spec/vue-jour-gtd.md b/docs/spec/vue-jour-gtd.md
index c43b153..078c9ae 100644
--- a/docs/spec/vue-jour-gtd.md
+++ b/docs/spec/vue-jour-gtd.md
@@ -32,7 +32,9 @@ chrono vivant + alertes → `docs/spec/temps-reel-chrono.md` ; dépendances/bloq
 récurrence (tâches et blocs) → `docs/spec/recurrence.md` ; vue Semaine détaillée et
 `/kairos/stats` → `docs/spec/statistiques.md` ; TimeTree/GitLab →
 `docs/spec/integrations-externes.md` ; réglages → `docs/spec/reglages-secrets.md` ;
-`base.html`/topnav/accueil → `docs/spec/accueil-navigation.md`.
+`base.html`/topnav/accueil → `docs/spec/accueil-navigation.md` ; capture GTD en
+amont de la boîte de réception (page Notes, `/kairos/notes`) →
+`docs/spec/notes-capture.md`.
 
 ---
 
@@ -140,6 +142,11 @@ aller-retour (infos, sous-tâches en lot, bloqueurs, épinglage).
   `docs/spec/integrations-externes.md`.
 - Réglages, secrets, page `/kairos/settings` → `docs/spec/reglages-secrets.md`.
 - `base.html`, topnav, page d'accueil → `docs/spec/accueil-navigation.md`.
+- La page Notes (`/kairos/notes`), mécanisme de capture GTD **en amont** de la
+  boîte de réception décrite ci-dessous (§ 2) — une note se convertit en tâche
+  titre-seul, qui atterrit alors dans cette même boîte de réception, mais la
+  capture, l'édition et l'archivage d'une note n'ont pas leur place ici →
+  `docs/spec/notes-capture.md`.
 
 ---
 
@@ -240,6 +247,11 @@ Qualification en ligne :
   faire disparaître la section — rappel volontaire de « où regarder en premier ».
 - Une aide repliable (`.mj-help`, motif réutilisé de `fibo_help()`) explique le
   principe GTD directement dans le `<summary>` (« pourquoi qualifier ? »).
+- **Alimentation en amont, hors de cette spec** : une tâche titre-seul peut venir
+  directement de la capture de cette vue (§ 1) **ou** d'une conversion depuis la
+  page Notes (`POST /kairos/notes/{id}/convert`, `docs/spec/notes-capture.md`) —
+  les deux chemins produisent le même objet (`Task(source="native")`, ni
+  priorité ni points), indiscernable ici une fois créé.
 
 **3. « Maintenant »** (`.mj-progress`) — `next_up_task` (calculé côté serveur) =
 `schedule.scheduled[0].task` si l'agenda a une première entrée planifiée, sinon
diff --git a/packaging/make_icon.py b/packaging/make_icon.py
index 89cfaa0..855546d 100644
--- a/packaging/make_icon.py
+++ b/packaging/make_icon.py
@@ -1,4 +1,5 @@
-"""Génère `packaging/kairos.ico` (icône de l'exécutable Windows) à partir du logo
+"""Génère `packaging/kairos.ico` (icône de l'exécutable Windows) et les icônes
+PNG pour la web app (favicons, apple-touch-icon, manifest) à partir du logo
 de l'application — le même dessin que `static/favicon.svg` et le bandeau
 d'accueil : cadran crème cerclé, secteur orange (l'aiguille qui balaie 12h→2h),
 point sombre au centre.
@@ -9,9 +10,13 @@
 
     python packaging/make_icon.py
 
-L'icône générée est commitée (asset binaire) et référencée par
+L'icône `.ico` générée est commitée (asset binaire) et référencée par
 `packaging/kairos.spec` (paramètre `icon=` de `EXE`, embarqué dans le .exe
 Windows ; ignoré sans erreur pour le binaire Linux, qui ne porte pas d'icône).
+
+Les PNG générés (`static/icon-192.png`, `static/icon-512.png`,
+`static/apple-touch-icon.png`) sont liés depuis `templates/base.html` et
+embarqués dans toutes les distributions (dev, PyInstaller, Android APK).
 """
 
 from __future__ import annotations
@@ -68,6 +73,29 @@ def render_master() -> Image.Image:
     return img
 
 
+def write_png_icons(master: Image.Image) -> None:
+    """Génère les icônes PNG pour la web app à partir de l'image maître.
+
+    Redimensionne l'image maître (2560×2560) en trois tailles standard :
+    - 192×192 pour `icon-192.png` (web manifest)
+    - 512×512 pour `icon-512.png` (web manifest, splash screens)
+    - 180×180 pour `apple-touch-icon.png` (iOS home screen)
+    """
+    static_dir = Path(__file__).resolve().parent.parent / "static"
+
+    png_configs = [
+        (192, "icon-192.png"),
+        (512, "icon-512.png"),
+        (180, "apple-touch-icon.png"),
+    ]
+
+    for size, filename in png_configs:
+        resized = master.resize((size, size), Image.LANCZOS)
+        out_path = static_dir / filename
+        resized.save(out_path, format="PNG")
+        print(f"Icône PNG écrite : {out_path}")
+
+
 def main() -> None:
     master = render_master()
     out_path = Path(__file__).resolve().parent / "kairos.ico"
@@ -83,6 +111,7 @@ def main() -> None:
         append_images=frames[1:],
     )
     print(f"Icône écrite : {out_path}")
+    write_png_icons(master)
 
 
 if __name__ == "__main__":
diff --git a/static/apple-touch-icon.png b/static/apple-touch-icon.png
new file mode 100644
index 0000000..75d2b0f
Binary files /dev/null and b/static/apple-touch-icon.png differ
diff --git a/static/icon-192.png b/static/icon-192.png
new file mode 100644
index 0000000..050d32e
Binary files /dev/null and b/static/icon-192.png differ
diff --git a/static/icon-512.png b/static/icon-512.png
new file mode 100644
index 0000000..bccec64
Binary files /dev/null and b/static/icon-512.png differ
diff --git a/static/manifest.webmanifest b/static/manifest.webmanifest
new file mode 100644
index 0000000..761fd95
--- /dev/null
+++ b/static/manifest.webmanifest
@@ -0,0 +1,12 @@
+{
+  "name": "Kairos",
+  "short_name": "Kairos",
+  "start_url": "/",
+  "display": "standalone",
+  "background_color": "#F3F5F8",
+  "theme_color": "#F3F5F8",
+  "icons": [
+    {"src": "/static/icon-192.png", "sizes": "192x192", "type": "image/png"},
+    {"src": "/static/icon-512.png", "sizes": "512x512", "type": "image/png"}
+  ]
+}
diff --git a/templates/_icons.html b/templates/_icons.html
index 668f844..46dd5ab 100644
--- a/templates/_icons.html
+++ b/templates/_icons.html
@@ -160,6 +160,11 @@
     <circle cx="8" cy="10.5" r="1.5" fill="currentColor" stroke="none"/>
     <line x1="12" y1="2.5" x2="12" y2="13.5"/>
     <circle cx="12" cy="7.5" r="1.5" fill="currentColor" stroke="none"/>
+  {%- elif name == 'notes' -%}
+    <rect x="2.5" y="2" width="11" height="12" rx="1.5"/>
+    <line x1="5" y1="5.8" x2="11" y2="5.8"/>
+    <line x1="5" y1="8.4" x2="11" y2="8.4"/>
+    <line x1="5" y1="11" x2="9" y2="11"/>
   {%- else -%}
     <circle cx="8" cy="8" r="5.5"/>
   {%- endif -%}
diff --git a/templates/_notes_list.html b/templates/_notes_list.html
new file mode 100644
index 0000000..40737a4
--- /dev/null
+++ b/templates/_notes_list.html
@@ -0,0 +1,78 @@
+{# Partiel de la page Notes : rendu à l'intérieur de `#mj-notes-content` par
+   `notes.html` (page pleine, `{% include %}`) ET rendu directement, sans
+   enveloppe, par `render_notes_response(fragment=True)` pour les réponses AJAX
+   (voir app/main.py) — même patron que `_kairos_day.html`/`#mj-day-content`
+   (docs/spec/vue-jour-gtd.md), un seul `id="mj-notes-content"` dans toute
+   l'app, posé par `notes.html`, jamais ici. #}
+{% from "_icons.html" import icon %}
+
+{# Notes ouvertes (capture active) : jamais masquées derrière un <details>, état
+   vide explicite si la liste est vide — même principe que la boîte de réception
+   de la vue Jour (`.mj-inbox-empty`, docs/spec/vue-jour-gtd.md). #}
+<section class="card" id="mj-notes-open" style="padding:1rem 1.1rem;">
+  <div class="mj-section-head">
+    <span class="mj-section-title">Notes <span class="count">({{ open_notes|length }})</span></span>
+  </div>
+  {% if not open_notes %}
+  <p class="hint">{{ icon('check_circle') }} Rien en attente : la capture est vide.</p>
+  {% else %}
+  <ul class="kairos-list">
+    {% for note in open_notes %}
+    <li class="kairos-item" style="align-items:flex-start;">
+      <p style="flex:0 0 100%;margin:0;white-space:pre-wrap;color:var(--text);">{{ note.body }}</p>
+      <span class="muted" style="font-size:11px;">{{ note.created_at.strftime('%d/%m %Hh%M') }}</span>
+      <span class="mj-actions">
+        <form method="post" action="/kairos/notes/{{ note.id }}/convert" class="inline" data-ajax>
+          <button type="submit" class="btn sm" title="Convertir en tâche (arrive titre-seul dans la boîte de réception de la vue Jour)">
+            {{ icon('arrow_up_right') }} Tâche</button>
+        </form>
+        {# Panneau d'édition flottant : même patron que edit_panel() de
+           _kairos_macros.html (.mj-edit/.mj-edit-toggle/.mj-edit-body), seule
+           vraie modale de l'app (voir CLAUDE.md § Forme & effets) — réutilisée
+           telle quelle pour la cohérence visuelle, avec un gestionnaire JS
+           propre à notes.html (page indépendante, pas de dépendance à
+           kairos.html). #}
+        <span class="mj-edit">
+          <button type="button" class="icbtn mj-edit-toggle" title="Modifier" aria-expanded="false">{{ icon('pencil') }}</button>
+          <div class="mj-edit-body" hidden>
+            <form method="post" action="/kairos/notes/{{ note.id }}/edit" class="mj-edit-form" data-ajax>
+              <label>Note<textarea name="body" rows="4" required>{{ note.body }}</textarea></label>
+              <div class="mj-edit-row">
+                <button type="submit" class="btn sm primary">{{ icon('save') }} Enregistrer</button>
+              </div>
+            </form>
+          </div>
+        </span>
+        <form method="post" action="/kairos/notes/{{ note.id }}/archive" class="inline" data-ajax>
+          <button type="submit" class="btn sm" title="Archiver sans en faire une tâche">{{ icon('folder') }} Archiver</button>
+        </form>
+        <form method="post" action="/kairos/notes/{{ note.id }}/delete" class="inline" data-ajax
+              onsubmit="return confirm('Supprimer cette note définitivement ?');">
+          <button type="submit" class="btn sm danger" title="Supprimer définitivement">{{ icon('trash') }} Supprimer</button>
+        </form>
+      </span>
+    </li>
+    {% endfor %}
+  </ul>
+  {% endif %}
+</section>
+
+{# Traité / archivé : notes converties (avec lien vers la tâche créée) ou classées
+   sans suite, repliées par défaut — même motif que le Backlog/les sections
+   secondaires de la vue Jour (`<details class="card">` + `.collapser`). #}
+{% if archived_notes %}
+<details class="card">
+  <summary class="collapser">{{ icon('chevron_right', '') }} Traité / archivé ({{ archived_notes|length }})</summary>
+  <ul class="kairos-list" style="padding:0 1.1rem 0.9rem;">
+    {% for note in archived_notes %}
+    <li class="kairos-item" style="align-items:flex-start;">
+      <p class="muted" style="flex:0 0 100%;margin:0;white-space:pre-wrap;">{{ note.body }}</p>
+      <span class="muted" style="font-size:11px;">{{ note.created_at.strftime('%d/%m %Hh%M') }}</span>
+      {% if note.converted_task_id %}
+      <a class="badge info" href="/kairos#mj-inbox">{{ icon('arrow_up_right') }} voir la tâche créée</a>
+      {% endif %}
+    </li>
+    {% endfor %}
+  </ul>
+</details>
+{% endif %}
diff --git a/templates/base.html b/templates/base.html
index d33a435..3eb7d9c 100644
--- a/templates/base.html
+++ b/templates/base.html
@@ -5,6 +5,11 @@
   <meta name="viewport" content="width=device-width, initial-scale=1">
   <title>{% block title %}Kairos{% endblock %}</title>
   <link rel="icon" href="/static/favicon.svg?v={{ asset_version }}" type="image/svg+xml">
+  <link rel="manifest" href="/static/manifest.webmanifest">
+  <link rel="icon" type="image/png" sizes="192x192" href="/static/icon-192.png?v={{ asset_version }}">
+  <link rel="icon" type="image/png" sizes="512x512" href="/static/icon-512.png?v={{ asset_version }}">
+  <link rel="apple-touch-icon" href="/static/apple-touch-icon.png?v={{ asset_version }}">
+  <meta name="theme-color" content="#F3F5F8">
   <link rel="preconnect" href="https://fonts.googleapis.com">
   <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
   <link href="https://fonts.googleapis.com/css2?family=IBM+Plex+Sans:wght@400;500;600;700&family=Newsreader:ital,wght@1,500&display=swap" rel="stylesheet">
@@ -31,6 +36,8 @@
       <nav class="tn-nav">
         <a class="tn-item {% if page == 'home' %}active{% endif %}" href="/">
           {{ icon('home') }}<span>Accueil</span></a>
+        <a class="tn-item {% if page == 'notes' %}active{% endif %}" href="/kairos/notes">
+          {{ icon('notes') }}<span>Notes</span></a>
         <a class="tn-item {% if page == 'kairos' and (view is not defined or view != 'week') %}active{% endif %}" href="/kairos?view=day">
           {{ icon('clock') }}<span>Jour</span></a>
         <a class="tn-item {% if page == 'kairos' and view == 'week' %}active{% endif %}" href="/kairos?view=week">
@@ -63,12 +70,14 @@ <h1>{% block topbar_title %}Kairos{% endblock %}</h1>
     {% if is_android %}
     {# Bottom nav réservée à l'APK Android (`is_android`, posé côté serveur depuis
        KAIROS_PLATFORM — jamais par la largeur de viewport seule, pour ne jamais
-       apparaître sur un navigateur desktop simplement rétréci). Mêmes cinq
+       apparaître sur un navigateur desktop simplement rétréci). Mêmes six
        destinations et mêmes conditions `active` que `.tn-nav` ci-dessus, sans
        dupliquer `.tn-brand`/`.tn-quit`. Voir docs/spec/accueil-navigation.md. #}
     <nav class="bn-nav">
       <a class="bn-item {% if page == 'home' %}active{% endif %}" href="/">
         {{ icon('home') }}<span>Accueil</span></a>
+      <a class="bn-item {% if page == 'notes' %}active{% endif %}" href="/kairos/notes">
+        {{ icon('notes') }}<span>Notes</span></a>
       <a class="bn-item {% if page == 'kairos' and (view is not defined or view != 'week') %}active{% endif %}" href="/kairos?view=day">
         {{ icon('clock') }}<span>Jour</span></a>
       <a class="bn-item {% if page == 'kairos' and view == 'week' %}active{% endif %}" href="/kairos?view=week">
diff --git a/templates/notes.html b/templates/notes.html
new file mode 100644
index 0000000..97c6236
--- /dev/null
+++ b/templates/notes.html
@@ -0,0 +1,103 @@
+{% extends "base.html" %}
+{% from "_icons.html" import icon %}
+{% block title %}Kairos · notes{% endblock %}
+{% block topbar_title %}Notes{% endblock %}
+
+{% block content %}
+
+{# Capture GTD : toujours visible, jamais dans un <details> replié — même
+   principe que `.mj-capture` de la vue Jour (docs/spec/vue-jour-gtd.md § 1) :
+   la capture ne doit jamais demander un clic supplémentaire pour être atteinte.
+   Un seul champ (le corps), volontairement sans autre option — pas de priorité,
+   pas de points, pas d'échéance : ceux-là se posent une fois la note convertie
+   en tâche, dans la boîte de réception de la vue Jour. #}
+<div class="panel">
+  <h2>{{ icon('plus') }} Capturer</h2>
+  <form method="post" action="/kairos/notes" class="filters" style="align-items:flex-end;" id="mj-note-capture" data-ajax>
+    <label style="flex:1;min-width:260px;">Note
+      <textarea name="body" required placeholder="Une idée, un rappel, un « il faudrait que »..." rows="3"
+                style="resize:vertical;"></textarea></label>
+    <button type="submit" class="btn primary">{{ icon('plus') }} Capturer</button>
+  </form>
+  <p class="hint mt-s">Ctrl+Entrée (ou ⌘+Entrée) pour capturer sans quitter le clavier.</p>
+</div>
+
+<div id="mj-notes-content">
+{% include "_notes_list.html" %}
+</div>
+
+{% endblock %}
+
+{% block scripts %}
+<script>
+  /* Amélioration progressive AJAX, patron minimal et autonome (pas de dépendance
+     au script de kairos.html — page indépendante, voir docs/spec/notes-capture.md) :
+     un `<form data-ajax>` intercepté ici est soit le formulaire de capture
+     (au-dessus de `#mj-notes-content`, donc PAS remplacé par le swap — la
+     textarea doit être vidée à la main après succès), soit un des mini-formulaires
+     rendus à l'intérieur de `#mj-notes-content` (convertir/archiver/supprimer,
+     eux remplacés avec le reste du fragment). Repli sans JS (ou en cas d'échec
+     réseau) : soumission HTML classique, POST → redirection 303 côté serveur,
+     identique au comportement de la vue Jour. */
+  document.addEventListener('submit', function (ev) {
+    var form = ev.target;
+    if (!(form instanceof HTMLFormElement) || !form.matches('[data-ajax]')) return;
+    var target = document.getElementById('mj-notes-content');
+    var isCapture = form.id === 'mj-note-capture';
+    if (!isCapture && !(target && target.contains(form))) return;
+    ev.preventDefault();
+    var scrollY = window.scrollY;
+    fetch(form.action, {
+      method: 'POST',
+      body: new FormData(form),
+      headers: { 'X-Requested-With': 'fetch' },
+    }).then(function (res) {
+      if (!res.ok) throw new Error('HTTP ' + res.status);
+      return res.text();
+    }).then(function (html) {
+      if (!target) { form.submit(); return; }
+      target.innerHTML = html;
+      if (isCapture) form.reset(); // le formulaire de capture est hors du swap
+      window.scrollTo(0, scrollY);
+    }).catch(function () {
+      form.submit(); // repli : réseau indisponible, formulaire non intercepté
+    });
+  });
+
+  /* Ctrl/Cmd+Entrée dans la textarea de capture soumet le formulaire — geste
+     GTD classique, éviter d'avoir à lâcher le clavier pour capturer vite. */
+  document.addEventListener('keydown', function (ev) {
+    if (ev.key !== 'Enter' || !(ev.ctrlKey || ev.metaKey)) return;
+    var field = ev.target.closest('#mj-note-capture textarea');
+    if (!field) return;
+    var form = field.closest('form');
+    if (!form) return;
+    ev.preventDefault();
+    if (form.requestSubmit) form.requestSubmit();
+    else form.submit();
+  });
+
+  /* Bascule du panneau d'édition d'une note (.mj-edit/.mj-edit-toggle/
+     .mj-edit-body — même patron que kairos.html, reproduit ici car cette page
+     est volontairement indépendante, sans dépendance à son script). Écoute
+     déléguée sur `document` : fonctionne aussi sur le contenu injecté par un
+     swap AJAX, jamais rebranchée. */
+  document.addEventListener('click', function (ev) {
+    var toggle = ev.target.closest('.mj-edit-toggle');
+    if (!toggle) return;
+    var body = toggle.closest('.mj-edit').querySelector('.mj-edit-body');
+    var opening = body.hidden;
+    body.hidden = !opening;
+    toggle.setAttribute('aria-expanded', String(opening));
+  });
+
+  /* Échap referme le panneau d'édition ouvert. */
+  document.addEventListener('keydown', function (ev) {
+    if (ev.key !== 'Escape') return;
+    var openToggle = document.querySelector('.mj-edit-toggle[aria-expanded="true"]');
+    if (!openToggle) return;
+    openToggle.closest('.mj-edit').querySelector('.mj-edit-body').hidden = true;
+    openToggle.setAttribute('aria-expanded', 'false');
+  });
+</script>
+{% endblock %}
diff --git a/tests/test_kairos_route.py b/tests/test_kairos_route.py
index ed9a8a9..10f61af 100644
--- a/tests/test_kairos_route.py
+++ b/tests/test_kairos_route.py
@@ -2108,7 +2108,9 @@ def test_bottom_nav_shown_when_android(route_client, monkeypatch) -> None:
     resp = client.get("/kairos")
     assert '<nav class="bn-nav">' in resp.text
     assert 'class="layout is-android"' in resp.text
-    assert resp.text.count('class="bn-item') == 5
+    # Six entrées depuis l'ajout de la page Notes (capture GTD) entre Accueil et
+    # Jour — voir docs/spec/accueil-navigation.md et docs/spec/notes-capture.md.
+    assert resp.text.count('class="bn-item') == 6
 
 
 def test_shutdown_route_sends_sigint_to_self(monkeypatch) -> None:
diff --git a/tests/test_launcher.py b/tests/test_launcher.py
index 523854c..d87d136 100644
--- a/tests/test_launcher.py
+++ b/tests/test_launcher.py
@@ -10,6 +10,7 @@
 import sys
 import threading
 
+from app.desktop_browser import find_app_capable_browser, launch_app_window
 from app.launcher import (
     _clear_lock,
     _ensure_std_streams,
@@ -132,6 +133,9 @@ def test_open_browser_uses_sanitized_environment(monkeypatch) -> None:
     monkeypatch.delenv("KAIROS_NO_BROWSER", raising=False)
     monkeypatch.setenv("LD_LIBRARY_PATH", "/tmp/_MEIxxxxxx")
     monkeypatch.delenv("LD_LIBRARY_PATH_ORIG", raising=False)
+    # Aucun navigateur Chromium trouvé : force le repli `webbrowser.open`,
+    # déterministe qu'un Chromium soit installé ou non sur la machine de test.
+    monkeypatch.setattr("app.launcher.find_app_capable_browser", lambda: None)
     seen = {}
 
     def fake_open(url):
@@ -159,7 +163,166 @@ def fake_open(url):
         return True
 
     monkeypatch.setattr("app.launcher.webbrowser.open", fake_open)
+    # Ni la recherche de navigateur d'application ni `webbrowser.open` ne
+    # doivent être tentés : KAIROS_NO_BROWSER coupe tout avant.
+    monkeypatch.setattr(
+        "app.launcher.find_app_capable_browser",
+        lambda: (_ for _ in ()).throw(AssertionError("ne doit pas être appelé")),
+    )
 
     _open_browser("http://127.0.0.1:8001")
 
     assert called is False
+
+
+def test_open_browser_skips_disabled_via_env_without_app_window_attempt(monkeypatch) -> None:
+    """Variante explicite : KAIROS_NO_BROWSER doit rester le tout premier
+    contrôle, avant même la tentative de fenêtre d'application (comportement
+    déjà garanti avant ce module, à ne jamais régresser)."""
+    monkeypatch.setenv("KAIROS_NO_BROWSER", "1")
+    launch_called = False
+
+    def fake_launch(browser_path, url):
+        nonlocal launch_called
+        launch_called = True
+        return True
+
+    monkeypatch.setattr("app.launcher.find_app_capable_browser", lambda: "/usr/bin/chromium")
+    monkeypatch.setattr("app.launcher.launch_app_window", fake_launch)
+    monkeypatch.setattr(
+        "app.launcher.webbrowser.open",
+        lambda url: (_ for _ in ()).throw(AssertionError("ne doit pas être appelé")),
+    )
+
+    _open_browser("http://127.0.0.1:8001")
+
+    assert launch_called is False
+
+
+def test_open_browser_prefers_app_window_and_skips_webbrowser(monkeypatch) -> None:
+    """Quand un navigateur Chromium est trouvé et se lance avec succès,
+    `webbrowser.open` (repli) ne doit jamais être appelé."""
+    monkeypatch.delenv("KAIROS_NO_BROWSER", raising=False)
+    monkeypatch.setattr("app.launcher.find_app_capable_browser", lambda: "/usr/bin/chromium")
+    monkeypatch.setattr("app.launcher.launch_app_window", lambda browser_path, url: True)
+    monkeypatch.setattr(
+        "app.launcher.webbrowser.open",
+        lambda url: (_ for _ in ()).throw(AssertionError("ne doit pas être appelé")),
+    )
+
+    _open_browser("http://127.0.0.1:8001")  # ne doit pas lever
+
+
+def test_open_browser_falls_back_when_no_app_capable_browser_found(monkeypatch) -> None:
+    """Aucun navigateur Chromium détecté : repli automatique sur
+    `webbrowser.open`, comportement d'origine."""
+    monkeypatch.delenv("KAIROS_NO_BROWSER", raising=False)
+    monkeypatch.setattr("app.launcher.find_app_capable_browser", lambda: None)
+    called = False
+
+    def fake_open(url):
+        nonlocal called
+        called = True
+        return True
+
+    monkeypatch.setattr("app.launcher.webbrowser.open", fake_open)
+
+    _open_browser("http://127.0.0.1:8001")
+
+    assert called is True
+
+
+def test_open_browser_falls_back_when_app_window_launch_fails(monkeypatch) -> None:
+    """Un navigateur Chromium est trouvé mais son lancement échoue
+    (`launch_app_window` renvoie `False`) : repli automatique sur
+    `webbrowser.open`, jamais d'erreur remontée."""
+    monkeypatch.delenv("KAIROS_NO_BROWSER", raising=False)
+    monkeypatch.setattr("app.launcher.find_app_capable_browser", lambda: "/usr/bin/chromium")
+    monkeypatch.setattr("app.launcher.launch_app_window", lambda browser_path, url: False)
+    called = False
+
+    def fake_open(url):
+        nonlocal called
+        called = True
+        return True
+
+    monkeypatch.setattr("app.launcher.webbrowser.open", fake_open)
+
+    _open_browser("http://127.0.0.1:8001")
+
+    assert called is True
+
+
+# --- app/desktop_browser.py -------------------------------------------------
+
+
+def test_find_app_capable_browser_returns_none_when_nothing_found(monkeypatch) -> None:
+    monkeypatch.delenv("KAIROS_BROWSER", raising=False)
+    monkeypatch.setattr("app.desktop_browser.sys.platform", "linux")
+    monkeypatch.setattr("app.desktop_browser.shutil.which", lambda name: None)
+
+    assert find_app_capable_browser() is None
+
+
+def test_find_app_capable_browser_returns_first_match_on_linux(monkeypatch) -> None:
+    monkeypatch.delenv("KAIROS_BROWSER", raising=False)
+    monkeypatch.setattr("app.desktop_browser.sys.platform", "linux")
+
+    def fake_which(name):
+        return "/usr/bin/chromium" if name == "chromium" else None
+
+    monkeypatch.setattr("app.desktop_browser.shutil.which", fake_which)
+
+    assert find_app_capable_browser() == "/usr/bin/chromium"
+
+
+def test_find_app_capable_browser_env_override_takes_priority(monkeypatch, tmp_path) -> None:
+    fake_browser = tmp_path / "my-browser"
+    fake_browser.write_text("#!/bin/sh\n", encoding="utf-8")
+    fake_browser.chmod(0o755)
+    monkeypatch.setenv("KAIROS_BROWSER", str(fake_browser))
+
+    def fail_which(name):  # pragma: no cover - ne doit jamais être appelé
+        raise AssertionError("shutil.which ne doit pas être consulté avec KAIROS_BROWSER posé")
+
+    monkeypatch.setattr("app.desktop_browser.shutil.which", fail_which)
+
+    assert find_app_capable_browser() == str(fake_browser)
+
+
+def test_launch_app_window_builds_argv_with_app_and_profile_flags(monkeypatch, tmp_path) -> None:
+    monkeypatch.setattr("app.desktop_browser.data_dir", lambda: tmp_path)
+    seen_argv = {}
+
+    class _FakeProcess:
+        pass
+
+    def fake_popen(argv, **kwargs):
+        seen_argv["argv"] = argv
+        return _FakeProcess()
+
+    monkeypatch.setattr("app.desktop_browser.subprocess.Popen", fake_popen)
+
+    result = launch_app_window("/usr/bin/chromium", "http://127.0.0.1:8001")
+
+    assert result is True
+    argv = seen_argv["argv"]
+    assert argv[0] == "/usr/bin/chromium"
+    assert "--app=http://127.0.0.1:8001" in argv
+    assert any(arg.startswith("--user-data-dir=") for arg in argv)
+    assert any(str(tmp_path) in arg for arg in argv if arg.startswith("--user-data-dir="))
+
+
+def test_launch_app_window_returns_false_and_does_not_raise_on_popen_error(
+    monkeypatch, tmp_path
+) -> None:
+    monkeypatch.setattr("app.desktop_browser.data_dir", lambda: tmp_path)
+
+    def failing_popen(argv, **kwargs):
+        raise OSError("binaire introuvable")
+
+    monkeypatch.setattr("app.desktop_browser.subprocess.Popen", failing_popen)
+
+    result = launch_app_window("/usr/bin/chromium", "http://127.0.0.1:8001")
+
+    assert result is False
diff --git a/tests/test_notes_route.py b/tests/test_notes_route.py
new file mode 100644
index 0000000..65b2faa
--- /dev/null
+++ b/tests/test_notes_route.py
@@ -0,0 +1,215 @@
+"""Tests de la page Notes (capture GTD) : rendu, création, conversion, archivage,
+suppression, contrat AJAX — voir docs/spec/notes-capture.md."""
+
+from __future__ import annotations
+
+import pytest
+from sqlalchemy import create_engine, select
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy.pool import StaticPool
+from starlette.testclient import TestClient
+
+from app import main
+from app.config import Settings
+from app.pilotage_link import PilotageBase
+from app.tasks_models import Note, Task, TasksBase
+
+
+@pytest.fixture
+def route_client(monkeypatch):
+    """Même patron que `tests/test_kairos_route.py::route_client` (bases en
+    mémoire, monkeypatch des fabriques de session) — la page Notes ne dépend que
+    de la base tâches, mais le fixture partagé ouvre aussi la base pilotage pour
+    rester réutilisable telle quelle par d'éventuels tests croisés."""
+    engine = create_engine(
+        "sqlite://", connect_args={"check_same_thread": False}, poolclass=StaticPool
+    )
+    TasksBase.metadata.create_all(engine)
+    TestSession = sessionmaker(bind=engine, expire_on_commit=False)
+
+    ticket_engine = create_engine(
+        "sqlite://", connect_args={"check_same_thread": False}, poolclass=StaticPool
+    )
+    PilotageBase.metadata.create_all(ticket_engine)
+    TicketTestSession = sessionmaker(bind=ticket_engine, expire_on_commit=False)
+
+    def override_tasks_session():
+        db = TestSession()
+        try:
+            yield db
+        finally:
+            db.close()
+
+    def override_session():
+        db = TicketTestSession()
+        try:
+            yield db
+        finally:
+            db.close()
+
+    test_settings = Settings()
+    monkeypatch.setattr(main, "get_settings", lambda: test_settings)
+    monkeypatch.setattr(main, "get_tasks_session", override_tasks_session)
+    monkeypatch.setattr(main, "get_pilotage_session", override_session)
+    client = TestClient(main.app)
+    yield client, TestSession
+
+
+def test_get_notes_returns_200_with_empty_state(route_client) -> None:
+    client, _ = route_client
+    resp = client.get("/kairos/notes")
+    assert resp.status_code == 200
+    assert "Notes" in resp.text
+    assert "Rien en attente" in resp.text
+
+
+def test_post_note_creates_and_shows_it(route_client) -> None:
+    client, TestSession = route_client
+    resp = client.post(
+        "/kairos/notes", data={"body": "Une idée à développer"}, follow_redirects=False
+    )
+    assert resp.status_code == 303
+    with TestSession() as db:
+        notes = list(db.scalars(select(Note)))
+    assert len(notes) == 1
+    assert notes[0].body == "Une idée à développer"
+    assert notes[0].status == "open"
+
+    page = client.get("/kairos/notes")
+    assert "Une idée à développer" in page.text
+
+
+def test_post_note_blank_body_is_ignored(route_client) -> None:
+    client, TestSession = route_client
+    resp = client.post("/kairos/notes", data={"body": "   "}, follow_redirects=False)
+    assert resp.status_code == 303
+    with TestSession() as db:
+        assert list(db.scalars(select(Note))) == []
+
+
+def test_convert_note_creates_task_archives_note_and_appears_in_inbox(route_client) -> None:
+    client, TestSession = route_client
+    with TestSession() as db:
+        note = Note(body="Premier titre\nDeuxième ligne ignorée")
+        db.add(note)
+        db.commit()
+        note_id = note.id
+
+    resp = client.post(f"/kairos/notes/{note_id}/convert", follow_redirects=False)
+    assert resp.status_code == 303
+
+    with TestSession() as db:
+        refreshed = db.get(Note, note_id)
+        assert refreshed.status == "archived"
+        assert refreshed.converted_task_id is not None
+        task = db.get(Task, refreshed.converted_task_id)
+        assert task is not None
+        assert task.title == "Premier titre"
+        assert task.source == "native"
+        # Titre seul : ni priorité, ni points renseignés à la conversion.
+        assert task.priority is None
+        assert task.fibonacci_points is None
+
+    # La tâche créée est titre-seul, donc dans la boîte de réception de « Jour ».
+    day_page = client.get("/kairos")
+    assert "Premier titre" in day_page.text
+
+
+def test_edit_note_updates_body(route_client) -> None:
+    client, TestSession = route_client
+    with TestSession() as db:
+        note = Note(body="Texte original")
+        db.add(note)
+        db.commit()
+        note_id = note.id
+
+    resp = client.post(
+        f"/kairos/notes/{note_id}/edit", data={"body": "Texte corrigé"}, follow_redirects=False
+    )
+    assert resp.status_code == 303
+    with TestSession() as db:
+        assert db.get(Note, note_id).body == "Texte corrigé"
+
+    page = client.get("/kairos/notes")
+    assert "Texte corrigé" in page.text
+    assert "Texte original" not in page.text
+
+
+def test_edit_missing_note_is_a_no_op(route_client) -> None:
+    client, _ = route_client
+    resp = client.post(
+        "/kairos/notes/999/edit", data={"body": "Peu importe"}, follow_redirects=False
+    )
+    assert resp.status_code == 303
+
+
+def test_convert_missing_note_is_a_no_op(route_client) -> None:
+    client, _ = route_client
+    resp = client.post("/kairos/notes/999/convert", follow_redirects=False)
+    assert resp.status_code == 303
+
+
+def test_archive_note(route_client) -> None:
+    client, TestSession = route_client
+    with TestSession() as db:
+        note = Note(body="À classer sans suite")
+        db.add(note)
+        db.commit()
+        note_id = note.id
+
+    resp = client.post(f"/kairos/notes/{note_id}/archive", follow_redirects=False)
+    assert resp.status_code == 303
+    with TestSession() as db:
+        assert db.get(Note, note_id).status == "archived"
+
+    page = client.get("/kairos/notes")
+    assert "Traité / archivé (1)" in page.text
+    assert "À classer sans suite" in page.text
+
+
+def test_delete_note(route_client) -> None:
+    client, TestSession = route_client
+    with TestSession() as db:
+        note = Note(body="À jeter")
+        db.add(note)
+        db.commit()
+        note_id = note.id
+
+    resp = client.post(f"/kairos/notes/{note_id}/delete", follow_redirects=False)
+    assert resp.status_code == 303
+    with TestSession() as db:
+        assert db.get(Note, note_id) is None
+
+
+def test_ajax_fragment_returns_partial_not_full_page(route_client) -> None:
+    resp_client, _ = route_client
+    resp = resp_client.post(
+        "/kairos/notes",
+        data={"body": "Capturée en AJAX"},
+        headers={"X-Requested-With": "fetch"},
+        follow_redirects=False,
+    )
+    assert resp.status_code == 200
+    assert "Capturée en AJAX" in resp.text
+    assert "<!DOCTYPE html>" not in resp.text
+    assert "topnav" not in resp.text
+    assert 'id="mj-notes-content"' not in resp.text  # posé uniquement par notes.html
+
+
+def test_non_ajax_post_redirects_with_303(route_client) -> None:
+    client, _ = route_client
+    resp = client.post(
+        "/kairos/notes", data={"body": "Sans en-tête AJAX"}, follow_redirects=False
+    )
+    assert resp.status_code == 303
+    assert resp.headers["location"] == "/kairos/notes"
+
+
+def test_notes_nav_item_active_only_on_notes_page(route_client) -> None:
+    client, _ = route_client
+    notes_page = client.get("/kairos/notes")
+    assert 'class="tn-item active" href="/kairos/notes"' in notes_page.text
+
+    day_page = client.get("/kairos")
+    assert 'class="tn-item active" href="/kairos/notes"' not in day_page.text
+    assert 'href="/kairos/notes"' in day_page.text  # l'entrée existe, non active