ChatCut

View saved version →

---
name: asset-import
description: Import local or downloaded media, or relink missing media to an existing ChatCut asset, through the hosted Codex plugin. Use the editor loopback bridge when the editor and files are on the same machine; use the upload helper for imports otherwise. Desktop MCP sessions use their own built-in import tools.
---

# Asset Import

Check `browse_assets` first when a file may already be imported.

## Same-machine editor import (preferred)

1. Open the target project using `browserHandoff.url` or `editorUrl`. Keep exactly one editor tab for this project open, on the same machine/network namespace as your shell. A remote sandbox's localhost is not the user's localhost.
2. Start the bundled server using Codex's bundled Node runtime when available, otherwise Node 18+ from PATH, and the origin of the actual editor URL:

```bash
"<bundled-or-global-node>" <this-skill-dir>/scripts/serve-local-media.mjs --origin <editor-origin> /path/to/source.mp4
```

Keep this process alive using the host's background-process support while calling MCP. It prints one JSON line and automatically exits after 900 seconds. It serves only the listed files over tokenized loopback URLs.

3. Import multiple files in **one** `import_media` call: `{"action":"from_editor","files":[...]}`. Copy each file's `assetId`, `url`, `filename`, and `sizeBytes` from the printed `imports` array into `files`, omitting its per-file `action`. Each URL may come from a different running helper. Send 1–16 files per call; for larger sets, submit successive batches of 16. Up to eight files are processed concurrently; the editor streams each one straight into its local store, so a card with transfer progress appears as soon as the download starts. There is no loopback-specific file-size cap. The original top-level single-file arguments still work.
4. Inspect every entry in `results`: successful entries have `ok:true` and `status:"locally_imported"`; failed entries have an `error`. Results preserve input order and include `assetId` and `filename`, with top-level `succeeded`/`failed` counts. Retry only failed files with the same asset IDs. Success means the editor has persisted local bytes and registered the asset locally. Stop the helpers only after all files succeed. Keep the editor open for server sync, background upload and transcription.
5. Use the returned asset IDs for timeline work. Wait on `track_progress target:"transcription"` before transcript/caption work. Browser-renderable timelines defer original-file uploads; cloud-only or unsupported timelines upload automatically. Check `browse_assets` before waiting on `target:"upload"`; a deferred upload is not in progress. Use the editor's Upload action when cloud bytes are needed, preserving the same asset ID. If server sync is still catching up, retry the asset lookup.

On timeout, check `browse_assets` and retry with the **same assetId**; the import may still be running, and a retry resumes an interrupted download from where it stopped rather than starting over. Keep the same ID even if restarting the helper changes its URL. Do not blindly start a second import. Allow the editor's browser local-network permission if prompted. If the editor cannot reach the helper or the bridge is unavailable, use the fallback. A host-policy denial is not permission to try another transfer route.

For visual analysis, inspect readable original files locally rather than waiting for cloud upload. Import original source assets; do not flatten an edit into a local pre-render.

## Relink an existing asset

For missing local media, preserve the existing asset and its timeline references:

1. Get the existing `assetId` from `browse_assets` and locate its corresponding original source file.
2. Serve that file with the same loopback helper above.
3. Call `import_media` with the helper's `url`, `filename`, and `sizeBytes`, but set `action: "relink_from_editor"` and replace the generated `assetId` with the **existing assetId**

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 2 — file references are metadata, not package contents.

View saved version →

---
name: chatcut-plugin-basics
description: "Must read before using the hosted ChatCut plugin in Codex, including creating projects, opening the editor, or editing/creating videos. Also use when ChatCut tools are missing or need authentication. For ChatCut Desktop, follow its own instructions unless the user explicitly chooses the hosted plugin/web surface."
---

# ChatCut Plugin Basics

## Purpose

Host scope: this skill is written for the Codex host. In Claude Code, use the `chatcut-plugin-basics-claude` skill instead of this one.

Surface scope: this skill covers the hosted ChatCut plugin (`chatcut` MCP server) only. When the conversation uses ChatCut Desktop (`chatcut_desktop*` servers), follow the desktop server's own instructions and skip this skill unless the user explicitly chooses the plugin/web surface — desktop media is registered locally (no uploads) and delivery happens in the ChatCut Desktop window, not a browser.

Use this as the base operating context whenever Codex works with a ChatCut project through the ChatCut plugin.

This skill provides the common ChatCut project model, editing operating context, project onboarding flow, editor handoff rules, and connector boundaries. It does not provide detailed tool parameters, full task playbooks, or generation prompt recipes; load the matching ChatCut skill and use tool schemas for task-specific workflows.

### MCP setup and authentication

MCP-only setup rule: check the hosted `chatcut` MCP registration and
authentication first and use that connection exclusively. Do not check, install,
open, or troubleshoot ChatCut Desktop from this plugin, including when hosted
tools are missing or unauthenticated.

ChatCut tools are served through the configured Hosted `chatcut` MCP server, whether registered directly or provided by an existing plugin. Route tool calls through `mcp__chatcut__*` and treat the active MCP manifest as the runtime contract.

If the tools are available and authenticated, continue normal work without reinstalling or starting a new session. Otherwise, check registration with `codex mcp get chatcut` (or inspect Codex's MCP settings when the CLI is unavailable). If it exists, use that server and do not create a duplicate. Follow the matching MCP path:

1. **Server not registered:** Offer to register the Hosted MCP server directly. Do not install, reinstall, repair, or enable a plugin to obtain the server:

```sh
codex mcp add chatcut --url https://api.chatcut.io/api/external-mcp/mcp --oauth-resource https://api.chatcut.io/api/external-mcp/mcp
```

Codex stores direct MCP registrations in its `config.toml`, not a project `.mcp.json`. Preserve other configuration and set `http_headers = { "x-chatcut-mcp-surface" = "codex" }` inside the `mcp_servers.chatcut` table created by the command; `codex mcp add` does not expose a static-header flag. If an available ChatCut `.mcp.json` specifies a different URL, OAuth resource, or headers, use those values instead of the example. Never retarget an existing registration or store auth tokens in configuration. Without the CLI, add the same HTTP server and header through the host's MCP settings if supported. Verify registration with `codex mcp get chatcut`, then complete authentication below.

2. **Server registered but authentication required:** Offer to run `codex mcp login chatcut` and have the user complete the browser sign-in. Without the CLI, have them re-authorize ChatCut in Codex's MCP/connector settings. An unauthenticated server can return 401 and leave the session with no tools; reinstalling does not fix that. Do not assume every missing-tool case is an auth failure: if authentication succeeds but tools remain absent, start a new session and check the server's reported connection error.

Explain whether registration, authentication, or connection failed and provide the matching concrete step, rather than only saying ChatCut is unavailable or asking the user to reconnect. Directly registering the Hosted MCP serve

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: create-motion-graphics
description: "Use when Codex uses the ChatCut plugin (chatcut MCP server) to add, create, hand-author, patch, or place Motion Graphic JSX assets. Covers reference browsing, direct inline JSX authoring, editable properties, asset binding, timeline placement, and composed verification."
---

# Create Motion Graphics

## Plugin host and project

Use the `chatcut` MCP server and the project ID from the user's editor URL or
the plugin's project result. This plugin works with the Web editor, including
local development URLs. Do not open ChatCut Desktop or use `chatcut_desktop`
for a Web project. If `chatcut` tools are unavailable, report the connection
failure; do not submit the task to the editor's native Agent as a substitute.

## Find MG references before designing

### Browse and confirm a visual direction

For production, reuse an accepted project style or user-supplied brand/reference.
Use `manage_design_style get` when its full spec is not already known. Routine
text/placement edits need no new style selection or catalog rescan.

When a new direction is needed or the user asks to browse alternatives, start
with `browse_library` `references: {view: "style-overview"}`. Read ALL numbered
contact sheets, following `nextOffset` until `complete`. They contain published,
agent-enabled style representatives, including linked existing Design Styles.
`list_presets` is only the legacy catalog subset; it cannot replace this visual
overview. Retry a failed page; report an incomplete overview instead of silently
skipping it.

For speech-led video, understand the spoken content and inspect representative
video frames before shortlisting styles. Reuse transcript and frame evidence
already in context. Consider the topic, delivery tone, on-screen language, and
the footage's color, subject framing and background alongside the style previews.

When the visual direction is not yet agreed, shortlist up to 6 distinct fits
for the current content and footage, and read their `hero` parts. Load the
host's `widget-forms` skill and show actual `heroPreview.url` images
with short names. Tool-returned images are evidence for the agent, not a
user-facing picker; text-only choices do not show the visual differences.
Keep each choice mapped to its reference ID; use the form's Other branch
for preferences or another batch
without repeating choices or adding a separate Show more option.
Wait for the selection before applying a new style and producing the MG,
unless the user has already chosen a direction or explicitly delegated the
style choice. An Other answer is not acceptance.

### Apply the selected style

Read the selected representative's `summary`, `hero` and `members`. Follow its
`designStyleAction` with `manage_design_style`:

- `apply_preset`: use the returned `presetId` directly; do not clone or update
  the preset merely to save reference metadata.
- `apply`: reuse the returned `designStyleId` for an existing saved user style.
- `create`: only an independent reference needs a new user-owned style. Define
  and save its palette, fonts and reusable visual rules from the selected reference.
  Reuse the reference's documented palette; if absent, derive a coherent palette
  from its representative image. Save `designSpec.referenceSources: [{id: "<reference ID>"}]`
  and the individual `heroPreview.url` in BOTH `thumbnailUrl` and
  `designSpec.images: [{role: "style reference", url: "<heroPreview.url>"}]`.
  Use `applyToProject: true`; preserve existing images when patching an array.

After applying, call `get` for the fresh full spec and source IDs; do not carry
over the previous style's cached rules. For a new style, verify that its palette,
fonts, source, cover and reference image were saved. A source ID alone does not
save an image.
Reference images are visual evidence, not footage/backgrounds to embed or
example copy to reproduce.

Use `fontRecommendations["zh-Hans"]` / `.en` according to the actual on-screen
text, i

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 2 — file references are metadata, not package contents.

View saved version →

---
name: digital-human
description: Create and manage script- or audio-driven AI avatar videos from an official or saved presenter, an imported portrait, or a representative still prepared from video. Use for 数字人、数字分身、虚拟人、照片开口说话、人像口播、改稿不重拍, AI avatar, AI avatar video, avatar video, talking avatar, talking photo, photo avatar, video avatar, AI presenter, virtual presenter, virtual spokesperson, digital human, or a person's digital twin, including choosing or creating the avatar and deciding its voice, script, aspect ratio, and output quality. Do not use for a static profile-picture avatar, game or 3D character creation, an industrial digital twin, ordinary B-roll, generic image-to-video, video translation, talking-head editing, lip-sync dubbing alone, or TTS-only requests.
user-invocable: true
---

# Digital Human

Create a reusable presenter identity or generate a lip-synced presenter video
without exposing the underlying provider. Treat avatar selection, speech, script,
format, consent, generation, and verification as one stateful conversation.

## When to Use

Use this skill when the user wants to:

- Make an official or saved AI avatar, talking avatar, or virtual presenter speak.
- Turn a consented portrait into a reusable digital-human identity.
- Use a representative still from an imported video as a photo avatar.
- Create a synthetic AI presenter from a description, when live capabilities allow it.
- Draft or revise the narration for a digital-human video.
- Regenerate, reorder, remove, retry, or accept segments from an avatar-video batch.

Treat **AI avatar** as the broad default English concept. **Digital twin** means a
reusable likeness of a specific real person; **photo avatar** or **talking photo**
means a still-image source; **AI presenter**, **virtual presenter**, and **virtual
spokesperson** describe the presenter's role. **Digital human** is valid but is often
used for broader enterprise or interactive experiences.

Route adjacent requests elsewhere:

- Speech, voice audition, or voice cloning without avatar video: use the Voice Skill.
- Ordinary footage cleanup or presenter editing: use the Talking Head Guide.
- Generic image-to-video or video generation without a speaking avatar: use the
  Video Generation Skill.
- Translation or dubbing of an existing video: use the dedicated translation or
  dubbing workflow when available.

## Required Inputs

Resolve these slots before submission, but do not ask for them in a fixed order:

1. **Target project** — use the active project when it is unambiguous.
2. **Avatar identity and ready revision** — an official avatar, a saved avatar, or
   a newly created photo or synthetic avatar.
3. **Speech source** — one exact available voice, one cloned voice, or one imported
   audio asset. A text-driven source also requires the final script.
4. **Final script** — preserve the user's wording and punctuation. Show any AI-written
   draft in full and let the user edit or approve it before generation.
5. **Aspect ratio** — `auto`, `1:1`, `4:5`, `5:4`, `9:16`, or `16:9`. Explicit user
   choice wins; otherwise omit it so the backend uses `auto` and preserves the
   selected avatar's original framing. Do not substitute the current project ratio.
6. **Resolution** — `1080p` by default; use `720p` when requested or when live
   capabilities require it, and explain any fallback.
7. **Optional controls** — motion guidance only when the live capability response
   says it is supported. For an official catalog avatar, use its returned
   `hasBackground` value: preserve the original scene when true and request a
   transparent background when false. For a saved/custom avatar, preserve its original
   background by default. Request a transparent background only when the user explicitly
   asks to remove the background or use transparency. Do not ask the user to choose a
   background mode; briefly state the resolved default before submission. An explicit
   user request to preserve or remove

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: export
description: Hosted ChatCut plugin sessions only (the `chatcut` MCP server). If the conversation is driving ChatCut Desktop (a `chatcut_desktop*` MCP server), load this skill only when the user explicitly chooses the plugin/web surface — desktop sessions otherwise ship their own instructions and tools. Export or deliver a ChatCut project through the hosted connector, including video, audio, subtitles, XML, and render-status checks.
---

# Export

Export only when the user asks for a render, download, or final standalone deliverable. A review checkpoint normally stays as an editable ChatCut timeline.

Use `submit_export` with the current tool schema. Confirm the target timeline, range, resolution, codec, and format from project state and user intent; do not guess a non-active timeline. Record every returned `renderId`.

Use `track_export` for status. It is the render-job tracker; do not use generation/transcription `track_progress` for exports. For the latest project export, use the tool's latest-render option when available rather than guessing an id.

When a render completes, return its `downloadUrl`. In Claude Code, download the completed file to a collision-safe local path and provide the path, local-file preview link, and concise render metadata. In Codex, surface the completed download URL through the host's normal file/link delivery. Do not claim delivery from a queued or running render.

For subtitle or NLE XML export, use the corresponding `submit_export` format and report warnings about unsupported or dropped elements. For transparent Motion Graphic delivery, use the dedicated MG export tool exposed by the current manifest and track the returned render ids.

If cloud rendering is blocked by media that is not remotely readable, use `asset-import` when the user permits upload. Otherwise report the blocker; do not flatten or substitute the edit locally without user intent.

View saved version →

---
name: known-errors
description: Diagnose ChatCut plugin tool failures, rejected mutations, unexpected response shapes, and blocked import, generation, or render operations.
---

# Known Errors

Treat the active MCP tool schema and returned structured error as authoritative. Do not retry with remembered legacy payloads when the current manifest differs.

## Mutation Rejections

- On same-track overlap, do not force the write or silently delete the conflicting item. Decide whether content is sequential or layered, choose an available track when appropriate, or ask which item should win.
- On locked-track or stale-id failures, refresh the affected timeline scope and retry only with current ids and state.
- On validation errors, change only the rejected field or transaction shape; preserve unrelated project state.

## Import And Media

- Hosted plugin surfaces use the `asset-import` adapter and `import_media`; do not substitute backend-only `push_asset` or `download_media` calls when they are absent.
- If media conversion fails, use the helper's structured retry when provided. Otherwise explain the unsupported source and ask for a compatible replacement; do not repeat the same failing editor import path.
- Wait for upload only before byte-dependent operations. A known asset id can be used for metadata and timeline placement while bytes continue uploading.

## Generation And Motion Graphics

- Use only generation tools visible on the current host. Codex and Claude Code plugins direct-author Motion Graphics with `create_motion_graphic_from_code`; the built-in ChatCut Agent may expose `submit_motion_graphic`.
- Preserve the original provider or content-policy failure. Do not spend credits on repeated identical retries or silently switch models.

## Verification And Export

- A successful mutation is not visual proof; load `verification` when the result must be seen.
- Use `track_export` for render jobs. If cloud render cannot read an asset, resolve remote readiness through `asset-import` only with user permission, or report the limitation.

On auth or project-access errors, verify the exact project id and that the editor and plugin use the same ChatCut account before attempting code or infrastructure debugging.

View saved version →

---
name: multicam-sync
description: Synchronize footage from a multi-camera / multi-recorder shoot — several cameras plus separate audio recorders covering one session, imported as loose clips — and optionally turn all or part of it into speaker-follow footage for a larger edit. Use when a user drops in multiple clips from the same recording and wants them aligned, asks for multicam / 多机位 / multi-angle sync, wants a "cut to whoever is talking" edit, or refers to camera A/B, angles, or separate lav or field recordings that need to line up with picture.
user-invocable: true
---

# Multicam Sync

Parts 1–3 always run: they produce the synced master, a verifiable fact that every
later edit is rebuilt from. Part 4 cuts a draft from it, and runs only on request.
Transcripts do almost all of the work. AI locates; arithmetic decides frames.

Use ordinary timelines, tracks, and items only. Never create a compound or nested
multicam clip, and never depend on a camera-switcher item. If a main edit already
exists, leave it untouched while building the synced master and speaker-follow
cutting board on separate timelines.

## Part 1 — Discover the structure

Work out what you actually have before aligning anything. Never ask the user how many
cameras there are. The material already answers it.

### The two rules that do the work

**Same words at the same moment → cannot be sequential spans of one camera.** Overlapping
transcripts mean two devices recorded one event simultaneously, so they are different
sources or simultaneous angles.

**No shared words, and one ends where the next begins → one camera that stopped and
restarted.** These are sequential spans of a single capture source, not separate angles.

### Steps

1. Read every asset's transcript, build a pairwise overlap matrix — how much text
   each pair shares, and where — and split by the rules above.
2. Video assets are **angles**; audio-only assets are **recorders**.
3. Corroborate with filenames, folder structure, camera-model metadata, durations —
   tie-breakers only, never over transcript evidence. Real shoots ship three cameras
   all named `C0001.MP4`.

### Report before acting

State the structure in the user's terms and wait if anything is ambiguous:

> 2 camera angles (Pocket3, 3 spans · Pocket4, 2 spans), 2 audio recorders
> (MIC1, MIC2). Session runs 53 minutes.

When evidence is thin — a source with little speech, an overlap resting on a handful
of matched lines — say so. Do not fill the gap with a guess.

## Part 2 — Align and place

One number per clip: timeline time minus source time. Keep that number constant for
every piece cut from the clip. Do not time-stretch automatically: a changing offset
may be a bad match, a clock difference, or dropped frames, and each needs review.

### Steps

1. **Reference**: the source that covers the whole session with the richest transcript —
   usually a dedicated audio recorder, not a camera.
2. **Use the renderer when available**: on the separate master timeline, put the
   untrimmed clips on ordinary source tracks, then call `multicam_sync` with the
   same-take items and the reference. This is the preferred Web/Desktop path. It
   uses existing source timing when decisive, otherwise audio correlation; it does
   not create a multicam object.

   Accept only `applied`, `already_synced`, or an understood `partial` result. Read
   `alignmentEvidence` for method, match confidence, correlation, overlap, and
   relative offset. Read `placementEvidence` for the actual post-sync
   `timelineSourceOffsetSeconds`. Do not use a skipped or low-confidence item. If
   the tool is unavailable or finds no confident alignment, leave the master
   untouched and use the transcript fallback below.

3. **Transcript fallback**: run
   `scripts/transcript-offset.mjs <utterances.json>` from this skill. Do not
   improvise the math. It first lets shared phrases vote on a coarse offset, then
   takes the median of near-identical utterance-pair deltas. I

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: music
description: Shared ChatCut entry point for newly generated music, soundtrack, theme music, 配乐, background music, an intro theme, a music bed, BGM, or vocal songs. If vocals are unspecified, ask whether the user wants a vocal song or instrumental music before choosing a generator. Use `submit_music` for either branch, with `generationType` selecting instrumental or song mode.
user-invocable: true
---

# Music

Use `submit_music` to create a new instrumental background-music or vocal-song audio asset. For an explicit sung song, lyrics-to-song request, or vocal MV song, read [`references/song.md`](references/song.md) for the lyric workflow, then call `submit_music` with `generationType:"song"`. When a request only says music, soundtrack, theme music, or 配乐 and does not specify vocals, ask the user to choose vocals or instrumental first instead of assuming.

The tool submits one generation job and returns a `jobId`. The generated audio asset is available after `track_progress` reports completion.

## Capability Boundary

Mureka creates a new original music asset; it does not edit, clean up, remix, separate, or adjust existing audio.

Mureka also cannot guarantee exact beat, drop, lyric, or timestamp alignment. Generate the music asset first, then use timeline tools for placement, trimming, looping, fades, and ducking. If the user requires precise beat-level sync, explain that this must be handled as a timeline/audio edit rather than guaranteed by the generation model.

## Workflow

1. Treat the vocal choice as a required gate before asking about style, mood,
   duration, instruments, or any other creative detail. Words such as music,
   soundtrack, theme music, 配乐, "for this video", or "for an MV" do not
   resolve that choice. If the user has not explicitly chosen vocals or
   instrumental music, reply only with the equivalent binary question in the
   user's conversation language. For Chinese use "要带人声的歌曲，还是纯音乐/无
   人声配乐？"; for English use "Would you like a vocal song or instrumental,
   no-vocals backing music?" Do not spend credits or ask other questions in
   that turn.
2. For explicit instrumental, BGM, music-bed, or no-vocals requests, write a
   concise prompt describing style, energy, instrumentation, mood, tempo, and
   edit role, then call `submit_music` with `generationType:"instrumental"`.
3. For explicit singing, lyrics-to-song, or vocal-MV requests, read
   [`references/song.md`](references/song.md), resolve lyrics and creative
   direction there, then call `submit_music` with `generationType:"song"`.
4. Provide a short descriptive `name` when useful.
5. Use `track_progress` if the next edit needs the completed asset.
6. Place, trim, loop, or duck the audio with timeline tools after the asset
   exists.

## Tool Input Shape

`submit_music` accepts:

- `generationType` — `instrumental` (default) for no-vocals BGM, or `song` for
  an original vocal song;
- `prompt` — required for instrumental mode and optional music/vocal direction
  for song mode; maximum 1,024 characters;
- `lyrics` — required for song mode and invalid for instrumental mode; maximum
  5,000 characters;
- `gender` — optional `female` or `male` preference for song mode only;
- `name` — optional descriptive asset name.

## Prompt Shape

For instrumental music, combine:

- genre or instrumentation: "minimal electronic", "warm acoustic guitar", "cinematic piano";
- energy: "upbeat", "calm", "tense", "confident";
- role: "under a product walkthrough", "intro sting", "background bed under speech";
- constraints: "not distracting", "no vocals", "short loop feel" when needed.

## Rules

- Never route an ordinary BGM request to vocal song generation, even if the
  prompt is stylistically ambiguous.
- Do not cover speech with loud music; lower volume or duck under narration.
- Do not call the generation path to remix, clean up, separate, or replace an
  existing copyrighted recording. The result is a new original asset.
- Submit one generation

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: product-help
description: Answer current ChatCut product questions using the latest official Docs, Releases, and Changelog. Use for how ChatCut works; UI layout, buttons, and feature instructions; troubleshooting; feature or fix availability on Web, Desktop, or Agent Plugin and minimum version requirements; credits including costs, balance, usage history, validity, or recent charges; plans, subscriptions, renewals, ChatCut Pro, pricing, card or Alipay (支付宝) payments, and billing; Desktop downloads; Agent Plugin installation or updates for Codex and Claude Code; and manual GUI guidance when an action cannot be completed directly. NOT for live project, asset, timeline, or item state; use the matching read tool instead.
user-invocable: false
---

# ChatCut Product Help

For a ChatCut product question, the first substantive action is to search the
exact topic within `https://chatcut.io/docs` and open the most relevant official
page. Do not answer from memory, a search snippet, or an unopened result. Use the
host's native search and page-reading capabilities; this Skill defines retrieval
and decision rules, not a second copy of product facts.

## Route the question

- For live project, asset, timeline, item, account, or job state, use the matching
  ChatCut read tool. If the question is only about live state, no Docs lookup is
  needed.
- For current behavior, visible UI labels, installation, credits, pricing,
  billing, and troubleshooting, use the owning product Docs page.
- For availability, regressions, or version requirements, use **Current versions**
  and the **Changelog** in addition to the owning product Docs page.
- For a mixed question, use tools for live state and Docs for what that state means
  or what the user should do next.

Treat this Skill only as stable routing guidance. Never answer a changeable
product fact from remembered Skill content when current Docs can be checked. Do
not use unofficial domains.

## Establish the relevant product surface

Before answering a surface- or version-dependent question, identify both the
surface hosting this agent and the surface the user is asking about.

- Prefer the explicit ChatCut runtime profile or the latest `[chatcut-runtime]`
  envelope. Map `chatcut-web-editor` to Web, `chatcut-desktop` to Desktop, and
  `chatcut-workbench-client` or `chatcut-chat-connector` to Agent Plugin.
- When Agent Plugin is hosted by ChatCut Desktop, treat its bundled Skills as part
  of the Desktop installation. A Desktop update updates that Plugin surface too;
  never ask the user to update the Plugin separately in this runtime.
- A user can ask an Agent Plugin about Desktop, or ask Desktop about a Web project.
  When the user names a target surface, answer for that target instead of assuming
  it is the same as the agent's host surface.
- Use an app URL, client name, or version supplied by runtime context as supporting
  evidence. Do not infer the current surface merely because the user mentions a
  product in an example.
- If no reliable signal exists and the surface changes the answer, ask which of
  Web, Desktop, or Agent Plugin they are using. If the answer is surface-independent,
  proceed without an unnecessary question.

## Find the smallest useful source

1. Extract the feature name, visible UI label, error text, product surface, and
   version from the user's question or runtime context when available.
2. Search the exact topic with a concise query containing only its essential terms.
   Prefer the most specific official result and open the smallest set of pages that
   establishes the answer.
3. For ordinary usage questions, start with the owning feature or troubleshooting
   page. For availability, regression, update, or version questions, directly open
   `https://chatcut.io/docs/releases` and `https://chatcut.io/docs/changelog`, then
   open the matching Changelog entry.
4. For one user question, issue at most two search queries total: the exact topic,
   then one narro

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: shader-gen
description: AI shader generator for WebGL video effects, transitions, masks, and color grading (LUT / 调色 / 电影感 / film look). Use when the user wants a video effect (滤镜 / 特效), a transition (转场 / crossfade / wipe / cube / 3d), a mask (蒙版 / 遮罩 / reveal), a zoom / push-in (推近 / 推镜头), or a color grade — try the built-in effects (zoom, builtin LUTs) before generating a new shader.
user-invocable: true
---

# Shader Generator

Submit-only: creates a backend generation job, returns `jobId`. Use the `track_progress` tool for job lifecycle after submission.

**Always use `generate.ts` for new shaders.** Manual authoring is only for editing existing asset code — never as a fallback when generation fails.

## Catalog-first rule — try existing assets before generation

Before generating a shader, call `browse_library` unless the user names an exact asset id that is already visible in `browse_assets`.

`browse_library` is the source of truth for built-in effects, built-in transitions, and project effect/transition assets. Built-ins are stable global asset ids, not per-project DB assets, so they may not appear in `browse_assets`.

Apply catalog entries with `edit_item`, do **not** call `submit_shader`.

Good catalog searches:

```text
browse_library(query: "zoom")
browse_library(category: "transitions", query: "dissolve")
browse_library(category: "audio-fx")
```

Generate only when no catalog entry matches the user's intent closely enough.

### `builtin:zoom` uses the same track-bound placement as every effect

Effects always have timeline geometry. For a whole-clip effect, pass `targetItemId`; ChatCut resolves it to a clip-anchored range covering that clip. For an explicit timeline range, pass `trackId` + `trackBoundFrom` + `trackBoundDurationInFrames`.

```text
# Zoom on the entire video clip
edit_item(json: '{"adds":[{"type":"effect","assetId":"builtin:zoom","targetItemId":"<clip-id>","propertyOverrides":{"magnification":1.5,"shape":"hold"}}]}')

# Zoom on a sub-range of the clip (e.g. frames 90–150 only, a punch zoom on a beat)
edit_item(json: '{"adds":[{"type":"effect","assetId":"builtin:zoom","mode":"track-bound","trackId":"<trackId>","trackBoundFrom":90,"trackBoundDurationInFrames":60,"propertyOverrides":{"magnification":2,"shape":"punch"}}]}')
```

Use `preview_timeline({views:["timeline"],tracks:["V1"]})` to obtain track item ids and timeline-frame ranges. Use `inspect_item({itemId:"..."})` when exact item detail is needed.

| Key             | Type   | Range / values                             | Default | Notes                                          |
| --------------- | ------ | ------------------------------------------ | ------- | ---------------------------------------------- |
| `magnification` | number | 1–4                                        | `1.5`   | Zoom factor; 1 = no zoom, 2 = 2× in            |
| `focalPointX`   | number | 0–1                                        | `0.5`   | Horizontal focal point (0 = left, 1 = right)   |
| `focalPointY`   | number | 0–1                                        | `0.5`   | Vertical focal point (0 = top, 1 = bottom)     |
| `shape`         | select | `punch` / `hold` / `slow-push` / `instant` | `hold`  | Animation curve                                |
| `focalMode`     | select | `auto` / `manual`                          | `auto`  | `auto` picks subject; `manual` uses focalPoint |
| `easeInFrames`  | number | 0–60                                       | `8`     | Frames to ramp in                              |
| `easeOutFrames` | number | 0–60                                       | `8`     | Frames to ramp out                             |

Omit `propertyOverrides` entirely for default zoom. Send only the keys you want to change — patch semantics.

### Clip-anchored vs adjustment-track

Effect items have two placements, both with a concrete time range:

- **Clip-anchored**: pass `targetItemId` for the whole clip, or include an explicit range that inter

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 5 — file references are metadata, not package contents.

View saved version →

---
name: talking-head-guide
description: Guide for editing speech-led videos where spoken delivery or conversation drives the cut — single-speaker talking-head / 口播, two- or multi-speaker interview / 访谈, video podcast, lecture, tutorial, course, and similar formats. Load before analyzing, planning, or performing non-trivial edits of those formats, including speech cleanup (剪口播 / 口播剪辑 / 去口癖 / clean up fillers / smooth speech), pause or repeated-take removal, motion graphics layered onto the footage (口播加 MG / 加动画), B-roll (加 B-roll / add B-roll), music, or captions. For motion graphics specifically, use this together with the active Motion Graphics skill/workflow available in the current ChatCut environment — this skill adds speech-specific guidance (rhythm-aware timing, frame-aware placement, subject/caption protection, placement verification).
user-invocable: true
---

# Speech-Led Video Editing (Talking Head, Interview, Podcast)

## What this skill covers

**Required input**: an existing speech-led source registered or imported into the project — for example a single-speaker talking-head / 口播, a two- or multi-speaker interview / 访谈, a video podcast, lecture, tutorial, or course. For transcript-based A-roll editing, follow `asset-import`, then start as soon as the transcript is ready. If the user wants to start without source footage (e.g., generate a fresh talking-head from scratch), this skill doesn't apply.

### When source media is missing

- **Inside ChatCut Web (including embedded agents):** Reuse source media already in the project or at a user-provided accessible path; otherwise, load `widget-forms` and include its native file-upload field (`<form-files>`) in the reply, together with any related edit preferences.
- **Standalone Claude Code:** The user may provide the source in the conversation or upload it directly in the open ChatCut editor. Use `asset-import` when a conversation attachment or local path still needs to be imported into ChatCut. For an editor upload, continue from the registered project asset without importing it again.
- **Standalone Codex:** Ask the user to attach or drop the source into the conversation, then follow `asset-import`. Do not use or redirect the user to the editor's Browser upload path: it can currently crash the Codex Browser runtime.

If this workflow is running through a Codex/connector host and the task creates, targets, or opens a ChatCut project for the user, satisfy any returned `browserHandoff.required=true`, `Codex internal Browser handoff`, or equivalent live project handoff before starting nontrivial edits and again before final delivery if the visible editor no longer matches the project.

Independent treatments that can be applied to speech-led videos. Pick the ones that match what the user wants — not all are needed every time.

- **A-roll editing** (Chinese product term: **语音剪辑**, including **去口癖、停顿、重复**) — transcript-based speech editing. Common operations include cleanup, highlight extraction, restructure, opening hook, and others as needed for the aligned outcome.
- **Motion graphics overlay** (write the full name **Motion Graphics** in English user-facing copy, not "MG"; the fixed Chinese product term is **MG 动画**, not alternatives such as "动效", "字幕条", or "动态字幕") — reinforce key information, structured content, and topic transitions with on-screen motion graphics
- **B-roll** (industry term — keep as "B-roll" in any language, do not translate) — cover jump cuts or visualize what's being said
- **Background music** (Chinese product term: **背景音乐**) — set mood and smooth micro-gaps
- **Captions** (Chinese product term: **字幕**) — on-screen text for accessibility
- **AI Voice Isolation** (Chinese product term: **AI 人声隔离**) — clean or isolate spoken human voice with DeepFilterNet3, picture untouched. See the `voice-isolation` skill.

> When the user's language is Chinese, **use the exact product terms in parentheses above** in widget options, choices options, and conversat

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 6 — file references are metadata, not package contents.

View saved version →

---
name: transcription
description: Hosted ChatCut plugin sessions only (the `chatcut` MCP server). If the conversation is driving ChatCut Desktop (a `chatcut_desktop*` MCP server), load this skill only when the user explicitly chooses the plugin/web surface — desktop sessions otherwise ship their own instructions and tools. Use for ChatCut transcription, transcript readiness, captions, subtitles, transcript repair, filler removal, and speech-led editing setup.
---

# Transcription

1. Use `browse_assets` to identify the video/audio asset and its transcription state.
2. For newly imported local media, complete the `asset-import` workflow first.
3. Check `track_progress` with target `transcription`. It returns current status; follow the returned check-back guidance and do not busy-loop.
4. Use `find_transcript` for timestamped text lookup.
5. Use the current caption tools to enable, inspect, translate, or style captions only after transcription is ready.

Do not call a transcription stuck from one pending status. Treat an explicit failed terminal state immediately; otherwise allow at least `max(5 minutes, min(60 minutes, 2 x asset duration))`, or at least 10 minutes across multiple checks when duration is unknown.

`no_audio` / no-speech is a successful terminal analysis result: the media is usable, but there is no transcript to read or caption. Do not report it as a transcription failure or retry it unless the user says the media contains speech that should have been detected.

Use `trigger_transcript` when the user explicitly wants transcription started or restarted. It is idempotent: only `idle` and `error` start work; ready, no-audio, and in-progress assets are left unchanged. If prepared transcription audio exists it is reused; otherwise the open Web/Desktop editor is asked to prepare and upload audio through its native pipeline. Then inspect readiness with `track_progress`.

For an `idle` or explicitly failed (`error`) run, call `trigger_transcript` with the asset id, then check transcription progress again. If an in-progress run has genuinely exceeded the stuck threshold, use `manage_transcript` action `retry_transcription` because `trigger_transcript` intentionally leaves in-progress work unchanged. The manage tool also remains available for low-level recovery where an external MCP host must supply prepared `audioBase64`. Repair source words with the transcript-fix action instead of rewriting visible captions when the source transcript itself is wrong.

For semantic speech edits, load `talking-head-guide` and use the Script workflow. Use mechanical cleanup only for fixed fillers and pauses; do not replace transcript-aware editing with destructive physical timeline cuts.

View saved version →

---
name: verification
description: Hosted ChatCut plugin sessions only (the `chatcut` MCP server). If the conversation is driving ChatCut Desktop (a `chatcut_desktop*` MCP server), load this skill only when the user explicitly chooses the plugin/web surface — desktop sessions otherwise ship their own instructions and tools. Verify that ChatCut plugin edits are reflected in project structure and visible timeline output before reporting success.
---

# Verification

Use both structural and visual evidence when the requested result is visible:

1. Re-read the affected scope with `read_project`, `preview_timeline`, `inspect_item`, `browse_assets`, or `inspect_asset` as appropriate. Use the latest response for ids, tracks, timing, and readiness.
2. Inspect composed timeline frames through the visual tool exposed by the current manifest. Successful rendering or mutation metadata is not visual proof until the returned pixels are inspected.

Use local source bytes for raw source understanding when the original path is available. Use `inspect_asset` when the original is not locally available. Source frames help select moments but do not prove timeline composition; use composed timeline frames for trims, layers, captions, effects, crops, transitions, and Motion Graphics.

If signed frame URLs are returned and the host cannot inspect them directly, download the complete shell-quoted URLs into a temporary directory and inspect those files. Do not report visual success from URLs alone.

If visual proof is blocked by upload/readiness or renderer state, report the blocker explicitly and ask the user to inspect the live editor when appropriate. Never convert a failed verification into an unsupported tool fallback or a false completion claim.

View saved version →

---
name: video-gen
description: AI video generation via Seedance, Kling, Gemini Omni, MiniMax H3, and MiniMax H3 Max. Use when the user wants to generate a video clip — text-to-video, image-to-video, first/last-frame transitions, reference-guided generation — or wants to modify / edit / extend an existing generated clip.
user-invocable: true
---

# Video Gen

Submits one video generation job per call and returns a `jobId`. Job status and later check-backs belong to `track_progress`; this skill does **not** place videos on the timeline automatically.

## When to Use

Any time the user wants to generate a video clip — text-to-video, image-to-video, first-last-frame transition, reference-based generation, or generatively editing / extending an existing video (producing new generated footage based on a source clip; not timeline trimming).

## Models

| Model            | Reference                                                    | Strengths                                                                                                                                                                                                            |
| ---------------- | ------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `seedance-2-5`   | [references/seedance25.md](references/seedance25.md)         | Default. 4-30s, up to 50 multimodal references, audio-only reference, timestamp control, and mp4/mov output. Strongest Seedance choice for new generation, edit, and extend.                                         |
| `seedance2`      | [references/seedance2.md](references/seedance2.md)           | Seedance 2.0 full model. 4-15s, rich multimodal references, and up to 1080p output.                                                                                                                                  |
| `seedance2fast`  | [references/seedance2.md](references/seedance2.md)           | Seedance 2.0 Fast — **same inputs and 4-15s range as `seedance2`, returns in minutes instead of ~ten, ~20% cheaper, capped at 720p**. Use when the user is iterating and turnaround matters more than peak fidelity. |
| `seedance2mini`  | [references/seedance2.md](references/seedance2.md)           | Seedance 2.0 mini — **same inputs and 4-15s range as `seedance2`, ~50% cheaper, capped at 720p**. Use for cheap drafts and high-volume batches where the full model's fidelity isn't required.                       |
| `kling`          | [references/kling.md](references/kling.md)                   | Camera-control language via prompt; strong on fine emotional / performance control for character shots. 1080p via `mode:"pro"`.                                                                                      |
| `minimax-h3`     | [references/minimax-h3.md](references/minimax-h3.md)         | MiniMax H3. 4-15s, 768p/2k, first/last frames, and up to 9 image + 3 video + 3 audio references (12 total). Strong multimodal reference following.                                                                   |
| `minimax-h3-max` | [references/minimax-h3-max.md](references/minimax-h3-max.md) | MiniMax H3 Max. 5-15s, 480p/768p, text or first/last-frame generation. No reference mode or 2K output.                                                                                                               |
| `omni`           | [references/omni.md](references/omni.md)                     | Gemini Omni 1.1 Flash. Targeted edits/extensions via `continueFrom`, first/last frames, and cheap 360p drafts. 3-10s; 720p default, upscaled 1080p/4k.                                                               |

**IMPORTANT:** Before generating, READ the chosen model's reference for capabilities, input channels, modes, prompt structure, and model-specific beh

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 6 — file references are metadata, not package contents.

View saved version →

---
name: video-translation
description: Translate, dub, and localize speech in an existing video while optionally preserving speaker voices, generating translated captions, or synchronizing the speaker's lip movements. Use when the user asks for 视频译制、多语言配音、 把视频里的中文变成英文、让视频里的人说另一种语言、保留原音色、翻译声音、 口型同步、translated video, video dubbing, voice translation, or lip-synced localization, as well as traducción de video, doblaje de video, traducir un video, or sincronización labial. This Skill MUST be loaded before composing treatment choices for an ambiguous video-translation request in any language, including a turn that only asks the user to choose a treatment. Do not use when the user only wants subtitles translated, wants an SRT/VTT file, wants text or a script translated before generating a new avatar video, or wants ordinary TTS with a newly selected voice.
user-invocable: true
---

# Video Translation

Create a new localized video asset from an existing project video. Treat
speech translation, dubbing, voice preservation, lip synchronization, captions,
quality, authorization, generation, and verification as one workflow.

Lip-synced translation starts with source-transcript review in an editable
ChatCut Widget. The recognized source wording is never treated as final until
the user has edited or approved that form and submitted it. Audio-only
translation keeps the existing direct-submit flow and skips this review.

## When to Use

Use this skill when the user wants an existing video to:

- Make its speakers speak another language.
- Produce a dubbed or localized version.
- Preserve the original speakers' vocal identity across languages.
- Synchronize visible mouth movements with translated speech.
- Translate only the spoken audio while keeping the original picture.
- Generate a translated video with optional translated captions.
- Create a language-specific version for another market.

Typical triggering requests include:

- "让视频里这个人说英语。"
- "把中文口播做成英文版，口型也对上。"
- "把这段采访译制成日语，保留每个人的声音。"
- "做一个西班牙语配音版。"
- "只把声音翻译成英语，画面不要变。"
- "把这个中文数字人成片改成英文。"

Route adjacent requests elsewhere:

- Only translate, add, edit, or export captions: use caption translation.
- Translate a script before generating a new avatar video: translate the text,
  then use the Digital Human Skill.
- Generate speech with a chosen replacement voice: use the Voice Skill.
- Transcribe spoken content without changing it: use the Transcription Skill.
- Edit pauses, mistakes, framing, or B-roll in talking-head footage: use the
  Talking Head Guide.
- Generate new footage rather than localize an existing video: use Video Gen.

Treat these requests as ambiguous:

- "把这个视频翻译成英文。"
- "帮我做一个英文版。"
- "中文改成英语。"
- "做一个海外版。"
- "把这个视频国际化一下。"

For an ambiguous request, ask one treatment question with text choices. Keep
the wording natural for the conversation, and include all applicable paths:

- Lip-sync translation: continue through the editable source-transcript review
  and submit with `audioOnly: false` or omit `audioOnly`.
- Audio-only translation: keep the existing direct-submit path and submit with
  `audioOnly: true`.
- Subtitle-only translation: use caption translation and do not submit a video
  translation job.

Keep user-facing terminology in one language. These are localized concept names,
not fixed full option sentences; descriptions may stay natural for the context:

| Conversation language | Lip-sync path                        | Audio-only path          | Subtitle-only path            |
| --------------------- | ------------------------------------ | ------------------------ | ----------------------------- |
| Chinese               | 口型同步翻译                         | 只翻译声音               | 只翻译字幕                    |
| English               | Lip-synced translation               | Audio-only translation   | Subtitle-only translation     |
| Spanish               | Traducción con sincronización labial | Traducción solo de audio | Traducción solo de subtítulos |

The targe

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: voice
description: Text-to-Speech (TTS), voice cloning, voiceover, narration placement/sync, and custom sound effects (SFX) generator. Use when the user wants generated speech from text, wants to clone a consented voice from uploaded reference audio, wants to correct a misspoken word or short phrase in recorded speech, wants to add/replace/align narration or voiceover for an existing video/timeline, wants to keep existing voiceover synced after visual retiming edits, needs voice audition/selection, or explicitly wants a newly generated/custom sound effect that is not available in the Sound Effects library.
user-invocable: true
---

# Voice & Sound Effects Generator

Generate voiceovers (TTS) and sound effects. For TTS, choose a concrete
provider and voice before calling `submit_voice`.

## When to Use

- Generate voiceover/narration from text
- Create text-to-speech audio for videos
- Add, replace, or redo narration/voiceover for an existing video, timeline,
  screen recording, slide animation, product demo, B-roll edit, MG explainer, or
  other visual sequence
- Keep existing narration/voiceover aligned after trimming, speeding up, slowing
  down, moving, reordering, or replacing the visuals it describes
- Offer and audition TTS voice choices when the user has not picked a concrete voice
- Clone the user's own or explicitly authorized voice from reference audio
- Correct a real misspoken word or short phrase with the authorized speaker's
  cloned voice while preserving picture and downstream timing
- Generate custom sound effects from text descriptions only after checking the Sound Effects library first

## TTS (Text-to-Speech)

If the user wants to correct a word or short phrase that was actually spoken
incorrectly in existing recorded speech, read
[references/fix-spoken-mistakes.md](references/fix-spoken-mistakes.md) before
editing or generating. That workflow preserves the picture and protects later
timing while replacing only the faulty sound. Do not use synthesized speech
when the recording is already correct and only its transcript is wrong; fix
the transcript instead. Use the ordinary narration path for a full rewrite or
complete new voiceover.

If the current request has an existing visual target and the user wants
narration, voiceover, dubbing, or replacement speech for that target, read
[references/video-sync.md](references/video-sync.md) before drafting new
narration, using existing narration text to generate TTS, or placing audio. Do
this even when the user did not explicitly say "sync" or "match the visuals";
the existence of a visual target means narration timing and meaning may need to
follow on-screen content. Use the normal standalone TTS path only when there is
no visual target or the user just wants an audio asset from text.

Also read [references/video-sync.md](references/video-sync.md) when the timeline
already has narration/voiceover and the user asks to change the visuals while
keeping that voiceover aligned. This is a sync maintenance task even if no new
TTS is needed.

Use `manage_voice` as the single catalog and management entry, and
`submit_voice` for final TTS. `manage_voice action="list" voiceType="all"`
returns official and cloned candidates in one normalized list. Only
`voiceType="custom"` supports create-access, apply, clone, preview, rename, or
delete actions. The current contracts are:

- `provider` is required. Use `doubao` for Chinese-optimized narration and
  `elevenlabs` for English or multilingual narration, or `fish-audio` for a
  ready ChatCut custom voice.
- `voiceId` is required and provider-specific. Do not mix catalogs.
- `submit_voice` creates an audio asset only. Timeline placement, replacement,
  trimming, and alignment happen later with timeline tools.
- For long narration, multiple `submit_voice` calls can be useful: split at
  natural pauses, sentence groups, or script beat boundaries when the workflow
  benefits from separately timed or placed voice clips, such as 

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 2 — file references are metadata, not package contents.

View saved version →

---
name: widget-forms
description: Ask for structured ChatCut input using the current plugin host's supported form surface.
---

# Widget Forms Host Adapter

The canonical agent's raw `<widget>`, `<choices/>`, and `<visual-option>` tags render only inside ChatCut. Never emit those tags from the published Codex or Claude Code plugin.

## Semantic contract mapping

This adapter owns how plugin hosts implement a caller's host-neutral form
contract. It does not decide which fields the workflow requires.

Map semantic field types as follows:

- `short_text`: one text input.
- `explicit_consent`: one explicit, initially unselected confirmation control
  using the caller's full localized copy. An attachment or another submitted
  field is never consent.
- `audio_reference`: plugin forms cannot record or upload media. Render the
  other fields, ask the user to attach the audio to the conversation, then load
  `asset-import`. Return the imported ChatCut audio `assetId` to the calling
  workflow; never return a local path, attachment URL, or raw bytes as an asset
  id.
- `playable_single_choice`: one choice surface with stable option values,
  localized labels, and playable media when the host supports it. Keep the
  value-to-label map in context when a host returns the visible label.
- `playable_preview`: one display-only, non-submitting audio surface using the
  exact caller-provided runtime media URL. Use only a host-supported safe media
  renderer; never emit raw `<audio>` HTML or expose the URL as ordinary prose.

## Codex

Call the ChatCut MCP tool `ask_followup_questions`. Put related fields into one form, write visible text in the user's language, and stop after the call until the submitted answer appears in chat. Use the current tool schema for field and option shapes.

Map `playable_single_choice` to one `single` field with `variant:"voice"`.
Use each stable value as the option id and keep its localized label,
description, and `audioUrl` tied to the same caller-provided item. An action
without playable media has no `audioUrl`.

Map an MG reference style choice to one `single` field with `variant:"visual"`.
Use the reference ID as the option id, its short title as the label, and the
selected detail's `heroPreview.url` as `preview`. Include one `__other__` option
labeled "Other" in the user's language; the tool supplies its text input. That branch accepts
either a new preference or a request for another batch; do not add a separate
Show more option. Return the selected reference ID to the MG skill; it owns
application. Do not bind `apply_preset` directly to a reference ID.

Example field, replacing the reference placeholders with the fetched shortlist
and localizing the labels:

```json
{
  "id": "mg_style",
  "label": "Choose a Motion Graphics style",
  "type": "single",
  "variant": "visual",
  "options": [
    { "id": "REFERENCE_ID", "label": "TITLE", "preview": "HERO_PREVIEW_URL" },
    { "id": "__other__", "label": "Other" }
  ]
}
```

The Other answer returns to discovery, without applying a style or
starting production. Keep the image-option IDs unchanged in the next step.

Map an AI-avatar identity choice to one `single` field with `variant:"visual"`.
Use the live `identityId` as the option id, the returned `name` as its label,
`previewVideoUrl` as `previewVideo`, and `previewImageUrl` as `preview`. The
image remains the poster and automatic fallback if video loading fails. Keep
`create_avatar` as a label-only option. Selecting it returns that value to the
workflow; it does not open ChatCut's native avatar dialog, so request the source
attachment separately and use `asset-import`.

Do not call `ask_followup_questions` solely to display a `playable_preview`,
because a passive preview is not a question. Use Codex's supported audio
attachment/media rendering when available. If this host session has no safe
runtime-URL audio renderer, say that the preview is available in the ChatCut
project assets and continue with the call

Preview of the first 4,000 characters. Read full instructions →