diff --git a/backend/alembic/versions/20260228_02_add_setup_version_published_project_snapshot.py b/backend/alembic/versions/20260228_02_add_setup_version_published_project_snapshot.py
new file mode 100644
index 00000000..e1c9432c
--- /dev/null
+++ b/backend/alembic/versions/20260228_02_add_setup_version_published_project_snapshot.py
@@ -0,0 +1,44 @@
+"""add published project snapshot to study_setup_config_versions
+
+Revision ID: 20260228_02
+Revises: 20260228_01
+Create Date: 2026-02-28 18:20:00.000000
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+
+# revision identifiers, used by Alembic.
+revision: str = "20260228_02"
+down_revision: Union[str, None] = "20260228_01"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    inspector = sa.inspect(bind)
+    tables = set(inspector.get_table_names())
+    if "study_setup_config_versions" not in tables:
+        return
+    columns = {col["name"] for col in inspector.get_columns("study_setup_config_versions")}
+    if "published_project_snapshot" not in columns:
+        op.add_column(
+            "study_setup_config_versions",
+            sa.Column("published_project_snapshot", postgresql.JSONB(astext_type=sa.Text()), nullable=True),
+        )
+
+
+def downgrade() -> None:
+    bind = op.get_bind()
+    inspector = sa.inspect(bind)
+    tables = set(inspector.get_table_names())
+    if "study_setup_config_versions" not in tables:
+        return
+    columns = {col["name"] for col in inspector.get_columns("study_setup_config_versions")}
+    if "published_project_snapshot" in columns:
+        op.drop_column("study_setup_config_versions", "published_project_snapshot")
diff --git a/backend/alembic/versions/20260302_01_add_setup_version_branching.py b/backend/alembic/versions/20260302_01_add_setup_version_branching.py
new file mode 100644
index 00000000..5a4bf83e
--- /dev/null
+++ b/backend/alembic/versions/20260302_01_add_setup_version_branching.py
@@ -0,0 +1,235 @@
+"""add setup config version branching metadata
+
+Revision ID: 20260302_01
+Revises: 20260228_02
+Create Date: 2026-03-02 16:30:00.000000
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+
+# revision identifiers, used by Alembic.
+revision: str = "20260302_01"
+down_revision: Union[str, None] = "20260228_02"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def _has_table(inspector: sa.Inspector, table_name: str) -> bool:
+    return table_name in set(inspector.get_table_names())
+
+
+def _has_column(inspector: sa.Inspector, table_name: str, column_name: str) -> bool:
+    return column_name in {col["name"] for col in inspector.get_columns(table_name)}
+
+
+def _has_unique_constraint(inspector: sa.Inspector, table_name: str, constraint_name: str) -> bool:
+    return constraint_name in {item["name"] for item in inspector.get_unique_constraints(table_name)}
+
+
+def _has_foreign_key(inspector: sa.Inspector, table_name: str, fk_name: str) -> bool:
+    return fk_name in {item["name"] for item in inspector.get_foreign_keys(table_name)}
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    inspector = sa.inspect(bind)
+
+    if _has_table(inspector, "study_setup_config_versions"):
+        if not _has_column(inspector, "study_setup_config_versions", "branch_name"):
+            op.add_column("study_setup_config_versions", sa.Column("branch_name", sa.String(), nullable=True))
+        if not _has_column(inspector, "study_setup_config_versions", "branch_seq"):
+            op.add_column("study_setup_config_versions", sa.Column("branch_seq", sa.Integer(), nullable=True))
+        if not _has_column(inspector, "study_setup_config_versions", "version_label"):
+            op.add_column("study_setup_config_versions", sa.Column("version_label", sa.String(), nullable=True))
+        if not _has_column(inspector, "study_setup_config_versions", "parent_version_id"):
+            op.add_column("study_setup_config_versions", sa.Column("parent_version_id", postgresql.UUID(as_uuid=True), nullable=True))
+        if not _has_column(inspector, "study_setup_config_versions", "merged_from_version_id"):
+            op.add_column(
+                "study_setup_config_versions",
+                sa.Column("merged_from_version_id", postgresql.UUID(as_uuid=True), nullable=True),
+            )
+
+        op.execute("UPDATE study_setup_config_versions SET branch_name = 'main' WHERE branch_name IS NULL")
+        op.execute(
+            "UPDATE study_setup_config_versions SET branch_seq = COALESCE(display_version, version, 1) WHERE branch_seq IS NULL"
+        )
+        op.execute(
+            "UPDATE study_setup_config_versions SET version_label = ('v' || COALESCE(display_version, version, 1)::text) WHERE version_label IS NULL"
+        )
+
+        op.alter_column("study_setup_config_versions", "branch_name", nullable=False)
+        op.alter_column("study_setup_config_versions", "branch_seq", nullable=False)
+        op.alter_column("study_setup_config_versions", "version_label", nullable=False)
+
+        inspector = sa.inspect(bind)
+        if not _has_foreign_key(inspector, "study_setup_config_versions", "fk_setup_config_versions_parent_version"):
+            op.create_foreign_key(
+                "fk_setup_config_versions_parent_version",
+                "study_setup_config_versions",
+                "study_setup_config_versions",
+                ["parent_version_id"],
+                ["id"],
+                ondelete="SET NULL",
+            )
+        if not _has_foreign_key(inspector, "study_setup_config_versions", "fk_setup_config_versions_merged_from_version"):
+            op.create_foreign_key(
+                "fk_setup_config_versions_merged_from_version",
+                "study_setup_config_versions",
+                "study_setup_config_versions",
+                ["merged_from_version_id"],
+                ["id"],
+                ondelete="SET NULL",
+            )
+
+        if _has_unique_constraint(inspector, "study_setup_config_versions", "uq_setup_config_versions_study_display_version"):
+            op.drop_constraint(
+                "uq_setup_config_versions_study_display_version",
+                "study_setup_config_versions",
+                type_="unique",
+            )
+        inspector = sa.inspect(bind)
+        if not _has_unique_constraint(inspector, "study_setup_config_versions", "uq_setup_config_versions_study_branch_seq"):
+            op.create_unique_constraint(
+                "uq_setup_config_versions_study_branch_seq",
+                "study_setup_config_versions",
+                ["study_id", "branch_name", "branch_seq"],
+            )
+        if not _has_unique_constraint(inspector, "study_setup_config_versions", "uq_setup_config_versions_study_version_label"):
+            op.create_unique_constraint(
+                "uq_setup_config_versions_study_version_label",
+                "study_setup_config_versions",
+                ["study_id", "version_label"],
+            )
+
+    if _has_table(inspector, "study_setup_configs"):
+        if not _has_column(inspector, "study_setup_configs", "current_branch_name"):
+            op.add_column("study_setup_configs", sa.Column("current_branch_name", sa.String(), nullable=True))
+        if not _has_column(inspector, "study_setup_configs", "active_branch_base_version_id"):
+            op.add_column(
+                "study_setup_configs",
+                sa.Column("active_branch_base_version_id", postgresql.UUID(as_uuid=True), nullable=True),
+            )
+        if not _has_column(inspector, "study_setup_configs", "current_published_version_id"):
+            op.add_column(
+                "study_setup_configs",
+                sa.Column("current_published_version_id", postgresql.UUID(as_uuid=True), nullable=True),
+            )
+
+        op.execute("UPDATE study_setup_configs SET current_branch_name = 'main' WHERE current_branch_name IS NULL")
+        op.alter_column("study_setup_configs", "current_branch_name", nullable=False)
+
+        if _has_table(inspector, "study_setup_config_versions"):
+            op.execute(
+                """
+                UPDATE study_setup_configs
+                SET current_published_version_id = (
+                  SELECT v.id
+                  FROM study_setup_config_versions AS v
+                  WHERE v.study_id = study_setup_configs.study_id
+                    AND study_setup_configs.published_config IS NOT NULL
+                    AND v.config = study_setup_configs.published_config
+                  ORDER BY
+                    CASE
+                      WHEN study_setup_configs.published_at IS NOT NULL
+                           AND v.published_at = study_setup_configs.published_at THEN 0
+                      ELSE 1
+                    END,
+                    v.version DESC
+                  LIMIT 1
+                )
+                WHERE current_published_version_id IS NULL
+                """
+            )
+
+        inspector = sa.inspect(bind)
+        if not _has_foreign_key(inspector, "study_setup_configs", "fk_setup_configs_active_branch_base_version"):
+            op.create_foreign_key(
+                "fk_setup_configs_active_branch_base_version",
+                "study_setup_configs",
+                "study_setup_config_versions",
+                ["active_branch_base_version_id"],
+                ["id"],
+                ondelete="SET NULL",
+            )
+        if not _has_foreign_key(inspector, "study_setup_configs", "fk_setup_configs_current_published_version"):
+            op.create_foreign_key(
+                "fk_setup_configs_current_published_version",
+                "study_setup_configs",
+                "study_setup_config_versions",
+                ["current_published_version_id"],
+                ["id"],
+                ondelete="SET NULL",
+            )
+
+
+def downgrade() -> None:
+    bind = op.get_bind()
+    inspector = sa.inspect(bind)
+
+    if _has_table(inspector, "study_setup_configs"):
+        if _has_foreign_key(inspector, "study_setup_configs", "fk_setup_configs_current_published_version"):
+            op.drop_constraint(
+                "fk_setup_configs_current_published_version",
+                "study_setup_configs",
+                type_="foreignkey",
+            )
+        if _has_foreign_key(inspector, "study_setup_configs", "fk_setup_configs_active_branch_base_version"):
+            op.drop_constraint(
+                "fk_setup_configs_active_branch_base_version",
+                "study_setup_configs",
+                type_="foreignkey",
+            )
+        if _has_column(inspector, "study_setup_configs", "current_published_version_id"):
+            op.drop_column("study_setup_configs", "current_published_version_id")
+        if _has_column(inspector, "study_setup_configs", "active_branch_base_version_id"):
+            op.drop_column("study_setup_configs", "active_branch_base_version_id")
+        if _has_column(inspector, "study_setup_configs", "current_branch_name"):
+            op.drop_column("study_setup_configs", "current_branch_name")
+
+    inspector = sa.inspect(bind)
+    if _has_table(inspector, "study_setup_config_versions"):
+        if _has_unique_constraint(inspector, "study_setup_config_versions", "uq_setup_config_versions_study_version_label"):
+            op.drop_constraint(
+                "uq_setup_config_versions_study_version_label",
+                "study_setup_config_versions",
+                type_="unique",
+            )
+        if _has_unique_constraint(inspector, "study_setup_config_versions", "uq_setup_config_versions_study_branch_seq"):
+            op.drop_constraint(
+                "uq_setup_config_versions_study_branch_seq",
+                "study_setup_config_versions",
+                type_="unique",
+            )
+        if not _has_unique_constraint(inspector, "study_setup_config_versions", "uq_setup_config_versions_study_display_version"):
+            op.create_unique_constraint(
+                "uq_setup_config_versions_study_display_version",
+                "study_setup_config_versions",
+                ["study_id", "display_version"],
+            )
+        if _has_foreign_key(inspector, "study_setup_config_versions", "fk_setup_config_versions_merged_from_version"):
+            op.drop_constraint(
+                "fk_setup_config_versions_merged_from_version",
+                "study_setup_config_versions",
+                type_="foreignkey",
+            )
+        if _has_foreign_key(inspector, "study_setup_config_versions", "fk_setup_config_versions_parent_version"):
+            op.drop_constraint(
+                "fk_setup_config_versions_parent_version",
+                "study_setup_config_versions",
+                type_="foreignkey",
+            )
+        if _has_column(inspector, "study_setup_config_versions", "merged_from_version_id"):
+            op.drop_column("study_setup_config_versions", "merged_from_version_id")
+        if _has_column(inspector, "study_setup_config_versions", "parent_version_id"):
+            op.drop_column("study_setup_config_versions", "parent_version_id")
+        if _has_column(inspector, "study_setup_config_versions", "version_label"):
+            op.drop_column("study_setup_config_versions", "version_label")
+        if _has_column(inspector, "study_setup_config_versions", "branch_seq"):
+            op.drop_column("study_setup_config_versions", "branch_seq")
+        if _has_column(inspector, "study_setup_config_versions", "branch_name"):
+            op.drop_column("study_setup_config_versions", "branch_name")
diff --git a/backend/alembic/versions/20260302_02_drop_setup_version_label_unique.py b/backend/alembic/versions/20260302_02_drop_setup_version_label_unique.py
new file mode 100644
index 00000000..efd621a3
--- /dev/null
+++ b/backend/alembic/versions/20260302_02_drop_setup_version_label_unique.py
@@ -0,0 +1,71 @@
+"""drop unique constraint on setup config version label
+
+Revision ID: 20260302_02
+Revises: 20260302_01
+Create Date: 2026-03-02 20:20:00.000000
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = "20260302_02"
+down_revision: Union[str, None] = "20260302_01"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def _has_table(inspector: sa.Inspector, table_name: str) -> bool:
+    return table_name in set(inspector.get_table_names())
+
+
+def _has_unique_constraint(inspector: sa.Inspector, table_name: str, constraint_name: str) -> bool:
+    return constraint_name in {item["name"] for item in inspector.get_unique_constraints(table_name)}
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    inspector = sa.inspect(bind)
+    table_name = "study_setup_config_versions"
+    constraint_name = "uq_setup_config_versions_study_version_label"
+    if _has_table(inspector, table_name) and _has_unique_constraint(inspector, table_name, constraint_name):
+        op.drop_constraint(constraint_name, table_name, type_="unique")
+    if _has_table(inspector, table_name):
+        op.execute(
+            """
+            WITH ranked AS (
+              SELECT
+                id,
+                display_version,
+                ROW_NUMBER() OVER (
+                  PARTITION BY study_id, branch_name, display_version
+                  ORDER BY published_at ASC, version ASC, created_at ASC
+                ) AS rev_seq
+              FROM study_setup_config_versions
+              WHERE branch_name = 'main'
+            )
+            UPDATE study_setup_config_versions AS v
+            SET version_label = CASE
+              WHEN ranked.rev_seq <= 1 THEN ('v' || ranked.display_version::text)
+              ELSE ('v' || ranked.display_version::text || '-r' || ranked.rev_seq::text)
+            END
+            FROM ranked
+            WHERE v.id = ranked.id
+            """
+        )
+
+
+def downgrade() -> None:
+    bind = op.get_bind()
+    inspector = sa.inspect(bind)
+    table_name = "study_setup_config_versions"
+    constraint_name = "uq_setup_config_versions_study_version_label"
+    if _has_table(inspector, table_name) and not _has_unique_constraint(inspector, table_name, constraint_name):
+        op.create_unique_constraint(
+            constraint_name,
+            table_name,
+            ["study_id", "version_label"],
+        )
diff --git a/backend/app/api/v1/studies.py b/backend/app/api/v1/studies.py
index cd54c236..2c54569a 100644
--- a/backend/app/api/v1/studies.py
+++ b/backend/app/api/v1/studies.py
@@ -1,6 +1,6 @@
 import uuid
 import re
-from datetime import date
+from datetime import date, datetime
 from collections import Counter
 from typing import Any
 
@@ -27,7 +27,10 @@ from app.schemas.member import StudyMemberCreate
 from app.schemas.study_setup_config import (
     ProjectPublishSnapshot,
     SetupProjectionSummary,
+    StudySetupConfigCheckoutBranch,
     StudySetupConfigData,
+    StudySetupConfigDraftAction,
+    StudySetupConfigMergeToMain,
     StudySetupConfigPublish,
     StudySetupConfigRead,
     StudySetupConfigRollback,
@@ -295,6 +298,8 @@ def _to_setup_config_read(
     *,
     saved_by_name: str | None = None,
     published_by_name: str | None = None,
+    current_published_version_label: str | None = None,
+    active_branch_base_version_label: str | None = None,
     projection_status: str | None = None,
     projection_summary: SetupProjectionSummary | None = None,
 ) -> StudySetupConfigRead:
@@ -302,6 +307,11 @@ def _to_setup_config_read(
         id=record.id,
         study_id=record.study_id,
         version=record.version,
+        current_branch_name=(getattr(record, "current_branch_name", None) or "main"),
+        current_published_version_id=getattr(record, "current_published_version_id", None),
+        current_published_version_label=current_published_version_label,
+        active_branch_base_version_id=getattr(record, "active_branch_base_version_id", None),
+        active_branch_base_version_label=active_branch_base_version_label,
         data=StudySetupConfigData.model_validate(record.config or {}),
         publish_status=record.publish_status or "DRAFT",
         published_data=StudySetupConfigData.model_validate(record.published_config) if record.published_config else None,
@@ -363,15 +373,42 @@ def _ensure_study_timeline_valid(
         raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="访视窗口开始偏移不能晚于结束偏移")
 
 
-def _to_setup_config_version_read(record, *, published_by_name: str | None = None) -> StudySetupConfigVersionRead:
+def _resolve_version_label(record: Any) -> str:
+    branch_name = (getattr(record, "branch_name", None) or "main").strip() or "main"
+    display_version = int(getattr(record, "display_version", 0) or 0)
+    branch_seq = int(getattr(record, "branch_seq", 1) or 1)
+    if branch_name == "main":
+        return getattr(record, "version_label", None) or f"v{display_version}"
+    return getattr(record, "version_label", None) or f"v{display_version}.{branch_seq}"
+
+
+def _to_setup_config_version_read(
+    record,
+    *,
+    published_by_name: str | None = None,
+    is_current_published: bool = False,
+    is_active_draft_base: bool = False,
+) -> StudySetupConfigVersionRead:
     return StudySetupConfigVersionRead(
         id=record.id,
         study_id=record.study_id,
         study_setup_config_id=record.study_setup_config_id,
         version=record.version,
         display_version=record.display_version,
+        branch_name=(record.branch_name or "main"),
+        branch_seq=record.branch_seq or 1,
+        version_label=_resolve_version_label(record),
         source_version=record.source_version,
+        parent_version_id=record.parent_version_id,
+        merged_from_version_id=record.merged_from_version_id,
         config=StudySetupConfigData.model_validate(record.config or {}),
+        published_project_snapshot=(
+            ProjectPublishSnapshot.model_validate(record.published_project_snapshot)
+            if record.published_project_snapshot
+            else None
+        ),
+        is_current_published=is_current_published,
+        is_active_draft_base=is_active_draft_base,
         published_by=record.published_by,
         published_by_name=published_by_name,
         published_at=record.published_at,
@@ -379,6 +416,89 @@ def _to_setup_config_version_read(record, *, published_by_name: str | None = Non
     )
 
 
+def _resolve_current_published_snapshot_version(
+    versions: list[Any],
+    setup_record: Any | None,
+) -> int | None:
+    if not setup_record:
+        return None
+    current_published_snapshot_id = getattr(setup_record, "current_published_version_id", None)
+    if current_published_snapshot_id:
+        matched = next((item for item in versions if item.id == current_published_snapshot_id), None)
+        if matched:
+            return matched.version
+
+    published_config = setup_record.published_config or {}
+    if not published_config:
+        return None
+
+    best_score = -1
+    best_version: int | None = None
+    for item in versions:
+        if (item.config or {}) != published_config:
+            continue
+        score = 1
+        if setup_record.published_at and item.published_at == setup_record.published_at:
+            score += 2
+        if setup_record.published_by and item.published_by == setup_record.published_by:
+            score += 1
+        if score > best_score or (score == best_score and (best_version is None or item.version > best_version)):
+            best_score = score
+            best_version = item.version
+    return best_version
+
+
+def _resolve_current_published_snapshot_label(
+    versions: list[Any],
+    setup_record: Any | None,
+) -> str | None:
+    if not setup_record:
+        return None
+    current_published_snapshot_id = getattr(setup_record, "current_published_version_id", None)
+    if current_published_snapshot_id:
+        matched = next((item for item in versions if item.id == current_published_snapshot_id), None)
+        if matched:
+            return _resolve_version_label(matched)
+
+    version = _resolve_current_published_snapshot_version(versions, setup_record)
+    if version is None:
+        return None
+    matched = next((item for item in versions if item.version == version), None)
+    if not matched:
+        return None
+    return _resolve_version_label(matched)
+
+
+def _resolve_active_branch_base_snapshot_version(
+    versions: list[Any],
+    setup_record: Any | None,
+) -> int | None:
+    if not setup_record:
+        return None
+    base_snapshot_id = getattr(setup_record, "active_branch_base_version_id", None)
+    if not base_snapshot_id:
+        return None
+    matched = next((item for item in versions if item.id == base_snapshot_id), None)
+    if not matched:
+        return None
+    return matched.version
+
+
+def _resolve_active_branch_base_snapshot_label(
+    versions: list[Any],
+    setup_record: Any | None,
+) -> str | None:
+    if not setup_record:
+        return None
+    base_snapshot_id = getattr(setup_record, "active_branch_base_version_id", None)
+    if not base_snapshot_id:
+        return None
+    matched = next((item for item in versions if item.id == base_snapshot_id), None)
+    if not matched:
+        return None
+    return _resolve_version_label(matched)
+
+
 _SETUP_MODULE_KEYS = (
     "projectMilestones",
     "enrollmentPlan",
@@ -777,7 +897,14 @@ async def get_study_setup_config(
         if user:
             published_by_name = user.full_name or user.username or user.email
 
-    return _to_setup_config_read(record, saved_by_name=saved_by_name, published_by_name=published_by_name)
+    versions = await study_setup_config_crud.list_versions(db, study_id)
+    return _to_setup_config_read(
+        record,
+        saved_by_name=saved_by_name,
+        published_by_name=published_by_name,
+        current_published_version_label=_resolve_current_published_snapshot_label(versions, record),
+        active_branch_base_version_label=_resolve_active_branch_base_snapshot_label(versions, record),
+    )
 
 
 @router.put(
@@ -843,7 +970,14 @@ async def upsert_study_setup_config(
         user = await user_crud.get_by_id(db, record.published_by)
         if user:
             published_by_name = user.full_name or user.username or user.email
-    return _to_setup_config_read(record, saved_by_name=saved_by_name, published_by_name=published_by_name)
+    versions = await study_setup_config_crud.list_versions(db, study_id)
+    return _to_setup_config_read(
+        record,
+        saved_by_name=saved_by_name,
+        published_by_name=published_by_name,
+        current_published_version_label=_resolve_current_published_snapshot_label(versions, record),
+        active_branch_base_version_label=_resolve_active_branch_base_snapshot_label(versions, record),
+    )
 
 
 @router.post(
@@ -864,6 +998,10 @@ async def publish_study_setup_config(
     record = await study_setup_config_crud.get_by_study(db, study_id)
     if not record:
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="请先保存立项配置草稿")
+    current_project_snapshot_for_publish = _build_project_publish_snapshot(study).model_dump(mode="json")
+    force_create_snapshot = bool(
+        (record.published_project_snapshot or {}) != current_project_snapshot_for_publish
+    )
 
     sites = await site_crud.list_by_study(db, study_id, skip=0, limit=1000, include_inactive=True)
     site_lookup = {str(site.id): site.name or "" for site in sites}
@@ -879,6 +1017,7 @@ async def publish_study_setup_config(
         study_id,
         expected_version=payload.expected_version,
         published_by=current_user.id,
+        force_create_snapshot=force_create_snapshot,
         auto_commit=False,
     )
     if conflict:
@@ -892,7 +1031,7 @@ async def publish_study_setup_config(
         projection = await apply_setup_projection_on_publish(
             db,
             study_id=study_id,
-            setup_data=StudySetupConfigData.model_validate(published.config or {}),
+            setup_data=StudySetupConfigData.model_validate(published.published_config or {}),
             operator_id=current_user.id,
         )
         projection_summary = SetupProjectionSummary(
@@ -907,7 +1046,14 @@ async def publish_study_setup_config(
         )
         study_after_publish = await study_crud.get(db, study_id)
         if study_after_publish:
-            published.published_project_snapshot = _build_project_publish_snapshot(study_after_publish).model_dump(mode="json")
+            project_snapshot = _build_project_publish_snapshot(study_after_publish).model_dump(mode="json")
+            published.published_project_snapshot = project_snapshot
+            await study_setup_config_crud.set_version_project_snapshot(
+                db,
+                study_id,
+                version=published.version,
+                project_snapshot=project_snapshot,
+            )
         await audit_crud.log_action(
             db,
             study_id=study_id,
@@ -926,6 +1072,10 @@ async def publish_study_setup_config(
             operator_role=current_user.role,
             auto_commit=False,
         )
+        published.config = study_setup_config_crud.empty_draft_payload()
+        published.active_branch_base_version_id = None
+        published.saved_by = current_user.id
+        published.updated_at = datetime.utcnow()
         await db.commit()
     except Exception:
         await db.rollback()
@@ -933,10 +1083,13 @@ async def publish_study_setup_config(
 
     operator_name = current_user.full_name or current_user.username or current_user.email
     await db.refresh(published)
+    versions = await study_setup_config_crud.list_versions(db, study_id)
     return _to_setup_config_read(
         published,
         saved_by_name=operator_name,
         published_by_name=operator_name,
+        current_published_version_label=_resolve_current_published_snapshot_label(versions, published),
+        active_branch_base_version_label=_resolve_active_branch_base_snapshot_label(versions, published),
         projection_status=projection.status,
         projection_summary=projection_summary,
     )
@@ -956,6 +1109,9 @@ async def list_study_setup_config_versions(
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="项目不存在")
 
     versions = await study_setup_config_crud.list_versions(db, study_id)
+    current_setup = await study_setup_config_crud.get_by_study(db, study_id)
+    current_published_version = _resolve_current_published_snapshot_version(versions, current_setup)
+    active_draft_base_version = _resolve_active_branch_base_snapshot_version(versions, current_setup)
     user_ids = {item.published_by for item in versions if item.published_by}
     name_map: dict[uuid.UUID, str] = {}
     for user_id in user_ids:
@@ -963,7 +1119,12 @@ async def list_study_setup_config_versions(
         if user:
             name_map[user_id] = user.full_name or user.username or user.email
     return [
-        _to_setup_config_version_read(item, published_by_name=name_map.get(item.published_by) if item.published_by else None)
+        _to_setup_config_version_read(
+            item,
+            published_by_name=name_map.get(item.published_by) if item.published_by else None,
+            is_current_published=item.version == current_published_version,
+            is_active_draft_base=item.version == active_draft_base_version,
+        )
         for item in versions
     ]
 
@@ -982,6 +1143,9 @@ async def rollback_study_setup_config(
     study = await study_crud.get(db, study_id)
     if not study:
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="项目不存在")
+    versions_before = await study_setup_config_crud.list_versions(db, study_id)
+    target_label_map = {item.version: (item.version_label or f"v{item.display_version}") for item in versions_before}
+    target_label = target_label_map.get(payload.target_version, f"v{payload.target_version}")
 
     record, conflict, target_missing = await study_setup_config_crud.rollback_to_version(
         db,
@@ -1003,7 +1167,7 @@ async def rollback_study_setup_config(
         entity_type="study_setup_config",
         entity_id=record.id,
         action="ROLLBACK_SETUP_CONFIG",
-        detail=f"立项配置已回滚到发布版本 v{payload.target_version}",
+        detail=f"立项配置已回滚并替换当前发布为 {target_label}，草稿分支已切换到对应分支基线",
         operator_id=current_user.id,
         operator_role=current_user.role,
     )
@@ -1013,7 +1177,273 @@ async def rollback_study_setup_config(
         user = await user_crud.get_by_id(db, record.published_by)
         if user:
             published_by_name = user.full_name or user.username or user.email
-    return _to_setup_config_read(record, saved_by_name=operator_name, published_by_name=published_by_name)
+    versions = await study_setup_config_crud.list_versions(db, study_id)
+    return _to_setup_config_read(
+        record,
+        saved_by_name=operator_name,
+        published_by_name=published_by_name,
+        current_published_version_label=_resolve_current_published_snapshot_label(versions, record),
+        active_branch_base_version_label=_resolve_active_branch_base_snapshot_label(versions, record),
+    )
+
+
+@router.post(
+    "/{study_id}/setup-config/draft/checkout-branch",
+    response_model=StudySetupConfigRead,
+    dependencies=[Depends(require_study_roles(["PM"])), Depends(require_study_not_locked())],
+)
+async def checkout_study_setup_config_branch_draft(
+    study_id: uuid.UUID,
+    payload: StudySetupConfigCheckoutBranch,
+    db: AsyncSession = Depends(get_db_session),
+    current_user=Depends(get_current_user),
+) -> StudySetupConfigRead:
+    study = await study_crud.get(db, study_id)
+    if not study:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="项目不存在")
+
+    versions_before = await study_setup_config_crud.list_versions(db, study_id)
+    target_label_map = {item.version: (item.version_label or f"v{item.display_version}") for item in versions_before}
+    target_label = target_label_map.get(payload.target_version, f"v{payload.target_version}")
+
+    record, conflict, target_missing = await study_setup_config_crud.checkout_branch_draft_from_version(
+        db,
+        study_id,
+        expected_version=payload.expected_version,
+        target_version=payload.target_version,
+        saved_by=current_user.id,
+    )
+    if conflict:
+        _raise_conflict_error()
+    if target_missing:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="目标版本不存在")
+    if not record:
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="切换分支草稿失败")
+
+    await audit_crud.log_action(
+        db,
+        study_id=study_id,
+        entity_type="study_setup_config",
+        entity_id=record.id,
+        action="CHECKOUT_SETUP_CONFIG_BRANCH_DRAFT",
+        detail=f"立项配置草稿已切换到 {target_label} 对应分支",
+        operator_id=current_user.id,
+        operator_role=current_user.role,
+    )
+    operator_name = current_user.full_name or current_user.username or current_user.email
+    published_by_name = None
+    if record.published_by:
+        user = await user_crud.get_by_id(db, record.published_by)
+        if user:
+            published_by_name = user.full_name or user.username or user.email
+    versions = await study_setup_config_crud.list_versions(db, study_id)
+    return _to_setup_config_read(
+        record,
+        saved_by_name=operator_name,
+        published_by_name=published_by_name,
+        current_published_version_label=_resolve_current_published_snapshot_label(versions, record),
+        active_branch_base_version_label=_resolve_active_branch_base_snapshot_label(versions, record),
+    )
+
+
+@router.post(
+    "/{study_id}/setup-config/draft/clear",
+    response_model=StudySetupConfigRead,
+    dependencies=[Depends(require_study_roles(["PM"])), Depends(require_study_not_locked())],
+)
+async def clear_study_setup_config_draft(
+    study_id: uuid.UUID,
+    payload: StudySetupConfigDraftAction,
+    db: AsyncSession = Depends(get_db_session),
+    current_user=Depends(get_current_user),
+) -> StudySetupConfigRead:
+    study = await study_crud.get(db, study_id)
+    if not study:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="项目不存在")
+
+    record, conflict = await study_setup_config_crud.clear_draft(
+        db,
+        study_id,
+        expected_version=payload.expected_version,
+        saved_by=current_user.id,
+    )
+    if conflict:
+        _raise_conflict_error()
+    if not record:
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="清空草稿失败")
+
+    await audit_crud.log_action(
+        db,
+        study_id=study_id,
+        entity_type="study_setup_config",
+        entity_id=record.id,
+        action="CLEAR_SETUP_CONFIG_DRAFT",
+        detail="立项配置草稿已清空",
+        operator_id=current_user.id,
+        operator_role=current_user.role,
+    )
+    operator_name = current_user.full_name or current_user.username or current_user.email
+    published_by_name = None
+    if record.published_by:
+        user = await user_crud.get_by_id(db, record.published_by)
+        if user:
+            published_by_name = user.full_name or user.username or user.email
+    versions = await study_setup_config_crud.list_versions(db, study_id)
+    return _to_setup_config_read(
+        record,
+        saved_by_name=operator_name,
+        published_by_name=published_by_name,
+        current_published_version_label=_resolve_current_published_snapshot_label(versions, record),
+        active_branch_base_version_label=_resolve_active_branch_base_snapshot_label(versions, record),
+    )
+
+
+@router.post(
+    "/{study_id}/setup-config/draft/refill",
+    response_model=StudySetupConfigRead,
+    dependencies=[Depends(require_study_roles(["PM"])), Depends(require_study_not_locked())],
+)
+async def refill_study_setup_config_draft(
+    study_id: uuid.UUID,
+    payload: StudySetupConfigDraftAction,
+    db: AsyncSession = Depends(get_db_session),
+    current_user=Depends(get_current_user),
+) -> StudySetupConfigRead:
+    study = await study_crud.get(db, study_id)
+    if not study:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="项目不存在")
+
+    record, conflict, no_published = await study_setup_config_crud.refill_draft_from_published(
+        db,
+        study_id,
+        expected_version=payload.expected_version,
+        saved_by=current_user.id,
+    )
+    if conflict:
+        _raise_conflict_error()
+    if no_published:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="当前无已发布版本，无法回填草稿")
+    if not record:
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="回填草稿失败")
+
+    await audit_crud.log_action(
+        db,
+        study_id=study_id,
+        entity_type="study_setup_config",
+        entity_id=record.id,
+        action="REFILL_SETUP_CONFIG_DRAFT",
+        detail="立项配置草稿已从当前发布版本一键回填",
+        operator_id=current_user.id,
+        operator_role=current_user.role,
+    )
+    operator_name = current_user.full_name or current_user.username or current_user.email
+    published_by_name = None
+    if record.published_by:
+        user = await user_crud.get_by_id(db, record.published_by)
+        if user:
+            published_by_name = user.full_name or user.username or user.email
+    versions = await study_setup_config_crud.list_versions(db, study_id)
+    return _to_setup_config_read(
+        record,
+        saved_by_name=operator_name,
+        published_by_name=published_by_name,
+        current_published_version_label=_resolve_current_published_snapshot_label(versions, record),
+        active_branch_base_version_label=_resolve_active_branch_base_snapshot_label(versions, record),
+    )
+
+
+@router.post(
+    "/{study_id}/setup-config/merge-main",
+    response_model=StudySetupConfigRead,
+    dependencies=[Depends(require_study_roles(["PM"])), Depends(require_study_not_locked())],
+)
+async def merge_study_setup_config_to_main(
+    study_id: uuid.UUID,
+    payload: StudySetupConfigMergeToMain,
+    db: AsyncSession = Depends(get_db_session),
+    current_user=Depends(get_current_user),
+) -> StudySetupConfigRead:
+    study = await study_crud.get(db, study_id)
+    if not study:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="项目不存在")
+    versions_before = await study_setup_config_crud.list_versions(db, study_id)
+    source_label_map = {item.version: (item.version_label or f"v{item.display_version}") for item in versions_before}
+    source_label = source_label_map.get(payload.source_version, f"v{payload.source_version}")
+
+    merged, conflict, source_missing = await study_setup_config_crud.merge_to_main(
+        db,
+        study_id,
+        expected_version=payload.expected_version,
+        source_version=payload.source_version,
+        merged_by=current_user.id,
+        auto_commit=False,
+    )
+    if conflict:
+        await db.rollback()
+        _raise_conflict_error()
+    if source_missing:
+        await db.rollback()
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="目标版本不存在")
+    if not merged:
+        await db.rollback()
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="合并主分支失败")
+
+    try:
+        projection = await apply_setup_projection_on_publish(
+            db,
+            study_id=study_id,
+            setup_data=StudySetupConfigData.model_validate(merged.published_config or {}),
+            operator_id=current_user.id,
+        )
+        projection_summary = SetupProjectionSummary(
+            study_updated=projection.study_updated,
+            site_updated_count=projection.site_updated_count,
+            site_skipped_count=projection.site_skipped_count,
+            warnings=projection.warnings,
+            skipped_items=[{"site_id": item.site_id, "reason": item.reason} for item in projection.skipped_items],
+        )
+        study_after_publish = await study_crud.get(db, study_id)
+        if study_after_publish:
+            project_snapshot = _build_project_publish_snapshot(study_after_publish).model_dump(mode="json")
+            merged.published_project_snapshot = project_snapshot
+            await study_setup_config_crud.set_version_project_snapshot(
+                db,
+                study_id,
+                version=merged.version,
+                project_snapshot=project_snapshot,
+            )
+        await audit_crud.log_action(
+            db,
+            study_id=study_id,
+            entity_type="study_setup_config",
+            entity_id=merged.id,
+            action="MERGE_SETUP_CONFIG_TO_MAIN",
+            detail=f"已将发布版本 {source_label} 合并到主分支并生成新主版本",
+            operator_id=current_user.id,
+            operator_role=current_user.role,
+            auto_commit=False,
+        )
+        merged.config = study_setup_config_crud.empty_draft_payload()
+        merged.active_branch_base_version_id = None
+        merged.saved_by = current_user.id
+        merged.updated_at = datetime.utcnow()
+        await db.commit()
+    except Exception:
+        await db.rollback()
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="合并主分支失败：联动同步异常")
+
+    operator_name = current_user.full_name or current_user.username or current_user.email
+    await db.refresh(merged)
+    versions = await study_setup_config_crud.list_versions(db, study_id)
+    return _to_setup_config_read(
+        merged,
+        saved_by_name=operator_name,
+        published_by_name=operator_name,
+        current_published_version_label=_resolve_current_published_snapshot_label(versions, merged),
+        active_branch_base_version_label=_resolve_active_branch_base_snapshot_label(versions, merged),
+        projection_status=projection.status,
+        projection_summary=projection_summary,
+    )
 
 
 @router.delete(
@@ -1034,9 +1464,12 @@ async def delete_study_setup_config_version(
     versions = await study_setup_config_crud.list_versions(db, study_id)
     if not versions:
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="目标版本不存在")
-    latest_version = max(item.version for item in versions)
-    if target_version == latest_version:
-        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="最新发布版本不能删除")
+    current_setup = await study_setup_config_crud.get_by_study(db, study_id)
+    current_published_version = _resolve_current_published_snapshot_version(versions, current_setup)
+    if current_published_version is None:
+        current_published_version = max(item.version for item in versions)
+    if target_version == current_published_version:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="当前发布版本不能删除")
 
     deleted = await study_setup_config_crud.delete_version(
         db,
diff --git a/backend/app/crud/study_setup_config.py b/backend/app/crud/study_setup_config.py
index 8f31a877..51be2369 100644
--- a/backend/app/crud/study_setup_config.py
+++ b/backend/app/crud/study_setup_config.py
@@ -2,7 +2,7 @@ import uuid
 from copy import deepcopy
 from datetime import datetime
 
-from sqlalchemy import delete as sa_delete, select
+from sqlalchemy import delete as sa_delete, select, update as sa_update
 from sqlalchemy import func
 from sqlalchemy.ext.asyncio import AsyncSession
 
@@ -10,6 +10,8 @@ from app.models.study_setup_config import StudySetupConfig
 from app.models.study_setup_config_version import StudySetupConfigVersion
 from app.schemas.study_setup_config import StudySetupConfigData
 
+MAIN_BRANCH = "main"
+
 
 def _to_storage(data: StudySetupConfigData | dict) -> dict:
     if isinstance(data, StudySetupConfigData):
@@ -17,6 +19,130 @@ def _to_storage(data: StudySetupConfigData | dict) -> dict:
     return deepcopy(data)
 
 
+def empty_draft_payload() -> dict:
+    return StudySetupConfigData().model_dump(mode="json")
+
+
+def _build_release_branch_name(base_display_version: int) -> str:
+    return f"release/v{base_display_version}"
+
+
+def _parse_release_branch_base_display_version(branch_name: str) -> int | None:
+    prefix = "release/v"
+    if not branch_name.startswith(prefix):
+        return None
+    suffix = branch_name[len(prefix) :]
+    if not suffix.isdigit():
+        return None
+    return int(suffix)
+
+
+def _build_version_label(branch_name: str, *, display_version: int, branch_seq: int) -> str:
+    if branch_name == MAIN_BRANCH:
+        return f"v{display_version}"
+    return f"v{display_version}.{branch_seq}"
+
+
+async def _get_snapshot_by_version(
+    db: AsyncSession,
+    *,
+    study_id: uuid.UUID,
+    version: int,
+) -> StudySetupConfigVersion | None:
+    result = await db.execute(
+        select(StudySetupConfigVersion).where(
+            StudySetupConfigVersion.study_id == study_id,
+            StudySetupConfigVersion.version == version,
+        )
+    )
+    return result.scalar_one_or_none()
+
+
+async def _get_snapshot_by_id(
+    db: AsyncSession,
+    *,
+    snapshot_id: uuid.UUID,
+) -> StudySetupConfigVersion | None:
+    result = await db.execute(select(StudySetupConfigVersion).where(StudySetupConfigVersion.id == snapshot_id))
+    return result.scalar_one_or_none()
+
+
+async def _get_latest_snapshot_in_branch(
+    db: AsyncSession,
+    *,
+    study_id: uuid.UUID,
+    branch_name: str,
+) -> StudySetupConfigVersion | None:
+    result = await db.execute(
+        select(StudySetupConfigVersion)
+        .where(
+            StudySetupConfigVersion.study_id == study_id,
+            StudySetupConfigVersion.branch_name == branch_name,
+        )
+        .order_by(
+            StudySetupConfigVersion.branch_seq.desc(),
+            StudySetupConfigVersion.version.desc(),
+            StudySetupConfigVersion.published_at.desc(),
+        )
+        .limit(1)
+    )
+    return result.scalar_one_or_none()
+
+
+async def _get_main_next_display_version(db: AsyncSession, *, study_id: uuid.UUID) -> int:
+    result = await db.execute(
+        select(func.max(StudySetupConfigVersion.display_version)).where(
+            StudySetupConfigVersion.study_id == study_id,
+            StudySetupConfigVersion.branch_name == MAIN_BRANCH,
+        )
+    )
+    current_max = result.scalar_one_or_none() or 0
+    return current_max + 1
+
+
+async def _get_branch_next_seq(
+    db: AsyncSession,
+    *,
+    study_id: uuid.UUID,
+    branch_name: str,
+) -> int:
+    result = await db.execute(
+        select(func.max(StudySetupConfigVersion.branch_seq)).where(
+            StudySetupConfigVersion.study_id == study_id,
+            StudySetupConfigVersion.branch_name == branch_name,
+        )
+    )
+    current_max = result.scalar_one_or_none() or 0
+    return current_max + 1
+
+
+async def _resolve_current_published_snapshot_id(
+    db: AsyncSession,
+    *,
+    study_id: uuid.UUID,
+    published_config: dict | None,
+    published_by: uuid.UUID | None,
+    published_at: datetime | None,
+) -> uuid.UUID | None:
+    if not published_config:
+        return None
+    rows = await list_versions(db, study_id)
+    best_score = -1
+    best_id: uuid.UUID | None = None
+    for item in rows:
+        if (item.config or {}) != (published_config or {}):
+            continue
+        score = 1
+        if published_at and item.published_at == published_at:
+            score += 2
+        if published_by and item.published_by == published_by:
+            score += 1
+        if score > best_score:
+            best_score = score
+            best_id = item.id
+    return best_id
+
+
 async def get_by_study(db: AsyncSession, study_id: uuid.UUID) -> StudySetupConfig | None:
     result = await db.execute(select(StudySetupConfig).where(StudySetupConfig.study_id == study_id))
     return result.scalar_one_or_none()
@@ -56,6 +182,7 @@ async def upsert(
         version=1,
         config=payload,
         publish_status="DRAFT",
+        current_branch_name=MAIN_BRANCH,
         saved_by=saved_by,
     )
     db.add(record)
@@ -70,6 +197,7 @@ async def publish(
     *,
     expected_version: int | None,
     published_by: uuid.UUID | None,
+    force_create_snapshot: bool = False,
     auto_commit: bool = True,
 ) -> tuple[StudySetupConfig | None, bool]:
     existing = await get_by_study(db, study_id)
@@ -79,15 +207,15 @@ async def publish(
         return None, True
     publish_payload = _to_storage(existing.config or {})
     next_version = existing.version + 1
-    latest_snapshot_stmt = (
-        select(StudySetupConfigVersion)
-        .where(StudySetupConfigVersion.study_id == study_id)
-        .order_by(StudySetupConfigVersion.version.desc(), StudySetupConfigVersion.published_at.desc())
-        .limit(1)
-    )
-    latest_snapshot_result = await db.execute(latest_snapshot_stmt)
-    latest_snapshot = latest_snapshot_result.scalar_one_or_none()
-    should_create_snapshot = not latest_snapshot or (latest_snapshot.config or {}) != publish_payload
+    branch_name = (existing.current_branch_name or MAIN_BRANCH).strip() or MAIN_BRANCH
+    current_published_snapshot: StudySetupConfigVersion | None = None
+    current_published_branch = ""
+    if existing.current_published_version_id:
+        current_published_snapshot = await _get_snapshot_by_id(db, snapshot_id=existing.current_published_version_id)
+        if current_published_snapshot:
+            current_published_branch = (current_published_snapshot.branch_name or MAIN_BRANCH).strip() or MAIN_BRANCH
+    branch_changed = bool(current_published_branch and current_published_branch != branch_name)
+    should_create_snapshot = force_create_snapshot or (existing.published_config or {}) != publish_payload or branch_changed
 
     existing.version = next_version
     existing.publish_status = "PUBLISHED"
@@ -98,23 +226,58 @@ async def publish(
     existing.updated_at = datetime.utcnow()
 
     if should_create_snapshot:
-        next_display_version_stmt = select(func.max(StudySetupConfigVersion.display_version)).where(
-            StudySetupConfigVersion.study_id == study_id
-        )
-        display_version_result = await db.execute(next_display_version_stmt)
-        current_max_display_version = display_version_result.scalar_one_or_none() or 0
-        next_display_version = current_max_display_version + 1
+        parent_snapshot_id = existing.active_branch_base_version_id
+        if parent_snapshot_id is None:
+            latest_branch_snapshot = await _get_latest_snapshot_in_branch(db, study_id=study_id, branch_name=branch_name)
+            parent_snapshot_id = latest_branch_snapshot.id if latest_branch_snapshot else None
+
+        if branch_name == MAIN_BRANCH:
+            next_display_version = await _get_main_next_display_version(db, study_id=study_id)
+            next_branch_seq = await _get_branch_next_seq(db, study_id=study_id, branch_name=branch_name)
+        else:
+            next_branch_seq = await _get_branch_next_seq(db, study_id=study_id, branch_name=branch_name)
+            branch_base = _parse_release_branch_base_display_version(branch_name)
+            if branch_base is None:
+                # Fall back to parent/main latest when branch name is customized.
+                if parent_snapshot_id:
+                    parent_result = await db.execute(
+                        select(StudySetupConfigVersion.display_version).where(StudySetupConfigVersion.id == parent_snapshot_id)
+                    )
+                    branch_base = parent_result.scalar_one_or_none()
+                if branch_base is None:
+                    branch_base = await _get_main_next_display_version(db, study_id=study_id) - 1
+            next_display_version = branch_base
+
         snapshot = StudySetupConfigVersion(
             study_setup_config_id=existing.id,
             study_id=study_id,
             version=next_version,
             display_version=next_display_version,
+            branch_name=branch_name,
+            branch_seq=next_branch_seq,
+            version_label=_build_version_label(
+                branch_name,
+                display_version=next_display_version,
+                branch_seq=next_branch_seq,
+            ),
             source_version=next_version - 1,
+            parent_version_id=parent_snapshot_id,
             config=_to_storage(publish_payload),
             published_by=published_by,
             published_at=existing.published_at,
         )
         db.add(snapshot)
+        existing.current_published_version_id = snapshot.id
+        existing.active_branch_base_version_id = snapshot.id
+    else:
+        if not existing.current_published_version_id:
+            existing.current_published_version_id = await _resolve_current_published_snapshot_id(
+                db,
+                study_id=study_id,
+                published_config=existing.published_config,
+                published_by=existing.published_by,
+                published_at=existing.published_at,
+            )
 
     if auto_commit:
         await db.commit()
@@ -133,6 +296,21 @@ async def list_versions(db: AsyncSession, study_id: uuid.UUID) -> list[StudySetu
     return list(result.scalars().all())
 
 
+async def set_version_project_snapshot(
+    db: AsyncSession,
+    study_id: uuid.UUID,
+    *,
+    version: int,
+    project_snapshot: dict | None,
+) -> bool:
+    target = await _get_snapshot_by_version(db, study_id=study_id, version=version)
+    if not target:
+        return False
+    target.published_project_snapshot = _to_storage(project_snapshot) if project_snapshot else None
+    await db.flush()
+    return True
+
+
 async def rollback_to_version(
     db: AsyncSession,
     study_id: uuid.UUID,
@@ -147,23 +325,200 @@ async def rollback_to_version(
     if expected_version is not None and expected_version != existing.version:
         return None, True, False
 
-    result = await db.execute(
-        select(StudySetupConfigVersion).where(
-            StudySetupConfigVersion.study_id == study_id,
-            StudySetupConfigVersion.version == target_version,
-        )
-    )
-    target = result.scalar_one_or_none()
+    target = await _get_snapshot_by_version(db, study_id=study_id, version=target_version)
     if not target:
         return None, False, True
 
+    target_display_version = target.display_version or 0
+    target_branch = (target.branch_name or MAIN_BRANCH).strip() or MAIN_BRANCH
+    if target_branch == MAIN_BRANCH:
+        branch_name = _build_release_branch_name(target_display_version)
+    else:
+        branch_name = target_branch
+
+    now = datetime.utcnow()
+    existing.version = existing.version + 1
+    target_config = _to_storage(target.config or {})
+    existing.config = target_config
+    existing.published_config = _to_storage(target.config or {})
+    existing.published_project_snapshot = (
+        _to_storage(target.published_project_snapshot) if target.published_project_snapshot else None
+    )
+    existing.current_branch_name = branch_name
+    existing.active_branch_base_version_id = target.id
+    existing.current_published_version_id = target.id
+    existing.saved_by = saved_by
+    existing.published_by = saved_by
+    existing.published_at = now
+    existing.publish_status = "PUBLISHED"
+    existing.updated_at = now
+    await db.commit()
+    await db.refresh(existing)
+    return existing, False, False
+
+
+async def checkout_branch_draft_from_version(
+    db: AsyncSession,
+    study_id: uuid.UUID,
+    *,
+    expected_version: int | None,
+    target_version: int,
+    saved_by: uuid.UUID | None,
+) -> tuple[StudySetupConfig | None, bool, bool]:
+    existing = await get_by_study(db, study_id)
+    if not existing:
+        return None, False, False
+    if expected_version is not None and expected_version != existing.version:
+        return None, True, False
+
+    target = await _get_snapshot_by_version(db, study_id=study_id, version=target_version)
+    if not target:
+        return None, False, True
+
+    target_display_version = target.display_version or 0
+    target_branch = (target.branch_name or MAIN_BRANCH).strip() or MAIN_BRANCH
+    if target_branch == MAIN_BRANCH:
+        checkout_branch = _build_release_branch_name(target_display_version)
+    else:
+        checkout_branch = target_branch
+
+    now = datetime.utcnow()
     existing.version = existing.version + 1
     existing.config = _to_storage(target.config or {})
+    existing.current_branch_name = checkout_branch
+    existing.active_branch_base_version_id = target.id
     existing.saved_by = saved_by
+    existing.publish_status = "PUBLISHED" if (existing.published_config or {}) == (existing.config or {}) else "DRAFT"
+    existing.updated_at = now
+    await db.commit()
+    await db.refresh(existing)
+    return existing, False, False
+
+
+async def clear_draft(
+    db: AsyncSession,
+    study_id: uuid.UUID,
+    *,
+    expected_version: int | None,
+    saved_by: uuid.UUID | None,
+) -> tuple[StudySetupConfig | None, bool]:
+    existing = await get_by_study(db, study_id)
+    if not existing:
+        return None, False
+    if expected_version is not None and expected_version != existing.version:
+        return None, True
+
+    existing.version = existing.version + 1
+    existing.config = empty_draft_payload()
+    existing.saved_by = saved_by
+    existing.active_branch_base_version_id = None
     existing.publish_status = "DRAFT"
     existing.updated_at = datetime.utcnow()
     await db.commit()
     await db.refresh(existing)
+    return existing, False
+
+
+async def refill_draft_from_published(
+    db: AsyncSession,
+    study_id: uuid.UUID,
+    *,
+    expected_version: int | None,
+    saved_by: uuid.UUID | None,
+) -> tuple[StudySetupConfig | None, bool, bool]:
+    existing = await get_by_study(db, study_id)
+    if not existing:
+        return None, False, False
+    if expected_version is not None and expected_version != existing.version:
+        return None, True, False
+    if not existing.published_config:
+        return None, False, True
+
+    existing.version = existing.version + 1
+    existing.config = _to_storage(existing.published_config or {})
+    existing.saved_by = saved_by
+    if existing.current_published_version_id:
+        snapshot = await _get_snapshot_by_id(db, snapshot_id=existing.current_published_version_id)
+        if snapshot:
+            if not (existing.current_branch_name or "").strip():
+                existing.current_branch_name = snapshot.branch_name or MAIN_BRANCH
+            if existing.active_branch_base_version_id is None:
+                existing.active_branch_base_version_id = snapshot.id
+    existing.publish_status = "PUBLISHED" if (existing.published_config or {}) == (existing.config or {}) else "DRAFT"
+    existing.updated_at = datetime.utcnow()
+    await db.commit()
+    await db.refresh(existing)
+    return existing, False, False
+
+
+async def merge_to_main(
+    db: AsyncSession,
+    study_id: uuid.UUID,
+    *,
+    expected_version: int | None,
+    source_version: int,
+    merged_by: uuid.UUID | None,
+    auto_commit: bool = True,
+) -> tuple[StudySetupConfig | None, bool, bool]:
+    existing = await get_by_study(db, study_id)
+    if not existing:
+        return None, False, False
+    if expected_version is not None and expected_version != existing.version:
+        return None, True, False
+
+    source = await _get_snapshot_by_version(db, study_id=study_id, version=source_version)
+    if not source:
+        return None, False, True
+
+    payload = _to_storage(source.config or {})
+    next_version = existing.version + 1
+    now = datetime.utcnow()
+    latest_main_snapshot = await _get_latest_snapshot_in_branch(db, study_id=study_id, branch_name=MAIN_BRANCH)
+    parent_snapshot_id = latest_main_snapshot.id if latest_main_snapshot else None
+    next_main_display_version = await _get_main_next_display_version(db, study_id=study_id)
+    next_main_branch_seq = await _get_branch_next_seq(db, study_id=study_id, branch_name=MAIN_BRANCH)
+    snapshot = StudySetupConfigVersion(
+        study_setup_config_id=existing.id,
+        study_id=study_id,
+        version=next_version,
+        display_version=next_main_display_version,
+        branch_name=MAIN_BRANCH,
+        branch_seq=next_main_branch_seq,
+        version_label=_build_version_label(
+            MAIN_BRANCH,
+            display_version=next_main_display_version,
+            branch_seq=next_main_branch_seq,
+        ),
+        source_version=source.version,
+        parent_version_id=parent_snapshot_id,
+        merged_from_version_id=source.id,
+        config=payload,
+        published_project_snapshot=_to_storage(source.published_project_snapshot) if source.published_project_snapshot else None,
+        published_by=merged_by,
+        published_at=now,
+    )
+    db.add(snapshot)
+
+    existing.version = next_version
+    existing.config = payload
+    existing.publish_status = "PUBLISHED"
+    existing.published_config = _to_storage(payload)
+    existing.published_project_snapshot = (
+        _to_storage(source.published_project_snapshot) if source.published_project_snapshot else None
+    )
+    existing.published_by = merged_by
+    existing.published_at = now
+    existing.saved_by = merged_by
+    existing.current_branch_name = MAIN_BRANCH
+    existing.active_branch_base_version_id = snapshot.id
+    existing.current_published_version_id = snapshot.id
+    existing.updated_at = now
+
+    if auto_commit:
+        await db.commit()
+        await db.refresh(existing)
+    else:
+        await db.flush()
     return existing, False, False
 
 
@@ -173,21 +528,25 @@ async def delete_version(
     *,
     target_version: int,
 ) -> bool:
-    result = await db.execute(
-        select(StudySetupConfigVersion).where(
-            StudySetupConfigVersion.study_id == study_id,
-            StudySetupConfigVersion.version == target_version,
-        )
-    )
-    target = result.scalar_one_or_none()
+    target = await _get_snapshot_by_version(db, study_id=study_id, version=target_version)
     if not target:
         return False
+    await db.execute(
+        sa_update(StudySetupConfig)
+        .where(StudySetupConfig.study_id == study_id, StudySetupConfig.active_branch_base_version_id == target.id)
+        .values(active_branch_base_version_id=None)
+    )
+    await db.execute(
+        sa_update(StudySetupConfig)
+        .where(StudySetupConfig.study_id == study_id, StudySetupConfig.current_published_version_id == target.id)
+        .values(current_published_version_id=None)
+    )
     await db.delete(target)
     await db.commit()
     return True
 
 
 async def delete_by_study(db: AsyncSession, study_id: uuid.UUID) -> None:
-    await db.execute(sa_delete(StudySetupConfigVersion).where(StudySetupConfigVersion.study_id == study_id))
     await db.execute(sa_delete(StudySetupConfig).where(StudySetupConfig.study_id == study_id))
+    await db.execute(sa_delete(StudySetupConfigVersion).where(StudySetupConfigVersion.study_id == study_id))
     await db.commit()
diff --git a/backend/app/models/study_setup_config.py b/backend/app/models/study_setup_config.py
index 4dea6071..0773e39c 100644
--- a/backend/app/models/study_setup_config.py
+++ b/backend/app/models/study_setup_config.py
@@ -19,6 +19,13 @@ class StudySetupConfig(Base):
     publish_status: Mapped[str] = mapped_column(default="DRAFT", nullable=False)
     published_config: Mapped[dict | None] = mapped_column(JSONB, nullable=True)
     published_project_snapshot: Mapped[dict | None] = mapped_column(JSONB, nullable=True)
+    current_branch_name: Mapped[str] = mapped_column(nullable=False, default="main")
+    active_branch_base_version_id: Mapped[uuid.UUID | None] = mapped_column(
+        UUID(as_uuid=True), ForeignKey("study_setup_config_versions.id", ondelete="SET NULL"), nullable=True
+    )
+    current_published_version_id: Mapped[uuid.UUID | None] = mapped_column(
+        UUID(as_uuid=True), ForeignKey("study_setup_config_versions.id", ondelete="SET NULL"), nullable=True
+    )
     published_by: Mapped[uuid.UUID | None] = mapped_column(UUID(as_uuid=True), ForeignKey("users.id"), nullable=True)
     published_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
     saved_by: Mapped[uuid.UUID | None] = mapped_column(UUID(as_uuid=True), ForeignKey("users.id"), nullable=True)
diff --git a/backend/app/models/study_setup_config_version.py b/backend/app/models/study_setup_config_version.py
index 3ad6cf7a..1bcc33cd 100644
--- a/backend/app/models/study_setup_config_version.py
+++ b/backend/app/models/study_setup_config_version.py
@@ -12,7 +12,7 @@ class StudySetupConfigVersion(Base):
     __tablename__ = "study_setup_config_versions"
     __table_args__ = (
         UniqueConstraint("study_id", "version", name="uq_setup_config_versions_study_version"),
-        UniqueConstraint("study_id", "display_version", name="uq_setup_config_versions_study_display_version"),
+        UniqueConstraint("study_id", "branch_name", "branch_seq", name="uq_setup_config_versions_study_branch_seq"),
     )
 
     id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
@@ -22,8 +22,18 @@ class StudySetupConfigVersion(Base):
     study_id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), ForeignKey("studies.id"), nullable=False, index=True)
     version: Mapped[int] = mapped_column(Integer, nullable=False)
     display_version: Mapped[int] = mapped_column(Integer, nullable=False)
+    branch_name: Mapped[str] = mapped_column(nullable=False, default="main")
+    branch_seq: Mapped[int] = mapped_column(Integer, nullable=False, default=1)
+    version_label: Mapped[str] = mapped_column(nullable=False, default="")
     source_version: Mapped[int | None] = mapped_column(Integer, nullable=True)
+    parent_version_id: Mapped[uuid.UUID | None] = mapped_column(
+        UUID(as_uuid=True), ForeignKey("study_setup_config_versions.id", ondelete="SET NULL"), nullable=True
+    )
+    merged_from_version_id: Mapped[uuid.UUID | None] = mapped_column(
+        UUID(as_uuid=True), ForeignKey("study_setup_config_versions.id", ondelete="SET NULL"), nullable=True
+    )
     config: Mapped[dict] = mapped_column(JSONB, nullable=False)
+    published_project_snapshot: Mapped[dict | None] = mapped_column(JSONB, nullable=True)
     published_by: Mapped[uuid.UUID | None] = mapped_column(UUID(as_uuid=True), ForeignKey("users.id"), nullable=True)
     published_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
     created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
diff --git a/backend/app/schemas/study_setup_config.py b/backend/app/schemas/study_setup_config.py
index ce719529..0183a4ba 100644
--- a/backend/app/schemas/study_setup_config.py
+++ b/backend/app/schemas/study_setup_config.py
@@ -92,14 +92,36 @@ class StudySetupConfigRollback(BaseModel):
     target_version: int
 
 
+class StudySetupConfigCheckoutBranch(BaseModel):
+    expected_version: int | None = None
+    target_version: int
+
+
+class StudySetupConfigDraftAction(BaseModel):
+    expected_version: int | None = None
+
+
+class StudySetupConfigMergeToMain(BaseModel):
+    expected_version: int | None = None
+    source_version: int
+
+
 class StudySetupConfigVersionRead(BaseModel):
     id: uuid.UUID
     study_id: uuid.UUID
     study_setup_config_id: uuid.UUID
     version: int
     display_version: int
+    branch_name: str = "main"
+    branch_seq: int = 1
+    version_label: str = ""
     source_version: int | None = None
+    parent_version_id: uuid.UUID | None = None
+    merged_from_version_id: uuid.UUID | None = None
     config: StudySetupConfigData
+    published_project_snapshot: "ProjectPublishSnapshot | None" = None
+    is_current_published: bool = False
+    is_active_draft_base: bool = False
     published_by: uuid.UUID | None = None
     published_by_name: str | None = None
     published_at: datetime
@@ -153,6 +175,11 @@ class StudySetupConfigRead(BaseModel):
     id: uuid.UUID
     study_id: uuid.UUID
     version: int
+    current_branch_name: str = "main"
+    current_published_version_id: uuid.UUID | None = None
+    current_published_version_label: str | None = None
+    active_branch_base_version_id: uuid.UUID | None = None
+    active_branch_base_version_label: str | None = None
     data: StudySetupConfigData
     publish_status: str
     published_data: StudySetupConfigData | None = None
diff --git a/backend/scripts/smoke_setup_config.py b/backend/scripts/smoke_setup_config.py
index 1788aecc..857def60 100644
--- a/backend/scripts/smoke_setup_config.py
+++ b/backend/scripts/smoke_setup_config.py
@@ -370,7 +370,7 @@ def main() -> int:
     )
     assert_or_exit(status == 200, f"回滚失败 status={status} body={rolled}")
     assert_or_exit(
-        rolled.get("publish_status") == "DRAFT"
+        rolled.get("publish_status") == "PUBLISHED"
         and (rolled.get("data") or {}).get("enrollmentPlan", {}).get("totalTarget") == payload["data"]["enrollmentPlan"]["totalTarget"],
         f"回滚结果异常 body={rolled}",
     )
diff --git a/docker-compose.yaml b/docker-compose.yaml
index 4aee40f4..ba85f58a 100755
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -53,6 +53,7 @@ services:
       context: ./frontend
       dockerfile: Dockerfile
     container_name: ctms_frontend
+    restart: always
     # 开启 Host 模式以支持 Vite 热更新
     command: npm run dev -- --host
     volumes:
@@ -63,6 +64,7 @@ services:
       - "5173:5173"
     environment:
       VITE_API_BASE_URL: /
+      NODE_OPTIONS: --max-old-space-size=4096
     depends_on:
       - backend
     networks:
diff --git a/frontend/src/api/studies.ts b/frontend/src/api/studies.ts
index 82472f4f..e1ef8b48 100644
--- a/frontend/src/api/studies.ts
+++ b/frontend/src/api/studies.ts
@@ -1,7 +1,10 @@
 import { apiGet, apiPatch, apiPost, apiDelete, apiPut } from "./axios";
 import type { ApiListResponse, Study } from "../types/api";
 import type {
+  StudySetupConfigCheckoutBranchPayload,
+  StudySetupConfigDraftActionPayload,
   StudySetupConfigPublishPayload,
+  StudySetupConfigMergeMainPayload,
   StudySetupConfigResponse,
   StudySetupConfigRollbackPayload,
   StudySetupConfigUpsertPayload,
@@ -42,3 +45,17 @@ export const deleteStudySetupConfigVersion = (studyId: string, targetVersion: nu
 
 export const rollbackStudySetupConfig = (studyId: string, payload: StudySetupConfigRollbackPayload) =>
   apiPost<StudySetupConfigResponse>(`/api/v1/studies/${studyId}/setup-config/rollback`, payload, { suppressErrorMessage: true });
+
+export const checkoutStudySetupConfigBranchDraft = (studyId: string, payload: StudySetupConfigCheckoutBranchPayload) =>
+  apiPost<StudySetupConfigResponse>(`/api/v1/studies/${studyId}/setup-config/draft/checkout-branch`, payload, {
+    suppressErrorMessage: true,
+  });
+
+export const clearStudySetupConfigDraft = (studyId: string, payload: StudySetupConfigDraftActionPayload) =>
+  apiPost<StudySetupConfigResponse>(`/api/v1/studies/${studyId}/setup-config/draft/clear`, payload, { suppressErrorMessage: true });
+
+export const refillStudySetupConfigDraft = (studyId: string, payload: StudySetupConfigDraftActionPayload) =>
+  apiPost<StudySetupConfigResponse>(`/api/v1/studies/${studyId}/setup-config/draft/refill`, payload, { suppressErrorMessage: true });
+
+export const mergeStudySetupConfigToMain = (studyId: string, payload: StudySetupConfigMergeMainPayload) =>
+  apiPost<StudySetupConfigResponse>(`/api/v1/studies/${studyId}/setup-config/merge-main`, payload, { suppressErrorMessage: true });
diff --git a/frontend/src/composables/useSetupConfig.ts b/frontend/src/composables/useSetupConfig.ts
index e90b15fe..7a95b98f 100644
--- a/frontend/src/composables/useSetupConfig.ts
+++ b/frontend/src/composables/useSetupConfig.ts
@@ -1,12 +1,19 @@
 import {
+  checkoutStudySetupConfigBranchDraft,
+  clearStudySetupConfigDraft,
   deleteStudySetupConfigVersion,
   fetchStudySetupConfig,
   fetchStudySetupConfigVersions,
+  mergeStudySetupConfigToMain,
   publishStudySetupConfig,
+  refillStudySetupConfigDraft,
   rollbackStudySetupConfig,
   saveStudySetupConfig,
 } from "../api/studies";
 import type {
+  StudySetupConfigCheckoutBranchPayload,
+  StudySetupConfigDraftActionPayload,
+  StudySetupConfigMergeMainPayload,
   StudySetupConfigPublishPayload,
   StudySetupConfigRollbackPayload,
   StudySetupConfigUpsertPayload,
@@ -16,16 +23,25 @@ export const useSetupConfig = () => {
   const getConfig = (studyId: string) => fetchStudySetupConfig(studyId);
   const saveConfig = (studyId: string, payload: StudySetupConfigUpsertPayload) => saveStudySetupConfig(studyId, payload);
   const publishConfig = (studyId: string, payload: StudySetupConfigPublishPayload) => publishStudySetupConfig(studyId, payload);
+  const mergeToMain = (studyId: string, payload: StudySetupConfigMergeMainPayload) => mergeStudySetupConfigToMain(studyId, payload);
   const listVersions = (studyId: string) => fetchStudySetupConfigVersions(studyId);
   const rollbackConfig = (studyId: string, payload: StudySetupConfigRollbackPayload) => rollbackStudySetupConfig(studyId, payload);
+  const checkoutBranchDraft = (studyId: string, payload: StudySetupConfigCheckoutBranchPayload) =>
+    checkoutStudySetupConfigBranchDraft(studyId, payload);
+  const clearDraft = (studyId: string, payload: StudySetupConfigDraftActionPayload) => clearStudySetupConfigDraft(studyId, payload);
+  const refillDraft = (studyId: string, payload: StudySetupConfigDraftActionPayload) => refillStudySetupConfigDraft(studyId, payload);
   const deleteVersion = (studyId: string, targetVersion: number) => deleteStudySetupConfigVersion(studyId, targetVersion);
 
   return {
     getConfig,
     saveConfig,
     publishConfig,
+    mergeToMain,
     listVersions,
     rollbackConfig,
+    checkoutBranchDraft,
+    clearDraft,
+    refillDraft,
     deleteVersion,
   };
 };
diff --git a/frontend/src/types/setupConfig.ts b/frontend/src/types/setupConfig.ts
index 1ba42fa3..700a3996 100644
--- a/frontend/src/types/setupConfig.ts
+++ b/frontend/src/types/setupConfig.ts
@@ -98,6 +98,11 @@ export interface StudySetupConfigResponse {
   id: string;
   study_id: string;
   version: number;
+  current_branch_name?: string;
+  current_published_version_id?: string | null;
+  current_published_version_label?: string | null;
+  active_branch_base_version_id?: string | null;
+  active_branch_base_version_label?: string | null;
   data: SetupConfigDraft;
   publish_status: "DRAFT" | "PUBLISHED" | string;
   published_data?: SetupConfigDraft | null;
@@ -134,14 +139,36 @@ export interface StudySetupConfigRollbackPayload {
   target_version: number;
 }
 
+export interface StudySetupConfigCheckoutBranchPayload {
+  expected_version?: number | null;
+  target_version: number;
+}
+
+export interface StudySetupConfigMergeMainPayload {
+  expected_version?: number | null;
+  source_version: number;
+}
+
+export interface StudySetupConfigDraftActionPayload {
+  expected_version?: number | null;
+}
+
 export interface StudySetupConfigVersionItem {
   id: string;
   study_id: string;
   study_setup_config_id: string;
   version: number;
   display_version: number;
+  branch_name?: string;
+  branch_seq?: number;
+  version_label?: string;
   source_version?: number | null;
+  parent_version_id?: string | null;
+  merged_from_version_id?: string | null;
   config: SetupConfigDraft;
+  published_project_snapshot?: ProjectPublishSnapshot | null;
+  is_current_published?: boolean;
+  is_active_draft_base?: boolean;
   published_by?: string | null;
   published_by_name?: string | null;
   published_at: string;
diff --git a/frontend/src/utils/setupDiffRows.ts b/frontend/src/utils/setupDiffRows.ts
index 26ddfe89..28666ea3 100644
--- a/frontend/src/utils/setupDiffRows.ts
+++ b/frontend/src/utils/setupDiffRows.ts
@@ -107,6 +107,38 @@ const getArrayRowIdentity = (moduleKey: keyof SetupConfigDraft, value: unknown):
   return "";
 };
 
+type ArrayRowEntry = {
+  key: string;
+  value: unknown;
+  rowIdentity: string;
+};
+
+const buildArrayRowEntry = (moduleKey: keyof SetupConfigDraft, value: unknown, index: number): ArrayRowEntry => {
+  const rowIdentity = getArrayRowIdentity(moduleKey, value);
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const id = String((value as Record<string, unknown>).id || "").trim();
+    if (id) {
+      return {
+        key: `id:${id}`,
+        value,
+        rowIdentity,
+      };
+    }
+  }
+  if (rowIdentity) {
+    return {
+      key: `identity:${rowIdentity}`,
+      value,
+      rowIdentity,
+    };
+  }
+  return {
+    key: `index:${index}`,
+    value,
+    rowIdentity: "",
+  };
+};
+
 const formatReadablePath = (moduleKey: keyof SetupConfigDraft, path: string): string => {
   let normalized = path;
   if (path === moduleKey) {
@@ -247,11 +279,47 @@ const collectDiffRows = (
   if (Array.isArray(localValue) || Array.isArray(serverValue)) {
     const localArr = Array.isArray(localValue) ? localValue : [];
     const serverArr = Array.isArray(serverValue) ? serverValue : [];
-    const maxLen = Math.max(localArr.length, serverArr.length);
-    for (let i = 0; i < maxLen; i += 1) {
-      const rowIdentity = getArrayRowIdentity(moduleKey, localArr[i] ?? serverArr[i]);
-      const indexLabel = rowIdentity ? `${i}|${rowIdentity}` : `${i}`;
-      collectDiffRows(moduleKey, moduleLabel, localArr[i], serverArr[i], `${path}[${indexLabel}]`, rows);
+
+    const localEntryMap = new Map<string, ArrayRowEntry[]>();
+    localArr.forEach((item, index) => {
+      const entry = buildArrayRowEntry(moduleKey, item, index);
+      const list = localEntryMap.get(entry.key);
+      if (list) {
+        list.push(entry);
+      } else {
+        localEntryMap.set(entry.key, [entry]);
+      }
+    });
+
+    const consumeLocalEntry = (key: string): ArrayRowEntry | null => {
+      const list = localEntryMap.get(key);
+      if (!list || list.length === 0) return null;
+      const entry = list.shift() || null;
+      if (list.length === 0) localEntryMap.delete(key);
+      return entry;
+    };
+
+    let pairIndex = 0;
+    serverArr.forEach((item, index) => {
+      const serverEntry = buildArrayRowEntry(moduleKey, item, index);
+      const localEntry = consumeLocalEntry(serverEntry.key);
+      const rowIdentity = (localEntry?.rowIdentity || serverEntry.rowIdentity || "").trim();
+      const indexLabel = rowIdentity ? `${pairIndex}|${rowIdentity}` : `${pairIndex}`;
+      collectDiffRows(moduleKey, moduleLabel, localEntry?.value, serverEntry.value, `${path}[${indexLabel}]`, rows);
+      pairIndex += 1;
+    });
+
+    localEntryMap.forEach((list) => {
+      list.forEach((localEntry) => {
+        const rowIdentity = localEntry.rowIdentity.trim();
+        const indexLabel = rowIdentity ? `${pairIndex}|${rowIdentity}` : `${pairIndex}`;
+        collectDiffRows(moduleKey, moduleLabel, localEntry.value, undefined, `${path}[${indexLabel}]`, rows);
+        pairIndex += 1;
+      });
+    });
+    if (localArr.length === 0 && serverArr.length === 0) {
+      // Keep behavior explicit for empty array pair to avoid extra recursion.
+      return;
     }
     return;
   }
diff --git a/frontend/src/utils/setupPublishWorkflow.ts b/frontend/src/utils/setupPublishWorkflow.ts
index adf19a1f..95175736 100644
--- a/frontend/src/utils/setupPublishWorkflow.ts
+++ b/frontend/src/utils/setupPublishWorkflow.ts
@@ -6,8 +6,8 @@ export type SetupWorkflowStatus = "UNSAVED_DRAFT" | "SAVED_DRAFT" | "PUBLISHED";
 export type SetupWorkflowTagMeta = { label: string; type: "success" | "warning" | "info" };
 
 export const SETUP_WORKFLOW_TAG_META: Record<SetupWorkflowStatus, SetupWorkflowTagMeta> = {
-  UNSAVED_DRAFT: { label: "草稿未保存", type: "warning" },
-  SAVED_DRAFT: { label: "草稿已保存（未发布）", type: "info" },
+  UNSAVED_DRAFT: { label: "未保存", type: "warning" },
+  SAVED_DRAFT: { label: "已保存", type: "info" },
   PUBLISHED: { label: "已发布", type: "success" },
 };
 
diff --git a/frontend/src/views/admin/ProjectDetail.vue b/frontend/src/views/admin/ProjectDetail.vue
index 7866909b..e3591781 100644
--- a/frontend/src/views/admin/ProjectDetail.vue
+++ b/frontend/src/views/admin/ProjectDetail.vue
@@ -18,39 +18,54 @@
       </div>
 
       <div class="setup-toolbar">
-        <div class="setup-switcher-wrap">
-          <div v-if="project?.is_locked" class="setup-switcher">
-            <el-tag type="warning" effect="plain">
-              <el-icon><Lock /></el-icon>
-              已锁定
-            </el-tag>
-          </div>
-          <div class="setup-save-meta">
-            <span class="meta-text">{{ setupSaveMetaText }}</span>
-            <el-tag size="small" :type="setupWorkflowTagType">
-              {{ setupWorkflowTagLabel }}
-            </el-tag>
-            <el-tag v-if="setupWorkflowStatus === 'PUBLISHED'" size="small" type="warning">
-              发布时间 {{ setupPublishedAt || "-" }}
-            </el-tag>
-          </div>
+        <div class="setup-toolbar-left">
           <div class="setup-view-mode">
             <el-radio-group v-model="setupViewMode" size="small">
               <el-radio-button label="draft">草稿</el-radio-button>
-              <el-radio-button label="published">预览</el-radio-button>
+              <el-radio-button label="preview">预览</el-radio-button>
+              <el-radio-button label="published" :disabled="!publishedSetupDraft">已发布版</el-radio-button>
             </el-radio-group>
           </div>
+          
+          <el-tag v-if="project?.is_locked" type="warning" effect="plain" class="locked-tag" size="small">
+            <el-icon><Lock /></el-icon>
+            已锁定
+          </el-tag>
+
+          <div class="setup-version-meta">
+            <div class="meta-item">
+              <span class="meta-label">当前发布</span>
+              <span class="meta-group">
+                <span class="meta-br">{{ setupPublishedBranchName || "main" }}</span>
+                <span class="meta-ver">{{ setupPublishedVersionText }}</span>
+              </span>
+              <el-tooltip v-if="setupPublishedAt" :content="setupPublishedAt" placement="top">
+                <span class="meta-time"><el-icon><Clock/></el-icon></span>
+              </el-tooltip>
+            </div>
+            
+            <div class="meta-item" v-if="!isPublishedView">
+              <span class="meta-label">草稿基线</span>
+              <span class="meta-group draft-group">
+                <span class="meta-br">{{ setupDraftBranchDisplay }}</span>
+                <span class="meta-ver">{{ setupDraftBaseVersionDisplay }}</span>
+              </span>
+              <el-tag v-if="setupDraftStatusDisplay !== '-'" size="small" :type="setupWorkflowTagType" class="meta-status">{{ setupDraftStatusDisplay }}</el-tag>
+            </div>
+          </div>
         </div>
 
         <div class="setup-toolbar-actions">
           <el-button type="success" plain :loading="primarySaveLoading" :disabled="isPublishedView" @click="handlePrimarySaveConfig">保存配置</el-button>
+          <el-button type="info" plain :disabled="isPublishedView || !publishedSetupDraft" @click="handleRefillDraft">一键回填</el-button>
+          <el-button type="danger" plain :disabled="isPublishedView" @click="handleClearDraft">清空草稿</el-button>
           <el-button type="warning" plain :loading="publishConfirmLoading" @click="publishConfigNow">发布版本</el-button>
           <el-button
             type="info"
             plain
             @click="openRollbackDialog"
           >
-            回滚版本
+            版本管理
           </el-button>
           <el-dropdown trigger="click" class="setup-secondary-menu" @command="handleSecondaryAction">
             <el-button plain class="secondary-menu-btn">
@@ -782,7 +797,7 @@
       </div>
 
       <el-table
-        v-if="enrollmentPlanCycle === 'month'"
+        v-if="currentEnrollmentPlanCycle === 'month'"
         :data="enrollmentPlanYearRows"
         class="ctms-table enrollment-month-plan-table"
         border
@@ -965,7 +980,7 @@
       </section>
 
     <section v-show="activeStep === 4" class="setup-section enrollment-plan-section">
-      <div class="enrollment-plan-actions enrollment-site-filter-row">
+      <div class="enrollment-plan-toolbar">
         <div class="site-plan-selector">
           <span class="enrollment-inline-label">中心</span>
           <el-select
@@ -983,9 +998,6 @@
             />
           </el-select>
         </div>
-      </div>
-
-      <div class="enrollment-plan-toolbar">
         <div class="enrollment-inline-group">
           <span class="enrollment-inline-label required">中心入组日期</span>
           <div class="field-cell enrollment-date-cell">
@@ -1124,7 +1136,7 @@
       <div v-else-if="!selectedSiteEnrollmentPlan" class="month-empty">当前中心暂未配置入组计划</div>
       <div v-else>
         <el-table
-          v-if="enrollmentPlanCycle === 'month'"
+          v-if="currentEnrollmentPlanCycle === 'month'"
           :data="enrollmentPlanYearRows"
           class="ctms-table enrollment-month-plan-table"
           border
@@ -1438,30 +1450,213 @@
         <el-button type="primary" :loading="publishConfirmLoading" @click="confirmPublishConfig">确认发布</el-button>
       </template>
     </el-dialog>
-    <el-dialog append-to="body" v-model="rollbackDialogVisible" title="选择回滚版本" width="760px" top="10vh">
-        <el-table :data="setupVersionHistory" height="360" v-loading="rollbackDialogLoading">
-          <el-table-column prop="version" label="发布版本" width="120">
-          <template #default="scope">v{{ scope.row.display_version || scope.row.version }}</template>
-        </el-table-column>
-        <el-table-column prop="published_by_name" label="发布人" min-width="150" />
-        <el-table-column prop="published_at" label="发布时间" min-width="200" />
-        <el-table-column label="操作" width="260">
-          <template #default="scope">
-            <el-button link type="danger" @click="selectRollbackVersion(scope.row.version)">回滚</el-button>
-            <el-button link type="primary" @click="downloadVersionRaw(scope.row)">下载</el-button>
-            <el-button
-              link
-              type="danger"
-              :disabled="isLatestPublishedVersion(scope.row.version)"
-              @click="removeVersion(scope.row.version)"
-            >
-              删除
-            </el-button>
-          </template>
-        </el-table-column>
-      </el-table>
+    <el-dialog
+      append-to="body"
+      v-model="rollbackDialogVisible"
+      width="960px"
+      top="6vh"
+      :show-close="false"
+      class="version-mgr-dialog"
+    >
+      <template #header>
+        <div class="vm-dialog-header">
+          <div class="vm-dialog-header-left">
+            <span class="vm-dialog-icon">
+              <el-icon :size="20"><List /></el-icon>
+            </span>
+            <span class="vm-dialog-title">版本管理</span>
+            <el-tag class="vm-version-count-tag" size="small" effect="plain" round>
+              {{ rollbackAxisRows.length }} 个版本
+            </el-tag>
+          </div>
+          <el-button class="vm-dialog-close-btn" :icon="Close" circle size="small" @click="rollbackDialogVisible = false" />
+        </div>
+      </template>
+
+      <div class="vm-body" v-loading="rollbackDialogLoading">
+        <!-- 分支轨道图例 -->
+        <div class="vm-legend-bar">
+          <div class="vm-legend-section">
+            <span class="vm-legend-label">分支轨道</span>
+            <div class="vm-legend-tags">
+              <span
+                v-for="lane in rollbackAxisLanes"
+                :key="lane.branch"
+                class="vm-lane-badge"
+                :class="{ 'is-main': lane.branch === 'main' }"
+              >
+                <span class="vm-lane-badge-dot" />
+                {{ lane.branch }}
+              </span>
+            </div>
+          </div>
+        </div>
+
+        <!-- 轨道头部标签 -->
+        <div class="rollback-axis-lane-head" :style="{ width: `${rollbackAxisWidth}px` }">
+          <span
+            v-for="lane in rollbackAxisLanes"
+            :key="`head-${lane.branch}`"
+            class="rollback-axis-lane-head-item"
+            :class="{ 'is-main': lane.branch === 'main' }"
+            :style="{ left: `${lane.x}px` }"
+          >
+            {{ formatAxisLaneLabel(lane.branch) }}
+          </span>
+        </div>
+
+        <!-- 时间线内容 -->
+        <div class="rollback-axis-scroll" ref="rollbackAxisScrollRef">
+          <svg
+            v-if="rollbackAxisOverlayHeight > 0"
+            class="rollback-axis-overlay"
+            :width="rollbackAxisWidth"
+            :height="rollbackAxisOverlayHeight"
+            :viewBox="`0 0 ${rollbackAxisWidth} ${rollbackAxisOverlayHeight}`"
+            preserveAspectRatio="none"
+          >
+            <defs>
+              <linearGradient id="mergeGrad" x1="0%" y1="0%" x2="0%" y2="100%">
+                <stop offset="0%" stop-color="#f59e0b" stop-opacity="0.8" />
+                <stop offset="100%" stop-color="#ef4444" stop-opacity="0.6" />
+              </linearGradient>
+              <linearGradient id="spawnGrad" x1="0%" y1="0%" x2="0%" y2="100%">
+                <stop offset="0%" stop-color="#3b82f6" stop-opacity="0.7" />
+                <stop offset="100%" stop-color="#8b5cf6" stop-opacity="0.6" />
+              </linearGradient>
+            </defs>
+            <!-- 同分支继承连接线 -->
+            <g v-for="connector in rollbackAxisSameBranchConnectors" :key="connector.key">
+              <line
+                :class="connector.isMain ? 'rollback-axis-branch-line is-main' : 'rollback-axis-branch-line'"
+                :x1="connector.x"
+                :y1="connector.y1"
+                :x2="connector.x"
+                :y2="connector.y2"
+              />
+            </g>
+            <!-- 合并连接线 -->
+            <g v-for="connector in rollbackAxisMergeConnectors" :key="connector.key">
+              <path
+                class="rollback-axis-merge-path"
+                :d="`M ${connector.x1} ${connector.y1} C ${connector.x1} ${(connector.y1 + connector.y2) / 2}, ${connector.x2} ${(connector.y1 + connector.y2) / 2}, ${connector.x2} ${connector.y2}`"
+              />
+            </g>
+            <!-- 派生连接线 -->
+            <g v-for="connector in rollbackAxisSpawnConnectors" :key="connector.key">
+              <path
+                class="rollback-axis-spawn-path"
+                :d="`M ${connector.x1} ${connector.y1} C ${connector.x1} ${(connector.y1 + connector.y2) / 2}, ${connector.x2} ${(connector.y1 + connector.y2) / 2}, ${connector.x2} ${connector.y2}`"
+              />
+            </g>
+          </svg>
+
+          <div
+            v-for="row in rollbackAxisRows"
+            :key="row.id"
+            class="rollback-axis-row"
+            :class="{
+              'is-current-row': row.is_current_published,
+              'is-draft-base-row': row.is_active_draft_base,
+            }"
+            :ref="(el) => setRollbackAxisRowRef(el as HTMLElement | null, row.id)"
+          >
+            <div class="rollback-axis-graph" :style="{ width: `${rollbackAxisWidth}px` }">
+              <span
+                v-for="lane in rollbackAxisLanes.filter(l => l.branch === 'main')"
+                :key="`${row.id}-${lane.branch}`"
+                class="rollback-axis-lane-segment is-main-lane"
+                :style="{ left: `${lane.x}px` }"
+              />
+              <span
+                class="rollback-axis-dot"
+                :class="{
+                  'is-main': row.branch_name === 'main',
+                  'is-current': row.is_current_published,
+                  'is-merge': row.mergeFromId !== null,
+                }"
+                :style="{ left: `${row.axisX}px` }"
+              />
+            </div>
+            <div class="rollback-axis-content">
+              <div class="rollback-axis-topline">
+                <span class="rollback-axis-version">{{ row.displayLabel }}</span>
+                <span v-if="row.is_current_published" class="vm-status-badge vm-badge-published">
+                  <el-icon :size="12"><SuccessFilled /></el-icon>
+                  当前发布
+                </span>
+                <span v-if="row.is_active_draft_base" class="vm-status-badge vm-badge-draft">
+                  <el-icon :size="12"><EditPen /></el-icon>
+                  草稿基线
+                </span>
+                <span v-if="row.mergeFromLabel" class="vm-status-badge vm-badge-merge">
+                  <el-icon :size="12"><Connection /></el-icon>
+                  来源 {{ row.mergeFromLabel }}
+                </span>
+              </div>
+              <div class="rollback-axis-meta">
+                <span class="vm-meta-item">
+                  <el-icon :size="13"><FolderOpened /></el-icon>
+                  {{ row.branch_name || "main" }}
+                </span>
+                <span class="vm-meta-item">
+                  <el-icon :size="13"><User /></el-icon>
+                  {{ row.published_by_name || "-" }}
+                </span>
+                <span class="vm-meta-item">
+                  <el-icon :size="13"><Clock /></el-icon>
+                  {{ row.published_at }}
+                </span>
+              </div>
+              <div class="rollback-axis-actions">
+                <el-tooltip content="回滚到此版本" placement="top" :show-after="300">
+                  <el-button class="vm-action-btn vm-action-danger" size="small" @click="selectRollbackVersion(row.version)">
+                    <el-icon :size="13"><RefreshLeft /></el-icon>
+                    回滚
+                  </el-button>
+                </el-tooltip>
+                <el-tooltip v-if="(row.branch_name || 'main') === 'main'" content="基于此版本新建分支草稿" placement="top" :show-after="300">
+                  <el-button class="vm-action-btn vm-action-primary" size="small" @click="checkoutBranchDraftFromVersion(row.version)">
+                    <el-icon :size="13"><DocumentCopy /></el-icon>
+                    新建分支草稿
+                  </el-button>
+                </el-tooltip>
+                <el-tooltip v-if="(row.branch_name || 'main') !== 'main'" content="合并至主线创建新版本" placement="top" :show-after="300">
+                  <el-button class="vm-action-btn vm-action-primary" size="small" @click="mergeVersionToMain(row.version)">
+                    <el-icon :size="13"><Connection /></el-icon>
+                    合并主线（新版本）
+                  </el-button>
+                </el-tooltip>
+                <el-tooltip content="下载版本数据" placement="top" :show-after="300">
+                  <el-button class="vm-action-btn vm-action-default" size="small" @click="downloadVersionRaw(row)">
+                    <el-icon :size="13"><Download /></el-icon>
+                    下载
+                  </el-button>
+                </el-tooltip>
+                <el-tooltip content="删除此版本" placement="top" :show-after="300">
+                  <el-button
+                    class="vm-action-btn vm-action-danger"
+                    size="small"
+                    :disabled="isLatestPublishedVersion(row.version)"
+                    @click="removeVersion(row.version)"
+                  >
+                    <el-icon :size="13"><Delete /></el-icon>
+                    删除
+                  </el-button>
+                </el-tooltip>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+
       <template #footer>
-        <el-button @click="rollbackDialogVisible = false">关闭</el-button>
+        <div class="vm-dialog-footer">
+          <el-button round @click="rollbackDialogVisible = false">
+            <el-icon><Close /></el-icon>
+            关闭
+          </el-button>
+        </div>
       </template>
     </el-dialog>
 
@@ -1761,10 +1956,10 @@
 </template>
 
 <script setup lang="ts">
-import { computed, onBeforeUnmount, onMounted, reactive, ref, watch, type Ref } from "vue";
+import { computed, nextTick, onBeforeUnmount, onMounted, reactive, ref, watch, type Ref } from "vue";
 import { onBeforeRouteLeave, useRoute, useRouter } from "vue-router";
 import { ElMessage, ElMessageBox, type FormInstance, type FormRules } from "element-plus";
-import { ArrowLeft, ArrowRight, Promotion, User, OfficeBuilding, Lock, SuccessFilled, ArrowDown } from "@element-plus/icons-vue";
+import { ArrowLeft, ArrowRight, Promotion, User, OfficeBuilding, Lock, SuccessFilled, ArrowDown, Close, List, EditPen, Connection, FolderOpened, Clock, RefreshLeft, DocumentCopy, Download, Delete } from "@element-plus/icons-vue";
 import {
   fetchStudyDetail,
   updateStudy,
@@ -1821,6 +2016,14 @@ type StepActionMode =
   | "project-milestone"
   | "site-milestone"
   | "monitoring-strategy";
+type RollbackAxisLane = { branch: string; index: number; x: number };
+type RollbackAxisRow = StudySetupConfigVersionItem & {
+  displayLabel: string;
+  mergeFromId: string | null;
+  axisX: number;
+  mergeFromLabel: string;
+  spawnParentId: string | null;
+};
 
 const DRAFT_VERSION = 2;
 const LOCAL_DRAFT_TTL_MS = 7 * 24 * 60 * 60 * 1000;
@@ -1919,8 +2122,12 @@ const {
   getConfig: fetchSetupConfig,
   saveConfig: upsertSetupConfig,
   publishConfig,
+  mergeToMain: mergeSetupVersionToMain,
   listVersions: fetchSetupVersions,
   rollbackConfig,
+  checkoutBranchDraft: checkoutSetupBranchDraft,
+  clearDraft: clearSetupDraftOnServer,
+  refillDraft: refillSetupDraftOnServer,
   deleteVersion: deleteSetupVersion,
 } = useSetupConfig();
 
@@ -1954,10 +2161,14 @@ const enrollmentTargetsByCycle = ref<Record<EnrollmentCycle, Record<string, numb
 const enrollmentStageSyncingFromModel = ref(false);
 const enrollmentStageSyncingToModel = ref(false);
 const setupRevision = ref<number>(1);
-const setupPublishedVersion = ref<number | null>(null);
+const setupPublishedVersion = ref<string>("v0");
+const setupPublishedBranchName = ref<string>("main");
+const setupCurrentBranchName = ref<string>("main");
+const setupActiveDraftBaseVersion = ref<string>("");
 const setupPublishStatus = ref<"DRAFT" | "PUBLISHED" | string>("DRAFT");
 const setupPublishedAt = ref<string>("");
-const setupViewMode = ref<"draft" | "published">("draft");
+type SetupViewMode = "draft" | "preview" | "published";
+const setupViewMode = ref<SetupViewMode>("draft");
 const publishedSetupDraft = ref<SetupConfigDraft | null>(null);
 const publishConfirmVisible = ref(false);
 const publishConfirmLoading = ref(false);
@@ -2123,8 +2334,13 @@ const storageKey = computed(() => `ctms_setup_config_draft_${String(route.params
 const projectDraftStorageKey = computed(() => `ctms_setup_project_draft_${String(route.params.projectId || "")}`);
 const setupRole = computed(() => String(project.value?.role_in_study || authStore.user?.role || "").toUpperCase());
 const canManageSetup = computed(() => ["ADMIN", "PM"].includes(setupRole.value));
-const isPublishedView = computed(() => setupViewMode.value === "published");
+const isPreviewView = computed(() => setupViewMode.value === "preview");
+const isPublishedVersionView = computed(() => setupViewMode.value === "published");
+const isPublishedView = computed(() => isPreviewView.value || isPublishedVersionView.value);
 const currentSetupDraft = computed<SetupConfigDraft>(() => {
+  if (isPublishedVersionView.value && publishedSetupDraft.value) {
+    return publishedSetupDraft.value;
+  }
   return setupDraft;
 });
 const canEditSetup = computed(
@@ -2190,7 +2406,7 @@ const canSaveDraftAction = computed(() => Boolean(project.value && canManageSetu
 const canPublishAction = computed(() => Boolean(project.value && canManageSetup.value && !project.value?.is_locked));
 const currentStepTitle = computed(() => `第${activeStep.value + 1}步：${steps[activeStep.value]?.label || ""}`);
 const setupPublishedVersionText = computed(() => {
-  return `v${setupPublishedVersion.value ?? 0}`;
+  return setupPublishedVersion.value || "v0";
 });
 const hasProjectPendingChanges = computed(() => hasFormUnsavedChanges.value || projectDirtySinceLastPersist.value);
 const draftSyncStatus = computed<DraftSyncStatus>(() => {
@@ -2209,13 +2425,37 @@ const setupWorkflowStatus = computed<SetupWorkflowStatus>(() =>
 const setupWorkflowTagMeta = computed<SetupWorkflowTagMeta>(() => SETUP_WORKFLOW_TAG_META[setupWorkflowStatus.value]);
 const setupWorkflowTagLabel = computed(() => setupWorkflowTagMeta.value.label);
 const setupWorkflowTagType = computed<"success" | "warning" | "info">(() => setupWorkflowTagMeta.value.type);
-const setupSaveMetaText = computed(() => {
-  if (draftSyncStatus.value === "LOCAL_ONLY") {
-    const localSavedAt = setupLocalDraftSavedAt.value || projectLocalDraftSavedAt.value || setupSaveMeta.value.updatedAt || "-";
-    return `本地草稿时间：${localSavedAt}｜服务端最新：${lastServerSaveMeta.value.updatedAt}`;
+const isSetupDraftEffectivelyEmpty = (draft: SetupConfigDraft): boolean => {
+  if (draft.projectMilestones.length > 0) return false;
+  if (draft.siteMilestones.length > 0) return false;
+  if (draft.siteEnrollmentPlans.length > 0) return false;
+  if (draft.monitoringStrategies.length > 0) return false;
+  if (draft.centerConfirm.length > 0) return false;
+  const plan = draft.enrollmentPlan;
+  const normalizedTotal = Number(plan.totalTarget || 0);
+  if (!Number.isFinite(normalizedTotal) || normalizedTotal !== 0) return false;
+  if ((plan.startDate || "").trim()) return false;
+  if ((plan.endDate || "").trim()) return false;
+  if ((plan.monthlyGoalNote || "").trim()) return false;
+  if ((plan.stageBreakdown || "").trim()) return false;
+  return true;
+};
+const shouldShowEmptyDraftBaseInfo = computed(() => isSetupDraftEffectivelyEmpty(setupDraft));
+const setupDraftBaseVersionText = computed(() => {
+  const explicit = (setupActiveDraftBaseVersion.value || "").trim();
+  if (explicit) return explicit;
+  const draftBranch = (setupCurrentBranchName.value || "main").trim() || "main";
+  const publishedBranch = (setupPublishedBranchName.value || "main").trim() || "main";
+  if (draftBranch === publishedBranch && setupPublishedVersionText.value && setupPublishedVersionText.value !== "v0") {
+    return setupPublishedVersionText.value;
   }
-  return `服务端保存：${lastServerSaveMeta.value.updatedAt}（${lastServerSaveMeta.value.savedBy}）｜发布版本：${setupPublishedVersionText.value}`;
+  return "-";
 });
+const setupDraftBaseVersionDisplay = computed(() => (shouldShowEmptyDraftBaseInfo.value ? "-" : setupDraftBaseVersionText.value));
+const setupDraftBranchDisplay = computed(() =>
+  shouldShowEmptyDraftBaseInfo.value ? "-" : ((setupCurrentBranchName.value || "main").trim() || "main")
+);
+const setupDraftStatusDisplay = computed(() => (shouldShowEmptyDraftBaseInfo.value ? "-" : setupWorkflowTagLabel.value));
 const serializeFormForCompare = (): string =>
   JSON.stringify({
     code: form.value.code || "",
@@ -2360,8 +2600,13 @@ type DisplayInfoItem = {
   updated?: boolean;
 };
 
-const shouldShowPreviewUpdateMark = computed(() => isPublishedView.value && !isFirstPublish.value);
-const currentProjectPublishSnapshot = computed<ProjectPublishSnapshot>(() => buildProjectPublishSnapshot());
+const shouldShowPreviewUpdateMark = computed(() => isPreviewView.value && !isFirstPublish.value);
+const currentProjectPublishSnapshot = computed<ProjectPublishSnapshot>(() => {
+  if (isPublishedVersionView.value && publishedProjectSnapshot.value) {
+    return publishedProjectSnapshot.value;
+  }
+  return buildProjectPublishSnapshot();
+});
 const normalizeCompareValue = (value: unknown): string => serializeDiffValue(value);
 const isPreviewValueUpdated = (currentValue: unknown, previousValue: unknown): boolean => {
   if (!shouldShowPreviewUpdateMark.value) return false;
@@ -2419,14 +2664,14 @@ const publishedEnrollmentPlanParsed = computed(() =>
 );
 const isEnrollmentPlanFieldUpdated = (field: "startDate" | "endDate" | "totalTarget" | "cycle"): boolean => {
   if (field === "cycle") {
-    return isPreviewValueUpdated(enrollmentPlanCycle.value, publishedEnrollmentPlanParsed.value.cycle);
+    return isPreviewValueUpdated(currentEnrollmentPlanCycle.value, publishedEnrollmentPlanParsed.value.cycle);
   }
-  return isPreviewValueUpdated(setupDraft.enrollmentPlan[field], publishCompareBase.value.enrollmentPlan[field]);
+  return isPreviewValueUpdated(currentSetupDraft.value.enrollmentPlan[field], publishCompareBase.value.enrollmentPlan[field]);
 };
 const isProjectEnrollmentPeriodUpdated = (key: string | null): boolean => {
   if (!key) return false;
-  const cycle = enrollmentPlanCycle.value;
-  const localValue = enrollmentTargetsByCycle.value[cycle]?.[key];
+  const cycle = currentEnrollmentPlanCycle.value;
+  const localValue = currentEnrollmentTargetsByCycle.value[cycle]?.[key];
   const serverValue = publishedEnrollmentPlanParsed.value.targetsByCycle[cycle]?.[key];
   return isPreviewValueUpdated(localValue, serverValue);
 };
@@ -2480,7 +2725,7 @@ const isSelectedSiteEnrollmentFieldUpdated = (field: "startDate" | "endDate" | "
 };
 const isSelectedSiteEnrollmentPeriodUpdated = (key: string | null): boolean => {
   if (!key || !selectedSiteEnrollmentPlan.value) return false;
-  const cycle = enrollmentPlanCycle.value;
+  const cycle = currentEnrollmentPlanCycle.value;
   const currentTargets = getSiteEnrollmentTargetsByCycle(selectedSiteEnrollmentPlan.value);
   const basePlan = getPublishedSiteEnrollmentPlan(selectedSiteEnrollmentPlan.value.siteId);
   const baseTargets = basePlan ? parseSiteEnrollmentStageBreakdown(basePlan.stageBreakdown) : createEmptyEnrollmentTargetsByCycle();
@@ -2493,44 +2738,44 @@ const isCenterConfirmPlanFieldUpdated = (siteId: string, field: "target" | "star
 };
 
 const projectInfoItems = computed<DisplayInfoItem[]>(() => [
-  { label: "项目名称", value: form.value.name || project.value?.name || "-", updated: isProjectSnapshotFieldUpdated("name") },
-  { label: "项目全称", value: form.value.project_full_name || project.value?.project_full_name || "-", updated: isProjectSnapshotFieldUpdated("project_full_name") },
-  { label: "申办方", value: form.value.sponsor || project.value?.sponsor || "-", updated: isProjectSnapshotFieldUpdated("sponsor") },
-  { label: "项目编号", value: form.value.code || project.value?.code || "-", updated: isProjectSnapshotFieldUpdated("code") },
-  { label: "方案号", value: form.value.protocol_no || project.value?.protocol_no || "-", updated: isProjectSnapshotFieldUpdated("protocol_no") },
-  { label: "组长单位", value: form.value.lead_unit || project.value?.lead_unit || "-", updated: isProjectSnapshotFieldUpdated("lead_unit") },
-  { label: "主要研究者", value: form.value.principal_investigator || project.value?.principal_investigator || "-", updated: isProjectSnapshotFieldUpdated("principal_investigator") },
-  { label: "主PM", value: form.value.main_pm || project.value?.main_pm || "-", updated: isProjectSnapshotFieldUpdated("main_pm") },
+  { label: "项目名称", value: currentProjectPublishSnapshot.value.name || "-", updated: isProjectSnapshotFieldUpdated("name") },
+  { label: "项目全称", value: currentProjectPublishSnapshot.value.project_full_name || "-", updated: isProjectSnapshotFieldUpdated("project_full_name") },
+  { label: "申办方", value: currentProjectPublishSnapshot.value.sponsor || "-", updated: isProjectSnapshotFieldUpdated("sponsor") },
+  { label: "项目编号", value: currentProjectPublishSnapshot.value.code || "-", updated: isProjectSnapshotFieldUpdated("code") },
+  { label: "方案号", value: currentProjectPublishSnapshot.value.protocol_no || "-", updated: isProjectSnapshotFieldUpdated("protocol_no") },
+  { label: "组长单位", value: currentProjectPublishSnapshot.value.lead_unit || "-", updated: isProjectSnapshotFieldUpdated("lead_unit") },
+  { label: "主要研究者", value: currentProjectPublishSnapshot.value.principal_investigator || "-", updated: isProjectSnapshotFieldUpdated("principal_investigator") },
+  { label: "主PM", value: currentProjectPublishSnapshot.value.main_pm || "-", updated: isProjectSnapshotFieldUpdated("main_pm") },
 ]);
 
 const researchInfoItems = computed<DisplayInfoItem[]>(() => [
-  { label: "研究分期", value: form.value.research_analysis || project.value?.research_analysis || "-", updated: isProjectSnapshotFieldUpdated("research_analysis") },
-  { label: "研究产品", value: form.value.research_product || project.value?.research_product || "-", updated: isProjectSnapshotFieldUpdated("research_product") },
-  { label: "对照产品", value: form.value.control_product || project.value?.control_product || "-", updated: isProjectSnapshotFieldUpdated("control_product") },
-  { label: "适应症", value: form.value.indication || project.value?.indication || "-", updated: isProjectSnapshotFieldUpdated("indication") },
-  { label: "研究人群", value: form.value.research_population || project.value?.research_population || "-", updated: isProjectSnapshotFieldUpdated("research_population") },
-  { label: "研究设计", value: form.value.research_design || project.value?.research_design || "-", updated: isProjectSnapshotFieldUpdated("research_design") },
+  { label: "研究分期", value: currentProjectPublishSnapshot.value.research_analysis || "-", updated: isProjectSnapshotFieldUpdated("research_analysis") },
+  { label: "研究产品", value: currentProjectPublishSnapshot.value.research_product || "-", updated: isProjectSnapshotFieldUpdated("research_product") },
+  { label: "对照产品", value: currentProjectPublishSnapshot.value.control_product || "-", updated: isProjectSnapshotFieldUpdated("control_product") },
+  { label: "适应症", value: currentProjectPublishSnapshot.value.indication || "-", updated: isProjectSnapshotFieldUpdated("indication") },
+  { label: "研究人群", value: currentProjectPublishSnapshot.value.research_population || "-", updated: isProjectSnapshotFieldUpdated("research_population") },
+  { label: "研究设计", value: currentProjectPublishSnapshot.value.research_design || "-", updated: isProjectSnapshotFieldUpdated("research_design") },
 ]);
 
 const executionInfoItems = computed<DisplayInfoItem[]>(() => [
-  { label: "计划开始日期", value: form.value.plan_start_date || project.value?.plan_start_date || "-", updated: isProjectSnapshotFieldUpdated("plan_start_date") },
-  { label: "计划结束日期", value: form.value.plan_end_date || project.value?.plan_end_date || "-", updated: isProjectSnapshotFieldUpdated("plan_end_date") },
-  { label: "项目状态", value: statusLabel(form.value.status || project.value?.status || "DRAFT"), updated: isProjectSnapshotFieldUpdated("status") },
-  { label: "计划中心数", value: toDisplayNumber(form.value.planned_site_count), updated: isProjectSnapshotFieldUpdated("planned_site_count") },
+  { label: "计划开始日期", value: currentProjectPublishSnapshot.value.plan_start_date || "-", updated: isProjectSnapshotFieldUpdated("plan_start_date") },
+  { label: "计划结束日期", value: currentProjectPublishSnapshot.value.plan_end_date || "-", updated: isProjectSnapshotFieldUpdated("plan_end_date") },
+  { label: "项目状态", value: statusLabel(currentProjectPublishSnapshot.value.status || "DRAFT"), updated: isProjectSnapshotFieldUpdated("status") },
+  { label: "计划中心数", value: toDisplayNumber(currentProjectPublishSnapshot.value.planned_site_count), updated: isProjectSnapshotFieldUpdated("planned_site_count") },
   {
     label: "计划入组数",
-    value: toDisplayNumber(setupDraft.enrollmentPlan.totalTarget),
+    value: toDisplayNumber(currentSetupDraft.value.enrollmentPlan.totalTarget),
     updated: isEnrollmentPlanFieldUpdated("totalTarget"),
   },
 ]);
 
 const summaryInfoItems = computed<DisplayInfoItem[]>(() => [
-  { label: "访视总数", value: toDisplayNumber(form.value.visit_total), updated: isProjectSnapshotFieldUpdated("visit_total") },
-  { label: "访视间隔（天）", value: toDisplayNumber(form.value.visit_interval_days), updated: isProjectSnapshotFieldUpdated("visit_interval_days") },
-  { label: "窗口期起始偏移", value: toDisplayNumber(form.value.visit_window_start_offset), updated: isProjectSnapshotFieldUpdated("visit_window_start_offset") },
-  { label: "窗口期结束偏移", value: toDisplayNumber(form.value.visit_window_end_offset), updated: isProjectSnapshotFieldUpdated("visit_window_end_offset") },
-  { label: "方案摘要说明", value: form.value.summary_note || "-", updated: isProjectSnapshotFieldUpdated("summary_note") },
-  { label: "研究目标摘要", value: form.value.objective_note || "-", updated: isProjectSnapshotFieldUpdated("objective_note") },
+  { label: "访视总数", value: toDisplayNumber(currentProjectPublishSnapshot.value.visit_total), updated: isProjectSnapshotFieldUpdated("visit_total") },
+  { label: "访视间隔（天）", value: toDisplayNumber(currentProjectPublishSnapshot.value.visit_interval_days), updated: isProjectSnapshotFieldUpdated("visit_interval_days") },
+  { label: "窗口期起始偏移", value: toDisplayNumber(currentProjectPublishSnapshot.value.visit_window_start_offset), updated: isProjectSnapshotFieldUpdated("visit_window_start_offset") },
+  { label: "窗口期结束偏移", value: toDisplayNumber(currentProjectPublishSnapshot.value.visit_window_end_offset), updated: isProjectSnapshotFieldUpdated("visit_window_end_offset") },
+  { label: "方案摘要说明", value: currentProjectPublishSnapshot.value.summary_note || "-", updated: isProjectSnapshotFieldUpdated("summary_note") },
+  { label: "研究目标摘要", value: currentProjectPublishSnapshot.value.objective_note || "-", updated: isProjectSnapshotFieldUpdated("objective_note") },
 ]);
 
 const rules = ref<FormRules>({
@@ -2826,11 +3071,30 @@ const buildEnrollmentSlotsByCycle = (
   }
   return result;
 };
+const currentEnrollmentPlanParsed = computed(() =>
+  parseEnrollmentStageBreakdown(currentSetupDraft.value.enrollmentPlan.stageBreakdown)
+);
+const currentEnrollmentPlanCycle = computed<EnrollmentCycle>(() => {
+  if (isPublishedVersionView.value) return currentEnrollmentPlanParsed.value.cycle;
+  return enrollmentPlanCycle.value;
+});
+const currentEnrollmentTargetsByCycle = computed<Record<EnrollmentCycle, Record<string, number>>>(() => {
+  if (isPublishedVersionView.value) return currentEnrollmentPlanParsed.value.targetsByCycle;
+  return enrollmentTargetsByCycle.value;
+});
 const currentEnrollmentSlots = computed(() =>
-  buildEnrollmentSlotsByCycle(enrollmentPlanCycle.value, setupDraft.enrollmentPlan.startDate, setupDraft.enrollmentPlan.endDate)
+  buildEnrollmentSlotsByCycle(
+    currentEnrollmentPlanCycle.value,
+    currentSetupDraft.value.enrollmentPlan.startDate,
+    currentSetupDraft.value.enrollmentPlan.endDate
+  )
 );
 const enrollmentPlanMonthSlots = computed(() => {
-  const slots = buildEnrollmentSlotsByCycle("month", setupDraft.enrollmentPlan.startDate, setupDraft.enrollmentPlan.endDate);
+  const slots = buildEnrollmentSlotsByCycle(
+    "month",
+    currentSetupDraft.value.enrollmentPlan.startDate,
+    currentSetupDraft.value.enrollmentPlan.endDate
+  );
   return slots.map((slot) => ({
     year: Number(slot.key.slice(0, 4)),
     month: Number(slot.key.slice(5, 7)),
@@ -2855,7 +3119,7 @@ const enrollmentPlanYearRows = computed<EnrollmentYearRow[]>(() => {
   }
   return rows;
 });
-const enrollmentPlanCycleLabel = computed(() => enrollmentCycleLabelMap[enrollmentPlanCycle.value] || "月");
+const enrollmentPlanCycleLabel = computed(() => enrollmentCycleLabelMap[currentEnrollmentPlanCycle.value] || "月");
 const buildEnrollmentCycleGridColumns = (): EnrollmentCycleGridColumn[] => {
   return Array.from({ length: 4 }, (_, idx) => {
     const quarter = idx + 1;
@@ -2868,12 +3132,12 @@ const resolveEnrollmentCycleColumnKey = (periodKey: string): string | null => {
   return matched ? `Q${matched[2]}` : null;
 };
 const enrollmentCycleGridColumns = computed<EnrollmentCycleGridColumn[]>(() => {
-  if (enrollmentPlanCycle.value === "month") return [];
+  if (currentEnrollmentPlanCycle.value === "month") return [];
   return buildEnrollmentCycleGridColumns();
 });
 const enrollmentCycleRowLabel = computed(() => "年份");
 const enrollmentCycleGridRows = computed<EnrollmentCycleGridRow[]>(() => {
-  if (enrollmentPlanCycle.value === "month") return [];
+  if (currentEnrollmentPlanCycle.value === "month") return [];
   const columns = enrollmentCycleGridColumns.value;
   if (!columns.length) return [];
   const columnIndexMap = new Map<string, number>();
@@ -2898,13 +3162,13 @@ const enrollmentCycleGridRows = computed<EnrollmentCycleGridRow[]>(() => {
 });
 const getEnrollmentPeriodTarget = (key: string | null): number => {
   if (!key) return 0;
-  const value = enrollmentTargetsByCycle.value[enrollmentPlanCycle.value]?.[key];
+  const value = currentEnrollmentTargetsByCycle.value[currentEnrollmentPlanCycle.value]?.[key];
   if (value === null || value === undefined) return 0;
   return normalizeEnrollmentTarget(value);
 };
 const displayEnrollmentPeriodTarget = (key: string | null): string => {
   if (!key) return "-";
-  const value = enrollmentTargetsByCycle.value[enrollmentPlanCycle.value]?.[key];
+  const value = currentEnrollmentTargetsByCycle.value[currentEnrollmentPlanCycle.value]?.[key];
   if (value === null || value === undefined) return "-";
   return String(normalizeEnrollmentTarget(value));
 };
@@ -2967,16 +3231,16 @@ const projectMonthlyPlannedCount = computed(() => {
   return currentEnrollmentSlots.value.reduce((sum, slot) => sum + getEnrollmentPeriodTarget(slot.key), 0);
 });
 const projectMonthlyPendingCount = computed(() => {
-  const totalTarget = normalizeEnrollmentTarget(setupDraft.enrollmentPlan.totalTarget);
+  const totalTarget = normalizeEnrollmentTarget(currentSetupDraft.value.enrollmentPlan.totalTarget);
   return Math.max(totalTarget - projectMonthlyPlannedCount.value, 0);
 });
 const projectMonthlyOverflowCount = computed(() => {
-  const totalTarget = normalizeEnrollmentTarget(setupDraft.enrollmentPlan.totalTarget);
+  const totalTarget = normalizeEnrollmentTarget(currentSetupDraft.value.enrollmentPlan.totalTarget);
   return Math.max(projectMonthlyPlannedCount.value - totalTarget, 0);
 });
 const centerEnrollmentTargetMap = computed(() => {
   const map = new Map<string, number>();
-  setupDraft.siteEnrollmentPlans.forEach((row) => {
+  currentSetupDraft.value.siteEnrollmentPlans.forEach((row) => {
     const siteId = String(row.siteId || "").trim();
     if (!siteId) return;
     map.set(siteId, normalizeEnrollmentTarget(row.target));
@@ -2992,11 +3256,11 @@ const centerPlannedCount = computed(() => {
   return Array.from(centerEnrollmentTargetMap.value.values()).reduce((sum, target) => sum + target, 0);
 });
 const centerPendingCount = computed(() => {
-  const totalTarget = normalizeEnrollmentTarget(setupDraft.enrollmentPlan.totalTarget);
+  const totalTarget = normalizeEnrollmentTarget(currentSetupDraft.value.enrollmentPlan.totalTarget);
   return Math.max(totalTarget - centerPlannedCount.value, 0);
 });
 const centerOverflowCount = computed(() => {
-  const totalTarget = normalizeEnrollmentTarget(setupDraft.enrollmentPlan.totalTarget);
+  const totalTarget = normalizeEnrollmentTarget(currentSetupDraft.value.enrollmentPlan.totalTarget);
   return Math.max(centerPlannedCount.value - totalTarget, 0);
 });
 const centerUnplannedSiteCount = computed(() => {
@@ -3014,7 +3278,7 @@ const getSiteEnrollmentTargetsByCycle = (row: SiteEnrollmentPlanDraft): Record<E
 };
 const sumSiteEnrollmentTargetForCurrentCycle = (targets: Record<EnrollmentCycle, Record<string, number>>): number => {
   const slotKeys = new Set(currentEnrollmentSlots.value.map((item) => item.key));
-  const activeTargets = targets[enrollmentPlanCycle.value] || {};
+  const activeTargets = targets[currentEnrollmentPlanCycle.value] || {};
   let sum = 0;
   Object.entries(activeTargets).forEach(([key, value]) => {
     if (!slotKeys.has(key)) return;
@@ -3023,7 +3287,7 @@ const sumSiteEnrollmentTargetForCurrentCycle = (targets: Record<EnrollmentCycle,
   return sum;
 };
 const centerCyclePlannedCount = computed(() => {
-  return setupDraft.siteEnrollmentPlans.reduce((sum, row) => {
+  return currentSetupDraft.value.siteEnrollmentPlans.reduce((sum, row) => {
     return sum + sumSiteEnrollmentTargetForCurrentCycle(getSiteEnrollmentTargetsByCycle(row));
   }, 0);
 });
@@ -3032,14 +3296,14 @@ const centerCycleOverflowCount = computed(() => Math.max(centerCyclePlannedCount
 const getSiteEnrollmentPeriodTarget = (row: SiteEnrollmentPlanDraft, key: string | null): number => {
   if (!key) return 0;
   const targets = getSiteEnrollmentTargetsByCycle(row);
-  const value = targets[enrollmentPlanCycle.value]?.[key];
+  const value = targets[currentEnrollmentPlanCycle.value]?.[key];
   if (value === null || value === undefined) return 0;
   return normalizeEnrollmentTarget(value);
 };
 const displaySiteEnrollmentPeriodTarget = (row: SiteEnrollmentPlanDraft, key: string | null): string => {
   if (!key) return "-";
   const targets = getSiteEnrollmentTargetsByCycle(row);
-  const value = targets[enrollmentPlanCycle.value]?.[key];
+  const value = targets[currentEnrollmentPlanCycle.value]?.[key];
   if (value === null || value === undefined) return "-";
   return String(normalizeEnrollmentTarget(value));
 };
@@ -3130,6 +3394,14 @@ const markValidationErrors = (errors: SetupValidationError[]) => {
 
 const getApiErrorMessage = (error: any, fallback: string): string => {
   const detail = error?.response?.data?.detail;
+  const errors = Array.isArray(detail?.errors) ? detail.errors : [];
+  const firstValidationMessage = typeof errors[0]?.message === "string" ? errors[0].message : "";
+  if (firstValidationMessage) {
+    if (typeof detail?.message === "string" && detail.message.trim()) {
+      return `${detail.message}：${firstValidationMessage}`;
+    }
+    return firstValidationMessage;
+  }
   if (typeof detail === "string") return detail;
   if (typeof detail?.message === "string") return detail.message;
   if (typeof error?.response?.data?.message === "string") return error.response.data.message;
@@ -3315,7 +3587,7 @@ const siteMilestoneOwnerOptions = computed(() => {
 });
 const siteEnrollmentPlanMap = computed(() => {
   const map = new Map<string, SiteEnrollmentPlanDraft>();
-  setupDraft.siteEnrollmentPlans.forEach((row) => {
+  currentSetupDraft.value.siteEnrollmentPlans.forEach((row) => {
     const siteId = normalizeSiteId(row.siteId);
     if (!siteId) return;
     map.set(siteId, row);
@@ -3351,7 +3623,7 @@ const siteEnrollmentSelectableSites = computed(() => {
       name: getSiteOptionLabel(site),
     });
   });
-  setupDraft.siteEnrollmentPlans.forEach((row) => {
+  currentSetupDraft.value.siteEnrollmentPlans.forEach((row) => {
     const siteId = normalizeSiteId(row.siteId);
     if (!siteId || map.has(siteId)) return;
     map.set(siteId, {
@@ -3370,12 +3642,12 @@ const siteEnrollmentSelectableSites = computed(() => {
 const selectedSiteEnrollmentPlanIndex = computed(() => {
   const selectedSiteId = normalizeSiteId(selectedSiteEnrollmentPlanSiteId.value);
   if (!selectedSiteId) return -1;
-  return setupDraft.siteEnrollmentPlans.findIndex((row) => normalizeSiteId(row.siteId) === selectedSiteId);
+  return currentSetupDraft.value.siteEnrollmentPlans.findIndex((row) => normalizeSiteId(row.siteId) === selectedSiteId);
 });
 const selectedSiteEnrollmentPlan = computed(() => {
   const index = selectedSiteEnrollmentPlanIndex.value;
   if (index < 0) return null;
-  return setupDraft.siteEnrollmentPlans[index] || null;
+  return currentSetupDraft.value.siteEnrollmentPlans[index] || null;
 });
 const selectedSitePlanName = computed(() => {
   const nameFromPlan = (selectedSiteEnrollmentPlan.value?.siteName || "").trim();
@@ -3401,7 +3673,8 @@ const syncSelectedSiteEnrollmentPlanSiteId = () => {
     return;
   }
   const firstConfiguredSiteId =
-    setupDraft.siteEnrollmentPlans.map((row) => normalizeSiteId(row.siteId)).find((siteId) => Boolean(siteId)) || "";
+    currentSetupDraft.value.siteEnrollmentPlans.map((row) => normalizeSiteId(row.siteId)).find((siteId) => Boolean(siteId)) ||
+    "";
   if (firstConfiguredSiteId) {
     selectedSiteEnrollmentPlanSiteId.value = firstConfiguredSiteId;
     return;
@@ -3440,7 +3713,7 @@ const isSiteEnrollmentSiteTaken = (siteId: string): boolean => {
   return isSiteEnrollmentDuplicate(siteId, editingIndex);
 };
 watch(
-  [siteOptions, () => setupDraft.siteEnrollmentPlans.map((row) => normalizeSiteId(row.siteId)).join("|")],
+  [siteOptions, () => currentSetupDraft.value.siteEnrollmentPlans.map((row) => normalizeSiteId(row.siteId)).join("|")],
   syncSelectedSiteEnrollmentPlanSiteId,
   { immediate: true }
 );
@@ -3721,6 +3994,11 @@ const emptySetupDraft: SetupConfigDraft = {
 };
 const publishCompareBase = computed<SetupConfigDraft>(() => clone(publishedSetupDraft.value || emptySetupDraft));
 const isFirstPublish = computed(() => !publishedSetupDraft.value);
+const hasBranchPublishDiff = computed(() => {
+  const draftBranch = (setupCurrentBranchName.value || "main").trim() || "main";
+  const publishedBranch = (setupPublishedBranchName.value || "main").trim() || "main";
+  return draftBranch !== publishedBranch;
+});
 const projectPublishCompareBase = computed<ProjectPublishSnapshot | null>(() => {
   const base = resolveProjectPublishCompareBase(publishedProjectSnapshot.value, projectPublishCompareFallback.value);
   return base ? clone(base) : null;
@@ -3729,9 +4007,12 @@ const hasProjectPublishDiff = computed(() => {
   return hasProjectSnapshotDiff(buildProjectPublishSnapshot(), projectPublishCompareBase.value);
 });
 const canStrictlyDetectNoDiff = computed(() => Boolean(!isFirstPublish.value && publishedProjectSnapshot.value));
-const hasPublishableDiff = computed(() => publishDiffLines.value.length > 0 || hasProjectPublishDiff.value);
+const hasPublishableDiff = computed(() => hasBranchPublishDiff.value || publishDiffLines.value.length > 0 || hasProjectPublishDiff.value);
 const publishDiffLines = computed(() => {
   const lines = buildSetupModuleDiffLines(setupDraft, publishCompareBase.value, setupModuleLabels);
+  if (hasBranchPublishDiff.value) {
+    lines.unshift(`发布分支差异：草稿 ${setupCurrentBranchName.value || "main"}，当前发布 ${setupPublishedBranchName.value || "main"}`);
+  }
   if (hasProjectPublishDiff.value) {
     lines.unshift("项目信息存在差异");
   }
@@ -3768,6 +4049,12 @@ const buildReadableDiffRows = (localDraft: SetupConfigDraft | null, serverDraft:
 
 const applySetupResponseMeta = (data: StudySetupConfigResponse) => {
   setupRevision.value = typeof data.version === "number" ? data.version : setupRevision.value;
+  setupCurrentBranchName.value = String(data.current_branch_name || setupCurrentBranchName.value || "main");
+  if (typeof data.current_published_version_label === "string" && data.current_published_version_label.trim()) {
+    setupPublishedVersion.value = data.current_published_version_label.trim();
+  }
+  setupActiveDraftBaseVersion.value =
+    typeof data.active_branch_base_version_label === "string" ? data.active_branch_base_version_label.trim() : "";
   setupPublishStatus.value = data.publish_status || "DRAFT";
   setupPublishedAt.value = formatDisplayTime(data.published_at);
   publishedSetupDraft.value = isSetupDraftShape(data?.published_data) ? clone(data.published_data) : null;
@@ -3788,13 +4075,15 @@ const applySetupResponseMeta = (data: StudySetupConfigResponse) => {
   }
 };
 
-const refreshSetupDraftFromServer = async () => {
+const refreshSetupDraftFromServer = async (options?: { silent?: boolean }) => {
   const latest = await loadSetupDraftFromServer();
   if (!latest) return false;
   applySetupDraft(latest);
   clearSetupValidationErrors();
   markSetupSynced();
-  ElMessage.info("已刷新服务端最新配置");
+  if (!options?.silent) {
+    ElMessage.info("已刷新服务端最新配置");
+  }
   return true;
 };
 
@@ -3836,7 +4125,7 @@ const persistSetupDraft = async (
     setupDirtySinceLastPersist.value = true;
     if (e?.response?.status === 409) {
       ElMessage.warning("配置已更新，正在刷新最新版本");
-      await refreshSetupDraftFromServer();
+      await refreshSetupDraftFromServer({ silent: true });
       return { serverSynced: false, retryable: false };
     }
     if (e?.response?.status === 403) {
@@ -3960,7 +4249,7 @@ watch(
 );
 
 watch(setupViewMode, (mode) => {
-  if (mode === "published") {
+  if (mode !== "draft") {
     isEditing.value = false;
     step1EditSection.value = "all";
   }
@@ -4170,7 +4459,7 @@ const startEdit = () => {
   if (!project.value) return;
   if (activeStep.value !== 0 && activeStep.value !== 2 && activeStep.value !== 4) return;
   if (isPublishedView.value) {
-    ElMessage.info("当前为预览，请先切换到草稿后再编辑");
+    ElMessage.info("当前为只读视图，请先切换到草稿后再编辑");
     return;
   }
   if (!canManageSetup.value) {
@@ -4383,7 +4672,7 @@ const doPublishConfigNow = async (): Promise<boolean> => {
     clearSetupValidationErrors();
     markSetupSynced();
     clearLocalSetupDraft();
-    setupViewMode.value = "published";
+    setupViewMode.value = "preview";
     setupSaveMeta.value = {
       updatedAt: formatDisplayTime(data.updated_at),
       savedBy: data.saved_by_name || resolveSavedByDisplay(data.saved_by),
@@ -4409,11 +4698,13 @@ const doPublishConfigNow = async (): Promise<boolean> => {
     return true;
   } catch (e: any) {
     if (handleValidationFailure(e, "发布失败，请先修正配置")) {
+      publishConfirmVisible.value = false;
+      setupViewMode.value = "draft";
       return false;
     }
     if (e?.response?.status === 409) {
       ElMessage.warning("发布失败：配置已更新，正在刷新最新版本");
-      await refreshSetupDraftFromServer();
+      await refreshSetupDraftFromServer({ silent: true });
       return false;
     }
     if (e?.response?.status === 403) {
@@ -4453,7 +4744,19 @@ const loadSetupVersionHistory = async () => {
       published_at: formatDisplayTime(item.published_at),
     }));
     setupVersionHistory.value = history;
-    setupPublishedVersion.value = history.length ? (history[0].display_version || history[0].version) : 0;
+    const currentPublished = history.find((item) => item.is_current_published) || history[0];
+    setupPublishedVersion.value = currentPublished
+      ? (currentPublished.version_label || `v${currentPublished.display_version || currentPublished.version}`)
+      : "v0";
+    setupPublishedBranchName.value = currentPublished?.branch_name || "main";
+    const activeDraftBase = history.find((item) => item.is_active_draft_base);
+    if (activeDraftBase) {
+      setupActiveDraftBaseVersion.value = activeDraftBase.version_label || `v${activeDraftBase.display_version || activeDraftBase.version}`;
+    } else if (currentPublished && (currentPublished.branch_name || "main") === (setupCurrentBranchName.value || "main")) {
+      setupActiveDraftBaseVersion.value = currentPublished.version_label || `v${currentPublished.display_version || currentPublished.version}`;
+    } else {
+      setupActiveDraftBaseVersion.value = "";
+    }
   } catch (e: any) {
     ElMessage.error(getApiErrorMessage(e, "获取版本历史失败"));
   } finally {
@@ -4461,14 +4764,218 @@ const loadSetupVersionHistory = async () => {
   }
 };
 
-const getDisplayVersion = (rawVersion: number): number => {
+const getDisplayVersionLabel = (rawVersion: number): string => {
   const found = setupVersionHistory.value.find((item) => item.version === rawVersion);
-  if (!found) return rawVersion;
-  return found.display_version || found.version;
+  if (!found) return `v${rawVersion}`;
+  return found.version_label || `v${found.display_version || found.version}`;
 };
 
+const ROLLBACK_AXIS_LANE_GAP = 34;
+const ROLLBACK_AXIS_LANE_START = 18;
+const normalizeAxisBranch = (branchName?: string | null): string => (branchName || "main").trim() || "main";
+const formatAxisLaneLabel = (branchName: string): string =>
+  branchName === "main" ? "main" : branchName.replace(/^release\//, "");
+const rollbackAxisLanes = computed<RollbackAxisLane[]>(() => {
+  const laneMap = new Map<string, number>();
+  laneMap.set("main", 0);
+  setupVersionHistory.value.forEach((item) => {
+    const branch = normalizeAxisBranch(item.branch_name);
+    if (!laneMap.has(branch)) {
+      laneMap.set(branch, laneMap.size);
+    }
+  });
+  return Array.from(laneMap.entries()).map(([branch, index]) => ({
+    branch,
+    index,
+    x: ROLLBACK_AXIS_LANE_START + index * ROLLBACK_AXIS_LANE_GAP,
+  }));
+});
+const rollbackAxisLaneMap = computed(() => {
+  const map = new Map<string, RollbackAxisLane>();
+  rollbackAxisLanes.value.forEach((lane) => map.set(lane.branch, lane));
+  return map;
+});
+const rollbackAxisWidth = computed(() => {
+  const laneCount = rollbackAxisLanes.value.length;
+  return Math.max(110, ROLLBACK_AXIS_LANE_START * 2 + Math.max(0, laneCount - 1) * ROLLBACK_AXIS_LANE_GAP + 12);
+});
+const resolveSpawnParentVersionId = (
+  item: StudySetupConfigVersionItem,
+  idMap: Map<string, StudySetupConfigVersionItem>
+): string | null => {
+  const itemBranch = normalizeAxisBranch(item.branch_name);
+  if (itemBranch === "main") return null;
+  const parentFromId = String(item.parent_version_id || "").trim();
+  if (parentFromId) {
+    const parent = idMap.get(parentFromId);
+    if (parent && normalizeAxisBranch(parent.branch_name) !== itemBranch) {
+      return parent.id;
+    }
+  }
+  if (Number(item.branch_seq || 0) <= 1) {
+    const fallbackMainParent = setupVersionHistory.value.find(
+      (candidate) =>
+        normalizeAxisBranch(candidate.branch_name) === "main" &&
+        Number(candidate.display_version || 0) === Number(item.display_version || 0)
+    );
+    return fallbackMainParent?.id || null;
+  }
+  return null;
+};
+const rollbackAxisRows = computed<RollbackAxisRow[]>(() => {
+  const idMap = new Map<string, StudySetupConfigVersionItem>();
+  setupVersionHistory.value.forEach((item) => {
+    idMap.set(item.id, item);
+  });
+  return setupVersionHistory.value.map((item) => {
+    const branch = normalizeAxisBranch(item.branch_name);
+    const lane = rollbackAxisLaneMap.value.get(branch);
+    const axisX = lane?.x ?? ROLLBACK_AXIS_LANE_START;
+    const mergedFromId = String(item.merged_from_version_id || "").trim();
+    const mergedFrom = mergedFromId ? idMap.get(mergedFromId) : undefined;
+    return {
+      ...item,
+      displayLabel: item.version_label || `v${item.display_version || item.version}`,
+      mergeFromId: mergedFrom?.id || null,
+      axisX,
+      mergeFromLabel: mergedFrom ? (mergedFrom.version_label || `v${mergedFrom.display_version || mergedFrom.version}`) : "",
+      spawnParentId: resolveSpawnParentVersionId(item, idMap),
+    };
+  });
+});
+const rollbackAxisScrollRef = ref<HTMLElement | null>(null);
+const rollbackAxisRowTopMap = ref<Record<string, number>>({});
+const rollbackAxisOverlayHeight = ref(0);
+const rollbackAxisRowElementMap = new Map<string, HTMLElement>();
+const setRollbackAxisRowRef = (el: HTMLElement | null, rowId: string) => {
+  if (el) {
+    rollbackAxisRowElementMap.set(rowId, el);
+  } else {
+    rollbackAxisRowElementMap.delete(rowId);
+  }
+};
+const syncRollbackAxisLayout = () => {
+  const scrollEl = rollbackAxisScrollRef.value;
+  if (!scrollEl) return;
+  const topMap: Record<string, number> = {};
+  rollbackAxisRows.value.forEach((row) => {
+    const rowEl = rollbackAxisRowElementMap.get(row.id);
+    if (rowEl) {
+      topMap[row.id] = rowEl.offsetTop;
+    }
+  });
+  rollbackAxisRowTopMap.value = topMap;
+  rollbackAxisOverlayHeight.value = scrollEl.scrollHeight;
+};
+const rollbackAxisSpawnConnectors = computed(() => {
+  const rowMap = new Map<string, RollbackAxisRow>();
+  rollbackAxisRows.value.forEach((row) => rowMap.set(row.id, row));
+  return rollbackAxisRows.value
+    .map((row) => {
+      const parentId = row.spawnParentId;
+      if (!parentId) return null;
+      const parent = rowMap.get(parentId);
+      if (!parent) return null;
+      const sourceY = (rollbackAxisRowTopMap.value[parent.id] ?? -1) + 28;
+      const targetY = (rollbackAxisRowTopMap.value[row.id] ?? -1) + 28;
+      if (sourceY <= 0 || targetY <= 0) return null;
+      return {
+        key: `${parent.id}-${row.id}`,
+        x1: parent.axisX,
+        y1: sourceY,
+        x2: row.axisX,
+        y2: targetY,
+      };
+    })
+    .filter(
+      (
+        item
+      ): item is {
+        key: string;
+        x1: number;
+        y1: number;
+        x2: number;
+        y2: number;
+      } => Boolean(item)
+    );
+});
+const rollbackAxisMergeConnectors = computed(() => {
+  const rowMap = new Map<string, RollbackAxisRow>();
+  rollbackAxisRows.value.forEach((row) => rowMap.set(row.id, row));
+  return rollbackAxisRows.value
+    .map((row) => {
+      const sourceId = row.mergeFromId;
+      if (!sourceId) return null;
+      const source = rowMap.get(sourceId);
+      if (!source) return null;
+      const sourceY = (rollbackAxisRowTopMap.value[source.id] ?? -1) + 28;
+      const targetY = (rollbackAxisRowTopMap.value[row.id] ?? -1) + 28;
+      if (sourceY <= 0 || targetY <= 0) return null;
+      return {
+        key: `${source.id}->${row.id}`,
+        x1: source.axisX,
+        y1: sourceY,
+        x2: row.axisX,
+        y2: targetY,
+      };
+    })
+    .filter(
+      (
+        item
+      ): item is {
+        key: string;
+        x1: number;
+        y1: number;
+        x2: number;
+        y2: number;
+      } => Boolean(item)
+    );
+});
+/* 同分支连续版本间的连接器 - 显示 release 分支内的继承关系 */
+const rollbackAxisSameBranchConnectors = computed(() => {
+  const branchGroups = new Map<string, RollbackAxisRow[]>();
+  rollbackAxisRows.value.forEach((row) => {
+    const branch = normalizeAxisBranch(row.branch_name);
+    if (!branchGroups.has(branch)) {
+      branchGroups.set(branch, []);
+    }
+    branchGroups.get(branch)!.push(row);
+  });
+  const connectors: { key: string; x: number; y1: number; y2: number; isMain: boolean }[] = [];
+  branchGroups.forEach((rows, branch) => {
+    if (rows.length < 2) return;
+    for (let i = 0; i < rows.length - 1; i++) {
+      const topRow = rows[i];
+      const bottomRow = rows[i + 1];
+      const topY = (rollbackAxisRowTopMap.value[topRow.id] ?? -1) + 28;
+      const bottomY = (rollbackAxisRowTopMap.value[bottomRow.id] ?? -1) + 28;
+      if (topY <= 0 || bottomY <= 0) continue;
+      connectors.push({
+        key: `sb-${topRow.id}-${bottomRow.id}`,
+        x: topRow.axisX,
+        y1: topY,
+        y2: bottomY,
+        isMain: branch === "main",
+      });
+    }
+  });
+  return connectors;
+});
+watch(
+  () => [rollbackDialogVisible.value, rollbackAxisRows.value.map((item) => item.id).join("|"), rollbackAxisWidth.value],
+  async ([visible]) => {
+    if (!visible) return;
+    await nextTick();
+    syncRollbackAxisLayout();
+  }
+);
+onMounted(() => {
+  window.addEventListener("resize", syncRollbackAxisLayout);
+});
+
 const isLatestPublishedVersion = (rawVersion: number): boolean => {
-  return setupVersionHistory.value.length > 0 && setupVersionHistory.value[0].version === rawVersion;
+  const currentPublished = setupVersionHistory.value.find((item) => item.is_current_published) || setupVersionHistory.value[0];
+  return Boolean(currentPublished && currentPublished.version === rawVersion);
 };
 
 const openRollbackDialog = async () => {
@@ -4479,13 +4986,17 @@ const openRollbackDialog = async () => {
 
 const selectRollbackVersion = async (targetVersion: number) => {
   if (!project.value) return;
-  const targetDisplayVersion = getDisplayVersion(targetVersion);
+  const targetDisplayVersion = getDisplayVersionLabel(targetVersion);
   try {
-    await ElMessageBox.confirm(`将当前草稿回滚到发布版本 v${targetDisplayVersion}，是否继续？`, "回滚确认", {
-      type: "warning",
-      confirmButtonText: "确认回滚",
-      cancelButtonText: "取消",
-    });
+    await ElMessageBox.confirm(
+      `将立即回滚并替换当前发布版本为 ${targetDisplayVersion}，同时将草稿切换到对应分支继续开发，是否继续？`,
+      "回滚确认",
+      {
+        type: "warning",
+        confirmButtonText: "确认回滚",
+        cancelButtonText: "取消",
+      }
+    );
   } catch {
     return;
   }
@@ -4507,12 +5018,14 @@ const selectRollbackVersion = async (targetVersion: number) => {
       serverSynced: true,
     };
     updateLastServerSaveMeta(data.updated_at, data.saved_by_name || resolveSavedByDisplay(data.saved_by));
+    await loadSetupVersionHistory();
     rollbackDialogVisible.value = false;
-    ElMessage.success(`已回滚到版本 v${targetDisplayVersion}`);
+    const currentBranch = setupCurrentBranchName.value || "main";
+    ElMessage.success(`已回滚并替换当前发布为 ${setupPublishedVersionText.value}，当前版本分支 ${currentBranch}`);
   } catch (e: any) {
     if (e?.response?.status === 409) {
       ElMessage.warning("回滚失败：版本冲突，正在刷新最新配置");
-      await refreshSetupDraftFromServer();
+      await refreshSetupDraftFromServer({ silent: true });
       await loadSetupVersionHistory();
       return;
     }
@@ -4522,21 +5035,338 @@ const selectRollbackVersion = async (targetVersion: number) => {
   }
 };
 
+const checkoutBranchDraftFromVersion = async (targetVersion: number) => {
+  if (!project.value) return;
+  const targetDisplayVersion = getDisplayVersionLabel(targetVersion);
+  try {
+    await ElMessageBox.confirm(
+      `将基于 ${targetDisplayVersion} 创建/切换分支草稿，不会改变当前发布版本，是否继续？`,
+      "新建分支草稿确认",
+      {
+        type: "warning",
+        confirmButtonText: "确认切换",
+        cancelButtonText: "取消",
+      }
+    );
+  } catch {
+    return;
+  }
+  rollbackDialogLoading.value = true;
+  try {
+    const { data } = await checkoutSetupBranchDraft(project.value.id, {
+      expected_version: setupRevision.value,
+      target_version: targetVersion,
+    });
+    applySetupResponseMeta(data);
+    applySetupDraft(clone(data.data));
+    clearSetupValidationErrors();
+    markSetupSynced();
+    clearLocalSetupDraft();
+    setupViewMode.value = "draft";
+    setupSaveMeta.value = {
+      updatedAt: formatDisplayTime(data.updated_at),
+      savedBy: data.saved_by_name || resolveSavedByDisplay(data.saved_by),
+      serverSynced: true,
+    };
+    updateLastServerSaveMeta(data.updated_at, data.saved_by_name || resolveSavedByDisplay(data.saved_by));
+    const checkoutRevision = data.version;
+
+    try {
+      const { data: refillData } = await refillSetupDraftOnServer(project.value.id, {
+        expected_version: checkoutRevision,
+      });
+      applySetupResponseMeta(refillData);
+      applySetupDraft(clone(refillData.data));
+      clearSetupValidationErrors();
+      markSetupSynced();
+      clearLocalSetupDraft();
+      setupViewMode.value = "draft";
+      setupSaveMeta.value = {
+        updatedAt: formatDisplayTime(refillData.updated_at),
+        savedBy: refillData.saved_by_name || resolveSavedByDisplay(refillData.saved_by),
+        serverSynced: true,
+      };
+      updateLastServerSaveMeta(refillData.updated_at, refillData.saved_by_name || resolveSavedByDisplay(refillData.saved_by));
+      await refreshSetupDraftFromServer({ silent: true });
+      await loadSetupVersionHistory();
+      const currentBranch = setupCurrentBranchName.value || "main";
+      ElMessage.success(`已切换到分支草稿 ${currentBranch}，并自动回填为 ${targetDisplayVersion}`);
+    } catch (refillError: any) {
+      if (refillError?.response?.status === 409) {
+        ElMessage.warning("分支已切换，但自动回填发生版本冲突，正在刷新最新配置");
+      } else {
+        ElMessage.warning(getApiErrorMessage(refillError, "分支已切换，但自动回填失败"));
+      }
+      await refreshSetupDraftFromServer({ silent: true });
+      await loadSetupVersionHistory();
+    }
+  } catch (e: any) {
+    if (e?.response?.status === 409) {
+      ElMessage.warning("切换失败：版本冲突，正在刷新最新配置");
+      await refreshSetupDraftFromServer({ silent: true });
+      await loadSetupVersionHistory();
+      return;
+    }
+    ElMessage.error(getApiErrorMessage(e, "新建分支草稿失败"));
+  } finally {
+    rollbackDialogLoading.value = false;
+  }
+};
+
+const excelEscapeXml = (value: string): string =>
+  value
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+
+const normalizeExcelCellValue = (value: unknown): string | number => {
+  if (value === null || value === undefined) return "";
+  if (typeof value === "number") return Number.isFinite(value) ? value : "";
+  if (typeof value === "boolean") return value ? "是" : "否";
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+};
+
+const buildExcelCellXml = (value: unknown, styleId = "cell"): string => {
+  const normalized = normalizeExcelCellValue(value);
+  if (typeof normalized === "number") {
+    return `<Cell ss:StyleID="${styleId}"><Data ss:Type="Number">${normalized}</Data></Cell>`;
+  }
+  return `<Cell ss:StyleID="${styleId}"><Data ss:Type="String">${excelEscapeXml(normalized)}</Data></Cell>`;
+};
+
+const sanitizeExcelSheetName = (name: string): string => {
+  const replaced = String(name || "")
+    .replace(/[\\/:*?\[\]]/g, "_")
+    .trim();
+  if (!replaced) return "Sheet";
+  return replaced.slice(0, 31);
+};
+
+const formatEnrollmentTargetsText = (raw: Record<string, number>): string => {
+  const entries = Object.entries(raw || {})
+    .filter(([key, value]) => key && value !== null && value !== undefined)
+    .sort(([a], [b]) => a.localeCompare(b, "zh-CN"));
+  if (!entries.length) return "-";
+  return entries.map(([key, value]) => `${key}:${normalizeEnrollmentTarget(value)}`).join("；");
+};
+
+const buildExcelWorksheetXml = (
+  name: string,
+  metaRows: Array<[string, unknown]>,
+  headers: string[],
+  rows: unknown[][]
+): string => {
+  const sheetName = sanitizeExcelSheetName(name);
+  const columnCount = Math.max(1, headers.length);
+  const safeRows = rows.length > 0 ? rows : [[...Array(columnCount - 1).fill(""), "无数据"]];
+  const metaXml = metaRows
+    .map(
+      ([key, value]) =>
+        `<Row>${buildExcelCellXml(key, "metaKey")}<Cell ss:StyleID="metaValue" ss:MergeAcross="${Math.max(columnCount - 2, 0)}"><Data ss:Type="String">${excelEscapeXml(
+          String(normalizeExcelCellValue(value) || "-")
+        )}</Data></Cell></Row>`
+    )
+    .join("");
+  const headerXml = `<Row>${headers.map((header) => buildExcelCellXml(header, "header")).join("")}</Row>`;
+  const dataXml = safeRows
+    .map((row) => `<Row>${headers.map((_, idx) => buildExcelCellXml(row[idx] ?? "", "cell")).join("")}</Row>`)
+    .join("");
+  return `<Worksheet ss:Name="${excelEscapeXml(sheetName)}"><Table>${metaXml}<Row/>${headerXml}${dataXml}</Table></Worksheet>`;
+};
+
 const downloadVersionRaw = (versionItem: StudySetupConfigVersionItem) => {
   if (!project.value) return;
-  const displayVersion = getDisplayVersion(versionItem.version);
-  const payload = {
-    study_id: versionItem.study_id,
-    version: versionItem.version,
-    display_version: displayVersion,
-    published_by: versionItem.published_by || null,
-    published_by_name: versionItem.published_by_name || null,
-    published_at: versionItem.published_at || null,
-    config: versionItem.config,
-  };
-  const blob = new Blob([JSON.stringify(payload, null, 2)], { type: "application/json;charset=utf-8" });
+  const displayVersion = getDisplayVersionLabel(versionItem.version);
+  const branchName = versionItem.branch_name || "main";
+  const configDraft = isSetupDraftShape(versionItem.config) ? versionItem.config : createDefaultSetupDraft([]);
+  const projectSnapshot = isProjectPublishSnapshotShape(versionItem.published_project_snapshot)
+    ? versionItem.published_project_snapshot
+    : null;
+  const metaRows: Array<[string, unknown]> = [
+    ["导出版本", displayVersion],
+    ["版本分支", branchName],
+    ["发布人", versionItem.published_by_name || "-"],
+    ["发布时间", versionItem.published_at || "-"],
+  ];
+
+  const step1Headers = ["字段", "值"];
+  const step1Rows: unknown[][] = [
+    ["项目名称", projectSnapshot?.name || "-"],
+    ["项目全称", projectSnapshot?.project_full_name || "-"],
+    ["申办方", projectSnapshot?.sponsor || "-"],
+    ["项目编号", projectSnapshot?.code || "-"],
+    ["方案号", projectSnapshot?.protocol_no || "-"],
+    ["组长单位", projectSnapshot?.lead_unit || "-"],
+    ["主要研究者", projectSnapshot?.principal_investigator || "-"],
+    ["主PM", projectSnapshot?.main_pm || "-"],
+    ["研究分期", projectSnapshot?.research_analysis || "-"],
+    ["研究产品", projectSnapshot?.research_product || "-"],
+    ["对照产品", projectSnapshot?.control_product || "-"],
+    ["适应症", projectSnapshot?.indication || "-"],
+    ["研究人群", projectSnapshot?.research_population || "-"],
+    ["研究设计", projectSnapshot?.research_design || "-"],
+    ["计划开始日期", projectSnapshot?.plan_start_date || "-"],
+    ["计划结束日期", projectSnapshot?.plan_end_date || "-"],
+    ["项目状态", projectSnapshot?.status ? statusLabel(projectSnapshot.status) : "-"],
+    ["计划中心数", projectSnapshot?.planned_site_count ?? "-"],
+    ["计划入组数", projectSnapshot?.planned_enrollment_count ?? "-"],
+    ["访视总数", projectSnapshot?.visit_total ?? "-"],
+    ["访视间隔（天）", projectSnapshot?.visit_interval_days ?? "-"],
+    ["窗口期起始偏移", projectSnapshot?.visit_window_start_offset ?? "-"],
+    ["窗口期结束偏移", projectSnapshot?.visit_window_end_offset ?? "-"],
+    ["方案摘要说明", projectSnapshot?.summary_note || "-"],
+    ["研究目标摘要", projectSnapshot?.objective_note || "-"],
+  ];
+
+  const step2Headers = ["里程碑", "计划日期", "开始日期", "结束日期", "耗时(天)", "负责人", "状态", "备注"];
+  const step2Rows = configDraft.projectMilestones.map((item) => [
+    item.name || "-",
+    item.planDate || "-",
+    item.startDate || "-",
+    item.endDate || "-",
+    item.durationDays ?? "-",
+    item.owner || "-",
+    item.status || "-",
+    item.remark || "-",
+  ]);
+
+  const step3Headers = ["计划开始日期", "计划结束日期", "当前周期", "计划入组总数", "周期类型", "周期", "计划人数", "备注"];
+  const parsedPlan = parseEnrollmentStageBreakdown(configDraft.enrollmentPlan.stageBreakdown);
+  const step3CycleRows: unknown[][] = [];
+  (["month", "quarter"] as EnrollmentCycle[]).forEach((cycle) => {
+    const entries = Object.entries(parsedPlan.targetsByCycle[cycle] || {})
+      .filter(([key, value]) => key && value !== null && value !== undefined)
+      .sort(([a], [b]) => a.localeCompare(b, "zh-CN"));
+    entries.forEach(([key, value]) => {
+      step3CycleRows.push([
+        configDraft.enrollmentPlan.startDate || "-",
+        configDraft.enrollmentPlan.endDate || "-",
+        enrollmentCycleLabelMap[parsedPlan.cycle] || parsedPlan.cycle,
+        normalizeEnrollmentTarget(configDraft.enrollmentPlan.totalTarget),
+        enrollmentCycleLabelMap[cycle] || cycle,
+        key,
+        normalizeEnrollmentTarget(value),
+        configDraft.enrollmentPlan.monthlyGoalNote || "-",
+      ]);
+    });
+  });
+  if (!step3CycleRows.length) {
+    step3CycleRows.push([
+      configDraft.enrollmentPlan.startDate || "-",
+      configDraft.enrollmentPlan.endDate || "-",
+      enrollmentCycleLabelMap[parsedPlan.cycle] || parsedPlan.cycle,
+      normalizeEnrollmentTarget(configDraft.enrollmentPlan.totalTarget),
+      "-",
+      "-",
+      "-",
+      configDraft.enrollmentPlan.monthlyGoalNote || "-",
+    ]);
+  }
+
+  const step4Headers = ["中心ID", "中心名称", "里程碑", "计划日期", "负责人", "状态", "备注"];
+  const step4Rows = configDraft.siteMilestones.map((item) => [
+    item.id || "-",
+    item.id ? getSiteName(item.id) : "-",
+    item.milestone || "-",
+    item.planDate || "-",
+    item.owner || "-",
+    item.status || "-",
+    item.remark || "-",
+  ]);
+
+  const step5Headers = ["中心ID", "中心名称", "计划入组数", "开始日期", "结束日期", "月度分解", "季度分解", "备注"];
+  const step5Rows = configDraft.siteEnrollmentPlans.map((item) => {
+    const parsed = parseSiteEnrollmentStageBreakdown(item.stageBreakdown);
+    return [
+      item.siteId || "-",
+      item.siteName || "-",
+      normalizeEnrollmentTarget(item.target),
+      item.startDate || "-",
+      item.endDate || "-",
+      formatEnrollmentTargetsText(parsed.month),
+      formatEnrollmentTargetsText(parsed.quarter),
+      item.note || "-",
+    ];
+  });
+
+  const step6Headers = ["策略类型", "策略详情", "监查次数", "是否启用", "更新时间"];
+  const step6Rows = configDraft.monitoringStrategies.map((item) => [
+    item.strategyType || "-",
+    item.detail || "-",
+    item.frequency || "-",
+    item.enabled ? "是" : "否",
+    item.updatedAt || "-",
+  ]);
+
+  const step7Headers = ["中心ID", "中心名称", "确认人", "确认状态", "确认日期", "备注"];
+  const step7Rows = configDraft.centerConfirm.map((item) => [
+    item.siteId || "-",
+    item.siteName || "-",
+    item.confirmer || "-",
+    item.confirmStatus || "-",
+    item.confirmDate || "-",
+    item.note || "-",
+  ]);
+
+  const workbookXml = `<?xml version="1.0" encoding="UTF-8"?>
+<?mso-application progid="Excel.Sheet"?>
+<Workbook xmlns="urn:schemas-microsoft-com:office:spreadsheet"
+ xmlns:o="urn:schemas-microsoft-com:office:office"
+ xmlns:x="urn:schemas-microsoft-com:office:excel"
+ xmlns:ss="urn:schemas-microsoft-com:office:spreadsheet"
+ xmlns:html="http://www.w3.org/TR/REC-html40">
+<Styles>
+  <Style ss:ID="Default" ss:Name="Normal">
+    <Alignment ss:Vertical="Center"/>
+    <Font ss:FontName="Microsoft YaHei" ss:Size="10"/>
+  </Style>
+  <Style ss:ID="header">
+    <Font ss:FontName="Microsoft YaHei" ss:Size="10" ss:Bold="1"/>
+    <Interior ss:Color="#EAF1FB" ss:Pattern="Solid"/>
+    <Borders>
+      <Border ss:Position="Bottom" ss:LineStyle="Continuous" ss:Weight="1" ss:Color="#C8D6EA"/>
+      <Border ss:Position="Top" ss:LineStyle="Continuous" ss:Weight="1" ss:Color="#C8D6EA"/>
+      <Border ss:Position="Left" ss:LineStyle="Continuous" ss:Weight="1" ss:Color="#C8D6EA"/>
+      <Border ss:Position="Right" ss:LineStyle="Continuous" ss:Weight="1" ss:Color="#C8D6EA"/>
+    </Borders>
+  </Style>
+  <Style ss:ID="cell">
+    <Borders>
+      <Border ss:Position="Bottom" ss:LineStyle="Continuous" ss:Weight="1" ss:Color="#E1E8F3"/>
+      <Border ss:Position="Top" ss:LineStyle="Continuous" ss:Weight="1" ss:Color="#E1E8F3"/>
+      <Border ss:Position="Left" ss:LineStyle="Continuous" ss:Weight="1" ss:Color="#E1E8F3"/>
+      <Border ss:Position="Right" ss:LineStyle="Continuous" ss:Weight="1" ss:Color="#E1E8F3"/>
+    </Borders>
+  </Style>
+  <Style ss:ID="metaKey">
+    <Font ss:FontName="Microsoft YaHei" ss:Size="10" ss:Bold="1"/>
+    <Interior ss:Color="#F4F7FC" ss:Pattern="Solid"/>
+  </Style>
+  <Style ss:ID="metaValue">
+    <Alignment ss:Vertical="Center" ss:WrapText="1"/>
+    <Interior ss:Color="#FCFDFF" ss:Pattern="Solid"/>
+  </Style>
+</Styles>
+${buildExcelWorksheetXml("第1步-项目信息", metaRows, step1Headers, step1Rows)}
+${buildExcelWorksheetXml("第2步-项目里程碑", metaRows, step2Headers, step2Rows)}
+${buildExcelWorksheetXml("第3步-项目入组计划", metaRows, step3Headers, step3CycleRows)}
+${buildExcelWorksheetXml("第4步-中心里程碑", metaRows, step4Headers, step4Rows)}
+${buildExcelWorksheetXml("第5步-中心入组计划", metaRows, step5Headers, step5Rows)}
+${buildExcelWorksheetXml("第6步-监查计划策略", metaRows, step6Headers, step6Rows)}
+${buildExcelWorksheetXml("第7步-中心确认", metaRows, step7Headers, step7Rows)}
+</Workbook>`;
+
+  const blob = new Blob([`\uFEFF${workbookXml}`], { type: "application/vnd.ms-excel;charset=utf-8;" });
   const url = URL.createObjectURL(blob);
-  const filename = `setup-config-raw-v${displayVersion}-${project.value.code || project.value.id}.json`;
+  const safeVersionLabel = displayVersion.replace(/[^\w.-]/g, "_");
+  const filename = `setup-config-${safeVersionLabel}-${project.value.code || project.value.id}.xls`;
   const link = document.createElement("a");
   link.href = url;
   link.download = filename;
@@ -4549,12 +5379,12 @@ const downloadVersionRaw = (versionItem: StudySetupConfigVersionItem) => {
 const removeVersion = async (targetVersion: number) => {
   if (!project.value) return;
   if (isLatestPublishedVersion(targetVersion)) {
-    ElMessage.warning("最新发布版本不能删除");
+    ElMessage.warning("当前发布版本不能删除");
     return;
   }
-  const displayVersion = getDisplayVersion(targetVersion);
+  const displayVersion = getDisplayVersionLabel(targetVersion);
   try {
-    await ElMessageBox.confirm(`确认删除发布版本 v${displayVersion} 的快照？此操作不可恢复。`, "删除确认", {
+    await ElMessageBox.confirm(`确认删除发布版本 ${displayVersion} 的快照？此操作不可恢复。`, "删除确认", {
       type: "warning",
       confirmButtonText: "确认删除",
       cancelButtonText: "取消",
@@ -4566,7 +5396,7 @@ const removeVersion = async (targetVersion: number) => {
   try {
     await deleteSetupVersion(project.value.id, targetVersion);
     await loadSetupVersionHistory();
-    ElMessage.success(`已删除发布版本 v${displayVersion}`);
+    ElMessage.success(`已删除发布版本 ${displayVersion}`);
   } catch (e: any) {
     ElMessage.error(getApiErrorMessage(e, "删除版本失败"));
   } finally {
@@ -4574,6 +5404,154 @@ const removeVersion = async (targetVersion: number) => {
   }
 };
 
+const mergeVersionToMain = async (sourceVersion: number) => {
+  if (!project.value) return;
+  const sourceVersionLabel = getDisplayVersionLabel(sourceVersion);
+  try {
+    await ElMessageBox.confirm(
+      `确认将 ${sourceVersionLabel} 合并到主分支并生成新的主版本号？`,
+      "合并主分支确认",
+      {
+        type: "warning",
+        confirmButtonText: "确认合并",
+        cancelButtonText: "取消",
+      }
+    );
+  } catch {
+    return;
+  }
+  rollbackDialogLoading.value = true;
+  try {
+    const { data } = await mergeSetupVersionToMain(project.value.id, {
+      expected_version: setupRevision.value,
+      source_version: sourceVersion,
+    });
+    applySetupResponseMeta(data);
+    applySetupDraft(clone(data.data));
+    clearSetupValidationErrors();
+    markSetupSynced();
+    clearLocalSetupDraft();
+    setupViewMode.value = "preview";
+    setupSaveMeta.value = {
+      updatedAt: formatDisplayTime(data.updated_at),
+      savedBy: data.saved_by_name || resolveSavedByDisplay(data.saved_by),
+      serverSynced: true,
+    };
+    updateLastServerSaveMeta(data.updated_at, data.saved_by_name || resolveSavedByDisplay(data.saved_by));
+    await loadSetupVersionHistory();
+    ElMessage.success(`${sourceVersionLabel} 已合并到主分支，当前发布为 ${setupPublishedVersionText.value}`);
+  } catch (e: any) {
+    if (e?.response?.status === 409) {
+      ElMessage.warning("合并失败：版本冲突，正在刷新最新配置");
+      await refreshSetupDraftFromServer({ silent: true });
+      await loadSetupVersionHistory();
+      return;
+    }
+    ElMessage.error(getApiErrorMessage(e, "合并主分支失败"));
+  } finally {
+    rollbackDialogLoading.value = false;
+  }
+};
+
+const handleRefillDraft = async () => {
+  if (!project.value || !canManageSetup.value) return;
+  try {
+    await ElMessageBox.confirm(
+      `确认将草稿一键回填为当前发布版本 ${setupPublishedVersionText.value} 的内容？`,
+      "一键回填确认",
+      {
+        type: "warning",
+        confirmButtonText: "确认回填",
+        cancelButtonText: "取消",
+      }
+    );
+  } catch {
+    return;
+  }
+  primarySaveLoading.value = true;
+  try {
+    const { data } = await refillSetupDraftOnServer(project.value.id, {
+      expected_version: setupRevision.value,
+    });
+    applySetupResponseMeta(data);
+    applySetupDraft(clone(data.data));
+    clearSetupValidationErrors();
+    markSetupSynced();
+    clearLocalSetupDraft();
+    setupViewMode.value = "draft";
+    setupSaveMeta.value = {
+      updatedAt: formatDisplayTime(data.updated_at),
+      savedBy: data.saved_by_name || resolveSavedByDisplay(data.saved_by),
+      serverSynced: true,
+    };
+    updateLastServerSaveMeta(data.updated_at, data.saved_by_name || resolveSavedByDisplay(data.saved_by));
+    await refreshSetupDraftFromServer({ silent: true });
+    await loadSetupVersionHistory();
+    ElMessage.success(`草稿已回填为 ${setupPublishedVersionText.value}`);
+  } catch (e: any) {
+    if (e?.response?.status === 409) {
+      ElMessage.warning("回填失败：版本冲突，正在刷新最新配置");
+      await refreshSetupDraftFromServer({ silent: true });
+      await loadSetupVersionHistory();
+      return;
+    }
+    ElMessage.error(getApiErrorMessage(e, "草稿回填失败"));
+  } finally {
+    primarySaveLoading.value = false;
+  }
+};
+
+const handleClearDraft = async () => {
+  if (!project.value || !canManageSetup.value) return;
+  try {
+    await ElMessageBox.confirm(
+      "确认清空当前立项配置草稿（第2-7步）？该操作不会影响已发布版本，也不会影响第1步项目信息主数据。",
+      "清空草稿确认",
+      {
+        type: "warning",
+        confirmButtonText: "确认清空",
+        cancelButtonText: "取消",
+      }
+    );
+  } catch {
+    return;
+  }
+  primarySaveLoading.value = true;
+  try {
+    const { data } = await clearSetupDraftOnServer(project.value.id, {
+      expected_version: setupRevision.value,
+    });
+    applySetupResponseMeta(data);
+    applySetupDraft(createDefaultSetupDraft(siteOptions.value));
+    clearSetupValidationErrors();
+    markSetupSynced();
+    clearLocalSetupDraft();
+    setupViewMode.value = "draft";
+    setupSaveMeta.value = {
+      updatedAt: formatDisplayTime(data.updated_at),
+      savedBy: data.saved_by_name || resolveSavedByDisplay(data.saved_by),
+      serverSynced: true,
+    };
+    updateLastServerSaveMeta(data.updated_at, data.saved_by_name || resolveSavedByDisplay(data.saved_by));
+    await refreshSetupDraftFromServer({ silent: true });
+    await loadSetupVersionHistory();
+    if (activeStep.value === 0) {
+      activeStep.value = 1;
+    }
+    ElMessage.success(`草稿已清空（第2-7步已重置，当前发布仍为 ${setupPublishedVersionText.value}）`);
+  } catch (e: any) {
+    if (e?.response?.status === 409) {
+      ElMessage.warning("清空失败：版本冲突，正在刷新最新配置");
+      await refreshSetupDraftFromServer({ silent: true });
+      await loadSetupVersionHistory();
+      return;
+    }
+    ElMessage.error(getApiErrorMessage(e, "清空草稿失败"));
+  } finally {
+    primarySaveLoading.value = false;
+  }
+};
+
 const ensureCanSaveDraftAction = (): boolean => {
   if (!project.value) {
     ElMessage.warning("项目信息尚未加载完成，请稍后重试");
@@ -4588,7 +5566,7 @@ const ensureCanSaveDraftAction = (): boolean => {
     return false;
   }
   if (isPublishedView.value) {
-    ElMessage.info("当前为预览视图，请先切换到草稿后再保存");
+    ElMessage.info("当前为只读视图，请先切换到草稿后再保存");
     return false;
   }
   return true;
@@ -4695,7 +5673,7 @@ const addProjectMilestone = () => {
 const ensureStep2Editable = (): boolean => {
   if (!project.value) return false;
   if (isPublishedView.value) {
-    ElMessage.info("当前为预览，请先切换到草稿后再操作");
+    ElMessage.info("当前为只读视图，请先切换到草稿后再操作");
     return false;
   }
   if (!canManageSetup.value) {
@@ -5047,6 +6025,7 @@ onMounted(() => {
   window.addEventListener("beforeunload", handleBeforeUnload);
 });
 onBeforeUnmount(() => {
+  window.removeEventListener("resize", syncRollbackAxisLayout);
   window.removeEventListener("beforeunload", handleBeforeUnload);
   if (autoSaveTimer.value) {
     window.clearTimeout(autoSaveTimer.value);
@@ -5076,17 +6055,17 @@ onBeforeUnmount(() => {
 .setup-header {
   position: relative;
   z-index: 1250;
-  background: linear-gradient(105deg, #091633 0%, #163d9a 52%, #2f8ce8 100%);
-  border-bottom: 1px solid rgba(199, 218, 255, 0.2);
-  padding: 12px 14px;
+  background: linear-gradient(135deg, #0b1426 0%, #17346b 50%, #2f69d2 100%);
+  padding: 6px 16px; /* 极限垂直留白压缩 */
+  border-bottom: 1px solid rgba(255, 255, 255, 0.1);
+  box-shadow: 0 4px 20px rgba(0, 0, 0, 0.15);
 }
 
 .setup-flow {
   display: flex;
   align-items: center;
   justify-content: space-between;
-  overflow: hidden;
-  padding-bottom: 2px;
+  margin-bottom: 8px; /* 极限缩短行间距 */
   gap: 0;
 }
 
@@ -5097,80 +6076,100 @@ onBeforeUnmount(() => {
   min-width: 0;
   white-space: nowrap;
   cursor: pointer;
-  color: rgba(226, 240, 255, 0.86);
+  color: rgba(255, 255, 255, 0.55);
+  transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
 }
 
-.flow-index {
-  width: 24px;
-  height: 24px;
-  border-radius: 50%;
-  border: 1.5px solid rgba(220, 236, 255, 0.92);
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
-  margin-right: 6px;
-  font-size: 12px;
-  font-weight: 700;
-  color: #ffffff;
-  flex: 0 0 auto;
-}
-
-.flow-label {
-  font-size: 13px;
-  line-height: 1;
-  font-weight: 600;
-  color: inherit;
-  flex: 0 1 auto;
-}
-
-.flow-done-icon {
-  margin-left: 4px;
-  color: #22c55e;
-  font-size: 13px;
-  flex: 0 0 auto;
-}
-
-.flow-connector {
-  width: auto;
-  min-width: 8px;
-  flex: 1 1 auto;
-  height: 2px;
-  background: rgba(206, 227, 255, 0.55);
-  margin: 0 6px;
-  border-radius: 999px;
+.flow-step:hover {
+  color: rgba(255, 255, 255, 0.85);
 }
 
 .flow-step.active {
   color: #ffffff;
-}
-
-.flow-step.has-error .flow-index {
-  border-color: #ff8d8d;
-  color: #ffd1d1;
-}
-
-.flow-step.active .flow-index {
-  background: rgba(255, 255, 255, 0.2);
-  border-color: #ffffff;
-  color: #ffffff;
+  text-shadow: 0 0 12px rgba(255, 255, 255, 0.4);
 }
 
 .flow-step.done {
+  color: #a7f3d0;
+}
+
+.flow-index {
+  width: 26px;
+  height: 26px;
+  border-radius: 50%;
+  border: 1.5px solid rgba(255, 255, 255, 0.3);
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  margin-right: 8px;
+  font-size: 13px;
+  font-weight: 700;
+  background: rgba(0, 0, 0, 0.2);
+  color: inherit;
+  transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+  flex: 0 0 auto;
+}
+
+.flow-step.active .flow-index {
+  background: #3b82f6; 
+  border-color: #60a5fa;
+  box-shadow: 0 0 12px rgba(59, 130, 246, 0.6);
   color: #ffffff;
 }
 
 .flow-step.done .flow-index {
-  border-color: #d8e9ff;
-  color: #d8e9ff;
+  background: #10b981; 
+  border-color: #34d399;
+  color: #ffffff;
+}
+
+.flow-label {
+  font-size: 14px;
+  font-weight: 600;
+  letter-spacing: 0.02em;
+  flex: 0 1 auto;
+}
+
+.flow-done-icon {
+  margin-left: 6px;
+  color: #10b981;
+  font-size: 15px;
+  flex: 0 0 auto;
+}
+
+.flow-connector {
+  flex: 1 1 auto;
+  min-width: 8px;
+  height: 2px;
+  background: rgba(255, 255, 255, 0.12);
+  margin: 0 12px;
+  border-radius: 999px;
+  position: relative;
+  overflow: hidden;
+  transition: background 0.3s ease;
+}
+
+.flow-step.done .flow-connector {
+  background: rgba(16, 185, 129, 0.4);
+}
+
+.flow-step.has-error .flow-index {
+  border-color: #f87171;
+  background: rgba(239, 68, 68, 0.2);
+  color: #fca5a5;
 }
 
 .setup-toolbar {
-  margin-top: 4px;
   display: flex;
   align-items: center;
   justify-content: space-between;
   gap: 12px;
-  flex-wrap: wrap;
+  flex-wrap: nowrap;
+  white-space: nowrap;
+  overflow-x: auto;
+}
+.setup-toolbar::-webkit-scrollbar {
+  display: none;
 }
 
 .setup-step-errors {
@@ -5218,38 +6217,88 @@ onBeforeUnmount(() => {
   margin-top: 6px;
 }
 
-.setup-switcher {
+.setup-toolbar-left {
   display: flex;
   align-items: center;
-  gap: 10px;
-  padding: 8px 12px;
-  border-radius: 14px;
-  background: rgba(11, 30, 75, 0.45);
-  border: 1px solid rgba(187, 217, 255, 0.28);
+  gap: 12px;
+  flex-wrap: nowrap;
 }
 
-.setup-switcher-wrap {
-  display: flex;
-  flex-direction: column;
-  gap: 4px;
-}
-
-.setup-save-meta {
+.setup-version-meta {
   display: flex;
   align-items: center;
-  gap: 6px;
-  flex-wrap: wrap;
+  gap: 12px;
+}
+
+.meta-item {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  background: rgba(255, 255, 255, 0.06);
+  border: 1px solid rgba(255, 255, 255, 0.12);
+  padding: 4px 10px;
+  border-radius: 8px;
   font-size: 12px;
-  color: rgba(226, 240, 255, 0.9);
-  padding-left: 4px;
+  color: rgba(255, 255, 255, 0.9);
+  backdrop-filter: blur(8px);
 }
 
-.setup-save-meta .meta-text {
-  color: rgba(226, 240, 255, 0.9);
+.meta-label {
+  font-weight: 600;
+  color: rgba(255, 255, 255, 0.5);
 }
 
-.setup-view-mode {
-  padding-left: 2px;
+.meta-item:first-child .meta-label {
+  color: #a7f3d0;
+}
+
+.meta-group {
+  display: flex;
+  align-items: center;
+  background: rgba(0, 0, 0, 0.2);
+  border-radius: 4px;
+  overflow: hidden;
+  border: 1px solid rgba(255, 255, 255, 0.05);
+}
+
+.meta-br {
+  background: rgba(255, 255, 255, 0.08);
+  padding: 2px 6px;
+  color: #93c5fd;
+}
+
+.draft-group .meta-br {
+  color: #c4b5fd;
+}
+
+.meta-ver {
+  padding: 2px 6px;
+  font-weight: 700;
+  color: #ffffff;
+}
+
+.meta-time {
+  color: rgba(255, 255, 255, 0.4);
+  display: inline-flex;
+  align-items: center;
+  cursor: help;
+  transition: color 0.2s;
+  font-size: 14px;
+}
+
+.meta-time:hover {
+  color: rgba(255, 255, 255, 0.8);
+}
+
+.meta-status {
+  margin-left: 2px;
+  border: none;
+  background: rgba(255, 255, 255, 0.1) !important;
+}
+
+.locked-tag {
+  background: rgba(245, 158, 11, 0.1) !important;
+  border-color: rgba(245, 158, 11, 0.3) !important;
 }
 
 .setup-view-mode :deep(.el-radio-group) {
@@ -5293,35 +6342,633 @@ onBeforeUnmount(() => {
 .setup-toolbar-actions {
   display: flex;
   align-items: center;
-  gap: 7px;
-  flex-wrap: wrap;
+  gap: 8px;
+  flex-wrap: nowrap;
+  padding-top: 2px;
 }
 
 .setup-toolbar-actions :deep(.el-button) {
   border-radius: 10px;
 }
 
-.setup-toolbar-actions :deep(.el-button--primary),
-.setup-toolbar-actions :deep(.el-button--success.is-plain),
-.setup-toolbar-actions :deep(.el-button--warning.is-plain),
-.setup-toolbar-actions :deep(.el-button--info.is-plain) {
-  background: rgba(11, 30, 75, 0.42);
-  border-color: rgba(167, 199, 255, 0.52);
+/* ========== 版本管理对话框 - 美化样式 ========== */
+
+/* 对话框整体样式 */
+.version-mgr-dialog :deep(.el-dialog) {
+  border-radius: 16px;
+  overflow: hidden;
+  box-shadow: 0 20px 60px rgba(15, 30, 60, 0.18), 0 2px 12px rgba(15, 30, 60, 0.08);
+}
+
+.version-mgr-dialog :deep(.el-dialog__header) {
+  padding: 0;
+  margin: 0;
+}
+
+.version-mgr-dialog :deep(.el-dialog__body) {
+  padding: 0;
+}
+
+.version-mgr-dialog :deep(.el-dialog__footer) {
+  padding: 12px 20px;
+  background: #f8fafc;
+  border-top: 1px solid #edf2f7;
+}
+
+/* 对话框头部 */
+.vm-dialog-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 16px 20px;
+  background: linear-gradient(135deg, #1e3a5f 0%, #2d5a8e 50%, #1a4478 100%);
   color: #ffffff;
 }
 
-.setup-toolbar-actions :deep(.el-button--primary:hover),
-.setup-toolbar-actions :deep(.el-button--success.is-plain:hover),
-.setup-toolbar-actions :deep(.el-button--warning.is-plain:hover),
-.setup-toolbar-actions :deep(.el-button--info.is-plain:hover) {
-  background: rgba(26, 62, 147, 0.66);
-  color: #ffffff;
+.vm-dialog-header-left {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+}
+
+.vm-dialog-icon {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 36px;
+  height: 36px;
+  border-radius: 10px;
+  background: rgba(255, 255, 255, 0.15);
+  backdrop-filter: blur(8px);
+}
+
+.vm-dialog-title {
+  font-size: 17px;
+  font-weight: 700;
+  letter-spacing: 0.02em;
+}
+
+.vm-version-count-tag {
+  background: rgba(255, 255, 255, 0.18) !important;
+  border-color: rgba(255, 255, 255, 0.25) !important;
+  color: rgba(255, 255, 255, 0.92) !important;
+  font-weight: 600;
+  font-size: 11px;
+  backdrop-filter: blur(4px);
+}
+
+.vm-dialog-close-btn {
+  background: rgba(255, 255, 255, 0.12) !important;
+  border: 1px solid rgba(255, 255, 255, 0.2) !important;
+  color: rgba(255, 255, 255, 0.85) !important;
+  transition: all 0.2s ease;
+}
+
+.vm-dialog-close-btn:hover {
+  background: rgba(255, 255, 255, 0.25) !important;
+  color: #ffffff !important;
+  transform: rotate(90deg);
+}
+
+/* 对话框主体 */
+.vm-body {
+  padding: 16px 20px 12px;
+  min-height: 200px;
+  background: linear-gradient(180deg, #f0f5fb 0%, #f8fafc 60px, #ffffff 100%);
+}
+
+/* 图例栏 */
+.vm-legend-bar {
+  display: flex;
+  align-items: center;
+  gap: 16px;
+  margin-bottom: 14px;
+  padding: 10px 14px;
+  background: #ffffff;
+  border-radius: 10px;
+  border: 1px solid #e8eef6;
+  box-shadow: 0 1px 4px rgba(15, 40, 80, 0.04);
+}
+
+.vm-legend-section {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  flex-wrap: wrap;
+}
+
+.vm-legend-label {
+  font-size: 12px;
+  font-weight: 600;
+  color: #475569;
+  white-space: nowrap;
+  padding-right: 4px;
+  border-right: 2px solid #e2e8f0;
+}
+
+.vm-legend-tags {
+  display: flex;
+  gap: 8px;
+  flex-wrap: wrap;
+}
+
+.vm-lane-badge {
+  display: inline-flex;
+  align-items: center;
+  gap: 5px;
+  padding: 3px 10px 3px 7px;
+  font-size: 12px;
+  font-weight: 600;
+  color: #64748b;
+  background: #f1f5f9;
+  border-radius: 20px;
+  border: 1px solid #e2e8f0;
+  transition: all 0.2s ease;
+}
+
+.vm-lane-badge:hover {
+  background: #e8eff8;
+  border-color: #c8d8ea;
+}
+
+.vm-lane-badge.is-main {
+  color: #1e40af;
+  background: linear-gradient(135deg, #eff6ff, #dbeafe);
+  border-color: #bfdbfe;
+}
+
+.vm-lane-badge-dot {
+  width: 7px;
+  height: 7px;
+  border-radius: 50%;
+  background: #94a3b8;
+}
+
+.vm-lane-badge.is-main .vm-lane-badge-dot {
+  background: #3b82f6;
+  box-shadow: 0 0 0 2px rgba(59, 130, 246, 0.2);
+}
+
+/* 轨道头部标签 */
+.rollback-axis-lane-head {
+  position: relative;
+  height: 28px;
+  margin: 0 0 8px;
+}
+
+.rollback-axis-lane-head-item {
+  position: absolute;
+  top: 0;
+  transform: translateX(-50%);
+  font-size: 10px;
+  line-height: 1;
+  color: #8896aa;
+  font-weight: 700;
+  letter-spacing: 0.03em;
+  text-transform: uppercase;
+  padding: 3px 6px;
+  background: #f0f4f8;
+  border-radius: 4px;
+}
+
+.rollback-axis-lane-head-item.is-main {
+  color: #3b6db5;
+  background: #e4edf8;
+}
+
+/* 时间线滚动区域 */
+.rollback-axis-scroll {
+  position: relative;
+  max-height: 400px;
+  overflow: auto;
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  padding: 6px 0;
+}
+
+.rollback-axis-scroll::-webkit-scrollbar {
+  width: 5px;
+}
+
+.rollback-axis-scroll::-webkit-scrollbar-track {
+  background: transparent;
+}
+
+.rollback-axis-scroll::-webkit-scrollbar-thumb {
+  background: #c8d6e5;
+  border-radius: 10px;
+}
+
+.rollback-axis-scroll::-webkit-scrollbar-thumb:hover {
+  background: #a0b4cc;
+}
+
+/* SVG 覆盖层 */
+.rollback-axis-overlay {
+  position: absolute;
+  top: 0;
+  left: 0;
+  pointer-events: none;
+  z-index: 1;
+}
+
+/* 版本行 */
+.rollback-axis-row {
+  position: relative;
+  z-index: 2;
+  display: flex;
+  gap: 10px;
+  padding: 4px 6px 4px 0;
+  border-radius: 10px;
+  transition: all 0.22s ease;
+}
+
+.rollback-axis-row:hover {
+  background: rgba(59, 130, 246, 0.04);
+}
+
+.rollback-axis-row.is-current-row {
+  background: linear-gradient(90deg, rgba(34, 197, 94, 0.06) 0%, rgba(34, 197, 94, 0.02) 100%);
+  box-shadow: inset 3px 0 0 #22c55e;
+}
+
+.rollback-axis-row.is-draft-base-row:not(.is-current-row) {
+  background: linear-gradient(90deg, rgba(99, 102, 241, 0.05) 0%, rgba(99, 102, 241, 0.01) 100%);
+  box-shadow: inset 3px 0 0 #8b9cf7;
+}
+
+/* 轨道图形 */
+.rollback-axis-graph {
+  position: relative;
+  min-height: 74px;
+  flex: 0 0 auto;
+}
+
+/* 轨道竖线段 */
+.rollback-axis-lane-segment {
+  position: absolute;
+  top: -8px;
+  bottom: -8px;
+  width: 2px;
+  background: linear-gradient(180deg, #d4dfe8, #cedbed);
+  transform: translateX(-50%);
+  opacity: 0.85;
+  border-radius: 1px;
+}
+
+.rollback-axis-lane-segment.is-main-lane {
+  width: 3px;
+  background: linear-gradient(180deg, #5b8fd4, #4a7ec8);
+  opacity: 0.9;
+}
+
+.rollback-axis-lane-segment.is-active-lane {
+  width: 2.5px;
+  background: linear-gradient(180deg, #818cf8, #6366f1);
+  opacity: 0.85;
+}
+
+/* SVG 同分支继承连接线 */
+.rollback-axis-branch-line {
+  stroke: #a5b4fc;
+  stroke-width: 3;
+  stroke-linecap: round;
+  opacity: 0.7;
+}
+
+.rollback-axis-branch-line.is-main {
+  stroke: #60a5fa;
+  stroke-width: 3.5;
+  opacity: 0.6;
+}
+
+/* SVG 连接线 */
+.rollback-axis-spawn-path {
+  fill: none;
+  stroke: url(#spawnGrad);
+  stroke-width: 2.5;
+  stroke-linecap: round;
+  stroke-linejoin: round;
+  opacity: 0.85;
+}
+
+.rollback-axis-merge-path {
+  fill: none;
+  stroke: url(#mergeGrad);
+  stroke-width: 2.5;
+  stroke-linecap: round;
+  stroke-linejoin: round;
+  stroke-dasharray: 6 3;
+  opacity: 0.85;
+}
+
+/* 轨道节点 */
+.rollback-axis-dot {
+  position: absolute;
+  top: 24px;
+  width: 14px;
+  height: 14px;
+  border-radius: 50%;
+  transform: translateX(-50%);
+  background: #94a3b8;
+  border: 2.5px solid #ffffff;
+  box-shadow: 0 0 0 2px rgba(148, 163, 184, 0.25), 0 2px 4px rgba(0, 0, 0, 0.08);
+  z-index: 3;
+  transition: all 0.25s ease;
+}
+
+.rollback-axis-row:hover .rollback-axis-dot {
+  transform: translateX(-50%) scale(1.2);
+}
+
+.rollback-axis-dot.is-main {
+  background: #3b82f6;
+  box-shadow: 0 0 0 2px rgba(59, 130, 246, 0.3), 0 2px 6px rgba(59, 130, 246, 0.15);
+}
+
+.rollback-axis-dot.is-current {
+  background: #22c55e;
+  width: 16px;
+  height: 16px;
+  top: 23px;
+  box-shadow: 0 0 0 3px rgba(34, 197, 94, 0.25), 0 2px 8px rgba(34, 197, 94, 0.2);
+  animation: dotPulse 2.5s ease-in-out infinite;
+}
+
+@keyframes dotPulse {
+  0%, 100% { box-shadow: 0 0 0 3px rgba(34, 197, 94, 0.25), 0 2px 8px rgba(34, 197, 94, 0.2); }
+  50% { box-shadow: 0 0 0 5px rgba(34, 197, 94, 0.12), 0 2px 12px rgba(34, 197, 94, 0.3); }
+}
+
+.rollback-axis-dot.is-merge {
+  background: #f59e0b;
+  border-color: #fffbeb;
+  box-shadow: 0 0 0 2px rgba(245, 158, 11, 0.25), 0 2px 4px rgba(245, 158, 11, 0.1);
+}
+
+/* 版本内容区域 */
+.rollback-axis-content {
+  flex: 1;
+  min-width: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  padding: 8px 0 10px;
+  border-bottom: 1px solid #f0f4f8;
+  transition: border-color 0.2s ease;
+}
+
+.rollback-axis-row:last-child .rollback-axis-content {
+  border-bottom: none;
+}
+
+.rollback-axis-row:hover .rollback-axis-content {
+  border-bottom-color: transparent;
+}
+
+/* 顶行标题 */
+.rollback-axis-topline {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  flex-wrap: wrap;
+}
+
+/* 版本号 */
+.rollback-axis-version {
+  font-size: 17px;
+  line-height: 1.15;
+  color: #1e293b;
+  font-weight: 800;
+  letter-spacing: -0.01em;
+}
+
+/* 状态徽章 */
+.vm-status-badge {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  padding: 2px 9px 2px 6px;
+  font-size: 11px;
+  font-weight: 600;
+  border-radius: 20px;
+  line-height: 1.5;
+  white-space: nowrap;
+}
+
+.vm-badge-published {
+  color: #166534;
+  background: linear-gradient(135deg, #dcfce7, #bbf7d0);
+  border: 1px solid #86efac;
+}
+
+.vm-badge-draft {
+  color: #3730a3;
+  background: linear-gradient(135deg, #e8e5ff, #ddd6fe);
+  border: 1px solid #c4b5fd;
+}
+
+.vm-badge-merge {
+  color: #92400e;
+  background: linear-gradient(135deg, #fef3c7, #fde68a);
+  border: 1px solid #fcd34d;
+}
+
+/* 元数据行 */
+.rollback-axis-meta {
+  display: flex;
+  gap: 14px;
+  flex-wrap: wrap;
+  font-size: 12px;
+  color: #64748b;
+}
+
+.vm-meta-item {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+}
+
+.vm-meta-item .el-icon {
+  color: #94a3b8;
+}
+
+/* 操作按钮行 */
+.rollback-axis-actions {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  flex-wrap: wrap;
+  margin-top: 2px;
+}
+
+.vm-action-btn {
+  border-radius: 6px !important;
+  font-size: 12px !important;
+  font-weight: 500 !important;
+  padding: 4px 10px !important;
+  height: 28px !important;
+  transition: all 0.2s ease !important;
+  border: 1px solid transparent !important;
+}
+
+.vm-action-btn .el-icon {
+  margin-right: 2px;
+}
+
+.vm-action-primary {
+  color: #3b82f6 !important;
+  background: #eff6ff !important;
+  border-color: #bfdbfe !important;
+}
+
+.vm-action-primary:hover {
+  color: #ffffff !important;
+  background: #3b82f6 !important;
+  border-color: #3b82f6 !important;
+  box-shadow: 0 2px 8px rgba(59, 130, 246, 0.25);
+}
+
+.vm-action-danger {
+  color: #ef4444 !important;
+  background: #fef2f2 !important;
+  border-color: #fecaca !important;
+}
+
+.vm-action-danger:hover {
+  color: #ffffff !important;
+  background: #ef4444 !important;
+  border-color: #ef4444 !important;
+  box-shadow: 0 2px 8px rgba(239, 68, 68, 0.25);
+}
+
+.vm-action-default {
+  color: #475569 !important;
+  background: #f8fafc !important;
+  border-color: #e2e8f0 !important;
+}
+
+.vm-action-default:hover {
+  color: #1e293b !important;
+  background: #f1f5f9 !important;
+  border-color: #cbd5e1 !important;
+  box-shadow: 0 2px 6px rgba(0, 0, 0, 0.06);
+}
+
+.vm-action-btn.is-disabled {
+  opacity: 0.4 !important;
+  cursor: not-allowed !important;
+}
+
+/* 对话框尾部 */
+.vm-dialog-footer {
+  display: flex;
+  justify-content: flex-end;
+}
+
+.setup-toolbar-actions :deep(.el-button) {
+  backdrop-filter: blur(4px);
+  -webkit-backdrop-filter: blur(4px);
+  background: rgba(255, 255, 255, 0.08) !important;
+  border: 1px solid rgba(255, 255, 255, 0.25) !important;
+  color: #ffffff !important;
+  border-radius: 8px;
+  padding: 0 12px;
+  height: 32px;
+  font-weight: 500;
+  white-space: nowrap;
+  transition: all 0.25s cubic-bezier(0.4, 0, 0.2, 1);
+}
+
+.setup-toolbar-actions :deep(.el-button:hover) {
+  background: rgba(255, 255, 255, 0.18) !important;
+  border-color: rgba(255, 255, 255, 0.4) !important;
+  transform: translateY(-2px);
+  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
+}
+
+.setup-toolbar-actions :deep(.el-button.is-disabled) {
+  opacity: 0.5;
+  background: rgba(255, 255, 255, 0.04) !important;
+  border-color: rgba(255, 255, 255, 0.1) !important;
+  color: rgba(255, 255, 255, 0.4) !important;
+  transform: none;
+  box-shadow: none;
+}
+
+/* 按钮特异性颜色提示 (利用边框和发光，不改变毛玻璃主体颜色) */
+.setup-toolbar-actions :deep(.el-button--success.is-plain) {
+  border-color: rgba(34, 197, 94, 0.4) !important;
+  color: #a7f3d0 !important;
+}
+.setup-toolbar-actions :deep(.el-button--success.is-plain:hover) {
+  background: rgba(34, 197, 94, 0.15) !important;
+  border-color: rgba(34, 197, 94, 0.6) !important;
+  color: #ffffff !important;
+  box-shadow: 0 4px 12px rgba(34, 197, 94, 0.2);
+}
+
+.setup-toolbar-actions :deep(.el-button--danger.is-plain) {
+  border-color: rgba(239, 68, 68, 0.4) !important;
+  color: #fca5a5 !important;
+}
+.setup-toolbar-actions :deep(.el-button--danger.is-plain:hover) {
+  background: rgba(239, 68, 68, 0.15) !important;
+  border-color: rgba(239, 68, 68, 0.6) !important;
+  color: #ffffff !important;
+  box-shadow: 0 4px 12px rgba(239, 68, 68, 0.2);
+}
+
+.setup-toolbar-actions :deep(.el-button--warning.is-plain) {
+  border-color: rgba(245, 158, 11, 0.4) !important;
+  color: #fde68a !important;
+}
+.setup-toolbar-actions :deep(.el-button--warning.is-plain:hover) {
+  background: rgba(245, 158, 11, 0.15) !important;
+  border-color: rgba(245, 158, 11, 0.6) !important;
+  color: #ffffff !important;
+  box-shadow: 0 4px 12px rgba(245, 158, 11, 0.2);
 }
 
 .secondary-menu-btn {
-  border-color: rgba(167, 199, 255, 0.52);
-  background: rgba(12, 36, 92, 0.25);
+  border-color: rgba(255, 255, 255, 0.25) !important;
+  background: rgba(255, 255, 255, 0.08) !important;
+}
+
+/* 模式切换单选按钮美化 */
+.setup-view-mode {
+  border-radius: 8px;
+  overflow: hidden;
+  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.08);
+}
+
+.setup-view-mode :deep(.el-radio-button__inner) {
+  background: rgba(255, 255, 255, 0.05);
+  border: 1px solid rgba(255, 255, 255, 0.15);
+  color: rgba(255, 255, 255, 0.6);
+  backdrop-filter: blur(8px);
+  -webkit-backdrop-filter: blur(8px);
+  box-shadow: none !important;
+  padding: 6px 14px;
+  font-weight: 500;
+  transition: all 0.2s;
+}
+
+.setup-view-mode :deep(.el-radio-button:not(:first-child) .el-radio-button__inner) {
+  border-left: 0;
+}
+
+.setup-view-mode :deep(.el-radio-button__inner:hover) {
+  background: rgba(255, 255, 255, 0.1);
+  color: rgba(255, 255, 255, 0.9);
+}
+
+.setup-view-mode :deep(.el-radio-button.is-active .el-radio-button__inner) {
+  background: #3b82f6;
+  border-color: #60a5fa;
   color: #ffffff;
+  font-weight: 600;
 }
 
 .setup-section {
@@ -5340,7 +6987,8 @@ onBeforeUnmount(() => {
   display: flex;
   flex-wrap: wrap;
   align-items: center;
-  gap: 10px 18px;
+  gap: 12px 32px;
+  padding: 4px 0 8px 0;
 }
 
 .enrollment-inline-group {
@@ -5352,15 +7000,18 @@ onBeforeUnmount(() => {
 
 .enrollment-inline-label {
   font-size: 13px;
-  font-weight: 600;
-  color: #4a6283;
-  background: #f3f6fb;
-  padding: 4px 10px;
-  border-radius: 6px;
-  height: 28px;
+  font-weight: 500;
+  color: #64748b;
+  background: transparent;
+  padding: 0;
   display: inline-flex;
   align-items: center;
-  border: 1px solid #e6edf7;
+  border: none;
+}
+
+.enrollment-inline-label:not(:empty)::after {
+  content: ":";
+  margin-left: 2px;
 }
 
 .enrollment-inline-label.required::before {
@@ -5373,68 +7024,100 @@ onBeforeUnmount(() => {
   min-width: auto;
 }
 
+.enrollment-date-cell :deep(.el-date-editor.el-input),
 .enrollment-date-cell :deep(.el-date-editor) {
-  min-width: 148px;
+  width: 135px !important;
+  min-width: 135px !important;
 }
 
 .enrollment-target-cell {
-  min-width: 112px;
+  min-width: auto;
+}
+
+.enrollment-target-cell :deep(.el-input-number) {
+  width: 110px !important;
+  min-width: 110px !important;
 }
 
 .enrollment-inline-value {
   font-size: 14px;
-  font-weight: 600;
-  color: #11264d;
+  font-weight: 500;
+  color: #0f172a;
 }
 
 .updated-value-wrap {
-  display: inline-block;
-  position: relative;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
   vertical-align: middle;
+  gap: 4px;
 }
 
 .field-updated-tag {
-  position: absolute;
-  left: calc(100% + 6px);
-  top: 50%;
-  transform: translateY(-50%);
+  position: static;
+  transform: none;
+  left: auto;
+  top: auto;
   margin: 0 !important;
   z-index: 1;
   pointer-events: none;
-  --el-tag-bg-color: #fff8eb;
-  --el-tag-border-color: #ecd2a3;
-  --el-tag-text-color: #9a6b0d;
+  
+  /* 极简指示风格：仅用文字高亮，去背景和边框 */
+  background: transparent !important;
+  border: none !important;
+  color: #ea580c !important; /* 精致的警惕橙 */
+  padding: 0 !important;
+  height: auto !important;
+  line-height: 1 !important;
+  font-size: 11px !important;
   font-weight: 600;
+  white-space: nowrap;
+}
+
+.enrollment-plan-toolbar .updated-value-wrap {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
 }
 
 .enrollment-sep {
-  color: #8da3c7;
-  font-weight: 600;
-  align-self: center;
+  color: #94a3b8;
+  font-weight: 500;
+  margin: 0 4px;
   display: inline-flex;
   align-items: center;
-  height: 32px;
-  line-height: 32px;
+  height: 28px;
+  line-height: 28px;
   flex-shrink: 0;
 }
 
 .enrollment-plan-summary {
-  border: 1px solid #e2ebf8;
-  border-radius: 10px;
-  background: #f8fbff;
-  padding: 8px 10px;
+  border: none;
+  border-radius: 0;
+  background: transparent;
+  padding: 12px 0;
+  border-top: 1px solid #f1f5f9;
+  border-bottom: 1px solid #f1f5f9;
+  margin-top: 8px;
   display: flex;
   flex-direction: column;
-  gap: 6px;
+  gap: 8px;
 }
 
 .enrollment-summary-line {
   display: flex;
   flex-wrap: wrap;
   align-items: center;
-  gap: 10px;
+  gap: 16px;
   font-size: 13px;
-  color: #38537b;
+  color: #64748b;
+}
+
+.enrollment-summary-line b {
+  color: #0f172a;
+  font-weight: 600;
+  font-size: 14px;
+  margin: 0 4px;
 }
 
 .summary-site-name {
@@ -5443,8 +7126,10 @@ onBeforeUnmount(() => {
 }
 
 .summary-title {
-  font-weight: 700;
-  color: #284a7b;
+  font-weight: 600;
+  color: #0f172a;
+  min-width: 90px;
+  margin-right: -4px;
 }
 
 .summary-danger {
@@ -5468,10 +7153,7 @@ onBeforeUnmount(() => {
   display: inline-flex;
   align-items: center;
   gap: 8px;
-}
-
-.enrollment-site-filter-row {
-  justify-content: flex-start;
+  margin-right: 12px;
 }
 
 .enrollment-plan-action-link {
@@ -5508,11 +7190,18 @@ onBeforeUnmount(() => {
 }
 
 .month-empty {
-  color: #b3bfd5;
+  color: #64748b;
+  font-size: 14px;
+  text-align: center;
+  padding: 40px 0;
+  background: #f8fafc;
+  border-radius: 8px;
+  border: 1px dashed #e2e8f0;
+  margin-top: 12px;
 }
 
 .site-plan-site-select {
-  width: 320px;
+  width: 200px;
   max-width: 100%;
 }
 
@@ -5538,6 +7227,30 @@ onBeforeUnmount(() => {
   gap: 8px;
 }
 
+.setup-content-step-nav :deep(.el-button.is-circle) {
+  width: 28px;
+  height: 28px;
+  padding: 0;
+  background: transparent !important;
+  border: 1px solid #e2e8f0 !important;
+  color: #64748b !important;
+  transition: all 0.2s;
+}
+
+.setup-content-step-nav :deep(.el-button.is-circle:hover) {
+  background: #f8fafc !important;
+  border-color: #cbd5e1 !important;
+  color: #3b82f6 !important;
+}
+
+.setup-content-step-nav :deep(.el-button.is-circle.is-disabled),
+.setup-content-step-nav :deep(.el-button.is-circle.is-disabled:hover) {
+  background: transparent !important;
+  border-color: #f1f5f9 !important;
+  color: #e2e8f0 !important;
+  cursor: not-allowed;
+}
+
 .setup-content-step-actions {
   margin-left: auto;
   display: flex;
@@ -5546,39 +7259,43 @@ onBeforeUnmount(() => {
 }
 
 .setup-content-step-actions :deep(.step-action-btn) {
-  min-width: 88px;
-  border-radius: 10px;
-  font-weight: 600;
+  min-width: 64px;
+  height: 28px;
+  padding: 0 12px;
+  border-radius: 6px;
+  font-weight: 500;
+  font-size: 13px;
+  transition: all 0.2s;
 }
 
 .setup-content-step-actions :deep(.step-action-btn.el-button--primary) {
-  background: #3f617d;
-  border-color: #3f617d;
-  color: #ffffff;
+  background: transparent !important;
+  border: 1px solid #3b82f6 !important;
+  color: #3b82f6 !important;
 }
 
 .setup-content-step-actions :deep(.step-action-btn.el-button--primary:hover) {
-  background: #355472;
-  border-color: #355472;
-  color: #ffffff;
+  background: #eff6ff !important;
+  border-color: #2563eb !important;
+  color: #2563eb !important;
 }
 
 .setup-content-step-actions :deep(.step-action-btn-cancel) {
-  background: #f3f6fb;
-  border-color: #d7e1ee;
-  color: #4a6283;
+  background: #f8fafc !important;
+  border: 1px solid #e2e8f0 !important;
+  color: #64748b !important;
 }
 
 .setup-content-step-actions :deep(.step-action-btn-cancel:hover) {
-  background: #e8eff8;
-  border-color: #c7d5e8;
-  color: #3b5476;
+  background: #f1f5f9 !important;
+  border-color: #cbd5e1 !important;
+  color: #334155 !important;
 }
 
 .setup-content-step-actions :deep(.step-action-btn.el-button--primary .el-button__text),
 .setup-content-step-actions :deep(.step-action-btn.el-button--primary > span),
 .setup-content-step-actions :deep(.step-action-btn.el-button--primary .el-button__inner) {
-  color: #ffffff !important;
+  color: inherit !important;
   opacity: 1 !important;
 }
 
@@ -5665,10 +7382,15 @@ onBeforeUnmount(() => {
 }
 
 .drawer-form-card {
-  padding: 10px;
-  border: 1px solid #e6edf7;
-  border-radius: 10px;
-  background: #fcfdff;
+  padding: 16px 0;
+  border: none;
+  border-bottom: 1px solid #f1f5f9;
+  background: transparent;
+  border-radius: 0;
+}
+
+.drawer-form-card:last-child {
+  border-bottom: none;
 }
 
 .drawer-form-card :deep(.el-form-item) {
@@ -5780,32 +7502,49 @@ onBeforeUnmount(() => {
 .info-grid {
   display: grid;
   grid-template-columns: repeat(2, minmax(0, 1fr));
-  gap: 10px 24px;
+  gap: 6px 24px; /* 进一步压缩行间距 */
 }
 
 .basic-info-groups {
   display: flex;
   flex-direction: column;
-  gap: 10px;
+  gap: 0;
 }
 
 .info-group {
-  padding: 16px 20px;
-  background: #ffffff;
-  border: 1px solid #eef3fb;
-  border-radius: 12px;
-  box-shadow: 0 2px 12px rgba(22, 47, 86, 0.03);
+  padding: 16px 0;
+  background: transparent;
+  border: none;
+  border-bottom: 1px solid #eaeff8;
+  border-radius: 0;
+  box-shadow: none;
+}
+
+.info-group:last-child {
+  border-bottom: none;
 }
 
 .info-group + .info-group {
-  margin-top: 14px;
+  margin-top: 0;
 }
 
 .info-group-title {
-  font-size: 14px;
+  font-size: 15px;
   font-weight: 700;
-  color: #284a7a;
+  color: #0f172a;
   margin-bottom: 12px;
+  display: flex;
+  align-items: center;
+}
+
+.info-group-title::before {
+  content: "";
+  display: inline-block;
+  width: 3px;
+  height: 14px;
+  background: #3b82f6;
+  border-radius: 4px;
+  margin-right: 8px;
 }
 
 .info-group-title-row {
@@ -5816,55 +7555,84 @@ onBeforeUnmount(() => {
 }
 
 .info-group-edit-btn {
-  min-width: 72px;
-  border-radius: 10px;
-  background: #3f617d;
-  border-color: #3f617d;
-  color: #ffffff;
-  font-size: 14px;
-  font-weight: 600;
+  min-width: 64px;
+  height: 28px;
+  padding: 0 12px;
+  border-radius: 6px;
+  background: transparent !important;
+  border: 1px solid #3b82f6 !important;
+  color: #3b82f6 !important;
+  font-size: 13px !important;
+  font-weight: 500 !important;
+  transition: all 0.2s;
 }
 
 .info-group-edit-btn:deep(span) {
-  font-size: 14px;
+  font-size: 13px;
   line-height: 1;
-  color: #ffffff !important;
+  color: #3b82f6 !important;
   opacity: 1 !important;
 }
 
 .info-group-edit-btn:hover,
 .info-group-edit-btn:focus {
-  background: #355472;
-  border-color: #355472;
-  color: #ffffff;
+  background: #eff6ff !important;
+  border-color: #2563eb !important;
+  color: #2563eb !important;
+}
+
+.info-group-edit-btn:hover:deep(span),
+.info-group-edit-btn:focus:deep(span) {
+  color: #2563eb !important;
 }
 
 .info-group-edit-btn.is-disabled,
 .info-group-edit-btn.is-disabled:hover {
-  background: #94a3b8;
-  border-color: #94a3b8;
-  color: #ffffff;
+  background: transparent !important;
+  border-color: #cbd5e1 !important;
+  color: #94a3b8 !important;
+}
+
+.info-group-edit-btn.is-disabled:deep(span),
+.info-group-edit-btn.is-disabled:hover:deep(span) {
+  color: #94a3b8 !important;
 }
 
 .basic-form-group-title {
   margin: 0 0 14px;
   font-size: 14px;
   font-weight: 700;
-  color: #284a7a;
+  color: #0f172a;
+  display: flex;
+  align-items: center;
+}
+.basic-form-group-title::before {
+  content: "";
+  display: inline-block;
+  width: 3px;
+  height: 14px;
+  background: #3b82f6;
+  border-radius: 4px;
+  margin-right: 8px;
 }
 
 .basic-edit-group {
-  padding: 18px 20px 4px;
-  background: #f8fbff;
-  border: 1px solid #e6edf7;
-  border-radius: 12px;
-  margin-bottom: 16px;
+  padding: 20px 0 4px;
+  background: transparent;
+  border: none;
+  border-bottom: 1px solid #eaeff8;
+  border-radius: 0;
+  margin-bottom: 0;
+}
+
+.basic-edit-group:last-child {
+  border-bottom: none;
 }
 
 .basic-edit-group + .basic-edit-group {
   margin-top: 0;
-  padding-top: 18px;
-  border-top: 1px solid #e6edf7;
+  padding-top: 20px;
+  border-top: none;
 }
 
 .info-item {
@@ -5872,26 +7640,25 @@ onBeforeUnmount(() => {
   align-items: flex-start;
   gap: 12px;
   min-height: 28px;
-  padding: 6px 0;
+  padding: 2px 0; /* 大幅精简项内垂直留白 */
 }
 
 .info-label {
-  color: #5f7499;
-  min-width: 112px;
-  font-size: 14px;
-  background: #f4f8ff;
-  padding: 4px 10px;
-  border-radius: 6px;
+  color: #64748b;
+  min-width: 100px;
+  font-size: 13px;
+  background: transparent;
+  padding: 2px 0;
   display: inline-flex;
   align-items: center;
 }
 
 .info-value {
-  color: #11264d;
-  font-weight: 600;
-  font-size: 15px;
+  color: #0f172a;
+  font-weight: 500;
+  font-size: 14px;
   word-break: break-word;
-  padding-top: 4px;
+  padding-top: 1px;
 }
 
 .info-value-wrap {
@@ -5913,20 +7680,42 @@ onBeforeUnmount(() => {
   background-color: #edf2f8;
 }
 
-.setup-section :deep(.el-table) {
-  border-radius: 10px;
-  overflow: hidden;
-  border: 1px solid #eef3fb;
+.setup-section :deep(.el-table),
+.setup-section :deep(.el-table__inner-wrapper) {
+  border-radius: 0;
+  overflow: visible;
+  border: none !important;
+  background: transparent !important;
+  box-shadow: none !important;
+  --el-table-border-color: #f1f5f9;
+}
+
+.setup-section :deep(.el-table::before),
+.setup-section :deep(.el-table::after),
+.setup-section :deep(.el-table__inner-wrapper::before),
+.setup-section :deep(.el-table__inner-wrapper::after) {
+  display: none !important; /* 去除原本表格底部及两侧的系统原生粗线 */
 }
 
 .setup-section :deep(.el-table th.el-table__cell) {
-  background: #f8fbff;
-  color: #35527d;
-  font-weight: 600;
+  background: #f8fafc !important;
+  color: #64748b !important;
+  font-weight: 500 !important;
+  border-bottom: 1px solid #e2e8f0 !important;
+  border-right: none !important;
+  border-left: none !important;
 }
 
 .setup-section :deep(.el-table td.el-table__cell) {
-  border-bottom-color: #edf2f8;
+  border-bottom: 1px solid #f1f5f9 !important;
+  border-right: none !important;
+  border-left: none !important;
+  background: transparent !important;
+}
+
+/* 覆盖悬停状态颜色，保持极简高级 */
+.setup-section :deep(.el-table--enable-row-hover .el-table__body tr:hover > td.el-table__cell) {
+  background-color: #f8fafc;
 }
 
 .setup-milestone-table :deep(th.el-table__cell),
@@ -5941,16 +7730,16 @@ onBeforeUnmount(() => {
 }
 
 .setup-milestone-table :deep(th.el-table__cell .cell) {
-  font-size: 12px;
-  font-weight: 700;
-  color: #000;
+  font-size: 13px;
+  font-weight: 500;
+  color: #64748b;
 }
 
 .milestone-cell-text {
   display: inline-block;
-  font-size: 12px;
-  font-weight: 400;
-  color: #000;
+  font-size: 13px;
+  font-weight: 500;
+  color: #0f172a;
   line-height: 16px;
 }
 
@@ -6230,6 +8019,11 @@ onBeforeUnmount(() => {
     width: 100%;
   }
 
+  .version-card {
+    width: 100%;
+    min-width: 0;
+  }
+
   .setup-toolbar-actions {
     width: 100%;
   }