C0BALT_CUT

Animate the title as a COLD OPEN in the TOP banner over the live opening footage — no blocking center card — held until TITLE_SWAP (default 2.0s) so brand-overlays can hand off to the source citation in the same slot. Frame 1 stays content (a face mid-sentence) to protect the swipe-rate / "Stayed to Watch" signal. ONE animation for every short — the glitch style (RGB-split banner + scanline tear, style-matched zap/crackle SFX) — a PIL frame sequence anchored at TITLE_ANCHOR_FRAC (default 0.135).

Generate a per-clip third-person engagement-driven title card text. Claude reads the clip's transcript, the source ingest.json metadata, and (optionally) pick-segments' per-span judgment (topic, rationale, suggested title) so it reads the speaker's register — sincere vs ironic vs joking — before titling. Emits a hook-driven ALL-CAPS title (<=7 words).

Per-clip upload-readiness grade (0-99) read off a FINISHED .mp4 plus its persisted sidecar plans — the first skill that inspects a delivered pixel-level artifact, the on-disk proxy for YouTube's VVSA swipe gate. Deterministic retention-proxy floor (frame1_is_face, letterbox_bars, credit_lit_at_open, first_visual_change, first_payoff_offset, longest_static_gap, opening_caption_words, max_residual_silence, terminal_loop_score) with hard caps (letterbox / face_withheld / credit_at_open / blocking_card / dead_tail) that cap grade≤40, plus ONE batched Claude rubric call (hook↔payoff / open-loop / cold-context) skipped when GRADE_SKIP_CLAUDE=1. Runs at the END of the per-span chain (after save-local) AND standalone over the whole output/ backlog (--backlog → output/_triage.json). Emits clip_NN.grade.json per the locked SELECTION-SUITE-CONTRACT schema. Idempotent (.gcmeta), non-fatal (any error → DROSS/empty, exit 0).

Claude picks CONTEXTUAL/scene-level anchors from a clip transcript (literal objects, establishing shots, evocative concept footage matched to the story's tone — not just keyword nouns) and sources full-bleed B-roll cutaways via keyless yt-dlp YouTube search + mcptube frame-sampling + Claude vision verify. The verify step gets the spoken context and rejects literal-but-wrong matches (e.g. a cat laser toy for a tense "red dot" beat). Aims dense (8-12 windows, targeting cutaway footage on ~60%+ of the runtime; emits cutaway_coverage in the plan and WARNs below BROLL_MIN_COVER, default 0.6). Emits broll_plan.json with per-cutaway placement [t0,t1] and source metadata; clip files are namespaced per-clip. Windows snap to whole chunk-captions boundaries; vision calls capped by BROLL_VISION_CAP (default 16).

Pick N clip-worthy spans from a transcript. Claude reads the full transcript plus a per-second RMS energy summary and returns the most engaging time ranges for shorts. The atomic unit of a short is ONE IDEA, not one topic — each span carries `cuts` (1-3 non-contiguous source ranges assembled into one flowing story) plus `idea` (the one-sentence throughline all cuts share). A multi-cut span may pull cuts from DIFFERENT topics when they develop the same single idea; a single-cut span must stay within one topic and is just `cuts:[[t0,t1]]`. A 1-second SPOKEN hook is mandatory (no title card rescues a slow open — picks under PICK_HOOK_FLOOR are dropped). Replaces the old keyword/hook-word heuristic ranker.

Deterministic source-video discovery — the clip-channel "outlier" method, keyless. Searches seed niche queries via yt-dlp ytsearch, prefilters to long-form candidates, fetches full metadata, and ranks by outlier score (views/day velocity, views-per-subscriber ratio, comment engagement, replay-heatmap peakiness). Emits a ranked candidates.json to pick the next pipeline source from. No Claude call, no API key.

Post-edit verification of a short's opening and closing 1.5s. Claude sees a 3-frame strip from each end plus the trimmed transcript text around each end and returns {action:keep}, {action:trim,t0,t1} (inward-only), or {action:drop,reason}. Checks three things — (1) cleanliness (partial words, breath cutoffs, off-shot frames); (2) opening-hook strength (snap t0 inward to a stronger hook line if the first 3s is pure setup); (3) payoff landing (snap t1 to ~80ms past the payoff word when the tail trails into filler). Runs after tighten-pace, before fit-vertical. Inward-only — bookend-trim's outward pass already had its chance. Drops the span only on cleanliness failures requiring >2s of trim — never on hook-weakness alone.

Sidecar-free style analyzer — reduce ANY finished vertical short (ours in output/ OR a downloaded Group C exemplar) into a versioned Style Profile JSON using ONLY pixels + audio, never our internal edit plans. Deterministic tier (ffmpeg scene-detect for cut rhythm, silencedetect + RMS for speech/SFX/music, MediaPipe face sampling for cutaway fraction, Canny caption-band density) fills every quantitative field; ONE optional Claude vision call on a director-pass contact sheet fills the enumerated judgment fields (broll_mode, caption_style, production_class, hook_device). The shared organ of the style-replication loop — style-corpus profiles Group C exemplars with it and style-gate profiles our span 0 with it, so comparison is fair (delivered pixels vs delivered pixels). Non-fatal, idempotent (.ppmeta). PROFILE_VISION=0 skips the vision call.

The offline LEARN phase of the style-replication loop. `learn <url|file>...` downloads each Group C exemplar short (yt-dlp, media into gitignored work/_style/<id>/), profiles it sidecar-free via profile-clip (vision ON), and stores the small JSON Style Profile in references/profiles/ (checked in); `distill` aggregates every profile into references/targets.json — per-field robust distribution targets (median + MAD-derived sigma, floored at 10% of the median) with each levered field carrying its code lever, so the style-gate can compare our span 0 against a DISTRIBUTION of good shorts instead of overfitting one exemplar; `show` prints the targets. Deterministic distill, non-fatal per exemplar, idempotent (profile-clip's .ppmeta makes re-learn a no-op on unchanged media).

The online VERIFY half of the style-replication loop — the first-span-feedback discipline with a different oracle (match against the Group C exemplar corpus in references/targets.json) and a different sensor (a sidecar-free Style Profile of the DELIVERED span-0 pixels via profile-clip, never our plans). On a levered-field mismatch (|z| > SG_Z vs the corpus distribution) it runs a bounded knob-first fix loop — moves.py maps the worst mismatches to CLAMPED ephemeral env deltas (JUMP_CUT_SEG, JUMP_CUT_MAX_GAP, SPEED, SWITCH_SPACING) in work/<id>/style.env, the entrypoint-owned SG_RERENDER_CMD re-renders span 0 with them, and the fix is accepted only when accept.py passes (no checked field worse, at least one improved, no new mismatch) AND span 0's grade.json did not regress (reuses first-span-feedback's check_grade.py). Accepted knobs steer spans 1..N (the entrypoint sources style.env before fan-out) and land in references/accepted.jsonl; mismatches no knob can reach are SURFACED for an operator-approved durable

The pre-fanout LEARNING GATE. start.sh finishes SPAN 0 alone (through the normal edit/captions/completion chain) before any lane launches, then this skill records a shot-scraper `video` demo of a generated per-span REVIEW PAGE (the 9:16 player + the grade/tier + the retention signals with the failing one flagged), has a Claude reviewer WATCH it via a contact sheet (like director-pass), and — when the reviewer names a SYSTEMIC defect that clears a hard three-gate re-verify (re-render span 0, grade≥prev + flagged signal cleared, re-record + re-review defect-gone) — makes a PERMANENT codebase change and commits only the fixer's paths, so every later span in the run and every future run inherits the fix. NON-FATAL everywhere (missing shot-scraper / record fail / parse fail / rejected gate / push fail all leave span 0 and the code untouched, exit 0). Idempotent via .fsfmeta. Gated by FIRST_SPAN_FEEDBACK (default 1), bounded by FSF_MAX_ITERS (default 1). Wired into start.sh / shorts.sh; autopilot.sh inherits it.

Name the CENTRAL SUBJECT (spine) of a long-form source so selection can tell on-theme moments from clip-shaped tangents. Claude reads the topic chapter list (topics.json) + source duration and emits thesis.json = {subject, thesis_sentence, key_threads[]} — the one durable source-level "what is this video about" artifact the pipeline lacked. Runs AFTER segment-topics and BEFORE pick-segments; pick-segments feeds it as a theme prior + scores each pick's theme_fit against it, and the confidence-floor backfill is gated on it so a high-standalone but off-spine tangent can no longer be auto-injected. Deterministic fallback (subject from the longest topic) on any failure. Non-fatal, idempotent, DERIVE_THESIS=0 skips.

Write output/<slug>/_selection.json for a source — the shipped shorts (scores + rationale from segments.raw.json, linked to their delivered filename) ALONGSIDE the considered-not-shipped RLM candidate menu (candidates.hint.json, each marked picked/unused) and the topic list (topics.json). Deterministic, no Claude, idempotent, non-fatal. Runs once at end of run AND standalone over the whole output/ backlog. Answers "show me the other arguments alongside the shorts".

Hard-cut full-frame B-roll cutaways onto a 1080x1920 clip per broll_plan.json. During each [t0,t1] the entire frame is replaced by the cutaway (instant in/out, no crossfade/zoom); 16:9 source is scale-to-cover + SUBJECT-cropped to 1080x1920 with no bars — the slack-axis offset is chosen subject-first (MediaPipe face -> pose person -> thresholded multi-frame saliency, reusing fill-vertical's engine), so the crop sits on the actual subject instead of drifting to background texture. No transition SFX by default (BROLL_SFX=1 re-enables a short synthesized whoosh on each cutaway in/out); the podcast audio stays continuous underneath (amix'd, never replaced). Zero valid picks -> passthrough copy. Pure ffmpeg.

Composite both persistent brand PNGs — the top "Original video: <title>" credit chyron (y≈4%) and the bottom @C0BALT_CUT watermark (y≈97.5%) — onto a finished short in ONE ffmpeg pass. The credit appears only in the FINAL CREDIT_TAIL seconds (default 3.0s) — it fades in at dur-tail and holds to the end so it lands on the closing beat, leaving the cold-open title to own the top banner uncontested at the open; the watermark holds the whole clip. Replaces the back-to-back source-credit + watermark re-encodes in the orchestrator (saves a full re-encode and an intermediate .mp4 per span); those two skills remain the standalone single-overlay ops and own the PNG renderers this skill reuses.

Burn karaoke-style word-timed subtitles into a video. Takes a transcript JSON with word timestamps and a video, emits a new video with subtitles rendered in. Renders text as a PNG overlay sequence (the local ffmpeg build has no libass/drawtext).

Composite a closing CTA banner ("FOLLOW FOR MORE" + @C0BALT_CUT) over the last ~2.5s of a finished short so it lands on an intentional beat instead of dead-stopping on a dangling word. Timeline-preserving (audio copied, duration identical), deterministic, non-fatal. END_CARD=0 skips.

Overlay the branded like/subscribe CTA animation — channel gem avatar + @C0BALT_CUT handle + subscribe/like/bell click choreography — for ~4 seconds WITHIN THE FIRST THIRD of a finished short (start clamped to end by the 1/3 mark, floored after the ~2.5s title card; early placement so viewers who bail never miss it). The animation source is cta.html (HTML+CSS+JS driving the pill pop-in, cursor moves, click punches, bell ring, thumb fill); build-cta.sh renders it frame-by-frame via headless Chromium (Playwright, omitBackground) and ffmpeg-encodes to assets/cta.mov (ProRes 4444 with alpha).

An agentic, vision-driven final QA/repair pass — a Claude "director" WATCHES the finished short (a contact sheet of frames sampled across the whole clip + the transcript + the sidecar plans) and decides, in natural language, what is broken ANYWHERE (cold open, dead/rambling tail, a tonally-wrong b-roll match, a wrong-person punch-in, mistimed captions, a too-hot music bed, a flat hook) — not just the cold open, not just a fixed route vocabulary. It then APPLIES the fixes it can from a bounded, pixel-safe set (tail_trim via cut-clip; music_down via a bg-music re-mix) and SURFACES everything else as an honest edit list, re-reviewing up to DIRECTOR_MAX_ITERS times. Layered ON TOP of grade-clip (the cheap proxy floor) + fix-cold-open (the closed-vocab cold-open repair). NON-FATAL, idempotent (.dpmeta). Two modes — preventive in-chain (the pre-mix .ctaed.mp4 + clip_NN.* sidecars are co-located, so music_down can re-mix) and curative standalone/backlog (a finished output clip → tail_trim only, everything else surfa

Reframe a horizontal (16:9) clip to 9:16 (1080x1920) by punching in to FILL the frame — never letterbox, no blur bars. Detects scene cuts and computes ONE static crop box per shot. Clusters face signatures across all shots to find the dominant speaker (storyteller); on multi-face shots it picks the speaker by lip-activity biased toward that identity. A non-speaking reaction/listener shot is framed LOOSER so the short never dwells hero-framed on the wrong person. When FaceLandmarker finds no face it falls to a PERSON tier (MediaPipe Pose) — an action/establishing shot with a human is framed on that person (head on the upper third, punched in) instead of stranding them in dead space; only genuinely person-free footage falls through to the OpenCV-saliency cover crop. Faces are framed ~45% of frame height with the eyeline on the upper third, capped at ~2x upscale. Replaces fit-vertical in the canonical chain.

Mix synthesized SFX into a short. Two modes — comedy (CANONICAL, runs after burn-subtitles in the pipeline): Claude marks punchline/irony beats and a vine boom / record scratch lands on each; tension (on request only): riser ending at the first pivot word, low hit at the loudest RMS peak after it, soft outro stinger. All SFX synthesized with stdlib `wave` — no external assets. Comedy mode marks ZERO beats on non-comedic clips and passes through untouched.

Globally retime a finished short by SPEED (default 1.25x) — the LAST step of the per-span edit chain. Video setpts + pitch-corrected audio atempo, so every relative beat (captions, zoom punches, b-roll windows, CTA, end-card) compresses uniformly and stays in sync. Deterministic, non-fatal. SPEED=1 or SPEED_UP=0 passes through.

Close the learning loop from real YouTube performance. Reads the newest YouTube Studio "Table data.csv" export, attributes each video's views/CTR/retention to topic + named-entity tokens, and rewrites the AUTO-managed block of schedule-drip's topics.scorelist (GO winners / HOLD dead niches) plus appends proven-winner search queries to scout-sources' niches.txt. Deterministic, no Claude, idempotent (no-op unless the export's mtime changed). The analytics half of the autopilot loop — runs at the top of every autopilot tick so scout + schedule-drip always reflect what actually performed.

Deterministic greedy scheduler over the graded clips — the only skill that attacks the

Reclaim disk by deleting a PROCESSED source's heavy artifacts — the full podcast source.mp4 (re-downloadable from its saved URL), every clip_NN.* stage intermediate, the b-roll cutaway cache, and the source's mcptube ingest (via broll-cleanup). KEEPS all lightweight JSON (ingest/transcript/topics/segments/grade/broll_plan) as the on-disk memory and updates the sources-ledger registry. Manual only — never auto-runs in the pipeline. Refuses a source with no finished shorts in output/ unless --force. The "cleanup" half of the disk-hygiene pair (sources-ledger is the "memory" half). Deterministic, non-fatal, idempotent (re-reaping a reaped source is a no-op).

Split a transcript into topical chapters. Claude reads the full transcript and emits a list of {t0, t1, title, summary} regions where each region covers one coherent subject. Used by pick-segments to ensure picked spans don't cross topic boundaries.

Maintain work/sources.json — the registry of which source videos have been processed into shorts. Scans every work/<id>/ingest.json + the output/<slug>/ folder it produced, recording title, url, duration, the produced shorts (with grades/tiers), current disk footprint, and active|reaped status. Also mirrors a keyed per-source bd memory so future sessions recall what's already been clipped (and can re-ingest from the saved URL). Pure deterministic scan, idempotent, no Claude. The "memory" half of the disk-hygiene pair (reap-source is the "cleanup" half).

Remove dead air from a clip by collapsing any inter-word gap > gap_max (default 0.18s). Gaps collapse to collapse_to (default 0.08s), or sentence_beat (default 0.15s) when the preceding word ends with . ? or !. Re-emits the clip and a re-timed transcript so downstream subtitle / chunk / title skills align. Use right after cut-clip + rebase to keep pacing punchy.

Arc-completeness gate. Re-reads each picked span's ASSEMBLED arc (the words inside its cuts) plus a tail lookahead and asks Claude whether the short LANDS as a standalone story — setup → turn → real landing, not an abrupt "so what?" stop. When the payoff is cut off but recoverable in the immediate source tail, it nudges t1 (and the last cut's end) OUTWARD to the landing sentence, within dmax. The outward counterpart to verify-bookends (inward-only). Runs after bookend-trim, before cut-clip, in SOURCE coordinates. Non-fatal, idempotent, disable with VERIFY_COMPLETENESS=0.

Deterministic, grade.json-routed repair of a short's cold open (the first ~2s swipe gate). Reads a clip's grade.json fix_routes and runs gated ops in order — broll_open_truncate (drop any b-roll cutaway overlapping [0,FIXCO_OPEN_GUARD_SEC] and re-composite so frame 1 is the speaker), shot0_repunch (re-run fill-vertical face detection on the 16:9 source when fillplan shot0.kind != face), credit_rerender / card_rerender (re-fire brand-overlays / title-transition). Two modes — PREVENTIVE in-chain (the 16:9 source + .vert.fillplan.json + .broll_plan.json all live in work/<id>/, so every op is clean) and CURATIVE standalone (a finished output clip whose defect is baked into pixels with no recoverable source → emits rerun_recommended, NEVER a fake degraded re-crop). NON-FATAL — any error leaves the input untouched and exits 0. Idempotent (.fixmeta).

Overlay a persistent "Original video: <title>" credit near the TOP of a finished short. Reads the source title from work/<id>/ingest.json and renders it as a transparent PNG via PIL; ffmpeg composites it only over the FINAL CREDIT_TAIL seconds (default 3.0s) so it lands on the closing beat. Positioned at the top so it sits above the captions (lower third) and clear of the centered title card. Runs after title-transition and before loudnorm in the per-span chain.

Overlay the persistent @C0BALT_CUT channel watermark at the BOTTOM of a finished short — the vertical opposite of source-credit's top banner. Renders the handle as a transparent PNG via PIL (Impact, Platinum

Manufacture "multi-cam" hard cuts on static talking-head stretches by alternating a base framing with tighter punch-in reframings of the SAME speaker, each cut snapped to a word start so it lands on speech. Deterministic, no Claude. Timeline-preserving — audio is copied untouched and total duration is identical, so every downstream timestamp (captions, b-roll windows) stays valid. Runs on the 1080x1920 vertical clip AFTER fill-vertical and BEFORE zoom-punch/broll/burn-subtitles, so cutaways override their own windows and captions burn on top. The visual-change-density lever for sources where b-roll stays sparse.

Measure the longest stretch of a rendered clip with NO visual change (the union of jump-cut/zoom/b-roll cuts) via ffmpeg scene detection. Emits a JSON verdict + a non-fatal WARN when the max static gap exceeds MAX_STATIC_GAP. Diagnostic only — never alters or rejects the clip. VISUAL_CADENCE=0 skips.

Hard-cut to a non-speaking listener's reaction shot at speech pauses — the "react" cutaway a real editor inserts while the speaker breathes. Deterministic, no Claude: detects a second face in the 16:9 source (reusing fill-vertical's face/identity clustering), picks the biggest speech-pause beats, and crops that listener's face into 1080x1920 for a ~0.8-1.2s hold before returning to the speaker. Timeline-preserving (audio copied, duration identical) so downstream timestamps stay valid. Runs on the clean vertical AFTER zoom-punch and BEFORE broll/captions. Solo talking-heads (no second face) pass through untouched. SWITCH_FACES=0 disables.

Snap each picked segment's [t0, t1] to a sentence boundary so shorts begin and end on full thoughts instead of mid-sentence. Claude reads ±extend seconds of context per span and picks clean sentence-completing endpoints from whisper transcript-line boundaries. Runs after verify-coherence, before cut-clip.

Download a source video from a YouTube/URL into ./work/<id>/source.mp4 using yt-dlp, and emit ingest.json with metadata (title, duration, fps, url, source_id). First step of the shorts pipeline.

Quick punch-in zooms at a clip's loudest words — the standard retention-edit emphasis beat. Deterministic, no Claude: per-second RMS peaks snapped to word starts pick 1-4 punch moments (4s+ apart, clear of the title card and the tail); each gets a ~0.6s 10% zoom pulse (fast attack, hold, smooth release) cropped toward the upper third so the eyeline holds. Runs on the 1080x1920 vertical clip BEFORE broll-composite and burn-subtitles so cutaways and captions never warp.

Pick the best `./songs/<mood>/` folder for a clip's background music. Reads the clip transcript and asks Claude to choose one mood label from the live list of mood subfolders. Emits a one-line mood string for bg-music to use as its category argument. Falls back to "ALL SONGS" on any failure.

Deferred end-of-run B-roll cache eviction. For ONLY the B-roll source video_ids this run ingested (from each broll_plan.json's ingested_video_ids), runs `mcptube remove <id>` AND deletes the local work/<id>/broll/*.mp4 cache. Never touches the podcast source, unrelated library videos, or broll_plan.json (placement metadata persists for editors). Runs once at the very end of a whole pipeline run.