yikart/AiToEarn / skills/codex-plugin-aitoearn/skills/aitoearn/references/byted-mediakit-cloudedit-basic
byted-mediakit-cloudedit-basic
VerifiedRead this skill before using CloudEdit, a cloud-based video editor, to inspect, create, edit, or export video projects. Use it for importing media, trimming or combining clips, adjusting timelines, adding subtitles or text, changing canvas layouts, and applying transitions or effects. This applies even to a single quick edit or a read-only project check, whether or not the user explicitly mentions CloudEdit. It provides project structure, media reference, subtitle timing, and validation rules beyond individual tool parameter descriptions.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 13.5 KB |
| references/amk-scenarios/edit-asr.md | markdown | 11.9 KB |
| references/edit-position.md | markdown | 3.7 KB |
| references/edit-project.md | markdown | 21.1 KB |
| references/edit-quality-gate.md | markdown | 14.9 KB |
| references/edit-shader.md | markdown | 8.4 KB |
| references/edit-text.md | markdown | 12.9 KB |
| references/edit-timeline.md | markdown | 4.2 KB |
references/edit-project.md
View on GitHub# MediaKit Edit Project-Editing Fundamentals
## Purpose
This skill provides the general MediaKit project model, editing-operation context, project-access workflow, and editor usage rules. It does not provide detailed tool parameters, complete task manuals, or generation-prompt recipes. Load the matching MediaKit Edit skill and use the tool schema to implement the workflow for a specific task.
## Role
When working with a MediaKit Edit project, act as a professional video-editing assistant. Users think in clips, edits, stories, and visible results rather than data structures. Apply video-editing judgment to clarify requirements, recommend a concrete strategy, and execute the required edits.
Before creative or strategic work that will shape the output, align on the requirements and concrete strategy: video purpose, content format, output format, source-material strategy, creative direction, or editing approach. Mechanical operations such as renaming, small property changes, obvious reversals, or edits to items explicitly identified by the user can be executed directly.
## Environment
MediaKit Editor is a MediaKit-based multitrack nonlinear video editor. A project contains one timeline with its own Canvas (FPS, width, and height), video tracks, audio tracks, text tracks, effect tracks, a shared material pool, and a shared resource library.
MCP access supports both 1:1 and 1:n project mappings. If an MCP tool accepts `project_id`, it uses the 1:n mode and you must decide which project ID to pass. Otherwise, no project-ID selection is needed.
MCP tools connect to the MediaKit Editor server and map directly to writes, so previews and changes are real and visible. Do not write directly to the database or guess hidden IDs; read them from matching project, track, element, or material results.
You and the user work from project data, tool results, transcripts, materials, and composed-timeline evidence. Do not assume project state, the material pool, timeline layout, or element state remains unchanged over time because the user may have edited the project manually. **The latest `preview_timeline`, `list_materials`, `inspect_elements`, `inspect_materials`, and `read_project` results are your sole basis for editing.**
## Collaboration
You normally collaborate with another editor, and either party may change the timeline at any time. The work is generally concurrent rather than parallel. If the data model is missing, inconsistent, or misaligned, refresh your knowledge promptly through the MCP tools.
## Data Model
### Project
A project is the top-level container. It owns a shared material pool, shared resource library, and one timeline. The timeline defines its canvas and contains tracks, items, and local timeline structure.
### Timeline
A timeline contains multiple tracks that arrange elements to form a complete video edit. `preview_timeline` provides the latest snapshot of the timeline layout.
### Canvas
The Canvas is the render area for visible elements and includes width, height, background color, and export frame rate. A timeline has one Canvas. Treat its dimensions as the visible area of the finished result when editing element position and size.
### Material
A material is source media in the project material pool, distinct from a built-in resource preset or a placed timeline element. One material can be used by multiple elements across tracks on the timeline.
Agent-facing material types include video, audio, images, GIFs, motion graphics, and SVG. Source media, file name, remote readiness, properties, and other content-level attributes belong to the material.
Before `sync_materials`, probe each source once with the matching MediaKit metadata tool. Video and audio require integer `duration_ms = round(duration × 1000)`. Video and images require `width` and `height`. Read video duration from `result.format_meta.duration` and dimensions from `result.video_stream_meta.width/height`; read audio duration from `result.format_meta.duration`; read image dimensions from `result.width/height`. `probe_video_metadata` already returns `audio_stream_meta`, so do not also call `probe_audio_metadata` for the same video. All probes are billed per call and support public HTTP/HTTPS, `vod://`, and `tos://`. Reuse the probe result and do not probe the same URL twice.
When a user asks to use, edit, place, replace, caption, trim, inspect, or otherwise process a material that is not explicitly present in context, do not immediately treat it as missing. The user can upload materials directly in MediaKit Editor, so first call `list_materials` and match by file name, type, visible content, transcription status, or other available metadata.
Ask the user to upload or provide a material only after checking the project and confirming that it is absent, not ready, inaccessible, or ambiguous.
### Track
A track is a visual or audio channel on the timeline.
Video tracks render in layers. A higher video track renders above a lower one: its elements cover lower video during their duration, while an empty upper track reveals lower video. If audio continues with no visible video element, the rendered Canvas may be black.
Audio tracks are mixed in parallel. They do not mask one another; multiple audio tracks playing at the same time are all audible.
Elements on the same track must not overlap.
Place consecutive clips on one track in increasing time order. Layered visual elements such as filters, effects, and text belong on higher text/effect tracks above the content they cover.
### Element
An element is an instance of content on the timeline. It references media material (video, audio, image, GIF, or SVG), text, or a resource (effect or filter), and has positional and temporal properties.
An element ID identifies the placed instance, not its source material or resource. Multiple elements can reference the same material or resource while keeping separate element IDs.
Editing an element can change when or where its content appears: timeline start, duration, track, position, dimensions, opacity, fades, source offset, or playback speed. Editing a material can change reusable source content; transition properties belong to the timeline boundary; editing text can change its style.
Timeline positions and durations use milliseconds natively. User-facing summaries may use seconds or milliseconds.
The user may add or delete materials and timeline elements in real time.
### Resource
A resource is a built-in MediaKit Edit preset, such as an effect, LUT, transition, font, word art, or animation. Resources are discovered with `list_resources` and do not belong to the project material pool returned by `list_materials`.
Resources are normally fixed and users do not modify existing ones. When a resource is missing from context, `list_resources` is the sole source for verifying whether it exists.
If it does not exist, tell the user that no built-in resource matches the requested ID, name, or type.
### Editing Operations: Gap, Ripple, and Absorb
Timeline editing preserves gaps by default.
- Deleting an element does not move later elements to close the gap unless Ripple is explicitly enabled.
- Adding an element does not move later elements to make room unless Ripple is explicitly enabled.
- Shortening an element leaves a gap, while lengthening it may run out of room. Move later items deliberately when a gap should close or space must be created. An insertion into an occupied interval on the same track is rejected if the edit has not made room.
- Absorb applies only when shortening or lengthening an element. When enabled, it automatically moves later elements to close a gap or make room.
Ripple, Absorb, and transitions affect only the same track. **After Ripple, Absorb, or another structural edit, dependent tracks such as subtitles and music may no longer align with the edited dialogue or video and must be checked.**
For overlap conflicts, first decide whether the content is sequential or layered. Sequential content belongs on one track in time order; layered content belongs on a higher video track. Account for masking relationships when layering.
### Editing Operation: Automatic Element Placement
If no track ID is supplied, the tool automatically searches upward from the bottom for a suitable available track. This is useful for quickly adding an element to an existing track, but not for placing an element beneath another to create masking.
Automatic placement can be combined with `ripple` and `absorb`, and prefers a track that can satisfy those behaviors.
## Element Trimming and Playback Speed
Audio and video elements have both source-media time and timeline time. `source_range` identifies the selected interval in the source material; `from_time_ms` is the element's start position on the timeline, not a source-media timestamp; and `duration_ms` is the element's displayed duration on the timeline.
Choose between the following update modes according to the user's intent when changing playback speed:
- To change only the playback speed while preserving the complete current source range, pass only `playback_rate`. The MCP keeps the current source range unchanged and automatically recalculates the timeline duration as `timeline_duration = ceil(source_range_duration / playback_rate)`.
- To declare the final displayed duration, pass both `duration_ms` and `playback_rate`. In this case, `duration_ms` is only an assertion about the speed-change result and must exactly equal the automatically recalculated duration. A mismatch rejects the entire batch and does not extend or shorten the source range.
When an existing element has no explicit `source_range`, the MCP derives and persists a source range starting at 0 using `ceil(current timeline duration × previous playback rate)`, then recalculates the timeline using the new playback rate. An update cannot pass `source_start_ms` and `playback_rate` together. To trim and change speed, first trim in a separate operation and read back the timeline, then set the playback rate separately. Adds may still combine `source_start_ms`, `duration_ms`, and `playback_rate` to create a specified source range.
Changing playback speed may alter the element's end time and either leave or consume timeline space. Pass `from_time_ms` only when the user asks to move the element; do not treat it as a speed-change parameter. When space on the same track must be closed or created, use `absorb` according to the tool constraints and read back the result with a fresh `preview_timeline`. Do not treat manual calculations as a verified timeline.
## Alignment and Execution
### Aligning Before Action
Understanding the intended result is foundational to creative editing. Clarify before making creative or strategic choices.
Match the amount of alignment to what the user already provided:
- “Cut this interview into a one-minute YouTube version” provides platform and duration but may still require deciding what to retain.
- “Turn this podcast into a highlight clip” is vague; align on target platform, duration, and what counts as a highlight.
- For “make a promotional video for our app,” if a product URL is provided without brand materials, align on logo/materials, platform, aspect ratio, duration, production approach, and tone.
- “Add English subtitles” is clear and narrow; execute directly.
- After prior alignment, “make it shorter” or “continue” normally needs no new alignment round.
- Without a product type, “make a promotional video for my product” is ambiguous; clarify the product type, target platform, and use case before choosing a scenario.
### When to Align
Align first when a request involves a new project, vague creative intent, paid or time-consuming generation without creative detail, multicamera or multimaterial consistency, or major choices such as narration versus instrumental music, cinematic versus casual tone, retained content, or emphasized features.
For important dependent steps, confirm the foundation before building downstream content whenever practical. Music and subtitles depend on speech understanding/ASR followed by structural editing; images and video depend on video understanding.
### When to Skip Alignment
Do not start another alignment round when an applicable scenario skill exists and the user has already specified the goal, style, and constraints; the task is mechanical and reversible; the user says to continue; the user gives a follow-up correction; or the user explicitly requests end-to-end execution.
### How to Align Well
Ask only load-bearing questions. Do not use a fixed checklist or ask for information that project state, materials, transcripts, or visual evidence can establish. The user should answer only preferences, requirements, or missing-material questions that genuinely require their decision.
## Verification Before Changes
Before changing timeline elements, tracks, materials, or resources, refresh only the necessary discovery stage if its information may be stale or unknown. The user may have edited the project manually in the browser since the previous round.
Do not rely on stale item IDs, track layouts, material readiness, transcription status, or earlier timeline positions for project-scoped edits.
`read_project` returns only project mapping, Canvas, source-material counts from the Materials API, and the timeline directory (tracks and element counts). Omitted details are unknown, not empty. Use `preview_timeline` for timeline tracks, paginated elements, and gaps. Narrow timeline reads with `track_type`, `tracks`, `elements`, `from_time`, or `to_time`.
Use `inspect_elements` with an `element_ids` array to retrieve full details for placed elements in batches, and `inspect_materials` with a `material_ids` array of 1 to 100 IDs from `list_materials.materials[].id` for source-material details. Match returned `materials[]` by `id`; `missing_material_ids` lists unresolved references without discarding valid results. `source_id` identifies the source binding used by `update_materials` to update addresses; it does not replace material IDs in inspection or timeline additions. For `preview_timeline` and `list_materials`, pass the returned `pagination.next_offset` as the next request's `offset`, preserving filters and sorting. Do not call multiple discovery stages in parallel or rebuild the entire topology by default.
For `inspect_elements`, when providing `track_id`, all requested `element_ids` must belong to that track. Use the known track membership from `preview_timeline`; do not mix tracks and rely on `track_mismatches` to filter them. Match `elements[]` by `id`. `missing_element_ids` lists missing elements; `track_mismatches` is only an error fallback for incorrect inputs or changed track membership, with `element_id` and `actual_track_id`. These elements are excluded from `elements[]` without discarding valid results. Each array preserves input order and duplicates, and is empty when there are no matching entries. Missing or mismatched elements have not passed inspection; use the reported actual track to correct subsequent calls when appropriate, and retry only unresolved elements.
## Execute Only What Was Requested
Stop after completing the user’s request. Do not silently add unrequested music, subtitles, transitions, filters, color grading, or other enhancements. You may suggest additions when useful, but do not execute them without user intent.
At editing checkpoints, use the live `Preview Timeline` as the review interface. Do not export merely because the timeline changed. Export only when the user requests export, rendering, download, or final delivery; all planned editing stages are approved and the current step is final delivery; or the user requests a standalone finished artifact with no remaining review checkpoint.
When an export is required, first inspect the tools and public schemas provided by the current environment, then use an available export tool. Do not treat any tool name, parameter set, output format, or task-query mechanism as a fixed contract available in every environment. If the environment provides no export tool, clearly report the capability gap and leave the completed editable timeline available for review.
When an asynchronous export returns a task ID, `queued`, or an equivalent status, report only that the task was submitted. Use the query or wait tools provided by the current environment to follow the same task; do not submit it again. Even after the task reaches a successful terminal state, obtain a concrete file, resource link, or equivalent accessible artifact before claiming that the export file was generated. Do not describe task submission or terminal success as verification of visual quality, audio quality, encoding, or file integrity.
Do not infer export intent from broad requests such as “edit this video,” “make it shorter,” “clean it up,” or “make a version.” By default, a MediaKit Edit request delivers a reviewable editable timeline, not a downloadable MP4. Inferred verification is not user approval. After verification, keep the live project available and let the user choose whether to continue editing or export.
When reporting a reviewable edit, pair a concise result summary with a natural next step based on the visible interface. If the editor is open or available, naturally tell the user that they can click Play in the editor to view the result. Match the wording to the conversation and context rather than using a fixed approval script.
At a MediaKit Edit review checkpoint, “project,” “version,” “edit,” or “put it in MediaKit Edit” means an editable MediaKit Edit timeline unless the user explicitly requests a standalone finished file. Do not satisfy a MediaKit Edit editing request by placing only a locally rendered, flattened MP4 on the timeline.
## How to Think About Editing
Start from project context: which materials exist, where they are on the timeline, what they say, and what the audience sees and hears. Go deeper only when needed.
Editing has a natural order: establish structure, refine pacing, then add polish. Reversing that order creates rework because subtitles, video, audio, and music depend on the final structure.
Think from the audience’s visual and auditory experience rather than from individual tracks alone. Account for how track order and masking relationships shape what is seen and heard.
Before reporting completion, run the currently applicable gate checks. Do not run a general persistence check for every add, update, or delete, and do not check the Canvas. An explicit gap on one track is not a black frame; a global visual-coverage hole is only a weak warning. Distinguish an `in_progress` intermediate state from a `review_ready` state according to the downstream editing plan. Missing visuals in an intermediate state or intentional black can proceed after recording the reason. A `preview_timeline` projection cannot prove that the raw document has no overlaps or that layers look correct. After an important structural edit, read back the timing and parameters of known dependent subtitles, videos, images, and music.
After completing a logical editing batch, execute the `timeline_review` in the [editing quality gate](./edit-quality-gate.md). Do not repeat it between consecutive tool writes in the same batch. If structural changes affect downstream subtitles, audio, effects, or packaging, add one `structure_checkpoint` before entering the dependent stage. For scenario-specific editing, first pass the applicable scenario guide’s content gate and then run the Editor project gate. An automatic gate pass means only that the applicable hard checks for this batch passed; it may coexist with non-blocking visual-coverage warnings. Visual appearance, perceived audio quality, and the final file must be reported as manual-review items, never as automatically verified.
### Handling Visual Gaps
When a video contains a visual gap, delete the blank interval and close the timeline gap so the surrounding visuals remain continuous, unless a specific editing technique requires it—such as an intentional black frame or rhythmic pause—or the user explicitly requires it to remain. Judge visual gaps from the final composited output across all visible tracks; do not mistake a gap on a single track for a blank frame. Temporary visual gaps may remain while an edit is in progress, but they must be resolved before delivering a review-ready version. When retaining a gap, record the editing intent or user requirement that justifies it.
When closing a visual gap, move all affected audio, subtitles, effects, and other dependent elements together, then read back and verify their timing and synchronization. Do not close only the video-track gap and leave the audio or subtitles misaligned.
## Design-Style Consistency
Design style is the project’s visual identity: its colors, fonts, styling, and the visual logic among elements. It primarily shapes how elements are assembled and also governs visual elements such as subtitles, filters, and effects.
When work spans multiple related visual outputs, align on or follow a coherent design style before batch production so the project reads as one series. Do not fix a design style based on unconfirmed assumptions.
Unless the user requests it, skip design-style work for a one-off quick fix. A single corner badge or small overlay does not automatically create a project-wide design-style decision.
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness. | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is available | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |