Erledigt, Sir. Ich habe den **Clean AI Image Cut** gebaut: **nur KI-Bilder + Voiceover + word-aligned Subtitles**, ohne grafische Overlays.

MEDIA:/tmp/autoshorts_proof_short_sprint31/calendar-invite-login-trap-30s/clean_ai_cut_v1/calendar-invite-login-trap-30s_clean_ai_cut_v1.mp4

MEDIA:/tmp/autoshorts_proof_short_sprint31/calendar-invite-login-trap-30s/clean_ai_cut_v1/clean_ai_cut_contact_sheet_v1.jpg

MEDIA:/tmp/autoshorts_proof_short_sprint31/calendar-invite-login-trap-30s/clean_ai_cut_v1/clean_ai_keyframes_contact_sheet_v1.jpg

## Version

```text
calendar-invite-login-trap-30s
v1.2.0-clean-ai-image-cut
```

## NoOverlayPolicy

**Erlaubt:**

```text
subtitles_only
```

**Geblockt / nicht verwendet:**

```text
Fake UI
Login Button Overlay
Domain-Karten
Labels
Boxen
Pfeile
Diagramme
Checklisten
Caption Box
Subtitle Bar
Platform API
Posting
Wan/I2V/T2V
```

## KI-Keyframes

Generiert:

```text
6
```

Verwendet:

```text
6
```

QA:

```text
no readable text
no pseudo text detected
no logos
no QR/barcodes
no people/hands/faces
no factual UI content
```

## Video-Metadaten

Preview:

```text
/tmp/autoshorts_proof_short_sprint31/calendar-invite-login-trap-30s/clean_ai_cut_v1/calendar-invite-login-trap-30s_clean_ai_cut_v1.mp4
```

Dauer:

```text
41.875s
```

Resolution:

```text
1080x1920
```

FPS:

```text
24/1
```

SHA256:

```text
6def921d2fe54fd4919e1450231d027fdd8a1833780d3a17d803d7bf7901be0e
```

Manifest:

```text
/tmp/autoshorts_proof_short_sprint31/calendar-invite-login-trap-30s/clean_ai_cut_v1/manifest_clean_ai_cut_v1.json
```

Review Package:

```text
/tmp/autoshorts_proof_short_sprint31/calendar-invite-login-trap-30s/clean_ai_cut_v1/review_package_clean_ai_cut_v1.json
```

## Erste Einschätzung

**Optisch:** klar besser.
Wirkt ruhiger, hochwertiger, weniger “Explainer-Board”, mehr echter Social-Short.

**Semantisch:** schwächer als die Hybrid-Version.
Ohne Login-Button, Domain-Karte und Checkliste sieht man nicht sofort *was genau* falsch ist. Die Story hängt stärker an Voiceover + Subtitles.

Mein Urteil:

```text
Clean AI Cut = premium mood / besserer Look
Hybrid Version = bessere Mechanismus-Klarheit
```

Der wahrscheinlich beste finale Stil wäre nicht entweder/oder, sondern:

```text
Clean AI Cut als Basis
+ maximal 1 sehr reduzierter deterministischer Mechanismus-Moment
```

Zum Beispiel nur einmal kurz:

```text
Suspicious link domain
```

oder

```text
Close invite → open app directly
```

aber ohne Checklisten-Overkill, Boxen-Orgie oder UI-PowerPoint.
Also: **90% Clean AI, 10% präziser Mechanismus**. Sehr unromantisch, aber vermutlich richtig.


[M G] Das sind alles nichtssagende bilder von bürotischen mit laptops… keine termineinladung sichtbar.


Explanation:
**Evaluating response options**

Okay, it seems I need to respond and probably agree with the user. There’s a need to clarify things regarding the feedback. They might expect a correction, so I should suggest that purely text-free AI images can't show a calendar invite without any UI or text. Maybe I can propose creating images that have recognizable shapes of a calendar invite but remain text-free? They said they don't want any visible invitation. I wonder if I need to revise this test.
**Considering next steps**

It looks like I should create the next render since there isn’t an explicit "fix." In this iterative process, I need to produce a corrected concept. I want to generate keyframes for a "visible calendar invite," but without any overlaid graphics. Maybe I can use an AI-generated text-free image featuring a blank calendar card with no readable text? I think generating three keyframes could be helpful. I’ll need to revise the approach and consider whether to allow the inclusion of non-readable UI elements in the image.


social-media-shorts-automation

# Proof Short Real-Problem Reset

Use this when an early short/pilot looks increasingly polished but still fails because viewers cannot see a real problem in the first second.

## Trigger

Switch to this mode when the user says a pilot is:

- pretty but semantically empty
- too abstract or generic
- missing a visible fail / real viewer pain
- overproduced before the format is validated
- relying on AI images, Wan/I2V, glassmorphism, or B-roll as the story carrier

## Archive the old candidate first

Mark the old candidate as a paused learning case, not a render target.

Recommended archive fields:

```json
{
  "status": "paused_learning_case",
  "reason": "Pretty but semantically weak. Too abstract for first pilot. Visuals do not create immediate viewer pain or retention.",
  "do_not_continue": {
    "further_optimization": false,
    "rendering": false,
    "posting": false,
    "wan": false,
    "i2v": false,
    "platform_api": false
  }
}
```

Postmortem structure:

- Worked: approval gates, clean captions, delivery discipline, workflow/styleframe learning, technical I2V sanity where applicable.
- Failed: topic too abstract, no visible fail, too much production before validation, too many visual metaphors, AI video/image generation used too early as story carrier.
- New rule: `Pretty Empty Visual Blocker`.

## Pretty Empty Visual Blocker

Block a candidate or visual plan if:

- the image is high-quality but does not show a clear problem without voiceover
- no visible fail exists
- the visual is only mood/B-roll
- the viewer cannot tell within 1 second what is at stake
- usefulness only emerges through abstract explanation
- the scene is interchangeable with dozens of other AI/productivity videos

A visual plan must answer:

1. What is concretely broken?
2. Where can the viewer see the error?
3. What is at stake for the viewer?
4. Which simple rule repairs it?
5. Why would someone save or share this?

## ProofShortMode defaults

Proof Shorts are the default for the first 10–20 unvalidated videos.

- 25–35 seconds
- screen/mockup-led or real-problem-led
- no Wan final
- no I2V/T2V full render
- no premium styleframe pass
- no abstract metaphors
- no AI B-roll as main visual
- fast useful preview to validate topic/format
- manual approval before any posting pack

Premium episodes come only after the theme/format is proven by viewer response.

## Good first Proof Short shape

For digital safety/workflow/AI-mechanism content:

```text
visible fail → recognition → mechanism → simple check/rule → safe next action → memorable takeaway
```

Example topic class: fake invoice/payment-route red flag.

- Use controlled fictional mockups.
- Show invoice/email/payment route in the first frame.
- Avoid real brands, addresses, IBANs, QR codes, logos, and real people.
- Use renderer-owned UI text/highlights; do not use real scam templates.
- Keep claims as general safety advice, not legal/financial advice.

## Caption style

Keep the user's corrected style:

- static phrase segments
- active-word highlight
- white inactive words
- yellow active word
- no frame/box/full-width bar/dark subtitle block
- subtle shadow or outline only
- mobile-safe bottom position

## ReviewPackageV2 additions

For Proof Shorts include:

- `ProofShortMode = true`
- selected hook plus hook variants
- script
- visual plan
- Pretty Empty Visual Blocker result
- claim gate
- AI disclosure
- save/share/follow reasons
- platform fit
- preview MP4 path, SHA256, duration, resolution
- Telegram delivery status

## Hard blocks until approval

Do not run:

- Wan/I2V/T2V full render
- full-final render
- platform API
- auto-posting
- scheduling
- render series

Allowed next commands should be explicit, e.g.:

```text
APPROVED_PROOF_SHORT <candidate_id>
REVISE_PROOF_SHORT <candidate_id> <field> "Änderungswunsch"
REJECT_PROOF_SHORT <candidate_id> "Grund"
APPROVED_FOR_MANUAL_POSTING_PACK <candidate_id>
```


User correctly identified that the clean AI images are non-specific office/laptop mood shots; no calendar invitation is visibly present, so the first-frame problem is not self-evident.

images interchangeable with generic office/productivity content

story relies too much on subtitles/voiceover

AI-only image cuts must still show the concrete object of the story in frame 1. For this topic: an unmistakable calendar invite / join prompt must be visible, while readable/factual text remains controlled or deliberately blank.


Prompt: Premium vertical 9:16 social-video keyframe for a cybersecurity short. Close-up of a laptop on a desk showing a large obvious calendar invitation window shape and join/sign-in prompt layout, but all fields are blank or abstract blocks: no readable words, no letters, no numbers. The viewer should instantly understand 'calendar invite on screen' from layout alone. Modern cinematic lighting, navy/amber, high-end. No logos, no brands, no QR/barcodes, no people, no hands, no watermarks, no pseudo text.

Prompt: Premium vertical 9:16 cinematic image. A phone on a desk clearly displays a calendar invite card UI layout with a prominent blank join button shape, notification-card composition, no readable content. Make it unmistakably a calendar invitation while remaining text-free: no words, no letters, no numbers, no logos, no brand icons, no pseudo-writing. Dark navy office light, amber warning glow, no people/hands/faces, no QR/barcodes, no watermarks.

Prompt: Premium vertical 9:16 keyframe. Suspicious calendar invite visible on a laptop screen as a large blank calendar-card interface: title line represented by empty blocks, attendee dots, big blank button, link area as abstract blocks, all completely unreadable. Cinematic cybersecurity mood, dark desk, subtle red warning glow. No text, no letters, no numbers, no logos, no icons, no QR/barcodes, no people, no hands, no watermarks.


Prompt: Premium vertical 9:16 social-video keyframe for a cybersecurity short. Close-up of a laptop on a desk showing a large obvious calendar invitation window shape and join/sign-in prompt layout, but all fields are blank or abstract blocks: no readable words, no letters, no numbers. The viewer should instantly understand 'calendar invite on screen' from layout alone. Modern cinematic lighting, navy/amber, high-end. No logos, no brands, no QR/barcodes, no people, no hands, no watermarks, no pseudo text.


Prompt: Premium vertical 9:16 cinematic image. A phone on a desk clearly displays a calendar invite card UI layout with a prominent blank join button shape, notification-card composition, no readable content. Make it unmistakably a calendar invitation while remaining text-free: no words, no letters, no numbers, no logos, no brand icons, no pseudo-writing. Dark navy office light, amber warning glow, no people/hands/faces, no QR/barcodes, no watermarks.


Prompt: Premium vertical 9:16 keyframe. Suspicious calendar invite visible on a laptop screen as a large blank calendar-card interface: title line represented by empty blocks, attendee dots, big blank button, link area as abstract blocks, all completely unreadable. Cinematic cybersecurity mood, dark desk, subtle red warning glow. No text, no letters, no numbers, no logos, no icons, no QR/barcodes, no people, no hands, no watermarks.


from pathlib import Path
import shutil, json, hashlib
from PIL import Image, ImageDraw
srcs=['/home/agent/.hermes/cache/images/openai_codex_gpt-image-2-high_20260525_220055_8bc0aae4.png','/home/agent/.hermes/cache/images/openai_codex_gpt-image-2-high_20260525_220154_f24b5973.png','/home/agent/.hermes/cache/images/openai_codex_gpt-image-2-high_20260525_220245_13aae3e6.png']
base=Path('/tmp/autoshorts_proof_short_sprint31/calendar-invite-login-trap-30s/visible_invite_ai_keyframe_test_v1')
base.mkdir(parents=True, exist_ok=True)
items=[]
for i,s in enumerate(srcs,1):
    dst=base/f'visible_invite_ai_test_{i:02d}.png'; shutil.copy2(s,dst)
    im=Image.open(dst)
    items.append({'index':i,'path':str(dst),'sha256':hashlib.sha256(dst.read_bytes()).hexdigest(),'resolution':f'{im.width}x{im.height}'})
sheet=Image.new('RGB',(1080,560),(12,16,24)); d=ImageDraw.Draw(sheet)
for idx,item in enumerate(items):
    im=Image.open(item['path']).convert('RGB'); im.thumbnail((330,495))
    cell=Image.new('RGB',(360,560),(12,16,24)); cd=ImageDraw.Draw(cell)
    cell.paste(im,((360-im.width)//2,42)); cd.text((14,14),f"TEST {item['index']:02d}",fill=(247,202,76)); cd.text((14,525),item['resolution'],fill=(220,225,235))
    sheet.paste(cell,(idx*360,0)); d.rectangle((idx*360,0,idx*360+359,559),outline=(55,65,90),width=2)
contact=base/'visible_invite_ai_keyframe_test_contact_sheet_v1.jpg'; sheet.save(contact,quality=92)
(base/'manifest_visible_invite_ai_keyframe_test_v1.json').write_text(json.dumps({'keyframes':items,'contact_sheet':str(contact),'purpose':'Test whether AI-only can visibly show a calendar invite without renderer overlays or readable text.'},indent=2),encoding='utf-8')
print(contact)


Question: Assess these three generated 'visible calendar invite but no overlay' AI keyframe tests. Are they actually recognizable as a calendar invite/login prompt? Do they contain pseudo-text/readable text/logos/QR/people/hands? Which, if any, are safe/useful?


Image loaded into your context — you can see it natively now. Use your built-in vision to answer the user.

Question: Assess these three generated 'visible calendar invite but no overlay' AI keyframe tests. Are they actually recognizable as a calendar invite/login prompt? Do they contain pseudo-text/readable text/logos/QR/people/hands? Which, if any, are safe/useful?


Ja — **korrekt beobachtet**. Der Clean AI Cut ist damit als Variante **durchgefallen**.

Ich habe ihn als Semantic-Failure dokumentiert:

```text
/tmp/autoshorts_proof_short_sprint31/calendar-invite-login-trap-30s/clean_ai_cut_v1/rejection_audit_semantic_failure.json
```

Grund:

```text
Pretty Empty Visual Blocker
```

Heisst konkret:

- schöne Bilder
- guter Mood
- aber keine sichtbare Termineinladung
- kein sichtbarer Login-Fail
- austauschbar mit jedem “Büro/Laptop/Productivity”-Video
- Story hängt fast komplett an Voiceover/Subtitles

Das ist exakt das Problem, das wir vermeiden wollten. Sehr hübsch, sehr leer. Die teuerste Form von Nichts, gewissermassen.

## Ich habe direkt einen kleinen Gegen-Test gemacht

Ich habe 3 neue KI-Keyframes erzeugt mit der Vorgabe:

```text
Kalendereinladung muss sichtbar sein,
aber ohne lesbaren Text,
ohne Overlays,
ohne Logos,
ohne echte Daten.
```

MEDIA:/tmp/autoshorts_proof_short_sprint31/calendar-invite-login-trap-30s/visible_invite_ai_keyframe_test_v1/visible_invite_ai_keyframe_test_contact_sheet_v1.jpg

## Ergebnis des Gegen-Tests

### TEST 01

**Besser.**

- Laptop mit klarer Kalender-/Invite-Card
- visuell am ehesten “Termineinladung”
- aber: AI erzeugt UI-Elemente selbst
- Risiko: sieht wie Fake-App-Interface aus

### TEST 02

**Auch besser.**

- Phone mit Kalenderkarte
- visuell sofort näher am Thema
- aber ebenfalls AI-baked UI/Icon-Elemente

### TEST 03

**Nicht geeignet.**

- wirkt eher wie generisches Login-/Security-Panel
- keine klare Termineinladung
- wieder zu abstrakt

## Wichtige Erkenntnis

Ein reiner “nur KI-Bilder, keine Overlays”-Ansatz hat ein strukturelles Problem:

```text
Wenn die KI keine UI zeigen darf, wird es nichtssagend.
Wenn die KI UI zeigen soll, verlieren wir Kontrolle über Genauigkeit, Text, Icons und Semantik.
```

Also: **AI-only ist für dieses Thema nicht zuverlässig genug.**

## Beste nächste Richtung

Nicht:

```text
100% Clean AI Image Cut
```

Sondern:

```text
Premium AI Background / Realistic Scene
+ eine sehr reduzierte deterministische Calendar Invite Card
+ Subtitles
```

Also eher:

```text
90% Premium KI-Bild
10% kontrollierte Semantik
```

Aber diese 10% müssen sichtbar sein:

- eine klare Calendar Invite Card
- ein Join/Login Button
- eine “link/domain changed”-Andeutung
- keine Checklisten-Orgie
- keine PowerPoint-Boxen
- keine Pfeil-/Label-Flut

## Mein Urteil

Die aktuelle Hybrid-Version war zu erklärgrafisch.
Der Clean Cut ist zu leer.
Der richtige Stil liegt dazwischen:

```text
Clean cinematic images
+ one controlled visible invite mechanism
```

Damit erreichen wir:

- Premium Look
- aber trotzdem sofort verständlich
- keine AI-Fake-UI als Wahrheitsquelle
- keine nichtssagenden Laptop-B-Rolls

Kurz: **Wir brauchen sichtbare Semantik, aber brutal reduziert.**


[M G] Ich finde es schon besser, schon besser als leere bildschirme. Wie fahren wir weiter? Wie optimieren wir?


Ja — dann ist die Richtung klarer:

```text
Nicht “AI-only ohne UI”.
Sondern “AI-generierte sichtbare Situation + kontrollierte semantische Korrektur”.
```

Die neuen Tests sind besser, weil der Viewer zumindest sofort erkennt:

```text
Da ist eine Einladung / ein Join-Kontext / ein Login-Moment.
```

Das ist bereits wertvoller als hübsche leere Laptops. Aber wir müssen jetzt kontrolliert optimieren, sonst landen wir bei AI-Fake-UI mit hübschem Quatsch. Also: nicht zurück zum Büro-Tisch-Nichts, aber auch nicht blind der KI die UI-Wahrheit überlassen.

## Meine Empfehlung: nächster Schritt

Wir bauen eine **Style Direction v2: Visible Invite Cinematic**.

Ziel:

```text
Premium KI-Bild zeigt die Situation.
Renderer korrigiert nur minimal die Wahrheit.
```

Nicht mehr grosse Explainer-Karten. Nicht mehr volle Mockup-UI. Sondern ein **minimaler kontrollierter Semantik-Layer**.

## Optimierungsstrategie

### 1. Bestes Motiv wählen

Aus dem Gegen-Test:

- **Test 01:** beste Laptop-/Invite-Situation
- **Test 02:** beste Phone-/Invite-Situation
- **Test 03:** verwerfen, zu generisch/security-panel-artig

Ich würde mit **Test 01 + Test 02** weiterarbeiten.

## 2. KI-Keyframes gezielter erzeugen

Nicht mehr “Büro mit Laptop”, sondern konkrete Shots:

### Shot A — visible invite

```text
A realistic laptop/phone shows a large calendar invite card.
No readable text.
The card layout is obvious: title area, time area, attendee dots, large join button.
Premium cinematic desk scene.
```

### Shot B — suspicious button

```text
Same invite card, but the join button glow feels slightly risky.
No readable text.
No logos.
No fake app names.
```

### Shot C — close invite

```text
The invite is visually de-emphasized / screen dimmed / user has stepped away.
No hands needed.
```

### Shot D — trusted path

```text
A calmer device/app context, same desk, less warning color.
Still no readable UI.
```

### Shot E — final safety

```text
Calm resolution shot, device at rest, warm light.
```

Das ergibt eine Story, ohne wieder PowerPoint zu werden.

## 3. Minimaler deterministic overlay — aber nur wo nötig

Hier ist der entscheidende Punkt.

Ich würde **nicht** wieder volle UI bauen.
Aber ich würde einen winzigen renderer-owned Layer zulassen:

```text
1. blank invite card outline / highlight
2. optional tiny controlled button shape
3. optional suspicious link underline, aber ohne echte Domain
```

Oder noch minimalistischer:

```text
Nur ein subtiler gelber Fokusrahmen auf der Invite Card.
```

Keine Labels wie “Link domain”.
Keine Checklist Cards.
Keine Pfeile.
Keine dicken Boxen.

## 4. Zwei Varianten rendern

Ich würde jetzt nicht raten. Ich würde testen.

### Variant B1 — AI-visible invite only

```text
AI images mit sichtbarer Invite-Situation
+ Voiceover
+ Subtitles
+ keine zusätzlichen Grafiken
```

Ziel:

```text
Prüfen, ob bessere KI-Keyframes allein reichen.
```

### Variant B2 — AI-visible invite + minimal semantic correction

```text
AI images
+ Voiceover
+ Subtitles
+ maximal 1–2 subtile deterministic UI-Fokusmomente
```

Ziel:

```text
Prüfen, ob minimaler Kontroll-Layer die Verständlichkeit stark erhöht,
ohne den Premium-Look zu zerstören.
```

Dann vergleichen wir:

```text
B1: schöner / weniger didaktisch
B2: verständlicher / immer noch premium
```

Meine Vermutung:

```text
B2 gewinnt.
```

## 5. Was wir vermeiden müssen

- keine generischen Büro-/Laptopbilder mehr
- keine leeren Screens mehr
- keine AI-Bilder ohne sichtbaren Story-Gegenstand
- keine KI-generierten lesbaren UI-Texte
- keine Logos / Brand-Icons
- keine QR-Codes
- keine PowerPoint-Checklisten
- keine dicken Domain-Karten
- keine “technical explainer board”-Ästhetik

## Konkreter nächster Produktionsschritt

Ich würde als Nächstes machen:

```text
calendar-invite-login-trap-30s
v1.3.0-visible-invite-cinematic-ab
```

Output:

1. **6 neue, konkrete Visible-Invite-Keyframes**
2. **Contact Sheet**
3. **Variant B1 MP4:** AI-visible invite only + subtitles
4. **Variant B2 MP4:** AI-visible invite + minimal focus layer + subtitles
5. **A/B Review Sheet**
6. Empfehlung: B1/B2/Hybrid weiterentwickeln

## Entscheidungsregel

Wir nehmen die Version, die diese 3 Dinge am besten erfüllt:

```text
1. In Sekunde 1 sichtbar: Es geht um eine Termineinladung.
2. In Sekunde 5 verständlich: Der Login/Join Button ist der riskante Moment.
3. Am Ende klar: Schliess die Einladung, öffne den Kalender selbst.
```

Wenn B1 das schafft: wunderbar, dann bleiben wir clean.
Wenn B2 das schafft und B1 nicht: minimaler Overlay ist erlaubt.
Wenn beide scheitern: zurück zur Hybrid-Version, aber visuell stark entschlackt.

## Meine Empfehlung

Weiter mit:

```text
B1 + B2 A/B Test
```

Das ist jetzt der sauberste nächste Schritt.
Wir haben gelernt:

```text
Leere KI-Bilder = zu generisch.
Volle Mockups = zu erklärgrafisch.
Sichtbare KI-Invite-Szene + minimale Kontrolle = wahrscheinlich Sweet Spot.
```