feat(templates): личные шаблоны серверов в хранилище и API (Фаза 7)

AGENT.md 7.3: свои шаблоны серверов — сохранить структуру сервера
(роли с правами и цветом, категории и комнаты) и создать по ней новый.
Миграция 00023 создаёт guild_templates (structure_json, source_guild_id,
каскад по владельцу) с индексом владельца.

- store: CRUD личных шаблонов с фильтром по owner_id и защитой лимитов
  (20 шаблонов, 16 КиБ structure_json);
- server: POST /guild-templates, GET /guild-templates/mine и
  DELETE /guild-templates/{id} (MANAGE_GUILD, чужой шаблон — 404),
  создание сервера по template_id=personal:<id> (аудит template=personal:<id>);
- структура шаблона повторяет API ролей (права строкой) и хранит
  slowmode_seconds, user_limit и категорию по имени.

internal/server/api_guilds.go

@@ -271,6 +271,9 @@ func (s *Server) registerGuildCoreRoutes(api huma.API) {
 		return output, nil
 	})
 
+	// Личные шаблоны серверов (Фаза 7): сохранить структуру, список и удаление.
+	s.registerUserGuildTemplateRoutes(api, security)
+
 	huma.Register(api, huma.Operation{
 		OperationID: "getGuild",
 		Method:      http.MethodGet,
@@ -1812,11 +1815,12 @@ func (s *Server) recordAudit(ctx context.Context, actor *store.User, guildID uin
 	}
 }
 
-// createGuild создаёт сервер с ролями по умолчанию и общей комнатой (AGENT.md 6.3).
+// createGuild создаёт сервер с ролями по умолчанию и структурой выбранного
+// шаблона — встроенного или личного (AGENT.md 6.3, 7.3).
 func (s *Server) createGuild(ctx context.Context, owner *store.User, name, templateID string) (*store.Guild, error) {
-	template, known := findGuildTemplate(templateID)
-	if !known {
-		return nil, humaErrorStatus(http.StatusUnprocessableEntity, "validation.failed", "unknown guild template")
+	template, templateReason, err := s.resolveGuildTemplate(ctx, owner, templateID)
+	if err != nil {
+		return nil, err
 	}
 	settings, err := s.store.InstanceSettings(ctx)
 	if err != nil {
@@ -1860,7 +1864,8 @@ func (s *Server) createGuild(ctx context.Context, owner *store.User, name, templ
 			return nil, humaError(err)
 		}
 	}
-	s.recordAudit(ctx, owner, guild.ID, "guild.create", "guild", &guild.ID, "template="+template.ID)
+	// Причина аудита: встроенный шаблон или personal:<id> у личного (7.3).
+	s.recordAudit(ctx, owner, guild.ID, "guild.create", "guild", &guild.ID, templateReason)
 	if bypassed {
 		s.recordAudit(ctx, owner, guild.ID, "limits.bypass", "guild", &guild.ID, "instance admin bypassed guild limit")
 	}

internal/server/guild_templates.go

@@ -2,33 +2,50 @@ package server
 
 import (
 	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"sort"
+	"strconv"
+	"strings"
+
+	"github.com/danielgtaylor/huma/v2"
 
 	"glchat/internal/permissions"
 	"glchat/internal/store"
 )
 
 // Шаблоны серверов (AGENT.md 7.3): при создании можно выбрать встроенный
-// шаблон — структура комнат и трёх ролей без сообщений. Свои шаблоны — после
-// MVP, поэтому каталог статический.
+// шаблон — структура комнат и трёх ролей без сообщений — или свой, снятый с
+// существующего сервера. Встроенный каталог статический (guildTemplates),
+// личные шаблоны живут в БД (guild_templates) и приватны для владельца.
 
 // guildTemplateRole — роль, которую создаёт шаблон.
 type guildTemplateRole struct {
 	Name        string
 	Permissions []permissions.Permission
-	Position    int
+	// Color — цвет роли в RGB (0 — по умолчанию).
+	Color    int64
+	Position int
 	// Hoist — показывать участников с этой ролью отдельной группой.
 	Hoist bool
+	// Mentionable — роль разрешено упоминать.
+	Mentionable bool
 }
 
 // guildTemplateChannel — комната шаблона; `Category` задаёт категорию, внутри
 // которой она создаётся (пусто — верхний уровень).
 type guildTemplateChannel struct {
-	Name     string
-	Type     store.ChannelType
-	Category string
+	Name            string
+	Type            store.ChannelType
+	Category        string
+	SlowmodeSeconds int
+	UserLimit       int
 }
 
-// guildTemplate — встроенный шаблон сервера.
+// guildTemplate — шаблон сервера: встроенный из каталога или личный,
+// разобранный из structure_json (AGENT.md 7.3).
 type guildTemplate struct {
 	ID          string
 	Name        string
@@ -60,8 +77,9 @@ var guildTemplates = []guildTemplate{
 					permissions.ViewAuditLog, permissions.MuteMembers, permissions.DeafenMembers,
 					permissions.MoveMembers,
 				},
-				Position: 50,
-				Hoist:    true,
+				Position:    50,
+				Hoist:       true,
+				Mentionable: true,
 			},
 		},
 		Channels: []guildTemplateChannel{
@@ -85,8 +103,9 @@ var guildTemplates = []guildTemplate{
 					permissions.ConnectVoice, permissions.Speak, permissions.UseSoundboard,
 					permissions.AttachFiles, permissions.AddReactions, permissions.EmbedLinks,
 				},
-				Position: 50,
-				Hoist:    true,
+				Position:    50,
+				Hoist:       true,
+				Mentionable: true,
 			},
 		},
 		Channels: []guildTemplateChannel{
@@ -141,10 +160,11 @@ func (s *Server) applyGuildTemplate(ctx context.Context, guild *store.Guild, tem
 		if _, err := s.store.CreateRole(ctx, store.CreateRoleParams{
 			GuildID:     guild.ID,
 			Name:        role.Name,
+			Color:       role.Color,
 			Permissions: uint64(permissionSet(role.Permissions)),
 			Position:    role.Position,
 			Hoist:       role.Hoist,
-			Mentionable: true,
+			Mentionable: role.Mentionable,
 		}); err != nil {
 			return humaError(err)
 		}
@@ -177,10 +197,12 @@ func (s *Server) applyGuildTemplate(ctx context.Context, guild *store.Guild, tem
 			continue
 		}
 		params := store.CreateChannelParams{
-			GuildID:  &guild.ID,
-			Type:     channel.Type,
-			Name:     channel.Name,
-			Position: position,
+			GuildID:         &guild.ID,
+			Type:            channel.Type,
+			Name:            channel.Name,
+			Position:        position,
+			SlowmodeSeconds: channel.SlowmodeSeconds,
+			UserLimit:       channel.UserLimit,
 		}
 		if parentID, ok := categories[channel.Category]; ok {
 			params.ParentID = &parentID
@@ -202,6 +224,9 @@ type guildTemplatePayload struct {
 	TextCount   int      `json:"text_channels"`
 	VoiceCount  int      `json:"voice_channels"`
 	Categories  []string `json:"categories"`
+	// CreatedAt и SourceGuildID заполнены только у личных шаблонов.
+	CreatedAt     string `json:"created_at,omitempty"`
+	SourceGuildID string `json:"source_guild_id,omitempty"`
 }
 
 type guildTemplateListOutput struct {
@@ -240,3 +265,457 @@ func guildTemplateFromCatalog(template guildTemplate) guildTemplatePayload {
 	}
 	return payload
 }
+
+// Личные шаблоны серверов (AGENT.md 7.3, Фаза 7): владелец сохраняет структуру
+// своего сервера и создаёт по ней новые. Шаблон приватный — видит и использует
+// только владелец; чужой шаблон неотличим от несуществующего (AGENT.md 9.7).
+//
+// Записи в аудит на CRUD личных шаблонов нет осознанно: шаблон — приватная
+// сущность пользователя, у неё нет сервера, а журнал аудита живёт на сервере
+// (AGENT.md 7.10). Единственное действие, попадающее в аудит, — создание
+// сервера по шаблону: там причина содержит template=<id>.
+const (
+	// personalTemplatePrefix — личный шаблон в template_id: personal:<id>.
+	personalTemplatePrefix = "personal:"
+	// maxUserGuildTemplateName и maxUserGuildTemplateDescription повторяют
+	// ограничения имён сервера и коротких описаний.
+	maxUserGuildTemplateName        = 64
+	maxUserGuildTemplateDescription = 200
+	// maxUserGuildTemplateRoles и maxUserGuildTemplateChannels ограничивают
+	// саму структуру: категории считаются комнатами.
+	maxUserGuildTemplateRoles    = 50
+	maxUserGuildTemplateChannels = 100
+)
+
+// userGuildTemplateStructure — structure_json личного шаблона. Формат повторяет
+// внутренний guildTemplate: роли (кроме роли по умолчанию) с цветом, позицией
+// и строкой прав, затем категории и комнаты. Права — строкой как в API ролей
+// («VIEW_CHANNEL|SEND_MESSAGES», «NONE» — нет прав): маска uint64 не теряет
+// точность в JSON. Числовая строка при разборе тоже принимается.
+type userGuildTemplateStructure struct {
+	Roles    []userGuildTemplateRole    `json:"roles"`
+	Channels []userGuildTemplateChannel `json:"channels"`
+}
+
+type userGuildTemplateRole struct {
+	Name        string `json:"name"`
+	Color       int64  `json:"color"`
+	Permissions string `json:"permissions"`
+	Position    int    `json:"position"`
+	Hoist       bool   `json:"hoist"`
+	Mentionable bool   `json:"mentionable"`
+}
+
+type userGuildTemplateChannel struct {
+	Name            string `json:"name"`
+	Type            string `json:"type"`
+	Category        string `json:"category,omitempty"`
+	Position        int    `json:"position"`
+	SlowmodeSeconds int    `json:"slowmode_seconds,omitempty"`
+	UserLimit       int    `json:"user_limit,omitempty"`
+}
+
+type userGuildTemplateOutput struct {
+	Body struct {
+		Template guildTemplatePayload `json:"template"`
+	}
+}
+
+type userGuildTemplateListOutput struct {
+	Body struct {
+		Templates []guildTemplatePayload `json:"templates"`
+	}
+}
+
+type guildTemplateDeleteOutput struct {
+	Body struct {
+		OK bool `json:"ok"`
+	}
+}
+
+// registerUserGuildTemplateRoutes описывает ручки личных шаблонов серверов.
+func (s *Server) registerUserGuildTemplateRoutes(api huma.API, security []map[string][]string) {
+	huma.Register(api, huma.Operation{
+		OperationID: "createUserGuildTemplate",
+		Method:      http.MethodPost,
+		Path:        "/guild-templates",
+		Summary:     "Сохранить структуру сервера личным шаблоном",
+		Tags:        []string{"Guilds"},
+		Security:    security,
+	}, func(ctx context.Context, input *struct {
+		Body struct {
+			GuildID     string `json:"guild_id"`
+			Name        string `json:"name,omitempty"`
+			Description string `json:"description,omitempty"`
+		}
+	},
+	) (*userGuildTemplateOutput, error) {
+		user, _, err := requireUser(ctx)
+		if err != nil {
+			return nil, err
+		}
+		guildID, err := parseID("guild_id", input.Body.GuildID)
+		if err != nil {
+			return nil, err
+		}
+		// Право MANAGE_GUILD: администратор инстанса проходит всегда
+		// (permissions.Resolved.IsInstanceAdmin).
+		resolved, err := s.guildPermissions(ctx, guildID, user)
+		if err != nil {
+			return nil, err
+		}
+		if !resolved.Has(permissions.ManageGuild) {
+			return nil, humaErrorStatus(http.StatusForbidden, "perm.denied", "permission denied")
+		}
+		guild, err := s.store.GetGuild(ctx, guildID)
+		if err != nil {
+			return nil, humaError(err)
+		}
+
+		name := strings.TrimSpace(input.Body.Name)
+		if name == "" {
+			name = guild.Name
+		}
+		if len([]rune(name)) > maxUserGuildTemplateName {
+			return nil, humaErrorStatus(http.StatusUnprocessableEntity, "validation.failed", "template name must be 1-64 characters")
+		}
+		description := strings.TrimSpace(input.Body.Description)
+		if len([]rune(description)) > maxUserGuildTemplateDescription {
+			return nil, humaErrorStatus(http.StatusUnprocessableEntity, "validation.failed", "template description must be at most 200 characters")
+		}
+
+		count, err := s.store.CountUserGuildTemplates(ctx, user.ID)
+		if err != nil {
+			return nil, humaError(err)
+		}
+		if count >= store.MaxUserGuildTemplates {
+			return nil, humaErrorStatus(http.StatusConflict, "template.limit_reached", "personal guild template limit is reached")
+		}
+
+		structure, err := s.buildUserGuildTemplateStructure(ctx, guildID)
+		if err != nil {
+			return nil, err
+		}
+		if len(structure.Roles) > maxUserGuildTemplateRoles || len(structure.Channels) > maxUserGuildTemplateChannels {
+			return nil, humaErrorStatus(http.StatusUnprocessableEntity, "validation.failed", "guild structure is too large for a template: at most 50 roles and 100 channels")
+		}
+		encoded, err := json.Marshal(structure)
+		if err != nil {
+			return nil, humaError(err)
+		}
+		if len(encoded) > store.MaxUserGuildTemplateBytes {
+			return nil, humaErrorStatus(http.StatusUnprocessableEntity, "validation.failed", "guild template structure is too large")
+		}
+
+		created, err := s.store.CreateUserGuildTemplate(ctx, store.CreateUserGuildTemplateParams{
+			OwnerID:       user.ID,
+			Name:          name,
+			Description:   description,
+			Structure:     encoded,
+			SourceGuildID: &guildID,
+		})
+		if err != nil {
+			switch {
+			case errors.Is(err, store.ErrTemplateLimitReached):
+				return nil, humaErrorStatus(http.StatusConflict, "template.limit_reached", "personal guild template limit is reached")
+			case errors.Is(err, store.ErrTemplateTooLarge):
+				return nil, humaErrorStatus(http.StatusUnprocessableEntity, "validation.failed", "guild template structure is too large")
+			}
+			return nil, humaError(err)
+		}
+		output := &userGuildTemplateOutput{}
+		output.Body.Template = s.userGuildTemplatePayload(*created)
+		return output, nil
+	})
+
+	huma.Register(api, huma.Operation{
+		OperationID: "listUserGuildTemplates",
+		Method:      http.MethodGet,
+		Path:        "/guild-templates/mine",
+		Summary:     "Свои шаблоны серверов",
+		Tags:        []string{"Guilds"},
+		Security:    security,
+	}, func(ctx context.Context, _ *struct{}) (*userGuildTemplateListOutput, error) {
+		user, _, err := requireUser(ctx)
+		if err != nil {
+			return nil, err
+		}
+		templates, err := s.store.ListUserGuildTemplates(ctx, user.ID)
+		if err != nil {
+			return nil, humaError(err)
+		}
+		output := &userGuildTemplateListOutput{}
+		output.Body.Templates = make([]guildTemplatePayload, 0, len(templates))
+		for _, template := range templates {
+			output.Body.Templates = append(output.Body.Templates, s.userGuildTemplatePayload(template))
+		}
+		return output, nil
+	})
+
+	huma.Register(api, huma.Operation{
+		OperationID: "deleteUserGuildTemplate",
+		Method:      http.MethodDelete,
+		Path:        "/guild-templates/{template_id}",
+		Summary:     "Удалить свой шаблон сервера",
+		Tags:        []string{"Guilds"},
+		Security:    security,
+	}, func(ctx context.Context, input *struct {
+		TemplateID string `path:"template_id"`
+	},
+	) (*guildTemplateDeleteOutput, error) {
+		user, _, err := requireUser(ctx)
+		if err != nil {
+			return nil, err
+		}
+		// Принимаем и «personal:<id>» (как в списке шаблонов клиента), и сам id.
+		templateID, err := parseID("template_id", strings.TrimPrefix(input.TemplateID, personalTemplatePrefix))
+		if err != nil {
+			return nil, err
+		}
+		deleted, err := s.store.DeleteUserGuildTemplate(ctx, templateID, user.ID)
+		if err != nil {
+			return nil, humaError(err)
+		}
+		if !deleted {
+			// Чужой шаблон неотличим от несуществующего (AGENT.md 9.7).
+			return nil, humaErrorStatus(http.StatusNotFound, "not_found", "guild template not found")
+		}
+		output := &guildTemplateDeleteOutput{}
+		output.Body.OK = true
+		return output, nil
+	})
+}
+
+// buildUserGuildTemplateStructure снимает структуру сервера: роли (кроме роли
+// по умолчанию — «Пользователь» создаётся для каждого сервера сам, AGENT.md 6.3)
+// и все комнаты вместе с категориями.
+func (s *Server) buildUserGuildTemplateStructure(ctx context.Context, guildID uint64) (userGuildTemplateStructure, error) {
+	roles, err := s.store.ListGuildRoles(ctx, guildID)
+	if err != nil {
+		return userGuildTemplateStructure{}, humaError(err)
+	}
+	structure := userGuildTemplateStructure{
+		Roles:    make([]userGuildTemplateRole, 0, len(roles)),
+		Channels: make([]userGuildTemplateChannel, 0, 8),
+	}
+	for _, role := range roles {
+		if role.IsDefault {
+			continue
+		}
+		structure.Roles = append(structure.Roles, userGuildTemplateRole{
+			Name:        role.Name,
+			Color:       role.Color,
+			Permissions: permissions.Permission(role.Permissions).String(),
+			Position:    role.Position,
+			Hoist:       role.Hoist,
+			Mentionable: role.Mentionable,
+		})
+	}
+
+	channels, err := s.store.ListGuildChannels(ctx, guildID)
+	if err != nil {
+		return userGuildTemplateStructure{}, humaError(err)
+	}
+	// Комната ссылается на категорию по имени: идентификаторы в новом сервере
+	// будут другими (AGENT.md 6.4).
+	categories := make(map[uint64]string, len(channels))
+	for _, channel := range channels {
+		if channel.Type == store.ChannelCategory {
+			categories[channel.ID] = channel.Name
+		}
+	}
+	for _, channel := range channels {
+		if channel.Type == store.ChannelDM {
+			continue
+		}
+		item := userGuildTemplateChannel{
+			Name:            channel.Name,
+			Type:            string(channel.Type),
+			Position:        channel.Position,
+			SlowmodeSeconds: channel.SlowmodeSeconds,
+			UserLimit:       channel.UserLimit,
+		}
+		if channel.ParentID != nil {
+			item.Category = categories[*channel.ParentID]
+		}
+		structure.Channels = append(structure.Channels, item)
+	}
+	return structure, nil
+}
+
+// structureToGuildTemplate превращает сохранённую структуру во внутренний
+// шаблон: порядок комнат задаёт position. Битый шаблон — ошибка целиком:
+// половина сервера хуже, чем отказ.
+func structureToGuildTemplate(structure userGuildTemplateStructure) (guildTemplate, error) {
+	template := guildTemplate{
+		Roles:    make([]guildTemplateRole, 0, len(structure.Roles)),
+		Channels: make([]guildTemplateChannel, 0, len(structure.Channels)),
+	}
+	for _, role := range structure.Roles {
+		name := strings.TrimSpace(role.Name)
+		if name == "" {
+			return guildTemplate{}, errors.New("role name must not be empty")
+		}
+		mask, err := parseTemplatePermissions(role.Permissions)
+		if err != nil {
+			return guildTemplate{}, err
+		}
+		template.Roles = append(template.Roles, guildTemplateRole{
+			Name:        name,
+			Permissions: permissionList(mask),
+			Color:       role.Color,
+			Position:    role.Position,
+			Hoist:       role.Hoist,
+			Mentionable: role.Mentionable,
+		})
+	}
+	channels := make([]userGuildTemplateChannel, len(structure.Channels))
+	copy(channels, structure.Channels)
+	sort.SliceStable(channels, func(i, j int) bool { return channels[i].Position < channels[j].Position })
+	for _, channel := range channels {
+		name := strings.TrimSpace(channel.Name)
+		if name == "" {
+			return guildTemplate{}, errors.New("channel name must not be empty")
+		}
+		channelType := store.ChannelType(channel.Type)
+		switch channelType {
+		case store.ChannelText, store.ChannelVoice, store.ChannelCategory:
+		case store.ChannelDM:
+			return guildTemplate{}, errors.New("dm channels are not allowed in a template")
+		default:
+			return guildTemplate{}, fmt.Errorf("unknown channel type %q", channel.Type)
+		}
+		template.Channels = append(template.Channels, guildTemplateChannel{
+			Name:            name,
+			Type:            channelType,
+			Category:        channel.Category,
+			SlowmodeSeconds: channel.SlowmodeSeconds,
+			UserLimit:       channel.UserLimit,
+		})
+	}
+	return template, nil
+}
+
+// permissionList разворачивает маску в список прав — внутренний вид шаблона.
+func permissionList(mask permissions.Permission) []permissions.Permission {
+	list := make([]permissions.Permission, 0, 8)
+	for bit := permissions.Permission(1); bit != 0 && bit <= permissions.Administrator; bit <<= 1 {
+		if mask.Has(bit) {
+			list = append(list, bit)
+		}
+	}
+	return list
+}
+
+// parseTemplatePermissions разбирает права роли из structure_json: строка
+// названий через «|» (как в API ролей), «NONE» или пустая строка — нет прав;
+// числовая строка-маска тоже принимается.
+func parseTemplatePermissions(value string) (permissions.Permission, error) {
+	trimmed := strings.TrimSpace(value)
+	if trimmed == "" || strings.EqualFold(trimmed, "NONE") {
+		return 0, nil
+	}
+	if mask, err := strconv.ParseUint(trimmed, 10, 64); err == nil {
+		return permissions.Permission(mask), nil
+	}
+	mask, err := permissions.Parse(trimmed)
+	if err != nil {
+		return 0, err
+	}
+	return mask, nil
+}
+
+// resolveGuildTemplate выбирает шаблон структуры для нового сервера: встроенный
+// по идентификатору каталога или личный по префиксу personal:<id>. Второе
+// значение — причина для аудита guild.create (AGENT.md 7.3).
+func (s *Server) resolveGuildTemplate(ctx context.Context, user *store.User, templateID string) (guildTemplate, string, error) {
+	if !strings.HasPrefix(templateID, personalTemplatePrefix) {
+		template, known := findGuildTemplate(templateID)
+		if !known {
+			return guildTemplate{}, "", humaErrorStatus(http.StatusUnprocessableEntity, "validation.failed", "unknown guild template")
+		}
+		return template, "template=" + template.ID, nil
+	}
+
+	id, err := parseID("template_id", strings.TrimPrefix(templateID, personalTemplatePrefix))
+	if err != nil {
+		return guildTemplate{}, "", humaErrorStatus(http.StatusUnprocessableEntity, "validation.failed", "unknown guild template")
+	}
+	stored, err := s.store.GetUserGuildTemplate(ctx, id)
+	if err != nil {
+		if errors.Is(err, store.ErrNotFound) {
+			return guildTemplate{}, "", humaErrorStatus(http.StatusUnprocessableEntity, "validation.failed", "unknown guild template")
+		}
+		return guildTemplate{}, "", humaError(err)
+	}
+	// Чужой личный шаблон неотличим от несуществующего (AGENT.md 9.7).
+	if stored.OwnerID != user.ID {
+		return guildTemplate{}, "", humaErrorStatus(http.StatusUnprocessableEntity, "validation.failed", "unknown guild template")
+	}
+	var structure userGuildTemplateStructure
+	if err := json.Unmarshal(stored.Structure, &structure); err != nil {
+		return guildTemplate{}, "", humaErrorStatus(http.StatusUnprocessableEntity, "validation.failed", "guild template structure is invalid")
+	}
+	template, err := structureToGuildTemplate(structure)
+	if err != nil {
+		return guildTemplate{}, "", humaErrorStatus(http.StatusUnprocessableEntity, "validation.failed", "guild template structure is invalid")
+	}
+	return template, "template=" + personalTemplatePrefix + formatSnowflake(stored.ID), nil
+}
+
+// userGuildTemplatePayload описывает личный шаблон для клиента: тот же
+// предпросмотр, что у встроенных шаблонов, плюс дата создания и сервер-источник.
+func (s *Server) userGuildTemplatePayload(template store.UserGuildTemplate) guildTemplatePayload {
+	payload := guildTemplatePayload{
+		ID:          formatSnowflake(template.ID),
+		Name:        template.Name,
+		Description: template.Description,
+		Roles:       []string{"Администратор", "Пользователь"},
+		Categories:  []string{},
+		CreatedAt:   s.store.Timestamp(template.CreatedAt),
+	}
+	if template.SourceGuildID != nil {
+		payload.SourceGuildID = formatSnowflake(*template.SourceGuildID)
+	}
+	var structure userGuildTemplateStructure
+	if err := json.Unmarshal(template.Structure, &structure); err != nil {
+		// Битый шаблон не должен ломать список: отдаём его без предпросмотра.
+		return payload
+	}
+	fillTemplatePreview(&payload, structure)
+	return payload
+}
+
+// fillTemplatePreview дополняет предпросмотр по структуре шаблона. Роли
+// «Администратор» и «Пользователь» уже перечислены: они создаются для каждого
+// сервера (AGENT.md 6.3), поэтому повторно их не добавляем.
+func fillTemplatePreview(payload *guildTemplatePayload, structure userGuildTemplateStructure) {
+	seen := make(map[string]bool, len(payload.Roles))
+	for _, name := range payload.Roles {
+		seen[name] = true
+	}
+	for _, role := range structure.Roles {
+		name := strings.TrimSpace(role.Name)
+		if name == "" || seen[name] {
+			continue
+		}
+		seen[name] = true
+		payload.Roles = append(payload.Roles, name)
+	}
+	categories := make(map[string]bool, 4)
+	for _, channel := range structure.Channels {
+		switch store.ChannelType(channel.Type) {
+		case store.ChannelText:
+			payload.TextCount++
+		case store.ChannelVoice:
+			payload.VoiceCount++
+		case store.ChannelCategory:
+			if !categories[channel.Name] {
+				categories[channel.Name] = true
+				payload.Categories = append(payload.Categories, channel.Name)
+			}
+		case store.ChannelDM:
+			// Личных бесед в шаблонах нет.
+		}
+	}
+}

internal/server/guild_templates_test.go

@@ -1,12 +1,18 @@
 package server
 
 import (
+	"encoding/json"
 	"net/http"
+	"strconv"
+	"strings"
 	"testing"
+
+	"glchat/internal/store"
 )
 
 // Тесты шаблонов серверов (AGENT.md 7.3): встроенный шаблон создаёт структуру
-// комнат и ролей без сообщений, неизвестный шаблон отклоняется.
+// комнат и ролей без сообщений, неизвестный шаблон отклоняется, личные шаблоны
+// приватны и воспроизводят структуру своего сервера (Фаза 7).
 
 func TestGuildTemplatesCatalog(t *testing.T) {
 	srv, _ := newTestServer(t)
@@ -190,3 +196,459 @@ func TestGuildFromTemplateCreatesNoDuplicates(t *testing.T) {
 		t.Fatalf("комнат %d, ожидалось 7", len(list.Channels))
 	}
 }
+
+// guildChannels читает комнаты сервера: имя, тип, родитель, медленный режим и
+// лимит участников — по ним проверяется воспроизведение структуры.
+type guildChannelView struct {
+	ID              string `json:"id"`
+	Name            string `json:"name"`
+	Type            string `json:"type"`
+	ParentID        string `json:"parent_id"`
+	SlowmodeSeconds int    `json:"slowmode_seconds"`
+	UserLimit       int    `json:"user_limit"`
+}
+
+func readGuildChannels(t *testing.T, srv *Server, guildID string, user *http.Cookie) []guildChannelView {
+	t.Helper()
+	rec := doJSON(t, srv, http.MethodGet, "/api/v1/guilds/"+guildID+"/channels", "", user)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("GET /guilds/%s/channels = %d (%s)", guildID, rec.Code, rec.Body.String())
+	}
+	return decodeResponse[struct {
+		Channels []guildChannelView `json:"channels"`
+	}](t, rec).Channels
+}
+
+// guildRoleView — роль глазами клиента: цвет и права строкой.
+type guildRoleView struct {
+	ID          string `json:"id"`
+	Name        string `json:"name"`
+	Color       int64  `json:"color"`
+	Permissions string `json:"permissions"`
+	Mentionable bool   `json:"mentionable"`
+}
+
+func readGuildRoles(t *testing.T, srv *Server, guildID string, user *http.Cookie) []guildRoleView {
+	t.Helper()
+	rec := doJSON(t, srv, http.MethodGet, "/api/v1/guilds/"+guildID+"/roles", "", user)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("GET /guilds/%s/roles = %d (%s)", guildID, rec.Code, rec.Body.String())
+	}
+	return decodeResponse[struct {
+		Roles []guildRoleView `json:"roles"`
+	}](t, rec).Roles
+}
+
+// TestUserGuildTemplateRoundTrip сохраняет структуру сервера личным шаблоном и
+// создаёт по нему новый сервер: роли с правами и цветом, категории и комнаты с
+// типами и настройками воспроизводятся (AGENT.md 7.3, Фаза 7).
+func TestUserGuildTemplateRoundTrip(t *testing.T) {
+	srv, _ := newTestServer(t)
+	owner := registerAndLogin(t, srv, "tpl_save", "tpl-save@example.com")
+	source := createGuildForTest(t, srv, owner, "Источник")
+
+	// Своя роль с цветом и правами: в шаблон она должна попасть целиком.
+	roleRec := doJSON(t, srv, http.MethodPost, "/api/v1/guilds/"+source+"/roles",
+		`{"name":"Модератор","color":16711680,"permissions":"KICK_MEMBERS|MANAGE_MESSAGES","hoist":true,"mentionable":true}`, owner)
+	if roleRec.Code != http.StatusOK {
+		t.Fatalf("создание роли = %d (%s)", roleRec.Code, roleRec.Body.String())
+	}
+	category := createChannelForTest(t, srv, owner, source,
+		`{"name":"Информация","type":"category"}`)
+	createChannelForTest(t, srv, owner, source,
+		`{"name":"правила","type":"text","parent_id":"`+category+`","slowmode_seconds":30}`)
+	createChannelForTest(t, srv, owner, source,
+		`{"name":"Голосовой","type":"voice","parent_id":"`+category+`","user_limit":5}`)
+
+	saved := doJSON(t, srv, http.MethodPost, "/api/v1/guild-templates",
+		`{"guild_id":"`+source+`","name":"Мой шаблон","description":"Структура источника"}`, owner)
+	if saved.Code != http.StatusOK {
+		t.Fatalf("сохранение шаблона = %d (%s)", saved.Code, saved.Body.String())
+	}
+	templatePayload := decodeResponse[struct {
+		Template struct {
+			ID          string   `json:"id"`
+			Name        string   `json:"name"`
+			Description string   `json:"description"`
+			Roles       []string `json:"roles"`
+			TextCount   int      `json:"text_channels"`
+			VoiceCount  int      `json:"voice_channels"`
+			Categories  []string `json:"categories"`
+			CreatedAt   string   `json:"created_at"`
+			SourceGuild string   `json:"source_guild_id"`
+		} `json:"template"`
+	}](t, saved).Template
+	if templatePayload.ID == "" || templatePayload.Name != "Мой шаблон" {
+		t.Fatalf("неожиданный шаблон: %+v", templatePayload)
+	}
+	if templatePayload.CreatedAt == "" || templatePayload.SourceGuild != source {
+		t.Fatalf("created_at/source_guild_id = %q/%q", templatePayload.CreatedAt, templatePayload.SourceGuild)
+	}
+	if !contains(templatePayload.Roles, "Модератор") {
+		t.Fatalf("роль шаблона потеряна: %v", templatePayload.Roles)
+	}
+	if templatePayload.TextCount != 2 || templatePayload.VoiceCount != 1 {
+		t.Fatalf("комнат в шаблоне: text=%d voice=%d, ожидалось 2/1", templatePayload.TextCount, templatePayload.VoiceCount)
+	}
+	if !contains(templatePayload.Categories, "Информация") {
+		t.Fatalf("категория шаблона потеряна: %v", templatePayload.Categories)
+	}
+
+	// Формат structure_json: права — строкой как в API ролей, комната ссылается
+	// на категорию по имени (идентификаторы в новом сервере другие).
+	templateID, err := strconv.ParseUint(templatePayload.ID, 10, 64)
+	if err != nil {
+		t.Fatalf("идентификатор шаблона %q: %v", templatePayload.ID, err)
+	}
+	stored, err := srv.store.GetUserGuildTemplate(t.Context(), templateID)
+	if err != nil {
+		t.Fatalf("GetUserGuildTemplate: %v", err)
+	}
+	var structure userGuildTemplateStructure
+	if err := json.Unmarshal(stored.Structure, &structure); err != nil {
+		t.Fatalf("разбор structure_json: %v (%s)", err, stored.Structure)
+	}
+	var storedRole *userGuildTemplateRole
+	for i := range structure.Roles {
+		if structure.Roles[i].Name == "Модератор" {
+			storedRole = &structure.Roles[i]
+		}
+	}
+	if storedRole == nil {
+		t.Fatalf("в structure_json нет роли: %s", stored.Structure)
+	}
+	if storedRole.Color != 16711680 || !strings.Contains(storedRole.Permissions, "KICK_MEMBERS") {
+		t.Errorf("роль в structure_json: %+v", *storedRole)
+	}
+	var storedChannel *userGuildTemplateChannel
+	for i := range structure.Channels {
+		if structure.Channels[i].Name == "правила" {
+			storedChannel = &structure.Channels[i]
+		}
+	}
+	if storedChannel == nil {
+		t.Fatalf("в structure_json нет комнаты: %s", stored.Structure)
+	}
+	if storedChannel.Type != "text" || storedChannel.Category != "Информация" || storedChannel.SlowmodeSeconds != 30 {
+		t.Errorf("комната в structure_json: %+v", *storedChannel)
+	}
+
+	// Каталог встроенных шаблонов личными не засоряется.
+	catalog := doJSON(t, srv, http.MethodGet, "/api/v1/guild-templates", "", owner)
+	if count := len(decodeResponse[struct {
+		Templates []struct {
+			ID string `json:"id"`
+		} `json:"templates"`
+	}](t, catalog).Templates); count != 3 {
+		t.Fatalf("встроенных шаблонов %d, ожидалось 3", count)
+	}
+
+	mine := doJSON(t, srv, http.MethodGet, "/api/v1/guild-templates/mine", "", owner)
+	if count := len(decodeResponse[struct {
+		Templates []struct {
+			ID string `json:"id"`
+		} `json:"templates"`
+	}](t, mine).Templates); count != 1 {
+		t.Fatalf("своих шаблонов %d, ожидалось 1", count)
+	}
+
+	created := doJSON(t, srv, http.MethodPost, "/api/v1/guilds",
+		`{"name":"Копия","template_id":"personal:`+templatePayload.ID+`"}`, owner)
+	if created.Code != http.StatusOK {
+		t.Fatalf("создание сервера по личному шаблону = %d (%s)", created.Code, created.Body.String())
+	}
+	copyID := decodeResponse[struct {
+		Guild struct {
+			ID   string `json:"id"`
+			Name string `json:"name"`
+		} `json:"guild"`
+	}](t, created).Guild.ID
+	if copyID == "" || copyID == source {
+		t.Fatalf("сервер не создан: %q", copyID)
+	}
+
+	roles := readGuildRoles(t, srv, copyID, owner)
+	var copied *guildRoleView
+	for i := range roles {
+		if roles[i].Name == "Модератор" {
+			copied = &roles[i]
+		}
+	}
+	if copied == nil {
+		t.Fatalf("роль «Модератор» не создана: %+v", roles)
+	}
+	if copied.Color != 16711680 {
+		t.Errorf("цвет роли = %d, ожидался 16711680", copied.Color)
+	}
+	if !strings.Contains(copied.Permissions, "KICK_MEMBERS") || !strings.Contains(copied.Permissions, "MANAGE_MESSAGES") {
+		t.Errorf("права роли = %q", copied.Permissions)
+	}
+	if !copied.Mentionable {
+		t.Error("роль не упоминаемая")
+	}
+	// Роли по умолчанию остаются на месте и не дублируются.
+	for _, name := range []string{"Администратор", "Пользователь"} {
+		seen := 0
+		for _, role := range roles {
+			if role.Name == name {
+				seen++
+			}
+		}
+		if seen != 1 {
+			t.Errorf("роль %q создана %d раз, ожидалось 1", name, seen)
+		}
+	}
+
+	channels := readGuildChannels(t, srv, copyID, owner)
+	byName := map[string]guildChannelView{}
+	for _, channel := range channels {
+		byName[channel.Name] = channel
+	}
+	copiedCategory, ok := byName["Информация"]
+	if !ok || copiedCategory.Type != "category" {
+		t.Fatalf("категория не создана: %+v", channels)
+	}
+	copiedText, ok := byName["правила"]
+	if !ok || copiedText.Type != "text" {
+		t.Fatalf("текстовая комната не создана: %+v", channels)
+	}
+	if copiedText.ParentID != copiedCategory.ID {
+		t.Errorf("текстовая комната вне категории: %+v", copiedText)
+	}
+	if copiedText.SlowmodeSeconds != 30 {
+		t.Errorf("медленный режим = %d, ожидался 30", copiedText.SlowmodeSeconds)
+	}
+	copiedVoice, ok := byName["Голосовой"]
+	if !ok || copiedVoice.Type != "voice" {
+		t.Fatalf("голосовая комната не создана: %+v", channels)
+	}
+	if copiedVoice.UserLimit != 5 {
+		t.Errorf("лимит участников = %d, ожидался 5", copiedVoice.UserLimit)
+	}
+
+	// Создание сервера по шаблону пишется в аудит с причиной template=personal:<id>.
+	copyGuildID, err := strconv.ParseUint(copyID, 10, 64)
+	if err != nil {
+		t.Fatalf("идентификатор сервера %q: %v", copyID, err)
+	}
+	entries, err := srv.store.ListAuditLog(t.Context(), copyGuildID, 20)
+	if err != nil {
+		t.Fatalf("ListAuditLog: %v", err)
+	}
+	found := false
+	for _, entry := range entries {
+		if entry.Action == "guild.create" && strings.Contains(entry.Reason, "template=personal:"+templatePayload.ID) {
+			found = true
+		}
+	}
+	if !found {
+		t.Fatalf("в аудите нет причины template=personal:%s: %+v", templatePayload.ID, entries)
+	}
+}
+
+// TestUserGuildTemplatePrivacy: чужой личный шаблон не виден в списке, не
+// удаляется (404) и не может быть использован при создании сервера (422).
+func TestUserGuildTemplatePrivacy(t *testing.T) {
+	srv, _ := newTestServer(t)
+	owner := registerAndLogin(t, srv, "tpl_priv_owner", "tpl-priv-owner@example.com")
+	other := registerAndLogin(t, srv, "tpl_priv_other", "tpl-priv-other@example.com")
+	source := createGuildForTest(t, srv, owner, "Закрытый")
+
+	saved := doJSON(t, srv, http.MethodPost, "/api/v1/guild-templates",
+		`{"guild_id":"`+source+`","name":"Секрет"}`, owner)
+	if saved.Code != http.StatusOK {
+		t.Fatalf("сохранение шаблона = %d (%s)", saved.Code, saved.Body.String())
+	}
+	templateID := decodeResponse[struct {
+		Template struct {
+			ID string `json:"id"`
+		} `json:"template"`
+	}](t, saved).Template.ID
+
+	mine := doJSON(t, srv, http.MethodGet, "/api/v1/guild-templates/mine", "", other)
+	if count := len(decodeResponse[struct {
+		Templates []struct {
+			ID string `json:"id"`
+		} `json:"templates"`
+	}](t, mine).Templates); count != 0 {
+		t.Fatalf("чужой шаблон виден в списке: %d", count)
+	}
+
+	deleted := doJSON(t, srv, http.MethodDelete, "/api/v1/guild-templates/"+templateID, "", other)
+	if deleted.Code != http.StatusNotFound {
+		t.Fatalf("удаление чужого шаблона = %d (%s)", deleted.Code, deleted.Body.String())
+	}
+	if code := errorCodeOf(t, deleted); code != "not_found" {
+		t.Fatalf("код ошибки = %q, ожидался not_found", code)
+	}
+
+	created := doJSON(t, srv, http.MethodPost, "/api/v1/guilds",
+		`{"name":"Чужой","template_id":"personal:`+templateID+`"}`, other)
+	if created.Code != http.StatusUnprocessableEntity {
+		t.Fatalf("создание по чужому шаблону = %d (%s)", created.Code, created.Body.String())
+	}
+	if code := errorCodeOf(t, created); code != "validation.failed" {
+		t.Fatalf("код ошибки = %q, ожидался validation.failed", code)
+	}
+
+	// Владелец по-прежнему видит и удаляет свой шаблон.
+	ok := doJSON(t, srv, http.MethodDelete, "/api/v1/guild-templates/"+templateID, "", owner)
+	if ok.Code != http.StatusOK {
+		t.Fatalf("удаление своего шаблона = %d (%s)", ok.Code, ok.Body.String())
+	}
+	if mine := doJSON(t, srv, http.MethodGet, "/api/v1/guild-templates/mine", "", owner); len(decodeResponse[struct {
+		Templates []struct {
+			ID string `json:"id"`
+		} `json:"templates"`
+	}](t, mine).Templates) != 0 {
+		t.Fatal("шаблон не удалён")
+	}
+}
+
+// TestUserGuildTemplateRequiresManageGuild: участник без MANAGE_GUILD не может
+// сохранить шаблон с чужого сервера.
+func TestUserGuildTemplateRequiresManageGuild(t *testing.T) {
+	srv, _ := newTestServer(t)
+	owner := registerAndLogin(t, srv, "tpl_perm_owner", "tpl-perm-owner@example.com")
+	member := registerAndLogin(t, srv, "tpl_perm_member", "tpl-perm-member@example.com")
+	source := createGuildForTest(t, srv, owner, "Права")
+
+	invite := doJSON(t, srv, http.MethodPost, "/api/v1/guilds/"+source+"/invites", `{}`, owner)
+	if invite.Code != http.StatusOK {
+		t.Fatalf("создание приглашения = %d (%s)", invite.Code, invite.Body.String())
+	}
+	code := decodeResponse[struct {
+		Invite struct {
+			Code string `json:"code"`
+		} `json:"invite"`
+	}](t, invite).Invite.Code
+	if joined := doJSON(t, srv, http.MethodPost, "/api/v1/invites/"+code, "", member); joined.Code != http.StatusOK {
+		t.Fatalf("вступление по приглашению = %d (%s)", joined.Code, joined.Body.String())
+	}
+
+	denied := doJSON(t, srv, http.MethodPost, "/api/v1/guild-templates",
+		`{"guild_id":"`+source+`","name":"Нельзя"}`, member)
+	if denied.Code != http.StatusForbidden {
+		t.Fatalf("сохранение без MANAGE_GUILD = %d (%s)", denied.Code, denied.Body.String())
+	}
+	if code := errorCodeOf(t, denied); code != "perm.denied" {
+		t.Fatalf("код ошибки = %q, ожидался perm.denied", code)
+	}
+}
+
+// TestUserGuildTemplateLimitReached: двадцать первый личный шаблон отклоняется
+// с кодом template.limit_reached (409).
+func TestUserGuildTemplateLimitReached(t *testing.T) {
+	srv, _ := newTestServer(t)
+	owner := registerAndLogin(t, srv, "tpl_limit", "tpl-limit@example.com")
+	source := createGuildForTest(t, srv, owner, "Лимит")
+	account, err := srv.auth.UserByEmail(t.Context(), "tpl-limit@example.com")
+	if err != nil {
+		t.Fatalf("UserByEmail: %v", err)
+	}
+	for i := 0; i < store.MaxUserGuildTemplates; i++ {
+		if _, err := srv.store.CreateUserGuildTemplate(t.Context(), store.CreateUserGuildTemplateParams{
+			OwnerID:   account.ID,
+			Name:      "Заполнение",
+			Structure: json.RawMessage(`{"roles":[],"channels":[]}`),
+		}); err != nil {
+			t.Fatalf("шаблон %d: %v", i, err)
+		}
+	}
+
+	rec := doJSON(t, srv, http.MethodPost, "/api/v1/guild-templates",
+		`{"guild_id":"`+source+`","name":"Лишний"}`, owner)
+	if rec.Code != http.StatusConflict {
+		t.Fatalf("превышение лимита = %d (%s)", rec.Code, rec.Body.String())
+	}
+	if code := errorCodeOf(t, rec); code != "template.limit_reached" {
+		t.Fatalf("код ошибки = %q, ожидался template.limit_reached", code)
+	}
+}
+
+// TestInstanceAdminSavesForeignGuildTemplate: у администратора инстанса
+// MANAGE_GUILD есть на любом сервере (AGENT.md 7.19).
+func TestInstanceAdminSavesForeignGuildTemplate(t *testing.T) {
+	srv, _ := newTestServer(t)
+	owner := registerAndLogin(t, srv, "tpl_admin_owner", "tpl-admin-owner@example.com")
+	admin := registerAndLogin(t, srv, "tpl_admin", "tpl-admin@example.com")
+	promoteAdmin(t, srv, "tpl-admin@example.com")
+	source := createGuildForTest(t, srv, owner, "Чужой сервер")
+
+	rec := doJSON(t, srv, http.MethodPost, "/api/v1/guild-templates",
+		`{"guild_id":"`+source+`","name":"От админа"}`, admin)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("админ инстанса не сохранил шаблон = %d (%s)", rec.Code, rec.Body.String())
+	}
+	template := decodeResponse[struct {
+		Template struct {
+			ID          string `json:"id"`
+			SourceGuild string `json:"source_guild_id"`
+		} `json:"template"`
+	}](t, rec).Template
+	if template.SourceGuild != source {
+		t.Fatalf("source_guild_id = %q, ожидался %q", template.SourceGuild, source)
+	}
+	if created := doJSON(t, srv, http.MethodPost, "/api/v1/guilds",
+		`{"name":"По чужому","template_id":"personal:`+template.ID+`"}`, admin); created.Code != http.StatusOK {
+		t.Fatalf("создание сервера админом = %d (%s)", created.Code, created.Body.String())
+	}
+}
+
+// TestUserGuildTemplateStructureLimit: слишком большая структура (больше 100
+// комнат) в шаблон не попадает — 422 validation.failed.
+func TestUserGuildTemplateStructureLimit(t *testing.T) {
+	srv, _ := newTestServer(t)
+	owner := registerAndLogin(t, srv, "tpl_big", "tpl-big@example.com")
+	source := createGuildForTest(t, srv, owner, "Большой")
+	guildID, err := strconv.ParseUint(source, 10, 64)
+	if err != nil {
+		t.Fatalf("идентификатор сервера %q: %v", source, err)
+	}
+	// В сервере уже есть общая комната, поэтому лимит превышен на одну.
+	for i := 0; i < maxUserGuildTemplateChannels; i++ {
+		if _, err := srv.store.CreateChannel(t.Context(), store.CreateChannelParams{
+			GuildID: &guildID, Type: store.ChannelText,
+			Name: "комната-" + strconv.Itoa(i), Position: i + 1,
+		}); err != nil {
+			t.Fatalf("комната %d: %v", i, err)
+		}
+	}
+
+	rec := doJSON(t, srv, http.MethodPost, "/api/v1/guild-templates",
+		`{"guild_id":"`+source+`","name":"Слишком большой"}`, owner)
+	if rec.Code != http.StatusUnprocessableEntity {
+		t.Fatalf("слишком большая структура = %d (%s)", rec.Code, rec.Body.String())
+	}
+	if code := errorCodeOf(t, rec); code != "validation.failed" {
+		t.Fatalf("код ошибки = %q, ожидался validation.failed", code)
+	}
+}
+
+// createGuildForTest создаёт сервер без шаблона и возвращает его id.
+func createGuildForTest(t *testing.T, srv *Server, user *http.Cookie, name string) string {
+	t.Helper()
+	rec := doJSON(t, srv, http.MethodPost, "/api/v1/guilds", `{"name":"`+name+`"}`, user)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("создание сервера %q = %d (%s)", name, rec.Code, rec.Body.String())
+	}
+	return decodeResponse[struct {
+		Guild struct {
+			ID string `json:"id"`
+		} `json:"guild"`
+	}](t, rec).Guild.ID
+}
+
+// createChannelForTest создаёт комнату и возвращает её id.
+func createChannelForTest(t *testing.T, srv *Server, user *http.Cookie, guildID, body string) string {
+	t.Helper()
+	rec := doJSON(t, srv, http.MethodPost, "/api/v1/guilds/"+guildID+"/channels", body, user)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("создание комнаты = %d (%s)", rec.Code, rec.Body.String())
+	}
+	return decodeResponse[struct {
+		Channel struct {
+			ID string `json:"id"`
+		} `json:"channel"`
+	}](t, rec).Channel.ID
+}