jperrello

@jperrello source repo

51 skills
0 followers
6 hours ago last updated

▌
Visual Cadence · jperrello bundle
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.

0
installs
▌
Broll Composite · jperrello bundle
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.

0
installs
▌
Verify Bookends · jperrello bundle
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.

0
installs
▌
Selection Report · jperrello bundle
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".

0
installs
▌
Title Transition · jperrello bundle
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).

0
installs
▌
Verify Coherence · jperrello bundle
Post-pick gate that re-reads each picked span's transcript and either keeps it as-is or tightens its [t0,t1] to cover only the dominant topic. Prevents shorts that feel like two unrelated clips spliced together.

0
installs
▌
Analytics Feedback · jperrello bundle
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.

0
installs
▌
First Span Feedback · jperrello bundle
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.

0
installs
▌
Verify Completeness · jperrello bundle
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.

0
installs
▌
Like Subscribe Overlay · jperrello bundle
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).

0
installs
▌
Ingest · jperrello bundle
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.

0
installs
▌
Qc Clip · jperrello bundle
Sanity-check a rendered short with ffprobe. Verifies duration is in range and file size is non-trivial. Pass/fail boolean plus a short reason. Use as a final gate before saving a render.

0
installs
▌
Bg Music · jperrello bundle
Mix a trendy looped background track under a finished short, attenuated well below the speaker (~-18dB). Picks a random song from ./songs/<category>/, or recurses across every mood folder when category is "ALL SONGS" (the default). Avoids repeating the last 5 picks via ./songs/.recent. Runs after loudnorm so the bed never overpowers the broadcast-leveled speech. Pair with pick-mood to route by clip vibe instead of pure random.

0
installs
▌
Cut Clip · jperrello bundle
Trim a video to a [t0, t1] time range using ffmpeg. Stream-copies where possible to avoid re-encoding. Use as the cheap building block for cutting source video into per-short slices.

0
installs
▌
End Card · jperrello bundle
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.

0
installs
▌
Jump Cut · jperrello bundle
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.

0
installs
▌
Loudnorm · jperrello bundle
Normalize audio loudness to broadcast levels using ffmpeg's two-pass loudnorm filter. Measures the input, then applies normalization with the measured parameters. Use as a final-stage audio leveling step.

0
installs
▌
Speed Up · jperrello bundle
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.

0
installs
▌
Pick Mood · jperrello bundle
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.

0
installs
▌
Sfx Beats · jperrello bundle
sfx-beats

0
installs
▌
Watermark · jperrello bundle
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

0
installs
▌
Broll Pick · jperrello bundle
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).

0
installs
▌
Cut Filler · jperrello bundle
Apply a trim-filler keeps.json to a clip's video. Reads the kept time ranges and re-encodes the clip with ffmpeg select/aselect so kept ranges are concatenated and removed spans (filler, trail-offs, digressions) disappear. Output aligns with the trimmed transcript trim-filler wrote, so downstream subtitle / caption / title skills stay in sync.

0
installs
▌
Grade Clip · jperrello bundle
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).

0
installs
▌
Name Short · jperrello bundle
Sanitize a generated title into a filesystem-safe filename for the final saved short. Reads the title text emitted by generate-title and prints a kebab-case `.mp4` filename. Pure string op — no Claude call.

0
installs
▌
Save Local · jperrello bundle
Move a rendered short into ./output/<source-video-name>/. Auto-creates the per-source folder. Use as the final step so all shorts from one source video land in one browseable folder.

0
installs
▌
Style Gate · jperrello bundle
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

0
installs
▌
Transcribe · jperrello bundle
Transcribe a video/audio file to a JSON transcript with word-level timestamps using local whisper.cpp + a GGML model. Use when you have a media file and need text + word timing for downstream subtitle burning or segment ranking.

0
installs
▌
Zoom Punch · jperrello bundle
zoom-punch

0
installs
▌
Reap Source · jperrello bundle
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).

0
installs
▌
Trim Filler · jperrello bundle
Semantic dead-air / filler removal. Claude reads a clip-local word-timed transcript and marks filler words, trail-offs, false starts, repeated re-starts, and short digressive asides for removal. Emits keeps.json (ranges to keep) and transcript.trimmed.json (kept words with shifted timestamps). Pairs with cut-filler, which applies the cuts to the clip's video.

0
installs
▌
Bookend Trim · jperrello bundle
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.

0
installs
▌
Profile Clip · jperrello bundle
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.

0
installs
▌
Style Corpus · jperrello bundle
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).

0
installs
▌
Switch Faces · jperrello bundle
switch-faces

0
installs
▌
Tighten Pace · jperrello bundle
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.

0
installs
▌
Broll Cleanup · jperrello bundle
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.

0
installs
▌
Derive Thesis · jperrello bundle
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.

0
installs
▌
Director Pass · jperrello bundle
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

0
installs
▌
Fill Vertical · jperrello bundle
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.

0
installs
▌
Fix Cold Open · jperrello bundle
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).

0
installs
▌
Pick Segments · jperrello bundle
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.

0
installs
▌
Schedule Drip · jperrello bundle
Deterministic greedy scheduler over the graded clips — the only skill that attacks the

0
installs
▌
Scout Sources · jperrello bundle
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.

0
installs
▌
Source Credit · jperrello bundle
source-credit

0
installs
▌
Brand Overlays · jperrello bundle
brand-overlays

0
installs
▌
Burn Subtitles · jperrello bundle
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).

0
installs
▌
Chunk Captions · jperrello bundle
Group a clip's word-timed transcript into phrase-sized caption chunks via Claude. Replaces the rolling 4-word window in burn-subtitles. Each chunk is one self-contained phrase that swaps in as a whole unit.

0
installs
▌
Generate Title · jperrello bundle
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).

0
installs
▌
Segment Topics · jperrello bundle
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.

0
installs
▌
Sources Ledger · jperrello bundle
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).

0
installs

51 published skills