A method and system for file version management in artificial intelligence programming sessions

By constructing a directed acyclic graph version structure in AI programming sessions and utilizing disk content verification and difference patching, the problem of expressing forks and nested forks in AI programming sessions is solved, enabling reliable version positioning and rollback, reducing storage redundancy and providing conflict detection capabilities.

CN123115075APending Publication Date: 2026-11-17FUJIAN FUJITSU COMM SOFTWARE CO LTD
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN202611429478.5
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Filing Date
2026-09-15
Publication Date
2026-11-17

AI Technical Summary

Technical Problem

Existing technologies struggle to accurately represent forks and nested forks in AI programming scenarios, relying on untrusted version pointers and lacking a reverse verification mechanism for disk content, resulting in unreliable version location and backtracking.

Method used

It adopts a Directed Acyclic Graph (DAG) version structure, constructs a version graph through file change records and rollback markers, uses disk content to reverse apply difference patches for version location and rollback, supports the expression of forks and nested forks, and performs conflict detection and security degradation when disk content is unreliable.

Benefits of technology

It achieves accurate representation of forks and nested forks in AI programming sessions, reduces storage redundancy and consistency maintenance costs, supports historical preview and version comparison, and has conflict detection and safe rollback capabilities.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN123115075A_ABST
    Figure CN123115075A_ABST
Patent Text Reader

Abstract

This invention discloses a file version management method and system in artificial intelligence programming sessions. The method uses the initial version as the root node and constructs a version DAG (Directed Acyclic Graph) that can represent linear continuation, branching, and nested branching based on file patches and rollback markers in the AI ​​session. When locating the current disk content, leaf nodes are enumerated and patches are applied in reverse to verify whether it is possible to backtrack to the root node; if successful, the initial content is cached. When reconstructing the target version, patches are applied forward from the root node along the path to generate a complete file. If all candidate paths fail to reverse successfully, it is determined that backtracking is not possible and rollback is prevented. This invention reuses existing session records, eliminates the need for persistent full snapshots, and reliably supports version display, rollback, and branch switching.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] This invention relates to the field of artificial intelligence programming management technology, and in particular to a file version management method and system in an artificial intelligence programming session. Background Technology

[0002] Existing technologies for version management and difference handling primarily focus on aspects such as program development version control, document collaboration and snapshot management, difference patch generation and synchronization, and data lineage graphs. For example, in program development scenarios, interactive commands are used to map version control commands to improve operational efficiency; in document collaboration and snapshot management scenarios, chapter-level splitting or metadata snapshots enable version rollback and data recovery; in patch handling, minimum-granularity incremental patches are generated based on requirement changes or configuration differences, achieving efficient synchronization; and in lineage management, directed acyclic graphs are used to record data sources and flows. These technologies have all addressed some version or difference management issues in their respective application scenarios.

[0003] However, these solutions have significant shortcomings in AI programming session scenarios: First, the version structure often uses linear chains or simple branches, which are difficult to represent the forks and nested forks generated after continuous AI editing and arbitrary rollbacks; Second, the determination of the current file version usually relies on a status pointer or version number identifier, but the actual disk content may be inconsistent with the identifier, resulting in unreliable backtracking; Third, it is necessary to persist a complete version graph or full snapshot, which duplicates the existing change log of the AI ​​session and is prone to consistency issues; Fourth, differential patching technology is mainly used for patch generation, transmission or synchronization, and lacks a verification mechanism to reverse-determine the version path based on the current disk content, making it impossible to reliably determine whether a file is traceable when the version panel is opened or a rollback is performed. Summary of the Invention

[0004] The purpose of this invention is to address the problems in existing file version management methods in AI programming scenarios, such as difficulty in expressing forks and nested forks, reliance on untrusted version pointers, and lack of reverse verification mechanisms based on disk content, which lead to unreliable version location and backtracking. This invention provides a file version management method and system for artificial intelligence programming sessions.

[0005] The technical solution adopted in this invention is:

[0006] A file version management method in an artificial intelligence programming session includes:

[0007] Obtain the initial version of the target file, as well as the file change record and rollback marker of the target file in the artificial intelligence programming session. The file change record includes at least the difference patch between the version before and after each file change.

[0008] Based on the file change records and rollback markers, a directed acyclic graph (DAG) version structure is constructed with the initial version of the target file as the root node. Each node in the DAG version structure corresponds to a file version, each directed edge corresponds to a difference patch, and the directed edges point from the parent node to the child node.

[0009] Based on the version positioning request, read the current disk content of the target file, enumerate at least one leaf node of the directed acyclic graph version structure as a candidate node, and apply the difference patch in reverse along the directed edge path from the candidate node to the root node; when the candidate node successfully applies the patch to the root node, locate the current node as the corresponding candidate node, and cache the initial version content.

[0010] Based on the version rollback request, determine the target rollback node, obtain the cached initial version, apply the difference patch forward from the root node along the path pointing to the target rollback node in the directed acyclic graph version structure to reconstruct the file content of the target rollback node, write the reconstructed file content to disk, mark the target rollback node with a rollback mark and update the time information.

[0011] Furthermore, in some implementations, the file change log includes at least the file path, change time, tool type, difference patch, session round, user messages, and row addition / deletion statistics; the rollback marker includes at least the rollback target node and rollback time.

[0012] Furthermore, in some implementations, constructing a directed acyclic graph version structure with the initial version of the target file as the root node includes:

[0013] Iterate through the file change history and rollback markers in chronological order;

[0014] If the patch is the first patch since the most recent rollback marker, then attach the corresponding patch node to the target node of the most recent rollback marker; otherwise, attach the corresponding patch node to the previous patch node.

[0015] Subsequent patches following a rollback marker are linearly attached until a new rollback marker appears, thus forming a directed acyclic graph version structure that expresses linear continuation, forks, and nested forks.

[0016] Furthermore, in some implementations, when constructing a directed acyclic graph version structure, multiple difference patches generated for the same file within the same session round are merged into an equivalent patch to form a single version node, while retaining the original change index.

[0017] Furthermore, in some implementations, when all candidate nodes fail to be reverse-applied to the root node, the rollback target node corresponding to the most recent rollback mark is obtained, and the difference patch is reverse-applied from the rollback target node along the directed edge to the root node.

[0018] If the rollback of the target node to the root node also fails, it is determined that the current disk content of the target file does not have reliable rollback capability, and the version rollback operation is prohibited and the risk of external modification is warned.

[0019] Furthermore, in some implementations, before enumerating leaf nodes, if there is a recent rollback flag, the verification is performed in reverse from the most recent rollback target node; if the verification is successful, the current node is determined directly; otherwise, all leaf nodes are enumerated.

[0020] Furthermore, some implementations also include: caching the reconstructed file content of frequently accessed version nodes and using a least recently used strategy for cache eviction.

[0021] Furthermore, in some implementations, when writing the content of the target node to disk, a rollback marker targeting the target node is recorded, and the time information is updated.

[0022] Furthermore, some implementations also include multi-file collaborative version management: establishing version associations between files based on session rounds, and supporting project-level version rollback.

[0023] Furthermore, in some implementations, a visual interface is provided for the acyclic graph version structure, supporting node dragging, path highlighting, and difference preview interaction.

[0024] This invention also discloses a file version management system in an artificial intelligence programming session, comprising:

[0025] The initial information acquisition module is used to acquire the initial version of the target file, as well as the file change record and rollback mark of the target file in the artificial intelligence programming session. The file change record includes at least the difference patch between the version before and after each file change.

[0026] The version graph construction module is used to construct a directed acyclic graph version structure with the initial version of the target file as the root node based on the file change record and rollback marker. Each node in the directed acyclic graph version structure corresponds to a file version, each directed edge corresponds to a difference patch, and the directed edge points from the parent node to the child node.

[0027] The version positioning module is used to read the current disk content of the target file according to the version positioning request, enumerate at least one leaf node of the directed acyclic graph version structure as a candidate node, and apply the difference patch in reverse along the directed edge path from the candidate node to the root node; when the candidate node is successfully reverse-applied to the root node, the current node is positioned as the corresponding candidate node.

[0028] The version reconstruction module is used to determine the target rollback node based on the version rollback request, obtain the cached initial version, apply difference patches forward from the root node along the path pointing to the target rollback node in the directed acyclic graph version structure to reconstruct the file content of the target rollback node, write the reconstructed file content to disk, mark the target rollback node with a rollback mark and update the time information.

[0029] Furthermore, some implementations also include a security determination module, which is used to obtain the rollback target node corresponding to the most recent rollback mark when all candidate nodes fail to be reverse-applied to the root node, and apply the difference patch to the root node from the rollback target node along the directed edge; when the rollback target node also fails to be reverse-applied to the root node, it is determined that the current disk content of the target file does not have reliable backtracking capability, the version rollback operation is prohibited and the risk of external modification is prompted.

[0030] The present invention adopts the above technical solution and has the following beneficial effects compared with the prior art:

[0031] (1) This invention uses a DAG to represent the version structure. New changes generated after rollback are attached to the rollback target node, naturally forming a fork. When rollback and modification are performed again under the fork node, nested forks can continue to form. This invention can accurately represent forks and nested forks in AI programming sessions.

[0032] (2) The present invention uses the current disk content as the positioning basis and verifies whether the candidate path can be traced back to V0 by applying the patch in reverse. Even if the state pointer is wrong or missing, as long as the file content is consistent with a certain DAG path, the current node can still be correctly located.

[0033] (3) The present invention dynamically reconstructs the version graph based on existing session records. It does not require the persistence of a complete DAG or a complete snapshot. Instead, it uses AI programming sessions to dynamically generate version graphs based on existing file change records and rollback markers, thereby reducing storage redundancy and consistency maintenance costs.

[0034] (4) After obtaining the V0 content, the present invention can apply the patch in the forward direction along any target node path to obtain the complete file content of the node, thereby supporting historical preview, version comparison, rollback to disk and branch switching.

[0035] (5) This invention has conflict detection and security degradation capabilities. When the current disk content cannot be successfully reversed along any candidate path, the system does not force a rollback, but determines that the current file does not have reliable backtracking capabilities, thus avoiding erroneous overwriting of user files.

[0036] (6) The version node of this invention can correspond to multiple tool calls in a round of conversation and retain the original change index, taking into account both the semantics of AI dialogue rounds and the replayability of specific file patches. Attached Figure Description

[0037] The present invention will be further described in detail below with reference to the accompanying drawings and specific embodiments;

[0038] Figure 1 This is a flowchart illustrating a file version management method in an artificial intelligence programming session according to the present invention. Detailed Implementation

[0039] To make the objectives, technical solutions, and advantages of the embodiments of this application clearer, the technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings.

[0040] like Figure 1 As shown, this invention discloses a file version management method in an artificial intelligence programming session, comprising:

[0041] Step 1: Obtain the initial version of the target file and the file change record and rollback mark of the target file in the artificial intelligence programming session. The file change record shall at least include the difference patch between the version before the change and the version after the change for each file change.

[0042] Furthermore, the file change log should include at least the file path, change time, tool type, difference patch, session round, user messages, and row addition / deletion statistics; the rollback marker should include at least the rollback target node and rollback time.

[0043] Step 2: Based on the file change records and rollback markers, construct a directed acyclic graph (DAG) version structure with the initial version of the target file as the root node; each node in the DAG version structure corresponds to a file version, each directed edge corresponds to a difference patch, and the directed edges point from the parent node to the child node.

[0044] Furthermore, in some implementations, constructing a directed acyclic graph version structure with the initial version of the target file as the root node includes:

[0045] Iterate through the file change history and rollback markers in chronological order;

[0046] If the patch is the first patch since the most recent rollback marker, then attach the corresponding patch node to the target node of the most recent rollback marker; otherwise, attach the corresponding patch node to the previous patch node.

[0047] Subsequent patches following a rollback marker are linearly attached until a new rollback marker appears, thus forming a directed acyclic graph version structure that expresses linear continuation, forks, and nested forks.

[0048] Furthermore, in some implementations, when constructing a directed acyclic graph version structure, multiple difference patches generated for the same file within the same session round are merged into an equivalent patch to form a single version node, while retaining the original change index.

[0049] Furthermore, in some implementations, a visual interface is provided for the acyclic graph version structure, supporting node dragging, path highlighting, and difference preview interaction.

[0050] Step 3: Read the current disk content of the target file according to the version positioning request, enumerate at least one leaf node of the directed acyclic graph version structure as a candidate node, and apply the difference patch in reverse along the directed edge path from the candidate node to the root node; when the candidate node is successfully reverse-applied to the root node, the current node is positioned as the corresponding candidate node, and the initial version content is cached at the same time.

[0051] Furthermore, in some implementations, before enumerating leaf nodes, if there is a recent rollback flag, the verification is performed in reverse from the most recent rollback target node; if the verification is successful, the current node is determined directly; otherwise, all leaf nodes are enumerated.

[0052] Furthermore, in some implementations, when all candidate nodes fail to be reverse-applied to the root node, the rollback target node corresponding to the most recent rollback mark is obtained, and the difference patch is reverse-applied from the rollback target node along the directed edge to the root node.

[0053] If the rollback of the target node to the root node also fails, it is determined that the current disk content of the target file does not have reliable rollback capability, and the version rollback operation is prohibited and the risk of external modification is warned.

[0054] Step 4: Determine the target rollback node based on the version rollback request, obtain the cached initial version, apply the difference patch forward from the root node along the path pointing to the target rollback node in the directed acyclic graph version structure to reconstruct the file content of the target rollback node, and write the reconstructed file content to disk.

[0055] Furthermore, in some implementations, when writing the content of the target node to disk, a rollback marker targeting the target node is recorded, and the time information is updated.

[0056] Furthermore, some implementations also include: caching the reconstructed file content of frequently accessed version nodes and using a least recently used strategy for cache eviction.

[0057] Furthermore, some implementations also include multi-file collaborative version management: establishing version associations between files based on session rounds, and supporting project-level version rollback.

[0058] This invention also discloses a file version management system in an artificial intelligence programming session, comprising:

[0059] The initial information acquisition module is used to acquire the initial version of the target file, as well as the file change record and rollback mark of the target file in the artificial intelligence programming session. The file change record includes at least the difference patch between the version before and after each file change.

[0060] The version graph construction module is used to construct a directed acyclic graph version structure with the initial version of the target file as the root node based on the file change record and rollback marker. Each node in the directed acyclic graph version structure corresponds to a file version, each directed edge corresponds to a difference patch, and the directed edge points from the parent node to the child node.

[0061] The version positioning module is used to read the current disk content of the target file according to the version positioning request, enumerate at least one leaf node of the directed acyclic graph version structure as a candidate node, and apply the difference patch in reverse along the directed edge path from the candidate node to the root node; when the candidate node is successfully reverse-applied to the root node, the current node is positioned as the corresponding candidate node.

[0062] The version reconstruction module is used to determine the target rollback node based on the version rollback request, obtain the cached initial version, apply the difference patch forward from the root node along the path pointing to the target rollback node in the directed acyclic graph version structure, reconstruct the file content of the target rollback node, and write the reconstructed file content to the disk.

[0063] Furthermore, some implementations also include a security determination module, which is used to obtain the rollback target node corresponding to the most recent rollback mark when all candidate nodes fail to be reverse-applied to the root node, and apply the difference patch to the root node from the rollback target node along the directed edge; when the rollback target node also fails to be reverse-applied to the root node, it is determined that the current disk content of the target file does not have reliable backtracking capability, the version rollback operation is prohibited and the risk of external modification is prompted.

[0064] The working principle of the present invention will be explained below with reference to specific embodiments:

[0065] Example 1: Basic Linear Version Backtracking. In an AI programming session, the initial content of the target file is V0. In the first round, the AI ​​tool generates patch d1, forming node V1; in the second round, the AI ​​tool generates patch d2, forming node V2. At this point, the DAG is: V0→V1→V2.

[0066] When a user opens the version panel, the system reads the current disk content x_disk, enumerates the leaf node V2, applies d2 in reverse from V2, and then applies d1 in reverse from V1 to obtain the content of V0. If both steps are successful, the current node is located as V2, and the content of V0 is cached. If the user chooses to roll back to V1, the system applies d1 in forward from V0 to generate the content of V1 and writes it to the disk, while simultaneously recording a rollback marker indicating that the target is V1.

[0067] Example 2: Fork Formation After Rollback. Based on V0→V1→V2, the user rolls back to V1. The system writes the content of V1 and records the rollback marker. Subsequently, the user requests the AI ​​to modify the file, and the AI ​​tool generates a new patch d3. When the system rebuilds the DAG, it finds that the version node corresponding to d3 occurs after the rollback marker, so it attaches this new node to V1, forming V2.1. At this point, the DAG is represented as: V0→V1→V2, and simultaneously V1→V2.1.

[0068] When the disk content is V2.1, the system reverse-applies d3 from the leaf node V2.1, then reverse-applies d1, successfully obtaining the content of V0, thus locating the current node as V2.1. The user can still choose to view or roll back to V2, because the system can reconstruct the content of V2 from V0 along the path V1→V2 in the forward direction.

[0069] Example 3: Nested Forking. Given the existence of V0→V1→V2 and V1→V2.1, the user rolls back from V2.1 to V2, and then continues to have the AI ​​modify the same file, generating patch d4. The system records the rollback marker to V2. When rebuilding the DAG, the new node corresponding to d4 is attached to V2, resulting in a new forked node, such as V2.1.1, or an equivalent label generated according to preset labeling rules.

[0070] This embodiment illustrates that the present invention does not require prior differentiation between the main branch and branches, but rather expresses branching at any level through parent-child relationships and temporal order. The content of any node can be reconstructed from V0 along the corresponding path in a forward direction.

[0071] Example 4: Current disk content cannot be rolled back. If a user manually modifies the target file outside the system, making the current disk content inconsistent with any existing version path, a conflict will occur when the system enumerates leaf nodes and reverse-engineers the patch. If all leaf paths and the most recent rollback target cannot be successfully reversed to V0, the system determines that the current file does not have reliable rollback capability and prompts the user that the current content may have been modified externally. In this case, the system can prohibit direct rollback or require user confirmation to avoid erroneously overwriting the current file.

[0072] The present invention adopts the above technical solution and has the following beneficial effects compared with the prior art:

[0073] (1) This invention uses a DAG to represent the version structure. New changes generated after rollback are attached to the rollback target node, naturally forming a fork. When rollback and modification are performed again under the fork node, nested forks can continue to form. This invention can accurately represent forks and nested forks in AI programming sessions.

[0074] (2) The present invention uses the current disk content as the positioning basis and verifies whether the candidate path can be traced back to V0 by applying the patch in reverse. Even if the state pointer is wrong or missing, as long as the file content is consistent with a certain DAG path, the current node can still be correctly located.

[0075] (3) The present invention dynamically reconstructs the version graph based on existing session records. It does not require the persistence of a complete DAG or a complete snapshot. Instead, it uses AI programming sessions to dynamically generate version graphs based on existing file change records and rollback markers, thereby reducing storage redundancy and consistency maintenance costs.

[0076] (4) After obtaining the V0 content, the present invention can apply the patch in the forward direction along any target node path to obtain the complete file content of the node, thereby supporting historical preview, version comparison, rollback to disk and branch switching.

[0077] (5) This invention has conflict detection and security degradation capabilities. When the current disk content cannot be successfully reversed along any candidate path, the system does not force a rollback, but determines that the current file does not have reliable backtracking capabilities, thus avoiding erroneous overwriting of user files.

[0078] (6) The version node of this invention can correspond to multiple tool calls in a round of conversation and retain the original change index, taking into account both the semantics of AI dialogue rounds and the replayability of specific file patches.

[0079] Obviously, the described embodiments are only a part of the embodiments of this application, not all of them. Without conflict, the embodiments and features in the embodiments of this application can be combined with each other. The components of the embodiments of this application described and illustrated herein can generally be arranged and designed in various different configurations. Therefore, the detailed description of the embodiments of this application is not intended to limit the scope of the claimed application, but merely to illustrate selected embodiments of this application. All other embodiments obtained by those skilled in the art based on the embodiments of this application without inventive effort are within the scope of protection of this application.

Claims

1. A method for file version management in an artificial intelligence programming session, the method comprising: include: Obtain the initial version of the target file, as well as the file change record and rollback marker of the target file in the artificial intelligence programming session. The file change record includes at least the difference patch between the version before and after each file change. Based on the file change records and rollback markers, a directed acyclic graph version structure is constructed with the initial version of the target file as the root node. Each node in the directed acyclic graph version structure corresponds to a file version, each directed edge corresponds to a difference patch, and the directed edges point from the parent node to the child node. Based on the version positioning request, read the current disk content of the target file, enumerate at least one leaf node of the directed acyclic graph version structure as a candidate node, and apply the difference patch in reverse along the directed edge path from the candidate node to the root node; when the candidate node successfully applies the patch to the root node, locate the current node as the corresponding candidate node, and cache the initial version content. Based on the version rollback request, determine the target rollback node, obtain the cached initial version, apply the difference patch forward from the root node along the path pointing to the target rollback node in the directed acyclic graph version structure to reconstruct the file content of the target rollback node, write the reconstructed file content to disk, mark the target rollback node with a rollback mark and update the time information.

2. The method of claim 1, wherein, File change logs also include file path, change time, tool type, session round, user messages, and statistics on added and deleted lines; rollback markers include at least the rollback target node and rollback time.

3. The method of claim 1, wherein, The implementation of constructing a directed acyclic graph version structure rooted at the initial version of the target file includes: Iterate through the file change history and rollback markers in chronological order; If the patch is the first patch since the most recent rollback marker, then attach the corresponding patch node to the target node of the most recent rollback marker; otherwise, attach the corresponding patch node to the previous patch node. Subsequent patches following a rollback marker are linearly attached until a new rollback marker appears, thus forming a directed acyclic graph version structure that expresses linear continuation, forks, and nested forks.

4. The method of claim 3, wherein, When constructing a directed acyclic graph version structure, multiple difference patches generated for the same file within the same session round are merged into an equivalent patch to form a single version node, while retaining the original change index.

5. The method of claim 1, wherein, If all candidate nodes fail to be reverse-applied to the root node, then obtain the rollback target node corresponding to the most recent rollback mark, and apply the difference patch to the root node in reverse along the directed edge from the rollback target node. If the rollback of the target node to the root node also fails, it is determined that the current disk content of the target file does not have reliable rollback capability, and the version rollback operation is prohibited and the risk of external modification is warned.

6. The method of claim 1, wherein, Before enumerating leaf nodes, if a recent rollback marker exists, reverse verification is performed starting from the most recent rollback target node; if the verification is successful, the current node is determined directly; otherwise, all leaf nodes are enumerated.

7. The method of claim 1, wherein, Also includes: Cache the reconstructed file content of frequently accessed version nodes and use a least recently used strategy to evict the cache.

8. The method of claim 1, wherein, It also includes multi-file collaborative version management: establishing version associations between files based on session rounds, and supporting project-level version rollback.

9. A file version management system in an artificial intelligence programming session, applying the file version management method in an artificial intelligence programming session of any one of claims 1 to 8, characterized in that, The system includes: The initial information acquisition module is used to acquire the initial version of the target file, as well as the file change record and rollback mark of the target file in the artificial intelligence programming session. The file change record includes at least the difference patch between the version before and after each file change. The version graph construction module is used to construct a directed acyclic graph version structure with the initial version of the target file as the root node based on the file change record and rollback marker. Each node in the directed acyclic graph version structure corresponds to a file version, each directed edge corresponds to a difference patch, and the directed edge points from the parent node to the child node. The version positioning module is used to read the current disk content of the target file according to the version positioning request, enumerate at least one leaf node of the directed acyclic graph version structure as a candidate node, and apply the difference patch in reverse along the directed edge path from the candidate node to the root node; when the candidate node is successfully reverse-applied to the root node, the current node is positioned as the corresponding candidate node. The version reconstruction module is used to determine the target rollback node based on the version rollback request, obtain the cached initial version, apply difference patches forward from the root node along the path pointing to the target rollback node in the directed acyclic graph version structure to reconstruct the file content of the target rollback node, write the reconstructed file content to disk, mark the target rollback node with a rollback mark and update the time information.

10. The file version management system in an artificial intelligence programming session of claim 9, wherein, It also includes a security determination module, which is used to obtain the rollback target node corresponding to the most recent rollback mark when all candidate nodes fail to be reversed to the root node, and to reverse apply the difference patch from the rollback target node to the root node along the directed edge. If the rollback of the target node to the root node also fails, it is determined that the current disk content of the target file does not have reliable rollback capability, and the version rollback operation is prohibited and the risk of external modification is warned.