docs: norme merge squash (feature→develop→master)

Décision §26 + briefing + API Gitea. Les merges --no-ff #167/#168 restent inchangés.

Co-authored-by: Julien Martin <julien.martin@ptits-pas.fr>

backend/src/entities/parents.entity.ts

@@ -5,6 +5,7 @@ import {
 import { Users } from './users.entity';
 import { ParentsChildren } from './parents_children.entity';
 import { Dossier } from './dossiers.entity';
+import { AmChildren } from './am_children.entity';
 
 @Entity('parents', { schema: 'public' })
 export class Parents {
@@ -25,6 +26,17 @@ export class Parents {
   @Column({ name: 'numero_dossier', length: 20, nullable: true })
   numero_dossier?: string;
 
+  /**
+   * Placement AM↔enfant sélectionné sur le TdB parent (couple actif) — ticket #168.
+   * Null / absent = le front prend le premier couple actif retourné par l’API.
+   */
+  @Column({ name: 'id_placement_garde_courant', type: 'uuid', nullable: true })
+  id_placement_garde_courant?: string;
+
+  @ManyToOne(() => AmChildren, { nullable: true, onDelete: 'SET NULL' })
+  @JoinColumn({ name: 'id_placement_garde_courant', referencedColumnName: 'id' })
+  placement_garde_courant?: AmChildren;
+
   // Lien vers enfants via la table enfants_parents
   @OneToMany(() => ParentsChildren, pc => pc.parent)
   parentChildren: ParentsChildren[];

backend/src/routes/parents/dto/couples-garde.dto.ts

@@ -0,0 +1,61 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+
+/** Identité minimale enfant pour le bandeau couple — ticket #168 */
+export class CoupleGardeEnfantDto {
+  @ApiProperty({ format: 'uuid' })
+  id: string;
+
+  @ApiPropertyOptional()
+  prenom?: string | null;
+
+  @ApiPropertyOptional()
+  nom?: string | null;
+
+  @ApiPropertyOptional()
+  photo_url?: string | null;
+}
+
+/** Identité minimale AM pour le bandeau couple — ticket #168 */
+export class CoupleGardeAmDto {
+  @ApiProperty({ format: 'uuid', description: 'UUID utilisateur de l’AM' })
+  id: string;
+
+  @ApiPropertyOptional()
+  prenom?: string | null;
+
+  @ApiPropertyOptional()
+  nom?: string | null;
+
+  @ApiPropertyOptional()
+  photo_url?: string | null;
+}
+
+/** Un couple de garde = placement actif enfant ↔ AM */
+export class CoupleGardeDto {
+  @ApiProperty({
+    format: 'uuid',
+    description: 'Id du placement (enfants_assistantes_maternelles.id)',
+  })
+  id: string;
+
+  @ApiProperty({ type: CoupleGardeEnfantDto })
+  enfant: CoupleGardeEnfantDto;
+
+  @ApiProperty({ type: CoupleGardeAmDto })
+  am: CoupleGardeAmDto;
+
+  @ApiProperty({ description: 'True si c’est le couple actuellement sélectionné' })
+  courant: boolean;
+}
+
+export class CouplesGardeResponseDto {
+  @ApiProperty({ type: [CoupleGardeDto] })
+  couples: CoupleGardeDto[];
+
+  @ApiPropertyOptional({
+    format: 'uuid',
+    nullable: true,
+    description: 'Id du couple courant (null si aucun / premier couple implicite côté client)',
+  })
+  couple_courant_id: string | null;
+}

backend/src/routes/parents/dto/definir-couple-garde-courant.dto.ts

@@ -0,0 +1,13 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsNotEmpty, IsUUID } from 'class-validator';
+
+/** Corps PUT couple de garde courant — ticket #168 */
+export class DefinirCoupleGardeCourantDto {
+  @ApiProperty({
+    format: 'uuid',
+    description: 'Id du placement (enfants_assistantes_maternelles.id) à sélectionner',
+  })
+  @IsUUID()
+  @IsNotEmpty()
+  couple_id: string;
+}

backend/src/routes/parents/parents.controller.spec.ts

@@ -13,7 +13,10 @@ describe('ParentsController', () => {
     createParentDossierStaff: jest.fn(),
     addCoParentStaff: jest.fn(),
   };
-  const parentsServiceMock = {};
+  const parentsServiceMock = {
+    listerCouplesGarde: jest.fn(),
+    definirCoupleGardeCourant: jest.fn(),
+  };
   const userServiceMock = {};
 
   beforeEach(async () => {
@@ -39,6 +42,31 @@ describe('ParentsController', () => {
     expect(controller).toBeDefined();
   });
 
+  it('listerCouplesGarde délègue au service (#168)', async () => {
+    parentsServiceMock.listerCouplesGarde.mockResolvedValue({
+      couples: [],
+      couple_courant_id: null,
+    });
+    const res = await controller.listerCouplesGarde('parent-uuid');
+    expect(parentsServiceMock.listerCouplesGarde).toHaveBeenCalledWith('parent-uuid');
+    expect(res.couples).toEqual([]);
+  });
+
+  it('definirCoupleGardeCourant délègue au service (#168)', async () => {
+    parentsServiceMock.definirCoupleGardeCourant.mockResolvedValue({
+      couples: [{ id: 'pl-1', courant: true }],
+      couple_courant_id: 'pl-1',
+    });
+    const res = await controller.definirCoupleGardeCourant('parent-uuid', {
+      couple_id: 'pl-1',
+    });
+    expect(parentsServiceMock.definirCoupleGardeCourant).toHaveBeenCalledWith(
+      'parent-uuid',
+      'pl-1',
+    );
+    expect(res.couple_courant_id).toBe('pl-1');
+  });
+
   it('createDossier delegates to authService.createParentDossierStaff with CGU accepted', async () => {
     authServiceMock.createParentDossierStaff.mockResolvedValue({
       message: 'Dossier famille créé et validé. Un e-mail de création de mot de passe a été envoyé.',

backend/src/routes/parents/parents.controller.ts

@@ -8,6 +8,7 @@ import {
   Param,
   Patch,
   Post,
+  Put,
   UseGuards,
 } from '@nestjs/common';
 import { ParentsService } from './parents.service';
@@ -39,6 +40,8 @@ import { User } from 'src/common/decorators/user.decorator';
 import { PendingFamilyDto } from './dto/pending-family.dto';
 import { DossierFamilleCompletDto } from './dto/dossier-famille-complet.dto';
 import { mapParentForApi, mapParentsForApi } from './parents.mapper';
+import { CouplesGardeResponseDto } from './dto/couples-garde.dto';
+import { DefinirCoupleGardeCourantDto } from './dto/definir-couple-garde-courant.dto';
 
 @ApiTags('Parents')
 @ApiBearerAuth('access-token')
@@ -51,6 +54,39 @@ export class ParentsController {
     private readonly authService: AuthService,
   ) {}
 
+  @Get('me/couples-garde')
+  @Roles(RoleType.PARENT)
+  @ApiOperation({
+    summary: 'Lister les couples de garde du parent connecté — ticket #168',
+    description:
+      'Retourne les placements actifs enfant↔AM rattachés au parent, ' +
+      'avec indication du couple courant (bandeau TdB quotidien).',
+  })
+  @ApiResponse({ status: 200, type: CouplesGardeResponseDto })
+  @ApiResponse({ status: 403, description: 'Réservé au rôle parent' })
+  @ApiResponse({ status: 404, description: 'Parent introuvable' })
+  listerCouplesGarde(@User('id') userId: string): Promise<CouplesGardeResponseDto> {
+    return this.parentsService.listerCouplesGarde(userId);
+  }
+
+  @Put('me/couples-garde/courant')
+  @Roles(RoleType.PARENT)
+  @ApiOperation({
+    summary: 'Définir le couple de garde courant — ticket #168',
+    description:
+      'Persiste la préférence de couple actif (enfant|nounou) pour contextualiser le TdB.',
+  })
+  @ApiBody({ type: DefinirCoupleGardeCourantDto })
+  @ApiResponse({ status: 200, type: CouplesGardeResponseDto })
+  @ApiResponse({ status: 400, description: 'Couple hors périmètre du parent' })
+  @ApiResponse({ status: 404, description: 'Parent ou couple introuvable' })
+  definirCoupleGardeCourant(
+    @User('id') userId: string,
+    @Body() dto: DefinirCoupleGardeCourantDto,
+  ): Promise<CouplesGardeResponseDto> {
+    return this.parentsService.definirCoupleGardeCourant(userId, dto.couple_id);
+  }
+
   @Roles(RoleType.SUPER_ADMIN, RoleType.ADMINISTRATEUR, RoleType.GESTIONNAIRE)
   @Post('dossier')
   @HttpCode(HttpStatus.CREATED)

backend/src/routes/parents/parents.module.ts

@@ -5,6 +5,7 @@ import { JwtModule } from '@nestjs/jwt';
 import { Parents } from 'src/entities/parents.entity';
 import { DossierFamille, DossierFamilleEnfant } from 'src/entities/dossier_famille.entity';
 import { ParentsChildren } from 'src/entities/parents_children.entity';
+import { AmChildren } from 'src/entities/am_children.entity';
 import { ParentsController } from './parents.controller';
 import { ParentsService } from './parents.service';
 import { Users } from 'src/entities/users.entity';
@@ -13,7 +14,14 @@ import { AuthModule } from '../auth/auth.module';
 
 @Module({
     imports: [
-        TypeOrmModule.forFeature([Parents, Users, DossierFamille, DossierFamilleEnfant, ParentsChildren]),
+        TypeOrmModule.forFeature([
+            Parents,
+            Users,
+            DossierFamille,
+            DossierFamilleEnfant,
+            ParentsChildren,
+            AmChildren,
+        ]),
         forwardRef(() => UserModule),
         forwardRef(() => AuthModule),
         JwtModule.registerAsync({

backend/src/routes/parents/parents.service.spec.ts

@@ -1,12 +1,43 @@
+import { BadRequestException, NotFoundException } from '@nestjs/common';
 import { Test, TestingModule } from '@nestjs/testing';
+import { getRepositoryToken } from '@nestjs/typeorm';
 import { ParentsService } from './parents.service';
+import { Parents } from 'src/entities/parents.entity';
+import { Users } from 'src/entities/users.entity';
+import { DossierFamille } from 'src/entities/dossier_famille.entity';
+import { ParentsChildren } from 'src/entities/parents_children.entity';
+import { AmChildren } from 'src/entities/am_children.entity';
 
-describe('ParentsService', () => {
+describe('ParentsService — couples de garde (#168)', () => {
   let service: ParentsService;
 
+  const parentsRepository = {
+    findOne: jest.fn(),
+    update: jest.fn(),
+  };
+  const parentsChildrenRepository = {
+    find: jest.fn(),
+    findOne: jest.fn(),
+  };
+  const amChildrenRepository = {
+    find: jest.fn(),
+    findOne: jest.fn(),
+  };
+
   beforeEach(async () => {
+    jest.clearAllMocks();
     const module: TestingModule = await Test.createTestingModule({
-      providers: [ParentsService],
+      providers: [
+        ParentsService,
+        { provide: getRepositoryToken(Parents), useValue: parentsRepository },
+        { provide: getRepositoryToken(Users), useValue: {} },
+        { provide: getRepositoryToken(DossierFamille), useValue: {} },
+        {
+          provide: getRepositoryToken(ParentsChildren),
+          useValue: parentsChildrenRepository,
+        },
+        { provide: getRepositoryToken(AmChildren), useValue: amChildrenRepository },
+      ],
     }).compile();
 
     service = module.get<ParentsService>(ParentsService);
@@ -15,4 +46,107 @@ describe('ParentsService', () => {
   it('should be defined', () => {
     expect(service).toBeDefined();
   });
+
+  describe('listerCouplesGarde', () => {
+    it('retourne une liste vide si le parent n’a pas d’enfant', async () => {
+      parentsRepository.findOne.mockResolvedValue({
+        user_id: 'p1',
+        id_placement_garde_courant: null,
+      });
+      parentsChildrenRepository.find.mockResolvedValue([]);
+
+      const res = await service.listerCouplesGarde('p1');
+      expect(res).toEqual({ couples: [], couple_courant_id: null });
+      expect(amChildrenRepository.find).not.toHaveBeenCalled();
+    });
+
+    it('mappe les placements actifs en couples et marque le courant', async () => {
+      parentsRepository.findOne.mockResolvedValue({
+        user_id: 'p1',
+        id_placement_garde_courant: 'pl-2',
+      });
+      parentsChildrenRepository.find.mockResolvedValue([
+        { enfantId: 'e1' },
+        { enfantId: 'e2' },
+      ]);
+      amChildrenRepository.find.mockResolvedValue([
+        {
+          id: 'pl-1',
+          amId: 'am-1',
+          child: { id: 'e1', first_name: 'Léo', last_name: 'M', photo_url: null },
+          am: { user: { prenom: 'Marie', nom: 'N', photo_url: '/a.jpg' } },
+        },
+        {
+          id: 'pl-2',
+          amId: 'am-2',
+          child: { id: 'e2', first_name: 'Léa', last_name: 'M', photo_url: null },
+          am: { user: { prenom: 'Sophie', nom: 'P', photo_url: null } },
+        },
+      ]);
+
+      const res = await service.listerCouplesGarde('p1');
+      expect(res.couples).toHaveLength(2);
+      expect(res.couple_courant_id).toBe('pl-2');
+      expect(res.couples[1].courant).toBe(true);
+      expect(res.couples[0].am.prenom).toBe('Marie');
+      expect(res.couples[0].enfant.prenom).toBe('Léo');
+    });
+
+    it('404 si parent inconnu', async () => {
+      parentsRepository.findOne.mockResolvedValue(null);
+      await expect(service.listerCouplesGarde('x')).rejects.toBeInstanceOf(
+        NotFoundException,
+      );
+    });
+  });
+
+  describe('definirCoupleGardeCourant', () => {
+    it('persiste le couple si l’enfant est rattaché au parent', async () => {
+      parentsRepository.findOne.mockResolvedValue({
+        user_id: 'p1',
+        id_placement_garde_courant: null,
+      });
+      amChildrenRepository.findOne.mockResolvedValue({
+        id: 'pl-1',
+        enfantId: 'e1',
+        date_fin: null,
+      });
+      parentsChildrenRepository.findOne.mockResolvedValue({
+        parentId: 'p1',
+        enfantId: 'e1',
+      });
+      parentsRepository.update.mockResolvedValue({ affected: 1 });
+      // second call via listerCouplesGarde
+      parentsChildrenRepository.find.mockResolvedValue([{ enfantId: 'e1' }]);
+      amChildrenRepository.find.mockResolvedValue([
+        {
+          id: 'pl-1',
+          amId: 'am-1',
+          child: { id: 'e1', first_name: 'Léo', last_name: null, photo_url: null },
+          am: { user: { prenom: 'Marie', nom: null, photo_url: null } },
+        },
+      ]);
+
+      const res = await service.definirCoupleGardeCourant('p1', 'pl-1');
+      expect(parentsRepository.update).toHaveBeenCalledWith(
+        { user_id: 'p1' },
+        { id_placement_garde_courant: 'pl-1' },
+      );
+      expect(res.couple_courant_id).toBe('pl-1');
+      expect(res.couples[0].courant).toBe(true);
+    });
+
+    it('400 si le couple n’appartient pas au parent', async () => {
+      parentsRepository.findOne.mockResolvedValue({ user_id: 'p1' });
+      amChildrenRepository.findOne.mockResolvedValue({
+        id: 'pl-1',
+        enfantId: 'e99',
+      });
+      parentsChildrenRepository.findOne.mockResolvedValue(null);
+
+      await expect(
+        service.definirCoupleGardeCourant('p1', 'pl-1'),
+      ).rejects.toBeInstanceOf(BadRequestException);
+    });
+  });
 });

backend/src/routes/parents/parents.service.ts

@@ -5,7 +5,7 @@ import {
   NotFoundException,
 } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
-import { In, Repository } from 'typeorm';
+import { In, IsNull, Repository } from 'typeorm';
 import { Parents } from 'src/entities/parents.entity';
 import { DossierFamille } from 'src/entities/dossier_famille.entity';
 import { RoleType, Users } from 'src/entities/users.entity';
@@ -20,6 +20,8 @@ import {
 import { ParentsChildren } from 'src/entities/parents_children.entity';
 import { Children } from 'src/entities/children.entity';
 import { UpdateParentFicheAdminDto } from './dto/update-parent-fiche-admin.dto';
+import { AmChildren } from 'src/entities/am_children.entity';
+import { CouplesGardeResponseDto } from './dto/couples-garde.dto';
 
 @Injectable()
 export class ParentsService {
@@ -32,6 +34,8 @@ export class ParentsService {
     private readonly dossierFamilleRepository: Repository<DossierFamille>,
     @InjectRepository(ParentsChildren)
     private readonly parentsChildrenRepository: Repository<ParentsChildren>,
+    @InjectRepository(AmChildren)
+    private readonly amChildrenRepository: Repository<AmChildren>,
   ) {}
 
   // Création d’un parent
@@ -505,4 +509,108 @@ export class ParentsService {
     }
     return raw.map((r: { id: string }) => r.id);
   }
+
+  /**
+   * Liste les couples de garde (enfant ↔ AM) du parent connecté — ticket #168.
+   * Un couple = un placement actif dans enfants_assistantes_maternelles pour un enfant du parent.
+   */
+  async listerCouplesGarde(parentUserId: string): Promise<CouplesGardeResponseDto> {
+    const parent = await this.parentsRepository.findOne({
+      where: { user_id: parentUserId },
+    });
+    if (!parent) {
+      throw new NotFoundException('Parent introuvable');
+    }
+
+    const liensEnfants = await this.parentsChildrenRepository.find({
+      where: { parentId: parentUserId },
+      select: ['enfantId'],
+    });
+    const enfantIds = liensEnfants.map((l) => l.enfantId);
+    if (enfantIds.length === 0) {
+      return { couples: [], couple_courant_id: null };
+    }
+
+    const placements = await this.amChildrenRepository.find({
+      where: { enfantId: In(enfantIds), date_fin: IsNull() },
+      relations: ['child', 'am', 'am.user'],
+      order: { date_debut: 'ASC' },
+    });
+
+    let idCourant = parent.id_placement_garde_courant ?? null;
+    const idsValides = new Set(placements.map((p) => p.id));
+    if (idCourant && !idsValides.has(idCourant)) {
+      idCourant = null;
+      await this.parentsRepository.update(
+        { user_id: parentUserId },
+        { id_placement_garde_courant: () => 'NULL' },
+      );
+    }
+    if (!idCourant && placements.length === 1) {
+      idCourant = placements[0].id;
+    }
+
+    const couples = placements.map((p) => {
+      const amUser = p.am?.user;
+      return {
+        id: p.id,
+        enfant: {
+          id: p.child.id,
+          prenom: p.child.first_name ?? null,
+          nom: p.child.last_name ?? null,
+          photo_url: p.child.photo_url ?? null,
+        },
+        am: {
+          id: p.amId,
+          prenom: amUser?.prenom ?? null,
+          nom: amUser?.nom ?? null,
+          photo_url: amUser?.photo_url ?? null,
+        },
+        courant: idCourant != null && p.id === idCourant,
+      };
+    });
+
+    return {
+      couples,
+      couple_courant_id: idCourant,
+    };
+  }
+
+  /**
+   * Persiste le couple de garde actif pour le parent — ticket #168.
+   */
+  async definirCoupleGardeCourant(
+    parentUserId: string,
+    coupleId: string,
+  ): Promise<CouplesGardeResponseDto> {
+    const parent = await this.parentsRepository.findOne({
+      where: { user_id: parentUserId },
+    });
+    if (!parent) {
+      throw new NotFoundException('Parent introuvable');
+    }
+
+    const placement = await this.amChildrenRepository.findOne({
+      where: { id: coupleId, date_fin: IsNull() },
+    });
+    if (!placement) {
+      throw new NotFoundException('Couple de garde introuvable ou inactif');
+    }
+
+    const lien = await this.parentsChildrenRepository.findOne({
+      where: { parentId: parentUserId, enfantId: placement.enfantId },
+    });
+    if (!lien) {
+      throw new BadRequestException(
+        'Ce couple ne concerne pas un enfant rattaché à ce parent',
+      );
+    }
+
+    await this.parentsRepository.update(
+      { user_id: parentUserId },
+      { id_placement_garde_courant: coupleId },
+    );
+
+    return this.listerCouplesGarde(parentUserId);
+  }
 }

database/BDD.sql

@@ -154,7 +154,10 @@ CREATE INDEX idx_assistantes_maternelles_numero_dossier
 CREATE TABLE parents (
     id_utilisateur UUID PRIMARY KEY REFERENCES utilisateurs(id) ON DELETE CASCADE,
     id_co_parent UUID REFERENCES utilisateurs(id),
-    numero_dossier VARCHAR(20)
+    numero_dossier VARCHAR(20),
+    -- Préférence couple de garde actif (TdB quotidien) — ticket #168
+    -- FK ajoutée après création de enfants_assistantes_maternelles (voir ALTER plus bas)
+    id_placement_garde_courant UUID
 );
 
 CREATE INDEX idx_parents_numero_dossier
@@ -206,6 +209,16 @@ CREATE UNIQUE INDEX uq_enfant_garde_active
     ON enfants_assistantes_maternelles (id_enfant)
     WHERE date_fin IS NULL;
 
+-- FK couple courant parent → placement (#168) — après table enfants_assistantes_maternelles
+ALTER TABLE parents
+  ADD CONSTRAINT fk_parents_placement_garde_courant
+  FOREIGN KEY (id_placement_garde_courant)
+  REFERENCES enfants_assistantes_maternelles(id) ON DELETE SET NULL;
+
+CREATE INDEX idx_parents_placement_garde_courant
+  ON parents(id_placement_garde_courant)
+  WHERE id_placement_garde_courant IS NOT NULL;
+
 -- ==========================================================
 -- Table : dossier_famille (inscription parent — ticket #119)
 -- ==========================================================

database/migrations/2026_parent_placement_garde_courant.sql

@@ -0,0 +1,10 @@
+-- Ticket #168 — Couple de garde courant (préférence parent)
+-- Idempotent : safe à rejouer.
+
+ALTER TABLE parents
+  ADD COLUMN IF NOT EXISTS id_placement_garde_courant UUID
+    REFERENCES enfants_assistantes_maternelles(id) ON DELETE SET NULL;
+
+CREATE INDEX IF NOT EXISTS idx_parents_placement_garde_courant
+  ON parents(id_placement_garde_courant)
+  WHERE id_placement_garde_courant IS NOT NULL;

docs/24_DECISIONS-PROJET.md

@@ -1,7 +1,7 @@
 # 📋 Décisions Projet - P'titsPas
 
-**Version** : 1.2  
-**Date** : 16 Juin 2026  
+**Version** : 1.3  
+**Date** : 24 Septembre 2026  
 **Auteur** : Équipe PtitsPas
 
 ---
@@ -465,19 +465,34 @@ docs/
 
 ---
 
-### 26. Branches Git
+### 26. Branches Git + merge squash (norme)
 
-**Décision** : ✅ **Stratégie simple : master + feature branches**
+**Décision** : ✅ **`develop` + `master` + `feature/*`, merges en squash**
 
 **Justification** :
 - Simplicité (petite équipe)
-- Flexibilité
+- Historique lisible sur `develop` / `master` (1 commit = 1 ticket)
+- Déploiement prod uniquement depuis `master`
 
 **Branches** :
-- `master` : Production
-- `archive/*` : Archives (ex: maquette initiale)
-- `migration/*` : Migrations (ex: intégration YNOV)
-- `feature/*` : Nouvelles fonctionnalités
+- `master` : Production (déploiement auto)
+- `develop` : Intégration / recette
+- `feature/*` : Ticket en cours (depuis `develop`)
+- `archive/*`, `migration/*` : Archives / migrations ponctuelles
+
+**Flux (norme à partir de #169+)** :
+1. Branche `feature/N-…` depuis `develop`
+2. PR **feature → `develop`** : merge **squash** (`Do: squash` côté Gitea)
+3. Quand un lot est prêt : PR **`develop` → `master`** : merge **squash** également
+4. Message squash : `feat(#N): …` / `fix(#N): …` + `Closes #N` si applicable
+
+**Exception** : les merges `--no-ff` déjà poussés (ex. #167, #168) restent tels quels — pas de réécriture d’historique.
+
+**API Gitea** (rappel) :
+```http
+POST /repos/jmartin/petitspas/pulls/{index}/merge
+{"Do":"squash","MergeTitleField":"feat(#N): …","MergeMessageField":"Closes #N"}
+```
 
 ---
 

docs/26_GITEA-API.md

@@ -116,10 +116,17 @@ curl -s -H "Authorization: token $GITEA_TOKEN" \
   "https://git.ptits-pas.fr/api/v1/repos/jmartin/petitspas/pulls?state=open" | jq .
 
 # Créer une PR (head = branche source, base = branche cible)
+# Norme : feature/* → develop, puis develop → master
 curl -s -X POST -H "Authorization: token $GITEA_TOKEN" \
   -H "Content-Type: application/json" \
-  -d '{"head":"develop","base":"master","title":"Titre de la PR"}' \
+  -d '{"head":"feature/XX-nom","base":"develop","title":"feat(#XX): Titre","body":"Closes #XX"}' \
   "https://git.ptits-pas.fr/api/v1/repos/jmartin/petitspas/pulls"
+
+# Merger en squash (norme — voir 24_DECISIONS-PROJET.md §26)
+curl -s -X POST -H "Authorization: token $GITEA_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"Do":"squash","MergeTitleField":"feat(#XX): Titre","MergeMessageField":"Closes #XX"}' \
+  "https://git.ptits-pas.fr/api/v1/repos/jmartin/petitspas/pulls/{index}/merge"
 ```
 
 ### 3.4 Branches

docs/27_BRIEFING-FRONTEND.md

@@ -194,6 +194,9 @@ frontend/lib/
 
 ## Workflow Git
 
+Norme projet : **squash merge** (voir [24_DECISIONS-PROJET.md](./24_DECISIONS-PROJET.md) §26).  
+Cible habituelle : `feature/*` → `develop` ; puis `develop` → `master` quand le lot est prêt.
+
 ```bash
 # 1. Créer une branche feature
 git checkout develop
@@ -204,15 +207,22 @@ git checkout -b feature/XX-nom-ticket
 git add .
 git commit -m "feat(#XX): Description courte"
 
-# 3. Pousser et créer PR
+# 3. Pousser et créer PR vers develop
 git push -u origin feature/XX-nom-ticket
 
-# 4. Créer PR vers master via Gitea ou API
+# 4. Créer PR (base = develop)
 curl -X POST \
-  -H "Authorization: token giteabu_1796c6aace0e2ef7e4fdb49cdc3bc1bf8ee31fbc" \
+  -H "Authorization: token $GITEA_TOKEN" \
   -H "Content-Type: application/json" \
-  -d '{"title":"feat(#XX): Titre","body":"Description\n\nCloses #XX","head":"feature/XX-nom-ticket","base":"master"}' \
+  -d '{"title":"feat(#XX): Titre","body":"Description\n\nCloses #XX","head":"feature/XX-nom-ticket","base":"develop"}' \
   "https://git.ptits-pas.fr/api/v1/repos/jmartin/petitspas/pulls"
+
+# 5. Merger en squash (pas merge commit)
+curl -X POST \
+  -H "Authorization: token $GITEA_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"Do":"squash","MergeTitleField":"feat(#XX): Titre","MergeMessageField":"Closes #XX"}' \
+  "https://git.ptits-pas.fr/api/v1/repos/jmartin/petitspas/pulls/{index}/merge"
 ```
 
 ---

frontend/lib/models/couple_garde.dart

@@ -0,0 +1,113 @@
+/// Modèles du couple de garde (enfant ↔ AM) — ticket #167.
+/// Contrat backend #168 : GET /parents/me/couples-garde.
+
+/// Identité minimale d'une personne du couple (enfant, AM ou parent).
+class CoupleMembre {
+  final String id;
+  final String? prenom;
+  final String? nom;
+  final String? photoUrl;
+
+  const CoupleMembre({
+    required this.id,
+    this.prenom,
+    this.nom,
+    this.photoUrl,
+  });
+
+  /// Nom d'affichage : prénom seul si dispo, sinon « Prénom Nom », sinon repli.
+  String displayName({String fallback = ''}) {
+    final p = (prenom ?? '').trim();
+    final n = (nom ?? '').trim();
+    if (p.isNotEmpty && n.isNotEmpty) return '$p $n';
+    if (p.isNotEmpty) return p;
+    if (n.isNotEmpty) return n;
+    return fallback;
+  }
+
+  factory CoupleMembre.fromJson(Map<String, dynamic> json) {
+    return CoupleMembre(
+      id: (json['id'] ?? '').toString(),
+      prenom: json['prenom']?.toString(),
+      nom: json['nom']?.toString(),
+      photoUrl: json['photo_url']?.toString(),
+    );
+  }
+}
+
+/// Un couple de garde = placement actif enfant ↔ AM.
+class CoupleGarde {
+  final String id;
+  final CoupleMembre enfant;
+  final CoupleMembre am;
+  final bool courant;
+
+  const CoupleGarde({
+    required this.id,
+    required this.enfant,
+    required this.am,
+    this.courant = false,
+  });
+
+  factory CoupleGarde.fromJson(Map<String, dynamic> json) {
+    return CoupleGarde(
+      id: (json['id'] ?? '').toString(),
+      enfant: CoupleMembre.fromJson(
+        Map<String, dynamic>.from(json['enfant'] ?? const {}),
+      ),
+      am: CoupleMembre.fromJson(
+        Map<String, dynamic>.from(json['am'] ?? const {}),
+      ),
+      courant: json['courant'] == true,
+    );
+  }
+
+  CoupleGarde copyWith({bool? courant}) {
+    return CoupleGarde(
+      id: id,
+      enfant: enfant,
+      am: am,
+      courant: courant ?? this.courant,
+    );
+  }
+}
+
+/// Réponse de l'API couples de garde (liste + id du couple courant).
+class CouplesGardeResponse {
+  final List<CoupleGarde> couples;
+  final String? coupleCourantId;
+
+  const CouplesGardeResponse({
+    required this.couples,
+    this.coupleCourantId,
+  });
+
+  bool get isEmpty => couples.isEmpty;
+  bool get isUnique => couples.length == 1;
+
+  /// Couple courant : celui marqué `courant`, sinon celui de [coupleCourantId],
+  /// sinon le premier (repli implicite côté client, prévu par le back).
+  CoupleGarde? get coupleCourant {
+    if (couples.isEmpty) return null;
+    for (final c in couples) {
+      if (c.courant) return c;
+    }
+    if (coupleCourantId != null) {
+      for (final c in couples) {
+        if (c.id == coupleCourantId) return c;
+      }
+    }
+    return couples.first;
+  }
+
+  factory CouplesGardeResponse.fromJson(Map<String, dynamic> json) {
+    final list = (json['couples'] as List?) ?? const [];
+    return CouplesGardeResponse(
+      couples: list
+          .whereType<Map>()
+          .map((e) => CoupleGarde.fromJson(Map<String, dynamic>.from(e)))
+          .toList(),
+      coupleCourantId: json['couple_courant_id']?.toString(),
+    );
+  }
+}

frontend/lib/screens/home/parent_screen/ParentDashboardScreen.dart

@@ -1,10 +1,14 @@
 import 'package:flutter/material.dart';
+import 'package:p_tits_pas/models/couple_garde.dart';
 import 'package:p_tits_pas/models/user.dart';
 import 'package:p_tits_pas/services/auth_service.dart';
+import 'package:p_tits_pas/services/couple_garde_service.dart';
+import 'package:p_tits_pas/widgets/quotidien/couple_selector_bandeau.dart';
 import 'package:p_tits_pas/widgets/quotidien/quotidien_shell.dart';
 import 'package:p_tits_pas/widgets/quotidien/quotidien_theme.dart';
 
 /// Tableau de bord parent — coquille 3 colonnes quotidien (#166).
+/// Colonne gauche : sélecteur de couple enfant–nounou (#167).
 /// Métier cartes / blog / messagerie : tickets C/D/E.
 class ParentDashboardScreen extends StatefulWidget {
   const ParentDashboardScreen({super.key});
@@ -17,10 +21,16 @@ class _ParentDashboardScreenState extends State<ParentDashboardScreen> {
   QuotidienNavSection _section = QuotidienNavSection.liaison;
   AppUser? _user;
 
+  List<CoupleGarde> _couples = const [];
+  String? _selectedCoupleId;
+  bool _couplesLoading = true;
+  String? _couplesError;
+
   @override
   void initState() {
     super.initState();
     _loadUser();
+    _loadCouples();
   }
 
   Future<void> _loadUser() async {
@@ -28,6 +38,52 @@ class _ParentDashboardScreenState extends State<ParentDashboardScreen> {
     if (mounted) setState(() => _user = user);
   }
 
+  Future<void> _loadCouples() async {
+    setState(() {
+      _couplesLoading = true;
+      _couplesError = null;
+    });
+    try {
+      final res = await CoupleGardeService.getCouplesGarde();
+      if (!mounted) return;
+      setState(() {
+        _couples = res.couples;
+        _selectedCoupleId = res.coupleCourant?.id;
+        _couplesLoading = false;
+      });
+    } catch (e) {
+      if (!mounted) return;
+      setState(() {
+        _couplesError = e.toString().replaceFirst('Exception: ', '');
+        _couplesLoading = false;
+      });
+    }
+  }
+
+  Future<void> _selectCouple(CoupleGarde couple) async {
+    if (couple.id == _selectedCoupleId) return;
+    // Optimiste : on bascule tout de suite, l'API persiste ensuite.
+    setState(() => _selectedCoupleId = couple.id);
+    try {
+      final res = await CoupleGardeService.definirCoupleCourant(couple.id);
+      if (!mounted) return;
+      setState(() {
+        _couples = res.couples;
+        _selectedCoupleId = res.coupleCourant?.id ?? couple.id;
+      });
+    } catch (e) {
+      if (!mounted) return;
+      ScaffoldMessenger.of(context).showSnackBar(
+        SnackBar(
+          content: Text(
+            'Impossible de changer de garde : '
+            '${e.toString().replaceFirst('Exception: ', '')}',
+          ),
+        ),
+      );
+    }
+  }
+
   String get _displayName {
     final n = _user?.fullName.trim() ?? '';
     if (n.isNotEmpty) return n;
@@ -52,11 +108,13 @@ class _ParentDashboardScreenState extends State<ParentDashboardScreen> {
       onProfileTap: () => _soon('Profil'),
       onSearchAmTap: () => _soon('Recherche AM'),
       onSettingsTap: () => _soon('Paramètres'),
-      leftColumn: const QuotidienColumnPlaceholder(
-        title: 'Cartes',
-        subtitle:
-            'Couple enfant–nounou et flux de cartes\n(à brancher — tickets #167 / #173).',
-        icon: Icons.style_outlined,
+      leftColumn: _LeftColumn(
+        couples: _couples,
+        selectedCoupleId: _selectedCoupleId,
+        loading: _couplesLoading,
+        error: _couplesError,
+        onRetry: _loadCouples,
+        onCoupleSelected: _selectCouple,
       ),
       centerColumn: const QuotidienColumnPlaceholder(
         title: 'Blog',
@@ -81,3 +139,51 @@ class _ParentDashboardScreenState extends State<ParentDashboardScreen> {
     );
   }
 }
+
+/// Colonne gauche : bandeau couple (#167) puis flux de cartes (#173 à venir).
+class _LeftColumn extends StatelessWidget {
+  final List<CoupleGarde> couples;
+  final String? selectedCoupleId;
+  final bool loading;
+  final String? error;
+  final VoidCallback onRetry;
+  final ValueChanged<CoupleGarde> onCoupleSelected;
+
+  const _LeftColumn({
+    required this.couples,
+    required this.selectedCoupleId,
+    required this.loading,
+    required this.error,
+    required this.onRetry,
+    required this.onCoupleSelected,
+  });
+
+  @override
+  Widget build(BuildContext context) {
+    return Padding(
+      padding: const EdgeInsets.all(14),
+      child: Column(
+        crossAxisAlignment: CrossAxisAlignment.stretch,
+        children: [
+          CoupleSelectorBandeau(
+            couples: couples,
+            selectedCoupleId: selectedCoupleId,
+            loading: loading,
+            errorMessage: error,
+            onRetry: onRetry,
+            onCoupleSelected: onCoupleSelected,
+          ),
+          const SizedBox(height: 14),
+          const Expanded(
+            child: QuotidienColumnPlaceholder(
+              title: 'Cartes',
+              subtitle:
+                  'Absences, congés AM, sorties à valider\n(à brancher — ticket #173).',
+              icon: Icons.style_outlined,
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+}

frontend/lib/services/api/api_config.dart

@@ -62,6 +62,10 @@ class ApiConfig {
   static const String parents = '/parents';
   /// Création dossier famille actif par le staff (#129) — body type register parent.
   static const String parentsDossier = '/parents/dossier';
+  /// Couples de garde du parent connecté (#167 / #168).
+  static const String parentsCouplesGarde = '/parents/me/couples-garde';
+  static const String parentsCoupleGardeCourant =
+      '/parents/me/couples-garde/courant';
   static const String assistantesMaternelles = '/assistantes-maternelles';
   /// Création dossier AM actif par le staff (#156) — body type register AM.
   static const String assistantesMaternellesDossier =

frontend/lib/services/couple_garde_service.dart

@@ -0,0 +1,76 @@
+import 'dart:convert';
+
+import 'package:http/http.dart' as http;
+import 'package:p_tits_pas/models/couple_garde.dart';
+import 'package:p_tits_pas/services/api/api_config.dart';
+import 'package:p_tits_pas/services/api/tokenService.dart';
+
+/// Accès API aux couples de garde du parent connecté — tickets #167 / #168.
+/// - GET  /parents/me/couples-garde
+/// - PUT  /parents/me/couples-garde/courant  { couple_id }
+class CoupleGardeService {
+  static Future<Map<String, String>> _headers() async {
+    final token = await TokenService.getToken();
+    return token != null
+        ? ApiConfig.authHeaders(token)
+        : Map<String, String>.from(ApiConfig.headers);
+  }
+
+  static String _extractError(String body, String fallback) {
+    try {
+      final decoded = jsonDecode(body);
+      if (decoded is Map<String, dynamic>) {
+        final message = decoded['message'];
+        if (message is String && message.trim().isNotEmpty) {
+          return message;
+        }
+        if (message is Map && message['message'] is String) {
+          return message['message'] as String;
+        }
+      }
+    } catch (_) {}
+    return fallback;
+  }
+
+  /// Liste les couples de garde et le couple courant du parent connecté.
+  static Future<CouplesGardeResponse> getCouplesGarde() async {
+    final response = await http.get(
+      Uri.parse('${ApiConfig.baseUrl}${ApiConfig.parentsCouplesGarde}'),
+      headers: await _headers(),
+    );
+
+    if (response.statusCode != 200) {
+      throw Exception(
+        _extractError(response.body, 'Erreur chargement des couples de garde'),
+      );
+    }
+
+    final decoded = jsonDecode(response.body);
+    return CouplesGardeResponse.fromJson(
+      Map<String, dynamic>.from(decoded as Map),
+    );
+  }
+
+  /// Persiste le couple courant (préférence utilisateur) et renvoie la liste
+  /// à jour.
+  static Future<CouplesGardeResponse> definirCoupleCourant(
+    String coupleId,
+  ) async {
+    final response = await http.put(
+      Uri.parse('${ApiConfig.baseUrl}${ApiConfig.parentsCoupleGardeCourant}'),
+      headers: await _headers(),
+      body: jsonEncode({'couple_id': coupleId}),
+    );
+
+    if (response.statusCode != 200) {
+      throw Exception(
+        _extractError(response.body, 'Erreur sélection du couple de garde'),
+      );
+    }
+
+    final decoded = jsonDecode(response.body);
+    return CouplesGardeResponse.fromJson(
+      Map<String, dynamic>.from(decoded as Map),
+    );
+  }
+}

frontend/lib/widgets/quotidien/couple_selector_bandeau.dart

@@ -0,0 +1,380 @@
+import 'package:flutter/material.dart';
+import 'package:google_fonts/google_fonts.dart';
+import 'package:p_tits_pas/models/couple_garde.dart';
+import 'package:p_tits_pas/services/api/api_config.dart';
+import 'package:p_tits_pas/widgets/common/auth_network_image.dart';
+import 'package:p_tits_pas/widgets/quotidien/quotidien_theme.dart';
+
+/// Rôle qui consulte le bandeau : côté parent (enfant | nounou) ou côté AM
+/// (enfant | parent(s)). Le composant est le même, seule la lecture change.
+/// Ticket #167 (parent) ; #170 réutilise en mode AM.
+enum CoupleBandeauMode { parent, assistanteMaternelle }
+
+/// Bandeau « couple de garde » en haut de la colonne gauche du TdB.
+///
+/// - Plusieurs couples → contrôle unique avec chevron (dropdown de bascule).
+/// - Un seul couple → affichage informatif (pas de chevron, pas de menu).
+/// - Aucun couple → état vide discret.
+class CoupleSelectorBandeau extends StatelessWidget {
+  final CoupleBandeauMode mode;
+  final List<CoupleGarde> couples;
+  final String? selectedCoupleId;
+  final ValueChanged<CoupleGarde>? onCoupleSelected;
+  final bool loading;
+  final String? errorMessage;
+  final VoidCallback? onRetry;
+
+  const CoupleSelectorBandeau({
+    super.key,
+    this.mode = CoupleBandeauMode.parent,
+    required this.couples,
+    this.selectedCoupleId,
+    this.onCoupleSelected,
+    this.loading = false,
+    this.errorMessage,
+    this.onRetry,
+  });
+
+  CoupleGarde? get _selected {
+    if (couples.isEmpty) return null;
+    if (selectedCoupleId != null) {
+      for (final c in couples) {
+        if (c.id == selectedCoupleId) return c;
+      }
+    }
+    for (final c in couples) {
+      if (c.courant) return c;
+    }
+    return couples.first;
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return LayoutBuilder(builder: (context, constraints) {
+      if (loading) return const _CoupleBandeauSkeleton();
+      if (errorMessage != null) {
+        return _CoupleBandeauError(message: errorMessage!, onRetry: onRetry);
+      }
+      if (couples.isEmpty) return const _CoupleBandeauEmpty();
+
+      final selected = _selected!;
+      final multi = couples.length > 1;
+
+      final card = _CoupleCard(
+        mode: mode,
+        couple: selected,
+        showChevron: multi,
+        colorIndex: couples.indexOf(selected),
+      );
+
+      if (!multi) return card;
+
+      return Theme(
+        data: Theme.of(context).copyWith(
+          hoverColor: Colors.transparent,
+          splashColor: Colors.transparent,
+          highlightColor: Colors.transparent,
+          focusColor: Colors.transparent,
+        ),
+        child: PopupMenuButton<String>(
+          tooltip: 'Changer de garde',
+          // L'offset doit être suffisant pour descendre sous la carte (qui fait 90px).
+          offset: const Offset(0, 95), 
+          color: Colors.transparent, // Le fond devient invisible
+          elevation: 0, // Pas d'ombre carrée
+          constraints: BoxConstraints.tightFor(width: constraints.maxWidth),
+          padding: EdgeInsets.zero,
+          onSelected: (id) {
+            final chosen = couples.firstWhere((c) => c.id == id);
+            onCoupleSelected?.call(chosen);
+          },
+          itemBuilder: (context) => [
+            for (final c in couples)
+              if (c.id != selected.id)
+                PopupMenuItem<String>(
+                  value: c.id,
+                  padding: EdgeInsets.zero,
+                  height: 100, // Hauteur de la carte (90) + un peu de marge (10)
+                  child: Padding(
+                    padding: const EdgeInsets.only(bottom: 10),
+                    child: _CoupleCard(
+                      mode: mode,
+                      couple: c,
+                      showChevron: false,
+                      selected: false,
+                      isMenuItem: true,
+                      colorIndex: couples.indexOf(c),
+                    ),
+                  ),
+                ),
+          ],
+          child: card,
+        ),
+      );
+    });
+  }
+}
+
+/// Carte principale : enfant à gauche, séparateur, AM/parents à droite.
+class _CoupleCard extends StatelessWidget {
+  final CoupleBandeauMode mode;
+  final CoupleGarde couple;
+  final bool showChevron;
+  final bool selected;
+  final bool isMenuItem;
+  final int colorIndex;
+
+  const _CoupleCard({
+    required this.mode,
+    required this.couple,
+    required this.showChevron,
+    this.selected = true,
+    this.isMenuItem = false,
+    required this.colorIndex,
+  });
+
+  @override
+  Widget build(BuildContext context) {
+    return Container(
+      height: 90,
+      decoration: BoxDecoration(
+        image: DecorationImage(
+          image: AssetImage(QuotidienTheme.bandeauColors[colorIndex % QuotidienTheme.bandeauColors.length]), 
+          fit: BoxFit.fill,
+        ),
+      ),
+      padding: const EdgeInsets.symmetric(horizontal: 24),
+      child: Row(
+        children: [
+          Expanded(
+            child: Padding(
+              padding: const EdgeInsets.only(right: 12),
+              child: _MembreTile(
+                photoUrl: couple.enfant.photoUrl,
+                name: (couple.enfant.prenom != null && couple.enfant.prenom!.isNotEmpty)
+                    ? couple.enfant.prenom!
+                    : couple.enfant.displayName(fallback: 'Enfant'),
+                fallbackIcon: Icons.child_care,
+              ),
+            ),
+          ),
+          Container(
+            width: 8,
+            height: 44,
+            decoration: const BoxDecoration(
+              image: DecorationImage(
+                image: AssetImage(QuotidienTheme.pencilLineVerticalAsset),
+                fit: BoxFit.contain,
+              ),
+            ),
+          ),
+          Expanded(
+            child: Padding(
+              padding: const EdgeInsets.only(left: 12),
+              child: _MembreTile(
+                photoUrl: couple.am.photoUrl,
+                name: (couple.am.prenom != null && couple.am.prenom!.isNotEmpty)
+                    ? couple.am.prenom!
+                    : couple.am.displayName(
+                        fallback: mode == CoupleBandeauMode.parent
+                            ? 'Nounou'
+                            : 'Parent',
+                      ),
+                fallbackIcon: mode == CoupleBandeauMode.parent
+                    ? Icons.volunteer_activism
+                    : Icons.person_outline,
+              ),
+            ),
+          ),
+          SizedBox(
+            width: 28,
+            child: showChevron 
+              ? const Icon(
+                  Icons.keyboard_arrow_down,
+                  color: QuotidienTheme.ink,
+                )
+              : null,
+          ),
+        ],
+      ),
+    );
+  }
+}
+
+/// Photo ronde + nom (une moitié du couple).
+class _MembreTile extends StatelessWidget {
+  final String? photoUrl;
+  final String name;
+  final IconData fallbackIcon;
+
+  const _MembreTile({
+    required this.photoUrl,
+    required this.name,
+    required this.fallbackIcon,
+  });
+
+  @override
+  Widget build(BuildContext context) {
+    return Row(
+      children: [
+        _Avatar(photoUrl: photoUrl, fallbackIcon: fallbackIcon, size: 64),
+        const SizedBox(width: 12),
+        Expanded(
+          child: Text(
+            name,
+            maxLines: 1,
+            overflow: TextOverflow.ellipsis,
+            style: GoogleFonts.merienda(
+              fontSize: 22,
+              fontWeight: FontWeight.bold,
+              color: QuotidienTheme.ink,
+            ),
+          ),
+        ),
+      ],
+    );
+  }
+}
+
+class _Avatar extends StatelessWidget {
+  final String? photoUrl;
+  final IconData fallbackIcon;
+  final double size;
+
+  const _Avatar({
+    required this.photoUrl,
+    required this.fallbackIcon,
+    required this.size,
+  });
+
+  @override
+  Widget build(BuildContext context) {
+    final url = ApiConfig.absoluteMediaUrl(photoUrl);
+    final placeholder = Container(
+      width: size,
+      height: size,
+      color: QuotidienTheme.lavender.withValues(alpha: 0.35),
+      child: Icon(fallbackIcon, size: size * 0.5, color: QuotidienTheme.ink),
+    );
+    return ClipOval(
+      child: SizedBox(
+        width: size,
+        height: size,
+        child: url.isEmpty
+            ? placeholder
+            : AuthNetworkImage(
+                url: url,
+                width: size,
+                height: size,
+                fit: BoxFit.cover,
+                errorBuilder: (_, __, ___) => placeholder,
+              ),
+      ),
+    );
+  }
+}
+
+class _CoupleBandeauSkeleton extends StatelessWidget {
+  const _CoupleBandeauSkeleton();
+
+  @override
+  Widget build(BuildContext context) {
+    return Container(
+      height: 90,
+      decoration: BoxDecoration(
+        image: DecorationImage(
+          image: const AssetImage(QuotidienTheme.bandeauLime), // Un asset existant
+          fit: BoxFit.fill,
+          colorFilter: ColorFilter.mode(
+            Colors.white.withValues(alpha: 0.5),
+            BlendMode.lighten,
+          ),
+        ),
+      ),
+      alignment: Alignment.center,
+      child: const SizedBox(
+        width: 26,
+        height: 26,
+        child: CircularProgressIndicator(strokeWidth: 2),
+      ),
+    );
+  }
+}
+
+class _CoupleBandeauEmpty extends StatelessWidget {
+  const _CoupleBandeauEmpty();
+
+  @override
+  Widget build(BuildContext context) {
+    return Container(
+      height: 90,
+      decoration: const BoxDecoration(
+        image: DecorationImage(
+          image: AssetImage(QuotidienTheme.bandeauLime), // Un asset existant par défaut
+          fit: BoxFit.fill,
+        ),
+      ),
+      padding: const EdgeInsets.symmetric(horizontal: 24),
+      child: Row(
+        children: [
+          const Icon(Icons.info_outline, color: QuotidienTheme.muted),
+          const SizedBox(width: 12),
+          Expanded(
+            child: Text(
+              'Aucune garde active pour le moment.',
+              style: GoogleFonts.merriweather(
+                fontSize: 14,
+                color: QuotidienTheme.muted,
+              ),
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+}
+
+class _CoupleBandeauError extends StatelessWidget {
+  final String message;
+  final VoidCallback? onRetry;
+
+  const _CoupleBandeauError({required this.message, this.onRetry});
+
+  @override
+  Widget build(BuildContext context) {
+    return Container(
+      height: 90,
+      decoration: BoxDecoration(
+        image: DecorationImage(
+          image: const AssetImage(QuotidienTheme.bandeauLime), // Un asset existant
+          fit: BoxFit.fill,
+          colorFilter: ColorFilter.mode(
+            QuotidienTheme.coral.withValues(alpha: 0.3),
+            BlendMode.srcATop,
+          ),
+        ),
+      ),
+      padding: const EdgeInsets.symmetric(horizontal: 24),
+      child: Row(
+        children: [
+          const Icon(Icons.error_outline, color: QuotidienTheme.ink),
+          const SizedBox(width: 12),
+          Expanded(
+            child: Text(
+              message,
+              style: GoogleFonts.merriweather(
+                fontSize: 13,
+                color: QuotidienTheme.ink,
+              ),
+            ),
+          ),
+          if (onRetry != null)
+            TextButton(
+              onPressed: onRetry,
+              child: const Text('Réessayer'),
+            ),
+        ],
+      ),
+    );
+  }
+}

frontend/lib/widgets/quotidien/quotidien_theme.dart

@@ -19,6 +19,29 @@ abstract final class QuotidienTheme {
   /// couleur charte par section ; l'inactive est la même, plus transparente.
   static const double pillInactiveOpacity = 0.45;
   static const String pillIvoryAsset = 'assets/images/bg_ivoire_pill.png';
+  static const String pillBlueAsset = 'assets/images/bg_blue_pill.png';
+  
+  // Bandeaux pour les couples (ratio 10:1, dessinés au crayon, couleur dynamique)
+  static const String bandeauLime = 'assets/images/bandeau_lime.png';
+  static const String bandeauBlue = 'assets/images/bandeau_blue.png';
+  static const String bandeauPeach = 'assets/images/bandeau_peach.png';
+  static const String bandeauYellow = 'assets/images/bandeau_yellow.png';
+  static const String bandeauLavender = 'assets/images/bandeau_lavender.png';
+
+  static const List<String> bandeauColors = [
+    bandeauLime,
+    bandeauBlue,
+    bandeauPeach,
+    bandeauYellow,
+    bandeauLavender,
+  ];
+
+  /// Retourne un asset bandeau fixe pour un couple donné (basé sur son ID)
+  static String bandeauAssetForCouple(String coupleId) {
+    if (coupleId.isEmpty) return bandeauLime;
+    final hash = coupleId.hashCode.abs();
+    return bandeauColors[hash % bandeauColors.length];
+  }
   static const String pillYellowAsset = 'assets/images/bg_yellow_pill.png';
   static const String pillPeachAsset = 'assets/images/bg_peach_pill.png';
   static const String pillTurquoiseAsset =