release: git-arboretum 3.4.0 (visibilité temps réel, historisation), desktop 0.2.0 (Windows, logo), vscode 0.4.1, site 0.4.0

Tout est additif : PROTOCOL_VERSION inchangé, aucune rupture d'API.

Temps réel réellement armé
- `pinSession` n'était appelé nulle part : une session vivante épingle désormais le watcher FS de son
  worktree (`WorktreeManager.syncSessionPin` + `resolveWorktreeForCwd`), donc un worktree où un agent
  écrit se rafraîchit même si personne ne le regarde (mesuré ~350 ms).
- Les abonnements `watch` sortent de `GitPanel`, démonté dès qu'on quitte son onglet, ce qui coupait le
  seul abonnement de toute l'app : `composables/useWatchedWorktrees.ts` (monté dans App.vue) suit le
  worktree actif et les dépôts dépliés, borné à 40.
- Une coupure WS ne laisse plus l'UI sur des listes périmées : rechargement complet au retour.
- `worktree_changes` alimente `worktrees.changeVersion`, consommé par l'arbre de fichiers, le diff
  (son `:version` était câblé à 0) et l'éditeur, qui recharge un tampon propre ou lève la bannière de
  conflit avant la sauvegarde au lieu d'attendre le 409.

Corrélation session ↔ worktree par contenance (`@arboretum/shared/path-match.ts`)
- Un terminal lancé dans un sous-répertoire (« Démarrer le projet ») ou une session de groupe reliée
  par `--add-dir` apparaissent enfin sous leur worktree ; le worktree le plus spécifique gagne.
- Règle unique partagée par le daemon, le web et l'extension.

Historisation
- `commitLog` / `commitDiff` purs, `GET /repos/:id/worktrees/log` et `diff?commit=` (hash strictement
  validé, mêmes bornes que les diffs de fichiers).
- `CommitHistory.vue` sous le panneau Git : commits, marquage des non poussés, diff déplié sur place.

Visibilité
- Compteurs git complets sur chaque worktree de l'arbre et du panneau Groupes (ils n'existaient qu'en
  barre de statut, pour le seul worktree actif), avec upstream et dernier commit en infobulle ;
  `locked`, `prunable` et un dépôt invalide sont désormais visibles.
- Le panneau Groupes montre sa composition réelle (dépôts, worktrees, sessions) et teinte l'explorateur.

Polish visuel
- Les toasts d'erreur, persistants, s'empilaient derrière les modals : téléportés au-dessus.
- Sur mobile, ouvrir un terminal ou changer d'activité n'avait aucun effet visible.
- Tailles de panneaux clampées sur la fenêtre, barres d'onglets sans scrollbar parasite, états de
  chargement et d'erreur dans les trois panneaux, accessibilité des 11 modals centralisée dans
  ModalHost, splitters au clavier, numéros de diff collants, `window.confirm` remplacé.

Windows (daemon et packaging)
- `where.exe`, PowerShell comme shell de lancement, askpass `.cmd` (clone/push HTTPS par PAT),
  `taskkill /T`, `%APPDATA%`, `arboretum install` via tâche planifiée.
- Scripts de build exécutables sur un hôte Windows (`npm.cmd`, extraction sans `unzip` ni `bash`).
- Job CI `windows-latest` conditionné par ENABLE_WINDOWS_BUILD ; procédure runner dans docs/CI_RUNNERS.md.

Logo Debian : cause racine
- Une icône unique de 895×895 atterrissait dans `hicolor/895x895`, répertoire absent d'`index.theme`
  donc ignoré par la spécification freedesktop ; et `executableName` dérivait du nom scopé du paquet
  (`@arboretumdesktop`). Jeu d'icônes standard généré + `executableName: arboretum`, plus
  `deb.synopsis` (description courte vide dans apt) et `Section: devel`.
- Runtime Node embarqué élagué : 205 → 118 Mo.
- Auto-update réparé : la release flottante `desktop-latest` que les binaires interrogent n'existait pas.

Doc et vitrine
- README/README.fr : installation par plateforme, mode serveur web (nginx, LAN), dépannage, variables
  d'environnement, flags manquants.
- Doc in-app réécrite (elle renvoyait aux pages Worktrees et Sessions supprimées).
- Section « Accès distant » dans les Réglages ; le 403 BAD_ORIGIN nomme le flag à ajouter.
- Site : prérequis et registre npm privé (le `npx` affiché renvoyait un 404), téléchargements réels par
  plateforme, section « trois façons de l'utiliser », navigation complétée, 16 clés i18n mortes purgées.

Vérifications : 483 tests unitaires, 14 acceptances E2E vertes (dont p14/p15 nouvelles), captures de
rendu sans erreur console (nouveau `verify-ui.mjs`), .deb reconstruit et contrôlé (icônes aux tailles
standard, entrée .desktop valide).

packages/server/test/cli-install.test.ts

@@ -12,6 +12,7 @@ import {
   xmlEscape,
   systemdUnitPath,
   launchAgentPlistPath,
+  windowsCreateArgs,
 } from '../src/cli/install.js';
 
 describe('cli install · detectPlatform', () => {
@@ -20,9 +21,10 @@ describe('cli install · detectPlatform', () => {
     expect(detectPlatform('darwin')).toBe('darwin');
   });
 
-  it('rejette les autres plateformes avec un message clair', () => {
-    expect(() => detectPlatform('win32')).toThrow(/Linux \(systemd\) and macOS \(launchd\)/);
+  it('rejette les plateformes sans superviseur connu, avec un message clair', () => {
+    // win32 est désormais SUPPORTÉ (Planificateur de tâches) : cf. la suite dédiée plus bas.
     expect(() => detectPlatform('freebsd')).toThrow(/freebsd/);
+    expect(() => detectPlatform('aix')).toThrow(/Task Scheduler/);
   });
 });
 
@@ -192,3 +194,30 @@ describe('cli install · chemins', () => {
     );
   });
 });
+
+describe('P14 · Windows (Planificateur de tâches)', () => {
+  it('detectPlatform accepte win32', () => {
+    expect(detectPlatform('win32')).toBe('win32');
+    expect(() => detectPlatform('freebsd')).toThrow(/Task Scheduler/);
+  });
+
+  it('windowsCreateArgs : tâche à l’ouverture de session, sans élévation, idempotente', () => {
+    const args = windowsCreateArgs({
+      taskName: 'Arboretum',
+      exec: 'C:\\Program Files\\nodejs\\node.exe',
+      scriptArgs: ['C:\\app\\dist\\index.js', '--port', '7317'],
+    });
+    expect(args).toEqual([
+      '/Create',
+      '/TN',
+      'Arboretum',
+      '/TR',
+      '"C:\\Program Files\\nodejs\\node.exe" C:\\app\\dist\\index.js --port 7317',
+      '/SC',
+      'ONLOGON',
+      '/RL',
+      'LIMITED',
+      '/F',
+    ]);
+  });
+});

packages/server/test/git.test.ts

@@ -32,6 +32,10 @@ import {
   amendCommit,
   lastCommit,
   isUnpushed,
+  commitLog,
+  commitDiff,
+  isValidCommitish,
+  parseLogZ,
 } from '../src/core/git.js';
 import { appendFileSync } from 'node:fs';
 
@@ -318,3 +322,79 @@ describe('addWorktree : résolution auto (créer / réutiliser)', () => {
     await expect(addWorktree(repo, { path: wt, branch: 'dup', mode: 'create' })).rejects.toBeDefined();
   });
 });
+
+describe('P14 · historique (commitLog / commitDiff)', () => {
+  it('parseLogZ : découpe par paquets de champs et tolère un sujet multi-lignes', () => {
+    const stdout = ['h1', 's1', 'auteur', '2026-01-01T00:00:00Z', 'sujet\navec saut', 'h2', 's2', 'a2', 'd2', 'sujet 2'].join('\0');
+    const recs = parseLogZ(stdout, 5);
+    expect(recs).toHaveLength(2);
+    expect(recs[0]?.[4]).toBe('sujet\navec saut');
+    expect(recs[1]?.[0]).toBe('h2');
+  });
+
+  it('parseLogZ : ignore un enregistrement final vide (NUL de fin)', () => {
+    expect(parseLogZ(['h', 's', 'a', 'd', 'sub', ''].join('\0'), 5)).toHaveLength(1);
+  });
+
+  it('isValidCommitish : hex 4-64 uniquement (refuse une option déguisée)', () => {
+    expect(isValidCommitish('abc1234')).toBe(true);
+    expect(isValidCommitish('ABCDEF12')).toBe(true);
+    expect(isValidCommitish('abc')).toBe(false);
+    expect(isValidCommitish('--upload-pack=x')).toBe(false);
+    expect(isValidCommitish('HEAD')).toBe(false);
+    expect(isValidCommitish('main..HEAD')).toBe(false);
+  });
+
+  it('commitLog : ordre récent → ancien, champs remplis, sans upstream tout est local', async () => {
+    const repo = makeTmpRepo();
+    appendFileSync(join(repo, 'README.md'), 'second\n');
+    await commitAll(repo, 'deuxième commit');
+
+    const { commits, hasUpstream, unpushedCount } = await commitLog(repo);
+    expect(commits).toHaveLength(2);
+    expect(commits[0]?.subject).toBe('deuxième commit');
+    expect(commits[1]?.subject).toBe('init');
+    expect(commits[0]?.hash).toMatch(/^[0-9a-f]{40}$/);
+    expect(commits[0]?.shortHash.length).toBeGreaterThanOrEqual(7);
+    expect(commits[0]?.author).toBe('Test');
+    expect(Number.isNaN(Date.parse(commits[0]?.date ?? ''))).toBe(false);
+    // branche locale sans remote : aucun commit n'est publié
+    expect(hasUpstream).toBe(false);
+    expect(unpushedCount).toBe(0);
+  });
+
+  it('commitLog : limit et skip bornent la fenêtre', async () => {
+    const repo = makeTmpRepo();
+    for (const n of [1, 2, 3]) {
+      appendFileSync(join(repo, 'README.md'), `line ${n}\n`);
+      await commitAll(repo, `commit ${n}`);
+    }
+    expect((await commitLog(repo, { limit: 2 })).commits.map((c) => c.subject)).toEqual(['commit 3', 'commit 2']);
+    expect((await commitLog(repo, { limit: 1, skip: 2 })).commits.map((c) => c.subject)).toEqual(['commit 1']);
+  });
+
+  it('commitLog : dépôt sans aucun commit → liste vide, pas d’exception', async () => {
+    const dir = mkdtempSync(join(tmpdir(), 'arb-git-empty-'));
+    dirs.push(dir);
+    execFileSync('git', ['init', '-b', 'main'], { cwd: dir, stdio: 'pipe' });
+    const res = await commitLog(dir);
+    expect(res.commits).toEqual([]);
+    expect(res.hasUpstream).toBe(false);
+  });
+
+  it('commitDiff : diff unifié du commit demandé, hash invalide et inconnu rejetés', async () => {
+    const repo = makeTmpRepo();
+    writeFileSync(join(repo, 'nouveau.txt'), 'contenu\n');
+    await commitAll(repo, 'ajout fichier');
+    const [head] = (await commitLog(repo)).commits;
+
+    const d = await commitDiff(repo, head?.hash ?? '');
+    expect(d.binary).toBe(false);
+    expect(d.tooLarge).toBe(false);
+    expect(d.diff).toContain('nouveau.txt');
+    expect(d.diff).toContain('+contenu');
+
+    await expect(commitDiff(repo, 'HEAD')).rejects.toThrow(/Invalid commit hash/);
+    await expect(commitDiff(repo, 'deadbeef')).rejects.toThrow(/Unknown commit/);
+  });
+});

packages/server/test/session-match.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, it } from 'vitest';
+import { containsPath, findWorktreeForCwd, sessionBelongsToWorktree } from '../src/core/session-match.js';
+
+describe('containsPath', () => {
+  it('vrai pour le répertoire lui-même', () => {
+    expect(containsPath('/p/repo', '/p/repo')).toBe(true);
+  });
+
+  it('vrai pour un descendant', () => {
+    expect(containsPath('/p/repo', '/p/repo/packages/api')).toBe(true);
+  });
+
+  it('compare par segment, pas par préfixe de chaîne', () => {
+    // /p/repo ne contient PAS /p/repo-wt-feature (piège du startsWith nu)
+    expect(containsPath('/p/repo', '/p/repo-wt-feature')).toBe(false);
+  });
+
+  it('faux pour un ancêtre', () => {
+    expect(containsPath('/p/repo/api', '/p/repo')).toBe(false);
+  });
+
+  it('normalise les chemins non résolus', () => {
+    expect(containsPath('/p/repo', '/p/repo/./api/../api')).toBe(true);
+  });
+});
+
+describe('sessionBelongsToWorktree', () => {
+  it('rattache une session lancée à la racine du worktree', () => {
+    expect(sessionBelongsToWorktree({ cwd: '/p/repo' }, '/p/repo')).toBe(true);
+  });
+
+  it('rattache une session lancée dans un sous-répertoire (« Démarrer le projet »)', () => {
+    // LaunchCommand.cwd autorise un sous-dossier : le terminal doit rester visible sous son worktree.
+    expect(sessionBelongsToWorktree({ cwd: '/p/repo/packages/api' }, '/p/repo')).toBe(true);
+  });
+
+  it('ne rattache pas une session d’un worktree frère', () => {
+    expect(sessionBelongsToWorktree({ cwd: '/p/repo-wt-feat' }, '/p/repo')).toBe(false);
+  });
+
+  it('donne un worktree imbriqué au plus spécifique, pas au principal', () => {
+    const session = { cwd: '/p/repo/.worktrees/feat/src' };
+    const all = ['/p/repo', '/p/repo/.worktrees/feat'];
+    expect(sessionBelongsToWorktree(session, '/p/repo/.worktrees/feat', all)).toBe(true);
+    expect(sessionBelongsToWorktree(session, '/p/repo', all)).toBe(false);
+  });
+
+  it('rattache une session de groupe via ses répertoires reliés', () => {
+    // cwd = parent commun (hors des repos), les worktrees couverts vivent dans addedDirs.
+    const session = { cwd: '/p', addedDirs: ['/p/api', '/p/web'] };
+    expect(sessionBelongsToWorktree(session, '/p/api')).toBe(true);
+    expect(sessionBelongsToWorktree(session, '/p/web')).toBe(true);
+    expect(sessionBelongsToWorktree(session, '/p/docs')).toBe(false);
+  });
+
+  it('ignore un addedDirs absent', () => {
+    expect(sessionBelongsToWorktree({ cwd: '/p/api' }, '/p/api', [])).toBe(true);
+  });
+});
+
+describe('findWorktreeForCwd', () => {
+  const worktrees = [
+    { repoId: 'r1', path: '/p/api' },
+    { repoId: 'r1', path: '/p/api-wt-feat' },
+    { repoId: 'r2', path: '/p/api/vendor/web' },
+  ];
+
+  it('choisit le worktree le plus spécifique', () => {
+    expect(findWorktreeForCwd('/p/api/vendor/web/src', worktrees)?.repoId).toBe('r2');
+  });
+
+  it('choisit le worktree frère exact et non le préfixe de chaîne', () => {
+    expect(findWorktreeForCwd('/p/api-wt-feat/src', worktrees)?.path).toBe('/p/api-wt-feat');
+  });
+
+  it('renvoie null hors de tout worktree connu', () => {
+    expect(findWorktreeForCwd('/tmp/ailleurs', worktrees)).toBeNull();
+  });
+});

packages/server/test/windows-support.test.ts

@@ -0,0 +1,94 @@
+// Support Windows du daemon : helpers purs, testés avec la plateforme INJECTÉE (ils doivent donc être
+// vérifiables depuis Linux). Chacun corrige un point qui rendait le daemon inutilisable sur Windows.
+import { describe, expect, it } from 'vitest';
+import { buildSpawnSpec, resolveInteractiveShell, resolvePlainShell, whichCommand } from '../src/core/claude-launcher.js';
+import { askpassScript } from '../src/core/git-auth.js';
+import { defaultDataRoot } from '../src/config.js';
+
+describe('recherche du binaire claude dans le PATH', () => {
+  it('utilise where.exe sur Windows, which ailleurs', () => {
+    expect(whichCommand('win32')).toEqual({ file: 'where.exe', args: ['claude'] });
+    expect(whichCommand('linux')).toEqual({ file: 'which', args: ['claude'] });
+    expect(whichCommand('darwin').file).toBe('which');
+  });
+});
+
+describe('shell de lancement', () => {
+  it('POSIX : $SHELL connu en login interactif, sinon bash', () => {
+    expect(resolveInteractiveShell('linux', { SHELL: '/usr/bin/zsh' })).toEqual({ file: '/usr/bin/zsh', args: ['-l', '-i'] });
+    expect(resolveInteractiveShell('linux', { SHELL: '/bin/dash' })).toEqual({ file: 'bash', args: ['-l', '-i'] });
+    expect(resolveInteractiveShell('linux', {})).toEqual({ file: 'bash', args: ['-l', '-i'] });
+  });
+
+  it('Windows : PowerShell qui reste attaché après la commande auto-tapée', () => {
+    const shell = resolveInteractiveShell('win32', {});
+    expect(shell.file).toBe('powershell.exe');
+    expect(shell.args).toContain('-NoExit');
+  });
+
+  it('Windows : le shell est surchargeable par ARBORETUM_SHELL', () => {
+    expect(resolveInteractiveShell('win32', { ARBORETUM_SHELL: 'pwsh.exe' }).file).toBe('pwsh.exe');
+  });
+
+  it('terminal simple : bash --norc sur POSIX, PowerShell sur Windows', () => {
+    expect(resolvePlainShell('linux')).toEqual({ file: 'bash', args: ['--norc'] });
+    expect(resolvePlainShell('win32').file).toBe('powershell.exe');
+  });
+});
+
+describe('buildSpawnSpec · plateforme injectée', () => {
+  it('command=bash sur Windows lance PowerShell (le contrat d’API reste claude|bash)', () => {
+    const spec = buildSpawnSpec({ command: 'bash', platform: 'win32' });
+    expect(spec.file).toBe('powershell.exe');
+    expect(spec.env.TERM).toBe('xterm-256color');
+  });
+
+  it('command=bash avec login sur Windows reste attaché', () => {
+    expect(buildSpawnSpec({ command: 'bash', login: true, platform: 'win32' }).args).toContain('-NoExit');
+  });
+
+  it('command=bash sur Linux inchangé', () => {
+    expect(buildSpawnSpec({ command: 'bash', platform: 'linux' })).toMatchObject({ file: 'bash', args: ['--norc'] });
+  });
+});
+
+describe('script askpass git', () => {
+  it('Windows : .cmd (un .sh à shebang n’y est pas exécutable)', () => {
+    const s = askpassScript('win32');
+    expect(s.name).toBe('askpass.cmd');
+    expect(s.content).toContain('@echo off');
+    expect(s.content).toContain('ARB_GIT_USER');
+    expect(s.content).toContain('ARB_GIT_PASS');
+  });
+
+  it('POSIX : .sh avec shebang', () => {
+    const s = askpassScript('linux');
+    expect(s.name).toBe('askpass.sh');
+    expect(s.content.startsWith('#!/bin/sh')).toBe(true);
+    expect(s.mode).toBe(0o700);
+  });
+
+  it('les deux variantes distinguent Username du mot de passe', () => {
+    for (const p of ['win32', 'linux'] as const) {
+      const c = askpassScript(p).content;
+      expect(c).toMatch(/Username/i);
+    }
+  });
+});
+
+describe('racine des données', () => {
+  it('XDG_DATA_HOME est prioritaire partout (l’app de bureau s’en sert pour isoler)', () => {
+    expect(defaultDataRoot('win32', { XDG_DATA_HOME: '/iso' }, '/home/u')).toBe('/iso');
+    expect(defaultDataRoot('linux', { XDG_DATA_HOME: '/iso' }, '/home/u')).toBe('/iso');
+  });
+
+  it('Windows : %APPDATA%, avec repli sur AppData/Roaming', () => {
+    expect(defaultDataRoot('win32', { APPDATA: 'C:\\Users\\u\\AppData\\Roaming' }, 'C:\\Users\\u')).toBe('C:\\Users\\u\\AppData\\Roaming');
+    expect(defaultDataRoot('win32', {}, '/home/u')).toBe('/home/u/AppData/Roaming');
+  });
+
+  it('POSIX : ~/.local/share', () => {
+    expect(defaultDataRoot('linux', {}, '/home/u')).toBe('/home/u/.local/share');
+    expect(defaultDataRoot('darwin', {}, '/Users/u')).toBe('/Users/u/.local/share');
+  });
+});