Artificial Intelligence-Based Work Incident Management Methods, Devices, Equipment, and Media
By parsing the skill rules in the R&D phase to generate runtime constraint objects, and configuring artificial intelligence tools and automated programs without direct data source permissions, the problem of unauthorized reading and writing in enterprise R&D collaboration scenarios is solved, and security verification and access control before request execution are achieved.
Patent Information
- Application Number
- CN202611627653.1
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2026-10-21
- Publication Date
- 2026-11-17
AI Technical Summary
In enterprise R&D collaboration scenarios, artificial intelligence tools cannot effectively prevent unauthorized reading, unauthorized tool calls, and unauthorized writing before the request is executed, leading to information security issues.
By acquiring information about the target R&D object, parsing the skill rules of the R&D stage to generate runtime constraint objects, configuring artificial intelligence tools and automated programs to have no direct data source permissions, and verifying the rule hashes and field patterns carried by the processing requests, we can ensure that the requests comply with permissions and context consistency before execution.
It effectively prevents unauthorized reads, unauthorized tool calls, and unauthorized writes, ensuring that requests comply with permissions and context consistency before execution, thus reducing information security risks.
Smart Images

Figure CN123116364A_ABST
Abstract
Description
Technical Field
[0001] This application relates to the field of computer technology, and more specifically, to a method, apparatus, device, and medium for managing work events based on artificial intelligence. Background Technology
[0002] In enterprise R&D collaboration scenarios, requirement clarification, task breakdown, code submission, merge request descriptions, test reports, and acceptance materials need to be advanced, supplemented, or corrected based on the context. Artificial intelligence tools can assist in understanding the context and generating processing suggestions. Automated programs triggered by R&D process nodes will also automatically initiate queries, evidence recording, and status checks. Both use standardized tool interfaces to call business services such as code repository services, test report services, and document services, and write the processing results to the project management system that stores the R&D objects.
[0003] However, operational guidelines for each stage of R&D are typically provided in the form of natural language documents or prompts. AI tools and automated programs can only determine which evidence to read, which tools to invoke, and which fields to write based on semantic understanding. The system cannot perform machine comparison with the same guidelines before execution. Furthermore, the permitted scope for the same R&D object varies across different stages and under different user roles. The content actually proposed by AI tools can easily exceed the boundaries of that stage and role, resulting in the read context containing information the user is not authorized to read, invoking tools unrelated to the current R&D stage, and writing fields not permitted for that stage. Simultaneously, AI tools and automated programs often possess access credentials to the project management system, enabling them to directly read and write the actual data of the R&D object. Operational guidelines exist only as prompts, not as mandatory conditions before invocation. Unauthorized reading and writing can only be discovered in the operation log after tool execution, by which time unauthorized information has already been read and unauthorized fields have already been written.
[0004] Therefore, how to prevent unauthorized reads, unauthorized tool calls, and unauthorized writes before processing request execution is a technical problem that needs to be solved by those skilled in the art. Summary of the Invention
[0005] The purpose of this application is to provide a work event management method, apparatus, device, and medium based on artificial intelligence, which prevents unauthorized reading, unauthorized tool calls, and unauthorized writing before processing request execution.
[0006] To achieve the above objectives, this application provides an artificial intelligence-based work event governance method, including: Obtain object information of the target R&D object, wherein the object information includes object identifier, object type, current R&D stage and caller role; Based on the object information, read the R&D stage skill rules that match the target R&D object, and parse the fields with a predetermined field pattern in the R&D stage skill rules into runtime constraint objects; Generate the rule hash of the runtime constraint object, and generate an artificial intelligence input context based on the runtime constraint object; The artificial intelligence tools and automated programs triggered by R&D process nodes are configured not to have direct read / write permissions to the target data source; wherein, the target data source is used to store the object data of the target R&D object; Receive a processing request sent by the artificial intelligence tool or the automation program; wherein the processing request carries the rule hash, the object identifier, and the expected read / write field; The processing request is validated based on the runtime constraint object and the artificial intelligence input context. If the validation fails, the processing request is rejected. If the validation passes, the processing request is forwarded to the corresponding business service via a proxy.
[0007] Optionally, after obtaining the object information of the target R&D object, the method further includes: Read the current object state of the target R&D object and the set of evidence required to advance the current R&D stage; The existing evidence for the target R&D object is compared with the set of evidence required for the state advancement, and the missing evidence items are regarded as evidence gaps.
[0008] Optionally, the predefined field pattern includes stage coding, object type, and role whitelist; Accordingly, the step of reading the R&D stage skill rules matching the target R&D object based on the object information includes: When there are multiple R&D stage skill rules that match the target R&D object, the multiple R&D stage skill rules are sorted according to a preset priority order, and the R&D stage skill rule with the highest ranking is selected. The preset priority order is as follows: complete matching of applicable stage, complete matching of object type, number of hits of evidence gap from most to least, matching degree of the caller role with the role whitelist from high to low, and skill version number from high to low.
[0009] Optionally, parsing the fields with a predetermined field pattern in the R&D stage skill rules into runtime constraint objects includes: Read the rule records corresponding to the skill rules in the R&D phase; Verify whether the rule record contains any pre-defined required fields, whether the field types match the pre-defined types, whether the tool names allowed by the rule record exist in the tool registry, and whether the fields allowed to be written back by the rule record exist in the field definitions of the target R&D object; If both are true, then the rule hash is generated based on the skill version number and normalized field content of the rule record, and the rule record is written to the runtime constraint cache.
[0010] Optionally, reading the rule record corresponding to the R&D stage skill rule includes: When the skill rules in the R&D phase originate from skill documents, the skill documents are extracted into rule records with the predetermined field patterns according to a preset field mapping table.
[0011] Optionally, the predetermined field pattern includes an evidence allowed list and a prohibited field list; Accordingly, generating the artificial intelligence input context based on the runtime constraint object includes: Based on the object identifier and the evidence allowed list, candidate evidence is read from the R&D evidence library, and evidence fields prohibited by the prohibited field list in the candidate evidence are deleted; The candidate evidence after deletion is sorted according to a preset sorting criterion to obtain a candidate evidence sequence; wherein, the preset sorting criterion includes any one or a combination of any of the following: the number of hits of evidence gaps from most to least, the distance of object relationships from closest to furthest, the priority of evidence types from highest to lowest, the evidence update time from closest to furthest, and the evidence hashes in lexicographical order from smallest to largest. Within a preset lexical budget, select evidence fragments from the candidate evidence sequence and add a source identifier and evidence hash to each evidence fragment; Generate the artificial intelligence input context; wherein the artificial intelligence input context includes any one or a combination of any of the following: the processing objective of the target research object, the current object state, the evidence gap, available tools, and output structure requirements.
[0012] Optionally, the predetermined field pattern includes any one or a combination of any of the following: tool permission list, tool parameter pattern, state machine preconditions, and write-back permission list; Accordingly, the step of validating the processing request based on the runtime constraint object and the artificial intelligence input context includes: Verify whether the rule hash carried in the processing request is equal to the rule hash of the runtime constraint object. And / or, verify whether the tool name for processing the request belongs to the tools allowed in the tool allow list; And / or, verify whether the tool parameters for processing the request satisfy the tool parameter pattern. And / or, verify whether the object identifier falls within the permission scope of the caller role. And / or, verify whether the expected read / write fields of the processing request belong to the fields allowed by the write-back allow list. And / or, verify whether the scope of evidence for the processing request exceeds the scope of evidence contained in the artificial intelligence input context. And / or, verify whether the processing request meets the current state machine prerequisites of the target R&D object.
[0013] Optionally, after forwarding the processing request to the corresponding business service via a proxy, the method further includes: The execution of the processing request is reviewed based on the review items; wherein, the review items include any one or more of the rule hash, state machine preconditions, object association records, and object version number of the target R&D object; The state machine preconditions adopt a restricted syntax, which includes only judgment operations and logical operations on whitelist fields. The judgment operations include any one or a combination of any of the following: equality judgment, inequality judgment, inclusion judgment, and existence judgment. The logical operations include any one or a combination of any of the following: logical AND, logical OR, and logical NOT.
[0014] Optionally, the method further includes: Receive a research and development object correction request sent by the artificial intelligence tool or the automated program; wherein, the research and development object correction request carries a base version number and a research and development object correction draft, and the base version number is the object version number of the target research and development object when the research and development object correction draft is generated; Save the revised draft of the research and development object as a record to be confirmed; Once the revised draft of the research and development object passes the consistency check and receives electronic confirmation status, confirmer identifier, and confirmation time, the revision result of the revised draft of the research and development object is written back to the object data of the target research and development object in the target data source according to the object version number of the target research and development object.
[0015] Optionally, the step of writing the revision result of the revised draft of the R&D object back to the object data of the target R&D object in the target data source according to the object version number of the target R&D object includes: Read the current object data and current object version number of the target R&D object; If the baseline version number is consistent with the current object version number, the correction result is written back to the object data of the target R&D object in the target data source, and the current object version number is incremented. If the base version number is inconsistent with the current object version number, a field-level difference record is generated between the correction result and the current object data so that anomaly handling can be performed based on the field-level difference record.
[0016] Optionally, after writing the revision result of the revised draft of the R&D object back to the object data of the target R&D object in the target data source based on the object version number of the target R&D object, the method further includes: The hash content is processed according to a normalized serialization method; wherein, the normalized serialization includes any one or a combination of any of the following: field names are sorted in ascending order, arrays are sorted by object identifier, time values are converted to a preset time format and time zones are unified, and null values are represented by a fixed marker. Fields for hash calculation are selected from the content to be hashed based on the set of fields determined by the runtime constraint object; Replace the sensitive fields in the selected fields with the field name, desensitization tag, and desensitized summary of the sensitive fields; Audit records are generated and stored based on the normalized serialized and selected fields and a preset digest algorithm; wherein, the audit record includes any one or a combination of any of the following: the rule hash, the preceding audit record hash, the context hash of the artificial intelligence input context, the request hash of the processing request, the result hash of the execution result corresponding to the processing request, the draft hash of the revised draft of the R&D object, and the write-back result hash.
[0017] Optionally, after generating and storing audit records based on the normalized serialized and selected fields and a preset digest algorithm, the method further includes: Reread the review object; wherein, the review object includes any one or a combination of any of the following: skill version, rule hash, artificial intelligence input context, tool call record, data source verification result, R&D object revision draft, write-back result, and write-back object version; Based on the same normalized serialization method and the same preset digest algorithm used when generating the audit record, the corresponding hash of the reread audit object is recalculated; By comparing the recalculated hash with the hash in the audit record, an abnormal alarm is generated if there are any anomalies. The anomalies include any one or a combination of any hash inconsistency, hash breakage in the previous audit record, and inconsistency between the write-back object version and the audit record.
[0018] To achieve the above objectives, this application provides an artificial intelligence-based work event management device, comprising: The acquisition module is used to acquire object information of the target R&D object, wherein the object information includes object identifier, object type, current R&D stage and caller role; The parsing module is used to read the R&D stage skill rules that match the target R&D object based on the object information, and parse the fields with a predetermined field pattern in the R&D stage skill rules into runtime constraint objects; The generation module is used to generate the rule hash of the runtime constraint object and generate an artificial intelligence input context based on the runtime constraint object; A configuration module is used to configure artificial intelligence tools and automated programs triggered according to R&D process nodes to not have direct read and write permissions to the target data source, wherein the target data source is used to store the object data of the target R&D object; The first receiving module is configured to receive a processing request sent by the artificial intelligence tool or the automation program, wherein the processing request carries the rule hash, the object identifier, and the expected read / write field; The verification module is used to verify the processing request based on the runtime constraint object and the artificial intelligence input context. If the verification fails, the processing request is rejected. If the verification passes, the processing request is forwarded to the business service pointed to by the processing request through a proxy.
[0019] To achieve the above objectives, this application provides an electronic device, comprising: Memory, used to store computer programs; A processor is used to implement the steps of the above-described AI-based job event management method when executing the computer program.
[0020] To achieve the above objectives, this application provides a computer-readable storage medium storing a computer program that, when executed by a processor, implements the steps of the above-described artificial intelligence-based work event management method.
[0021] In this application, since the skill rules in the R&D phase are obtained by matching the object type of the target R&D object, the current R&D phase, and the caller role, the fields with predetermined field patterns are parsed into runtime constraint objects. The processing scope allowed by the current phase and the current caller role then becomes data that the program can directly read and compare, rather than a natural language description that the requester needs to understand semantically. Therefore, the same R&D object will not have different execution boundaries due to differences in understanding at different phases and with different callers. Because processing requests must carry the rule hash of the runtime constraint object, and the verification compares this rule hash with the rule hash of the current runtime constraint object, whether the request belongs to the current processing and whether the current constraint applies can be directly determined. Requests generated according to other rules or invalid rules cannot pass the comparison. Because processing requests carry object identifiers and expected read / write fields, and the pre-execution verification is based on both the runtime constraint object and artificial intelligence... The system allows for input context verification. Whether the requested object and the fields to be read / written exceed the allowed scope of the current processing, and whether the content of the request is consistent with the generated AI input context, can all be identified before the tool is invoked. Requests that fail verification are rejected. Therefore, the AI tool will not read information that the caller is not authorized to access, nor will it invoke tools unrelated to the current development stage or write to fields not permitted at this stage. Since the AI tool and automated programs triggered by development process nodes are configured not to have direct read / write permissions to the target data source, their read and write operations can only be initiated as processing requests. After verification, these requests are forwarded to the business service indicated by the processing request via a proxy. Even if the requester generates out-of-bounds content, there is no way to bypass verification and directly modify the object data in the target data source. Unauthorized reads and writes no longer need to wait until after tool execution to be detected in the operation log. Therefore, this application prevents unauthorized reads, unauthorized tool calls, and unauthorized writes before request execution, reducing unauthorized data retrieval and writes when AI tools and automated programs participate in request processing. This application also discloses an artificial intelligence-based work event management device, an electronic device, and a computer-readable storage medium, which can achieve the same technical effects as described above.
[0022] It should be understood that the above general description and the following detailed description are merely exemplary and do not limit this application. Attached Figure Description
[0023] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort. The drawings are used to provide a further understanding of this disclosure and constitute a part of the specification. They are used together with the following detailed description to explain this disclosure, but do not constitute a limitation of this disclosure. In the drawings: Figure 1 This is a flowchart illustrating an artificial intelligence-based work event management method according to an exemplary embodiment; Figure 2 A flowchart illustrating another AI-based job event governance method according to an exemplary embodiment; Figure 3 This is a structural diagram illustrating an artificial intelligence-based work event management device according to an exemplary embodiment; Figure 4 This is a structural diagram of an electronic device according to an exemplary embodiment. Detailed Implementation
[0024] The technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, and not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those of ordinary skill in the art without creative effort are within the protection scope of this application.
[0025] It should be noted that, in the description of this application, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. The terms "first," "second," etc., in this application are used to distinguish similar objects and are not used to describe a specific order or sequence.
[0026] To enable those skilled in the art to better understand the present application, the present application will be further described in detail below with reference to the accompanying drawings and specific embodiments.
[0027] This application discloses an artificial intelligence-based method for managing work events. (See also...) Figure 1 A flowchart illustrating an artificial intelligence-based work event governance method according to an exemplary embodiment is shown below. Figure 1 As shown, it includes: S101: Obtain object information of the target R&D object, wherein the object information includes object identifier, object type, current R&D stage and caller role; The target R&D object refers to the data entity in the R&D process being processed. Its value range includes briefs, projects, tasks, merge requests (MRs), code review records, test reports, release records, acceptance records, and AI processing records. The object identifier is a unique number used to identify the R&D object. The object type refers to the data category to which the R&D object belongs, i.e., whether it belongs to a task, merge request, test report, or release record. The current R&D stage refers to the stage of the R&D process in which the R&D object is located, and its value range includes requirement clarification, project creation, task decomposition, task owner alignment, development execution, code review, test report correction, release preparation, and business acceptance. The caller role refers to the identity of the person initiating this processing, including product managers (PMs), developers, testers, reviewers, and project administrators.
[0028] In this step, the system reads the four current values mentioned above from the target data source instead of using local cached values to avoid making judgments based on expired information. For example, the object being processed is merge request M-001, whose object type is merge request, the current development stage is before code review, the caller role is a developer, and the object identifier is M-001. As can be seen, this step, by reading the current values from the target data source, ensures that subsequent rule matching and validation are based on a defined object and stage, avoiding incorrect constraint selection due to incorrect stage or role identification.
[0029] As a feasible implementation, after obtaining the object information of the target R&D object, the method further includes: reading the current object state of the target R&D object and the evidence set required for state advancement corresponding to the current R&D stage; comparing the existing evidence of the target R&D object with the evidence set required for state advancement, and taking the missing evidence items as evidence gaps.
[0030] The current object status refers to the specific state value of the development object within its lifecycle. For example, the status of a merge request is open, under review, or merged; the status of a task is not aligned, aligned, under development, or accepted. The evidence set required for state advancement refers to the set of evidence items necessary to move from one development phase to the next. Evidence refers to data that proves a task has been completed, such as task objectives, acceptance criteria, code change summaries, automated test results, and review comments. An evidence gap refers to the lack of existing evidence for the target development object relative to the evidence set required for state advancement.
[0031] In practice, the system first lists the existing evidence for the target R&D object item by item, and then performs a difference operation with the evidence set required for state advancement. Each item in the difference set represents an evidence gap. Evidence gaps include at least one of the following: missing requirement description, missing acceptance criteria, missing task understanding, merge request not associated with a task, merge request description not covering acceptance criteria, test report not covering test cases, AI output not forming an electronic confirmation record, or release record not associated with a test report. For example, if the description of merge request M-001 only records fixing login timeouts, but this stage before code review requires task identification, change scope, and test descriptions, then the evidence gaps addressed in this case are these three items.
[0032] As can be seen, this implementation method determines the evidence gap by set difference operation rather than by artificial intelligence tools. Therefore, the gap results of the same object at the same stage are determined and reproducible, providing an objective basis for subsequent rule matching and context ranking.
[0033] S102: Read the R&D stage skill rules that match the target R&D object according to the object information, and parse the fields with predetermined field patterns in the R&D stage skill rules into runtime constraint objects; Among them, the R&D phase skill rules refer to stage constraint rule records that are formulated for a specific R&D phase, object type, and role set, have a predetermined field pattern, and can be parsed and verified by the program. These are not merely manual instructions for human reading. The predetermined field pattern refers to the field structure that the rule record must possess, including field names, field types, value ranges, whether they are required, and the correspondence between fields. Runtime constraint objects refer to the verification data structure generated in memory after the rule record has been verified, which the program can directly read before execution.
[0034] In practice, development-phase skill rules are stored as database records, YAML (YAML Ain't MarkupLanguage) records, or JavaScript Object Notation (JSON) records. If the rules originate from skill documents, the system first converts them into structured rule records using a field extractor; natural language text that cannot be extracted into predefined fields is only used for display purposes and not as a basis for pre-execution validation. After reading the development-phase skill rules, the system does not merely display them to the user, but uses them as a common control basis between the request initiator, proxy components, and target data sources. Rule records include at least the rule identifier, rule version, applicable phase, applicable object type, applicable role set, evidence input fields, prohibited input fields, context sorting rules, lexical budget, allowed business service identifiers, tool parameter modes, output field requirements, validation rules, write-back targets, and write-back conflict handling rules.
[0035] The configuration items, meanings, and system uses of the skill rules during the R&D phase are shown in Table 1: Table 1
[0036] After loading the skill rules from the development phase, the system parses them into runtime constraint objects. These runtime constraint objects are not ordinary descriptions displayed to the request initiator, but rather verification data structures read by the system before request execution. The runtime constraint object comprises rule version, rule hash, context field whitelist, prohibited field set, tool whitelist, parameter mode, state machine preconditions, write-back field whitelist, electronic confirmation conditions, and exception handling strategy. Runtime fields, example values, and execution effects are shown in Table 2. Table 2
[0037] The skill rule parsing process during the R&D phase includes: reading rule records; verifying the existence of required fields; verifying field types and value ranges; verifying the existence of tool names in the tool registry; verifying the existence of write-back fields in the R&D object field definitions; generating rule hashes based on rule version numbers and normalized field content; and writing rules that pass verification to the runtime constraint cache. The parsing items, verification rules, and failure handling are shown in Table 3. Table 3
[0038] In one data structure implementation, examples of fields and their technical applications for various record types are shown in Table 4: Table 4
[0039] The rule record includes the following fields: rule identifier (skill_id), rule version (skill_version), stage code (stage_code), object type (object_type), role whitelist (role_allowlist), evidence allowed list (evidence_allowlist), prohibited fields (field_denylist), tool allowed list (tool_allowlist), tool parameter mode (tool_schema), state machine precondition (state_precondition), write-back allowed list (write_allowlist), confirmation policy (confirm_policy), and conflict policy (conflict_policy). The runtime constraint object is generated from the above fields after type validation, tool registration validation, and field definition validation, and also includes the rule hash (rule_hash) and effective time (effective_time) fields.
[0040] The following is an example of the minimum rule pattern. The system only uses the fields in Table 5 to generate runtime constraint objects. Descriptive text that is not included in the structured fields does not participate in pre-execution validation, and tool, field, or state constraints cannot be relaxed.
[0041] Table 5
[0042] As can be seen, this step parses the phase rules into machine-readable runtime constraint objects, transforming the phase specifications from natural language descriptions into data that can be directly compared before execution. This is a prerequisite for the success of subsequent checks.
[0043] As a feasible implementation, the predetermined field pattern includes stage code, object type, and role whitelist; correspondingly, the step of reading the R&D stage skill rules matching the target R&D object based on the object information includes: when there are multiple R&D stage skill rules matching the target R&D object, sorting the multiple R&D stage skill rules according to a preset priority order, and selecting the R&D stage skill rule with the highest ranking; wherein, the preset priority order is as follows: applicable stage complete match, object type complete match, number of evidence gap hits from high to low, matching degree between the caller role and the role whitelist from high to low, and skill version number from high to low.
[0044] Here, the stage code refers to the code value for the development stage to which the rule applies. The role whitelist refers to the set of caller roles allowed to trigger the rule. The skill version number refers to the version number of the skill rule itself during the development stage, used to distinguish between new and old versions of the same rule.
[0045] In practice, when multiple rules apply to the same research and development object, the system sorts them in the following order: complete match of applicable stage, complete match of object type, number of evidence gaps hit, role matching priority, and rule version number, selecting the rule with the highest ranking. Specifically, the number of evidence gaps hit is sorted from highest to lowest; the more gaps covered, the more effective the rule. Role matching is sorted from highest to lowest degree of match with the role whitelist; a complete match is better than a partial match, and a partial match is better than no match. Rule version numbers are sorted from highest to lowest, with newer versions overriding older ones. If the results are still tied after sorting by these five criteria, the system refuses to execute automatically and generates a rule conflict record, requiring manual intervention to determine the applicable rule.
[0046] As a feasible implementation, parsing the fields with predetermined field patterns in the R&D stage skill rules into runtime constraint objects includes: reading the rule record corresponding to the R&D stage skill rules; verifying whether there are predetermined required fields in the rule record, whether the field type conforms to the predetermined type, whether the tool name allowed by the rule record exists in the tool registry, and whether the field allowed to be written back by the rule record exists in the field definition of the target R&D object; if all are yes, then generating the rule hash based on the skill version number and normalized field content of the rule record, and writing the rule record into the runtime constraint cache.
[0047] The tool registry is a registration form that lists the names of all available business service tools. The field definition of the target R&D object refers to the set of fields possessed by that R&D object. The rule hash is a summary value calculated based on the skill version number recorded according to the rules and the normalized field content. The runtime constraint cache is a storage area that stores runtime constraint objects that have passed verification.
[0048] In practice, the content and failure handling of the four verifications are as described in the previous table: RULE_REQUIRED_FIELD_MISSING is returned for required field verification, RULE_TYPE_ERROR is returned for field type verification, RULE_TOOL_UNKNOWN is returned for tool registration verification, and RULE_WRITE_FIELD_UNKNOWN is returned for write-back field verification. After all four verifications pass, the system generates a rule hash based on the skill version number and normalized field content recorded in the rule, and writes the rule record to the runtime constraint cache. The runtime constraint object includes this rule hash and its effective time. If a write-back rule of the same priority exists for the same object at the same stage, RULE_CONFLICT is returned. It should be noted that the rule hash is calculated using a normalized digest algorithm, such as Secure Hash Algorithm 256 (SHA-256). Before calculation, the fields involved in the calculation are arranged in ascending order by field name and represented with a unified encoding, thus ensuring that the same content will always obtain the same digest value.
[0049] As one feasible implementation, reading the rule record corresponding to the R&D stage skill rule includes: when the R&D stage skill rule originates from a skill document, extracting the skill document into a rule record with the predetermined field pattern according to a preset field mapping table.
[0050] Among them, the skill document refers to an unstructured operational instruction document written in natural language. The preset field mapping table is a mapping table that specifies which part of the document corresponds to which structured field.
[0051] In practice, the system first uses a field extractor to extract the stages, roles, evidence fields, tool lists, parameter patterns, state machine preconditions, and write-back rules from the skill document according to a preset field mapping table, forming rule records with predetermined field patterns. Text in the document that is not extracted as structured fields is only used for display purposes; it does not participate in pre-execution validation and cannot be used to relax tool, field, or state constraints. When a field mapping fails, field type mismatches occur, or the same field is mapped to any of the mutually exclusive actions, the system terminates the parsing of the skill document, and the rule is not entered into the runtime constraint cache.
[0052] S103: Generate the rule hash of the runtime constraint object, and generate an artificial intelligence input context based on the runtime constraint object; Here, the AI input context refers to the set of data provided to AI tools as inference input. The rule hash is generated in this step from rule records already written to the runtime constraint cache, and is carried in processing requests and compared in verification steps in subsequent steps.
[0053] In practice, the system calculates the rule hash while writing the rule record to the runtime constraint cache. Then, it organizes the context content based on the evidence fields allowed by the same runtime constraint object, ensuring that the context only contains evidence that the rule allows to reference. Since the context and subsequent verifications are generated based on the same runtime constraint object, the scope that the request initiator can reference is naturally consistent with the scope on which the verification is based.
[0054] As a feasible implementation, the predetermined field pattern includes an evidence allowed list and a prohibited field list; correspondingly, generating the artificial intelligence input context based on the runtime constraint object includes: reading candidate evidence from the R&D evidence library according to the object identifier and the evidence allowed list, deleting evidence fields prohibited by the prohibited field list from the candidate evidence; sorting the deleted candidate evidence according to a preset sorting criterion to obtain a candidate evidence sequence; wherein, the preset sorting criterion includes any one or a combination of any of the following: the number of evidence gap hits from most to least, the object relationship distance from closest to furthest, the evidence type priority from highest to lowest, the evidence update time from closest to furthest, and the evidence hash in lexicographical order from smallest to largest; selecting evidence fragments from the candidate evidence sequence within a preset lexical budget, and adding a source identifier and evidence hash to each evidence fragment; generating the artificial intelligence input context; wherein, the artificial intelligence input context includes any one or a combination of any of the following: the processing target of the target R&D object, the current object state, the evidence gap, available tools, and output structure requirements.
[0055] The R&D evidence repository refers to the storage area for various types of evidence data. It differs from the target data source, which is the sole authoritative repository; the former can contain multiple sources and copies. Candidate evidence refers to evidence retrieved from the R&D evidence repository based on object identifiers that may be included in the current context. Object relationship distance refers to the shortest number of edges connecting candidate evidence and the current R&D object in the object association record. Evidence hash refers to the summary value calculated from the evidence content using a digest algorithm; this summary value changes as the content changes. A term is the basic unit of measurement for text processing by artificial intelligence tools; the term budget is the amount of text allowed in the current context. Source identifier is the unique number for each piece of evidence.
[0056] In practice, the system reads candidate evidence based on the R&D object identifier. For example, when task T-001 is in the task owner alignment phase, candidate evidence includes requirements specifications, product management alignment conclusions, task descriptions, acceptance criteria, and historical risk records of similar tasks. The system first deletes unauthorized fields based on the caller's role and permission tags, and then sorts the evidence according to the relevance of the gap. If the current gap is a missing acceptance criterion, task objectives, business rules, and historical acceptance criteria are given priority in the context, while chat logs or cross-project documents unrelated to the gap are not included.
[0057] Contextual sorting employs deterministic sorting rules. The system first removes fields prohibited by cross-project or permission policies, then sorts them by evidence gap hit rate, object relationship distance, evidence type priority, evidence update time in descending order, and evidence hash lexicographical order. Evidence gap hit rate indicates whether a candidate evidence field belongs to the required evidence set corresponding to the current gap. Deletion is performed before sorting to ensure that prohibited fields are not reselected due to high relevance. A fixed sorting order ensures that identical inputs produce identical outputs, facilitating subsequent recalculation.
[0058] The lexical budget is not simply text truncation. The system first allocates budgets according to evidence type, for example, 30% for requirement specifications, 25% for task descriptions, 25% for acceptance criteria, and 20% for historical risks. When the content of a certain type of evidence is insufficient for its corresponding budget, the remaining amount is reallocated according to the gap hit priority. When an evidence fragment exceeds the single fragment budget, the system retains the fragment's field names, object identifiers, version numbers, beginning and end summaries, and evidence hashes. Each selected fragment is given a source identifier and evidence hash, and the output of the AI tool must reference these source identifiers; otherwise, it will fail subsequent consistency checks. The final generated context content includes the processing objective, current object status, evidence gaps, available tools, and output structure requirements. Therefore, this implementation method ensures that the composition of the context directly corresponds to evidence gaps, permission policies, and budget constraints, guaranteeing relevance while ensuring that the AI tool does not read information that the caller is not authorized to access.
[0059] S104: Configure the artificial intelligence tools and the automated programs triggered by the R&D process nodes to not have direct read / write permissions to the target data source; wherein, the target data source is used to store the object data of the target R&D object; In this context, the target data source refers to the sole authoritative repository of the target R&D object's data; that is, the same data is only truly stored there, while data stored elsewhere is merely a copy or cache. Judgments are based on the records stored there, and modifications must also be completed through that repository. In one implementation, the target data source is a project management system (project fact source). Object data refers to all data content of the target R&D object in the target data source, including object status, object version number, object association records, and write-back results. Artificial intelligence tools refer to tools driven by large language models used to understand context and generate suggestions. Automated procedures triggered by R&D process nodes refer to programs that automatically initiate queries, evidence recording, and status checks according to R&D process nodes; in one implementation, this is also called a background process. In this application, the artificial intelligence tool and the automated procedures triggered by R&D process nodes are collectively referred to as the request initiator.
[0060] In practice, the system only provides proxy addresses to AI tools and automated programs, without providing access addresses to the target data source or issuing read / write credentials for the target data source, thus preventing them from having the ability to directly read and write the target data source. When an AI tool or automated program initiates an access request that directly points to the target data source, the system rejects the access request and generates an unauthorized access record.
[0061] As can be seen, this step structurally separates the request initiator from the unique authoritative storage location, ensuring that all read and write requests can only be made in the form of requests and executed through a proxy, thereby eliminating the path of bypassing verification to directly modify object data.
[0062] S105: Receive a processing request sent by the artificial intelligence tool or the automation program; wherein the processing request carries the rule hash, the object identifier, and the expected read / write field; Here, a processing request refers to an intention declaration made by the request initiator that has not yet been executed, and it does not constitute a read or write operation on the data itself. Expected read / write fields refer to fields that the request initiator declares in advance in the request that it intends to read or write in this instance, and include at least one of the expected read fields and expected write fields.
[0063] In practice, the types of requests handled include tool invocation requests, project progress requests, evidence recording requests, and R&D object correction requests. Tool invocation requests include a rule hash (rule_hash), business service identifier, tool name (tool_name), tool parameters, target object (target_object), expected read fields (read_fields), expected write fields (write_fields), base version number (base_version), and execution reason (reason). The request initiator does not save the target data source read or write credentials. Artificial intelligence tools issue requests after reading the AI input context, while automated programs automatically issue requests according to R&D process nodes. Both generate their own processing requests independently, carrying the same fields and applying the same validation rules.
[0064] S106: The processing request is validated based on the runtime constraint object and the artificial intelligence input context. If the validation fails, the processing request is rejected. If the validation passes, the processing request is forwarded to the corresponding business service via a proxy.
[0065] In this context, a proxy is a forwarding component located between the request initiator and the business service, used for session binding credential forwarding, token refresh, error masking, and forced forwarding. Business services refer to services that provide external data and operational capabilities, including project management services, code repository services, merge request services, test report services, documentation services, knowledge base services, automated testing services, and release inspection services.
[0066] In practice, the system first reads the tool list and tool parameter patterns from the skill rules in the R&D phase, and verifies the rule hash, tool name, target object, read fields, write fields, parameter type, permission scope, and project state machine preconditions. Verification occurs before the tool is invoked, based on runtime constraint objects and the generated AI input context. If any condition is not met, the system refuses to execute the corresponding tool invocation and returns a reason for refusal to the request initiator or caller. After successful verification, the request is forwarded via a proxy to the business service to which the request is directed.
[0067] The request initiator does not store the target data source read or write credentials. After receiving the tool request, the proxy reads the session binding credentials or local credentials to obtain a short-term access token. All requests to read or write to the target data source can only be executed through the proxy and the target data source interface; requests bypassing this path are rejected. If the target data source returns a 401 error or a token expiration error, the proxy refreshes or re-obtains a short-term access token and retryes once; if it still fails, it returns AUTH_REFRESH_FAILED. Before returning an error to the request initiator, the proxy deletes the key, access token, authentication header, session identifier, and internal user identifier. The execution result returned by the business service is converted into a tool result record, which includes the tool call identifier, business service identifier, tool name, input parameter hash, output digest, target object version number, execution status, error code, and result hash. It should be noted that the proxy and the request initiator do not transmit the target data source's long-term credentials; the request initiator never holds these credentials.
[0068] As can be seen, this step intercepts unauthorized and out-of-bounds requests before the tool is executed, rather than waiting until after execution to discover them from the operation log, thus preventing unauthorized reads from occurring and unauthorized fields from being written.
[0069] As a feasible implementation, the predetermined field pattern includes any one or a combination of any of the following: a tool permission list, a tool parameter pattern, state machine preconditions, and a write-back permission list. Correspondingly, the verification of the processing request based on the runtime constraint object and the artificial intelligence input context includes: verifying whether the rule hash carried by the processing request is equal to the rule hash of the runtime constraint object, and / or verifying whether the tool name of the processing request belongs to a tool allowed by the tool permission list, and / or verifying whether the tool parameters of the processing request satisfy the tool parameter pattern, and / or verifying whether the object identifier belongs to the permission scope of the caller role, and / or verifying whether the expected read / write fields of the processing request belong to fields allowed by the write-back permission list, and / or verifying whether the evidence scope of the processing request exceeds the evidence scope contained in the artificial intelligence input context, and / or verifying whether the processing request conforms to the current state machine preconditions of the target R&D object.
[0070] In this context, "tool parameter pattern" refers to a machine-readable description of the field names, types, required fields, and value ranges of tool parameters. "State machine preconditions" refers to the conditions that an object must meet to transition from one state to another via a specific event. "Evidence scope" refers to the set of evidence that the request points to and intends to cite.
[0071] In practice, the request fields, validation methods, and failure handling are shown in Table 6: Table 6
[0072] When a request fails validation, the system refuses to execute the corresponding tool call and returns a rejection reason to the AI tool, automation program, or caller. Rejection reasons include one of the following: unauthorized tool, parameter pattern mismatch, target object exceeding authority, expected write field exceeding authority, evidence scope mismatch, failure to meet process preconditions, or exceeding lexical budget. For example, the merge request description correction rule allows calls to the code repository service to read change files, calls to the merge request service to read and update the merge request description, and calls to the automated testing service to read test results, but does not allow calls to the HR system, payroll system, or cross-project document service. Accordingly, requests to the HR system are rejected at the tool name validation stage, and write requests to fields outside the merge request description are rejected at the expected write field validation stage. All seven validations can be executed, or one or more can be selected. Thus, this implementation refines the comparison between requests and rules into machine validation that can be judged item by item, ensuring that unauthorized tool calls, incorrect parameter calls, and unauthorized writes are intercepted before execution and their corresponding failure reasons are recorded.
[0073] As a preferred implementation, after forwarding the processing request to the corresponding business service via a proxy, the method further includes: reviewing the execution of the processing request based on review items; wherein, the review items include any one or more of the rule hash, state machine preconditions, object association records, and the object version number of the target R&D object; wherein, the state machine preconditions adopt a restricted syntax, and the restricted syntax only includes judgment operations and logical operations on whitelist fields, the judgment operations include any one or more of the following: equality judgment, inequality judgment, inclusion judgment, and existence judgment, and the logical operations include any one or more of the following: logical AND, logical OR, and logical NOT.
[0074] Among them, the object association record refers to a ledger record that binds the task identifier, merge request identifier, test report identifier, release record identifier, object version number, evidence hash, source tool call identifier, write-back status, confirmer identifier, and confirmation time together. Review refers to a further determination of whether a request meets all conditions, under the condition that other requests are prohibited from modifying the object data during the period from reading the object data to writing the processing result on the target data source side.
[0075] In practical implementation, for the relationships between tasks, merge requests, test reports, and release records, the system does not rely on the natural language description in the request initiator's output, but instead saves object association records. The target data source reads this record before test checks, release checks, acceptance checks, and write-backs to verify whether the associated objects exist, whether the versions are consistent, and whether the evidence hashes match. The associated fields, meanings, and verification purposes of the object association records are shown in Table 7. Table 7
[0076] The writeback status (writeback_status) can take the following values: draft, confirmed, written, conflict, and abandoned. The system does not determine the association relationship based on the natural language description provided by the requester; it only verifies the relationship based on this ledger. The status transitions, the necessary object association conditions, and failure handling are shown in Table 8. Table 8
[0077] The state machine record of the target data source includes the following fields: starting state (from_state), event code (event_code), target state (to_state), guard expression (guard_expression), required evidence (required_evidence), required relation (required_relation), and failure code (failure_code). The state machine fields, examples, and uses are shown in Table 9. Table 9
[0078] The guard condition expression uses restricted Boolean expression syntax, allowing only equality, inequality, inclusion, existence, AND, OR, and NOT operations on whitelisted fields of the runtime constraint object. Script code execution or dynamic reflection is prohibited. This restricted syntax can be represented as follows: the expression consists of condition terms, AND, OR, and NOT operations; the condition terms consist of whitelisted fields, comparison operators, and values; comparison operators include =, !=, in, and exists; the value can be a string, number, Boolean value, or field reference. The system does not execute function calls, script code, database concatenation statements, or reflection access.
[0079] During state progression, the target data source reads the current object state, object association records, electronic confirmation status, and target object version number within the same backend transaction, and evaluates each item of the guard condition expression. The evaluation steps, machine processing, and failure codes are shown in Table 10: Table 10
[0080] If any condition is not met, the state remains unchanged, and the corresponding failure code is returned. If the object state or version is concurrently changed during the evaluation, STATE_VERSION_CONFLICT is returned, and the current attempt is rejected. The target data source also performs session identity verification, rule hash verification, project state machine verification, object association record verification, object version number verification, and persistent writing. Read or write requests that are not forwarded by a proxy, do not carry a valid rule hash, or do not pass through the target data source interface are rejected. As can be seen, this preferred embodiment concentrates the verification and state machine evaluation on the target data source side within the same read / write cycle, and uses restricted syntax to ensure that the condition evaluation process is not injected with arbitrary code. At the same time, it replaces the natural language description of the request initiator with object association records, so that the consistency of association and version can be determined by the machine.
[0081] In this embodiment, since the skill rules for the R&D phase are obtained by matching the object type of the target R&D object, the current R&D phase, and the caller role, the fields with predetermined field patterns are parsed into runtime constraint objects. The processing range allowed by the current phase and the current caller role then becomes data that the program can directly read and compare, rather than a natural language description that the requester needs to understand semantically. Therefore, the same R&D object will not have different execution boundaries due to differences in understanding at different phases and with different callers. Since processing requests must carry the rule hash of the runtime constraint object, and the verification compares this rule hash with the rule hash of the current runtime constraint object, whether the request belongs to the current processing and whether the current constraint applies can be directly determined. Requests generated according to other rules or expired rules cannot pass the comparison. Since processing requests carry object identifiers and expected read / write fields, and the pre-execution verification is based on both the runtime constraint object and the caller role... The AI input context is used to determine whether the requested object and the fields to be read or written exceed the allowed range of this processing, and whether the content on which the request is based is consistent with the generated AI input context. All of these can be identified before the tool is invoked. Requests that fail verification are rejected. Therefore, the AI tool will not read information that the caller is not authorized to read, nor will it invoke tools unrelated to the current development stage or write fields that are not allowed at this stage. Since the AI tool and the automated programs triggered by development process nodes are configured not to have direct read / write permissions to the target data source, their read and write operations can only be initiated in the form of processing requests. After verification, these requests are forwarded by a proxy to the business service indicated by the processing request. Even if the requester generates out-of-bounds content, there is no way to bypass verification and directly modify the object data in the target data source. Unauthorized reads and writes no longer need to wait until after the tool executes to be detected in the operation log. Therefore, this embodiment of the application prevents unauthorized reads, unauthorized tool calls, and unauthorized writes before the processing request is executed, reducing unauthorized data retrieval and unauthorized writes when AI tools and automated programs participate in request processing.
[0082] This application discloses another artificial intelligence-based method for managing work events; see [link to relevant documentation]. Figure 2 A flowchart illustrating another AI-based work event governance method according to an exemplary embodiment, such as... Figure 2 As shown, it includes: S201: Receive a research and development object correction request sent by the artificial intelligence tool or the automated program; wherein, the research and development object correction request carries a base version number and a research and development object correction draft, and the base version number is the object version number of the target research and development object when the research and development object correction draft is generated; Among them, a research and development object modification request refers to a processing request initiated by the requester that modifies the content of the target research and development object. A research and development object modification draft refers to the modification suggestions generated by the requester, and its types include field-level modification drafts, document paragraph modification drafts, test report completion drafts, merge request description completion drafts, and task acceptance standard completion drafts. The base version number (base_version) refers to the version number of the target research and development object at the time the draft was generated.
[0083] In practical implementation, for example in a merge request description revision scenario, the AI tool generates a revised draft of the merge request description based on the task objectives, acceptance criteria, code change summary, and test results. The request initiator generates the draft after reading the AI input context and includes the object version number used to generate the draft when submitting the revision request. This version number serves as a comparison benchmark for subsequent write-backs: if the target object is modified by someone else after the draft is generated, the version number will inevitably change, allowing subsequent write-backs to detect this.
[0084] S202: Save the revised draft of the research and development object as a record to be confirmed; Among them, the pending confirmation record refers to the draft record that has not yet been confirmed and is not used as the object data content in the target data source. Its writeback status in the object association record is set to draft.
[0085] In practice, the system first saves the revised content as a draft, without directly overwriting the target object. The system saves the draft independently, without writing its content to the target object or overwriting the object data in the target data source; only when the draft's status changes from draft to confirmed can the writing process begin.
[0086] S203: If the revised draft of the R&D object passes the consistency check and receives the electronic confirmation status, confirmer identifier and confirmation time, write the revision result of the revised draft of the R&D object back to the object data of the target R&D object in the target data source according to the object version number of the target R&D object.
[0087] Among these, consistency verification refers to checking whether the draft content contradicts the contextual evidence, field ranges, and the current version. Electronic confirmation status refers to a confirmation status that leaves a traceable record within the system, rather than a verbal or instant messaging statement. The confirmer identifier (confirm_user) is the ID of the person making the confirmation. The confirmation time (confirm_time) is the time the confirmation was made. Write-back refers to writing the corrected results into the object data of the target R&D object in the target data source.
[0088] In practice, consistency verification includes: verifying whether the revised draft cites evidence sources from the AI input context; verifying whether the merge request description includes task identifier, scope of change, and test instructions; verifying whether the test report covers task acceptance criteria and test cases; verifying whether the write-back fields are allowed by the rules; and verifying whether the tool execution results are consistent with the current version of the target object. For example, the system verifies whether the completed merge request description draft includes task T-001 identifier, scope of change, test instructions, and evidence source citations, and verifies whether its modified fields are limited to the merge request description fields. All three confirmation elements—electronic confirmation status, confirmer identifier, and confirmation time—must be present simultaneously; the write-back process will not proceed if any one of them is missing.
[0089] As one feasible implementation, the step of writing the correction result of the revised draft of the R&D object back to the object data of the target R&D object in the target data source based on the object version number of the target R&D object includes: reading the current object data and the current object version number of the target R&D object; if the base version number is consistent with the current object version number, writing the correction result back to the object data of the target R&D object in the target data source and incrementing the current object version number; if the base version number is inconsistent with the current object version number, generating a field-level difference record between the correction result and the current object data, so as to perform anomaly handling based on the field-level difference record.
[0090] Here, "current object data" refers to the existing data content of the target R&D object in the target data source. "Field-level difference record (diff_record)" refers to the difference obtained by comparing the corrected result with the current object data field by field.
[0091] In practice, the system uses the object version number for optimistic concurrency control during write-back. The write-back transaction takes the target object identifier (target_object), base version number (base_version), rule hash (rule_hash), write-back field whitelist, and electronic confirmation record as input. Within the same backend transaction, it completes the current version reading, field whitelist verification, state machine precondition review, and write commit, and prohibits other requests from modifying the object data during the period from reading the object data to writing the correction result. The conflict steps, system processing, and output status are shown in Table 11. Table 11
[0092] For example, if the AI tool generates a draft with merge request M-001 version number 4, and M-001 is still version 4 when the system receives the electronic confirmation, the system writes back the draft and updates M-001 to version 5. If M-001 has been modified to version 5 by someone else before electronic confirmation, the system generates a WRITEBACK_VERSION_CONFLICT record, showing the AI draft, the current merge request content, and the differences between the two, allowing the confirmer to choose to merge, discard, or regenerate. Thus, this implementation uses version number comparison to prevent content generated based on an older version from overwriting manually modified new content, and provides comparable differences and a clear recovery path when conflicts occur.
[0093] As a preferred embodiment, after writing the correction result of the R&D object revision draft back to the object data of the target R&D object in the target data source based on the object version number of the target R&D object, the method further includes: processing the content to be hashed in a normalized serialization manner; wherein, the normalized serialization includes any one or a combination of any of the following: field name ascending order, array sorted by object identifier, time value converted to a preset time format and unified time zone, and null values represented by a fixed marker; selecting fields to participate in hash calculation from the content to be hashed according to the field set determined by the runtime constraint object; replacing sensitive fields in the selected fields with the field name, desensitization marker, and desensitized summary of the sensitive fields; generating and storing audit records based on the normalized serialization and the selected fields and the preset summary algorithm; wherein, the audit records include any one or a combination of any of the following: the rule hash, the previous audit record hash, the context hash of the artificial intelligence input context, the request hash of the processing request, the result hash of the execution result corresponding to the processing request, the draft hash of the R&D object revision draft, and the write-back result hash.
[0094] In this context, normalized serialization refers to the standardized processing of data before digest calculation to ensure that identical content always yields the same digest value. The content to be hashed refers to the processing data intended for digest calculation. The previous_audit_hash is the normalized digest value of the previous audit record. An audit record is a record documenting the current processing procedure for subsequent review. The audit hash chain is a verifiable chain of audit records linked together by hashes, consisting of the AI input context hash, processing request hash, execution result hash, revised draft hash, write-back result hash, and previous audit record hash.
[0095] In its implementation, the system employs standardized JSON serialization, sorts fields participating in hash calculations in ascending order by field name, converts field names and values to 8-bit Unicode Transformation Format (UTF-8) encoding, and sorts array values by configured object identifier, field name, or element identifier. Null values are represented by fixed null markers, and time values are converted to International Organization for Standardization (ISO) 8601 format with unified time zones. The system uses the SHA-256 algorithm to calculate the rule hash, AI input context hash, processing request hash, business service execution result hash, revised draft hash, write-back result hash, and previous audit record hash, respectively.
[0096] Audit logs include the R&D object identifier, object version number, rule identifier, rule version, rule hash, caller role, AI input context hash, request processing hash, execution result hash, draft correction hash, target data source verification result, electronic confirmation status, confirmer identifier, confirmation time, write-back result hash, and previous audit log hash. The hash items, overriding fields, and review purposes are shown in Table 12. Table 12
[0097] The set of input fields for each hash item is determined by the runtime constraint object and does not automatically expand with the output of the request initiator. Hash items, required input fields, and excluded fields are shown in Table 13. Table 13
[0098] Sensitive fields are not hashed in plaintext; instead, they are hashed using their field name, de-identification tag, and de-identified digest. Display text, interface styles, temporary cache addresses, paging information, and error stack traces are not hashed in plaintext. Audit records are written to an append-only storage area; already written records are not overwritten by update statements. When reversal is required, a reversal record is appended and references the original audit record's hash. Therefore, this preferred embodiment calculates the digest using a fixed set of fields and a uniform processing order, ensuring that the same processing procedure yields the same digest value, providing a basis for subsequent recalculation and verification.
[0099] As a preferred implementation, after generating and storing the audit record based on the normalized serialization and selected fields and the preset digest algorithm, the method further includes: rereading the review object; wherein, the review object includes any one or a combination of any of the following: skill version, rule hash, artificial intelligence input context, tool call record, data source verification result, R&D object revision draft, write-back result, and write-back object version; recalculating the corresponding hash of the reread review object based on the same normalized serialization method and the same preset digest algorithm as when generating the audit record; comparing the recalculated hash with the hash in the audit record, and generating a processing abnormality alarm if there are any anomalies, wherein the anomalies include any one or a combination of any of the following: hash inconsistency, hash breakage of the previous audit record, and inconsistency between the write-back object version and the audit record.
[0100] The review object refers to the process data that is reread during the review process and used to recalculate the summary. A hash break in a preceding audit record refers to a discrepancy between the summary of the previous record recorded in a particular audit record and the actual summary of the previous record; this is usually caused by the insertion, deletion, or alteration of the record.
[0101] In practice, the review trigger conditions include pre-state advancement review, post-write-back sampling review, anomaly alarm review, and external audit review. During review, the system rereads the aforementioned review objects, recalculates the corresponding digests using the same normalized serialization method and digest algorithm as when generating the audit records, and then compares the recalculated results with the digests in the audit records item by item. When any hash inconsistency, hash breakage in the preceding audit record, or inconsistency between the write-back object version and the audit record occurs, the system generates an AUDIT_CHAIN_BROKEN alarm and prohibits the use of this processing result as the basis for automatic state advancement.
[0102] In this embodiment, the modified content of the R&D object generated by the AI tools and automated programs is first saved as a pending confirmation record that does not overwrite the object data. It is only written back to the target data source after passing the consistency check and receiving electronic confirmation status, confirmer identifier, and confirmation time. Thus, the generation and writing actions are isolated from each other. The content generated by the request initiator will not automatically fall onto the actual R&D object after generation. Even if it has defects or goes out of bounds, it will only remain at the pending confirmation draft level and will not pollute the object data in the target data source. Since the consistency check requires the draft to cite contextual evidence sources, include elements such as task identifiers and change scope, and the modified fields are limited to fields that the rules allow to be written back, whether the draft can be written back depends on whether it is consistent with the contextual evidence and the current object field range, rather than the request initiator's own claim. Therefore, drafts with insufficient evidence or non-compliance are intercepted before being written. Because write-back is based on comparing the baseline version number with the current object version number, when versions are inconsistent, field-level difference records are generated for merging, abandoning the write-back, or regenerating. Drafts generated based on older object versions cannot cover new modifications made by the confirmer or other R&D personnel. In the event of version conflicts, a comparable and selectable recovery path can be obtained, rather than being indiscriminately overwritten. Furthermore, since write-back must simultaneously possess electronic confirmation status, confirmer identification, and confirmation time, and leave a record, and this processing appends audit records in a standardized serialized manner, allowing for recalculation and comparison with records during review, any modification can be traced back to who made the modification, when, on which R&D object, what evidence was used as the basis for the write-back, and what the result was. The processing process can be independently verified afterward, thus solving the problems of difficulty in identifying the basis for modifications and the difficulty in detecting tampering of the process.
[0103] The following describes an application embodiment provided by this application, taking a research and development collaboration scenario in which the task leader aligns and merges the request review in one go through the two research and development stages as an example.
[0104] In this embodiment, the target data source stores research and development objects such as task T-001 and merge request M-001. The skill rules in the research and development stage include task understanding rules and merge request description and correction rules. The request initiators include artificial intelligence tools and automated programs triggered according to the research and development process nodes, involving caller roles such as product managers, researchers and reviewers.
[0105] Task T-001 is currently in the task owner alignment phase. The system first obtains the object information for Task T-001, identifying its object type as a task, its current development phase as task owner alignment, and its caller role as a product manager. Then, it calculates the evidence gap, which involves reading the set of evidence required for the status progression from the task owner alignment phase to the development execution phase, comparing it with the existing evidence for Task T-001, and identifying the missing evidence items. If the goal and implementation method of Task T-001 are not yet clear, then the evidence gap is a lack of understanding of the task.
[0106] The system matches the task understanding rules based on the object type, current development stage, and caller role of task T-001. It then parses fields with predefined field patterns in these rules into runtime constraint objects and generates rule hashes. When the same object matches multiple rules, the system sorts them by applicable stage (full match), object type (full match), number of evidence gaps (from highest to lowest), caller role matching degree (from highest to lowest), and skill version number (from highest to lowest), selecting the rule with the highest ranking. The runtime constraint objects generated by the task understanding rules limit the evidence fields that can be referenced in this stage (requirements specifications, product management alignment conclusions, task description, acceptance criteria), prohibited fields, allowed tools (knowledge base retrieval, document modification), state machine preconditions, and fields that can be written back.
[0107] The system reads candidate evidence from the R&D evidence library based on the runtime constraint object, deletes fields listed in the prohibited field list, sorts evidence fragments by relevance to the evidence gap within the lexical budget, selects evidence fragments, adds source identifiers and evidence hashes to each fragment, and generates an AI input context. Since the evidence gap in this case is a lack of task understanding, requirements specifications, product management alignment conclusions, and task descriptions are prioritized for inclusion in the context, while chat logs unrelated to the gap are excluded. The system provides the AI input context to the AI tool and configures the AI tool and automation program to not have direct read / write permissions to the target data source, ensuring that read and write operations can only be initiated as processing requests and executed through a proxy.
[0108] After reading the AI input context, the AI tool submits knowledge base retrieval and document modification requests. Automated programs can also trigger task status check requests according to development process nodes. Each processing request carries the current rule hash, object identifier, and expected read / write fields. Before execution, the system verifies the processing request based on the same runtime constraint object and AI input context. It checks each item: whether the request's rule hash equals the current runtime constraint object's rule hash; whether the tool name belongs to the tool's allowed list; whether the tool parameters meet the tool parameter mode; whether the target object is within the caller's permission range; whether the expected read / write fields belong to the write-back allowed list; whether the evidence scope exceeds the AI input context; and whether it meets the target data source's state machine preconditions. Requests that fail verification are rejected. Requests that pass verification are forwarded to the corresponding business service via a proxy carrying a short-term access token. The target data source reviews the rule hash, state machine preconditions, object association records, and object version number within the same backend transaction before returning the execution result.
[0109] The AI tool generates a draft for task understanding and risk correction based on the context. The draft references evidence source identifiers from the context, and modifications are limited to fields listed in the task understanding rule write-back allowable list. The system saves this draft as a pending confirmation record and performs consistency checks. After the draft passes the consistency check and receives electronic confirmation status, confirmer identifier, and confirmation time from the product manager, a write-back is performed based on the object version number of task T-001. During the write-back, the system rereads the current object data and current object version number of task T-001 from the target data source. If the base version number carried by the draft matches the current object version number, the correction result is written and the version number is incremented; if they do not match, a field-level difference record is generated and the process enters the merging, abandoning the write-back, or regeneration process. The system also generates audit records in a normalized serialization manner, appending the rule hash, AI input context hash, processing request hash, execution result hash, corrected draft hash, write-back result hash, and previous audit record hash to the audit hash chain.
[0110] After alignment, task T-001 enters the development execution phase. Developers complete the code changes and submit merge request M-001. The description of M-001 only mentions fixing login timeouts, omitting the task number, scope of changes, and test descriptions. The system identifies the current object as a merge request, the current development phase as before code review, the caller role as a developer, and the calculated evidence gap as the merge request description not covering acceptance criteria. Based on this, it matches the merge request description correction rules and generates corresponding runtime constraint objects and rule hashes. These rules restrict the callable business services to code repository services, merge request services, and automated testing services, disallowing calls to HR systems, payroll systems, or cross-project document services, and limiting the fields allowed to be written back to the merge request description fields.
[0111] The system generates an AI input context based on the runtime constraint object. The code change summary and test results are prioritized according to the evidence gap hit and the distance to the object relationship. The task objective and acceptance criteria of task T-001, to which M-001 belongs, are also included in the context. Based on the context, the AI tool requests to read the change file, read the test results, and update the merge request description. Automated programs can also trigger merge request description verification requests based on the same rules. The system verifies that all tools for the above requests are within the allowed tool list. After the parameters, target object, caller permissions, and state machine preconditions are valid, the request is forwarded to the corresponding business service for execution via a proxy. The target data source reviews the request and returns the change file, test results, or write-back results.
[0112] The AI tool generates a draft of the merge request description, which includes the identifier of task T-001, the scope of changes, test instructions, and evidence source citations. Modifications are limited to the merge request description field. After the system verifies the draft, it saves it as a pending confirmation record and submits it to the R&D personnel for electronic confirmation. During confirmation, if the current object version number of M-001 matches the base version number of the draft record, the system writes back the merge request description from the target data source and increments the version number. If M-001 has been modified by the reviewer before confirmation, the system generates a version conflict record and displays the AI draft, the current merge request content, and the differences between the two. The confirmer can then choose to merge, abandon the write-back, or regenerate. The system also appends audit records to M-001 in a standardized serialization manner, allowing for subsequent recalculation and review.
[0113] Therefore, in this application embodiment, although the two R&D phases of task leader alignment and merging request review match different rules and call different business services, they both follow the same controlled link. That is, first, object information is obtained and evidence gaps are calculated, then the skill rules of the R&D phase are matched and parsed as runtime constraint objects, and an artificial intelligence input context is generated based on the same runtime constraint object. The request initiator is configured to have no direct read / write permissions to the target data source, and the processing request carrying the rule hash is received. Before execution, the request is verified according to the same runtime constraint object and artificial intelligence input context, and unauthorized requests are rejected and legitimate requests are forwarded. After review by the target data source, a revised draft of the R&D object is generated. After consistency verification and electronic confirmation, it is written back according to the object version number, and an appended audit record is generated. Context unauthorization, tool unauthorization, state machine bypass, old version write-back, and audit chain break are blocked in turn at each stage of this link.
[0114] The comparison items, the handling methods for unconstrained rules, and the methods and technical effects of this application are shown in Table 14: Table 14
[0115] In one test implementation, the system can process the same batch of merge request description correction processes using both the ruleless constraint processing method and the method described in this application, and record the following objective indicators. The statistical period is 100 consecutive merge request description correction requests, and the samples all include the fields for task, merge request, test result, and description to be written back; unauthorized requests are based on records of denial by permission policies, and version overwrite risk is based on records where the base version number is inconsistent with the current version number but still attempts to write back. The results are shown in Table 15: Table 15
[0116] In related technologies, standalone role-based access control can typically only determine whether a caller has access to a certain type of resource, but cannot determine whether the context generated by the request initiator, the processing request, the target object version, and the write-back fields originate from the same development phase constraints. Standalone tool invocation proxies can typically only forward tool invocations, and cannot guarantee that the tool request is consistent with the development object state, evidence gaps, and write-back fields. Standalone optimistic locking can only prevent version overwriting, but cannot prevent unauthorized contexts from entering AI input or unauthorized tools from being invoked. Standalone audit logs can only record results, and cannot reverse-check the consistency of the context, tool request, execution results, and revised drafts before state progression.
[0117] In this application, the same runtime constraint object and its rule hash are reused continuously in context construction, request admission processing, proxy forced routing, target data source write-back, and audit hash chain verification. The evidence source, object version, and hash result generated in the previous stage become the verification input for the next stage, ensuring that context privilege escalation, tool privilege escalation, state machine bypass, old version write-back, and audit chain breakage are detected and blocked by the same constraint chain. This collaborative relationship enables rule features and technical features to functionally support each other and jointly solve the problem of controlled execution when an untrusted request initiator generates a request.
[0118] The AI-based work event governance method provided in this application matches R&D stage skill rules with object information and parses them into runtime constraint objects. It then generates an AI input context based on the same runtime constraint object and performs pre-execution verification on processing requests, preventing unauthorized reading, unauthorized tool calls, and unauthorized writing before the processing request is executed. Specifically, since the R&D stage skill rules are matched according to the object type of the target R&D object, the current R&D stage, and the caller's role, fields with predetermined field patterns are parsed into runtime constraint objects. The processing scope allowed by the current stage and the current caller role becomes data that the program can directly read and compare, rather than natural language descriptions that the requester needs to understand semantically. Therefore, the same R&D object will not have different execution boundaries due to differences in understanding at different stages and with different callers. Since processing requests must carry the rule hash of the runtime constraint object, and the verification compares this rule hash with the rule hash of the current runtime constraint object, whether the request belongs to the current processing and whether the current constraint applies can be directly determined. Requests generated according to other rules or invalid rules cannot pass the comparison. Because processing requests carry object identifiers and expected read / write fields, and the pre-execution verification is based on both runtime constraint objects and AI... The system allows for input context analysis. Whether the requested object and the fields to be read / written exceed the allowed scope of the current processing, and whether the content of the request is consistent with the generated AI input context, can all be identified before the tool is invoked. Requests that fail verification are rejected. Therefore, the AI tool will not read information that the caller is not authorized to read, nor will it invoke tools unrelated to the current development stage or write to fields not permitted at this stage. Since the AI tool and automated programs triggered by development process nodes are configured not to have direct read / write permissions to the target data source, their read and write operations can only be initiated in the form of processing requests. After verification, these requests are forwarded to the business service indicated by the processing request via a proxy. Even if the requester generates out-of-bounds content, there is no way to bypass verification and directly modify the object data in the target data source. Unauthorized reads and writes no longer need to wait until after tool execution to be detected in the operation log. Therefore, this embodiment of the application prevents unauthorized reads, unauthorized tool calls, and unauthorized writes before the processing request is executed, reducing unauthorized data retrieval and unauthorized writes when AI tools and automated programs participate in request processing.
[0119] The following describes an AI-based work event management device provided in an embodiment of this application. The AI-based work event management device described below and the AI-based work event management method described above can be referred to each other.
[0120] See Figure 3A structural diagram of an artificial intelligence-based work event management device is shown according to an exemplary embodiment, such as... Figure 3 As shown, it includes: The acquisition module 100 is used to acquire object information of the target R&D object, wherein the object information includes object identifier, object type, current R&D stage and caller role; The parsing module 200 is used to read the R&D stage skill rules that match the target R&D object according to the object information, and parse the fields with a predetermined field pattern in the R&D stage skill rules into runtime constraint objects; The generation module 300 is used to generate the rule hash of the runtime constraint object and generate an artificial intelligence input context based on the runtime constraint object. Configuration module 400 is used to configure artificial intelligence tools and automated programs triggered according to R&D process nodes to not have direct read and write permissions to the target data source, wherein the target data source is used to store object data of the target R&D object; The first receiving module 500 is configured to receive a processing request sent by the artificial intelligence tool or the automation program, wherein the processing request carries the rule hash, the object identifier, and the expected read / write field; The verification module 600 is used to verify the processing request based on the runtime constraint object and the artificial intelligence input context. If the verification fails, the processing request is rejected. If the verification passes, the processing request is forwarded to the business service pointed to by the processing request through a proxy.
[0121] In this embodiment, since the skill rules for the R&D phase are obtained by matching the object type of the target R&D object, the current R&D phase, and the caller role, the fields with predetermined field patterns are parsed into runtime constraint objects. The processing range allowed by the current phase and the current caller role then becomes data that the program can directly read and compare, rather than a natural language description that the requester needs to understand semantically. Therefore, the same R&D object will not have different execution boundaries due to differences in understanding at different phases and with different callers. Since processing requests must carry the rule hash of the runtime constraint object, and the verification compares this rule hash with the rule hash of the current runtime constraint object, whether the request belongs to the current processing and whether the current constraint applies can be directly determined. Requests generated according to other rules or expired rules cannot pass the comparison. Since processing requests carry object identifiers and expected read / write fields, and the pre-execution verification is based on both the runtime constraint object and the caller role... The AI input context is used to determine whether the requested object and the fields to be read or written exceed the allowed range of this processing, and whether the content on which the request is based is consistent with the generated AI input context. All of these can be identified before the tool is invoked. Requests that fail verification are rejected. Therefore, the AI tool will not read information that the caller is not authorized to read, nor will it invoke tools unrelated to the current development stage or write fields that are not allowed at this stage. Since the AI tool and the automated programs triggered by development process nodes are configured not to have direct read / write permissions to the target data source, their read and write operations can only be initiated in the form of processing requests. After verification, these requests are forwarded by a proxy to the business service indicated by the processing request. Even if the requester generates out-of-bounds content, there is no way to bypass verification and directly modify the object data in the target data source. Unauthorized reads and writes no longer need to wait until after the tool executes to be detected in the operation log. Therefore, this embodiment of the application prevents unauthorized reads, unauthorized tool calls, and unauthorized writes before the processing request is executed, reducing unauthorized data retrieval and unauthorized writes when AI tools and automated programs participate in request processing.
[0122] Based on the above embodiments, as a preferred embodiment, it further includes: The evidence gap determination module is used to read the current object state of the target R&D object and the evidence set required for state advancement corresponding to the current R&D stage; compare the existing evidence of the target R&D object with the evidence set required for state advancement, and identify the missing evidence items as evidence gaps.
[0123] Based on the above embodiments, as a preferred implementation, the predetermined field pattern includes stage coding, object type, and role whitelist; Accordingly, the parsing module 200 includes: The selection unit is used to sort the multiple R&D stage skill rules according to a preset priority order when there are multiple R&D stage skill rules that match the target R&D object, and select the R&D stage skill rule with the highest ranking. The preset priority order is as follows: complete matching of applicable stage, complete matching of object type, number of hits of evidence gap from most to least, matching degree of the caller role with the role whitelist from high to low, and skill version number from high to low.
[0124] Based on the above embodiments, as a preferred embodiment, the parsing module 200 includes: The reading unit is used to read the rule records corresponding to the skill rules in the research and development stage. The verification unit is used to verify whether there are any predetermined required fields in the rule record, whether the field type conforms to the predetermined type, whether the tool name allowed by the rule record exists in the tool registry, and whether the field that the rule record is allowed to write back exists in the field definition of the target R&D object; if all of these are true, the rule hash is generated based on the skill version number and normalized field content of the rule record, and the rule record is written to the runtime constraint cache.
[0125] Based on the above embodiments, as a preferred implementation, the reading unit is specifically used to: extract the skill document into a rule record with the predetermined field pattern according to a preset field mapping table when the skill rules in the R&D stage originate from the skill document.
[0126] Based on the above embodiments, as a preferred implementation, the predetermined field pattern includes an evidence allowed list and a prohibited field list; Accordingly, the generation module 300 is specifically used for: reading candidate evidence from the R&D evidence library according to the object identifier and the evidence allowed list, and deleting evidence fields prohibited by the prohibited field list in the candidate evidence; sorting the deleted candidate evidence according to a preset sorting criterion to obtain a candidate evidence sequence; wherein, the preset sorting criterion includes any one or a combination of any of the following: the number of evidence gap hits from most to least, the object relationship distance from closest to furthest, the evidence type priority from highest to lowest, the evidence update time from closest to furthest, and the evidence hash in lexicographical order from smallest to largest; selecting evidence fragments from the candidate evidence sequence within a preset lexical budget, and adding a source identifier and evidence hash to each evidence fragment; generating the artificial intelligence input context; wherein, the artificial intelligence input context includes any one or a combination of any of the following: the processing target of the target R&D object, the current object status, the evidence gap, available tools, and output structure requirements.
[0127] Based on the above embodiments, as a preferred implementation, the predetermined field pattern includes any one or a combination of any of the following: tool permission list, tool parameter pattern, state machine preconditions, and write-back permission list; Accordingly, the verification module 600 is specifically used to: verify whether the rule hash carried by the processing request is equal to the rule hash of the runtime constraint object, and / or verify whether the tool name of the processing request belongs to the tools allowed by the tool allowed list, and / or verify whether the tool parameters of the processing request meet the tool parameter mode, and / or verify whether the object identifier belongs to the permission scope of the caller role, and / or verify whether the expected read / write fields of the processing request belong to the fields allowed by the write-back allowed list, and / or verify whether the evidence scope of the processing request exceeds the evidence scope contained in the artificial intelligence input context, and / or verify whether the processing request meets the current state machine preconditions of the target R&D object.
[0128] Based on the above embodiments, as a preferred embodiment, it further includes: The review module is used to review the execution of the processing request based on the review items; wherein, the review items include any one or more of the rule hash, state machine preconditions, object association records, and object version number of the target R&D object; The state machine preconditions adopt a restricted syntax, which includes only judgment operations and logical operations on whitelist fields. The judgment operations include any one or a combination of any of the following: equality judgment, inequality judgment, inclusion judgment, and existence judgment. The logical operations include any one or a combination of any of the following: logical AND, logical OR, and logical NOT.
[0129] Based on the above embodiments, as a preferred embodiment, it further includes: The second receiving module is used to receive a research and development object correction request sent by the artificial intelligence tool or the automated program; wherein, the research and development object correction request carries a base version number and a research and development object correction draft, and the base version number is the object version number of the target research and development object when the research and development object correction draft is generated; The retention module is used to save the revised draft of the research and development object as a record to be confirmed. The R&D object correction module is used to write the correction result of the R&D object correction draft back to the object data of the target R&D object in the target data source according to the object version number of the target R&D object, after the R&D object correction draft passes the consistency check and receives the electronic confirmation status, confirmer identifier and confirmation time.
[0130] Based on the above embodiments, as a preferred implementation, the R&D object correction module is specifically used to: read the current object data and current object version number of the target R&D object; if the base version number is consistent with the current object version number, write the correction result back to the object data of the target R&D object in the target data source, and increment the current object version number; if the base version number is inconsistent with the current object version number, generate a field-level difference record between the correction result and the current object data, so as to perform anomaly handling based on the field-level difference record.
[0131] Based on the above embodiments, as a preferred embodiment, it further includes: The audit module is used to process the content to be hashed in a normalized serialization manner. The normalized serialization includes any one or a combination of the following: field names are sorted in ascending order; arrays are sorted by object identifier; time values are converted to a preset time format and time zones are unified; null values are represented by a fixed marker. Fields for hash calculation are selected from the content to be hashed based on the field set determined by the runtime constraint object. Sensitive fields in the selected fields are replaced with the field names, desensitization markers, and desensitized summaries of the sensitive fields. Audit records are generated and stored based on the normalized serialization, the selected fields, and the preset summary algorithm. The audit records include any one or a combination of the following: the rule hash, the hash of the preceding audit record, the context hash of the AI input context, the request hash of the processing request, the result hash of the execution result corresponding to the processing request, the draft hash of the revised draft of the R&D object, and the write-back result hash.
[0132] Based on the above embodiments, as a preferred embodiment, it further includes: An exception handling module is used to reread the review object; wherein the review object includes any one or a combination of any of the following: skill version, rule hash, artificial intelligence input context, tool call record, data source verification result, R&D object revision draft, write-back result, and write-back object version; based on the same normalized serialization method and the same preset digest algorithm used when generating the audit record, the corresponding hash of the reread review object is recalculated; the recalculated hash is compared with the hash in the audit record, and if there are any exceptions, a processing exception alarm is generated, wherein the exceptions include any one or a combination of any of the following: hash inconsistency, hash breakage of the previous audit record, and inconsistency between the write-back object version and the audit record.
[0133] Regarding the apparatus in the above embodiments, the specific manner in which each module performs its operation has been described in detail in the embodiments related to the method, and will not be elaborated upon here.
[0134] Based on the hardware implementation of the above program modules, and in order to implement the method of the embodiments of this application, the embodiments of this application also provide an electronic device. Figure 4 This is a structural diagram of an electronic device according to an exemplary embodiment, such as... Figure 4 As shown, the electronic device includes: Communication interface 1 enables information exchange with other devices, such as network devices; Processor 2 is connected to communication interface 1 to enable information interaction with other devices. When running a computer program, it executes the artificial intelligence-based work event management method provided by one or more of the above-mentioned technical solutions. The computer program is stored in memory 3.
[0135] Of course, in practical applications, the various components in an electronic device are coupled together through bus system 4. It can be understood that bus system 4 is used to achieve communication and connection between these components. In addition to the data bus, bus system 4 also includes a power bus, a control bus, and a status signal bus. However, for clarity, in... Figure 4 The general will label all buses as Bus System 4.
[0136] The memory 3 in this embodiment is used to store various types of data to support the operation of the electronic device. Examples of such data include any computer program used to operate on the electronic device.
[0137] It is understood that memory 3 can be volatile memory or non-volatile memory, or both. Non-volatile memory can be read-only memory (ROM), programmable read-only memory (PROM), erasable programmable read-only memory (EPROM), electrically erasable programmable read-only memory (EEPROM), ferroelectric random access memory (FRAM), flash memory, magnetic surface memory, optical disc, or compact disc read-only memory (CD-ROM); magnetic surface memory can be disk storage or magnetic tape storage. Volatile memory can be random access memory (RAM), which is used as an external cache. By way of example, but not limitation, many forms of RAM are available, such as Static Random Access Memory (SRAM), Synchronous Static Random Access Memory (SSRAM), Dynamic Random Access Memory (DRAM), Synchronous Dynamic Random Access Memory (SDRAM), Double Data Rate Synchronous Dynamic Random Access Memory (DDRSDRAM), Enhanced Synchronous Dynamic Random Access Memory (ESDRAM), SyncLink Dynamic Random Access Memory (SLDRAM), and Direct Rambus Random Access Memory (DRRAM).The memory 3 described in the embodiments of this application is intended to include, but is not limited to, these and any other suitable types of memory.
[0138] The methods disclosed in the embodiments of this application can be applied to processor 2, or implemented by processor 2. Processor 2 may be an integrated circuit chip with signal processing capabilities. In the implementation process, each step of the above method can be completed by the integrated logic circuit of the hardware in processor 2 or by instructions in the form of software. The processor 2 may be a general-purpose processor, DSP, or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. Processor 2 can implement or execute the methods, steps and logic block diagrams disclosed in the embodiments of this application. The general-purpose processor may be a microprocessor or any conventional processor, etc. The steps of the methods disclosed in the embodiments of this application can be directly manifested as being executed by a hardware decoding processor, or being executed by a combination of hardware and software modules in the decoding processor. The software modules may be located in a storage medium, which is located in memory 3. Processor 2 reads the program in memory 3 and completes the steps of the aforementioned method in combination with its hardware.
[0139] When processor 2 executes the program, it implements the corresponding processes in the various methods of the embodiments of this application. For the sake of brevity, these will not be described in detail here.
[0140] In an exemplary embodiment, this application also provides a storage medium, namely a computer storage medium, specifically a computer-readable storage medium, such as a memory 3 that stores a computer program, which can be executed by a processor 2 to complete the steps described in the aforementioned method. The computer-readable storage medium may be a memory such as FRAM, ROM, PROM, EPROM, EEPROM, Flash Memory, magnetic surface memory, optical disc, or CD-ROM.
[0141] Those skilled in the art will understand that all or part of the steps of the above method embodiments can be implemented by hardware related to program instructions. The aforementioned program can be stored in a computer-readable storage medium. When the program is executed, it performs the steps of the above method embodiments. The aforementioned storage medium includes various media that can store program code, such as mobile storage devices, ROM, RAM, magnetic disks, or optical disks.
[0142] Alternatively, if the integrated units described above are implemented as software functional modules and sold or used as independent products, they can also be stored in a computer-readable storage medium. Based on this understanding, the technical solutions of the embodiments of this application, or the parts that contribute to the prior art, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause an electronic device (which may be a personal computer, server, network device, etc.) to execute all or part of the methods described in the various embodiments of this application. The aforementioned storage medium includes various media capable of storing program code, such as mobile storage devices, ROM, RAM, magnetic disks, or optical disks.
[0143] The above description is merely a specific embodiment of this application, but the scope of protection of this application is not limited thereto. Any changes or substitutions that can be easily conceived by those skilled in the art within the scope of the technology disclosed in this application should be included within the scope of protection of this application.
Claims
1. A work event management method based on artificial intelligence, characterized in that, include: Obtain object information of the target R&D object, wherein the object information includes object identifier, object type, current R&D stage and caller role; Based on the object information, read the R&D stage skill rules that match the target R&D object, and parse the fields with a predetermined field pattern in the R&D stage skill rules into runtime constraint objects; Generate the rule hash of the runtime constraint object, and generate an artificial intelligence input context based on the runtime constraint object; The artificial intelligence tools and automated programs triggered by R&D process nodes are configured not to have direct read / write permissions to the target data source; wherein, the target data source is used to store the object data of the target R&D object; Receive a processing request sent by the artificial intelligence tool or the automation program; wherein the processing request carries the rule hash, the object identifier, and the expected read / write field; The processing request is validated based on the runtime constraint object and the artificial intelligence input context. If the validation fails, the processing request is rejected. If the validation passes, the processing request is forwarded to the corresponding business service via a proxy.
2. The work incident management method according to claim 1, characterized in that, After obtaining the object information of the target R&D object, the process also includes: Read the current object state of the target R&D object and the set of evidence required to advance the current R&D stage; The existing evidence for the target R&D object is compared with the set of evidence required for the state advancement, and the missing evidence items are regarded as evidence gaps.
3. The work incident management method according to claim 2, characterized in that, The predefined field pattern includes stage coding, object type, and role whitelist; Accordingly, the step of reading the R&D stage skill rules matching the target R&D object based on the object information includes: When there are multiple R&D stage skill rules that match the target R&D object, the multiple R&D stage skill rules are sorted according to a preset priority order, and the R&D stage skill rule with the highest ranking is selected. The preset priority order is as follows: complete matching of applicable stage, complete matching of object type, number of hits of evidence gap from most to least, matching degree of the caller role with the role whitelist from high to low, and skill version number from high to low.
4. The work incident management method according to claim 1, characterized in that, The step of parsing fields with predetermined field patterns in the R&D phase skill rules into runtime constraint objects includes: Read the rule records corresponding to the skill rules in the R&D phase; Verify whether the rule record contains any pre-defined required fields, whether the field types match the pre-defined types, whether the tool names allowed by the rule record exist in the tool registry, and whether the fields allowed to be written back by the rule record exist in the field definitions of the target R&D object; If both are true, then the rule hash is generated based on the skill version number and normalized field content of the rule record, and the rule record is written to the runtime constraint cache.
5. The work incident management method according to claim 4, characterized in that, The step of reading the rule record corresponding to the skill rules in the R&D phase includes: When the skill rules in the R&D phase originate from skill documents, the skill documents are extracted into rule records with the predetermined field patterns according to a preset field mapping table.
6. The work incident management method according to claim 2, characterized in that, The predefined field pattern includes a list of allowed evidence fields and a list of prohibited evidence fields; Accordingly, generating the artificial intelligence input context based on the runtime constraint object includes: Based on the object identifier and the evidence allowed list, candidate evidence is read from the R&D evidence library, and evidence fields prohibited by the prohibited field list in the candidate evidence are deleted; The candidate evidence after deletion is sorted according to a preset sorting criterion to obtain a candidate evidence sequence; wherein, the preset sorting criterion includes any one or a combination of any of the following: the number of hits of evidence gaps from most to least, the distance of object relationships from closest to furthest, the priority of evidence types from highest to lowest, the evidence update time from closest to furthest, and the evidence hashes in lexicographical order from smallest to largest. Within a preset lexical budget, select evidence fragments from the candidate evidence sequence and add a source identifier and evidence hash to each evidence fragment; Generate the artificial intelligence input context; wherein the artificial intelligence input context includes any one or a combination of any of the following: the processing objective of the target research object, the current object state, the evidence gap, available tools, and output structure requirements.
7. The work incident management method according to claim 1, characterized in that, The predefined field pattern includes any one or a combination of any of the following: tool permission list, tool parameter pattern, state machine preconditions, and write-back permission list; Accordingly, the step of validating the processing request based on the runtime constraint object and the artificial intelligence input context includes: Verify whether the rule hash carried in the processing request is equal to the rule hash of the runtime constraint object. And / or, verify whether the tool name for processing the request belongs to the tools allowed in the tool allow list; And / or, verify whether the tool parameters for processing the request satisfy the tool parameter pattern. And / or, verify whether the object identifier falls within the permission scope of the caller role. And / or, verify whether the expected read / write fields of the processing request belong to the fields allowed by the write-back allow list. And / or, verify whether the scope of evidence for the processing request exceeds the scope of evidence contained in the artificial intelligence input context. And / or, verify whether the processing request meets the current state machine prerequisites of the target R&D object.
8. The work incident management method according to claim 1, characterized in that, After the processing request is forwarded to the corresponding business service via a proxy, the process further includes: The execution of the processing request is reviewed based on the review items; wherein, the review items include any one or more of the rule hash, state machine preconditions, object association records, and object version number of the target R&D object; The state machine preconditions adopt a restricted syntax, which includes only judgment operations and logical operations on whitelist fields. The judgment operations include any one or a combination of any of the following: equality judgment, inequality judgment, inclusion judgment, and existence judgment. The logical operations include any one or a combination of any of the following: logical AND, logical OR, and logical NOT.
9. The work incident management method according to claim 1, characterized in that, The method further includes: Receive a research and development object correction request sent by the artificial intelligence tool or the automated program; wherein, the research and development object correction request carries a base version number and a research and development object correction draft, and the base version number is the object version number of the target research and development object when the research and development object correction draft is generated; Save the revised draft of the research and development object as a record to be confirmed; Once the revised draft of the research and development object passes the consistency check and receives electronic confirmation status, confirmer identifier, and confirmation time, the revision result of the revised draft of the research and development object is written back to the object data of the target research and development object in the target data source according to the object version number of the target research and development object.
10. The work incident management method according to claim 9, characterized in that, The step of writing the revision result of the revised draft of the research and development object back to the object data of the target research and development object in the target data source based on the object version number of the target research and development object includes: Read the current object data and current object version number of the target R&D object; If the baseline version number is consistent with the current object version number, the correction result is written back to the object data of the target R&D object in the target data source, and the current object version number is incremented. If the base version number is inconsistent with the current object version number, a field-level difference record is generated between the correction result and the current object data so that anomaly handling can be performed based on the field-level difference record.
11. The work incident management method according to claim 9, characterized in that, After writing the revision result of the R&D object revision draft back to the object data of the target R&D object in the target data source based on the object version number of the target R&D object, the method further includes: The hash content is processed according to a normalized serialization method; wherein, the normalized serialization includes any one or a combination of any of the following: field names are sorted in ascending order, arrays are sorted by object identifier, time values are converted to a preset time format and time zones are unified, and null values are represented by a fixed marker. Fields for hash calculation are selected from the content to be hashed based on the set of fields determined by the runtime constraint object; Replace the sensitive fields in the selected fields with the field name, desensitization tag, and desensitized summary of the sensitive fields; Audit records are generated and stored based on the normalized serialized and selected fields and a preset digest algorithm; wherein, the audit record includes any one or a combination of any of the following: the rule hash, the preceding audit record hash, the context hash of the artificial intelligence input context, the request hash of the processing request, the result hash of the execution result corresponding to the processing request, the draft hash of the revised draft of the R&D object, and the write-back result hash.
12. The work incident management method according to claim 11, characterized in that, After generating and storing audit records based on the normalized serialized and selected fields and a preset digest algorithm, the process also includes: Reread the review object; wherein, the review object includes any one or a combination of any of the following: skill version, rule hash, artificial intelligence input context, tool call record, data source verification result, R&D object revision draft, write-back result, and write-back object version; Based on the same normalized serialization method and the same preset digest algorithm used when generating the audit record, the corresponding hash of the reread audit object is recalculated; By comparing the recalculated hash with the hash in the audit record, an abnormal alarm is generated if there are any anomalies. The anomalies include any one or a combination of any hash inconsistency, hash breakage in the previous audit record, and inconsistency between the write-back object version and the audit record.
13. A work event management device based on artificial intelligence, characterized in that, include: The acquisition module is used to acquire object information of the target R&D object, wherein the object information includes object identifier, object type, current R&D stage and caller role; The parsing module is used to read the R&D stage skill rules that match the target R&D object based on the object information, and parse the fields with a predetermined field pattern in the R&D stage skill rules into runtime constraint objects; The generation module is used to generate the rule hash of the runtime constraint object and generate an artificial intelligence input context based on the runtime constraint object; A configuration module is used to configure artificial intelligence tools and automated programs triggered according to R&D process nodes to not have direct read and write permissions to the target data source, wherein the target data source is used to store the object data of the target R&D object; The first receiving module is configured to receive a processing request sent by the artificial intelligence tool or the automation program, wherein the processing request carries the rule hash, the object identifier, and the expected read / write field; The verification module is used to verify the processing request based on the runtime constraint object and the artificial intelligence input context. If the verification fails, the processing request is rejected. If the verification passes, the processing request is forwarded to the business service pointed to by the processing request through a proxy.
14. An electronic device, characterized in that, include: Memory, used to store computer programs; A processor, configured to implement the steps of the AI-based job event management method as described in any one of claims 1 to 12 when executing the computer program.
15. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores a computer program that, when executed by a processor, implements the steps of the artificial intelligence-based job event management method as described in any one of claims 1 to 12.
