docs(#117): CDC V1.4 (users à jour, reste conservé) + SRS utilisateurs.

- CDC complet conservé ; sections gestion utilisateurs / dossiers alignées v0.1.0
- Archive V1.3 + EVOLUTIONS_CDC ; nouvelle 12_SRS-GESTION-UTILISATEURS
- INDEX / versions / bilan mis à jour

Co-authored-by: Cursor <cursoragent@cursor.com>

backend/package.json

@@ -89,6 +89,9 @@
     "transform": {
       "^.+\\.(t|j)s$": "ts-jest"
     },
+    "moduleNameMapper": {
+      "^src/(.*)$": "<rootDir>/$1"
+    },
     "collectCoverageFrom": [
       "**/*.(t|j)s"
     ],

backend/prisma/schema.prisma

@@ -33,7 +33,6 @@ model Child {
   dateOfBirth   DateTime
   photoUrl      String?
   photoConsent  Boolean   @default(false)
-  isMultiple    Boolean   @default(false)
   isUnborn      Boolean   @default(false)
   parentId      String
   parent        Parent    @relation(fields: [parentId], references: [id])

backend/scripts/create-gitea-issue-gestionnaire-self-delete.js

@@ -0,0 +1,111 @@
+/**
+ * Crée l'issue Gitea — gestionnaire ne doit pas pouvoir se supprimer.
+ * Usage: node backend/scripts/create-gitea-issue-gestionnaire-self-delete.js
+ */
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+
+const repoRoot = path.join(__dirname, '../..');
+const MILESTONE_0_1_0 = 10;
+
+let token = process.env.GITEA_TOKEN;
+if (!token) {
+  try {
+    const tokenFile = path.join(repoRoot, '.gitea-token');
+    if (fs.existsSync(tokenFile)) token = fs.readFileSync(tokenFile, 'utf8').trim();
+  } catch (_) {}
+}
+if (!token) {
+  try {
+    const briefing = fs.readFileSync(
+      path.join(repoRoot, 'docs/27_BRIEFING-FRONTEND.md'),
+      'utf8',
+    );
+    const m = briefing.match(/Token:\s*(gitebu_[a-f0-9]+)/);
+    if (m) token = m[1].trim();
+  } catch (_) {}
+}
+if (!token) {
+  console.error('Token non trouvé : .gitea-token ou GITEA_TOKEN');
+  process.exit(1);
+}
+
+const body = `## Contexte
+
+Quand un **gestionnaire** connecté ouvre sa propre fiche dans l'onglet **Gestionnaires** (Gestion des utilisateurs), la modale **Modifier un "Gestionnaire"** affiche le bouton **Supprimer**.
+
+Comportement actuel : le gestionnaire voit et peut tenter de supprimer son propre compte.
+
+## Comportement attendu
+
+Comme pour le **super administrateur** (bouton Supprimer masqué sur la fiche super admin) :
+
+- **Pas de bouton Supprimer** quand l'utilisateur édite **sa propre fiche**
+- **Modification** des informations (prénom, nom, email, téléphone, relais, mot de passe) **toujours autorisée**
+
+## Périmètre
+
+- Frontend : \`AdminUserFormDialog\` (\`gestionnaires_create.dart\`)
+- Comparer \`initialUser.id\` avec l'utilisateur connecté (\`AuthService.getCurrentUser\`)
+- Masquer Supprimer si édition de soi-même ; conserver garde existante super admin
+
+## Critères d'acceptation
+
+- [ ] Gestionnaire connecté → ouvre sa fiche → **pas** de bouton Supprimer
+- [ ] Gestionnaire connecté → peut **Modifier** ses informations
+- [ ] Super admin / admin → peut toujours supprimer **un autre** gestionnaire (si droits API)
+- [ ] Pas de régression sur fiche super administrateur (Supprimer toujours masqué)
+
+## Fichiers clés
+
+- \`frontend/lib/screens/administrateurs/creation/gestionnaires_create.dart\`
+- \`frontend/lib/widgets/admin/gestionnaire_management_widget.dart\`
+
+## Milestone
+
+**0.1.0** — correction UX / sécurité gestion utilisateurs.`;
+
+const payloadClean = JSON.stringify({
+  title: '[Bug] Gestionnaire peut voir Supprimer sur sa propre fiche',
+  body,
+  milestone: MILESTONE_0_1_0,
+});
+
+const opts = {
+  hostname: 'git.ptits-pas.fr',
+  path: '/api/v1/repos/jmartin/petitspas/issues',
+  method: 'POST',
+  headers: {
+    Authorization: 'token ' + token,
+    'Content-Type': 'application/json',
+    'Content-Length': Buffer.byteLength(payloadClean),
+  },
+};
+
+const req = https.request(opts, (res) => {
+  let d = '';
+  res.on('data', (c) => (d += c));
+  res.on('end', () => {
+    try {
+      const o = JSON.parse(d);
+      if (o.number) {
+        console.log('NUMBER:', o.number);
+        console.log('URL:', o.html_url);
+        console.log('MILESTONE:', o.milestone?.title ?? '(aucun)');
+      } else {
+        console.error('Réponse:', d);
+        process.exit(1);
+      }
+    } catch (e) {
+      console.error(d);
+      process.exit(1);
+    }
+  });
+});
+req.on('error', (e) => {
+  console.error(e);
+  process.exit(1);
+});
+req.write(payloadClean);
+req.end();

backend/src/app.module.ts

@@ -18,6 +18,7 @@ import { AppConfigModule } from './modules/config/config.module';
 import { DocumentsLegauxModule } from './modules/documents-legaux';
 import { RelaisModule } from './routes/relais/relais.module';
 import { DossiersModule } from './routes/dossiers/dossiers.module';
+import { SuppressionsModule } from './routes/suppressions/suppressions.module';
 
 @Module({
   imports: [
@@ -57,6 +58,7 @@ import { DossiersModule } from './routes/dossiers/dossiers.module';
     DocumentsLegauxModule,
     RelaisModule,
     DossiersModule,
+    SuppressionsModule,
   ],
   controllers: [AppController],
   providers: [

backend/src/entities/children.entity.ts

@@ -63,9 +63,6 @@ export class Children {
   @Column({ type: 'timestamptz', nullable: true, name: 'date_consentement_photo' })
   consent_photo_at?: Date;
 
-  @Column({ default: false, name: 'est_multiple', type: 'boolean' })
-  is_multiple: boolean;
-
   // Lien via table de jointure enfants_parents
   @OneToMany(() => ParentsChildren, pc => pc.child)
   parentLinks: ParentsChildren[];

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

@@ -1,20 +1,69 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { AssistantesMaternellesController } from './assistantes_maternelles.controller';
 import { AssistantesMaternellesService } from './assistantes_maternelles.service';
+import { AuthService } from '../auth/auth.service';
+import { AuthGuard } from 'src/common/guards/auth.guard';
+import { RolesGuard } from 'src/common/guards/roles.guard';
 
 describe('AssistantesMaternellesController', () => {
   let controller: AssistantesMaternellesController;
+  const authServiceMock = {
+    createAmDossierStaff: jest.fn(),
+  };
+  const amServiceMock = {};
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
       controllers: [AssistantesMaternellesController],
-      providers: [AssistantesMaternellesService],
+      providers: [
-    }).compile();
+        { provide: AssistantesMaternellesService, useValue: amServiceMock },
+        { provide: AuthService, useValue: authServiceMock },
+      ],
+    })
+      .overrideGuard(AuthGuard)
+      .useValue({ canActivate: () => true })
+      .overrideGuard(RolesGuard)
+      .useValue({ canActivate: () => true })
+      .compile();
 
     controller = module.get<AssistantesMaternellesController>(AssistantesMaternellesController);
+    jest.clearAllMocks();
   });
 
   it('should be defined', () => {
     expect(controller).toBeDefined();
   });
+
+  it('createDossier delegates to authService.createAmDossierStaff with CGU accepted', async () => {
+    authServiceMock.createAmDossierStaff.mockResolvedValue({
+      message: 'ok',
+      user_id: 'u1',
+      statut: 'actif',
+      numero_dossier: '2026-000001',
+    });
+
+    const body = {
+      email: 'am.staff@test.fr',
+      prenom: 'Marie',
+      nom: 'TEST',
+      telephone: '0689567890',
+      consentement_photo: false,
+      lieu_naissance_ville: 'Paris',
+      lieu_naissance_pays: 'France',
+      nir: '285017512345678',
+      numero_agrement: 'AGR-TEST-001',
+      capacite_accueil: 3,
+      places_disponibles: 2,
+    };
+
+    const res = await controller.createDossier(body as any);
+    expect(authServiceMock.createAmDossierStaff).toHaveBeenCalledWith(
+      expect.objectContaining({
+        email: body.email,
+        acceptation_cgu: true,
+        acceptation_privacy: true,
+      }),
+    );
+    expect(res.numero_dossier).toBe('2026-000001');
+  });
 });

backend/src/routes/assistantes_maternelles/assistantes_maternelles.controller.ts

@@ -7,6 +7,8 @@ import {
   Param,
   Delete,
   UseGuards,
+  HttpCode,
+  HttpStatus,
 } from '@nestjs/common';
 import { AssistantesMaternellesService } from './assistantes_maternelles.service';
 import { ApiBearerAuth, ApiBody, ApiOperation, ApiParam, ApiResponse, ApiTags } from '@nestjs/swagger';
@@ -16,17 +18,49 @@ import { RoleType, Users } from 'src/entities/users.entity';
 import { CreateAssistanteDto } from '../user/dto/create_assistante.dto';
 import { UpdateAssistanteDto } from '../user/dto/update_assistante.dto';
 import { UpdateAmFicheAdminDto } from './dto/update-am-fiche-admin.dto';
+import { StaffCreateAmDossierDto } from './dto/staff-create-am-dossier.dto';
+import { StaffCreateAmDossierResponseDto } from './dto/staff-create-am-dossier-response.dto';
 import { RolesGuard } from 'src/common/guards/roles.guard';
 import { AuthGuard } from 'src/common/guards/auth.guard';
 import { User } from 'src/common/decorators/user.decorator';
 import { mapAmForApi, mapAmsForApi } from './assistantes_maternelles.mapper';
+import { AuthService } from '../auth/auth.service';
+import { RegisterAMCompletDto } from '../auth/dto/register-am-complet.dto';
 
 @ApiTags("Assistantes Maternelles")
 @ApiBearerAuth('access-token')
 @UseGuards(AuthGuard, RolesGuard)
 @Controller('assistantes-maternelles')
 export class AssistantesMaternellesController {
-  constructor(private readonly assistantesMaternellesService: AssistantesMaternellesService) { }
+  constructor(
+    private readonly assistantesMaternellesService: AssistantesMaternellesService,
+    private readonly authService: AuthService,
+  ) { }
+
+  @Roles(RoleType.SUPER_ADMIN, RoleType.GESTIONNAIRE, RoleType.ADMINISTRATEUR)
+  @Post('dossier')
+  @HttpCode(HttpStatus.CREATED)
+  @ApiOperation({
+    summary: 'Créer un dossier AM complet (staff) — ticket #156',
+    description:
+      'Crée user + fiche AM avec statut actif, n° dossier, et envoie l’e-mail de création de mot de passe. ' +
+      'Ne pas utiliser POST /auth/register/am depuis le dashboard.',
+  })
+  @ApiBody({ type: StaffCreateAmDossierDto })
+  @ApiResponse({ status: 201, type: StaffCreateAmDossierResponseDto })
+  @ApiResponse({ status: 400, description: 'Validation métier / NIR' })
+  @ApiResponse({ status: 403, description: 'Rôle non autorisé' })
+  @ApiResponse({ status: 409, description: 'Email / NIR / agrément déjà pris' })
+  async createDossier(
+    @Body() dto: StaffCreateAmDossierDto,
+  ): Promise<StaffCreateAmDossierResponseDto> {
+    const registerDto = {
+      ...dto,
+      acceptation_cgu: true,
+      acceptation_privacy: true,
+    } as RegisterAMCompletDto;
+    return this.authService.createAmDossierStaff(registerDto);
+  }
 
   @Roles(RoleType.SUPER_ADMIN, RoleType.GESTIONNAIRE)
   @ApiOperation({ summary: 'Créer nounou' })

backend/src/routes/assistantes_maternelles/dto/staff-create-am-dossier-response.dto.ts

@@ -0,0 +1,23 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { StatutUtilisateurType } from 'src/entities/users.entity';
+
+/** Réponse 201 POST /assistantes-maternelles/dossier (#156). */
+export class StaffCreateAmDossierResponseDto {
+  @ApiProperty()
+  message: string;
+
+  @ApiProperty({ format: 'uuid' })
+  user_id: string;
+
+  @ApiProperty({
+    enum: StatutUtilisateurType,
+    example: StatutUtilisateurType.ACTIF,
+  })
+  statut: StatutUtilisateurType;
+
+  @ApiProperty({
+    example: '2026-000042',
+    description: 'Numéro de dossier attribué',
+  })
+  numero_dossier: string;
+}

backend/src/routes/assistantes_maternelles/dto/staff-create-am-dossier.dto.ts

@@ -0,0 +1,29 @@
+import { ApiPropertyOptional, OmitType } from '@nestjs/swagger';
+import { IsBoolean, IsOptional } from 'class-validator';
+import { RegisterAMCompletDto } from 'src/routes/auth/dto/register-am-complet.dto';
+
+/**
+ * Création dossier AM par staff (#156).
+ * Mêmes champs que l'inscription publique, sans CGU/privacy obligatoires
+ * (acceptées côté serveur pour le compte du gestionnaire).
+ */
+export class StaffCreateAmDossierDto extends OmitType(RegisterAMCompletDto, [
+  'acceptation_cgu',
+  'acceptation_privacy',
+] as const) {
+  @ApiPropertyOptional({
+    description: 'Ignoré côté staff (CGU acceptées serveur). Conservé pour compat éventuelle.',
+    default: true,
+  })
+  @IsOptional()
+  @IsBoolean()
+  acceptation_cgu?: boolean;
+
+  @ApiPropertyOptional({
+    description: 'Ignoré côté staff (privacy acceptée serveur).',
+    default: true,
+  })
+  @IsOptional()
+  @IsBoolean()
+  acceptation_privacy?: boolean;
+}

backend/src/routes/auth/auth.module.ts

@@ -29,7 +29,7 @@ import { ParentsChildren } from 'src/entities/parents_children.entity';
       ParentsChildren,
     ]),
     forwardRef(() => UserModule),
-    ParentsModule,
+    forwardRef(() => ParentsModule),
     DossiersModule,
     AppConfigModule,
     MailModule,

backend/src/routes/auth/auth.service.ts

@@ -36,6 +36,7 @@ import { MailService } from 'src/modules/mail/mail.service';
 import { ParentsService } from '../parents/parents.service';
 import { DossiersService } from '../dossiers/dossiers.service';
 import { DossierAmCompletDto } from '../dossiers/dto/dossier-am-complet.dto';
+import { StaffAddCoParentDto } from '../parents/dto/staff-add-co-parent.dto';
 
 @Injectable()
 export class AuthService {
@@ -416,11 +417,20 @@ export class AuthService {
     }
 
     /**
-     * Inscription Parent COMPLÈTE - Workflow CDC 6 étapes en 1 transaction
+     * Cœur partagé création dossier parent (#129).
-     * Gère : Parent 1 + Parent 2 (opt) + Enfants + Présentation + CGU
+     * - public : statut en_attente + mails pending
+     * - staff : statut actif + mails création MDP (pas de mail « dossier en attente »)
      */
-    async inscrireParentComplet(dto: RegisterParentCompletDto) {
+    async createParentDossier(
-        if (!dto.acceptation_cgu || !dto.acceptation_privacy) {
+        dto: RegisterParentCompletDto,
+        options: {
+            statut: StatutUtilisateurType;
+            sendPendingEmail: boolean;
+            sendPasswordSetupEmail: boolean;
+            requireCgu: boolean;
+        },
+    ) {
+        if (options.requireCgu && (!dto.acceptation_cgu || !dto.acceptation_privacy)) {
             throw new BadRequestException('L\'acceptation des CGU et de la politique de confidentialité est obligatoire');
         }
 
@@ -471,7 +481,7 @@ export class AuthService {
                 prenom: dto.prenom,
                 nom: dto.nom,
                 role: RoleType.PARENT,
-                statut: StatutUtilisateurType.EN_ATTENTE,
+                statut: options.statut,
                 telephone: dto.telephone,
                 adresse: dto.adresse,
                 code_postal: dto.code_postal,
@@ -496,7 +506,7 @@ export class AuthService {
                     prenom: dto.co_parent_prenom,
                     nom: dto.co_parent_nom,
                     role: RoleType.PARENT,
-                    statut: StatutUtilisateurType.EN_ATTENTE,
+                    statut: options.statut,
                     telephone: dto.co_parent_telephone,
                     adresse: dto.co_parent_meme_adresse ? dto.adresse : dto.co_parent_adresse,
                     code_postal: dto.co_parent_meme_adresse ? dto.code_postal : dto.co_parent_code_postal,
@@ -552,8 +562,8 @@ export class AuthService {
                     : undefined;
                 enfant.photo_url = urlPhoto || undefined;
                 enfant.status = enfantDto.date_naissance ? StatutEnfantType.SANS_GARDE : StatutEnfantType.A_NAITRE;
-                enfant.consent_photo = false;
+                enfant.consent_photo = !!enfantDto.consent_photo;
-                enfant.is_multiple = enfantDto.grossesse_multiple || false;
+                enfant.consent_photo_at = enfant.consent_photo ? new Date() : null!;
 
                 const enfantEnregistre = await manager.save(Children, enfant);
                 enfantsEnregistres.push(enfantEnregistre);
@@ -611,44 +621,287 @@ export class AuthService {
 
         const numeroDossier = resultat.parent1.numero_dossier ?? '';
 
-        try {
+        if (options.sendPendingEmail) {
-            await this.mailService.sendRegistrationPendingEmail(
+            try {
-                resultat.parent1.email,
-                resultat.parent1.prenom ?? '',
-                resultat.parent1.nom ?? '',
-                numeroDossier,
-            );
-            if (resultat.parent2) {
                 await this.mailService.sendRegistrationPendingEmail(
-                    resultat.parent2.email,
+                    resultat.parent1.email,
-                    resultat.parent2.prenom ?? '',
+                    resultat.parent1.prenom ?? '',
-                    resultat.parent2.nom ?? '',
+                    resultat.parent1.nom ?? '',
                     numeroDossier,
                 );
+                if (resultat.parent2) {
+                    await this.mailService.sendRegistrationPendingEmail(
+                        resultat.parent2.email,
+                        resultat.parent2.prenom ?? '',
+                        resultat.parent2.nom ?? '',
+                        numeroDossier,
+                    );
+                }
+            } catch (err) {
+                this.logger.error(
+                    "[createParentDossier] Échec envoi email d'accusé de réception (inscription conservée)",
+                    err instanceof Error ? err.stack : String(err),
+                );
             }
-        } catch (err) {
-            this.logger.error(
-                "[inscrireParentComplet] Échec envoi email d'accusé de réception (inscription conservée)",
-                err instanceof Error ? err.stack : String(err),
-            );
         }
 
+        if (options.sendPasswordSetupEmail) {
+            try {
+                await this.mailService.sendValidatedAccountPasswordSetupEmail(
+                    {
+                        email: resultat.parent1.email,
+                        prenom: resultat.parent1.prenom ?? '',
+                        nom: resultat.parent1.nom ?? '',
+                        token: resultat.tokenCreationMdp,
+                        numeroDossier,
+                    },
+                    'parent',
+                );
+                if (resultat.parent2 && resultat.tokenCoParent) {
+                    await this.mailService.sendValidatedAccountPasswordSetupEmail(
+                        {
+                            email: resultat.parent2.email,
+                            prenom: resultat.parent2.prenom ?? '',
+                            nom: resultat.parent2.nom ?? '',
+                            token: resultat.tokenCoParent,
+                            numeroDossier,
+                        },
+                        'parent',
+                    );
+                }
+            } catch (err) {
+                this.logger.error(
+                    '[createParentDossier] Échec envoi email création MDP (dossier conservé)',
+                    err instanceof Error ? err.stack : String(err),
+                );
+            }
+        }
+
+        const message = options.sendPasswordSetupEmail
+            ? 'Dossier famille créé et validé. Un e-mail de création de mot de passe a été envoyé.'
+            : 'Inscription réussie. Votre dossier est en attente de validation par un gestionnaire.';
+
         return {
-            message: 'Inscription réussie. Votre dossier est en attente de validation par un gestionnaire.',
+            message,
             parent_id: resultat.parent1.id,
-            co_parent_id: resultat.parent2?.id,
+            parent_user_id: resultat.parent1.id,
+            co_parent_id: resultat.parent2?.id ?? null,
+            co_parent_user_id: resultat.parent2?.id ?? null,
             enfants_ids: resultat.enfants.map(e => e.id),
-            statut: StatutUtilisateurType.EN_ATTENTE,
+            enfant_ids: resultat.enfants.map(e => e.id),
+            statut: options.statut,
             numero_dossier: numeroDossier,
         };
     }
 
     /**
-     * Inscription Assistante Maternelle COMPLÈTE - Un seul endpoint (identité + pro + photo + CGU)
+     * Inscription Parent publique — CDC (statut en_attente + mail pending).
-     * Crée User (role AM) + entrée assistantes_maternelles, token création MDP
      */
-    async inscrireAMComplet(dto: RegisterAMCompletDto) {
+    async inscrireParentComplet(dto: RegisterParentCompletDto) {
-        if (!dto.acceptation_cgu || !dto.acceptation_privacy) {
+        return this.createParentDossier(dto, {
+            statut: StatutUtilisateurType.EN_ATTENTE,
+            sendPendingEmail: true,
+            sendPasswordSetupEmail: false,
+            requireCgu: true,
+        });
+    }
+
+    /**
+     * Création dossier parent par le staff (#129) — actif + mail création MDP.
+     */
+    async createParentDossierStaff(dto: RegisterParentCompletDto) {
+        return this.createParentDossier(dto, {
+            statut: StatutUtilisateurType.ACTIF,
+            sendPendingEmail: false,
+            sendPasswordSetupEmail: true,
+            requireCgu: false,
+        });
+    }
+
+    /**
+     * Ajoute un co-parent à un foyer existant (mono-parent) — ticket #135.
+     * Compte actif + mail création MDP + liens Parents bidirectionnels + enfants du foyer.
+     */
+    async addCoParentStaff(pivotUserId: string, dto: StaffAddCoParentDto) {
+        const pivotParent = await this.parentsRepo.findOne({
+            where: { user_id: pivotUserId },
+            relations: ['user', 'co_parent', 'parentChildren'],
+        });
+        if (!pivotParent?.user) {
+            throw new NotFoundException('Parent introuvable');
+        }
+
+        if (pivotParent.co_parent) {
+            throw new BadRequestException('Ce foyer a déjà un co-parent.');
+        }
+
+        const numeroDossier = pivotParent.numero_dossier?.trim() || pivotParent.user.numero_dossier?.trim();
+        if (!numeroDossier) {
+            throw new BadRequestException("Ce parent n'a pas de numéro de dossier.");
+        }
+
+        const sameDossierCount = await this.parentsRepo.count({
+            where: { numero_dossier: numeroDossier },
+        });
+        if (sameDossierCount >= 2) {
+            throw new BadRequestException('Ce dossier a déjà deux responsables.');
+        }
+
+        const email = dto.email.trim().toLowerCase();
+        if (pivotParent.user.email.trim().toLowerCase() === email) {
+            throw new BadRequestException(
+                "L'email du co-parent doit être différent de celui du parent principal.",
+            );
+        }
+
+        const emailExiste = await this.usersService.findByEmailOrNull(dto.email);
+        if (emailExiste) {
+            throw new ConflictException("L'email du co-parent est déjà utilisé");
+        }
+
+        const memeAdresse = dto.meme_adresse ?? true;
+        if (!memeAdresse) {
+            if (!dto.adresse?.trim() || !dto.ville?.trim() || !dto.code_postal?.trim()) {
+                throw new BadRequestException(
+                    "Adresse, code postal et ville du co-parent sont requis si meme_adresse est faux.",
+                );
+            }
+        }
+
+        const joursExpirationToken = await this.appConfigService.get<number>(
+            'password_reset_token_expiry_days',
+            7,
+        );
+        const tokenCreationMdp = crypto.randomUUID();
+        const dateExpiration = new Date();
+        dateExpiration.setDate(dateExpiration.getDate() + joursExpirationToken);
+
+        let coParent: Users;
+
+        try {
+            coParent = await this.usersRepo.manager.transaction(async (manager) => {
+                const pivotUser = await manager.findOne(Users, {
+                    where: { id: pivotUserId },
+                });
+                if (!pivotUser) {
+                    throw new NotFoundException('Parent introuvable');
+                }
+
+                const pivotEntite = await manager.findOne(Parents, {
+                    where: { user_id: pivotUserId },
+                    relations: ['parentChildren'],
+                });
+                if (!pivotEntite) {
+                    throw new NotFoundException('Parent introuvable');
+                }
+
+                const coUser = manager.create(Users, {
+                    email: dto.email.trim(),
+                    prenom: dto.prenom,
+                    nom: dto.nom,
+                    role: RoleType.PARENT,
+                    statut: StatutUtilisateurType.ACTIF,
+                    telephone: dto.telephone,
+                    adresse: memeAdresse ? pivotUser.adresse : dto.adresse,
+                    code_postal: memeAdresse ? pivotUser.code_postal : dto.code_postal,
+                    ville: memeAdresse ? pivotUser.ville : dto.ville,
+                    token_creation_mdp: tokenCreationMdp,
+                    token_creation_mdp_expire_le: dateExpiration,
+                    numero_dossier: numeroDossier,
+                });
+                const coUserSaved = await manager.save(Users, coUser);
+
+                pivotEntite.co_parent = coUserSaved;
+                pivotEntite.numero_dossier = numeroDossier;
+                await manager.save(Parents, pivotEntite);
+
+                const coEntite = manager.create(Parents, {
+                    user_id: coUserSaved.id,
+                    numero_dossier: numeroDossier,
+                });
+                coEntite.user = coUserSaved;
+                coEntite.co_parent = pivotUser;
+                await manager.save(Parents, coEntite);
+
+                const enfantIds = (pivotEntite.parentChildren ?? [])
+                    .map((pc) => pc.enfantId)
+                    .filter(Boolean);
+                for (const enfantId of enfantIds) {
+                    const existing = await manager.findOne(ParentsChildren, {
+                        where: { parentId: coUserSaved.id, enfantId },
+                    });
+                    if (existing) continue;
+                    await manager.save(
+                        ParentsChildren,
+                        manager.create(ParentsChildren, {
+                            parentId: coUserSaved.id,
+                            enfantId,
+                        }),
+                    );
+                }
+
+                return coUserSaved;
+            });
+        } catch (err) {
+            if (this.isPostgresUniqueViolation(err)) {
+                throw new ConflictException(
+                    'Un compte avec cet email existe déjà (contrainte unique en base).',
+                );
+            }
+            throw err;
+        }
+
+        try {
+            await this.mailService.sendValidatedAccountPasswordSetupEmail(
+                {
+                    email: coParent.email,
+                    prenom: coParent.prenom ?? '',
+                    nom: coParent.nom ?? '',
+                    token: tokenCreationMdp,
+                    numeroDossier,
+                },
+                'parent',
+            );
+        } catch (err) {
+            this.logger.error(
+                '[addCoParentStaff] Échec envoi email création MDP (co-parent conservé)',
+                err instanceof Error ? err.stack : String(err),
+            );
+        }
+
+        return {
+            message:
+                'Co-parent ajouté au foyer. Un e-mail de création de mot de passe a été envoyé.',
+            numero_dossier: numeroDossier,
+            parent_user_id: pivotUserId,
+            co_parent_user_id: coParent.id,
+            statut: StatutUtilisateurType.ACTIF,
+        };
+    }
+
+    /**
+     * Cœur partagé création dossier AM (#156).
+     * - public : statut en_attente + mail pending
+     * - staff : statut actif + mail création MDP
+     */
+    async createAmDossier(
+        dto: RegisterAMCompletDto,
+        options: {
+            statut: StatutUtilisateurType;
+            sendPendingEmail: boolean;
+            sendPasswordSetupEmail: boolean;
+            requireCgu: boolean;
+            logContext?: string;
+        },
+    ): Promise<{
+        message: string;
+        user_id: string;
+        statut: StatutUtilisateurType;
+        numero_dossier: string;
+    }> {
+        const logCtx = options.logContext ?? 'createAmDossier';
+
+        if (options.requireCgu && (!dto.acceptation_cgu || !dto.acceptation_privacy)) {
             throw new BadRequestException(
                 "L'acceptation des CGU et de la politique de confidentialité est obligatoire",
             );
@@ -668,8 +921,7 @@ export class AuthService {
             throw new BadRequestException(nirValidation.error || 'NIR invalide');
         }
         if (nirValidation.warning) {
-            // Warning uniquement : on ne bloque pas (AM souvent étrangères, DOM-TOM, Corse)
+            console.warn(`[${logCtx}] NIR warning:`, nirValidation.warning, 'email=', dto.email);
-            console.warn('[inscrireAMComplet] NIR warning:', nirValidation.warning, 'email=', dto.email);
         }
 
         const existe = await this.usersService.findByEmailOrNull(dto.email);
@@ -720,79 +972,142 @@ export class AuthService {
         let resultat: { user: Users };
         try {
             resultat = await this.usersRepo.manager.transaction(async (manager) => {
-            const { numero: numeroDossier } = await this.numeroDossierService.getNextNumeroDossier(manager);
+                const { numero: numeroDossier } =
+                    await this.numeroDossierService.getNextNumeroDossier(manager);
 
-            const user = manager.create(Users, {
+                const user = manager.create(Users, {
-                email: dto.email,
+                    email: dto.email,
-                prenom: dto.prenom,
+                    prenom: dto.prenom,
-                nom: dto.nom,
+                    nom: dto.nom,
-                role: RoleType.ASSISTANTE_MATERNELLE,
+                    role: RoleType.ASSISTANTE_MATERNELLE,
-                statut: StatutUtilisateurType.EN_ATTENTE,
+                    statut: options.statut,
-                telephone: dto.telephone,
+                    telephone: dto.telephone,
-                adresse: dto.adresse,
+                    adresse: dto.adresse,
-                code_postal: dto.code_postal,
+                    code_postal: dto.code_postal,
-                ville: dto.ville,
+                    ville: dto.ville,
-                token_creation_mdp: tokenCreationMdp,
+                    token_creation_mdp: tokenCreationMdp,
-                token_creation_mdp_expire_le: dateExpiration,
+                    token_creation_mdp_expire_le: dateExpiration,
-                photo_url: urlPhoto ?? undefined,
+                    photo_url: urlPhoto ?? undefined,
-                consentement_photo: dto.consentement_photo,
+                    consentement_photo: dto.consentement_photo,
-                date_consentement_photo: dateConsentementPhoto,
+                    date_consentement_photo: dateConsentementPhoto,
-                date_naissance: dto.date_naissance ? new Date(dto.date_naissance) : undefined,
+                    date_naissance: dto.date_naissance
-                lieu_naissance_ville: dto.lieu_naissance_ville,
+                        ? new Date(dto.date_naissance)
-                lieu_naissance_pays: dto.lieu_naissance_pays,
+                        : undefined,
-                numero_dossier: numeroDossier,
+                    lieu_naissance_ville: dto.lieu_naissance_ville,
+                    lieu_naissance_pays: dto.lieu_naissance_pays,
+                    numero_dossier: numeroDossier,
+                });
+                const userEnregistre = await manager.save(Users, user);
+
+                const amRepo = manager.getRepository(AssistanteMaternelle);
+                const am = amRepo.create({
+                    user_id: userEnregistre.id,
+                    approval_number: dto.numero_agrement,
+                    nir: nirNormalized,
+                    max_children: dto.capacite_accueil,
+                    places_available: dto.places_disponibles,
+                    biography: dto.biographie,
+                    residence_city: dto.ville ?? undefined,
+                    agreement_date: dto.date_agrement
+                        ? new Date(dto.date_agrement)
+                        : undefined,
+                    available: true,
+                    numero_dossier: numeroDossier,
+                });
+                await amRepo.save(am);
+
+                return { user: userEnregistre };
             });
-            const userEnregistre = await manager.save(Users, user);
-
-            const amRepo = manager.getRepository(AssistanteMaternelle);
-            const am = amRepo.create({
-                user_id: userEnregistre.id,
-                approval_number: dto.numero_agrement,
-                nir: nirNormalized,
-                max_children: dto.capacite_accueil,
-                places_available: dto.places_disponibles,
-                biography: dto.biographie,
-                residence_city: dto.ville ?? undefined,
-                agreement_date: dto.date_agrement ? new Date(dto.date_agrement) : undefined,
-                available: true,
-                numero_dossier: numeroDossier,
-            });
-            await amRepo.save(am);
-
-            return { user: userEnregistre };
-        });
         } catch (err) {
             if (this.isPostgresUniqueViolation(err)) {
-                throw new ConflictException('Un compte avec cet email existe déjà (contrainte unique en base).');
+                throw new ConflictException(
+                    'Un compte avec cet email existe déjà (contrainte unique en base).',
+                );
             }
             throw err;
         }
 
         const numeroDossier = resultat.user.numero_dossier ?? '';
 
-        try {
+        if (options.sendPendingEmail) {
-            await this.mailService.sendRegistrationPendingEmail(
+            try {
-                resultat.user.email,
+                await this.mailService.sendRegistrationPendingEmail(
-                resultat.user.prenom ?? '',
+                    resultat.user.email,
-                resultat.user.nom ?? '',
+                    resultat.user.prenom ?? '',
-                numeroDossier,
+                    resultat.user.nom ?? '',
-            );
+                    numeroDossier,
-        } catch (err) {
+                );
-            this.logger.error(
+            } catch (err) {
-                "[inscrireAMComplet] Échec envoi email d'accusé de réception (inscription conservée)",
+                this.logger.error(
-                err instanceof Error ? err.stack : String(err),
+                    `[${logCtx}] Échec envoi email d'accusé de réception (inscription conservée)`,
-            );
+                    err instanceof Error ? err.stack : String(err),
+                );
+            }
         }
 
+        if (options.sendPasswordSetupEmail) {
+            try {
+                await this.mailService.sendValidatedAccountPasswordSetupEmail(
+                    {
+                        email: resultat.user.email,
+                        prenom: resultat.user.prenom ?? '',
+                        nom: resultat.user.nom ?? '',
+                        token: tokenCreationMdp,
+                        numeroDossier,
+                    },
+                    'am',
+                );
+            } catch (err) {
+                this.logger.error(
+                    `[${logCtx}] Échec envoi email création MDP (dossier conservé)`,
+                    err instanceof Error ? err.stack : String(err),
+                );
+            }
+        }
+
+        const message =
+            options.statut === StatutUtilisateurType.ACTIF
+                ? 'Dossier AM créé et validé. Un e-mail de création de mot de passe a été envoyé.'
+                : 'Inscription réussie. Votre dossier est en attente de validation par un gestionnaire.';
+
         return {
-            message:
+            message,
-                'Inscription réussie. Votre dossier est en attente de validation par un gestionnaire.',
             user_id: resultat.user.id,
-            statut: StatutUtilisateurType.EN_ATTENTE,
+            statut: options.statut,
             numero_dossier: numeroDossier,
         };
     }
 
+    /**
+     * Inscription Assistante Maternelle COMPLÈTE - Un seul endpoint (identité + pro + photo + CGU)
+     * Crée User (role AM) + entrée assistantes_maternelles, token création MDP
+     */
+    async inscrireAMComplet(dto: RegisterAMCompletDto) {
+        return this.createAmDossier(dto, {
+            statut: StatutUtilisateurType.EN_ATTENTE,
+            sendPendingEmail: true,
+            sendPasswordSetupEmail: false,
+            requireCgu: true,
+            logContext: 'inscrireAMComplet',
+        });
+    }
+
+    /**
+     * Création dossier AM par staff (#156) — statut actif + e-mail création MDP.
+     */
+    async createAmDossierStaff(dto: RegisterAMCompletDto) {
+        return this.createAmDossier(dto, {
+            statut: StatutUtilisateurType.ACTIF,
+            sendPendingEmail: false,
+            sendPasswordSetupEmail: true,
+            requireCgu: false,
+            logContext: 'createAmDossierStaff',
+        });
+    }
+
+    /**
+     * Sauvegarde une photo depuis base64 vers le système de fichiers
+     */
     /**
      * Sauvegarde une photo depuis base64 vers le système de fichiers
      */
@@ -1071,8 +1386,11 @@ export class AuthService {
                             enfant.status = StatutEnfantType.A_NAITRE;
                         }
                     }
-                    if (enfantDto.grossesse_multiple !== undefined) {
+                    if (enfantDto.consent_photo !== undefined) {
-                        enfant.is_multiple = enfantDto.grossesse_multiple;
+                        enfant.consent_photo = !!enfantDto.consent_photo;
+                        enfant.consent_photo_at = enfant.consent_photo
+                            ? new Date()
+                            : null!;
                     }
 
                     if (enfantDto.photo_base64 && enfantDto.photo_filename) {

backend/src/routes/auth/dto/enfant-inscription.dto.ts

@@ -55,9 +55,13 @@ export class EnfantInscriptionDto {
   @IsString()
   photo_filename?: string;
 
-  @ApiProperty({ example: false, required: false, description: 'Grossesse multiple (jumeaux, triplés, etc.)' })
+  @ApiProperty({
+    example: true,
+    required: false,
+    description: 'Consentement affichage / stockage photo (colonne enfants.consentement_photo)',
+  })
   @IsOptional()
   @IsBoolean()
-  grossesse_multiple?: boolean;
+  consent_photo?: boolean;
 }
 

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

@@ -0,0 +1,85 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { DossiersController } from './dossiers.controller';
+import { DossiersService } from './dossiers.service';
+import { SuppressionService } from '../suppressions/suppression.service';
+import { AuthGuard } from 'src/common/guards/auth.guard';
+import { RolesGuard } from 'src/common/guards/roles.guard';
+import { StatutUtilisateurType } from 'src/entities/users.entity';
+
+describe('DossiersController', () => {
+  let controller: DossiersController;
+  const dossiersServiceMock = {
+    listDossiers: jest.fn(),
+    getDossierByNumero: jest.fn(),
+  };
+  const suppressionServiceMock = {
+    deleteDossier: jest.fn(),
+  };
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [DossiersController],
+      providers: [
+        { provide: DossiersService, useValue: dossiersServiceMock },
+        { provide: SuppressionService, useValue: suppressionServiceMock },
+      ],
+    })
+      .overrideGuard(AuthGuard)
+      .useValue({ canActivate: () => true })
+      .overrideGuard(RolesGuard)
+      .useValue({ canActivate: () => true })
+      .compile();
+
+    controller = module.get<DossiersController>(DossiersController);
+    jest.clearAllMocks();
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+
+  it('list delegates to dossiersService.listDossiers with q', async () => {
+    dossiersServiceMock.listDossiers.mockResolvedValue([
+      {
+        type: 'famille',
+        numero_dossier: '2026-000043',
+        libelle: 'Claire MARTIN',
+        emails: ['claire@test.fr'],
+        user_ids: ['u1'],
+        statut: StatutUtilisateurType.ACTIF,
+        a_valider: false,
+        date_reference: null,
+      },
+    ]);
+
+    const res = await controller.list('martin');
+    expect(dossiersServiceMock.listDossiers).toHaveBeenCalledWith('martin');
+    expect(res).toHaveLength(1);
+    expect(res[0].numero_dossier).toBe('2026-000043');
+  });
+
+  it('getDossier delegates to getDossierByNumero', async () => {
+    dossiersServiceMock.getDossierByNumero.mockResolvedValue({
+      type: 'family',
+      dossier: { numero_dossier: '2026-000001' },
+    });
+    const res = await controller.getDossier('2026-000001');
+    expect(dossiersServiceMock.getDossierByNumero).toHaveBeenCalledWith('2026-000001');
+    expect(res.type).toBe('family');
+  });
+
+  it('remove delegates to suppressionService.deleteDossier', async () => {
+    const user = { id: 'u1', role: 'gestionnaire' } as never;
+    suppressionServiceMock.deleteDossier.mockResolvedValue({
+      type: 'famille',
+      deleted_user_ids: [],
+      deleted_enfant_ids: [],
+      message: 'ok',
+    });
+    await controller.remove('2026-000001', user);
+    expect(suppressionServiceMock.deleteDossier).toHaveBeenCalledWith(
+      '2026-000001',
+      user,
+    );
+  });
+});

backend/src/routes/dossiers/dossiers.controller.ts

@@ -1,17 +1,58 @@
-import { Controller, Get, Param, UseGuards } from '@nestjs/common';
+import {
-import { ApiOperation, ApiParam, ApiResponse, ApiTags } from '@nestjs/swagger';
+  Controller,
+  Delete,
+  Get,
+  Param,
+  Query,
+  UseGuards,
+} from '@nestjs/common';
+import {
+  ApiBearerAuth,
+  ApiOperation,
+  ApiParam,
+  ApiQuery,
+  ApiResponse,
+  ApiTags,
+} from '@nestjs/swagger';
 import { Roles } from 'src/common/decorators/roles.decorator';
-import { RoleType } from 'src/entities/users.entity';
+import { RoleType, Users } from 'src/entities/users.entity';
 import { AuthGuard } from 'src/common/guards/auth.guard';
 import { RolesGuard } from 'src/common/guards/roles.guard';
+import { User } from 'src/common/decorators/user.decorator';
 import { DossiersService } from './dossiers.service';
+import { SuppressionService } from '../suppressions/suppression.service';
 import { DossierUnifieDto } from './dto/dossier-unifie.dto';
+import { DossierListItemDto } from './dto/dossier-list-item.dto';
 
 @ApiTags('Dossiers')
+@ApiBearerAuth('access-token')
 @Controller('dossiers')
 @UseGuards(AuthGuard, RolesGuard)
 export class DossiersController {
-  constructor(private readonly dossiersService: DossiersService) {}
+  constructor(
+    private readonly dossiersService: DossiersService,
+    private readonly suppressionService: SuppressionService,
+  ) {}
+
+  @Get()
+  @Roles(RoleType.SUPER_ADMIN, RoleType.ADMINISTRATEUR, RoleType.GESTIONNAIRE)
+  @ApiOperation({
+    summary: 'Liste unifiée des dossiers (familles + AM) — ticket #153',
+    description:
+      '1 entrée = 1 numero_dossier. Types `famille` | `assistante_maternelle`. ' +
+      'Filtre optionnel `q` (n°, nom, email). Tri : à valider d’abord, puis n° décroissant. ' +
+      '`sans_enfant` (#159) pour dossiers famille sans enfant.',
+  })
+  @ApiQuery({
+    name: 'q',
+    required: false,
+    description: 'Recherche libre : n° dossier, libellé, email…',
+  })
+  @ApiResponse({ status: 200, type: [DossierListItemDto] })
+  @ApiResponse({ status: 403, description: 'Accès refusé' })
+  list(@Query('q') q?: string): Promise<DossierListItemDto[]> {
+    return this.dossiersService.listDossiers(q);
+  }
 
   @Get(':numeroDossier')
   @Roles(RoleType.SUPER_ADMIN, RoleType.ADMINISTRATEUR, RoleType.GESTIONNAIRE)
@@ -23,4 +64,21 @@ export class DossiersController {
   getDossier(@Param('numeroDossier') numeroDossier: string): Promise<DossierUnifieDto> {
     return this.dossiersService.getDossierByNumero(numeroDossier);
   }
+
+  @Delete(':numeroDossier')
+  @Roles(RoleType.SUPER_ADMIN, RoleType.ADMINISTRATEUR, RoleType.GESTIONNAIRE)
+  @ApiOperation({
+    summary: 'Supprimer un dossier (famille ou AM) — #159',
+    description:
+      'Famille : parents + enfants. AM : compte AM + dossier AM (enfants conservés, placements clos).',
+  })
+  @ApiParam({ name: 'numeroDossier', description: 'Numéro de dossier' })
+  @ApiResponse({ status: 200, description: 'Résultat de suppression' })
+  @ApiResponse({ status: 404, description: 'Dossier introuvable' })
+  remove(
+    @Param('numeroDossier') numeroDossier: string,
+    @User() currentUser: Users,
+  ) {
+    return this.suppressionService.deleteDossier(numeroDossier, currentUser);
+  }
 }

backend/src/routes/dossiers/dossiers.module.ts

@@ -5,6 +5,7 @@ import { JwtModule } from '@nestjs/jwt';
 import { Parents } from 'src/entities/parents.entity';
 import { AssistanteMaternelle } from 'src/entities/assistantes_maternelles.entity';
 import { ParentsModule } from '../parents/parents.module';
+import { SuppressionsModule } from '../suppressions/suppressions.module';
 import { DossiersController } from './dossiers.controller';
 import { DossiersService } from './dossiers.service';
 
@@ -12,6 +13,7 @@ import { DossiersService } from './dossiers.service';
   imports: [
     TypeOrmModule.forFeature([Parents, AssistanteMaternelle]),
     ParentsModule,
+    SuppressionsModule,
     JwtModule.registerAsync({
       imports: [ConfigModule],
       useFactory: (config: ConfigService) => ({

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

@@ -0,0 +1,148 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { getRepositoryToken } from '@nestjs/typeorm';
+import { DossiersService } from './dossiers.service';
+import { Parents } from 'src/entities/parents.entity';
+import { AssistanteMaternelle } from 'src/entities/assistantes_maternelles.entity';
+import { ParentsService } from '../parents/parents.service';
+import { SuppressionService } from '../suppressions/suppression.service';
+import { StatutUtilisateurType } from 'src/entities/users.entity';
+
+describe('DossiersService.listDossiers', () => {
+  let service: DossiersService;
+  const parentsQb = {
+    innerJoinAndSelect: jest.fn().mockReturnThis(),
+    leftJoinAndSelect: jest.fn().mockReturnThis(),
+    where: jest.fn().mockReturnThis(),
+    andWhere: jest.fn().mockReturnThis(),
+    getMany: jest.fn(),
+  };
+  const amQb = {
+    innerJoinAndSelect: jest.fn().mockReturnThis(),
+    where: jest.fn().mockReturnThis(),
+    andWhere: jest.fn().mockReturnThis(),
+    getMany: jest.fn(),
+  };
+  const parentsRepo = {
+    createQueryBuilder: jest.fn(() => parentsQb),
+    findOne: jest.fn(),
+  };
+  const amRepo = {
+    createQueryBuilder: jest.fn(() => amQb),
+    findOne: jest.fn(),
+  };
+  const parentsService = {
+    getDossierFamilleByNumero: jest.fn(),
+  };
+  const suppressionService = {
+    countEnfantsForNumero: jest.fn().mockResolvedValue(1),
+  };
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        DossiersService,
+        { provide: getRepositoryToken(Parents), useValue: parentsRepo },
+        { provide: getRepositoryToken(AssistanteMaternelle), useValue: amRepo },
+        { provide: ParentsService, useValue: parentsService },
+        { provide: SuppressionService, useValue: suppressionService },
+      ],
+    }).compile();
+
+    service = module.get(DossiersService);
+    jest.clearAllMocks();
+    parentsRepo.createQueryBuilder.mockReturnValue(parentsQb);
+    amRepo.createQueryBuilder.mockReturnValue(amQb);
+    suppressionService.countEnfantsForNumero.mockResolvedValue(1);
+  });
+
+  it('aggregates famille (pivot+co-parent) and AM, sorts a_valider first', async () => {
+    parentsQb.getMany.mockResolvedValue([
+      {
+        user_id: 'p1',
+        numero_dossier: '2026-000010',
+        user: {
+          id: 'p1',
+          email: 'claire@test.fr',
+          prenom: 'Claire',
+          nom: 'Martin',
+          statut: StatutUtilisateurType.ACTIF,
+          cree_le: new Date('2026-01-01'),
+        },
+        co_parent: {
+          id: 'p2',
+          email: 'thomas@test.fr',
+          prenom: 'Thomas',
+          nom: 'Martin',
+          statut: StatutUtilisateurType.ACTIF,
+          cree_le: new Date('2026-01-02'),
+        },
+      },
+      {
+        user_id: 'p3',
+        numero_dossier: '2026-000020',
+        user: {
+          id: 'p3',
+          email: 'pending@test.fr',
+          prenom: 'Paul',
+          nom: 'Pending',
+          statut: StatutUtilisateurType.EN_ATTENTE,
+          cree_le: new Date('2026-02-01'),
+        },
+        co_parent: undefined,
+      },
+    ]);
+    amQb.getMany.mockResolvedValue([
+      {
+        user_id: 'am1',
+        numero_dossier: '2026-000015',
+        user: {
+          id: 'am1',
+          email: 'am@test.fr',
+          prenom: 'Marie',
+          nom: 'Dupont',
+          statut: StatutUtilisateurType.ACTIF,
+          cree_le: new Date('2026-01-15'),
+        },
+      },
+    ]);
+
+    const list = await service.listDossiers();
+    expect(list).toHaveLength(3);
+    expect(list[0].a_valider).toBe(true);
+    expect(list[0].type).toBe('famille');
+    expect(list[0].numero_dossier).toBe('2026-000020');
+
+    const famille = list.find((i) => i.numero_dossier === '2026-000010')!;
+    expect(famille.type).toBe('famille');
+    expect(famille.user_ids).toEqual(expect.arrayContaining(['p1', 'p2']));
+    expect(famille.emails).toHaveLength(2);
+    expect(famille.libelle).toContain('MARTIN');
+
+    const am = list.find((i) => i.type === 'assistante_maternelle')!;
+    expect(am.numero_dossier).toBe('2026-000015');
+    expect(am.libelle).toContain('Marie');
+  });
+
+  it('filters with q', async () => {
+    parentsQb.getMany.mockResolvedValue([]);
+    amQb.getMany.mockResolvedValue([
+      {
+        user_id: 'am1',
+        numero_dossier: '2026-000015',
+        user: {
+          id: 'am1',
+          email: 'am@test.fr',
+          prenom: 'Marie',
+          nom: 'Dupont',
+          statut: StatutUtilisateurType.ACTIF,
+          cree_le: new Date('2026-01-15'),
+        },
+      },
+    ]);
+
+    const hit = await service.listDossiers('dupont');
+    expect(hit).toHaveLength(1);
+    const miss = await service.listDossiers('zzz');
+    expect(miss).toHaveLength(0);
+  });
+});

backend/src/routes/dossiers/dossiers.service.ts

@@ -3,12 +3,15 @@ import { InjectRepository } from '@nestjs/typeorm';
 import { Repository } from 'typeorm';
 import { Parents } from 'src/entities/parents.entity';
 import { AssistanteMaternelle } from 'src/entities/assistantes_maternelles.entity';
+import { StatutUtilisateurType, Users } from 'src/entities/users.entity';
 import { ParentsService } from '../parents/parents.service';
+import { SuppressionService } from '../suppressions/suppression.service';
 import { DossierUnifieDto } from './dto/dossier-unifie.dto';
 import { DossierAmCompletDto, DossierAmUserDto } from './dto/dossier-am-complet.dto';
+import { DossierListItemDto } from './dto/dossier-list-item.dto';
 
 /**
- * Endpoint unifié GET /dossiers/:numeroDossier – AM ou famille. Ticket #119.
+ * Dossiers unifiés — détail (#119) + liste (#153) + sans_enfant (#159).
  */
 @Injectable()
 export class DossiersService {
@@ -18,8 +21,173 @@ export class DossiersService {
     @InjectRepository(AssistanteMaternelle)
     private readonly amRepository: Repository<AssistanteMaternelle>,
     private readonly parentsService: ParentsService,
+    private readonly suppressionService: SuppressionService,
   ) {}
 
+  /**
+   * Liste unifiée tous dossiers (familles + AM) ayant un numero_dossier.
+   * Ticket #153 — optionnel `q` filtre n° / nom / prénom / email (côté serveur).
+   */
+  async listDossiers(q?: string): Promise<DossierListItemDto[]> {
+    const items: DossierListItemDto[] = [
+      ...(await this.listFamilleItems()),
+      ...(await this.listAmItems()),
+    ];
+
+    const needle = (q ?? '').trim().toLowerCase();
+    const filtered = needle
+      ? items.filter((item) => this.matchesQuery(item, needle))
+      : items;
+
+    filtered.sort((a, b) => {
+      // À valider d'abord, puis n° dossier décroissant
+      if (a.a_valider !== b.a_valider) return a.a_valider ? -1 : 1;
+      return b.numero_dossier.localeCompare(a.numero_dossier, 'fr');
+    });
+
+    for (const item of filtered) {
+      if (item.type === 'famille') {
+        const n = await this.suppressionService.countEnfantsForNumero(
+          item.numero_dossier,
+        );
+        item.sans_enfant = n === 0;
+      } else {
+        item.sans_enfant = false;
+      }
+    }
+
+    return filtered;
+  }
+
+  private async listFamilleItems(): Promise<DossierListItemDto[]> {
+    const parents = await this.parentsRepository
+      .createQueryBuilder('p')
+      .innerJoinAndSelect('p.user', 'u')
+      .leftJoinAndSelect('p.co_parent', 'cp')
+      .where('p.numero_dossier IS NOT NULL')
+      .andWhere("TRIM(p.numero_dossier) <> ''")
+      .getMany();
+
+    const byNum = new Map<string, Parents[]>();
+    for (const p of parents) {
+      const num = (p.numero_dossier ?? '').trim();
+      if (!num) continue;
+      const group = byNum.get(num) ?? [];
+      group.push(p);
+      byNum.set(num, group);
+    }
+
+    const items: DossierListItemDto[] = [];
+    for (const [numero_dossier, group] of byNum) {
+      const usersMap = new Map<string, Users>();
+      for (const p of group) {
+        if (p.user) usersMap.set(p.user.id, p.user);
+        if (p.co_parent) usersMap.set(p.co_parent.id, p.co_parent);
+      }
+      const users = [...usersMap.values()].sort((a, b) => {
+        const an = `${a.nom ?? ''} ${a.prenom ?? ''}`.toLowerCase();
+        const bn = `${b.nom ?? ''} ${b.prenom ?? ''}`.toLowerCase();
+        return an.localeCompare(bn, 'fr') || a.id.localeCompare(b.id);
+      });
+      if (users.length === 0) continue;
+
+      const names = users.map((u) => this.formatPersonName(u)).filter(Boolean);
+      const libelle =
+        names.length === 0
+          ? `Dossier ${numero_dossier}`
+          : names.length === 1
+            ? names[0]
+            : names.join(' & ');
+
+      const emails = users.map((u) => u.email).filter(Boolean);
+      const user_ids = users.map((u) => u.id);
+      const a_valider = users.some((u) => u.statut === StatutUtilisateurType.EN_ATTENTE);
+      const statut = a_valider
+        ? StatutUtilisateurType.EN_ATTENTE
+        : (users[0].statut ?? StatutUtilisateurType.ACTIF);
+      const date_reference = this.minCreeLeIso(users);
+
+      items.push({
+        type: 'famille',
+        numero_dossier,
+        libelle,
+        emails,
+        user_ids,
+        statut,
+        a_valider,
+        date_reference,
+      });
+    }
+    return items;
+  }
+
+  private async listAmItems(): Promise<DossierListItemDto[]> {
+    const ams = await this.amRepository
+      .createQueryBuilder('am')
+      .innerJoinAndSelect('am.user', 'u')
+      .where('am.numero_dossier IS NOT NULL')
+      .andWhere("TRIM(am.numero_dossier) <> ''")
+      .getMany();
+
+    const byNum = new Map<string, AssistanteMaternelle>();
+    for (const am of ams) {
+      const num = (am.numero_dossier ?? '').trim();
+      if (!num || !am.user) continue;
+      // Un n° = une AM ; garder le premier
+      if (!byNum.has(num)) byNum.set(num, am);
+    }
+
+    const items: DossierListItemDto[] = [];
+    for (const [numero_dossier, am] of byNum) {
+      const u = am.user!;
+      const libelle = this.formatPersonName(u) || `AM ${numero_dossier}`;
+      const a_valider = u.statut === StatutUtilisateurType.EN_ATTENTE;
+      items.push({
+        type: 'assistante_maternelle',
+        numero_dossier,
+        libelle,
+        emails: u.email ? [u.email] : [],
+        user_ids: [u.id],
+        statut: u.statut ?? StatutUtilisateurType.ACTIF,
+        a_valider,
+        date_reference: this.minCreeLeIso([u]),
+      });
+    }
+    return items;
+  }
+
+  private matchesQuery(item: DossierListItemDto, needle: string): boolean {
+    const hay = [
+      item.numero_dossier,
+      item.libelle,
+      ...item.emails,
+      item.statut,
+      item.type,
+    ]
+      .join(' ')
+      .toLowerCase();
+    return hay.includes(needle);
+  }
+
+  private formatPersonName(u: Users): string {
+    const prenom = (u.prenom ?? '').trim();
+    const nom = (u.nom ?? '').trim();
+    const nomFmt = nom ? nom.toUpperCase() : '';
+    return [prenom, nomFmt].filter(Boolean).join(' ');
+  }
+
+  private minCreeLeIso(users: Users[]): string | null {
+    let min: Date | null = null;
+    for (const u of users) {
+      const d = u.cree_le;
+      if (!d) continue;
+      const date = d instanceof Date ? d : new Date(d);
+      if (Number.isNaN(date.getTime())) continue;
+      if (!min || date < min) min = date;
+    }
+    return min ? min.toISOString() : null;
+  }
+
   async getDossierByNumero(numeroDossier: string): Promise<DossierUnifieDto> {
     const num = numeroDossier?.trim();
     if (!num) {

backend/src/routes/dossiers/dto/dossier-list-item.dto.ts

@@ -0,0 +1,58 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { StatutUtilisateurType } from 'src/entities/users.entity';
+
+/** Ligne de liste GET /dossiers (#153). */
+export class DossierListItemDto {
+  @ApiProperty({
+    enum: ['famille', 'assistante_maternelle'],
+    description: 'Type de dossier',
+  })
+  type: 'famille' | 'assistante_maternelle';
+
+  @ApiProperty({ example: '2026-000043' })
+  numero_dossier: string;
+
+  @ApiProperty({
+    example: 'Claire MARTIN & Thomas MARTIN',
+    description: 'Libellé affiché (noms)',
+  })
+  libelle: string;
+
+  @ApiProperty({
+    type: [String],
+    example: ['claire@example.com', 'thomas@example.com'],
+  })
+  emails: string[];
+
+  @ApiProperty({
+    type: [String],
+    format: 'uuid',
+    description: 'IDs utilisateur liés au dossier (parents du foyer ou AM)',
+  })
+  user_ids: string[];
+
+  @ApiProperty({
+    enum: StatutUtilisateurType,
+    description:
+      'Statut agrégé : en_attente si au moins un user en_attente, sinon statut du premier',
+  })
+  statut: StatutUtilisateurType;
+
+  @ApiProperty({
+    description: 'True si le dossier est en attente de validation (section haute UI)',
+  })
+  a_valider: boolean;
+
+  @ApiPropertyOptional({
+    nullable: true,
+    example: '2026-01-12T10:00:00.000Z',
+    description: 'Date de référence (MIN cree_le des users du dossier)',
+  })
+  date_reference: string | null;
+
+  @ApiPropertyOptional({
+    description:
+      'True si dossier famille sans enfant lié (#159). Omis ou false pour AM.',
+  })
+  sans_enfant?: boolean;
+}

backend/src/routes/enfants/dto/create_enfants.dto.ts

@@ -1,4 +1,5 @@
-import { ApiProperty } from '@nestjs/swagger';
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { Transform } from 'class-transformer';
 import {
     IsBoolean,
     IsDateString,
@@ -6,11 +7,23 @@ import {
     IsNotEmpty,
     IsOptional,
     IsString,
+    IsUUID,
     MaxLength,
     ValidateIf,
 } from 'class-validator';
 import { GenreType, StatutEnfantType } from 'src/entities/children.entity';
 
+/** Multipart envoie des strings ("true"/"false") — JSON envoie déjà des booleans. */
+function toBoolean({ value }: { value: unknown }): boolean | unknown {
+    if (typeof value === 'boolean') return value;
+    if (typeof value === 'string') {
+        const v = value.trim().toLowerCase();
+        if (v === 'true' || v === '1') return true;
+        if (v === 'false' || v === '0' || v === '') return false;
+    }
+    return value;
+}
+
 export class CreateEnfantsDto {
     @ApiProperty({ enum: StatutEnfantType, example: StatutEnfantType.SANS_GARDE })
     @IsEnum(StatutEnfantType)
@@ -52,6 +65,7 @@ export class CreateEnfantsDto {
     photo_url?: string;
 
     @ApiProperty({ default: false })
+    @Transform(toBoolean)
     @IsBoolean()
     consent_photo: boolean;
 
@@ -60,7 +74,16 @@ export class CreateEnfantsDto {
     @IsDateString()
     consent_photo_at?: string;
 
-    @ApiProperty({ default: false })
+    /**
-    @IsBoolean()
+     * Parent pivot du foyer — obligatoire pour staff (gestionnaire/admin).
-    is_multiple: boolean;
+     * Ignoré / interdit en externe pour un PARENT (ticket #132).
+     */
+    @ApiPropertyOptional({
+        description:
+            'UUID du parent pivot (staff only). Obligatoire pour GESTIONNAIRE / ADMIN / SUPER_ADMIN.',
+        format: 'uuid',
+    })
+    @IsOptional()
+    @IsUUID('4')
+    parent_user_id?: string;
 }

backend/src/routes/enfants/dto/enfants_response.dto.ts

@@ -29,9 +29,6 @@ export class EnfantResponseDto {
   @ApiProperty({ example: false })
   consent_photo: boolean;
 
-  @ApiProperty({ example: false })
-  is_multiple: boolean;
-
   @ApiProperty({ example: 'UUID-parent' })
   parent_id: string;
 }

backend/src/routes/enfants/enfants.controller.ts

@@ -1,20 +1,35 @@
 import {
   Body,
+  CallHandler,
   Controller,
   Delete,
+  ExecutionContext,
   Get,
+  HttpCode,
+  HttpStatus,
+  Injectable,
+  NestInterceptor,
   Param,
   ParseUUIDPipe,
   Patch,
   Post,
+  Query,
+  UploadedFile,
   UseGuards,
   UseInterceptors,
-  UploadedFile,
 } from '@nestjs/common';
 import { FileInterceptor } from '@nestjs/platform-express';
-import { ApiBearerAuth, ApiTags, ApiConsumes } from '@nestjs/swagger';
+import {
+  ApiBearerAuth,
+  ApiBody,
+  ApiConsumes,
+  ApiOperation,
+  ApiQuery,
+  ApiTags,
+} from '@nestjs/swagger';
 import { diskStorage } from 'multer';
 import { extname } from 'path';
+import { Observable } from 'rxjs';
 import { EnfantsService } from './enfants.service';
 import { CreateEnfantsDto } from './dto/create_enfants.dto';
 import { UpdateEnfantsDto } from './dto/update_enfants.dto';
@@ -23,38 +38,80 @@ import { User } from 'src/common/decorators/user.decorator';
 import { AuthGuard } from 'src/common/guards/auth.guard';
 import { Roles } from 'src/common/decorators/roles.decorator';
 import { RolesGuard } from 'src/common/guards/roles.guard';
+import { SuppressionService } from '../suppressions/suppression.service';
+
+const photoMulterOptions = {
+  storage: diskStorage({
+    destination: './uploads/photos',
+    filename: (req, file, cb) => {
+      const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1e9);
+      const ext = extname(file.originalname);
+      cb(null, `enfant-${uniqueSuffix}${ext}`);
+    },
+  }),
+  fileFilter: (req, file, cb) => {
+    if (!file.mimetype.match(/\/(jpg|jpeg|png|gif)$/)) {
+      return cb(new Error('Seules les images sont autorisées'), false);
+    }
+    cb(null, true);
+  },
+  limits: {
+    fileSize: 5 * 1024 * 1024,
+  },
+};
+
+/**
+ * Multer uniquement si Content-Type multipart (parent ou staff + photo).
+ * JSON sans photo (#132) passe sans interceptor fichier.
+ */
+@Injectable()
+class OptionalEnfantPhotoInterceptor implements NestInterceptor {
+  private readonly multipart = new (FileInterceptor(
+    'photo',
+    photoMulterOptions,
+  ))();
+
+  intercept(context: ExecutionContext, next: CallHandler): Observable<unknown> | Promise<Observable<unknown>> {
+    const req = context.switchToHttp().getRequest();
+    const ct = String(req.headers['content-type'] ?? '');
+    if (!ct.includes('multipart/form-data')) {
+      return next.handle();
+    }
+    return this.multipart.intercept(context, next);
+  }
+}
 
 @ApiBearerAuth('access-token')
 @ApiTags('Enfants')
 @UseGuards(AuthGuard, RolesGuard)
 @Controller('enfants')
 export class EnfantsController {
-  constructor(private readonly enfantsService: EnfantsService) { }
+  constructor(
+    private readonly enfantsService: EnfantsService,
+    private readonly suppressionService: SuppressionService,
+  ) { }
 
-  @Roles(RoleType.PARENT)
+  @Roles(
-  @Post()
+    RoleType.PARENT,
-  @ApiConsumes('multipart/form-data')
+    RoleType.GESTIONNAIRE,
-  @UseInterceptors(
+    RoleType.ADMINISTRATEUR,
-    FileInterceptor('photo', {
+    RoleType.SUPER_ADMIN,
-      storage: diskStorage({
-        destination: './uploads/photos',
-        filename: (req, file, cb) => {
-          const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1e9);
-          const ext = extname(file.originalname);
-          cb(null, `enfant-${uniqueSuffix}${ext}`);
-        },
-      }),
-      fileFilter: (req, file, cb) => {
-        if (!file.mimetype.match(/\/(jpg|jpeg|png|gif)$/)) {
-          return cb(new Error('Seules les images sont autorisées'), false);
-        }
-        cb(null, true);
-      },
-      limits: {
-        fileSize: 5 * 1024 * 1024,
-      },
-    }),
   )
+  @Post()
+  @HttpCode(HttpStatus.CREATED)
+  @ApiOperation({
+    summary: 'Créer un enfant',
+    description:
+      'PARENT : multipart éventuel, rattache au compte connecté. ' +
+      'Staff : parent_user_id obligatoire ; JSON sans photo OK ; avec photo → multipart (champ fichier `photo`, max 5 Mo). Ticket #132.',
+  })
+  @ApiConsumes('application/json', 'multipart/form-data')
+  @ApiBody({
+    description:
+      'Champs métier (+ parent_user_id côté staff). Fichier optionnel `photo` en multipart.',
+    type: CreateEnfantsDto,
+  })
+  @UseInterceptors(OptionalEnfantPhotoInterceptor)
   create(
     @Body() dto: CreateEnfantsDto,
     @UploadedFile() photo: Express.Multer.File,
@@ -90,17 +147,47 @@ export class EnfantsController {
     RoleType.GESTIONNAIRE,
   )
   @Patch(':id')
+  @ApiOperation({
+    summary: 'Mettre à jour un enfant',
+    description:
+      'JSON sans photo OK ; avec nouvelle photo → multipart (champ fichier `photo`, max 5 Mo).',
+  })
+  @ApiConsumes('application/json', 'multipart/form-data')
+  @UseInterceptors(OptionalEnfantPhotoInterceptor)
   update(
     @Param('id', new ParseUUIDPipe()) id: string,
     @Body() dto: UpdateEnfantsDto,
+    @UploadedFile() photo: Express.Multer.File,
     @User() currentUser: Users,
   ) {
-    return this.enfantsService.update(id, dto, currentUser);
+    return this.enfantsService.update(id, dto, currentUser, photo);
   }
 
-  @Roles(RoleType.SUPER_ADMIN)
+  @Roles(
+    RoleType.SUPER_ADMIN,
+    RoleType.ADMINISTRATEUR,
+    RoleType.GESTIONNAIRE,
+  )
   @Delete(':id')
-  remove(@Param('id', new ParseUUIDPipe()) id: string) {
+  @ApiOperation({
-    return this.enfantsService.remove(id);
+    summary: 'Supprimer un enfant (#159)',
+    description:
+      'Query `deleteDossier=true` si dernier enfant et suppression du dossier famille souhaitée.',
+  })
+  @ApiQuery({
+    name: 'deleteDossier',
+    required: false,
+    description: 'Si true et dernier enfant : cascade dossier famille',
+  })
+  remove(
+    @Param('id', new ParseUUIDPipe()) id: string,
+    @Query('deleteDossier') deleteDossier: string | undefined,
+    @User() currentUser: Users,
+  ) {
+    const flag =
+      deleteDossier === 'true' ||
+      deleteDossier === '1' ||
+      deleteDossier === 'yes';
+    return this.suppressionService.deleteEnfant(id, flag, currentUser);
   }
 }

backend/src/routes/enfants/enfants.module.ts

@@ -6,13 +6,16 @@ import { Children } from 'src/entities/children.entity';
 import { Parents } from 'src/entities/parents.entity';
 import { ParentsChildren } from 'src/entities/parents_children.entity';
 import { AuthModule } from '../auth/auth.module';
+import { SuppressionsModule } from '../suppressions/suppressions.module';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([Children, Parents, ParentsChildren]),
+  imports: [
-    AuthModule
+    TypeOrmModule.forFeature([Children, Parents, ParentsChildren]),
-
+    AuthModule,
+    SuppressionsModule,
   ],
   controllers: [EnfantsController],
-  providers: [EnfantsService]
+  providers: [EnfantsService],
+  exports: [EnfantsService],
 })
 export class EnfantsModule { }

backend/src/routes/enfants/enfants.service.ts

@@ -13,6 +13,12 @@ import { ParentsChildren } from 'src/entities/parents_children.entity';
 import { RoleType, Users } from 'src/entities/users.entity';
 import { CreateEnfantsDto } from './dto/create_enfants.dto';
 
+const STAFF_ROLES: RoleType[] = [
+  RoleType.GESTIONNAIRE,
+  RoleType.ADMINISTRATEUR,
+  RoleType.SUPER_ADMIN,
+];
+
 @Injectable()
 export class EnfantsService {
   constructor(
@@ -24,20 +30,35 @@ export class EnfantsService {
     private readonly parentsChildrenRepository: Repository<ParentsChildren>,
   ) { }
 
-  // Création d'un enfant
+  private isStaff(user: Users): boolean {
-  async create(dto: CreateEnfantsDto, currentUser: Users, photoFile?: Express.Multer.File): Promise<Children> {
+    return STAFF_ROLES.includes(user.role);
+  }
+
+  /**
+   * Création d'un enfant.
+   * - PARENT : rattache au parent connecté (multipart photo optionnel).
+   * - Staff : `parent_user_id` obligatoire ; JSON sans photo OK ;
+   *   avec photo → multipart (même stockage `/uploads/photos/...`). Ticket #132.
+   */
+  async create(
+    dto: CreateEnfantsDto,
+    currentUser: Users,
+    photoFile?: Express.Multer.File,
+  ): Promise<Children> {
+    const pivotUserId = this.resolvePivotParentUserId(dto, currentUser);
+
     const parent = await this.parentsRepository.findOne({
-      where: { user_id: currentUser.id },
+      where: { user_id: pivotUserId },
       relations: ['co_parent'],
     });
     if (!parent) throw new NotFoundException('Parent introuvable');
 
-    // Vérif métier simple
+    // Vérif métier simple (aligné comportement historique parent)
     if (dto.status !== StatutEnfantType.A_NAITRE && !dto.birth_date) {
       throw new BadRequestException('Un enfant né doit avoir une date de naissance');
     }
 
-    // Vérif doublon éventuel (ex: même prénom + date de naissance pour ce parent)
+    // Vérif doublon éventuel (ex: même prénom + date de naissance)
     const exist = await this.childrenRepository.findOne({
       where: {
         first_name: dto.first_name,
@@ -47,50 +68,107 @@ export class EnfantsService {
     });
     if (exist) throw new ConflictException('Cet enfant existe déjà');
 
-    // Gestion de la photo uploadée
+    // Gestion de la photo uploadée (multipart parent ou staff)
+    let photoUrl = dto.photo_url;
+    let consentAt: Date | undefined;
     if (photoFile) {
-      dto.photo_url = `/uploads/photos/${photoFile.filename}`;
+      photoUrl = `/uploads/photos/${photoFile.filename}`;
       if (dto.consent_photo) {
-        dto.consent_photo_at = new Date().toISOString();
+        consentAt = new Date();
       }
+    } else if (dto.consent_photo) {
+      consentAt = dto.consent_photo_at
+        ? new Date(dto.consent_photo_at)
+        : new Date();
     }
 
-    // Création
+    const child = this.childrenRepository.create({
-    const child = this.childrenRepository.create(dto);
+      status: dto.status,
+      first_name: dto.first_name,
+      last_name: dto.last_name,
+      gender: dto.gender,
+      birth_date: dto.birth_date ? new Date(dto.birth_date) : undefined,
+      due_date: dto.due_date ? new Date(dto.due_date) : undefined,
+      photo_url: photoUrl,
+      consent_photo: !!dto.consent_photo,
+      consent_photo_at: consentAt,
+    });
     await this.childrenRepository.save(child);
 
-    // Lien parent-enfant (Parent 1)
+    // Lien parent-enfant (pivot)
-    const parentLink = this.parentsChildrenRepository.create({
+    await this.parentsChildrenRepository.save(
-      parentId: parent.user_id,
+      this.parentsChildrenRepository.create({
-      enfantId: child.id,
+        parentId: parent.user_id,
-    });
+        enfantId: child.id,
-    await this.parentsChildrenRepository.save(parentLink);
+      }),
+    );
 
     // Rattachement automatique au co-parent s'il existe
     if (parent.co_parent) {
-      const coParentLink = this.parentsChildrenRepository.create({
+      await this.parentsChildrenRepository.save(
-        parentId: parent.co_parent.id,
+        this.parentsChildrenRepository.create({
-        enfantId: child.id,
+          parentId: parent.co_parent.id,
-      });
+          enfantId: child.id,
-      await this.parentsChildrenRepository.save(coParentLink);
+        }),
+      );
     }
 
     return this.findOne(child.id, currentUser);
   }
 
-  // Liste des enfants (admin/gestionnaire)
+  private resolvePivotParentUserId(
-  async findAll(): Promise<Children[]> {
+    dto: CreateEnfantsDto,
-    return this.childrenRepository.find({
+    currentUser: Users,
-      relations: ['parentLinks', 'parentLinks.parent', 'parentLinks.parent.user'],
+  ): string {
-      order: { last_name: 'ASC', first_name: 'ASC' },
+    if (this.isStaff(currentUser)) {
+      const id = dto.parent_user_id?.trim();
+      if (!id) {
+        throw new BadRequestException(
+          'parent_user_id est obligatoire pour créer un enfant (staff)',
+        );
+      }
+      return id;
+    }
+
+    if (currentUser.role === RoleType.PARENT) {
+      if (
+        dto.parent_user_id &&
+        dto.parent_user_id.trim() !== currentUser.id
+      ) {
+        throw new ForbiddenException(
+          'Un parent ne peut pas créer un enfant pour un autre compte',
+        );
+      }
+      return currentUser.id;
+    }
+
+    throw new ForbiddenException('Accès interdit');
+  }
+
+  /** Flag API #157 — true si aucun lien enfants_parents. */
+  private withSansResponsable(child: Children): Children & { sans_responsable: boolean } {
+    return Object.assign(child, {
+      sans_responsable: !child.parentLinks || child.parentLinks.length === 0,
     });
   }
 
+  // Liste des enfants (admin/gestionnaire) — inclut les orphelins (parentLinks: [])
+  async findAll(): Promise<Array<Children & { sans_responsable: boolean }>> {
+    const children = await this.childrenRepository.find({
+      relations: ['parentLinks', 'parentLinks.parent', 'parentLinks.parent.user'],
+      order: { last_name: 'ASC', first_name: 'ASC' },
+    });
+    return children.map((c) => this.withSansResponsable(c));
+  }
+
   // Récupérer un enfant par id
-  async findOne(id: string, currentUser: Users): Promise<Children> {
+  async findOne(
+    id: string,
+    currentUser: Users,
+  ): Promise<Children & { sans_responsable: boolean }> {
     const child = await this.childrenRepository.findOne({
       where: { id },
-      relations: ['parentLinks'],
+      relations: ['parentLinks', 'parentLinks.parent', 'parentLinks.parent.user'],
     });
     if (!child) throw new NotFoundException('Enfant introuvable');
 
@@ -104,23 +182,42 @@ export class EnfantsService {
       case RoleType.ADMINISTRATEUR:
       case RoleType.SUPER_ADMIN:
       case RoleType.GESTIONNAIRE:
-        // accès complet
+        // accès complet (y compris orphelins)
         break;
 
       default:
         throw new ForbiddenException('Accès interdit');
     }
 
-    return child;
+    return this.withSansResponsable(child);
   }
 
 
   // Mise à jour
-  async update(id: string, dto: Partial<CreateEnfantsDto>, currentUser: Users): Promise<Children> {
+  async update(
+    id: string,
+    dto: Partial<CreateEnfantsDto>,
+    currentUser: Users,
+    photoFile?: Express.Multer.File,
+  ): Promise<Children> {
     const child = await this.childrenRepository.findOne({ where: { id } });
     if (!child) throw new NotFoundException('Enfant introuvable');
 
-    await this.childrenRepository.update(id, dto);
+    const { parent_user_id: _ignored, ...rest } = dto;
+    const patch: Partial<Children> = { ...rest } as Partial<Children>;
+    if (dto.consent_photo !== undefined) {
+      patch.consent_photo = dto.consent_photo;
+      patch.consent_photo_at = dto.consent_photo ? new Date() : null!;
+    }
+    if (photoFile) {
+      patch.photo_url = `/uploads/photos/${photoFile.filename}`;
+      if (dto.consent_photo !== false) {
+        patch.consent_photo = true;
+        patch.consent_photo_at = new Date();
+      }
+    }
+
+    await this.childrenRepository.update(id, patch);
     return this.findOne(id, currentUser);
   }
 

backend/src/routes/parents/dto/dossier-famille-complet.dto.ts

@@ -54,9 +54,6 @@ export class DossierFamilleEnfantDto {
     description: 'Consentement affichage photo (colonne consentement_photo)',
   })
   consent_photo?: boolean;
-
-  @ApiProperty({ required: false, description: 'Grossesse multiple (est_multiple)' })
-  est_multiple?: boolean;
 }
 
 /** Réponse GET /parents/dossier-famille/:numeroDossier – dossier famille complet. Ticket #119 */

backend/src/routes/parents/dto/pending-family.dto.ts

@@ -7,6 +7,12 @@ export class ParentPendingSummaryDto {
   @ApiProperty()
   email: string;
 
+  @ApiPropertyOptional({ nullable: true })
+  nom?: string | null;
+
+  @ApiPropertyOptional({ nullable: true })
+  prenom?: string | null;
+
   @ApiPropertyOptional({ nullable: true })
   telephone?: string | null;
 
@@ -18,7 +24,10 @@ export class ParentPendingSummaryDto {
 }
 
 export class PendingFamilyDto {
-  @ApiProperty({ example: 'Famille Dupont', description: 'Libellé affiché pour la famille' })
+  @ApiProperty({
+    example: 'MARTIN Claire - MARTIN Thomas',
+    description: 'Libellé affiché : NOM Prénom (séparés par « - » si co-parent)',
+  })
   libelle: string;
 
   @ApiProperty({

backend/src/routes/parents/dto/staff-add-co-parent-response.dto.ts

@@ -0,0 +1,23 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { StatutUtilisateurType } from 'src/entities/users.entity';
+
+/** Réponse 201 POST /parents/:id/co-parent (#135). */
+export class StaffAddCoParentResponseDto {
+  @ApiProperty()
+  message: string;
+
+  @ApiProperty({ example: '2026-000043' })
+  numero_dossier: string;
+
+  @ApiProperty({ format: 'uuid', description: 'UUID du parent pivot' })
+  parent_user_id: string;
+
+  @ApiProperty({ format: 'uuid', description: 'UUID du co-parent créé' })
+  co_parent_user_id: string;
+
+  @ApiProperty({
+    enum: StatutUtilisateurType,
+    example: StatutUtilisateurType.ACTIF,
+  })
+  statut: StatutUtilisateurType;
+}

backend/src/routes/parents/dto/staff-add-co-parent.dto.ts

@@ -0,0 +1,69 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import {
+  IsBoolean,
+  IsEmail,
+  IsNotEmpty,
+  IsOptional,
+  IsString,
+  Matches,
+  MaxLength,
+  MinLength,
+} from 'class-validator';
+
+/**
+ * Ajout d’un co-parent sur un foyer existant (staff) — ticket #135.
+ * Corps sans préfixe `co_parent_*` (l’URL cible déjà le pivot).
+ */
+export class StaffAddCoParentDto {
+  @ApiProperty({ example: 'thomas.martin@ptits-pas.fr' })
+  @IsEmail({}, { message: 'Email invalide' })
+  @IsNotEmpty({ message: "L'email est requis" })
+  email: string;
+
+  @ApiProperty({ example: 'Thomas' })
+  @IsString()
+  @IsNotEmpty({ message: 'Le prénom est requis' })
+  @MinLength(2)
+  @MaxLength(100)
+  prenom: string;
+
+  @ApiProperty({ example: 'MARTIN' })
+  @IsString()
+  @IsNotEmpty({ message: 'Le nom est requis' })
+  @MinLength(2)
+  @MaxLength(100)
+  nom: string;
+
+  @ApiProperty({ example: '0678456789' })
+  @IsString()
+  @IsNotEmpty({ message: 'Le téléphone est requis' })
+  @Matches(/^(\+33|0)[1-9](\d{2}){4}$/, {
+    message: 'Le numéro de téléphone doit être valide (ex: 0689567890 ou +33689567890)',
+  })
+  telephone: string;
+
+  @ApiPropertyOptional({
+    example: true,
+    description: 'Si true, copie l’adresse du parent pivot',
+  })
+  @IsOptional()
+  @IsBoolean()
+  meme_adresse?: boolean;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  adresse?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  @MaxLength(10)
+  code_postal?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  @MaxLength(150)
+  ville?: string;
+}

backend/src/routes/parents/dto/staff-create-parent-dossier-response.dto.ts

@@ -0,0 +1,37 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { StatutUtilisateurType } from 'src/entities/users.entity';
+
+/** Réponse 201 POST /parents/dossier (#129). */
+export class StaffCreateParentDossierResponseDto {
+  @ApiProperty()
+  message: string;
+
+  @ApiProperty({
+    example: '2026-000043',
+    description: 'Numéro de dossier famille attribué',
+  })
+  numero_dossier: string;
+
+  @ApiProperty({ format: 'uuid', description: 'UUID user du parent pivot' })
+  parent_user_id: string;
+
+  @ApiPropertyOptional({
+    format: 'uuid',
+    nullable: true,
+    description: 'UUID user du co-parent, ou null',
+  })
+  co_parent_user_id: string | null;
+
+  @ApiProperty({
+    enum: StatutUtilisateurType,
+    example: StatutUtilisateurType.ACTIF,
+  })
+  statut: StatutUtilisateurType;
+
+  @ApiProperty({
+    type: [String],
+    format: 'uuid',
+    description: 'IDs des enfants créés',
+  })
+  enfant_ids: string[];
+}

backend/src/routes/parents/dto/staff-create-parent-dossier.dto.ts

@@ -0,0 +1,29 @@
+import { ApiPropertyOptional, OmitType } from '@nestjs/swagger';
+import { IsBoolean, IsOptional } from 'class-validator';
+import { RegisterParentCompletDto } from 'src/routes/auth/dto/register-parent-complet.dto';
+
+/**
+ * Création dossier parent/famille par staff (#129).
+ * Mêmes champs que l'inscription publique, sans CGU/privacy obligatoires
+ * (acceptées côté serveur pour le compte du gestionnaire).
+ */
+export class StaffCreateParentDossierDto extends OmitType(RegisterParentCompletDto, [
+  'acceptation_cgu',
+  'acceptation_privacy',
+] as const) {
+  @ApiPropertyOptional({
+    description: 'Ignoré côté staff (CGU acceptées serveur). Conservé pour compat éventuelle.',
+    default: true,
+  })
+  @IsOptional()
+  @IsBoolean()
+  acceptation_cgu?: boolean;
+
+  @ApiPropertyOptional({
+    description: 'Ignoré côté staff (privacy acceptée serveur).',
+    default: true,
+  })
+  @IsOptional()
+  @IsBoolean()
+  acceptation_privacy?: boolean;
+}

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

@@ -1,18 +1,104 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { ParentsController } from './parents.controller';
+import { ParentsService } from './parents.service';
+import { UserService } from '../user/user.service';
+import { AuthService } from '../auth/auth.service';
+import { AuthGuard } from 'src/common/guards/auth.guard';
+import { RolesGuard } from 'src/common/guards/roles.guard';
+import { StatutUtilisateurType } from 'src/entities/users.entity';
 
 describe('ParentsController', () => {
   let controller: ParentsController;
+  const authServiceMock = {
+    createParentDossierStaff: jest.fn(),
+    addCoParentStaff: jest.fn(),
+  };
+  const parentsServiceMock = {};
+  const userServiceMock = {};
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
       controllers: [ParentsController],
-    }).compile();
+      providers: [
+        { provide: ParentsService, useValue: parentsServiceMock },
+        { provide: UserService, useValue: userServiceMock },
+        { provide: AuthService, useValue: authServiceMock },
+      ],
+    })
+      .overrideGuard(AuthGuard)
+      .useValue({ canActivate: () => true })
+      .overrideGuard(RolesGuard)
+      .useValue({ canActivate: () => true })
+      .compile();
 
     controller = module.get<ParentsController>(ParentsController);
+    jest.clearAllMocks();
   });
 
   it('should be defined', () => {
     expect(controller).toBeDefined();
   });
+
+  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é.',
+      parent_user_id: 'p1',
+      co_parent_user_id: 'p2',
+      enfant_ids: ['e1'],
+      statut: StatutUtilisateurType.ACTIF,
+      numero_dossier: '2026-000043',
+    });
+
+    const body = {
+      email: 'parent.staff@test.fr',
+      prenom: 'Claire',
+      nom: 'MARTIN',
+      telephone: '0689567890',
+      enfants: [
+        {
+          prenom: 'Emma',
+          nom: 'MARTIN',
+          date_naissance: '2023-02-15',
+          genre: 'F',
+        },
+      ],
+    };
+
+    const res = await controller.createDossier(body as any);
+    expect(authServiceMock.createParentDossierStaff).toHaveBeenCalledWith(
+      expect.objectContaining({
+        email: body.email,
+        acceptation_cgu: true,
+        acceptation_privacy: true,
+      }),
+    );
+    expect(res.numero_dossier).toBe('2026-000043');
+    expect(res.parent_user_id).toBe('p1');
+    expect(res.co_parent_user_id).toBe('p2');
+    expect(res.enfant_ids).toEqual(['e1']);
+    expect(res.statut).toBe(StatutUtilisateurType.ACTIF);
+  });
+
+  it('addCoParent delegates to authService.addCoParentStaff', async () => {
+    authServiceMock.addCoParentStaff.mockResolvedValue({
+      message: 'ok',
+      numero_dossier: '2026-000043',
+      parent_user_id: 'p1',
+      co_parent_user_id: 'p2',
+      statut: StatutUtilisateurType.ACTIF,
+    });
+
+    const body = {
+      email: 'coparent@test.fr',
+      prenom: 'Thomas',
+      nom: 'MARTIN',
+      telephone: '0678456789',
+      meme_adresse: true,
+    };
+
+    const res = await controller.addCoParent('p1', body as any);
+    expect(authServiceMock.addCoParentStaff).toHaveBeenCalledWith('p1', body);
+    expect(res.co_parent_user_id).toBe('p2');
+    expect(res.statut).toBe(StatutUtilisateurType.ACTIF);
+  });
 });

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

@@ -3,6 +3,8 @@ import {
   Controller,
   Delete,
   Get,
+  HttpCode,
+  HttpStatus,
   Param,
   Patch,
   Post,
@@ -10,14 +12,27 @@ import {
 } from '@nestjs/common';
 import { ParentsService } from './parents.service';
 import { UserService } from '../user/user.service';
+import { AuthService } from '../auth/auth.service';
 import { Parents } from 'src/entities/parents.entity';
 import { Users } from 'src/entities/users.entity';
 import { Roles } from 'src/common/decorators/roles.decorator';
 import { RoleType, StatutUtilisateurType } from 'src/entities/users.entity';
-import { ApiBody, ApiOperation, ApiParam, ApiResponse, ApiTags } from '@nestjs/swagger';
+import {
+  ApiBearerAuth,
+  ApiBody,
+  ApiOperation,
+  ApiParam,
+  ApiResponse,
+  ApiTags,
+} from '@nestjs/swagger';
 import { CreateParentDto } from '../user/dto/create_parent.dto';
 import { UpdateParentsDto } from '../user/dto/update_parent.dto';
 import { UpdateParentFicheAdminDto } from './dto/update-parent-fiche-admin.dto';
+import { StaffCreateParentDossierDto } from './dto/staff-create-parent-dossier.dto';
+import { StaffCreateParentDossierResponseDto } from './dto/staff-create-parent-dossier-response.dto';
+import { StaffAddCoParentDto } from './dto/staff-add-co-parent.dto';
+import { StaffAddCoParentResponseDto } from './dto/staff-add-co-parent-response.dto';
+import { RegisterParentCompletDto } from '../auth/dto/register-parent-complet.dto';
 import { AuthGuard } from 'src/common/guards/auth.guard';
 import { RolesGuard } from 'src/common/guards/roles.guard';
 import { User } from 'src/common/decorators/user.decorator';
@@ -26,14 +41,50 @@ import { DossierFamilleCompletDto } from './dto/dossier-famille-complet.dto';
 import { mapParentForApi, mapParentsForApi } from './parents.mapper';
 
 @ApiTags('Parents')
+@ApiBearerAuth('access-token')
 @Controller('parents')
 @UseGuards(AuthGuard, RolesGuard)
 export class ParentsController {
   constructor(
     private readonly parentsService: ParentsService,
     private readonly userService: UserService,
+    private readonly authService: AuthService,
   ) {}
 
+  @Roles(RoleType.SUPER_ADMIN, RoleType.ADMINISTRATEUR, RoleType.GESTIONNAIRE)
+  @Post('dossier')
+  @HttpCode(HttpStatus.CREATED)
+  @ApiOperation({
+    summary: 'Créer un dossier famille/parent complet (staff) — ticket #129',
+    description:
+      'Crée parent (+ co-parent optionnel) + enfants + n° dossier avec statut actif, ' +
+      'et envoie l’e-mail de création de mot de passe. ' +
+      'Ne pas utiliser POST /auth/register/parent depuis le dashboard.',
+  })
+  @ApiBody({ type: StaffCreateParentDossierDto })
+  @ApiResponse({ status: 201, type: StaffCreateParentDossierResponseDto })
+  @ApiResponse({ status: 400, description: 'Validation DTO / métier' })
+  @ApiResponse({ status: 403, description: 'Rôle non autorisé' })
+  @ApiResponse({ status: 409, description: 'Email pivot et/ou co-parent déjà pris' })
+  async createDossier(
+    @Body() dto: StaffCreateParentDossierDto,
+  ): Promise<StaffCreateParentDossierResponseDto> {
+    const registerDto = {
+      ...dto,
+      acceptation_cgu: true,
+      acceptation_privacy: true,
+    } as RegisterParentCompletDto;
+    const result = await this.authService.createParentDossierStaff(registerDto);
+    return {
+      message: result.message,
+      numero_dossier: result.numero_dossier,
+      parent_user_id: result.parent_user_id,
+      co_parent_user_id: result.co_parent_user_id ?? null,
+      statut: result.statut,
+      enfant_ids: result.enfant_ids,
+    };
+  }
+
   @Get('pending-families')
   @Roles(RoleType.SUPER_ADMIN, RoleType.ADMINISTRATEUR, RoleType.GESTIONNAIRE)
   @ApiOperation({ summary: 'Liste des familles en attente (une entrée par famille)' })
@@ -127,6 +178,28 @@ export class ParentsController {
     return mapParentForApi(parent);
   }
 
+  @Roles(RoleType.SUPER_ADMIN, RoleType.ADMINISTRATEUR, RoleType.GESTIONNAIRE)
+  @Post(':id/co-parent')
+  @HttpCode(HttpStatus.CREATED)
+  @ApiOperation({
+    summary: 'Ajouter un co-parent à un foyer existant (staff) — ticket #135',
+    description:
+      'Foyer mono-parent uniquement. Crée le co-parent actif, liens foyer + enfants, ' +
+      'e-mail de création de mot de passe. Ne pas utiliser POST /auth/register/parent.',
+  })
+  @ApiParam({ name: 'id', description: 'UUID utilisateur du parent pivot' })
+  @ApiBody({ type: StaffAddCoParentDto })
+  @ApiResponse({ status: 201, type: StaffAddCoParentResponseDto })
+  @ApiResponse({ status: 400, description: 'Foyer déjà à 2 parents / validation' })
+  @ApiResponse({ status: 404, description: 'Parent introuvable' })
+  @ApiResponse({ status: 409, description: 'Email déjà pris' })
+  async addCoParent(
+    @Param('id') id: string,
+    @Body() dto: StaffAddCoParentDto,
+  ): Promise<StaffAddCoParentResponseDto> {
+    return this.authService.addCoParentStaff(id, dto);
+  }
+
   @Roles(RoleType.SUPER_ADMIN, RoleType.GESTIONNAIRE, RoleType.ADMINISTRATEUR)
   @Post(':id/enfants/:enfantId')
   @ApiOperation({ summary: 'Rattacher un enfant à un parent — ticket #115' })

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

@@ -9,11 +9,13 @@ import { ParentsController } from './parents.controller';
 import { ParentsService } from './parents.service';
 import { Users } from 'src/entities/users.entity';
 import { UserModule } from '../user/user.module';
+import { AuthModule } from '../auth/auth.module';
 
 @Module({
     imports: [
         TypeOrmModule.forFeature([Parents, Users, DossierFamille, DossierFamilleEnfant, ParentsChildren]),
         forwardRef(() => UserModule),
+        forwardRef(() => AuthModule),
         JwtModule.registerAsync({
             imports: [ConfigModule],
             useFactory: (config: ConfigService) => ({

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

@@ -114,34 +114,86 @@ export class ParentsService {
   }
 
   /**
-   * Rattacher un enfant existant à un parent (enfants_parents). Ticket #115 / doc 28 §6.2.
+   * Membres du foyer (user ids) pour affiliation enfant.
+   * Pivot + co-parent (A→B et B→A) + même numero_dossier. Ticket #158.
    */
-  async attachEnfant(parentUserId: string, enfantId: string): Promise<Parents> {
+  private async resolveFoyerParentUserIds(parent: Parents): Promise<string[]> {
-    await this.findOne(parentUserId);
+    const ids = new Set<string>([parent.user_id]);
 
-    const existing = await this.parentsChildrenRepository.findOne({
+    if (parent.co_parent?.id) {
-      where: { parentId: parentUserId, enfantId },
+      ids.add(parent.co_parent.id);
-    });
-    if (existing) {
-      throw new ConflictException('Cet enfant est déjà rattaché à ce parent');
     }
 
-    const child = await this.parentsRepository.manager.findOne(Children, { where: { id: enfantId } });
+    // Sens inverse : parents qui déclarent ce user comme co-parent
+    const reverseLinks = await this.parentsRepository.find({
+      where: { co_parent: { id: parent.user_id } },
+      relations: ['co_parent'],
+    });
+    for (const p of reverseLinks) {
+      ids.add(p.user_id);
+      if (p.co_parent?.id) ids.add(p.co_parent.id);
+    }
+
+    const dossier = parent.numero_dossier?.trim();
+    if (dossier) {
+      const sameDossier = await this.parentsRepository.find({
+        where: { numero_dossier: dossier },
+        relations: ['co_parent'],
+      });
+      for (const p of sameDossier) {
+        ids.add(p.user_id);
+        if (p.co_parent?.id) ids.add(p.co_parent.id);
+      }
+    }
+
+    return [...ids];
+  }
+
+  /**
+   * Rattacher un enfant au foyer du parent (tous les responsables). Ticket #158.
+   * Un seul POST suffit : liens créés pour pivot + co-parent / même dossier.
+   */
+  async attachEnfant(parentUserId: string, enfantId: string): Promise<Parents> {
+    const parent = await this.findOne(parentUserId);
+
+    const child = await this.parentsRepository.manager.findOne(Children, {
+      where: { id: enfantId },
+    });
     if (!child) {
       throw new NotFoundException('Enfant introuvable');
     }
 
-    await this.parentsChildrenRepository.save(
+    const foyerIds = await this.resolveFoyerParentUserIds(parent);
-      this.parentsChildrenRepository.create({ parentId: parentUserId, enfantId }),
+    let created = 0;
-    );
+
+    for (const memberId of foyerIds) {
+      const existing = await this.parentsChildrenRepository.findOne({
+        where: { parentId: memberId, enfantId },
+      });
+      if (existing) continue;
+
+      await this.parentsChildrenRepository.save(
+        this.parentsChildrenRepository.create({
+          parentId: memberId,
+          enfantId,
+        }),
+      );
+      created += 1;
+    }
+
+    if (created === 0) {
+      throw new ConflictException('Cet enfant est déjà rattaché à ce foyer');
+    }
+
     return this.findOne(parentUserId);
   }
 
   /**
-   * Détacher un enfant d'un parent sans supprimer l'enfant. Ticket #115 / doc 28 §6.2.
+   * Détacher un enfant du foyer du parent (tous les responsables). Ticket #158.
+   * Si plus aucun lien ensuite → enfant orphelin (#157).
    */
   async detachEnfant(parentUserId: string, enfantId: string): Promise<Parents> {
-    await this.findOne(parentUserId);
+    const parent = await this.findOne(parentUserId);
 
     const link = await this.parentsChildrenRepository.findOne({
       where: { parentId: parentUserId, enfantId },
@@ -150,12 +202,12 @@ export class ParentsService {
       throw new NotFoundException('Lien parent-enfant introuvable');
     }
 
-    const totalLinks = await this.parentsChildrenRepository.count({ where: { enfantId } });
+    const foyerIds = await this.resolveFoyerParentUserIds(parent);
-    if (totalLinks <= 1) {
+    await this.parentsChildrenRepository.delete({
-      throw new BadRequestException('Un enfant doit rester rattaché à au moins un responsable');
+      parentId: In(foyerIds),
-    }
+      enfantId,
+    });
 
-    await this.parentsChildrenRepository.delete({ parentId: parentUserId, enfantId });
     return this.findOne(parentUserId);
   }
 
@@ -199,7 +251,15 @@ export class ParentsService {
           SELECT id, (MIN(rep::text))::uuid AS rep FROM rec GROUP BY id
         )
         SELECT
-          'Famille ' || string_agg(u.nom, ' - ' ORDER BY u.nom, u.prenom) AS libelle,
+          string_agg(
+            UPPER(TRIM(u.nom))
+              || CASE
+                WHEN u.prenom IS NOT NULL AND TRIM(u.prenom) <> ''
+                THEN ' ' || INITCAP(TRIM(u.prenom))
+                ELSE ''
+              END,
+            ' - ' ORDER BY u.nom, u.prenom, u.id
+          ) AS libelle,
           array_agg(p.id_utilisateur ORDER BY u.nom, u.prenom, u.id) AS "parentIds",
           (array_agg(p.numero_dossier))[1] AS numero_dossier,
           MIN(u.cree_le) AS date_soumission,
@@ -215,6 +275,8 @@ export class ParentsService {
             json_build_object(
               'id', u.id::text,
               'email', u.email,
+              'nom', u.nom,
+              'prenom', u.prenom,
               'telephone', u.telephone,
               'code_postal', u.code_postal,
               'ville', u.ville
@@ -265,11 +327,21 @@ export class ParentsService {
     return [];
   }
 
-  private normalizeParents(parents: unknown): { id: string; email: string; telephone: string | null; code_postal: string | null; ville: string | null }[] {
+  private normalizeParents(parents: unknown): {
+    id: string;
+    email: string;
+    nom: string | null;
+    prenom: string | null;
+    telephone: string | null;
+    code_postal: string | null;
+    ville: string | null;
+  }[] {
     if (Array.isArray(parents)) {
       return parents.map((p: any) => ({
         id: String(p?.id ?? ''),
         email: String(p?.email ?? ''),
+        nom: p?.nom != null ? String(p.nom) : null,
+        prenom: p?.prenom != null ? String(p.prenom) : null,
         telephone: p?.telephone != null ? String(p.telephone) : null,
         code_postal: p?.code_postal != null ? String(p.code_postal) : null,
         ville: p?.ville != null ? String(p.ville) : null,
@@ -298,7 +370,6 @@ export class ParentsService {
       status: child.status,
       photo_url: child.photo_url ?? undefined,
       consent_photo: child.consent_photo,
-      est_multiple: child.is_multiple,
     };
   }
 

backend/src/routes/relais/relais.controller.ts

@@ -24,15 +24,19 @@ export class RelaisController {
   }
 
   @Get()
-  @Roles(RoleType.SUPER_ADMIN, RoleType.ADMINISTRATEUR)
+  @Roles(RoleType.SUPER_ADMIN, RoleType.ADMINISTRATEUR, RoleType.GESTIONNAIRE)
-  @ApiOperation({ summary: 'Lister tous les relais' })
+  @ApiOperation({
+    summary: 'Lister tous les relais',
+    description:
+      'Lecture ouverte aux gestionnaires (combobox fiches). CRUD write reste admin-only. Ticket #151.',
+  })
   @ApiResponse({ status: 200, description: 'Liste des relais.' })
   findAll() {
     return this.relaisService.findAll();
   }
 
   @Get(':id')
-  @Roles(RoleType.SUPER_ADMIN, RoleType.ADMINISTRATEUR)
+  @Roles(RoleType.SUPER_ADMIN, RoleType.ADMINISTRATEUR, RoleType.GESTIONNAIRE)
   @ApiOperation({ summary: 'Récupérer un relais par ID' })
   @ApiResponse({ status: 200, description: 'Le relais trouvé.' })
   findOne(@Param('id') id: string) {

backend/src/routes/suppressions/suppression.service.spec.ts

@@ -0,0 +1,175 @@
+import { ForbiddenException, NotFoundException } from '@nestjs/common';
+import { SuppressionService } from './suppression.service';
+import { RoleType } from 'src/entities/users.entity';
+
+describe('SuppressionService (#159)', () => {
+  const dataSource = {
+    transaction: jest.fn(async (cb: (m: unknown) => Promise<unknown>) =>
+      cb({
+        delete: jest.fn(),
+        query: jest.fn(),
+      }),
+    ),
+  };
+
+  const usersRepository = {
+    findOne: jest.fn(),
+    delete: jest.fn(),
+    count: jest.fn(),
+  };
+  const parentsRepository = {
+    findOne: jest.fn(),
+    find: jest.fn(),
+    query: jest.fn(),
+  };
+  const amRepository = {
+    findOne: jest.fn(),
+  };
+  const childrenRepository = {
+    findOne: jest.fn(),
+    delete: jest.fn(),
+    save: jest.fn(),
+  };
+  const parentsChildrenRepository = {
+    find: jest.fn(),
+  };
+  const amChildrenRepository = {
+    find: jest.fn(),
+    save: jest.fn(),
+    count: jest.fn(),
+  };
+
+  let service: SuppressionService;
+
+  const staff = {
+    id: 'staff-1',
+    role: RoleType.GESTIONNAIRE,
+  } as never;
+
+  const admin = {
+    id: 'admin-1',
+    role: RoleType.ADMINISTRATEUR,
+  } as never;
+
+  const superAdmin = {
+    id: 'sa-1',
+    role: RoleType.SUPER_ADMIN,
+  } as never;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    service = new SuppressionService(
+      dataSource as never,
+      usersRepository as never,
+      parentsRepository as never,
+      amRepository as never,
+      childrenRepository as never,
+      parentsChildrenRepository as never,
+      amChildrenRepository as never,
+    );
+  });
+
+  it('refuse self-delete', async () => {
+    usersRepository.findOne.mockResolvedValue({
+      id: 'admin-1',
+      role: RoleType.ADMINISTRATEUR,
+    });
+    await expect(service.deleteUser('admin-1', admin)).rejects.toBeInstanceOf(
+      ForbiddenException,
+    );
+  });
+
+  it('refuse gestionnaire deleting another gestionnaire', async () => {
+    usersRepository.findOne.mockResolvedValue({
+      id: 'g2',
+      role: RoleType.GESTIONNAIRE,
+    });
+    await expect(service.deleteUser('g2', staff)).rejects.toBeInstanceOf(
+      ForbiddenException,
+    );
+  });
+
+  it('dernier admin : refus si pas super_admin', async () => {
+    usersRepository.findOne.mockResolvedValue({
+      id: 'admin-2',
+      role: RoleType.ADMINISTRATEUR,
+    });
+    usersRepository.count.mockResolvedValue(1);
+    await expect(service.deleteUser('admin-2', admin)).rejects.toBeInstanceOf(
+      ForbiddenException,
+    );
+  });
+
+  it('dernier admin : OK pour super_admin', async () => {
+    usersRepository.findOne.mockResolvedValue({
+      id: 'admin-2',
+      role: RoleType.ADMINISTRATEUR,
+    });
+    usersRepository.count.mockResolvedValue(1);
+    usersRepository.delete.mockResolvedValue({ affected: 1 });
+    const res = await service.deleteUser('admin-2', superAdmin);
+    expect(res.deleted_user_ids).toEqual(['admin-2']);
+  });
+
+  it('delete AM : clos placements, pas d’enfants deleted', async () => {
+    usersRepository.findOne.mockResolvedValue({
+      id: 'am-1',
+      role: RoleType.ASSISTANTE_MATERNELLE,
+    });
+    amRepository.findOne.mockResolvedValue({
+      user_id: 'am-1',
+      numero_dossier: '2026-000015',
+    });
+    amChildrenRepository.find.mockResolvedValue([
+      {
+        amId: 'am-1',
+        enfantId: 'e1',
+        child: { id: 'e1', status: 'garde' },
+      },
+    ]);
+    amChildrenRepository.count.mockResolvedValue(0);
+    amChildrenRepository.save.mockImplementation(async (x) => x);
+    childrenRepository.save.mockResolvedValue({});
+    usersRepository.delete.mockResolvedValue({ affected: 1 });
+
+    const res = await service.deleteUser('am-1', staff);
+    expect(res.deleted_enfant_ids).toEqual([]);
+    expect(res.deleted_user_ids).toEqual(['am-1']);
+    expect(res.type).toBe('assistante_maternelle');
+  });
+
+  it('delete dossier famille introuvable', async () => {
+    parentsRepository.findOne.mockResolvedValue(null);
+    amRepository.findOne.mockResolvedValue(null);
+    await expect(
+      service.deleteDossier('2026-999999', staff),
+    ).rejects.toBeInstanceOf(NotFoundException);
+  });
+
+  it('co-parent : delete user seul', async () => {
+    usersRepository.findOne.mockResolvedValue({
+      id: 'p2',
+      role: RoleType.PARENT,
+    });
+    parentsRepository.findOne.mockResolvedValue({
+      user_id: 'p2',
+      numero_dossier: '2026-000010',
+      co_parent: { id: 'p1' },
+    });
+    parentsRepository.query.mockResolvedValue([
+      { id: 'p1' },
+      { id: 'p2' },
+    ]);
+    dataSource.transaction.mockImplementation(async (cb) =>
+      cb({
+        delete: jest.fn(),
+        query: jest.fn(),
+      }),
+    );
+
+    const res = await service.deleteUser('p2', staff);
+    expect(res.deleted_enfant_ids).toEqual([]);
+    expect(res.deleted_user_ids).toEqual(['p2']);
+    expect(res.message).toMatch(/co-parent/i);
+  });
+});

backend/src/routes/suppressions/suppression.service.ts

@@ -0,0 +1,420 @@
+import {
+  BadRequestException,
+  ForbiddenException,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { DataSource, In, IsNull, Repository } from 'typeorm';
+import { RoleType, Users } from 'src/entities/users.entity';
+import { Parents } from 'src/entities/parents.entity';
+import { AssistanteMaternelle } from 'src/entities/assistantes_maternelles.entity';
+import { Children, StatutEnfantType } from 'src/entities/children.entity';
+import { ParentsChildren } from 'src/entities/parents_children.entity';
+import { AmChildren } from 'src/entities/am_children.entity';
+
+export type SuppressionResult = {
+  type?: 'famille' | 'assistante_maternelle';
+  numero_dossier?: string;
+  deleted_user_ids: string[];
+  deleted_enfant_ids: string[];
+  dossier_supprime?: boolean;
+  message: string;
+};
+
+const STAFF_METIER: RoleType[] = [
+  RoleType.GESTIONNAIRE,
+  RoleType.ADMINISTRATEUR,
+  RoleType.SUPER_ADMIN,
+];
+
+/**
+ * Cascades de suppression métier — tickets #154 / #159.
+ */
+@Injectable()
+export class SuppressionService {
+  constructor(
+    private readonly dataSource: DataSource,
+    @InjectRepository(Users)
+    private readonly usersRepository: Repository<Users>,
+    @InjectRepository(Parents)
+    private readonly parentsRepository: Repository<Parents>,
+    @InjectRepository(AssistanteMaternelle)
+    private readonly amRepository: Repository<AssistanteMaternelle>,
+    @InjectRepository(Children)
+    private readonly childrenRepository: Repository<Children>,
+    @InjectRepository(ParentsChildren)
+    private readonly parentsChildrenRepository: Repository<ParentsChildren>,
+    @InjectRepository(AmChildren)
+    private readonly amChildrenRepository: Repository<AmChildren>,
+  ) {}
+
+  assertStaffMetier(currentUser: Users): void {
+    if (!STAFF_METIER.includes(currentUser.role)) {
+      throw new ForbiddenException('Accès refusé');
+    }
+  }
+
+  async deleteDossier(
+    numeroDossier: string,
+    currentUser: Users,
+  ): Promise<SuppressionResult> {
+    this.assertStaffMetier(currentUser);
+    const num = numeroDossier?.trim();
+    if (!num) {
+      throw new BadRequestException('Numéro de dossier requis.');
+    }
+
+    const parentHit = await this.parentsRepository.findOne({
+      where: { numero_dossier: num },
+    });
+    if (parentHit) {
+      return this.deleteFamilleByNumero(num);
+    }
+
+    const amHit = await this.amRepository.findOne({
+      where: { numero_dossier: num },
+      relations: ['user'],
+    });
+    if (amHit?.user) {
+      return this.deleteAmUser(amHit.user.id);
+    }
+
+    throw new NotFoundException('Aucun dossier trouvé pour ce numéro.');
+  }
+
+  async deleteUser(
+    id: string,
+    currentUser: Users,
+  ): Promise<SuppressionResult> {
+    const target = await this.usersRepository.findOne({ where: { id } });
+    if (!target) {
+      throw new NotFoundException('Utilisateur introuvable');
+    }
+
+    if (target.id === currentUser.id) {
+      throw new ForbiddenException('Vous ne pouvez pas supprimer votre propre compte.');
+    }
+    if (target.role === RoleType.SUPER_ADMIN) {
+      throw new ForbiddenException('Le super administrateur ne peut pas être supprimé.');
+    }
+
+    if (target.role === RoleType.PARENT) {
+      this.assertStaffMetier(currentUser);
+      return this.deleteParentUser(target.id);
+    }
+    if (target.role === RoleType.ASSISTANTE_MATERNELLE) {
+      this.assertStaffMetier(currentUser);
+      return this.deleteAmUser(target.id);
+    }
+    if (target.role === RoleType.GESTIONNAIRE) {
+      if (
+        currentUser.role !== RoleType.ADMINISTRATEUR &&
+        currentUser.role !== RoleType.SUPER_ADMIN
+      ) {
+        throw new ForbiddenException(
+          'Seul un administrateur peut supprimer un gestionnaire.',
+        );
+      }
+      await this.usersRepository.delete(target.id);
+      return {
+        deleted_user_ids: [target.id],
+        deleted_enfant_ids: [],
+        message: 'Gestionnaire supprimé.',
+      };
+    }
+    if (target.role === RoleType.ADMINISTRATEUR) {
+      await this.assertCanDeleteAdministrateur(target, currentUser);
+      await this.usersRepository.delete(target.id);
+      return {
+        deleted_user_ids: [target.id],
+        deleted_enfant_ids: [],
+        message: 'Administrateur supprimé.',
+      };
+    }
+
+    throw new BadRequestException('Type d’utilisateur non supprimable via cet endpoint.');
+  }
+
+  async deleteEnfant(
+    enfantId: string,
+    deleteDossier: boolean,
+    currentUser: Users,
+  ): Promise<SuppressionResult> {
+    this.assertStaffMetier(currentUser);
+
+    const child = await this.childrenRepository.findOne({
+      where: { id: enfantId },
+      relations: ['parentLinks', 'parentLinks.parent'],
+    });
+    if (!child) {
+      throw new NotFoundException('Enfant introuvable');
+    }
+
+    const parentIds = (child.parentLinks ?? [])
+      .map((l) => l.parentId ?? l.parent?.user_id)
+      .filter(Boolean) as string[];
+
+    let numero: string | undefined;
+    if (parentIds.length > 0) {
+      const parents = await this.parentsRepository.find({
+        where: { user_id: In(parentIds) },
+      });
+      numero = parents.map((p) => p.numero_dossier?.trim()).find((n) => !!n);
+    }
+
+    if (!numero) {
+      await this.closePlacementsForEnfants([enfantId]);
+      await this.childrenRepository.delete(enfantId);
+      return {
+        deleted_user_ids: [],
+        deleted_enfant_ids: [enfantId],
+        dossier_supprime: false,
+        message: 'Enfant supprimé.',
+      };
+    }
+
+    const siblingIds = await this.listEnfantIdsForNumero(numero);
+    const isLast = siblingIds.length <= 1;
+
+    if (isLast && deleteDossier) {
+      const result = await this.deleteFamilleByNumero(numero);
+      return {
+        ...result,
+        dossier_supprime: true,
+        message: 'Dernier enfant et dossier famille supprimés.',
+      };
+    }
+
+    await this.closePlacementsForEnfants([enfantId]);
+    await this.childrenRepository.delete(enfantId);
+    return {
+      deleted_user_ids: [],
+      deleted_enfant_ids: [enfantId],
+      dossier_supprime: false,
+      numero_dossier: numero,
+      type: 'famille',
+      message: isLast
+        ? 'Dernier enfant supprimé. Le dossier famille reste sans enfant.'
+        : 'Enfant supprimé du dossier famille.',
+    };
+  }
+
+  /** Compte enfants liés à un numero_dossier famille (pour flag sans_enfant). */
+  async countEnfantsForNumero(numeroDossier: string): Promise<number> {
+    const ids = await this.listEnfantIdsForNumero(numeroDossier);
+    return ids.length;
+  }
+
+  private async assertCanDeleteAdministrateur(
+    target: Users,
+    currentUser: Users,
+  ): Promise<void> {
+    if (
+      currentUser.role !== RoleType.ADMINISTRATEUR &&
+      currentUser.role !== RoleType.SUPER_ADMIN
+    ) {
+      throw new ForbiddenException(
+        'Seul un administrateur peut supprimer un administrateur.',
+      );
+    }
+    const adminCount = await this.usersRepository.count({
+      where: { role: RoleType.ADMINISTRATEUR },
+    });
+    if (adminCount <= 1) {
+      if (currentUser.role !== RoleType.SUPER_ADMIN) {
+        throw new ForbiddenException(
+          'Seul le super administrateur peut supprimer le dernier administrateur.',
+        );
+      }
+    }
+  }
+
+  private async deleteParentUser(userId: string): Promise<SuppressionResult> {
+    const parent = await this.parentsRepository.findOne({
+      where: { user_id: userId },
+      relations: ['co_parent'],
+    });
+    if (!parent) {
+      // Compte parent sans fiche — hard delete user
+      await this.usersRepository.delete(userId);
+      return {
+        deleted_user_ids: [userId],
+        deleted_enfant_ids: [],
+        message: 'Parent supprimé.',
+      };
+    }
+
+    const numero = parent.numero_dossier?.trim();
+    const foyerIds = numero
+      ? await this.listParentUserIdsForNumero(numero)
+      : [userId];
+
+    const isLast = foyerIds.filter((id) => id !== userId).length === 0;
+
+    if (!isLast) {
+      // Co-parent : retirer liens enfants de ce parent, clear co_parent refs, delete user
+      await this.dataSource.transaction(async (manager) => {
+        await manager.delete(ParentsChildren, { parentId: userId });
+        await manager.query(
+          `UPDATE parents SET id_co_parent = NULL WHERE id_co_parent = $1 OR id_utilisateur = $1`,
+          [userId],
+        );
+        await manager.delete(Users, { id: userId });
+      });
+      return {
+        deleted_user_ids: [userId],
+        deleted_enfant_ids: [],
+        numero_dossier: numero,
+        type: 'famille',
+        message: 'Parent retiré du dossier (co-parent).',
+      };
+    }
+
+    // Dernier parent : + enfants
+    const enfantIds = numero
+      ? await this.listEnfantIdsForNumero(numero)
+      : await this.listEnfantIdsForParent(userId);
+    await this.closePlacementsForEnfants(enfantIds);
+    await this.dataSource.transaction(async (manager) => {
+      if (enfantIds.length) {
+        await manager.delete(Children, { id: In(enfantIds) });
+      }
+      await manager.query(
+        `UPDATE parents SET id_co_parent = NULL WHERE id_utilisateur = $1 OR id_co_parent = $1`,
+        [userId],
+      );
+      await manager.delete(Users, { id: userId });
+    });
+    return {
+      deleted_user_ids: [userId],
+      deleted_enfant_ids: enfantIds,
+      numero_dossier: numero,
+      type: 'famille',
+      message: 'Dernier parent et enfants rattachés supprimés.',
+    };
+  }
+
+  private async deleteFamilleByNumero(numero: string): Promise<SuppressionResult> {
+    const parentIds = await this.listParentUserIdsForNumero(numero);
+    if (parentIds.length === 0) {
+      throw new NotFoundException('Aucun parent pour ce dossier.');
+    }
+    const enfantIds = await this.listEnfantIdsForNumero(numero);
+    await this.closePlacementsForEnfants(enfantIds);
+
+    await this.dataSource.transaction(async (manager) => {
+      if (enfantIds.length) {
+        await manager.delete(Children, { id: In(enfantIds) });
+      }
+      await manager.query(
+        `UPDATE parents SET id_co_parent = NULL WHERE id_utilisateur = ANY($1::uuid[]) OR id_co_parent = ANY($1::uuid[])`,
+        [parentIds],
+      );
+      await manager.delete(Users, { id: In(parentIds) });
+    });
+
+    return {
+      type: 'famille',
+      numero_dossier: numero,
+      deleted_user_ids: parentIds,
+      deleted_enfant_ids: enfantIds,
+      message: 'Dossier famille supprimé.',
+    };
+  }
+
+  private async deleteAmUser(userId: string): Promise<SuppressionResult> {
+    const am = await this.amRepository.findOne({ where: { user_id: userId } });
+    const numero = am?.numero_dossier?.trim();
+
+    const active = await this.amChildrenRepository.find({
+      where: { amId: userId, date_fin: IsNull() },
+      relations: ['child'],
+    });
+    const now = new Date();
+    for (const link of active) {
+      link.date_fin = now;
+      await this.amChildrenRepository.save(link);
+      if (link.child) {
+        await this.applySansGarde(link.child);
+      }
+    }
+
+    await this.usersRepository.delete(userId);
+    return {
+      type: 'assistante_maternelle',
+      numero_dossier: numero,
+      deleted_user_ids: [userId],
+      deleted_enfant_ids: [],
+      message: 'Dossier assistante maternelle supprimé.',
+    };
+  }
+
+  private async applySansGarde(child: Children): Promise<void> {
+    if (
+      child.status === StatutEnfantType.A_NAITRE ||
+      child.status === StatutEnfantType.SCOLARISE
+    ) {
+      return;
+    }
+    const remaining = await this.amChildrenRepository.count({
+      where: { enfantId: child.id, date_fin: IsNull() },
+    });
+    if (remaining === 0) {
+      child.status = StatutEnfantType.SANS_GARDE;
+      await this.childrenRepository.save(child);
+    }
+  }
+
+  private async closePlacementsForEnfants(enfantIds: string[]): Promise<void> {
+    if (!enfantIds.length) return;
+    const links = await this.amChildrenRepository.find({
+      where: { enfantId: In(enfantIds), date_fin: IsNull() },
+      relations: ['child'],
+    });
+    const now = new Date();
+    for (const link of links) {
+      link.date_fin = now;
+      await this.amChildrenRepository.save(link);
+      if (link.child) {
+        await this.applySansGarde(link.child);
+      }
+    }
+  }
+
+  private async listParentUserIdsForNumero(numero: string): Promise<string[]> {
+    const rows: Array<{ id: string }> = await this.parentsRepository.query(
+      `
+      SELECT DISTINCT x.id::text AS id FROM (
+        SELECT id_utilisateur AS id FROM parents WHERE TRIM(numero_dossier) = $1
+        UNION
+        SELECT id_co_parent AS id FROM parents
+          WHERE TRIM(numero_dossier) = $1 AND id_co_parent IS NOT NULL
+        UNION
+        SELECT p2.id_utilisateur AS id FROM parents p1
+          JOIN parents p2 ON p2.id_utilisateur = p1.id_co_parent
+          WHERE TRIM(p1.numero_dossier) = $1
+      ) x WHERE x.id IS NOT NULL
+      `,
+      [numero],
+    );
+    return rows.map((r) => r.id);
+  }
+
+  private async listEnfantIdsForNumero(numero: string): Promise<string[]> {
+    const parentIds = await this.listParentUserIdsForNumero(numero);
+    if (!parentIds.length) return [];
+    return this.listEnfantIdsForParents(parentIds);
+  }
+
+  private async listEnfantIdsForParent(parentId: string): Promise<string[]> {
+    return this.listEnfantIdsForParents([parentId]);
+  }
+
+  private async listEnfantIdsForParents(parentIds: string[]): Promise<string[]> {
+    const links = await this.parentsChildrenRepository.find({
+      where: { parentId: In(parentIds) },
+    });
+    return [...new Set(links.map((l) => l.enfantId))];
+  }
+}

backend/src/routes/suppressions/suppressions.module.ts

@@ -0,0 +1,25 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { Users } from 'src/entities/users.entity';
+import { Parents } from 'src/entities/parents.entity';
+import { AssistanteMaternelle } from 'src/entities/assistantes_maternelles.entity';
+import { Children } from 'src/entities/children.entity';
+import { ParentsChildren } from 'src/entities/parents_children.entity';
+import { AmChildren } from 'src/entities/am_children.entity';
+import { SuppressionService } from './suppression.service';
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([
+      Users,
+      Parents,
+      AssistanteMaternelle,
+      Children,
+      ParentsChildren,
+      AmChildren,
+    ]),
+  ],
+  providers: [SuppressionService],
+  exports: [SuppressionService],
+})
+export class SuppressionsModule {}

backend/src/routes/user/gestionnaires/gestionnaires.controller.spec.ts

@@ -1,20 +1,21 @@
-import { Test, TestingModule } from '@nestjs/testing';
+import 'reflect-metadata';
 import { GestionnairesController } from './gestionnaires.controller';
-import { GestionnairesService } from './gestionnaires.service';
+import { RoleType } from 'src/entities/users.entity';
 
-describe('GestionnairesController', () => {
+describe('GestionnairesController roles (#161)', () => {
-  let controller: GestionnairesController;
+  it('POST /gestionnaires autorise SUPER_ADMIN et ADMINISTRATEUR', () => {
-
+    const roles = Reflect.getMetadata('roles', GestionnairesController.prototype.create);
-  beforeEach(async () => {
+    expect(roles).toEqual(
-    const module: TestingModule = await Test.createTestingModule({
+      expect.arrayContaining([RoleType.SUPER_ADMIN, RoleType.ADMINISTRATEUR]),
-      controllers: [GestionnairesController],
+    );
-      providers: [GestionnairesService],
+    expect(roles).not.toContain(RoleType.GESTIONNAIRE);
-    }).compile();
-
-    controller = module.get<GestionnairesController>(GestionnairesController);
   });
 
-  it('should be defined', () => {
+  it('PATCH /gestionnaires/:id autorise SUPER_ADMIN et ADMINISTRATEUR', () => {
-    expect(controller).toBeDefined();
+    const roles = Reflect.getMetadata('roles', GestionnairesController.prototype.update);
+    expect(roles).toEqual(
+      expect.arrayContaining([RoleType.SUPER_ADMIN, RoleType.ADMINISTRATEUR]),
+    );
+    expect(roles).not.toContain(RoleType.GESTIONNAIRE);
   });
 });

backend/src/routes/user/gestionnaires/gestionnaires.controller.ts

@@ -25,10 +25,10 @@ import { AuthGuard } from 'src/common/guards/auth.guard';
 export class GestionnairesController {
   constructor(private readonly gestionnairesService: GestionnairesService) { }
 
-  @Roles(RoleType.SUPER_ADMIN)
+  @Roles(RoleType.SUPER_ADMIN, RoleType.ADMINISTRATEUR)
   @ApiResponse({ status: 201, description: 'Le gestionnaire a été créé avec succès.', type: Users })
   @ApiResponse({ status: 409, description: 'Conflit. L\'email est déjà utilisé.' })
-  @ApiOperation({ summary: 'Création d\'un gestionnaire' })
+  @ApiOperation({ summary: 'Création d\'un gestionnaire (admin / super admin)' })
   @ApiBody({ type: CreateGestionnaireDto })
   @Post()
   create(@Body() dto: CreateGestionnaireDto): Promise<Users> {
@@ -43,7 +43,7 @@ export class GestionnairesController {
     return this.gestionnairesService.findAll();
   }
 
-  @Roles(RoleType.GESTIONNAIRE, RoleType.SUPER_ADMIN)
+  @Roles(RoleType.GESTIONNAIRE, RoleType.SUPER_ADMIN, RoleType.ADMINISTRATEUR)
   @ApiOperation({ summary: 'Récupérer un gestionnaire par ID' })
   @ApiResponse({ status: 400, description: 'ID invalide' })
   @ApiResponse({ status: 403, description: 'Accès refusé' })
@@ -56,8 +56,8 @@ export class GestionnairesController {
     return this.gestionnairesService.findOne(id);
   }
 
-  @Roles(RoleType.SUPER_ADMIN)
+  @Roles(RoleType.SUPER_ADMIN, RoleType.ADMINISTRATEUR)
-  @ApiOperation({ summary: 'Mettre à jour un gestionnaire' })
+  @ApiOperation({ summary: 'Mettre à jour un gestionnaire (admin / super admin)' })
   @ApiResponse({ status: 200, description: 'Le gestionnaire a été mis à jour avec succès.', type: Users })
   @ApiResponse({ status: 404, description: 'Gestionnaire non trouvé' })
   @ApiResponse({ status: 403, description: 'Accès refusé' })

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

@@ -1,20 +1,13 @@
-import { Test, TestingModule } from '@nestjs/testing';
+import 'reflect-metadata';
 import { UserController } from './user.controller';
-import { UserService } from './user.service';
+import { RoleType } from 'src/entities/users.entity';
 
-describe('UserController', () => {
+describe('UserController roles (#161)', () => {
-  let controller: UserController;
+  it('POST /users/admin autorise SUPER_ADMIN et ADMINISTRATEUR', () => {
-
+    const roles = Reflect.getMetadata('roles', UserController.prototype.createAdmin);
-  beforeEach(async () => {
+    expect(roles).toEqual(
-    const module: TestingModule = await Test.createTestingModule({
+      expect.arrayContaining([RoleType.SUPER_ADMIN, RoleType.ADMINISTRATEUR]),
-      controllers: [UserController],
+    );
-      providers: [UserService],
+    expect(roles).not.toContain(RoleType.GESTIONNAIRE);
-    }).compile();
-
-    controller = module.get<UserController>(UserController);
-  });
-
-  it('should be defined', () => {
-    expect(controller).toBeDefined();
   });
 });

backend/src/routes/user/user.controller.ts

@@ -10,18 +10,22 @@ import { CreateUserDto } from './dto/create_user.dto';
 import { CreateAdminDto } from './dto/create_admin.dto';
 import { UpdateUserDto } from './dto/update_user.dto';
 import { AffecterNumeroDossierDto } from './dto/affecter-numero-dossier.dto';
+import { SuppressionService } from '../suppressions/suppression.service';
 
 @ApiTags('Utilisateurs')
 @ApiBearerAuth('access-token')
 @UseGuards(AuthGuard, RolesGuard)
 @Controller('users')
 export class UserController {
-  constructor(private readonly userService: UserService) { }
+  constructor(
+    private readonly userService: UserService,
+    private readonly suppressionService: SuppressionService,
+  ) { }
 
-  // Création d'un administrateur (réservée aux super admins)
+  // Création d'un administrateur (admin + super admin) — #161
   @Post('admin')
-  @Roles(RoleType.SUPER_ADMIN)
+  @Roles(RoleType.SUPER_ADMIN, RoleType.ADMINISTRATEUR)
-  @ApiOperation({ summary: 'Créer un nouvel administrateur (super admin seulement)' })
+  @ApiOperation({ summary: 'Créer un nouvel administrateur (admin / super admin)' })
   createAdmin(
     @Body() dto: CreateAdminDto,
     @User() currentUser: Users
@@ -146,12 +150,20 @@ export class UserController {
     return this.userService.suspendUser(id, currentUser, comment);
   }
 
-  // Supprimer un utilisateur (super_admin uniquement)
+  // Supprimer un utilisateur — cascades métier #159
   @Delete(':id')
-  @Roles(RoleType.SUPER_ADMIN)
+  @Roles(
-  @ApiOperation({ summary: 'Supprimer un utilisateur' })
+    RoleType.SUPER_ADMIN,
+    RoleType.ADMINISTRATEUR,
+    RoleType.GESTIONNAIRE,
+  )
+  @ApiOperation({
+    summary: 'Supprimer un utilisateur (cascades métier #159)',
+    description:
+      'Parent / AM / staff selon matrice. Gestionnaire ne peut pas supprimer un autre gestionnaire. Self interdit.',
+  })
   @ApiParam({ name: 'id', description: "UUID de l'utilisateur" })
   remove(@Param('id') id: string, @User() currentUser: Users) {
-    return this.userService.remove(id, currentUser);
+    return this.suppressionService.deleteUser(id, currentUser);
   }
 }

backend/src/routes/user/user.module.ts

@@ -12,6 +12,7 @@ import { Parents } from 'src/entities/parents.entity';
 import { GestionnairesModule } from './gestionnaires/gestionnaires.module';
 import { MailModule } from 'src/modules/mail/mail.module';
 import { AppConfigModule } from 'src/modules/config/config.module';
+import { SuppressionsModule } from '../suppressions/suppressions.module';
 
 @Module({
   imports: [TypeOrmModule.forFeature(
@@ -26,6 +27,7 @@ import { AppConfigModule } from 'src/modules/config/config.module';
     GestionnairesModule,
     MailModule,
     AppConfigModule,
+    SuppressionsModule,
   ],
   controllers: [UserController],
   providers: [UserService],

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

@@ -1,18 +1,87 @@
-import { Test, TestingModule } from '@nestjs/testing';
+import { BadRequestException, ForbiddenException } from '@nestjs/common';
 import { UserService } from './user.service';
+import { RoleType, StatutUtilisateurType } from 'src/entities/users.entity';
+
+describe('UserService.createAdmin (#161)', () => {
+  const usersRepository = {
+    findOneBy: jest.fn(),
+    create: jest.fn(),
+    save: jest.fn(),
+  };
 
-describe('UserService', () => {
   let service: UserService;
 
-  beforeEach(async () => {
+  const dto = {
-    const module: TestingModule = await Test.createTestingModule({
+    email: 'nouveau.admin@ptits-pas.fr',
-      providers: [UserService],
+    password: 'Password1!',
-    }).compile();
+    prenom: 'Nina',
+    nom: 'Admin',
+    telephone: '0601020304',
+  };
 
-    service = module.get<UserService>(UserService);
+  beforeEach(() => {
+    jest.clearAllMocks();
+    service = new UserService(
+      usersRepository as never,
+      {} as never,
+      {} as never,
+      {} as never,
+      {} as never,
+      {} as never,
+    );
   });
 
-  it('should be defined', () => {
+  it('autorise un administrateur à créer un admin', async () => {
-    expect(service).toBeDefined();
+    usersRepository.findOneBy.mockResolvedValue(null);
+    usersRepository.create.mockImplementation((data) => data);
+    usersRepository.save.mockImplementation(async (entity) => ({
+      id: 'new-admin',
+      ...entity,
+    }));
+
+    const result = await service.createAdmin(dto as never, {
+      id: 'admin-1',
+      role: RoleType.ADMINISTRATEUR,
+    } as never);
+
+    expect(result.role).toBe(RoleType.ADMINISTRATEUR);
+    expect(result.statut).toBe(StatutUtilisateurType.ACTIF);
+    expect(usersRepository.save).toHaveBeenCalled();
+  });
+
+  it('autorise un super_admin à créer un admin', async () => {
+    usersRepository.findOneBy.mockResolvedValue(null);
+    usersRepository.create.mockImplementation((data) => data);
+    usersRepository.save.mockImplementation(async (entity) => ({
+      id: 'new-admin',
+      ...entity,
+    }));
+
+    await expect(
+      service.createAdmin(dto as never, {
+        id: 'sa-1',
+        role: RoleType.SUPER_ADMIN,
+      } as never),
+    ).resolves.toMatchObject({ role: RoleType.ADMINISTRATEUR });
+  });
+
+  it('refuse un gestionnaire (403 métier)', async () => {
+    await expect(
+      service.createAdmin(dto as never, {
+        id: 'gest-1',
+        role: RoleType.GESTIONNAIRE,
+      } as never),
+    ).rejects.toBeInstanceOf(ForbiddenException);
+    expect(usersRepository.save).not.toHaveBeenCalled();
+  });
+
+  it('refuse un email déjà utilisé', async () => {
+    usersRepository.findOneBy.mockResolvedValue({ id: 'exists' });
+    await expect(
+      service.createAdmin(dto as never, {
+        id: 'admin-1',
+        role: RoleType.ADMINISTRATEUR,
+      } as never),
+    ).rejects.toBeInstanceOf(BadRequestException);
   });
 });

backend/src/routes/user/user.service.ts

@@ -117,8 +117,14 @@ export class UserService {
     }
 
     async createAdmin(dto: CreateAdminDto, currentUser: Users): Promise<Users> {
-        if (currentUser.role !== RoleType.SUPER_ADMIN) {
+        // #161 — admin et super_admin peuvent créer un administrateur
-             throw new ForbiddenException('Seuls les super administrateurs peuvent créer un administrateur');
+        if (
+            currentUser.role !== RoleType.SUPER_ADMIN &&
+            currentUser.role !== RoleType.ADMINISTRATEUR
+        ) {
+            throw new ForbiddenException(
+                'Seuls les administrateurs et super administrateurs peuvent créer un administrateur',
+            );
         }
 
         const exist = await this.usersRepository.findOneBy({ email: dto.email });
@@ -520,6 +526,7 @@ export class UserService {
     }
 
     async remove(id: string, currentUser: Users): Promise<void> {
+        // Délégué historiquement ; préférer SuppressionService via controller (#159).
         if (currentUser.role !== RoleType.SUPER_ADMIN) {
             throw new ForbiddenException('Accès réservé aux super admins');
         }

database/BDD.sql

@@ -174,8 +174,7 @@ CREATE TABLE enfants (
     date_prevue_naissance DATE,
     photo_url TEXT,
     consentement_photo BOOLEAN DEFAULT false,
-    date_consentement_photo TIMESTAMPTZ,
+    date_consentement_photo TIMESTAMPTZ
-    est_multiple BOOLEAN DEFAULT false
 );
 
 -- ==========================================================

database/bdd/data_test/enfants.csv

@@ -1,10 +1,10 @@
-"id","statut","prenom","nom","genre","date_naissance","date_prevue_naissance","photo_url","consentement_photo","date_consentement_photo","est_multiple"
+"id","statut","prenom","nom","genre","date_naissance","date_prevue_naissance","photo_url","consentement_photo","date_consentement_photo"
-"5e8574b7-63e6-4d48-9af3-8d3bf7a6a6cf","sans_garde","Emma","Dupont","F","2020-06-01",,,False,,False
+"5e8574b7-63e6-4d48-9af3-8d3bf7a6a6cf","sans_garde","Emma","Dupont","F","2020-06-01",,,False,
-"a5c3268e-07eb-41a4-9f6c-2f9f16f37c3d","sans_garde",,,,"2020-01-01","2025-01-01",,False,,False
+"a5c3268e-07eb-41a4-9f6c-2f9f16f37c3d","sans_garde",,,,"2020-01-01","2025-01-01",,False,
-"e1a2b3c4-d5e6-4f7a-8b9c-1d2e3f4a5b6c","sans_garde","Emma","Martin",,"2023-02-15",,,False,,False
+"e1a2b3c4-d5e6-4f7a-8b9c-1d2e3f4a5b6c","sans_garde","Emma","Martin",,"2023-02-15",,,False,
-"e2b3c4d5-e6f7-4a8b-9c1d-2e3f4a5b6c7d","sans_garde","Noah","Martin",,"2023-02-15",,,False,,False
+"e2b3c4d5-e6f7-4a8b-9c1d-2e3f4a5b6c7d","sans_garde","Noah","Martin",,"2023-02-15",,,False,
-"e3c4d5e6-f7a8-4b9c-1d2e-3f4a5b6c7d8e","sans_garde","Léa","Martin",,"2023-02-15",,,False,,False
+"e3c4d5e6-f7a8-4b9c-1d2e-3f4a5b6c7d8e","sans_garde","Léa","Martin",,"2023-02-15",,,False,
-"e4d5e6f7-a8b9-4c1d-2e3f-4a5b6c7d8e9f","sans_garde","Chloé","Rousseau",,"2022-04-20",,,False,,False
+"e4d5e6f7-a8b9-4c1d-2e3f-4a5b6c7d8e9f","sans_garde","Chloé","Rousseau",,"2022-04-20",,,False,
-"e5e6f7a8-b9c1-4d2e-3f4a-5b6c7d8e9f1a","sans_garde","Hugo","Rousseau",,"2024-03-10",,,False,,False
+"e5e6f7a8-b9c1-4d2e-3f4a-5b6c7d8e9f1a","sans_garde","Hugo","Rousseau",,"2024-03-10",,,False,
-"e6f7a8b9-c1d2-4e3f-5a6b-7c8d9e0f1a2b","sans_garde","Maxime","Lecomte",,"2023-04-15",,,False,,False
+"e6f7a8b9-c1d2-4e3f-5a6b-7c8d9e0f1a2b","sans_garde","Maxime","Lecomte",,"2023-04-15",,,False,
-"edd19cd1-bb67-4f14-8a37-c66b75c94537","scolarise","Lucas","Durand","H","2018-09-15",,,False,,False
+"edd19cd1-bb67-4f14-8a37-c66b75c94537","scolarise","Lucas","Durand","H","2018-09-15",,,False,

database/migrations/2026_drop_enfants_est_multiple.sql

@@ -0,0 +1,2 @@
+-- #152 — Suppression grossesse multiple / est_multiple
+ALTER TABLE enfants DROP COLUMN IF EXISTS est_multiple;

database/seed/02_seed.sql

@@ -69,12 +69,12 @@ ON CONFLICT (id_utilisateur) DO NOTHING;
 --  - child B : à naître (statut = 'a_naitre' et date_prevue_naissance requise)
 -- ------------------------------------------------------------
 
-INSERT INTO enfants (id, prenom, nom, statut, date_naissance, jumeau_multiple)
+INSERT INTO enfants (id, prenom, nom, statut, date_naissance)
-VALUES ('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', 'Léo', 'Parent', 'sans_garde', '2022-04-12', false)
+VALUES ('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', 'Léo', 'Parent', 'sans_garde', '2022-04-12')
 ON CONFLICT (id) DO NOTHING;
 
-INSERT INTO enfants (id, prenom, nom, statut, date_prevue_naissance, jumeau_multiple)
+INSERT INTO enfants (id, prenom, nom, statut, date_prevue_naissance)
-VALUES ('bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb', 'Mila', 'Parent', 'a_naitre', '2026-02-15', false)
+VALUES ('bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb', 'Mila', 'Parent', 'a_naitre', '2026-02-15')
 ON CONFLICT (id) DO NOTHING;
 
 -- ------------------------------------------------------------

database/seed/03_seed_test_data.sql

@@ -49,14 +49,14 @@ VALUES
 ON CONFLICT (id_utilisateur) DO NOTHING;
 
 -- ========== ENFANTS ==========
-INSERT INTO enfants (id, prenom, nom, genre, date_naissance, statut, est_multiple)
+INSERT INTO enfants (id, prenom, nom, genre, date_naissance, statut)
 VALUES
-  ('e0000001-0001-0001-0001-000000000001', 'Emma', 'MARTIN', 'F', '2023-02-15', 'sans_garde', true),
+  ('e0000001-0001-0001-0001-000000000001', 'Emma', 'MARTIN', 'F', '2023-02-15', 'sans_garde'),
-  ('e0000002-0002-0002-0002-000000000002', 'Noah', 'MARTIN', 'H', '2023-02-15', 'sans_garde', true),
+  ('e0000002-0002-0002-0002-000000000002', 'Noah', 'MARTIN', 'H', '2023-02-15', 'sans_garde'),
-  ('e0000003-0003-0003-0003-000000000003', 'Léa', 'MARTIN', 'F', '2023-02-15', 'sans_garde', true),
+  ('e0000003-0003-0003-0003-000000000003', 'Léa', 'MARTIN', 'F', '2023-02-15', 'sans_garde'),
-  ('e0000004-0004-0004-0004-000000000004', 'Chloé', 'ROUSSEAU', 'F', '2022-04-20', 'sans_garde', false),
+  ('e0000004-0004-0004-0004-000000000004', 'Chloé', 'ROUSSEAU', 'F', '2022-04-20', 'sans_garde'),
-  ('e0000005-0005-0005-0005-000000000005', 'Hugo', 'ROUSSEAU', 'H', '2024-03-10', 'sans_garde', false),
+  ('e0000005-0005-0005-0005-000000000005', 'Hugo', 'ROUSSEAU', 'H', '2024-03-10', 'sans_garde'),
-  ('e0000006-0006-0006-0006-000000000006', 'Maxime', 'LECOMTE', 'H', '2023-04-15', 'sans_garde', false)
+  ('e0000006-0006-0006-0006-000000000006', 'Maxime', 'LECOMTE', 'H', '2023-04-15', 'sans_garde')
 ON CONFLICT (id) DO NOTHING;
 
 -- ========== ENFANTS_PARENTS (liaison N:N) ==========

docs/00_INDEX.md

@@ -1,94 +1,77 @@
-# 📚 Index de la Documentation - PtitsPas App
+# Index de la documentation — P'titsPas
 
-Bienvenue dans la documentation complète de l'application PtitsPas.
+Index de navigation du dépôt. Dernière révision : **septembre 2026** (CDC V1.4 + SRS users #117).
 
-Ce fichier sert d'index pour naviguer dans toute la documentation du projet.
+## Produit & versions
 
-## 📖 Table des matières
+| Doc | Contenu |
+|-----|---------|
+| [01 — Cahier des charges V1.4](./01_CAHIER-DES-CHARGES.md) | CDC **complet** (cible) ; gestion utilisateurs alignée `v0.1.0` |
+| [12 — SRS gestion utilisateurs](./12_SRS-GESTION-UTILISATEURS.md) | Spécification **technique** du domaine users / dossiers |
+| [05 — Versions & milestones](./05_VERSIONS-ET-MILESTONES.md) | Semver Gitea + bilans |
+| [29 — Bilan version 0.1.0](./29_BILAN-VERSION-0.1.0.md) | Tickets livrés 0.1.0 |
+| [04 — Roadmap générale](./04_ROADMAP-GENERALE.md) | Vision phases long terme |
+| [28 — Évolution famille / responsables](./28_EVOLUTION-FAMILLE-ET-RESPONSABLES.md) | Limites modèle foyer / contournements |
 
-### 📋 Cahier des Charges
+## Architecture & infra
-- [**01 - Cahier des Charges**](./01_CAHIER-DES-CHARGES.md) - Cahier des charges complet du projet P'titsPas (V1.3 - 24/11/2025)
 
-### Architecture & Infrastructure
+| Doc | Contenu |
-- [**02 - Architecture**](./02_ARCHITECTURE.md) - Vue d'ensemble de l'architecture mono-repo et multi-conteneurs
+|-----|---------|
-- [**03 - Déploiement**](./03_DEPLOYMENT.md) - Guide complet de déploiement et configuration CI/CD
+| [02 — Architecture](./02_ARCHITECTURE.md) | Mono-repo, conteneurs |
+| [03 — Déploiement](./03_DEPLOYMENT.md) | Deploy / CI-CD |
+| [10 — Database](./10_DATABASE.md) | Schéma BDD |
+| [11 — API](./11_API.md) | Endpoints REST |
+| [21 — Configuration système](./21_CONFIGURATION-SYSTEME.md) | Config on-premise |
+| [99 — Règles de codage](./99_REGLES-CODAGE.md) | Conventions |
 
-### Planification
+## Workflows & métier
-- [**04 - Roadmap Générale**](./04_ROADMAP-GENERALE.md) - Roadmap complète du projet (Phases 1 à 5+)
 
-### Développement
+| Doc | Contenu |
-- [**10 - Database Schema**](./10_DATABASE.md) - Schéma de la base de données et modèles
+|-----|---------|
-- [**11 - API Documentation**](./11_API.md) - Documentation complète des endpoints REST
+| [20 — Workflow création de compte](./20_WORKFLOW-CREATION-COMPTE.md) | Inscription / validation (détail historique) |
-- [**14 - Note backend config setup**](./14_NOTE-BACKEND-CONFIG-SETUP.md) - Setup configuration
+| [juridique/](./juridique/README.md) | CGU / CGC / privacy + [22 technique](./juridique/22_DOCUMENTS-LEGAUX.md) |
-- [**92 - Note backend gestionnaires**](./92_NOTE-BACKEND-GESTIONNAIRES.md) - Gestionnaires
+| [CHARTE_GRAPHIQUE.md](./CHARTE_GRAPHIQUE.md) | Charte UI |
-- [**99 - Règles de codage**](./99_REGLES-CODAGE.md) - Conventions de code
 
-### Workflows Fonctionnels
+## Projet & outillage
-- [**20 - Workflow Création de Compte**](./20_WORKFLOW-CREATION-COMPTE.md) - Workflow complet de création et validation des comptes utilisateurs
-- [**21 - Configuration Système**](./21_CONFIGURATION-SYSTEME.md) - Configuration on-premise dynamique
-- [**22 - Documents Légaux**](./juridique/22_DOCUMENTS-LEGAUX.md) - Gestion CGU/Privacy avec versioning
 
-### Juridique (sources & technique)
+| Doc | Contenu |
-- [**Dossier juridique**](./juridique/README.md) - Index : CGU/CGC en Markdown,
+|-----|---------|
-  export PDF, lien vers la doc technique n°22
+| [23 — Suivi tickets](./23_SUIVI-TICKETS.md) | Pointeur Gitea |
+| [24 — Décisions projet](./24_DECISIONS-PROJET.md) | ADR / décisions |
+| [26 — API Gitea](./26_GITEA-API.md) | Issues, PR, milestones |
+| [27 — Briefing frontend](./27_BRIEFING-FRONTEND.md) | Accès Git, priorités |
 
-### Projet & suivi (Gitea / tickets)
+## Audit
-- [**23 - Liste des Tickets**](./23_LISTE-TICKETS.md) - 61 tickets Phase 1 détaillés
-- [**24 - Décisions Projet**](./24_DECISIONS-PROJET.md) - Décisions architecturales et fonctionnelles
-- [**25 - Backlog Phase 2**](./25_PHASE-2-BACKLOG.md) - Fonctionnalités techniques reportées
-- [**28 - Évolution famille et responsables**](./28_EVOLUTION-FAMILLE-ET-RESPONSABLES.md) - Modèle dossier/famille, recompositions, v1.0.0 vs post-1.0.0
-- [**26 - API Gitea**](./26_GITEA-API.md) - Procédure d'utilisation de l'API Gitea (issues, PR, branches, labels)
-- [**27 - Briefing frontend**](./27_BRIEFING-FRONTEND.md) - Accès Git, priorités, scripts Gitea (token)
 
-### Archive & convention de nommage
+| Doc | Contenu |
-- [**Dossier archive**](./archive/README.md) - Fichiers **sans** `NN_` déplacés
+|-----|---------|
-  (temporaires, obsolètes) ; règles de rangement et suppression
+| [90 — Audit YNOV](./90_AUDIT.md) | Analyse code étudiant |
-- Pointeur : [PROCEDURE-API-GITEA.md](./PROCEDURE-API-GITEA.md) → voir **26**
 
-### Exceptions de nommage (racine `docs/`)
+## Archive
-Fichiers **sans préfixe numérique** encore à la racine par **héritage** ou
-références outils (`.cursorrules`, etc.) — **à renommer** en `NN_` quand
-possible :
-- `CHARTE_GRAPHIQUE.md`
-- [`EVOLUTIONS_CDC.md`](./EVOLUTIONS_CDC.md) — écarts CDC / app ; voir aussi [**28 - Évolution famille**](./28_EVOLUTION-FAMILLE-ET-RESPONSABLES.md)
-- `SuperNounou_Cahier_Des_Charges_Complet_V1.1.md`
-- `SuperNounou_SSS-001.md`
 
-### Administration (À créer)
+| Emplacement | Usage |
-- [**30 - Guide d'administration**](./30_ADMIN.md) - Gestion des utilisateurs, accès PgAdmin, logs
+|-------------|--------|
-- [**31 - Troubleshooting**](./31_TROUBLESHOOTING.md) - Résolution des problèmes courants
+| [archive/](./archive/README.md) | Obsolete / temporaires |
+| [archive/obsolete/](./archive/obsolete/) | CDC V1.3, EVOLUTIONS_CDC, SuperNounou, listes figées |
 
-### Frontend (À créer)
+## Données de test
-- [**40 - Frontend Flutter**](./40_FRONTEND.md) - Structure de l'application mobile/web
 
-### Audit & Analyse
+| Doc | Contenu |
-- [**90 - Audit du projet YNOV**](./90_AUDIT.md) - Analyse complète du code étudiant et fonctionnalités
+|-----|---------|
+| [test-data/](./test-data/README.md) | Jeux utilisateurs test |
 
-## 🚀 Quick Start
+## Quick start
 
 ```bash
-# Cloner le projet
+git clone … ptitspas-app
-git clone ssh://gitea-jmartin/jmartin/app.git ptitspas-app
-
-# Lancer l'environnement de développement
 cd ptitspas-app
 docker compose up -d
-
+# Front https://app.ptits-pas.fr — API /api — PgAdmin /pgadmin
-# Accéder aux services
-Frontend: https://app.ptits-pas.fr
-API: https://app.ptits-pas.fr/api
-PgAdmin: https://app.ptits-pas.fr/pgadmin
 ```
 
-## 🔗 Liens utiles
+## Liens
 
-- **Gitea** : https://git.ptits-pas.fr
+- Gitea : https://git.ptits-pas.fr/jmartin/petitspas  
-- **Production** : https://app.ptits-pas.fr
+- Prod : https://app.ptits-pas.fr  
-- **Mail** : https://mail.ptits-pas.fr
-
-## 📝 Maintenance
-
-Cette documentation est maintenue par Julien Martin (julien.martin@ptits-pas.fr).
-
-Dernière mise à jour : Juin 2026
 
+Mainteneur : Julien Martin (julien.martin@ptits-pas.fr).

docs/01_CAHIER-DES-CHARGES.md

@@ -1,14 +1,19 @@
 ---
 title: "P'titsPas - Cahier des Charges Fonctionnel"
 author: "Julien MARTIN"
-date: "Novembre 2025"
+date: "Septembre 2026"
-version: "v1.3"
+version: "v1.4"
 ---
 
 # P'titsPas – Cahier des Charges Fonctionnel
 
 > **Objet :** Définir le périmètre fonctionnel, les rôles utilisateurs, les processus métiers et les exigences techniques de la plateforme P'titsPas, destinée à accompagner les collectivités locales dans la gestion de la garde d’enfants.
 
+> **V1.4 (sept. 2026)** — Mise à jour de la **gestion des utilisateurs / dossiers / validation** pour coller au livré produit **`v0.1.0`**. Le reste du CDC (contrats, messagerie, agenda, paie, recherche AM, etc.) est **conservé** comme cible fonctionnelle.  
+> Détail technique du domaine utilisateurs : [12_SRS-GESTION-UTILISATEURS.md](./12_SRS-GESTION-UTILISATEURS.md).  
+> Bilan tickets `v0.1.0` : [29_BILAN-VERSION-0.1.0.md](./29_BILAN-VERSION-0.1.0.md).  
+> Archive V1.3 : [archive/obsolete/01_CAHIER-DES-CHARGES-v1.3.md](./archive/obsolete/01_CAHIER-DES-CHARGES-v1.3.md).
+
 ---
 
 ## Historique des versions
@@ -19,6 +24,7 @@ version: "v1.3"
 | 1.1     | 24/04/2025 | Julien MARTIN  | Ajouts : gestion multi-enfants, fin de contrat, tableau de bord étendu |
 | 1.2     | 26/05/2025 | Julien MARTIN  | Remplacement de "SuperNounou" par "P'titsPas" |
 | 1.3     | 24/11/2025 | Julien MARTIN  | Correction : retrait photo de profil parent (section 3.1.1) |
+| **1.4** | **15/09/2026** | Julien MARTIN  | **Gestion utilisateurs** alignée `v0.1.0` (dossiers, validation/refus/reprise, fiches staff, suppressions, retrait naissance multiple & SMS) ; reste du CDC inchangé en cible |
 
 ---
 
@@ -42,6 +48,8 @@ version: "v1.3"
 ### 3.4 Création d’un administrateur  
 ### 3.5 Fiche enfant  
 ### 3.6 Authentification et sécurité  
+### 3.7 Numéro de dossier, validation, refus et reprise  
+### 3.8 Suppressions (vue métier)  
 
 ## 4. Tableaux de bord  
 ### 4.1 Vue d’ensemble  
@@ -60,15 +68,15 @@ version: "v1.3"
 #### 4.3.5 Heures supplémentaires  
 #### 4.3.6 Messagerie  
 ### 4.4 Tableau de bord des gestionnaires  
-#### 4.4.1 Comptes à valider  
+#### 4.4.1 Dossiers à valider  
-#### 4.4.2 Liste des utilisateurs  
+#### 4.4.2 Gestion des utilisateurs (partagée)  
 #### 4.4.3 Contrats  
 #### 4.4.4 Messagerie  
 #### 4.4.5 Événements RPE  
 #### 4.4.6 Alertes  
 ### 4.5 Tableau de bord des administrateurs  
 #### 4.5.1 Menu Profil  
-#### 4.5.2 Gestion des utilisateurs  
+#### 4.5.2 Gestion des utilisateurs (partagée admin + gestionnaire)  
 #### 4.5.3 Gestion des enfants  
 #### 4.5.4 Paramètres de la plateforme  
 #### 4.5.5 Statistiques et supervision  
@@ -193,18 +201,23 @@ Les assistantes maternelles peuvent :
 
 Les gestionnaires (responsables de relais petite enfance) disposent d’un tableau de bord de supervision. Ils peuvent :
 
-- Valider ou rejeter les demandes de création de compte
+- Valider ou refuser les **dossiers** (inscriptions parent / AM) et accompagner les reprises
-- Suivre les mises en relation et les contrats
+- Gérer les usagers (fiches parent / AM / enfant, rattachements, dossiers) — socle partagé avec l’admin
-- Organiser des événements ou des rendez-vous
+- Suivre les mises en relation et les contrats (cible CDC)
-- Gérer les conflits ou les fins de contrat
+- Organiser des événements ou des rendez-vous (cible CDC)
+- Gérer les conflits ou les fins de contrat (cible CDC)
 - Lancer des sondages ou modérer un blog RPE (si activé)
 - Voir les historiques et statistiques liés à leur périmètre
 
+Ils **ne créent pas** les comptes gestionnaire / administrateur (réservé à l’admin).
+
 ### 2.1.4 Administrateurs
 
 Les administrateurs sont les représentants techniques et institutionnels de la collectivité (DSI ou agents désignés). Ils peuvent :
 
-- Créer ou supprimer des comptes (gestionnaires, parents, assistantes maternelles)
+- Tout ce que peut faire un gestionnaire sur les usagers / dossiers
+- Créer ou supprimer des comptes **staff** (gestionnaires, administrateurs) selon garde-fous
+- Créer ou supprimer des comptes usagers (parents, AM, enfants) selon droits
 - Personnaliser l’interface (logo, couleurs, nom de la ville)
 - Activer ou désactiver des modules complémentaires
 - Consulter les statistiques d’usage
@@ -245,12 +258,15 @@ Le parcours de création d’un compte parent s’effectue en plusieurs étapes
 **Note** : Le parent 2 ne définit **pas** de mot de passe lors de l'inscription. Il recevra un email avec un lien pour créer son mot de passe après validation du gestionnaire. Cette approche est particulièrement adaptée aux situations de parents séparés ou divorcés où la communication peut être difficile.
 
 ### 3.1.3 Informations sur l'enfant
+- Un ou **plusieurs** enfants peuvent être ajoutés
 - Prénom (facultatif si enfant à naître)
 - Nom (hérité des parents)
-- Genre (H / F) - obligatoire
+- Genre (H / F / Autre) — obligatoire
 - Date de naissance ou **date prévisionnelle de naissance** (si l'enfant n'est pas encore né, un switch modifie le label)
-- Photo obligatoire si l'enfant est né
+- Photo (selon règles d’inscription) et **consentement photo**
-- Rattachement automatique aux deux parents
+- Rattachement automatique au parent 1 et au parent 2 s’il est renseigné
+
+**Note V1.4** : il n’existe **pas** de champ « naissance multiple / jumeaux » (retiré du produit).
 
 ### 3.1.4 Présentation du dossier
 - Zone de texte libre permettant aux parents de décrire leur situation
@@ -265,10 +281,12 @@ Le parcours de création d’un compte parent s’effectue en plusieurs étapes
 ### 3.1.6 Récapitulatif et validation
 - Résumé des données saisies
 - Vérification, puis envoi de la demande
+- Attribution d’un **numéro de dossier** (format type AAAA-NNNNNN)
 - Les comptes parent sont soumis à validation par un gestionnaire avant activation
-- Une fois validé, chaque parent (Parent 1 et Parent 2 si renseigné) reçoit un e-mail ou un SMS contenant un lien pour créer son mot de passe
+- Une fois validé, chaque parent (Parent 1 et Parent 2 si renseigné) reçoit un **e-mail** contenant un lien pour créer son mot de passe
-- Le lien est valable pendant 7 jours
+- Le lien est valable pendant une durée limitée (jeton à usage unique)
 - Une fois le mot de passe créé, le parent peut se connecter à son espace
+- En cas de **refus**, le dossier n’est pas supprimé : l’usager peut **reprendre** sa demande (lien e-mail ou numéro de dossier) — voir §3.7
 
 ## 3.2 Création de compte assistante maternelle
 
@@ -298,7 +316,7 @@ Ce parcours est divisé en deux panneaux.
 - Champ libre : message à destination du gestionnaire
 - Permet de justifier une demande ou d’ajouter des précisions
 
-### 3.1.4 – Acceptation des CGU
+### 3.2.4 – Acceptation des CGU
 - Les utilisateurs doivent cocher la case  
   « J’ai lu et j’accepte les Conditions Générales d’Utilisation et la Politique de confidentialité ».  
 - Un lien direct ouvre la version PDF des CGU.  
@@ -307,23 +325,26 @@ Ce parcours est divisé en deux panneaux.
 ### 3.2.5 Récapitulatif et validation
 - Résumé des données saisies
 - Vérification, puis envoi de la demande
+- Attribution d’un **numéro de dossier**
 - Validation par un gestionnaire requise avant activation
-- Une fois validé, l'assistante maternelle reçoit un e-mail ou un SMS contenant un lien pour créer son mot de passe
+- Une fois validé, l'assistante maternelle reçoit un **e-mail** contenant un lien pour créer son mot de passe
-- Le lien est valable pendant 7 jours
+- Le lien est valable pendant une durée limitée (jeton à usage unique)
 - Une fois le mot de passe créé, l'assistante maternelle peut se connecter à son espace
+- En cas de **refus** : reprise possible — voir §3.7
 
 ## 3.3 Création d’un gestionnaire
 
-- Réalisée par un administrateur
+- Réalisée par un **administrateur** (ou super administrateur) — un gestionnaire ne crée pas de comptes staff
-- Champs obligatoires : nom, prénom, adresse e-mail, mot de passe
+- Champs : nom, prénom, e-mail, téléphone, mot de passe, **relais principal** (optionnel)
-- Affectation à un ou plusieurs relais petite enfance
+- Le mot de passe peut être modifié à la première connexion si la politique l’exige
-- Le mot de passe doit être modifié lors de la première connexion
+- Formulaire unifié de création / édition (même présentation que pour les administrateurs)
 
 ## 3.4 Création d’un administrateur
 
-- Seuls les administrateurs existants peuvent créer de nouveaux comptes administrateurs
+- Seuls les **administrateurs** (et super administrateur) peuvent créer de nouveaux comptes administrateurs
-- Les droits sont équivalents (possibilité de restreindre par périmètre dans une version multi-mairies)
+- Champs : nom, prénom, e-mail, téléphone, mot de passe (pas de relais)
-- Obligation de changer le mot de passe à la première connexion
+- Les droits sont équivalents entre administrateurs (le **super administrateur** est un compte d’installation non supprimable)
+- Obligation de changer le mot de passe à la première connexion si exigé
 
 ## 3.5 Fiche enfant
 
@@ -331,22 +352,68 @@ Chaque enfant est représenté par une fiche :
 
 - Prénom (facultatif si enfant à naître)
 - Nom
-- Genre (H / F) - obligatoire
+- Genre (H / F / Autre) — obligatoire
 - Date de naissance ou date prévisionnelle
-- Photo (obligatoire si l'enfant est né ET si l'option *Photo obligatoire* est activée)  
+- Photo et consentement photo selon configuration (consentement tracé)
-- Consentement photo enregistré : valeur booléenne + horodatage liés à l'accord donné par le parent
+- Statut : à naître / actif / scolarisé (évolutions de libellés possibles ultérieurement)
-- Statut : à naître / actif / scolarisé
+- Responsables (parents) rattachés — liens vers les fiches parent
-- Indication possible : jumeaux, triplés, etc.
+- Assistante maternelle de rattachement (le cas échéant)
-- Possibilité de rattacher un enfant à plusieurs parents (garde alternée)
+
+**Note V1.4** : pas d’indication « jumeaux / triplés » comme champ dédié.
+
+Les fiches enfants sont :
+- Accessibles depuis la fiche parent, la fiche AM, l’onglet **Enfants** du dashboard staff
+- Créables par le staff pour un foyer existant
+- Partagées entre les responsables rattachés
 
 ## 3.6 Authentification et sécurité
 
-- Tous les comptes utilisent une combinaison adresse e-mail + mot de passe
+- Authentification par e-mail + mot de passe
-- Les gestionnaires et administrateurs doivent modifier leur mot de passe à la première connexion
+- Comptes **en attente** ou **suspendus** : connexion refusée
-- Des mécanismes de récupération sont disponibles en cas de perte
+- Les gestionnaires et administrateurs doivent modifier leur mot de passe à la première connexion (si exigé)
+- **Création de mot de passe** post-validation : lien e-mail (jeton TTL, usage unique)
+- **Mot de passe oublié** : parcours distinct (demande → e-mail → réinitialisation)
+- Pas d’envoi de lien de mot de passe par SMS (canal **e-mail** uniquement)
 
 Un lien direct vers les **Mentions légales** et la **Politique de confidentialité** est accessible en permanence depuis le pied de page, y compris avant la connexion.
 
+## 3.7 Numéro de dossier, validation, refus et reprise
+
+### Numéro de dossier
+- Format type **AAAA-NNNNNN**
+- Affiché dans les listes staff, les modales et les e-mails concernés
+- Sert de clé métier pour validation, refus et reprise
+
+### Validation
+- Le staff (gestionnaire / administrateur) examine le dossier (wizard de revue)
+- Action **Valider** : activation du circuit comptes + e-mails de création de mot de passe
+
+### Refus
+- Action **Refuser** : le dossier est refusé **sans suppression** des données
+- L’usager est informé par e-mail et peut reprendre sa demande
+
+### Reprise
+- Via le **lien** reçu par e-mail, ou depuis l’écran de connexion avec le **numéro de dossier**
+- Formulaire prérempli / correction des informations
+- Nouvelle soumission → retour en file « à valider »
+
+### Création et édition de dossiers par le staff
+- En plus de l’inscription publique, le staff peut **créer** un dossier famille ou AM (wizard)
+- Le staff peut **éditer** un dossier existant (y compris ajout d’un 2ᵉ parent pour une famille mono-parent)
+
+## 3.8 Suppressions (vue métier)
+
+Sous réserve des droits (détail technique : [SRS gestion utilisateurs](./12_SRS-GESTION-UTILISATEURS.md)) :
+
+| Cible | Principe |
+|-------|----------|
+| Parent, AM, enfant, dossier | Gestionnaire, administrateur, super admin — avec confirmation |
+| Gestionnaire | Administrateur / super admin uniquement |
+| Administrateur | Admin / super admin, hors soi-même, hors cible super admin ; garde-fou sur le dernier administrateur |
+| Super administrateur | Non supprimable |
+
+Un gestionnaire ne peut pas supprimer **son propre** compte.
+
 # 4. Tableaux de bord
 
 Chaque rôle utilisateur dispose d’un tableau de bord personnalisé, adapté à ses fonctions dans la plateforme. Ces interfaces sont pensées pour être lisibles, fonctionnelles et évolutives.
@@ -357,8 +424,8 @@ Chaque rôle utilisateur dispose d’un tableau de bord personnalisé, adapté
 |------------------------|-------------------------------------------------------------------|
 | Parents                | Recherche d'assistante maternelle, gestion des enfants, contrat, agenda         |
 | Assistantes maternelles| Dossiers reçus, enfants accueillis, heures sup, agenda, messagerie|
-| Gestionnaires          | Validation de comptes, contrats, messagerie, événements RPE       |
+| Gestionnaires          | Dossiers à valider, gestion utilisateurs/enfants (partagée), contrats, messagerie, événements RPE |
-| Administrateurs        | Paramètres globaux, gestion des utilisateurs, statistiques        |
+| Administrateurs        | Paramètres globaux, même gestion utilisateurs (droits staff élargis), statistiques        |
 
 Les tableaux de bord intègrent :
 - Une **barre de navigation supérieure** (liens de navigation rapide)
@@ -502,17 +569,24 @@ L’assistante maternelle accède à une interface dédiée à la gestion de ses
 
 Le gestionnaire RPE dispose d’une vision transversale sur les utilisateurs, les dossiers et les activités de la structure. Son rôle est d'accompagner, superviser, et arbitrer si nécessaire.
 
-### 4.4.1 Comptes à valider
+### 4.4.1 Dossiers à valider
 
-- File d’attente des demandes de création de compte
+- File d’attente des **dossiers** (famille / AM) en attente de validation
-- Détails de chaque demande : parent, assistante maternelle
+- Affichage du **numéro de dossier** et des informations essentielles
-- Actions possibles : Valider / Refuser / Demander des précisions
+- Ouverture en **revue** (wizard étapes) : Valider / Refuser
+- Le refus n’efface pas le dossier : l’usager peut reprendre (voir §3.7)
+- L’onglet **Dossiers** du dashboard regroupe aussi une **liste unifiée** des dossiers (au-delà de la seule file « à valider »)
 
-### 4.4.2 Liste des utilisateurs
+### 4.4.2 Gestion des utilisateurs (partagée)
 
-- Filtres par rôle, statut, date d’inscription
+> **V1.4** — La gestion opérationnelle des usagers (parents, AM, enfants, dossiers) est **partagée** entre gestionnaire et administrateur via le même dashboard. Seule la gestion des **comptes staff** (création / suppression gestionnaire ou admin) est réservée à l’administrateur.
-- Accès rapide aux informations et historiques
+
-- Possibilité de contacter un utilisateur
+- Onglets : Parents, Assistantes maternelles, Enfants, Gestionnaires (selon droits), Administrateurs (admin)
+- Accès aux **fiches** (identité, rattachements, capacité AM, etc.)
+- Création de dossiers / enfants par le staff
+- Filtres et recherche ; ouverture des fiches depuis les cartes / listes
+
+Le détail des panneaux admin historiques est décrit en §4.5.2 (même socle fonctionnel).
 
 ### 4.4.3 Contrats
 
@@ -566,47 +640,56 @@ Le menu profil de l’administrateur comprend uniquement :
 
 Toutes les fonctionnalités de gestion sont accessibles via des onglets distincts dans le tableau de bord.
 
-### 4.5.2 Gestion des utilisateurs
+### 4.5.2 Gestion des utilisateurs (partagée admin + gestionnaire)
 
-L’administration des utilisateurs est organisée par panneaux distincts pour chaque type de profil.
+L’administration des utilisateurs est organisée par panneaux / onglets. **Admin et gestionnaire** partagent les panneaux usagers ; l’admin dispose en plus des droits staff.
 
 #### a. Gestion des gestionnaires
 - Liste des gestionnaires existants
-- Création (nom, prénom, e-mail, mot de passe)
+- Création / édition (nom, prénom, e-mail, téléphone, mot de passe, relais principal) — **administrateur uniquement** pour la création
-- Attribution à un ou plusieurs RPE
+- Réinitialisation / nouveau mot de passe en édition
-- Réinitialisation du mot de passe
+- Suppression du compte — **administrateur uniquement** (pas d’auto-suppression)
-- Suppression du compte
 
 #### b. Gestion des parents
-- Liste complète des parents enregistrés
+- Liste des parents enregistrés
-- Recherche par nom, statut, enfants associés
+- Ouverture de la **fiche parent** (identité, statut, enfants, lien co-parent)
-- Modification des informations
+- Rattacher / détacher un enfant
-- Suppression d’un compte
+- Création de dossier famille (wizard staff)
-- Consultation du statut des dossiers liés
+- Suppression d’un compte / dossier selon droits (§3.8)
 
 #### c. Gestion des assistantes maternelles
-- Liste des assistantes avec numéro d’agrément
+- Liste des AM (agrément, capacité, etc.)
-- Modification ou suppression d’un compte
+- **Fiche AM** (identité, professionnel, enfants accueillis)
-- Filtrage par zone géographique ou capacité
+- Respect de la **capacité max** pour les rattachements
+- Création de dossier AM (wizard staff)
+- Suppression selon droits
 
 #### d. Gestion des administrateurs
-- Création de nouveaux comptes administrateurs
+- Création de nouveaux comptes administrateurs — **administrateur / super admin**
 - Suivi des droits
-- Obligation de modification du mot de passe à la première connexion
+- Obligation de modification du mot de passe à la première connexion si exigé
+- Suppression avec garde-fous (pas soi-même, pas le super admin, dernier admin)
+
+#### e. Onglet Dossiers
+- Liste unifiée + dossiers à valider
+- Revue / édition des dossiers (wizards)
 
 ### 4.5.3 Gestion des enfants
 
 Deux accès possibles à la gestion des enfants :
 
-#### a. Par fiche parent
+#### a. Par fiche parent (ou fiche AM)
-- Consultation et édition des enfants associés à chaque parent
+- Consultation et édition des enfants associés
+- Rattacher / détacher depuis la fiche
 
 #### b. Vue globale “Enfants”
 - Liste complète avec :
   - Nom, prénom, date de naissance ou prévisionnelle
   - Statut (à naître, actif, scolarisé)
-  - Parents associés
+  - Parents associés (alerte si **sans responsable**)
-  - Contrat en cours (si applicable)
+  - AM associée le cas échéant
+  - Contrat en cours (si applicable — module contrats)
+- Création d’un enfant rattaché à un **foyer existant**
 - Possibilité de modifier ou supprimer une fiche enfant
 
 ### 4.5.4 Paramètres de la plateforme
@@ -905,10 +988,10 @@ Certains outils de la plateforme sont accessibles à plusieurs profils et favori
   - Le gestionnaire (à titre d’information)
 - Contient :
   - Identité
-  - Photo (obligatoire si né)
+  - Photo (selon configuration / consentement)
   - Statut (à naître / actif / scolarisé)
   - Parents associés
-  - Mention s’il s’agit de jumeaux, triplés, etc.
+  - AM associée le cas échéant
 
 ## 6.4 Contrats et avenants
 
@@ -1185,11 +1268,11 @@ P'titsPas s’inscrit dans une démarche de service public, avec des fondements
 | **Gestionnaires**       | Suivi global des situations, outils de médiation, organisation d’événements |
 | **Administrateurs**     | Supervision complète, gouvernance multi-rôle, contrôle des données       |
 
-## 10.3 Périmètre fonctionnel de la V1
+## 10.3 Périmètre fonctionnel
 
-Fonctionnalités incluses dès la première version :
+**Cible CDC (plateforme complète)** — fonctionnalités décrites dans ce document :
-- Création de comptes
+- Création de comptes et gestion des utilisateurs / dossiers
-- Recherche et sélection de nounous
+- Recherche et sélection d’assistantes maternelles
 - Suivi des dossiers
 - Génération de contrat et avenants
 - Messagerie
@@ -1198,6 +1281,8 @@ Fonctionnalités incluses dès la première version :
 - Gestion des heures supplémentaires
 - Suivi RGPD et administration
 
+**Livré produit `v0.1.0`** (voir [bilan](./29_BILAN-VERSION-0.1.0.md)) : cœur **gestion des utilisateurs** — inscription, validation/refus/reprise, auth, dashboard staff (dossiers, fiches, rattachements, suppressions). Les autres modules du CDC restent la **feuille de route**.
+
 ## 10.4 Perspectives
 
 La structure du produit permet une montée en charge progressive :

docs/04_ROADMAP-GENERALE.md

@@ -44,22 +44,21 @@ Les **Phases 2, 3, 4+** sont des **ébauches indicatives** qui seront affinées
 - ✅ Logging & Monitoring
 - ✅ Tests & Documentation
 
-### Versions incrémentales
+### Versions incrémentales (semver / Gitea)
 
-| Version | Objectif | Tickets | Estimation |
+La table historique « ~21 tickets / 0.1.0 » est **obsolète**.  
-|---------|----------|---------|------------|
+État réel des milestones, bilans et tag : **[05_VERSIONS-ET-MILESTONES.md](./05_VERSIONS-ET-MILESTONES.md)**.
-| **0.1.0** | MVP Fonctionnel | ~21 | ~45h |
-| **0.2.0** | Sécurité & RGPD | ~10 | ~35h |
-| **0.3.0** | Interfaces Complètes | ~17 | ~52h |
-| **0.4.0** | Tests & Documentation | ~6 | ~24h |
-| **0.5.0** | Monitoring & Optimisations | ~7 | ~17h |
-| **1.0.0** | 🎉 **Release Phase 1** | **61** | **~173h** |
 
-### Livrable
+| Version | Statut (sept. 2026) |
+|---------|---------------------|
+| **0.1.0** | **Terminée** — [bilan](./29_BILAN-VERSION-0.1.0.md) (48 tickets fermés) |
+| **0.2.0+** | Ouvertes — voir Gitea + doc 05 |
 
-Application installable avec création et validation de comptes utilisateurs.
+### Livrable Phase 1 (visée)
 
-**Référence** : [23_LISTE-TICKETS.md](./23_LISTE-TICKETS.md)
+Application installable avec création et validation de comptes utilisateurs, puis enrichissements dashboard / dossiers (0.1.0 livré).
+
+**Tickets** : Gitea — pointeur [23_SUIVI-TICKETS.md](./23_SUIVI-TICKETS.md).
 
 ---
 
@@ -216,7 +215,7 @@ Suivi quotidien des enfants + Fonctionnalités complémentaires.
 
 Application mature, optimisée et riche en fonctionnalités.
 
-**Référence** : [25_PHASE-2-BACKLOG.md](./25_PHASE-2-BACKLOG.md) (anciennes fonctionnalités techniques)
+**Référence** : [archive/obsolete/25_PHASE-2-BACKLOG.md](./archive/obsolete/25_PHASE-2-BACKLOG.md) (figé) + [05_VERSIONS-ET-MILESTONES.md](./05_VERSIONS-ET-MILESTONES.md)
 
 ---
 
@@ -317,9 +316,10 @@ Exemples :
 - [00_INDEX.md](./00_INDEX.md) - Index général de la documentation
 - [01_CAHIER-DES-CHARGES.md](./01_CAHIER-DES-CHARGES.md) - Cahier des charges v1.3
 - [20_WORKFLOW-CREATION-COMPTE.md](./20_WORKFLOW-CREATION-COMPTE.md) - Workflow création de comptes
-- [23_LISTE-TICKETS.md](./23_LISTE-TICKETS.md) - Liste des 61 tickets Phase 1
+- [23_SUIVI-TICKETS.md](./23_SUIVI-TICKETS.md) / [29_BILAN-VERSION-0.1.0.md](./29_BILAN-VERSION-0.1.0.md) — suivi Gitea + bilan 0.1.0
 - [24_DECISIONS-PROJET.md](./24_DECISIONS-PROJET.md) - Décisions architecturales
-- [25_PHASE-2-BACKLOG.md](./25_PHASE-2-BACKLOG.md) - Anciennes fonctionnalités techniques
+- [05_VERSIONS-ET-MILESTONES.md](./05_VERSIONS-ET-MILESTONES.md) — milestones Gitea
+- [archive/obsolete/25_PHASE-2-BACKLOG.md](./archive/obsolete/25_PHASE-2-BACKLOG.md) — backlog Phase 2 figé
 
 ---
 

docs/05_VERSIONS-ET-MILESTONES.md

@@ -0,0 +1,64 @@
+# Versions & milestones — P'titsPas
+
+**Source de vérité tickets** : Gitea [`jmartin/petitspas`](https://git.ptits-pas.fr/jmartin/petitspas)  
+**Bilans de version** : documents `29_BILAN-…` (et suivants)
+
+Ce fichier remplace, pour le **semver / milestones**, les anciennes tables figées de la roadmap Phase 1.
+
+---
+
+## État des milestones
+
+| Milestone | Rôle | Statut |
+|-----------|------|--------|
+| **0.1.0** | MVP opérable (auth, inscription, dashboard dossiers/fiches, suppressions, cleanups) | **Terminée** — [bilan](./29_BILAN-VERSION-0.1.0.md) |
+| **0.2.0** | Suite produit (ex. recherche / échanges — sans contrat) | Ouverte |
+| **0.3.0** | Contrat + planning | Ouverte |
+| **0.4.0** | Carnet de liaison | Ouverte |
+| **0.9.0** | Hors périmètre cleanup 0.1.0 (doublons, upload, tech auth/photos, UX erreurs…) | Ouverte |
+| **1.0.0** | Release majeure Phase 1 (critères PO) | Réserve |
+| **Backlog transverse** | Doc étendue, CI/tests, RGPD avancé, monitoring — hors semver dédié | Ouverte |
+
+Liens Gitea : [milestones](https://git.ptits-pas.fr/jmartin/petitspas/milestones).
+
+---
+
+## Bilans
+
+| Version | Document |
+|---------|----------|
+| 0.1.0 | [29_BILAN-VERSION-0.1.0.md](./29_BILAN-VERSION-0.1.0.md) |
+
+## Documents produit de référence (post-0.1.0)
+
+| Doc | Rôle |
+|-----|------|
+| [01_CAHIER-DES-CHARGES.md](./01_CAHIER-DES-CHARGES.md) | CDC **complet** V1.4 (users mis à jour ; reste = cible) |
+| [12_SRS-GESTION-UTILISATEURS.md](./12_SRS-GESTION-UTILISATEURS.md) | SRS technique domaine utilisateurs |
+| Archive CDC V1.3 | [archive/obsolete/01_CAHIER-DES-CHARGES-v1.3.md](./archive/obsolete/01_CAHIER-DES-CHARGES-v1.3.md) |
+
+---
+
+## Relation avec la roadmap phases
+
+La vision long terme (Phases 2–5 : mise en relation, contrats, carnet…) reste dans [04_ROADMAP-GENERALE.md](./04_ROADMAP-GENERALE.md).  
+Les **jalons livrables** se gèrent ici + dans Gitea.
+
+Ancien backlog « Phase 2 » technique ([archive](./archive/obsolete/25_PHASE-2-BACKLOG.md)) : à croiser avec les milestones ci-dessus ; ne plus maintenir en double.
+
+---
+
+## Suivi des tickets
+
+- **Création / état** : Gitea uniquement.
+- **Mémoire d’une version livrée** : bilan `29_…` (pas de re-copie exhaustive dans un fichier tickets).
+- Ancienne liste figée Phase 1 : [archive/obsolete/23_LISTE-TICKETS.md](./archive/obsolete/23_LISTE-TICKETS.md).
+- Pointeur court : [23_SUIVI-TICKETS.md](./23_SUIVI-TICKETS.md).
+
+---
+
+## Tag Git
+
+| Tag | Condition |
+|-----|-----------|
+| `v0.1.0` | Milestone 0.1.0 fermée + bilan mergé sur `master` |

docs/10_DATABASE.md

@@ -117,7 +117,6 @@ Table des enfants pris en charge.
 | `photo_url` | TEXT | | URL de la photo |
 | `consentement_photo` | BOOLEAN | DEFAULT false | Consentement photo |
 | `date_consentement_photo` | TIMESTAMPTZ | | Date du consentement |
-| `est_multiple` | BOOLEAN | DEFAULT false | Indique si grossesse multiple |
 
 ---
 

docs/12_SRS-GESTION-UTILISATEURS.md

@@ -0,0 +1,250 @@
+# SRS — Gestion des utilisateurs (domaine livré v0.1.0)
+
+**Version** : 1.0  
+**Date** : 15/09/2026  
+**Ticket** : [#117](https://git.ptits-pas.fr/jmartin/petitspas/issues/117)  
+**Niveau** : **technique** (dev / QA)  
+**CDC associé** : [01_CAHIER-DES-CHARGES.md](./01_CAHIER-DES-CHARGES.md) (V1.4 — **CDC complet** ; cette SRS ne couvre que le domaine utilisateurs)
+
+> Périmètre SRS : comptes, auth liée, dossiers famille/AM, enfants, affiliations, dashboard staff, suppressions.  
+> Le CDC V1.4 conserve **l’ensemble** des chapitres cibles (contrats, messagerie, etc.) ; ils ne sont **pas** redécrits ici.  
+> Hors SRS technique : OpenAPI exhaustif, PRA/CI → voir [11_API](./11_API.md), [10_DATABASE](./10_DATABASE.md).
+
+---
+
+## 1. Glossaire
+
+| Terme | Définition |
+|-------|------------|
+| **User / utilisateur** | Compte authentifiable (`utilisateurs`) avec `role` et `statut` |
+| **Parent pivot** | Responsable principal du foyer à l’inscription / création staff |
+| **Co-parent** | Second responsable optionnel (au plus un), lié au pivot |
+| **Foyer** | Pivot + co-parent éventuel + enfants affiliés |
+| **Dossier** | Unité métier identifiée par `numero_dossier` (format `AAAA-NNNNNN`) — famille ou AM |
+| **Pending / en_attente** | Compte ou dossier en attente de validation staff |
+| **Refus** | Rejet sans suppression ; ouvre la **reprise** |
+| **Relais** | Structure RPE ; rattachement optionnel d’un gestionnaire |
+| **Staff** | `gestionnaire`, `administrateur`, `super_admin` |
+
+---
+
+## 2. Acteurs et rôles applicatifs
+
+| `role` | Inscription publique | Dashboard staff | Créer staff | Suppressions métier usagers | Supprimer gestionnaire | Supprimer admin |
+|--------|---------------------|-----------------|-------------|----------------------------|------------------------|-----------------|
+| `parent` | oui | non | non | non | non | non |
+| `assistante_maternelle` | oui | non | non | non | non | non |
+| `gestionnaire` | non (créé staff) | oui | non | oui* | non | non |
+| `administrateur` | non | oui | oui | oui* | oui | oui** |
+| `super_admin` | non (install) | oui | oui | oui* | oui | oui** |
+
+\* Sous réserve des garde-fous (pas soi-même pour sa fiche staff, etc.).  
+\*\* Pas soi-même ; pas de cible `super_admin` ; dernier admin : règles `canDeleteAdministrateur` (front `staff_deletion_rights.dart`).
+
+Réf. front : `frontend/lib/utils/staff_deletion_rights.dart`  
+- `canCreateStaffAccounts` → admin / super_admin  
+- `canDeleteMetier` → gestionnaire / admin / super_admin  
+- `canDeleteGestionnaire` → admin / super_admin  
+
+---
+
+## 3. Statuts
+
+### 3.1 Utilisateur (`statut_utilisateur_type`)
+
+| Statut | Signification |
+|--------|----------------|
+| `en_attente` | Inscrit, non validé ; **login refusé** |
+| `actif` | Validé / utilisable |
+| `suspendu` | Bloqué ; **login refusé** |
+
+### 3.2 Enfant (`statut_enfant_type`)
+
+Valeurs actuelles : `a_naitre`, `actif`, `scolarise` (évolution métier « gardé / sans garde » **hors** cette SRS — ticket dédié).
+
+### 3.3 Validation dossier
+
+Circuit staff : revue → **valider** ou **refuser**. Refus ≠ delete. Reprise → nouveau passage en attente.
+
+---
+
+## 4. Modèle de données (vue synthétique)
+
+```mermaid
+flowchart TB
+  user[utilisateurs]
+  parent[parents]
+  am[assistantes_maternelles]
+  enfant[enfants]
+  ep[enfants_parents]
+  df[dossier_famille]
+  user --> parent
+  user --> am
+  parent --> ep
+  enfant --> ep
+  parent --> df
+```
+
+| Concept | Tables / liens clés |
+|---------|---------------------|
+| Compte | `utilisateurs` (role, statut, email, numero_dossier, relais…) |
+| Parent | `parents` (+ `id_co_parent` optionnel) |
+| AM | `assistantes_maternelles` (agrément, capacité, NIR…) |
+| Enfant | `enfants` |
+| Affiliation parent | `enfants_parents` (N–N) |
+| Dossier famille | `dossier_famille` (+ enfants dossier) |
+| Tokens MDP | tables / flux tokens création & reset (TTL, usage unique) |
+
+Détail colonnes : [10_DATABASE.md](./10_DATABASE.md).
+
+### Invariants
+
+1. **Pas** de champ `est_multiple` / naissance multiple (#152).  
+2. Au plus **un** co-parent par fiche parent.  
+3. Affiliation création enfant : rattache **pivot + co-parent** s’il existe (#158).  
+4. Détachement du **dernier** parent → enfant **sans responsable** possible (#157).  
+5. Rattachement AM plafonné par **capacité** (#148 / #149).  
+6. `super_admin` **non supprimable**.
+
+---
+
+## 5. Flux
+
+### 5.1 Inscription → validation → mot de passe
+
+```mermaid
+sequenceDiagram
+  participant U as Usager
+  participant API as API
+  participant S as Staff
+  participant M as Mail
+  U->>API: register parent/AM
+  API-->>U: numero_dossier, statut en_attente
+  S->>API: review / valider
+  API->>M: mail lien create-password
+  U->>API: verify token + set password
+  API-->>U: compte actif, login OK
+```
+
+Variante **refus** : staff refuse → mail refus → usager **reprise** (token lien ou n° dossier) → resoumission → à valider.
+
+### 5.2 Mot de passe oublié
+
+Flux distinct de la création post-validation : demande → e-mail → reset (#127). Tokens durcis (#123).
+
+### 5.3 Création dossier staff
+
+- Famille : wizard + `POST` staff parent/dossier (#129).  
+- AM : wizard + API staff AM (#156).  
+- Édition : mode `edit` wizards + PATCH fiches ; ajout co-parent `POST …/co-parent` (#135).
+
+### 5.4 Rattachements
+
+| Lien | Opérations |
+|------|------------|
+| Parent ↔ enfant | attach / detach (fiche parent, fiche enfant) |
+| AM ↔ enfant | attach / detach (fiche AM, fiche enfant) ; UI capacité |
+
+API : tickets #115 / #116 ; liste enfants enrichie #136.
+
+---
+
+## 6. Matrice droits × actions (synthèse)
+
+| Action | gestionnaire | administrateur | super_admin |
+|--------|:------------:|:--------------:|:-----------:|
+| Voir dashboard usagers / dossiers | ✓ | ✓ | ✓ |
+| Valider / refuser dossier | ✓ | ✓ | ✓ |
+| Créer dossier parent / AM | ✓ | ✓ | ✓ |
+| Éditer fiches parent / AM / enfant | ✓ | ✓ | ✓ |
+| Rattacher / détacher enfant | ✓ | ✓ | ✓ |
+| GET liste relais (combo) | ✓ | ✓ | ✓ |
+| Créer gestionnaire / admin | ✗ | ✓ | ✓ |
+| Supprimer parent / AM / enfant / dossier | ✓ | ✓ | ✓ |
+| Supprimer gestionnaire | ✗ | ✓ | ✓ |
+| Supprimer admin (garde-fous) | ✗ | ✓* | ✓* |
+| Supprimer super_admin | ✗ | ✗ | ✗ |
+| Supprimer son propre compte staff | ✗ | ✗ | ✗ |
+
+\* Voir `canDeleteAdministrateur` / messages `adminDeleteBlockedReason`.
+
+---
+
+## 7. UI staff (points d’entrée code)
+
+| Zone | Emplacement typique |
+|------|---------------------|
+| Panneau gestion users | `widgets/dashboard/user_management_panel.dart` |
+| Onglets parents / AM / enfants / dossiers | `widgets/dashboard/*_management_widget.dart` |
+| Fiche parent | `parent_edit_modal.dart` |
+| Fiche AM | `am_edit_modal.dart` |
+| Fiche enfant | `child_detail_modal.dart` |
+| Wizards dossier | `parent_dossier_wizard.dart`, `am_dossier_wizard.dart` |
+| Modale staff | `staff_user_form_modal.dart` (`StaffUserFormModal`) |
+| Confirm suppressions | `widgets/dashboard/common/suppression_confirm_dialog.dart` |
+| Champs contrôlés | `validation_detail_section.dart` (`ValidationEmailField`, `ValidationPhoneField`…) |
+| Thème primaire modales | `validation_modal_theme.dart` |
+
+Shell fiches / wizards : largeur **930**, labels au-dessus, primaire violet `ValidationModalTheme`.
+
+---
+
+## 8. API — groupes (renvoi)
+
+Ne pas dupliquer OpenAPI ici. Groupes utiles au domaine :
+
+| Groupe | Exemples d’usage |
+|--------|------------------|
+| Auth / register | Inscription parent & AM, login, tokens MDP, oubli MDP |
+| Dossiers | `GET /dossiers/:numero`, listes à valider / unifiées, validate/refuse |
+| Parents | Fiche PATCH, co-parent POST, dossier staff POST |
+| AM | Fiche PATCH, dossier staff POST |
+| Enfants | CRUD staff, attach/detach parent & AM |
+| Users / staff | CRUD gestionnaires / admins, DELETE métier |
+| Relais | `GET /relais` (autorisé gestionnaire — #151) |
+| Config | setup / configuration instance |
+
+Référence : [11_API.md](./11_API.md) (à maintenir en parallèle si écart).
+
+---
+
+## 9. Exigences non fonctionnelles (domaine users)
+
+| ID | Exigence |
+|----|----------|
+| NFR-U1 | Tokens création / reset MDP : TTL strict, usage unique |
+| NFR-U2 | Mots de passe : politique min. longueur (création staff / usager selon flux) |
+| NFR-U3 | E-mails métier (validation, refus, MDP) via config SMTP instance |
+| NFR-U4 | Pas de login si `en_attente` ou `suspendu` |
+| NFR-U5 | Confirmations explicites avant toute suppression |
+| NFR-U6 | Champs e-mail / téléphone : validation & normalisation côté UI staff (SRS UX #164) |
+
+Hors scope immédiat : normalisation erreurs auth globale (#121), observabilité (#122), audit trail complet (#128).
+
+---
+
+## 10. Limites modèle famille (assumées)
+
+Documentées pour les développeurs — détail produit : [28_EVOLUTION-FAMILLE-ET-RESPONSABLES.md](./28_EVOLUTION-FAMILLE-ET-RESPONSABLES.md).
+
+- Un `numero_dossier` / user ; un seul co-parent.  
+- Familles recomposées multi-contextes : contournement (2ᵉ compte / composition staff) jusqu’à epic #139.  
+- La SRS **n’exige pas** N responsables en v0.1.0.
+
+---
+
+## 11. Traçabilité livré 0.1.0
+
+Source : [29_BILAN-VERSION-0.1.0.md](./29_BILAN-VERSION-0.1.0.md) — 48 tickets milestone 0.1.0 (auth, inscription, fiches, dossiers, suppressions, cleanups #152/#155/#162/#164).
+
+---
+
+## 12. Hors périmètre de cette SRS
+
+- Contrats, avenants, fin de contrat (restent dans le **CDC** cible)  
+- Messagerie, agenda, événements RPE (idem CDC)  
+- Paie / Pajemploi  
+- Recherche AM côté parent  
+- PRA, CI/CD, monitoring infra  
+- Spécification OpenAPI ligne à ligne  
+- Texte fonctionnel complet → [01_CAHIER-DES-CHARGES.md](./01_CAHIER-DES-CHARGES.md)

docs/22_DOCUMENTS-LEGAUX.md

@@ -1,8 +0,0 @@
-# Fichier déplacé
-
-La documentation **Documents légaux** a été déplacée vers :
-
-**[juridique/22_DOCUMENTS-LEGAUX.md](./juridique/22_DOCUMENTS-LEGAUX.md)**
-
-Voir aussi le dossier **[juridique/](./juridique/)** pour les sources **CGU**
-et **CGC** en Markdown.

docs/23_SUIVI-TICKETS.md

@@ -0,0 +1,12 @@
+# Suivi des tickets — P'titsPas
+
+**Source de vérité** : [Gitea — issues](https://git.ptits-pas.fr/jmartin/petitspas/issues)  
+**Milestones / versions** : [05_VERSIONS-ET-MILESTONES.md](./05_VERSIONS-ET-MILESTONES.md)  
+**API Gitea** : [26_GITEA-API.md](./26_GITEA-API.md)
+
+Ne plus maintenir de catalogue exhaustif des tickets dans le dépôt : l’état (ouvert / fermé / milestone) change dans Gitea.
+
+Pour une **version livrée**, lire le bilan correspondant (ex. [29_BILAN-VERSION-0.1.0.md](./29_BILAN-VERSION-0.1.0.md)).
+
+Archive historique (liste Phase 1 figée, avril 2026) :  
+[archive/obsolete/23_LISTE-TICKETS.md](./archive/obsolete/23_LISTE-TICKETS.md).

docs/24_DECISIONS-PROJET.md

@@ -423,31 +423,23 @@ ptitspas-app/
 - Maintenance (tout au même endroit)
 - Versioning (Git)
 
-**Structure** :
+**Structure** (sept. 2026) :
 ```
 docs/
 ├── 00_INDEX.md
-├── 01_CAHIER-DES-CHARGES.md
+├── 01_CAHIER-DES-CHARGES.md   # V1.4 fonctionnel
-├── 02_ARCHITECTURE.md
+├── 05_VERSIONS-ET-MILESTONES.md
-├── 03_DEPLOYMENT.md
+├── 12_SRS-GESTION-UTILISATEURS.md
-├── 10_DATABASE.md
+├── 23_SUIVI-TICKETS.md
-├── 11_API.md
-├── 20_WORKFLOW-CREATION-COMPTE.md
-├── 21_CONFIGURATION-SYSTEME.md
-├── 22_DOCUMENTS-LEGAUX.md   # pointeur → juridique/
-├── 27_BRIEFING-FRONTEND.md
-├── PROCEDURE-API-GITEA.md   # pointeur → 26_GITEA-API.md
-├── juridique/
-│   ├── README.md
-│   ├── cgu.md
-│   ├── cgc.md
-│   └── 22_DOCUMENTS-LEGAUX.md
-├── archive/
-│   ├── README.md
-│   ├── temporaires/
-│   └── obsolete/
-├── 23_LISTE-TICKETS.md
 ├── 24_DECISIONS-PROJET.md (ce document)
+├── 26_GITEA-API.md
+├── 27_BRIEFING-FRONTEND.md
+├── 28_EVOLUTION-FAMILLE-ET-RESPONSABLES.md
+├── 29_BILAN-VERSION-0.1.0.md
+├── 99_REGLES-CODAGE.md
+├── CHARTE_GRAPHIQUE.md
+├── juridique/               # CGU + 22_DOCUMENTS-LEGAUX.md
+├── archive/                 # obsolete / temporaires
 ├── 90_AUDIT.md
 └── test-data/
 ```

docs/28_EVOLUTION-FAMILLE-ET-RESPONSABLES.md

@@ -3,7 +3,9 @@
 **Version** : 1.1  
 **Date** : 16 juin 2026  
 **Statut** : Réflexions produit / architecture — complément au [CDC](./01_CAHIER-DES-CHARGES.md)  
-**Documents liés** : [EVOLUTIONS_CDC.md](./EVOLUTIONS_CDC.md), [24_DECISIONS-PROJET.md](./24_DECISIONS-PROJET.md), [23_LISTE-TICKETS.md](./23_LISTE-TICKETS.md)
+**Documents liés** : [01_CAHIER-DES-CHARGES.md](./01_CAHIER-DES-CHARGES.md) (V1.4), [12_SRS-GESTION-UTILISATEURS.md](./12_SRS-GESTION-UTILISATEURS.md), [24_DECISIONS-PROJET.md](./24_DECISIONS-PROJET.md), [23_SUIVI-TICKETS.md](./23_SUIVI-TICKETS.md), [29_BILAN-VERSION-0.1.0.md](./29_BILAN-VERSION-0.1.0.md)  
+**Archive** : ancien patch CDC → [archive/obsolete/EVOLUTIONS_CDC.md](./archive/obsolete/EVOLUTIONS_CDC.md)
+
 
 ---
 

docs/29_BILAN-VERSION-0.1.0.md

@@ -0,0 +1,197 @@
+# Bilan — Version 0.1.0
+
+**Statut** : terminée  
+**Milestone Gitea** : [0.1.0](https://git.ptits-pas.fr/jmartin/petitspas/milestone/10)  
+**Dépôt** : `jmartin/petitspas`  
+**Tag prévu** : `v0.1.0` (sur `master` après merge de cette doc)
+
+Ce document est la **mémoire produit** de la version 0.1.0 : ce qui a été livré, ticket par ticket, et ce qui a été reporté.
+
+---
+
+## 1. Périmètre produit livré
+
+La 0.1.0 couvre le **MVP opérable** pour une collectivité :
+
+- Authentification, création / oubli de mot de passe, e-mails associés
+- Inscription parent & AM, validation / refus gestionnaire, reprise après refus
+- Dashboard staff (admin + gestionnaire) : listes, fiches, rattachements
+- Onglet **Dossiers** + wizards création / édition (famille & AM)
+- Suppressions métier (droits, confirms, cascades API)
+- Cleanups structurels (préfixe `Admin*`, panels dashboard, modale staff, retrait `est_multiple`)
+
+**Hors 0.1.0** (reporté) : doublons avancés, famille N responsables, statut enfant gardé/sans garde, combobox RPE AM, chantier CDC (#117), tickets tech/observabilité — voir §4 et [05_VERSIONS-ET-MILESTONES.md](./05_VERSIONS-ET-MILESTONES.md).
+
+---
+
+## 2. Thèmes livrés
+
+### 2.1 Auth, mot de passe, e-mails
+
+| # | Titre | Livré |
+|---|-------|--------|
+| 24 | API Création mot de passe | Endpoints token → création MDP post-validation |
+| 28 | Templates Email — Validation | Mails validation avec lien MDP |
+| 30 | Connexion — Vérification statut | Blocage comptes pending / suspendus à la connexion |
+| 43 | Écran Création Mot de Passe | UI lien e-mail création MDP |
+| 47 | Écran Changement MDP Obligatoire | Première connexion staff |
+| 50 | Affichage dynamique CGU | CGU/Privacy versionnées à l’inscription |
+| 118 | Page création mot de passe (Front + API) | Alignement front/API du flux lien e-mail |
+| 123 | Durcissement token création MDP | TTL, usage unique, contrôles API |
+| 127 | Mot de passe oublié | Demande → e-mail → réinitialisation (flux distinct de #24/#43) |
+
+### 2.2 Inscription, numéros de dossier, reprise
+
+| # | Titre | Livré |
+|---|-------|--------|
+| 104 | Numéro de dossier — frontend | Affichage listes / mails / modales ; format AAAA-… |
+| 112 | Reprise après refus — frontend | Lien e-mail `/reprise` + reprise par n° dossier |
+| 120 | Inscription AM — photo & UX | Chaîne photo / API / UX alignée parents |
+| 144 | Consentement photo enfant | Persistance du consentement à l’inscription |
+
+### 2.3 Dashboard — fiches, listes, rattachements
+
+| # | Titre | Livré |
+|---|-------|--------|
+| 115 | Rattachement enfants — backend | Attach/detach parent↔enfant et AM↔enfant |
+| 116 | Rattachement enfants — frontend | UI fiches parent / AM |
+| 130 | UserService — APIs métier | Branchement parents / AM / enfants côté front |
+| 131 | Édition fiche parent + AM | Modales édition dashboard |
+| 132 | Création enfant (onglet Enfants) | Création + rattachement foyer |
+| 136 | API enfants — droits & liste | Droits gestionnaire + enrichissement liste |
+| 137 | Onglet Enfants — liste globale | Panneau liste dashboard |
+| 138 | Fiche enfant + liste dans parent | Fiche enfant ; enfants dans fiche parent |
+| 140 | Epic fiche parent / affiliation | Livraison regroupée dashboard admin/gestionnaire |
+| 142 | Clic carte → modale | Ouverture fiche depuis les listes |
+| 145 | Lien co-parent cliquable | Navigation fiche parent → co-parent |
+| 146 | Modale sélection enfant | UX rattacher enfant (AM + parent) |
+| 147 | Modale sélection AM | UX rattacher AM depuis fiche enfant |
+| 148 | Capacité max AM | Désactivation rattachement si capacité atteinte |
+| 149 | Case libre AM → rattacher | Clic emplacement vide pour rattacher |
+| 151 | GET /relais pour gestionnaire | Combo relais dans modale staff |
+| 157 | Enfant sans responsable | Détachement dernier parent + alerte liste |
+| 158 | Affiliation foyer (pivot + co-parent) | Attach/detach cohérents sur le foyer |
+
+### 2.4 Dossiers staff (création, édition, liste)
+
+| # | Titre | Livré |
+|---|-------|--------|
+| 129 | Création dossier parent | Wizard + API staff famille |
+| 135 | Édition dossier + 2ᵉ parent | Mode edit wizards + `POST …/co-parent` |
+| 153 | Onglet Dossiers | Liste unifiée + à valider (sans création dans l’onglet) |
+| 156 | Création dossier AM | Wizard + API staff AM |
+
+### 2.5 Suppressions & droits staff
+
+| # | Titre | Livré |
+|---|-------|--------|
+| 133 | Suppression parent + AM (UI) | Première vague UI (complétée par #160) |
+| 134 | Droits « Ajouter gestionnaire » | Visibilité / API selon rôle |
+| 143 | Bug supprimer sa propre fiche | Masquage / interdiction auto-suppression |
+| 154 | Epic suppressions | Cadrage règles métier suppressions |
+| 159 | Suppressions métier — backend | Cascades, garde-fous, droits API |
+| 160 | Suppressions dashboard — frontend | Poubelles + dialogues de confirmation |
+| 161 | Admin création staff 403 | Admin peut créer gestionnaire et administrateur |
+
+### 2.6 Cleanups structure & UX
+
+| # | Titre | Livré |
+|---|-------|--------|
+| 25 | API Liste comptes en attente | Historique ; couvert par flux dossiers / validation |
+| 26 | API Validation / Refus | Historique ; couvert par flux dossiers / validation |
+| 152 | Retrait `est_multiple` | Suppression full stack (BDD, API, front, docs) |
+| 155 | Rename préfixe `Admin*` | Widgets partagés sans préfixe Admin (option C) |
+| 162 | Panels → `widgets/dashboard/` | Suite #155 — panels staff sous dashboard |
+| 164 | Modale staff uniformisée | `StaffUserFormModal` (shell 930, champs contrôlés) |
+
+---
+
+## 3. Inventaire exhaustif (48 tickets fermés, milestone 0.1.0)
+
+| # | Titre |
+|---|-------|
+| 24 | [Backend] API Création mot de passe |
+| 25 | [Backend] API Liste comptes en attente |
+| 26 | [Backend] API Validation/Refus comptes |
+| 28 | [Backend] Templates Email - Validation |
+| 30 | [Backend] Connexion - Vérification statut |
+| 43 | [Frontend] Écran Création Mot de Passe |
+| 47 | [Frontend] Écran Changement MDP Obligatoire |
+| 50 | [Frontend] Affichage dynamique CGU lors inscription |
+| 104 | Numéro de dossier – frontend |
+| 112 | Reprise après refus – frontend |
+| 115 | [Backend] Rattachement enfants — parent et AM |
+| 116 | [Frontend] Rattachement enfants — parent et AM |
+| 118 | Page création mot de passe (lien email) – Front + API |
+| 120 | [Full-stack] Inscription AM — photo, API et UX alignés sur les parents |
+| 123 | [Tech] Durcissement token création MDP |
+| 127 | [Full-stack] Mot de passe oublié — flux complet |
+| 129 | Création dossier parent (wizard + API staff) |
+| 130 | [Frontend] UserService — brancher APIs parents, AM et enfants |
+| 131 | [Frontend] Édition fiche parent + AM |
+| 132 | Création enfant depuis l’onglet Enfants |
+| 133 | [Frontend] Suppression compte parent + AM |
+| 134 | Droits bouton « Ajouter gestionnaire » |
+| 135 | Mode édition dossier (+ ajout 2ᵉ parent) |
+| 136 | [Backend] API enfants — droits gestionnaire + enrichissement liste |
+| 137 | [Frontend] Onglet Enfants — liste globale |
+| 138 | [Frontend] Fiche enfant + liste enfants dans fiche parent |
+| 140 | Dashboard admin — fiche parent, enfants et affiliation |
+| 142 | Clic sur carte → ouvrir la modale |
+| 143 | Bug — Gestionnaire Supprimer sur sa propre fiche |
+| 144 | Bug — Consentement photo enfant non sauvegardé |
+| 145 | Lien co-parent cliquable |
+| 146 | UX — modale sélection d'enfant |
+| 147 | UX — modale sélection d'AM |
+| 148 | Bug — capacité max AM |
+| 149 | Fiche AM — clic case libre pour rattacher |
+| 151 | Bug — GET /relais gestionnaire |
+| 152 | Cleanup — supprimer `est_multiple` |
+| 153 | Onglet permanent « Dossiers » |
+| 154 | Epic — suppressions utilisateurs / dossiers / enfants / AM |
+| 155 | Cleanup — renommer préfixe Admin* |
+| 156 | Création dossier AM (wizard + API staff) |
+| 157 | Enfant sans responsable |
+| 158 | Affiliation enfant au foyer (pivot + co-parent) |
+| 159 | Backend suppressions métier (#154) |
+| 160 | Frontend suppressions dashboard (#154) |
+| 161 | Bug — Admin création gestionnaire / administrateur |
+| 162 | Cleanup — panels vers `widgets/dashboard/` |
+| 164 | Uniformisation modale staff + champs contrôlés |
+
+Issues : https://git.ptits-pas.fr/jmartin/petitspas/issues?q=&type=all&state=closed&labels=&milestone=10&assignee=0
+
+---
+
+## 4. Reporté hors 0.1.0
+
+| # | Titre | Destination typique |
+|---|-------|---------------------|
+| 113 / 114 | Doublons inscription / alerte gestionnaire | 0.9.0 |
+| 117 | Évolution du cahier des charges | Doc (amendement CDC post-0.1.0) |
+| 121–122, 124–125 | Tech auth / photos / DB | 0.9.0 |
+| 126 | Upload documents légaux 500 | 0.9.0 |
+| 128 | Audit / traçabilité modifications | 0.9.0 |
+| 139 | Famille complexe N responsables | Post-0.1.0 / epic |
+| 141 | Statut enfant gardé / sans garde | Post-0.1.0 |
+| 150 | Combobox rattachement RPE (AM) | 0.2.0 |
+
+Voir aussi [05_VERSIONS-ET-MILESTONES.md](./05_VERSIONS-ET-MILESTONES.md).
+
+---
+
+## 5. Suite documentaire
+
+1. **Amendement CDC (#117)** — CDC V1.4 : mise à jour **gestion utilisateurs** ; le reste du CDC reste la cible. SRS technique : [12_SRS-GESTION-UTILISATEURS.md](./12_SRS-GESTION-UTILISATEURS.md). Intrants historiques archivés : [archive/obsolete/EVOLUTIONS_CDC.md](./archive/obsolete/EVOLUTIONS_CDC.md), [28_EVOLUTION-FAMILLE-ET-RESPONSABLES.md](./28_EVOLUTION-FAMILLE-ET-RESPONSABLES.md).
+2. **Tag** `v0.1.0` sur `master` lorsque milestone fermée + ce bilan mergé.
+3. Enchaîner les milestones **0.2.0+** selon [05_VERSIONS-ET-MILESTONES.md](./05_VERSIONS-ET-MILESTONES.md).
+
+---
+
+## 6. Références code (points d’entrée)
+
+- Modale staff : `frontend/lib/widgets/dashboard/staff_user_form_modal.dart`
+- Fiches : `parent_edit_modal.dart`, `am_edit_modal.dart`, `child_detail_modal.dart`
+- Wizards dossiers : `parent_dossier_wizard.dart`, `am_dossier_wizard.dart`
+- Règles suppressions : tickets #154 / #159 / #160
+- Cleanup `est_multiple` : #152

docs/99_REGLES-CODAGE.md

@@ -276,9 +276,6 @@ export class Enfants {
   @Column({ name: 'consentement_photo', type: 'boolean', default: false })
   consentementPhoto: boolean;
 
-  @Column({ name: 'est_multiple', type: 'boolean', default: false })
-  estMultiple: boolean;
-
   @Column({
     type: 'enum',
     enum: StatutEnfantType,

docs/PROCEDURE-API-GITEA.md

@@ -1,8 +0,0 @@
-# Fichier déplacé / fusionné
-
-La procédure **API Gitea** est désormais documentée sous :
-
-**[26_GITEA-API.md](./26_GITEA-API.md)**
-
-L’ancienne copie `PROCEDURE-API-GITEA.md` est archivée dans
-`docs/archive/obsolete/` (doublon).

docs/archive/README.md

@@ -1,30 +1,19 @@
 # Archive documentation · P'titsPas
 
-Ce dossier regroupe les fichiers **sans préfixe numérique** à la racine de
+Fichiers **hors références actives** : brouillons livrés, CDC historiques, listes figées.
-`docs/` qui ne sont plus des **références actives**, ou qui sont des
-**brouillons / temporaires**.
 
 ## Règle de nommage (racine `docs/`)
 
-- Les documents **normatifs** à la racine portent un préfixe **`NN_`**
+- Documents **normatifs** : préfixe **`NN_`**.
-  (deux chiffres), ex. `23_LISTE-TICKETS.md`.
+- Exceptions héritage listées dans [00_INDEX.md](../00_INDEX.md) (`CHARTE_GRAPHIQUE.md`).
-- **Exceptions** (héritage ou outillage) listées dans
-  [**00_INDEX.md**](../00_INDEX.md#exceptions-de-nommage) : charte, CDC
-  historique, évolutions — **cible** : les renommer progressivement en `NN_`
-  et mettre à jour `.cursorrules` / liens.
 
-## Sous-dossiers ici
+## Sous-dossiers
 
 | Dossier | Usage |
 |---------|--------|
-| [**temporaires/**](./temporaires/) | Notes jetables, exports de travail.
+| [**temporaires/**](./temporaires/) | Brouillons jetables. **Vider** dès livraison. |
-  **Supprimables** quand la tâche associée est close. |
+| [**obsolete/**](./obsolete/) | Doc remplacée (CDC SuperNounou, ancienne liste tickets, notes ponctuelles, backlog Phase 2 figé). |
-| [**obsolete/**](./obsolete/) | Ancienne doc **remplacée** ou **doublon**
-  (conservée un temps pour historique). **Supprimer** après bascule confirmée
-  si plus aucune référence. |
 
-## Hors `docs/` racine
+## Politique `tmp/`
 
-Les dossiers thématiques (**`juridique/`**, **`test-data/`**, etc.) peuvent
+Le dossier `docs/tmp/` **n’est plus utilisé**. Les mini-specs de tickets livrés sont purgés ; la mémoire produit = bilans de version (`29_…`) + tickets Gitea.
-contenir des fichiers sans `NN_` : la règle `NN_` s’applique surtout aux
-fichiers **directement** sous `docs/`.

docs/archive/obsolete/EVOLUTIONS_CDC.md

@@ -2,7 +2,9 @@
 
 Ce document liste les modifications à apporter au cahier des charges original pour le rendre conforme à l'application développée.
 
-> **Document complémentaire (juin 2026)** — réflexions sur le **modèle famille / numéro de dossier**, familles recomposées, tuteurs et responsables légaux : voir **[28 - Évolution famille et responsables](./28_EVOLUTION-FAMILLE-ET-RESPONSABLES.md)**.
+> **Intrant pour #117** (amendement CDC post-0.1.0). Compléter avec le [bilan 0.1.0](./29_BILAN-VERSION-0.1.0.md) et **[28 - Évolution famille et responsables](./28_EVOLUTION-FAMILLE-ET-RESPONSABLES.md)**.
+
+> **Obsolète depuis #152** : ne plus proposer de champ « naissance multiple / `est_multiple` » — retiré de l’app (BDD, API, front).
 
 ## 1. Gestion des Enfants
 
@@ -11,7 +13,6 @@ Ce document liste les modifications à apporter au cahier des charges original p
 #### Situation actuelle dans le CDC :
 - Mentionne uniquement la collecte d'informations sur l'enfant
 - Ne précise pas la possibilité d'ajouter plusieurs enfants
-- Ne mentionne pas la gestion des naissances multiples
 - Ne mentionne pas la gestion des enfants à naître
 
 #### Modifications proposées :
@@ -22,17 +23,18 @@ Ajouter le paragraphe suivant après la description de la collecte d'information
 Les parents peuvent ajouter autant d'enfants que nécessaire. Pour chaque enfant, les informations suivantes sont collectées :
 - Prénom
 - Date de naissance (ou date prévue pour les enfants à naître)
+- Genre
 - Photo (optionnelle)
 - Consentement pour l'utilisation de la photo
-- Indication si l'enfant fait partie d'une naissance multiple (jumeaux, triplés, etc.)
 
 Les parents peuvent :
 - Ajouter un nouvel enfant à tout moment
 - Supprimer un enfant ajouté
 - Modifier les informations d'un enfant existant
 - Indiquer si l'enfant est à naître
-- Indiquer si l'enfant fait partie d'une naissance multiple
 - Donner ou retirer leur consentement pour l'utilisation de la photo de l'enfant
+
+Note : le concept de « naissance multiple » / jumeaux n'est pas géré par un champ dédié (retiré en 0.1.0, #152).
 ```
 
 ### Modifications à apporter dans la section "Workflow de création de compte"
@@ -50,9 +52,9 @@ Remplacer l'étape 3 par :
    - Pour chaque enfant :
      * Saisie du prénom
      * Saisie de la date de naissance (ou date prévue)
+     * Genre
      * Option d'ajout d'une photo
      * Option de consentement photo
-     * Indication si naissance multiple
      * Indication si enfant à naître
    - Possibilité de modifier ou supprimer un enfant
 ```

docs/archive/obsolete/README.md

@@ -4,11 +4,15 @@ Ancienne documentation **déplacée** depuis `docs/` :
 
 | Fichier | Motif |
 |---------|--------|
-| `PROCEDURE-API-GITEA.md` | Doublon fonctionnel de
+| `01_CAHIER-DES-CHARGES-v1.3.md` | CDC V1.3 — remplacé par [01 V1.4](../../01_CAHIER-DES-CHARGES.md) |
-  [**26_GITEA-API.md**](../../26_GITEA-API.md). |
+| `EVOLUTIONS_CDC.md` | Patch CDC — absorbé dans V1.4 + [12_SRS](../../12_SRS-GESTION-UTILISATEURS.md) |
-| `ARCHITECTURE_TECHNIQUE.md` | Non référencé ; la vue d’ensemble est dans
+| `PROCEDURE-API-GITEA.md` | Doublon de [26_GITEA-API.md](../../26_GITEA-API.md) |
-  [**02_ARCHITECTURE.md**](../../02_ARCHITECTURE.md). |
+| `ARCHITECTURE_TECHNIQUE.md` | Remplacé par [02_ARCHITECTURE.md](../../02_ARCHITECTURE.md) |
-| `STATUS-APPLICATION.md` | Instantané daté ; non tenu comme doc vivante. |
+| `STATUS-APPLICATION.md` | Instantané daté |
+| `23_LISTE-TICKETS.md` | Liste Phase 1 figée — suivi = Gitea + bilans |
+| `25_PHASE-2-BACKLOG.md` | Backlog technique figé — voir [05_VERSIONS…](../../05_VERSIONS-ET-MILESTONES.md) |
+| `SuperNounou_*` | CDC / SSS historiques |
+| `14_NOTE-BACKEND-CONFIG-SETUP.md` | Note ticket ponctuelle |
+| `92_NOTE-BACKEND-GESTIONNAIRES.md` | Note ticket ponctuelle |
 
-Après vérification qu’aucun lien externe ne pointe encore vers ces chemins, on
+Références actives : [01 CDC V1.4](../../01_CAHIER-DES-CHARGES.md), [12 SRS users](../../12_SRS-GESTION-UTILISATEURS.md), [29 bilan 0.1.0](../../29_BILAN-VERSION-0.1.0.md).
-peut **supprimer** ce sous-dossier ou ne garder que des pointeurs minimalistes.

docs/archive/temporaires/131-fiche-parent-co-parent-header.md

@@ -1,127 +0,0 @@
-# #131 — En-tête fiche parent : co-parent (note front → back)
-
-**Ticket :** #131 (fiche parent dashboard, doc `28_EVOLUTION-FAMILLE-ET-RESPONSABLES.md` §6.1)  
-**Date :** 2026-06-01  
-**Statut front :** livré (en-tête dynamique)  
-**Modif backend demandée :** **aucune fonctionnelle** — ce document fixe le contrat attendu ; le back valide `co_parent` et masque les champs sensibles.
-
----
-
-## 1. Comportement UI (front)
-
-Dans la modale **fiche parent** (`AdminParentEditModal`) :
-
-| Zone | Contenu |
-|------|---------|
-| **Titre** | `prenom` + `nom` du parent affiché (plus le libellé fixe « Fiche parent ») |
-| **Sous-titre** | `Co-parent : {prenom} {nom}` — affiché **uniquement** si un co-parent est connu |
-
-Le titre se met à jour en direct pendant l’édition des champs nom/prénom.  
-Le sous-titre provient du co-parent **chargé depuis l’API** (pas saisi à la main dans la modale).
-
----
-
-## 2. Endpoints consommés
-
-| Méthode | Route | Usage front |
-|---------|-------|-------------|
-| `GET` | `/api/v1/parents` | Liste parents (onglet Parents) |
-| `GET` | `/api/v1/parents/:userId` | Rechargement fiche après rattachement/détachement enfant |
-| `PATCH` | `/api/v1/parents/:userId/fiche` | Sauvegarde identité + statut (inchangé) |
-
-Rôles : `super_admin`, `gestionnaire`, `administrateur` (selon route).
-
----
-
-## 3. Contrat JSON attendu pour `co_parent`
-
-Le front parse `ParentModel.fromJson` avec la clé **`co_parent`** (snake_case), objet utilisateur imbriqué.
-
-### Champs minimum utilisés pour le sous-titre
-
-| Clé JSON | Usage |
-|----------|--------|
-| `co_parent` | Objet ou absent/`null` |
-| `co_parent.id` | Identifiant (futur lien cliquable éventuel) |
-| `co_parent.prenom` | Affichage |
-| `co_parent.nom` | Affichage |
-
-Affichage front : `'{prenom} {nom}'.trim()` → libellé `Co-parent : …`.
-
-### Exemple de fragment de réponse (`GET /parents/:id`)
-
-```json
-{
-  "user_id": "33333333-3333-3333-3333-333333333333",
-  "numero_dossier": "2026-000042",
-  "user": {
-    "id": "33333333-3333-3333-3333-333333333333",
-    "email": "parent1@example.com",
-    "prenom": "Paul",
-    "nom": "PARENT",
-    "statut": "actif",
-    "telephone": "0601020304"
-  },
-  "co_parent": {
-    "id": "44444444-4444-4444-4444-444444444444",
-    "email": "coparent1@example.com",
-    "prenom": "Clara",
-    "nom": "COPARENT",
-    "role": "parent",
-    "statut": "actif"
-  },
-  "parentChildren": []
-}
-```
-
-> **Note :** le front lit `user` (pas `utilisateur`). La doc `11_API.md` § Parents mentionne encore `utilisateur` / `id_co_parent` seul — le contrat **effectif** côté Nest/TypeORM est l’entité `Parents` sérialisée (`user`, `co_parent`, `parentChildren`, …).
-
----
-
-## 4. État backend
-
-### Relations (déjà en place)
-
-- `findAll()` et `findOne(user_id)` chargent **`co_parent`** ;
-- FK : `parents.id_co_parent` → `utilisateurs.id` ;
-- inscription couple : les deux sens renseignés en principe (`auth.service.ts`).
-
-### Livraison back (#131)
-
-- `mapParentForApi` / `sanitizeUserForApi` : réponses `GET/PATCH/POST/DELETE` parents **sans** `password`, `token_creation_mdp`, `password_reset_*` sur `user` et `co_parent`.
-
-**Checklist validation :**
-
-- [x] `GET /parents/:id` renvoie `co_parent` peuplé quand `id_co_parent` est non null
-- [x] `GET /parents` (liste) inclut `co_parent`
-- [x] `prenom` / `nom` du co-parent présents
-- [x] Pas de fuite `password` / tokens sur `user` ni `co_parent`
-
----
-
-## 5. Points d’attention (hors périmètre immédiat)
-
-| Sujet | Détail |
-|-------|--------|
-| **Lien inverse** | Si B est co-parent de A (`A.id_co_parent = B`) mais `B.id_co_parent` est `null`, le sous-titre **ne s’affichera pas** sur la fiche de B. Pas de résolution inverse côté front. |
-| **Familles > 2 adultes** | Sous-titre = co-parent direct (`id_co_parent`) uniquement. |
-| **Trou AM ↔ enfants en garde** | Pas de lien AM–enfant aujourd’hui (à documenter / traiter plus tard). |
-
----
-
-## 6. Fichiers back concernés
-
-| Fichier | Rôle |
-|---------|------|
-| `backend/src/routes/parents/parents.service.ts` | `findOne`, `findAll` + relations |
-| `backend/src/routes/parents/parents.controller.ts` | `mapParentForApi` sur les réponses |
-| `backend/src/routes/parents/parents.mapper.ts` | Sérialisation API |
-| `backend/src/common/utils/sanitize-user-for-api.ts` | Masquage secrets |
-| `backend/src/entities/parents.entity.ts` | relation `co_parent` |
-
----
-
-## 7. Références
-
-- `docs/28_EVOLUTION-FAMILLE-ET-RESPONSABLES.md` §6.1
-- Ticket Gitea **#131**

docs/archive/temporaires/POINT_TICKETS_FRONT_API.txt

@@ -1,36 +0,0 @@
-# Archivé docs/archive/temporaires/ — export jetable, supprimer si inutile.
-Point tickets frontend (API Gitea) - 27/01/2026
-================================================
-
-Issues avec label "frontend" : 20 (ouvertes: 12, fermees: 8)
-
-Num | Etat   | Titre
-----+--------+--------------------------------------------------------
- 35 | open   | [Frontend] Écran Création Gestionnaire
- 36 | closed | [Frontend] Inscription Parent - Étape 1 (Parent 1)
- 37 | closed | [Frontend] Inscription Parent - Étape 2 (Parent 2)
- 38 | closed | [Frontend] Inscription Parent - Étape 3 (Enfants)
- 39 | closed | [Frontend] Inscription Parent - Étapes 4-6 (Finalisatio
- 40 | closed | [Frontend] Inscription AM - Panneau 1 (Identité)
- 41 | closed | [Frontend] Inscription AM - Panneau 2 (Infos pro)
- 42 | closed | [Frontend] Inscription AM - Finalisation
- 43 | open   | [Frontend] Écran Création Mot de Passe
- 44 | closed | [Frontend] Dashboard Gestionnaire - Structure
- 45 | open   | [Frontend] Dashboard Gestionnaire - Liste Parents
- 46 | open   | [Frontend] Dashboard Gestionnaire - Liste AM
- 47 | open   | [Frontend] Écran Changement MDP Obligatoire
- 48 | open   | [Frontend] Gestion Erreurs & Messages
- 49 | open   | [Frontend] Écran Gestion Documents Légaux (Admin)
- 50 | open   | [Frontend] Affichage dynamique CGU lors inscription
- 51 | open   | [Frontend] Écran Logs Admin (optionnel v1.1)
- 54 | open   | [Tests] Tests E2E Frontend
- 82 | closed | [Frontend] Adapter �cran Login pour mobile
- 83 | closed | [Frontend] Adapter �cran Choix Inscription pour mobile
-
-Suivi doc 23_LISTE-TICKETS (Gitea #73,78,79,81,82,83):
-  #73 closed labels=[]
-  #78 closed labels=[]
-  #79 closed labels=[]
-  #81 closed labels=[]
-  #82 closed (écran Login mobile)
-  #83 closed labels=['frontend', 'p3', 'phase-1', 'ux']

docs/archive/temporaires/README.md

@@ -1,10 +1,11 @@
 # Temporaires
 
-Fichiers **non numérotés** de travail (brouillons, listes de tickets exportées,
+Dossier **vide** après clôture 0.1.0 (purge sept. 2026).
-alignements UI en cours, etc.).
 
-- Préfixe conseillé pour les nouveaux fichiers jetables : **`TEMP_`** ou
+Si un brouillon de travail est nécessaire un temps :
-  **`WIP_`** dans ce dossier.
+
-- **Suppression** : dès que la fonctionnalité est livrée ou le sujet clos,
+- le placer ici avec préfixe `TEMP_` / `WIP_` ;
-  supprimer le fichier (ou le déplacer vers `obsolete/` si une trace utile
+- le **supprimer** dès livraison (ne pas laisser pourrir) ;
-  reste nécessaire).
+- pour une trace utile durable → bilan de version ou archive `obsolete/`.
+
+Ne plus utiliser `docs/tmp/`.

docs/archive/temporaires/TEMP_112-back-reprise-alignement-front.md

@@ -1,244 +0,0 @@
-# #112 — Alignement front après évolution back (reprise dossier complet)
-
-**Branche déployée :** `feature/112-reprise-apres-refus-front`  
-**Commit back :** `d70577b1` — `feat(#112): reprise après refus — dossier complet GET/PATCH`  
-**Date :** 2026-06-16
-
-Ce document décrit le **contrat API réel** après extension du back, et ce que le front doit encore brancher pour exploiter le dossier complet (au-delà de l’identité seule).
-
----
-
-## 1. Endpoints (inchangés côté URL)
-
-| Méthode | Route | Auth |
-|---------|-------|------|
-| `GET` | `/api/v1/auth/reprise-dossier?token={uuid}` | Public |
-| `PATCH` | `/api/v1/auth/reprise-resoumettre` | Public |
-| `POST` | `/api/v1/auth/reprise-identify` | Public (inchangé) |
-
-> **Note :** le ticket #111 parlait de `PUT` ; l’implémentation reste en **`PATCH`** (comme avant).
-
----
-
-## 2. `GET /auth/reprise-dossier` — réponse enrichie
-
-### Champs communs (toujours présents)
-
-Identiques à avant : `id`, `email`, `prenom`, `nom`, `telephone`, `adresse`, `ville`, `code_postal`, `numero_dossier`, `role`, `photo_url`, `genre`, `situation_familiale`.
-
-### Rôle `parent` (+ champs #119)
-
-Alignés sur `DossierFamilleCompletDto` :
-
-```json
-{
-  "parents": [
-    {
-      "user_id": "uuid",
-      "email": "…",
-      "prenom": "…",
-      "nom": "…",
-      "telephone": "…",
-      "adresse": "…",
-      "ville": "…",
-      "code_postal": "…",
-      "statut": "refuse",
-      "co_parent_id": "uuid-parent-entity"
-    }
-  ],
-  "enfants": [
-    {
-      "id": "uuid-enfant",
-      "first_name": "Emma",
-      "last_name": "MARTIN",
-      "genre": "F",
-      "status": "actif",
-      "birth_date": "2023-02-15T00:00:00.000Z",
-      "due_date": null,
-      "photo_url": "/uploads/photos/…",
-      "consent_photo": true,
-      "est_multiple": false
-    }
-  ],
-  "texte_motivation": "Nous recherchons…"
-}
-```
-
-**Mapping front suggéré :**
-
-| JSON back | Modèle / wizard parent |
-|-----------|-------------------------|
-| `parents[]` | `UserRegistrationData.parent1` + `parent2` (matcher par `email` ou ordre : titulaire = `id` du GET racine) |
-| `enfants[].first_name` / `last_name` | `ChildData.firstName` / `lastName` |
-| `enfants[].birth_date` | `ChildData.birthDate` (ISO → `DateTime`) |
-| `enfants[].due_date` | `ChildData.dueDate` (enfant `a_naitre`) |
-| `enfants[].status` | `actif` = né, `a_naitre` = à naître |
-| `enfants[].photo_url` | `ApiConfig.absoluteMediaUrl()` + conserver pour reprise sans re-upload |
-| `enfants[].id` | **Obligatoire** pour le PATCH (update par id) |
-| `enfants[].est_multiple` | `grossesse_multiple` si utilisé |
-| `texte_motivation` | étape présentation / motivation |
-
-Si `numero_dossier` absent : pas de `parents[]` / `enfants[]` / `texte_motivation` (identité seule).
-
-### Rôle `assistante_maternelle`
-
-Champs racine + fiche pro (structure **aplatie**, pas de sous-objet `user`) :
-
-```json
-{
-  "consentement_photo": true,
-  "date_naissance": "1985-03-12T00:00:00.000Z",
-  "lieu_naissance_ville": "Paris",
-  "lieu_naissance_pays": "France",
-  "numero_agrement": "AGR-2024-12345",
-  "nir": "123456789012345",
-  "date_agrement": "2024-06-01T00:00:00.000Z",
-  "nb_max_enfants": 4,
-  "place_disponible": 2,
-  "biographie": "…"
-}
-```
-
-**Mapping `AmRegistrationData` :**
-
-| JSON back | Champ front |
-|-----------|-------------|
-| `nb_max_enfants` | `capaciteAccueil` |
-| `place_disponible` | `placesDisponibles` |
-| `numero_agrement` | `numeroAgrement` |
-| `biographie` | `biographie` / présentation |
-| `photo_url` | déjà géré via `RepriseSession.photoUrl` |
-
----
-
-## 3. `PATCH /auth/reprise-resoumettre` — body étendu
-
-### Commun
-
-```json
-{ "token": "uuid-reprise" }
-```
-
-### Parent — champs à envoyer depuis le wizard
-
-| Champ PATCH | Source wizard | Notes |
-|-------------|---------------|-------|
-| `prenom`, `nom`, `telephone`, `adresse`, `ville`, `code_postal` | Parent 1 (titulaire token) | Champs racine |
-| `co_parent_prenom`, `co_parent_nom`, `co_parent_telephone` | Parent 2 | |
-| `co_parent_meme_adresse`, `co_parent_adresse`, `co_parent_code_postal`, `co_parent_ville` | Parent 2 adresse | |
-| `texte_motivation` **ou** `presentation_dossier` | Étape motivation | Les deux alias acceptés |
-| `enfants[]` | Liste enfants | Voir ci-dessous |
-
-**Structure `enfants[]` (miroir inscription + `id` obligatoire) :**
-
-```json
-{
-  "id": "uuid-enfant-existant",
-  "prenom": "Emma",
-  "nom": "MARTIN",
-  "date_naissance": "2023-02-15",
-  "date_previsionnelle_naissance": null,
-  "genre": "F",
-  "photo_base64": "data:image/jpeg;base64,…",
-  "photo_filename": "emma.jpg",
-  "grossesse_multiple": false
-}
-```
-
-- **v1 back :** update par `id` uniquement — pas de création/suppression d’enfant.
-- Si `id` inconnu pour ce dossier → **400** `Enfant inconnu pour ce dossier : {id}`.
-- Sans nouvelle photo : ne pas envoyer `photo_base64` (l’existant est conservé).
-
-### AM — champs à envoyer
-
-| Champ PATCH | Source |
-|-------------|--------|
-| Identité + `photo_url` ou `photo_base64` + `photo_filename` | Étapes 1–2 |
-| `consentement_photo`, `date_naissance`, `lieu_naissance_ville`, `lieu_naissance_pays` | Identité |
-| `numero_agrement`, `nir`, `date_agrement` | Pro |
-| `capacite_accueil`, `places_disponibles` | Pro |
-| `biographie` | Présentation |
-
-Validation NIR identique à l’inscription si `nir` fourni.
-
-### Réponse succès (nouveau format)
-
-```json
-{
-  "message": "Dossier resoumis avec succès. Il est de nouveau en attente de validation.",
-  "statut": "en_attente",
-  "user_id": "uuid",
-  "numero_dossier": "2026-000021"
-}
-```
-
-Code HTTP : **200** (pas de corps `Users` brut comme l’ancien back).
-
-### Effet métier
-
-- **Parent :** tous les users `role=parent` avec le même `numero_dossier` passent en `en_attente` ; `token_reprise` invalidé sur **tous** (symétrique refus #110).
-- **AM :** un seul user.
-
-### E-mail accusé resoumission (parent)
-
-Après `PATCH` réussi, un e-mail est envoyé à **chaque parent** du dossier (`sendResoumissionPendingEmail`) :
-- confirmation de resoumission ;
-- rappel du **numéro de dossier** ;
-- mention « en attente de validation ».
-
-Échec SMTP : logué, **ne bloque pas** la resoumission (même règle que l'inscription initiale).
-
----
-
-## 4. Fichiers front à modifier (checklist)
-
-### Modèles
-
-- [ ] `lib/models/reprise_dossier.dart` — parser `parents[]`, `enfants[]`, `texte_motivation`, champs AM
-- [ ] Réutiliser ou mapper vers `DossierFamilleEnfant` / structures existantes (#119 admin) si possible
-
-### Session / préremplissage
-
-- [ ] `lib/services/reprise_session.dart`
-  - `applyToParent` : remplir parent1/parent2 depuis `parents[]`, enfants, motivation
-  - `applyToAm` : remplir tous les champs AM
-
-### API
-
-- [ ] `lib/services/auth_service.dart` — `resoumettreReprise()` : accepter body complet (parent + AM), pas seulement identité
-- [ ] Étendre `UserRegistrationData` / `AmRegistrationData` helpers `toReprisePatchBody()` si utile
-
-### Écrans fin de parcours
-
-- [ ] `parent_register_step5_screen.dart` — PATCH avec co-parent, enfants, motivation
-- [ ] `am_register_step4_screen.dart` — PATCH avec fiche AM complète
-
-### Hors scope back (inchangé)
-
-RIB / IBAN / attestation CAF (étape 5 wizard parent) : **non persistés** — rien à envoyer en reprise.
-
-### Non implémenté front (ticket #112 initial)
-
-- [ ] Modale login « J’ai un numéro de dossier » → `POST /auth/reprise-identify` (back prêt, front absent)
-
----
-
-## 5. Tests manuels suggérés
-
-1. Refuser un dossier parent complet (≥1 enfant + co-parent + motivation).
-2. Ouvrir le lien mail `/reprise?token=…`.
-3. Vérifier dans DevTools que le GET contient `enfants[]` et `texte_motivation`.
-4. Après branchement front : wizard prérempli sur toutes les étapes.
-5. Resoumettre → statut `en_attente` pour les deux parents ; dossier visible file validation admin (#119).
-
----
-
-## 6. Références code back
-
-```
-backend/src/routes/auth/dto/reprise-dossier.dto.ts
-backend/src/routes/auth/dto/resoumettre-reprise.dto.ts
-backend/src/routes/auth/dto/enfant-reprise.dto.ts
-backend/src/routes/auth/auth.service.ts  → getRepriseDossier, resoumettreReprise
-backend/src/routes/parents/dto/dossier-famille-complet.dto.ts
-```

docs/archive/temporaires/TEMP_131-back-fiche-am-enfants.md

@@ -1,132 +0,0 @@
-# #131 — Fiche AM éditable + affiliation enfants (note front → back)
-
-**Ticket :** #131 (partie AM, doc `28_EVOLUTION-FAMILLE-ET-RESPONSABLES.md` §6.1)  
-**Date :** 2026-06-01  
-**Statut front :** modale livrée (2 onglets) — **API affiliation AM↔enfant à implémenter**
-
----
-
-## 1. Comportement UI (front)
-
-Modale `AdminAmEditModal` — même shell que la fiche parent (~930 px) :
-
-| Onglet | Contenu |
-|--------|---------|
-| **Identité & professionnel** | `IdentityBlock` éditable + grille pro (agrément, ville résidence, capacité, places, NIR/agrément date en lecture seule, biographie, switch disponible) + gélule statut |
-| **Enfants accueillis** | Liste cartes enfants (réutilise `AdminChildrenAffiliationPanel` / `AdminEnfantUserCard`) + rattacher / détacher |
-
-En-tête : prénom nom · sous-titre `Zone · Agrément · Dossier`.
-
----
-
-## 2. Endpoints consommés
-
-### Déjà existants (partiels)
-
-| Méthode | Route | Usage |
-|---------|-------|-------|
-| `GET` | `/api/v1/assistantes-maternelles` | Liste AM |
-| `GET` | `/api/v1/assistantes-maternelles/:userId` | Détail (403 possible pour `administrateur` → fallback liste) |
-| `PATCH` | `/api/v1/users/:userId` | Identité + statut (admin / super_admin uniquement) |
-| `PATCH` | `/api/v1/assistantes-maternelles/:userId` | Champs pro (gestionnaire / super_admin) |
-
-### À créer (recommandé — miroir parent #131 / #115)
-
-| Méthode | Route | Rôle |
-|---------|-------|------|
-| `PATCH` | `/api/v1/assistantes-maternelles/:userId/fiche` | Mise à jour unifiée identité + pro + statut (`super_admin`, `gestionnaire`, `administrateur`) |
-| `POST` | `/api/v1/assistantes-maternelles/:userId/enfants/:enfantId` | Rattacher un enfant |
-| `DELETE` | `/api/v1/assistantes-maternelles/:userId/enfants/:enfantId` | Détacher un enfant |
-| `GET` | `/api/v1/assistantes-maternelles/:userId` | Inclure `amChildren[]` (relation enfant) |
-
-Le front appelle déjà ces routes ; en l’absence de `PATCH …/fiche`, il tente un fallback `PATCH users` + `PATCH assistantes-maternelles` (échoue selon le rôle connecté).
-
----
-
-## 3. Modèle de données affiliation AM ↔ enfant
-
-**À définir côté BDD** (pas de table dédiée aujourd’hui, contrairement à `enfants_parents`) :
-
-Proposition alignée parent :
-
-```sql
--- Piste : enfants_assistantes_maternelles
-CREATE TABLE enfants_assistantes_maternelles (
-  id_am UUID NOT NULL REFERENCES utilisateurs(id) ON DELETE CASCADE,
-  id_enfant UUID NOT NULL REFERENCES enfants(id) ON DELETE CASCADE,
-  PRIMARY KEY (id_am, id_enfant)
-);
-```
-
-Réponse API attendue sur `GET /assistantes-maternelles/:id` :
-
-```json
-{
-  "user_id": "uuid-am",
-  "user": { "id": "…", "prenom": "Claire", "nom": "MARTIN", "statut": "actif" },
-  "approval_number": "AGR-2024-12345",
-  "residence_city": "Bezons",
-  "max_children": 4,
-  "places_available": 2,
-  "available": true,
-  "amChildren": [
-    {
-      "child": {
-        "id": "uuid-enfant",
-        "first_name": "Emma",
-        "last_name": "MARTIN",
-        "status": "actif",
-        "birth_date": "2023-02-15"
-      }
-    }
-  ]
-}
-```
-
-Le front parse `amChildren` / `am_children` / `assistanteChildren` (même logique que `parentChildren`).
-
----
-
-## 4. Body `PATCH …/fiche` suggéré
-
-```json
-{
-  "nom": "MARTIN",
-  "prenom": "Claire",
-  "email": "claire@example.com",
-  "telephone": "0612345678",
-  "adresse": "5 place Bellecour",
-  "ville": "Lyon",
-  "code_postal": "69002",
-  "statut": "actif",
-  "approval_number": "AGR-2024-12345",
-  "residence_city": "Lyon",
-  "max_children": 4,
-  "places_available": 2,
-  "biography": "…",
-  "available": true
-}
-```
-
-NIR et date d’agrément : lecture seule dans la modale (modification hors périmètre admin v1).
-
----
-
-## 5. Fichiers front concernés
-
-| Fichier | Rôle |
-|---------|------|
-| `frontend/lib/widgets/admin/common/admin_am_edit_modal.dart` | Modale 2 onglets |
-| `frontend/lib/widgets/admin/common/admin_children_affiliation_panel.dart` | Liste enfants partagée parent/AM |
-| `frontend/lib/widgets/admin/common/admin_status_capsule.dart` | Gélule statut partagée |
-| `frontend/lib/models/assistante_maternelle_model.dart` | Parse champs pro + `amChildren` |
-| `frontend/lib/services/user_service.dart` | `getAssistanteMaternelle`, `updateAmFiche`, `attachEnfantToAm`, `detachEnfantFromAm` |
-| `frontend/lib/widgets/admin/assistante_maternelle_management_widget.dart` | Ouverture modale au clic Modifier |
-
----
-
-## 6. Références
-
-- Fiche parent : `PATCH /parents/:id/fiche`, `POST|DELETE /parents/:id/enfants/:enfantId`
-- Ticket Gitea **#131**, **#115**
-- `docs/archive/temporaires/TEMP_131-back-fiche-parent-co-parent.md`

docs/archive/temporaires/TEMP_131-back-fiche-parent-co-parent.md

@@ -1,124 +0,0 @@
-# #131 — En-tête fiche parent : co-parent (note front → back)
-
-**Ticket :** #131 (fiche parent dashboard, doc `28_EVOLUTION-FAMILLE-ET-RESPONSABLES.md` §6.1)  
-**Date :** 2026-06-01  
-**Statut front :** livré (en-tête dynamique)  
-**Modif backend demandée :** **aucune** — ce document fixe le contrat attendu et invite à valider que l’existant le couvre.
-
----
-
-## 1. Comportement UI (front)
-
-Dans la modale **fiche parent** (`AdminParentEditModal`) :
-
-| Zone | Contenu |
-|------|---------|
-| **Titre** | `prenom` + `nom` du parent affiché (plus le libellé fixe « Fiche parent ») |
-| **Sous-titre** | `Co-parent : {prenom} {nom}` — affiché **uniquement** si un co-parent est connu |
-
-Le titre se met à jour en direct pendant l’édition des champs nom/prénom.  
-Le sous-titre provient du co-parent **chargé depuis l’API** (pas saisi à la main dans la modale).
-
----
-
-## 2. Endpoints consommés
-
-| Méthode | Route | Usage front |
-|---------|-------|-------------|
-| `GET` | `/api/v1/parents` | Liste parents (onglet Parents) |
-| `GET` | `/api/v1/parents/:userId` | Rechargement fiche après rattachement/détachement enfant |
-| `PATCH` | `/api/v1/parents/:userId/fiche` | Sauvegarde identité + statut (inchangé) |
-
-Rôles : `super_admin`, `gestionnaire`, `administrateur` (selon route).
-
----
-
-## 3. Contrat JSON attendu pour `co_parent`
-
-Le front parse `ParentModel.fromJson` avec la clé **`co_parent`** (snake_case), objet utilisateur imbriqué.
-
-### Champs minimum utilisés pour le sous-titre
-
-| Clé JSON | Usage |
-|----------|--------|
-| `co_parent` | Objet ou absent/`null` |
-| `co_parent.id` | Identifiant (futur lien cliquable éventuel) |
-| `co_parent.prenom` | Affichage |
-| `co_parent.nom` | Affichage |
-
-Affichage front : `'{prenom} {nom}'.trim()` → libellé `Co-parent : …`.
-
-### Exemple de fragment de réponse (`GET /parents/:id`)
-
-```json
-{
-  "user_id": "33333333-3333-3333-3333-333333333333",
-  "numero_dossier": "2026-000042",
-  "user": {
-    "id": "33333333-3333-3333-3333-333333333333",
-    "email": "parent1@example.com",
-    "prenom": "Paul",
-    "nom": "PARENT",
-    "statut": "actif",
-    "telephone": "0601020304"
-  },
-  "co_parent": {
-    "id": "44444444-4444-4444-4444-444444444444",
-    "email": "coparent1@example.com",
-    "prenom": "Clara",
-    "nom": "COPARENT",
-    "role": "parent",
-    "statut": "actif"
-  },
-  "parentChildren": []
-}
-```
-
-> **Note :** le front lit `user` (pas `utilisateur`). La doc `11_API.md` § Parents mentionne encore `utilisateur` / `id_co_parent` seul — le contrat **effectif** côté Nest/TypeORM est l’entité `Parents` sérialisée (`user`, `co_parent`, `parentChildren`, …).
-
----
-
-## 4. État backend (à valider, pas à refaire)
-
-D’après le code actuel (`parents.service.ts`) :
-
-- `findAll()` et `findOne(user_id)` chargent déjà la relation **`co_parent`** ;
-- la FK métier est `parents.id_co_parent` → `utilisateurs.id` ;
-- à l’inscription couple, les deux sens sont en principe renseignés (`auth.service.ts`).
-
-**Checklist validation back :**
-
-- [ ] `GET /parents/:id` renvoie bien `co_parent` peuplé quand `id_co_parent` est non null
-- [ ] `GET /parents` (liste) inclut aussi `co_parent` (sous-titre disponible dès l’ouverture sans re-fetch)
-- [ ] Les champs `prenom` / `nom` du co-parent sont présents dans la réponse JSON
-
-Si ces trois points passent en recette, **aucun changement backend n’est nécessaire** pour cette fonctionnalité.
-
----
-
-## 5. Points d’attention (hors périmètre immédiat)
-
-| Sujet | Détail |
-|-------|--------|
-| **Lien inverse** | Si le parent B est le co-parent de A (`A.id_co_parent = B`) mais que `B.id_co_parent` est `null`, le sous-titre **ne s’affichera pas** sur la fiche de B. Le front ne fait pas de résolution inverse. À traiter côté back **seulement si** des données legacy ont un lien à sens unique. |
-| **Familles > 2 adultes** | Le sous-titre n’affiche que le co-parent direct (`id_co_parent`). Les autres responsables liés uniquement via `enfants_parents` ne sont pas listés ici (cf. doc 28 §6). |
-| **Données sensibles** | Vérifier que la sérialisation de `co_parent` n’expose pas `password` / tokens (même remarque que pour `user`). |
-
----
-
-## 6. Fichiers front concernés
-
-| Fichier | Rôle |
-|---------|------|
-| `frontend/lib/models/parent_model.dart` | Parse `co_parent` → `AppUser? coParent` |
-| `frontend/lib/widgets/admin/common/admin_parent_edit_modal.dart` | Titre + sous-titre |
-| `frontend/lib/services/user_service.dart` | `getParents()` / `getParent()` |
-
----
-
-## 7. Références
-
-- `docs/28_EVOLUTION-FAMILLE-ET-RESPONSABLES.md` §6.1
-- `backend/src/routes/parents/parents.service.ts` — `findOne`, `findAll`
-- `backend/src/entities/parents.entity.ts` — relation `co_parent`
-- Ticket Gitea **#131**

docs/archive/temporaires/TEMP_FRONT_alignement_AM.md

@@ -1,46 +0,0 @@
-# TEMP — Alignement front / API (inscription AM & validation gestionnaire)
-
-> **Archivé** (`docs/archive/temporaires/`) — **fichier temporaire** ; à
-> **supprimer** une fois le front livré ou le sujet clos (voir
-> `docs/archive/temporaires/README.md`).
-
-Ce document décrit les changements **côté API** et ce que **Flutter** doit faire pour rester aligné. Aucune modification front n’a été faite dans le chantier backend associé.
-
-## 1. `POST /auth/register/am` — lieu de naissance obligatoire
-
-- **`lieu_naissance_ville`** et **`lieu_naissance_pays`** sont **obligatoires** (non vides après trim, min. **2 caractères** chacun, max 100).
-- Réponses **400** si manquants ou invalides (messages class-validator).
-- **Action front** : champs obligatoires dans le parcours AM (étapes identité / naissance), validation UI avant envoi ; afficher les erreurs renvoyées par l’API.
-
-## 2. Réponse `GET /dossiers/:numeroDossier` (type `am`)
-
-Sous `dossier.user`, l’API peut inclure :
-
-| Clé JSON | Description |
-|----------|-------------|
-| `date_naissance` | Date (si renseignée à l’inscription) |
-| `lieu_naissance_ville` | Ville de naissance |
-| `lieu_naissance_pays` | Pays de naissance |
-| `consentement_photo` | Booléen (exposé dans `dossier.user`) |
-
-À la **racine** de `dossier` (objet AM), champs déjà renvoyés par le backend : `disponible`, `annees_experience`, `specialite`, `nb_max_enfants`, `place_disponible`, etc.
-
-**Action front** :
-
-- Étendre **`AppUser.fromJson` / `toJson`** (`lib/models/user.dart`) pour mapper `date_naissance`, `lieu_naissance_ville`, `lieu_naissance_pays`, `consentement_photo`.
-- Étendre **`DossierAM.fromJson`** (`lib/models/dossier_unifie.dart`) pour parser `disponible`, `annees_experience`, `specialite` à la racine du dossier (noms snake_case comme dans la réponse JSON Nest).
-
-## 3. `ValidationAmWizard` (admin)
-
-Afficher pour cohérence avec le formulaire d’inscription :
-
-- **Informations personnelles** : date de naissance, ville / pays de naissance, consentement photo (Oui/Non).
-- **Informations professionnelles** : disponibilité, années d’expérience, spécialité (afficher « – » si `null`).
-
-## 4. `place_disponible` à l’inscription
-
-- Le backend initialise **`place_disponible`** sur la fiche AM à la **même valeur** que **`capacite_accueil`** à la création. Le wizard peut donc afficher une valeur cohérente avec la capacité sans champ séparé côté public.
-
----
-
-*Dernière mise à jour : alignement backend branche `feature/120-inscription-am-photo-backend`.*

docs/métriques/2026-07-22_analyse-empreinte.md

@@ -0,0 +1,104 @@
+# Analyse d’empreinte — P'titsPas
+
+**Date :** 2026-07-22  
+**Contexte :** snapshot pour mémoire (après alerte disque plein + purge cache Gitea)  
+**Périmètre :** application `jmartin/petitspas` déployée sur le VPS (`/home/deploy/dev/ptitspas-app`)
+
+---
+
+## 1. Lignes de code
+
+Comptage brut (`wc -l`), hors `node_modules` / builds / `.dart_tool`.
+
+| Zone | Lignes | Fichiers |
+|------|--------|----------|
+| **Frontend** (Dart `frontend/lib/`) | ~29 800 | 141 |
+| **Backend** (TypeScript `backend/src/`) | ~10 000 | 141 |
+| **BDD** (SQL sous `database/`) | ~1 250 | ~15 |
+| **Total** | **~41 000** | |
+
+### Frontend (détail)
+
+| Dossier | Lignes |
+|---------|--------|
+| `widgets/` | ~18 400 |
+| `screens/` | ~5 000 |
+| `services/` | ~2 300 |
+| `models/` | ~2 200 |
+| `utils/` | ~1 400 |
+| reste | ~500 |
+
+### Backend (détail)
+
+| Dossier | Lignes |
+|---------|--------|
+| `routes/` | ~6 500 |
+| `modules/` | ~1 700 |
+| `entities/` | ~1 000 |
+| `common/` + `config/` | ~400 |
+
+### BDD (détail)
+
+| Élément | Lignes |
+|---------|--------|
+| `BDD.sql` (schéma) | ~470 |
+| seeds | ~300 |
+| migrations / patches | ~280 |
+| tests SQL | ~205 |
+
+---
+
+## 2. Empreinte disque — runtime (Docker)
+
+| Composant | Taille | Notes |
+|-----------|--------|--------|
+| Image `ptitspas-app-backend` | ~300 Mo | NestJS |
+| Image `ptitspas-app-frontend` | ~122 Mo | Flutter web + Nginx |
+| Image `postgres:17` | ~454 Mo | |
+| Image `dpage/pgadmin4` | ~534 Mo | optionnel |
+| Volume `postgres_data` | ~49 Mo | données BDD live |
+| Volume `backend_uploads` | ~20 Mo | photos |
+| Volume `backend_documents_legaux` | ~0 | |
+| **Stack complète (avec pgAdmin)** | **~1,5 Go** | |
+| **Stack prod sans pgAdmin** | **~945 Mo** | |
+
+---
+
+## 3. Empreinte disque — code source
+
+| Élément | Taille |
+|---------|--------|
+| Clone `/home/deploy/dev/ptitspas-app` | ~701 Mo |
+| dont `backend/node_modules` | ~354 Mo |
+| dont `frontend` (+ `.dart_tool`) | ~114 Mo |
+| **Code utile** (hors deps / `.git` / builds) | **~51 Mo** |
+| Repo Gitea `petitspas.git` | ~109 Mo |
+| Dump `database/BDD.sql` | ~19 Ko |
+
+---
+
+## 4. Pour (re)déployer
+
+Minimum requis :
+
+1. Images custom backend + frontend (~422 Mo), ou code + build Docker  
+2. Image `postgres:17` (~454 Mo)  
+3. Volumes persistants (~70 Mo au snapshot)  
+4. Optionnel : pgAdmin (~534 Mo)
+
+**Ordre de grandeur :** ~1 Go pour faire tourner l’app en prod (sans pgAdmin).
+
+---
+
+## 5. Notes infra du jour (lié)
+
+- Disque VPS passé de **100 %** à ~**44 %** après :
+  - purge cache Docker / journals
+  - purge officielle Gitea `delete_repo_archives` (~24 Go de zip/bundle `petitspas`)
+- Crons Gitea activés :
+  - `archive_cleanup` @midnight (`OLDER_THAN = 24h`)
+  - `delete_repo_archives` @weekly
+
+---
+
+*Fichier généré pour historique projet — ne pas considérer comme métrique CI automatisée.*

docs/tmp/112-back-reprise-alignement-front.md

@@ -1,244 +0,0 @@
-# #112 — Alignement front après évolution back (reprise dossier complet)
-
-**Branche déployée :** `feature/112-reprise-apres-refus-front`  
-**Commit back :** `d70577b1` — `feat(#112): reprise après refus — dossier complet GET/PATCH`  
-**Date :** 2026-06-16
-
-Ce document décrit le **contrat API réel** après extension du back, et ce que le front doit encore brancher pour exploiter le dossier complet (au-delà de l’identité seule).
-
----
-
-## 1. Endpoints (inchangés côté URL)
-
-| Méthode | Route | Auth |
-|---------|-------|------|
-| `GET` | `/api/v1/auth/reprise-dossier?token={uuid}` | Public |
-| `PATCH` | `/api/v1/auth/reprise-resoumettre` | Public |
-| `POST` | `/api/v1/auth/reprise-identify` | Public (inchangé) |
-
-> **Note :** le ticket #111 parlait de `PUT` ; l’implémentation reste en **`PATCH`** (comme avant).
-
----
-
-## 2. `GET /auth/reprise-dossier` — réponse enrichie
-
-### Champs communs (toujours présents)
-
-Identiques à avant : `id`, `email`, `prenom`, `nom`, `telephone`, `adresse`, `ville`, `code_postal`, `numero_dossier`, `role`, `photo_url`, `genre`, `situation_familiale`.
-
-### Rôle `parent` (+ champs #119)
-
-Alignés sur `DossierFamilleCompletDto` :
-
-```json
-{
-  "parents": [
-    {
-      "user_id": "uuid",
-      "email": "…",
-      "prenom": "…",
-      "nom": "…",
-      "telephone": "…",
-      "adresse": "…",
-      "ville": "…",
-      "code_postal": "…",
-      "statut": "refuse",
-      "co_parent_id": "uuid-parent-entity"
-    }
-  ],
-  "enfants": [
-    {
-      "id": "uuid-enfant",
-      "first_name": "Emma",
-      "last_name": "MARTIN",
-      "genre": "F",
-      "status": "actif",
-      "birth_date": "2023-02-15T00:00:00.000Z",
-      "due_date": null,
-      "photo_url": "/uploads/photos/…",
-      "consent_photo": true,
-      "est_multiple": false
-    }
-  ],
-  "texte_motivation": "Nous recherchons…"
-}
-```
-
-**Mapping front suggéré :**
-
-| JSON back | Modèle / wizard parent |
-|-----------|-------------------------|
-| `parents[]` | `UserRegistrationData.parent1` + `parent2` (matcher par `email` ou ordre : titulaire = `id` du GET racine) |
-| `enfants[].first_name` / `last_name` | `ChildData.firstName` / `lastName` |
-| `enfants[].birth_date` | `ChildData.birthDate` (ISO → `DateTime`) |
-| `enfants[].due_date` | `ChildData.dueDate` (enfant `a_naitre`) |
-| `enfants[].status` | `actif` = né, `a_naitre` = à naître |
-| `enfants[].photo_url` | `ApiConfig.absoluteMediaUrl()` + conserver pour reprise sans re-upload |
-| `enfants[].id` | **Obligatoire** pour le PATCH (update par id) |
-| `enfants[].est_multiple` | `grossesse_multiple` si utilisé |
-| `texte_motivation` | étape présentation / motivation |
-
-Si `numero_dossier` absent : pas de `parents[]` / `enfants[]` / `texte_motivation` (identité seule).
-
-### Rôle `assistante_maternelle`
-
-Champs racine + fiche pro (structure **aplatie**, pas de sous-objet `user`) :
-
-```json
-{
-  "consentement_photo": true,
-  "date_naissance": "1985-03-12T00:00:00.000Z",
-  "lieu_naissance_ville": "Paris",
-  "lieu_naissance_pays": "France",
-  "numero_agrement": "AGR-2024-12345",
-  "nir": "123456789012345",
-  "date_agrement": "2024-06-01T00:00:00.000Z",
-  "nb_max_enfants": 4,
-  "place_disponible": 2,
-  "biographie": "…"
-}
-```
-
-**Mapping `AmRegistrationData` :**
-
-| JSON back | Champ front |
-|-----------|-------------|
-| `nb_max_enfants` | `capaciteAccueil` |
-| `place_disponible` | `placesDisponibles` |
-| `numero_agrement` | `numeroAgrement` |
-| `biographie` | `biographie` / présentation |
-| `photo_url` | déjà géré via `RepriseSession.photoUrl` |
-
----
-
-## 3. `PATCH /auth/reprise-resoumettre` — body étendu
-
-### Commun
-
-```json
-{ "token": "uuid-reprise" }
-```
-
-### Parent — champs à envoyer depuis le wizard
-
-| Champ PATCH | Source wizard | Notes |
-|-------------|---------------|-------|
-| `prenom`, `nom`, `telephone`, `adresse`, `ville`, `code_postal` | Parent 1 (titulaire token) | Champs racine |
-| `co_parent_prenom`, `co_parent_nom`, `co_parent_telephone` | Parent 2 | |
-| `co_parent_meme_adresse`, `co_parent_adresse`, `co_parent_code_postal`, `co_parent_ville` | Parent 2 adresse | |
-| `texte_motivation` **ou** `presentation_dossier` | Étape motivation | Les deux alias acceptés |
-| `enfants[]` | Liste enfants | Voir ci-dessous |
-
-**Structure `enfants[]` (miroir inscription + `id` obligatoire) :**
-
-```json
-{
-  "id": "uuid-enfant-existant",
-  "prenom": "Emma",
-  "nom": "MARTIN",
-  "date_naissance": "2023-02-15",
-  "date_previsionnelle_naissance": null,
-  "genre": "F",
-  "photo_base64": "data:image/jpeg;base64,…",
-  "photo_filename": "emma.jpg",
-  "grossesse_multiple": false
-}
-```
-
-- **v1 back :** update par `id` uniquement — pas de création/suppression d’enfant.
-- Si `id` inconnu pour ce dossier → **400** `Enfant inconnu pour ce dossier : {id}`.
-- Sans nouvelle photo : ne pas envoyer `photo_base64` (l’existant est conservé).
-
-### AM — champs à envoyer
-
-| Champ PATCH | Source |
-|-------------|--------|
-| Identité + `photo_url` ou `photo_base64` + `photo_filename` | Étapes 1–2 |
-| `consentement_photo`, `date_naissance`, `lieu_naissance_ville`, `lieu_naissance_pays` | Identité |
-| `numero_agrement`, `nir`, `date_agrement` | Pro |
-| `capacite_accueil`, `places_disponibles` | Pro |
-| `biographie` | Présentation |
-
-Validation NIR identique à l’inscription si `nir` fourni.
-
-### Réponse succès (nouveau format)
-
-```json
-{
-  "message": "Dossier resoumis avec succès. Il est de nouveau en attente de validation.",
-  "statut": "en_attente",
-  "user_id": "uuid",
-  "numero_dossier": "2026-000021"
-}
-```
-
-Code HTTP : **200** (pas de corps `Users` brut comme l’ancien back).
-
-### Effet métier
-
-- **Parent :** tous les users `role=parent` avec le même `numero_dossier` passent en `en_attente` ; `token_reprise` invalidé sur **tous** (symétrique refus #110).
-- **AM :** un seul user.
-
-### E-mail accusé resoumission (parent)
-
-Après `PATCH` réussi, un e-mail est envoyé à **chaque parent** du dossier (`sendResoumissionPendingEmail`) :
-- confirmation de resoumission ;
-- rappel du **numéro de dossier** ;
-- mention « en attente de validation ».
-
-Échec SMTP : logué, **ne bloque pas** la resoumission (même règle que l'inscription initiale).
-
----
-
-## 4. Fichiers front à modifier (checklist)
-
-### Modèles
-
-- [ ] `lib/models/reprise_dossier.dart` — parser `parents[]`, `enfants[]`, `texte_motivation`, champs AM
-- [ ] Réutiliser ou mapper vers `DossierFamilleEnfant` / structures existantes (#119 admin) si possible
-
-### Session / préremplissage
-
-- [ ] `lib/services/reprise_session.dart`
-  - `applyToParent` : remplir parent1/parent2 depuis `parents[]`, enfants, motivation
-  - `applyToAm` : remplir tous les champs AM
-
-### API
-
-- [ ] `lib/services/auth_service.dart` — `resoumettreReprise()` : accepter body complet (parent + AM), pas seulement identité
-- [ ] Étendre `UserRegistrationData` / `AmRegistrationData` helpers `toReprisePatchBody()` si utile
-
-### Écrans fin de parcours
-
-- [ ] `parent_register_step5_screen.dart` — PATCH avec co-parent, enfants, motivation
-- [ ] `am_register_step4_screen.dart` — PATCH avec fiche AM complète
-
-### Hors scope back (inchangé)
-
-RIB / IBAN / attestation CAF (étape 5 wizard parent) : **non persistés** — rien à envoyer en reprise.
-
-### Non implémenté front (ticket #112 initial)
-
-- [ ] Modale login « J’ai un numéro de dossier » → `POST /auth/reprise-identify` (back prêt, front absent)
-
----
-
-## 5. Tests manuels suggérés
-
-1. Refuser un dossier parent complet (≥1 enfant + co-parent + motivation).
-2. Ouvrir le lien mail `/reprise?token=…`.
-3. Vérifier dans DevTools que le GET contient `enfants[]` et `texte_motivation`.
-4. Après branchement front : wizard prérempli sur toutes les étapes.
-5. Resoumettre → statut `en_attente` pour les deux parents ; dossier visible file validation admin (#119).
-
----
-
-## 6. Références code back
-
-```
-backend/src/routes/auth/dto/reprise-dossier.dto.ts
-backend/src/routes/auth/dto/resoumettre-reprise.dto.ts
-backend/src/routes/auth/dto/enfant-reprise.dto.ts
-backend/src/routes/auth/auth.service.ts  → getRepriseDossier, resoumettreReprise
-backend/src/routes/parents/dto/dossier-famille-complet.dto.ts
-```

frontend/lib/models/dossier_list_item.dart

@@ -0,0 +1,239 @@
+import 'package:p_tits_pas/models/assistante_maternelle_model.dart';
+import 'package:p_tits_pas/models/parent_model.dart';
+import 'package:p_tits_pas/utils/name_format_utils.dart';
+
+/// Ligne de liste unifiée dossiers (famille ou AM) — ticket #153.
+enum DossierListType { famille, assistanteMaternelle }
+
+class DossierListItem {
+  final DossierListType type;
+  final String numeroDossier;
+  final String libelle;
+  final List<String> emails;
+  final String? statut;
+  /// Photo profil (AM) — affichée à la place de l’icône si présente.
+  final String? photoUrl;
+  /// Dossier famille sans enfant lié (#159 / #160).
+  final bool sansEnfant;
+  /// Nombre d’enfants du foyer (famille uniquement ; null pour AM).
+  final int? enfantsCount;
+
+  const DossierListItem({
+    required this.type,
+    required this.numeroDossier,
+    required this.libelle,
+    this.emails = const [],
+    this.statut,
+    this.photoUrl,
+    this.sansEnfant = false,
+    this.enfantsCount,
+  });
+
+  DossierListItem copyWith({
+    DossierListType? type,
+    String? numeroDossier,
+    String? libelle,
+    List<String>? emails,
+    String? statut,
+    String? photoUrl,
+    bool? sansEnfant,
+    int? enfantsCount,
+  }) {
+    return DossierListItem(
+      type: type ?? this.type,
+      numeroDossier: numeroDossier ?? this.numeroDossier,
+      libelle: libelle ?? this.libelle,
+      emails: emails ?? this.emails,
+      statut: statut ?? this.statut,
+      photoUrl: photoUrl ?? this.photoUrl,
+      sansEnfant: sansEnfant ?? this.sansEnfant,
+      enfantsCount: enfantsCount ?? this.enfantsCount,
+    );
+  }
+
+  bool get isFamille => type == DossierListType.famille;
+  bool get isAm => type == DossierListType.assistanteMaternelle;
+
+  String get typeLabel => isFamille ? 'Famille' : 'AM';
+
+  /// Sous-titre carte : `NOM Prénom` ou `NOM Prénom - NOM Prénom`.
+  String get namesLine => libelle;
+
+  String get emailsLine => emails.where((e) => e.trim().isNotEmpty).join(' · ');
+
+  /// Titre carte : numéro de dossier seul.
+  String get titleLine => numeroDossier;
+
+  bool matchesQuery(String query) {
+    final q = query.trim().toLowerCase();
+    if (q.isEmpty) return true;
+    if (numeroDossier.toLowerCase().contains(q)) return true;
+    if (libelle.toLowerCase().contains(q)) return true;
+    for (final e in emails) {
+      if (e.toLowerCase().contains(q)) return true;
+    }
+    return false;
+  }
+
+  /// Une ligne par `numero_dossier` (foyer dédupliqué).
+  static List<DossierListItem> fromParents(List<ParentModel> parents) {
+    final byDossier = <String, List<ParentModel>>{};
+    for (final p in parents) {
+      final num = (p.user.numeroDossier ?? '').trim();
+      if (num.isEmpty) continue;
+      byDossier.putIfAbsent(num, () => []).add(p);
+    }
+
+    final items = <DossierListItem>[];
+    for (final entry in byDossier.entries) {
+      final seenIds = <String>{};
+      final names = <String>[];
+      final emails = <String>[];
+      final statuts = <String>[];
+
+      void consider(
+        String? id,
+        String? nom,
+        String? prenom,
+        String? email,
+        String? statut,
+      ) {
+        final uid = (id ?? '').trim();
+        if (uid.isEmpty || !seenIds.add(uid)) return;
+        final label = formatDossierPersonLabel(
+          nom: nom,
+          prenom: prenom,
+          email: email,
+        );
+        if (label.isNotEmpty) names.add(label);
+        final e = (email ?? '').trim();
+        if (e.isNotEmpty) emails.add(e);
+        final s = (statut ?? '').trim();
+        if (s.isNotEmpty) statuts.add(s);
+      }
+
+      for (final p in entry.value) {
+        consider(
+          p.user.id,
+          p.user.nom,
+          p.user.prenom,
+          p.user.email,
+          p.user.statut,
+        );
+        final co = p.coParent;
+        if (co != null) {
+          consider(co.id, co.nom, co.prenom, co.email, co.statut);
+        }
+      }
+
+      final childIds = <String>{};
+      var maxCountFallback = 0;
+      for (final p in entry.value) {
+        for (final c in p.children) {
+          final id = c.id.trim();
+          if (id.isNotEmpty) childIds.add(id);
+        }
+        final n = p.children.isNotEmpty ? p.children.length : p.childrenCount;
+        if (n > maxCountFallback) maxCountFallback = n;
+      }
+      final enfantsCount =
+          childIds.isNotEmpty ? childIds.length : maxCountFallback;
+
+      items.add(
+        DossierListItem(
+          type: DossierListType.famille,
+          numeroDossier: entry.key,
+          libelle: names.isNotEmpty ? names.join(' - ') : 'Famille',
+          emails: emails,
+          statut: _preferStatut(statuts),
+          enfantsCount: enfantsCount,
+          sansEnfant: enfantsCount == 0,
+        ),
+      );
+    }
+    return items;
+  }
+
+  static List<DossierListItem> fromAssistantes(
+    List<AssistanteMaternelleModel> ams,
+  ) {
+    final byDossier = <String, AssistanteMaternelleModel>{};
+    for (final am in ams) {
+      final num = (am.user.numeroDossier ?? '').trim();
+      if (num.isEmpty) continue;
+      byDossier.putIfAbsent(num, () => am);
+    }
+
+    return byDossier.entries.map((e) {
+      final u = e.value.user;
+      final name = formatDossierPersonLabel(
+        nom: u.nom,
+        prenom: u.prenom,
+        email: u.email,
+      );
+      final photo = (u.photoUrl ?? '').trim();
+      return DossierListItem(
+        type: DossierListType.assistanteMaternelle,
+        numeroDossier: e.key,
+        libelle: name.isNotEmpty ? name : 'AM',
+        emails: u.email.trim().isEmpty ? const [] : [u.email.trim()],
+        statut: u.statut?.trim(),
+        photoUrl: photo.isEmpty ? null : photo,
+      );
+    }).toList();
+  }
+
+  /// Priorité affichage : en_attente > suspendu > refuse > actif > autre.
+  static String? _preferStatut(List<String> raw) {
+    if (raw.isEmpty) return null;
+    const order = ['en_attente', 'suspendu', 'refuse', 'actif'];
+    for (final wanted in order) {
+      for (final s in raw) {
+        if (s.toLowerCase() == wanted) return s;
+      }
+    }
+    return raw.first;
+  }
+}
+
+/// Affichage carte dossier : `NOM Prénom` (repli email).
+String formatDossierPersonLabel({
+  String? nom,
+  String? prenom,
+  String? email,
+}) {
+  final n = (nom ?? '').trim().toUpperCase();
+  final p = formatPersonNameCase(prenom ?? '');
+  if (n.isNotEmpty && p.isNotEmpty) return '$n $p';
+  if (n.isNotEmpty) return n;
+  if (p.isNotEmpty) return p;
+  return (email ?? '').trim();
+}
+
+/// Reformate un libellé famille API (`A & B` / `Famille …`) en `NOM Prénom - …`.
+String formatDossierFamilyNamesLine(String libelle) {
+  var raw = libelle.trim();
+  if (raw.isEmpty) return '';
+  raw = raw.replaceFirst(RegExp(r'^famille\s+', caseSensitive: false), '');
+  raw = raw
+      .replaceAll(RegExp(r'\s+&\s+'), ' - ')
+      .replaceAll(RegExp(r'\s+et\s+', caseSensitive: false), ' - ');
+  final parts = raw
+      .split(RegExp(r'\s+-\s+'))
+      .map((part) => _formatLoosePersonSegment(part.trim()))
+      .where((s) => s.isNotEmpty)
+      .toList();
+  return parts.join(' - ');
+}
+
+/// Segment libre type « martin sophie » ou « DURAND Amélie » → `NOM Prénom`.
+String _formatLoosePersonSegment(String segment) {
+  final words =
+      segment.split(RegExp(r'\s+')).where((w) => w.isNotEmpty).toList();
+  if (words.isEmpty) return '';
+  if (words.length == 1) return words.first.toUpperCase();
+  // Convention affichage : premier mot = NOM, reste = prénom(s).
+  final nom = words.first.toUpperCase();
+  final prenom = formatPersonNameCase(words.sublist(1).join(' '));
+  return '$nom $prenom';
+}

frontend/lib/models/dossier_unifie.dart

@@ -185,7 +185,6 @@ class EnfantDossier {
   final String? dueDate;
   final String? photoUrl;
   final bool consentPhoto;
-  final bool estMultiple;
 
   EnfantDossier({
     required this.id,
@@ -197,7 +196,6 @@ class EnfantDossier {
     this.dueDate,
     this.photoUrl,
     this.consentPhoto = false,
-    this.estMultiple = false,
   });
 
   String get fullName => '${firstName ?? ''} ${lastName ?? ''}'.trim();
@@ -215,8 +213,13 @@ class EnfantDossier {
   factory EnfantDossier.fromJson(Map<String, dynamic> json) {
     final rawPhoto = json['photo_url'] ?? json['photoUrl'];
     final resolvedPhoto = _optionalPhotoUrl(rawPhoto);
+    final rawId = json['id'] ??
+        json['enfant_id'] ??
+        json['enfantId'] ??
+        json['child_id'] ??
+        json['childId'];
     return EnfantDossier(
-      id: json['id']?.toString() ?? '',
+      id: rawId?.toString().trim() ?? '',
       firstName: (json['first_name'] ?? json['prenom'])?.toString(),
       lastName: (json['last_name'] ?? json['nom'])?.toString(),
       birthDate: json['birth_date']?.toString(),
@@ -226,8 +229,6 @@ class EnfantDossier {
       photoUrl: resolvedPhoto,
       consentPhoto:
           json['consent_photo'] == true || json['consentPhoto'] == true,
-      estMultiple:
-          json['est_multiple'] == true || json['estMultiple'] == true,
     );
   }
 }

frontend/lib/models/enfant_admin_model.dart

@@ -12,8 +12,9 @@ class EnfantAdminModel {
   final String status;
   final String? photoUrl;
   final bool consentPhoto;
-  final bool isMultiple;
   final List<EnfantParentLink> parentLinks;
+  /// Flag API #157 (sinon déduit de [parentLinks]).
+  final bool? sansResponsable;
 
   EnfantAdminModel({
     required this.id,
@@ -25,8 +26,8 @@ class EnfantAdminModel {
     required this.status,
     this.photoUrl,
     this.consentPhoto = false,
-    this.isMultiple = false,
     this.parentLinks = const [],
+    this.sansResponsable,
   });
 
   String get fullName {
@@ -37,6 +38,40 @@ class EnfantAdminModel {
     return '$fn $ln';
   }
 
+  /// Aucun lien parent valide — ticket #157.
+  bool get hasNoResponsable {
+    if (sansResponsable != null) return sansResponsable!;
+    return !parentLinks.any((l) => l.parentId.trim().isNotEmpty);
+  }
+
+  EnfantAdminModel copyWith({
+    String? id,
+    String? firstName,
+    String? lastName,
+    String? gender,
+    String? birthDate,
+    String? dueDate,
+    String? status,
+    String? photoUrl,
+    bool? consentPhoto,
+    List<EnfantParentLink>? parentLinks,
+    bool? sansResponsable,
+  }) {
+    return EnfantAdminModel(
+      id: id ?? this.id,
+      firstName: firstName ?? this.firstName,
+      lastName: lastName ?? this.lastName,
+      gender: gender ?? this.gender,
+      birthDate: birthDate ?? this.birthDate,
+      dueDate: dueDate ?? this.dueDate,
+      status: status ?? this.status,
+      photoUrl: photoUrl ?? this.photoUrl,
+      consentPhoto: consentPhoto ?? this.consentPhoto,
+      parentLinks: parentLinks ?? this.parentLinks,
+      sansResponsable: sansResponsable ?? this.sansResponsable,
+    );
+  }
+
   factory EnfantAdminModel.fromJson(Map<String, dynamic> json) {
     final linksRaw = json['parentLinks'] as List?;
     final links = <EnfantParentLink>[];
@@ -48,18 +83,32 @@ class EnfantAdminModel {
       }
     }
 
+    final photoUrl = json['photo_url'] as String? ?? json['photoUrl'] as String?;
+    final consentPhoto = _parseBool(json['consent_photo']) ||
+        _parseBool(json['consentement_photo']) ||
+        _parseBool(json['consentPhoto']);
+
+    bool? sansResponsable;
+    if (json.containsKey('sans_responsable') ||
+        json.containsKey('sansResponsable')) {
+      sansResponsable = _parseBool(json['sans_responsable']) ||
+          _parseBool(json['sansResponsable']);
+    }
+
     return EnfantAdminModel(
       id: (json['id'] ?? '').toString(),
-      firstName: json['first_name'] as String?,
+      firstName: json['first_name'] as String? ?? json['prenom'] as String?,
-      lastName: json['last_name'] as String?,
+      lastName: json['last_name'] as String? ?? json['nom'] as String?,
-      gender: json['gender'] as String?,
+      gender: json['gender'] as String? ?? json['genre'] as String?,
-      birthDate: _dateString(json['birth_date']),
+      birthDate: _dateString(json['birth_date'] ?? json['date_naissance']),
-      dueDate: _dateString(json['due_date']),
+      dueDate: _dateString(json['due_date'] ?? json['date_prevue_naissance']),
-      status: normalizeEnfantStatus(json['status']?.toString()),
+      status: normalizeEnfantStatus(
-      photoUrl: json['photo_url'] as String?,
+        (json['status'] ?? json['statut'])?.toString(),
-      consentPhoto: json['consent_photo'] == true,
+      ),
-      isMultiple: json['is_multiple'] == true,
+      photoUrl: photoUrl,
+      consentPhoto: consentPhoto,
       parentLinks: links,
+      sansResponsable: sansResponsable,
     );
   }
 
@@ -72,10 +121,18 @@ class EnfantAdminModel {
       if (birthDate != null && birthDate!.isNotEmpty) 'birth_date': birthDate,
       if (dueDate != null && dueDate!.isNotEmpty) 'due_date': dueDate,
       'consent_photo': consentPhoto,
-      'is_multiple': isMultiple,
     };
   }
 
+  static bool _parseBool(dynamic value) {
+    if (value == true || value == 1) return true;
+    if (value is String) {
+      final s = value.trim().toLowerCase();
+      return s == 'true' || s == '1' || s == 't' || s == 'yes';
+    }
+    return false;
+  }
+
   static String? _dateString(dynamic v) {
     if (v == null) return null;
     if (v is String) return v.split('T').first;
@@ -89,6 +146,13 @@ class EnfantParentLink {
 
   EnfantParentLink({required this.parentId, this.parentName});
 
+  EnfantParentLink copyWith({String? parentId, String? parentName}) {
+    return EnfantParentLink(
+      parentId: parentId ?? this.parentId,
+      parentName: parentName ?? this.parentName,
+    );
+  }
+
   factory EnfantParentLink.fromJson(Map<String, dynamic> json) {
     final parentId =
         (json['parentId'] ?? json['id_parent'] ?? '').toString();
@@ -99,6 +163,12 @@ class EnfantParentLink {
       if (user is Map<String, dynamic>) {
         final u = AppUser.fromJson(user);
         name = u.fullName.isNotEmpty ? u.fullName : u.email;
+      } else {
+        // Parfois le parent est aplati (prenom/nom) sans nested user.
+        final prenom = (parent['prenom'] ?? parent['first_name'] ?? '').toString().trim();
+        final nom = (parent['nom'] ?? parent['last_name'] ?? '').toString().trim();
+        final flat = '$prenom $nom'.trim();
+        if (flat.isNotEmpty) name = flat;
       }
     }
     return EnfantParentLink(

frontend/lib/models/parent_model.dart

@@ -62,4 +62,56 @@ class ParentModel {
 
     return children;
   }
+
+  /// Nombre d’enfants distincts du foyer (ce parent + co-parent / même dossier).
+  /// Évite Claire=7 / Thomas=6 quand un lien n’est que sur un des deux (#157).
+  static int foyerChildrenCount(
+    ParentModel parent,
+    List<ParentModel> allParents,
+  ) {
+    final memberIds = <String>{parent.user.id};
+    final coId = parent.coParent?.id.trim();
+    if (coId != null && coId.isNotEmpty) memberIds.add(coId);
+
+    final dossier = (parent.user.numeroDossier ?? '').trim();
+
+    for (final other in allParents) {
+      if (memberIds.contains(other.user.id)) continue;
+      final otherCo = other.coParent?.id.trim();
+      if (otherCo != null && memberIds.contains(otherCo)) {
+        memberIds.add(other.user.id);
+        continue;
+      }
+      if (dossier.isNotEmpty &&
+          (other.user.numeroDossier ?? '').trim() == dossier) {
+        memberIds.add(other.user.id);
+        final oc = other.coParent?.id.trim();
+        if (oc != null && oc.isNotEmpty) memberIds.add(oc);
+      }
+    }
+
+    final childIds = <String>{};
+    for (final p in allParents) {
+      if (!memberIds.contains(p.user.id)) continue;
+      for (final c in p.children) {
+        final id = c.id.trim();
+        if (id.isNotEmpty) childIds.add(id);
+      }
+      // Repli si la liste enfants n’est pas hydratée.
+      if (p.children.isEmpty && p.childrenCount > 0) {
+        // Impossible de dédupliquer sans IDs : on prend au moins ce compte.
+        // (évite d’afficher 0 si l’API n’envoie que childrenCount)
+      }
+    }
+
+    if (childIds.isNotEmpty) return childIds.length;
+
+    var maxCount = 0;
+    for (final p in allParents) {
+      if (!memberIds.contains(p.user.id)) continue;
+      final n = p.children.isNotEmpty ? p.children.length : p.childrenCount;
+      if (n > maxCount) maxCount = n;
+    }
+    return maxCount;
+  }
 }

frontend/lib/models/parent_user_registration_data.dart

@@ -30,7 +30,6 @@ class ChildData {
   String lastName;
   String dob; // Date de naissance ou prévisionnelle
   bool photoConsent;
-  bool multipleBirth;
   bool isUnbornChild;
   File? imageFile;
   CardColorVertical cardColor; // Nouveau champ pour la couleur de la carte
@@ -40,7 +39,6 @@ class ChildData {
     this.lastName = '',
     this.dob = '',
     this.photoConsent = false,
-    this.multipleBirth = false,
     this.isUnbornChild = false,
     this.imageFile,
     required this.cardColor, // Rendre requis dans le constructeur

frontend/lib/models/user_registration_data.dart

@@ -38,7 +38,6 @@ class ChildData {
   /// Valeurs API : `H`, `F`, `Autre` (GenreType backend). Vide tant que non choisi.
   String genre;
   bool photoConsent;
-  bool multipleBirth;
   bool isUnbornChild;
   File? imageFile;
   /// Octets de la photo (fiable à l’envoi API ; [imageFile] peut être absent sur le web).
@@ -55,7 +54,6 @@ class ChildData {
     this.dob = '',
     this.genre = '',
     this.photoConsent = false,
-    this.multipleBirth = false,
     this.isUnbornChild = false,
     this.imageFile,
     this.imageBytes,
@@ -70,7 +68,6 @@ class ChildData {
     String? dob,
     String? genre,
     bool? photoConsent,
-    bool? multipleBirth,
     bool? isUnbornChild,
     Object? imageFile = _unsetImage,
     Object? imageBytes = _unsetImageBytes,
@@ -84,7 +81,6 @@ class ChildData {
       dob: dob ?? this.dob,
       genre: genre ?? this.genre,
       photoConsent: photoConsent ?? this.photoConsent,
-      multipleBirth: multipleBirth ?? this.multipleBirth,
       isUnbornChild: isUnbornChild ?? this.isUnbornChild,
       imageFile: identical(imageFile, _unsetImage) ? this.imageFile : imageFile as File?,
       imageBytes:

frontend/lib/screens/administrateurs/admin_dashboardScreen.dart

@@ -2,9 +2,9 @@ import 'package:flutter/material.dart';
 import 'package:p_tits_pas/models/user.dart';
 import 'package:p_tits_pas/services/auth_service.dart';
 import 'package:p_tits_pas/services/configuration_service.dart';
-import 'package:p_tits_pas/widgets/admin/dashboard_admin.dart';
+import 'package:p_tits_pas/widgets/dashboard/user_management_sub_bar.dart';
-import 'package:p_tits_pas/widgets/admin/parametres_panel.dart';
+import 'package:p_tits_pas/widgets/dashboard/parametres_panel.dart';
-import 'package:p_tits_pas/widgets/admin/user_management_panel.dart';
+import 'package:p_tits_pas/widgets/dashboard/user_management_panel.dart';
 import 'package:p_tits_pas/widgets/app_footer.dart';
 import 'package:p_tits_pas/widgets/dashboard/dashboard_bandeau.dart';
 

frontend/lib/screens/administrateurs/creation/admin_create.dart

@@ -3,6 +3,7 @@ import 'package:p_tits_pas/utils/phone_utils.dart';
 import 'package:p_tits_pas/models/user.dart';
 import 'package:p_tits_pas/services/user_service.dart';
 import 'package:p_tits_pas/utils/email_utils.dart';
+import 'package:p_tits_pas/widgets/dashboard/common/suppression_confirm_dialog.dart';
 import 'package:p_tits_pas/widgets/email_text_field.dart';
 import 'package:p_tits_pas/widgets/french_phone_field.dart';
 
@@ -151,30 +152,19 @@ class _AdminCreateDialogState extends State<AdminCreateDialog> {
   Future<void> _delete() async {
     if (!_isEditMode || _isSubmitting) return;
 
-    final confirmed = await showDialog<bool>(
+    final name = widget.initialUser!.fullName.isEmpty
-      context: context,
+        ? widget.initialUser!.email
-      builder: (ctx) {
+        : widget.initialUser!.fullName;
-        return AlertDialog(
+    final confirmed = await showSuppressionConfirmDialog(
-          title: const Text('Confirmer la suppression'),
+      context,
-          content: Text(
+      title: 'Supprimer l\'administrateur',
-            'Supprimer ${widget.initialUser!.fullName.isEmpty ? widget.initialUser!.email : widget.initialUser!.fullName} ?',
+      people: [SuppressionPersonLine.administrateur(name)],
-          ),
+      footnotes: const [
-          actions: [
+        'Le compte sera définitivement supprimé.',
-            TextButton(
+      ],
-              onPressed: () => Navigator.of(ctx).pop(false),
-              child: const Text('Annuler'),
-            ),
-            FilledButton(
-              onPressed: () => Navigator.of(ctx).pop(true),
-              style: FilledButton.styleFrom(backgroundColor: Colors.red.shade700),
-              child: const Text('Supprimer'),
-            ),
-          ],
-        );
-      },
     );
 
-    if (confirmed != true) return;
+    if (!confirmed) return;
 
     setState(() {
       _isSubmitting = true;

frontend/lib/screens/administrateurs/creation/gestionnaires_create.dart

@@ -1,630 +0,0 @@
-import 'package:flutter/material.dart';
-import 'package:p_tits_pas/models/relais_model.dart';
-import 'package:p_tits_pas/utils/phone_utils.dart';
-import 'package:p_tits_pas/utils/email_utils.dart';
-import 'package:p_tits_pas/widgets/email_text_field.dart';
-import 'package:p_tits_pas/widgets/french_phone_field.dart';
-import 'package:p_tits_pas/models/user.dart';
-import 'package:p_tits_pas/services/relais_service.dart';
-import 'package:p_tits_pas/services/user_service.dart';
-
-class AdminUserFormDialog extends StatefulWidget {
-  final AppUser? initialUser;
-  final bool withRelais;
-  final bool adminMode;
-  final bool readOnly;
-
-  const AdminUserFormDialog({
-    super.key,
-    this.initialUser,
-    this.withRelais = true,
-    this.adminMode = false,
-    this.readOnly = false,
-  });
-
-  @override
-  State<AdminUserFormDialog> createState() => _AdminUserFormDialogState();
-}
-
-class _AdminUserFormDialogState extends State<AdminUserFormDialog> {
-  final _formKey = GlobalKey<FormState>();
-  final _nomController = TextEditingController();
-  final _prenomController = TextEditingController();
-  final _emailController = TextEditingController();
-  final _passwordController = TextEditingController();
-  final _telephoneController = TextEditingController();
-  final _passwordToggleFocusNode =
-      FocusNode(skipTraversal: true, canRequestFocus: false);
-
-  bool _isSubmitting = false;
-  bool _obscurePassword = true;
-  bool _isLoadingRelais = true;
-  List<RelaisModel> _relais = [];
-  String? _selectedRelaisId;
-  bool get _isEditMode => widget.initialUser != null;
-  bool get _isSuperAdminTarget =>
-      (widget.initialUser?.role ?? '').toLowerCase() == 'super_admin';
-  bool get _isLockedAdminIdentity =>
-      _isEditMode && widget.adminMode && _isSuperAdminTarget;
-  String get _targetRoleKey {
-    if (widget.initialUser != null) {
-      return (widget.initialUser!.role).toLowerCase();
-    }
-    return widget.adminMode ? 'administrateur' : 'gestionnaire';
-  }
-
-  String get _targetRoleLabel {
-    switch (_targetRoleKey) {
-      case 'super_admin':
-        return 'Super administrateur';
-      case 'administrateur':
-        return 'Administrateur';
-      case 'gestionnaire':
-        return 'Gestionnaire';
-      case 'assistante_maternelle':
-        return 'Assistante maternelle';
-      case 'parent':
-        return 'Parent';
-      default:
-        return 'Utilisateur';
-    }
-  }
-
-  IconData get _targetRoleIcon {
-    switch (_targetRoleKey) {
-      case 'super_admin':
-        return Icons.verified_user_outlined;
-      case 'administrateur':
-        return Icons.admin_panel_settings_outlined;
-      case 'gestionnaire':
-        return Icons.assignment_ind_outlined;
-      case 'assistante_maternelle':
-        return Icons.child_care_outlined;
-      case 'parent':
-        return Icons.supervisor_account_outlined;
-      default:
-        return Icons.person_outline;
-    }
-  }
-
-  @override
-  void initState() {
-    super.initState();
-    final user = widget.initialUser;
-    if (user != null) {
-      _nomController.text = user.nom ?? '';
-      _prenomController.text = user.prenom ?? '';
-      _emailController.text = user.email;
-      _telephoneController.text = formatPhoneForDisplay(user.telephone ?? '');
-      // En édition, on ne préremplit jamais le mot de passe.
-      _passwordController.clear();
-      final initialRelaisId = user.relaisId?.trim();
-      _selectedRelaisId =
-          (initialRelaisId == null || initialRelaisId.isEmpty)
-              ? null
-              : initialRelaisId;
-    }
-    if (widget.withRelais) {
-      _loadRelais();
-    } else {
-      _isLoadingRelais = false;
-    }
-  }
-
-  @override
-  void dispose() {
-    _nomController.dispose();
-    _prenomController.dispose();
-    _emailController.dispose();
-    _passwordController.dispose();
-    _telephoneController.dispose();
-    _passwordToggleFocusNode.dispose();
-    super.dispose();
-  }
-
-  Future<void> _loadRelais() async {
-    try {
-      final list = await RelaisService.getRelais();
-      if (!mounted) return;
-      final uniqueById = <String, RelaisModel>{};
-      for (final relais in list) {
-        uniqueById[relais.id] = relais;
-      }
-
-      final filtered = uniqueById.values.where((r) => r.actif).toList();
-      if (_selectedRelaisId != null &&
-          !filtered.any((r) => r.id == _selectedRelaisId)) {
-        final selected = uniqueById[_selectedRelaisId!];
-        if (selected != null) {
-          filtered.add(selected);
-        } else {
-          _selectedRelaisId = null;
-        }
-      }
-
-      setState(() {
-        _relais = filtered;
-        _isLoadingRelais = false;
-      });
-    } catch (_) {
-      if (!mounted) return;
-      setState(() {
-        _selectedRelaisId = null;
-        _relais = [];
-        _isLoadingRelais = false;
-      });
-    }
-  }
-
-  String? _required(String? value, String field) {
-    if (value == null || value.trim().isEmpty) {
-      return '$field est requis';
-    }
-    return null;
-  }
-
-  String? _validateEmail(String? value) {
-    final base = _required(value, 'Email');
-    if (base != null) {
-      return base;
-    }
-    return validateEmail(value, allowEmpty: true);
-  }
-
-  String? _validatePassword(String? value) {
-    if (_isEditMode && (value == null || value.trim().isEmpty)) {
-      return null;
-    }
-    final base = _required(value, 'Mot de passe');
-    if (base != null) return base;
-    if (value!.trim().length < 6) return 'Minimum 6 caractères';
-    return null;
-  }
-
-  String? _validatePhone(String? value) {
-    if (_isEditMode && (value == null || value.trim().isEmpty)) {
-      return null;
-    }
-    final base = _required(value, 'Téléphone');
-    if (base != null) {
-      return base;
-    }
-    return validateFrenchNationalPhone(value, allowEmpty: false);
-  }
-
-  String _toTitleCase(String raw) {
-    final trimmed = raw.trim();
-    if (trimmed.isEmpty) return trimmed;
-    final words = trimmed.split(RegExp(r'\s+'));
-    final normalizedWords = words.map(_capitalizeComposedWord).toList();
-    return normalizedWords.join(' ');
-  }
-
-  String _capitalizeComposedWord(String word) {
-    if (word.isEmpty) return word;
-    final lower = word.toLowerCase();
-    final separators = <String>{"-", "'", "’"};
-    final buffer = StringBuffer();
-    var capitalizeNext = true;
-
-    for (var i = 0; i < lower.length; i++) {
-      final char = lower[i];
-      if (capitalizeNext && RegExp(r'[a-zà-öø-ÿ]').hasMatch(char)) {
-        buffer.write(char.toUpperCase());
-        capitalizeNext = false;
-      } else {
-        buffer.write(char);
-        capitalizeNext = separators.contains(char);
-      }
-    }
-    return buffer.toString();
-  }
-
-  Future<void> _submit() async {
-    if (widget.readOnly) return;
-    if (_isSubmitting) return;
-    if (!_formKey.currentState!.validate()) return;
-
-    setState(() {
-      _isSubmitting = true;
-    });
-
-    try {
-      final normalizedNom = _toTitleCase(_nomController.text);
-      final normalizedPrenom = _toTitleCase(_prenomController.text);
-      final normalizedPhone = normalizePhone(_telephoneController.text);
-      final passwordProvided = _passwordController.text.trim().isNotEmpty;
-
-      if (_isEditMode) {
-        if (widget.adminMode) {
-          final lockedNom = _toTitleCase(widget.initialUser!.nom ?? '');
-          final lockedPrenom = _toTitleCase(widget.initialUser!.prenom ?? '');
-          await UserService.updateAdministrateur(
-            adminId: widget.initialUser!.id,
-            nom: _isLockedAdminIdentity ? lockedNom : normalizedNom,
-            prenom: _isLockedAdminIdentity ? lockedPrenom : normalizedPrenom,
-            email: _emailController.text.trim(),
-            telephone: normalizedPhone.isEmpty
-                ? normalizePhone(widget.initialUser!.telephone ?? '')
-                : normalizedPhone,
-            password: passwordProvided ? _passwordController.text : null,
-          );
-        } else {
-          final currentUser = widget.initialUser!;
-          final initialNom = _toTitleCase(currentUser.nom ?? '');
-          final initialPrenom = _toTitleCase(currentUser.prenom ?? '');
-          final initialEmail = currentUser.email.trim();
-          final initialPhone = normalizePhone(currentUser.telephone ?? '');
-
-          final onlyRelaisChanged =
-              normalizedNom == initialNom &&
-              normalizedPrenom == initialPrenom &&
-              _emailController.text.trim() == initialEmail &&
-              normalizedPhone == initialPhone &&
-              !passwordProvided;
-
-          if (onlyRelaisChanged) {
-            await UserService.updateGestionnaireRelais(
-              gestionnaireId: currentUser.id,
-              relaisId: _selectedRelaisId,
-            );
-          } else {
-            await UserService.updateGestionnaire(
-              gestionnaireId: currentUser.id,
-              nom: normalizedNom,
-              prenom: normalizedPrenom,
-              email: _emailController.text.trim(),
-              telephone: normalizedPhone.isEmpty ? initialPhone : normalizedPhone,
-              relaisId: _selectedRelaisId,
-              password: passwordProvided ? _passwordController.text : null,
-            );
-          }
-        }
-      } else {
-        if (widget.adminMode) {
-          await UserService.createAdministrateur(
-            nom: normalizedNom,
-            prenom: normalizedPrenom,
-            email: _emailController.text.trim(),
-            password: _passwordController.text,
-            telephone: normalizePhone(_telephoneController.text),
-          );
-        } else {
-          await UserService.createGestionnaire(
-            nom: normalizedNom,
-            prenom: normalizedPrenom,
-            email: _emailController.text.trim(),
-            password: _passwordController.text,
-            telephone: normalizePhone(_telephoneController.text),
-            relaisId: _selectedRelaisId,
-          );
-        }
-      }
-      if (!mounted) return;
-      ScaffoldMessenger.of(context).showSnackBar(
-        SnackBar(
-          content: Text(
-            _isEditMode
-                ? (widget.adminMode
-                    ? 'Administrateur modifié avec succès.'
-                    : 'Gestionnaire modifié avec succès.')
-                : (widget.adminMode
-                    ? 'Administrateur créé avec succès.'
-                    : 'Gestionnaire créé avec succès.'),
-          ),
-        ),
-      );
-      Navigator.of(context).pop(true);
-    } catch (e) {
-      if (!mounted) return;
-      ScaffoldMessenger.of(context).showSnackBar(
-        SnackBar(
-          content: Text(
-            e.toString().replaceFirst('Exception: ', ''),
-          ),
-          backgroundColor: Colors.red.shade700,
-        ),
-      );
-    } finally {
-      if (!mounted) return;
-      setState(() {
-        _isSubmitting = false;
-      });
-    }
-  }
-
-  Future<void> _delete() async {
-    if (widget.readOnly) return;
-    if (_isSuperAdminTarget) return;
-    if (!_isEditMode || _isSubmitting) return;
-
-    final confirmed = await showDialog<bool>(
-      context: context,
-      builder: (ctx) {
-        return AlertDialog(
-          title: const Text('Confirmer la suppression'),
-          content: Text(
-            'Supprimer ${widget.initialUser!.fullName.isEmpty ? widget.initialUser!.email : widget.initialUser!.fullName} ?',
-          ),
-          actions: [
-            TextButton(
-              onPressed: () => Navigator.of(ctx).pop(false),
-              child: const Text('Annuler'),
-            ),
-            FilledButton(
-              onPressed: () => Navigator.of(ctx).pop(true),
-              style: FilledButton.styleFrom(backgroundColor: Colors.red.shade700),
-              child: const Text('Supprimer'),
-            ),
-          ],
-        );
-      },
-    );
-
-    if (confirmed != true) return;
-
-    setState(() {
-      _isSubmitting = true;
-    });
-    try {
-      await UserService.deleteUser(widget.initialUser!.id);
-      if (!mounted) return;
-      ScaffoldMessenger.of(context).showSnackBar(
-        const SnackBar(content: Text('Gestionnaire supprimé.')),
-      );
-      Navigator.of(context).pop(true);
-    } catch (e) {
-      if (!mounted) return;
-      ScaffoldMessenger.of(context).showSnackBar(
-        SnackBar(
-          content: Text(e.toString().replaceFirst('Exception: ', '')),
-          backgroundColor: Colors.red.shade700,
-        ),
-      );
-      setState(() {
-        _isSubmitting = false;
-      });
-    }
-  }
-
-  @override
-  Widget build(BuildContext context) {
-    return AlertDialog(
-      title: Row(
-        children: [
-          CircleAvatar(
-            radius: 16,
-            backgroundColor: const Color(0xFFEDE5FA),
-            child: Icon(
-              _targetRoleIcon,
-              size: 20,
-              color: const Color(0xFF6B3FA0),
-            ),
-          ),
-          const SizedBox(width: 8),
-          Expanded(
-            child: Text(
-              _isEditMode
-                  ? (widget.readOnly
-                      ? 'Consulter un "$_targetRoleLabel"'
-                      : 'Modifier un "$_targetRoleLabel"')
-                  : 'Créer un "$_targetRoleLabel"',
-            ),
-          ),
-          if (_isEditMode && !widget.readOnly)
-            IconButton(
-              icon: const Icon(Icons.close),
-              tooltip: 'Fermer',
-              onPressed: _isSubmitting
-                  ? null
-                  : () => Navigator.of(context).pop(false),
-            ),
-        ],
-      ),
-      content: SizedBox(
-        width: 620,
-        child: Form(
-          key: _formKey,
-          child: SingleChildScrollView(
-            child: Column(
-              mainAxisSize: MainAxisSize.min,
-              children: [
-                Row(
-                  children: [
-                    Expanded(child: _buildPrenomField()),
-                    const SizedBox(width: 12),
-                    Expanded(child: _buildNomField()),
-                  ],
-                ),
-                const SizedBox(height: 12),
-                _buildEmailField(),
-                const SizedBox(height: 12),
-                Row(
-                  children: [
-                    Expanded(child: _buildPasswordField()),
-                    const SizedBox(width: 12),
-                    Expanded(child: _buildTelephoneField()),
-                  ],
-                ),
-                if (widget.withRelais) ...[
-                  const SizedBox(height: 12),
-                  _buildRelaisField(),
-                ],
-              ],
-            ),
-          ),
-        ),
-      ),
-      actions: [
-        if (widget.readOnly) ...[
-          FilledButton(
-            onPressed: _isSubmitting ? null : () => Navigator.of(context).pop(false),
-            child: const Text('Fermer'),
-          ),
-        ] else if (_isEditMode) ...[
-          if (!_isSuperAdminTarget)
-            OutlinedButton(
-              onPressed: _isSubmitting ? null : _delete,
-              style: OutlinedButton.styleFrom(foregroundColor: Colors.red.shade700),
-              child: const Text('Supprimer'),
-            ),
-          FilledButton.icon(
-            onPressed: _isSubmitting ? null : _submit,
-            icon: _isSubmitting
-                ? const SizedBox(
-                    width: 16,
-                    height: 16,
-                    child: CircularProgressIndicator(strokeWidth: 2),
-                  )
-                : const Icon(Icons.edit),
-            label: Text(_isSubmitting ? 'Modification...' : 'Modifier'),
-          ),
-        ] else ...[
-          OutlinedButton(
-            onPressed:
-                _isSubmitting ? null : () => Navigator.of(context).pop(false),
-            child: const Text('Annuler'),
-          ),
-          FilledButton.icon(
-            onPressed: _isSubmitting ? null : _submit,
-            icon: _isSubmitting
-                ? const SizedBox(
-                    width: 16,
-                    height: 16,
-                    child: CircularProgressIndicator(strokeWidth: 2),
-                  )
-                : const Icon(Icons.person_add_alt_1),
-            label: Text(_isSubmitting ? 'Création...' : 'Créer'),
-          ),
-        ],
-      ],
-    );
-  }
-
-  Widget _buildNomField() {
-    return TextFormField(
-      controller: _nomController,
-      readOnly: widget.readOnly || _isLockedAdminIdentity,
-      textCapitalization: TextCapitalization.words,
-      decoration: const InputDecoration(
-        labelText: 'Nom',
-        border: OutlineInputBorder(),
-      ),
-      validator: (widget.readOnly || _isLockedAdminIdentity)
-          ? null
-          : (v) => _required(v, 'Nom'),
-    );
-  }
-
-  Widget _buildPrenomField() {
-    return TextFormField(
-      controller: _prenomController,
-      readOnly: widget.readOnly || _isLockedAdminIdentity,
-      textCapitalization: TextCapitalization.words,
-      decoration: const InputDecoration(
-        labelText: 'Prénom',
-        border: OutlineInputBorder(),
-      ),
-      validator: (widget.readOnly || _isLockedAdminIdentity)
-          ? null
-          : (v) => _required(v, 'Prénom'),
-    );
-  }
-
-  Widget _buildEmailField() {
-    return EmailTextFormField(
-      controller: _emailController,
-      readOnly: widget.readOnly,
-      label: 'Email',
-      validator: widget.readOnly ? null : _validateEmail,
-    );
-  }
-
-  Widget _buildPasswordField() {
-    return TextFormField(
-      controller: _passwordController,
-      readOnly: widget.readOnly,
-      obscureText: _obscurePassword,
-      enableSuggestions: false,
-      autocorrect: false,
-      autofillHints: _isEditMode
-          ? const <String>[]
-          : const [AutofillHints.newPassword],
-      decoration: InputDecoration(
-        labelText: _isEditMode
-            ? 'Nouveau mot de passe'
-            : 'Mot de passe',
-        border: const OutlineInputBorder(),
-        suffixIcon: widget.readOnly
-            ? null
-            : ExcludeFocus(
-                child: IconButton(
-                  focusNode: _passwordToggleFocusNode,
-                  onPressed: () {
-                    setState(() {
-                      _obscurePassword = !_obscurePassword;
-                    });
-                  },
-                  icon: Icon(
-                    _obscurePassword ? Icons.visibility_off : Icons.visibility,
-                  ),
-                ),
-              ),
-      ),
-      validator: widget.readOnly ? null : _validatePassword,
-    );
-  }
-
-  Widget _buildTelephoneField() {
-    return FrenchPhoneTextFormField(
-      controller: _telephoneController,
-      readOnly: widget.readOnly,
-      label: 'Téléphone (ex: 06 12 34 56 78)',
-      validator: widget.readOnly ? null : _validatePhone,
-    );
-  }
-
-  Widget _buildRelaisField() {
-    final selectedValue = _selectedRelaisId != null &&
-            _relais.any((relais) => relais.id == _selectedRelaisId)
-        ? _selectedRelaisId
-        : null;
-
-    return Column(
-      mainAxisSize: MainAxisSize.min,
-      children: [
-        DropdownButtonFormField<String?>(
-          isExpanded: true,
-          value: selectedValue,
-          decoration: const InputDecoration(
-            labelText: 'Relais principal',
-            border: OutlineInputBorder(),
-          ),
-          items: [
-            const DropdownMenuItem<String?>(
-              value: null,
-              child: Text('Aucun relais'),
-            ),
-            ..._relais.map(
-              (relais) => DropdownMenuItem<String?>(
-                value: relais.id,
-                child: Text(relais.nom),
-              ),
-            ),
-          ],
-          onChanged: (_isLoadingRelais || widget.readOnly)
-              ? null
-              : (value) {
-                  setState(() {
-                    _selectedRelaisId = value;
-                  });
-                },
-        ),
-        if (_isLoadingRelais) ...[
-          const SizedBox(height: 8),
-          const LinearProgressIndicator(minHeight: 2),
-        ],
-      ],
-    );
-  }
-}

frontend/lib/screens/auth/parent_register_step3_screen.dart

@@ -121,7 +121,6 @@ class _ParentRegisterStep3ScreenState extends State<ParentRegisterStep3Screen> {
         dob: '',
         isUnbornChild: false,
         photoConsent: false,
-        multipleBirth: false,
         cardColor: cardColor,
       );
       registrationData.addChild(newChild);

frontend/lib/screens/gestionnaire/gestionnaire_dashboard_screen.dart

@@ -1,7 +1,7 @@
 import 'package:flutter/material.dart';
 import 'package:p_tits_pas/models/user.dart';
 import 'package:p_tits_pas/services/auth_service.dart';
-import 'package:p_tits_pas/widgets/admin/user_management_panel.dart';
+import 'package:p_tits_pas/widgets/dashboard/user_management_panel.dart';
 import 'package:p_tits_pas/widgets/app_footer.dart';
 import 'package:p_tits_pas/widgets/dashboard/dashboard_bandeau.dart';
 
@@ -62,7 +62,10 @@ class _GestionnaireDashboardScreenState extends State<GestionnaireDashboardScree
       body: Column(
         children: [
           Expanded(
-            child: UserManagementPanel(showAdministrateursTab: false),
+            child: UserManagementPanel(
+              showAdministrateursTab: false,
+              allowStaffAccountCreation: false,
+            ),
           ),
           const AppFooter(),
         ],

frontend/lib/services/api/api_config.dart

@@ -60,7 +60,12 @@ class ApiConfig {
   static const String userChildren = '/users/children';
   static const String gestionnaires = '/gestionnaires';
   static const String parents = '/parents';
+  /// Création dossier famille actif par le staff (#129) — body type register parent.
+  static const String parentsDossier = '/parents/dossier';
   static const String assistantesMaternelles = '/assistantes-maternelles';
+  /// Création dossier AM actif par le staff (#156) — body type register AM.
+  static const String assistantesMaternellesDossier =
+      '/assistantes-maternelles/dossier';
   static const String enfants = '/enfants';
   static const String relais = '/relais';
   static const String dossiers = '/dossiers';

frontend/lib/services/user_service.dart

@@ -1,5 +1,6 @@
 import 'dart:convert';
 import 'package:http/http.dart' as http;
+import 'package:http_parser/http_parser.dart';
 import 'package:p_tits_pas/models/user.dart';
 import 'package:p_tits_pas/models/enfant_admin_model.dart';
 import 'package:p_tits_pas/models/parent_model.dart';
@@ -8,6 +9,7 @@ import 'package:p_tits_pas/models/pending_family.dart';
 import 'package:p_tits_pas/models/dossier_unifie.dart';
 import 'package:p_tits_pas/services/api/api_config.dart';
 import 'package:p_tits_pas/services/api/tokenService.dart';
+import 'package:p_tits_pas/utils/am_vigilance.dart';
 
 class DocumentActifInfo {
   final String id;
@@ -56,6 +58,33 @@ class UserService {
     return v.toString();
   }
 
+  /// MIME pour upload photo enfant (filtre Nest : jpg/jpeg/png/gif).
+  static MediaType _imageMediaType(String filename, List<int> bytes) {
+    if (bytes.length >= 3 &&
+        bytes[0] == 0xFF &&
+        bytes[1] == 0xD8 &&
+        bytes[2] == 0xFF) {
+      return MediaType('image', 'jpeg');
+    }
+    if (bytes.length >= 8 &&
+        bytes[0] == 0x89 &&
+        bytes[1] == 0x50 &&
+        bytes[2] == 0x4E &&
+        bytes[3] == 0x47) {
+      return MediaType('image', 'png');
+    }
+    if (bytes.length >= 6 &&
+        bytes[0] == 0x47 &&
+        bytes[1] == 0x49 &&
+        bytes[2] == 0x46) {
+      return MediaType('image', 'gif');
+    }
+    final lower = filename.toLowerCase();
+    if (lower.endsWith('.png')) return MediaType('image', 'png');
+    if (lower.endsWith('.gif')) return MediaType('image', 'gif');
+    return MediaType('image', 'jpeg');
+  }
+
   static String _errMessage(dynamic err) {
     if (err == null) return 'Erreur inconnue';
     if (err is String) return err;
@@ -460,22 +489,259 @@ class UserService {
     if (response.statusCode != 200) {
       throw Exception(_extractErrorMessage(response.body, 'Erreur chargement enfant'));
     }
-    return EnfantAdminModel.fromJson(jsonDecode(response.body) as Map<String, dynamic>);
+    final enfant = EnfantAdminModel.fromJson(
+      jsonDecode(response.body) as Map<String, dynamic>,
+    );
+    // GET /enfants/:id ne joint pas toujours parent.user → noms manquants.
+    return enrichEnfantParentNames(enfant);
   }
 
+  /// Complète [parentName] via GET parent quand l'API n'a pas fourni le nested user.
+  static Future<EnfantAdminModel> enrichEnfantParentNames(
+    EnfantAdminModel enfant,
+  ) async {
+    final links = enfant.parentLinks;
+    if (links.isEmpty) return enfant;
+    if (links.every((l) => (l.parentName ?? '').trim().isNotEmpty)) {
+      return enfant;
+    }
+
+    final enriched = await Future.wait(
+      links.map((link) async {
+        if ((link.parentName ?? '').trim().isNotEmpty) return link;
+        final id = link.parentId.trim();
+        if (id.isEmpty) return link;
+        try {
+          final parent = await getParent(id);
+          final name = parent.user.fullName.trim();
+          if (name.isEmpty) return link;
+          return link.copyWith(parentName: name);
+        } catch (_) {
+          return link;
+        }
+      }),
+    );
+
+    return enfant.copyWith(parentLinks: enriched);
+  }
+
+  /// Mise à jour enfant. Avec [photoBytes] : multipart (champ `photo`), sinon JSON.
   static Future<EnfantAdminModel> updateEnfant({
     required String enfantId,
     required Map<String, dynamic> body,
+    List<int>? photoBytes,
+    String? photoFilename,
   }) async {
-    final response = await http.patch(
+    final id = enfantId.trim();
-      Uri.parse('${ApiConfig.baseUrl}${ApiConfig.enfants}/$enfantId'),
+    if (id.isEmpty) {
-      headers: await _headers(),
+      throw Exception('Identifiant enfant manquant.');
-      body: jsonEncode(body),
-    );
-    if (response.statusCode != 200) {
-      throw Exception(_extractErrorMessage(response.body, 'Erreur mise à jour enfant'));
     }
-    return EnfantAdminModel.fromJson(jsonDecode(response.body) as Map<String, dynamic>);
+    final hasPhoto = photoBytes != null && photoBytes.isNotEmpty;
+    final http.Response response;
+    if (hasPhoto) {
+      final token = await TokenService.getToken();
+      final req = http.MultipartRequest(
+        'PATCH',
+        Uri.parse('${ApiConfig.baseUrl}${ApiConfig.enfants}/$id'),
+      );
+      req.headers['Accept'] = 'application/json';
+      if (token != null) {
+        req.headers['Authorization'] = 'Bearer $token';
+      }
+      body.forEach((key, value) {
+        if (value == null) return;
+        req.fields[key] = value is bool
+            ? (value ? 'true' : 'false')
+            : value.toString();
+      });
+      final name = (photoFilename ?? '').trim();
+      final filename = name.isNotEmpty ? name : 'photo.jpg';
+      req.files.add(
+        http.MultipartFile.fromBytes(
+          'photo',
+          photoBytes,
+          filename: filename,
+          contentType: _imageMediaType(filename, photoBytes),
+        ),
+      );
+      final streamed = await req.send();
+      response = await http.Response.fromStream(streamed);
+    } else {
+      response = await http.patch(
+        Uri.parse('${ApiConfig.baseUrl}${ApiConfig.enfants}/$id'),
+        headers: await _headers(),
+        body: jsonEncode(body),
+      );
+    }
+    if (response.statusCode != 200) {
+      throw Exception(
+        _extractErrorMessage(response.body, 'Erreur mise à jour enfant'),
+      );
+    }
+    final enfant = EnfantAdminModel.fromJson(
+      jsonDecode(response.body) as Map<String, dynamic>,
+    );
+    return enrichEnfantParentNames(enfant);
+  }
+
+  /// Création enfant côté staff (#132) — nécessite `POST /enfants` étendu (voir mini-spec).
+  /// [parentUserId] : parent pivot du foyer (`parent_user_id`).
+  /// Avec [photoBytes] : `multipart/form-data` (champ fichier `photo`), sinon JSON.
+  static Future<EnfantAdminModel> createEnfant({
+    required String parentUserId,
+    required Map<String, dynamic> body,
+    List<int>? photoBytes,
+    String? photoFilename,
+  }) async {
+    final hasPhoto = photoBytes != null && photoBytes.isNotEmpty;
+    final http.Response response;
+    if (hasPhoto) {
+      final token = await TokenService.getToken();
+      final req = http.MultipartRequest(
+        'POST',
+        Uri.parse('${ApiConfig.baseUrl}${ApiConfig.enfants}'),
+      );
+      req.headers['Accept'] = 'application/json';
+      if (token != null) {
+        req.headers['Authorization'] = 'Bearer $token';
+      }
+      body.forEach((key, value) {
+        if (value == null) return;
+        req.fields[key] = value is bool
+            ? (value ? 'true' : 'false')
+            : value.toString();
+      });
+      req.fields['parent_user_id'] = parentUserId;
+      final name = (photoFilename ?? '').trim();
+      final filename = name.isNotEmpty ? name : 'photo.jpg';
+      req.files.add(
+        http.MultipartFile.fromBytes(
+          'photo',
+          photoBytes,
+          filename: filename,
+          contentType: _imageMediaType(filename, photoBytes),
+        ),
+      );
+      final streamed = await req.send();
+      response = await http.Response.fromStream(streamed);
+    } else {
+      final payload = <String, dynamic>{
+        ...body,
+        'parent_user_id': parentUserId,
+      };
+      response = await http.post(
+        Uri.parse('${ApiConfig.baseUrl}${ApiConfig.enfants}'),
+        headers: await _headers(),
+        body: jsonEncode(payload),
+      );
+    }
+    if (response.statusCode != 200 && response.statusCode != 201) {
+      throw Exception(
+        _extractErrorMessage(response.body, 'Erreur création enfant'),
+      );
+    }
+    final enfant = EnfantAdminModel.fromJson(
+      jsonDecode(response.body) as Map<String, dynamic>,
+    );
+    return enrichEnfantParentNames(enfant);
+  }
+
+  /// DELETE /enfants/:id?deleteDossier= — ticket #159 / #160.
+  static Future<Map<String, dynamic>> deleteEnfant(
+    String enfantId, {
+    bool deleteDossier = false,
+  }) async {
+    final uri = Uri.parse(
+      '${ApiConfig.baseUrl}${ApiConfig.enfants}/$enfantId',
+    ).replace(
+      queryParameters: {
+        'deleteDossier': deleteDossier ? 'true' : 'false',
+      },
+    );
+    final response = await http.delete(uri, headers: await _headers());
+    if (response.statusCode != 200 && response.statusCode != 204) {
+      throw Exception(
+        _extractErrorMessage(response.body, 'Erreur suppression enfant'),
+      );
+    }
+    return _parseSuppressionBody(response.body);
+  }
+
+  /// DELETE /dossiers/:numeroDossier — ticket #159 / #160.
+  static Future<Map<String, dynamic>> deleteDossier(
+    String numeroDossier,
+  ) async {
+    final num = numeroDossier.trim();
+    if (num.isEmpty) {
+      throw Exception('Numéro de dossier manquant.');
+    }
+    final encoded = Uri.encodeComponent(num);
+    final response = await http.delete(
+      Uri.parse('${ApiConfig.baseUrl}${ApiConfig.dossiers}/$encoded'),
+      headers: await _headers(),
+    );
+    if (response.statusCode != 200 && response.statusCode != 204) {
+      throw Exception(
+        _extractErrorMessage(response.body, 'Erreur suppression dossier'),
+      );
+    }
+    return _parseSuppressionBody(response.body);
+  }
+
+  /// Liste unifiée GET /dossiers — flags `sans_enfant` (#159).
+  static Future<List<Map<String, dynamic>>> listDossiers({String? q}) async {
+    final uri = Uri.parse('${ApiConfig.baseUrl}${ApiConfig.dossiers}')
+        .replace(
+      queryParameters: (q != null && q.trim().isNotEmpty)
+          ? {'q': q.trim()}
+          : null,
+    );
+    final response = await http.get(uri, headers: await _headers());
+    if (response.statusCode != 200) {
+      throw Exception(
+        _extractErrorMessage(response.body, 'Erreur chargement dossiers'),
+      );
+    }
+    final decoded = jsonDecode(response.body);
+    if (decoded is! List) return const [];
+    return decoded
+        .whereType<Map>()
+        .map((e) => Map<String, dynamic>.from(e))
+        .toList();
+  }
+
+  /// Map `numero_dossier` → `sans_enfant` (familles uniquement).
+  static Future<Map<String, bool>> getSansEnfantByNumero() async {
+    final rows = await listDossiers();
+    final out = <String, bool>{};
+    for (final row in rows) {
+      final num = (row['numero_dossier'] ?? '').toString().trim();
+      if (num.isEmpty) continue;
+      final type = (row['type'] ?? '').toString().toLowerCase();
+      if (type != 'famille') continue;
+      out[num] = row['sans_enfant'] == true;
+    }
+    return out;
+  }
+
+  static Map<String, dynamic> _parseSuppressionBody(String body) {
+    if (body.trim().isEmpty) return <String, dynamic>{};
+    try {
+      final decoded = jsonDecode(body);
+      if (decoded is Map) {
+        return Map<String, dynamic>.from(decoded);
+      }
+    } catch (_) {}
+    return <String, dynamic>{};
+  }
+
+  /// AM dont la liste d'enfants actifs contient [enfantId] (API actuelle).
+  static Future<AssistanteMaternelleModel?> findAmForEnfant(String enfantId) async {
+    final ams = await getAssistantesMaternelles();
+    for (final am in ams) {
+      if (am.children.any((c) => c.id == enfantId)) return am;
+    }
+    return null;
   }
 
   static ParentModel _parentModelFromBody(String body) {
@@ -499,6 +765,155 @@ class UserService {
     return fallback;
   }
 
+  /// Ajout d’un co-parent sur foyer mono-parent (staff, #135).
+  /// `POST /parents/:pivotUserId/co-parent` — succès 201.
+  static Future<Map<String, dynamic>> addCoParent(
+    String pivotUserId, {
+    required Map<String, dynamic> body,
+  }) async {
+    final id = pivotUserId.trim();
+    if (id.isEmpty) {
+      throw Exception('Identifiant du parent pivot manquant.');
+    }
+    final http.Response response;
+    try {
+      response = await http.post(
+        Uri.parse('${ApiConfig.baseUrl}${ApiConfig.parents}/$id/co-parent'),
+        headers: await _headers(),
+        body: jsonEncode(body),
+      );
+    } on http.ClientException {
+      throw Exception(
+        'Connexion au serveur impossible. Vérifiez votre réseau puis réessayez.',
+      );
+    }
+
+    if (response.statusCode == 200 || response.statusCode == 201) {
+      if (response.body.trim().isEmpty) return <String, dynamic>{};
+      try {
+        final decoded = jsonDecode(response.body);
+        if (decoded is Map) {
+          return Map<String, dynamic>.from(decoded);
+        }
+      } catch (_) {}
+      return <String, dynamic>{};
+    }
+
+    final message = _extractErrorMessage(
+      response.body,
+      'Erreur ajout co-parent',
+    );
+    if (response.statusCode == 409) {
+      throw Exception(
+        message.isNotEmpty ? message : 'Conflit : e-mail déjà utilisé.',
+      );
+    }
+    if (response.statusCode == 400) {
+      throw Exception(
+        message.isNotEmpty ? message : 'Données invalides (400).',
+      );
+    }
+    throw Exception(message);
+  }
+
+  /// Création dossier famille actif côté staff (#129).
+  /// `POST /parents/dossier` — body aligné sur register parent complet.
+  /// Succès 201 : dossier actif + `numero_dossier` (mail MDP côté serveur, par parent créé).
+  /// Ne pas utiliser `POST /auth/register/parent` (public / en_attente).
+  static Future<Map<String, dynamic>> createParentDossier(
+    Map<String, dynamic> body,
+  ) async {
+    final http.Response response;
+    try {
+      response = await http.post(
+        Uri.parse('${ApiConfig.baseUrl}${ApiConfig.parentsDossier}'),
+        headers: await _headers(),
+        body: jsonEncode(body),
+      );
+    } on http.ClientException {
+      throw Exception(
+        'Connexion au serveur impossible. Vérifiez votre réseau puis réessayez.',
+      );
+    }
+
+    if (response.statusCode == 200 || response.statusCode == 201) {
+      if (response.body.trim().isEmpty) return <String, dynamic>{};
+      try {
+        final decoded = jsonDecode(response.body);
+        if (decoded is Map) {
+          return Map<String, dynamic>.from(decoded);
+        }
+      } catch (_) {}
+      return <String, dynamic>{};
+    }
+
+    final message = _extractErrorMessage(
+      response.body,
+      'Erreur création dossier famille',
+    );
+    if (response.statusCode == 409) {
+      throw Exception(
+        message.isNotEmpty ? message : 'Conflit : e-mail déjà utilisé.',
+      );
+    }
+    if (response.statusCode == 400) {
+      throw Exception(
+        message.isNotEmpty ? message : 'Données invalides (400).',
+      );
+    }
+    throw Exception(message);
+  }
+
+  /// Création dossier AM actif côté staff (#156).
+  /// `POST /assistantes-maternelles/dossier` — body aligné sur register AM.
+  /// Succès 201 : dossier actif + `numero_dossier` (mail MDP côté serveur).
+  /// Ne pas utiliser `POST /auth/register/am` (public / en_attente).
+  static Future<Map<String, dynamic>> createAmDossier(
+    Map<String, dynamic> body,
+  ) async {
+    final http.Response response;
+    try {
+      response = await http.post(
+        Uri.parse(
+          '${ApiConfig.baseUrl}${ApiConfig.assistantesMaternellesDossier}',
+        ),
+        headers: await _headers(),
+        body: jsonEncode(body),
+      );
+    } on http.ClientException {
+      throw Exception(
+        'Connexion au serveur impossible. Vérifiez votre réseau puis réessayez.',
+      );
+    }
+
+    if (response.statusCode == 200 || response.statusCode == 201) {
+      if (response.body.trim().isEmpty) return <String, dynamic>{};
+      try {
+        final decoded = jsonDecode(response.body);
+        if (decoded is Map) {
+          return Map<String, dynamic>.from(decoded);
+        }
+      } catch (_) {}
+      return <String, dynamic>{};
+    }
+
+    final message = _extractErrorMessage(
+      response.body,
+      'Erreur création dossier AM',
+    );
+    if (response.statusCode == 409) {
+      throw Exception(message.isNotEmpty
+          ? message
+          : 'Conflit : e-mail, NIR ou agrément déjà utilisé.');
+    }
+    if (response.statusCode == 400) {
+      throw Exception(
+        message.isNotEmpty ? message : 'Données invalides (400).',
+      );
+    }
+    throw Exception(message);
+  }
+
   // Récupérer la liste des assistantes maternelles
   static Future<List<AssistanteMaternelleModel>>
       getAssistantesMaternelles() async {
@@ -633,7 +1048,24 @@ class UserService {
     if (response.statusCode != 200 && response.statusCode != 201) {
       throw Exception(_extractErrorMessage(response.body, 'Erreur rattachement enfant'));
     }
-    return _amModelFromBody(response.body);
+    final am = _amModelFromBody(response.body);
+    // Recalcule toujours places_available (capacité − enfants) après attachement.
+    return syncAmPlacesAvailable(am);
+  }
+
+  /// Aligne `places_available` sur capacité − enfants rattachés.
+  static Future<AssistanteMaternelleModel> syncAmPlacesAvailable(
+    AssistanteMaternelleModel am,
+  ) async {
+    final expected = amExpectedPlacesAvailable(
+      maxChildren: am.maxChildren,
+      childrenCount: am.children.length,
+    );
+    if (expected == null || am.placesAvailable == expected) return am;
+    return updateAmFiche(
+      amUserId: am.user.id,
+      body: {'places_available': expected},
+    );
   }
 
   static Future<AssistanteMaternelleModel> detachEnfantFromAm({
@@ -871,22 +1303,18 @@ class UserService {
     return AppUser.fromJson(data);
   }
 
-  static Future<void> deleteUser(String userId) async {
+  /// DELETE /users/:id — cascades métier #159 / #160.
+  static Future<Map<String, dynamic>> deleteUser(String userId) async {
     final response = await http.delete(
       Uri.parse('${ApiConfig.baseUrl}${ApiConfig.users}/$userId'),
       headers: await _headers(),
     );
 
     if (response.statusCode != 200 && response.statusCode != 204) {
-      final decoded = jsonDecode(response.body);
+      throw Exception(
-      if (decoded is Map<String, dynamic>) {
+        _extractErrorMessage(response.body, 'Erreur suppression utilisateur'),
-        final message = decoded['message'];
+      );
-        if (message is List && message.isNotEmpty) {
-          throw Exception(message.join(' - '));
-        }
-        throw Exception(_toStr(message) ?? 'Erreur suppression utilisateur');
-      }
-      throw Exception('Erreur suppression utilisateur');
     }
+    return _parseSuppressionBody(response.body);
   }
 }

frontend/lib/utils/am_vigilance.dart

@@ -9,6 +9,18 @@ int? amExpectedPlacesAvailable({
   return (maxChildren - childrenCount).clamp(0, maxChildren);
 }
 
+/// True s'il reste au moins une place d'accueil (capacité − enfants).
+bool amHasFreePlace(AssistanteMaternelleModel am) {
+  final expected = amExpectedPlacesAvailable(
+    maxChildren: am.maxChildren,
+    childrenCount: am.children.length,
+  );
+  if (expected != null) return expected > 0;
+  final places = am.placesAvailable;
+  if (places != null) return places > 0;
+  return true;
+}
+
 /// True si la valeur déclarée par l'AM ne correspond pas au calcul métier.
 bool amHasPlacesInconsistency({
   required int? maxChildren,

frontend/lib/utils/date_display_utils.dart

@@ -1,3 +1,4 @@
+import 'package:flutter/services.dart';
 import 'package:intl/intl.dart';
 import 'package:p_tits_pas/utils/enfant_status_utils.dart';
 
@@ -11,10 +12,50 @@ String formatIsoDateFr(String? s, {String ifEmpty = '–'}) {
   }
 }
 
-/// Convertit `dd/MM/yyyy` (ou ISO) en `yyyy-MM-dd` pour l'API.
+/// Affiche une date ISO en saisie guidée `jj / mm / aaaa`.
+String formatIsoDateFrInput(String? s, {String ifEmpty = ''}) {
+  if (s == null || s.trim().isEmpty) return ifEmpty;
+  try {
+    final dt = DateTime.parse(s.trim());
+    return formatFrenchDateDigits(
+      DateFormat('ddMMyyyy').format(dt),
+    );
+  } catch (_) {
+    return formatFrenchDateDigits(s.replaceAll(RegExp(r'\D'), ''));
+  }
+}
+
+/// Formate jusqu’à 8 chiffres en `jj / mm / aaaa`.
+String formatFrenchDateDigits(String digits) {
+  final d = digits.replaceAll(RegExp(r'\D'), '');
+  final limited = d.length > 8 ? d.substring(0, 8) : d;
+  final buf = StringBuffer();
+  for (var i = 0; i < limited.length; i++) {
+    if (i == 2 || i == 4) buf.write(' / ');
+    buf.write(limited[i]);
+  }
+  return buf.toString();
+}
+
+/// Convertit `dd/MM/yyyy`, `dd / MM / yyyy`, 8 chiffres ou ISO en `yyyy-MM-dd`.
 String? parseFrDateToIso(String text) {
   final t = text.trim();
   if (t.isEmpty) return null;
+
+  final digits = t.replaceAll(RegExp(r'\D'), '');
+  if (digits.length == 8) {
+    final dd = digits.substring(0, 2);
+    final mm = digits.substring(2, 4);
+    final yyyy = digits.substring(4, 8);
+    try {
+      return DateFormat('dd/MM/yyyy')
+          .parseStrict('$dd/$mm/$yyyy')
+          .toIso8601String()
+          .split('T')
+          .first;
+    } catch (_) {}
+  }
+
   try {
     return DateFormat('dd/MM/yyyy')
         .parseStrict(t)
@@ -96,3 +137,43 @@ String formatChildAgeLabel({
     return 'Né le ${formatIsoDateFr(birthDate)}';
   }
 }
+
+/// Saisie date FR : 8 chiffres → `jj / mm / aaaa`.
+class FrenchDateInputFormatter extends TextInputFormatter {
+  const FrenchDateInputFormatter();
+
+  @override
+  TextEditingValue formatEditUpdate(
+    TextEditingValue oldValue,
+    TextEditingValue newValue,
+  ) {
+    final digits = newValue.text.replaceAll(RegExp(r'\D'), '');
+    final limited = digits.length > 8 ? digits.substring(0, 8) : digits;
+    final formatted = formatFrenchDateDigits(limited);
+
+    final digitsBeforeCursor = newValue.text
+        .substring(0, newValue.selection.start.clamp(0, newValue.text.length))
+        .replaceAll(RegExp(r'\D'), '')
+        .length
+        .clamp(0, limited.length);
+
+    return TextEditingValue(
+      text: formatted,
+      selection: TextSelection.collapsed(
+        offset: _cursorOffset(formatted, digitsBeforeCursor),
+      ),
+    );
+  }
+
+  static int _cursorOffset(String formatted, int digitsBeforeCursor) {
+    if (digitsBeforeCursor <= 0) return 0;
+    var seen = 0;
+    for (var i = 0; i < formatted.length; i++) {
+      if (RegExp(r'\d').hasMatch(formatted[i])) {
+        seen++;
+        if (seen >= digitsBeforeCursor) return i + 1;
+      }
+    }
+    return formatted.length;
+  }
+}

frontend/lib/utils/enfant_status_utils.dart

@@ -14,10 +14,10 @@ String normalizeEnfantStatus(String? raw) {
   return s;
 }
 
-String _scolariseAccordeAuGenre(String? gender) {
+String _accordeAuGenre(String masculin, String feminin, String? gender) {
   final g = (gender ?? '').trim().toUpperCase();
-  if (g == 'F') return 'Scolarisée';
+  if (g == 'F') return feminin;
-  return 'Scolarisé';
+  return masculin;
 }
 
 /// Libellé affiché pour un statut enfant.
@@ -28,9 +28,9 @@ String enfantStatusLabel(String? status, {String? gender}) {
     case 'sans_garde':
       return 'Sans garde';
     case 'garde':
-      return 'En garde';
+      return _accordeAuGenre('Gardé', 'Gardée', gender);
     case 'scolarise':
-      return _scolariseAccordeAuGenre(gender);
+      return _accordeAuGenre('Scolarisé', 'Scolarisée', gender);
     default:
       return status?.trim().isNotEmpty == true ? status!.trim() : '–';
   }

frontend/lib/utils/enfant_vigilance.dart

@@ -0,0 +1,10 @@
+import 'package:p_tits_pas/models/enfant_admin_model.dart';
+
+/// Enfant sans lien parent (orphelins d’affiliation) — ticket #157.
+bool enfantHasNoResponsable(EnfantAdminModel enfant) => enfant.hasNoResponsable;
+
+/// Message vigilance liste Enfants (même usage que [amPlacesVigilanceMessage]).
+String? enfantSansResponsableVigilanceMessage(EnfantAdminModel enfant) {
+  if (!enfantHasNoResponsable(enfant)) return null;
+  return 'Aucun responsable rattaché — à rattacher à un foyer';
+}

frontend/lib/utils/name_format_utils.dart

@@ -1,3 +1,5 @@
+import 'package:flutter/services.dart';
+
 /// Formatage affichage prénom / nom (capitalisation par mot et segments après `-` ou `'`).
 
 String formatPersonNameCase(String raw) {
@@ -9,6 +11,22 @@ String formatPersonNameCase(String raw) {
   return words.map(_capitalizeComposedWord).join(' ');
 }
 
+/// Variante saisie live : pas de majuscule tant que le mot n’a qu’une lettre ;
+/// dès la 2ᵉ lettre, capitalisation comme [formatPersonNameCase].
+String formatPersonNameCaseTyping(String raw) {
+  if (raw.isEmpty) return raw;
+  final trailingMatch = RegExp(r'(\s*)$').firstMatch(raw);
+  final trailing = trailingMatch?.group(1) ?? '';
+  final core = raw.substring(0, raw.length - trailing.length);
+  if (core.isEmpty) return raw;
+  final words = core.split(RegExp(r'\s+'));
+  final formatted = words.map((w) {
+    if (w.length < 2) return w;
+    return _capitalizeComposedWord(w);
+  }).join(' ');
+  return formatted + trailing;
+}
+
 String _capitalizeComposedWord(String word) {
   if (word.isEmpty) {
     return word;
@@ -30,3 +48,26 @@ String _capitalizeComposedWord(String word) {
   }
   return buffer.toString();
 }
+
+/// Formateur de saisie prénom / nom (capitalisation progressive).
+class PersonNameInputFormatter extends TextInputFormatter {
+  const PersonNameInputFormatter();
+
+  @override
+  TextEditingValue formatEditUpdate(
+    TextEditingValue oldValue,
+    TextEditingValue newValue,
+  ) {
+    final formatted = formatPersonNameCaseTyping(newValue.text);
+    if (formatted == newValue.text) return newValue;
+
+    final sel = newValue.selection;
+    final offset = sel.isValid
+        ? sel.baseOffset.clamp(0, formatted.length)
+        : formatted.length;
+    return TextEditingValue(
+      text: formatted,
+      selection: TextSelection.collapsed(offset: offset),
+    );
+  }
+}

frontend/lib/utils/nir_utils.dart

@@ -49,12 +49,21 @@ String nirToRaw(String normalized) {
   return s;
 }
 
-/// Formate pour affichage : 1 12 34 56 789 012 - 34 ou 1 12 34 2A 789 012 - 34 (Corse).
+/// Formate pour affichage (complet ou en cours de saisie) :
+/// `1 12 34 56 789 012 - 34` ou `1 12 34 2A 789 012 - 34` (Corse).
 String formatNir(String raw) {
-  final r = nirToRaw(raw);
+  final r = nirToRaw(raw).toUpperCase();
-  if (r.length < 15) return r;
+  if (r.isEmpty) return '';
-  // Même structure pour tous : sexe + année + mois + département + commune + ordre-clé.
+  final buf = StringBuffer();
-  return '${r.substring(0, 1)} ${r.substring(1, 3)} ${r.substring(3, 5)} ${r.substring(5, 7)} ${r.substring(7, 10)} ${r.substring(10, 13)} - ${r.substring(13, 15)}';
+  for (var i = 0; i < r.length && i < 15; i++) {
+    if (i == 1 || i == 3 || i == 5 || i == 7 || i == 10) {
+      buf.write(' ');
+    } else if (i == 13) {
+      buf.write(' - ');
+    }
+    buf.write(r[i]);
+  }
+  return buf.toString();
 }
 
 /// Aligné sur le backend (NIR côté API / nir.util.ts) : sexe 1–3, département 2A ou 2B pour la Corse.
@@ -92,20 +101,39 @@ String? validateNir(String? value) {
   return null;
 }
 
-/// Formateur de saisie : affiche le NIR formaté (1 12 34 56 789 012 - 34) et limite à 15 caractères utiles.
+/// Validation pendant la saisie : pas d’erreur si incomplet encore plausible ;
+/// dès 15 caractères, même contrôles que [validateNir].
+String? validateNirTyping(String? value) {
+  if (value == null || value.trim().isEmpty) return null;
+  final raw = nirToRaw(value).toUpperCase();
+  if (raw.isEmpty) return null;
+  if (raw[0] != '1' && raw[0] != '2' && raw[0] != '3') {
+    return 'Format NIR invalide (ex. 1 12 34 56 789 012 - 34 ou 2A pour la Corse)';
+  }
+  if (raw.length < 15) return null;
+  return validateNir(value);
+}
+
+/// Formateur de saisie : affiche le NIR formaté au fil de la frappe et limite à 15 caractères utiles.
 class NirInputFormatter extends TextInputFormatter {
+  const NirInputFormatter();
+
   @override
   TextEditingValue formatEditUpdate(
     TextEditingValue oldValue,
     TextEditingValue newValue,
   ) {
     final raw = normalizeNir(newValue.text);
-    if (raw.isEmpty) return newValue;
+    if (raw.isEmpty) {
+      return const TextEditingValue(
+        text: '',
+        selection: TextSelection.collapsed(offset: 0),
+      );
+    }
     final formatted = formatNir(raw);
-    final offset = formatted.length;
     return TextEditingValue(
       text: formatted,
-      selection: TextSelection.collapsed(offset: offset),
+      selection: TextSelection.collapsed(offset: formatted.length),
     );
   }
 }