feat(worktrees): création intelligente (auto) + commit/push/promotion + grille agrandissable

- addWorktree résout la branche par dépôt (branchExists) : checkout si présente, suivi de origin/<b> si seulement remote, sinon création (-b) depuis la branche par défaut. Corrige le 'fatal: invalid reference' sur les groupes hétérogènes ; newBranch -> mode (déprécié, mappé en route).
- Nouvelles opérations git : commit (add -A), push (upstream auto), promotion « en principal » (la branche du worktree devient le checkout principal, sans merge ni conflit, ancienne branche conservée). Routes /worktrees/{commit,push,promote} auditées + GET /repos/:id/branches.
- Web : actions Commit/Push/Promouvoir sur WorktreeCard, sélecteur de branche de base (datalist) dans RepoSection et GroupSessionModal, agrandissement d'un terminal au choix dans TerminalGrid.
- Court-circuite la session de groupe quand aucun worktree n'a pu être créé (fini le masquage par « no resolvable worktree »).
- Tests : git.ts (branchExists/listBranches/commitAll/auto), worktree-manager (commit/promote/branches) ; acceptance P5 étend le scénario worktree de groupe sur branche neuve + commit + promotion.

packages/server/test/git.test.ts

@@ -15,6 +15,10 @@ import {
   pruneWorktrees,
   switchBranch,
   isDirtyWorktreeError,
+  branchExists,
+  currentBranch,
+  listBranches,
+  commitAll,
 } from '../src/core/git.js';
 
 const dirs: string[] = [];
@@ -96,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));
@@ -136,9 +140,57 @@ describe('opérations git (repo tmp réel)', () => {
   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();
+  });
+});