A method, system, electronic device, and storage medium for intelligent collaborative creation in film and television projects based on staged context snapshots and a closed loop of multi-source knowledge assets.

By adopting an intelligent collaborative creation method for film and television projects based on phased context snapshots and multi-source knowledge asset closed loops, the problems of disconnect between artificial intelligence dialogue and project phases and fragmentation of knowledge assets in film and television project creation are solved, and the traceability of generated results and closed-loop synchronization of task delivery are achieved.

CN123118043APending Publication Date: 2026-11-17BEIJING EMBODIED NARRATIVE TECHNOLOGY CO LTD
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN202611306024.9
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Filing Date
2026-08-26
Publication Date
2026-11-17

AI Technical Summary

Technical Problem

In existing film and television project creation systems, AI dialogue is disconnected from project phases, knowledge assets are separated from generated results, project memory lacks stable version control, context assembly relies on manual copying, task delivery and material storage lack a unified link, and multi-terminal collaboration and synchronization are difficult to carry out in sequence.

Method used

A collaborative intelligent creation method for film and television projects is adopted, based on phased context snapshots and a closed loop of multi-source knowledge assets. The method uses projects, phases, and sessions as unified state entry points and organizes the AI ​​request context, knowledge assets, generated results, task delivery, and multi-terminal synchronization into a traceable closed-loop processing link. It utilizes steps such as server-side phase model capability limitation, AI request context assembly, generated result assetization, dialogue incremental task generation, and task delivery into the database.

Benefits of technology

It achieves a clear organization of model capabilities, task types, and permission boundaries, reduces omissions caused by manually splicing context, enhances the traceability of generated results, reduces the probability of repeatedly creating tasks, and forms a traceable closed loop of task submission results and material assets.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN123118043A_ABST
    Figure CN123118043A_ABST
Patent Text Reader

Abstract

This invention discloses a method, system, electronic device, and storage medium for intelligent collaborative creation of film and television projects based on staged context snapshots and a closed loop of multi-source knowledge assets. The method receives project, user, stage, and session identifiers; after verifying permissions, it generates a server-side workspace snapshot containing project metadata, session messages, tasks, knowledge assets, stage model capabilities, and event versions; it defines the capabilities of the artificial intelligence model according to the stage; it assembles project memory, session working memory, knowledge references, and structured instructions into an artificial intelligence request context; it saves the artificial intelligence generation results as traceable project assets; it extracts and deduplicates task cards from newly added dialogue message windows; it generates material assets and delivery records upon task delivery; and it achieves multi-terminal synchronization and offline playback through incrementing event sequence numbers. This invention can reduce context omissions and duplicate saving, and improve the consistency and traceability of generation results, task delivery, and collaborative status.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] This invention relates to the fields of digital media creation, film and television project collaboration, generative artificial intelligence, knowledge asset management, task flow management and real-time data synchronization, and in particular to a method, system, electronic device and storage medium for intelligent creation collaboration of film and television projects based on staged context snapshots and multi-source knowledge asset closed loop. Background Technology

[0002] Film and television projects typically involve multiple stages, including script development, art direction, storyboarding, video production, delivery review, and team collaboration. With the development of large language models, image generation models, and video generation models, creators can leverage artificial intelligence to generate text, images, or videos, and can also use knowledge bases to store project information and reference materials.

[0003] However, existing creative methods often scatter project materials, team discussions, generated results, task assignments, and interim deliverables across different systems. Each time a creator initiates an AI request, they must manually search for information, piece together context, select a model, save the results, and then transfer them to the task or resource system. This approach easily leads to problems such as missing context, version inconsistencies, difficulty in tracing results, duplicate saving, and difficulty in closing the task loop.

[0004] Furthermore, existing systems typically only cover a single stage, such as providing only dialogue generation, only knowledge retrieval, only material storage, or only task dashboards. They lack a unified data organization method for the film and television project creation stage, and also lack a workspace structure that integrates project memory, conversation working memory, knowledge reference, structured instructions, generated results, and task delivery into a closed loop.

[0005] Therefore, there is a need for an intelligent collaborative creation solution for film and television projects that can organize creative capabilities in stages, unify organizational context, accumulate and generate assets, automatically extract tasks, and maintain multi-terminal synchronization.

[0006] The existing technology has at least the following shortcomings:

[0007] 1. The AI ​​dialogue is disconnected from the project phase, and cannot automatically constrain the available models and task types based on the script, art, video, and other phases.

[0008] 2. Knowledge assets are separated from generated results. Generated text, images, and videos often remain in the dialogue history or third-party platforms and cannot be automatically incorporated into the project asset system.

[0009] 3. The project memory lacks stable version control, which can easily lead to overwriting, conflicts, or duplicate organization when multiple people are collaborating.

[0010] 4. Context assembly relies on manual copying, resulting in incomplete data splicing and making it difficult to statistically analyze context usage.

[0011] 5. The content of the conversation is difficult to automatically convert into actionable tasks, and the to-do items in the discussion need to be manually organized again.

[0012] 6. The lack of a unified link between task delivery and material storage makes it difficult to trace audit records, deliverables, and task status.

[0013] 7. Multi-device collaboration often uses full refresh or ordinary polling, which makes it difficult to synchronize message, knowledge and task changes in sequence. Summary of the Invention

[0014] In view of the shortcomings of the prior art, the purpose of this invention is to: in the process of intelligent creative collaboration in film and television projects, how to use projects, stages and sessions as unified state entry points, and organize artificial intelligence request context, knowledge assets, generated results, task delivery and multi-terminal synchronization into a traceable closed-loop processing link.

[0015] To address the aforementioned technical problems, embodiments of the present invention provide an intelligent collaborative creation method for film and television projects, comprising steps S1 to S8 as described in claim 1.

[0016] This invention provides an intelligent collaborative creation method for film and television projects based on staged context snapshots and a multi-source knowledge asset closed loop. The system uses projects as the basic unit, creative stages such as scriptwriting, art direction, and video production as constraints, workspace snapshots as a unified entry point, and knowledge assets, AI dialogue, task delivery, and event flow as the core closed loop. Its processing chain does not execute content generation, video processing, material retrieval, or general task extraction in isolation, but rather sequentially executes workspace state aggregation, stage model capability limitation, AI request context assembly, generation result assetization, dialogue incremental task generation, task delivery and storage, and incremental event synchronization.

[0017] The present invention also provides a system comprising a project initialization and permission unit, a phased workspace snapshot unit, a phased model capability unit, a multi-source knowledge asset unit, an artificial intelligence request context assembly unit, a result generation and sedimentation unit, a dialogue incremental task card unit, a task delivery unit, and an event stream synchronization unit.

[0018] The present invention also provides an electronic device and a computer-readable storage medium for performing the above-described method.

[0019] The beneficial effects of the technical solutions provided in the embodiments of the present invention include at least the following:

[0020] 1. Organize the film and television project creation process into stages to make the model capabilities, task types, and authority boundaries clearer.

[0021] 2. Integrate project memory, session working memory, knowledge references, and structured instructions into a unified whole to reduce omissions caused by manually piecing together context.

[0022] 3. Standardize and save the generated text, images, and videos as project assets to enhance the traceability of the results.

[0023] 4. Convert the incremental to-do items in the dialogue into task cards to reduce the probability of repeated scanning and task creation.

[0024] 5. Link task submission results with material assets, delivery records, and review status to form a traceable closed loop.

[0025] 6. Improve multi-terminal state consistency and disconnection recovery capabilities by using incremental event sequence numbers and event replay mechanisms. Attached Figure Description

[0026] The accompanying drawings are for illustrative purposes only and are not intended to limit the scope of the invention. Throughout the drawings, the same or similar reference numerals denote the same or similar parts. It is obvious that the drawings described below are merely some embodiments of the present invention, and those skilled in the art can obtain other drawings based on these drawings without any creative effort.

[0027] Figure 1 This is a schematic diagram of the overall process of a film and television project intelligent creation collaboration method based on staged context snapshots and multi-source knowledge asset closed loop provided by an embodiment of the present invention.

[0028] Figure 2 This is a schematic diagram of the structure of an intelligent collaborative creation system for film and television projects based on staged context snapshots and a closed loop of multi-source knowledge assets, provided by an embodiment of the present invention.

[0029] Figure 3 This is a closed-loop flowchart of asset task events provided in an embodiment of the present invention. Detailed Implementation

[0030] To enable those skilled in the art to better understand the technical solutions in the embodiments of the present invention, the technical solutions of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, not all embodiments. It should be understood that these descriptions are merely exemplary and not intended to limit the scope of the present invention. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort should fall within the scope of protection of the present invention.

[0031] The following detailed description, in conjunction with the accompanying drawings, of the intelligent collaborative creation method for film and television projects based on staged context snapshots and multi-source knowledge asset closed loops provided by the embodiments of the present invention, through specific implementations and application scenarios, will be provided in detail.

[0032] Reference manual attached Figure 1 This illustration shows a schematic diagram of the overall process of a collaborative intelligent creation method for film and television projects based on staged context snapshots and a multi-source knowledge asset closed loop, as provided by an embodiment of the present invention. The method provided by this embodiment can be executed collaboratively by a server, a client, a database, and object storage. The server is used to complete project verification, stage normalization, permission judgment, workspace snapshot generation, AI request context assembly, result saving, task card generation, task delivery processing, and event synchronization. The client is used to display the creation area interface and update its local state based on the workspace snapshots and incremental events returned by the server. The database is used to store projects, members, stage permissions, sessions, messages, memories, knowledge files, tasks, task actions, delivery records, media resources, and project events. Object storage is used to store persistent files such as text, images, or videos.

[0033] In this embodiment, the film and television project creation area does not process AI conversations, knowledge assets, task dashboards, and real-time messages separately. Instead, under the same project identifier, project stages, conversations, knowledge assets, generated results, task delivery, and event sequence numbers are organized into a continuous processing chain. The server carries the project identifier, user identifier, stage identifier, and conversation identifier in each read, generate, save, and deliver action, enabling mutual traceability of the creation area status, generation source, knowledge assets, task delivery records, and event synchronization results.

[0034] This invention provides an intelligent collaborative creation method for film and television projects, which may include the following steps:

[0035] S1: Receive project identifier, user identifier, stage identifier and session identifier, and verify project access permissions and stage validity.

[0036] Specifically, when the server receives a workspace entry request, AI request, knowledge preservation request, result preservation request, task generation request, or task delivery request from a client, it first parses the project identifier, user identifier, stage identifier, and session identifier. The stage identifier is used to define the creation stage; in one specific implementation, stages include script stage, art stage, and video stage. The server can uniformly normalize page routing parameters, query parameters, or business aliases to the aforementioned stage identifiers. When the stage identifier is empty, the server can use the default stage; when the stage identifier does not belong to the preset stage set, the server rejects the request. Therefore, subsequent knowledge retrieval, model selection, task actions, and event synchronization are all executed at the same stage boundary, avoiding stage mismatch caused by the client manually piecing together states.

[0037] In one possible implementation, S1 specifically includes sub-steps S101 to S105:

[0038] S101: Parse the project identifier and identify the target project.

[0039] Specifically, the server can read the project identifier from path parameters, query parameters, or the request body, and compare the path project identifier with the request body project identifier. If they do not match, the server returns a result indicating a parameter mismatch. After the project identifier passes format validation, the server reads the project's runtime data to determine if the target project exists, whether access to the creation area is allowed, and whether the default session, basic knowledge files, or project event table need to be initialized. If the target project does not exist, has been deleted, or the creation area entry is not enabled, the server refuses to continue processing.

[0040] S102: Parse the user identifier and determine the actual access subject within the project.

[0041] Specifically, the server does not directly trust the display name or temporary identity passed in by the client. Instead, it determines the actual access subject based on the project creator, project member relationships, and stage permission records. If the access subject is the project creator, it is considered to have creator permissions; if the access subject is a project member, its role is further read; if the access subject is not a project member and has not obtained stage authorization, the server refuses to read or write. This ensures that access control in multi-person collaborative scenarios is uniformly executed by the server.

[0042] S103: Parse the stage identifier and determine the stage permission boundaries.

[0043] Specifically, the server normalizes stage identifiers to a stage within a script, art, or video, and based on this, determines the readable knowledge assets, visible task list, available AI model capabilities, and executable task actions for the current stage. If a stage has inaccessible permissions, the server blocks subsequent reads; if a stage has read-only permissions, only a workspace snapshot and knowledge presentation data are returned, and writing messages, knowledge files, tasks, or delivery records is not allowed.

[0044] S104: Resolve the session identifier and determine the current working session.

[0045] Specifically, when a request includes a session identifier, the server verifies whether the session belongs to the target project and reads its stage, title, model identifier, and update time. When the request does not include a session identifier, the server reads the target project's default session or the most recently updated session as the current working session. If the specified session does not exist, is archived, or does not belong to the target project, the server rejects the request. Session ownership verification avoids reading messages and storing data across projects.

[0046] S105: Determine read / write permissions based on the request type.

[0047] Specifically, reading workspace snapshots only requires read permissions for the project; AI requests, knowledge storage, result storage, task generation, and task delivery all require the current user to have write permissions for the corresponding stage. The server performs permission checks repeatedly before each write operation, rather than relying solely on client button states. This separation of read and write permissions prevents read-only members from triggering operations that alter project assets, task states, or event sequence numbers.

[0048] S2: Generate server-side workspace snapshots based on project identifiers, stage identifiers, and session identifiers.

[0049] Specifically, after completing the basic verification of S1, the server generates a workspace snapshot. This workspace snapshot is not a local client cache, nor is it a simple concatenation of multiple interfaces; rather, it is a structured state object aggregated by the server in real time according to project, stage, and session. This workspace snapshot includes at least project metadata, the current stage, the current session, session messages, a task list, a knowledge asset list, permission status, stage model capabilities, a sidebar snapshot, and event versions. When the client enters the creation area, it can restore the session area, knowledge area, task area, and stage model selection state based on this workspace snapshot.

[0050] Reference manual attached Figure 1 The diagram illustrates the overall process flow, where S1 to S3 correspond to project verification, workspace snapshot generation, and stage model capability limitation processes. In one possible implementation, S2 specifically includes sub-steps S201 to S208:

[0051] S201: Read basic project data.

[0052] Specifically, the server reads the project name, project creator, invitation code, update time, creation area entry status, and cross-entry metadata, and encapsulates this into project metadata for a workspace snapshot. Cross-entry metadata may include the project entry point, creation area entry point, creation area status, whether entry to the creation area is allowed, the number of project members, and entry point availability. This data is used to determine the initial display scope for the client and whether entry to the creation area is allowed.

[0053] S202: Read the phased knowledge cards.

[0054] Specifically, the server uses project identifier and stage identifier as search criteria to retrieve knowledge cards for the corresponding stage from the project's knowledge file records. These knowledge cards can originate from team knowledge assets, generated assets, or personal knowledge assets, and carry the knowledge file identifier, name, asset library, stage, file size, upload status, update time, and accessible address. If no knowledge card has yet been generated for the current stage, the server can retrieve the most recently updated knowledge card from within the project as supplementary display data, while retaining the original stage identifier for subsequent filtering.

[0055] S203: Read current session messages.

[0056] Specifically, the server reads message records in the current session in the order of creation time and message identifier. Each message may include a message identifier, role, author, body content, generation engine, model identifier, knowledge reference, structured instruction reference, image result, video result, timeline change information, source information, and observable information. The server can also process access tickets for the media preview address before returning, ensuring that the client can only display image or video results within the authorized scope.

[0057] S204: Read the phased task list.

[0058] Specifically, the server reads task records from the task table based on project and stage identifiers, and converts task status, priority, responsible person, start and end time, scene tag, status tag, action button, version number, source message, delivery summary, and update time into a task structure that can be displayed on the client. The server can determine whether the task action button is available based on the current user's stage permissions, and perform permission verification again when actually executing the task action.

[0059] S205: Generate event version.

[0060] Specifically, the server reads the current maximum incrementing event number of the target project from the project event table and uses this maximum number as the event version of the workspace snapshot. After acquiring this snapshot, the client uses this event version as the starting cursor for subsequent event synchronization. If there is no record in the project event table, the event version is zero. Through this event version, the workspace snapshot and subsequent incremental events form a continuous state link.

[0061] S206: Model capability information during the generation phase.

[0062] Specifically, the server reads the stage model capability configuration based on the stage identifier to obtain the default model and available model list for the current stage. If the stage model capability configuration exists in the database, the database configuration prevails; otherwise, the server's preset stage model capability configuration is used. Model capability information may include model identifier, display name, service provider, model type, context window, consumption unit, whether it is default, and sorting information.

[0063] S207: Generate a sidebar snapshot.

[0064] Specifically, the server generates a sidebar snapshot, which includes at least three knowledge sections: team knowledge, generated assets, and personal knowledge; project member permission information; session group information; a summary of the current stage's tasks; and module access status. For local preview scenarios or read-only members, the server can downgrade member permissions, media addresses, or sensitive modules. The sidebar snapshot shares project and stage identifiers with the workspace snapshot, thus preventing stage inconsistencies in the AI ​​session area, knowledge sidebar, and task panel.

[0065] S208: Return to the unified workspace snapshot.

[0066] Specifically, the server merges project metadata, current stage, stage model capabilities, number of members, knowledge cards, session messages, task list, permission status, event version, and sidebar snapshot into a unified response. To ensure compatibility with different client versions, the server can also return alias fields for session messages and task list. Through these steps, clients can restore the initial state of the creation area based on a single server-side snapshot without needing to request messages, tasks, knowledge assets, permissions, and model configurations separately.

[0067] S3: Determine the capability boundaries of the AI ​​model based on the stage identifier, and perform availability verification on the target model and target task before initiating the AI ​​request.

[0068] Specifically, different stages of film and television production have different requirements for model types and generated result types. For example, text models are more suitable for the script stage, image models are more suitable for the art direction stage, and video models are more suitable for the video stage. To prevent users from selecting inappropriate models at the wrong stage, this invention sets up stage model capability units on the server side, and the server, rather than just the client, performs model boundary checks. Even if the client passes in an out-of-bounds model identifier, the server will still reject the request or return optional model information based on the stage model capability configuration.

[0069] In one possible implementation, S3 specifically includes sub-steps S301 to S305:

[0070] S301: Model capability configuration during the reading phase.

[0071] Specifically, the server first reads the enabled model configurations from the stage model capability table and determines the list of available models and the default model based on the sorting field and default tag. When the stage model capability table does not exist or has no valid records, the server uses a preset model catalog and preset stage model configuration. This configuration allows the deployer to adjust the model scope for different stages without modifying the client code.

[0072] S302: Determine the model type.

[0073] Specifically, the server records the model type for each model, which includes at least one of text, image, and video. Text models correspond to text generation requests, image models to image generation requests, and video models to video generation requests. The server may also record the context window length, generation unit, estimated consumption unit, service provider, and model display name.

[0074] S303: Determine the default model.

[0075] Specifically, when the request does not explicitly carry a model identifier, the server uses the default model in the current stage's model capability configuration as the target model; when multiple available models exist, the server can determine the candidate order based on the default tag, sorting field, and model identifier. If the database configuration lacks a default model, the server can select the first enabled model in this stage as the fallback model.

[0076] S304: Verify whether the target model belongs to the current stage.

[0077] Specifically, when a request carries a target model identifier, the server checks if the target model exists in the list of available models for the current stage. If it does not belong to the current stage, the AI ​​request is rejected, and the server returns the current stage, target model, and available model information to avoid cross-stage model misuse. This check is performed before the AI ​​request actually invokes the generation service, thus reducing invalid external calls.

[0078] S305: Verify additional parameters of the model.

[0079] Specifically, the server can validate additional parameters based on the model type. For image models, the server verifies whether the image size or aspect ratio belongs to the supported set; for video models, the server verifies whether the generation duration is within a preset range; for text models, the server can verify the upper limit of output length, temperature parameters, and context length range. Through these parameter validations, the AI ​​request meets the stage constraints and interface constraints before calling external or internal models.

[0080] S4: Assemble project memory, session working memory, knowledge references, and structured instructions into an AI request context.

[0081] Reference manual attached Figure 1 The diagram illustrates the overall process flow, where S4 corresponds to the AI ​​request context assembly process. Specifically, when an AI request enters the generation process, the server does not directly send the user's original input to the model. Instead, it reads project memory, session working memory, session long-term memory, knowledge references, and structured instructions, using projects, stages, and sessions as boundaries, to form a traceable AI request context. Each part of the above context retains a source identifier so that subsequent message logging, generation results, and task delivery can trace the source.

[0082] In one possible implementation, S4 specifically includes sub-steps S401 to S410:

[0083] S401: Read the target session and verify write permissions.

[0084] Specifically, the server reads the AI ​​session record based on the project identifier and session identifier, and verifies the project and stage to which the session belongs. If the session does not exist, does not belong to the target project, or the user does not have write permissions for the corresponding stage, the server rejects the request. If the requested stage differs from the session stage, the server may perform normalization according to the session stage, or reject cross-stage writes based on business rules.

[0085] S402: Read user input and target model.

[0086] Specifically, the server verifies that the user input is not empty and its length does not exceed a preset limit, and reads the target model, temperature parameters, maximum output length, image size, video duration, knowledge references, and structured instruction references from the request. When the target model is empty, the stage default model determined by S3 is used; when the target model exists but does not meet the stage's capabilities, the request is rejected according to S304.

[0087] S403: Read session working memory.

[0088] Specifically, the server reads working memory objects from the session log and standardizes the key-value entries into a "key and value" format. Session working memory is used to record short-term valid role settings, creative constraints, style preferences, temporary decisions, or conclusions of the current discussion. The server can filter or prune null entries, duplicate entries, or entries exceeding length limits.

[0089] S404: Read session long-term memory and project-level memory.

[0090] Specifically, the server reads long-term memory entries from the current session, as well as project-level memory entries from the same project. Project-level memories can be used to store team-agreed project settings, character relationships, worldviews, visual direction, delivery rules, or review guidelines. The server can set a maximum number of memory entries and their priority to control the context size.

[0091] S405: Generate memory instruction block.

[0092] Specifically, the server combines session working memory, current session long-term memory, and project-level memory into memory instruction blocks, and distinguishes between different sources within these blocks. The server can also calculate the original memory text volume and the assembled text volume to form a contextualized record for subsequent observable statistics and troubleshooting.

[0093] S406: Read knowledge references and structured instruction references.

[0094] Specifically, knowledge references can point to team knowledge, generated assets, or personal knowledge; structured instruction references can point to creation rules stored within the project. The server reads the corresponding content based on the reference identifier and writes the reference name, source library, selection identifier, and rule text into the context. If a reference does not exist or does not belong to the target project, the server can reject the request or ignore the reference and log the exception information.

[0095] S407: Save user messages.

[0096] Specifically, the server writes user messages within a transaction. Message records can include message identifier, project identifier, session identifier, stage, role, author, body, target model, knowledge references, structured instruction references, and request metadata. Saving user messages beforehand is beneficial because even if subsequent service calls fail, the system can still retain the user request and the reason for failure, facilitating retries and auditing.

[0097] S408: Generate results based on model type.

[0098] Specifically, when the target model is a text model, the server calls the text generation service and returns the text content; when the target model is an image model, the server calls the image generation service and returns the image address, asset identifier, and service provider information; when the target model is a video model, the server calls the video generation service and returns the video task identifier, video address, asset identifier, and status information. All of the above branches reuse the stage model capabilities defined in S3 to ensure that the result type matches the current stage.

[0099] S409: Save assistant messages and generated result metadata.

[0100] Specifically, the server writes the generated results to an assistant message. The assistant message can carry the model identifier, service provider, generated result type, media resource, request source, contextual statistics, usage statistics, and observable status. For image or video results, the message can simultaneously save the preview address and the source information that can be retained as project assets, for reuse when S5 saves the generated assets later.

[0101] S410: Update the session summary and return a response.

[0102] Specifically, after the generation process is complete, the server updates the session update time, final stage, and final model, and returns an assistant message, media results, session summary, and observables. Upon receiving the response, the client appends the message to its local session and can display a preview button or save entry based on the returned media results. This step ensures consistency between AI-generated content, message logging, and subsequent asset accumulation.

[0103] S5: Obtain AI-generated results and save them as project assets according to result type, source request identifier, model identifier, and asset identifier.

[0104] Reference manual attached Figure 3The diagram illustrates a closed-loop process for asset task events, where multi-source knowledge assets and generated asset accumulation form a closed loop of knowledge input and generation output. Specifically, AI-generated results should not merely remain in conversation messages but should be accumulated as searchable, referable, deliverable, and traceable project assets in the generated asset repository. The result saving process handles text, image, and video results simultaneously, and provides unified processing for repeated saving, media persistence, and knowledge event writing.

[0105] In one possible implementation, S5 specifically includes sub-steps S501 to S509:

[0106] S501: Receive a request to save the generated results.

[0107] Specifically, save requests can originate from the save button in the assistant message, or from task submission or the sidebar save entry. The request content must include at least the project identifier, stage identifier, result type, title, model identifier, source message identifier, source session identifier, and text content or media address. The server first performs enumeration and validation of the result type, allowing only text, image, and video results to enter the save process.

[0108] S502: Verification phase and write permissions.

[0109] Specifically, the server normalizes the stage identifier in the request to a script, art, or video stage, and reads the target project and the current access subject. If the user does not have write permissions for the current stage, the server refuses to save. This check prevents read-only members from writing temporary session content to the project asset library and also prevents the output results of one stage from being mistakenly written to another stage.

[0110] S503: Generate output unique key.

[0111] Specifically, the output unique key is used to identify whether the same generated result has already been saved. For results with existing asset identifiers, the server can generate a unique key using the asset identifier; for text results, the server can calculate a summary value from the text content; for media results without asset identifiers, the server can generate a unique key using the normalized media address. By using a unified unique key, the number of times the same content is saved repeatedly as multiple files can be reduced.

[0112] S504: Perform idempotency processing and duplicate save identification.

[0113] Specifically, the server reads the request's idempotency key and searches for idempotency records within the project, access subject, and save scope. If an idempotency record is found, the server directly returns the previously saved result. If no idempotency record is found, the server continues searching for existing generated files based on the output's unique key. If the same output already exists, the server returns the already saved file and a new sidebar snapshot, recording the current idempotency result. This two-layer processing can simultaneously address network retries and duplicate user clicks.

[0114] S505: Generate file identifier and file name.

[0115] Specifically, when no duplicate results are saved, the server generates new knowledge file identifiers and media resource identifiers. The file name can be determined based on the user-provided title, task title, or a default generated name, and the file extension corresponding to text, image, or video is appended depending on the result type. The server also replaces path separators and illegal characters in the filenames to prevent the creation of invalid storage paths.

[0116] S506: Persistent media content.

[0117] Specifically, for image and video results, when the request does not contain a reusable asset identifier, the server can read the media address or data address, verify the protocol, accessibility, content length, and file size limit, and then write the media content to object storage. If the media address is inaccessible, the protocol is unsupported, the content is empty, or it exceeds a preset size, the server refuses to save it. This step transforms the temporary media address returned externally into a persistent media resource within the project.

[0118] S507: Create a media asset.

[0119] Specifically, media resource records can include resource identifier, project identifier, source type, source job identifier, storage key, media type, file name, file size, preview address, download address, status, and metadata. For results with existing asset identifiers, media resources can reference the preview and download interfaces of that asset; for newly persisted media results, media resources can reference files in object storage.

[0120] S508: Write to the generated asset library.

[0121] Specifically, the server writes the generated results to the project knowledge file table and marks its source library as a generated asset. Source metadata can include result type, output unique key, model identifier, asset identifier, media type, preview address, download address, source message identifier, source session identifier, saver, and save time. For text results, the server can save preview text in the source metadata for quick display in the sidebar.

[0122] S509: Write knowledge events and return sidebar snapshots.

[0123] Specifically, after the generated asset is successfully written, the server appends a knowledge file creation event to the project event table and returns a sidebar snapshot containing the updated results of the generated asset area. Upon receiving the response or event, the client refreshes the generated asset area. Thus, the generated results in the AI ​​session can enter the knowledge sidebar and be referenced again in subsequent sessions, task delivery, or personal save processes.

[0124] S6: Extract task cards based on newly added dialogue message windows, and parse the person responsible for task card execution, match stages, match scene relationships, and deduplicate task fingerprints.

[0125] Reference manual attached Figure 3 The diagram illustrates a closed-loop flowchart for asset task events, where the generation of incremental task cards and task delivery constitute the execution loop. Specifically, creation discussions often include to-do items, responsible parties, scenario scope, and delivery requirements. This invention does not re-extract tasks from all historical messages each time; instead, it limits new message windows to message watermarks and performs responsible party parsing, scenario relationship matching, and task fingerprint deduplication before task creation.

[0126] In one possible implementation, S6 specifically includes sub-steps S601 to S610:

[0127] S601: Create a task card to process running records.

[0128] Specifically, the server generates task card processing run identifiers and writes them to the run log. If a running record already exists for the same project, session, and processing action, the server can reject new processing requests. For records that remain running for an extended period, the server can mark them as stale or failed records before starting a new run. This avoids duplicate tasks caused by concurrent retrieval.

[0129] S602: Read message watermark.

[0130] Specifically, message watermarks can include the identifier of the last processed message and its creation time. The server reads the watermark using the project identifier, session identifier, and processing action as the watermark key. If no watermark exists, it reads from the beginning of the session; if a watermark exists, it only reads messages after the watermark. This watermarking mechanism enables incremental processing capabilities for task extraction.

[0131] S603: Read the newly added message window.

[0132] Specifically, the server reads new messages after the watermark based on the creation time and message identifier, and sets a window limit. If the number of new messages exceeds the limit, the marked window is truncated. The server can filter system messages, historical receipt messages, and messages without text, retaining user messages and assistant messages that express to-do items as candidate sources.

[0133] S604: Generate task candidates.

[0134] Specifically, the server can first extract candidate items from new messages using rules. If an available AI service is available, the AI ​​service can also generate candidate items based on the project name, stage, and new message. Candidate items must include at least the task title, task description, stage, responsible person clue, role clue, and source message identifier. If the AI ​​service is unavailable or returns an unresolvable value, the server uses the candidate items generated using the rules as a fallback result.

[0135] S605: Normalization task candidate.

[0136] Specifically, the server performs header non-empty verification, stage normalization, responsible person clue cleaning, source message identifier verification, and duplicate blanking on the candidates. If no stage is specified for the candidate, the current session stage is used; if the specified stage cannot be identified, it reverts to the current stage. Through normalization, the candidates can enter the unified task creation process.

[0137] S606: Person responsible for analysis.

[0138] Specifically, the server determines the responsible person based on the candidate's responsibilities, role, task title, task description, and source information, combined with project member and role information. If a specific member can be matched, a member identifier is written; if only a role can be matched, a suggested role is written; if no match can be found, an empty responsible person is reserved, and the description records the content requiring manual confirmation.

[0139] S607: Matching scene relationships.

[0140] Specifically, for film and television projects, tasks may be related to script scenes, shots, or segments. The server can read project scene candidate data and perform scene matching by combining candidate content and source messages. If the matching confidence reaches a threshold, the scene identifier, scene location identifier, scene order, matching confidence, and matching reason are written into the task metadata; if no match is found, the task can still be created, but scene binding is not written.

[0141] S608: Computation task fingerprint.

[0142] Specifically, task fingerprints can be calculated based on session identifier, stage, title, responsible person tag, and source message identifier. The server first checks the fingerprint set created in the current round plan to prevent duplication within the same round; then it queries the historical task association table to prevent duplication across rounds. If a fingerprint already exists, it is skipped and counted in the duplicate skip count.

[0143] S609: Create a task and record the association.

[0144] Specifically, the server creates a task record within a transaction, writing the task title, description, stage, priority, responsible person, scenario tag, and metadata, and simultaneously writes a task source association record. The task source association record can include a run identifier, task identifier, task fingerprint, source message identifier, responsible person parsing result, and creation time. This association record is used for subsequent deduplication and source tracing.

[0145] S610: Update the watermark and generate a receipt event.

[0146] Specifically, after a task is created, the server updates the watermark to the last message in the current processing window and generates an assistant receipt message indicating the number of tasks created and the number of skipped duplicates. The server then appends a message creation event and a task update event. Upon receiving these events through the event stream, the client can simultaneously update both the session messages and the task list.

[0147] S7: In response to a task delivery request, convert the submission result into material assets and delivery records, and update the task status.

[0148] Specifically, S7 is used to transform task execution results from temporary session content into auditable, downloadable, and traceable delivery records. Task delivery requests can carry text, image, or video results, or only status actions. The server determines the target status based on action rules and requires the submitted results to meet type and content validation in actions such as submitting for review, submitting for approval, or handover.

[0149] In one possible implementation, S7 specifically includes sub-steps S701 to S709:

[0150] S701: Receive task action request.

[0151] Specifically, a task action request includes at least a task identifier, action name, stage identifier, and optional remarks. When the action is a submit action, the request also includes the submission result. The server first parses the task identifier and action name and determines whether the action belongs to the preset action set; if the action is not supported, the server refuses to execute it.

[0152] S702: Verify task, project, and stage permissions.

[0153] Specifically, the server reads the task record to confirm that the task exists and belongs to the target project. If the request path, request body, or query parameters contain a project identifier, the server verifies that it matches the project to which the task belongs. Subsequently, the server performs stage normalization and write permission checks according to the task stage or request stage to prevent modification of the task status across projects or stages.

[0154] S703: Perform idempotency check.

[0155] Specifically, the server reads the idempotent key and queries for idempotent records using the project identifier, access subject, and task action scope. If an idempotent record is found, the server directly returns the previous response. This mechanism is suitable for situations where users repeatedly click task buttons, retry after network timeouts, or the client automatically resends requests, avoiding duplicate creation of delivery records and duplicate material entry into the database.

[0156] S704: Verify delivery lock status.

[0157] Specifically, when a task already has a delivery record and its delivery status is "approved," the server refuses to overwrite the delivery record and prompts the user to create a new task to continue the iteration. This locking mechanism protects approved results and prevents subsequent operations from unintentionally overwriting historical delivery versions.

[0158] S705: Parse the submitted results.

[0159] Specifically, the submitted result must be one of text, image, or video. Text results must include body content; image or video results must include an accessible URL, or a reusable asset identifier, generated asset file identifier, source message identifier, and source session identifier. The server validates the submitted result for type, title, body, URL, and source fields to ensure that it can be subsequently used to create media assets.

[0160] S706: Create or reuse material assets.

[0161] Specifically, for text-based results, the server can construct a file upload request from the text content and write it into the project's media assets. For image or video results, the server prioritizes reusing the asset identifier in the submitted result; if no asset identifier is available, it attempts to reuse a file from the generated asset library; if reuse is still not possible, it imports it as a new media asset based on the media address. During import, the server can write the stage, scene identifier, task identifier, and source information into the media metadata.

[0162] S707: Generate or update delivery records.

[0163] Specifically, the server generates delivery record data based on the task identifier, stage, submission result, and media assets. Delivery records may include the task title, scene identifier, shot or segment identifier, submission result type, media asset identifier, preview address, download address, source generated file identifier, source message identifier, source session identifier, submission title, submission body, or submission media address. If a delivery record for a task already exists but has not been approved, the server updates that record and retains the change description; otherwise, a new delivery record is created.

[0164] S708: Update task status and task action records.

[0165] Specifically, the server changes the task status from pending, in progress, pending review, completed, or blocked to the target status according to action rules, and updates the action button set. The server also writes a task action record, recording the action identifier, task identifier, action name, original status, target status, remarks, stage, operator, and creation time. These records are used to audit the complete workflow of the task from creation to delivery.

[0166] S709: Write event and return the latest sidebar snapshot.

[0167] Specifically, when the task status, delivery record, or generated asset changes, the server appends a task update event; if the action results in a new file being added to the generated asset library, the server also appends a knowledge file creation event. The response returns the updated task, action record, optional generated assets, and sidebar snapshot. The client then updates the task dashboard, knowledge sidebar, and delivery preview status accordingly.

[0168] S8: Writes changes to messages, knowledge, tasks, assets, and delivery status to a project event table with incrementing event numbers, and provides online push and offline replay to clients.

[0169] Reference manual attached Figure 3 This invention illustrates a closed-loop flowchart of asset task events, where incremental event numbers are synchronously used to connect changes in message, knowledge, task, and delivery status. Specifically, this invention organizes state changes in the creation area using project-level incremental event numbers, creating a continuous state link between workspace snapshots and subsequent event flows. Whenever any message, knowledge file, upload status, task, or delivery status changes, the server can write it to the project event table and push the event to online clients. If a client experiences an abnormal disconnection, it can request historical events from the server based on a cursor.

[0170] In one possible implementation, S8 specifically includes sub-steps S801 to S808:

[0171] S801: Generate the next event sequence number.

[0172] Specifically, before writing an event, the server reads the current maximum event sequence number of the target project and increments it by one to obtain the next event sequence number. Event sequence numbers increment by project dimension, thus ensuring a consistent and sortable order for messages, knowledge, tasks, and delivery events within the same project.

[0173] S802: Write to the project event table.

[0174] Specifically, the project event table can store project identifier, event sequence number, event type, event content, and creation time. Event content can be represented using structured data; for example, a message creation event includes a session identifier and message content, a knowledge document creation event includes a file identifier and source library, and a task update event includes a task identifier, action, original state, and target state.

[0175] S803: Push events to online clients.

[0176] Specifically, the server maintains a set of online connections grouped by project. After an event is written, the server pushes the event type, event sequence number, project identifier, and event content to the online client. For clients with session filtering conditions, the server can push only message creation events related to that session, while task and knowledge events are still pushed by project.

[0177] S804: Filter message events by session.

[0178] Specifically, when a client subscribes to only one session, the server checks the session identifier in the message event; if the event session is inconsistent with the client's subscribed session, the message event is not pushed to that client. This filtering can reduce the interference of irrelevant session messages on the current creation interface, while preserving the synchronization capability of project-level tasks and knowledge events.

[0179] S805: Provides playback of historical events.

[0180] Specifically, when a disconnected client reconnects, it carries a local cursor. The server queries events with sequence numbers greater than this cursor and returns them in ascending order of sequence number. The server can set a limit on the number of events that can be replayed at one time to prevent too many historical events from being returned in a single connection. If there are still remaining events, the client can continue to request the next batch with the latest cursor.

[0181] S806: Maintain online connection.

[0182] Specifically, the server sends a connection success event to the client and periodically sends keep-alive events. Keep-alive events can carry the server's time, allowing the client to determine if the connection is still valid. If the client closes the page or the network connection is interrupted, the server releases the connection and removes it from the item's connection collection.

[0183] S807: Client merge event.

[0184] Specifically, after receiving an event, the client first checks if the event sequence number is greater than the local cursor, and then updates the local state according to the event type. Message creation events are appended to the corresponding session, task update events are merged into the task list, and knowledge file creation events trigger a refresh of the sidebar knowledge area or partial insertion. After the event processing is complete, the client advances the local cursor.

[0185] S808: Client reconnects abnormally.

[0186] Specifically, when an event connection is abnormally closed, the client retains the sequence number of the last event processed and uses that number to re-establish the connection. The server then replays historical events after that sequence number and continues to push real-time events. Therefore, even if the project state changes during network fluctuations, page switching, or service restarts, the client can restore itself to a state consistent with the server.

[0187] Through S1 to S8 above, this invention organizes the stage states, artificial intelligence generation, knowledge assets, task delivery, and multi-terminal synchronization in the film and television project creation process into a continuous closed loop. Unlike solutions that only provide single content generation, a separate knowledge base, or a regular task dashboard, this invention uses server-side workspace snapshots as the entry point, stage model capabilities as constraints, multi-source knowledge assets as input and output, task cards and delivery records as the execution closed loop, and incremental event sequence numbers to maintain consistency across multiple terminals.

[0188] Reference manual attached Figure 2 The diagram illustrates the structure of an intelligent collaborative creation system for film and television projects based on staged context snapshots and a closed loop of multi-source knowledge assets, as provided in an embodiment of the present invention.

[0189] This invention provides an intelligent collaborative creation system 20 for film and television projects, which may include:

[0190] The project initialization and permission unit 201 is used to receive the project identifier, user identifier, stage identifier, and session identifier, and to verify the project access permissions and stage validity. This unit can call the project runtime read interface, project member read interface, and stage permission read interface, and output the actual access subject, target project, and normalized stage.

[0191] The phased workspace snapshot unit 202 is used to generate server-side workspace snapshots based on project identifiers, phase identifiers, and session identifiers. This unit can aggregate project metadata, phase knowledge cards, current session messages, task lists, phase model capabilities, sidebar snapshots, and event versions, and return the message list and task list simultaneously as standard and compatible fields.

[0192] The stage model capability unit 203 is used to determine the capability boundaries of the artificial intelligence model based on the stage identifier and to perform availability verification on the target model and target task before initiating an artificial intelligence request. This unit can read database configuration or a preset model directory and complete the verification that the target model belongs to the current stage before calling the generation service.

[0193] The Multi-Source Knowledge Asset Module 204 is used to manage team knowledge, generate assets, and personal knowledge. It supports knowledge card display, knowledge saving, personal saving, batch saving, upload retry, and sidebar refresh, and works in conjunction with the asset accumulation steps in S5. This module enables both AI-generated results and manually uploaded materials to be incorporated into the project's knowledge asset system.

[0194] The AI ​​request context assembly module 205 is used to assemble project memory, session working memory, knowledge references, and structured instructions into an AI request context, save user messages and assistant messages, and record model results and contextual observable information. This module can enter text, image, or video generation branches according to the model type, and write the generated results back to the session in the form of messages, media resources, and observable data.

[0195] The result accumulation module 206 is used to acquire AI-generated results and save them as project assets according to result type, source request identifier, model identifier, and asset identifier. This module can perform output unique key generation, idempotent processing, media persistence, media resource creation, writing to the generated asset library, and writing knowledge events.

[0196] The incremental task card module 207 is used to extract task cards based on newly added dialogue message windows, and to parse the person responsible for task card execution, match stages, match scene relationships, and deduplicate task fingerprints. This module can maintain message watermarks and task source association records, enabling pending items in the discussion to enter the task system incrementally.

[0197] Task delivery module 208 is used to respond to task delivery requests, converting submitted results into material assets and delivery records, and updating the task status. This module can process three types of submission results: text, images, and videos, generate or update delivery records, and lock the delivery records after approval.

[0198] The event stream synchronization module 209 is used to write changes in messages, knowledge, tasks, assets, and delivery status to a project event table with incrementing event numbers, and to provide online push and offline replay to clients. This module can maintain a set of online connections at the project level, providing filtering by session, historical event replay, and connection persistence mechanisms.

[0199] The modules described in this embodiment can be implemented by different program modules on the same server, or they can be deployed on multiple servers or service instances. The above method can also be embodied in an electronic device, a computer-readable storage medium, or a computer program product. When the program instructions stored in the storage medium are executed by one or more processors, the processors perform project verification, workspace snapshot generation, stage model capability verification, context assembly, asset accumulation generation, task card generation, task delivery, and incremental event synchronization.

Claims

1. A method for intelligent collaborative creation in film and television projects based on staged context snapshots and a closed loop of multi-source knowledge assets, characterized in that: include: S1: Receive project identifier, user identifier, stage identifier and session identifier, and verify project access permissions and stage validity; S2: Generate a server-side workspace snapshot based on the project identifier, the stage identifier, and the session identifier. The workspace snapshot includes at least project metadata, current stage, current session, session messages, task list, knowledge asset list, permission status, stage model capabilities, and event version. S3: Determine the capability boundary of the artificial intelligence model based on the stage identifier, and perform availability verification on the target model and target task before initiating the artificial intelligence request; S4: Assemble project memory, session working memory, knowledge references, and structured instructions into an AI request context; S5: Obtain the AI-generated results and save the AI-generated results as project assets according to the result type, source request identifier, model identifier, and asset identifier; S6: Extract task cards based on newly added dialogue message windows, and perform responsibility parsing, stage matching, scene relationship matching, and task fingerprint deduplication on the task cards; S7: In response to a task delivery request, convert the submission result into material assets and delivery records, and update the task status; S8: Writes changes to messages, knowledge, tasks, assets, and delivery status into a project event table with incrementing event numbers, and provides online push and offline replay to clients.

2. The method according to claim 1, characterized in that, S2 includes: parsing the default session or a specified session, reading project metadata, session messages, task list and knowledge cards, generating phase model capability information and knowledge sidebar snapshots, and returning a unified workspace snapshot with event versions to the client.

3. The method according to claim 1, characterized in that, The stage model capabilities include available model types, default models, supported output types, and task type restrictions corresponding to different creation stages; when the target model or target task does not meet the stage model capabilities, the request is rejected or optional model information is returned.

4. The method according to claim 1, characterized in that, The S4 includes: reading the project-level long-term creative consensus as project memory, reading the session-level short-term state as session working memory, reading the selected team knowledge, generated assets or personal knowledge as knowledge references, reading the phased creation rules as structured instructions, and encapsulating the above content into a model request payload.

5. The method according to claim 1, characterized in that, S5 includes: identifying that the artificial intelligence-generated result is at least one of text, image, or video; generating asset metadata based on source session, source message, source request, model identifier, and output identifier; and performing idempotent storage when there is the same output identifier or the same task submission source.

6. The method according to claim 1, characterized in that, S6 includes: reading the message watermark processed previously, and only obtaining new dialogue messages after the message watermark; filtering system automatic messages and duplicate content; extracting task candidates from new dialogue messages; parsing the responsible person, job type, stage and candidate scenario; calculating task fingerprints and filtering duplicate tasks.

7. The method according to claim 1, characterized in that, S7 includes: verifying task action permissions, stage rules, and task status; creating or reusing corresponding material assets when the submission result is text, image, or video; generating a delivery record containing task identifier, stage identifier, scene relationship, asset identifier, and submission instructions; and locking the delivery record after it has been approved.

8. The method according to claim 1, characterized in that, S8 includes: calculating the next incrementing event number each time a message, knowledge, task, asset, or delivery status is written, and writing the event type, event payload, and event number into the project event table; online clients receive push events, and offline clients request historical events based on cursors and merge local states.

9. A film and television project intelligent creative collaboration system based on staged context snapshots and a multi-source knowledge asset closed loop, characterized in that, include: The system comprises a project initialization and permission unit, a phased workspace snapshot unit, a phased model capability unit, a multi-source knowledge asset unit, an artificial intelligence request context assembly unit, a result generation and sedimentation unit, a dialogue incremental task card unit, a task delivery unit, and an event stream synchronization unit; wherein each unit is configured to perform the method described in any one of claims 1 to 8.

10. An electronic device, characterized in that, The invention includes a processor and a memory, the memory storing a computer program that, when executed by the processor, implements the method of any one of claims 1 to 8; and a computer-readable storage medium storing a computer program thereon that, when executed by a processor, implements the method of any one of claims 1 to 8.