video_editing_poc/.claude/skills/video-editing-research-frontier/SKILL.md

---
name: video-editing-research-frontier
description: Load when proposing, ranking, starting, evaluating, retiring, or positioning research that could advance this repository beyond its current cinematic-highlight baseline, especially offline local multimodal ranking, constrained directing, audiovisual QA, local voice/music/SFX generation, causal ablations, efficient model packaging, or restartable deterministic rendering. Do not load for ordinary defect repair, production hardening, or execution of the current highlight campaign.
---

# Video Editing Research Frontier

Use this runbook to turn an open technical question into a falsifiable, repo-local research program. Treat all landscape statements below as hypotheses, not claims about the external state of the art (SOTA). The repository does not contain a reviewed literature survey or competitive benchmark.

**Status date:** 2026-07-21.

## Choose The Correct Skill

| Need | Use instead |
|---|---|
| Fix a known defect, remove a prohibited fallback, make the clean build reproducible, or harden production | `video-editing-change-control` and the relevant engineering skill |
| Execute the hardest live objective with decision gates | `video-editing-cinematic-highlights-campaign` |
| Form hypotheses, pre-register predictions, assign adversarial review, or retire an idea | `video-editing-research-methodology` |
| Derive a score, prove an invariant, design an ablation, or calculate uncertainty | `video-editing-proof-and-analysis-toolkit` |
| Certify an output, add a golden, or define release evidence | `video-editing-validation-and-qa` |
| Make a paper, novelty, benchmark, or release claim | `video-editing-external-positioning` |
| Debug an observed failure | `video-editing-debugging-playbook` |

Do **not** use this skill to label missing production controls as research. Adding authentication, immutable model packaging, fail-closed startup, a clean build, render approval, or measured QA is engineering backlog. Research begins only when a controlled experiment compares mechanisms under those controls.

## Enforce The Research Perimeter

Apply these rules before any experiment:

- Run without network access. Never call an external AI service. Never let Maven, Python, a model library, or a worker download dependencies or weights.
- Provision every dependency and model before runtime through the approved artifact process. Record artifact name, exact version, SHA-256, license, approval, platform, and expected resource envelope.
- Use only footage, voices, music, sound effects, fonts, LUTs, and model outputs whose experiment and redistribution rights are recorded. Treat generated media as licensable artifacts, not automatically safe assets.
- Reject missing or invalid models and assets. Never substitute silence, tones, heuristic analysis, host `say`, host `espeak`, or an untracked local asset.
- Require explicit render approval. Keep every experiment flag off by default and leave production-facing defaults unchanged.
- Keep raw media and model prompts out of logs. Treat faces, voices, transcripts, filenames, and embeddings as sensitive data until the threat model says otherwise.
- Execute experiments in an isolated project/output root with quotas. Do not point a scheduler at production input or output directories.
- Route all source changes, model additions, data collection, and promotion through `video-editing-change-control`. A research result is not production approval.

The checked-in launchers violate the target perimeter if used as written: `tools/run_local_cv_worker.sh` can install Python packages and load the default `yolov8n.pt`; `tools/run_local_asset_worker.sh` can install packages; and `tools/local_asset_worker.py` calls `get_pretrained`. Do not run those launchers for research until an offline, pinned, checksum-verified mode exists.

## Separate Backlog From Research

Complete or explicitly gate this backlog before interpreting creative results:

| Known gap | Why it is not research | Required gate |
|---|---|---|
| Highlight rendering now defaults off and approval on, but approval is a bare file rather than authenticated evidence bound to source/plan/configuration digests | This is an authorization and provenance gap, not a hypothesis | Keep rendering disabled until digest-bound approval and recovery behavior are implemented and tested |
| `SourceVisualAnalyzer` can fall back to `HeuristicVisualAnalysisProvider` | Silent mechanism substitution invalidates attribution | Set fallback off and persist the exact analyzer identity |
| Generated audio still lacks certified semantic-fit and provenance evaluation | Placeholder rejection is implemented, but file audibility is not creative or licensing evidence | Add model/asset manifests and held-out scene-to-audio preference evaluation |
| No licensed, checksummed resident asset-model bundle is present | Packaging and provenance are engineering prerequisites | Provision and verify Piper, MusicGen, and AudioGen artifacts without runtime acquisition |
| Highlight QA measures only selected technical defects | Duration, black ranges, long silence, and sample peaks are probed, while loudness, true peak, A/V sync, freezes, raster text safety, semantic fit, and human correlation remain open | Extend the versioned probe portfolio before using certification labels |
| No licensed, versioned creative corpus or human-scored golden inventory is checked in | An experiment cannot generalize from anecdotal outputs | Approve a corpus manifest and annotation protocol; store media outside Git |
| Python audio dependencies are unpinned and model artifacts are not locked | Results cannot be reproduced | Build an immutable offline runtime with a Software Bill of Materials (SBOM) and checksums |

Verify the current guardrail-sensitive defaults without starting the application:

```bash
rg -n "render-enabled:|require-director-approval:|fallback-to-heuristic:|auto-start:|strict-runtime:" src/main/resources/application.yml
rg -n "pip install|get_pretrained|YOLO\(|write_silence|write_fallback_tone|fallbackTone" tools src/main/java/org/example/videoclips/editing
```

## Establish One Evaluation Contract

Create one versioned corpus manifest and one immutable evaluation split before comparing ideas. Do not select examples after seeing results.

Define these terms once:

- **Temporal IoU:** intersection divided by union of a predicted and reference time range.
- **nDCG@3:** normalized discounted cumulative gain for the first three ranked candidates; it rewards relevant moments near the top.
- **Pairwise win rate:** fraction of blinded A/B judgments preferring the candidate over the baseline; ties count as one half.
- **Spearman rho:** rank correlation between an automated score and human ordering.
- **RTF:** real-time factor, processing seconds divided by source-media seconds; lower is faster.
- **Equivalence margin:** the largest quality loss accepted when testing that a faster method is practically no worse.
- **Confidence interval (CI):** an uncertainty interval computed by the pre-registered method; do not report a point estimate alone.

For every frontier item, write a dated experiment record with:

```text
question; mechanism; baseline commit; corpus-manifest hash; split hash
model/dependency hashes and licenses; hardware/OS; experiment flag
primary metric; prediction made before running; equivalence margin
negative controls; adversarial reviewer; stop/retire rule; raw artifact root
```

Use blinded review with multiple reviewers and report disagreement. Category, source identity, variant, and generation seed belong in the analysis table, not metric labels or normal application logs.

## Frontier Portfolio

Rank work in this order unless evidence changes the dependency graph.

| Rank | Program | Research question | Depends on |
|---:|---|---|---|
| 1 | Offline multimodal highlight ranking | Can local temporal evidence find human-valued moments better than positional windows? | Corpus, fail-closed local inference |
| 2 | Controllable cinematic planning | Can a constrained local director produce valid, intentional timelines rather than one-range templates? | Ranked moments, plan semantics |
| 3 | Human-correlated audiovisual QA | Can measurements predict reviewer judgment and block technical defects? | Scored outputs, real probes |
| 4 | Fail-closed local generative audio and voiceover | Can locally packaged models create licensed, intelligible, context-fit assets that pass gates? | Immutable model runtime, QA |
| 5 | Causal edit-component evaluation | Which effects actually cause preference changes, and for which categories? | Deterministic variants, blinded review |
| 6 | Quality-preserving local inference efficiency | Can cascades reduce runtime and memory without meaningful quality loss? | Stable quality metrics, hardware matrix |
| 7 | Restartable, reproducible rendering | Can content-addressed stages resume safely and reproduce equivalent outputs? | Manifested inputs, deterministic stage contracts |

## 1. Offline Multimodal Highlight Ranking

**Repo-grounded problem.** In the older edit-project flow, `CinematicHighlightAnalyzer` creates fixed eight-second windows, caps each clip at twelve candidates, classifies from project names and paths, and adds source-position bonuses. The single-source flow now has a safer deterministic baseline: `HighlightCandidateGenerator` persists shot-aligned or overlapping coverage windows, ranks them with source-level visual quality, scene score, duration fit, and FFmpeg non-silence, and downweights heuristic/fallback visual evidence. The visual scores are not temporally resolved, `unclassified_audio` is not semantic audio understanding, and there is no checked-in transcript or temporal audio-event classifier. The baseline therefore produces review candidates, not content-aware highlight discovery.

**Hypothesis.** A fully local, temporally aligned ranker using shot-level visual embeddings, speech/transcript evidence, audio events, motion, novelty, and narrative role will improve top-three relevance across car, food, family, and generic footage. This is a repo hypothesis, not an external SOTA claim.

**Concrete asset.** Reuse `ShotSceneSegmenter`, extracted frames/contact sheets, `SourceAudioAnalysis`, the `VisualAnalysisProvider` port, `HighlightCandidate`, persisted analysis JSON, and the tested `HighlightCandidateGenerator` as the frozen single-source baseline. Do not call that baseline a research result.

**First three steps.**

1. Approve a licensed corpus manifest; have blinded reviewers mark worthwhile ranges, category, narrative role, and 0-4 relevance. Freeze source-disjoint train/development/test splits and compute baseline nDCG@3 and temporal IoU.
2. Add a disabled experimental provider behind an explicit port. Feed per-shot features only from preprovisioned local models; persist timestamps, model hashes, feature schema, confidence, and missing-modality state. Fail if a required modality is missing.
3. Compare positional baseline, each single modality, the complete model, shuffled-timestamp control, and metadata-only control. Use the same candidate budget and report per-category CIs.

**Prediction before running.** Predict at least `+0.10` absolute nDCG@3 and `+0.10` absolute best-match temporal IoU over the frozen baseline, with no category losing more than `0.03` nDCG@3. Lock these numbers in the experiment record before inference.

**You have a result when:** the held-out, source-disjoint test CI excludes zero for the primary improvement; shuffled timestamps materially reduce performance; and blinded reviewers prefer montages built from the new top candidates by at least 60% pairwise win rate. This proves a repo result, not SOTA.

**Retire or narrow when:** the CI includes zero after the pre-registered sample size, gains vanish on unseen sources, the metadata control matches the full model, or any required model lacks approved offline packaging or rights.

**Risks and obligations.** Control transcript leakage and repeated scenes; measure demographic/category error; encrypt or isolate embeddings; bound CPU/GPU memory and RTF; never send media to a remote endpoint.

## 2. Controllable Cinematic Planning

**Repo-grounded problem.** `HighlightDirectorFlowService` consumes a manually supplied and contract-validated `director/edit-plan.json`, converts each highlight to one `EditDecision`, schedules per-line voiceover from estimated reading time, spaces overlays evenly, and chooses mostly cut/fade transitions. The plan contains direction text, but the renderer still has a much smaller executable vocabulary.

**Hypothesis.** A local planner that combines a typed capability graph, hard timeline constraints, and a learned or search-based objective can produce more intentional and controllable edits than the current one-range template without allowing invalid plans.

**Concrete asset.** Reuse `HighlightDirectorPlan`, `EditPlan`, `EditPlanValidator`, `HighlightVisualEffectsStage`, render manifests, and FFmpeg rendering. Treat every renderer feature as unavailable until a contract test proves it executable.

**First three steps.**

1. Inventory the exact executable vocabulary: trims, speed bounds, transitions, overlays, audio cues, assets, and output profiles. Add round-trip contract fixtures for valid, invalid, and unsupported plans.
2. Define measurable planning controls: target duration, shot diversity, narrative roles, pacing curve, dialogue preservation, asset budget, effect density, and forbidden combinations. Predict all constraint values before rendering.
3. Generate blinded A/B plans from the frozen template and the experimental local planner over the same ranked moments and assets. Render only after approval; score validity, control adherence, repetition, story coherence, and preference.

**Prediction before running.** Predict 100% hard-constraint validity, at least 95% requested-control adherence, and at least 60% pairwise preference over the template, with median rendered duration error no greater than 50 ms.

**You have a result when:** every held-out plan validates and renders, the preference CI is above 50%, changing one requested control changes its measured output while unrelated controls remain within pre-registered tolerances, and unsupported capabilities fail before rendering.

**Retire or narrow when:** preference is indistinguishable from the template, the planner depends on prompt wording rather than typed controls, renderer behavior cannot implement the plan, or constraint repairs erase the preference gain.

**Risks and obligations.** Prevent prompt/filename injection, fabricated factual voiceover, unsafe overlay text, excessive flash/cut rates, and unbounded plan complexity. Persist planner/model hash, seed, constraint decisions, repairs, and approval identity.

## 3. Human-Correlated Audiovisual QA

**Repo-grounded problem.** `HighlightFfmpegRenderer.buildQaReport` now probes encoded duration, black ranges, long silence, and sample peaks, while asset resolution, mastering-filter presence, and overlay plan bounds are structural checks. Neither renderer establishes integrated loudness, true peak, A/V sync, freeze detection, raster text safety, cinematic quality, or correlation with human judgment.

**Hypothesis.** A transparent scorecard combining technical defects, speech intelligibility, dialogue/music balance, cut/beat alignment, shot repetition, exposure/blur continuity, text safety, and artifact provenance will predict human accept/reject decisions well enough to gate review.

**Concrete asset.** Reuse `RenderQaReport`, `RenderQaCheck`, FFmpeg command capture, `RenderManifest`, source analysis, and the existing black/silence/peak probe patterns.

**First three steps.**

1. Define a 0-4 blinded human rubric with mandatory technical rejects and separate creative dimensions. Label real outputs plus deliberately injected black frames, silence, clipping, desynchronization, repetition, unsafe text, and missing provenance.
2. Implement each metric as a versioned probe that emits raw numbers, threshold source, evidence path, and failure semantics. Never infer success from a command string or planned value.
3. Fit thresholds on development data, freeze them, then report defect sensitivity/specificity, Spearman rho by dimension, calibration, and false-pass cases on held-out sources.

**Prediction before running.** Predict at least 95% sensitivity to injected blocking defects, no more than 5% false passes for mandatory rejects, and Spearman `rho >= 0.65` between the composite score and overall human rank.

**You have a result when:** held-out results meet all three predictions, reviewer disagreement is reported, every blocking decision links to reproducible measurements, and removing any claimed useful metric causes the pre-registered degradation.

**Retire or narrow when:** correlation fails on a category, thresholds drift across render profiles, a proxy rewards visibly worse outputs, or human disagreement makes the target unidentifiable. Keep reliable technical probes even if the creative composite is retired.

**Risks and obligations.** Do not hide category-specific failures in an average. Avoid sensitive identifiers in metrics. Pin FFmpeg and probe versions. Treat automated creative scoring as review prioritization until change control explicitly promotes it.

## 4. Fail-Closed Local Generative Audio And Voiceover

**Repo-grounded problem.** The 2026-07-21 working tree removed silence/tone/host-speech success fallbacks, requires existing local AudioCraft model paths with offline resolution, deletes failed/inaudible output, and blocks rendering when requested assets are missing. The runtime still lacks a checked-in immutable licensed Piper/MusicGen/AudioGen bundle, semantic music/SFX fit measurement, speech intelligibility measurement, and artifact-level license attestations. Demonstrating locally generated production quality remains research.

**Hypothesis.** Preprovisioned local models plus artifact-level validation can generate script-faithful voiceover and context-fit music/SFX that reviewers prefer to source-audio-only edits without placeholders or unverifiable assets.

**Concrete asset.** Reuse typed `HighlightAssetRequest`, `ResolvedEditAsset`, category-aware libraries, audio cues, ducking/loudness filters, and render manifests.

**First three steps.**

1. Define an immutable model/voice registry with checksums, licenses, approved uses, voice consent, sample rates, languages, seeds, resource limits, and a zero-network startup test. Make missing entries block the experiment.
2. Add pre-mix asset gates: non-silence/non-tone detection, duration, clipping, script fidelity, pronunciation review, loudness, model provenance, and license completeness. Preserve rejected files as quarantined evidence, never render inputs.
3. Run approved, seed-controlled A/B tests for source-only, licensed-library, and local-generated variants. Score intelligibility, script faithfulness, semantic fit, distraction, mix balance, preference, generation RTF, and failure rate.

**Prediction before running.** Predict zero placeholder false passes, at least 95% reviewer-rated script faithfulness for voiceover, at least 60% pairwise preference over source-only edits, and no unresolved provenance or license field.

**You have a result when:** all outputs are traceable to approved immutable artifacts, blocking gates catch every injected silence/tone/wrong-script control, preference clears its CI gate on held-out prompts, and an offline cold start neither attempts network access nor degrades to another mechanism.

**Retire or narrow when:** licensing blocks deployment, voice consent is absent, faithfulness misses target, generation is unstable across seeds, reviewers prefer source-only audio, or resource use violates the declared service envelope. Fall back only to an explicitly planned source-only edit, never a placeholder asset.

**Risks and obligations.** Threat-model voice impersonation, prompt injection, harmful content, model supply chain, copyrighted training/output concerns, GPU denial of service, and retention of generated voices. Record security and legal approval before promotion.

## 5. Causal Edit-Component Evaluation

**Repo-grounded problem.** The renderer applies coupled treatments such as contrast, saturation, sharpening, vignette, crop, transitions, overlays, music, SFX, and voiceover. Current tests prove command construction, not which component changes human judgment.

**Hypothesis.** Controlled counterfactual renders can identify category- and context-specific effects that cause preference changes, enabling a smaller and safer cinematic vocabulary.

**Concrete asset.** FFmpeg is a deterministic command backend; `EditPlan`, `HighlightVisualEffectsStage`, and manifests can generate paired variants from identical source decisions.

**First three steps.**

1. Freeze edit decisions and assets, then define one-factor removals and a small pre-registered interaction set. Hash all non-varied inputs and randomize blinded presentation order.
2. Render paired variants with identical codec settings. Verify duration, frames outside the treatment, and audio outside the treatment remain within declared equivalence tolerances.
3. Estimate per-category effect sizes and CIs; repeat the strongest result on new sources and assign an adversarial reviewer to search for confounding.

**Prediction before running.** Predict that at least one component has an absolute pairwise preference effect of 10 percentage points or more in one category, while at least one currently available component is neutral or harmful.

**You have a result when:** the effect repeats on held-out sources, the negative control remains neutral, the changed mechanism explains all observed differences, and the effect survives correction for the pre-registered comparisons.

**Retire or narrow when:** effects reverse across sources without an explanatory moderator, equivalence checks show unintended differences, or reviewer blinding fails. Remove unsupported default treatments through change control; do not universalize a category-specific result.

**Risks and obligations.** Guard against photosensitive flash, abrupt loudness, reviewer fatigue, and source memorization. Store assignments and analysis code; do not store reviewer identity in application telemetry.

## 6. Quality-Preserving Local Inference Efficiency

**Repo-grounded problem.** Local CV is an HTTP worker loading YOLO; local audio generation loads Python/Torch/AudioCraft. The repository has no fixed model artifact set, cross-platform hardware matrix, per-stage memory limits, or quality-versus-runtime benchmark for macOS development, Linux/VPS production, and cloud deployment.

**Hypothesis.** An uncertainty-gated cascade using cheap temporal features first and expensive local models only for ambiguous segments can reduce RTF and peak memory while remaining within a pre-registered quality-equivalence margin.

**Concrete asset.** Reuse proxy media, thumbnails, shots, process timing logs, the visual provider boundary, local worker health contracts, and benchmark-harness conventions under `src/test/java/org/example/videoclips/perf`.

**First three steps.**

1. Declare reproducible macOS CPU, Linux/VPS CPU, and approved cloud CPU/GPU profiles; pin thread counts, model hashes, warm/cold state, corpus split, and power mode. Measure per-stage RTF, peak resident memory, throughput, failures, and quality.
2. Implement a disabled cascade that emits uncertainty and escalation reasons. Bound queue depth, concurrency, memory, timeout, and cancellation; never substitute a different analyzer after failure.
3. Sweep thresholds on development data, freeze one operating point per hardware profile, and run equivalence tests on held-out sources plus 2x load and 60-minute endurance tests.

**Prediction before running.** Predict at least 30% lower median analysis RTF and 25% lower peak memory than always-expensive inference, with nDCG@3 loss no greater than `0.02` and no category loss greater than `0.03`.

**You have a result when:** both efficiency CIs clear their targets, quality stays inside the equivalence margins, memory does not grow continuously, and slowdown or failure does not cause unbounded work accumulation.

**Retire or narrow when:** quality equivalence fails, uncertainty is miscalibrated on unseen categories, GPU gains disappear after transfer/queue overhead, or separate artifacts create an unmaintainable supply chain. Keep platform-specific results platform-specific.

**Risks and obligations.** Enforce container/device least privilege, resource quotas, model license compatibility, SBOM coverage, predictable startup, and telemetry without high-cardinality media IDs.

## 7. Restartable, Reproducible Rendering

**Repo-grounded problem.** The highlight flow loops through assets and renders, then publishes final files and manifests. It has no checked-in content-addressed stage graph or failure-injection evidence for restart. Runtime timestamps, temporary prompt filenames, model randomness, host tools, and codecs can change bytes.

**Hypothesis.** A content-addressed stage contract with atomic publication can resume after failure, avoid repeated work, and reproduce exact bytes on one pinned platform plus semantically equivalent media across approved platforms.

**Concrete asset.** Reuse the folder contract, JSON stores, `RenderManifest`, recorded FFmpeg commands, stable project/highlight IDs, and deterministic edit decisions.

**First three steps.**

1. Define a stage key over normalized plan, source/asset/model/tool hashes, render profile, seed, and schema version. Separate immutable stage output from atomic publication; never include wall-clock time or absolute workspace paths in the key.
2. Add crash points before/after analysis, asset generation, segment render, mix, QA, and publication. Restart and record reused stages, recomputed stages, orphan cleanup, final status, and manifest lineage.
3. Compare clean and resumed runs on each pinned platform. Require exact hashes on the same platform/toolchain; define measured semantic tolerances for duration, frame/audio similarity, loudness, and synchronization across platforms.

**Prediction before running.** Predict at least 50% less recomputation after a failure beyond the midpoint, zero published partial finals, exact same-platform final hashes for deterministic assets, and all cross-platform measurements inside pre-registered tolerances.

**You have a result when:** every injected failure resumes or fails terminally without corrupting prior evidence, cache invalidation responds to every declared input change, same-platform hashes repeat, and cross-platform equivalence passes independent probes.

**Retire or narrow when:** hidden inputs repeatedly invalidate reproducibility, cache validation costs approach recomputation, nondeterministic models cannot expose seeds, or hardware codecs cannot meet exactness. Narrow exact reproducibility to pinned software encoding and retain semantic equivalence elsewhere.

**Risks and obligations.** Prevent cache poisoning, cross-tenant artifact reuse, path traversal, stale-license reuse, secret inclusion in keys, and disk exhaustion. Encrypt or isolate sensitive stage outputs and apply retention policy.

## Promote Or Retire

At the end of every experiment:

- Publish raw measurements, exclusions, failed predictions, negative controls, reviewer disagreement, licenses, hashes, and resource profiles.
- Ask the assigned adversarial reviewer to explain all positive and negative observations with one mechanism and attempt to refute it.
- Mark the idea `candidate`, `replicated`, `retired`, or `inconclusive`; never call it production-ready from one experiment.
- Require replication on held-out sources and at least the applicable macOS and Linux/VPS profiles before proposing a production change.
- Route adoption through `video-editing-change-control`, certification through `video-editing-validation-and-qa`, and any novelty/SOTA statement through `video-editing-external-positioning`.
- Preserve a retired idea's hypothesis, commands, evidence, and stop reason so the next engineer does not repeat it unchanged.

## Provenance and maintenance

This skill was derived from repository source, tests, configuration, plans, and Git history available on 2026-07-21. Predictions and thresholds are proposed falsifiable targets, not observed results. No external SOTA claims were verified.

Re-verify volatile facts with no network and no application startup:

```bash
rg -n "DEFAULT_CANDIDATE_SECONDS|MAX_CANDIDATES_PER_CLIP|source position|Project metadata" src/main/java/org/example/videoclips/editing/CinematicHighlightAnalyzer.java
rg -n "analyzer.analyze|directorPromptGenerator.generate|CinematicHighlightAnalyzer" src/main/java/org/example/videoclips/editing/HighlightSourceScheduler.java
rg -n "List.of\(decision\)|step = targetDuration|transitionIn|transitionOut|missing_director_plan" src/main/java/org/example/videoclips/editing/HighlightDirectorFlowService.java
rg -n "duration_matches_timeline|required_assets_resolved|text_overlays_safe|audio_mastering_applied" src/main/java/org/example/videoclips/editing/HighlightFfmpegRenderer.java
rg -n "blackDetectCommand|silenceDetectCommand|clippingDetectCommand" src/main/java/org/example/videoclips/editing/FfmpegEditRenderer.java
rg -n "get_pretrained|write_silence|write_fallback_tone|say|espeak" tools/local_asset_worker.py src/main/java/org/example/videoclips/editing/LocalAssetSynthesizer.java
rg -n "pip install|YOLO\(|yolov8n.pt" tools/run_local_cv_worker.sh tools/run_local_asset_worker.sh tools/local_cv_worker.py
rg -n "^torch$|^audiocraft$|^soundfile$|^numpy$" tools/local_asset_requirements.txt
git log --oneline --all -- src/main/java/org/example/videoclips/editing tools docs/production-cinematic-highlight-editing-plan.md
mvn -o -Dtest=CinematicHighlightAnalyzerTest,HighlightDirectorFlowServiceTest,LocalCvVisualAnalysisProviderTest test
```

The final command passed locally on 2026-07-21 with eight tests. Offline Maven fails closed if required artifacts are absent; do not remove `-o` to make it pass.