Volcano ASR Transcription + Talking-head Auto Rough Cut

This skill handles two types of tasks:

Pure transcription: recognize local audio/video into text, timestamps, and subtitles.
Talking-head rough cut: use ASR timestamps to remove repeats, pauses, verbal stumbles, and filler sentences, then generate a rough-cut MP4 and SRT ready for fine editing in CapCut/Jianying.

Safety Rules

Never modify the original media. Always copy a working copy first, then transcribe, re-transcribe, or edit the working copy.
Do not delete any files directly. Temporary file cleanup must be explicitly approved by the user, and files may only be moved to the trash first.
Original media, working copy, rough-cut output, and re-transcription temporary files must be kept separately.
Do not write TOS, ASR Token, Cookie, or API Key into the skill, normal memory, or logs; only read from environment variables or user-specified private configuration.
ASR billing order is fixed: first use the Doubao speech application that still has trial/duration package in the Volcano console; only after the trial/duration package is confirmed exhausted may you switch to a paid application. Both trial and paid AppIDs must be read from environment variables and not hardcoded in this public skill.
Trial and paid tokens must be kept separate: use
```
VOLC_ASR_TRIAL_TOKEN
```
for the trial application and
```
VOLC_ASR_PAID_TOKEN
```
or legacy
```
VOLC_ASR_TOKEN
```
for the paid application. Do not use the paid token as the default token before the trial package is exhausted.
Before the trial/duration package is confirmed exhausted, you must not set
```
VOLC_ASR_TRIAL_EXHAUSTED=1
```
nor let
```
VOLC_ASR_APP_ID
```
point to a paid application. If a temporary bypass is truly necessary, you must explicitly state that charges will apply and obtain user confirmation.
After a long-audio ASR submission succeeds, do not run the same file again to "try once more". Prefer waiting for the current task to complete, or recover the query using the saved
```
{working_copy}.asr_pending.json
```
/
```
--request-id
```
, to avoid consuming trial time or balance repeatedly.

Usage

bash

# Basic usage: transcribe + analyze + auto edit
python3 yichen-volc-asr/scripts/transcribe.py '<working copy path>'

# Review annotations only, do not edit
python3 yichen-volc-asr/scripts/transcribe.py '<working copy path>' --dry-run

# Ignore ASR cache and re-recognize
python3 yichen-volc-asr/scripts/transcribe.py '<working copy path>' --no-cache

# Do not run ffmpeg editing; still generate transcription, annotations, and SRT
python3 yichen-volc-asr/scripts/transcribe.py '<working copy path>' --no-execute

# Transcribe only; no edit analysis or SRT generation
python3 yichen-volc-asr/scripts/transcribe.py '<working copy path>' --transcribe-only

# Recover a submitted task only; no re-upload/submit
python3 yichen-volc-asr/scripts/transcribe.py '<working copy path>' --request-id '<Volcano ASR request_id>' --no-execute

The script defaults to

VOLC_ASR_TRIAL_APP_ID

and reads

VOLC_ASR_TRIAL_TOKEN

first. Only after confirming the trial/duration package is exhausted should you set

VOLC_ASR_TRIAL_EXHAUSTED=1

; only then will the script switch to

VOLC_ASR_PAID_APP_ID

and read

VOLC_ASR_PAID_TOKEN

or legacy

VOLC_ASR_TOKEN

. If you really need to switch to another Volcano speech application, set

VOLC_ASR_APP_ID

first; if that application is not a trial-package application and the trial exhaustion flag is not set, the script will stop unless

VOLC_ASR_ALLOW_NON_TRIAL_APP=1

is also explicitly set.

If the local legacy environment only has

VOLC_ASR_TOKEN

, the script will not use it by default for the trial application, to avoid a paid token being mistakenly used as a trial. Only when you confirm

VOLC_ASR_TOKEN

is itself a trial token may you temporarily set

VOLC_ASR_ALLOW_LEGACY_TOKEN=1

for compatibility with the old configuration.

After a successful submission, the script writes

{working_copy}.asr_pending.json

, which stores only

request_id

, AppID, audio URL, and status—never tokens/secrets. When re-running without completed cache, it will first recover this unfinished task; only explicitly passing

--force-new

will re-upload and submit a new task.

Output Files

File	Description
`{working_copy}_cut.mp4`	Rough-cut video, can be imported into CapCut/Jianying
`{working_copy}_cut.srt`	Subtitle file, importable into CapCut/Jianying
`{working_copy}.txt`	Full transcription text with timestamps
`{working_copy}.asr_cache.json`	ASR cache, reusable on re-run
`{working_copy}.asr_pending.json`	Record of an unfinished ASR task, for query recovery; not a completed result

Pure Transcription Flow

Confirm the input file exists and has a reasonable size; use
```
ffprobe
```
to check duration and codec if needed.
Copy the original to a working copy, e.g.,
```
source_for_asr.mp4
```
.

Run

python3 yichen-volc-asr/scripts/transcribe.py '<working copy path>' --no-execute

Deliver the transcription text, timestamps, subtitle draft, and cache path.
Explicitly state that no editing was performed this time.

Talking-head Auto Rough Cut Flow

When the user asks to "edit my talking-head video", "rough cut automatically", or "remove repeats/pauses/verbal stumbles/choppy sentences":

Copy the original to a working copy to avoid modifying the original.
Use Volcano ASR to generate timestamped transcription and
```
.asr_cache.json
```
.
Write a readable keep/delete plan:
- ```
KEEP
```
  : clean, informative, narratively necessary content.
- ```
DELETE
```
  : verbal stumbles, repeats, long pauses, filler sentences, half sentences, ineffective interjections.
- ```
CHECK
```
  : content may be useful but wordy or questionable in listening experience.
Generate delete or keep ranges using source timecodes.
Generate the rough-cut MP4. For long talking-head videos with multiple deletions, prefer a stable segment-extract + concat workflow.
Re-transcribe the rough-cut MP4 for review.
After review passes, output the rough-cut MP4, SRT, transcription, keep/delete plan, and review notes.
If further fine editing is needed, provide the rough-cut MP4 and SRT as delivery materials for later import into CapCut/Jianying.

Editing Rules

#	Rule	Description
1	Pause deletion	Silence with long gaps between adjacent segments can be deleted
2	Pure interjection deletion	Delete segments consisting entirely of interjections like um, ah, uh, oh
3	Adjacent repeat deletion	Prefer deleting the earlier occurrence and keeping the later one; gray areas need manual judgment
4	Keep mid-sentence interjections	Keep the entire segment when interjections appear in the middle of a sentence
5	Consecutive prefix cleanup	Clean redundant consecutive starters like "then", "so", "actually", "I mean"
6	Handle short segments carefully	Keep non-pure-interjection short segments by default
7	Smart margin	Add buffer before/after kept segments to avoid clipped speech
8	Smoothing	Merge overly short kept segments into adjacent segments to avoid flicker frames

Three-layer Review

Each layer checks:

Whether there are word, phrase, sentence, or paragraph-level repeats.
Whether complete sentences have been cut in half.
Whether residual verbal stumbles, filler sentences, half sentences, or fragments with only a beginning remain.
Whether there are obvious pauses, blank spots, or rhythm breaks.
Whether transition sentences were mistakenly deleted, causing abrupt logical jumps.
Whether the paragraph structure still flows smoothly.

Layer 1: Pre-edit keep/delete plan

Delete ranges must correspond to repeats, verbal stumbles, filler sentences, obvious pauses, or unusable broken fragments; boundaries must not cut into the middle of a complete sentence unless a cleaner complete version exists later.

Layer 2: Re-transcribe the rough cut

After rendering, re-transcribe the rough-cut MP4. The final transcription must not contain obvious repeats, broken fragments, long pauses, logical jumps, or incomplete sentences caused by hard cuts.

Layer 3: Final pass

The latest rough cut must pass a full review before you can say "ready for fine editing in CapCut/Jianying". If it fails, produce a new version.

It is recommended to use a manually confirmed rough-cut video as the quality benchmark. Future talking-head rough cuts should be judged against this standard: no repeated fragments, no obvious pauses, no complete sentences cut in half.

Final Reply Requirements

Pure transcription: provide the transcription path, subtitle path, cache path, and state that no editing was performed.
Talking-head rough cut: provide the rough-cut MP4 path, SRT path, transcription path, keep/delete plan path, and review conclusion.
On failure, explain missing environment variables, missing files, upload failure, ASR failure, or ffmpeg errors.

yichen-volc-asr

NPX Install

Tags

SKILL.md Content (Chinese)