diff --git a/assets/users/user_CV/Mont-Bold.ttf b/assets/users/user_CV/Mont-Bold.ttf
new file mode 100644
index 00000000..4952bac4
Binary files /dev/null and b/assets/users/user_CV/Mont-Bold.ttf differ
diff --git a/assets/users/user_CV/Mont-Light.ttf b/assets/users/user_CV/Mont-Light.ttf
new file mode 100644
index 00000000..86bfb258
Binary files /dev/null and b/assets/users/user_CV/Mont-Light.ttf differ
diff --git a/docker-compose.dev-ci.yml b/docker-compose.dev-ci.yml
index 77de9869..1058d9cd 100644
--- a/docker-compose.dev-ci.yml
+++ b/docker-compose.dev-ci.yml
@@ -14,6 +14,8 @@ services:
     environment:
       HOST: 0.0.0.0
       EXPERT_WORKSPACE_FRONTEND_URL: https://dev.procollab.ru
+      PROGRAM_SOLUTIONS_ENABLED: ${PROGRAM_SOLUTIONS_ENABLED:-false}
+      PROJECT_DEFAULT_PACK_URL: https://dev.procollab.ru/assets/project-defaults
     ports:
       - "127.0.0.1:8000:8000" 
 
@@ -34,6 +36,7 @@ services:
       - .env
     environment:
       EXPERT_WORKSPACE_FRONTEND_URL: https://dev.procollab.ru
+      PROGRAM_SOLUTIONS_ENABLED: ${PROGRAM_SOLUTIONS_ENABLED:-false}
     command: bash ./scripts/celery.sh
     depends_on:
       - redis
diff --git a/partner_programs/admin.py b/partner_programs/admin.py
index 11ace654..77633333 100644
--- a/partner_programs/admin.py
+++ b/partner_programs/admin.py
@@ -30,6 +30,7 @@
 from partner_programs.services.case_fields import case_field_has_values
 from partner_programs.admin_registration import ProgramRegistrationAdminMixin
 from partner_programs.admin_publication import ProgramPublicationAdminMixin
+from partner_programs.admin_certificate_fonts import ProgramCertificateFontsAdminMixin
 from partner_programs.program_dates import (
     DATE_FIELDS,
     program_date_errors,
@@ -53,7 +54,10 @@ class PartnerProgramFieldInline(admin.TabularInline):
 
 @admin.register(PartnerProgram)
 class PartnerProgramAdmin(
-    ProgramPublicationAdminMixin, ProgramRegistrationAdminMixin, admin.ModelAdmin
+    ProgramPublicationAdminMixin,
+    ProgramRegistrationAdminMixin,
+    ProgramCertificateFontsAdminMixin,
+    admin.ModelAdmin,
 ):
     class PartnerProgramAdminForm(forms.ModelForm):
         confirm_reopen = forms.BooleanField(
@@ -130,6 +134,7 @@ class Meta:
                     "is_competitive",
                     "legacy_team_min_size",
                     "legacy_team_max_size",
+                    "project_sections",
                     "projects_availability",
                     "publish_projects_after_finish",
                     "max_project_rates",
@@ -398,13 +403,18 @@ def get_deleted_objects(self, objs, request):
             objs, request
         )
         for obj in objs:
+            from partner_programs.project_form import protected_project_field
             from partner_programs.solution_forms import answer_count
 
-            if case_field_has_values(obj) or (
-                obj.partner_program.solution_storage_mode == "solution"
-                and answer_count(obj)
+            if (
+                protected_project_field(obj)
+                or case_field_has_values(obj)
+                or (
+                    obj.partner_program.solution_storage_mode == "solution"
+                    and answer_count(obj)
+                )
             ):
-                protected.append(f"Используемое поле кейса: {obj}")
+                protected.append(f"Стандартное поле или поле с ответами: {obj}")
         return deleted, counts, permissions_needed, protected
 
     list_display = (
@@ -414,6 +424,7 @@ def get_deleted_objects(self, objs, request):
         "label",
         "field_type",
         "is_required",
+        "is_visible",
         "show_filter",
     )
     list_filter = ("partner_program",)
diff --git a/partner_programs/admin_certificate_fonts.py b/partner_programs/admin_certificate_fonts.py
new file mode 100644
index 00000000..be039f86
--- /dev/null
+++ b/partner_programs/admin_certificate_fonts.py
@@ -0,0 +1,122 @@
+from copy import deepcopy
+
+from django import forms
+from django.contrib import messages
+from django.core.exceptions import PermissionDenied
+from django.db import transaction
+from django.shortcuts import get_object_or_404, redirect
+from django.template.response import TemplateResponse
+from django.urls import path, reverse
+from rest_framework.exceptions import ValidationError
+
+from partner_programs.certificate_models import (
+    ProgramCertificateAsset,
+    ProgramCertificateConfig,
+)
+from partner_programs.services import certificates
+
+
+class CertificateFontsForm(forms.Form):
+    element = forms.ChoiceField(
+        label="Текстовый элемент",
+        choices=[
+            ("name", "Имя участника"),
+            ("title", "Заголовок"),
+            ("subtitle", "Подзаголовок"),
+            ("program", "Название программы"),
+            ("date", "Дата выдачи"),
+            ("number", "Номер сертификата"),
+            ("director", "Имя директора"),
+            ("position", "Должность"),
+        ],
+    )
+    font = forms.ChoiceField(label="Шрифт")
+    upload = forms.FileField(
+        label="Загрузить шрифт для выбранного элемента",
+        required=False,
+        widget=forms.ClearableFileInput(attrs={"accept": ".ttf,.otf"}),
+        help_text="TTF или OTF до 2 МБ.",
+    )
+    revision = forms.IntegerField(widget=forms.HiddenInput())
+
+    def __init__(self, *args, program, config, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.fields["revision"].initial = config.revision
+        self.fields["font"].choices = [
+            ("mont", "Mont"),
+            ("mont-regular", "Mont Regular"),
+            ("mont-light", "Mont Light"),
+            ("mont-bold", "Mont Bold"),
+            ("pt-serif", "PT Serif"),
+            ("lobster", "Lobster"),
+            *[
+                (f"custom-{pk}", name)
+                for pk, name in ProgramCertificateAsset.objects.filter(
+                    program=program, kind="font"
+                ).values_list("pk", "name")
+            ],
+        ]
+        self.fields["font"].initial = config.draft["layout"]["name"].get(
+            "font_family", "mont"
+        )
+
+
+class ProgramCertificateFontsAdminMixin:
+    def get_urls(self):
+        return [
+            path(
+                "<int:object_id>/certificate-fonts/",
+                self.admin_site.admin_view(self.certificate_fonts),
+                name="partner_programs_partnerprogram_certificate_fonts",
+            ),
+            *super().get_urls(),
+        ]
+
+    def certificate_fonts(self, request, object_id):
+        program = get_object_or_404(self.get_queryset(request), pk=object_id)
+        if not self.has_change_permission(request, program):
+            raise PermissionDenied
+        config = certificates.config_for(program)
+        form = CertificateFontsForm(
+            request.POST or None, request.FILES or None, program=program, config=config
+        )
+        if request.method == "POST" and form.is_valid():
+            try:
+                with transaction.atomic():
+                    type(program).objects.select_for_update().get(pk=program.pk)
+                    current = ProgramCertificateConfig.objects.select_for_update().get(
+                        pk=config.pk
+                    )
+                    data = form.cleaned_data
+                    if current.revision != data["revision"]:
+                        raise ValidationError("Шаблон уже изменен. Обновите страницу.")
+                    font = data["font"]
+                    if data["upload"]:
+                        font = f"custom-{certificates.upload_font(program, data['upload']).pk}"
+                    draft = deepcopy(current.draft)
+                    draft["layout"][data["element"]]["font_family"] = font
+                    current.draft = certificates.validate_draft(
+                        program, draft, current.draft
+                    )
+                    current.revision += 1
+                    current.save(update_fields=["draft", "revision"])
+            except ValidationError as error:
+                form.add_error(None, " ".join(map(str, error.detail)))
+            else:
+                self.message_user(request, "Шрифт элемента сохранен.", messages.SUCCESS)
+                return redirect(
+                    "admin:partner_programs_partnerprogram_certificate_fonts", object_id
+                )
+        return TemplateResponse(
+            request,
+            "partner_programs/admin/certificate_fonts.html",
+            {
+                **self.admin_site.each_context(request),
+                "title": "Шрифты сертификата",
+                "program": program,
+                "form": form,
+                "change_url": reverse(
+                    "admin:partner_programs_partnerprogram_change", args=[object_id]
+                ),
+            },
+        )
diff --git a/partner_programs/attention_views.py b/partner_programs/attention_views.py
index b2c38b8e..29014d4c 100644
--- a/partner_programs/attention_views.py
+++ b/partner_programs/attention_views.py
@@ -36,7 +36,13 @@ def post(self, request, pk, category, action):
         if action == "reminders":
             response = Response(
                 confirm_reminder(
-                    program, category, request.user, serializer.validated_data["token"]
+                    program,
+                    category,
+                    request.user,
+                    serializer.validated_data["token"],
+                    excluded_recipient_ids=serializer.validated_data[
+                        "excluded_recipient_ids"
+                    ],
                 )
             )
         elif action == "reminder-preview":
diff --git a/partner_programs/certificate_views.py b/partner_programs/certificate_views.py
index 9510cd01..5d65b3a0 100644
--- a/partner_programs/certificate_views.py
+++ b/partner_programs/certificate_views.py
@@ -72,7 +72,8 @@ def post(self, request, pk):
     def get(self, request, pk, asset_id):
         program = managed_program(pk, request.user)
         asset = get_object_or_404(ProgramCertificateAsset, pk=asset_id, program=program)
-        response = HttpResponse(bytes(asset.content), content_type="image/png")
+        content_type = "font/sfnt" if asset.kind == "font" else "image/png"
+        response = HttpResponse(bytes(asset.content), content_type=content_type)
         response["Cache-Control"] = "private, no-store"
         response["X-Content-Type-Options"] = "nosniff"
         return response
@@ -93,6 +94,7 @@ def post(self, request, pk):
             program.name,
             "ПРОБНЫЙ",
             timezone.localtime(),
+            program_id=program.pk,
         )
         return pdf_response(content, "certificate-preview")
 
@@ -384,6 +386,7 @@ def current_certificate_pdf(program, config, row, public_base_url):
             program.name,
             str(row.pk).upper(),
             timezone.localtime(row.created_at),
+            program_id=program.pk,
         )
         row.batch = service.manual_batch(program, draft, public_base_url, "refresh")
         row.rendered_batch = row.batch
@@ -430,13 +433,21 @@ def post(self, request, pk):
 
         program = managed_program(pk, request.user, lock=True)
         config = service.config_for(program)
-        revision_check(config, request.data)
         rows = (
             selected_rows(program, request.data)
             .select_for_update(of=("self",))
             .select_related("batch", "rendered_batch", "program")
             .defer(None)
         )
+        published_only = serializers.BooleanField(default=False).run_validation(
+            request.data.get("published_only", False)
+        )
+        if not published_only:
+            revision_check(config, request.data)
+        if published_only and rows.filter(pdf__isnull=True).exists():
+            raise ValidationError(
+                "Сначала подготовьте PDF для всех выбранных участников."
+            )
         if rows.filter(status__in=["pending", "generating", "sending"]).exists():
             raise ValidationError(
                 "Дождитесь завершения обработки выбранных сертификатов."
@@ -444,11 +455,19 @@ def post(self, request, pk):
         output = tempfile.SpooledTemporaryFile(max_size=8 * 1024 * 1024)
         try:
             with zipfile.ZipFile(output, "w", zipfile.ZIP_DEFLATED) as archive:
+                names = set()
                 for row in rows.iterator(chunk_size=20):
-                    content = current_certificate_pdf(
-                        program, config, row, request.build_absolute_uri("/").rstrip("/")
+                    content = (
+                        bytes(row.pdf)
+                        if published_only
+                        else current_certificate_pdf(
+                            program,
+                            config,
+                            row,
+                            request.build_absolute_uri("/").rstrip("/"),
+                        )
                     )
-                    archive.writestr(f"certificate-{row.pk}.pdf", content)
+                    archive.writestr(certificate_archive_name(row.name, names), content)
             output.seek(0)
         except Exception:
             output.close()
@@ -466,16 +485,39 @@ def get(self, request, pk):
 
         output = tempfile.SpooledTemporaryFile(max_size=8 * 1024 * 1024)
         with zipfile.ZipFile(output, "w", zipfile.ZIP_DEFLATED) as archive:
+            names = set()
             for row in (
-                rows.filter(pdf__isnull=False).only("pk", "pdf").iterator(chunk_size=50)
+                rows.filter(pdf__isnull=False)
+                .only("pk", "name", "pdf")
+                .iterator(chunk_size=50)
             ):
-                archive.writestr(f"certificate-{row.pk}.pdf", bytes(row.pdf))
+                archive.writestr(
+                    certificate_archive_name(row.name, names), bytes(row.pdf)
+                )
         output.seek(0)
         response = FileResponse(output, as_attachment=True, filename="certificates.zip")
         response["Cache-Control"] = "private, no-store"
         return response
 
 
+def certificate_archive_name(name, used):
+    import re
+    from pathlib import PureWindowsPath
+    from unicodedata import normalize
+
+    stem = re.sub(r'[\\/:*?"<>|\x00-\x1f\x7f]', "_", normalize("NFC", name))
+    stem = stem[:120].strip(" .") or "Сертификат"
+    if PureWindowsPath(stem).is_reserved():
+        stem = "Сертификат " + stem
+    filename = stem + ".pdf"
+    suffix = 2
+    while filename.casefold() in used:
+        filename = f"{stem} ({suffix}).pdf"
+        suffix += 1
+    used.add(filename.casefold())
+    return filename
+
+
 class MyCertificatesView(ManagementBase):
     def get(self, request, pk):
         rows = ProgramCertificate.objects.filter(
diff --git a/partner_programs/forms.py b/partner_programs/forms.py
index 0a40a95c..012f6c24 100644
--- a/partner_programs/forms.py
+++ b/partner_programs/forms.py
@@ -4,6 +4,7 @@
 from django.forms.models import BaseInlineFormSet
 
 from partner_programs.services.case_fields import case_field_has_values
+from partner_programs.project_form import protected_project_field
 from partner_programs.services.field_values import (
     FIELD_VALUES_FROZEN_MESSAGE,
     program_field_values_are_frozen,
@@ -18,14 +19,20 @@ def clean(self):
         for form in self.deleted_forms:
             from partner_programs.solution_forms import answer_count
 
-            if case_field_has_values(form.instance) or (
-                form.instance.pk
-                and form.instance.partner_program.solution_storage_mode == "solution"
-                and answer_count(form.instance)
+            field = form.instance
+            if not field.pk:
+                continue
+            if case_field_has_values(field) or (
+                field.partner_program.solution_storage_mode == "solution"
+                and answer_count(field)
             ):
                 raise ValidationError(
                     "Нельзя удалить системное поле с выбранными кейсами."
                 )
+            if protected_project_field(field):
+                raise ValidationError(
+                    "Стандартное поле или поле с ответами можно скрыть."
+                )
 
 
 class ProgramFieldValueInlineFormSet(BaseInlineFormSet):
diff --git a/partner_programs/migrations/0043_project_copy_form.py b/partner_programs/migrations/0043_project_copy_form.py
new file mode 100644
index 00000000..4aef70f5
--- /dev/null
+++ b/partner_programs/migrations/0043_project_copy_form.py
@@ -0,0 +1,45 @@
+# Generated by Django 5.2.18 on 2026-11-08 14:32
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("partner_programs", "0042_partnerprogram_tag_optional"),
+        ("projects", "0035_interface_copy"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="partnerprogram",
+            name="project_sections",
+            field=models.JSONField(
+                blank=True, default=dict, verbose_name="Разделы проекта в программе"
+            ),
+        ),
+        migrations.AddField(
+            model_name="partnerprogramfield",
+            name="is_visible",
+            field=models.BooleanField(default=True, verbose_name="Показывать в форме"),
+        ),
+        migrations.AddField(
+            model_name="partnerprogramproject",
+            name="source_project",
+            field=models.ForeignKey(
+                blank=True,
+                editable=False,
+                null=True,
+                on_delete=django.db.models.deletion.SET_NULL,
+                related_name="program_copies",
+                to="projects.project",
+                verbose_name="Исходный проект",
+            ),
+        ),
+        migrations.AddField(
+            model_name="partnerprogramproject",
+            name="submitted_form",
+            field=models.JSONField(blank=True, editable=False, null=True),
+        ),
+    ]
diff --git a/partner_programs/models.py b/partner_programs/models.py
index d055a1fd..19f1df93 100644
--- a/partner_programs/models.py
+++ b/partner_programs/models.py
@@ -149,6 +149,9 @@ class PartnerProgram(models.Model):
         verbose_name="Максимум участников legacy-команды",
         help_text="NULL — без максимума. Ожидающие приглашения резервируют места.",
     )
+    project_sections = models.JSONField(
+        default=dict, blank=True, verbose_name="Разделы проекта в программе"
+    )
     city = models.TextField(
         verbose_name="Город",
     )
@@ -298,6 +301,17 @@ class PartnerProgram(models.Model):
     def clean(self):
         super().clean()
         self.validate_solution_template_change()
+        from partner_programs.project_form import PROJECT_SECTIONS
+
+        if not isinstance(self.project_sections, dict) or any(
+            key not in PROJECT_SECTIONS or not isinstance(value, bool)
+            for key, value in self.project_sections.items()
+        ):
+            raise ValidationError(
+                {
+                    "project_sections": "Укажите доступные разделы и значения true или false."
+                }
+            )
         for field in ("legacy_team_min_size", "legacy_team_max_size"):
             value = getattr(self, field)
             if value is not None and value < 1:
@@ -518,6 +532,16 @@ class PartnerProgramProject(models.Model):
     project = models.ForeignKey(
         Project, on_delete=models.CASCADE, related_name="program_links"
     )
+    source_project = models.ForeignKey(
+        Project,
+        null=True,
+        blank=True,
+        editable=False,
+        on_delete=models.SET_NULL,
+        related_name="program_copies",
+        verbose_name="Исходный проект",
+    )
+    submitted_form = models.JSONField(null=True, blank=True, editable=False)
     datetime_created = models.DateTimeField(auto_now_add=True)
     datetime_updated = models.DateTimeField(auto_now=True)
     submitted = models.BooleanField(default=False, verbose_name="Проект сдан")
@@ -584,6 +608,17 @@ def save(self, *args, **kwargs):
         self.project = context.project
         self.partner_program = context.programs[self.partner_program_id]
         self.clean()
+        fields = kwargs.get("update_fields")
+        if (
+            self.submitted
+            and self.submitted_form is None
+            and (fields is None or "submitted" in fields)
+        ):
+            from partner_programs.services.project_fields import form_snapshot
+
+            self.submitted_form = form_snapshot(self)
+            if fields is not None:
+                kwargs["update_fields"] = {*fields, "submitted_form"}
         return super().save(*args, **kwargs)
 
     @transaction.atomic
@@ -638,6 +673,7 @@ class PartnerProgramField(models.Model):
     label = models.CharField(max_length=256, verbose_name="Отображаемое название")
     field_type = models.CharField(max_length=20, choices=FIELD_TYPES)
     is_required = models.BooleanField(default=False)
+    is_visible = models.BooleanField(default=True, verbose_name="Показывать в форме")
     purpose = models.CharField(max_length=24, default="other")
     position = models.PositiveIntegerField(default=0)
     validation = models.JSONField(default=dict, blank=True)
diff --git a/partner_programs/permissions.py b/partner_programs/permissions.py
index 46005509..2e0ccc4c 100644
--- a/partner_programs/permissions.py
+++ b/partner_programs/permissions.py
@@ -1,5 +1,6 @@
 from functools import wraps
 
+from django.conf import settings
 from rest_framework.exceptions import NotFound, PermissionDenied
 from rest_framework.permissions import BasePermission, SAFE_METHODS
 
@@ -10,9 +11,7 @@
 
 def can_create_program(user) -> bool:
     return bool(
-        user
-        and user.is_authenticated
-        and user.has_perm(PROGRAM_CREATION_PERMISSION)
+        user and user.is_authenticated and user.has_perm(PROGRAM_CREATION_PERMISSION)
     )
 
 
@@ -27,6 +26,19 @@ def has_permission(self, request, view):
         return True
 
 
+def active_programs(queryset):
+    if not settings.PROGRAM_SOLUTIONS_ENABLED:
+        return queryset.exclude(solution_storage_mode="solution")
+    return queryset
+
+
+class SolutionFlowEnabled(BasePermission):
+    def has_permission(self, request, view):
+        if not settings.PROGRAM_SOLUTIONS_ENABLED:
+            raise NotFound()
+        return True
+
+
 class ProgramDraftVisibility(BasePermission):
     """One boundary for every program route, after DRF authentication."""
 
@@ -46,6 +58,15 @@ def has_permission(self, request, view):
             program = PartnerProgram.objects.filter(pk=pk).first() if pk else None
         # Reuse this read in read-only views, never for transactional writes.
         view.visibility_program = program
+        if (
+            program
+            and program.solution_storage_mode == "solution"
+            and not settings.PROGRAM_SOLUTIONS_ENABLED
+        ):
+            setattr(
+                getattr(request, "_request", request), "_program_draft_response", True
+            )
+            raise NotFound()
         if program is None or not program.draft:
             return True
         setattr(getattr(request, "_request", request), "_program_draft_response", True)
diff --git a/partner_programs/program_launch_views.py b/partner_programs/program_launch_views.py
index 8a0a33de..5b2c4ac1 100644
--- a/partner_programs/program_launch_views.py
+++ b/partner_programs/program_launch_views.py
@@ -6,7 +6,11 @@
 from partner_programs.management_views import ManagementBase
 from partner_programs.models import PartnerProgram
 from partner_programs.pagination import ProgramAttentionPagination
-from partner_programs.permissions import can_create_program, require_create_program
+from partner_programs.permissions import (
+    active_programs,
+    can_create_program,
+    require_create_program,
+)
 from partner_programs.serializers.management import StrictFieldsMixin
 from partner_programs.services import program_launch as service
 from partner_programs.services.management import management_data
@@ -42,7 +46,7 @@ class ManagedProgramsView(ManagementBase):
     def get(self, request):
         form = ManagedProgramsQuery(data=request.query_params)
         form.is_valid(raise_exception=True)
-        rows = PartnerProgram.objects.all()
+        rows = active_programs(PartnerProgram.objects.all())
         if not (request.user.is_staff or request.user.is_superuser):
             rows = rows.filter(managers=request.user)
         if form.validated_data["search"]:
diff --git a/partner_programs/project_form.py b/partner_programs/project_form.py
new file mode 100644
index 00000000..89620198
--- /dev/null
+++ b/partner_programs/project_form.py
@@ -0,0 +1,32 @@
+"""The form of a Project copy belongs to its program."""
+
+from partner_programs.constants import PROGRAM_CASE_FIELD_NAME
+
+PROJECT_SECTIONS = ("partners", "achievements", "vacancies", "program_data")
+PROJECT_FIELDS = {
+    "project_description": "description",
+    "project_presentation": "presentation_address",
+}
+
+
+def project_sections(program):
+    return {key: program.project_sections.get(key, True) for key in PROJECT_SECTIONS}
+
+
+def visible_project_fields(program):
+    fields = program.fields.filter(is_visible=True).order_by("pk")
+    if not project_sections(program)["program_data"]:
+        fields = fields.filter(name__in=(PROGRAM_CASE_FIELD_NAME, "project_description"))
+    return fields
+
+
+def field_value(link, field, values):
+    attribute = PROJECT_FIELDS.get(field.name)
+    return getattr(link.project, attribute) if attribute else values.get(field.pk)
+
+
+def protected_project_field(field):
+    return (
+        field.name in PROJECT_FIELDS
+        or field.values.filter(value_text__regex=r"\S").exists()
+    )
diff --git a/partner_programs/serializers/attention.py b/partner_programs/serializers/attention.py
index 1a80d5f3..86b9bd00 100644
--- a/partner_programs/serializers/attention.py
+++ b/partner_programs/serializers/attention.py
@@ -100,6 +100,10 @@ class ProgramAttentionProjectSerializer(serializers.Serializer):
     reason_label = serializers.SerializerMethodField()
     assignments_total = serializers.IntegerField(allow_null=True)
     assignments_completed = serializers.IntegerField(allow_null=True)
+    experts = serializers.SerializerMethodField()
+
+    def get_experts(self, link):
+        return self.context.get("experts_by_project", {}).get(link.project.id, [])
 
     def get_reason(self, link):
         """Причина следует из общего статуса и реальных назначений, не из лимита."""
diff --git a/partner_programs/serializers/attention_actions.py b/partner_programs/serializers/attention_actions.py
index 32c0600d..c052e861 100644
--- a/partner_programs/serializers/attention_actions.py
+++ b/partner_programs/serializers/attention_actions.py
@@ -40,3 +40,8 @@ class AttentionActionSerializer(serializers.Serializer):
 
 class AttentionConfirmationSerializer(serializers.Serializer):
     token = serializers.CharField(max_length=1000000)
+    excluded_recipient_ids = serializers.ListField(
+        child=serializers.IntegerField(min_value=1),
+        max_length=MAX_SELECTION,
+        default=list,
+    )
diff --git a/partner_programs/serializers/fields.py b/partner_programs/serializers/fields.py
index 35d67041..aac69a5c 100644
--- a/partner_programs/serializers/fields.py
+++ b/partner_programs/serializers/fields.py
@@ -51,6 +51,7 @@ def _get_validator(self, field: PartnerProgramField):
             "select": self._validate_select,
             "radio": self._validate_radio,
             "file": self._validate_file,
+            "url": self._validate_file,
         }
         try:
             return validators[field.field_type]
diff --git a/partner_programs/services/attention_actions.py b/partner_programs/services/attention_actions.py
index 46e5f721..35076b69 100644
--- a/partner_programs/services/attention_actions.py
+++ b/partner_programs/services/attention_actions.py
@@ -193,19 +193,25 @@ def preview_reminder(program, category, actor, payload):
         if available
         else None
     )
+    recipients = []
+    for target in available[:20] if category == SOLUTION_AWAITING else available:
+        user = users[target["user_id"]]
+        recipient = {"user_id": user.pk, "full_name": person_name(user)}
+        if category != SOLUTION_AWAITING:
+            recipient.update(email=user.email, avatar=user.avatar)
+        recipients.append(recipient)
     return {
         "token": token,
         "selected_count": len(rows),
         "recipient_count": len(available),
-        "without_assignments_count": len(rows) - len(assigned_sources)
-        if category in ("projects-awaiting-evaluation", SOLUTION_AWAITING)
-        else 0,
+        "without_assignments_count": (
+            len(rows) - len(assigned_sources)
+            if category in ("projects-awaiting-evaluation", SOLUTION_AWAITING)
+            else 0
+        ),
         "unavailable_count": len(targets) - len(available),
         "preview_text": preview_text,
-        "recipients": [
-            {"user_id": t["user_id"], "full_name": person_name(users[t["user_id"]])}
-            for t in available[:20]
-        ],
+        "recipients": recipients,
         "expires_in": PREVIEW_TTL,
     }
 
@@ -254,7 +260,7 @@ def fresh_targets(program, category, ids, snapshot):
     return rows, result
 
 
-def confirm_reminder(program, category, actor, token):
+def confirm_reminder(program, category, actor, token, *, excluded_recipient_ids=()):
     try:
         data = signing.loads(token, salt=SALT, max_age=PREVIEW_TTL)
     except signing.BadSignature:
@@ -269,6 +275,12 @@ def confirm_reminder(program, category, actor, token):
         raise ValidationError(
             {"detail": "Предпросмотр относится к другому списку или пользователю."}
         )
+    excluded = set(excluded_recipient_ids)
+    if excluded - {target["user_id"] for target in data["targets"]}:
+        raise ValidationError({"detail": "Получатель не входит в список напоминаний."})
+    snapshot = [target for target in data["targets"] if target["user_id"] not in excluded]
+    if not snapshot:
+        raise ValidationError({"detail": "Оставьте хотя бы одного получателя."})
     with transaction.atomic():
         # Serialize confirmations for the same program; token UUID is the durable
         # idempotency key, including when the client loses the HTTP response.
@@ -278,16 +290,14 @@ def confirm_reminder(program, category, actor, token):
         ).first()
         if existing:
             return existing.result
-        rows, targets = fresh_targets(
-            program, category, data["source_ids"], data["targets"]
-        )
+        rows, targets = fresh_targets(program, category, data["source_ids"], snapshot)
         users = CustomUser.objects.in_bulk([t["user_id"] for t in targets])
         targets = [
             t for t in targets if users.get(t["user_id"]) and users[t["user_id"]].email
         ]
         result = {
             "created_count": len(targets),
-            "skipped_count": len(data["targets"]) - len(targets),
+            "skipped_count": len(snapshot) - len(targets),
         }
         batch = ProgramAttentionReminderBatch.objects.create(
             id=data["request_id"],
diff --git a/partner_programs/services/case_fields.py b/partner_programs/services/case_fields.py
index e533ef06..562aad50 100644
--- a/partner_programs/services/case_fields.py
+++ b/partner_programs/services/case_fields.py
@@ -49,6 +49,8 @@ def validate_program_case_configuration(field):
         errors["field_type"] = "Системный кейс должен быть полем select."
     if not field.is_required:
         errors["is_required"] = "Кейс обязателен перед сдачей проекта."
+    if not field.is_visible:
+        errors["is_visible"] = "Кейс должен быть доступен в форме сдачи."
     if not field.show_filter:
         errors["show_filter"] = "Системный кейс должен быть доступен для фильтрации."
     options = (
@@ -64,9 +66,9 @@ def validate_program_case_configuration(field):
         errors["options"] = "Укажите хотя бы один кейс без пустых вариантов."
         options = []
     elif len({value.strip().casefold() for value in options}) != len(options):
-        errors[
-            "options"
-        ] = "Варианты кейсов не должны повторяться (без учета регистра и внешних пробелов)."
+        errors["options"] = (
+            "Варианты кейсов не должны повторяться (без учета регистра и внешних пробелов)."
+        )
     if field.pk:
         used = set(field.values.values_list("value_text", flat=True).distinct())
         if used - set(options):
@@ -89,6 +91,14 @@ def validate_case_before_submission(program_project, *, for_update=True):
     """Lock config inside the caller's transaction; validate this link only."""
     field = get_program_case_field(program_project.partner_program, for_update=for_update)
     if field is None:
+        program = program_project.partner_program
+        if program.is_competitive and program.program_format in (
+            "case_championship",
+            "hackathon",
+        ):
+            raise ValidationError(
+                "Организатор еще не настроил кейсы или треки программы."
+            )
         return
     value = (
         program_project.field_values.filter(field=field)
diff --git a/partner_programs/services/certificates.py b/partner_programs/services/certificates.py
index 16e9754a..5690c933 100644
--- a/partner_programs/services/certificates.py
+++ b/partner_programs/services/certificates.py
@@ -29,6 +29,14 @@
 logger = logging.getLogger(__name__)
 CERTIFICATE_FONTS = {
     "mont": ("Mont", "Mont-Regular.ttf", "Mont-SemiBold.ttf", 600),
+    "mont-regular": (
+        "Certificate Mont Regular",
+        "Mont-Regular.ttf",
+        "Mont-Regular.ttf",
+        400,
+    ),
+    "mont-light": ("Certificate Mont Light", "Mont-Light.ttf", "Mont-Light.ttf", 400),
+    "mont-bold": ("Certificate Mont Bold", "Mont-Bold.ttf", "Mont-Bold.ttf", 400),
     "pt-serif": ("Certificate PT Serif", "PTSerif-Regular.ttf", "PTSerif-Bold.ttf", 700),
     "lobster": ("Certificate Lobster", "Lobster-Regular.ttf", "Lobster-Regular.ttf", 400),
 }
@@ -175,6 +183,20 @@ def assets_for(program, draft):
     return result
 
 
+def uploaded_fonts(program_id, draft):
+    keys = {box.get("font_family", "") for box in draft["layout"].values()}
+    ids = {int(key.removeprefix("custom-")) for key in keys if key.startswith("custom-")}
+    if not ids:
+        return {}
+    rows = ProgramCertificateAsset.objects.filter(
+        program_id=program_id, kind="font", pk__in=ids
+    )
+    fonts = {f"custom-{asset.pk}": asset for asset in rows}
+    if len(fonts) != len(ids):
+        raise ValidationError("Шрифт не найден в этой программе.")
+    return fonts
+
+
 def state(program):
     config = config_for(program)
     batch = (
@@ -186,6 +208,14 @@ def state(program):
     return {
         "revision": config.revision,
         "draft": normalized_draft(config.draft),
+        "fonts": [
+            asset_data(asset)
+            for asset in ProgramCertificateAsset.objects.filter(
+                program=program, kind="font"
+            )
+            .defer("content")
+            .order_by("pk")
+        ],
         "assets": {
             key: asset_data(value)
             for key, value in assets_for(program, config.draft).items()
@@ -193,14 +223,16 @@ def state(program):
         "eligible_counts": {
             a: recipient_users(program, a).count() for a in ("all", "submitted")
         },
-        "batch": {
-            "id": batch.pk,
-            "active": batch.active,
-            "issue_at": batch.issue_at,
-            "initialized_at": batch.initialized_at,
-        }
-        if batch
-        else None,
+        "batch": (
+            {
+                "id": batch.pk,
+                "active": batch.active,
+                "issue_at": batch.issue_at,
+                "initialized_at": batch.initialized_at,
+            }
+            if batch
+            else None
+        ),
     }
 
 
@@ -255,6 +287,8 @@ def manual_batch(program, draft, public_base_url, action):
 
 
 def upload_asset(program, kind, upload):
+    if kind == "font":
+        return upload_font(program, upload)
     if kind not in ("background", "signature") or not upload:
         raise ValidationError("Выберите фон или подпись и файл.")
     if upload.size > 10 * 1024 * 1024:
@@ -298,6 +332,33 @@ def upload_asset(program, kind, upload):
     )
 
 
+@transaction.atomic
+def upload_font(program, upload):
+    if not upload or upload.size > 2 * 1024 * 1024:
+        raise ValidationError("Выберите файл шрифта TTF или OTF размером до 2 МБ.")
+    name = Path(upload.name).name[:255]
+    content = upload.read()
+    try:
+        if (Path(name).suffix.lower(), content[:4]) not in (
+            (".ttf", b"\x00\x01\x00\x00"),
+            (".otf", b"OTTO"),
+        ):
+            raise ValueError()
+        font = ImageFont.truetype(io.BytesIO(content), 40)
+        font.getlength("Имя участника")
+    except (OSError, ValueError) as error:
+        raise ValidationError(
+            "Не удалось прочитать шрифт. Загрузите файл TTF или OTF."
+        ) from error
+    type(program).objects.select_for_update().get(pk=program.pk)
+    fonts = ProgramCertificateAsset.objects.filter(program=program, kind="font")
+    if fonts.count() >= 24:
+        raise ValidationError("Можно загрузить до 24 шрифтов на программу.")
+    return fonts.create(
+        program=program, kind="font", name=name, content=content, width=0, height=0
+    )
+
+
 def validate_draft(program, draft, previous=None):
     """The API owns allowed geometry and substitutions, not arbitrary HTML/CSS."""
     from rest_framework import serializers
@@ -308,8 +369,9 @@ class Element(serializers.Serializer):
         width = serializers.FloatField(min_value=2, max_value=100)
         height = serializers.FloatField(min_value=1, max_value=100)
         font_size = serializers.FloatField(min_value=8, max_value=72)
-        font_family = serializers.ChoiceField(
-            choices=list(CERTIFICATE_FONTS), required=False
+        font_family = serializers.RegexField(
+            r"^(?:mont(?:-regular|-light|-bold)?|pt-serif|lobster|custom-[1-9][0-9]{0,17})\Z",
+            required=False,
         )
 
     class Draft(serializers.Serializer):
@@ -384,6 +446,7 @@ class Draft(serializers.Serializer):
                 "Доступные подстановки: {name}, {program}, {date}, {number}."
             )
     assets_for(program, data)
+    uploaded_fonts(program.pk, data)
     return normalized_draft(dict(data))
 
 
@@ -394,7 +457,9 @@ def certificate_font_key(box):
 
 def certificate_font_path(key, bold):
     filename = CERTIFICATE_FONTS[key][2 if bold else 1]
-    directory = "assets/users/user_CV" if key == "mont" else "assets/certificates/fonts"
+    directory = (
+        "assets/users/user_CV" if key.startswith("mont") else "assets/certificates/fonts"
+    )
     return Path(settings.BASE_DIR) / directory / filename
 
 
@@ -407,9 +472,10 @@ def page_dimensions(orientation="landscape"):
     return (210, 297) if orientation == "portrait" else (297, 210)
 
 
-def fit_certificate_text(value, box, bold=False, orientation="landscape"):
+def fit_certificate_text(value, box, bold=False, orientation="landscape", font=None):
     """Подгоняем реальные строки выбранного шрифта без обрезки ФИО."""
-    font = certificate_font(bold, certificate_font_key(box))
+    if font is None:
+        font = certificate_font(bold, certificate_font_key(box))
     page_width, page_height = (
         (793.7, 1122) if orientation == "portrait" else (1122, 793.7)
     )
@@ -451,16 +517,28 @@ def fits(text):
     return size, lines_at(size)
 
 
-def render_pdf(snapshot, assets, name, program_name, number, issued_at):
+def render_pdf(
+    snapshot, assets, name, program_name, number, issued_at, *, program_id=None
+):
     from weasyprint import HTML
     from weasyprint.text.fonts import FontConfiguration
     from weasyprint.urls import URLFetcher, URLFetcherResponse
 
     orientation = snapshot.get("orientation", "landscape")
     page_width, page_height = page_dimensions(orientation)
+    fonts = uploaded_fonts(program_id, snapshot)
+    custom_faces = {
+        key: ImageFont.truetype(io.BytesIO(bytes(asset.content)), 1000)
+        for key, asset in fonts.items()
+    }
 
     class CertificateURLFetcher(URLFetcher):
         def fetch(self, url, headers=None):
+            custom = fonts.get(url.removeprefix("certificate-font:"))
+            if custom and url.startswith("certificate-font:"):
+                return URLFetcherResponse(
+                    url, bytes(custom.content), {"Content-Type": "font/sfnt"}
+                )
             for key in CERTIFICATE_FONTS:
                 for bold, weight in ((False, "regular"), (True, "bold")):
                     if url == f"certificate-font:{key}:{weight}":
@@ -505,11 +583,17 @@ def src(asset):
                 )
         else:
             value = values[key]
-            family = certificate_font_key(box)
-            family_name, _, _, bold_weight = CERTIFICATE_FONTS[family]
-            weight = bold_weight if key in ("name", "title") else 400
+            custom_key = box.get("font_family")
+            custom_font = custom_faces.get(custom_key)
+            bold = key in ("name", "title")
+            if custom_font:
+                family_name, weight = custom_key, 400
+            else:
+                family = certificate_font_key(box)
+                family_name, _, _, bold_weight = CERTIFICATE_FONTS[family]
+                weight = bold_weight if bold else 400
             size, lines = fit_certificate_text(
-                value, box, key in ("name", "title"), orientation
+                value, box, bold, orientation, font=custom_font
             )
             content = "<br>".join(escape(line) for line in lines)
             elements.append(
@@ -518,6 +602,10 @@ def src(asset):
             )
     html = (
         '<html><head><meta charset="utf-8"><style>'
+        + "".join(
+            f"@font-face{{font-family:'{key}';src:url('certificate-font:{key}');font-weight:400}}"
+            for key in fonts
+        )
         + "".join(
             f"@font-face{{font-family:'{name}';src:url('certificate-font:{key}:regular');font-weight:400}}"
             + (
@@ -543,7 +631,9 @@ def src(asset):
         + "</div></body></html>"
     )
     fetcher = CertificateURLFetcher(allowed_protocols=("certificate-font", "data"))
-    return HTML(string=html, url_fetcher=fetcher).write_pdf(font_config=FontConfiguration())
+    return HTML(string=html, url_fetcher=fetcher).write_pdf(
+        font_config=FontConfiguration()
+    )
 
 
 def substitute(text, values):
@@ -668,6 +758,7 @@ def process(certificate_id):
                 batch.snapshot.get("program_name", row.program.name),
                 str(row.pk).upper(),
                 timezone.localtime(row.created_at),
+                program_id=batch.program_id,
             )
             ProgramCertificate.objects.filter(pk=row.pk).update(
                 pdf=row.pdf, rendered_batch_id=row.batch_id
diff --git a/partner_programs/services/management_form.py b/partner_programs/services/management_form.py
index b8026041..9dd9e3d6 100644
--- a/partner_programs/services/management_form.py
+++ b/partner_programs/services/management_form.py
@@ -11,10 +11,16 @@
 from rest_framework.exceptions import APIException, ValidationError
 
 from partner_programs.models import PartnerProgramField, PartnerProgramProject
+from partner_programs.project_form import (
+    PROJECT_FIELDS,
+    PROJECT_SECTIONS,
+    project_sections,
+    protected_project_field,
+)
 from partner_programs.serializers.management import StrictFieldsMixin
 from partner_programs.services.management import managed_program
 
-SUPPORTED_TYPES = ("text", "textarea", "select", "file")
+SUPPORTED_TYPES = ("text", "textarea", "select", "file", "url")
 
 
 class StaleProjectForm(APIException):
@@ -33,6 +39,7 @@ class FormFieldWrite(StrictFieldsMixin, serializers.Serializer):
         choices=[p[0] for p in PartnerProgramField.FIELD_TYPES]
     )
     is_required = serializers.BooleanField()
+    is_visible = serializers.BooleanField(required=False)
     help_text = serializers.CharField(
         required=False, allow_blank=True, default="", max_length=4000
     )
@@ -48,6 +55,14 @@ class ProjectFormWrite(StrictFieldsMixin, serializers.Serializer):
         child=serializers.CharField(max_length=1000), max_length=200
     )
     fields = FormFieldWrite(many=True)
+    sections = serializers.DictField(child=serializers.BooleanField(), required=False)
+    team_min_size = serializers.IntegerField(min_value=1, allow_null=True, required=False)
+    team_max_size = serializers.IntegerField(min_value=1, allow_null=True, required=False)
+
+    def validate_sections(self, value):
+        if set(value) - set(PROJECT_SECTIONS):
+            raise serializers.ValidationError("Выберите доступные разделы проекта.")
+        return value
 
     def validate_fields(self, value):
         if len(value) > 100:
@@ -79,6 +94,8 @@ def form_data(program):
             "label": f.label,
             "field_type": f.field_type,
             "is_required": f.is_required,
+            "is_visible": f.is_visible,
+            "standard": f.name in PROJECT_FIELDS,
             "help_text": f.help_text or "",
             "options": f.get_options_list(),
             "show_filter": f.show_filter,
@@ -109,6 +126,14 @@ def form_data(program):
         "has_projects": PartnerProgramProject.objects.filter(
             partner_program=program
         ).exists(),
+        "sections": project_sections(program),
+        "case_required": bool(case)
+        or program.program_format in ("case_championship", "hackathon"),
+        "case_label": (
+            "Задача или трек" if program.program_format == "hackathon" else "Кейс"
+        ),
+        "team_min_size": program.legacy_team_min_size,
+        "team_max_size": program.legacy_team_max_size,
         "cases": [
             {"name": option, "projects_count": case_counts.get(option, 0)}
             for option in (case.get_options_list() if case else [])
@@ -154,6 +179,15 @@ def save_form(program_id, user, payload):
     ):
         raise StaleProjectForm()
     cases = _options(data["cases"])
+    min_size = data.get("team_min_size", program.legacy_team_min_size)
+    max_size = data.get("team_max_size", program.legacy_team_max_size)
+    if min_size and max_size and min_size > max_size:
+        raise ValidationError(
+            {"team_max_size": "Максимум должен быть не меньше минимума."}
+        )
+    program.legacy_team_min_size = min_size
+    program.legacy_team_max_size = max_size
+    program.project_sections = {**program.project_sections, **data.get("sections", {})}
     generic = {f.pk: f for f in existing if f.name != "case"}
     case = next((f for f in existing if f.name == "case"), None)
     ids = {item["id"] for item in data["fields"] if item.get("id") is not None}
@@ -161,9 +195,9 @@ def save_form(program_id, user, payload):
         raise ValidationError({"fields": "Поле не относится к этой программе."})
     for pk, field in generic.items():
         if pk not in ids:
-            if field.values.filter(value_text__regex=r"\S").exists():
+            if protected_project_field(field):
                 raise ValidationError(
-                    {"fields": "Нельзя удалить поле с сохраненными ответами."}
+                    {"fields": "Стандартное поле или поле с ответами можно скрыть."}
                 )
             field.delete()
     for item in data["fields"]:
@@ -195,6 +229,12 @@ def save_form(program_id, user, payload):
                             "fields": "Нельзя удалить или переименовать использованный вариант ответа."
                         }
                     )
+        if (
+            field
+            and field.name in PROJECT_FIELDS
+            and field.field_type != item["field_type"]
+        ):
+            raise ValidationError({"fields": "Тип стандартного поля изменить нельзя."})
         if field and field.field_type not in SUPPORTED_TYPES:
             if (
                 item["field_type"] != field.field_type
@@ -213,6 +253,7 @@ def save_form(program_id, user, payload):
         field.label = item["label"]
         field.field_type = item["field_type"]
         field.is_required = item["is_required"]
+        field.is_visible = item.get("is_visible", field.is_visible)
         field.help_text = item["help_text"]
         field.options = "|".join(options)
         try:
@@ -237,11 +278,18 @@ def save_form(program_id, user, payload):
         PartnerProgramField.objects.create(
             partner_program=program,
             name="case",
-            label="Кейс",
+            label="Задача или трек" if program.program_format == "hackathon" else "Кейс",
             field_type="select",
             is_required=True,
             show_filter=True,
             options="|".join(cases),
         )
-    program.save(update_fields=["datetime_updated"])
+    program.save(
+        update_fields=[
+            "legacy_team_min_size",
+            "legacy_team_max_size",
+            "project_sections",
+            "datetime_updated",
+        ]
+    )
     return form_data(program)
diff --git a/partner_programs/services/management_project_actions.py b/partner_programs/services/management_project_actions.py
index ad983f77..e345350b 100644
--- a/partner_programs/services/management_project_actions.py
+++ b/partner_programs/services/management_project_actions.py
@@ -330,9 +330,24 @@ def apply_action(program_id, actor, data):
         ).delete()
     else:
         # Только этот endpoint разрешает сдачу после срока, после повторной валидации.
-        PartnerProgramProject.objects.filter(
-            partner_program=program, pk__in=data["ids"], submitted=False
-        ).update(submitted=True, datetime_submitted=now, datetime_updated=now)
+        from partner_programs.services.project_fields import form_snapshot
+
+        links = list(
+            PartnerProgramProject.objects.filter(
+                partner_program=program, pk__in=data["ids"], submitted=False
+            ).select_related("project", "partner_program")
+        )
+        for link in links:
+            link.submitted = True
+            link.datetime_submitted = link.datetime_updated = now
+            link.submitted_form = form_snapshot(link)
+        PartnerProgramProject.objects.bulk_update(
+            links,
+            ["submitted", "datetime_submitted", "datetime_updated", "submitted_form"],
+        )
+        Project.objects.filter(pk__in=[link.project_id for link in links]).update(
+            draft=False, datetime_updated=now
+        )
     logger.info(
         "Program project action program=%s actor=%s action=%s links=%s",
         program.pk,
diff --git a/partner_programs/services/program_launch.py b/partner_programs/services/program_launch.py
index aff23fa0..ec20b04b 100644
--- a/partner_programs/services/program_launch.py
+++ b/partner_programs/services/program_launch.py
@@ -5,6 +5,7 @@
 import copy
 from html import unescape
 
+from django.conf import settings
 from django.contrib.auth import get_user_model
 from django.db import transaction
 from django.utils import timezone
@@ -13,7 +14,11 @@
 from django.core.exceptions import ValidationError as DjangoValidationError
 from rest_framework.exceptions import ValidationError
 
-from partner_programs.models import PartnerProgram, ProgramRegistration
+from partner_programs.models import (
+    PartnerProgram,
+    PartnerProgramField,
+    ProgramRegistration,
+)
 from partner_programs.permissions import require_create_program
 from partner_programs.services.management import managed_program
 from partner_programs.serializers.management import BASIC_FIELDS
@@ -23,6 +28,21 @@
 
 FORMATS = ("case_championship", "hackathon", "noncompetitive")
 
+PROJECT_FORM_FIELDS = {
+    "case_championship": (
+        ("solution_description", "Описание решения", "textarea", True),
+        ("project_presentation", "Презентация", "file", True),
+        ("prototype_url", "Ссылка на прототип", "url", False),
+    ),
+    "hackathon": (
+        ("implementation", "Описание реализации", "textarea", True),
+        ("repository", "Репозиторий", "url", True),
+        ("launch", "Инструкция запуска", "textarea", True),
+        ("demo", "Демо", "url", False),
+        ("project_presentation", "Презентация", "file", False),
+    ),
+}
+
 
 def summary(program):
     return {
@@ -59,6 +79,7 @@ def create_program(user, data):
             )
         return previous, False
     competitive = data["format"] != "noncompetitive"
+    use_solutions = competitive and settings.PROGRAM_SOLUTIONS_ENABLED
     program = PartnerProgram.objects.create(
         name=data["name"],
         tag="",
@@ -69,12 +90,31 @@ def create_program(user, data):
         creation_key=data["idempotency_key"],
         creation_fingerprint=fingerprint,
         is_competitive=competitive,
-        solution_storage_mode="solution" if competitive else "legacy_project",
-        solution_template=data["format"] if competitive else None,
-        # Only a new program opts in. Existing switches and operator rollback stay intact.
-        solution_creation_enabled=competitive,
+        solution_storage_mode="solution" if use_solutions else "legacy_project",
+        solution_template=data["format"] if use_solutions else None,
+        solution_creation_enabled=use_solutions,
     )
     program.managers.add(actor)
+    if competitive and not use_solutions:
+        program.project_sections = {
+            "partners": False,
+            "achievements": False,
+            "vacancies": False,
+        }
+        program.save(update_fields=["project_sections"])
+        PartnerProgramField.objects.bulk_create(
+            PartnerProgramField(
+                partner_program=program,
+                name=name,
+                label=label,
+                field_type=kind,
+                is_required=required,
+            )
+            for name, label, kind, required in (
+                ("project_description", "Описание проекта", "textarea", False),
+                *PROJECT_FORM_FIELDS[data["format"]],
+            )
+        )
     return program, True
 
 
@@ -102,9 +142,11 @@ def preview_program(pk, user, request):
         "submission_open": program.is_project_submission_open(),
     }
     participant[
-        "application"
-        if program.solution_storage_mode == "solution"
-        else "participant_project"
+        (
+            "application"
+            if program.solution_storage_mode == "solution"
+            else "participant_project"
+        )
     ] = None
     data["preview_widget"] = {
         "program_id": program.pk,
@@ -128,14 +170,16 @@ def _revision(program, config):
             name: getattr(program, name) for name in (*BASIC_FIELDS, *DATE_FIELDS)
         },
         "updated_at": program.datetime_updated,
-        "registration": {
-            "revision": config.revision,
-            "draft": config.draft,
-            "external_status": config.external_status,
-            "external_url": config.external_url,
-        }
-        if config
-        else None,
+        "registration": (
+            {
+                "revision": config.revision,
+                "draft": config.draft,
+                "external_status": config.external_status,
+                "external_url": config.external_url,
+            }
+            if config
+            else None
+        ),
     }
     return hashlib.sha256(
         json.dumps(values, sort_keys=True, default=str).encode()
@@ -228,17 +272,17 @@ def readiness_data(program, config=None):
         "revision": _revision(program, config),
         "checks": checks,
         "blockers": blockers,
-        "warnings": [
-            "Форму решения, критерии и экспертов можно настроить после публикации."
-        ]
-        if program.is_competitive
-        else [],
+        "warnings": (
+            ["Форму решения, критерии и экспертов можно настроить после публикации."]
+            if program.is_competitive
+            else []
+        ),
         "can_publish": program.draft and not blockers,
         "links": {
             "program": f"{registration.frontend_url()}/office/program/{program.pk}",
-            "registration": registration.public_link(program)
-            if not program.draft
-            else None,
+            "registration": (
+                registration.public_link(program) if not program.draft else None
+            ),
         },
     }
 
diff --git a/partner_programs/services/project_apply.py b/partner_programs/services/project_apply.py
index 31eb2bc3..3570b3ef 100644
--- a/partner_programs/services/project_apply.py
+++ b/partner_programs/services/project_apply.py
@@ -11,11 +11,12 @@
     PartnerProgramProject,
     PartnerProgramUserProfile,
 )
+from partner_programs.project_form import PROJECT_FIELDS, visible_project_fields
 from partner_programs.services.case_fields import (
     get_program_case_field,
     validate_case_value,
 )
-from projects.models import Project
+from projects.models import Collaborator, Project
 
 User = get_user_model()
 
@@ -32,6 +33,48 @@ class ProgramProjectApplicationResult:
     program_link: PartnerProgramProject
 
 
+def copy_project(source, *, leader):
+    copy = Project.objects.create(
+        name=source.name,
+        description=source.description,
+        region=source.region,
+        hidden_score=source.hidden_score,
+        actuality=source.actuality,
+        target_audience=source.target_audience,
+        trl=source.trl,
+        implementation_deadline=source.implementation_deadline,
+        problem=source.problem,
+        industry_id=source.industry_id,
+        presentation_address=source.presentation_address,
+        image_address=source.image_address,
+        leader=leader,
+        draft=True,
+        is_public=False,
+        is_company=source.is_company,
+        cover_image_address=source.cover_image_address,
+        cover_id=source.cover_id,
+    )
+    members = []
+    for member in source.collaborator_set.all():
+        if member.user_id == leader.pk:
+            Collaborator.objects.update_or_create(
+                user_id=leader.pk,
+                project=copy,
+                defaults={"role": member.role, "specialization": member.specialization},
+            )
+        else:
+            members.append(
+                Collaborator(
+                    user_id=member.user_id,
+                    project=copy,
+                    role=member.role,
+                    specialization=member.specialization,
+                )
+            )
+    Collaborator.objects.bulk_create(members)
+    return copy
+
+
 def require_can_apply_project_to_program(
     *,
     program: PartnerProgram,
@@ -120,6 +163,12 @@ def apply_project_to_program(
 
     _validate_unique_program_fields(values_data)
     _validate_program_field_ownership(program=program, values_data=values_data)
+    if values_data:
+        visible_ids = set(visible_project_fields(program).values_list("pk", flat=True))
+        if any(item["field"].pk not in visible_ids for item in values_data):
+            raise ValidationError(
+                {"program_field_values": "Форма программы изменилась. Обновите страницу."}
+            )
 
     with transaction.atomic():
         # Missing case is valid at draft creation; an explicit choice must stay valid
@@ -132,15 +181,24 @@ def apply_project_to_program(
                         validate_case_value(case_field, item.get("value_text"))
                     except DjangoValidationError as error:
                         raise ValidationError({"program_field_values": error.messages})
-        project = Project.objects.create(
+        source = Project.objects.create(
             leader=user,
             draft=True,
             is_public=False,
             **project_data,
         )
+        project = copy_project(source, leader=user) if program.is_competitive else source
+        project_changes = {
+            PROJECT_FIELDS[item["field"].name]: item.get("value_text") or None
+            for item in values_data
+            if item["field"].name in PROJECT_FIELDS
+        }
+        if project_changes:
+            Project.objects.filter(pk=project.pk).update(**project_changes)
         program_link = PartnerProgramProject.objects.create(
             partner_program=program,
             project=project,
+            source_project=source if project.pk != source.pk else None,
         )
 
         profile = PartnerProgramUserProfile.objects.filter(
@@ -158,7 +216,7 @@ def apply_project_to_program(
                 value_text=item.get("value_text") or "",
             )
             for item in values_data
-            if item.get("value_text")
+            if item.get("value_text") and item["field"].name not in PROJECT_FIELDS
         ]
         if value_objs:
             PartnerProgramFieldValue.objects.bulk_create(value_objs)
diff --git a/partner_programs/services/project_fields.py b/partner_programs/services/project_fields.py
index 402ab662..78ed54e9 100644
--- a/partner_programs/services/project_fields.py
+++ b/partner_programs/services/project_fields.py
@@ -7,6 +7,12 @@
 from rest_framework.exceptions import APIException, PermissionDenied, ValidationError
 
 from partner_programs.models import PartnerProgramFieldValue, PartnerProgramProject
+from partner_programs.project_form import (
+    PROJECT_FIELDS,
+    field_value,
+    project_sections,
+    visible_project_fields,
+)
 from partner_programs.serializers import (
     PartnerProgramFieldSerializer,
     PartnerProgramFieldValueUpdateSerializer,
@@ -58,10 +64,11 @@ def program_link_fields(link_id, user, *, link=None):
         user, link.project, program_id=link.partner_program_id
     ):
         raise PermissionDenied("У вас нет доступа к полям этой программы проекта.")
-    values = dict(link.field_values.values_list("field_id", "value_text"))
-    fields = PartnerProgramFieldSerializer(
-        link.partner_program.fields.order_by("pk"), many=True
-    ).data
+    form = (
+        link.submitted_form
+        if link.submitted and link.submitted_form
+        else form_snapshot(link)
+    )
     program = link.partner_program
     submission_open = program.is_project_submission_open()
     return {
@@ -73,13 +80,33 @@ def program_link_fields(link_id, user, *, link=None):
         "submission_open": submission_open,
         "submission_deadline": program.get_project_submission_deadline(),
         "can_submit": program.is_competitive and not link.submitted and submission_open,
-        "fields": [{**field, "value": values.get(field["id"])} for field in fields],
+        **form,
+    }
+
+
+def form_snapshot(link):
+    definitions = list(visible_project_fields(link.partner_program))
+    values = (
+        dict(link.field_values.values_list("field_id", "value_text")) if link.pk else {}
+    )
+    return {
+        "sections": project_sections(link.partner_program),
+        "fields": [
+            {**data, "value": field_value(link, field, values)}
+            for field, data in zip(
+                definitions, PartnerProgramFieldSerializer(definitions, many=True).data
+            )
+        ],
     }
 
 
 @transaction.atomic
 def update_program_link_fields(link_id, user, data):
     """Atomic partial update; link lock also serializes this write with submission."""
+    from projects.team_policy import lock_team
+
+    reference = get_program_link(link_id)
+    lock_team(reference.project_id)
     link = get_program_link(link_id, for_update=True)
     require_link_leader(link, user)
     if link.partner_program.is_competitive and link.submitted:
@@ -99,8 +126,20 @@ def update_program_link_fields(link_id, user, data):
     field_ids = [item["field"].pk for item in serializer.validated_data]
     if len(field_ids) != len(set(field_ids)):
         raise ValidationError({"detail": "В запросе не должны повторяться field_id."})
+    visible_ids = set(
+        visible_project_fields(link.partner_program).values_list("pk", flat=True)
+    )
+    if set(field_ids) - visible_ids:
+        raise ValidationError(
+            {"detail": "Форма программы изменилась. Обновите страницу."}
+        )
     try:
+        project_changes = {}
         for item in serializer.validated_data:
+            attribute = PROJECT_FIELDS.get(item["field"].name)
+            if attribute:
+                project_changes[attribute] = item.get("value_text") or None
+                continue
             if not item.get("value_text"):
                 link.field_values.filter(field=item["field"]).delete()
                 continue
@@ -109,6 +148,10 @@ def update_program_link_fields(link_id, user, data):
                 field=item["field"],
                 defaults={"value_text": item.get("value_text")},
             )
+        if project_changes:
+            Project.objects.filter(pk=link.project_id).update(
+                **project_changes, datetime_updated=timezone.now()
+            )
     except DjangoValidationError as error:
         raise ValidationError({"detail": error.messages})
 
@@ -142,3 +185,6 @@ def submit_program_project(link_id, user):
     link.submitted = True
     link.datetime_submitted = timezone.now()
     link.save(update_fields=["submitted", "datetime_submitted", "datetime_updated"])
+    Project.objects.filter(pk=link.project_id).update(
+        draft=False, datetime_updated=link.datetime_submitted
+    )
diff --git a/partner_programs/services/project_filters.py b/partner_programs/services/project_filters.py
index d12f625a..85bad53a 100644
--- a/partner_programs/services/project_filters.py
+++ b/partner_programs/services/project_filters.py
@@ -6,6 +6,7 @@
     PartnerProgramFieldValue,
     PartnerProgramProject,
 )
+from partner_programs.project_form import visible_project_fields
 
 
 class ProgramProjectFilterError(Exception):
@@ -15,10 +16,7 @@ def __init__(self, detail: dict):
 
 
 def get_filterable_program_fields(program: PartnerProgram):
-    return PartnerProgramField.objects.filter(
-        partner_program=program,
-        show_filter=True,
-    )
+    return visible_project_fields(program).filter(show_filter=True)
 
 
 def validate_program_project_filters(
diff --git a/partner_programs/solution_api.py b/partner_programs/solution_api.py
index 346e564a..0c7825f8 100644
--- a/partner_programs/solution_api.py
+++ b/partner_programs/solution_api.py
@@ -209,9 +209,11 @@ def solution_data(solution, user):
                 and not frozen
             ),
         ),
-        readiness=dict(is_ready=not problems, issues=problems)
-        if program.is_competitive and own
-        else None,
+        readiness=(
+            dict(is_ready=not problems, issues=problems)
+            if program.is_competitive and own
+            else None
+        ),
     )
 
 
@@ -320,7 +322,9 @@ def create_solution(program_id, user, data):
 
 
 class SolutionAPIView(APIView):
-    permission_classes = [IsAuthenticated]
+    from partner_programs.permissions import SolutionFlowEnabled
+
+    permission_classes = [SolutionFlowEnabled, IsAuthenticated]
 
     def handle_exception(self, exc):
         if isinstance(exc, SolutionError):
@@ -371,6 +375,9 @@ def handle_exception(self, exc):
 
 
 class SolutionContextView(SolutionAPIView):
+    # Older project clients read the context before opening the V1 entry form.
+    permission_classes = [IsAuthenticated]
+
     def get(self, request, pk):
         return Response(context_data(program_for(pk), request.user))
 
diff --git a/partner_programs/tasks.py b/partner_programs/tasks.py
index eccc9f51..18e8c207 100644
--- a/partner_programs/tasks.py
+++ b/partner_programs/tasks.py
@@ -57,6 +57,7 @@ def send_test_program_certificate(program_id, user_id, snapshot):
         program.name,
         "ПРОБНЫЙ",
         row.created_at,
+        program_id=program.pk,
     )
     send_certificate(row, test=True)
 
diff --git a/partner_programs/tests/test_attention_analytics_api.py b/partner_programs/tests/test_attention_analytics_api.py
index e458c7d5..241f0d4a 100644
--- a/partner_programs/tests/test_attention_analytics_api.py
+++ b/partner_programs/tests/test_attention_analytics_api.py
@@ -22,7 +22,6 @@
 from project_rates.tests.helpers import create_rate_expert
 from projects.models import Collaborator
 
-
 NOW = datetime(2026, 9, 5, 12, tzinfo=datetime_timezone.utc)
 PARTICIPANTS = "manager-overview-participants-without-team"
 ONBOARDING = "manager-overview-participants-without-onboarding"
@@ -773,6 +772,7 @@ def test_project_and_leader_contract_has_only_safe_minimal_fields(self):
                 "reason_label",
                 "assignments_total",
                 "assignments_completed",
+                "experts",
             },
         )
         self.assertEqual(
@@ -782,6 +782,7 @@ def test_project_and_leader_contract_has_only_safe_minimal_fields(self):
             item["leader"],
             {"user_id": leader.pk, "full_name": "Анна Иванова", "avatar": None},
         )
+        self.assertEqual(item["experts"], [])
         self.assertEqual(parse_datetime(item["submitted_at"]), NOW - timedelta(hours=1))
 
     def test_serializer_only_defensively_accepts_null_leader_without_schema_change(self):
@@ -884,4 +885,4 @@ def test_query_count_is_constant_when_work_page_and_assignments_grow(self):
             data = self.get(PROJECTS, limit=100)
         self.assertEqual(len(data["results"]), 31)
         self.assertEqual(len(small), len(large))
-        self.assertLessEqual(len(large), 4)
+        self.assertLessEqual(len(large), 5)
diff --git a/partner_programs/tests/test_certificates.py b/partner_programs/tests/test_certificates.py
index 7722411a..f002ea32 100644
--- a/partner_programs/tests/test_certificates.py
+++ b/partner_programs/tests/test_certificates.py
@@ -424,13 +424,42 @@ def test_current_archive_applies_template_and_respects_selected_rows(self, rende
         )
         self.assertEqual(response.status_code, 200)
         with zipfile.ZipFile(io.BytesIO(b"".join(response.streaming_content))) as archive:
-            self.assertEqual(archive.namelist(), [f"certificate-{first.pk}.pdf"])
+            self.assertEqual(archive.namelist(), [f"{first.name}.pdf"])
             self.assertEqual(archive.read(archive.namelist()[0]), b"%PDF-current")
         first.refresh_from_db()
         second.refresh_from_db()
         self.assertEqual(bytes(first.pdf), b"%PDF-current")
         self.assertEqual(bytes(second.pdf), b"%PDF-untouched")
 
+    def test_download_existing_archive_never_updates_platform_copy(self):
+        import zipfile
+
+        first = self.row(status="ready", pdf=b"%PDF-one")
+        second = self.row(user=self.member, status="ready", pdf=b"%PDF-two")
+        first.name = second.name = "../Анна Крылова"
+        first.save(update_fields=["name"])
+        second.save(update_fields=["name"])
+        response = self.client.post(
+            self.root + "archive/",
+            {
+                "revision": 1,
+                "ids": [str(first.pk), str(second.pk)],
+                "published_only": True,
+            },
+            format="json",
+        )
+        self.assertEqual(response.status_code, 200)
+        with zipfile.ZipFile(io.BytesIO(b"".join(response.streaming_content))) as archive:
+            self.assertEqual(
+                set(archive.namelist()), {"_Анна Крылова.pdf", "_Анна Крылова (2).pdf"}
+            )
+            self.assertEqual(
+                {archive.read(name) for name in archive.namelist()},
+                {b"%PDF-one", b"%PDF-two"},
+            )
+        first.refresh_from_db()
+        self.assertEqual(bytes(first.pdf), b"%PDF-one")
+
     def test_access_requires_program_manager_and_does_not_leak_email(self):
         for user, status in [
             (None, 401),
@@ -713,6 +742,37 @@ def test_legacy_elements_default_to_mont_without_rewriting_the_snapshot(self):
             all("font_family" not in box for box in self.config.draft["layout"].values())
         )
 
+    def test_uploaded_font_is_private_and_preview_uses_element_styles(self):
+        upload = SimpleUploadedFile(
+            "Mont Bold.ttf",
+            service.certificate_font_path("mont-bold", False).read_bytes(),
+        )
+        response = self.client.post(
+            self.root + "assets/", {"kind": "font", "file": upload}, format="multipart"
+        )
+        self.assertEqual(response.status_code, 201, response.data)
+        asset_id = response.data["id"]
+        draft = service.default_draft()
+        draft["layout"]["name"]["font_family"] = f"custom-{asset_id}"
+        draft["layout"]["subtitle"]["font_family"] = "mont-light"
+        draft["hidden_elements"].remove("subtitle")
+        response = self.client.put(
+            self.root, {"revision": 1, "draft": draft}, format="json"
+        )
+        self.assertEqual(response.status_code, 200, response.data)
+        self.assertEqual(
+            response.data["draft"]["layout"]["subtitle"]["font_family"], "mont-light"
+        )
+        response = self.client.post(
+            self.root + "preview/", {"revision": 2}, format="json"
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(response.content.startswith(b"%PDF"))
+        self.client.force_authenticate(self.other)
+        self.assertEqual(
+            self.client.get(self.root + f"assets/{asset_id}/").status_code, 403
+        )
+
     def test_all_certificate_fonts_fit_long_cyrillic_names_in_both_orientations(self):
         value = "Александра Константиновна Добровольская"
         for family in service.CERTIFICATE_FONTS:
diff --git a/partner_programs/tests/test_program_launch.py b/partner_programs/tests/test_program_launch.py
index c8f1c2e4..b6341053 100644
--- a/partner_programs/tests/test_program_launch.py
+++ b/partner_programs/tests/test_program_launch.py
@@ -2,7 +2,12 @@
 from unittest.mock import patch
 
 from django.contrib.auth.models import Permission
-from django.test import TestCase, TransactionTestCase, skipUnlessDBFeature
+from django.test import (
+    TestCase,
+    TransactionTestCase,
+    override_settings,
+    skipUnlessDBFeature,
+)
 from django.utils import timezone
 from rest_framework.test import APIClient
 
@@ -37,6 +42,31 @@ def create(self, **changes):
 
 
 class ProgramCreationTests(ProgramLaunchTestCase):
+    @override_settings(PROGRAM_SOLUTIONS_ENABLED=False)
+    def test_v1_switch_selects_project_templates_and_archives_v2_routes(self):
+        archived = create_partner_program(
+            is_competitive=True, solution_storage_mode="solution"
+        )
+        archived.managers.add(self.creator)
+        response = self.create(format="hackathon")
+        self.assertEqual(response.status_code, 201, response.data)
+        program = PartnerProgram.objects.get(pk=response.data["id"])
+        self.assertEqual(program.solution_storage_mode, "legacy_project")
+        self.assertFalse(program.solution_creation_enabled)
+        self.assertTrue(
+            program.fields.filter(name="repository", is_required=True).exists()
+        )
+        self.assertEqual(self.client.get(f"/programs/{archived.pk}/").status_code, 404)
+        self.assertEqual(
+            self.client.get(f"/programs/{archived.pk}/solution-context/").status_code, 404
+        )
+        self.assertNotIn(
+            archived.pk,
+            [row["id"] for row in self.client.get("/programs/managed/").data["results"]],
+        )
+        archived.refresh_from_db()
+        self.assertEqual(archived.solution_storage_mode, "solution")
+
     def test_all_formats_start_private_without_fake_dates_and_enrollment(self):
         for kind in ("case_championship", "hackathon", "noncompetitive"):
             with self.subTest(kind=kind):
diff --git a/partner_programs/tests/test_program_link_fields_api.py b/partner_programs/tests/test_program_link_fields_api.py
index f5afe26a..66893f63 100644
--- a/partner_programs/tests/test_program_link_fields_api.py
+++ b/partner_programs/tests/test_program_link_fields_api.py
@@ -59,6 +59,12 @@ def test_get_context_order_null_value_and_other_program_isolation(self):
                 "submission_open": True,
                 "submission_deadline": self.program.datetime_registration_ends,
                 "can_submit": True,
+                "sections": {
+                    "partners": True,
+                    "achievements": True,
+                    "vacancies": True,
+                    "program_data": True,
+                },
             },
         )
         fields = response.data["fields"]
diff --git a/partner_programs/tests/test_project_apply.py b/partner_programs/tests/test_project_apply.py
index 5947da4c..2ad5140e 100644
--- a/partner_programs/tests/test_project_apply.py
+++ b/partner_programs/tests/test_project_apply.py
@@ -20,6 +20,73 @@ def setUp(self):
         self.user = create_user(prefix="program-apply-user")
         self.program = create_partner_program()
 
+    def test_title_only_creates_source_and_submission_freezes_only_copy(self):
+        self.program.is_competitive = True
+        self.program.save(update_fields=["is_competitive"])
+        create_program_member(self.program, user=self.user)
+        field = create_program_field(
+            self.program, name="answer", label="Ответ", is_required=True
+        )
+        self.client.force_authenticate(self.user)
+        response = self.client.post(
+            f"/programs/{self.program.pk}/projects/apply/",
+            {"project": {"name": "Проект команды"}},
+            format="json",
+        )
+        self.assertEqual(response.status_code, 201, response.data)
+        link = PartnerProgramProject.objects.get(pk=response.data["program_link_id"])
+        self.assertNotEqual(link.project_id, link.source_project_id)
+        self.assertEqual(link.source_project.name, "Проект команды")
+        self.assertFalse(link.source_project.program_links.exists())
+        projects = {
+            item["id"]: item for item in self.client.get("/auth/users/projects/").data["results"]
+        }
+        self.assertIsNone(projects[link.source_project_id]["partner_program"])
+        self.assertEqual(
+            projects[link.project_id]["partner_program"]["source_project_id"],
+            link.source_project_id,
+        )
+        fields_url = f"/programs/partner-program-projects/{link.pk}/fields/"
+        self.assertEqual(
+            self.client.put(
+                fields_url,
+                [{"field_id": field.pk, "value_text": "Первый ответ"}],
+                format="json",
+            ).status_code,
+            200,
+        )
+        response = self.client.post(
+            f"/programs/partner-program-projects/{link.pk}/submit/", {}, format="json"
+        )
+        self.assertEqual(response.status_code, 200, response.data)
+        field.is_visible = False
+        field.save(update_fields=["is_visible"])
+        self.assertEqual(
+            self.client.get(fields_url).data["fields"][0]["value"], "Первый ответ"
+        )
+        self.assertEqual(
+            self.client.patch(
+                f"/projects/{link.project_id}/", {"name": "Правка копии"}, format="json"
+            ).status_code,
+            403,
+        )
+        self.assertEqual(
+            self.client.patch(
+                f"/projects/{link.source_project_id}/",
+                {"name": "Правка оригинала"},
+                format="json",
+            ).status_code,
+            200,
+        )
+        link.project.refresh_from_db()
+        self.assertEqual(link.project.name, "Проект команды")
+        self.assertEqual(
+            self.client.post(
+                f"/projects/{link.project_id}/goals/", [], format="json"
+            ).status_code,
+            403,
+        )
+
     def test_member_can_get_project_apply_schema(self):
         create_program_member(self.program, user=self.user)
         field = create_program_field(
diff --git a/partner_programs/views.py b/partner_programs/views.py
index 6d8ca752..8759c5d6 100644
--- a/partner_programs/views.py
+++ b/partner_programs/views.py
@@ -1,5 +1,5 @@
 from django.contrib.auth import get_user_model
-from django.db.models import Exists, F, OuterRef, Value
+from django.db.models import Exists, F, OuterRef, Q, Value
 from django.db.models.functions import Concat
 from django.shortcuts import get_object_or_404
 from django.utils import timezone
@@ -132,7 +132,9 @@ def perform_create(self, serializer):
             program.managers.add(self.request.user)
 
     def get_queryset(self):
-        base_qs = super().get_queryset()
+        from partner_programs.permissions import active_programs
+
+        base_qs = active_programs(super().get_queryset())
         participating_flag = self.request.query_params.get("participating")
         if not participating_flag:
             qs = base_qs
@@ -144,6 +146,23 @@ def get_queryset(self):
                 partner_program_profiles__user=self.request.user,
                 datetime_finished__gte=now,
             ).distinct()
+        if self.request.query_params.get("project_submission") == "true":
+            now = timezone.now()
+            qs = qs.filter(
+                is_competitive=True,
+                solution_storage_mode="legacy_project",
+                datetime_finished__gte=now,
+            ).filter(
+                Q(datetime_project_submission_ends__gte=now)
+                | Q(
+                    datetime_project_submission_ends__isnull=True,
+                    datetime_registration_ends__gte=now,
+                )
+                | Q(
+                    datetime_project_submission_ends__isnull=True,
+                    datetime_registration_ends__isnull=True,
+                )
+            )
 
         user = self.request.user
         if not user.is_authenticated:
@@ -274,7 +293,9 @@ def get(self, request, pk, *args, **kwargs):
         program = self.get_object()
         require_can_apply_project_to_program(program=program, user=request.user)
 
-        fields_qs = program.fields.all()
+        from partner_programs.project_form import visible_project_fields
+
+        fields_qs = visible_project_fields(program)
         return Response(
             {
                 "program_id": program.id,
@@ -524,7 +545,9 @@ def get(self, request, pk):
         queryset = self.get_queryset(program, query.validated_data["search"])
         page = paginator.paginate_queryset(queryset, request, view=self)
         response = paginator.get_paginated_response(
-            self.serializer_class(page, many=True).data
+            self.serializer_class(
+                page, many=True, context=self.serializer_context(program, page)
+            ).data
         )
         response.data.update(self.get_metadata(program))
         return response
@@ -537,6 +560,9 @@ def get_metadata(self, program):
             }
         return {}
 
+    def serializer_context(self, program, page):
+        return {}
+
 
 class ProgramManagerParticipantsWithoutTeamAPIView(ProgramManagerAttentionListAPIView):
     """Уникальные зарегистрированные пользователи без команды именно этой программы."""
@@ -584,6 +610,29 @@ def get_queryset(self, program, search):
             queryset = queryset.filter(project__name__icontains=search)
         return queryset.order_by(F("datetime_submitted").asc(nulls_last=True), "pk")
 
+    def serializer_context(self, program, page):
+        from partner_programs.services.assignment_analytics import (
+            annotated_assignment_queryset,
+        )
+        from partner_programs.services.management import person_name
+
+        experts_by_project = {}
+        assignments = (
+            annotated_assignment_queryset(program.pk)
+            .filter(project_id__in=[link.project_id for link in page])
+            .select_related("expert__user")
+            .order_by("pk")
+        )
+        for assignment in assignments:
+            experts_by_project.setdefault(assignment.project_id, []).append(
+                {
+                    "id": assignment.expert_id,
+                    "full_name": person_name(assignment.expert.user),
+                    "completed": assignment.is_completed,
+                }
+            )
+        return {"experts_by_project": experts_by_project}
+
 
 class ProgramManagerProjectsNotSubmittedAPIView(ProgramManagerAttentionListAPIView):
     """Read-only список несданных связей только текущей соревновательной программы."""
diff --git a/procollab/settings.py b/procollab/settings.py
index 218a1737..7adc6b7c 100644
--- a/procollab/settings.py
+++ b/procollab/settings.py
@@ -18,6 +18,8 @@
 EXPERT_WORKSPACE_FRONTEND_URL = config(
     "EXPERT_WORKSPACE_FRONTEND_URL", default="https://app.procollab.ru"
 )
+PROGRAM_SOLUTIONS_ENABLED = config("PROGRAM_SOLUTIONS_ENABLED", default=True, cast=bool)
+PROJECT_DEFAULT_PACK_URL = config("PROJECT_DEFAULT_PACK_URL", default="")
 
 AUTOPOSTING_ON = config("AUTOPOSTING_ON", default=False, cast=bool)
 
diff --git a/projects/migrations/0036_neutral_default_images.py b/projects/migrations/0036_neutral_default_images.py
new file mode 100644
index 00000000..6867e8c3
--- /dev/null
+++ b/projects/migrations/0036_neutral_default_images.py
@@ -0,0 +1,27 @@
+from django.conf import settings
+from django.db import migrations
+
+
+def add_default_images(apps, schema_editor):
+    base = settings.PROJECT_DEFAULT_PACK_URL.rstrip("/")
+    if not base:
+        return
+    files = apps.get_model("files", "UserFile")
+    for model, directory, prefix in (
+        ("DefaultProjectAvatar", "avatars", "avatar"),
+        ("DefaultProjectCover", "covers", "cover"),
+    ):
+        catalog = apps.get_model("projects", model)
+        for index in range(1, 13):
+            name = f"{prefix}-{index:02d}"
+            url = f"{base}/{directory}/{name}.jpg"
+            files.objects.get_or_create(
+                link=url,
+                defaults={"name": name, "extension": "jpg", "mime_type": "image/jpeg"},
+            )
+            catalog.objects.get_or_create(image_id=url)
+
+
+class Migration(migrations.Migration):
+    dependencies = [("projects", "0035_interface_copy")]
+    operations = [migrations.RunPython(add_default_images, migrations.RunPython.noop)]
diff --git a/projects/models.py b/projects/models.py
index d0ac1a3e..13cd0f8e 100644
--- a/projects/models.py
+++ b/projects/models.py
@@ -39,10 +39,15 @@ class Meta:
 
     @classmethod
     def get_random_file(cls) -> Optional[UserFile]:
-        if not cls.objects.exists():
-            return None
-        obj = cls.objects.order_by("?").first()
-        return obj.image if obj and obj.image else None
+        row = (
+            cls.objects.exclude(image_id__isnull=True)
+            .exclude(image_id="")
+            .select_related("image")
+            .only("image", "image__link")
+            .order_by("?")
+            .first()
+        )
+        return row.image if row else None
 
     @classmethod
     def get_random_file_link(cls) -> Optional[str]:
@@ -232,11 +237,16 @@ def save(self, *args, **kwargs):
             if kwargs.get("update_fields"):
                 kwargs["update_fields"] = {*kwargs["update_fields"], "name"}
 
-        if not self.cover_image_address:
-            self.cover_image_address = DefaultProjectCover.get_random_file_link()
-
-        if not self.image_address:
-            self.image_address = DefaultProjectAvatar.get_random_file_link()
+        for field, catalog in (
+            ("cover_image_address", DefaultProjectCover),
+            ("image_address", DefaultProjectAvatar),
+        ):
+            if not getattr(self, field):
+                url = catalog.get_random_file_link()
+                if url:
+                    setattr(self, field, url)
+                    if kwargs.get("update_fields"):
+                        kwargs["update_fields"] = {*kwargs["update_fields"], field}
 
         super().save(*args, **kwargs)
 
diff --git a/projects/permissions.py b/projects/permissions.py
index dadb5742..ecbe41b3 100644
--- a/projects/permissions.py
+++ b/projects/permissions.py
@@ -1,5 +1,6 @@
 from datetime import datetime, timedelta
 
+from django.conf import settings
 from django.utils import timezone
 from django.db.models import Q
 from rest_framework.exceptions import NotFound, PermissionDenied, ValidationError
@@ -13,6 +14,13 @@
 from projects.models import Project
 
 
+def require_editable_submission(project):
+    if project.program_links.filter(
+        submitted=True, partner_program__is_competitive=True
+    ).exists():
+        raise PermissionDenied("Проект зафиксирован после сдачи в программу.")
+
+
 def has_project_read_involvement(user, project: Project, *, program_id=None) -> bool:
     """Restricted READ; optional program scope limits program roles, never grants WRITE."""
     if not user or not user.is_authenticated:
@@ -186,6 +194,7 @@ class TimingAfterEndsProgramPermission(BasePermission):
     def has_object_permission(self, request, view, obj) -> bool:
         if request.method in SAFE_METHODS:
             return True
+        require_editable_submission(obj)
 
         program_profile = (
             PartnerProgramUserProfile.objects.filter(user=request.user, project=obj)
@@ -257,11 +266,18 @@ def has_permission(self, request, view):
             return False
 
         try:
-            project = Project.objects.only("id", "leader_id").get(pk=project_id)
+            project = (
+                Project.objects.select_for_update()
+                .only("id", "leader_id")
+                .get(pk=project_id)
+            )
         except Project.DoesNotExist:
             return False
 
-        return project.leader_id == request.user.id
+        if project.leader_id != request.user.id:
+            return False
+        require_editable_submission(project)
+        return True
 
     def has_object_permission(self, request, view, obj):
         if request.method in SAFE_METHODS:
@@ -287,7 +303,10 @@ def has_permission(self, request, view):
         except PartnerProgram.DoesNotExist:
             raise ValidationError({"partner_program_id": "Программа не найдена."})
 
-        if program.draft:
+        if program.draft or (
+            not settings.PROGRAM_SOLUTIONS_ENABLED
+            and program.solution_storage_mode == "solution"
+        ):
             raise NotFound()
 
         submission_deadline = program.get_project_submission_deadline()
@@ -296,7 +315,7 @@ def has_permission(self, request, view):
                 {"partner_program_id": "Срок подачи проектов в программу завершен."}
             )
 
-        if program.datetime_finished < timezone.now():
+        if not program.datetime_finished or program.datetime_finished < timezone.now():
             raise ValidationError(
                 {"partner_program_id": "Нельзя выбрать завершенную программу."}
             )
diff --git a/projects/serializers.py b/projects/serializers.py
index ac4e80e5..c75ea7ed 100644
--- a/projects/serializers.py
+++ b/projects/serializers.py
@@ -12,13 +12,8 @@
 from industries.models import Industry
 from partner_programs.models import (
     PartnerProgram,
-    PartnerProgramFieldValue,
     PartnerProgramProject,
 )
-from partner_programs.serializers import (
-    PartnerProgramFieldSerializer,
-    PartnerProgramFieldValueSerializer,
-)
 from projects.models import (
     Achievement,
     Collaborator,
@@ -92,6 +87,8 @@ class PartnerProgramProjectSerializer(serializers.ModelSerializer):
     name = serializers.CharField(source="partner_program.name", read_only=True)
     program_link_id = serializers.IntegerField(source="pk", read_only=True)
     program_id = serializers.IntegerField(source="partner_program.id", read_only=True)
+    source_project_id = serializers.IntegerField(read_only=True)
+    sections = serializers.SerializerMethodField()
     is_submitted = serializers.BooleanField(source="submitted", read_only=True)
     can_submit = serializers.SerializerMethodField()
     program_fields = serializers.SerializerMethodField()
@@ -104,6 +101,8 @@ class Meta:
             "program_link_id",
             "program_id",
             "is_submitted",
+            "source_project_id",
+            "sections",
             "can_submit",
             "program_fields",
             "program_field_values",
@@ -116,15 +115,31 @@ def get_can_submit(self, obj):
             and obj.partner_program.is_project_submission_open()
         )
 
+    def to_representation(self, instance):
+        from partner_programs.services.project_fields import form_snapshot
+
+        self._form = (
+            instance.submitted_form
+            if instance.submitted and instance.submitted_form
+            else form_snapshot(instance)
+        )
+        return super().to_representation(instance)
+
     def get_program_fields(self, obj):
-        fields_qs = obj.partner_program.fields.all()
-        return PartnerProgramFieldSerializer(fields_qs, many=True).data
+        return [
+            {key: value for key, value in field.items() if key != "value"}
+            for field in self._form["fields"]
+        ]
 
     def get_program_field_values(self, obj):
-        values_qs = PartnerProgramFieldValue.objects.filter(
-            program_project=obj
-        ).select_related("field")
-        return PartnerProgramFieldValueSerializer(values_qs, many=True).data
+        return [
+            {"field_name": field["name"], "value": field["value"]}
+            for field in self._form["fields"]
+            if field["value"] is not None
+        ]
+
+    def get_sections(self, obj):
+        return self._form["sections"]
 
 
 class ResponsibleMiniSerializer(serializers.ModelSerializer):
@@ -277,6 +292,7 @@ class ProjectDetailSerializer(TeamPolicySerializerMixin, serializers.ModelSerial
     views_count = serializers.SerializerMethodField(method_name="count_views")
     links = serializers.SerializerMethodField()
     partner_program = serializers.SerializerMethodField()
+    program_copies = serializers.SerializerMethodField()
     partner_program_tags = serializers.SerializerMethodField()
     actuality = serializers.CharField(required=False, allow_null=True, allow_blank=True)
     problem = serializers.CharField(required=False, allow_null=True, allow_blank=True)
@@ -326,6 +342,28 @@ def get_partner_program(self, project):
         )
         return PartnerProgramProjectSerializer(link).data if link is not None else None
 
+    def get_program_copies(self, project):
+        request = self.context.get("request")
+        if getattr(getattr(request, "user", None), "pk", None) != project.leader_id:
+            return []
+        from partner_programs.permissions import active_programs
+
+        copies = (
+            project.program_copies.select_related("partner_program")
+            .filter(partner_program__in=active_programs(PartnerProgram.objects.all()))
+            .order_by("pk")
+        )
+        return [
+            {
+                "project_id": link.project_id,
+                "program_id": link.partner_program_id,
+                "program_link_id": link.pk,
+                "name": link.partner_program.name,
+                "submitted": link.submitted,
+            }
+            for link in copies
+        ]
+
     @classmethod
     def get_partner_program_tags(cls, project):
         profiles_qs = project.partner_program_profiles.select_related(
@@ -393,6 +431,7 @@ class Meta:
             "trl",
             "partner_program_tags",
             "partner_program",
+            "program_copies",
         ]
         read_only_fields = [
             "leader",
diff --git a/projects/team_policy.py b/projects/team_policy.py
index c5e15db8..895872b0 100644
--- a/projects/team_policy.py
+++ b/projects/team_policy.py
@@ -237,8 +237,9 @@ def validate_project_binding(project, program):
 
 def validate_required_program_fields(link):
     from django.core.exceptions import ValidationError
+    from partner_programs.project_form import field_value, visible_project_fields
 
-    fields = link.partner_program.fields.filter(is_required=True).order_by("pk")
+    fields = visible_project_fields(link.partner_program).filter(is_required=True)
     if connection.in_atomic_block:
         fields = fields.select_for_update()
     required = list(fields)
@@ -251,13 +252,13 @@ def validate_required_program_fields(link):
         if link.pk
         else {}
     )
-    if any(
-        field.pk not in values
-        or values[field.pk] is None
-        or not str(values[field.pk]).strip()
+    missing = [
+        field.label
         for field in required
-    ):
-        raise ValidationError("Не заполнены обязательные поля программы.")
+        if not str(field_value(link, field, values) or "").strip()
+    ]
+    if missing:
+        raise ValidationError("Заполните обязательные поля: " + ", ".join(missing) + ".")
 
 
 def actionable_users(project, users, *, program_link_id=None):
diff --git a/projects/team_service.py b/projects/team_service.py
index afab1e37..f2e46aab 100644
--- a/projects/team_service.py
+++ b/projects/team_service.py
@@ -301,7 +301,9 @@ def add_member(
 
 
 @transaction.atomic
-def bind_project_to_program(*, project_id, program_id, actor, program_link_id=None):
+def bind_project_to_program(
+    *, project_id, program_id, actor, program_link_id=None, source_project=None
+):
     if program_id is None:
         return
     try:
@@ -354,7 +356,9 @@ def bind_project_to_program(*, project_id, program_id, actor, program_link_id=No
         current_link.delete()
     if program:
         link, _created = PartnerProgramProject.objects.get_or_create(
-            project=project, partner_program=program
+            project=project,
+            partner_program=program,
+            defaults={"source_project": source_project},
         )
         project.is_public = False
         project.save(update_fields=["is_public"])
diff --git a/projects/tests/test_project_default_name.py b/projects/tests/test_project_default_name.py
index b0dd4cfe..6987dc0f 100644
--- a/projects/tests/test_project_default_name.py
+++ b/projects/tests/test_project_default_name.py
@@ -62,15 +62,16 @@ def test_update_api_defaults_cleared_name_and_allows_renaming(self):
                 project.refresh_from_db()
                 self.assertEqual(project.name, expected_name)
 
-    def test_normalization_does_not_bypass_other_publication_validation(self):
+    def test_publication_allows_an_empty_optional_description(self):
         project = Project.objects.create(leader=self.user, name="Название")
         response = self.client.put(
             f"/projects/{project.pk}/",
             {"name": "", "description": "", "draft": False},
             format="json",
         )
-        self.assertEqual(response.status_code, 400)
-        self.assertIn("description", response.data)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["name"], DEFAULT_PROJECT_NAME)
+        self.assertEqual(response.data["description"], "")
 
     def test_published_default_name_is_searchable(self):
         project = Project.objects.create(leader=self.user)
diff --git a/projects/validators.py b/projects/validators.py
index 5de3bba8..a3dfcd25 100644
--- a/projects/validators.py
+++ b/projects/validators.py
@@ -1,5 +1,4 @@
 from django.core.validators import RegexValidator
-from rest_framework.serializers import ValidationError
 
 from projects.names import normalize_project_name
 
@@ -7,15 +6,6 @@
 def validate_project(data):
     if "name" in data:
         data["name"] = normalize_project_name(data["name"])
-
-    if not data.get("draft"):
-        error = {}
-        allowed_blank = {"image_address"}
-        for key, value in data.items():
-            if (value == "" or value is None) and key not in allowed_blank:
-                error[key] = "This field is required"
-        if error:
-            raise ValidationError(error)
     return data
 
 
diff --git a/projects/views.py b/projects/views.py
index 77119dc5..e86efe62 100644
--- a/projects/views.py
+++ b/projects/views.py
@@ -4,11 +4,12 @@
 from django.db import transaction
 from django.db.models import QuerySet
 from django.shortcuts import get_object_or_404
+from django.utils.decorators import method_decorator
 from django_filters import rest_framework as filters
 from drf_yasg import openapi
 from drf_yasg.utils import swagger_auto_schema
 from rest_framework import generics, permissions, status, viewsets
-from rest_framework.exceptions import NotFound
+from rest_framework.exceptions import NotFound, ValidationError
 from rest_framework.generics import ListAPIView
 from rest_framework.permissions import IsAuthenticated
 from rest_framework.response import Response
@@ -20,6 +21,7 @@
     PartnerProgram,
     PartnerProgramUserProfile,
 )
+from partner_programs.services.project_apply import copy_project
 from projects.cover_reset import reset_project_cover
 from projects.filters import ProjectFilter
 from projects.helpers import (
@@ -29,7 +31,6 @@
 )
 from projects.models import (
     Achievement,
-    Collaborator,
     Company,
     Project,
     ProjectCompany,
@@ -170,6 +171,13 @@ def retrieve(self, request, *args, **kwargs):
         serializer = self.get_serializer(instance)
         return Response(serializer.data)
 
+    def lock_for_edit(self):
+        from projects.team_policy import lock_team
+
+        project = lock_team(self.get_object().pk).project
+        self.check_object_permissions(self.request, project)
+        return project
+
     @transaction.atomic
     def put(self, request, pk, **kwargs):
         # fixme: add partner_program_id to docs
@@ -178,7 +186,7 @@ def put(self, request, pk, **kwargs):
             update_partner_program(
                 partner_program_id,
                 request.user,
-                self.get_object(),
+                self.lock_for_edit(),
                 program_link_id=requested_program_link(request),
             )
         except PartnerProgram.DoesNotExist:
@@ -202,7 +210,7 @@ def patch(self, request, pk, **kwargs):
             update_partner_program(
                 partner_program_id,
                 request.user,
-                self.get_object(),
+                self.lock_for_edit(),
                 program_link_id=requested_program_link(request),
             )
         except PartnerProgram.DoesNotExist:
@@ -218,6 +226,10 @@ def patch(self, request, pk, **kwargs):
         check_related_fields_update(request.data, pk)
         return super(ProjectDetail, self).put(request, pk)
 
+    @transaction.atomic
+    def perform_destroy(self, instance):
+        super().perform_destroy(self.lock_for_edit())
+
 
 class ProjectResetCover(generics.GenericAPIView):
     """Команда Angular-редактора с теми же ограничениями, что и запись проекта."""
@@ -517,45 +529,6 @@ def patch(self, request, project_pk: int, user_to_leader_pk: int) -> Response:
 class DuplicateProjectView(APIView):
     permission_classes = [IsAuthenticated, CanBindProjectToProgram]
 
-    @staticmethod
-    def _copy_collaborators(original_project: Project, new_project: Project) -> None:
-        """
-        Copy all collaborators from the source project to the duplicated one.
-        Keep the leader collaborator (auto-created by signal) in sync with the original.
-        """
-        leader_id = new_project.leader_id
-        collaborators_to_create: list[Collaborator] = []
-        leader_collaborator = None
-
-        for collaborator in original_project.collaborator_set.select_related(
-            "user"
-        ).all():
-            if collaborator.user_id == leader_id:
-                leader_collaborator = collaborator
-                continue
-
-            collaborators_to_create.append(
-                Collaborator(
-                    user=collaborator.user,
-                    project=new_project,
-                    role=collaborator.role,
-                    specialization=collaborator.specialization,
-                )
-            )
-
-        if collaborators_to_create:
-            Collaborator.objects.bulk_create(collaborators_to_create)
-
-        if leader_collaborator:
-            Collaborator.objects.update_or_create(
-                user_id=leader_id,
-                project=new_project,
-                defaults={
-                    "role": leader_collaborator.role,
-                    "specialization": leader_collaborator.specialization,
-                },
-            )
-
     @swagger_auto_schema(
         request_body=ProjectDuplicateRequestSerializer,
         responses={201: ProjectDuplicateRequestSerializer(), 400: "Validation error"},
@@ -578,32 +551,27 @@ def post(self, request):
                 original_project.pk, extra_program_ids=[partner_program.pk]
             ).project
             team_service.require_team_manager(original_project, request.user)
-            new_project = Project.objects.create(
-                name=original_project.name,
-                description=original_project.description,
-                region=original_project.region,
-                hidden_score=original_project.hidden_score,
-                actuality=original_project.actuality,
-                target_audience=original_project.target_audience,
-                trl=original_project.trl,
-                implementation_deadline=original_project.implementation_deadline,
-                problem=original_project.problem,
-                industry=original_project.industry,
-                image_address=original_project.image_address,
-                leader=request.user,
-                draft=True,
-                is_public=False,
-                is_company=original_project.is_company,
-                cover_image_address=original_project.cover_image_address,
-                cover=original_project.cover,
-            )
-
-            self._copy_collaborators(original_project, new_project)
-
+            if original_project.program_links.filter(
+                source_project__isnull=False
+            ).exists():
+                raise ValidationError("Выберите исходный проект.")
+            existing = original_project.program_copies.filter(
+                partner_program=partner_program
+            ).first()
+            if existing:
+                return Response(
+                    {
+                        "new_project_id": existing.project_id,
+                        "program_link_id": existing.id,
+                        "partner_program": partner_program.name,
+                    }
+                )
+            new_project = copy_project(original_project, leader=request.user)
             program_link = team_service.bind_project_to_program(
                 project_id=new_project.pk,
                 program_id=partner_program.pk,
                 actor=request.user,
+                source_project=original_project,
             )
 
         return Response(
@@ -616,6 +584,7 @@ def post(self, request):
         )
 
 
+@method_decorator(transaction.atomic, name="dispatch")
 class GoalViewSet(viewsets.ModelViewSet):
     queryset = ProjectGoal.objects.select_related("project", "responsible")
     serializer_class = ProjectGoalSerializer
@@ -667,6 +636,7 @@ def perform_update(self, serializer):
         serializer.save(project=self.get_object().project)
 
 
+@method_decorator(transaction.atomic, name="dispatch")
 class CompanyViewSet(viewsets.ModelViewSet):
     queryset = Company.objects.all().order_by("name")
     serializer_class = CompanySerializer
@@ -675,6 +645,7 @@ class CompanyViewSet(viewsets.ModelViewSet):
     search_fields = ("name", "inn")
 
 
+@method_decorator(transaction.atomic, name="dispatch")
 class ResourceViewSet(viewsets.ModelViewSet):
     queryset = Resource.objects.select_related("project", "partner_company").all()
     serializer_class = ResourceSerializer
@@ -694,6 +665,7 @@ def perform_create(self, serializer):
         serializer.save(project_id=project_pk)
 
 
+@method_decorator(transaction.atomic, name="dispatch")
 class ProjectCompanyUpsertView(APIView):
     """
     POST /projects/<project_id>/companies/
@@ -759,6 +731,7 @@ def get_queryset(self):
         )
 
 
+@method_decorator(transaction.atomic, name="dispatch")
 class ProjectCompanyDetailView(APIView):
     """
     PATCH - частично обновляет вклад/ответственного в связи ProjectCompany
diff --git a/templates/partner_programs/admin/certificate_fonts.html b/templates/partner_programs/admin/certificate_fonts.html
new file mode 100644
index 00000000..60e8cc49
--- /dev/null
+++ b/templates/partner_programs/admin/certificate_fonts.html
@@ -0,0 +1,10 @@
+{% extends "admin/base_site.html" %}
+
+{% block content %}
+<p><a href="{{ change_url }}">{{ program.name }}</a></p>
+<form method="post" enctype="multipart/form-data">
+    {% csrf_token %}
+    {{ form.as_p }}
+    <div class="submit-row"><input type="submit" value="Сохранить шрифт элемента" class="default"></div>
+</form>
+{% endblock %}
diff --git a/templates/partner_programs/admin/program_manager_change_form.html b/templates/partner_programs/admin/program_manager_change_form.html
index bf46ee80..97aa84dd 100644
--- a/templates/partner_programs/admin/program_manager_change_form.html
+++ b/templates/partner_programs/admin/program_manager_change_form.html
@@ -4,6 +4,7 @@
 {% block object-tools-items %}
     {% if original and has_change_permission %}
         <li><a href="{% url 'admin:partner_programs_partnerprogram_registration' original.pk %}">Регистрация</a></li>
+        <li><a href="{% url 'admin:partner_programs_partnerprogram_certificate_fonts' original.pk %}">Шрифты сертификата</a></li>
         {% if not original.draft %}
             <li><a href="{% url 'admin:partner_programs_partnerprogram_unpublish' original.pk %}">Вернуть в черновик</a></li>
         {% endif %}
diff --git a/templates/partner_programs/admin/programs_change_form.html b/templates/partner_programs/admin/programs_change_form.html
index 17fcc100..136a58e7 100644
--- a/templates/partner_programs/admin/programs_change_form.html
+++ b/templates/partner_programs/admin/programs_change_form.html
@@ -4,6 +4,7 @@
 {% block object-tools-items %}
     {% if original and has_change_permission %}
         <li><a href="{% url 'admin:partner_programs_partnerprogram_registration' original.pk %}">Регистрация</a></li>
+        <li><a href="{% url 'admin:partner_programs_partnerprogram_certificate_fonts' original.pk %}">Шрифты сертификата</a></li>
         {% if not original.draft %}
             <li><a href="{% url 'admin:partner_programs_partnerprogram_unpublish' original.pk %}">Вернуть в черновик</a></li>
         {% endif %}
diff --git a/users/serializers.py b/users/serializers.py
index 21ae4ab7..9f9f0e98 100644
--- a/users/serializers.py
+++ b/users/serializers.py
@@ -1026,13 +1026,16 @@ def get_partner_program(project):
             .first()
         )
         if link and link.partner_program:
-            return {
+            program = {
                 "id": link.partner_program_id,
                 "name": link.partner_program.name,
                 "program_link_id": link.pk,
                 "program_id": link.partner_program_id,
                 "is_submitted": link.submitted,
             }
+            if link.source_project_id:
+                program["source_project_id"] = link.source_project_id
+            return program
         return None
 
     class Meta: