video-to-shorts

Vidéo en Courts (Shorts)

Dépendances

/video-understand est un prérequis. Exécutez-le d'abord pour que les courts utilisent la transcription source validée et la chronologie canonique. Avant de commencer, vérifiez qu'il est installé. S'il ne l'est pas, prévenez l'utilisateur que ce prérequis manque et arrêtez-vous avant de traiter les médias.

Nécessite ffmpeg/ffprobe dans le PATH et Python avec Pillow. Vérifiez-les avant de traiter les médias.

Périmètre

Ce skill comporte deux phases de projet :

1. Planifier avant le rendu : mapper la transcription comprise au temps programme, rédiger et approuver les candidats, et écrire work/shorts/shorts-plan.json. Cette phase n'écrit aucune vidéo finale.
2. Finaliser après le rendu : après que chaque montage principal sélectionné est approuvé et que la livraison principale partagée est vérifiée, réexécuter plan.py pour lier les mêmes plages approuvées à cette livraison, puis extraire les sorties horizontales et verticales optionnelles.

Il possède le jugement des candidats courts, la qualification déterministe, l'extraction horizontale, les transcriptions relatives aux courts, et la livraison verticale déterministe optionnelle. Il ne transcrit pas en mode projet, ne modifie pas la séquence principale, n'ajoute pas de sous-titres/graphismes, n'étalonne pas, ne publie pas, et n'effectue pas de suivi continu du sujet.

Les Courts livrés sont des dérivés de final/final-video.mp4, mais la planification des candidats précède ce fichier. Enregistrez l'opération dans le DAG du projet, mais ne l'ajoutez jamais à sequences.main.operations ; la livraison principale et sa comparaison original-vs-final restent inchangées.

Entrées du Projet

• work/project.json
• la source du projet enregistrée par project.source.path
• work/understand/transcript.json en temps source
• work/timeline.json
• les révisions actives des opérations principales à chaque phase

La planification ne nécessite pas final/final-video.mp4. La finalisation et l'extraction nécessitent ce rendu exact du projet avec render.status: verified.

prepare_transcript.py --timeline appelle la fonction partagée projectlib.map_transcript_to_timeline. Les temps des candidats/extraction sont donc en secondes programme sur la vidéo finale réelle. Les mots supprimés par le montage principal ne sont pas disponibles pour les courts. Chaque mot conservé garde son source_range, program_range, et clip_id.

Les métadonnées de transcription du projet lient la source du projet, la transcription source et la chronologie par chemin absolu, taille, date de modification et SHA-256. Les images de révision des candidats mappent leurs horodatages programme via timeline.json vers la vidéo source. La validation des candidats refuse une liaison modifiée.

Structure des Sorties

work/shorts/
|-- transcript.json
|-- transcript_metadata.json
|-- candidates.json
|-- shorts-plan.json
|-- review/
|   |-- candidate_review.json
|   `-- approved_candidates.json
`-- short-001/
    |-- transcript.json
    |-- extraction-report.json
    `-- vertical-agent/
        |-- agent_vertical_plan.json
        |-- vertical_plan.json
        `-- review/vertical_review.json

work/cache/shorts/                 # images/feuilles/médias intermédiaires jetables

review/06-shorts/
|-- candidates-<review-id>.html              # page faisant autorité, immuable
|-- candidates-<review-id>-question.md
|-- assets/candidates-<review-id>/            # images début/milieu/fin immuables
|-- candidates.html                           # alias non autoritaire du dernier
|-- candidates-summary.md
|-- short-001-horizontal.jpg
|-- short-001-vertical-preview.mp4
|-- short-001-vertical-contact-sheet.jpg
|-- short-001-vertical-preview-summary.json
|-- short-001-vertical-preview-probe.json
|-- <short-id>-vertical-review-<review-id>.html # page faisant autorité, immuable
|-- <short-id>-vertical-review-<review-id>-question.md
|-- <short-id>-vertical-review.html             # alias non autoritaire du dernier
|-- <short-id>-vertical-review-assets/
|   `-- <review-id>/                             # preuves faisant autorité, immuables
|       |-- preview.mp4                          # absent pour REVIEW_REQUIRED
|       |-- contact-sheet.jpg                    # absent pour REVIEW_REQUIRED
|       |-- preview-summary.json
|       `-- media-probe.json
`-- shorts-summary.md

final/shorts/
|-- short-001-horizontal.mp4
`-- short-001-vertical.mp4          # seulement si sélectionné et approuvé

Transcription Programme

Exécutez depuis la racine du dépôt :

$RepoRoot = (Resolve-Path ".").Path
$SkillRoot = Join-Path $RepoRoot "skills\video-to-shorts"
$ProjectRoot = (Resolve-Path "<project-root>").Path
$Work = Join-Path $ProjectRoot "work"
$ShortsWork = Join-Path $Work "shorts"
$ProjectSource = (Resolve-Path "<project-source-from-work/project.json>").Path
$FinalVideo = Join-Path $ProjectRoot "final\final-video.mp4"
$ShortsReview = Join-Path $ProjectRoot "review\06-shorts"
New-Item -ItemType Directory -Force $ShortsWork,$ShortsReview | Out-Null

python "$SkillRoot\scripts\prepare_transcript.py" $ProjectSource `
  --transcript "$Work\understand\transcript.json" `
  --timeline "$Work\timeline.json" `
  --out $ShortsWork

Le mode chronologie de projet nécessite la transcription canonique fournie. Le mode autonome peut omettre --timeline ; il conserve le temps relatif à l'entrée et peut utiliser le repli temporaire video-understand/scripts/transcribe.py. Aucune transcription n'est découverte automatiquement.

Rédaction des Candidats

Générez le contexte visuel de la vidéo longue dans le cache, inspectez chaque feuille nécessaire à une décision, et rédigez manuellement le JSON des candidats. Le code déterministe valide le jugement éditorial ; il n'invente ni candidats ni scores.

python "$SkillRoot\scripts\prepare_visual_context.py" $ProjectSource `
  --timeline "$Work\timeline.json" `
  --out "$Work\cache\shorts\candidate-visual" --interval 15

L'entrée des candidats reste shorts-candidates.v2 pour la compatibilité. Définissez selection.evidence_mode et chaque evidence_mode du candidat à text_visual. Chaque candidat nécessite :

• un candidate_id, titre et type de scène stables ;
• des start_time/end_time complets en temps programme ;
• un transcript_excerpt exactement égal aux mots de transcription chevauchants, et non aux segments chevauchants entiers ;
• les six entrées de score et des raisons non vides ;
• un metadata.editorial_reason non vide ;
• des filler_drop_spans et champs de preuve visuelle éventuellement révisés.

Ne fournissez pas de score total ; le validateur ajoute les six dimensions :

Dimension	Maximum
hook	20
completeness	20
audience_value	20
emotion_tension	15
quotability	15
pace_editability	10

Préférez une pensée complète et indépendamment compréhensible à un fragment plus court. Conservez une question d'intervieweur dépendante, une prémisse, un support d'affirmation, un retournement ou un aboutissement lorsqu'il est nécessaire. Les limites doivent tomber sur des mots et des pensées entiers.

Validez le fichier rédigé :

$CandidateDir = Join-Path $ShortsWork "preview\text_visual"
python "$SkillRoot\scripts\candidates.py" `
  --out $CandidateDir `
  --candidates "$CandidateDir\candidate-input.json" `
  --transcript "$ShortsWork\transcript.json" `
  --project-root $ProjectRoot

Ceci écrit les fichiers de prévisualisation de compatibilité, le work/shorts/candidates.json durable, et review/06-shorts/candidates.{html,summary.md}.

Modes de Révision

La sélection des candidats et le mode de livraison sont une seule porte liée par hachage. La livraison est exactement horizontal_only ou horizontal_and_vertical.

Ouvrez la page interactive liée en mode humain :

python "$SkillRoot\scripts\interaction.py" candidate-open --out $ShortsWork --review-out $ShortsReview

La commande imprime une page faisant autorité, avec un identifiant de révision. Le reçu lie cette page, son JSON candidat, la transcription, le média source, la question fixe et chaque image extraite par SHA-256. candidates.html n'est qu'un alias de commodité non autoritaire vers la dernière page. Ouvrez le chemin faisant autorité imprimé avec la commande native du système d'exploitation actuel :

# Windows PowerShell
Start-Process (Resolve-Path -LiteralPath "<printed-authoritative-page>")
# macOS
open "<printed-authoritative-page>"
# Linux
xdg-open "<printed-authoritative-page>"
# Agent : Présentez la page faisant autorité et STOP.

Si l'ouverture échoue, réessayez la commande native et signalez l'échec si elle ne s'ouvre toujours pas. Ne continuez pas après l'avoir présentée. La page commence avec toutes les cases à cocher des candidats et les deux choix de livraison initialement non sélectionnés. L'utilisateur doit sélectionner 1 à 5 candidats et un mode de livraison. La page liée ne sélectionne jamais silencieusement des candidats.

Pour l'approbation, copiez ce résumé structuré exact généré par la page sans le modifier dans candidate-answer :

Révision des candidats Shorts
Révision : <review-id>
Candidats : text_visual/cand-001, text_visual/cand-002
Livraison : horizontal_and_vertical

Pour une révision, copiez ce résumé structuré exact généré par la page sans le modifier :

Révision des candidats Shorts
Révision : <review-id>
Décision : revise
Modifications : <modifications demandées non vides>

Enregistrez la réponse ultérieure sans la réécrire :

python "$SkillRoot\scripts\interaction.py" candidate-answer `
  --out $ShortsWork --response-file "<verbatim-summary-file>"

Lorsque l'utilisateur délègue explicitement les décisions :

python "$SkillRoot\scripts\interaction.py" candidate-open `
  --out $ShortsWork --review-out $ShortsReview --decision-mode agent `
  --delegation-note "L'utilisateur a délégué la sélection des Shorts et l'approbation verticale."

python "$SkillRoot\scripts\interaction.py" candidate-agent-approve `
  --out $ShortsWork `
  --candidates "text_visual/cand-001" `
  --delivery horizontal_and_vertical `
  --rationale "La plage sélectionnée a un accroche, une explication et un aboutissement autonomes."

L'Agent ouvre et inspecte la même page faisant autorité, utilise des références de candidats explicites, un mode de livraison explicite et une justification non vide. Il n'écrit jamais de fausse réponse humaine ou de user_response. Les modes Humain et Agent s'excluent mutuellement ; les commandes de réponse humaine échouent en mode Agent et les commandes d'approbation d'Agent échouent en mode humain. La vérification du reçu revérifie les hachages de la révision, de la page et du média. Les artefacts de source, de candidat, de transcription, de page, de question, d'image ou de candidat approuvé régénérés invalident l'approbation.

Plan Canonique

python "$SkillRoot\scripts\plan.py" `
  --out $ShortsWork --project-root $ProjectRoot

work/shorts/shorts-plan.json utilise le schema_version: 1 entier. Il enregistre :

• target: derived, timebase: program, et timeline_id ;
• delivery_status: awaiting_main_render pendant la planification ;
• les liaisons de source et de chronologie du projet utilisées pour la révision des candidats ;
• les révisions exactes depends_on / based_on de la séquence principale active ;
• le mode de sélection, la justification, le mode de livraison et l'ID de révision ;
• les identifiants stables des Shorts ;
• le program_range explicite et les source_ranges mappés ;
• les preuves de score/éditoriales, les suppressions de mots de remplissage approuvées et les plages de conservation en temps programme ;
• les chemins de transcription/rapport de travail et les chemins de livraison ../final/shorts/*.mp4.

La première exécution est la fin de la phase de planification. Arrêtez-vous ici et continuez les sous-titres, cartes de contenu, animations graphiques et autres opérations de séquence principale restantes dans l'ordre canonique. N'exécutez pas extract_shorts.py et ne créez pas final.mp4 à partir de ce skill.

Après que le rendu partagé a vérifié final/final-video.mp4, réexécutez la même commande plan.py. Elle revalide la source et la chronologie approuvées du projet, actualise les révisions complètes des opérations actives, ajoute l'empreinte du rendu principal vérifié et définit delivery_status: ready. Un changement de chronologie nécessite de nouveaux candidats et une nouvelle approbation ; les opérations uniquement pixel comme les cartes de contenu et les sous-titres non.

La qualification reste déterministe : score d'au moins 70, complétude d'au moins 15, durée de sortie estimée de 20 à 90 secondes, extrait exact valide, pas de chevauchement supérieur à 50 % avec un court mieux classé, et au plus cinq sorties sauf configuration.

Seuls les mots d'hésitation isolés et sémantiquement vides avec des limites de mots sûres peuvent être approuvés comme suppressions de mots de remplissage. Les plages rejetées/non sûres restent dans le plan avec les raisons. La suppression totale ne peut pas dépasser 15 % et aucune plage de conservation ne peut être inférieure à 0,15 seconde.

Extraction Horizontale

python "$SkillRoot\scripts\extract_shorts.py" `
  --video $FinalVideo --out $ShortsWork `
  --project-root $ProjectRoot

Avant l'extraction, le script revérifie l'empreinte du rendu principal, l'état du rendu du projet, la liste complète des opérations principales et leurs révisions, le reçu du candidat, le hachage du candidat approuvé et la vidéo source. Un plan awaiting_main_render est rejeté. Chaque plage de conservation devient sa propre entrée -ss/-t/-i seekée ; ffmpeg concatène ces entrées et effectue un codage H.264/AAC. Il ne décode pas la vidéo principale complète une fois par plage de conservation.

Le mot de transcription final sélectionné et le point de coupure du média sont des limites séparées. L'extraction préserve au moins 0,25 seconde d'audio de relâchement après le contenu sélectionné et cible 0,30 seconde. --no-refine-boundaries désactive uniquement l'accrochage de phrase sémantique ; il ne désactive jamais la poignée de relâchement obligatoire. Si la source se termine avant que la poignée requise ne puisse être préservée, l'extraction échoue au lieu de marquer le court comme vérifié.

La transcription relative au court exclut les mots supprimés, décale les mots ultérieurs sur une horloge continue basée sur zéro et conserve les preuves de la source/du programme d'entrée. Le média horizontal va directement dans final/shorts ; le travail ne contient que sa transcription et son rapport.

Planification Verticale

La livraison verticale commence à partir de la sortie horizontale approuvée. Générez des preuves visuelles denses à 1 seconde, ou 0,5 seconde lorsque le mouvement l'exige. Inspectez chaque feuille et rédigez l'un des éléments suivants :

• STATIC_CROP : un seul recadrage fixe stable 9:16.
• SCENE_CROP : recadrages fixes délimités par scène, avec LETTERBOX uniquement pour les scènes nécessitant des informations horizontales complètes.
• LETTERBOX : avant-plan net complet sur un remplissage flou/assombri.
• REVIEW_REQUIRED : les preuves ne peuvent pas supporter des recadrages fixes déterministes ; le rendu formel est bloqué.

Les scènes de présentateur doivent garder la tête et le torse stables et grands. Les diapositives, produits, groupes et diagrammes doivent conserver les informations essentielles. Ne revendiquez pas de suivi continu. Les changements de recadrage appartiennent aux limites de scène.

Chaque segment du plan couvre entièrement la chronologie du court, a une stratégie, etc.

[...tronqué pour la traduction]