ci(vscode): réutiliser NPM_TOKEN pour l'asset de release du VSIX

Le token Gitea NPM_TOKEN (déjà utilisé pour publier le daemon) a les droits repository
suffisants pour l'API release → pas de secret RELEASE_TOKEN dédié à configurer.

.gitea/workflows/ci.yml

@@ -27,6 +27,7 @@ jobs:
       - run: npm ci
       - run: npm run typecheck
       - run: npm run build
+      - run: npm run build:site
       - run: npx vitest run
 
   pack-smoke:
@@ -41,30 +42,26 @@ jobs:
           cache: npm
       - run: npm ci
       - run: npm run build
-      # @arboretum/shared (dépendance runtime non publiée) est embarquée dans le tarball
+      # @arboretum/shared (paquet workspace NON publié) est INLINÉ dans dist/_shared au prepack
-      # via bundleDependencies (matérialisée au prepack). On packe donc UN SEUL tarball
+      # (scripts/inline-shared.mjs) : le tarball est 100 % autonome — aucun node_modules embarqué,
-      # et on l'installe seul, comme un vrai consommateur depuis le registre.
+      # aucune bundleDependency, aucun symlink. On packe en mode workspace (-w), EXACTEMENT comme
+      # le fait « npm publish » dans release.yml, puis on l'installe seul comme un vrai consommateur.
       - name: Pack tarball
         run: |
           rm -rf /tmp/tarballs && mkdir -p /tmp/tarballs
-          # Le hook prepack (copy-web + vendor-shared + copy-meta) matérialise
+          npm pack -w @johanleroy/git-arboretum --pack-destination /tmp/tarballs
-          # @arboretum/shared comme VRAI dossier dans le node_modules du serveur —
-          # condition pour que npm l'embarque via bundleDependencies. Selon la version
-          # de npm du runner, « npm pack -w » ne déclenche PAS toujours ce lifecycle
-          # (contrairement à « npm publish -w », qui lance bien prepack). On l'exécute
-          # donc explicitement, on vérifie la matérialisation, puis on packe avec
-          # --ignore-scripts (prepack déjà fait, dossier physique présent → bundlé).
-          npm run prepack -w @johanleroy/git-arboretum
-          test -f packages/server/node_modules/@arboretum/shared/dist/index.js \
-            || { echo "ERREUR: prepack n'a pas matérialisé @arboretum/shared/dist/index.js"; exit 1; }
-          npm pack -w @johanleroy/git-arboretum --pack-destination /tmp/tarballs --ignore-scripts
           ls -l /tmp/tarballs
-      - name: Assert @arboretum/shared is bundled in the tarball
+      - name: Assert the package is self-contained (@arboretum/shared inlined)
         run: |
           tgz=$(ls /tmp/tarballs/*.tgz)
-          tar -tzf "$tgz" | grep -q 'node_modules/@arboretum/shared/dist/index.js' \
+          rm -rf /tmp/inspect && mkdir -p /tmp/inspect && tar -xzf "$tgz" -C /tmp/inspect
-            || { echo "ERREUR: @arboretum/shared non embarqué dans $tgz"; exit 1; }
+          test -f /tmp/inspect/package/dist/_shared/index.js \
-          echo "OK: bundleDependency @arboretum/shared présente dans $tgz"
+            || { echo "ERREUR: dist/_shared/index.js absent de $tgz — inline-shared n'a pas tourné ?"; exit 1; }
+          if grep -rq '@arboretum/shared' /tmp/inspect/package/dist; then
+            echo "ERREUR: import bare '@arboretum/shared' encore présent dans le JS publié"
+            grep -rn '@arboretum/shared' /tmp/inspect/package/dist; exit 1
+          fi
+          echo "OK: paquet autonome — shared inliné dans dist/_shared, aucun import externe"
       - name: Install tarball in an empty project
         run: |
           mkdir /tmp/smoke

.gitea/workflows/prod.yml

@@ -0,0 +1,55 @@
+name: Deploy site (production)
+
+# Déploie le site vitrine (packages/site) sur Plesk via FTPS (lftp), à l'identique
+# de lidge_web / tracksniff-web. Ne se déclenche que sur un changement du site.
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - 'packages/site/**'
+      - '.gitea/workflows/prod.yml'
+  workflow_dispatch:
+
+concurrency:
+  group: deploy-site
+  cancel-in-progress: true
+
+jobs:
+  build-and-deploy:
+    runs-on: ubuntu-latest
+    container:
+      image: node:22-bookworm
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      # Install scopé au workspace du site : pas de build des deps natives du
+      # serveur (node-pty / node:sqlite) qui n'ont rien à faire ici.
+      - name: Install deps (@arboretum/site)
+        run: npm install -w @arboretum/site --no-audit --no-fund
+
+      - name: Build site
+        run: npm run build:site
+
+      - name: Check build output
+        run: ls -la packages/site/dist
+
+      - name: Deploy via FTPS (lftp)
+        run: |
+          if [ -z "$REMOTE_PATH" ]; then
+            echo "::error::Secret SITE_REMOTE_PATH manquant (chemin docroot du vhost git-arboretum.com)."
+            exit 1
+          fi
+          apt-get update && apt-get install -y lftp
+          lftp -c "
+          open -u \"$FTP_USER\",\"$FTP_PASSWORD\" \"$FTP_HOST\"
+          set ssl:verify-certificate no
+          mirror -R --delete --verbose packages/site/dist \"$REMOTE_PATH\"
+          "
+        env:
+          FTP_HOST: ${{ secrets.FTP_HOST }}
+          FTP_USER: ${{ secrets.FTP_USER }}
+          FTP_PASSWORD: ${{ secrets.FTP_PASSWORD }}
+          # Chemin docroot du vhost git-arboretum.com sur Plesk (ex. /httpdocs/arboretum/public).
+          REMOTE_PATH: ${{ secrets.SITE_REMOTE_PATH }}

.gitea/workflows/release.yml

@@ -0,0 +1,73 @@
+# Publication du paquet @johanleroy/git-arboretum sur le registre npm du Gitea,
+# déclenchée UNIQUEMENT par un tag vX.Y.Z (jamais sur un push de branche).
+name: Release
+
+on:
+  push:
+    tags: ['v*']
+
+permissions:
+  contents: read
+  packages: write
+
+jobs:
+  publish:
+    name: Publish to Gitea npm registry
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          registry-url: 'https://git.lidge.fr/api/packages/johanleroy/npm/'
+          scope: '@johanleroy'
+          cache: npm
+      - run: npm ci
+      - run: npm run build
+      # Garde-fou : le tag (sans le "v") doit correspondre à la version du paquet.
+      # GITHUB_REF_NAME est une variable d'env du runner (pas d'interpolation ${{ }} dans le shell).
+      - name: Verify tag matches package version
+        run: |
+          pkg=$(node -p "require('./packages/server/package.json').version")
+          tag="${GITHUB_REF_NAME#v}"
+          if [ "$pkg" != "$tag" ]; then
+            echo "ERREUR: tag '$tag' != version paquet '$pkg'"
+            exit 1
+          fi
+          echo "OK: tag $tag == version $pkg"
+      # Publication idempotente : le signal faisant autorité d'une version déjà présente est le
+      # 409 « already exists » renvoyé par npm publish lui-même (npm view est non fiable contre le
+      # registre npm de Gitea — faux négatif masqué par >/dev/null). On tente toujours le publish ;
+      # un 409 = succès idempotent, tout autre échec reste fatal. Le shell Actions tourne en
+      # `bash -eo pipefail` : on isole l'échec attendu dans la condition d'un `if` pour ne pas
+      # déclencher `set -e`. Le secret du registre est mappé sur NODE_AUTH_TOKEN lu par le .npmrc
+      # de setup-node.
+      - name: Publish (idempotent — tolère un 409 « already exists »)
+        run: |
+          if out="$(npm publish -w @johanleroy/git-arboretum 2>&1)"; then
+            printf '%s\n' "$out"
+            echo "Publication réussie."
+          else
+            code=$?
+            printf '%s\n' "$out"
+            if printf '%s' "$out" | grep -qiE 'E409|409 Conflict|already exists'; then
+              echo "::notice::Version déjà présente sur le registre (409) — publication idempotente, étape ignorée."
+            else
+              echo "::error::Échec de la publication (code $code)."
+              exit "$code"
+            fi
+          fi
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+      # SBOM (transparence supply-chain entreprise) : généré pour le paquet publié et exposé en
+      # artefact. C'est un bonus : un échec de génération/upload ne doit jamais faire rougir une
+      # release dont le publish a réussi → continue-on-error.
+      # upload-artifact@v3 : Gitea Actions (GHES-like) ne supporte pas @v4 (@actions/artifact v2+).
+      - name: Generate SBOM (CycloneDX)
+        continue-on-error: true
+        run: npx --yes @cyclonedx/cyclonedx-npm --omit dev --output-format JSON --output-file sbom.json -w @johanleroy/git-arboretum || npx --yes @cyclonedx/cyclonedx-npm --omit dev --output-format JSON --output-file sbom.json
+      - uses: actions/upload-artifact@v3
+        continue-on-error: true
+        with:
+          name: sbom
+          path: sbom.json

.gitea/workflows/vscode-release.yml

@@ -0,0 +1,74 @@
+# Packaging du VSIX de l'extension VS Code, déclenché UNIQUEMENT par un tag vscode-vX.Y.Z
+# (séparé de la release du daemon, qui écoute les tags v*). Le .vsix est exposé en artefact du run
+# (toujours) et, en best-effort, attaché à la release Gitea correspondante.
+name: VSCode Release
+
+on:
+  push:
+    tags: ['vscode-v*']
+
+permissions:
+  contents: write
+
+jobs:
+  package:
+    name: Package VSIX
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: npm
+      - run: npm ci
+      # Garde-fou : le tag (sans "vscode-v") doit correspondre à la version du manifeste de l'extension.
+      - name: Verify tag matches extension version
+        run: |
+          pkg=$(node -p "require('./packages/vscode/package.json').version")
+          tag="${GITHUB_REF_NAME#vscode-v}"
+          if [ "$pkg" != "$tag" ]; then
+            echo "ERREUR: tag '$tag' != version extension '$pkg'"
+            exit 1
+          fi
+          echo "OK: tag $tag == version $pkg"
+      # Build du shared puis bundle esbuild de l'extension (typecheck inclus), puis packaging VSIX.
+      # --no-dependencies : tout est bundlé dans dist/extension.js → pas de node_modules dans le VSIX.
+      - name: Build & package
+        run: |
+          npm run build:vscode
+          version=$(node -p "require('./packages/vscode/package.json').version")
+          cd packages/vscode
+          npx --yes @vscode/vsce package --no-dependencies -o "git-arboretum-${version}.vsix"
+      # Artefact du run : canal de distribution fiable, indépendant de l'API release.
+      # upload-artifact@v3 : Gitea Actions ne supporte pas @v4 (@actions/artifact v2+).
+      - uses: actions/upload-artifact@v3
+        with:
+          name: vsix
+          path: packages/vscode/*.vsix
+      # Best-effort : attache le VSIX à la release Gitea du tag (crée la release si absente).
+      # Réutilise le secret NPM_TOKEN (même token Gitea que la publication du daemon — droits
+      # repository suffisants pour l'API release). Sans lui, l'étape est ignorée sans faire échouer
+      # le job (continue-on-error) ; le VSIX reste disponible en artefact.
+      - name: Attach VSIX to Gitea release
+        continue-on-error: true
+        env:
+          RELEASE_TOKEN: ${{ secrets.NPM_TOKEN }}
+        run: |
+          if [ -z "$RELEASE_TOKEN" ]; then
+            echo "::notice::NPM_TOKEN absent — VSIX disponible en artefact uniquement."
+            exit 0
+          fi
+          api="${GITHUB_SERVER_URL}/api/v1/repos/${GITHUB_REPOSITORY}"
+          auth="Authorization: token ${RELEASE_TOKEN}"
+          version=$(node -p "require('./packages/vscode/package.json').version")
+          vsix="packages/vscode/git-arboretum-${version}.vsix"
+          # id de release du tag, sinon création
+          rid=$(curl -fsSL -H "$auth" "${api}/releases/tags/${GITHUB_REF_NAME}" | node -p "JSON.parse(require('fs').readFileSync(0,'utf8')).id || ''" || true)
+          if [ -z "$rid" ]; then
+            rid=$(curl -fsSL -X POST -H "$auth" -H 'Content-Type: application/json' \
+              -d "{\"tag_name\":\"${GITHUB_REF_NAME}\",\"name\":\"Arboretum VSCode ${version}\"}" \
+              "${api}/releases" | node -p "JSON.parse(require('fs').readFileSync(0,'utf8')).id || ''")
+          fi
+          curl -fsSL -X POST -H "$auth" -F "attachment=@${vsix}" \
+            "${api}/releases/${rid}/assets?name=git-arboretum-${version}.vsix"
+          echo "VSIX attaché à la release ${GITHUB_REF_NAME}."

.github/workflows/release.yml

@@ -1,42 +0,0 @@
-# Publication du paquet @johanleroy/git-arboretum sur le registre npm du Gitea,
-# déclenchée UNIQUEMENT par un tag vX.Y.Z (jamais sur un push de branche).
-name: Release
-
-on:
-  push:
-    tags: ['v*']
-
-permissions:
-  contents: read
-  packages: write
-
-jobs:
-  publish:
-    name: Publish to Gitea npm registry
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 22
-          registry-url: 'https://git.lidge.fr/api/packages/johanleroy/npm/'
-          scope: '@johanleroy'
-          cache: npm
-      - run: npm ci
-      - run: npm run build
-      # Garde-fou : le tag (sans le "v") doit correspondre à la version du paquet.
-      # GITHUB_REF_NAME est une variable d'env du runner (pas d'interpolation ${{ }} dans le shell).
-      - name: Verify tag matches package version
-        run: |
-          pkg=$(node -p "require('./packages/server/package.json').version")
-          tag="${GITHUB_REF_NAME#v}"
-          if [ "$pkg" != "$tag" ]; then
-            echo "ERREUR: tag '$tag' != version paquet '$pkg'"
-            exit 1
-          fi
-          echo "OK: tag $tag == version $pkg"
-      - run: npm publish -w @johanleroy/git-arboretum
-        env:
-          # Mapper le secret du registre (PAT Gitea write:package, ou le token auto
-          # GITEA_TOKEN s'il a ce scope) sur NODE_AUTH_TOKEN lu par le .npmrc de setup-node.
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

README.fr.md

@@ -10,7 +10,7 @@
   <a href="README.md">English</a> · <strong>Français</strong>
 </p>
 
-**Statut : MVP.** Le dashboard worktree-first, la découverte et la reprise de sessions, le cycle de vie des worktrees multi-repo, les états de session en temps réel, le terminal web, la supervision mobile (PWA installable, Web Push quand une session vous attend, valider/refuser sans ouvrir de terminal) et les groupes de travail (piloter plusieurs repos liés à la fois) sont implémentés et testés.
+**Statut : MVP.** Le dashboard worktree-first, la découverte et la reprise de sessions, le cycle de vie des worktrees multi-repo, le démarrage de sessions sur votre branche principale ou n'importe quel worktree, les états de session en temps réel, le terminal web, la supervision mobile (PWA installable, Web Push quand une session vous attend, répondre à une demande sans ouvrir de terminal) et les groupes de travail (piloter plusieurs repos liés depuis une seule session Claude) sont implémentés et testés.
 
 ---
 
@@ -28,10 +28,11 @@ Un unique daemon Node.js que vous lancez sur votre machine de dev (`npx @johanle
 
 - **Dashboard worktree-first, multi-repo** — chaque worktree de chaque repo enregistré, avec son état git (branche, ahead/behind, fichiers modifiés) *et* l'état de sa session Claude Code (busy / en attente d'entrée / idle / reprenable).
 - **Cycle de vie complet des worktrees** — créer (avec des hooks post-création par repo : `npm ci`, copie de `.env`…), adopter des worktrees créés à la main, supprimer avec garde-fous, élaguer les orphelins.
-- **Découverte & reprise de sessions** — les sessions lancées dans votre propre terminal apparaissent automatiquement ; reprenez les sessions mortes, observez ou forkez les vivantes. Ne corrompt jamais une session vivante.
+- **Découverte & reprise de sessions** — les sessions lancées dans votre propre terminal apparaissent automatiquement ; reprenez les sessions mortes, observez ou forkez les vivantes. Ne corrompt jamais une session vivante. Masquez les anciennes qui encombrent la liste (un clic efface tout l'historique externe ; elles restent reprenables).
-- **Terminal web** — terminal xterm.js complet vers chaque session managée, qui survit aux déconnexions du navigateur.
+- **Terminal web** — terminal xterm.js complet vers chaque session managée, qui survit aux déconnexions du navigateur ; vraiment plein écran, avec l'invite ancrée en bas et tout l'historique défilable au-dessus.
-- **Supervision depuis votre téléphone** — PWA installable avec notifications push quand une session vous attend ; validez ou refusez une demande sans ouvrir de terminal.
+- **Supervision depuis votre téléphone** — PWA installable avec notifications push quand une session vous attend ; répondez à une demande (ses options, ou refusez) sans ouvrir de terminal.
-- **Groupes de travail** — regroupez des repos liés (ex. une API, son frontend web et une lib partagée) dans un groupe nommé pour travailler sur tous à la fois : une vue unifiée de leurs worktrees et sessions, une grille multi-terminaux côte à côte, et une action « feature cross-repo » en un clic qui crée le même worktree de branche (et au besoin une session Claude) dans chaque repo du groupe.
+- **Groupes de travail** — regroupez des repos liés (ex. une API, son frontend web et sa doc) dans un groupe nommé, puis lancez **une seule session Claude qui les couvre tous à la fois** (via le flag `--add-dir` du CLI) : une conversation unique avec un contexte partagé travaillant à travers chaque repo, plus une vue unifiée de tous leurs worktrees et une grille multi-terminaux côte à côte. Une session de groupe peut d'abord créer le même worktree de branche dans chaque repo, ou tourner directement sur les checkouts principaux.
+- **Extension VS Code** — une extension native (pas un webview) qui amène l'arbre en direct, les terminaux de session natifs, les alertes d'attente et les actions git directement dans votre éditeur. Voir [Extension VS Code](#extension-vs-code).
 
 ---
 
@@ -100,9 +101,27 @@ node packages/server/dist/index.js
 
 1. **Ajoutez un dépôt.** Depuis le dashboard, enregistrez un repo git local par son chemin. Configurez éventuellement des **hooks post-création** (ex. `npm ci`, `cp ../.env .env`) exécutés automatiquement à chaque création d'un nouveau worktree pour ce repo.
 2. **Créez ou adoptez des worktrees.** Créez un nouveau worktree + branche en un clic (les hooks s'exécutent pour vous), ou adoptez un worktree créé à la main. Chaque worktree affiche sa branche, son ahead/behind et son nombre de fichiers modifiés.
-3. **Démarrez ou reprenez une session.** Lancez une session Claude Code sur un worktree, ou reprenez-en une démarrée dans votre terminal — Arboretum découvre les sessions existantes automatiquement et les reprend toujours dans leur répertoire de travail d'origine.
+3. **Démarrez ou reprenez une session.** Lancez une session Claude Code sur la branche principale du repo ou n'importe quel worktree, ou reprenez-en une démarrée dans votre terminal — Arboretum découvre les sessions existantes automatiquement et les reprend toujours dans leur répertoire de travail d'origine.
 4. **Suivez les états en direct.** Chaque session indique si elle est *busy*, *en attente de votre entrée* ou *idle*. Ouvrez le **terminal web** pour interagir directement ; il survit aux déconnexions du navigateur (fermer l'onglet ne tue pas la session).
-5. **Supervisez depuis votre téléphone.** Installez la PWA, et quand une session bascule en *attente*, vous recevez une notification push. Validez ou refusez la demande directement depuis l'interface de notification — sans terminal.
+5. **Supervisez depuis votre téléphone.** Installez la PWA, et quand une session bascule en *attente*, vous recevez une notification push. Répondez à la demande — choisissez l'une de ses options ou refusez-la — directement depuis le dashboard, sans terminal.
+
+## Extension VS Code
+
+Vous préférez rester dans votre éditeur ? Arboretum fournit une **extension VS Code native** (`packages/vscode`) — pas un webview. Elle se connecte au même daemon et l'expose avec les primitives natives de VS Code :
+
+- Un arbre **Repositories** et **Groups** en direct (repos → worktrees → sessions) dans l'Activity Bar, mis à jour en temps réel via le WebSocket du daemon.
+- **Terminaux natifs** : attachez-vous (ou observez) n'importe quelle session dans un vrai terminal VS Code — vous bénéficiez du rendu, du scrollback et du copier-coller de VS Code gratuitement.
+- Un compteur en **status bar** et des **notifications** natives quand une session attend, avec réponses Oui/Non sans ouvrir de terminal.
+- Les mutations git (créer un worktree, commit, push, promouvoir) et la **conscience du workspace** — le worktree de votre dossier ouvert est mis en évidence, avec « démarrer une session / créer un worktree ici » en un clic.
+
+Elle est distribuée en **VSIX privé**. Buildez-la et packagez-la depuis le monorepo :
+
+```bash
+npm run build:vscode
+cd packages/vscode && npx @vscode/vsce package --no-dependencies   # → git-arboretum-0.1.0.vsix
+```
+
+Puis installez-la via **Extensions : Installer à partir d'un VSIX…** (ou `code --install-extension git-arboretum-0.1.0.vsix`), lancez **Arboretum: Sign In** et collez un token. Détails complets dans [`packages/vscode/README.md`](packages/vscode/README.md).
 
 ## Accès distant depuis votre téléphone
 
@@ -209,9 +228,13 @@ Un terminal web, c'est de l'exécution de code à distance *par conception*. Les
 - Se bind sur `127.0.0.1` par défaut ; refuse les binds non-loopback sans flag explicite.
 - Authentifie **chaque** requête `/api/**` **et** chaque upgrade `/ws` avec des tokens révocables, et applique un **check `Origin` strict** (le cookie `SameSite=Strict` ne couvre pas les upgrades WebSocket — c'est le garde-fou anti cross-site hijacking).
 - Les tokens sont stockés **hashés** (sha256) et comparés en temps constant ; le bootstrap token n'est affiché qu'une seule fois. Le cookie de session est un payload signé HMAC, `HttpOnly` et `SameSite=Strict`, et reçoit automatiquement le flag `Secure` quand la requête arrive en HTTPS (p. ex. derrière Tailscale Serve). Le login est rate-limité avec backoff exponentiel.
+- Envoie des en-têtes HTTP durcis (CSP, `X-Frame-Options`, `nosniff`, `Referrer-Policy`, HSTS conditionnel, `no-store` sur l'API), restreint le dossier de données à `0o700` et la base à `0o600`, et **chiffre les secrets sensibles au repos** (AES-256-GCM).
+- Tient un **journal d'audit** des opérations sensibles et offre l'**export/effacement RGPD** des données (Réglages → Sécurité & conformité).
 
 Tailscale Serve est **la** façon d'atteindre Arboretum depuis d'autres appareils — pas seulement une recommandation : HTTPS valide, identité tailnet, aucun port ouvert. Le flag `--i-know-this-exposes-a-terminal` est une trappe de secours, pas un mode de déploiement ; n'exposez jamais Arboretum directement sur internet.
 
+Voir [`SECURITY.md`](SECURITY.md) pour le modèle de menace complet et [`docs/ENTERPRISE_DEPLOYMENT.md`](docs/ENTERPRISE_DEPLOYMENT.md) pour le durcissement en environnement réglementé.
+
 ## Ce qui le distingue
 
 | | Arboretum | GitKraken Agent Mode / Conductor / Nimbalyst | Happy / CloudCLI | Anthropic Remote Control |
@@ -231,7 +254,7 @@ Arboretum enveloppe le CLI Claude Code **interactif** dans un PTY — la même c
 
 ## Développement
 
-Arboretum est un monorepo npm workspaces : `@arboretum/shared` (protocole WS/REST, source de vérité), `@johanleroy/git-arboretum` (le daemon Fastify, le paquet publié) et `@arboretum/web` (la SPA Vue 3).
+Arboretum est un monorepo npm workspaces : `@arboretum/shared` (protocole WS/REST, source de vérité), `@johanleroy/git-arboretum` (le daemon Fastify, le paquet publié), `@arboretum/web` (la SPA Vue 3) et `git-arboretum` (l'extension VS Code — buildée séparément avec `npm run build:vscode`).
 
 ```bash
 npm run build        # build shared → server → web (l'ordre compte)
@@ -251,6 +274,12 @@ node packages/server/scripts/acceptance-p4.mjs   # Web Push + commande WS `answe
 node packages/server/scripts/acceptance-p5.mjs   # groupes de travail : CRUD + broadcast WS + CASCADE
 ```
 
+## Soutenir le projet
+
+Arboretum est un projet personnel libre et auto-financé. S'il vous fait gagner du temps, vous pouvez soutenir son développement :
+
+[![Buy Me a Coffee](https://img.shields.io/badge/Buy%20Me%20a%20Coffee-johanleroy-FFDD00?logo=buymeacoffee&logoColor=black)](https://buymeacoffee.com/johanleroy)
+
 ## Licence
 
 MIT — voir [LICENSE](LICENSE).

README.md

@@ -10,7 +10,7 @@
   <strong>English</strong> · <a href="README.fr.md">Français</a>
 </p>
 
-**Status: MVP.** The worktree-first dashboard, session discovery & resume, multi-repo worktree lifecycle, live session states, the web terminal, and mobile supervision (installable PWA, Web Push when a session needs you, approve/deny without opening a terminal), and work groups (run several related repos at once) are implemented and tested.
+**Status: MVP.** The worktree-first dashboard, session discovery & resume, multi-repo worktree lifecycle, sessions on your main branch or any worktree, live session states, the web terminal, mobile supervision (installable PWA, Web Push when a session needs you, answer a prompt without opening a terminal), and work groups (drive several related repos from a single Claude session) are implemented and tested.
 
 ---
 
@@ -28,10 +28,11 @@ A single Node.js daemon you run on your dev machine (`npx @johanleroy/git-arbore
 
 - **Worktree-first, multi-repo dashboard** — every worktree of every registered repo, with its git state (branch, ahead/behind, dirty files) *and* the state of its Claude Code session (busy / waiting for input / idle / resumable).
 - **Full worktree lifecycle** — create (with per-repo post-create hooks: `npm ci`, copy `.env`…), adopt worktrees created by hand, delete with guardrails, prune orphans.
-- **Session discovery & resume** — sessions you launched in your own terminal show up automatically; resume dead ones, observe or fork live ones. Never corrupts a live session.
+- **Session discovery & resume** — sessions you launched in your own terminal show up automatically; resume dead ones, observe or fork live ones. Never corrupts a live session. Hide the old ones that clutter the list (one click clears the whole external history; they stay resumable).
-- **Web terminal** — full xterm.js terminal to every managed session, surviving browser disconnects.
+- **Web terminal** — full xterm.js terminal to every managed session, surviving browser disconnects; truly fullscreen, with the prompt pinned to the bottom and full scrollback above.
-- **Supervision from your phone** — installable PWA with push notifications when a session needs you; approve/deny a prompt without opening a terminal.
+- **Supervision from your phone** — installable PWA with push notifications when a session needs you; answer a prompt (its options, or deny) without opening a terminal.
-- **Work groups** — bundle related repos (e.g. an API, its web frontend and a shared library) into a named group to work on them at once: a unified view of all their worktrees and sessions, a side-by-side multi-terminal grid, and a one-click "cross-repo feature" that creates the same branch worktree (and optionally a Claude session) across every repo in the group.
+- **Work groups** — bundle related repos (e.g. an API, its web frontend and its docs) into a named group, then launch **one Claude session that spans all of them at once** (via the CLI's `--add-dir`): a single conversation with one shared context working across every repo, plus a unified view of all their worktrees and a side-by-side multi-terminal grid. Group sessions can either create the same branch worktree in each repo first, or run straight on the main checkouts.
+- **VS Code extension** — a native extension (not a webview) that brings the live tree, native session terminals, waiting alerts and git actions right into your editor. See [VS Code extension](#vs-code-extension).
 
 ---
 
@@ -100,9 +101,27 @@ node packages/server/dist/index.js
 
 1. **Add a repository.** From the dashboard, register a local git repo by its path. Optionally configure **post-create hooks** (e.g. `npm ci`, `cp ../.env .env`) that run automatically every time you create a new worktree for that repo.
 2. **Create or adopt worktrees.** Spin up a new worktree + branch in one click (hooks run for you), or adopt a worktree you created by hand. Each worktree shows its branch, ahead/behind, and dirty-file count.
-3. **Start or resume a session.** Launch a Claude Code session on a worktree, or resume one that was started in your terminal — Arboretum discovers existing sessions automatically and always resumes them in their original working directory.
+3. **Start or resume a session.** Launch a Claude Code session on the repo's main branch or any worktree, or resume one that was started in your terminal — Arboretum discovers existing sessions automatically and always resumes them in their original working directory.
 4. **Watch the live states.** Each session reports whether it's *busy*, *waiting for your input*, or *idle*. Open the **web terminal** to interact directly; it survives browser disconnects (closing the tab does not kill the session).
-5. **Supervise from your phone.** Install the PWA, and when a session flips to *waiting* you get a push notification. Approve or deny the prompt straight from the notification UI — no terminal required.
+5. **Supervise from your phone.** Install the PWA, and when a session flips to *waiting* you get a push notification. Answer the prompt — pick one of its options or deny it — straight from the dashboard, no terminal required.
+
+## VS Code extension
+
+Prefer to stay in your editor? Arboretum ships a **native VS Code extension** (`packages/vscode`) — not a webview. It connects to the same daemon and surfaces it with VS Code's own primitives:
+
+- A live **Repositories** and **Groups** tree (repos → worktrees → sessions) in the Activity Bar, updated in real time over the daemon's WebSocket.
+- **Native terminals**: attach to (or observe) any session in a real VS Code terminal — you get VS Code's rendering, scrollback and copy/paste for free.
+- A **status-bar** counter and native **notifications** when a session is waiting, with Yes/No answers without opening a terminal.
+- Git mutations (create worktree, commit, push, promote) and **workspace awareness** — the worktree for your open folder is highlighted, with one-click "start session / create worktree here".
+
+It is distributed as a **private VSIX**. Build and package it from the monorepo:
+
+```bash
+npm run build:vscode
+cd packages/vscode && npx @vscode/vsce package --no-dependencies   # → git-arboretum-0.1.0.vsix
+```
+
+Then install it via **Extensions: Install from VSIX…** (or `code --install-extension git-arboretum-0.1.0.vsix`), run **Arboretum: Sign In** and paste a token. Full details in [`packages/vscode/README.md`](packages/vscode/README.md).
 
 ## Remote access from your phone
 
@@ -209,9 +228,13 @@ A web terminal is remote code execution *by design*. Arboretum's guardrails are
 - Binds to `127.0.0.1` by default; refuses non-loopback binds without an explicit flag.
 - Authenticates **every** `/api/**` request **and** every `/ws` upgrade with revocable tokens, and applies a **strict `Origin` check** (the `SameSite=Strict` cookie does not cover WebSocket upgrades — this is the anti cross-site hijacking guard).
 - Tokens are stored **hashed** (sha256) and compared in constant time; the bootstrap token is shown only once. The session cookie is an HMAC-signed payload, `HttpOnly` and `SameSite=Strict`, and it automatically gains the `Secure` flag when the request arrives over HTTPS (e.g. behind Tailscale Serve). Login is rate-limited with exponential backoff.
+- Sends hardened HTTP headers (CSP, `X-Frame-Options`, `nosniff`, `Referrer-Policy`, conditional HSTS, `no-store` on the API), restricts the data directory to `0o700` and the database to `0o600`, and **encrypts sensitive secrets at rest** (AES-256-GCM).
+- Keeps an **audit log** of sensitive operations and offers **GDPR** data export/erasure (Settings → Security & compliance).
 
 Tailscale Serve is **the** way to reach Arboretum from other devices — not just a recommendation: valid HTTPS, tailnet identity, no open ports. The `--i-know-this-exposes-a-terminal` flag is an escape hatch, not a deployment mode; never expose Arboretum directly to the internet.
 
+See [`SECURITY.md`](SECURITY.md) for the full threat model and [`docs/ENTERPRISE_DEPLOYMENT.md`](docs/ENTERPRISE_DEPLOYMENT.md) for hardening in regulated environments.
+
 ## What makes it different
 
 | | Arboretum | GitKraken Agent Mode / Conductor / Nimbalyst | Happy / CloudCLI | Anthropic Remote Control |
@@ -231,7 +254,7 @@ Arboretum wraps the **interactive** Claude Code CLI in a PTY — the same thing
 
 ## Development
 
-Arboretum is an npm-workspaces monorepo: `@arboretum/shared` (WS/REST protocol, source of truth), `@johanleroy/git-arboretum` (the Fastify daemon, the published package), and `@arboretum/web` (the Vue 3 SPA).
+Arboretum is an npm-workspaces monorepo: `@arboretum/shared` (WS/REST protocol, source of truth), `@johanleroy/git-arboretum` (the Fastify daemon, the published package), `@arboretum/web` (the Vue 3 SPA), and `git-arboretum` (the VS Code extension — built separately with `npm run build:vscode`).
 
 ```bash
 npm run build        # build shared → server → web (order matters)
@@ -251,6 +274,12 @@ node packages/server/scripts/acceptance-p4.mjs   # Web Push + WS `answer` comman
 node packages/server/scripts/acceptance-p5.mjs   # work groups: CRUD + WS broadcast + CASCADE
 ```
 
+## Support
+
+Arboretum is a free, self-funded side project. If it saves you time, you can support its development:
+
+[![Buy Me a Coffee](https://img.shields.io/badge/Buy%20Me%20a%20Coffee-johanleroy-FFDD00?logo=buymeacoffee&logoColor=black)](https://buymeacoffee.com/johanleroy)
+
 ## License
 
 MIT — see [LICENSE](LICENSE).

SECURITY.md

@@ -0,0 +1,61 @@
+# Security Policy
+
+Arboretum is a self-hosted daemon that serves a web dashboard to drive git worktrees and the
+Claude Code sessions running on them. **A web terminal is remote code execution by design** — that
+is the product, not a bug. Arboretum's security model is therefore built on *structural* guards
+(loopback-only binding, authenticated access, strict Origin checks) far more than on cryptography
+alone.
+
+This document describes the threat model, the controls that are implemented, the deliberate
+trade-offs, and how to report a vulnerability. For hardening a deployment in a regulated
+environment, see [`docs/ENTERPRISE_DEPLOYMENT.md`](docs/ENTERPRISE_DEPLOYMENT.md).
+
+## Threat model
+
+- **Single-user by design.** Arboretum runs on the owner's machine and is meant for one operator.
+  There is no multi-tenant isolation and no RBAC — and none is claimed.
+- **Loopback by default.** The server binds `127.0.0.1`; `config.ts` *refuses* any non-loopback bind
+  unless you pass `--i-know-this-exposes-a-terminal`. Remote access is expected via **Tailscale Serve**
+  (TLS + tailnet identity), never by opening a port.
+- **The terminal is RCE.** Anyone who can authenticate can run code. The controls below exist to make
+  sure only the authenticated operator reaches it, and that the surrounding surface (cookies, headers,
+  data at rest) is hardened.
+
+## Implemented controls
+
+| Area | Control | Where |
+| --- | --- | --- |
+| Network | Loopback-only default; non-loopback refused without explicit flag | `packages/server/src/config.ts` |
+| AuthN | Global guard on **all** `/api/**` and `/ws` (only login is public, and rate-limited) | `packages/server/src/app.ts` |
+| AuthN | Tokens stored **hashed** (SHA-256), compared in constant time; bootstrap token shown once | `packages/server/src/auth/service.ts` |
+| Sessions | Cookie is an HMAC-SHA256 signed payload, `HttpOnly` + `SameSite=Strict`, `Secure` when HTTPS | `packages/server/src/routes/auth.ts` |
+| CSRF / WS | Strict `Origin` check on every `/api/**` and `/ws` request (anti cross-site WS hijacking) | `packages/server/src/app.ts` |
+| CSRF | Mutations carrying a body must be `application/json` | `packages/server/src/app.ts` |
+| Rate limit | Global login rate limit with exponential backoff (not per-IP — Tailscale fronts everything as 127.0.0.1) | `packages/server/src/auth/service.ts` |
+| HTTP headers | CSP, `X-Frame-Options: DENY`, `X-Content-Type-Options: nosniff`, `Referrer-Policy`, `Permissions-Policy`, conditional HSTS, `Cache-Control: no-store` on API; `Server` header stripped | `packages/server/src/app.ts` |
+| Injection | All SQL is parameterized; all git calls use `execFile` (no shell); path-traversal guards | `packages/server/src/**` |
+| Data at rest | DB file/dir forced to `0o600`/`0o700`; sensitive secrets (server secret, VAPID private key) encrypted with AES-256-GCM | `packages/server/src/db/index.ts`, `core/secret-box.ts` |
+| Audit | Persistent audit log of sensitive mutations (tokens, settings, secrets, push, groups) | `packages/server/src/core/audit-log.ts` |
+| Privacy | GDPR export (`/api/v1/data/export`) and erasure (`/api/v1/data/delete-my-data`) | `packages/server/src/routes/data.ts` |
+| Install | Runs as a **user** service (systemd user unit / launchd LaunchAgent), never root | `packages/server/src/cli/install.ts` |
+
+## Deliberate trade-offs
+
+- **Long-lived API tokens.** Tokens do not expire by age (CLI automation stability) but can be revoked
+  instantly, and `last_used_at` is tracked. Review and rotate tokens periodically.
+- **Encryption-at-rest key management.** With no `ARBORETUM_SECRET_KEY` set, the encryption key lives in
+  `dataDir/secret.key` (`0o600`) next to the database — this protects a leaked database *copy* (backup,
+  WAL) but not a full `dataDir` compromise. For strong protection, set `ARBORETUM_SECRET_KEY` and store it
+  separately from database backups. Full-DB SQLCipher is intentionally avoided (it breaks the `npx`
+  prebuilt portability).
+- **No multi-user model.** If you need multiple operators with isolation, Arboretum is not the right tool.
+
+## Reporting a vulnerability
+
+Please report security issues **privately** — do not open a public issue.
+
+- Email: **security@johanleroy.fr** (or `contact@johanleroy.fr`).
+- Include a description, affected version, and reproduction steps.
+- Expect an acknowledgement within **7 days** and a coordinated disclosure window of up to **90 days**.
+
+Thank you for helping keep Arboretum users safe.

docs/ENTERPRISE_DEPLOYMENT.md

@@ -0,0 +1,95 @@
+# Enterprise deployment guide
+
+This guide complements [`../SECURITY.md`](../SECURITY.md) with the operational steps a regulated or
+security-conscious organization needs to deploy Arboretum with confidence.
+
+## 1. Remote access: Tailscale Serve (recommended)
+
+Never open a public port. Keep the default `127.0.0.1` bind and put Arboretum behind Tailscale Serve:
+
+```bash
+# on the host running arboretum (default bind 127.0.0.1:7317)
+tailscale serve --bg 7317
+```
+
+This gives you TLS, a stable `*.ts.net` hostname, and tailnet identity. Then add that origin to the
+allow-list so the strict Origin check accepts it:
+
+```bash
+arboretum --allow-origin https://my-host.tailnet.ts.net
+```
+
+The `--i-know-this-exposes-a-terminal` flag exists only as an escape hatch for non-loopback binds; it
+is **never** a deployment mode and is never injected automatically by `arboretum install`.
+
+## 2. Encryption at rest
+
+Sensitive secrets (the HMAC server secret and the VAPID private key) are encrypted with AES-256-GCM
+before being stored in SQLite. Token values are never stored — only their SHA-256 hashes.
+
+For **strong** protection (key not co-located with the database), provide a passphrase via the
+environment instead of the on-disk key file:
+
+```bash
+ARBORETUM_SECRET_KEY='<a long random passphrase from your secrets manager>' arboretum
+```
+
+- Store this passphrase in your secrets manager / KMS, **separately** from database backups.
+- Without it, the key is auto-generated in `dataDir/secret.key` (`0o600`). This still protects a leaked
+  database copy, but not a full `dataDir` compromise.
+- Rotating the passphrase requires re-encrypting existing values; the simplest path is to revoke and
+  recreate the bootstrap token after rotation.
+
+## 3. Filesystem permissions
+
+On startup Arboretum forces `dataDir` to `0o700` and the database files (`*.db`, `-wal`, `-shm`) to
+`0o600`. Verify after first run:
+
+```bash
+stat -c '%a %n' ~/.local/share/arboretum ~/.local/share/arboretum/*.db
+# expect: 700 …/arboretum   and   600 …/arboretum.db
+```
+
+Keep `$HOME` private (standard `0o700`). If you relocate data with `--db` or `XDG_DATA_HOME`, make sure
+the target directory is not world-readable.
+
+## 4. Audit logging
+
+All sensitive mutations are recorded in an append-only `audit_logs` table: token create/revoke, login
+success/failure, settings changes, secret generation, push subscribe/unsubscribe, group CRUD, and data
+erasure. Query it via the API (paginated):
+
+```bash
+curl -s -H "Authorization: Bearer $TOKEN" \
+  'http://127.0.0.1:7317/api/v1/audit-logs?limit=100'
+```
+
+The audit log never contains secret values — only non-sensitive metadata (ids, labels, counters). It is
+also visible in the dashboard under **Settings → Security & compliance**.
+
+## 5. GDPR (data subject requests)
+
+- **Export**: `GET /api/v1/data/export` returns every record tied to the authenticated token (token
+  metadata, push subscriptions, session history, settings) as JSON. Also available as a one-click
+  download in **Settings → Security & compliance**.
+- **Erasure**: `POST /api/v1/data/delete-my-data` is a two-step call — the first response returns a
+  `confirm` code that must be POSTed back to execute. It purges the token's push subscriptions and
+  revokes the token (unless it is the last active one).
+
+## 6. Backups & retention
+
+- Back up the SQLite database (`arboretum.db`) with the WAL checkpointed. Treat backups as sensitive.
+- If you use `ARBORETUM_SECRET_KEY`, back the key up **separately** — a database backup is useless (and
+  safe) without it, which is the point.
+- Session history is retained until the database is reset. To start clean, stop the service and remove
+  the database file.
+
+## 7. Logging hygiene
+
+The log level is controlled by `ARBORETUM_LOG` (default `info`). Do **not** run `debug`/`trace` in
+production: verbose levels may log request metadata. Keep `info` or higher.
+
+## 8. Supply chain
+
+Each published release ships with a CycloneDX SBOM (`sbom.json`) generated in CI, so you can scan the
+dependency tree for known vulnerabilities before deploying.

package.json

@@ -15,7 +15,12 @@
     "pack": "npm run build && npm pack -w @johanleroy/git-arboretum",
     "test": "vitest run",
     "dev:server": "npm run dev -w @johanleroy/git-arboretum",
-    "dev:web": "npm run dev -w @arboretum/web"
+    "dev:web": "npm run dev -w @arboretum/web",
+    "build:site": "npm run build -w @arboretum/site",
+    "dev:site": "npm run dev -w @arboretum/site",
+    "preview:site": "npm run preview -w @arboretum/site",
+    "build:vscode": "npm run build -w @arboretum/shared -w git-arboretum",
+    "dev:vscode": "npm run dev -w git-arboretum"
   },
   "devDependencies": {
     "@types/node": "^22.10.0",

packages/server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@johanleroy/git-arboretum",
-  "version": "1.3.0",
+  "version": "1.9.0",
   "description": "Self-hosted web dashboard for git worktrees and the Claude Code sessions running on them",
   "license": "MIT",
   "type": "module",
@@ -14,6 +14,10 @@
   "bugs": {
     "url": "https://git.lidge.fr/johanleroy/arboretum/issues"
   },
+  "funding": {
+    "type": "buymeacoffee",
+    "url": "https://buymeacoffee.com/johanleroy"
+  },
   "keywords": [
     "git",
     "worktree",
@@ -44,14 +48,10 @@
   "scripts": {
     "build": "tsc -b",
     "dev": "tsc -b --watch & node --watch dist/index.js",
-    "prepack": "node scripts/copy-web.mjs && node scripts/vendor-shared.mjs && node scripts/copy-meta.mjs",
+    "prepack": "node scripts/copy-web.mjs && node scripts/inline-shared.mjs && node scripts/copy-meta.mjs",
     "test": "vitest run"
   },
-  "bundleDependencies": [
-    "@arboretum/shared"
-  ],
   "dependencies": {
-    "@arboretum/shared": "0.1.0",
     "@fastify/cookie": "^11.0.0",
     "@fastify/static": "^9.0.0",
     "@fastify/websocket": "^11.0.0",
@@ -61,6 +61,7 @@
     "web-push": "^3.6.7"
   },
   "devDependencies": {
+    "@arboretum/shared": "0.1.0",
     "@types/web-push": "^3.6.4",
     "@types/ws": "^8.5.0"
   }

packages/server/scripts/acceptance-p2.mjs

@@ -144,6 +144,37 @@ try {
   const out = c.state.outputs.get(att?.channel) ?? '';
   check('resume lance `--resume sid-dead` dans le bon cwd', out.includes('args=[--resume sid-dead]') && out.includes(`cwd=${workDir}`), out.replace(/\s+/g, ' ').slice(0, 120));
 
+  // --- Régression « Reprendre » : reprise d'une session MANAGÉE morte par son UUID Arboretum ---
+  // (le bouton web envoie l'UUID managé, pas le claudeSessionId ; le serveur doit le résoudre en DB).
+  const createManaged = await fetch(`${ORIGIN}/api/v1/sessions`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', Origin: ORIGIN, Cookie: cookie },
+    body: JSON.stringify({ cwd: workDir, command: 'claude' }),
+  });
+  const managed = (await createManaged.json()).session;
+  check('création session managée claude → 201 (pid)', createManaged.status === 201 && managed?.pid > 0);
+
+  // Simule la capture du claudeSessionId : entrée registre pour le pid du PTY managé (pollée toutes les 400ms).
+  writeFileSync(
+    join(sessions, `${managed.pid}.json`),
+    JSON.stringify({ pid: managed.pid, sessionId: 'sid-managed', cwd: workDir, status: 'idle' }),
+  );
+  const captured = await c.waitMsg(
+    (m) => m.type === 'session_update' && m.session?.id === managed.id && m.session?.claudeSessionId === 'sid-managed',
+  );
+  check('claudeSessionId capturé depuis le registre (session managée)', !!captured);
+
+  // Fermeture (kill) puis reprise par UUID managé → 201 dans le cwd d'origine (avant le fix : 404).
+  const killManaged = await fetch(`${ORIGIN}/api/v1/sessions/${managed.id}`, { method: 'DELETE', headers: { Origin: ORIGIN, Cookie: cookie } });
+  check('kill session managée → 200', killManaged.status === 200);
+  await sleep(400); // laisse handleExit persister ended_at
+  const resumeManaged = await postJson(`/api/v1/sessions/${managed.id}/resume`, cookie);
+  const resumedManaged = (await resumeManaged.json()).session;
+  check(
+    'resume d’une session MANAGÉE morte par UUID → 201',
+    resumeManaged.status === 201 && resumedManaged?.command === 'claude' && resumedManaged?.source === 'managed' && resumedManaged?.cwd === workDir,
+  );
+
   // Broadcast : une nouvelle session découverte est poussée via session_update au rafraîchissement périodique.
   writeJsonl(workDir, 'sid-new');
   const pushed = await c.waitMsg((m) => m.type === 'session_update' && m.session?.id === 'sid-new', 13000);

packages/server/scripts/acceptance-p3.mjs

@@ -3,7 +3,7 @@
 // Vrai daemon + vrai repo git tmp. Couvre : enregistrement repo, création worktree avec hook
 // post-create, broadcast WS worktree_update, corrélation worktree↔session (bash), suppression.
 import { spawn, execFileSync } from 'node:child_process';
-import { mkdtempSync, rmSync, existsSync } from 'node:fs';
+import { mkdtempSync, rmSync, existsSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join, dirname, basename } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -119,6 +119,24 @@ try {
   const feat = wlist1.worktrees.find((w) => w.branch === 'feat');
   check('corrélation worktree ↔ session (cwd)', feat?.sessions?.some((s) => s.command === 'bash' && s.live));
 
+  // Session sur le checkout principal (« bosser sur la branche principale ») avec création de branche.
+  const mainSess = await j(`/api/v1/repos/${repoSummary.id}/session`, 'POST', cookie, { command: 'bash', branch: 'mainfeat', newBranch: true });
+  const mainBody = await mainSess.json();
+  check('POST repo session → 201 (bash)', mainSess.status === 201 && mainBody.session?.command === 'bash');
+  check('session de branche principale : cwd = checkout principal', mainBody.session?.cwd === repoSummary.path);
+  const mainPush = await c.waitMsg((m) => m.type === 'worktree_update' && m.worktree?.isMain && m.worktree?.branch === 'mainfeat');
+  check('broadcast worktree_update (branche principale basculée)', !!mainPush);
+  await sleep(300);
+  const wlistM = await (await j('/api/v1/worktrees', 'GET', cookie)).json();
+  const mainWt = wlistM.worktrees.find((w) => w.isMain);
+  check('session corrélée au checkout principal', mainWt?.branch === 'mainfeat' && mainWt.sessions.some((s) => s.id === mainBody.session.id));
+
+  // Refus 409 quand le checkout principal est sale.
+  writeFileSync(join(repo, 'scratch.txt'), 'wip\n');
+  const dirtyRefused = await j(`/api/v1/repos/${repoSummary.id}/session`, 'POST', cookie, { command: 'bash', branch: 'other', newBranch: true });
+  check('repo session sur checkout sale → 409', dirtyRefused.status === 409);
+  rmSync(join(repo, 'scratch.txt'), { force: true });
+
   // Suppression forcée (une session vit dans le worktree).
   const refused = await j(`/api/v1/repos/${repoSummary.id}/worktrees?path=${encodeURIComponent(wtPath)}&force=false`, 'DELETE', cookie);
   check('delete sans force (session live) → 409', refused.status === 409);

packages/server/scripts/acceptance-p5.mjs

@@ -4,7 +4,7 @@
 // group_removed sur le topic 'groups', ajout/retrait de repo, et purge CASCADE de la membership
 // quand le repo est supprimé (PRAGMA foreign_keys = ON).
 import { spawn, execFileSync } from 'node:child_process';
-import { mkdtempSync, rmSync } from 'node:fs';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -24,15 +24,20 @@ const check = (name, ok, detail = '') => {
 };
 
 const tmp = mkdtempSync(join(tmpdir(), 'arb-accept-p5-'));
+function initRepo(path) {
+  execFileSync('mkdir', ['-p', path]);
+  const git = (...args) => execFileSync('git', args, { cwd: path, stdio: 'pipe' });
+  git('init', '-b', 'main');
+  git('config', 'user.email', 'test@arboretum.dev');
+  git('config', 'user.name', 'Test');
+  execFileSync('bash', ['-lc', 'echo "# demo" > README.md'], { cwd: path });
+  git('add', '-A');
+  git('commit', '-m', 'init');
+}
 const repo = join(tmp, 'demo-repo');
-execFileSync('mkdir', ['-p', repo]);
+const repo2 = join(tmp, 'demo-repo-2');
-const git = (...args) => execFileSync('git', args, { cwd: repo, stdio: 'pipe' });
+initRepo(repo);
-git('init', '-b', 'main');
+initRepo(repo2);
-git('config', 'user.email', 'test@arboretum.dev');
-git('config', 'user.name', 'Test');
-execFileSync('bash', ['-lc', 'echo "# demo" > README.md'], { cwd: repo });
-git('add', '-A');
-git('commit', '-m', 'init');
 
 const srv = spawn(
   'node',
@@ -109,6 +114,71 @@ try {
   const pushedAdd = await c.waitMsg((m) => m.type === 'group_update' && m.group?.repoIds?.includes(repoSummary.id));
   check('broadcast WS group_update (ajout repo)', !!pushedAdd);
 
+  // ---- P6 : session de groupe multi-repo (UNE session couvrant tous les repos via --add-dir) ----
+  // Enregistre un 2e repo, l'ajoute au groupe, puis lance UNE session de groupe (bash, sans quota).
+  const addRepo2 = await j('/api/v1/repos', 'POST', cookie, { path: repo2 });
+  const repo2Summary = (await addRepo2.json()).repo;
+  check('POST /repos (2e repo) → 201', addRepo2.status === 201 && repo2Summary?.valid === true);
+  await j(`/api/v1/groups/${group.id}/repos`, 'POST', cookie, { repoId: repo2Summary.id });
+
+  // Mode « checkouts principaux » (pas de branch) : couvre le worktree principal de chaque repo.
+  const gsRes = await j(`/api/v1/groups/${group.id}/session`, 'POST', cookie, { command: 'bash' });
+  const gsBody = await gsRes.json();
+  const gsession = gsBody.session;
+  check('POST /groups/:id/session → 201', gsRes.status === 201 && !!gsession);
+  check('session de groupe : 2 répertoires couverts', Array.isArray(gsBody.dirs) && gsBody.dirs.length === 2);
+  // cwd = parent commun des repos (P6), chaque repo relié en --add-dir → 2 addedDirs.
+  check('session de groupe : cwd = parent commun des repos', gsession?.cwd === tmp);
+  check('session de groupe : addedDirs = les 2 repos', (gsession?.addedDirs?.length ?? 0) === 2);
+  check('session de groupe : groupId posé', gsession?.groupId === group.id);
+  check('session de groupe : cwd parent + 2 repos addedDirs = 3 chemins distincts', new Set([gsession?.cwd, ...(gsession?.addedDirs ?? [])]).size === 3);
+
+  // La session apparaît dans la liste globale avec son groupId.
+  const sessList = await (await j('/api/v1/sessions', 'GET', cookie)).json();
+  const listed = sessList.sessions?.find((s) => s.id === gsession.id);
+  check('GET /sessions : session de groupe présente avec groupId', listed?.groupId === group.id);
+
+  // broadcast WS session_update reçu pour la session de groupe.
+  const pushedSession = await c.waitMsg((m) => m.type === 'session_update' && m.session?.id === gsession.id);
+  check('broadcast WS session_update (session de groupe)', !!pushedSession);
+
+  // ---- Worktree de groupe sur une NOUVELLE branche (scénario corrigé : mode auto, plus de -b raté) ----
+  const wtA = await j(`/api/v1/repos/${repoSummary.id}/worktrees`, 'POST', cookie, { branch: 'feature/cross', mode: 'auto', startSession: null });
+  const wtABody = await wtA.json();
+  check('POST /repos/:id/worktrees (branche neuve) → 201 + action=created', wtA.status === 201 && wtABody.action === 'created');
+  const wtB = await j(`/api/v1/repos/${repo2Summary.id}/worktrees`, 'POST', cookie, { branch: 'feature/cross', mode: 'auto', startSession: null });
+  check('POST /repos (2e repo) worktree branche neuve → 201', wtB.status === 201);
+
+  // GET /branches : la nouvelle branche apparaît (alimente le sélecteur de base côté UI).
+  const branchesA = await (await j(`/api/v1/repos/${repoSummary.id}/branches`, 'GET', cookie)).json();
+  check('GET /repos/:id/branches : feature/cross présente', Array.isArray(branchesA.local) && branchesA.local.includes('feature/cross'));
+
+  // session de groupe SUR cette branche → résout les worktrees créés (le cas qui échouait avant).
+  const gsBranch = await j(`/api/v1/groups/${group.id}/session`, 'POST', cookie, { command: 'bash', branch: 'feature/cross' });
+  const gsBranchBody = await gsBranch.json();
+  check('POST /groups/:id/session (branche) → 201 + 2 dirs', gsBranch.status === 201 && gsBranchBody.dirs?.length === 2);
+  await j(`/api/v1/sessions/${gsBranchBody.session.id}`, 'DELETE', cookie);
+
+  // commit : fichier neuf dans le worktree de repo1 puis commit via l'endpoint.
+  writeFileSync(join(wtABody.worktree.path, 'cross.txt'), 'wip\n');
+  const commitRes = await j(`/api/v1/repos/${repoSummary.id}/worktrees/commit`, 'POST', cookie, { path: wtABody.worktree.path, message: 'wip cross' });
+  check('POST /worktrees/commit → 200 + dirty=0', commitRes.status === 200 && (await commitRes.json()).worktree?.git?.dirtyCount === 0);
+
+  // promotion « en principal » : feature/cross devient le checkout principal de repo1, worktree supprimé.
+  const promRes = await j(`/api/v1/repos/${repoSummary.id}/worktrees/promote`, 'POST', cookie, { path: wtABody.worktree.path });
+  check('POST /worktrees/promote → 200', promRes.status === 200);
+  const wtsAfter = await (await j(`/api/v1/repos/${repoSummary.id}/worktrees`, 'GET', cookie)).json();
+  check('promotion : checkout principal désormais sur feature/cross', wtsAfter.worktrees?.find((w) => w.isMain)?.branch === 'feature/cross');
+
+  // groupe sans worktree résolu (branche inexistante) → 400.
+  const gsBad = await j(`/api/v1/groups/${group.id}/session`, 'POST', cookie, { command: 'bash', branch: 'no/such/branch' });
+  check('POST /groups/:id/session branche absente → 400', gsBad.status === 400);
+
+  // Arrêt de la session de groupe + nettoyage du 2e repo (CASCADE retire repo2 de la membership).
+  const killSession = await j(`/api/v1/sessions/${gsession.id}`, 'DELETE', cookie);
+  check('DELETE session de groupe → 200', killSession.status === 200);
+  await j(`/api/v1/repos/${repo2Summary.id}`, 'DELETE', cookie);
+
   // Renommage via PATCH.
   const patched = await j(`/api/v1/groups/${group.id}`, 'PATCH', cookie, { label: 'Renamed' });
   check('PATCH /groups/:id → 200 (renommé)', patched.status === 200 && (await patched.json()).group?.label === 'Renamed');

packages/server/scripts/inline-shared.mjs

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+// Inline @arboretum/shared (paquet workspace NON publié) directement dans le dist du serveur,
+// pour que le tarball npm soit 100 % autonome. Branché sur le hook "prepack".
+//
+// Pourquoi PAS bundleDependencies : embarquer une dépendance qui est aussi un *workspace* via
+// bundleDependencies est instable selon l'environnement npm (mode -w, exécution en root sur un
+// runner CI, version d'arborist) — npm voit le nœud comme un lien workspace et n'embarque parfois
+// AUCUN fichier ("bundled files: 0"), produisant un paquet cassé chez le consommateur. On élimine
+// donc toute magie de bundling : on copie le JS compilé de shared dans dist/_shared et on réécrit
+// l'import bare '@arboretum/shared' du serveur vers ce chemin relatif. Zéro node_modules embarqué,
+// zéro symlink, résultat identique partout.
+import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { join, dirname, relative, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const serverDir = join(dirname(fileURLToPath(import.meta.url)), '..');
+const serverDist = join(serverDir, 'dist');
+const sharedDist = join(serverDir, '..', 'shared', 'dist');
+const inlineDir = join(serverDist, '_shared');
+
+for (const [label, p] of [['dist serveur', serverDist], ['dist shared', sharedDist]]) {
+  if (!existsSync(p)) {
+    console.error(`inline-shared: ${label} introuvable (${p}) — lance "npm run build" avant le pack.`);
+    process.exit(1);
+  }
+}
+
+// 1) Copier le JS compilé de shared dans dist/_shared (uniquement *.js : seul le runtime compte ;
+//    les .d.ts/.map ne sont de toute façon pas publiés via le glob `files`). index.js réexporte
+//    ./protocol.js et ./api.js en relatif → la copie complète préserve la résolution interne.
+rmSync(inlineDir, { recursive: true, force: true });
+mkdirSync(inlineDir, { recursive: true });
+let copied = 0;
+for (const name of readdirSync(sharedDist)) {
+  if (name.endsWith('.js')) {
+    cpSync(join(sharedDist, name), join(inlineDir, name));
+    copied++;
+  }
+}
+if (copied === 0) {
+  console.error(`inline-shared: aucun .js dans ${sharedDist} — shared n'est pas compilé.`);
+  process.exit(1);
+}
+
+// 2) Réécrire l'import bare '@arboretum/shared' de chaque .js du serveur vers le chemin relatif
+//    (POSIX) pointant sur dist/_shared/index.js, calculé par fichier (profondeur variable).
+const walk = (dir) =>
+  readdirSync(dir, { withFileTypes: true }).flatMap((e) => {
+    const p = join(dir, e.name);
+    if (e.isDirectory()) return p === inlineDir ? [] : walk(p); // ne pas se réécrire soi-même
+    return e.name.endsWith('.js') ? [p] : [];
+  });
+
+let rewritten = 0;
+for (const file of walk(serverDist)) {
+  const src = readFileSync(file, 'utf8');
+  if (!src.includes('@arboretum/shared')) continue;
+  let rel = relative(dirname(file), join(inlineDir, 'index.js')).split(sep).join('/');
+  if (!rel.startsWith('.')) rel = `./${rel}`;
+  const out = src.replaceAll(`'@arboretum/shared'`, `'${rel}'`).replaceAll(`"@arboretum/shared"`, `"${rel}"`);
+  if (out !== src) {
+    writeFileSync(file, out);
+    rewritten++;
+  }
+}
+if (rewritten === 0) {
+  console.error(`inline-shared: aucun import '@arboretum/shared' réécrit dans ${serverDist} — build manquant ?`);
+  process.exit(1);
+}
+
+console.log(`inline-shared: ${copied} fichier(s) shared -> dist/_shared, import réécrit dans ${rewritten} fichier(s) serveur`);

packages/server/scripts/vendor-shared.mjs

@@ -1,43 +0,0 @@
-#!/usr/bin/env node
-// Embarque @arboretum/shared (dépendance runtime non publiée) DANS le tarball npm.
-// Branché sur le hook "prepack", aux côtés de bundleDependencies dans package.json.
-//
-// Pourquoi un vrai dossier et pas le symlink workspace : sous npm workspaces, shared
-// est seulement symlinké dans le node_modules racine ; `npm pack` n'embarque une
-// bundleDependency que si elle existe comme VRAI dossier dans le node_modules du
-// paquet packé (packages/server/node_modules/@arboretum/shared). On le matérialise ici.
-import { cpSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const serverDir = join(dirname(fileURLToPath(import.meta.url)), '..');
-const sharedDir = join(serverDir, '..', 'shared');
-const sharedDist = join(sharedDir, 'dist');
-const target = join(serverDir, 'node_modules', '@arboretum', 'shared');
-
-if (!existsSync(sharedDist)) {
-  console.error(
-    `vendor-shared: ${sharedDist} introuvable — lance "npm run build" (shared doit être compilé) avant le pack.`,
-  );
-  process.exit(1);
-}
-
-// package.json minimal et déterministe : on reprend les champs de résolution réels de
-// shared (version incluse, pour rester synchro), sans scripts ni files inutiles au runtime.
-const shared = JSON.parse(readFileSync(join(sharedDir, 'package.json'), 'utf8'));
-const minimal = {
-  name: shared.name,
-  version: shared.version,
-  type: shared.type,
-  main: shared.main,
-  types: shared.types,
-  exports: shared.exports,
-};
-
-// Idempotent : on repart d'un dossier propre à chaque pack.
-rmSync(target, { recursive: true, force: true });
-mkdirSync(target, { recursive: true });
-writeFileSync(join(target, 'package.json'), JSON.stringify(minimal, null, 2) + '\n');
-cpSync(sharedDist, join(target, 'dist'), { recursive: true });
-
-console.log(`vendor-shared: embarqué ${shared.name}@${shared.version} -> ${target}`);

packages/server/src/app.ts

@@ -1,4 +1,4 @@
-import Fastify, { type FastifyInstance, type FastifyRequest } from 'fastify';
+import Fastify, { type FastifyError, type FastifyInstance, type FastifyRequest } from 'fastify';
 import fastifyCookie from '@fastify/cookie';
 import fastifyWebsocket from '@fastify/websocket';
 import fastifyStatic from '@fastify/static';
@@ -14,6 +14,7 @@ import { WorktreeManager } from './core/worktree-manager.js';
 import { RepoDiscoveryService } from './core/repo-discovery.js';
 import { GroupManager } from './core/group-manager.js';
 import { PushService } from './core/push-service.js';
+import { loadSecretBox } from './core/secret-box.js';
 import { registerAuthRoutes } from './routes/auth.js';
 import { registerSessionRoutes } from './routes/sessions.js';
 import { registerRepoRoutes } from './routes/repos.js';
@@ -22,7 +23,37 @@ import { registerWorktreeRoutes } from './routes/worktrees.js';
 import { registerPushRoutes } from './routes/push.js';
 import { registerSettingsRoutes } from './routes/settings.js';
 import { registerFsRoutes } from './routes/fs.js';
+import { registerAuditRoutes } from './routes/audit.js';
+import { registerDataRoutes } from './routes/data.js';
 import { registerWsGateway } from './ws/gateway.js';
+import { isHttpsRequest } from './routes/auth.js';
+
+// En-têtes de sécurité posés sur TOUTES les réponses (defense-in-depth + conformité scanners
+// entreprise). Le terminal web reste du RCE par conception : ces en-têtes durcissent la SPA et
+// le transport, ils ne remplacent pas le modèle loopback + auth + Origin.
+const SECURITY_HEADERS: Record<string, string> = {
+  'X-Content-Type-Options': 'nosniff',
+  'X-Frame-Options': 'DENY',
+  'Referrer-Policy': 'no-referrer',
+  'Cross-Origin-Opener-Policy': 'same-origin',
+  'Permissions-Policy': 'geolocation=(), microphone=(), camera=(), payment=()',
+  // CSP calibrée pour la SPA : Tailwind/xterm injectent du style inline ; le WebSocket impose
+  // ws:/wss: en connect-src ; le service worker push impose worker-src 'self'.
+  'Content-Security-Policy': [
+    "default-src 'self'",
+    "script-src 'self'",
+    "style-src 'self' 'unsafe-inline'",
+    "img-src 'self' data:",
+    "font-src 'self' data:",
+    "connect-src 'self' ws: wss:",
+    "worker-src 'self'",
+    "manifest-src 'self'",
+    "frame-ancestors 'none'",
+    "base-uri 'self'",
+    "object-src 'none'",
+    "form-action 'self'",
+  ].join('; '),
+};
 
 declare module 'fastify' {
   interface FastifyRequest {
@@ -46,11 +77,14 @@ export interface AppBundle {
 
 export function buildApp(config: Config, db: Db, serverVersion: string): AppBundle {
   const app = Fastify({ logger: { level: process.env.ARBORETUM_LOG ?? 'info' } });
-  const auth = new AuthService(db);
+  // Chiffrement au repos des secrets (server_secret, clé privée VAPID) dans la base.
+  const box = loadSecretBox(config.dataDir);
+  const auth = new AuthService(db, box);
   const limiter = new LoginRateLimiter();
-  const push = new PushService(db, config.vapidContact);
+  const push = new PushService(db, config.vapidContact, undefined, box);
   const manager = new PtyManager(db, config.claudeSessionsDir, push);
   const discovery = new DiscoveryService({
+    db,
     ptyManager: manager,
     projectsDir: config.claudeProjectsDir,
     sessionsDir: config.claudeSessionsDir,
@@ -60,6 +94,43 @@ export function buildApp(config: Config, db: Db, serverVersion: string): AppBund
   const repoDiscovery = new RepoDiscoveryService(db, worktrees);
   const groups = new GroupManager(db);
 
+  // En-têtes de sécurité sur toute réponse + no-store sur les réponses sensibles (API/WS).
+  // onSend DOIT retourner le payload (sinon Fastify vide la réponse).
+  app.addHook('onSend', async (req, reply, payload) => {
+    reply.removeHeader('Server'); // anti-fingerprinting (no-op si absent)
+    for (const [k, v] of Object.entries(SECURITY_HEADERS)) reply.header(k, v);
+    if (isHttpsRequest(req)) {
+      reply.header('Strict-Transport-Security', 'max-age=31536000; includeSubDomains');
+    }
+    if (req.url.startsWith('/api/') || req.url.startsWith('/ws')) {
+      reply.header('Cache-Control', 'no-store, no-cache, must-revalidate, proxy-revalidate, max-age=0');
+    }
+    return payload;
+  });
+
+  // Garde CSRF defense-in-depth : une mutation porteuse d'un corps DOIT être en application/json
+  // (bloque les soumissions de formulaire cross-site en text/plain, que Fastify parserait sinon).
+  app.addHook('preHandler', async (req, reply) => {
+    if (!['POST', 'PATCH', 'PUT', 'DELETE'].includes(req.method)) return;
+    const len = req.headers['content-length'];
+    if (!len || len === '0') return; // pas de corps : rien à valider
+    const ct = (req.headers['content-type'] ?? '').toLowerCase();
+    if (!ct.startsWith('application/json')) {
+      return reply.status(415).send({ error: { code: 'UNSUPPORTED_MEDIA_TYPE', message: 'Content-Type must be application/json' } });
+    }
+  });
+
+  // Handler d'erreur : ne jamais fuiter de stack/chemin au client ; détail complet côté logs.
+  app.setErrorHandler((err: FastifyError, req, reply) => {
+    const status = err.statusCode && err.statusCode >= 400 && err.statusCode < 600 ? err.statusCode : 500;
+    if (status >= 500) {
+      req.log.error({ err }, 'unhandled error');
+      return reply.status(status).send({ error: { code: 'INTERNAL', message: 'Internal Server Error' } });
+    }
+    // erreurs client (4xx) : code générique, message court non sensible.
+    return reply.status(status).send({ error: { code: err.code ?? 'BAD_REQUEST', message: err.message } });
+  });
+
   void app.register(fastifyCookie);
   void app.register(fastifyWebsocket, {
     options: { maxPayload: 1024 * 1024 },
@@ -97,14 +168,16 @@ export function buildApp(config: Config, db: Db, serverVersion: string): AppBund
     }
   });
 
-  registerAuthRoutes(app, auth, limiter, serverVersion);
+  registerAuthRoutes(app, auth, limiter, serverVersion, db);
-  registerSessionRoutes(app, manager, discovery);
+  registerSessionRoutes(app, manager, discovery, db);
   registerRepoRoutes(app, worktrees, db);
-  registerGroupRoutes(app, groups);
+  registerGroupRoutes(app, groups, db, worktrees, manager);
-  registerWorktreeRoutes(app, worktrees);
+  registerWorktreeRoutes(app, worktrees, db);
-  registerPushRoutes(app, push);
+  registerPushRoutes(app, push, db);
   registerSettingsRoutes(app, db, config, serverVersion, push);
   registerFsRoutes(app);
+  registerAuditRoutes(app, db);
+  registerDataRoutes(app, db, auth);
   // La route websocket doit être déclarée APRÈS le chargement du plugin (contexte
   // encapsulé) — sinon le handler reçoit la signature REST (request, reply).
   void app.register(async (scoped) => {

packages/server/src/auth/service.ts

@@ -1,5 +1,7 @@
 import { createHash, createHmac, randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
 import { type Db, getSetting, setSetting } from '../db/index.js';
+import type { SecretBox } from '../core/secret-box.js';
+import { recordAudit } from '../core/audit-log.js';
 
 const COOKIE_NAME = 'arb_session';
 const COOKIE_TTL_MS = 30 * 24 * 3600 * 1000;
@@ -12,11 +14,21 @@ export interface AuthContext {
 export class AuthService {
   private readonly secret: Buffer;
 
-  constructor(private readonly db: Db) {
+  constructor(
-    let secretHex = getSetting(db, 'server_secret');
+    private readonly db: Db,
-    if (!secretHex) {
+    box?: SecretBox,
+  ) {
+    // server_secret chiffré au repos quand un SecretBox est fourni (prod). Migration douce :
+    // une valeur en clair pré-existante est re-chiffrée à la lecture.
+    const stored = getSetting(db, 'server_secret');
+    let secretHex: string;
+    if (!stored) {
       secretHex = randomBytes(32).toString('hex');
-      setSetting(db, 'server_secret', secretHex);
+      setSetting(db, 'server_secret', box ? box.encrypt(secretHex) : secretHex);
+      recordAudit(db, { actor: 'system', action: 'secret.generate', resourceId: 'server_secret' });
+    } else {
+      secretHex = box ? box.decrypt(stored) : stored;
+      if (box && !box.isEncrypted(stored)) setSetting(db, 'server_secret', box.encrypt(secretHex));
     }
     this.secret = Buffer.from(secretHex, 'hex');
   }

packages/server/src/config.ts

@@ -1,7 +1,7 @@
 import { parseArgs } from 'node:util';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
-import { mkdirSync } from 'node:fs';
+import { chmodSync, mkdirSync } from 'node:fs';
 
 export interface Config {
   port: number;
@@ -53,6 +53,14 @@ export function loadConfig(argv = process.argv.slice(2)): Config {
 
   const dataDir = join(process.env.XDG_DATA_HOME ?? join(homedir(), '.local', 'share'), 'arboretum');
   mkdirSync(dataDir, { recursive: true });
+  // La DB contient des secrets (server_secret, clé privée VAPID, hashs de tokens) : le dossier de
+  // données ne doit jamais être lisible par d'autres utilisateurs du système. chmod best-effort
+  // (peut échouer sur certains FS Windows/montés ; le démarrage avertit alors sans bloquer).
+  try {
+    chmodSync(dataDir, 0o700);
+  } catch {
+    /* FS sans permissions POSIX : ignoré, cf. avertissement dans db.openDb */
+  }
   const claudeHome = values['claude-home'] ?? join(homedir(), '.claude');
   return {
     port: Number(values.port),

packages/server/src/core/audit-log.ts

@@ -0,0 +1,65 @@
+// Journal d'audit : trace persistante des opérations sensibles (création/révocation de tokens,
+// changements de réglages, génération de secrets, abonnements push, CRUD groupes). Exigence de
+// conformité entreprise (GDPR/SOX/ISO 27001). Règle ABSOLUE : ne JAMAIS journaliser un secret en
+// clair — `details` ne contient que des métadonnées non sensibles (ids, labels, compteurs).
+import { randomUUID } from 'node:crypto';
+import type { AuditLogEntry } from '@arboretum/shared';
+import type { Db } from '../db/index.js';
+
+export type AuditResult = 'ok' | 'denied' | 'error';
+
+export interface AuditEntry {
+  /** tokenId de l'acteur, ou 'system' (opérations automatiques), ou 'anonymous' (avant auth). */
+  actor: string;
+  /** verbe.objet, ex. 'token.create', 'settings.update', 'login.failure'. */
+  action: string;
+  resourceId?: string | null;
+  details?: Record<string, unknown> | null;
+  result?: AuditResult;
+}
+
+/** Enregistre une entrée d'audit. Best-effort : une erreur d'écriture ne casse jamais l'opération métier. */
+export function recordAudit(db: Db, e: AuditEntry): void {
+  try {
+    db.prepare(
+      'INSERT INTO audit_logs (id, ts, actor, action, resource_id, details, result) VALUES (?, ?, ?, ?, ?, ?, ?)',
+    ).run(
+      randomUUID(),
+      new Date().toISOString(),
+      e.actor,
+      e.action,
+      e.resourceId ?? null,
+      e.details ? JSON.stringify(e.details) : null,
+      e.result ?? 'ok',
+    );
+  } catch {
+    /* l'audit ne doit jamais faire échouer l'action auditée */
+  }
+}
+
+/** Liste paginée par date décroissante (curseur `before` = ts strictement inférieur). */
+export function listAudit(db: Db, opts: { limit: number; before?: string | null }): AuditLogEntry[] {
+  const limit = Math.min(Math.max(Math.trunc(opts.limit) || 50, 1), 200);
+  const rows = (
+    opts.before
+      ? db
+          .prepare(
+            'SELECT id, ts, actor, action, resource_id AS resourceId, details, result FROM audit_logs WHERE ts < ? ORDER BY ts DESC LIMIT ?',
+          )
+          .all(opts.before, limit)
+      : db
+          .prepare(
+            'SELECT id, ts, actor, action, resource_id AS resourceId, details, result FROM audit_logs ORDER BY ts DESC LIMIT ?',
+          )
+          .all(limit)
+  ) as Array<{ id: string; ts: string; actor: string; action: string; resourceId: string | null; details: string | null; result: string }>;
+  return rows.map((r) => ({ ...r, details: r.details ? safeParse(r.details) : null }));
+}
+
+function safeParse(s: string): unknown {
+  try {
+    return JSON.parse(s);
+  } catch {
+    return s;
+  }
+}

packages/server/src/core/claude-launcher.ts

@@ -10,6 +10,8 @@ export interface SpawnOptions {
   command: 'claude' | 'bash';
   /** reprise d'une session existante (P2) : `--resume <id>`, `--fork-session` si fork. */
   resume?: { claudeSessionId: string; fork?: boolean };
+  /** répertoires supplémentaires à relier dans une seule session (P6) : `--add-dir <path>` répété. */
+  addDirs?: string[];
 }
 
 let cachedClaudeBin: string | null = null;
@@ -42,5 +44,7 @@ export function buildSpawnSpec(opts: SpawnOptions): SpawnSpec {
     args.push('--resume', opts.resume.claudeSessionId);
     if (opts.resume.fork) args.push('--fork-session');
   }
+  // Session de groupe : relie plusieurs repos/worktrees dans une seule session (P6).
+  for (const dir of opts.addDirs ?? []) args.push('--add-dir', dir);
   return { file: resolveClaudeBin(), args, env };
 }

packages/server/src/core/discovery-service.ts

@@ -7,6 +7,7 @@ import { join } from 'node:path';
 import type { SessionSummary } from '@arboretum/shared';
 import { scanProjects, type DiscoveredJsonl } from './jsonl-discovery.js';
 import { readRegistry, type RegistryEntry } from './session-registry.js';
+import { listHiddenSessionIds, type Db } from '../db/index.js';
 import type { PtyManager } from './pty-manager.js';
 
 const DEFAULT_REFRESH_MS = 10_000;
@@ -17,6 +18,7 @@ export interface DiscoveryServiceEvents {
 }
 
 export interface DiscoveryOptions {
+  db: Db;
   ptyManager: PtyManager;
   projectsDir?: string;
   sessionsDir?: string;
@@ -24,6 +26,7 @@ export interface DiscoveryOptions {
 }
 
 export class DiscoveryService extends EventEmitter<DiscoveryServiceEvents> {
+  private readonly db: Db;
   private readonly projectsDir: string;
   private readonly sessionsDir: string;
   private readonly ptyManager: PtyManager;
@@ -35,6 +38,7 @@ export class DiscoveryService extends EventEmitter<DiscoveryServiceEvents> {
 
   constructor(opts: DiscoveryOptions) {
     super();
+    this.db = opts.db;
     this.ptyManager = opts.ptyManager;
     this.projectsDir = opts.projectsDir ?? join(homedir(), '.claude', 'projects');
     this.sessionsDir = opts.sessionsDir ?? join(homedir(), '.claude', 'sessions');
@@ -81,6 +85,9 @@ export class DiscoveryService extends EventEmitter<DiscoveryServiceEvents> {
       if (r.claudeSessionId) regBySid.set(r.claudeSessionId, r);
     }
     const known = this.ptyManager.knownClaudeSessionIds();
+    // Sessions masquées par l'utilisateur : on les garde dans le cache (resume/fork possibles) mais
+    // marquées `hidden` → la route /sessions les exclut par défaut.
+    const hiddenIds = listHiddenSessionIds(this.db);
 
     // Dédoublonnage des JSONL par claudeSessionId (on retient le plus récent).
     const latest = new Map<string, DiscoveredJsonl>();
@@ -113,6 +120,7 @@ export class DiscoveryService extends EventEmitter<DiscoveryServiceEvents> {
         resumable: !live, // morte → --resume direct ; vivante → fork/observe (jamais resume : corruption)
         attachable: false, // Arboretum ne tient pas le PTY d'une session externe
         registryStatus: r?.status ?? null,
+        hidden: hiddenIds.has(d.claudeSessionId),
       });
     }
 

packages/server/src/core/git.ts

@@ -2,9 +2,11 @@
 // les chemins/refs utilisateur. Fonctions pures sans état, prenant un cwd déjà validé par l'appelant.
 import { execFile } from 'node:child_process';
 import { resolve, sep } from 'node:path';
-import type { WorktreeGitStatus } from '@arboretum/shared';
+import type { WorktreeGitStatus, WorktreeBranchAction, WorktreeBranchMode } from '@arboretum/shared';
 
 const GIT_TIMEOUT_MS = 10_000;
+// `push` peut dialoguer avec un remote (réseau) : on lui laisse une marge bien plus large.
+const GIT_PUSH_TIMEOUT_MS = 120_000;
 const GIT_MAX_BUFFER = 8 * 1024 * 1024;
 
 interface GitError extends Error {
@@ -12,14 +14,14 @@ interface GitError extends Error {
   code?: number | string;
 }
 
-function git(cwd: string, args: string[]): Promise<string> {
+function git(cwd: string, args: string[], timeoutMs: number = GIT_TIMEOUT_MS): Promise<string> {
   return new Promise((resolveP, reject) => {
     execFile(
       'git',
       args,
       {
         cwd,
-        timeout: GIT_TIMEOUT_MS,
+        timeout: timeoutMs,
         maxBuffer: GIT_MAX_BUFFER,
         // GIT_OPTIONAL_LOCKS=0 : pas de prise de verrou par `status` (perf + concurrence avec une
         // session claude active) ; LC_ALL=C : sortie stable pour le parsing.
@@ -140,6 +142,52 @@ export async function defaultBranch(repoPath: string): Promise<string | null> {
   }
 }
 
+/** Branche courante (nom court) du checkout en `repoPath`, ou null si HEAD détaché. */
+export async function currentBranch(repoPath: string): Promise<string | null> {
+  try {
+    const b = (await git(repoPath, ['rev-parse', '--abbrev-ref', 'HEAD'])).trim();
+    return b === 'HEAD' ? null : b;
+  } catch {
+    return null;
+  }
+}
+
+/** Existence d'une branche, en local (`refs/heads`) et/ou suivie du remote (`refs/remotes/origin`). */
+export async function branchExists(repoPath: string, branch: string): Promise<{ local: boolean; remote: boolean }> {
+  const verify = async (ref: string): Promise<boolean> => {
+    try {
+      await git(repoPath, ['rev-parse', '--verify', '--quiet', ref]);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  const [local, remote] = await Promise.all([verify(`refs/heads/${branch}`), verify(`refs/remotes/origin/${branch}`)]);
+  return { local, remote };
+}
+
+/** Branches locales + suivies de `origin` (noms courts) + branche par défaut — pour un sélecteur de base. */
+export async function listBranches(repoPath: string): Promise<{ local: string[]; remote: string[]; default: string | null }> {
+  const local: string[] = [];
+  const remote: string[] = [];
+  try {
+    const out = await git(repoPath, ['for-each-ref', '--format=%(refname:short)', 'refs/heads', 'refs/remotes/origin']);
+    for (const line of out.split('\n')) {
+      const name = line.trim();
+      if (!name) continue;
+      if (name.startsWith('origin/')) {
+        const short = name.slice('origin/'.length);
+        if (short && short !== 'HEAD') remote.push(short);
+      } else {
+        local.push(name);
+      }
+    }
+  } catch {
+    /* dépôt sans refs encore (premier commit absent) → listes vides */
+  }
+  return { local, remote, default: await defaultBranch(repoPath) };
+}
+
 export async function listWorktrees(repoPath: string): Promise<ParsedWorktree[]> {
   return parseWorktreePorcelain(await git(repoPath, ['worktree', 'list', '--porcelain']));
 }
@@ -175,19 +223,79 @@ export async function worktreeStatus(worktreePath: string): Promise<WorktreeGitS
   return { ahead, behind, dirtyCount, upstream };
 }
 
+/** Point de départ d'une branche créée : `baseRef` explicite, sinon la branche par défaut du dépôt
+ * (locale ou suivie de `origin`), sinon undefined (git part alors du HEAD courant). */
+async function resolveStartPoint(repoPath: string, baseRef?: string): Promise<string | undefined> {
+  if (baseRef) return baseRef;
+  const def = await defaultBranch(repoPath);
+  if (!def) return undefined;
+  const { local, remote } = await branchExists(repoPath, def);
+  if (local) return def;
+  if (remote) return `origin/${def}`;
+  return undefined;
+}
+
+/**
+ * Crée un worktree en résolvant la branche selon `mode` (voir `WorktreeBranchMode`). Renvoie l'action
+ * effective. En mode `auto`, on choisit checkout / suivi-remote / création selon l'existence réelle de
+ * la branche — indispensable pour les groupes hétérogènes (branche présente dans certains dépôts seulement).
+ */
 export async function addWorktree(
   repoPath: string,
-  opts: { path: string; branch: string; newBranch: boolean; baseRef?: string },
+  opts: { path: string; branch: string; mode: WorktreeBranchMode; baseRef?: string },
-): Promise<void> {
+): Promise<WorktreeBranchAction> {
+  const { local, remote } = await branchExists(repoPath, opts.branch);
+  let action: WorktreeBranchAction;
+  if (opts.mode === 'create') action = 'created';
+  else if (opts.mode === 'checkout') action = local ? 'reused' : 'tracked';
+  else action = local ? 'reused' : remote ? 'tracked' : 'created'; // auto
+
   const args = ['worktree', 'add'];
-  if (opts.newBranch) args.push('-b', opts.branch);
+  if (action === 'reused') {
-  args.push('--', opts.path);
+    args.push('--', opts.path, opts.branch);
-  if (opts.newBranch) {
+  } else if (action === 'tracked') {
-    if (opts.baseRef) args.push(opts.baseRef);
+    args.push('--track', '-b', opts.branch, '--', opts.path, `origin/${opts.branch}`);
   } else {
-    args.push(opts.branch);
+    const start = await resolveStartPoint(repoPath, opts.baseRef);
+    args.push('-b', opts.branch, '--', opts.path);
+    if (start) args.push(start);
   }
   await git(repoPath, args);
+  return action;
+}
+
+/** `git add -A` puis commit. L'appelant garantit qu'il y a quelque chose à committer. */
+export async function commitAll(repoPath: string, message: string): Promise<void> {
+  await git(repoPath, ['add', '-A']);
+  await git(repoPath, ['commit', '-m', message]);
+}
+
+/** Pousse la branche courante. Si aucun upstream n'est configuré : `git push -u origin <branche>`. */
+export async function push(repoPath: string): Promise<void> {
+  let hasUpstream = false;
+  try {
+    await git(repoPath, ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}']);
+    hasUpstream = true;
+  } catch {
+    hasUpstream = false;
+  }
+  if (hasUpstream) {
+    await git(repoPath, ['push'], GIT_PUSH_TIMEOUT_MS);
+  } else {
+    const branch = await currentBranch(repoPath);
+    if (!branch) throw new Error('cannot push a detached HEAD');
+    await git(repoPath, ['push', '-u', 'origin', branch], GIT_PUSH_TIMEOUT_MS);
+  }
+}
+
+/**
+ * Crée/bascule une branche dans le checkout (worktree) en `repoPath` — utilisé pour démarrer une
+ * session sur la branche principale sans worktree dédié. `create` → `git switch -c <branch>` (échoue
+ * si la branche existe) ; sinon `git switch <branch>` (branche existante). Pas de `--` : l'argument
+ * est une réf (pas un pathspec) et le nom est déjà filtré en amont par `isValidBranchName` (anti-flag).
+ */
+export async function switchBranch(repoPath: string, opts: { branch: string; create: boolean }): Promise<void> {
+  await git(repoPath, opts.create ? ['switch', '-c', opts.branch] : ['switch', opts.branch]);
 }
 
 export async function removeWorktree(repoPath: string, worktreePath: string, force: boolean): Promise<void> {

packages/server/src/core/group-manager.ts

@@ -167,6 +167,8 @@ export class GroupManager extends EventEmitter<GroupManagerEvents> {
     // CASCADE (PRAGMA foreign_keys = ON) purge group_repos.
     const res = this.db.prepare('DELETE FROM groups WHERE id = ?').run(id);
     if (res.changes === 0) return false;
+    // Les sessions de groupe (P6) ne sont pas en FK : on désorpheline leur group_id manuellement.
+    this.db.prepare('UPDATE sessions SET group_id = NULL WHERE group_id = ?').run(id);
     this.emit('group_removed', id);
     return true;
   }

packages/server/src/core/group-session.ts

@@ -0,0 +1,37 @@
+import { parse, resolve, sep } from 'node:path';
+
+/**
+ * Plus long ancêtre commun d'un ensemble de chemins absolus (par segments, jamais par préfixe
+ * de chaîne — `/a/bc` n'est PAS un ancêtre de `/a/bcd`). Pour un seul chemin, renvoie ce chemin.
+ */
+export function commonAncestorDir(paths: string[]): string {
+  const first = paths[0];
+  if (first === undefined) throw new Error('commonAncestorDir: empty input');
+  const firstSegs = resolve(first).split(sep);
+  let common = firstSegs.length;
+  for (let i = 1; i < paths.length; i++) {
+    const segs = resolve(paths[i]!).split(sep);
+    let k = 0;
+    while (k < common && k < segs.length && segs[k] === firstSegs[k]) k++;
+    common = k;
+  }
+  const joined = firstSegs.slice(0, common).join(sep);
+  // `['', 'a', 'b'].slice(0,1).join('/')` === '' → racine POSIX ; rétablir le séparateur racine.
+  return joined === '' ? parse(resolve(first)).root : joined;
+}
+
+/**
+ * Politique de répertoire de travail d'une session de groupe (P6) : le `cwd` est le PARENT COMMUN
+ * des répertoires couverts (racine neutre, chemins relatifs cross-repo naturels), chaque répertoire
+ * étant ensuite relié via `--add-dir` (le dédoublonnage + filtrage du cwd est fait par `PtyManager`).
+ * Garde-fou : si le parent commun est la racine du FS (repos éparpillés sur des racines différentes),
+ * on retombe sur le premier répertoire pour ne pas accorder à Claude la permission sur tout le disque.
+ */
+export function resolveGroupCwd(dirs: string[]): { cwd: string; addDirs: string[] } {
+  const first = dirs[0];
+  if (first === undefined) throw new Error('resolveGroupCwd: empty input');
+  const ancestor = commonAncestorDir(dirs);
+  const root = parse(resolve(first)).root;
+  const cwd = ancestor === root ? first : ancestor;
+  return { cwd, addDirs: dirs };
+}

packages/server/src/core/pty-manager.ts

@@ -12,7 +12,9 @@ import { SessionActivityTracker } from './claude-adapter.js';
 import type { PushService } from './push-service.js';
 import type { Db } from '../db/index.js';
 
-const RING_CAPACITY = 2 * 1024 * 1024;
+// 4 Mo : conserve assez d'historique pour que le replay (REPLAY_TAIL_BYTES = 1 Mo) reste largement
+// dans le ring et qu'on puisse remonter une conversation Claude après ré-attache.
+const RING_CAPACITY = 4 * 1024 * 1024;
 const KILL_GRACE_MS = 5000;
 /** Délai avant envoi d'une notif push sur passage en `waiting` : annulé si la session repart (faux positif). */
 const NOTIFY_DEBOUNCE_MS = 1500;
@@ -20,6 +22,17 @@ const NOTIFY_DEBOUNCE_MS = 1500;
 const CLAUDE_ID_POLL_MS = 400;
 const CLAUDE_ID_TIMEOUT_MS = 60_000;
 
+/** Parse la colonne `added_dirs` (JSON array de chemins) de façon défensive ; [] si NULL/invalide. */
+function parseAddedDirs(raw: string | null): string[] {
+  if (!raw) return [];
+  try {
+    const v = JSON.parse(raw);
+    return Array.isArray(v) ? v.filter((x): x is string => typeof x === 'string') : [];
+  } catch {
+    return [];
+  }
+}
+
 /** Lien entre un client WS attaché et une session. La gateway fournit les callbacks d'envoi. */
 export interface ClientBinding {
   channel: number;
@@ -48,6 +61,10 @@ interface ManagedSession {
   killTimer: NodeJS.Timeout | null;
   /** ID interne du CLI claude, résolu via le registre après spawn (null pour bash / pas encore prêt). */
   claudeSessionId: string | null;
+  /** répertoires supplémentaires reliés dans la session (--add-dir) ; [] pour une session mono-repo (P6). */
+  addedDirs: string[];
+  /** groupe propriétaire d'une session de groupe multi-repo ; null sinon (P6). */
+  groupId: string | null;
   /** détection d'état fin (busy/waiting/idle + dialogue) ; null pour bash (P3-B). */
   tracker: SessionActivityTracker | null;
   /** dernière activité notifiée (détection du front montant vers `waiting` pour le push P4-B). */
@@ -72,14 +89,33 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
     super();
   }
 
-  spawn(opts: { cwd: string; command?: 'claude' | 'bash'; resume?: { claudeSessionId: string; fork?: boolean } }): SessionSummary {
+  spawn(opts: {
+    cwd: string;
+    command?: 'claude' | 'bash';
+    resume?: { claudeSessionId: string; fork?: boolean };
+    /** répertoires supplémentaires à relier (session de groupe multi-repo, P6). */
+    addDirs?: string[];
+    /** groupe propriétaire (session de groupe, P6). */
+    groupId?: string;
+  }): SessionSummary {
     const cwd = opts.cwd;
     if (!existsSync(cwd) || !statSync(cwd).isDirectory()) {
       throw Object.assign(new Error(`Not a directory: ${cwd}`), { statusCode: 400 });
     }
+    // Dédoublonne et écarte le cwd primaire ; valide chaque répertoire supplémentaire (comme le cwd).
+    const addedDirs = [...new Set(opts.addDirs ?? [])].filter((d) => d !== cwd);
+    for (const dir of addedDirs) {
+      if (!existsSync(dir) || !statSync(dir).isDirectory()) {
+        throw Object.assign(new Error(`Not a directory: ${dir}`), { statusCode: 400 });
+      }
+    }
     // Un resume/fork est toujours une session claude (le cwd d'origine est garanti par l'appelant — S1).
     const command = opts.resume ? 'claude' : (opts.command ?? 'claude');
-    const spec = buildSpawnSpec({ command, ...(opts.resume ? { resume: opts.resume } : {}) });
+    const spec = buildSpawnSpec({
+      command,
+      ...(opts.resume ? { resume: opts.resume } : {}),
+      ...(addedDirs.length ? { addDirs: addedDirs } : {}),
+    });
     const id = randomUUID();
     const proc = pty.spawn(spec.file, spec.args, {
       name: 'xterm-256color',
@@ -101,6 +137,8 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
       exited: null,
       killTimer: null,
       claudeSessionId: null,
+      addedDirs,
+      groupId: opts.groupId ?? null,
       tracker: null,
       prevActivity: null,
       notifyTimer: null,
@@ -116,8 +154,16 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
     }
     this.live.set(id, session);
     this.db
-      .prepare('INSERT INTO sessions (id, cwd, command, created_at, resumed_from) VALUES (?, ?, ?, ?, ?)')
+      .prepare('INSERT INTO sessions (id, cwd, command, created_at, resumed_from, added_dirs, group_id) VALUES (?, ?, ?, ?, ?, ?, ?)')
-      .run(id, cwd, command, session.createdAt, opts.resume?.claudeSessionId ?? null);
+      .run(
+        id,
+        cwd,
+        command,
+        session.createdAt,
+        opts.resume?.claudeSessionId ?? null,
+        addedDirs.length ? JSON.stringify(addedDirs) : null,
+        session.groupId,
+      );
 
     proc.onData((data) => this.handleOutput(session, Buffer.from(data, 'utf8')));
     proc.onExit(({ exitCode, signal }) => this.handleExit(session, exitCode, signal ?? null));
@@ -145,6 +191,36 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
     setTimeout(tick, CLAUDE_ID_POLL_MS).unref();
   }
 
+  /**
+   * Contexte de session de groupe (P6) à réinjecter au resume : derniers `added_dirs`/`group_id`
+   * persistés pour ce claudeSessionId. Permet à `--resume` de re-relier les mêmes répertoires.
+   */
+  groupSessionContext(claudeSessionId: string): { addedDirs: string[]; groupId: string | null } | null {
+    const row = this.db
+      .prepare('SELECT added_dirs, group_id FROM sessions WHERE claude_session_id = ? AND added_dirs IS NOT NULL ORDER BY created_at DESC LIMIT 1')
+      .get(claudeSessionId) as { added_dirs: string | null; group_id: string | null } | undefined;
+    if (!row) return null;
+    return { addedDirs: parseAddedDirs(row.added_dirs), groupId: row.group_id };
+  }
+
+  /**
+   * Cible de reprise d'une session managée MORTE (P2/P6), résolue par UUID Arboretum : son cwd
+   * d'origine, son claudeSessionId et son contexte de groupe, lus en DB. null si l'id ne correspond
+   * pas à une session managée morte, reprenable (claude + claudeSessionId connu).
+   * Complète `DiscoveryService.getDiscovered`, qui ne couvre QUE les sessions claude EXTERNES
+   * (une managée connue est justement exclue de la découverte).
+   */
+  resumeTargetById(id: string): { cwd: string; claudeSessionId: string; addedDirs: string[]; groupId: string | null } | null {
+    if (this.live.has(id)) return null; // vivante : pas de resume direct (fork via le même chemin)
+    const row = this.db
+      .prepare(
+        "SELECT cwd, claude_session_id, added_dirs, group_id FROM sessions WHERE id = ? AND ended_at IS NOT NULL AND claude_session_id IS NOT NULL AND command = 'claude'",
+      )
+      .get(id) as { cwd: string; claude_session_id: string; added_dirs: string | null; group_id: string | null } | undefined;
+    if (!row) return null;
+    return { cwd: row.cwd, claudeSessionId: row.claude_session_id, addedDirs: parseAddedDirs(row.added_dirs), groupId: row.group_id };
+  }
+
   /** Session managée VIVANTE portant ce claudeSessionId (garde-fou anti-resume d'une session vivante). */
   findLiveByClaudeSessionId(claudeSessionId: string): SessionSummary | null {
     for (const s of this.live.values()) {
@@ -170,29 +246,34 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
     const liveSummaries = [...this.live.values()].map((s) => this.summarize(s));
     const liveIds = new Set(this.live.keys());
     const rows = this.db
-      .prepare('SELECT id, cwd, command, title, created_at, ended_at, exit_code, claude_session_id FROM sessions ORDER BY created_at DESC LIMIT 100')
+      .prepare('SELECT id, cwd, command, title, created_at, ended_at, exit_code, claude_session_id, added_dirs, group_id FROM sessions ORDER BY created_at DESC LIMIT 100')
-      .all() as Array<{ id: string; cwd: string; command: string; title: string | null; created_at: string; ended_at: string | null; exit_code: number | null; claude_session_id: string | null }>;
+      .all() as Array<{ id: string; cwd: string; command: string; title: string | null; created_at: string; ended_at: string | null; exit_code: number | null; claude_session_id: string | null; added_dirs: string | null; group_id: string | null }>;
     const historical: SessionSummary[] = rows
       .filter((r) => !liveIds.has(r.id))
-      .map((r) => ({
+      .map((r) => {
+        const addedDirs = parseAddedDirs(r.added_dirs);
+        return {
           id: r.id,
           cwd: r.cwd,
           command: r.command,
           title: r.title,
-        status: 'exited',
+          status: 'exited' as const,
           live: false,
           createdAt: r.created_at,
           endedAt: r.ended_at,
           exitCode: r.exit_code,
           clients: 0,
-        source: 'managed',
+          source: 'managed' as const,
           claudeSessionId: r.claude_session_id,
           pid: null,
           // une session claude morte avec un claudeSessionId connu est reprenable (--resume direct).
           resumable: r.command === 'claude' && r.claude_session_id != null,
           attachable: false,
           registryStatus: null,
-      }));
+          ...(addedDirs.length ? { addedDirs } : {}),
+          groupId: r.group_id,
+        };
+      });
     return [...liveSummaries, ...historical];
   }
 
@@ -427,6 +508,8 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
       activity: act?.activity ?? null,
       waitingFor: act?.waitingFor ?? null,
       dialog: act?.dialog ?? null,
+      ...(s.addedDirs.length ? { addedDirs: s.addedDirs } : {}),
+      groupId: s.groupId,
     };
   }
 }

packages/server/src/core/push-service.ts

@@ -4,6 +4,8 @@
 import { randomUUID } from 'node:crypto';
 import { createRequire } from 'node:module';
 import { type Db, getSetting, setSetting } from '../db/index.js';
+import type { SecretBox } from './secret-box.js';
+import { recordAudit } from './audit-log.js';
 
 // web-push est publié en CommonJS : on le charge via require (verbatimModuleSyntax + NodeNext),
 // typé par l'import type — même pattern que @xterm/headless dans screen-reader.ts.
@@ -47,16 +49,22 @@ export class PushService {
     private readonly db: Db,
     private readonly contact: string = 'mailto:arboretum@localhost',
     sender?: PushSender,
+    box?: SecretBox,
   ) {
     this.send = sender ?? ((sub, payload, options) => webpush.sendNotification(sub, payload, options as Parameters<typeof webpush.sendNotification>[2]));
-    let pub = getSetting(db, 'vapid_public');
+    let pub = getSetting(db, 'vapid_public'); // clé publique : jamais chiffrée (sûre à exposer)
-    let priv = getSetting(db, 'vapid_private');
+    const storedPriv = getSetting(db, 'vapid_private');
+    let priv = storedPriv ? (box ? box.decrypt(storedPriv) : storedPriv) : null;
     if (!pub || !priv) {
       const keys = webpush.generateVAPIDKeys();
       pub = keys.publicKey;
       priv = keys.privateKey;
       setSetting(db, 'vapid_public', pub);
-      setSetting(db, 'vapid_private', priv);
+      setSetting(db, 'vapid_private', box ? box.encrypt(priv) : priv);
+      recordAudit(db, { actor: 'system', action: 'secret.generate', resourceId: 'vapid' });
+    } else if (box && storedPriv && !box.isEncrypted(storedPriv)) {
+      // migration douce : clé privée pré-existante en clair → re-chiffrée.
+      setSetting(db, 'vapid_private', box.encrypt(priv));
     }
     this.vapidPublic = pub;
     this.vapidPrivate = priv;

packages/server/src/core/repo-scanner.ts

@@ -37,7 +37,9 @@ interface Frame {
  * Parcours itératif (pile explicite, jamais de récursion non bornée) des `roots`.
  * Règles :
  *  - un dossier contenant `.git` (fichier OU dossier → couvre les worktrees liés) est un repo :
- *    on l'enregistre et on NE descend PAS dedans (sous-modules/worktrees imbriqués ignorés) ;
+ *    on l'enregistre ; en profondeur on NE descend PAS dedans (sous-modules/worktrees imbriqués
+ *    ignorés). EXCEPTION : une racine fournie (depth 0) qui est elle-même un repo est aussi un
+ *    conteneur — on l'enregistre ET on continue de descendre pour trouver les repos internes ;
  *  - on n'empile que les vrais sous-dossiers (`d.isDirectory()`), donc les symlinks ne sont PAS
  *    suivis (anti-cycle + anti-sortie de racine), et on saute dotdirs + excludeDirs ;
  *  - bornes : `maxDepth`, `maxRepos`, et un éventuel `signal` (timeout global) ;
@@ -68,10 +70,13 @@ export async function scanForRepos(
     if (seen.has(dir)) continue;
     seen.add(dir);
 
-    // un repo : on l'enregistre et on ne descend pas.
+    // Un dossier avec `.git` est un repo. En PROFONDEUR (depth > 0) c'est une feuille : on
+    // l'enregistre sans descendre (on n'ouvre pas les sous-modules/worktrees imbriqués). Mais une
+    // RACINE fournie explicitement (depth 0) est un CONTENEUR de scan : si elle est elle-même un
+    // repo on l'enregistre, puis on CONTINUE de descendre pour découvrir les dépôts qu'elle contient.
     if (existsSync(join(dir, '.git'))) {
       found.add(dir);
-      continue;
+      if (depth > 0) continue;
     }
     if (depth >= limits.maxDepth) continue;
 

packages/server/src/core/scan-settings.ts

@@ -1,7 +1,6 @@
 // Réglages de la découverte auto des repos, persistés dans la table `settings` (clé/valeur).
 // Frontière de sécurité : ces clés sont NON sensibles et n'entrent dans l'allow-list du PATCH
 // /api/v1/settings que via les validateurs ci-dessous. Aucun secret ne transite par ici.
-import { homedir } from 'node:os';
 import { getSetting } from '../db/index.js';
 import type { Db } from '../db/index.js';
 import { isSafeAbsolutePath } from './git.js';
@@ -15,12 +14,14 @@ export const DEFAULT_SCAN_INTERVAL_MIN = 5;
 export const MAX_SCAN_INTERVAL_MIN = 1440;
 export const MAX_SCAN_ROOTS = 16;
 
-/** Racines à scanner. Défaut : le home de l'utilisateur. Lecture tolérante (JSON malformé → défaut). */
+/**
+ * Racines à scanner. Défaut : AUCUNE racine → aucun scan (clean install).
+ * L'utilisateur ajoute ses racines via Réglages → Découverte. Lecture tolérante (JSON malformé → []).
+ */
 export function readScanRoots(db: Db): string[] {
   const raw = getSetting(db, SCAN_ROOTS_KEY);
-  if (!raw) return [homedir()];
+  if (!raw) return [];
-  const parsed = normalizeScanRoots(safeParse(raw));
+  return normalizeScanRoots(safeParse(raw)) ?? [];
-  return parsed && parsed.length > 0 ? parsed : [homedir()];
 }
 
 /** Intervalle périodique en minutes (0 = désactivé). Défaut DEFAULT_SCAN_INTERVAL_MIN. */

packages/server/src/core/secret-box.ts

@@ -0,0 +1,69 @@
+// Chiffrement au repos des secrets applicatifs (server_secret HMAC, clé privée VAPID) stockés dans
+// la table `settings`. node:sqlite (DatabaseSync) ne supporte pas sqlcipher → on chiffre au niveau
+// applicatif les VALEURS sensibles, en AES-256-GCM (authentifié), avant insertion.
+//
+// Gestion de clé (par ordre de priorité) :
+//   1. ARBORETUM_SECRET_KEY (variable d'env) → vraie protection : la clé ne vit pas sur le disque,
+//      donc une fuite de la base seule (backup, WAL) ne révèle pas les secrets ;
+//   2. sinon, fichier clé `dataDir/secret.key` (0o600), généré au 1er démarrage. Protection partielle :
+//      couvre la fuite de la base seule, PAS celle du dossier de données complet (clé + base ensemble).
+// Compromis assumé et documenté (docs/ENTERPRISE_DEPLOYMENT.md) : pour une protection forte, fournir
+// ARBORETUM_SECRET_KEY et sauvegarder cette clé séparément des backups de la base.
+import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from 'node:crypto';
+import { chmodSync, existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const PREFIX = 'v1:'; // versionne le format ; absence de préfixe = valeur en clair (legacy → migration douce)
+const SCRYPT_SALT = 'arboretum-secret-box-v1'; // sel fixe : l'entropie vient de la passphrase fournie
+
+export class SecretBox {
+  constructor(private readonly key: Buffer) {}
+
+  /** Chiffre en `v1:<iv>:<tag>:<ciphertext>` (hex). */
+  encrypt(plaintext: string): string {
+    const iv = randomBytes(12);
+    const cipher = createCipheriv('aes-256-gcm', this.key, iv);
+    const ct = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    return `${PREFIX}${iv.toString('hex')}:${tag.toString('hex')}:${ct.toString('hex')}`;
+  }
+
+  /** Déchiffre une valeur `v1:` ; une valeur sans préfixe est retournée telle quelle (clair legacy). */
+  decrypt(stored: string): string {
+    if (!this.isEncrypted(stored)) return stored;
+    const [, ivHex, tagHex, ctHex] = stored.split(':');
+    if (!ivHex || !tagHex || !ctHex) throw new Error('secret-box: format chiffré invalide');
+    const decipher = createDecipheriv('aes-256-gcm', this.key, Buffer.from(ivHex, 'hex'));
+    decipher.setAuthTag(Buffer.from(tagHex, 'hex'));
+    return Buffer.concat([decipher.update(Buffer.from(ctHex, 'hex')), decipher.final()]).toString('utf8');
+  }
+
+  isEncrypted(stored: string): boolean {
+    return stored.startsWith(PREFIX);
+  }
+}
+
+/**
+ * Construit le SecretBox de production : clé dérivée d'ARBORETUM_SECRET_KEY si fournie, sinon
+ * d'un fichier clé `dataDir/secret.key` (0o600) généré au besoin.
+ */
+export function loadSecretBox(dataDir: string): SecretBox {
+  const passphrase = process.env.ARBORETUM_SECRET_KEY;
+  if (passphrase && passphrase.length > 0) {
+    return new SecretBox(scryptSync(passphrase, SCRYPT_SALT, 32));
+  }
+  const keyPath = join(dataDir, 'secret.key');
+  let keyHex: string;
+  if (existsSync(keyPath)) {
+    keyHex = readFileSync(keyPath, 'utf8').trim();
+  } else {
+    keyHex = randomBytes(32).toString('hex');
+    writeFileSync(keyPath, keyHex + '\n', { mode: 0o600 });
+  }
+  try {
+    chmodSync(keyPath, 0o600);
+  } catch {
+    /* FS sans permissions POSIX : ignoré */
+  }
+  return new SecretBox(Buffer.from(keyHex, 'hex'));
+}

packages/server/src/core/worktree-manager.ts

@@ -12,6 +12,8 @@ import type {
   PostCreateHook,
   RepoSummary,
   SessionSummary,
+  WorktreeBranchAction,
+  WorktreeBranchMode,
   WorktreeGitStatus,
   WorktreeSummary,
 } from '@arboretum/shared';
@@ -22,14 +24,18 @@ import { scanForRepos } from './repo-scanner.js';
 import { preTrustProject } from './claude-trust.js';
 import {
   addWorktree,
+  commitAll,
   defaultBranch,
   isDirtyWorktreeError,
   isRepo,
   isSafeAbsolutePath,
   isValidBranchName,
+  listBranches,
   listWorktrees,
   pruneWorktrees,
+  push,
   removeWorktree,
+  switchBranch,
   worktreeStatus,
   type ParsedWorktree,
 } from './git.js';
@@ -244,10 +250,18 @@ export class WorktreeManager extends EventEmitter<WorktreeManagerEvents> {
 
   // ---- worktrees ----
 
-  /** Sessions (managées + découvertes) dont le cwd correspond à ce chemin de worktree. */
+  /**
-  private sessionsForCwd(path: string): SessionSummary[] {
+   * Sessions (managées + découvertes) dont le cwd correspond à ce chemin de worktree.
+   * Les sessions explicitement masquées (`hidden`) sont exclues — cohérent avec `/api/v1/sessions`
+   * (sans quoi le masquage était ignoré dans les fiches worktree). Le tri managées/externes est laissé
+   * au client (interrupteur « afficher les externes »), qui dispose du champ `source`. La garde de
+   * suppression réclame en revanche TOUTES les sessions vivantes (`includeHidden`) pour rester sûre.
+   */
+  private sessionsForCwd(path: string, opts?: { includeHidden?: boolean }): SessionSummary[] {
     const rp = resolve(path);
-    return mergeSessions(this.ptyManager.list(), this.discovery.list()).filter((s) => resolve(s.cwd) === rp);
+    return mergeSessions(this.ptyManager.list(), this.discovery.list())
+      .filter((s) => resolve(s.cwd) === rp)
+      .filter((s) => opts?.includeHidden || !s.hidden);
   }
 
   private toSummary(repoId: string, repoPath: string, w: ParsedWorktree, status: WorktreeGitStatus): WorktreeSummary {
@@ -321,8 +335,8 @@ export class WorktreeManager extends EventEmitter<WorktreeManagerEvents> {
 
   async createWorktree(
     repoId: string,
-    req: { branch: string; newBranch: boolean; baseRef?: string; path?: string; runHooks?: boolean; preTrust?: boolean; startSession?: 'claude' | 'bash' | null },
+    req: { branch: string; mode?: WorktreeBranchMode; baseRef?: string; path?: string; runHooks?: boolean; preTrust?: boolean; startSession?: 'claude' | 'bash' | null },
-  ): Promise<{ worktree: WorktreeSummary; hookResults: HookRunResult[]; session: SessionSummary | null }> {
+  ): Promise<{ worktree: WorktreeSummary; hookResults: HookRunResult[]; session: SessionSummary | null; action: WorktreeBranchAction }> {
     const row = this.getRepoRow(repoId);
     if (!row) throw httpError(404, 'NOT_FOUND', 'No repo with this id');
     if (!isValidBranchName(req.branch)) throw httpError(400, 'BAD_BRANCH', `Invalid branch name: ${req.branch}`);
@@ -331,8 +345,9 @@ export class WorktreeManager extends EventEmitter<WorktreeManagerEvents> {
     if (existsSync(path)) throw httpError(409, 'PATH_EXISTS', `Path already exists: ${path}`);
 
     return this.withLock(repoId, async () => {
+      let action: WorktreeBranchAction;
       try {
-        await addWorktree(row.path, { path, branch: req.branch, newBranch: req.newBranch, ...(req.baseRef ? { baseRef: req.baseRef } : {}) });
+        action = await addWorktree(row.path, { path, branch: req.branch, mode: req.mode ?? 'auto', ...(req.baseRef ? { baseRef: req.baseRef } : {}) });
       } catch (err) {
         throw httpError(400, 'WORKTREE_ADD_FAILED', (err as Error).message);
       }
@@ -351,7 +366,128 @@ export class WorktreeManager extends EventEmitter<WorktreeManagerEvents> {
       if (req.startSession) session = this.ptyManager.spawn({ cwd: path, command: req.startSession });
 
       const worktree = (await this.emitWorktree(row, path)) ?? this.toSummary(row.id, row.path, { path, head: null, branch: req.branch, detached: false, locked: false, prunable: false, bare: false }, { ahead: 0, behind: 0, dirtyCount: 0, upstream: null });
-      return { worktree, hookResults, session };
+      return { worktree, hookResults, session, action };
+    });
+  }
+
+  /** Branches locales/remote + branche par défaut d'un repo — alimente le sélecteur de base côté UI. */
+  async listRepoBranches(repoId: string): Promise<{ local: string[]; remote: string[]; default: string | null }> {
+    const row = this.getRepoRow(repoId);
+    if (!row) throw httpError(404, 'NOT_FOUND', 'No repo with this id');
+    return listBranches(row.path);
+  }
+
+  /** `git add -A` + commit dans le worktree visé (le checkout principal est un worktree valide ici). */
+  async commitWorktree(repoId: string, path: string, message: string): Promise<WorktreeSummary> {
+    const row = this.getRepoRow(repoId);
+    if (!row) throw httpError(404, 'NOT_FOUND', 'No repo with this id');
+    const w = await this.findWorktree(row, path);
+    if (!w) throw httpError(404, 'NOT_FOUND', 'No such worktree under this repo');
+    return this.withLock(repoId, async () => {
+      if ((await worktreeStatus(w.path)).dirtyCount === 0) {
+        throw httpError(409, 'NOTHING_TO_COMMIT', 'Nothing to commit — working tree is clean');
+      }
+      try {
+        await commitAll(w.path, message);
+      } catch (err) {
+        throw httpError(400, 'COMMIT_FAILED', (err as Error).message);
+      }
+      this.factsCache.delete(repoId);
+      return (await this.emitWorktree(row, w.path)) as WorktreeSummary;
+    });
+  }
+
+  /** Pousse la branche du worktree visé (upstream auto si absent). */
+  async pushWorktree(repoId: string, path: string): Promise<WorktreeSummary> {
+    const row = this.getRepoRow(repoId);
+    if (!row) throw httpError(404, 'NOT_FOUND', 'No repo with this id');
+    const w = await this.findWorktree(row, path);
+    if (!w) throw httpError(404, 'NOT_FOUND', 'No such worktree under this repo');
+    return this.withLock(repoId, async () => {
+      try {
+        await push(w.path);
+      } catch (err) {
+        throw httpError(400, 'PUSH_FAILED', (err as Error).message);
+      }
+      this.factsCache.delete(repoId);
+      return (await this.emitWorktree(row, w.path)) as WorktreeSummary;
+    });
+  }
+
+  /**
+   * « Passer en principal » : la branche du worktree devient le checkout principal du dépôt. Une branche
+   * ne pouvant être extraite qu'à un seul endroit, on retire d'abord le worktree (libère la branche) puis
+   * on bascule le checkout principal dessus. Sans merge ni conflit possible. L'ancienne branche principale
+   * est conservée (jamais supprimée). Garde-fous d'arbre sale outrepassables par `force`.
+   */
+  async promoteWorktree(repoId: string, path: string, force = false): Promise<WorktreeSummary | null> {
+    const row = this.getRepoRow(repoId);
+    if (!row) throw httpError(404, 'NOT_FOUND', 'No repo with this id');
+    const w = await this.findWorktree(row, path);
+    if (!w) throw httpError(404, 'NOT_FOUND', 'No such worktree under this repo');
+    if (resolve(w.path) === resolve(row.path)) throw httpError(400, 'IS_MAIN_WORKTREE', 'This is already the main checkout');
+    if (!w.branch || w.detached) throw httpError(400, 'DETACHED_WORKTREE', 'Worktree has no branch to promote (detached HEAD)');
+    const branch = w.branch;
+    return this.withLock(repoId, async () => {
+      if (!force) {
+        if ((await worktreeStatus(w.path)).dirtyCount > 0) {
+          throw httpError(409, 'WORKTREE_DIRTY', 'Worktree has uncommitted changes — commit or pass force');
+        }
+        if ((await worktreeStatus(row.path)).dirtyCount > 0) {
+          throw httpError(409, 'DIRTY_TREE', 'Main checkout has uncommitted changes — commit/stash or pass force');
+        }
+      }
+      try {
+        await removeWorktree(row.path, w.path, force);
+      } catch (err) {
+        if (!force && isDirtyWorktreeError(err)) {
+          throw httpError(409, 'WORKTREE_DIRTY', 'Worktree has uncommitted changes — pass force to promote anyway');
+        }
+        throw httpError(500, 'WORKTREE_REMOVE_FAILED', (err as Error).message);
+      }
+      try {
+        await switchBranch(row.path, { branch, create: false });
+      } catch (err) {
+        throw httpError(500, 'SWITCH_FAILED', (err as Error).message);
+      }
+      this.factsCache.delete(repoId);
+      this.emit('worktree_removed', { repoId, path: w.path });
+      return this.emitWorktree(row, row.path); // le checkout principal est désormais sur `branch`
+    });
+  }
+
+  /**
+   * Lance UNE session dans le checkout principal du repo (`repo.path`) — pour « bosser sur la branche
+   * principale » sans créer de worktree. Si `branch` est fourni, crée/bascule d'abord cette branche
+   * dans ce checkout (`git switch[-c]`), refusé si l'arbre est sale (on n'écrase pas un HEAD modifié).
+   * Volontairement SANS hooks ni pré-trust (contraste avec createWorktree) : le checkout principal
+   * est le dépôt réel de l'utilisateur, déjà configuré/approuvé. Sérialisé par repo (withLock).
+   */
+  async startMainSession(
+    repoId: string,
+    req: { command?: 'claude' | 'bash'; branch?: string; newBranch?: boolean },
+  ): Promise<{ session: SessionSummary; worktree: WorktreeSummary | null }> {
+    const row = this.getRepoRow(repoId);
+    if (!row) throw httpError(404, 'NOT_FOUND', 'No repo with this id');
+    const branch = req.branch?.trim() || undefined;
+    if (branch !== undefined && !isValidBranchName(branch)) throw httpError(400, 'BAD_BRANCH', `Invalid branch name: ${branch}`);
+
+    return this.withLock(repoId, async () => {
+      if (branch !== undefined) {
+        // garde-fou : ne pas basculer le HEAD du checkout principal s'il a des changements non sauvegardés.
+        if ((await worktreeStatus(row.path)).dirtyCount > 0) {
+          throw httpError(409, 'DIRTY_TREE', 'Main checkout has uncommitted changes — commit or stash before switching branch');
+        }
+        try {
+          await switchBranch(row.path, { branch, create: req.newBranch ?? true });
+        } catch (err) {
+          throw httpError(400, 'SWITCH_FAILED', (err as Error).message);
+        }
+        this.factsCache.delete(repoId);
+      }
+      const session = this.ptyManager.spawn({ cwd: row.path, command: req.command ?? 'claude' });
+      const worktree = await this.emitWorktree(row, row.path);
+      return { session, worktree };
     });
   }
 
@@ -379,7 +515,7 @@ export class WorktreeManager extends EventEmitter<WorktreeManagerEvents> {
     if (!w) throw httpError(404, 'NOT_FOUND', 'No such worktree under this repo');
     if (resolve(w.path) === resolve(row.path)) throw httpError(400, 'IS_MAIN_WORKTREE', 'Cannot remove the main worktree');
     // garde-fou : une session vivante tourne dans ce worktree → exiger une confirmation explicite.
-    if (!force && this.sessionsForCwd(w.path).some((s) => s.live)) {
+    if (!force && this.sessionsForCwd(w.path, { includeHidden: true }).some((s) => s.live)) {
       throw httpError(409, 'SESSION_LIVE_IN_WORKTREE', 'A live session runs in this worktree — pass force to delete anyway');
     }
     return this.withLock(repoId, async () => {

packages/server/src/db/index.ts

@@ -1,4 +1,5 @@
 import { DatabaseSync } from 'node:sqlite';
+import { chmodSync, existsSync } from 'node:fs';
 
 const MIGRATIONS: Array<{ id: number; sql: string }> = [
   {
@@ -99,6 +100,48 @@ const MIGRATIONS: Array<{ id: number; sql: string }> = [
     id: 6,
     sql: `ALTER TABLE repos ADD COLUMN hidden INTEGER NOT NULL DEFAULT 0;`,
   },
+  {
+    // Journal d'audit (conformité entreprise : GDPR/SOX/ISO 27001). Trace les mutations
+    // sensibles (tokens, réglages, secrets, abonnements push, groupes). Ne contient JAMAIS
+    // de secret en clair — `details` est un JSON de métadonnées non sensibles.
+    id: 7,
+    sql: `
+      CREATE TABLE audit_logs (
+        id          TEXT PRIMARY KEY,
+        ts          TEXT NOT NULL,
+        actor       TEXT NOT NULL,
+        action      TEXT NOT NULL,
+        resource_id TEXT,
+        details     TEXT,
+        result      TEXT NOT NULL
+      );
+      CREATE INDEX idx_audit_ts ON audit_logs(ts);
+    `,
+  },
+  {
+    // P6 — session de groupe multi-repo. Une session peut couvrir plusieurs répertoires (--add-dir)
+    // et appartenir à un groupe. `added_dirs` : JSON array de chemins absolus (NULL si mono-repo).
+    // `group_id` : pas de FK (ALTER ADD COLUMN sqlite n'en pose pas) ; nettoyé à la suppression du groupe.
+    id: 8,
+    sql: `
+      ALTER TABLE sessions ADD COLUMN added_dirs TEXT;
+      ALTER TABLE sessions ADD COLUMN group_id TEXT;
+      CREATE INDEX idx_sessions_group_id ON sessions(group_id);
+    `,
+  },
+  {
+    // Masquage des sessions Claude découvertes (lancées en CLI hors Arboretum) qui polluent la liste.
+    // Calqué sur repos.hidden (#6) : la session masquée reste connue (resume/fork possibles) mais est
+    // exclue de la liste par défaut, et un re-scan ne la ressuscite pas. Clé = claudeSessionId (stable,
+    // partagé entre une découverte et sa reprise managée).
+    id: 9,
+    sql: `
+      CREATE TABLE hidden_sessions (
+        claude_session_id TEXT PRIMARY KEY,
+        hidden_at         TEXT NOT NULL
+      );
+    `,
+  },
 ];
 
 export type Db = DatabaseSync;
@@ -107,10 +150,27 @@ export function openDb(path: string): Db {
   const db = new DatabaseSync(path);
   db.exec('PRAGMA journal_mode = WAL');
   db.exec('PRAGMA foreign_keys = ON');
+  hardenDbPermissions(path);
   migrate(db);
   return db;
 }
 
+/**
+ * Restreint la base (et ses fichiers WAL/SHM) à 0o600 — proprio uniquement. La base contient des
+ * secrets (server_secret, clé privée VAPID, hashs de tokens) : elle ne doit jamais être lisible par
+ * d'autres utilisateurs du système. Best-effort : ignoré sur les FS sans permissions POSIX.
+ */
+function hardenDbPermissions(path: string): void {
+  if (path === ':memory:') return;
+  for (const p of [path, `${path}-wal`, `${path}-shm`]) {
+    try {
+      if (existsSync(p)) chmodSync(p, 0o600);
+    } catch {
+      /* FS sans permissions POSIX (Windows / montage) : ignoré */
+    }
+  }
+}
+
 function migrate(db: DatabaseSync): void {
   db.exec('CREATE TABLE IF NOT EXISTS schema_migrations (id INTEGER PRIMARY KEY, applied_at TEXT NOT NULL)');
   const applied = new Set(
@@ -138,3 +198,23 @@ export function getSetting(db: Db, key: string): string | null {
 export function setSetting(db: Db, key: string, value: string): void {
   db.prepare('INSERT INTO settings (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value').run(key, value);
 }
+
+// ---- Sessions masquées (par claudeSessionId) ----
+
+/** Ensemble des claudeSessionId masqués par l'utilisateur. */
+export function listHiddenSessionIds(db: Db): Set<string> {
+  const rows = db.prepare('SELECT claude_session_id FROM hidden_sessions').all() as Array<{ claude_session_id: string }>;
+  return new Set(rows.map((r) => r.claude_session_id));
+}
+
+/** Masque une session (idempotent). */
+export function hideSession(db: Db, claudeSessionId: string): void {
+  db.prepare(
+    'INSERT INTO hidden_sessions (claude_session_id, hidden_at) VALUES (?, ?) ON CONFLICT(claude_session_id) DO NOTHING',
+  ).run(claudeSessionId, new Date().toISOString());
+}
+
+/** Ré-affiche une session masquée (idempotent). */
+export function unhideSession(db: Db, claudeSessionId: string): void {
+  db.prepare('DELETE FROM hidden_sessions WHERE claude_session_id = ?').run(claudeSessionId);
+}

packages/server/src/routes/audit.ts

@@ -0,0 +1,17 @@
+// Consultation du journal d'audit (onglet Réglages / outils de conformité). Lecture seule, sous
+// l'auth globale. Pagination par curseur `before` (ts décroissant).
+import type { FastifyInstance } from 'fastify';
+import type { AuditLogsResponse } from '@arboretum/shared';
+import type { Db } from '../db/index.js';
+import { listAudit } from '../core/audit-log.js';
+
+export function registerAuditRoutes(app: FastifyInstance, db: Db): void {
+  app.get('/api/v1/audit-logs', async (req): Promise<AuditLogsResponse> => {
+    const q = req.query as { limit?: string; before?: string };
+    const limit = Math.min(Math.max(Math.trunc(Number(q.limit) || 50), 1), 200);
+    const entries = listAudit(db, { limit, before: q.before ?? null });
+    // s'il reste potentiellement des entrées (page pleine), expose le curseur suivant.
+    const nextBefore = entries.length === limit ? entries[entries.length - 1]!.ts : null;
+    return { entries, nextBefore };
+  });
+}

packages/server/src/routes/auth.ts

@@ -8,11 +8,13 @@ import type {
   TokensListResponse,
 } from '@arboretum/shared';
 import type { AuthService, LoginRateLimiter } from '../auth/service.js';
+import type { Db } from '../db/index.js';
+import { recordAudit } from '../core/audit-log.js';
 
 // Tailscale Serve / un reverse-proxy TLS posent x-forwarded-proto. On ne sert jamais
 // en TLS direct : `secure` n'est posé que derrière un front HTTPS, jamais en localhost http
 // (sinon le navigateur refuserait le cookie sur http://127.0.0.1 et le login local casserait).
-function isHttpsRequest(req: FastifyRequest): boolean {
+export function isHttpsRequest(req: FastifyRequest): boolean {
   const xfp = req.headers['x-forwarded-proto'];
   const proto = (Array.isArray(xfp) ? xfp[0] : xfp)?.split(',')[0]?.trim();
   return proto === 'https';
@@ -23,6 +25,7 @@ export function registerAuthRoutes(
   auth: AuthService,
   limiter: LoginRateLimiter,
   serverVersion: string,
+  db: Db,
 ): void {
   app.post('/api/v1/auth/login', { config: { public: true } }, async (req, reply) => {
     const wait = limiter.check();
@@ -33,9 +36,11 @@ export function registerAuthRoutes(
     const ctx = typeof body?.token === 'string' ? auth.verifyRawToken(body.token) : null;
     if (!ctx) {
       limiter.recordFailure();
+      recordAudit(db, { actor: 'anonymous', action: 'login.failure', result: 'denied' });
       return reply.status(401).send({ error: { code: 'BAD_TOKEN', message: 'Invalid token' } });
     }
     limiter.recordSuccess();
+    recordAudit(db, { actor: ctx.tokenId, action: 'login.success' });
     void reply.setCookie(auth.cookieName, auth.issueCookie(ctx), {
       path: '/',
       httpOnly: true,
@@ -78,18 +83,22 @@ export function registerAuthRoutes(
       return reply.status(400).send({ error: { code: 'BAD_REQUEST', message: 'label must be 1–64 characters' } });
     }
     const { id, token } = auth.createTokenRecord(label);
+    recordAudit(db, { actor: req.authContext?.tokenId ?? 'unknown', action: 'token.create', resourceId: id, details: { label } });
     return reply.status(201).send({ id, label, token } satisfies CreateTokenResponse);
   });
 
   app.delete('/api/v1/auth/tokens/:id', async (req, reply) => {
     const { id } = req.params as { id: string };
     const result = auth.revokeToken(id);
+    const actor = req.authContext?.tokenId ?? 'unknown';
     if (result === 'not_found') {
       return reply.status(404).send({ error: { code: 'NOT_FOUND', message: 'No active token with this id' } });
     }
     if (result === 'last') {
+      recordAudit(db, { actor, action: 'token.revoke', resourceId: id, result: 'denied', details: { reason: 'last_active_token' } });
       return reply.status(409).send({ error: { code: 'LAST_TOKEN', message: 'Cannot revoke the last active token' } });
     }
+    recordAudit(db, { actor, action: 'token.revoke', resourceId: id });
     // 200 + corps JSON (pas 204) : le mini-client REST du front parse toujours la réponse.
     return reply.send({ ok: true });
   });

packages/server/src/routes/data.ts

@@ -0,0 +1,54 @@
+// RGPD (droits d'accès & d'effacement) : export et suppression des données rattachées au token
+// authentifié. Modèle mono-utilisateur → le détenteur du token EST le sujet des données. Sous l'auth
+// globale. La suppression se fait en deux temps (code de confirmation) pour éviter les clics accidentels.
+import { createHash } from 'node:crypto';
+import type { FastifyInstance } from 'fastify';
+import type { DataExportResponse, DeleteMyDataRequest, DeleteMyDataResponse } from '@arboretum/shared';
+import type { Db } from '../db/index.js';
+import type { AuthService } from '../auth/service.js';
+import { readScanIntervalMin, readScanRoots } from '../core/scan-settings.js';
+import { recordAudit } from '../core/audit-log.js';
+
+export function registerDataRoutes(app: FastifyInstance, db: Db, auth: AuthService): void {
+  app.get('/api/v1/data/export', async (req): Promise<DataExportResponse> => {
+    const current = req.authContext!.tokenId;
+    const tokens = auth.listTokens().map((t) => ({ ...t, current: t.id === current }));
+    const pushSubscriptions = db
+      .prepare(
+        'SELECT endpoint, user_agent AS userAgent, created_at AS createdAt, last_ok_at AS lastOkAt FROM push_subscriptions WHERE token_id = ?',
+      )
+      .all(current) as DataExportResponse['pushSubscriptions'];
+    const sessions = db
+      .prepare(
+        'SELECT id, cwd, command, title, created_at AS createdAt, ended_at AS endedAt, exit_code AS exitCode FROM sessions ORDER BY created_at',
+      )
+      .all() as DataExportResponse['sessions'];
+    return {
+      exportedAt: new Date().toISOString(),
+      tokens,
+      pushSubscriptions,
+      sessions,
+      settings: { scanRoots: readScanRoots(db), scanIntervalMin: readScanIntervalMin(db) },
+    };
+  });
+
+  app.post('/api/v1/data/delete-my-data', async (req, reply) => {
+    const current = req.authContext!.tokenId;
+    // code déterministe lié au token (sans état serveur) : renvoyé au 1er appel, exigé au 2nd.
+    const code = createHash('sha256').update(`delete:${current}`).digest('hex').slice(0, 12);
+    const body = (req.body as DeleteMyDataRequest | null) ?? {};
+    const subsCount = (db.prepare('SELECT COUNT(*) AS n FROM push_subscriptions WHERE token_id = ?').get(current) as { n: number }).n;
+
+    if (body.confirm !== code) {
+      const res: DeleteMyDataResponse = { status: 'pending', confirm: code, summary: { pushSubscriptions: subsCount, tokenRevoked: false } };
+      return reply.send(res);
+    }
+
+    db.prepare('DELETE FROM push_subscriptions WHERE token_id = ?').run(current);
+    // révoque le token courant (sauf si c'est le dernier actif → garde anti lock-out conservée).
+    const revoked = auth.revokeToken(current) === 'ok';
+    recordAudit(db, { actor: current, action: 'data.delete', details: { pushSubscriptions: subsCount, tokenRevoked: revoked } });
+    const res: DeleteMyDataResponse = { status: 'done', summary: { pushSubscriptions: subsCount, tokenRevoked: revoked } };
+    return reply.send(res);
+  });
+}

packages/server/src/routes/groups.ts

@@ -2,14 +2,27 @@ import type { FastifyInstance } from 'fastify';
 import type {
   AddRepoRequest,
   CreateGroupRequest,
+  CreateGroupSessionRequest,
   GroupResponse,
+  GroupSessionResponse,
   GroupsListResponse,
   UpdateGroupRequest,
 } from '@arboretum/shared';
 import type { GroupManager } from '../core/group-manager.js';
+import type { WorktreeManager } from '../core/worktree-manager.js';
+import type { PtyManager } from '../core/pty-manager.js';
+import type { Db } from '../db/index.js';
+import { recordAudit } from '../core/audit-log.js';
+import { resolveGroupCwd } from '../core/group-session.js';
 import { sendManagerError } from './repos.js';
 
-export function registerGroupRoutes(app: FastifyInstance, gm: GroupManager): void {
+export function registerGroupRoutes(
+  app: FastifyInstance,
+  gm: GroupManager,
+  db: Db,
+  wt: WorktreeManager,
+  manager: PtyManager,
+): void {
   app.get('/api/v1/groups', async (): Promise<GroupsListResponse> => ({ groups: gm.listGroups() }));
 
   app.get('/api/v1/groups/:id', async (req, reply) => {
@@ -33,6 +46,7 @@ export function registerGroupRoutes(app: FastifyInstance, gm: GroupManager): voi
         ...(body.color !== undefined ? { color: body.color } : {}),
         ...(Array.isArray(body.repoIds) ? { repoIds: body.repoIds } : {}),
       });
+      recordAudit(db, { actor: req.authContext?.tokenId ?? 'unknown', action: 'group.create', resourceId: group.id, details: { label: group.label } });
       return reply.status(201).send({ group } satisfies GroupResponse);
     } catch (err) {
       return sendManagerError(reply, err);
@@ -48,6 +62,7 @@ export function registerGroupRoutes(app: FastifyInstance, gm: GroupManager): voi
         ...(body.description !== undefined ? { description: body.description } : {}),
         ...(body.color !== undefined ? { color: body.color } : {}),
       });
+      recordAudit(db, { actor: req.authContext?.tokenId ?? 'unknown', action: 'group.update', resourceId: id });
       return reply.send({ group } satisfies GroupResponse);
     } catch (err) {
       return sendManagerError(reply, err);
@@ -59,6 +74,7 @@ export function registerGroupRoutes(app: FastifyInstance, gm: GroupManager): voi
     if (!gm.deleteGroup(id)) {
       return reply.status(404).send({ error: { code: 'NOT_FOUND', message: 'No group with this id' } });
     }
+    recordAudit(db, { actor: req.authContext?.tokenId ?? 'unknown', action: 'group.delete', resourceId: id });
     return reply.send({ ok: true });
   });
 
@@ -83,4 +99,64 @@ export function registerGroupRoutes(app: FastifyInstance, gm: GroupManager): voi
       return sendManagerError(reply, err);
     }
   });
+
+  // Session de groupe (P6) : UNE session Claude couvrant tous les repos du groupe (--add-dir).
+  // Les répertoires sont résolus côté serveur depuis les propres worktrees du groupe — le client
+  // ne passe jamais de chemin brut. `branch` présent → worktree de cette branche par repo ;
+  // absent → le worktree principal de chaque repo.
+  app.post('/api/v1/groups/:id/session', async (req, reply) => {
+    const { id } = req.params as { id: string };
+    const body = (req.body as Partial<CreateGroupSessionRequest> | null) ?? {};
+    const command = body.command ?? 'claude';
+    if (command !== 'claude' && command !== 'bash') {
+      return reply.status(400).send({ error: { code: 'BAD_REQUEST', message: 'command must be claude or bash' } });
+    }
+    const branch = typeof body.branch === 'string' && body.branch.trim() !== '' ? body.branch.trim() : null;
+
+    let group;
+    try {
+      group = gm.getGroup(id);
+    } catch (err) {
+      return sendManagerError(reply, err);
+    }
+
+    const dirs: string[] = [];
+    const skipped: Array<{ repoId: string; reason: string }> = [];
+    for (const repoId of group.repoIds) {
+      let worktrees;
+      try {
+        worktrees = await wt.listRepoWorktrees(repoId);
+      } catch (err) {
+        skipped.push({ repoId, reason: err instanceof Error ? err.message : String(err) });
+        continue;
+      }
+      const match = branch ? worktrees.find((w) => w.branch === branch) : worktrees.find((w) => w.isMain);
+      if (!match) {
+        skipped.push({ repoId, reason: branch ? `no worktree on branch ${branch}` : 'no main worktree' });
+        continue;
+      }
+      if (!dirs.includes(match.path)) dirs.push(match.path);
+    }
+
+    if (dirs.length === 0) {
+      const detail = branch ? `no repo has a worktree on branch "${branch}" (create it first)` : 'no repo has a resolvable main checkout';
+      return reply.status(400).send({ error: { code: 'NO_RESOLVABLE_WORKTREE', message: `Cannot start group session: ${detail}` } });
+    }
+    // cwd = parent commun des repos couverts, chacun relié en --add-dir (P6). Voir resolveGroupCwd.
+    const { cwd, addDirs } = resolveGroupCwd(dirs);
+
+    try {
+      const session = manager.spawn({ cwd, addDirs, command, groupId: id });
+      recordAudit(db, {
+        actor: req.authContext?.tokenId ?? 'unknown',
+        action: 'group.session.create',
+        resourceId: id,
+        details: { command, dirs: dirs.length, ...(branch ? { branch } : {}) },
+      });
+      return reply.status(201).send({ session, dirs, skipped } satisfies GroupSessionResponse);
+    } catch (err) {
+      const statusCode = (err as { statusCode?: number }).statusCode ?? 500;
+      return reply.status(statusCode).send({ error: { code: 'SPAWN_FAILED', message: (err as Error).message } });
+    }
+  });
 }

packages/server/src/routes/push.ts

@@ -3,8 +3,10 @@
 import type { FastifyInstance } from 'fastify';
 import type { PushSubscribeRequest, PushUnsubscribeRequest, VapidKeyResponse } from '@arboretum/shared';
 import type { PushService } from '../core/push-service.js';
+import type { Db } from '../db/index.js';
+import { recordAudit } from '../core/audit-log.js';
 
-export function registerPushRoutes(app: FastifyInstance, push: PushService): void {
+export function registerPushRoutes(app: FastifyInstance, push: PushService, db: Db): void {
   app.get('/api/v1/push/vapid-public-key', async (): Promise<VapidKeyResponse> => ({ key: push.publicKey() }));
 
   app.post('/api/v1/push/subscribe', async (req, reply) => {
@@ -15,6 +17,7 @@ export function registerPushRoutes(app: FastifyInstance, push: PushService): voi
     // garanti non-null : la route est protégée par le preValidation global.
     const tokenId = req.authContext!.tokenId;
     push.subscribe(tokenId, { endpoint: body.endpoint, keys: { p256dh: body.keys.p256dh, auth: body.keys.auth } }, req.headers['user-agent'] ?? null);
+    recordAudit(db, { actor: tokenId, action: 'push.subscribe' });
     return reply.status(201).send({ ok: true });
   });
 
@@ -24,6 +27,7 @@ export function registerPushRoutes(app: FastifyInstance, push: PushService): voi
       return reply.status(400).send({ error: { code: 'BAD_REQUEST', message: 'endpoint is required' } });
     }
     push.unsubscribe(body.endpoint);
+    recordAudit(db, { actor: req.authContext?.tokenId ?? 'unknown', action: 'push.unsubscribe' });
     return reply.send({ ok: true });
   });
 

packages/server/src/routes/sessions.ts

@@ -1,13 +1,24 @@
 import type { FastifyInstance } from 'fastify';
-import type { CreateSessionRequest, SessionResponse, SessionsListResponse } from '@arboretum/shared';
+import type { CreateSessionRequest, HideDiscoveredResponse, SessionResponse, SessionsListResponse } from '@arboretum/shared';
 import type { PtyManager } from '../core/pty-manager.js';
 import { mergeSessions, type DiscoveryService } from '../core/discovery-service.js';
+import { hideSession, unhideSession, type Db } from '../db/index.js';
+import { recordAudit } from '../core/audit-log.js';
 
-export function registerSessionRoutes(app: FastifyInstance, manager: PtyManager, discovery: DiscoveryService): void {
+export function registerSessionRoutes(app: FastifyInstance, manager: PtyManager, discovery: DiscoveryService, db: Db): void {
-  app.get('/api/v1/sessions', async (): Promise<SessionsListResponse> => {
+  app.get('/api/v1/sessions', async (req): Promise<SessionsListResponse> => {
-    return { sessions: mergeSessions(manager.list(), discovery.list()) };
+    const includeHidden = (req.query as { includeHidden?: string }).includeHidden === 'true';
+    const all = mergeSessions(manager.list(), discovery.list());
+    return { sessions: includeHidden ? all : all.filter((s) => !s.hidden) };
   });
 
+  // Résout le claudeSessionId d'un :id de session (managée par UUID, ou découverte dont l'id EST le sid).
+  const resolveClaudeSid = (id: string): string | null => {
+    const managed = manager.resumeTargetById(id);
+    if (managed?.claudeSessionId) return managed.claudeSessionId;
+    return discovery.getDiscovered(id) ? id : null;
+  };
+
   app.post('/api/v1/sessions', async (req, reply) => {
     const body = req.body as Partial<CreateSessionRequest> | null;
     if (!body || typeof body.cwd !== 'string' || !body.cwd.startsWith('/')) {
@@ -26,20 +37,32 @@ export function registerSessionRoutes(app: FastifyInstance, manager: PtyManager,
     }
   });
 
-  // Reprise d'une session morte : nouveau PTY managé `--resume <id>` DANS SON CWD D'ORIGINE (spike S1).
+  // Reprise d'une session morte : nouveau PTY managé `--resume <claudeSessionId>` DANS SON CWD D'ORIGINE
-  // Le cwd n'est jamais fourni par le client : il est lu sur disque via la découverte.
+  // (spike S1). Le cwd n'est JAMAIS fourni par le client. Deux origines d'id possibles :
+  //  - session managée morte (id = UUID Arboretum) → cwd + claudeSessionId + groupe lus en DB ;
+  //  - session claude EXTERNE découverte (id = claudeSessionId) → cwd lu sur disque.
   app.post('/api/v1/sessions/:id/resume', async (req, reply) => {
     const { id } = req.params as { id: string };
-    const discovered = discovery.getDiscovered(id);
+    const managed = manager.resumeTargetById(id);
-    if (!discovered) {
+    const discovered = managed ? null : discovery.getDiscovered(id);
+    if (!managed && !discovered) {
       return reply.status(404).send({ error: { code: 'NOT_FOUND', message: 'No resumable session with this id' } });
     }
+    const cwd = managed ? managed.cwd : discovered!.cwd;
+    const claudeSessionId = managed ? managed.claudeSessionId : id;
     // Garde-fou anti-corruption : jamais de resume direct d'une session vivante (vérif FRAÎCHE).
-    if (discovery.isClaudeSessionLive(id) || manager.findLiveByClaudeSessionId(id)) {
+    if (discovery.isClaudeSessionLive(claudeSessionId) || manager.findLiveByClaudeSessionId(claudeSessionId)) {
       return reply.status(409).send({ error: { code: 'SESSION_LIVE', message: 'Session is live — fork it instead' } });
     }
     try {
-      const session = manager.spawn({ cwd: discovered.cwd, resume: { claudeSessionId: id } });
+      // Session de groupe (P6) : re-relie les mêmes répertoires (--add-dir) et son groupe au resume.
+      const ctx = managed ? { addedDirs: managed.addedDirs, groupId: managed.groupId } : manager.groupSessionContext(claudeSessionId);
+      const session = manager.spawn({
+        cwd,
+        resume: { claudeSessionId },
+        ...(ctx?.addedDirs.length ? { addDirs: ctx.addedDirs } : {}),
+        ...(ctx?.groupId ? { groupId: ctx.groupId } : {}),
+      });
       const res: SessionResponse = { session };
       return reply.status(201).send(res);
     } catch (err) {
@@ -49,14 +72,18 @@ export function registerSessionRoutes(app: FastifyInstance, manager: PtyManager,
   });
 
   // Fork : duplique une session (vivante ou morte) sans la corrompre (`--resume <id> --fork-session`).
+  // Même résolution d'id que /resume (managée morte par UUID, sinon externe découverte par claudeSessionId).
   app.post('/api/v1/sessions/:id/fork', async (req, reply) => {
     const { id } = req.params as { id: string };
-    const discovered = discovery.getDiscovered(id);
+    const managed = manager.resumeTargetById(id);
-    if (!discovered) {
+    const discovered = managed ? null : discovery.getDiscovered(id);
+    if (!managed && !discovered) {
       return reply.status(404).send({ error: { code: 'NOT_FOUND', message: 'No session with this id to fork' } });
     }
+    const cwd = managed ? managed.cwd : discovered!.cwd;
+    const claudeSessionId = managed ? managed.claudeSessionId : id;
     try {
-      const session = manager.spawn({ cwd: discovered.cwd, resume: { claudeSessionId: id, fork: true } });
+      const session = manager.spawn({ cwd, resume: { claudeSessionId, fork: true } });
       const res: SessionResponse = { session };
       return reply.status(201).send(res);
     } catch (err) {
@@ -65,6 +92,49 @@ export function registerSessionRoutes(app: FastifyInstance, manager: PtyManager,
     }
   });
 
+  // Masque une session découverte (ou managée morte) : exclue de la liste sauf ?includeHidden=true.
+  // Reste reprenable/forkable — c'est un filtre d'affichage, pas une suppression.
+  app.post('/api/v1/sessions/:id/hide', async (req, reply) => {
+    const { id } = req.params as { id: string };
+    const sid = resolveClaudeSid(id);
+    if (!sid) {
+      return reply.status(404).send({ error: { code: 'NOT_FOUND', message: 'No session with this id to hide' } });
+    }
+    hideSession(db, sid);
+    await discovery.refresh(); // rediffuse l'état (hidden) aux clients
+    recordAudit(db, { actor: req.authContext?.tokenId ?? 'unknown', action: 'session.hide', resourceId: sid });
+    return reply.send({ ok: true });
+  });
+
+  // Ré-affiche une session masquée.
+  app.delete('/api/v1/sessions/:id/hide', async (req, reply) => {
+    const { id } = req.params as { id: string };
+    const sid = resolveClaudeSid(id);
+    if (!sid) {
+      return reply.status(404).send({ error: { code: 'NOT_FOUND', message: 'No session with this id to unhide' } });
+    }
+    unhideSession(db, sid);
+    await discovery.refresh();
+    recordAudit(db, { actor: req.authContext?.tokenId ?? 'unknown', action: 'session.unhide', resourceId: sid });
+    return reply.send({ ok: true });
+  });
+
+  // Masquage de masse : nettoie d'un coup tout l'historique externe actuellement visible. Les futures
+  // sessions externes réapparaîtront (sinon --no-discover). Renvoie le nombre de sessions masquées.
+  app.post('/api/v1/sessions/hide-discovered', async (req, reply) => {
+    const sids = discovery
+      .list()
+      .filter((s) => !s.hidden && s.claudeSessionId)
+      .map((s) => s.claudeSessionId as string);
+    for (const sid of sids) hideSession(db, sid);
+    await discovery.refresh();
+    if (sids.length > 0) {
+      recordAudit(db, { actor: req.authContext?.tokenId ?? 'unknown', action: 'session.hideDiscovered', resourceId: null, details: { count: sids.length } });
+    }
+    const res: HideDiscoveredResponse = { hidden: sids.length };
+    return reply.send(res);
+  });
+
   app.delete('/api/v1/sessions/:id', async (req, reply) => {
     const { id } = req.params as { id: string };
     if (!manager.kill(id)) {

packages/server/src/routes/settings.ts

@@ -4,8 +4,9 @@
 import type { FastifyInstance } from 'fastify';
 import type { ServerInfo, SettingsResponse, UpdateSettingsRequest } from '@arboretum/shared';
 import type { Config } from '../config.js';
-import { type Db, getSetting, setSetting } from '../db/index.js';
+import { type Db, setSetting } from '../db/index.js';
 import type { PushService } from '../core/push-service.js';
+import { recordAudit } from '../core/audit-log.js';
 import {
   SCAN_INTERVAL_KEY,
   SCAN_ROOTS_KEY,
@@ -15,23 +16,7 @@ import {
   readScanRoots,
 } from '../core/scan-settings.js';
 
-// Clés de `settings` modifiables via l'API (allow-list stricte). Les secrets ne figurent JAMAIS ici.
+// Réglages modifiables via l'API (allow-list stricte). Les secrets ne figurent JAMAIS ici.
-const GITEA_URL_KEY = 'gitea_url';
-
-/** Valide/normalise une URL Gitea : http(s) uniquement (anti-XSS sur le href de l'icône). */
-function normalizeGiteaUrl(raw: string): string | null {
-  const trimmed = raw.trim();
-  if (trimmed === '') return null;
-  let url: URL;
-  try {
-    url = new URL(trimmed);
-  } catch {
-    return null;
-  }
-  if (url.protocol !== 'http:' && url.protocol !== 'https:') return null;
-  return url.toString();
-}
-
 export function registerSettingsRoutes(
   app: FastifyInstance,
   db: Db,
@@ -39,8 +24,6 @@ export function registerSettingsRoutes(
   serverVersion: string,
   push: PushService,
 ): void {
-  // '' (effacé) est normalisé en null côté réponse.
-  const readGiteaUrl = (): string | null => getSetting(db, GITEA_URL_KEY) || null;
   const serverInfo = (): ServerInfo => ({
     version: serverVersion,
     port: config.port,
@@ -52,7 +35,6 @@ export function registerSettingsRoutes(
   });
   const snapshot = (): SettingsResponse => ({
     settings: {
-      giteaUrl: readGiteaUrl(),
       scanRoots: readScanRoots(db),
       scanIntervalMin: readScanIntervalMin(db),
     },
@@ -63,20 +45,6 @@ export function registerSettingsRoutes(
 
   app.patch('/api/v1/settings', async (req, reply) => {
     const body = (req.body as Partial<UpdateSettingsRequest> | null) ?? {};
-    if ('giteaUrl' in body) {
-      const v = body.giteaUrl;
-      if (v === null || v === '') {
-        setSetting(db, GITEA_URL_KEY, ''); // effacement
-      } else if (typeof v === 'string') {
-        const normalized = normalizeGiteaUrl(v);
-        if (!normalized) {
-          return reply.status(400).send({ error: { code: 'BAD_REQUEST', message: 'giteaUrl must be a valid http(s) URL' } });
-        }
-        setSetting(db, GITEA_URL_KEY, normalized);
-      } else {
-        return reply.status(400).send({ error: { code: 'BAD_REQUEST', message: 'giteaUrl must be a string or null' } });
-      }
-    }
     if ('scanRoots' in body) {
       const roots = normalizeScanRoots(body.scanRoots);
       if (!roots) {
@@ -91,6 +59,11 @@ export function registerSettingsRoutes(
       }
       setSetting(db, SCAN_INTERVAL_KEY, String(interval));
     }
+    recordAudit(db, {
+      actor: req.authContext?.tokenId ?? 'unknown',
+      action: 'settings.update',
+      details: { keys: Object.keys(body) },
+    });
     return reply.send(snapshot());
   });
 }

packages/server/src/routes/worktrees.ts

@@ -1,15 +1,32 @@
 import type { FastifyInstance } from 'fastify';
 import type {
   AdoptWorktreeRequest,
+  CommitWorktreeRequest,
   CreateWorktreeRequest,
   CreateWorktreeResponse,
+  PromoteWorktreeRequest,
+  PushWorktreeRequest,
+  RepoBranchesResponse,
+  SessionResponse,
+  StartRepoSessionRequest,
+  WorktreeBranchMode,
   WorktreeResponse,
   WorktreesListResponse,
 } from '@arboretum/shared';
 import type { WorktreeManager } from '../core/worktree-manager.js';
+import type { Db } from '../db/index.js';
+import { recordAudit } from '../core/audit-log.js';
 import { sendManagerError } from './repos.js';
 
-export function registerWorktreeRoutes(app: FastifyInstance, wt: WorktreeManager): void {
+/** Mappe l'API (mode prioritaire ; `newBranch` déprécié) vers la stratégie de résolution de branche. */
+function resolveMode(body: { mode?: unknown; newBranch?: unknown }): WorktreeBranchMode {
+  if (body.mode === 'auto' || body.mode === 'create' || body.mode === 'checkout') return body.mode;
+  if (body.newBranch === true) return 'create';
+  if (body.newBranch === false) return 'checkout';
+  return 'auto';
+}
+
+export function registerWorktreeRoutes(app: FastifyInstance, wt: WorktreeManager, db: Db): void {
   app.get('/api/v1/worktrees', async (): Promise<WorktreesListResponse> => ({ worktrees: await wt.listAllWorktrees() }));
 
   app.get('/api/v1/repos/:id/worktrees', async (req): Promise<WorktreesListResponse> => {
@@ -29,7 +46,7 @@ export function registerWorktreeRoutes(app: FastifyInstance, wt: WorktreeManager
     try {
       const out = await wt.createWorktree(id, {
         branch: body.branch,
-        newBranch: body.newBranch !== false, // défaut : créer la branche
+        mode: resolveMode(body), // défaut : auto (détecte créer / checkout / suivi remote)
         ...(body.baseRef !== undefined ? { baseRef: body.baseRef } : {}),
         ...(body.path !== undefined ? { path: body.path } : {}),
         ...(body.runHooks !== undefined ? { runHooks: body.runHooks } : {}),
@@ -43,6 +60,44 @@ export function registerWorktreeRoutes(app: FastifyInstance, wt: WorktreeManager
     }
   });
 
+  // Branches du repo (locales + suivies de origin + défaut) — alimente le sélecteur de base côté UI.
+  app.get('/api/v1/repos/:id/branches', async (req, reply) => {
+    const { id } = req.params as { id: string };
+    try {
+      const out = await wt.listRepoBranches(id);
+      return reply.send(out satisfies RepoBranchesResponse);
+    } catch (err) {
+      return sendManagerError(reply, err);
+    }
+  });
+
+  // Session sur le checkout principal (« bosser sur la branche principale » sans worktree),
+  // avec création/bascule de branche optionnelle côté serveur.
+  app.post('/api/v1/repos/:id/session', async (req, reply) => {
+    const { id } = req.params as { id: string };
+    const body = (req.body as Partial<StartRepoSessionRequest> | null) ?? {};
+    if (body.command != null && body.command !== 'claude' && body.command !== 'bash') {
+      return reply.status(400).send({ error: { code: 'BAD_REQUEST', message: 'command must be claude or bash' } });
+    }
+    if (body.branch != null && typeof body.branch !== 'string') {
+      return reply.status(400).send({ error: { code: 'BAD_REQUEST', message: 'branch must be a string' } });
+    }
+    if (body.newBranch != null && typeof body.newBranch !== 'boolean') {
+      return reply.status(400).send({ error: { code: 'BAD_REQUEST', message: 'newBranch must be a boolean' } });
+    }
+    try {
+      const out = await wt.startMainSession(id, {
+        ...(body.command !== undefined ? { command: body.command } : {}),
+        ...(body.branch !== undefined ? { branch: body.branch } : {}),
+        ...(body.newBranch !== undefined ? { newBranch: body.newBranch } : {}),
+      });
+      const res: SessionResponse = { session: out.session };
+      return reply.status(201).send(res);
+    } catch (err) {
+      return sendManagerError(reply, err);
+    }
+  });
+
   app.post('/api/v1/repos/:id/worktrees/adopt', async (req, reply) => {
     const { id } = req.params as { id: string };
     const body = req.body as Partial<AdoptWorktreeRequest> | null;
@@ -72,6 +127,57 @@ export function registerWorktreeRoutes(app: FastifyInstance, wt: WorktreeManager
     }
   });
 
+  // Commit (git add -A + commit) dans un worktree (ou le checkout principal).
+  app.post('/api/v1/repos/:id/worktrees/commit', async (req, reply) => {
+    const { id } = req.params as { id: string };
+    const body = req.body as Partial<CommitWorktreeRequest> | null;
+    if (!body || typeof body.path !== 'string') {
+      return reply.status(400).send({ error: { code: 'BAD_REQUEST', message: 'path is required' } });
+    }
+    if (typeof body.message !== 'string' || body.message.trim() === '') {
+      return reply.status(400).send({ error: { code: 'BAD_REQUEST', message: 'message is required' } });
+    }
+    try {
+      const worktree = await wt.commitWorktree(id, body.path, body.message.trim());
+      recordAudit(db, { actor: req.authContext?.tokenId ?? 'unknown', action: 'worktree.commit', resourceId: id, details: { path: body.path } });
+      return reply.send({ worktree } satisfies WorktreeResponse);
+    } catch (err) {
+      return sendManagerError(reply, err);
+    }
+  });
+
+  // Push de la branche d'un worktree (upstream auto si absent).
+  app.post('/api/v1/repos/:id/worktrees/push', async (req, reply) => {
+    const { id } = req.params as { id: string };
+    const body = req.body as Partial<PushWorktreeRequest> | null;
+    if (!body || typeof body.path !== 'string') {
+      return reply.status(400).send({ error: { code: 'BAD_REQUEST', message: 'path is required' } });
+    }
+    try {
+      const worktree = await wt.pushWorktree(id, body.path);
+      recordAudit(db, { actor: req.authContext?.tokenId ?? 'unknown', action: 'worktree.push', resourceId: id, details: { path: body.path } });
+      return reply.send({ worktree } satisfies WorktreeResponse);
+    } catch (err) {
+      return sendManagerError(reply, err);
+    }
+  });
+
+  // Promotion « en principal » : la branche du worktree devient le checkout principal (worktree supprimé).
+  app.post('/api/v1/repos/:id/worktrees/promote', async (req, reply) => {
+    const { id } = req.params as { id: string };
+    const body = req.body as Partial<PromoteWorktreeRequest> | null;
+    if (!body || typeof body.path !== 'string') {
+      return reply.status(400).send({ error: { code: 'BAD_REQUEST', message: 'path is required' } });
+    }
+    try {
+      const worktree = await wt.promoteWorktree(id, body.path, body.force === true);
+      recordAudit(db, { actor: req.authContext?.tokenId ?? 'unknown', action: 'worktree.promote', resourceId: id, details: { path: body.path } });
+      return reply.send({ worktree });
+    } catch (err) {
+      return sendManagerError(reply, err);
+    }
+  });
+
   app.delete('/api/v1/repos/:id/worktrees', async (req, reply) => {
     const { id } = req.params as { id: string };
     const query = req.query as { path?: string; force?: string };

packages/server/test/app.e2e.test.ts

@@ -148,6 +148,20 @@ describe('app e2e — auth, origin et sessions', () => {
     expect(res.json()).toEqual({ sessions: [] });
   });
 
+  it('masquage des sessions : hide-discovered (vide), includeHidden, hide d’un id inconnu → 404', async () => {
+    const headers = { authorization: `Bearer ${t.token}` };
+    const mass = await t.bundle.app.inject({ method: 'POST', url: '/api/v1/sessions/hide-discovered', headers });
+    expect(mass.statusCode).toBe(200);
+    expect(mass.json()).toEqual({ hidden: 0 });
+
+    const withHidden = await t.bundle.app.inject({ method: 'GET', url: '/api/v1/sessions?includeHidden=true', headers });
+    expect(withHidden.statusCode).toBe(200);
+    expect(withHidden.json()).toEqual({ sessions: [] });
+
+    const unknown = await t.bundle.app.inject({ method: 'POST', url: '/api/v1/sessions/nope/hide', headers });
+    expect(unknown.statusCode).toBe(404);
+  });
+
   it('Origin interdite → 403 même avec un Bearer valide, et même sur la route publique de login', async () => {
     const res = await t.bundle.app.inject({
       method: 'GET',

packages/server/test/audit-data-routes.test.ts

@@ -0,0 +1,164 @@
+// Lot 5 — sécurité enterprise : en-têtes de sécurité, journal d'audit, RGPD (export/suppression),
+// garde Content-Type. Vérifie le câblage de bout en bout via buildApp + token bootstrap.
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest';
+import { buildApp, type AppBundle } from '../src/app.js';
+import { openDb, type Db } from '../src/db/index.js';
+import type { Config } from '../src/config.js';
+import type { AuditLogsResponse, DataExportResponse, DeleteMyDataResponse } from '@arboretum/shared';
+
+vi.mock('node:child_process', () => ({ execFileSync: () => '/usr/bin/claude\n' }));
+vi.mock('@homebridge/node-pty-prebuilt-multiarch', () => {
+  class FakePty {
+    pid = 424242;
+    write = vi.fn();
+    resize = vi.fn();
+    pause = vi.fn();
+    resume = vi.fn();
+    kill = vi.fn();
+    onData(): { dispose: () => void } {
+      return { dispose: () => {} };
+    }
+    onExit(): { dispose: () => void } {
+      return { dispose: () => {} };
+    }
+  }
+  return { default: { spawn: (): FakePty => new FakePty() } };
+});
+
+process.env.ARBORETUM_LOG = 'silent';
+
+let dir: string;
+let bundle: AppBundle;
+let db: Db;
+let token: string;
+const auth = (): { authorization: string } => ({ authorization: `Bearer ${token}` });
+
+beforeAll(() => {
+  dir = mkdtempSync(join(tmpdir(), 'arboretum-audit-'));
+  const dbPath = join(dir, 'audit.db');
+  db = openDb(dbPath);
+  const config: Config = {
+    port: 9998,
+    bind: '127.0.0.1',
+    dbPath,
+    dataDir: dir,
+    allowedOrigins: ['https://host.tailnet.ts.net'],
+    printToken: false,
+    claudeProjectsDir: join(dir, 'claude', 'projects'),
+    claudeSessionsDir: join(dir, 'claude', 'sessions'),
+    vapidContact: 'mailto:test@localhost',
+    autoDiscover: false,
+  };
+  bundle = buildApp(config, db, '1.2.3-test');
+  const t = bundle.auth.ensureBootstrapToken();
+  if (!t) throw new Error('bootstrap token attendu');
+  token = t;
+});
+
+afterAll(async () => {
+  await bundle.app.close();
+  db.close();
+  rmSync(dir, { recursive: true, force: true });
+});
+
+describe('En-têtes de sécurité', () => {
+  it('pose les en-têtes durs + no-store sur /api, sans header Server', async () => {
+    const res = await bundle.app.inject({ method: 'GET', url: '/api/v1/auth/me', headers: auth() });
+    expect(res.statusCode).toBe(200);
+    expect(res.headers['x-content-type-options']).toBe('nosniff');
+    expect(res.headers['x-frame-options']).toBe('DENY');
+    expect(res.headers['referrer-policy']).toBe('no-referrer');
+    expect(res.headers['content-security-policy']).toContain("default-src 'self'");
+    expect(res.headers['content-security-policy']).toContain("frame-ancestors 'none'");
+    expect(String(res.headers['cache-control'])).toContain('no-store');
+    expect(res.headers['server']).toBeUndefined();
+  });
+
+  it('pose HSTS uniquement derrière HTTPS (x-forwarded-proto)', async () => {
+    const http = await bundle.app.inject({ method: 'GET', url: '/api/v1/auth/me', headers: auth() });
+    expect(http.headers['strict-transport-security']).toBeUndefined();
+    const https = await bundle.app.inject({
+      method: 'GET',
+      url: '/api/v1/auth/me',
+      headers: { ...auth(), 'x-forwarded-proto': 'https' },
+    });
+    expect(String(https.headers['strict-transport-security'])).toContain('max-age=');
+  });
+
+  it('rejette une mutation avec corps non-JSON (415)', async () => {
+    const res = await bundle.app.inject({
+      method: 'POST',
+      url: '/api/v1/auth/tokens',
+      headers: { ...auth(), 'content-type': 'text/plain' },
+      payload: 'label=pwned',
+    });
+    expect(res.statusCode).toBe(415);
+  });
+});
+
+describe('Journal d’audit', () => {
+  it('journalise la création de token et l’expose via GET /audit-logs', async () => {
+    const create = await bundle.app.inject({
+      method: 'POST',
+      url: '/api/v1/auth/tokens',
+      headers: auth(),
+      payload: { label: 'ci-extra' },
+    });
+    expect(create.statusCode).toBe(201);
+
+    const res = await bundle.app.inject({ method: 'GET', url: '/api/v1/audit-logs', headers: auth() });
+    expect(res.statusCode).toBe(200);
+    const body = res.json() as AuditLogsResponse;
+    const actions = body.entries.map((e) => e.action);
+    expect(actions).toContain('token.create');
+    expect(actions).toContain('secret.generate'); // généré au bootstrap (system)
+    // aucune VALEUR secrète en clair : pas de chaîne hex de 64 caractères (server_secret / clé).
+    // (les ids sont des UUID avec tirets → non concernés ; 'server_secret' est un nom de ressource.)
+    expect(res.body).not.toMatch(/[a-f0-9]{64}/i);
+  });
+
+  it('journalise les échecs de login (actor anonymous)', async () => {
+    await bundle.app.inject({ method: 'POST', url: '/api/v1/auth/login', payload: { token: 'arb_invalid_xxx' } });
+    const res = await bundle.app.inject({ method: 'GET', url: '/api/v1/audit-logs?limit=200', headers: auth() });
+    const body = res.json() as AuditLogsResponse;
+    expect(body.entries.some((e) => e.action === 'login.failure' && e.actor === 'anonymous')).toBe(true);
+  });
+});
+
+describe('RGPD', () => {
+  it('exporte les données du token authentifié', async () => {
+    const res = await bundle.app.inject({ method: 'GET', url: '/api/v1/data/export', headers: auth() });
+    expect(res.statusCode).toBe(200);
+    const body = res.json() as DataExportResponse;
+    expect(Array.isArray(body.tokens)).toBe(true);
+    expect(body.tokens.some((t) => t.current)).toBe(true);
+    expect(Array.isArray(body.pushSubscriptions)).toBe(true);
+    expect(Array.isArray(body.sessions)).toBe(true);
+    expect(body.settings).toHaveProperty('scanRoots');
+  });
+
+  it('supprime en deux temps (pending → confirm → done) et révoque le token', async () => {
+    const pending = await bundle.app.inject({ method: 'POST', url: '/api/v1/data/delete-my-data', headers: auth(), payload: {} });
+    const p = pending.json() as DeleteMyDataResponse;
+    expect(p.status).toBe('pending');
+    expect(p.confirm).toBeTruthy();
+
+    // un 2e token existe (créé plus haut) → révoquer le token courant est autorisé.
+    const done = await bundle.app.inject({
+      method: 'POST',
+      url: '/api/v1/data/delete-my-data',
+      headers: auth(),
+      payload: { confirm: p.confirm },
+    });
+    const d = done.json() as DeleteMyDataResponse;
+    expect(d.status).toBe('done');
+    expect(d.summary.tokenRevoked).toBe(true);
+
+    // le token courant est désormais révoqué → 401.
+    const after = await bundle.app.inject({ method: 'GET', url: '/api/v1/auth/me', headers: auth() });
+    expect(after.statusCode).toBe(401);
+  });
+});

packages/server/test/claude-launcher.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it, vi } from 'vitest';
+import { buildSpawnSpec } from '../src/core/claude-launcher.js';
+
+// resolveClaudeBin() fait `which claude` : on le stub pour ne pas dépendre d'un claude réel en PATH.
+vi.mock('node:child_process', () => ({ execFileSync: () => '/usr/bin/claude\n' }));
+
+describe('buildSpawnSpec — session de groupe multi-repo (P6)', () => {
+  it('émet un --add-dir par répertoire supplémentaire (claude)', () => {
+    const spec = buildSpawnSpec({ command: 'claude', addDirs: ['/a', '/b', '/c'] });
+    expect(spec.file).toBe('/usr/bin/claude');
+    expect(spec.args).toEqual(['--add-dir', '/a', '--add-dir', '/b', '--add-dir', '/c']);
+  });
+
+  it('combine --resume et --add-dir (reprise d’une session de groupe)', () => {
+    const spec = buildSpawnSpec({ command: 'claude', resume: { claudeSessionId: 'sid' }, addDirs: ['/x'] });
+    expect(spec.args).toEqual(['--resume', 'sid', '--add-dir', '/x']);
+  });
+
+  it('aucun --add-dir quand addDirs est vide/absent', () => {
+    expect(buildSpawnSpec({ command: 'claude' }).args).toEqual([]);
+    expect(buildSpawnSpec({ command: 'claude', addDirs: [] }).args).toEqual([]);
+  });
+
+  it('ignore addDirs pour bash (pas de --add-dir)', () => {
+    const spec = buildSpawnSpec({ command: 'bash', addDirs: ['/a', '/b'] });
+    expect(spec.file).toBe('bash');
+    expect(spec.args).toEqual(['--norc']);
+  });
+});

packages/server/test/discovery-service.test.ts

@@ -7,7 +7,7 @@ import { DiscoveryService, mergeSessions } from '../src/core/discovery-service.j
 import { munge } from '../src/core/jsonl-discovery.js';
 import { readProcStart } from '../src/core/session-registry.js';
 import { PtyManager } from '../src/core/pty-manager.js';
-import { openDb, type Db } from '../src/db/index.js';
+import { openDb, hideSession, unhideSession, listHiddenSessionIds, type Db } from '../src/db/index.js';
 
 function writeJsonl(projectsDir: string, cwd: string, sid: string): void {
   const dir = join(projectsDir, munge(cwd));
@@ -30,7 +30,7 @@ describe('DiscoveryService', () => {
     sessionsDir = mkdtempSync(join(tmpdir(), 'arb-sess-'));
     db = openDb(':memory:');
     manager = new PtyManager(db, sessionsDir);
-    svc = new DiscoveryService({ ptyManager: manager, projectsDir, sessionsDir });
+    svc = new DiscoveryService({ db, ptyManager: manager, projectsDir, sessionsDir });
   });
   afterEach(() => {
     svc.stop();
@@ -71,6 +71,29 @@ describe('DiscoveryService', () => {
     expect(svc.list().find((x) => x.id === 'managed-sid')).toBeUndefined();
   });
 
+  it('marque hidden une session masquée mais la garde résoluble (resume/fork)', async () => {
+    writeJsonl(projectsDir, '/home/u/old', 'old-sid');
+    hideSession(db, 'old-sid');
+    await svc.refresh();
+    const s = svc.list().find((x) => x.id === 'old-sid');
+    expect(s?.hidden).toBe(true);
+    // toujours connue : la reprise/le fork doivent rester possibles
+    expect(svc.getDiscovered('old-sid')?.cwd).toBe('/home/u/old');
+    // ré-affichage
+    unhideSession(db, 'old-sid');
+    await svc.refresh();
+    expect(svc.list().find((x) => x.id === 'old-sid')?.hidden).toBe(false);
+  });
+
+  it('hideSession est idempotent et listHiddenSessionIds reflète l’état', () => {
+    hideSession(db, 'a');
+    hideSession(db, 'a');
+    hideSession(db, 'b');
+    expect(listHiddenSessionIds(db)).toEqual(new Set(['a', 'b']));
+    unhideSession(db, 'a');
+    expect(listHiddenSessionIds(db)).toEqual(new Set(['b']));
+  });
+
   it('émet discovery_update sur changement uniquement', async () => {
     writeJsonl(projectsDir, '/home/u/x', 'sid-x');
     const seen: SessionSummary[] = [];

packages/server/test/fixtures/dialogs/ask2.raw

@@ -19,7 +19,7 @@
 ClaudeCode'llbeabletoread,edit,andexecutefileshere.
 
 
-
+
 ]8;id=zaxmda;https://code.claude.com/docs/en/securitySecurity guide]8;;
 
 
@@ -321,13 +321,13 @@
 [?25h[?2026l[?2026h[?25l
 Simrin(2s · thinking with xhigh effort)
 
-
+
 
 
 
 
 [?25h[?2026l[?2026h[?25l
-thinking with xhigh effort
+thinking with xhigh effort
 
 
 
@@ -343,7 +343,7 @@
 
 
 [?25h[?2026l[?2026h[?25l
-thinking with xhigh effort
+thinking with xhigh effort
 
 
 
@@ -359,7 +359,7 @@
 
 
 [?25h[?2026l[?2026h[?25l
-57thinking with xhigh effort
+57thinking with xhigh effort
 
 
 
@@ -566,7 +566,7 @@
 
 esctointerruptYou'veused96%ofyoursessionlimit·resets7pm(America/Lima)·/usage-creditstorequestmore
 
-[?25h[?2026l[?2026h[?25l
+[?25h[?2026l[?2026h[?25l
 nn
-
+
 

packages/server/test/fixtures/dialogs/deny-esc2.raw

@@ -19,7 +19,7 @@
 ClaudeCode'llbeabletoread,edit,andexecutefileshere.
 
 
-
+
 ]8;id=zaxmda;https://code.claude.com/docs/en/securitySecurity guide]8;;
 
 
@@ -475,7 +475,7 @@
 4thought for 1s)
 
 
-
+
 
 
 

packages/server/test/fixtures/dialogs/perm-bash2.raw

@@ -19,7 +19,7 @@
 ClaudeCode'llbeabletoread,edit,andexecutefileshere.
 
 
-
+
 ]8;id=zaxmda;https://code.claude.com/docs/en/securitySecurity guide]8;;
 
 

packages/server/test/fixtures/dialogs/perm-write2.raw

@@ -19,7 +19,7 @@
 ClaudeCode'llbeabletoread,edit,andexecutefileshere.
 
 
-
+
 ]8;id=zaxmda;https://code.claude.com/docs/en/securitySecurity guide]8;;
 
 
@@ -218,13 +218,13 @@
 
 
 
-[?25h[?2026l[?2026h[?25l
+[?25h[?2026l[?2026h[?25l
 ✻
 
 
 
 
-
+
 
 [?25h[?2026l[?2026h[?25l
 ✽
@@ -242,7 +242,7 @@
 
 
 
-[?25h[?2026l[?2026h[?25l
+[?25h[?2026l[?2026h[?25l
 (1s · thinking with xhigh effort)
 
 
@@ -251,7 +251,7 @@
 
 
 [?25h[?2026l[?2026h[?25l
-on2thinking with xhigh effort
+on2thinking with xhigh effort
 
 
 
@@ -416,7 +416,7 @@
 ❯ 
 
 ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
-
+
 esctointerruptYou'veused91%ofyoursessionlimit·resets7pm(America/Lima)·/usage-creditstorequestmore
 
 [?25h[?2026l[?2026h[?25l
@@ -430,16 +430,16 @@
 [?25h[?2026l[?2026h[?25l
 *ng
 
-
+
 
 
-
+
 
 [?25h[?2026l[?2026h[?25l
 …
 
 
-
+
 
 
 

packages/server/test/fixtures/dialogs/trust.raw

@@ -19,7 +19,7 @@
 ClaudeCode'llbeabletoread,edit,andexecutefileshere.
 
 
-
+
 ]8;id=zaxmda;https://code.claude.com/docs/en/securitySecurity guide]8;;
 
 

packages/server/test/git.test.ts

@@ -13,7 +13,12 @@ import {
   addWorktree,
   removeWorktree,
   pruneWorktrees,
+  switchBranch,
   isDirtyWorktreeError,
+  branchExists,
+  currentBranch,
+  listBranches,
+  commitAll,
 } from '../src/core/git.js';
 
 const dirs: string[] = [];
@@ -95,7 +100,7 @@ describe('opérations git (repo tmp réel)', () => {
     const repo = makeTmpRepo();
     const wtPath = join(dirname(repo), `${basename(repo)}-wt-feat`);
     dirs.push(wtPath);
-    await addWorktree(repo, { path: wtPath, branch: 'feat', newBranch: true });
+    await addWorktree(repo, { path: wtPath, branch: 'feat', mode: 'create' });
 
     const list = await listWorktrees(repo);
     const wt = list.find((w) => resolve(w.path) === resolve(wtPath));
@@ -118,12 +123,74 @@ describe('opérations git (repo tmp réel)', () => {
     expect((await listWorktrees(repo)).some((w) => resolve(w.path) === resolve(wtPath))).toBe(false);
   });
 
+  it('switchBranch : create=true crée une branche, create=false bascule sur une existante', async () => {
+    const repo = makeTmpRepo();
+    const cur = (): string => execFileSync('git', ['branch', '--show-current'], { cwd: repo }).toString().trim();
+
+    await switchBranch(repo, { branch: 'feature/new', create: true });
+    expect(cur()).toBe('feature/new');
+
+    await switchBranch(repo, { branch: 'main', create: false });
+    expect(cur()).toBe('main');
+
+    // créer une branche déjà existante échoue (git refuse).
+    await expect(switchBranch(repo, { branch: 'feature/new', create: true })).rejects.toBeDefined();
+  });
+
   it('prune retire un worktree dont le dossier a disparu', async () => {
     const repo = makeTmpRepo();
     const wtPath = join(dirname(repo), `${basename(repo)}-wt-gone`);
-    await addWorktree(repo, { path: wtPath, branch: 'gone', newBranch: true });
+    await addWorktree(repo, { path: wtPath, branch: 'gone', mode: 'create' });
     rmSync(wtPath, { recursive: true, force: true }); // suppression "à la main"
     await pruneWorktrees(repo);
     expect((await listWorktrees(repo)).some((w) => resolve(w.path) === resolve(wtPath))).toBe(false);
   });
 });
+
+describe('branche : existence, liste, courante, commit', () => {
+  it('branchExists / currentBranch / listBranches', async () => {
+    const repo = makeTmpRepo();
+    expect(await currentBranch(repo)).toBe('main');
+    expect(await branchExists(repo, 'main')).toEqual({ local: true, remote: false });
+    expect(await branchExists(repo, 'nope')).toEqual({ local: false, remote: false });
+
+    execFileSync('git', ['branch', 'dev'], { cwd: repo });
+    const b = await listBranches(repo);
+    expect(b.local).toContain('main');
+    expect(b.local).toContain('dev');
+    expect(b.remote).toEqual([]);
+  });
+
+  it('commitAll : add -A + commit, fait baisser dirtyCount à 0', async () => {
+    const repo = makeTmpRepo();
+    writeFileSync(join(repo, 'new.txt'), 'hello\n');
+    expect((await worktreeStatus(repo)).dirtyCount).toBeGreaterThan(0);
+    await commitAll(repo, 'add new.txt');
+    expect((await worktreeStatus(repo)).dirtyCount).toBe(0);
+  });
+});
+
+describe('addWorktree : résolution auto (créer / réutiliser)', () => {
+  it('auto crée la branche si absente, la réutilise si présente', async () => {
+    const repo = makeTmpRepo();
+    // branche absente → création (renvoie "created")
+    const wt1 = join(dirname(repo), `${basename(repo)}-wt-feat`);
+    dirs.push(wt1);
+    expect(await addWorktree(repo, { path: wt1, branch: 'feat', mode: 'auto' })).toBe('created');
+    expect((await listWorktrees(repo)).find((w) => resolve(w.path) === resolve(wt1))?.branch).toBe('feat');
+
+    // la même branche existe désormais ; un AUTRE worktree dessus → checkout (renvoie "reused")
+    await removeWorktree(repo, wt1, true); // libère la branche
+    const wt2 = join(dirname(repo), `${basename(repo)}-wt-feat2`);
+    dirs.push(wt2);
+    expect(await addWorktree(repo, { path: wt2, branch: 'feat', mode: 'auto' })).toBe('reused');
+  });
+
+  it('mode create échoue si la branche existe déjà', async () => {
+    const repo = makeTmpRepo();
+    execFileSync('git', ['branch', 'dup'], { cwd: repo });
+    const wt = join(dirname(repo), `${basename(repo)}-wt-dup`);
+    dirs.push(wt);
+    await expect(addWorktree(repo, { path: wt, branch: 'dup', mode: 'create' })).rejects.toBeDefined();
+  });
+});

packages/server/test/group-cwd.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from 'vitest';
+import { commonAncestorDir, resolveGroupCwd } from '../src/core/group-session.js';
+
+describe('commonAncestorDir', () => {
+  it('renvoie le chemin lui-même pour un seul répertoire', () => {
+    expect(commonAncestorDir(['/home/johan/WebstormProjects/arboretum'])).toBe('/home/johan/WebstormProjects/arboretum');
+  });
+
+  it('renvoie le parent commun de deux siblings', () => {
+    expect(commonAncestorDir(['/p/a', '/p/b'])).toBe('/p');
+  });
+
+  it('gère un répertoire ancêtre d’un autre', () => {
+    expect(commonAncestorDir(['/p/a', '/p/a/b'])).toBe('/p/a');
+  });
+
+  it('compare par segments, pas par préfixe de chaîne', () => {
+    // /a/bc n'est PAS un ancêtre de /a/bcd : ancêtre commun = /a
+    expect(commonAncestorDir(['/a/bc', '/a/bcd'])).toBe('/a');
+  });
+
+  it('renvoie la racine quand aucun segment n’est commun', () => {
+    expect(commonAncestorDir(['/x/a', '/y/b'])).toBe('/');
+  });
+});
+
+describe('resolveGroupCwd', () => {
+  it('mono-repo : cwd = le repo, addDirs sera filtré à vide par PtyManager', () => {
+    const { cwd, addDirs } = resolveGroupCwd(['/p/a']);
+    expect(cwd).toBe('/p/a');
+    expect(addDirs).toEqual(['/p/a']);
+  });
+
+  it('multi-repos sous un parent commun : cwd = parent, addDirs = tous les repos', () => {
+    const dirs = ['/home/johan/WebstormProjects/beehelp_lambdas', '/home/johan/WebstormProjects/beehelp_api'];
+    const { cwd, addDirs } = resolveGroupCwd(dirs);
+    expect(cwd).toBe('/home/johan/WebstormProjects');
+    expect(addDirs).toEqual(dirs);
+  });
+
+  it('garde-fou : repos sur des racines différentes → retombe sur le premier répertoire', () => {
+    const { cwd } = resolveGroupCwd(['/x/a', '/y/b']);
+    expect(cwd).toBe('/x/a');
+  });
+});

packages/server/test/group-manager.test.ts

@@ -97,4 +97,15 @@ describe('GroupManager', () => {
     db.prepare('DELETE FROM repos WHERE id = ?').run('repo-a');
     expect(gm.getGroup(g.id).repoIds).toEqual(['repo-b']);
   });
+
+  it('deleteGroup : désorpheline le group_id des sessions de groupe (P6)', () => {
+    const g = gm.createGroup({ label: 'A' });
+    // session de groupe liée à g (insérée directement, comme le ferait PtyManager.spawn).
+    db.prepare(
+      'INSERT INTO sessions (id, cwd, command, created_at, group_id) VALUES (?, ?, ?, ?, ?)',
+    ).run('sess-1', '/tmp/a', 'claude', new Date().toISOString(), g.id);
+    expect(gm.deleteGroup(g.id)).toBe(true);
+    const row = db.prepare('SELECT group_id FROM sessions WHERE id = ?').get('sess-1') as { group_id: string | null };
+    expect(row.group_id).toBeNull();
+  });
 });

packages/server/test/jsonl-discovery.test.ts

@@ -13,7 +13,7 @@ function writeJsonl(projectsDir: string, cwd: string, sid: string, lines: object
 describe('munge', () => {
   it('reproduit le nom de dossier ~/.claude/projects', () => {
     expect(munge('/home/x/My Project!')).toBe('-home-x-My-Project-');
-    expect(munge('/home/johan/WebstormProjects/arboretum')).toBe('-home-johan-WebstormProjects-arboretum');
+    expect(munge('/home/user/projects/demo')).toBe('-home-user-projects-demo');
   });
 });
 

packages/server/test/pty-manager.test.ts

@@ -187,6 +187,34 @@ describe('PtyManager (pty mocké)', () => {
       expect(listed).toMatchObject({ live: false, resumable: true, claudeSessionId: 'sid-known' });
     });
 
+    it('resumeTargetById : session claude morte → cwd + claudeSessionId + groupe ; null sinon', () => {
+      const d1 = mkdtempSync(join(tmpdir(), 'arb-rt-'));
+      try {
+        const summary = manager.spawn({ cwd, command: 'claude', addDirs: [d1], groupId: 'grpR' });
+        db.prepare('UPDATE sessions SET claude_session_id = ? WHERE id = ?').run('cs-resume', summary.id);
+        // vivante → null (resume direct interdit ; fork passe par le même chemin)
+        expect(manager.resumeTargetById(summary.id)).toBeNull();
+        lastPty().emitExit(0);
+        // morte avec claudeSessionId connu → cible complète
+        expect(manager.resumeTargetById(summary.id)).toEqual({
+          cwd,
+          claudeSessionId: 'cs-resume',
+          addedDirs: [d1],
+          groupId: 'grpR',
+        });
+        // id inconnu → null
+        expect(manager.resumeTargetById('nope')).toBeNull();
+      } finally {
+        rmSync(d1, { recursive: true, force: true });
+      }
+    });
+
+    it('resumeTargetById : session bash morte (sans claudeSessionId) → null', () => {
+      const { summary, pty } = spawnBash();
+      pty.emitExit(0);
+      expect(manager.resumeTargetById(summary.id)).toBeNull();
+    });
+
     it('capture le claudeSessionId via le registre (poll par pid) → findLiveByClaudeSessionId', () => {
       vi.useFakeTimers();
       const sessDir = mkdtempSync(join(tmpdir(), 'arb-sess-'));
@@ -215,7 +243,11 @@ describe('PtyManager (pty mocké)', () => {
 
     it('resync à l’attach = queue du ring (REPLAY_TAIL_BYTES max)', () => {
       const { summary, pty } = spawnBash();
-      const chunks = ['A', 'B', 'C'].map((c) => c.repeat(100 * 1024));
+      // on écrit volontairement PLUS que REPLAY_TAIL_BYTES (mais < RING_CAPACITY) pour vérifier
+      // le plafonnement de la queue rejouée. Tailles dérivées de la constante → robuste aux bumps.
+      const chunkSize = 256 * 1024;
+      const chunkCount = Math.ceil(REPLAY_TAIL_BYTES / chunkSize) + 2;
+      const chunks = Array.from({ length: chunkCount }, (_, i) => String.fromCharCode(65 + (i % 26)).repeat(chunkSize));
       for (const c of chunks) pty.emitData(c);
 
       const b = makeBinding('interactive');
@@ -574,4 +606,53 @@ describe('PtyManager (pty mocké)', () => {
       expect(manager.attach(summary.id, makeBinding('interactive'), 80, 24)).toEqual({ ok: false, code: 'NOT_FOUND' });
     });
   });
+
+  describe('session de groupe multi-repo (P6)', () => {
+    it('spawn avec addDirs : --add-dir au pty, addedDirs + groupId résumés et persistés', () => {
+      const d1 = mkdtempSync(join(tmpdir(), 'arb-g1-'));
+      const d2 = mkdtempSync(join(tmpdir(), 'arb-g2-'));
+      try {
+        const summary = manager.spawn({ cwd, command: 'claude', addDirs: [d1, d2], groupId: 'grp1' });
+        expect(lastPty().args).toEqual(['--add-dir', d1, '--add-dir', d2]);
+        expect(summary.addedDirs).toEqual([d1, d2]);
+        expect(summary.groupId).toBe('grp1');
+        const row = db.prepare('SELECT added_dirs, group_id FROM sessions WHERE id = ?').get(summary.id) as {
+          added_dirs: string | null;
+          group_id: string | null;
+        };
+        expect(JSON.parse(row.added_dirs as string)).toEqual([d1, d2]);
+        expect(row.group_id).toBe('grp1');
+      } finally {
+        rmSync(d1, { recursive: true, force: true });
+        rmSync(d2, { recursive: true, force: true });
+      }
+    });
+
+    it('dédoublonne et écarte le cwd primaire des addDirs', () => {
+      const d1 = mkdtempSync(join(tmpdir(), 'arb-g4-'));
+      try {
+        const summary = manager.spawn({ cwd, command: 'claude', addDirs: [d1, d1, cwd] });
+        expect(summary.addedDirs).toEqual([d1]);
+      } finally {
+        rmSync(d1, { recursive: true, force: true });
+      }
+    });
+
+    it('rejette un addDir inexistant (400)', () => {
+      expect(() => manager.spawn({ cwd, command: 'bash', addDirs: ['/no/such/dir/xyz-arb'] })).toThrow();
+    });
+
+    it('groupSessionContext renvoie les addedDirs/groupId persistés (resume)', () => {
+      const d1 = mkdtempSync(join(tmpdir(), 'arb-g5-'));
+      try {
+        const summary = manager.spawn({ cwd, command: 'claude', addDirs: [d1], groupId: 'grpX' });
+        // simule la capture du claudeSessionId (normalement résolue via le registre)
+        db.prepare('UPDATE sessions SET claude_session_id = ? WHERE id = ?').run('cs-1', summary.id);
+        expect(manager.groupSessionContext('cs-1')).toEqual({ addedDirs: [d1], groupId: 'grpX' });
+        expect(manager.groupSessionContext('unknown')).toBeNull();
+      } finally {
+        rmSync(d1, { recursive: true, force: true });
+      }
+    });
+  });
 });

packages/server/test/repo-scanner.test.ts

@@ -38,6 +38,16 @@ describe('scanForRepos', () => {
     expect(paths).toEqual([join(root, 'a')]);
   });
 
+  it('descend dans une racine qui est elle-même un repo (workspace + sous-repos)', async () => {
+    const root = tmpRoot();
+    makeRepo(root); // la racine fournie contient elle-même un .git (cas WebstormProjects)
+    makeRepo(root, 'a');
+    makeRepo(root, 'b');
+    const { paths } = await scanForRepos([root], limits);
+    // la racine ET ses dépôts internes sont découverts (la racine n'arrête pas le scan)
+    expect([...paths].sort()).toEqual([root, join(root, 'a'), join(root, 'b')].sort());
+  });
+
   it('ignore node_modules et les dotdirs', async () => {
     const root = tmpRoot();
     makeRepo(root, 'node_modules', 'pkg');

packages/server/test/secret-box.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest';
+import { randomBytes } from 'node:crypto';
+import { SecretBox } from '../src/core/secret-box.js';
+
+const box = (): SecretBox => new SecretBox(randomBytes(32));
+
+describe('SecretBox', () => {
+  it('chiffre puis déchiffre (round-trip)', () => {
+    const b = box();
+    const secret = 'deadbeef'.repeat(8);
+    const enc = b.encrypt(secret);
+    expect(enc.startsWith('v1:')).toBe(true);
+    expect(enc).not.toContain(secret); // le clair n'apparaît pas
+    expect(b.decrypt(enc)).toBe(secret);
+  });
+
+  it('produit un chiffré différent à chaque fois (IV aléatoire)', () => {
+    const b = box();
+    expect(b.encrypt('x')).not.toBe(b.encrypt('x'));
+  });
+
+  it('retourne tel quel une valeur en clair (legacy) et la détecte', () => {
+    const b = box();
+    expect(b.isEncrypted('plain-secret')).toBe(false);
+    expect(b.decrypt('plain-secret')).toBe('plain-secret');
+    expect(b.isEncrypted(b.encrypt('x'))).toBe(true);
+  });
+
+  it('échoue si la clé ne correspond pas (GCM authentifié)', () => {
+    const enc = box().encrypt('secret');
+    expect(() => box().decrypt(enc)).toThrow();
+  });
+
+  it('échoue sur un format chiffré corrompu', () => {
+    expect(() => box().decrypt('v1:zzz')).toThrow();
+  });
+});

packages/server/test/settings-routes.test.ts

@@ -1,5 +1,5 @@
 // Routes Réglages : GET expose la config non sensible (jamais les secrets), PATCH n'écrit que
-// l'allow-list et valide l'URL Gitea (http/https only, anti-XSS).
+// l'allow-list (découverte des dépôts) et ignore toute clé hors allow-list.
 import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
@@ -65,7 +65,7 @@ afterAll(async () => {
 });
 
 describe('GET /api/v1/settings', () => {
-  it('renvoie la config serveur non sensible et giteaUrl null par défaut', async () => {
+  it('renvoie la config serveur non sensible et aucune racine de scan par défaut', async () => {
     const res = await bundle.app.inject({ method: 'GET', url: '/api/v1/settings', headers: auth() });
     expect(res.statusCode).toBe(200);
     const body = res.json() as SettingsResponse;
@@ -74,10 +74,8 @@ describe('GET /api/v1/settings', () => {
     expect(body.server.bind).toBe('127.0.0.1');
     expect(body.server.allowedOrigins).toEqual(['https://host.tailnet.ts.net']);
     expect(body.server.vapidPublicKey).toBeTruthy(); // clé publique = sûre à exposer
-    expect(body.settings.giteaUrl).toBeNull();
+    // défauts de découverte : AUCUNE racine (clean install → pas de scan) + intervalle 5 min
-    // défauts de découverte : home (1 racine) + intervalle 5 min
+    expect(body.settings.scanRoots).toEqual([]);
-    expect(Array.isArray(body.settings.scanRoots)).toBe(true);
-    expect(body.settings.scanRoots).toHaveLength(1);
     expect(body.settings.scanIntervalMin).toBe(5);
   });
 
@@ -93,29 +91,7 @@ describe('GET /api/v1/settings', () => {
   });
 });
 
-describe('PATCH /api/v1/settings', () => {
+describe('PATCH /api/v1/settings — sécurité', () => {
-  it('enregistre une URL Gitea valide et la renvoie', async () => {
-    const res = await bundle.app.inject({ method: 'PATCH', url: '/api/v1/settings', headers: auth(), payload: { giteaUrl: 'https://git.lidge.fr' } });
-    expect(res.statusCode).toBe(200);
-    expect((res.json() as SettingsResponse).settings.giteaUrl).toBe('https://git.lidge.fr/');
-    // persisté
-    const get = await bundle.app.inject({ method: 'GET', url: '/api/v1/settings', headers: auth() });
-    expect((get.json() as SettingsResponse).settings.giteaUrl).toBe('https://git.lidge.fr/');
-  });
-
-  it('efface l’URL avec null ou chaîne vide', async () => {
-    await bundle.app.inject({ method: 'PATCH', url: '/api/v1/settings', headers: auth(), payload: { giteaUrl: 'https://git.lidge.fr' } });
-    const res = await bundle.app.inject({ method: 'PATCH', url: '/api/v1/settings', headers: auth(), payload: { giteaUrl: null } });
-    expect((res.json() as SettingsResponse).settings.giteaUrl).toBeNull();
-  });
-
-  it('rejette une URL non http(s) — anti-XSS (400)', async () => {
-    const res = await bundle.app.inject({ method: 'PATCH', url: '/api/v1/settings', headers: auth(), payload: { giteaUrl: 'javascript:alert(1)' } });
-    expect(res.statusCode).toBe(400);
-    const notUrl = await bundle.app.inject({ method: 'PATCH', url: '/api/v1/settings', headers: auth(), payload: { giteaUrl: 'pas une url' } });
-    expect(notUrl.statusCode).toBe(400);
-  });
-
   it('ignore toute clé hors allow-list (ne touche pas aux secrets)', async () => {
     const before = getSetting(db, 'server_secret');
     await bundle.app.inject({ method: 'PATCH', url: '/api/v1/settings', headers: auth(), payload: { server_secret: 'pwned', vapid_private: 'pwned' } });
@@ -124,7 +100,7 @@ describe('PATCH /api/v1/settings', () => {
   });
 
   it('sans authentification → 401', async () => {
-    const res = await bundle.app.inject({ method: 'PATCH', url: '/api/v1/settings', payload: { giteaUrl: 'https://x.example' } });
+    const res = await bundle.app.inject({ method: 'PATCH', url: '/api/v1/settings', payload: { scanRoots: ['/home/u/work'] } });
     expect(res.statusCode).toBe(401);
   });
 });

packages/server/test/worktree-manager.test.ts

@@ -69,7 +69,7 @@ describe('WorktreeManager', () => {
     claudeHome = mkdtempSync(join(tmpdir(), 'arb-ch-'));
     dirs.push(claudeHome);
     pty = new PtyManager(db, join(claudeHome, 'sessions'));
-    discovery = new DiscoveryService({ ptyManager: pty, projectsDir: join(claudeHome, 'projects'), sessionsDir: join(claudeHome, 'sessions') });
+    discovery = new DiscoveryService({ db, ptyManager: pty, projectsDir: join(claudeHome, 'projects'), sessionsDir: join(claudeHome, 'sessions') });
     wt = new WorktreeManager(db, pty, discovery);
   });
 
@@ -97,7 +97,8 @@ describe('WorktreeManager', () => {
 
     const wtPath = join(dirname(repo), `${basename(repo)}-wt-feat`);
     dirs.push(wtPath);
-    const out = await wt.createWorktree(r.id, { branch: 'feat', newBranch: true, runHooks: true });
+    const out = await wt.createWorktree(r.id, { branch: 'feat', mode: 'create', runHooks: true });
+    expect(out.action).toBe('created');
 
     expect(resolve(out.worktree.path)).toBe(resolve(wtPath));
     expect(out.worktree.branch).toBe('feat');
@@ -113,7 +114,47 @@ describe('WorktreeManager', () => {
   it('createWorktree : branche invalide → 400', async () => {
     const repo = makeTmpRepo();
     const r = await wt.addRepo({ path: repo });
-    await expect(wt.createWorktree(r.id, { branch: '../evil', newBranch: true })).rejects.toMatchObject({ statusCode: 400 });
+    await expect(wt.createWorktree(r.id, { branch: '../evil', mode: 'create' })).rejects.toMatchObject({ statusCode: 400 });
+  });
+
+  it('startMainSession : session dans le checkout principal (branche actuelle, sans mutation git)', async () => {
+    const repo = makeTmpRepo();
+    const r = await wt.addRepo({ path: repo });
+    const out = await wt.startMainSession(r.id, { command: 'bash' });
+    expect(resolve(out.session.cwd)).toBe(resolve(repo));
+    expect(out.session).toMatchObject({ command: 'bash', live: true });
+    // pas de bascule de branche → toujours sur main.
+    expect(execFileSync('git', ['branch', '--show-current'], { cwd: repo }).toString().trim()).toBe('main');
+    const main = (await wt.listRepoWorktrees(r.id, true)).find((w) => w.isMain);
+    expect(main?.sessions.some((s) => s.id === out.session.id)).toBe(true);
+  });
+
+  it('startMainSession : newBranch crée et bascule la branche dans le checkout principal + event', async () => {
+    const repo = makeTmpRepo();
+    const r = await wt.addRepo({ path: repo });
+    const events: Array<{ worktree: WorktreeSummary }> = [];
+    wt.on('worktree_update', (e) => events.push(e));
+    const out = await wt.startMainSession(r.id, { command: 'bash', branch: 'feature/x', newBranch: true });
+    expect(execFileSync('git', ['branch', '--show-current'], { cwd: repo }).toString().trim()).toBe('feature/x');
+    expect(out.worktree?.branch).toBe('feature/x');
+    expect(events.some((e) => e.worktree.isMain && e.worktree.branch === 'feature/x')).toBe(true);
+  });
+
+  it('startMainSession : checkout principal sale → 409 DIRTY_TREE (pas de bascule)', async () => {
+    const repo = makeTmpRepo();
+    const r = await wt.addRepo({ path: repo });
+    writeFileSync(join(repo, 'scratch.txt'), 'wip\n'); // arbre sale
+    await expect(wt.startMainSession(r.id, { command: 'bash', branch: 'feature/y', newBranch: true })).rejects.toMatchObject({
+      statusCode: 409,
+      code: 'DIRTY_TREE',
+    });
+    expect(execFileSync('git', ['branch', '--show-current'], { cwd: repo }).toString().trim()).toBe('main');
+  });
+
+  it('startMainSession : branche invalide → 400', async () => {
+    const repo = makeTmpRepo();
+    const r = await wt.addRepo({ path: repo });
+    await expect(wt.startMainSession(r.id, { command: 'bash', branch: '../evil', newBranch: true })).rejects.toMatchObject({ statusCode: 400 });
   });
 
   it('deleteWorktree : main refusé (400), dirty refusé (409) puis force OK', async () => {
@@ -123,7 +164,7 @@ describe('WorktreeManager', () => {
 
     const wtPath = join(dirname(repo), `${basename(repo)}-wt-x`);
     dirs.push(wtPath);
-    await wt.createWorktree(r.id, { branch: 'x', newBranch: true, runHooks: false });
+    await wt.createWorktree(r.id, { branch: 'x', mode: 'create', runHooks: false });
     writeFileSync(join(wtPath, 'scratch.txt'), 'wip\n'); // worktree sale
 
     await expect(wt.deleteWorktree(r.id, wtPath, false)).rejects.toMatchObject({ statusCode: 409, code: 'WORKTREE_DIRTY' });
@@ -136,7 +177,7 @@ describe('WorktreeManager', () => {
     const r = await wt.addRepo({ path: repo });
     const wtPath = join(dirname(repo), `${basename(repo)}-wt-sess`);
     dirs.push(wtPath);
-    await wt.createWorktree(r.id, { branch: 'sess', newBranch: true, runHooks: false });
+    await wt.createWorktree(r.id, { branch: 'sess', mode: 'create', runHooks: false });
 
     pty.spawn({ cwd: wtPath, command: 'bash' });
     const list = await wt.listRepoWorktrees(r.id, true);
@@ -150,11 +191,49 @@ describe('WorktreeManager', () => {
     const r = await wt.addRepo({ path: repo });
     const wtPath = join(dirname(repo), `${basename(repo)}-wt-busy`);
     dirs.push(wtPath);
-    await wt.createWorktree(r.id, { branch: 'busy', newBranch: true, runHooks: false });
+    await wt.createWorktree(r.id, { branch: 'busy', mode: 'create', runHooks: false });
     pty.spawn({ cwd: wtPath, command: 'bash' });
     await expect(wt.deleteWorktree(r.id, wtPath, false)).rejects.toMatchObject({ statusCode: 409, code: 'SESSION_LIVE_IN_WORKTREE' });
   });
 
+  it('listRepoBranches : renvoie les branches locales (dont main)', async () => {
+    const repo = makeTmpRepo();
+    const r = await wt.addRepo({ path: repo });
+    const b = await wt.listRepoBranches(r.id);
+    expect(b.local).toContain('main');
+  });
+
+  it('commitWorktree : arbre propre → 409 NOTHING_TO_COMMIT ; arbre sale → commit (dirty=0)', async () => {
+    const repo = makeTmpRepo();
+    const r = await wt.addRepo({ path: repo });
+    await expect(wt.commitWorktree(r.id, repo, 'noop')).rejects.toMatchObject({ statusCode: 409, code: 'NOTHING_TO_COMMIT' });
+    writeFileSync(join(repo, 'f.txt'), 'x\n');
+    const w = await wt.commitWorktree(r.id, repo, 'add f');
+    expect(w.git.dirtyCount).toBe(0);
+  });
+
+  it('promoteWorktree : la branche du worktree devient le checkout principal, worktree supprimé, ancienne branche conservée', async () => {
+    const repo = makeTmpRepo();
+    const r = await wt.addRepo({ path: repo });
+    const wtPath = join(dirname(repo), `${basename(repo)}-wt-prom`);
+    dirs.push(wtPath);
+    await wt.createWorktree(r.id, { branch: 'prom', mode: 'create', runHooks: false });
+
+    await wt.promoteWorktree(r.id, wtPath);
+
+    expect(execFileSync('git', ['branch', '--show-current'], { cwd: repo }).toString().trim()).toBe('prom');
+    expect((await wt.listRepoWorktrees(r.id, true)).some((w) => resolve(w.path) === resolve(wtPath))).toBe(false);
+    const branches = await wt.listRepoBranches(r.id);
+    expect(branches.local).toContain('main'); // ancienne branche principale conservée
+    expect(branches.local).toContain('prom');
+  });
+
+  it('promoteWorktree : checkout principal refusé (400 IS_MAIN_WORKTREE)', async () => {
+    const repo = makeTmpRepo();
+    const r = await wt.addRepo({ path: repo });
+    await expect(wt.promoteWorktree(r.id, repo)).rejects.toMatchObject({ statusCode: 400, code: 'IS_MAIN_WORKTREE' });
+  });
+
   it('addRepo renvoie hidden:false ; updateRepo({hidden}) bascule et émet repo_update', async () => {
     const repo = makeTmpRepo();
     const r = await wt.addRepo({ path: repo });

packages/shared/src/api.ts

@@ -53,6 +53,11 @@ export interface SessionsListResponse {
 export interface SessionResponse {
   session: SessionSummary;
 }
+/** POST /sessions/hide-discovered — masque tout l'historique de sessions externes visible. */
+export interface HideDiscoveredResponse {
+  /** nombre de sessions effectivement masquées. */
+  hidden: number;
+}
 
 // POST /sessions/:id/resume et /sessions/:id/fork (P2) : aucun corps — cwd et command
 // sont TOUJOURS dérivés du :id (lu sur disque), jamais fournis par le client (cf. spike S1).
@@ -104,11 +109,25 @@ export interface HookRunResult {
   output: string;
   durationMs: number;
 }
+/**
+ * Stratégie de résolution de la branche d'un nouveau worktree :
+ * - `auto` (défaut) : détecte l'existence de la branche — checkout si elle existe en local, suivi de
+ *   `origin/<branch>` si elle n'existe que sur le remote, sinon création (`-b`). Robuste pour les
+ *   groupes hétérogènes où la branche peut déjà exister dans certains dépôts mais pas d'autres.
+ * - `create` : force la création (`-b`), échoue si la branche existe déjà.
+ * - `checkout` : force le checkout d'une branche existante, échoue si elle est absente.
+ */
+export type WorktreeBranchMode = 'auto' | 'create' | 'checkout';
+/** Action réellement effectuée par la résolution `auto` (feedback UI). */
+export type WorktreeBranchAction = 'created' | 'reused' | 'tracked';
+
 export interface CreateWorktreeRequest {
   branch: string;
-  /** true : créer la branche (`-b`) ; false : checkout d'une branche existante. */
+  /** stratégie de résolution de la branche (défaut : `auto`). Voir {@link WorktreeBranchMode}. */
-  newBranch: boolean;
+  mode?: WorktreeBranchMode;
-  /** point de départ de la nouvelle branche (défaut : HEAD courant du repo). */
+  /** @deprecated remplacé par `mode` ; mappé : true→create, false→checkout, absent→auto. */
+  newBranch?: boolean;
+  /** point de départ d'une branche créée (défaut : branche par défaut du dépôt, sinon HEAD). */
   baseRef?: string;
   /** chemin cible du worktree (défaut : `<parent>/<repo>-wt-<branch>`). */
   path?: string;
@@ -121,6 +140,35 @@ export interface CreateWorktreeResponse {
   worktree: WorktreeSummary;
   hookResults: HookRunResult[];
   session: SessionSummary | null;
+  /** action effective de la résolution de branche (créée / réutilisée / suivie du remote). */
+  action: WorktreeBranchAction;
+}
+
+/** GET /api/v1/repos/:id/branches — branches locales/remote pour alimenter un sélecteur de base. */
+export interface RepoBranchesResponse {
+  local: string[];
+  remote: string[];
+  /** branche par défaut du dépôt (origin/HEAD), ou null si indéterminée. */
+  default: string | null;
+}
+
+/** POST /api/v1/repos/:id/worktrees/commit — `git add -A` puis commit dans le worktree visé. */
+export interface CommitWorktreeRequest {
+  path: string;
+  message: string;
+}
+/** POST /api/v1/repos/:id/worktrees/push — pousse la branche du worktree (upstream auto si absent). */
+export interface PushWorktreeRequest {
+  path: string;
+}
+/**
+ * POST /api/v1/repos/:id/worktrees/promote — « passer en principal » : la branche du worktree devient
+ * le checkout principal du dépôt (le worktree est supprimé, l'ancienne branche principale est conservée).
+ */
+export interface PromoteWorktreeRequest {
+  path: string;
+  /** outrepasse les garde-fous d'arbre sale (worktree/checkout principal). */
+  force?: boolean;
 }
 export interface AdoptWorktreeRequest {
   path: string;
@@ -128,6 +176,20 @@ export interface AdoptWorktreeRequest {
   preTrust?: boolean;
 }
 
+/**
+ * POST /api/v1/repos/:id/session — lance UNE session dans le checkout principal du repo
+ * (`repo.path`) pour « bosser sur la branche principale » sans créer de worktree.
+ * Réponse : `SessionResponse`.
+ */
+export interface StartRepoSessionRequest {
+  /** binaire à lancer — défaut "claude" ; "bash" sert aux tests sans quota. */
+  command?: 'claude' | 'bash';
+  /** si fourni : crée/bascule cette branche dans le checkout principal avant la session. */
+  branch?: string;
+  /** true (défaut quand `branch` fourni) : `git switch -c` ; false : bascule sur une branche existante. */
+  newBranch?: boolean;
+}
+
 // ---- Groupes de travail (P5) ----
 export interface GroupsListResponse {
   groups: GroupSummary[];
@@ -152,6 +214,22 @@ export interface AddRepoRequest {
   repoId: string;
 }
 
+// ---- Session de groupe multi-repo (P6) ----
+/** Lance UNE session Claude couvrant tous les repos du groupe (via `--add-dir`). */
+export interface CreateGroupSessionRequest {
+  /** défaut : claude. */
+  command?: 'claude' | 'bash';
+  /** présent → couvre le worktree de cette branche dans chaque repo ; absent → les checkouts principaux. */
+  branch?: string;
+}
+export interface GroupSessionResponse {
+  session: SessionSummary;
+  /** répertoires effectivement couverts par la session (cwd primaire en tête). */
+  dirs: string[];
+  /** repos du groupe pour lesquels aucun worktree n'a pu être résolu. */
+  skipped: Array<{ repoId: string; reason: string }>;
+}
+
 // ---- Navigateur de répertoires (sélecteur de dossier côté web) ----
 export interface FsEntry {
   name: string;
@@ -199,8 +277,7 @@ export interface ServerInfo {
 export interface SettingsResponse {
   /** réglages modifiables à chaud (allow-list serveur — jamais les secrets). */
   settings: {
-    giteaUrl: string | null;
+    /** racines absolues scannées pour la découverte auto des repos (défaut : aucune → pas de scan). */
-    /** racines absolues scannées pour la découverte auto des repos (défaut : home). */
     scanRoots: string[];
     /** intervalle du re-scan périodique en minutes ; 0 = périodique désactivé. */
     scanIntervalMin: number;
@@ -208,10 +285,48 @@ export interface SettingsResponse {
   server: ServerInfo;
 }
 export interface UpdateSettingsRequest {
-  /** URL de l'instance Gitea (http/https) ; null ou '' pour effacer. */
-  giteaUrl?: string | null;
   /** racines absolues à scanner (chemins normalisés, ≤ 16) ; remplace la liste. */
   scanRoots?: string[];
   /** intervalle du re-scan périodique en minutes (0–1440 ; 0 désactive). */
   scanIntervalMin?: number;
 }
+
+// ---- Journal d'audit (conformité entreprise) ----
+export interface AuditLogEntry {
+  id: string;
+  /** horodatage ISO 8601 */
+  ts: string;
+  /** tokenId de l'acteur, 'system' (auto) ou 'anonymous' (avant auth) */
+  actor: string;
+  /** verbe.objet, ex. 'token.create', 'settings.update' */
+  action: string;
+  resourceId: string | null;
+  /** métadonnées non sensibles (jamais de secret) */
+  details: unknown;
+  result: string;
+}
+export interface AuditLogsResponse {
+  entries: AuditLogEntry[];
+  /** curseur de pagination (ts à passer en `before`) ; null si fin de liste. */
+  nextBefore: string | null;
+}
+
+// ---- RGPD : export / suppression des données liées au token authentifié ----
+export interface DataExportResponse {
+  exportedAt: string;
+  tokens: Array<{ id: string; label: string; createdAt: string; lastUsedAt: string | null; current: boolean }>;
+  pushSubscriptions: Array<{ endpoint: string; userAgent: string | null; createdAt: string; lastOkAt: string | null }>;
+  sessions: Array<{ id: string; cwd: string; command: string; title: string | null; createdAt: string; endedAt: string | null; exitCode: number | null }>;
+  settings: { scanRoots: string[]; scanIntervalMin: number };
+}
+export interface DeleteMyDataRequest {
+  /** code de confirmation renvoyé par un premier appel sans `confirm` ; doit être renvoyé pour exécuter. */
+  confirm?: string;
+}
+export interface DeleteMyDataResponse {
+  /** 'pending' = confirmation requise (renvoie `confirm`) ; 'done' = suppression effectuée. */
+  status: 'pending' | 'done';
+  confirm?: string;
+  /** récapitulatif de ce qui sera/a été supprimé. */
+  summary: { pushSubscriptions: number; tokenRevoked: boolean };
+}

packages/shared/src/protocol.ts

@@ -51,8 +51,12 @@ export const FLOW = {
   LAGGING_BYTES: 2 * 1024 * 1024,
 } as const;
 
-/** Replay à l'attach : reset terminal + queue du ring (l'écran TUI se repeint en continu) */
+/**
-export const REPLAY_TAIL_BYTES = 256 * 1024;
+ * Replay à l'attach : reset terminal + queue du ring (l'écran TUI se repeint en continu).
+ * 1 Mo (≈ 10–15k lignes) pour permettre de remonter une vraie conversation Claude dans le terminal ;
+ * reste < LAGGING_BYTES (pas de faux lagging) et bien dans RING_CAPACITY.
+ */
+export const REPLAY_TAIL_BYTES = 1024 * 1024;
 
 // ---- États de session (sous-ensemble P1 ; étendu en P3) ----
 export type SessionRuntimeStatus =
@@ -113,6 +117,14 @@ export interface SessionSummary {
   waitingFor?: string | null;
   /** dialogue typé en cours (présent quand activity === 'waiting'). */
   dialog?: SessionDialog | null;
+  // ---- P6 : session de groupe multi-repo (additif) ----
+  /** répertoires supplémentaires couverts via `--add-dir` ; absent/[] pour une session mono-repo. */
+  addedDirs?: string[];
+  /** groupe propriétaire d'une session de groupe (couvre plusieurs repos) ; null/absent sinon. */
+  groupId?: string | null;
+  // ---- Masquage (additif) ----
+  /** true = session découverte masquée par l'utilisateur (exclue de la liste sauf includeHidden). */
+  hidden?: boolean;
 }
 
 // ---- Worktrees & repos (P3) ----

packages/site/index.html

@@ -0,0 +1,53 @@
+<!doctype html>
+<html lang="en" style="background-color: #09090b">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <meta name="color-scheme" content="dark" />
+    <meta name="theme-color" content="#09090b" />
+
+    <title>Arboretum — Mission control for your AI coding agents</title>
+    <meta
+      name="description"
+      content="Arboretum is a local-first daemon you launch with npx that serves a web dashboard to run and supervise many Claude Code sessions across git worktrees — from any device, even your phone."
+    />
+    <link rel="canonical" href="https://git-arboretum.com/" />
+
+    <!-- Open Graph / Twitter -->
+    <meta property="og:type" content="website" />
+    <meta property="og:url" content="https://git-arboretum.com/" />
+    <meta property="og:title" content="Arboretum — Mission control for your AI coding agents" />
+    <meta
+      property="og:description"
+      content="Run and supervise many Claude Code sessions across every git worktree — from any device, even your phone."
+    />
+    <meta property="og:site_name" content="Arboretum" />
+    <meta property="og:image" content="https://git-arboretum.com/assets/og-cover.png" />
+    <meta property="og:image:width" content="1200" />
+    <meta property="og:image:height" content="630" />
+    <meta property="og:image:alt" content="Arboretum — mission control for your AI coding agents" />
+    <meta name="twitter:card" content="summary_large_image" />
+    <meta name="twitter:title" content="Arboretum — Mission control for your AI coding agents" />
+    <meta
+      name="twitter:description"
+      content="Run and supervise many Claude Code sessions across every git worktree — from any device, even your phone."
+    />
+    <meta name="twitter:image" content="https://git-arboretum.com/assets/og-cover.png" />
+
+    <!-- Icons -->
+    <link rel="icon" type="image/svg+xml" href="/icon.svg" />
+    <link rel="icon" type="image/x-icon" href="/favicon.ico" />
+    <link rel="apple-touch-icon" href="/apple-touch-icon.png" />
+    <!-- Polices JetBrains Mono self-host via @fontsource (importées dans src/main.ts). -->
+  </head>
+  <body>
+    <div id="app"></div>
+    <noscript>
+      <div style="padding: 24px; font-family: system-ui, sans-serif; color: #f4f4f5; text-align: center">
+        Arboretum — mission control for your AI coding agents.
+        <a href="https://git.lidge.fr/johanleroy/arboretum" style="color: #34d399">View on Gitea</a>.
+      </div>
+    </noscript>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>

packages/site/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@arboretum/site",
+  "private": true,
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vue-tsc --noEmit && vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "vue": "^3.5.38",
+    "vue-i18n": "^11.4.5"
+  },
+  "devDependencies": {
+    "@fontsource/jetbrains-mono": "^5.1.0",
+    "@tailwindcss/vite": "^4.3.0",
+    "@vitejs/plugin-vue": "^6.0.7",
+    "tailwindcss": "^4.3.0",
+    "typescript": "^5.7.0",
+    "vite": "^8.0.16",
+    "vue-tsc": "^3.3.4"
+  }
+}

packages/site/public/.htaccess

@@ -0,0 +1,16 @@
+# git-arboretum.com — site vitrine statique (Vue 3 / Vite).
+#
+# Google PageSpeed (mod_pagespeed) renvoie un corps HTML VIDE sur ce domaine Plesk
+# (la home répond 200 mais 0 octet → page blanche), alors que les assets statiques
+# passent. Les bundles Vite sont déjà minifiés, hashés et gzippés : PageSpeed
+# n'apporte rien ici et casse le rendu. On le désactive pour ce vhost.
+#
+# NB : si l'hébergement interdit ces directives en .htaccess (AllowOverride
+# restrictif), Apache renverra une 500 → dans ce cas, supprimer ce fichier et
+# désactiver PageSpeed depuis Plesk (Apache & nginx Settings).
+<IfModule pagespeed_module>
+  ModPagespeed off
+</IfModule>
+<IfModule ngx_pagespeed_module>
+  pagespeed off;
+</IfModule>

packages/site/public/icon.svg

@@ -0,0 +1,46 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="512" height="512" viewBox="0 0 512 512" role="img" aria-label="Arboretum">
+  <defs>
+    <!-- glow néon : flou doux derrière les traits et les nœuds -->
+    <filter id="glow" x="-30%" y="-30%" width="160%" height="160%">
+      <feGaussianBlur stdDeviation="6" result="b"/>
+      <feMerge><feMergeNode in="b"/><feMergeNode in="SourceGraphic"/></feMerge>
+    </filter>
+    <linearGradient id="branch" x1="256" y1="430" x2="256" y2="90" gradientUnits="userSpaceOnUse">
+      <stop offset="0" stop-color="#10b981"/>
+      <stop offset="1" stop-color="#34d399"/>
+    </linearGradient>
+  </defs>
+
+  <rect width="512" height="512" fill="#09090b"/>
+
+  <!-- branches / circuit (tronc + fourches symétriques), tracées dans la zone sûre maskable -->
+  <g fill="none" stroke="url(#branch)" stroke-width="17" stroke-linecap="round" stroke-linejoin="round" filter="url(#glow)">
+    <!-- tronc : du nœud sommet jusqu'à la base avec le curseur >_ -->
+    <path d="M256 96 V392"/>
+    <!-- paire haute -->
+    <path d="M256 232 L150 232 V150"/>
+    <path d="M256 232 L362 232 V150"/>
+    <!-- paire médiane -->
+    <path d="M256 300 L104 300 V214"/>
+    <path d="M256 300 L408 300 V214"/>
+    <!-- paire basse -->
+    <path d="M256 356 L150 356 V300"/>
+    <path d="M256 356 L362 356 V300"/>
+    <!-- base : invite de commande >_ -->
+    <path d="M232 404 L246 418 L232 432" stroke-width="14"/>
+    <path d="M258 434 H286" stroke-width="14"/>
+  </g>
+
+  <!-- nœuds (sessions) : anneaux cyan lumineux, centre sombre -->
+  <g filter="url(#glow)">
+    <g fill="#09090b" stroke="#22d3ee" stroke-width="9">
+      <circle cx="256" cy="96"  r="20"/>
+      <circle cx="150" cy="150" r="16"/>
+      <circle cx="362" cy="150" r="16"/>
+      <circle cx="104" cy="214" r="16"/>
+      <circle cx="408" cy="214" r="16"/>
+      <circle cx="150" cy="300" r="16"/>
+      <circle cx="362" cy="300" r="16"/>
+    </g>
+  </g>
+</svg>

packages/site/public/robots.txt

@@ -0,0 +1,4 @@
+User-agent: *
+Allow: /
+
+Sitemap: https://git-arboretum.com/sitemap.xml

packages/site/public/sitemap.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+  <url>
+    <loc>https://git-arboretum.com/</loc>
+    <lastmod>2026-06-19</lastmod>
+    <changefreq>monthly</changefreq>
+    <priority>1.0</priority>
+  </url>
+</urlset>

packages/site/src/App.vue

@@ -0,0 +1,74 @@
+<script setup lang="ts">
+import { watch } from 'vue';
+import { useI18n } from 'vue-i18n';
+import AppHeader from './components/AppHeader.vue';
+import HeroSection from './components/HeroSection.vue';
+import ProblemSection from './components/ProblemSection.vue';
+import FeaturesSection from './components/FeaturesSection.vue';
+import ShowcaseSection from './components/ShowcaseSection.vue';
+import WorkGroupsSection from './components/WorkGroupsSection.vue';
+import HowItWorksSection from './components/HowItWorksSection.vue';
+import SecuritySection from './components/SecuritySection.vue';
+import FaqSection from './components/FaqSection.vue';
+import FinalCta from './components/FinalCta.vue';
+import AppFooter from './components/AppFooter.vue';
+
+const { locale } = useI18n();
+
+// Tient l'attribut <html lang> synchronisé avec la langue active.
+watch(
+  locale,
+  (l) => {
+    document.documentElement.lang = l;
+  },
+  { immediate: true },
+);
+
+// Grain de fond + halo emerald (décoratifs) — portés tels quels du design.
+const grainStyle = {
+  position: 'fixed',
+  inset: '0',
+  zIndex: 0,
+  pointerEvents: 'none',
+  backgroundImage: 'radial-gradient(rgba(255,255,255,.025) 1px,transparent 1.4px)',
+  backgroundSize: '34px 34px',
+  WebkitMaskImage: 'radial-gradient(ellipse 120% 70% at 50% -4%,#000,transparent 70%)',
+  maskImage: 'radial-gradient(ellipse 120% 70% at 50% -4%,#000,transparent 70%)',
+} as const;
+
+const glowStyle = {
+  position: 'fixed',
+  top: '-26%',
+  left: '50%',
+  transform: 'translateX(-50%)',
+  width: '1100px',
+  height: '680px',
+  zIndex: 0,
+  pointerEvents: 'none',
+  background: 'radial-gradient(50% 50% at 50% 50%,rgba(16,185,129,.12),transparent 64%)',
+  filter: 'blur(18px)',
+} as const;
+</script>
+
+<template>
+  <div class="relative overflow-x-hidden">
+    <div aria-hidden="true" :style="grainStyle"></div>
+    <div aria-hidden="true" :style="glowStyle"></div>
+
+    <AppHeader />
+
+    <main id="top" class="relative z-[1]">
+      <HeroSection />
+      <ProblemSection />
+      <FeaturesSection />
+      <ShowcaseSection />
+      <WorkGroupsSection />
+      <HowItWorksSection />
+      <SecuritySection />
+      <FaqSection />
+      <FinalCta />
+    </main>
+
+    <AppFooter />
+  </div>
+</template>

packages/site/src/components/AppFooter.vue

@@ -0,0 +1,50 @@
+<script setup lang="ts">
+import { useI18n } from 'vue-i18n';
+import { INSTALL_COMMAND } from '../composables/useCopy';
+import { REPO, LICENSE, COFFEE } from '../lib/links';
+import IconGitea from './icons/IconGitea.vue';
+import CopyButton from './CopyButton.vue';
+
+const { t } = useI18n();
+</script>
+
+<template>
+  <footer class="relative z-[1] border-t border-[#1c1c1f]">
+    <div class="mx-auto flex max-w-[1200px] flex-wrap items-center justify-between gap-5 px-6 py-[34px]">
+      <div class="flex items-center gap-[11px]">
+        <img
+          src="/assets/arboretum-mark.png"
+          alt=""
+          width="22"
+          height="22"
+          class="h-[22px] w-[22px] object-contain"
+          style="filter: grayscale(1) brightness(1.5); opacity: 0.4"
+        />
+        <span class="font-mono text-sm text-zinc-300">git-arboretum.com</span>
+        <span class="ml-1 text-[13px] text-zinc-600">— {{ t('footTag') }}</span>
+      </div>
+      <div class="flex items-center gap-[22px] text-sm">
+        <a :href="REPO" target="_blank" rel="noopener" class="inline-flex items-center gap-1.5 text-zinc-400 no-underline transition-colors hover:text-emerald-400">
+          <IconGitea :size="15" />
+          Gitea
+        </a>
+        <a :href="LICENSE" target="_blank" rel="noopener" class="text-zinc-400 no-underline transition-colors hover:text-emerald-400">
+          {{ t('license') }}
+        </a>
+        <a
+          :href="COFFEE"
+          target="_blank"
+          rel="noopener"
+          class="inline-flex items-center gap-1.5 text-zinc-400 no-underline transition-colors hover:text-amber-400 focus-visible:rounded-md focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-amber-400/70"
+        >
+          <svg width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M10 2v2" /><path d="M14 2v2" /><path d="M5 8h13a1 1 0 0 1 1 1v2a4 4 0 0 1-4 4H8a4 4 0 0 1-4-4V9a1 1 0 0 1 1-1Z" /><path d="M6 15a4 4 0 0 0 4 4h2a4 4 0 0 0 4-4" /><path d="M19 9h1.5a2.5 2.5 0 0 1 0 5H18" /></svg>
+          {{ t('coffee') }}
+        </a>
+        <div class="flex items-center gap-2">
+          <code class="font-mono text-[12.5px] text-zinc-600">{{ INSTALL_COMMAND }}</code>
+          <CopyButton variant="icon" :text="INSTALL_COMMAND" :label="t('copyCommand')" />
+        </div>
+      </div>
+    </div>
+  </footer>
+</template>

packages/site/src/components/AppHeader.vue

@@ -0,0 +1,59 @@
+<script setup lang="ts">
+import { useI18n } from 'vue-i18n';
+import { REPO } from '../lib/links';
+import LangToggle from './LangToggle.vue';
+import IconGitea from './icons/IconGitea.vue';
+
+const { t } = useI18n();
+
+const navLinks = [
+  { href: '#features', key: 'navFeatures' },
+  { href: '#how', key: 'navHow' },
+  { href: '#security', key: 'navSecurity' },
+  { href: '#faq', key: 'navFaq' },
+] as const;
+</script>
+
+<template>
+  <header
+    class="sticky top-0 z-50 border-b border-[#1c1c1f] bg-[rgba(9,9,11,0.72)] backdrop-blur-[14px]"
+  >
+    <div class="mx-auto flex h-16 max-w-[1200px] items-center justify-between gap-6 px-6">
+      <a href="#top" class="flex items-center gap-2.5 text-zinc-100 no-underline">
+        <img
+          src="/assets/arboretum-mark.png"
+          alt="Arboretum"
+          width="28"
+          height="28"
+          class="block h-7 w-7 object-contain"
+        />
+        <span class="font-mono text-[17px] font-semibold tracking-[-0.01em]">Arboretum</span>
+      </a>
+
+      <nav class="hidden items-center gap-[30px] min-[900px]:flex">
+        <a
+          v-for="link in navLinks"
+          :key="link.href"
+          :href="link.href"
+          class="text-[14.5px] text-zinc-400 no-underline transition-colors hover:text-zinc-100"
+        >
+          {{ t(link.key) }}
+        </a>
+      </nav>
+
+      <div class="flex items-center gap-3.5">
+        <LangToggle />
+        <a
+          :href="REPO"
+          target="_blank"
+          rel="noopener"
+          aria-label="Gitea"
+          class="inline-flex items-center gap-[7px] rounded-lg border border-zinc-800 px-[13px] py-[7px] text-[13.5px] font-medium text-zinc-300 no-underline transition-colors hover:border-emerald-500/50 hover:text-emerald-400 focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-emerald-500/70"
+        >
+          <IconGitea :size="16" />
+          Gitea
+        </a>
+      </div>
+    </div>
+  </header>
+</template>

packages/site/src/components/CopyButton.vue

@@ -0,0 +1,57 @@
+<script setup lang="ts">
+import { useI18n } from 'vue-i18n';
+import { useCopy } from '../composables/useCopy';
+import IconCopy from './icons/IconCopy.vue';
+import IconCheck from './icons/IconCheck.vue';
+
+// Bouton « copier » réutilisable, avec retour visuel (icône ✓ + label) pendant 1800 ms.
+// Deux variantes :
+//  - 'bar'  : bouton étiqueté intégré aux barres de commande (hero, CTA final).
+//  - 'icon' : bouton compact icône seule, pour les blocs de code (étapes, footer).
+withDefaults(
+  defineProps<{
+    text: string;
+    variant?: 'bar' | 'icon';
+    label?: string; // aria-label décrivant ce qui est copié
+    barClass?: string; // padding/ajustements de la variante 'bar'
+  }>(),
+  { variant: 'bar', label: '', barClass: 'px-[15px]' },
+);
+
+const { t } = useI18n();
+const { copied, copy } = useCopy();
+</script>
+
+<template>
+  <button
+    v-if="variant === 'bar'"
+    type="button"
+    :aria-label="label || t('copy')"
+    :class="[
+      'inline-flex flex-none items-center gap-[7px] border-l border-zinc-800 bg-zinc-900 font-mono text-[13px] font-semibold transition-colors hover:bg-zinc-800 hover:text-emerald-400 focus-visible:outline-2 focus-visible:-outline-offset-2 focus-visible:outline-emerald-500/70',
+      barClass,
+      copied ? 'text-emerald-400' : 'text-zinc-300',
+    ]"
+    @click="copy(text)"
+  >
+    <component :is="copied ? IconCheck : IconCopy" :size="15" />
+    <span aria-live="polite">{{ copied ? t('copied') : t('copy') }}</span>
+  </button>
+
+  <button
+    v-else
+    type="button"
+    :aria-label="label || t('copy')"
+    :title="copied ? t('copied') : label || t('copy')"
+    :class="[
+      'inline-flex flex-none items-center justify-center rounded-md border p-1.5 transition-colors focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-emerald-500/70',
+      copied
+        ? 'border-emerald-500/40 bg-zinc-800 text-emerald-400'
+        : 'border-zinc-800 bg-zinc-900/80 text-zinc-400 hover:border-emerald-500/40 hover:bg-zinc-800 hover:text-emerald-400',
+    ]"
+    @click="copy(text)"
+  >
+    <component :is="copied ? IconCheck : IconCopy" :size="14" />
+    <span aria-live="polite" class="sr-only">{{ copied ? t('copied') : t('copy') }}</span>
+  </button>
+</template>

packages/site/src/components/FaqSection.vue

@@ -0,0 +1,52 @@
+<script setup lang="ts">
+import { computed, ref } from 'vue';
+import { useI18n } from 'vue-i18n';
+import { FAQS } from '../i18n/content';
+import type { AppLocale } from '../i18n';
+
+const { t, locale } = useI18n();
+const open = ref(0);
+const items = computed(() => FAQS[locale.value as AppLocale]);
+
+function toggle(i: number): void {
+  open.value = open.value === i ? -1 : i;
+}
+
+function panelStyle(i: number) {
+  return {
+    maxHeight: open.value === i ? '300px' : '0px',
+    opacity: open.value === i ? 1 : 0,
+    overflow: 'hidden',
+    transition: 'max-height .4s ease, opacity .35s ease',
+  } as const;
+}
+</script>
+
+<template>
+  <section id="faq" class="mx-auto max-w-[780px] scroll-mt-[84px] px-6 pb-[100px]">
+    <div v-reveal class="mb-[38px] text-center">
+      <div class="mb-3.5 font-mono text-xs uppercase tracking-[0.14em] text-emerald-400">{{ t('navFaq') }}</div>
+      <h2 class="m-0 text-[clamp(28px,3.4vw,40px)] font-semibold tracking-[-0.025em] text-zinc-50">{{ t('faqTitle') }}</h2>
+    </div>
+
+    <div v-reveal>
+      <div v-for="(f, i) in items" :key="i" class="border-t" :class="open === i ? 'border-emerald-400/40' : 'border-zinc-800'">
+        <button
+          type="button"
+          :aria-expanded="open === i"
+          :aria-controls="`faq-panel-${i}`"
+          class="flex w-full cursor-pointer items-center justify-between gap-4 border-none bg-transparent px-1 py-5 text-left text-[clamp(16px,2vw,18px)] font-medium text-zinc-50 focus-visible:rounded-md focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-emerald-500/70"
+          @click="toggle(i)"
+        >
+          <span>{{ f.q }}</span>
+          <span class="flex flex-none text-emerald-400 transition-transform duration-300" :class="open === i ? 'rotate-180' : ''">
+            <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="#34d399" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="m6 9 6 6 6-6" /></svg>
+          </span>
+        </button>
+        <div :id="`faq-panel-${i}`" :style="panelStyle(i)" :inert="open !== i" :aria-hidden="open !== i">
+          <p class="m-0 max-w-[640px] px-1 pb-5 text-[15.5px] leading-[1.6] text-zinc-400">{{ f.a }}</p>
+        </div>
+      </div>
+    </div>
+  </section>
+</template>

packages/site/src/components/FeatureCard.vue

@@ -0,0 +1,17 @@
+<script setup lang="ts">
+defineProps<{ title: string }>();
+</script>
+
+<template>
+  <div
+    class="rounded-xl border border-zinc-800 bg-zinc-900/50 p-6 transition-[transform,border-color] duration-[180ms] ease-in-out hover:-translate-y-[3px] hover:border-emerald-400/40"
+  >
+    <div
+      class="mb-4 inline-flex h-[42px] w-[42px] items-center justify-center rounded-[10px] bg-emerald-500/10 text-emerald-400"
+    >
+      <slot name="icon" />
+    </div>
+    <h3 class="m-0 mb-[7px] text-lg font-semibold text-zinc-50">{{ title }}</h3>
+    <p class="m-0 text-[14.5px] leading-[1.55] text-zinc-400"><slot /></p>
+  </div>
+</template>

packages/site/src/components/FeaturesSection.vue

@@ -0,0 +1,83 @@
+<script setup lang="ts">
+import { useI18n } from 'vue-i18n';
+import FeatureCard from './FeatureCard.vue';
+const { t } = useI18n();
+</script>
+
+<template>
+  <section id="features" class="mx-auto max-w-[1200px] scroll-mt-[84px] px-6 pb-[100px]">
+    <div v-reveal class="mb-[46px] text-center">
+      <div class="mb-3.5 font-mono text-xs uppercase tracking-[0.14em] text-emerald-400">{{ t('featKicker') }}</div>
+      <h2 class="m-0 text-[clamp(28px,3.4vw,40px)] font-semibold tracking-[-0.025em] text-zinc-50">
+        {{ t('featTitle') }}
+      </h2>
+    </div>
+
+    <div v-reveal class="grid grid-cols-[repeat(auto-fit,minmax(264px,1fr))] gap-4">
+      <FeatureCard :title="t('feat1Title')">
+        <template #icon>
+          <svg width="21" height="21" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><line x1="6" y1="3" x2="6" y2="15" /><circle cx="18" cy="6" r="3" /><circle cx="6" cy="18" r="3" /><path d="M18 9a9 9 0 0 1-9 9" /></svg>
+        </template>
+        {{ t('feat1Desc') }}
+      </FeatureCard>
+
+      <FeatureCard :title="t('feat2Title')">
+        <template #icon>
+          <svg width="21" height="21" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><rect width="7" height="7" x="3" y="3" rx="1" /><rect width="7" height="7" x="14" y="3" rx="1" /><rect width="7" height="7" x="14" y="14" rx="1" /><rect width="7" height="7" x="3" y="14" rx="1" /></svg>
+        </template>
+        {{ t('feat2Desc') }}
+      </FeatureCard>
+
+      <FeatureCard :title="t('feat3Title')">
+        <template #icon>
+          <svg width="21" height="21" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M22 12h-4l-3 9L9 3l-3 9H2" /></svg>
+        </template>
+        <span class="text-sky-300">{{ t('busy') }}</span> ·
+        <span class="text-amber-300">{{ t('waiting') }}</span> ·
+        <span class="text-emerald-400">{{ t('idle') }}</span> — {{ t('feat3Desc') }}
+      </FeatureCard>
+
+      <FeatureCard :title="t('feat4Title')">
+        <template #icon>
+          <svg width="21" height="21" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><rect width="14" height="20" x="5" y="2" rx="2.5" /><path d="M12 18h.01" /></svg>
+        </template>
+        {{ t('feat4Desc') }}
+      </FeatureCard>
+
+      <FeatureCard :title="t('feat5Title')">
+        <template #icon>
+          <svg width="21" height="21" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M10.27 21a1.94 1.94 0 0 0 3.46 0" /><path d="M3.262 15.326A1 1 0 0 0 4 17h16a1 1 0 0 0 .74-1.673C19.41 13.956 18 12.499 18 8A6 6 0 0 0 6 8c0 4.499-1.411 5.956-2.738 7.326" /></svg>
+        </template>
+        {{ t('feat5Desc') }}
+      </FeatureCard>
+
+      <FeatureCard :title="t('feat6Title')">
+        <template #icon>
+          <svg width="21" height="21" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z" /></svg>
+        </template>
+        {{ t('feat6Desc') }}
+      </FeatureCard>
+
+      <FeatureCard :title="t('feat7Title')">
+        <template #icon>
+          <svg width="21" height="21" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M2.97 12.92A2 2 0 0 0 2 14.63v3.24a2 2 0 0 0 .97 1.71l3 1.8a2 2 0 0 0 2.06 0L12 19v-5.5l-5-3-4.03 2.42Z" /><path d="m7 16.5-4.74-2.85" /><path d="m7 16.5 5-3" /><path d="M7 16.5v5.17" /><path d="M12 13.5V19l3.97 2.38a2 2 0 0 0 2.06 0l3-1.8a2 2 0 0 0 .97-1.71v-3.24a2 2 0 0 0-.97-1.71L17 10.5l-5 3Z" /><path d="m17 16.5 4.74-2.85" /><path d="M7.97 4.42A2 2 0 0 0 7 6.13v4.37l5 3 5-3V6.13a2 2 0 0 0-.97-1.71l-3-1.8a2 2 0 0 0-2.06 0l-3 1.8Z" /></svg>
+        </template>
+        {{ t('feat7Desc') }}
+      </FeatureCard>
+
+      <FeatureCard :title="t('feat8Title')">
+        <template #icon>
+          <svg width="21" height="21" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z" /></svg>
+        </template>
+        {{ t('feat8Desc') }}
+      </FeatureCard>
+
+      <FeatureCard :title="t('feat9Title')">
+        <template #icon>
+          <svg width="21" height="21" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><polyline points="16 18 22 12 16 6" /><polyline points="8 6 2 12 8 18" /></svg>
+        </template>
+        {{ t('feat9Desc') }}
+      </FeatureCard>
+    </div>
+  </section>
+</template>

packages/site/src/components/FinalCta.vue

@@ -0,0 +1,52 @@
+<script setup lang="ts">
+import { useI18n } from 'vue-i18n';
+import { INSTALL_COMMAND } from '../composables/useCopy';
+import { REPO } from '../lib/links';
+import IconGitea from './icons/IconGitea.vue';
+import CopyButton from './CopyButton.vue';
+
+const { t } = useI18n();
+</script>
+
+<template>
+  <section class="mx-auto max-w-[1200px] px-6 pb-[100px]">
+    <div
+      v-reveal
+      class="rounded-[20px] border border-zinc-800 px-6 py-[clamp(36px,5vw,64px)] text-center"
+      style="background: radial-gradient(120% 140% at 50% 0%, rgba(16, 185, 129, 0.1), transparent 60%), #0c0c0e"
+    >
+      <img
+        src="/assets/arboretum-mark.png"
+        alt=""
+        width="52"
+        height="52"
+        class="mx-auto mb-5 block h-[52px] w-[52px] object-contain"
+      />
+      <h2 class="m-0 mb-3.5 text-[clamp(30px,4vw,46px)] font-bold leading-[1.08] tracking-[-0.03em] text-zinc-50">
+        {{ t('ctaTitle') }}
+      </h2>
+      <p class="mx-auto mb-7 max-w-[480px] text-[17px] text-zinc-400">{{ t('ctaBody') }}</p>
+
+      <div
+        class="mx-auto flex max-w-[460px] items-stretch overflow-hidden rounded-[10px] border border-zinc-800 bg-zinc-950"
+      >
+        <div class="flex min-w-0 flex-1 items-center gap-2.5 overflow-x-auto whitespace-nowrap px-4 font-mono text-sm">
+          <span class="text-emerald-400">$</span><span class="text-zinc-200">{{ INSTALL_COMMAND }}</span>
+        </div>
+        <CopyButton variant="bar" :text="INSTALL_COMMAND" :label="t('copyCommand')" bar-class="px-4" />
+      </div>
+
+      <div class="mt-[18px]">
+        <a
+          :href="REPO"
+          target="_blank"
+          rel="noopener"
+          class="inline-flex items-center gap-2 text-[14.5px] text-zinc-400 no-underline transition-colors hover:text-emerald-400"
+        >
+          <IconGitea :size="16" />
+          {{ t('ctaSource') }}
+        </a>
+      </div>
+    </div>
+  </section>
+</template>

packages/site/src/components/HeroMockup.vue

@@ -0,0 +1,218 @@
+<script setup lang="ts">
+import { computed } from 'vue';
+import { useI18n } from 'vue-i18n';
+import { useHeroTimeline, type SessionState } from '../composables/useHeroTimeline';
+import { DLG_OPTS } from '../i18n/content';
+import type { AppLocale } from '../i18n';
+import IconGitea from './icons/IconGitea.vue';
+
+const { t, locale } = useI18n();
+const { anim } = useHeroTimeline('hero-stage');
+
+// Couleurs des lignes de terminal par type (porté de renderVals.C).
+const LINE_COLORS: Record<string, string> = {
+  cmd: '#52525b',
+  tool: '#a1a1aa',
+  edit: '#34d399',
+  add: '#34d399',
+  del: '#f87171',
+  ok: '#34d399',
+  warn: '#fcd34d',
+  run: '#7dd3fc',
+};
+
+// Couleurs alignées sur SessionStateBadge de l'app (zinc/emerald/amber/sky de Tailwind).
+const PILL: Record<SessionState, { bg: string; fg: string; dot: string; pulse: string }> = {
+  idle: { bg: '#022c22', fg: '#34d399', dot: '#34d399', pulse: '' },
+  busy: { bg: '#082f49', fg: '#7dd3fc', dot: '#7dd3fc', pulse: 'pulseSky 2s ease-in-out infinite' },
+  waiting: { bg: '#451a03', fg: '#fcd34d', dot: '#fcd34d', pulse: 'pulseAmber 2.2s ease-in-out infinite' },
+};
+
+const pill = computed(() => PILL[anim.value.sess]);
+const sessText = computed(() => t(anim.value.sess));
+
+const termLines = computed(() =>
+  anim.value.lines.map((l) => ({ text: l.text, color: LINE_COLORS[l.k] ?? '#d4d4d8' })),
+);
+
+// Options du dialogue de permission — reproduit DialogPrompt (boutons numérotés + Deny).
+const dlgOptions = computed(() =>
+  DLG_OPTS[locale.value as AppLocale].map((txt, i) => ({
+    num: anim.value.ans === i ? '✓' : String(i + 1),
+    text: txt,
+    highlighted: anim.value.hl === i,
+    answered: anim.value.ans === i,
+  })),
+);
+</script>
+
+<template>
+  <div id="hero-stage" class="relative min-w-[300px] flex-[1_1_480px]">
+    <div
+      class="relative overflow-hidden rounded-[14px] border border-zinc-800 bg-zinc-950 shadow-hero"
+    >
+      <!-- barre de fenêtre -->
+      <div class="flex items-center gap-2 border-b border-[#1c1c1f] bg-[#0c0c0e] px-[14px] py-[11px]">
+        <span class="h-2.5 w-2.5 rounded-full bg-zinc-700"></span>
+        <span class="h-2.5 w-2.5 rounded-full bg-zinc-700"></span>
+        <span class="h-2.5 w-2.5 rounded-full bg-zinc-700"></span>
+        <span class="ml-2 font-mono text-[11.5px] text-zinc-600">arboretum · localhost:7317</span>
+      </div>
+
+      <div class="flex min-h-[440px]">
+        <!-- sidebar (fidèle à AppSidebar : Worktrees / Sessions / Groups, puis Réglages / Aide / Gitea / Café) -->
+        <div
+          class="flex w-[190px] flex-none flex-col border-r border-[#1c1c1f] bg-zinc-900/40 px-2 py-3"
+        >
+          <div class="flex items-center gap-2 px-2 pb-3">
+            <img
+              src="/assets/arboretum-mark.png"
+              alt=""
+              width="22"
+              height="22"
+              class="h-[22px] w-[22px] object-contain"
+            />
+            <span class="text-[14px] font-semibold text-zinc-100">Arboretum</span>
+          </div>
+
+          <div
+            class="mb-2 flex items-center gap-2 rounded-lg border border-zinc-800 bg-zinc-950/40 px-2.5 py-1.5"
+          >
+            <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="#52525b" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="8" /><path d="m21 21-4.3-4.3" /></svg>
+            <span class="flex-1 text-[12px] text-zinc-500">{{ t('mSearch') }}</span>
+            <span class="rounded border border-zinc-700 px-[5px] py-px font-mono text-[10px] text-zinc-500">⌘K</span>
+          </div>
+
+          <!-- nav primaire -->
+          <div class="flex flex-col gap-1">
+            <div class="flex items-center gap-2.5 rounded-lg bg-zinc-800 px-2.5 py-1.5 text-zinc-100">
+              <svg width="17" height="17" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><line x1="6" x2="6" y1="3" y2="15" /><circle cx="18" cy="6" r="3" /><circle cx="6" cy="18" r="3" /><path d="M18 9a9 9 0 0 1-9 9" /></svg>
+              <span class="flex-1 text-[12.5px] font-medium">{{ t('mWorktrees') }}</span>
+            </div>
+            <div class="flex items-center gap-2.5 rounded-lg px-2.5 py-1.5 text-zinc-400">
+              <svg width="17" height="17" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="m7 11 2-2-2-2" /><path d="M11 13h4" /><rect width="18" height="18" x="3" y="3" rx="2" ry="2" /></svg>
+              <span class="flex-1 text-[12.5px] font-medium">{{ t('mSessions') }}</span>
+              <span
+                v-show="anim.att > 0"
+                class="rounded-full bg-amber-500/20 px-1.5 text-[11px] font-semibold text-amber-300"
+                >{{ anim.att }}</span
+              >
+            </div>
+            <div class="flex items-center gap-2.5 rounded-lg px-2.5 py-1.5 text-zinc-400">
+              <svg width="17" height="17" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M2.97 12.92A2 2 0 0 0 2 14.63v3.24a2 2 0 0 0 .97 1.71l3 1.8a2 2 0 0 0 2.06 0L12 19v-5.5l-5-3-4.03 2.42Z" /><path d="M7 16.5 12 13.5" /><path d="M12 13.5V19l3.97 2.38a2 2 0 0 0 2.06 0l3-1.8a2 2 0 0 0 .97-1.71v-3.24a2 2 0 0 0-.97-1.71L17 10.5l-5 3Z" /><path d="m17 16.5 4.74-2.85" /><path d="M7.97 4.42A2 2 0 0 0 7 6.13v4.37l5 3 5-3V6.13a2 2 0 0 0-.97-1.71l-3-1.8a2 2 0 0 0-2.06 0z" /></svg>
+              <span class="flex-1 text-[12.5px] font-medium">{{ t('mGroups') }}</span>
+            </div>
+          </div>
+
+          <div class="flex-1"></div>
+
+          <!-- nav secondaire -->
+          <div class="flex flex-col gap-1">
+            <div class="flex items-center gap-2.5 rounded-lg px-2.5 py-1.5 text-zinc-400">
+              <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M12.22 2h-.44a2 2 0 0 0-2 2v.18a2 2 0 0 1-1 1.73l-.43.25a2 2 0 0 1-2 0l-.15-.08a2 2 0 0 0-2.73.73l-.22.38a2 2 0 0 0 .73 2.73l.15.1a2 2 0 0 1 1 1.72v.51a2 2 0 0 1-1 1.74l-.15.09a2 2 0 0 0-.73 2.73l.22.38a2 2 0 0 0 2.73.73l.15-.08a2 2 0 0 1 2 0l.43.25a2 2 0 0 1 1 1.73V20a2 2 0 0 0 2 2h.44a2 2 0 0 0 2-2v-.18a2 2 0 0 1 1-1.73l.43-.25a2 2 0 0 1 2 0l.15.08a2 2 0 0 0 2.73-.73l.22-.39a2 2 0 0 0-.73-2.73l-.15-.08a2 2 0 0 1-1-1.74v-.5a2 2 0 0 1 1-1.74l.15-.09a2 2 0 0 0 .73-2.73l-.22-.38a2 2 0 0 0-2.73-.73l-.15.08a2 2 0 0 1-2 0l-.43-.25a2 2 0 0 1-1-1.73V4a2 2 0 0 0-2-2z" /><circle cx="12" cy="12" r="3" /></svg>
+              <span class="flex-1 text-[12.5px] font-medium">{{ t('mSettings') }}</span>
+            </div>
+            <div class="flex items-center gap-2.5 rounded-lg px-2.5 py-1.5 text-zinc-400">
+              <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="12" cy="12" r="10" /><path d="m4.93 4.93 4.24 4.24" /><path d="m14.83 9.17 4.24-4.24" /><path d="m14.83 14.83 4.24 4.24" /><path d="m9.17 14.83-4.24 4.24" /><circle cx="12" cy="12" r="4" /></svg>
+              <span class="flex-1 text-[12.5px] font-medium">{{ t('mHelp') }}</span>
+            </div>
+            <div class="flex items-center gap-2.5 rounded-lg px-2.5 py-1.5 text-zinc-400">
+              <IconGitea :size="16" />
+              <span class="flex-1 text-[12.5px] font-medium">{{ t('mGitea') }}</span>
+            </div>
+            <div class="flex items-center gap-2.5 rounded-lg px-2.5 py-1.5 text-zinc-400">
+              <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M10 2v2" /><path d="M14 2v2" /><path d="M16 8a1 1 0 0 1 1 1v8a4 4 0 0 1-4 4H7a4 4 0 0 1-4-4V9a1 1 0 0 1 1-1h14a4 4 0 1 1 0 8h-1" /><path d="M6 2v2" /></svg>
+              <span class="flex-1 text-[12.5px] font-medium">{{ t('coffee') }}</span>
+            </div>
+          </div>
+
+          <!-- pied : langue · notifications · déconnexion + version (fidèle à AppShellFooter) -->
+          <div class="mt-2 flex items-center gap-2 border-t border-[#1c1c1f] px-1 pt-2.5">
+            <span class="rounded border border-zinc-700 px-1.5 py-px font-mono text-[10px] text-zinc-400">{{ locale.toUpperCase() }}</span>
+            <svg width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="#34d399" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M10.268 21a2 2 0 0 0 3.464 0" /><path d="M3.262 15.326A1 1 0 0 0 4 17h16a1 1 0 0 0 .74-1.673C19.41 13.956 18 12.499 18 8A6 6 0 0 0 6 8c0 4.499-1.411 5.956-2.738 7.326" /></svg>
+            <svg width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="#71717a" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M9 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h4" /><polyline points="16 17 21 12 16 7" /><line x1="21" x2="9" y1="12" y2="12" /></svg>
+            <span class="ml-auto font-mono text-[10px] text-zinc-600">v1.6.0</span>
+          </div>
+        </div>
+
+        <!-- main -->
+        <div class="flex min-w-0 flex-1 flex-col gap-[11px] p-[13px]">
+          <!-- terminal pane -->
+          <div
+            class="flex min-h-0 flex-1 flex-col overflow-hidden rounded-[10px] border border-zinc-800 bg-zinc-950"
+          >
+            <div class="flex items-center justify-between border-b border-[#1c1c1f] px-[11px] py-2">
+              <span class="font-mono text-[11.5px] text-zinc-300">api · feat/auth</span>
+              <span
+                class="inline-flex items-center gap-1.5 rounded px-2 py-[3px] font-mono text-[11px]"
+                :style="{ background: pill.bg, color: pill.fg }"
+              >
+                <span
+                  class="h-1.5 w-1.5 flex-none rounded-full"
+                  :style="{ background: pill.dot, animation: pill.pulse }"
+                ></span>
+                {{ sessText }}
+              </span>
+            </div>
+            <div
+              class="flex min-h-[150px] flex-1 flex-col justify-end overflow-hidden p-[11px] font-mono text-xs leading-[1.7] text-zinc-300"
+            >
+              <div v-for="(ln, i) in termLines" :key="i" :style="{ color: ln.color, whiteSpace: 'pre' }">
+                {{ ln.text }}
+              </div>
+              <div v-if="anim.cur">
+                <span class="text-emerald-400">$</span>
+                <span class="ml-1 inline-block h-[13px] w-[7px] animate-blink align-middle bg-zinc-200"></span>
+              </div>
+            </div>
+          </div>
+
+          <!-- dialogue de permission (fidèle à DialogPrompt : badge type + question + options + Deny) -->
+          <div
+            v-if="anim.dlg"
+            class="animate-dlg-in rounded-lg border border-amber-900/60 bg-amber-950/30 p-[11px]"
+          >
+            <div class="mb-2 flex items-center gap-2">
+              <span class="inline-flex items-center rounded bg-amber-900 px-1.5 py-0.5 text-[11px] font-medium text-amber-200">{{ t('mPermission') }}</span>
+              <span class="text-[12.5px] text-amber-100">{{ t('dlgQ') }}</span>
+            </div>
+            <div class="flex flex-wrap gap-[6px]">
+              <span
+                v-for="(op, i) in dlgOptions"
+                :key="i"
+                class="inline-flex items-center gap-1.5 rounded-lg border px-2.5 py-1.5 text-xs font-medium transition-colors"
+                :class="op.answered
+                  ? 'border-emerald-500/70 bg-emerald-950/50 text-emerald-300'
+                  : op.highlighted
+                    ? 'border-amber-400 bg-amber-950/50 text-amber-200'
+                    : 'border-zinc-700 bg-zinc-800 text-zinc-200'"
+              >
+                <span class="font-mono" :class="op.answered ? 'text-emerald-400' : 'text-amber-400'">{{ op.num }}</span>
+                {{ op.text }}
+              </span>
+              <span class="inline-flex items-center rounded-lg border border-red-900 bg-red-950 px-2.5 py-1.5 text-xs font-medium text-red-300">{{ t('mDeny') }}</span>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <!-- toast push -->
+    <div
+      v-if="anim.toast"
+      class="animate-toast-in absolute bottom-[14px] right-[14px] flex w-[248px] items-start gap-2.5 rounded-[11px] border border-[rgba(120,53,15,0.5)] bg-[#0c0c0e] p-3 shadow-toast"
+    >
+      <span class="inline-flex h-[30px] w-[30px] flex-none items-center justify-center rounded-lg bg-emerald-500/15">
+        <img src="/assets/arboretum-mark.png" alt="" width="18" height="18" class="h-[18px] w-[18px] object-contain" />
+      </span>
+      <div class="min-w-0 flex-1">
+        <div class="flex items-center justify-between">
+          <span class="font-mono text-[11px] text-emerald-400">Arboretum</span>
+          <span class="text-[10px] text-zinc-600">now</span>
+        </div>
+        <div class="mt-[3px] text-[13px] font-semibold text-zinc-100">{{ t('toastTitle') }}</div>
+        <div class="mt-px text-[11.5px] leading-[1.4] text-zinc-400">{{ t('toastBody') }}</div>
+      </div>
+    </div>
+  </div>
+</template>

packages/site/src/components/HeroSection.vue

@@ -0,0 +1,71 @@
+<script setup lang="ts">
+import { useI18n } from 'vue-i18n';
+import { INSTALL_COMMAND } from '../composables/useCopy';
+import { REPO } from '../lib/links';
+import HeroMockup from './HeroMockup.vue';
+import IconGitea from './icons/IconGitea.vue';
+import CopyButton from './CopyButton.vue';
+
+const { t } = useI18n();
+</script>
+
+<template>
+  <section class="mx-auto flex max-w-[1200px] flex-wrap items-center gap-12 px-6 pb-16 pt-[72px]">
+    <div class="min-w-[300px] flex-[1_1_430px]">
+      <div class="mb-[22px] flex items-center gap-[13px]">
+        <img
+          src="/assets/arboretum-mark.png"
+          alt=""
+          width="46"
+          height="46"
+          class="block h-[46px] w-[46px] object-contain"
+        />
+        <span
+          class="inline-flex items-center gap-2 rounded-full border border-emerald-500/30 bg-emerald-500/[0.07] px-[11px] py-[5px] font-mono text-[11.5px] uppercase tracking-[0.1em] text-emerald-400"
+        >
+          <span class="h-1.5 w-1.5 rounded-full bg-emerald-400 shadow-[0_0_8px_#34d399]"></span>
+          {{ t('heroBadge') }}
+        </span>
+      </div>
+
+      <h1 class="m-0 text-[clamp(40px,5.6vw,64px)] font-bold leading-[1.04] tracking-[-0.035em] text-zinc-50">
+        {{ t('heroTitle') }}
+      </h1>
+      <p class="mt-[22px] max-w-[520px] text-[clamp(17px,1.7vw,20px)] leading-[1.55] text-zinc-400">
+        {{ t('heroSub') }}
+      </p>
+
+      <div
+        class="mt-[30px] flex max-w-[480px] items-stretch overflow-hidden rounded-[10px] border border-zinc-800 bg-zinc-950/60"
+      >
+        <div
+          class="flex min-w-0 flex-1 items-center gap-2.5 overflow-x-auto whitespace-nowrap px-[15px] font-mono text-sm"
+        >
+          <span class="text-emerald-400">$</span><span class="text-zinc-200">{{ INSTALL_COMMAND }}</span>
+        </div>
+        <CopyButton variant="bar" :text="INSTALL_COMMAND" :label="t('copyCommand')" />
+      </div>
+
+      <div class="mt-6 flex flex-wrap gap-[13px]">
+        <a
+          href="#how"
+          class="inline-flex items-center gap-[9px] rounded-[9px] bg-emerald-600 px-6 py-[13px] text-[15.5px] font-semibold text-white no-underline transition-[background,transform] duration-150 ease-in-out hover:-translate-y-px hover:bg-emerald-500 focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-emerald-500/70"
+        >
+          {{ t('getStarted') }}
+          <svg width="17" height="17" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M5 12h14" /><path d="m12 5 7 7-7 7" /></svg>
+        </a>
+        <a
+          :href="REPO"
+          target="_blank"
+          rel="noopener"
+          class="inline-flex items-center gap-[9px] rounded-[9px] border border-zinc-800 px-[22px] py-[13px] text-[15.5px] font-medium text-zinc-100 no-underline transition-colors hover:border-emerald-500/45 hover:text-emerald-400 focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-emerald-500/70"
+        >
+          <IconGitea :size="17" />
+          {{ t('gitea') }}
+        </a>
+      </div>
+    </div>
+
+    <HeroMockup />
+  </section>
+</template>

packages/site/src/components/HowItWorksSection.vue

@@ -0,0 +1,53 @@
+<script setup lang="ts">
+import { useI18n } from 'vue-i18n';
+import { INSTALL_COMMAND } from '../composables/useCopy';
+import CopyButton from './CopyButton.vue';
+
+const { t } = useI18n();
+// Port par défaut réel du daemon (cf. packages/server/src/config.ts).
+const LOCAL_URL = 'http://localhost:7317';
+</script>
+
+<template>
+  <section id="how" class="mx-auto max-w-[1200px] scroll-mt-[84px] px-6 pb-[100px]">
+    <div v-reveal class="mb-[46px] text-center">
+      <div class="mb-3.5 font-mono text-xs uppercase tracking-[0.14em] text-emerald-400">{{ t('howKicker') }}</div>
+      <h2 class="m-0 text-[clamp(28px,3.4vw,40px)] font-semibold tracking-[-0.025em] text-zinc-50">{{ t('howTitle') }}</h2>
+    </div>
+
+    <div v-reveal class="grid grid-cols-[repeat(auto-fit,minmax(280px,1fr))] gap-4">
+      <div class="rounded-xl border border-zinc-800 bg-zinc-900/50 p-[26px]">
+        <div class="mb-[18px] font-mono text-[13px] text-emerald-400">01</div>
+        <h3 class="m-0 mb-2.5 text-lg font-semibold text-zinc-50">{{ t('step1Title') }}</h3>
+        <p class="m-0 mb-4 text-[14.5px] leading-[1.55] text-zinc-400">{{ t('step1Desc') }}</p>
+        <div class="flex items-center gap-2 rounded-lg border border-zinc-800 bg-zinc-950 p-[11px]">
+          <code class="min-w-0 flex-1 overflow-x-auto whitespace-nowrap font-mono text-[12.5px] text-zinc-200">
+            <span class="text-emerald-400">$ </span>{{ INSTALL_COMMAND }}
+          </code>
+          <CopyButton variant="icon" :text="INSTALL_COMMAND" :label="t('copyCommand')" />
+        </div>
+      </div>
+      <div class="rounded-xl border border-zinc-800 bg-zinc-900/50 p-[26px]">
+        <div class="mb-[18px] font-mono text-[13px] text-emerald-400">02</div>
+        <h3 class="m-0 mb-2.5 text-lg font-semibold text-zinc-50">{{ t('step2Title') }}</h3>
+        <p class="m-0 mb-4 text-[14.5px] leading-[1.55] text-zinc-400">{{ t('step2Desc') }}</p>
+        <div class="flex items-center gap-2 rounded-lg border border-zinc-800 bg-zinc-950 p-[11px]">
+          <code class="min-w-0 flex-1 overflow-x-auto whitespace-nowrap font-mono text-[12.5px] text-sky-300">
+            → {{ LOCAL_URL }}
+          </code>
+          <CopyButton variant="icon" :text="LOCAL_URL" :label="t('copyUrl')" />
+        </div>
+      </div>
+      <div class="rounded-xl border border-zinc-800 bg-zinc-900/50 p-[26px]">
+        <div class="mb-[18px] font-mono text-[13px] text-emerald-400">03</div>
+        <h3 class="m-0 mb-2.5 text-lg font-semibold text-zinc-50">{{ t('step3Title') }}</h3>
+        <p class="m-0 mb-4 text-[14.5px] leading-[1.55] text-zinc-400">{{ t('step3Desc') }}</p>
+        <div class="flex flex-wrap gap-1.5">
+          <span class="rounded-md bg-emerald-500/10 px-[9px] py-1 font-mono text-[11px] text-emerald-400">{{ t('idle') }}</span>
+          <span class="rounded-md bg-[rgba(8,47,73,0.7)] px-[9px] py-1 font-mono text-[11px] text-sky-300">{{ t('busy') }}</span>
+          <span class="rounded-md bg-[rgba(69,26,3,0.6)] px-[9px] py-1 font-mono text-[11px] text-amber-300">{{ t('waiting') }}</span>
+        </div>
+      </div>
+    </div>
+  </section>
+</template>

packages/site/src/components/LangToggle.vue

@@ -0,0 +1,37 @@
+<script setup lang="ts">
+import { useI18n } from 'vue-i18n';
+import { setLocale, type AppLocale } from '../i18n';
+
+const { locale } = useI18n();
+
+function set(l: AppLocale): void {
+  setLocale(l);
+}
+</script>
+
+<template>
+  <div
+    role="group"
+    aria-label="Language"
+    class="flex items-center overflow-hidden rounded-lg border border-zinc-800 bg-zinc-950/40"
+  >
+    <button
+      type="button"
+      :aria-pressed="locale === 'en'"
+      class="cursor-pointer border-none px-[11px] py-1.5 font-mono text-xs font-semibold focus-visible:outline-2 focus-visible:outline-offset-1 focus-visible:outline-emerald-500/70"
+      :class="locale === 'en' ? 'bg-zinc-800 text-emerald-400' : 'bg-transparent text-zinc-500'"
+      @click="set('en')"
+    >
+      EN
+    </button>
+    <button
+      type="button"
+      :aria-pressed="locale === 'fr'"
+      class="cursor-pointer border-none px-[11px] py-1.5 font-mono text-xs font-semibold focus-visible:outline-2 focus-visible:outline-offset-1 focus-visible:outline-emerald-500/70"
+      :class="locale === 'fr' ? 'bg-zinc-800 text-emerald-400' : 'bg-transparent text-zinc-500'"
+      @click="set('fr')"
+    >
+      FR
+    </button>
+  </div>
+</template>

packages/site/src/components/ProblemSection.vue

@@ -0,0 +1,14 @@
+<script setup lang="ts">
+import { useI18n } from 'vue-i18n';
+const { t } = useI18n();
+</script>
+
+<template>
+  <section v-reveal class="mx-auto max-w-[920px] px-6 pb-[92px] pt-12 text-center">
+    <div class="mb-4 font-mono text-xs uppercase tracking-[0.14em] text-emerald-400">{{ t('probKicker') }}</div>
+    <h2 class="m-0 text-[clamp(28px,3.6vw,42px)] font-semibold leading-[1.18] tracking-[-0.025em] text-zinc-50">
+      {{ t('probTitle') }}
+    </h2>
+    <p class="mx-auto mt-[22px] max-w-[640px] text-[clamp(17px,1.6vw,19px)] text-zinc-400">{{ t('probBody') }}</p>
+  </section>
+</template>

packages/site/src/components/SecuritySection.vue

@@ -0,0 +1,47 @@
+<script setup lang="ts">
+import { useI18n } from 'vue-i18n';
+const { t } = useI18n();
+</script>
+
+<template>
+  <section id="security" class="mx-auto max-w-[1200px] scroll-mt-[84px] px-6 pb-[100px]">
+    <div
+      v-reveal
+      class="rounded-[18px] border border-emerald-500/[0.18] p-[clamp(28px,4vw,48px)]"
+      style="background: linear-gradient(180deg, rgba(16, 185, 129, 0.05), rgba(16, 185, 129, 0))"
+    >
+      <div class="mb-[30px] flex flex-wrap items-end justify-between gap-3.5">
+        <div>
+          <div class="mb-3 font-mono text-xs uppercase tracking-[0.14em] text-emerald-400">{{ t('secKicker') }}</div>
+          <h2 class="m-0 text-[clamp(26px,3.2vw,38px)] font-semibold leading-[1.12] tracking-[-0.025em] text-zinc-50">
+            {{ t('secTitle') }}
+          </h2>
+        </div>
+        <p class="m-0 max-w-[380px] text-[15.5px] leading-[1.55] text-zinc-400">{{ t('secIntro') }}</p>
+      </div>
+
+      <div class="grid grid-cols-[repeat(auto-fit,minmax(200px,1fr))] gap-3.5">
+        <div class="flex flex-col gap-2.5 rounded-[11px] border border-zinc-800 bg-[#0c0c0e] p-[18px]">
+          <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="#34d399" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><rect width="18" height="11" x="3" y="11" rx="2" /><path d="M7 11V7a5 5 0 0 1 10 0v4" /></svg>
+          <div class="text-[15px] font-semibold text-zinc-50">{{ t('sec1Title') }}</div>
+          <div class="text-[13.5px] leading-[1.5] text-zinc-400">{{ t('sec1Desc') }}</div>
+        </div>
+        <div class="flex flex-col gap-2.5 rounded-[11px] border border-zinc-800 bg-[#0c0c0e] p-[18px]">
+          <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="#34d399" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="m15.5 7.5 2.3 2.3a1 1 0 0 0 1.4 0l2.1-2.1a1 1 0 0 0 0-1.4L19 4" /><path d="m21 2-9.6 9.6" /><circle cx="7.5" cy="15.5" r="5.5" /></svg>
+          <div class="text-[15px] font-semibold text-zinc-50">{{ t('sec2Title') }}</div>
+          <div class="text-[13.5px] leading-[1.5] text-zinc-400">{{ t('sec2Desc') }}</div>
+        </div>
+        <div class="flex flex-col gap-2.5 rounded-[11px] border border-zinc-800 bg-[#0c0c0e] p-[18px]">
+          <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="#34d399" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z" /><path d="m9 12 2 2 4-4" /></svg>
+          <div class="text-[15px] font-semibold text-zinc-50">{{ t('sec3Title') }}</div>
+          <div class="text-[13.5px] leading-[1.5] text-zinc-400">{{ t('sec3Desc') }}</div>
+        </div>
+        <div class="flex flex-col gap-2.5 rounded-[11px] border border-zinc-800 bg-[#0c0c0e] p-[18px]">
+          <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="#34d399" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M5 12.55a11 11 0 0 1 14.08 0" /><path d="M1.42 9a16 16 0 0 1 21.16 0" /><path d="M8.53 16.11a6 6 0 0 1 6.95 0" /><path d="M12 20h.01" /></svg>
+          <div class="text-[15px] font-semibold text-zinc-50">{{ t('sec4Title') }}</div>
+          <div class="text-[13.5px] leading-[1.5] text-zinc-400">{{ t('sec4Desc') }}</div>
+        </div>
+      </div>
+    </div>
+  </section>
+</template>

packages/site/src/components/ShowcaseSection.vue

@@ -0,0 +1,257 @@
+<script setup lang="ts">
+import { computed } from 'vue';
+import { useI18n } from 'vue-i18n';
+import { DLG_OPTS } from '../i18n/content';
+import type { AppLocale } from '../i18n';
+
+const { t, locale } = useI18n();
+
+// Options du dialogue (réutilisées pour le rail « À traiter » et la vue mobile).
+const dlgOpts = computed(() => DLG_OPTS[locale.value as AppLocale]);
+</script>
+
+<template>
+  <section id="showcase" class="mx-auto flex max-w-[1200px] scroll-mt-[84px] flex-col gap-[92px] px-6">
+    <!-- a) dashboard worktree-first : rail « À traiter » + section de repo (fidèle à AttentionSection + RepoSection) -->
+    <div v-reveal class="flex flex-wrap items-center gap-12">
+      <div class="min-w-[280px] flex-[1_1_360px]">
+        <div class="mb-3 font-mono text-xs uppercase tracking-[0.12em] text-emerald-400">{{ t('scAKicker') }}</div>
+        <h2 class="m-0 mb-4 text-[clamp(26px,3vw,34px)] font-semibold leading-[1.15] tracking-[-0.025em] text-zinc-50">
+          {{ t('scATitle') }}
+        </h2>
+        <p class="m-0 text-[16.5px] leading-[1.6] text-zinc-400">{{ t('scABody') }}</p>
+      </div>
+      <div class="flex min-w-[280px] flex-[1_1_440px] flex-col gap-3">
+        <!-- rail « À traiter » -->
+        <div class="flex flex-col gap-2 rounded-xl border border-amber-900/50 bg-amber-950/20 p-3 shadow-card">
+          <div class="flex items-center gap-2">
+            <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="#fbbf24" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="m21.73 18-8-14a2 2 0 0 0-3.48 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3Z" /><path d="M12 9v4" /><path d="M12 17h.01" /></svg>
+            <h3 class="text-sm font-semibold text-amber-200">{{ t('mAttn') }}</h3>
+            <span class="rounded-full bg-amber-500/20 px-1.5 text-[11px] font-semibold text-amber-300">1</span>
+          </div>
+          <span class="truncate font-mono text-xs text-amber-300/80">~/code/arboretum/api</span>
+          <!-- DialogPrompt -->
+          <div class="rounded-lg border border-amber-900/60 bg-amber-950/30 p-2.5">
+            <div class="flex items-center gap-2">
+              <span class="inline-flex items-center rounded bg-amber-900 px-1.5 py-0.5 text-[11px] font-medium text-amber-200">{{ t('mPermission') }}</span>
+              <span class="text-[12.5px] text-amber-100">{{ t('dlgQ') }}</span>
+            </div>
+            <div class="mt-2 flex flex-wrap gap-1.5">
+              <span
+                v-for="(op, i) in dlgOpts"
+                :key="i"
+                class="inline-flex items-center gap-1.5 rounded-lg border border-zinc-700 bg-zinc-800 px-2.5 py-1.5 text-xs font-medium text-zinc-200"
+              >
+                <span class="font-mono text-amber-400">{{ i + 1 }}</span> {{ op }}
+              </span>
+              <span class="inline-flex items-center rounded-lg border border-red-900 bg-red-950 px-2.5 py-1.5 text-xs font-medium text-red-300">{{ t('mDeny') }}</span>
+            </div>
+          </div>
+        </div>
+
+        <!-- section de repo : worktrees + état de session -->
+        <div class="flex flex-col gap-2 rounded-xl border border-zinc-800 bg-zinc-900/50 p-3 shadow-card">
+          <header class="flex flex-wrap items-center gap-2">
+            <h3 class="font-semibold text-zinc-100">arboretum</h3>
+            <span class="truncate font-mono text-xs text-zinc-500">~/code/arboretum</span>
+            <span class="ml-auto inline-flex items-center gap-1.5 rounded-lg border border-zinc-700 bg-zinc-800 px-2 py-1 text-xs font-medium text-zinc-200">
+              <svg width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M5 12h14" /><path d="M12 5v14" /></svg>
+              {{ t('mStart') }}
+            </span>
+          </header>
+
+          <!-- worktree : branche principale, session au repos -->
+          <div class="rounded border border-zinc-800 bg-zinc-900/40 p-2">
+            <div class="flex items-center gap-2">
+              <span class="font-mono text-sm text-zinc-200">main</span>
+              <span class="inline-flex items-center rounded bg-zinc-800 px-1.5 py-0.5 text-[11px] font-medium text-zinc-400">{{ t('mMain') }}</span>
+              <span class="ml-auto text-xs text-zinc-600">{{ t('mClean') }}</span>
+            </div>
+            <p class="truncate font-mono text-xs text-zinc-500">~/code/arboretum</p>
+            <div class="mt-1 flex items-center gap-2">
+              <span class="inline-flex items-center gap-1 rounded bg-zinc-800/60 px-1.5 py-0.5">
+                <span class="inline-flex items-center gap-1 rounded bg-emerald-950 px-1.5 py-0.5 text-[11px] font-medium text-emerald-400">
+                  <span class="h-1.5 w-1.5 rounded-full bg-emerald-400"></span>{{ t('idle') }}
+                </span>
+                <span class="font-mono text-[11px] text-zinc-400">claude</span>
+              </span>
+            </div>
+          </div>
+
+          <!-- worktree : branche de feature, session occupée -->
+          <div class="rounded border border-zinc-800 bg-zinc-900/40 p-2">
+            <div class="flex items-center gap-2">
+              <span class="font-mono text-sm text-zinc-200">feat/auth</span>
+              <span class="ml-auto flex items-center gap-2 text-xs text-zinc-500">
+                <span>↑2</span>
+                <span class="text-amber-400">● {{ t('mDirty') }}</span>
+              </span>
+            </div>
+            <p class="truncate font-mono text-xs text-zinc-500">~/code/arboretum/.wt/feat-auth</p>
+            <div class="mt-1 flex items-center gap-2">
+              <span class="inline-flex items-center gap-1 rounded bg-zinc-800/60 px-1.5 py-0.5">
+                <span class="inline-flex items-center gap-1 rounded bg-sky-950 px-1.5 py-0.5 text-[11px] font-medium text-sky-300">
+                  <span class="h-1.5 w-1.5 animate-pulse-sky rounded-full bg-sky-300"></span>{{ t('busy') }}
+                </span>
+                <span class="font-mono text-[11px] text-zinc-400">claude</span>
+              </span>
+            </div>
+            <!-- actions git de la carte : commit / push (fidèle au WorktreeCard) -->
+            <div class="mt-1 flex items-center gap-1.5">
+              <span class="inline-flex items-center rounded border border-zinc-700 bg-zinc-800 px-1.5 py-0.5 text-[11px] font-medium text-zinc-300">{{ t('mCommit') }}</span>
+              <span class="inline-flex items-center rounded border border-zinc-700 bg-zinc-800 px-1.5 py-0.5 text-[11px] font-medium text-zinc-300">{{ t('mPush') }} ↑2</span>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <!-- b) grille multi-terminaux (fidèle à TerminalCell : badge d'état + titre repo · branche + commande) -->
+    <div v-reveal class="flex flex-wrap-reverse items-center gap-12">
+      <div class="min-w-[280px] flex-[1_1_440px]">
+        <div class="grid grid-cols-2 gap-2.5 overflow-hidden rounded-xl border border-zinc-800 bg-[#0c0c0e] p-3 shadow-card">
+          <div class="overflow-hidden rounded-lg border border-zinc-800 bg-[#09090b]">
+            <div class="flex items-center gap-2 border-b border-zinc-800 px-2 py-1.5">
+              <span class="inline-flex items-center gap-1 rounded bg-sky-950 px-1.5 py-0.5 text-[10px] font-medium text-sky-300"><span class="h-1.5 w-1.5 animate-pulse-sky rounded-full bg-sky-300"></span>{{ t('busy') }}</span>
+              <span class="truncate font-mono text-[11px] text-zinc-300">api · feat/auth</span>
+              <span class="ml-auto shrink-0 font-mono text-[11px] text-zinc-500">claude</span>
+            </div>
+            <div class="p-[11px] font-mono text-[11px] leading-[1.75] text-zinc-300">
+              <div class="text-emerald-400">● Edit session.ts</div>
+              <div class="text-emerald-400">+ const token = sign(...)</div>
+              <div class="text-red-400">- legacy cookie auth</div>
+              <div class="text-zinc-500">refactoring guards…</div>
+            </div>
+          </div>
+          <div class="overflow-hidden rounded-lg border border-zinc-800 bg-[#09090b]">
+            <div class="flex items-center gap-2 border-b border-zinc-800 px-2 py-1.5">
+              <span class="inline-flex items-center gap-1 rounded bg-emerald-950 px-1.5 py-0.5 text-[10px] font-medium text-emerald-400"><span class="h-1.5 w-1.5 rounded-full bg-emerald-400"></span>{{ t('idle') }}</span>
+              <span class="truncate font-mono text-[11px] text-zinc-300">web · fix/cart</span>
+              <span class="ml-auto shrink-0 font-mono text-[11px] text-zinc-500">claude</span>
+            </div>
+            <div class="p-[11px] font-mono text-[11px] leading-[1.75] text-zinc-300">
+              <div class="text-emerald-400">✓ all tests passing</div>
+              <div class="text-zinc-500">24 passed, 0 failed</div>
+              <div>
+                <span class="text-emerald-400">$</span>
+                <span class="ml-1 inline-block h-[11px] w-1.5 animate-blink align-middle bg-zinc-200"></span>
+              </div>
+            </div>
+          </div>
+          <div class="overflow-hidden rounded-lg border border-zinc-800 bg-[#09090b]">
+            <div class="flex items-center gap-2 border-b border-zinc-800 px-2 py-1.5">
+              <span class="inline-flex items-center gap-1 rounded bg-sky-950 px-1.5 py-0.5 text-[10px] font-medium text-sky-300"><span class="h-1.5 w-1.5 animate-pulse-sky rounded-full bg-sky-300"></span>{{ t('busy') }}</span>
+              <span class="truncate font-mono text-[11px] text-zinc-300">db · refactor</span>
+              <span class="ml-auto shrink-0 font-mono text-[11px] text-zinc-500">claude</span>
+            </div>
+            <div class="p-[11px] font-mono text-[11px] leading-[1.75] text-zinc-300">
+              <div class="text-emerald-400">● Write migration</div>
+              <div class="text-zinc-500">0003_add_index.sql</div>
+              <div class="text-zinc-500">applying to schema…</div>
+            </div>
+          </div>
+          <div class="overflow-hidden rounded-lg border border-zinc-800 bg-[#09090b]">
+            <div class="flex items-center gap-2 border-b border-zinc-800 px-2 py-1.5">
+              <span class="inline-flex items-center gap-1 rounded bg-amber-950 px-1.5 py-0.5 text-[10px] font-medium text-amber-300"><span class="h-1.5 w-1.5 animate-pulse-amber rounded-full bg-amber-300"></span>{{ t('waiting') }}</span>
+              <span class="truncate font-mono text-[11px] text-zinc-300">docs · api</span>
+              <span class="ml-auto shrink-0 font-mono text-[11px] text-zinc-500">claude</span>
+            </div>
+            <div class="p-[11px] font-mono text-[11px] leading-[1.75] text-zinc-300">
+              <div class="text-emerald-400">● Read README.md</div>
+              <div class="text-amber-300">Permission required</div>
+              <div class="text-zinc-500">waiting for input…</div>
+            </div>
+          </div>
+        </div>
+      </div>
+      <div class="min-w-[280px] flex-[1_1_360px]">
+        <div class="mb-3 font-mono text-xs uppercase tracking-[0.12em] text-emerald-400">{{ t('scBKicker') }}</div>
+        <h2 class="m-0 mb-4 text-[clamp(26px,3vw,34px)] font-semibold leading-[1.15] tracking-[-0.025em] text-zinc-50">
+          {{ t('scBTitle') }}
+        </h2>
+        <p class="m-0 text-[16.5px] leading-[1.6] text-zinc-400">{{ t('scBBody') }}</p>
+      </div>
+    </div>
+
+    <!-- c) mobile : push + réponse au dialogue (fidèle à DialogPrompt) + barre d'onglets -->
+    <div v-reveal class="flex flex-wrap items-center gap-12">
+      <div class="min-w-[280px] flex-[1_1_380px]">
+        <div class="mb-3 font-mono text-xs uppercase tracking-[0.12em] text-emerald-400">{{ t('scCKicker') }}</div>
+        <h2 class="m-0 mb-4 text-[clamp(26px,3vw,34px)] font-semibold leading-[1.15] tracking-[-0.025em] text-zinc-50">
+          {{ t('scCTitle') }}
+        </h2>
+        <p class="m-0 text-[16.5px] leading-[1.6] text-zinc-400">{{ t('scCBody') }}</p>
+      </div>
+      <div class="flex min-w-[280px] flex-[1_1_320px] justify-center">
+        <div class="relative w-[300px] overflow-hidden rounded-[40px] border-[9px] border-zinc-900 bg-zinc-950 shadow-phone">
+          <div class="flex h-[30px] items-center justify-center">
+            <div class="h-1.5 w-[90px] rounded-full bg-zinc-800"></div>
+          </div>
+          <div class="px-3 pb-[64px]">
+            <!-- toast push -->
+            <div class="flex items-start gap-[11px] rounded-[15px] border border-[rgba(120,53,15,0.5)] bg-[#0c0c0e] p-[13px] shadow-toast-sm">
+              <span class="inline-flex h-[30px] w-[30px] flex-none items-center justify-center rounded-lg bg-emerald-500/[0.14]">
+                <img src="/assets/arboretum-mark.png" alt="" width="18" height="18" class="h-[18px] w-[18px] object-contain" />
+              </span>
+              <div class="min-w-0 flex-1">
+                <div class="flex items-center justify-between">
+                  <span class="font-mono text-[11px] text-emerald-400">Arboretum</span>
+                  <span class="text-[10px] text-zinc-600">now</span>
+                </div>
+                <div class="mt-[3px] text-[13.5px] font-semibold text-zinc-50">{{ t('toastTitle') }}</div>
+                <div class="text-xs leading-[1.45] text-zinc-400">{{ t('toastBody') }}</div>
+              </div>
+            </div>
+
+            <!-- carte « À traiter » + DialogPrompt -->
+            <div class="mt-[14px] flex flex-col gap-2 rounded-[15px] border border-amber-900/50 bg-amber-950/20 p-2.5">
+              <div class="flex items-center gap-2">
+                <svg width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="#fbbf24" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="m21.73 18-8-14a2 2 0 0 0-3.48 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3Z" /><path d="M12 9v4" /><path d="M12 17h.01" /></svg>
+                <span class="text-[13px] font-semibold text-amber-200">{{ t('mAttn') }}</span>
+                <span class="rounded-full bg-amber-500/20 px-1.5 text-[11px] font-semibold text-amber-300">1</span>
+              </div>
+              <span class="font-mono text-[11px] text-amber-300/80">api · feat/auth</span>
+              <div class="rounded-lg border border-amber-900/60 bg-amber-950/30 p-2.5">
+                <span class="inline-flex items-center rounded bg-amber-900 px-1.5 py-0.5 text-[11px] font-medium text-amber-200">{{ t('mPermission') }}</span>
+                <div class="mt-1.5 text-[13px] leading-[1.4] text-amber-100">{{ t('dlgQ') }}</div>
+                <div class="mt-2 flex flex-col gap-1.5">
+                  <span
+                    v-for="(op, i) in dlgOpts"
+                    :key="i"
+                    class="flex items-center gap-2 rounded-lg border border-zinc-700 bg-zinc-800 px-2.5 py-2 text-[13px] font-medium text-zinc-200"
+                  >
+                    <span class="font-mono text-amber-400">{{ i + 1 }}</span> {{ op }}
+                  </span>
+                  <span class="rounded-lg border border-red-900 bg-red-950 px-2.5 py-2 text-center text-[13px] font-medium text-red-300">{{ t('mDeny') }}</span>
+                </div>
+              </div>
+            </div>
+          </div>
+
+          <!-- barre d'onglets mobile (fidèle à MobileTabBar) -->
+          <div class="absolute inset-x-0 bottom-0 flex border-t border-zinc-800 bg-zinc-950/95 backdrop-blur">
+            <div class="flex flex-1 flex-col items-center gap-0.5 py-2 text-zinc-500">
+              <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><line x1="6" x2="6" y1="3" y2="15" /><circle cx="18" cy="6" r="3" /><circle cx="6" cy="18" r="3" /><path d="M18 9a9 9 0 0 1-9 9" /></svg>
+              <span class="text-[10px]">{{ t('mWorktrees') }}</span>
+            </div>
+            <div class="relative flex flex-1 flex-col items-center gap-0.5 py-2 text-emerald-400">
+              <span class="relative">
+                <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="m7 11 2-2-2-2" /><path d="M11 13h4" /><rect width="18" height="18" x="3" y="3" rx="2" ry="2" /></svg>
+                <span class="absolute -right-1.5 -top-1.5 flex h-3.5 min-w-3.5 items-center justify-center rounded-full bg-amber-500 px-1 text-[9px] font-semibold text-amber-950">1</span>
+              </span>
+              <span class="text-[10px]">{{ t('mSessions') }}</span>
+            </div>
+            <div class="flex flex-1 flex-col items-center gap-0.5 py-2 text-zinc-500">
+              <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M2.97 12.92A2 2 0 0 0 2 14.63v3.24a2 2 0 0 0 .97 1.71l3 1.8a2 2 0 0 0 2.06 0L12 19v-5.5l-5-3-4.03 2.42Z" /><path d="M7 16.5 12 13.5" /><path d="M12 13.5V19l3.97 2.38a2 2 0 0 0 2.06 0l3-1.8a2 2 0 0 0 .97-1.71v-3.24a2 2 0 0 0-.97-1.71L17 10.5l-5 3Z" /><path d="m17 16.5 4.74-2.85" /><path d="M7.97 4.42A2 2 0 0 0 7 6.13v4.37l5 3 5-3V6.13a2 2 0 0 0-.97-1.71l-3-1.8a2 2 0 0 0-2.06 0z" /></svg>
+              <span class="text-[10px]">{{ t('mGroups') }}</span>
+            </div>
+            <div class="flex flex-1 flex-col items-center gap-0.5 py-2 text-zinc-500">
+              <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><line x1="4" x2="20" y1="12" y2="12" /><line x1="4" x2="20" y1="6" y2="6" /><line x1="4" x2="20" y1="18" y2="18" /></svg>
+              <span class="text-[10px]">{{ t('mMore') }}</span>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </section>
+</template>

packages/site/src/components/WorkGroupsSection.vue

@@ -0,0 +1,55 @@
+<script setup lang="ts">
+import { useI18n } from 'vue-i18n';
+const { t } = useI18n();
+</script>
+
+<template>
+  <section class="mx-auto max-w-[1200px] scroll-mt-[84px] px-6 py-[92px]">
+    <div
+      v-reveal
+      class="flex flex-wrap items-center gap-12 rounded-[18px] border border-zinc-800 p-[clamp(28px,4vw,52px)]"
+      style="background: linear-gradient(180deg, rgba(24, 24, 27, 0.55), rgba(12, 12, 14, 0.55))"
+    >
+      <div class="min-w-[280px] flex-[1_1_360px]">
+        <div class="mb-3 font-mono text-xs uppercase tracking-[0.12em] text-emerald-400">{{ t('grpKicker') }}</div>
+        <h2 class="m-0 mb-4 text-[clamp(26px,3vw,36px)] font-semibold leading-[1.15] tracking-[-0.025em] text-zinc-50">
+          {{ t('grpTitle') }}
+        </h2>
+        <p class="m-0 text-[16.5px] leading-[1.6] text-zinc-400">{{ t('grpBody') }}</p>
+      </div>
+      <div class="flex min-w-[280px] flex-[1_1_360px] justify-center">
+        <div class="flex w-full max-w-[380px] items-center">
+          <div class="flex flex-none flex-col items-center gap-2">
+            <div
+              class="inline-flex h-[62px] w-[62px] items-center justify-center rounded-[15px] border border-emerald-500/35 bg-emerald-500/[0.12] text-emerald-400"
+            >
+              <svg width="26" height="26" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M2.97 12.92A2 2 0 0 0 2 14.63v3.24a2 2 0 0 0 .97 1.71l3 1.8a2 2 0 0 0 2.06 0L12 19v-5.5l-5-3-4.03 2.42Z" /><path d="M7 16.5 12 13.5" /><path d="M12 13.5V19l3.97 2.38a2 2 0 0 0 2.06 0l3-1.8a2 2 0 0 0 .97-1.71v-3.24a2 2 0 0 0-.97-1.71L17 10.5l-5 3Z" /><path d="m17 16.5 4.74-2.85" /><path d="M7.97 4.42A2 2 0 0 0 7 6.13v4.37l5 3 5-3V6.13a2 2 0 0 0-.97-1.71l-3-1.8a2 2 0 0 0-2.06 0z" /></svg>
+            </div>
+            <span class="font-mono text-[11px] text-zinc-300">{{ t('grpHub') }}</span>
+          </div>
+          <div class="relative h-[96px] flex-1">
+            <svg width="100%" height="100%" viewBox="0 0 100 96" preserveAspectRatio="none" class="absolute inset-0" aria-hidden="true">
+              <path d="M0 48 H40 V14 H100" fill="none" stroke="rgba(16,185,129,.45)" stroke-width="1.4" />
+              <path d="M0 48 H40 V48 H100" fill="none" stroke="rgba(16,185,129,.45)" stroke-width="1.4" />
+              <path d="M0 48 H40 V82 H100" fill="none" stroke="rgba(16,185,129,.45)" stroke-width="1.4" />
+            </svg>
+          </div>
+          <div class="flex flex-none flex-col gap-2.5">
+            <div class="flex items-center gap-2 rounded-lg border border-zinc-800 bg-[#0c0c0e] px-3 py-2">
+              <span class="h-1.5 w-1.5 rounded-full bg-sky-300"></span>
+              <span class="font-mono text-[11px] text-zinc-300">api</span>
+            </div>
+            <div class="flex items-center gap-2 rounded-lg border border-zinc-800 bg-[#0c0c0e] px-3 py-2">
+              <span class="h-1.5 w-1.5 rounded-full bg-sky-300"></span>
+              <span class="font-mono text-[11px] text-zinc-300">web</span>
+            </div>
+            <div class="flex items-center gap-2 rounded-lg border border-zinc-800 bg-[#0c0c0e] px-3 py-2">
+              <span class="h-1.5 w-1.5 rounded-full bg-sky-300"></span>
+              <span class="font-mono text-[11px] text-zinc-300">sdk</span>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </section>
+</template>

packages/site/src/components/icons/IconCheck.vue

@@ -0,0 +1,19 @@
+<script setup lang="ts">
+withDefaults(defineProps<{ size?: number }>(), { size: 15 });
+</script>
+
+<template>
+  <svg
+    :width="size"
+    :height="size"
+    viewBox="0 0 24 24"
+    fill="none"
+    stroke="currentColor"
+    stroke-width="2.2"
+    stroke-linecap="round"
+    stroke-linejoin="round"
+    aria-hidden="true"
+  >
+    <path d="M20 6 9 17l-5-5" />
+  </svg>
+</template>

packages/site/src/components/icons/IconCopy.vue

@@ -0,0 +1,20 @@
+<script setup lang="ts">
+withDefaults(defineProps<{ size?: number }>(), { size: 15 });
+</script>
+
+<template>
+  <svg
+    :width="size"
+    :height="size"
+    viewBox="0 0 24 24"
+    fill="none"
+    stroke="currentColor"
+    stroke-width="1.9"
+    stroke-linecap="round"
+    stroke-linejoin="round"
+    aria-hidden="true"
+  >
+    <rect width="13" height="13" x="9" y="9" rx="2" />
+    <path d="M5 15c-1.1 0-2-.9-2-2V5c0-1.1.9-2 2-2h8c1.1 0 2 .9 2 2" />
+  </svg>
+</template>

packages/site/src/components/icons/IconGitea.vue

@@ -0,0 +1,22 @@
+<script setup lang="ts">
+withDefaults(defineProps<{ size?: number }>(), { size: 16 });
+</script>
+
+<template>
+  <svg
+    :width="size"
+    :height="size"
+    viewBox="0 0 24 24"
+    fill="none"
+    stroke="currentColor"
+    stroke-width="1.7"
+    stroke-linecap="round"
+    stroke-linejoin="round"
+    aria-hidden="true"
+  >
+    <path d="M4 10h12v4a4 4 0 0 1-4 4H8a4 4 0 0 1-4-4z" />
+    <path d="M16 11h2.5a2.5 2.5 0 0 1 0 5H16" />
+    <path d="M7 3c-.5.8.5 1.6 0 2.5" />
+    <path d="M11 3c-.5.8.5 1.6 0 2.5" />
+  </svg>
+</template>

packages/site/src/composables/useCopy.ts

@@ -0,0 +1,24 @@
+import { ref } from 'vue';
+
+export const INSTALL_COMMAND = 'npx @johanleroy/git-arboretum';
+
+// Bouton « copier la commande » : copie + bascule le label 1800 ms (fidèle au design).
+export function useCopy() {
+  const copied = ref(false);
+  let timer: ReturnType<typeof setTimeout> | undefined;
+
+  async function copy(text: string = INSTALL_COMMAND): Promise<void> {
+    try {
+      if (navigator.clipboard) await navigator.clipboard.writeText(text);
+    } catch {
+      /* clipboard indisponible (contexte non sécurisé) */
+    }
+    copied.value = true;
+    clearTimeout(timer);
+    timer = setTimeout(() => {
+      copied.value = false;
+    }, 1800);
+  }
+
+  return { copied, copy };
+}

packages/site/src/composables/useHeroTimeline.ts

@@ -0,0 +1,113 @@
+import { onMounted, onUnmounted, ref } from 'vue';
+
+// Portage 1:1 de la timeline animée du mockup hero (Arboretum.dc.html).
+export type SessionState = 'idle' | 'busy' | 'waiting';
+
+export interface AnimLine {
+  text: string;
+  k: string;
+}
+
+export interface HeroAnim {
+  sess: SessionState;
+  lines: AnimLine[];
+  att: number;
+  toast: boolean;
+  dlg: boolean;
+  hl: number;
+  ans: number;
+  cur: boolean;
+}
+
+const TOTAL = 13000;
+const TICK = 80;
+
+interface ScriptEntry {
+  at: number;
+  text: string;
+  k: string;
+}
+
+function script(): ScriptEntry[] {
+  return [
+    { at: 850, text: '$ claude --resume feat/auth', k: 'cmd' },
+    { at: 1400, text: '> Reading src/auth/login.ts', k: 'tool' },
+    { at: 1950, text: '● Edit  login.ts', k: 'edit' },
+    { at: 2400, text: "  + import { verifyToken } from './jwt'", k: 'add' },
+    { at: 2850, text: '  + const user = await verifyToken(req)', k: 'add' },
+    { at: 3350, text: '● Bash  npm test -- auth', k: 'edit' },
+    { at: 3850, text: '  ✓ 14 passed (1.24s)', k: 'ok' },
+    { at: 4300, text: '● Permission required to edit login.ts', k: 'warn' },
+    { at: 7950, text: '✓ approved · applying change', k: 'ok' },
+    { at: 8500, text: '● Edit  login.ts', k: 'edit' },
+    { at: 9050, text: '● Running…', k: 'run' },
+  ];
+}
+
+export function deriveAnim(clock: number): HeroAnim {
+  const sess: SessionState = clock < 700 ? 'idle' : clock < 4500 ? 'busy' : clock < 7700 ? 'waiting' : 'busy';
+  const sc = script();
+  const lines: AnimLine[] = [];
+  for (const entry of sc) {
+    if (clock >= entry.at) lines.push({ text: entry.text, k: entry.k });
+  }
+  const att = clock >= 4500 && clock < 7700 ? 1 : 0;
+  const toast = clock >= 4650 && clock < 7700;
+  const dlg = clock >= 4600 && clock < 7700;
+  const hl = clock >= 6000 && clock < 7050 ? 0 : -1;
+  const ans = clock >= 7050 && clock < 7700 ? 0 : -1;
+  const cur = sess !== 'waiting';
+  return { sess, lines, att, toast, dlg, hl, ans, cur };
+}
+
+export function useHeroTimeline(stageId = 'hero-stage') {
+  const anim = ref<HeroAnim>(deriveAnim(0));
+  let clock = 0;
+  let visible = true;
+  let everVisible = false;
+  let timer: ReturnType<typeof setInterval> | undefined;
+  let io: IntersectionObserver | undefined;
+
+  onMounted(() => {
+    let reduced = false;
+    try {
+      reduced = window.matchMedia('(prefers-reduced-motion: reduce)').matches;
+    } catch {
+      /* ignore */
+    }
+    if (reduced) {
+      anim.value = deriveAnim(5200);
+      return;
+    }
+    const stage = document.getElementById(stageId);
+    if (stage && 'IntersectionObserver' in window) {
+      io = new IntersectionObserver(
+        (entries) => {
+          const e = entries[0];
+          if (!e) return;
+          if (e.isIntersecting) {
+            visible = true;
+            everVisible = true;
+          } else if (everVisible) {
+            visible = false;
+          }
+        },
+        { threshold: 0, rootMargin: '200px 0px 200px 0px' },
+      );
+      io.observe(stage);
+    }
+    timer = setInterval(() => {
+      if (!visible) return;
+      clock += TICK;
+      if (clock >= TOTAL) clock = 0;
+      anim.value = deriveAnim(clock);
+    }, TICK);
+  });
+
+  onUnmounted(() => {
+    if (timer) clearInterval(timer);
+    if (io) io.disconnect();
+  });
+
+  return { anim };
+}

packages/site/src/composables/useScrollReveal.ts

@@ -0,0 +1,52 @@
+import type { Directive } from 'vue';
+
+// Directive `v-reveal` : révèle un bloc quand il entre dans le viewport.
+// Reprend l'intention du setupReveal() du design (seuil ~92% de la hauteur),
+// via un IntersectionObserver partagé. Respecte prefers-reduced-motion.
+let reducedMotion = false;
+try {
+  reducedMotion = window.matchMedia('(prefers-reduced-motion: reduce)').matches;
+} catch {
+  /* matchMedia indisponible */
+}
+
+let observer: IntersectionObserver | null = null;
+
+function getObserver(): IntersectionObserver | null {
+  if (typeof IntersectionObserver === 'undefined') return null;
+  if (!observer) {
+    observer = new IntersectionObserver(
+      (entries) => {
+        for (const entry of entries) {
+          if (entry.isIntersecting) {
+            entry.target.classList.add('is-visible');
+            observer?.unobserve(entry.target);
+          }
+        }
+      },
+      // -8% en bas ≈ déclenche quand le haut du bloc franchit ~92% du viewport.
+      { threshold: 0, rootMargin: '0px 0px -8% 0px' },
+    );
+  }
+  return observer;
+}
+
+export const reveal: Directive<HTMLElement> = {
+  mounted(el) {
+    el.classList.add('reveal');
+    if (reducedMotion) {
+      el.classList.add('is-visible');
+      return;
+    }
+    const io = getObserver();
+    if (!io) {
+      // Pas d'IntersectionObserver : on révèle immédiatement (pas de contenu caché).
+      el.classList.add('is-visible');
+      return;
+    }
+    io.observe(el);
+  },
+  unmounted(el) {
+    observer?.unobserve(el);
+  },
+};

packages/site/src/env.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="vite/client" />
+
+declare module '*.vue' {
+  import type { DefineComponent } from 'vue';
+  const component: DefineComponent<Record<string, unknown>, Record<string, unknown>, unknown>;
+  export default component;
+}

packages/site/src/i18n/content.ts

@@ -0,0 +1,60 @@
+// Listes structurées (FAQ, options de dialogue) — gardées hors des messages
+// vue-i18n et indexées par locale, pour rester du texte pur typé (pas d'innerHTML).
+import type { AppLocale } from './index';
+
+export interface FaqItem {
+  q: string;
+  a: string;
+}
+
+export const FAQS: Record<AppLocale, FaqItem[]> = {
+  en: [
+    {
+      q: 'How is this different from running Claude Code in a terminal?',
+      a: 'It runs the very same interactive claude CLI — Arboretum just wraps it in a managed terminal you reach from a browser. What you gain on top: a worktree-first dashboard across all your repos, live busy / waiting / idle states, a multi-terminal grid, push notifications, and the ability to answer a prompt from your phone. It supervises your sessions; it does not change how Claude Code works.',
+    },
+    {
+      q: 'Does it need the cloud?',
+      a: 'No. Arboretum is local-first. The daemon runs on your own machine and binds to 127.0.0.1 by default. Your code and sessions never leave your network unless you choose to expose the dashboard.',
+    },
+    {
+      q: 'How do I access it remotely?',
+      a: 'Through Tailscale Serve. Expose the dashboard to your tailnet and reach it securely from any device — no port forwarding, no public endpoint.',
+    },
+    {
+      q: 'Does it work on mobile?',
+      a: 'Yes. The dashboard is an installable PWA. Add it to your home screen, get Web Push the moment a session needs you, and answer a prompt with a single tap.',
+    },
+    {
+      q: 'Is my code safe?',
+      a: 'Arboretum binds to localhost, hashes access tokens at rest, and enforces strict origin checks on every request. Remote access runs through Tailscale rather than an open port.',
+    },
+  ],
+  fr: [
+    {
+      q: 'En quoi est-ce différent de lancer Claude Code dans un terminal ?',
+      a: "C'est exactement le même CLI claude interactif — Arboretum l'enveloppe simplement dans un terminal managé accessible depuis un navigateur. Ce que vous gagnez en plus : un dashboard worktree-first sur tous vos repos, les états occupée / en attente / inactive en direct, une grille multi-terminaux, des notifications push, et la possibilité de répondre à une question depuis votre téléphone. Il supervise vos sessions ; il ne change rien au fonctionnement de Claude Code.",
+    },
+    {
+      q: 'A-t-il besoin du cloud ?',
+      a: 'Non. Arboretum est local-first. Le daemon tourne sur votre propre machine et se lie à 127.0.0.1 par défaut. Votre code et vos sessions ne quittent jamais votre réseau sauf si vous exposez le dashboard.',
+    },
+    {
+      q: 'Comment y accéder à distance ?',
+      a: "Via Tailscale Serve. Exposez le dashboard à votre tailnet et accédez-y en sécurité depuis n'importe quel appareil — sans redirection de port ni endpoint public.",
+    },
+    {
+      q: 'Fonctionne-t-il sur mobile ?',
+      a: "Oui. Le dashboard est une PWA installable. Ajoutez-le à l'écran d'accueil, recevez un Web Push dès qu'une session a besoin de vous, et répondez à une question d'un seul toucher.",
+    },
+    {
+      q: 'Mon code est-il en sécurité ?',
+      a: "Arboretum se lie à localhost, hashe les tokens au repos, et applique une vérification d'origine stricte sur chaque requête. L'accès distant passe par Tailscale plutôt qu'un port ouvert.",
+    },
+  ],
+};
+
+export const DLG_OPTS: Record<AppLocale, string[]> = {
+  en: ['Yes, apply the change', "Yes, and don't ask again", 'No, keep current version'],
+  fr: ['Oui, appliquer le changement', 'Oui, et ne plus demander', 'Non, garder la version actuelle'],
+};

packages/site/src/i18n/en.ts

@@ -0,0 +1,107 @@
+// Messages EN — copie fidèle du dict() du design Arboretum.dc.html.
+export default {
+  navFeatures: 'Features',
+  navHow: 'How it works',
+  navSecurity: 'Security',
+  navFaq: 'FAQ',
+  gitea: 'View on Gitea',
+  heroBadge: 'Mission control for AI coding agents',
+  heroTitle: 'Mission control for your AI coding agents',
+  heroSub:
+    'Run many Claude Code sessions across every git worktree — and supervise them from any device, even your phone.',
+  getStarted: 'Get started',
+  probKicker: 'The problem',
+  probTitle: "Many agents across worktrees is chaos — and you're chained to one terminal.",
+  probBody:
+    'Sessions scattered across tabs. No idea which agent is waiting on you. Step away from the desk and everything stalls. Arboretum is the single pane of glass.',
+  featKicker: 'Everything in one view',
+  featTitle: 'Built to supervise agents working in parallel',
+  feat1Title: 'Worktree-first',
+  feat1Desc: 'Work on your main branch or spin up an isolated worktree — then commit, push or promote a branch to main, without opening a terminal. Branches, not chaos.',
+  feat2Title: 'Many sessions, one view',
+  feat2Desc: 'Run parallel Claude Code agents side by side in a single live grid.',
+  feat3Title: 'Fine-grained states',
+  feat3Desc: 'tell at a glance what each agent is doing.',
+  feat4Title: 'Supervise anywhere',
+  feat4Desc: 'Installable PWA. Check in from your laptop, tablet, or phone.',
+  feat5Title: 'Web Push alerts',
+  feat5Desc: 'Get pinged the moment a session needs a decision from you.',
+  feat6Title: 'Answer without a terminal',
+  feat6Desc: 'Respond to agent prompts and dialogs right from the dashboard.',
+  feat7Title: 'Work groups',
+  feat7Desc: 'Group repos and run one Claude session across all of them at once.',
+  feat8Title: 'Local-first & secure',
+  feat8Desc: 'Binds to localhost, hashes tokens, remote access via Tailscale.',
+  feat9Title: 'Native VS Code extension',
+  feat9Desc: 'Drive worktrees and attach sessions in native terminals, right inside your editor.',
+  scAKicker: 'Worktree-first dashboard',
+  scATitle: 'See what needs you — before anything stalls',
+  scABody:
+    'A live list of every worktree and its session state. The Needs attention rail floats the agents waiting on a decision to the top, so nothing sits blocked while you are heads-down elsewhere. Commit, push or promote a branch to main straight from the card, and hide the noisy history left by past terminal sessions so the list stays actionable.',
+  scBKicker: 'Multi-terminal grid',
+  scBTitle: "Every agent's output, streaming live",
+  scBBody:
+    'Watch all your sessions at once — real terminal output, color-coded by state, updating in real time. Click any pane to take over in a fullscreen terminal — prompt pinned to the bottom, full scrollback above — answer a prompt, or stop a run.',
+  scCKicker: 'On your phone',
+  scCTitle: 'Unblock an agent from the kitchen',
+  scCBody:
+    'Install the PWA and get a Web Push the second a session needs you. Tap the notification, read the prompt, answer the dialog — your agent keeps moving while you are away.',
+  grpHub: '1 session',
+  grpKicker: 'Work groups · cross-repo',
+  grpTitle: 'Drive every repo from one Claude session',
+  grpBody:
+    'Group the repos that move together — a service, its client, its docs. Launch a single Claude session that spans all of them at once: one conversation, one shared context working across every repo — instead of juggling one agent per repo.',
+  howKicker: 'How it works',
+  howTitle: 'Zero install. Three steps.',
+  step1Title: 'Launch the daemon',
+  step1Desc: 'One command. No install, no config, no account.',
+  step2Title: 'Open the dashboard',
+  step2Desc: 'It serves a web dashboard on localhost. Install it as a PWA on any device.',
+  step3Title: 'Spawn & supervise',
+  step3Desc: 'Start Claude Code sessions on your main branch or any worktree, and watch them from anywhere.',
+  secKicker: 'Security',
+  secTitle: 'A web terminal you can actually trust',
+  secIntro: 'Built local-first. Nothing is exposed unless you choose to — and even then, on your terms.',
+  sec1Title: 'Localhost by default',
+  sec1Desc: 'Binds to 127.0.0.1. Nothing leaves your machine unless you say so.',
+  sec2Title: 'Hashed tokens',
+  sec2Desc: 'Access tokens are hashed (sha256) at rest. No plaintext secrets on disk.',
+  sec3Title: 'Strict origin checks',
+  sec3Desc: 'Every request is origin-validated. No cross-site surprises.',
+  sec4Title: 'Remote via Tailscale',
+  sec4Desc: 'Reach it over Tailscale Serve — no public port, no port forwarding.',
+  faqTitle: 'Questions, answered',
+  ctaTitle: 'Take command of your agents',
+  ctaBody: 'One command to launch. Supervise everything from one place.',
+  ctaSource: 'View the source on Gitea',
+  footTag: 'a garden of branches, one pane of glass.',
+  license: 'MIT License',
+  coffee: 'Buy me a coffee',
+  mWorktrees: 'Worktrees',
+  mSessions: 'Sessions',
+  mGroups: 'Groups',
+  mSettings: 'Settings',
+  mHelp: 'Help',
+  mGitea: 'Gitea',
+  mMore: 'More',
+  mSearch: 'Search',
+  mAttn: 'Needs attention',
+  waiting: 'waiting',
+  busy: 'busy',
+  idle: 'idle',
+  mPermission: 'Permission',
+  mDeny: 'Deny (Esc)',
+  mMain: 'main',
+  mClean: 'clean',
+  mDirty: '3 changed',
+  mStart: 'Start work',
+  mCommit: 'Commit',
+  mPush: 'Push',
+  toastTitle: 'Session waiting for you',
+  toastBody: 'api · feat/auth needs a decision',
+  dlgQ: 'Apply this change to login.ts?',
+  copy: 'Copy',
+  copied: 'Copied',
+  copyCommand: 'Copy command',
+  copyUrl: 'Copy URL',
+};

packages/site/src/i18n/fr.ts

@@ -0,0 +1,107 @@
+// Messages FR — copie fidèle du dict() du design Arboretum.dc.html.
+export default {
+  navFeatures: 'Fonctionnalités',
+  navHow: 'Comment ça marche',
+  navSecurity: 'Sécurité',
+  navFaq: 'FAQ',
+  gitea: 'Voir sur Gitea',
+  heroBadge: 'Poste de commandement pour agents de code IA',
+  heroTitle: 'Le poste de commandement de vos agents de code IA',
+  heroSub:
+    "Lancez plusieurs sessions Claude Code à travers chaque worktree git — et supervisez-les depuis n'importe quel appareil, même votre téléphone.",
+  getStarted: 'Commencer',
+  probKicker: 'Le problème',
+  probTitle: "Plein d'agents à travers les worktrees, c'est le chaos — et vous êtes cloué à un seul terminal.",
+  probBody:
+    "Des sessions éparpillées dans des onglets. Aucune idée de quel agent vous attend. Vous quittez le bureau et tout se fige. Arboretum, c'est la vitre unique.",
+  featKicker: 'Tout dans une seule vue',
+  featTitle: 'Conçu pour superviser des agents qui travaillent en parallèle',
+  feat1Title: "Worktree d'abord",
+  feat1Desc: 'Travaillez sur votre branche principale ou créez un worktree isolé — puis commitez, poussez ou passez une branche en principal, sans ouvrir de terminal. Des branches, pas du chaos.',
+  feat2Title: 'Plusieurs sessions, une vue',
+  feat2Desc: 'Lancez des agents Claude Code en parallèle, côte à côte dans une seule grille en direct.',
+  feat3Title: 'États fins',
+  feat3Desc: "sachez d'un coup d'œil ce que fait chaque agent.",
+  feat4Title: 'Supervisez partout',
+  feat4Desc: "PWA installable. Surveillez depuis l'ordinateur, la tablette ou le téléphone.",
+  feat5Title: 'Alertes Web Push',
+  feat5Desc: "Soyez prévenu dès qu'une session attend une décision.",
+  feat6Title: 'Répondre sans terminal',
+  feat6Desc: 'Répondez aux questions et dialogues des agents directement depuis le dashboard.',
+  feat7Title: 'Work groups',
+  feat7Desc: 'Regroupez des repos et pilotez-les via une seule session Claude, tous à la fois.',
+  feat8Title: 'Local-first & sécurisé',
+  feat8Desc: 'Se lie à localhost, hashe les tokens, accès distant via Tailscale.',
+  feat9Title: 'Extension VS Code native',
+  feat9Desc: 'Pilotez vos worktrees et attachez vos sessions dans des terminaux natifs, directement dans votre éditeur.',
+  scAKicker: 'Dashboard worktree-first',
+  scATitle: 'Voyez ce qui vous attend — avant que ça ne bloque',
+  scABody:
+    "Une liste en direct de chaque worktree et de l'état de sa session. Le bandeau À traiter fait remonter les agents en attente d'une décision, pour que rien ne reste bloqué pendant que vous êtes concentré ailleurs. Commitez, poussez ou passez une branche en principal directement depuis la carte, et masquez l'historique encombrant laissé par vos anciennes sessions terminal pour garder la liste actionnable.",
+  scBKicker: 'Grille multi-terminaux',
+  scBTitle: 'La sortie de chaque agent, en direct',
+  scBBody:
+    "Surveillez toutes vos sessions en même temps — vraie sortie terminal, couleur selon l'état, mise à jour en temps réel. Cliquez sur un panneau pour reprendre la main dans un terminal plein écran — invite ancrée en bas, historique défilable au-dessus — répondre, ou arrêter une exécution.",
+  scCKicker: 'Sur votre téléphone',
+  scCTitle: 'Débloquez un agent depuis la cuisine',
+  scCBody:
+    "Installez la PWA et recevez un Web Push dès qu'une session a besoin de vous. Touchez la notification, lisez la question, répondez au dialogue — votre agent continue pendant que vous êtes loin du bureau.",
+  grpHub: '1 session',
+  grpKicker: 'Work groups · cross-repo',
+  grpTitle: 'Pilotez tous vos repos depuis une seule session Claude',
+  grpBody:
+    'Regroupez les repos qui avancent ensemble — un service, son client, sa doc. Lancez une seule session Claude qui les couvre tous à la fois : une conversation, un contexte partagé travaillant à travers chaque repo — au lieu de jongler avec un agent par repo.',
+  howKicker: 'Comment ça marche',
+  howTitle: 'Zéro install. Trois étapes.',
+  step1Title: 'Lancez le daemon',
+  step1Desc: "Une commande. Pas d'install, pas de config, pas de compte.",
+  step2Title: 'Ouvrez le dashboard',
+  step2Desc: "Il sert un dashboard web sur localhost. Installez-le en PWA sur n'importe quel appareil.",
+  step3Title: 'Lancez & supervisez',
+  step3Desc: "Démarrez des sessions Claude Code sur votre branche principale ou n'importe quel worktree, et surveillez-les de partout.",
+  secKicker: 'Sécurité',
+  secTitle: 'Un terminal web en qui vous pouvez avoir confiance',
+  secIntro: "Conçu local-first. Rien n'est exposé sauf si vous le décidez — et toujours selon vos règles.",
+  sec1Title: 'Localhost par défaut',
+  sec1Desc: 'Se lie à 127.0.0.1. Rien ne quitte votre machine sans votre accord.',
+  sec2Title: 'Tokens hashés',
+  sec2Desc: 'Les tokens sont hashés (sha256) au repos. Aucun secret en clair sur le disque.',
+  sec3Title: "Vérification d'origine stricte",
+  sec3Desc: 'Chaque requête est validée par origine. Pas de surprise cross-site.',
+  sec4Title: 'Distant via Tailscale',
+  sec4Desc: 'Accédez-y via Tailscale Serve — aucun port public, aucune redirection de port.',
+  faqTitle: 'Vos questions, les réponses',
+  ctaTitle: 'Prenez le commandement de vos agents',
+  ctaBody: 'Une commande pour lancer. Tout superviser depuis un seul endroit.',
+  ctaSource: 'Voir le code sur Gitea',
+  footTag: 'un jardin de branches, une seule vitre.',
+  license: 'Licence MIT',
+  coffee: 'Paye-moi un café',
+  mWorktrees: 'Worktrees',
+  mSessions: 'Sessions',
+  mGroups: 'Groupes',
+  mSettings: 'Réglages',
+  mHelp: 'Aide',
+  mGitea: 'Gitea',
+  mMore: 'Plus',
+  mSearch: 'Rechercher',
+  mAttn: 'À traiter',
+  waiting: 'en attente',
+  busy: 'occupée',
+  idle: 'inactive',
+  mPermission: 'Permission',
+  mDeny: 'Refuser (Échap)',
+  mMain: 'principal',
+  mClean: 'propre',
+  mDirty: '3 modifiés',
+  mStart: 'Démarrer',
+  mCommit: 'Commit',
+  mPush: 'Push',
+  toastTitle: 'Une session vous attend',
+  toastBody: 'api · feat/auth attend une décision',
+  dlgQ: 'Appliquer ce changement à login.ts ?',
+  copy: 'Copier',
+  copied: 'Copié',
+  copyCommand: 'Copier la commande',
+  copyUrl: "Copier l'URL",
+};

packages/site/src/i18n/index.ts

@@ -0,0 +1,37 @@
+import { createI18n } from 'vue-i18n';
+import en from './en';
+import fr from './fr';
+
+export type AppLocale = 'en' | 'fr';
+
+const STORAGE_KEY = 'arb-lang';
+
+// Détection fidèle au design : localStorage prioritaire, sinon langue navigateur
+// (fr → FR, sinon EN).
+function initialLocale(): AppLocale {
+  let saved: string | null = null;
+  try {
+    saved = localStorage.getItem(STORAGE_KEY);
+  } catch {
+    /* localStorage indisponible (mode privé, etc.) */
+  }
+  if (saved === 'fr' || saved === 'en') return saved;
+  const nav = (typeof navigator !== 'undefined' && navigator.language ? navigator.language : '').toLowerCase();
+  return nav.indexOf('fr') === 0 ? 'fr' : 'en';
+}
+
+export const i18n = createI18n({
+  legacy: false,
+  locale: initialLocale(),
+  fallbackLocale: 'en',
+  messages: { en, fr },
+});
+
+export function setLocale(locale: AppLocale): void {
+  i18n.global.locale.value = locale;
+  try {
+    localStorage.setItem(STORAGE_KEY, locale);
+  } catch {
+    /* ignore */
+  }
+}

packages/site/src/lib/links.ts

@@ -0,0 +1,6 @@
+// URLs externes du site vitrine — source unique de vérité.
+// Le dépôt Gitea est « arboretum » (et non « git-arboretum », qui est le nom du
+// paquet npm `@johanleroy/git-arboretum`). Centralisé ici pour ne plus dériver.
+export const REPO = 'https://git.lidge.fr/johanleroy/arboretum';
+export const LICENSE = `${REPO}/src/branch/main/LICENSE`;
+export const COFFEE = 'https://buymeacoffee.com/johanleroy';

packages/site/src/main.ts

@@ -0,0 +1,12 @@
+import { createApp } from 'vue';
+// Polices self-host (subset latin) — bundlées par Vite, aucune requête Google Fonts.
+import '@fontsource/jetbrains-mono/latin-400.css';
+import '@fontsource/jetbrains-mono/latin-500.css';
+import '@fontsource/jetbrains-mono/latin-600.css';
+import '@fontsource/jetbrains-mono/latin-700.css';
+import App from './App.vue';
+import { i18n } from './i18n';
+import { reveal } from './composables/useScrollReveal';
+import './style.css';
+
+createApp(App).use(i18n).directive('reveal', reveal).mount('#app');