A collaborative asset management method, system, and storage medium based on HAS graph architecture.

Abstract

This invention relates to a collaborative asset management method based on HAS graph architecture. S1: High-value subgraphs are extracted through graph traversal, and standardized collaborative recipes are generated through parameter abstraction, privacy desensitization, and role slotting. S2: The project environment is encapsulated as a Project Pack, version relationships are recorded using dependency locking, and sensitive information is replaced through credential remapping to ensure distribution security. S3: When creating a new project based on the Pack, FRK7 environment verification is performed to confirm compatibility, users inject credentials and bind roles, enabling one-click reproduction. S4: Collaborative solutions are evaluated using a multi-dimensional composite scoring system to quantify quality, automation rate, and economic efficiency. The optimal solution is automatically recycled as a new asset, forming a closed loop of knowledge iteration. This invention effectively solves the technical problems of the inability to accumulate collaborative experience, the difficulty in securely reproducing projects across environments, and the inability of solutions to continuously evolve.

Description

Technical Field

[0001] This invention belongs to the field of artificial intelligence collaboration and digital asset management technology, specifically relating to a collaborative asset management method, system and storage medium based on HAS graph architecture. Background Technology

[0002] Currently, with the explosive growth of large language models and multi-agent technologies, human-machine hybrid collaboration has gradually evolved into the mainstream paradigm for handling complex tasks. In high-value scenarios such as financial risk control and medical review, successful collaboration often relies heavily on the meticulous design of human-machine division of labor, graph topology orchestration, and interaction protocols. To support this model, template marketplaces such as Dify or Coze, code-based SOP definitions like MetaGPT and CrewAI, multi-agent orchestration frameworks such as Microsoft AutoGen, and traditional RPA platforms like UiPath have emerged. These mainstream solutions each have their own characteristics at the task execution level; some focus on the reuse of linear workflows, some on standardized processes defined by code, and some on the dynamic orchestration of multiple agents, collectively forming the basic technological ecosystem of current human-machine collaboration systems.

[0003] However, while existing technologies each have their strengths at the execution level, they suffer from fundamental shortcomings in the assetization and accumulation of collaborative experience, cross-environment distribution, and solution evolution. First, collaborative experience cannot be automatically extracted as reusable assets, causing excellent collaborative models to often be lost after the project ends, failing to form structured knowledge accumulation. Second, due to the lack of dependency locking and credential remapping mechanisms, project distribution often stalls due to API key expiration, model version conflicts, or unreachable knowledge bases, making one-click reproduction across environments difficult. Third, existing evaluation systems only focus on the accuracy of model output results, failing to quantify the comprehensive impact of human-machine division of labor, topology, and agency levels on collaborative efficiency. This prevents optimal solutions from automatically flowing back into reusable assets, thus hindering the construction of a continuous evolutionary closed loop of operation, evaluation, and optimization.

[0004] The collaborative asset management technology based on HAS graph architecture proposed in this application presents a level of difficulty far exceeding conventional structural modifications, primarily due to the in-depth analysis of unstructured operational trajectories and the construction of dynamic closed loops. Technical personnel must break through conventional thinking in existing technologies and design an algorithmic system capable of automatically identifying high-value subgraphs from complex, non-linear operational trajectories and accurately executing parameter abstraction, privacy desensitization, and role slotting. This requires the system to possess extremely high semantic understanding and graph computation capabilities. Simultaneously, implementing dependency locking and credential remapping mechanisms requires addressing cross-environment version compatibility and sensitive information isolation issues while ensuring security. Furthermore, constructing a closed-loop evolutionary system based on multi-dimensional composite scoring requires integrating complex logic such as LLMasaJudge evaluation and automated backflow. This poses extremely high technical challenges to the overall system architecture stability, data consistency, and real-time processing capabilities, and cannot be achieved simply by adding more functions. Summary of the Invention

[0005] To address the aforementioned shortcomings in existing technologies, this invention provides a collaborative asset management method based on HAS graph architecture. This method solves the technical problems in complex human-machine collaboration scenarios, such as the inability to automatically extract collaborative experience into standardized assets, the difficulty in safely reproducing projects across environments, and the inability of collaborative solutions to achieve automated evaluation and continuous evolution.

[0006] To solve the above-mentioned technical problems, the present invention adopts the following technical solution:

[0007] One of the objectives of this invention is to provide a collaborative asset management method based on HAS graph architecture, which is used to automatically extract standardized collaborative recipes from human-machine collaboration trajectories, realize safe cross-environment one-click reproduction of project environments, and drive multi-dimensional evaluation and continuous evolution of collaborative solutions.

[0008] To achieve the above objectives, the technical solution of the present invention is as follows:

[0009] A collaborative asset management method based on HAS graph architecture includes the following steps:

[0010] S1. Extract high-value subgraphs from the project's operational trajectory using a graph traversal algorithm, and transform specific data into a general template using parameter abstraction technology. At the same time, remove sensitive information through privacy desensitization processing, and finally generate a collaborative recipe containing role slots.

[0011] S2. Encapsulate the project environment into a Project Pack that includes dependency locking and credential remapping mechanisms. Record the dependencies of models, tools, and skills through a version chain and replace credentials with placeholders to ensure distribution security.

[0012] S3. When creating a new project based on Project Pack, perform FRK7 environment verification to confirm dependency compatibility, replace placeholders with user-input credentials, and bind role slots to specific members.

[0013] S4. Perform a composite evaluation on multiple collaborative solutions, quantify quality, automation rate and economic efficiency through a multi-dimensional evaluation formula, and automatically feed the best solution back as a new skill to form a knowledge iteration closed loop.

[0014] To further optimize the design, the graph traversal algorithm adopts depth-first search and uses heuristic rules to filter high-value subgraphs.

[0015] Further optimization of the design involves using a depth-first search algorithm and heuristic rules to filter high-value subgraphs, specifically by prioritizing based on product quality scores, running frequency, and the proportion of human node response time.

[0016] To further optimize the design, the parameter abstraction adopts regular expression matching technology, replacing file path, date string, and SQL query statement with {input file}, {date}, and {SQL query template}, and recording the input and output contracts.

[0017] Further design optimization involves using an NLP model to identify personal identity information, API keys, and trade secret keywords, and employing a predefined sensitive word library and regular expressions for dynamic replacement to ensure data untraceability.

[0018] The design has been further optimized so that the dependency locking records the dependency relationships of Agent, Tool and Skill through a version linked list.

[0019] Further optimizing the design, the composite scoring formula is as follows:

[0020] S = w1Q + w2(1 T_human / T_total) + w3(V_artifact / C_token);

[0021] Where Q is the product quality score, T_human / T_total is the automation rate, V_artifact / C_token is the economic efficiency, and w1, w2, and w3 are configurable weight coefficients.

[0022] Further design optimization involves generating a new Skill through the asset extraction service and calling the packaging service to generate a Project Pack during the return flow of the optimal solution. This Pack is then marked as a "golden recipe" and published to the public asset repository for direct reuse in subsequent projects.

[0023] The second objective of this invention is to provide a collaborative asset management method based on HAS graph architecture for running on a computer.

[0024] To achieve the above objectives, the technical solution of the present invention is as follows:

[0025] A collaborative asset management system based on HAS graph architecture includes an asset extraction service module, a packaging and distribution service module, a fork and remapping service module, and an evaluation and leaderboard service module.

[0026] The asset extraction service module is configured to extract high-value sub-graphs from the project's operational trajectory and generate Skills through parameter abstraction, privacy desensitization, and role slotting.

[0027] The packaging and distribution service module is configured to: package projects into Project Packs and ensure cross-environment distribution security through dependency locking and credential remapping;

[0028] The Fork and remapping service module is configured to perform FRK7 environment verification, credential injection, and role slot binding to enable one-click project reproduction.

[0029] The evaluation and ranking service module is configured to perform composite scoring on multiple options and automatically revert the winning options to new assets.

[0030] To achieve the above objectives, the technical solution of the present invention is as follows:

[0031] A computer-readable storage medium storing program instructions that, when executed by a processor, are used to implement a collaborative asset management method and optimization design based on a HAS graph architecture as described in one of the objectives of this invention.

[0032] Compared with the prior art, the present invention has the following beneficial effects:

[0033] 1. This invention utilizes core algorithms such as automated subgraph recognition, parameter abstraction, privacy anonymization, and role slotting to automatically transform successful human-machine collaboration trajectories into standardized collaboration recipes, or Skill assets. This technology allows enterprises to directly reuse proven best practices without designing processes from scratch, effectively avoiding the pain points of personnel turnover or project termination leading to the loss of experience and knowledge. It achieves the structured accumulation and efficient reuse of collaborative experience.

[0034] 2. This invention utilizes dependency locking and credential remapping mechanisms to encapsulate a complete project into an independently distributable project package. When the recipient forks the project, the system automatically performs FRK7 environment verification and guides the user to configure the necessary credential information. This mechanism ensures that the project can run out of the box in different environments without the need to manually fix version conflicts or supplement missing credentials, greatly improving the efficiency and security of cross-organizational distribution of collaborative projects.

[0035] 3. This invention constructs a multi-dimensional evaluation system based on collaboration method cards and composite scoring formulas. It comprehensively considers key indicators such as product quality, automation rate, and cost efficiency to accurately rank multiple collaboration solutions for the same task. The best-ranked solution is automatically recycled into a new Skill or Pack and published to the public asset repository. This closed-loop mechanism drives the system's knowledge base to continuously absorb best practices, achieving adaptive evolution from operation and evaluation to optimization, ensuring a continuous output of high-value collaboration solutions.

[0036] 4. This invention automatically removes sensitive credentials and replaces them with placeholders during the packaging stage. After distribution, the recipient can independently configure these placeholders, cutting off the risk of sensitive information leakage at the source. Simultaneously, by constructing an artifact version chain and Provenance traceability fields, the entire process is audited, ensuring that every collaboration is traceable and auditable. This systematic set of safeguards fully meets the stringent requirements of enterprises regarding data privacy and compliance, providing a solid security foundation for large-scale human-machine collaboration. Attached Figure Description

[0037] Figure 1 This invention provides a system architecture diagram for a collaborative asset management method based on a HAS graph architecture.

[0038] Figure 2 This invention provides a flowchart of the automated skill extraction process based on execution trajectory in a collaborative asset management method based on HAS graph architecture.

[0039] Figure 3 This invention provides a flowchart of ProjectPack encapsulation and dependency locking in a collaborative asset management method based on HAS graph architecture.

[0040] Figure 4 This invention provides a flowchart of the ProjectPack Fork and FR-K7 verification process in a collaborative asset management method based on HAS graph architecture.

[0041] Figure 5 This invention provides a flowchart of a collaborative evolutionary closed-loop process based on a score S in a collaborative asset management method based on a HAS graph architecture.

[0042] Figure 6 This invention provides a schematic diagram of the product version chain and traceability in a collaborative asset management method based on HAS graph architecture. Detailed Implementation

[0043] The present invention will be further described below with reference to specific embodiments. It should be understood that these embodiments are for illustrative purposes only and are not intended to limit the scope of the invention. Furthermore, it should be understood that after reading the teachings of this invention, those skilled in the art can make various alterations or modifications to the invention, and these equivalent forms also fall within the scope defined by the appended claims.

[0044] This application provides a collaborative asset management system and method based on HAS graph architecture. The system uses "Project" as the basic asset unit and achieves the structured accumulation, secure distribution, and continuous evolution of human-computer collaboration experience through five interrelated and independently operable technical modules. The following detailed description follows the order of overall system architecture → core modules (including inter-module call relationships) → key data structures → algorithm flow → exception handling.

[0045] 4.1 System Overall Architecture

[0046] 4.1.1 The system of this invention is divided into three layers: front-end interaction layer, business logic layer, and data storage layer.

[0047] Front-end interaction layer: Provides a visual collaboration diagram editor, task dashboard, asset library management interface, and leaderboard display page. Users interact with the system through a browser or client to initiate operations such as project creation, skill extraction, pack packaging, and forking.

[0048] Business logic layer: Contains the following core service modules (which communicate with each other via internal APIs or message bus):

[0049] Skill Extractor: Responsible for extracting skills from the running records.

[0050] Pack Builder: Responsible for packaging projects into Project Packs.

[0051] Fork and Remapping Service (Fork Manager): Responsible for creating new projects based on the Pack and handling credential / role binding.

[0052] Evaluation and Ranking Service (Evaluator): Responsible for scoring and ranking multiple solutions under standardized tasks.

[0053] Scheduling engine: responsible for task routing and execution (this patent can call its interface to obtain the running trajectory).

[0054] Data storage layer: including graph databases (such as Neo4j, which stores HAS Graph topologies: Project, Node, Edge) and relational databases (such as PostgreSQL, which stores business tables such as running instances, artifacts, Skills, Packs, leaderboards, etc.).

[0055] 4.1.2 Inter-module connection relationships

[0056] After the scheduling engine completes a project run, it writes the run trajectory (including graph topology, artifacts, and logs) to the database and triggers the asset extraction service (if configured for automatic extraction).

[0057] The Skills generated by the asset extraction service are stored in the Skill library, and the packaging and distribution service can be triggered to package the original project into a Pack.

[0058] The Pack generated by the packaging and distribution service is stored in the Pack library. When a user initiates a Fork request through the front end, the Fork and remapping service reads the Pack and instantiates a new project.

[0059] The evaluation and ranking service reads the artifacts and execution records submitted by multiple projects, and calls the asset extraction service and packaging and distribution service to feed back the optimal solution as a new Skill / Pack. Specifically, this includes the following:

[0060] 4.1 System Overall Architecture

[0061] 4.1.1 The system of this invention is divided into three layers: front-end interaction layer, business logic layer, and data storage layer.

[0062] Front-end interaction layer: Provides a visual collaboration diagram editor, task dashboard, asset library management interface, and leaderboard display page. Users interact with the system through a browser or client to initiate operations such as project creation, skill extraction, pack packaging, and forking.

[0063] Business logic layer: Contains the following core service modules (which communicate with each other via internal APIs or message bus):

[0064] Skill Extractor: Responsible for extracting skills from the running records.

[0065] Pack Builder: Responsible for packaging projects into Project Packs.

[0066] Fork and Remapping Service (Fork Manager): Responsible for creating new projects based on the Pack and handling credential / role binding.

[0067] Evaluation and Ranking Service (Evaluator): Responsible for scoring and ranking multiple solutions under standardized tasks.

[0068] Scheduling engine: responsible for task routing and execution (this patent can call its interface to obtain the running trajectory).

[0069] Data storage layer: including graph databases (such as Neo4j, which stores HAS Graph topologies: Project, Node, Edge) and relational databases (such as PostgreSQL, which stores business tables such as running instances, artifacts, Skills, Packs, leaderboards, etc.).

[0070] 4.1.2 Inter-module connection relationships

[0071] After the scheduling engine completes a project run, it writes the run trajectory (including graph topology, artifacts, and logs) to the database and triggers the asset extraction service (if configured for automatic extraction).

[0072] The Skills generated by the asset extraction service are stored in the Skill library, and the packaging and distribution service can be triggered to package the original project into a Pack.

[0073] The Pack generated by the packaging and distribution service is stored in the Pack library. When a user initiates a Fork request through the front end, the Fork and remapping service reads the Pack and instantiates a new project.

[0074] The evaluation and ranking service reads the artifacts and running records submitted by multiple projects, calls the asset extraction service and the packaging and distribution service to feed back the optimal solution as a new Skill / Pack.

[0075] 4.2 Automated Extraction and Role Slotting of Collaborative Recipes (Skills)

[0076] 4.2.1 Functional Overview

[0077] It addresses the problem of "how to automatically extract reusable collaboration patterns from a successful project execution." It segments high-value subgraphs from the execution trajectory, and through parameter abstraction, privacy anonymization, and role slotting, generates standardized Skill (collaboration recipe) assets.

[0078] 4.2.2 Connection with other modules

[0079] Input source: After the scheduling engine completes execution, it writes the Run (running instance) and its associated Artifact to the database. This module retrieves the complete trajectory by querying the graph database and relational database using the Run ID.

[0080] Output destination: The generated Skill is stored in the Skill library (relational database), and optionally triggers the packaging and distribution service or the evaluation and leaderboard service (such as returning the winning solution as a Skill).

[0081] 4.2.3 Detailed Steps

[0082] (1) Running trajectory scanning

[0083] The system calls the Run Inspector module to read the following data for the specified Run:

[0084] The HAS Graph topology (nodes, edges, activation conditions) corresponding to this Run in the graph database.

[0085] All artifacts generated by this Run in the relational database (including quality scores and version chains).

[0086] The execution log records the number of C / F / C (clarification / feedback / control) channel triggers and response times.

[0087] (2) Identify candidate subgraphs

[0088] Enumerate all connected subgraphs using graph traversal algorithms (such as depth-first search) and then filter them based on heuristic rules:

[0089] Quality First: Select the sub-image with the highest final Artifact quality score (by LLM-as-a-Judge or human evaluation).

[0090] Frequency priority: If the same project is run multiple times, select the subgraph that appears repeatedly in multiple runs.

[0091] Minimal human intervention: Select subgraphs where the percentage of human node response time is below a threshold (e.g., 30%).

[0092] (3) Parameter abstraction

[0093] Iterate through the attributes of each node in the subgraph, identifying parameterizable fields (such as file paths, numeric thresholds, date strings, and database query statements). Replacement rules:

[0094] The regular expression `\d{4}-\d{2}-\d{2}` replaces `{date}`.

[0095] Match .*\.xlsx and replace with {input file}.

[0096] Replace SELECT.*FROM.* with {SQL query template}.

[0097] The replaced value is stored in the inputContract / outputContract fields as the input / output contracts for Skill.

[0098] (4) Privacy desensitization

[0099] Use the compliance scanning engine to detect and remove the following sensitive content:

[0100] Personal identification information (name, ID number, mobile phone number) – regular expression matching or NLP recognition.

[0101] API Key, Password, Internal IP Address — Predefined Sensitive Word Database.

[0102] Trade secret keywords (such as "contract amount of 1 million") - replace with {amount}.

[0103] The de-identified subgraph no longer contains any data traceable back to the original business.

[0104] (5) Role Slotting

[0105] Identify the Human node in the subgraph and execute:

[0106] Remove the specific member ID (e.g., user_zhangsan → {role slot}).

[0107] Extract the functional description of this node from the original project (e.g., "responsible for reviewing financial reports").

[0108] Retain the C / F / C channel permissions configured for this node (e.g., allow receiving Feedback channel messages).

[0109] Generate roleSlots objects, where the key is the role name and the value is the desired number.

[0110] For Agent nodes, capture their Profile snapshot (model name, version, temperature, tool list) and store it in agentConfig and toolBindings.

[0111] (6) Construct Skill JSON and store it

[0112] Assemble the Skill object according to the JSON structure given in Section 4.4, generate a unique skillId, and save it to the Skill table in the relational database. Also record information such as the source Run ID, creation time, and publisher. If automatic publishing is configured, set the status to "released" directly; otherwise, set it to "draft" for manual review.

[0113] 4.2.4 Pseudocode (Core Logic)

[0114] text

[0115] function extractSkill(runId):

[0116] run = loadRun(runId)

[0117] graph = run.graphSnapshot

[0118] candidateSubgraphs = findHighValueSubgraphs(graph, run.artifacts)

[0119] for subgraph in candidateSubgraphs:

[0120] subgraph = abstractParameters(subgraph)

[0121] subgraph = removeSensitiveInfo(subgraph)

[0122] subgraph = roleSlotting(subgraph)

[0123] skillJson = buildSkillJson(subgraph)

[0124] skillId = saveSkill(skillJson, sourceRun=runId)

[0125] if autoPublishEnabled:

[0126] publishSkill(skillId)

[0127] return

[0128] 4.2.5 Handling of Exceptions and Timeouts

[0129] If the Run data is incomplete (e.g., missing product), an error is logged and the extraction is terminated, returning a failure report.

[0130] The extraction process is set as an asynchronous task with a timeout of 5 minutes. It will automatically interrupt and notify the user after the timeout.

[0131] 4.3 Project Pack Encapsulation and Dependency Locking Module

[0132] 4.3.1 Functional Overview

[0133] This module encapsulates the complete project environment (graph topology, role definitions, tool bindings, prompt word templates, dependency versions, etc.) into an independently distributable, versioned Project Pack. Dependency locking prevents environment drift, and credential anonymization ensures security.

[0134] 4.3.2 Connection with other modules

[0135] Input source: The front-end user or evaluation service triggers the packaging request, and the Project ID is passed in.

[0136] Output destination: The generated Pack is stored in the Pack library, and a download link is provided. The Fork module will read this Pack.

[0137] 4.3.3 Detailed Steps

[0138] (1) Copy project configuration

[0139] Reading items from the database:

[0140] Graph topology (nodes, edges, activation conditions).

[0141] Role definition (functionality and C / F / C permissions of each Human node).

[0142] Tool binding (a list of tools and parameters bound to each Agent node).

[0143] Prompt templates (system prompt and user prompt for all agents).

[0144] This content is deep copied into the projectTemplate object.

[0145] (2) Lock the dependency versions

[0146] Iterate through all items in the project:

[0147] Agent: Record its Profile version number (e.g., gpt-4-turbo-2024-04-09).

[0148] Tools: Record the API version or code repository commit hash of the tool (e.g., data_tool@v1.2.3).

[0149] Skill: Records the skillId and version number of the referenced skill.

[0150] Generate a dependencyLock dictionary.

[0151] (3) Voucher desensitization mapping

[0152] Scan all fields in the projectTemplate to identify key-value pairs (such as api_key, password, secret, token) that match the credential pattern. For each match:

[0153] Replace the original value with the placeholder {{credential}. <key>}}.

[0154] Record in credentialMap <key>→ {{credential. <key>The mapping of}}.

[0155] The original voucher is not written into the Pack; only a placeholder is retained.

[0156] (4) Generate a list and compress it

[0157] Construct a Pack JSON containing packId, name, projectTemplate, dependencyLock, credentialMap, createdBy, and createdAt. Package the JSON along with project-related resource files (such as prompt text files and script code) into a ZIP file, placing pack.json in the root directory.

[0158] (5) Storage and publishing

[0159] Store the Pack metadata in the ProjectPack table of the relational database, save the ZIP file to object storage (or local file system), and return the Pack ID and download link.

[0160] 4.3.4 Pseudocode

[0161] text

[0162] function createProjectPack(projectId):

[0163] project = loadProject(projectId)

[0164] template = extractProjectTemplate(project)

[0165] lock = { agents: {}, tools: {}, skills: {}}

[0166] for agent in project.agents: lock.agents[agent.name] = agent.version

[0167] for tool in project.tools: lock.tools[tool.name] = tool.version

[0168] for skill in project.skills: lock.skills[skill.id] = skill.version

[0169] credMap = {}

[0170] for (key, value) in project.credentials:

[0171] placeholder = "{{credential." + key + "}}"

[0172] credMap[key] = placeholder

[0173] replaceInTemplate(template, key, placeholder)

[0174] packJson = {

[0175] packId: genId(),

[0176] projectTemplate: template,

[0177] dependencyLock: lock,

[0178] credentialMap: credMap,

[0179] createdBy: currentUser(),

[0180] createdAt: now()

[0181] }

[0182] zipPath = createZip(packJson, template.assets)

[0183] savePackRecord(packJson, zipPath)

[0184] return packJson.packId

[0185] 4.3.5 Handling of Exceptions and Timeouts

[0186] If the dependent version cannot be obtained (e.g., Agent Profile has been deleted), the packaging will fail and an error message will be displayed.

[0187] Package it as an asynchronous task with a 10-minute timeout. After the timeout, it will automatically roll back and clean up temporary files.

[0188] 4.4 Cross-environment Fork and credential remapping (including FR-K7 verification)

[0189] 4.4.1 Functional Overview

[0190] It allows users to create a new, immediately runnable project in their workspace based on an existing Project Pack. It performs dependency environment checks, credential injection, and role slot binding, enabling "one-click reproduction".

[0191] 4.4.2 Connection with other modules

[0192] Input source: Front-end users select a Pack, fill in the credentials form, and assign roles.

[0193] Output destination: Generate a new Project instance and notify the scheduling engine that the new project is ready.

[0194] Dependent modules: Call the Pack reading interface of the packaging module and call the Skill library to query the role slot definition.

[0195] 4.4.3 Detailed Steps

[0196] (1) Trigger Fork and load Pack

[0197] When a user clicks "Fork" on the front end and passes in the packId, the system loads the corresponding Pack metadata and ZIP package from the database and object storage.

[0198] (2) FR-K7 Dependency Lock Check

[0199] Read the dependencyLock in the Pack and check the target environment item by item:

[0200] Model check: Call the LLM gateway to confirm whether the current workspace has permission to access the specified model version (e.g., gpt-4-turbo). If not, prompt for an upgrade or permission request.

[0201] Tool check: Check whether the required tools are installed and whether the versions are compatible (compare semantic version numbers).

[0202] Skill Check: Confirms if the specified version of the skill exists in the skill library. If it is missing, it attempts to download it from the public repository.

[0203] If any condition is not met, the system blocks the Fork and returns a list of the missing items.

[0204] (3) Credential remapping declaration

[0205] The system displays all placeholders (such as {{credential.DB_PASSWORD}}) in the credentialMap to the front end, prompting the user to fill in the actual values. After the user enters the information, the front end encrypts and transmits it to the back end.

[0206] (4) Character slot binding

[0207] After reading the roleSlots of all Skills in the Pack, merging and deduplicating them, the system requires the user to assign a local member to each abstract role slot (e.g., binding {Financial Auditor} to user_lisi). If a role slot is not bound to a human, it can be retained as an Agent role.

[0208] (5) Instantiate a new project

[0209] Create a new HAS Graph in the graph database based on the projectTemplate (cloning all nodes and edges).

[0210] Replace all placeholders {{credential.xxx}} with the actual credential value provided by the user (encrypted and stored in the database).

[0211] Map role slots to specific node attributes (such as the assigned_user_id field of the Human node).

[0212] The dependencyLock locks the versions of the Agent and tools (if the versions do not match exactly but are compatible, a warning is logged).

[0213] (6) Consistency confirmation and activation

[0214] Perform a quick smoke test (e.g., test tool connectivity, whether the model API returns correctly). Once successful, set the new project status to active and return the new project ID for the frontend to navigate to.

[0215] 4.4.4 Pseudocode

[0216] text

[0217] function forkProject(packId, userCredentials, roleAssignments):

[0218] pack = loadPack(packId)

[0219] / / FR-K7 verification

[0220] for each dep in pack.dependencyLock:

[0221] if not checkAvailability(dep):

[0222] throw IncompatibleEnvironmentError(dep)

[0223] newProject = cloneProjectTemplate(pack.projectTemplate)

[0224] / / Credential Replacement

[0225] for (key, placeholder) in pack.credentialMap:

[0226] if key not in userCredentials:

[0227] throw MissingCredentialError(key)

[0228] replacePlaceholder(newProject, placeholder, userCredentials[key])

[0229] / / Character binding

[0230] for (roleSlot, memberId) in roleAssignments:

[0231] assignRoleToProject(newProject, roleSlot, memberId)

[0232] saveProject(newProject)

[0233] return newProject.id

[0234] 4.4.5 Exception and Timeout Handling

[0235] If credentials are missing, a 400 error is returned, requiring the user to provide them.

[0236] When dependency checks fail, a "force continue" option can be provided (but the run may fail), and an audit log will be logged.

[0237] The fork process has an overall timeout of 3 minutes, after which the created database records are rolled back.

[0238] 4.5 Closed-loop evolution based on collaborative method cards and composite scoring

[0239] 4.5.1 Functional Overview

[0240] Around a standardized task, multiple collaborative solutions submitted by users are collected, a leaderboard is generated through multi-dimensional evaluation, and the best solution is automatically fed back and transformed into a new skill or pack, driving the platform to continuously evolve.

[0241] 4.5.2 Connection with other modules

[0242] Input source: Multiple projects submitted by front-end users (each project has been completed and generated an artifact).

[0243] Call other modules: Call the asset extraction module and the packaging module to backflow the winning solution.

[0244] Output destination: Generate a leaderboard to display to users and write the new Skill / Pack to the asset library.

[0245] 4.5.3 Detailed Steps

[0246] (1) Standardized Task Release

[0247] The administrator creates a Task record, which includes:

[0248] Task description, input dataset (or API endpoint).

[0249] Expected output format (e.g., PDF report, JSON data).

[0250] Evaluation weights: w1 (quality), w2 (automation rate), w3 (cost efficiency), all of which default to 1 / 3.

[0251]

[0252] in:

[0253] Q: Product quality score (can be evaluated by LLM-as-a-Judge or human experts, ranging from 0-100).

[0254] Thuman / Ttotal: The proportion of total response time of human nodes on the C / F / C channels to total running time. The smaller the value, the higher the automation rate.

[0255] Vartifact / Ctoken: The ratio of output value (such as the number of words in the product, the number of lines of code, and business metrics) to the cost of token consumption, which measures economic efficiency.

[0256] w1, w2, w3: Configurable weighting coefficients, each set to 1 / 3 by default.

[0257] Scoring threshold (e.g., 80 points; if the score is exceeded, the score will be automatically returned).

[0258] (2) Project submission and collaboration method card generation

[0259] When a user creates and runs a project based on this Task, the system automatically records the results.

[0260] HAS Graph Topology (Node Type Distribution, Edge Type Statistics);

[0261] Human-machine role ratio (number of agents / number of humans);

[0262] C / F / C channel trigger count and density (the proportion of each channel in the total interaction);

[0263] Human agency levels (A1-A5):

[0264] A1 (Fully Automatic): AI completes tasks independently, with humans only monitoring;

[0265] A5 (Human-Driven): Each step requires human instructions; the AI ​​merely executes them.

[0266] This information is organized into a Methodology Card, which is stored together with the results of the operation.

[0267] (3) Multidimensional performance evaluation

[0268] The evaluation engine calculates three dimensions for each submitted solution:

[0269] Product quality Q: Use LLM-as-a-Judge (or human expert) to score the product, ranging from 0 to 100. For example, have GPT-4 score the product from 1 to 5 stars according to the task requirements and then normalize it.

[0270] Automation rate: 1 - (T_human / T_total), where T_human is the total response time of all Human nodes on the C / F / C channel, and T_total is the total runtime from project startup to final output generation.

[0271] Economic efficiency: V_artifact / C_token, where V_artifact is the value of the artifact (which can be defined as the number of artifact characters, lines of code, or business metrics), and C_token is the total number of tokens consumed in this run (accumulated by LLM calls).

[0272] Overall score: S = w1*Q + w2*(1 - T_human / T_total) + w3*(V_artifact / C_token).

[0273] (4) Generate leaderboard

[0274] Sort all solutions in descending order of S, and select the top N (N is configurable). The leaderboard displays the solution name, submitter, scores for each item, and total score, and provides links to view the method cards.

[0275] (5) Return of winning solutions

[0276] If the S value of the first-ranked solution is greater than or equal to the threshold, the system automatically:

[0277] Call the extractSkill(runId) function of the asset extraction module (Section 4.2) to generate a new Skill from the core subgraph of the scheme.

[0278] Call the createProjectPack(projectId) method of the packaging module (Section 4.3) to package the entire project into a new pack.

[0279] The generated Skill and Pack are labeled "Gold Recipe", published to the public asset library, and highlighted on the leaderboard page.

[0280] 4.5.4 Pseudocode

[0281] text

[0282] function evaluateAndEvolve(taskId):

[0283] submissions = getSubmissionsByTask(taskId)

[0284] scores = []

[0285] for sub in submissions:

[0286] Q = autoEvaluateQuality(sub.artifact)

[0287] T_ratio = sub.humanResponseTime / sub.totalRunTime

[0288] V_per_token = sub.artifactValue / sub.tokenCost

[0289] S = w1*Q + w2*(1 - T_ratio) + w3*V_per_token

[0290] scores.append({ submissionId: sub.id, score: S})

[0291] ranking = sortByScore(scores, descending)

[0292] saveLeaderboard(taskId, ranking)

[0293] top = ranking[0]

[0294] if top.score >= threshold:

[0295] newSkillId = extractSkill(top.submission.runId)

[0296] newPackId = createProjectPack(top.submission.projectId)

[0297] markAsGoldRecipe(newSkillId, newPackId)

[0298] return ranking

[0299] 4.5.5 Exception and Timeout Handling

[0300] If the automatic assessment service is unavailable, it will be downgraded to manual scoring (the system will send the review task to the designated expert).

[0301] The evaluation task is executed asynchronously with a timeout of 30 minutes. After the timeout, incomplete solutions are marked as "evaluation failed".

[0302] If the generated Skill / Pack is highly similar to an existing asset during the reflow process, version merging can be performed (by adding a parentId chain).

[0303] 4.6 Artifact-Centric Versioning and Implicit Activation Signals

[0304] 4.6.1 Functional Overview

[0305] This module establishes a complete traceability chain across all artifacts and versions, and supports automatic triggering of downstream nodes based on artifact status changes, enhancing the flexibility of the collaboration process.

[0306] 4.6.2 Connection with other modules

[0307] Source of traceable data: After executing each node, the scheduling engine generates an Artifact record and calls the traceability storage interface of this module.

[0308] Signal Trigger: When the Artifact status changes to "Approved", this module sends an event to the scheduling engine, which then activates downstream nodes waiting for the artifact.

[0309] 4.6.3 Detailed Steps

[0310] (1) Establishment of product version chain

[0311] Each time a node generates a new Artifact, the system automatically:

[0312] Query the last Artifact ID generated for this node (same node, same project).

[0313] Set parentArtifactId to the previous version ID to form a singly linked list.

[0314] Generate a proofance object, which contains:

[0315] generated_by_node_id: The ID of the node that generated this artifact.

[0316] run_id: The ID of the running instance to which it belongs.

[0317] approved_by_human_ids: A list of human IDs who approved the product through the C / F / C pathway.

[0318] agency_level: The level of human agency at that time (A1-A5).

[0319] tool_versions: Snapshot of the tool / model version used.

[0320] (2) Product-driven execution signal

[0321] Define implicit triggering rules: When the status field of an Artifact changes from pending to approved or ready, the system publishes an ArtifactReadyEvent via a message queue. The event payload includes:

[0322] artifactId

[0323] producingNodeId

[0324] targetEdgeIds (finds all edges in the graph topology that originate from this node)

[0325] The scheduling engine listens for this event. For each edge, if the edge's activation condition is met (such as always or conditional conditions being true), the downstream node is marked as executable, and a corresponding Task record is generated.

[0326] (3) Source tracing query interface

[0327] Provides a REST API:

[0328] GET / api / artifacts / {artifactId} / lineage: Returns a list of all artifacts from the first version to the current version, along with proof information.

[0329] GET / api / artifacts / {artifactId} / provenance: Returns only the current version of the proof.

[0330] 4.6.4 Exception Handling

[0331] If event publishing fails (e.g., message queue is unavailable), the system starts a timed compensation task: every 5 minutes, it scans for Artifacts with an approved status but not activated downstream, and resends the event.

[0332] Version chain writes use database transactions to ensure that the parentArtifactId reference is valid.

[0333] 4.7 Data Storage and Version Management

[0334] 4.7.1 Storage Scheme

[0335] Graph database (Neo4j): Stores HAS Graph topology, including:

[0336] Project node (attributes: projectId, name, status).

[0337] Node (attributes: nodeId, type, role, configPointer).

[0338] Edge Relationship (Attributes: edgeId, activationType, conditionExpression).

[0339] Relational database (PostgreSQL): Stores business tables:

[0340] Run (Run Instance)

[0341] Task

[0342] Artifact (product, containing a proof JSON field)

[0343] Skill (including topology JSON, roleSlots JSON, etc.)

[0344] ProjectPack (project package, including projectTemplate JSON, dependencyLock JSON, and credentialMap JSON)

[0345] Evaluation (Record of Evaluation)

[0346] Leaderboard (Leaderboard Snapshot)

[0347] 4.7.2 Description of Core Data Model Fields

[0348]

[0349] 4.7.2.1 Table 1 - Description of Entity Relationships in the Core Data Model

[0350]

[0351] Version chain implementation details 4.7.3

[0352] When updating a skill: copy the original record, modify the fields, set parentId to the original skillId, and increment version.

[0353] When an Artifact is updated: Same as above, linked via parentArtifactId.

[0354] Query history: Use recursive CTE (relational database) or traverse the linked list.

[0355] 4.7.4 Transactions and Consistency

[0356] All write operations (creating projects, generating artifacts, saving skills, etc.) are encapsulated within database transactions. If an operation fails, the entire operation is rolled back. The database is backed up regularly (daily full backup + incremental backup).

[0357] 4.8 Interfaces and Security Modules

[0358] 4.8.1 REST API Endpoint Example

[0359]

[0360] 4.8.2 Safety Measures

[0361] Authentication: JWT (JSON Web Token), valid for 2 hours, refreshable.

[0362] Authorization: Role-based access control (RBAC). Roles include: ProjectOwner (can package and extract), OrganAdmin (can publish global skills), and Viewer (read-only).

[0363] Credential encryption: User credentials (such as API keys) stored in the database are encrypted using AES-256-GCM, and the key is kept by the Key Management Service (KMS).

[0364] Audit logs: Record all POST, PUT, and DELETE operations, including the operator, time, request summary, and response status. Logs are stored in a separate table and retained for 180 days.

[0365] 4.8.3 Exception Response Format

[0366] json

[0367] {

[0368] "error": "MissingCredential",

[0369] "message": "Credential 'DB_PASSWORD' is required but not provided.",

[0370] "status": 400

[0371] }

[0372] 4.9 Implementation and Deployment

[0373] Containerization: All services are packaged as Docker images, orchestrated using Kubernetes, and support autoscaling.

[0374] Database: Neo4j cluster (3 core nodes + replicas), PostgreSQL master-slave replication.

[0375] Message Queues: RabbitMQ is used for asynchronous tasks (Skill extraction, packaging, and evaluation).

[0376] Monitoring: Prometheus collects metrics (API latency, task queue length), Grafana provides visualization; ELK collects logs.

[0377] CI / CD: GitLab CI automates testing, building, and deployment, supporting blue-green deployments.

[0378] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention and are not intended to limit it. Although the present invention has been described in detail with reference to preferred embodiments, those skilled in the art should understand that modifications can be made to the technical solutions of the present invention without departing from the spirit and scope of the present invention, and all such modifications should be covered within the scope of the claims of the present invention.< / key> < / key> < / key>

Claims

1. A collaborative asset management method based on HAS graph architecture, characterized in that, Includes the following steps: S1. Extract high-value subgraphs from the project's operational trajectory using a graph traversal algorithm, and transform specific data into a general template using parameter abstraction technology. At the same time, remove sensitive information through privacy desensitization processing, and finally generate a collaborative recipe containing role slots. S2. Encapsulate the project environment into a Project Pack that includes dependency locking and credential remapping mechanisms. Record the dependencies of models, tools, and skills through a version chain and replace credentials with placeholders to ensure distribution security. S3. When creating a new project based on Project Pack, perform FRK7 environment verification to confirm dependency compatibility, replace placeholders with user-input credentials, and bind role slots to specific members. S4. Perform a composite evaluation on multiple collaborative solutions, quantify quality, automation rate and economic efficiency through a multi-dimensional evaluation formula, and automatically feed the best solution back as a new skill to form a knowledge iteration closed loop.

2. The collaborative asset management method based on HAS graph architecture as described in claim 1, characterized in that: The graph traversal algorithm employs depth-first search and uses heuristic rules to filter high-value subgraphs.

3. The collaborative asset management method based on HAS graph architecture as described in claim 2, characterized in that, The graph traversal algorithm employs depth-first search and uses heuristic rules to filter high-value subgraphs, specifically including prioritizing based on product quality scores, running frequency, and the proportion of human node response time.

4. The collaborative asset management method based on HAS graph architecture as described in claim 3, characterized in that: The parameter abstraction uses regular expression matching technology to replace file paths, date strings, and SQL query statements with {input file}, {date}, and {SQL query template}, and records the input and output contracts.

5. The collaborative asset management method based on HAS graph architecture as described in claim 4, characterized in that: The privacy desensitization process uses an NLP model to identify personal identity information, API keys, and trade secret keywords, and employs a predefined sensitive word library and regular expressions for dynamic replacement to ensure data untraceability.

6. The collaborative asset management method based on HAS graph architecture as described in claim 5, characterized in that: The dependency locking uses a version list to record the dependency relationships of Agent, tool, and Skill.

7. The collaborative asset management method based on HAS graph architecture as described in claim 6, characterized in that, The composite scoring formula is as follows: ； Where Q is the product quality score, Thuman / Ttotal is the automation rate, Vartifact / Ctoken is the economic efficiency, and w1, w2, and w3 are configurable weighting coefficients.

8. The collaborative asset management method based on HAS graph architecture as described in claim 7, characterized in that: When the optimal solution is reverted, a new Skill is generated through the asset extraction service, and a Project Pack is generated by calling the packaging service. At the same time, it is marked as a golden recipe and published to the public asset library for direct reuse in subsequent projects.

9. A collaborative asset management system based on HAS graph architecture, characterized in that, It includes asset extraction service module, packaging and distribution service module, Fork and remapping service module, and evaluation and ranking service module. The asset extraction service module is configured to extract high-value sub-graphs from the project's operational trajectory and generate Skills through parameter abstraction, privacy desensitization, and role slotting. The packaging and distribution service module is configured to: package projects into Project Packs and ensure cross-environment distribution security through dependency locking and credential remapping; The Fork and remapping service module is configured to perform FRK7 environment verification, credential injection, and role slot binding to enable one-click project reproduction. The evaluation and ranking service module is configured to perform composite scoring on multiple options and automatically revert the winning options to new assets.

10. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores program instructions that, when executed by a processor, implement the method as described in any one of claims 1 to 8.

Images