@officexapp/vidfarm-devcli 0.21.58 → 0.21.60

package/experimental/meme-recaption.md

@@ -28,6 +28,15 @@ checks:
     - learn more
     # the bait lives in the POST caption, never on the meme:
     - comment below
+    # Rule 10 — context debt. Each of these is an admission that the caption needs
+    # something the viewer does not have on the frame. See "The four contexts a
+    # viewer does not have". Banned here as literal substrings so gate 1 catches
+    # them before a render exists:
+    - iykyk
+    - if you know you know
+    - you already know
+    - as promised
+    - part 2
 ---
 
 # Meme Recaption
@@ -45,7 +54,7 @@ Two ingredients, no more:
 
 | Ingredient | What it is | Where it comes from |
 |---|---|---|
-| 🎬 **The meme** | A borrowed clip everyone already half-recognises, doing one absurd physical thing | `vidfarm.cc/explore` → public raws, `sourceType: MemeScreens` (851 of them, once you page past what the CLI shows you) |
+| 🎬 **The meme** | A borrowed clip everyone already half-recognises, doing one absurd physical thing | `vidfarm.cc/explore` → public raws, `sourceType: MemeScreens` (851 of them — reached with `vector_q`, **not** with the CLI, which shows you 200 and does not say so) |
 | ✍️ **The caption** | One sentence naming a specific lived experience, in the second person or the first | You. This is the only original work in the video, and it is 90% of the outcome |
 
 **The offer is named on the video.** First choice: inside the caption, as a character in the setup
@@ -63,14 +72,54 @@ Three questions. **All three must be yes** or you have not got a meme recaption
 
 | # | Question | If no |
 |---|---|---|
-| 1 | **Standalone** — Show it to someone who has never heard of the offer. Do they laugh? | You wrote an ad with a meme stapled on |
+| 1 | **Standalone** — Show it to someone who has never heard of the offer, and who did not see your last post, and who has never seen the source meme. Do they laugh? | You wrote something that needs a briefing. See Rule 10 |
 | 2 | **Problem space** — Is the experience it names one the product actually removes? | You wrote a meme. Funny, worthless. Post it from a personal account |
-| 3 | **Enactment** — Is the meme's *physical action* the literal body of the feeling the caption names? | You wrote a caption over stock footage |
+| 3 | **Enactment** — Does the clip *enact* the caption — same situation, told twice, once in a body and once in words? Run the two covers below. **Not "does it suit the vibe"** | You wrote a caption over stock footage. See Rule 3 |
 
-Test 3 is the one editors skip, and it is the one that separates a meme that lands from a caption
-sitting on top of a clip. The meme is not an illustration of the caption. **The meme is what the
-caption's subject is doing with their body.** If the caption says "quietly giving up" and the clip
-is someone dancing, the joke has no floor, and no amount of caption polish will give it one.
+> **Amended.** Test 3 used to read *"is the meme's physical action the literal body of the feeling
+> the caption names?"* That is still what it means, but it was a single look, and a single look
+> cannot fail — see the read-order paragraph below. It is now two covers and a comparison, and the
+> word *literal* has been pinned down: **literal about the VERB, never about the NOUNS.** A caption
+> about 10 tabs enacted by someone staring at 10 tabs is a stock photo, not a meme.
+
+### The two-cover test — the enactment test, made testable
+
+You cannot check a match by looking at the finished frame, because by the time you look at it you
+already know the answer. So you take the two channels apart, describe each one **cold and in
+writing**, and then compare the two sentences you wrote — not the video.
+
+| Step | What you do | What you write down | If it fails |
+|---|---|---|---|
+| **Cover the caption** | Watch the clip alone, muted, with the caption hidden | `clip_reads_blind:` one sentence — what is happening to that person, named by a stranger | The clip is a mood, not an action. **Recast.** No caption rescues a clip that does nothing |
+| **Cover the visual** | Read the caption alone, cold, with no clip at all | `caption_reads_blind:` one sentence — the situation a stranger holds after one read | The caption is a stage direction waiting for a picture. **Rewrite.** The caption must already be a complete joke |
+| **Uncover both** | Read your two sentences side by side | — | **They are two different situations.** This is the defect. Change one of them |
+
+Both sentences go in the composition, in the enactment declaration, and gate 2 reads them. See
+"Declare the enactment" under Casting.
+
+#### The failure mode, and why it is invisible to you
+
+The defect this catches has a name: **vibe-adjacency** — a clip that is emotionally *compatible*
+with the caption without being the same event. A caption about quietly giving up, over a clip of
+someone rolling their eyes: both are "annoyed", both are the right *temperature*, and neither is
+the other one. It is the most common ship-blocking defect in this format, and it is the one the
+author is structurally unable to see.
+
+*(Its opposite twin is worth naming here too: a clip that is the same event and also the same
+picture — the caption about 10 tabs over someone glaring at 10 tabs. That one is not adjacent, it
+is redundant, and it is Rule 3.3. Both are failures of the same knob, turned the two different
+ways.)*
+
+> **The reason is read order.** You wrote the caption first. So you approach the clip already
+> holding the situation in your head, and you see the clip *as* that situation. Any clip that does
+> not actively contradict the caption looks like a perfect match to you, and only to you. The
+> viewer has no such pre-load: they get 1.2 seconds and two channels, and if the channels are only
+> adjacent, the recognition never fires. They do not think "that's a mismatch" — they feel nothing
+> and keep scrolling, which is why this defect never shows up as a complaint, only as a flat
+> number.
+
+That is why the test is written as two covers and a comparison rather than as one look. The two
+covers force you to meet each channel without the other one loading the answer for you.
 
 ---
 
@@ -265,11 +314,111 @@ feel specific when you write them, and only one survives being read by a strange
 > This test is also **elegance-test question 5** (Rule 1). It is listed twice on purpose: it decides
 > whether the caption works at all, *and* whether the offer can be named inside it.
 
+### The four contexts a viewer does not have
+
+The cold-viewer test above covers **one** source of missing context — the product. There are three
+more, and they kill a caption just as dead. The rule underneath all four is Rule 10:
+
+> **Every word the caption needs must already be on the frame or already in the viewer's life.
+> Nothing may be borrowed from off-screen.**
+
+| # | The context they do not have | What it looks like when you lean on it | Why it is fatal |
+|---|---|---|---|
+| 1 | **The product** | brand names, feature words, category jargon, the founder's demo | Lands only on people who already bought — which defeats a meme ad. *(the existing cold-viewer test)* |
+| 2 | **Your previous post** | `part 2`, `as promised`, `like i said`, a callback to another video | The platform serves this video cold, on purpose. Most people who see video 2 never saw video 1, and the ones who did are the ones you already have |
+| 3 | **The source meme's own lore** | `for 47 seconds`, `and my day is ruined`, naming the character, riffing on what the meme originally meant | Caps your reach at **the meme's fandom**, which is not your niche. The clip is borrowed *equipment*, not a shared reference. Checked by `caption_does_not_borrow_lore` |
+| 4 | **Your own life** | a detail only you can verify — the specific street, the specific colleague, the actual date | This is **rung 4** on the ladder above, arriving by a different road. It is your story, not theirs |
+
+**And the phrase that admits all four at once: `iykyk`.** *"If you know, you know"* is a caption
+telling you it did not do its job, while explicitly excluding everyone you needed to reach. It is
+banned in the front matter, so gate 1 stops it before a render exists.
+
+**The mechanical version:** hand the caption, as plain text, to someone who has seen none of your
+posts, does not know the product, and has never seen the clip. If they need one question answered
+before they get it, the caption is not finished. **A cold viewer with zero setup gets it, or it
+does not ship.**
+
 **Get the specifics from the customer, not from your imagination.** Their testimonials, their
 support inbox and their landing-page copy are full of rung-3 sentences written by actual users. In
 the worked example in Appendix D, the shipped caption is a lightly compressed version of a
 testimonial printed on the customer's own homepage — which also happens to satisfy Rule 6.
 
+### Strictness vs relatability — the two rules above do NOT mean "play it safe"
+
+Read Rule 3 and Rule 10 naively and you get this:
+
+> ❌ `me when my code doesn't work`
+
+It passes both. It is enacted by literally any frowning clip. It needs no context at all. It is
+also completely dead, and if this file let you ship it, the file would be worse than useless. So
+this section is not optional colour — it is the half of the format the strict rules do not carry.
+
+**The diagnosis:** that caption is standalone *because* it is universal, and universal is the same
+thing as unfelt. The ladder already says so at rung 1: *"true of everyone, felt by no one."*
+Tightening for context and tightening for specificity feel like the same move — they are opposites.
+
+#### The one distinction that resolves it: context vs detail
+
+> **Context is what the viewer must be TOLD. Detail is what the viewer already HAS.
+> Rule 10 turns context to zero. The ladder turns detail as high as it goes. They are two dials.**
+
+A safe, dead caption is what you get by turning both down at once — which is the default mistake,
+because at 2am both feel like "things I'm assuming the reader knows".
+
+**The test that separates them, one question per specific in your caption:**
+
+> **Who had to have been there?**
+
+| The specific | Who had to have been there | Verdict |
+|---|---|---|
+| `10 tabs` | anyone who has ever tried to pick dinner | **Detail.** Keep it. Add more |
+| `since 7pm` | anyone with an evening | **Detail** |
+| `one scallop roll` | anyone who has wanted one exact thing | **Detail** — and it is the best word in the caption |
+| `the v2 sync` | someone who bought the product | **Context.** Cut |
+| `part 2` | someone who saw your last post | **Context.** Cut |
+| `for 47 seconds` | someone who has seen the source meme | **Context.** Cut |
+| `that place on ludlow` | you | **Context.** Cut — this is rung 4 |
+
+Detail is *shared* and specific. Context is *private* and specific. They look identical while you
+are typing, which is exactly why you write the question down and answer it per word.
+
+#### Strictness makes the caption MORE relatable, in two mechanical ways
+
+Not as a consolation. As arithmetic:
+
+1. **The word budget.** A caption is 8–20 words and it spends every one of them on either context
+   or detail. Every word you win back by cutting context is a word you can spend on detail —
+   **so spend it.** Cutting `on resy` and not replacing it leaves a weaker caption; cutting it and
+   buying `since 7pm` leaves a stronger one. **Deleting context without re-spending the refund is
+   how a correct edit produces a worse video**, and it is the most common way this section gets
+   misread.
+2. **The cover-the-caption step will not accept a flat line.** You have to write down, in one
+   sentence, the situation a stranger holds after reading the caption cold. *"A person is sad"* is
+   not a situation and will not survive being compared to a clip's blind read — the two sentences
+   have nothing to agree on. **The test that looks like it would flatten the caption is the test
+   that refuses a flat one.**
+
+#### And the same distinction on the visual side
+
+> **Enactment is about the VERB, not the WORLD. The verb must match; the world must not.**
+
+- The clip must **do** the caption's verb — deflate, blank, loop, stare.
+- The clip must **not depict** the caption's nouns. Ten tabs, a laptop, a restaurant, a
+  spreadsheet: if the clip shows the thing the caption is about, you have filmed a re-enactment,
+  and a re-enactment is a stock photo with a joke written under it.
+
+The comedy lives in the gap between where the feeling came from (10 tabs at 7pm) and the body it
+arrives in (a hungover dog). That gap is the same one "Match the INTENSITY" is talking about, and
+it is why `caption_does_not_borrow_lore` fails a caption that reuses a word from the clip's slug:
+a caption that names what the clip literally *is* has closed the gap.
+
+#### If you cut the context and the caption goes generic
+
+Then you never had a caption — you had a reference. **Go back to Rule 6.** A sentence a real user
+actually said is reliably both context-free and specific, because they said it to a stranger who
+also had none of the context. That is why testimonials outperform anything you would invent, and
+it is the cheapest route out of a caption that got safe.
+
 ### Banned captions
 
 - **The product as the thing that WORKS.** The name may appear as a subject in the setup (Rule 1,
@@ -283,58 +432,262 @@ testimonial printed on the customer's own homepage — which also happens to sat
 - Two-part setups split across a cut. That is a different format and it is weaker.
 - Anything naming a real competitor doing something bad. Personify a *category* ("every delivery
   app"), not a company you can be sued by.
+- **Anything with context debt** (Rule 10): `iykyk`, `if you know you know`, `you already know`,
+  `part 2`, `as promised`, `like i said`, `see my last`. Each one asks the viewer for something
+  they do not have. Banned in the front matter and checked by `caption_no_context_debt`.
+- **Anything riffing on the source meme's own lore.** The clip is borrowed equipment, not a shared
+  reference. If the caption only works for people who recognise the meme, its ceiling is that
+  meme's fandom. Checked by `caption_does_not_borrow_lore`.
+- **Anything that narrates the clip.** `me quietly giving up` over a clip of someone quietly giving
+  up is a subtitle, not a joke — the caption's job is to supply the *situation* the body is
+  reacting to, and a clip that already contains the situation leaves it nothing to do.
 
 ---
 
 ## Casting the meme
 
-### Browse the shelf. Do not search it.
+### Two channels: the slug is the IDENTITY, the vector is the BODY
+
+The shelf answers two completely different questions and it answers them through two different
+fields. Casting badly is almost always the result of asking one of them the other's question.
+
+| You want to know | Ask | Why |
+|---|---|---|
+| **which meme is this** | the `slugId` | The AI descriptions are blind to the meme's identity — see the warning below |
+| **what does the body DO** | `vector_q`, semantic search | The embedding is built from the description **plus the action / emotion / motion / subject tags**, which is exactly the verb axis this format casts on |
 
 > ⚠️ **The descriptions on this shelf were written by a model that has never heard of the meme.**
-> This is not a small problem — it is the defining fact of sourcing this format.
->
 > `my-brain-every-10-seconds` is described as *"A man in a suit gestures and looks at the camera
 > with a neutral expression."* `jonah-jameson-laugh-you-serious` is described as *"A solid green
-> screen background."* A semantic query for `hungry food eating` returns **zero results** on a shelf
-> that contains a dozen clips of people eating.
+> screen background."*
 >
-> **The `slugId` is the index. The description is noise.** Pull the whole shelf as JSON, read the
-> slugs, and only look at descriptions to break a tie.
+> **The `slugId` is the index of identity. The description is noise about identity.** But that same
+> description says *what the body is doing*, and **that is the only thing this format casts on.** A
+> model that does not know it is looking at J. Jonah Jameson can still tell you the man is laughing
+> in your face — so the descriptions are worthless for the question you were not going to ask and
+> useful for the one you were.
+
+#### 🚨 `--query` is LEXICAL. Semantic search is a different parameter, and the CLI has no flag for it
+
+This is the single most expensive mistake in sourcing this format, and an earlier draft of this file
+made it and drew the wrong conclusion from it.
+
+`vidfarm public-raws --query "…"` sends `?q=`, and `q` is a **substring filter that runs first**. It
+throws away every clip whose text does not literally contain your words, and only *then* does the
+server rank whatever survived. On a shelf whose descriptions never use your vocabulary, the filter
+empties the set before the ranking gets to see it — so a perfectly good semantic query returns
+nothing, and it looks like semantic search is broken. It is not. It never ran.
 
 ```bash
-vidfarm public-raws --categories                       # the shelves + live counts
-vidfarm public-raws --category greenscreen --limit 200 # 193 of these 200 are MemeScreens
-                                                       # ...and this is only the FIRST 200. See below
-vidfarm public-raws --category text-graphics --limit 200
-vidfarm public-raws --category lifestyle --limit 200   # also almost entirely MemeScreens
+# ❌ lexical filter. Measured: 0 results, on a shelf full of blank stares
+vidfarm api GET "/api/v1/public-raws?category=greenscreen&limit=8&q=blank%20stare%20confused"
+
+# ✅ semantic. Same shelf, same words, ranked by MEANING
+vidfarm api GET "/api/v1/public-raws?category=greenscreen&limit=8&vector_q=blank%20stare%20confused%20no%20comprehension"
+#   cat-staring · mrbean-wtf-greenscreen · james-franco-shocked · spongebob-panting …
 ```
 
+> **Pass `vector_q` and do NOT pass `q`.** The server defaults `vector_q` to `q` when you omit it,
+> which means the CLI's `--query` gets you the lexical filter *and* the ranking — and the filter has
+> already deleted the answer. Sending only `vector_q` skips the filter and ranks the whole shelf.
+>
+> **`vidfarm public-raws` cannot do this.** It maps `--query` to `q` and has no vector flag. Every
+> semantic cast in this file goes through `vidfarm api GET`.
+
+**It needs a login and an embedding key, and it fails SILENTLY without one.** The ranking requires a
+logged-in customer with a saved gemini or openai provider key. With no key — or logged out — the
+server skips the ranking, returns **HTTP 200 with a full page of results**, and says nothing. You
+get the shelf in recency order wearing the costume of a search result.
+
+```bash
+vidfarm whoami                       # must show a login
+vidfarm api GET /api/v1/user/me/provider-keys | grep -iE "gemini|openai"
+```
+
+**Confirm the ranking is live before you trust a cast:** query `arms up jumping celebration confetti`
+and query `shoulders drop giving up defeated sigh`. If the top result is the same clip for both, the
+embedder is not running and you are reading a recency list.
+
+#### Semantic search reaches the whole shelf. The CLI reaches a quarter of it
+
 > 🚨 **`vidfarm public-raws` shows you 200 clips and stops, and it does not tell you.** The server
 > caps a shelf at 200 per call and returns a `next_cursor` — but the CLI has **no `--cursor` flag**,
-> so raising `--limit` to 1200 still returns exactly 200. Paging the same shelves through
-> `vidfarm api GET` instead turns **200 clips into 959** (851 of them MemeScreens). Cast from the
-> first 200 and you are picking from under a quarter of the library, with nothing anywhere saying so.
->
-> **Build the full index once (Appendix C) and cast from the TSV, not from the CLI.**
+> so raising `--limit` to 1200 still returns exactly 200.
+
+`vector_q` on a **curated shelf** (`greenscreen`, `reaction`, `lifestyle`, `text-graphics`, …) is
+not a rerank of that 200. The server scans **1500 records** for a curated category and ranks all of
+them, so one call sees essentially the entire MemeScreens library and hands you its top N.
+
+Measured on the `greenscreen` shelf, ten verb queries against one plain `--limit 200` page:
+
+| | |
+|---|---|
+| Distinct clips the ten queries returned | **143** |
+| Of those, **not present** in the CLI's first 200 | **93 — 65%** |
+| Of those, hallucinated / not really on the shelf | **0.** All 143 verified against the fully-paged 693 |
+
+**Two thirds of what semantic search finds is invisible to the CLI**, and the two thirds it hides
+are not the boring ones — they are the animal and anonymous clips (`cat-staring`, `cat-sleeping`,
+`hangover-dog`) that are 🟢 **safe tier**, which is the tier client work is supposed to default to.
+Casting from the first 200 quietly pushes you toward the celebrity clips you are not allowed to use.
+
+```bash
+vidfarm public-raws --categories                       # the shelves + live counts. Start here
+vidfarm public-raws --category greenscreen --limit 200 # the first 200 only — for a browse, not a cast
+```
 
 **Every shelf the CLI exposes is dominated by MemeScreens** — `b-roll`, `lifestyle` and
 `text-graphics` all come back as greenscreen memes. Good news for this format, bad news for
 backgrounds (see below).
 
+### The diversity sweep — one query per verb, then dedupe
+
+> **A single vector query is a relevance tool. It is the OPPOSITE of a diversity tool.** It returns
+> the twenty clips nearest one point, and near-neighbours are near-duplicates: four `cat-sitting`
+> variants of the same cat. Cast ten videos off one query and you will ship ten videos that look
+> like one video.
+
+Diversity comes from **querying ten different points and taking the union.** The ten points are
+already written down — they are the ten verb tokens in the table below, which is why the list is
+closed. One query per verb, top 20 each, deduped, is a 143-clip casting pool spread across the whole
+shelf by meaning instead of by upload date.
+
+```python
+#!/usr/bin/env python3
+"""meme-sweep.py — one vector query per verb token -> a deduped casting pool.
+
+Needs a vidfarm login + a saved gemini/openai key, or the ranking silently
+does not happen (see above). Run it once per session; it is ~10 API calls.
+"""
+import json, subprocess, urllib.parse
+
+VERBS = {
+    "deflate":    "shoulders drop eyes go flat accepting a bad outcome without a fight",
+    "blank":      "total non-comprehension head tilt dead eyes nothing processing",
+    "loop":       "the same thought going round again mechanically forever repetitive",
+    "smug":       "arms folded self-satisfied already solved it insufferable",
+    "overreact":  "full body screaming sobbing flailing at something trivial",
+    "correct":    "turning to camera to tell you patiently that you are wrong",
+    "unbothered": "completely relaxed doing nothing while chaos happens calm",
+    "celebrate":  "arms up jumping celebration confetti scale joy",
+    "stare":      "holding eye contact with the camera saying nothing silent",
+    "wait":       "still waiting visibly longer than is reasonable impatient",
+}
+SHELVES = ("greenscreen", "reaction", "lifestyle", "text-graphics")
+
+def get(path):
+    out = subprocess.run(["vidfarm", "api", "GET", path], capture_output=True, text=True).stdout
+    brace = out.find("{")           # first line is a coloured "GET … → 200" status line
+    return json.JSONDecoder().raw_decode(out[brace:])[0] if brace >= 0 else {}
+
+pool, tops = {}, {}
+for shelf in SHELVES:
+    for verb, q in VERBS.items():
+        d = get(f"/api/v1/public-raws?category={shelf}&limit=20"
+                f"&vector_q={urllib.parse.quote(q)}")          # vector_q ONLY. Never q
+        raws = d.get("raws", [])
+        if raws:
+            tops.setdefault(shelf, []).append(raws[0]["rawId"])
+        for rank, raw in enumerate(raws):
+            slug = raw.get("slugId") or raw["rawId"]
+            pool.setdefault(slug, {"verb": verb, "rank": rank, "id": raw["rawId"],
+                                   "desc": (raw.get("description") or "")[:90]})
+
+# The ranking fails SILENTLY (no login / no embedding key) and still returns a
+# full page. The only reliable tell is differential: ten different queries that
+# rank must not all return the same clip first. Do NOT test this by looking for
+# a slugId — several shelves legitimately return bare UUIDs.
+for shelf, first in tops.items():
+    if len(set(first)) < len(first) / 2:
+        raise SystemExit(f"{shelf}: {len(set(first))} distinct top hits from {len(first)} queries — "
+                         "the embedder is not running. Check `vidfarm whoami` and your gemini/openai key.")
+
+with open("casting-pool.tsv", "w") as f:
+    f.write("slug\tverb\trank\trawId\tdescription\n")
+    for slug, v in sorted(pool.items(), key=lambda kv: (kv[1]["verb"], kv[1]["rank"])):
+        f.write(f"{slug}\t{v['verb']}\t{v['rank']}\t{v['id']}\t{v['desc']}\n")
+print(len(pool), "distinct clips -> casting-pool.tsv")
+```
+
+**Then cast off the TSV, and cast off a verb you have not shipped this week:**
+
+```bash
+awk -F'\t' '$2=="unbothered"' casting-pool.tsv | cut -f1,5    # the whole neighbourhood, one verb
+cut -f2 casting-pool.tsv | sort | uniq -c                     # how deep each verb actually goes
+```
+
+**Three rules for keeping the pool diverse, all of them cheap:**
+
+1. **Drop the near-duplicate families.** `cat-sitting-5e58…` and `cat-sitting-8edd…` are one casting
+   choice, not two. Collapse on the slug stem (the slug minus its trailing hex) before you count
+   your options, or you will believe you have 143 and be choosing among about 110.
+2. **Take the top ~20 per verb, never the top 60 of one.** The tail of one query is further from
+   that verb than the head of the next query is — depth on one point buys worse clips, breadth
+   across points buys better ones.
+3. **Subtract the delivery log before you look, not after.** `join` the pool against
+   `DELIVERED.tsv` so a retired clip is never on the sheet you are choosing from. A clip you have
+   already sent is not an option you rejected, it is an option you should not have seen.
+
+```bash
+cut -f5 CLIPPER/DELIVERED.tsv | sort -u > /tmp/used.txt
+grep -vFf /tmp/used.txt casting-pool.tsv > casting-pool.fresh.tsv   # cast from THIS
+```
+
+> **The sweep is how "there was nothing else" stops being sayable.** Rule 11 asks you not to reuse a
+> clip you have already delivered; the honest objection has always been that finding a fresh one
+> meant paging a 693-clip shelf by hand. It is now ten API calls and a TSV.
+
+> **Delivery work: open your delivery log in the same breath as the sweep.** Anything you already
+> sent this client is out (Rule 11), and anything that has been passed on twice is out for everybody.
+> **A clip you have already used is not a shortcut, it is the shelf you did not read** — and the
+> sweep hands you 143 candidates, so "there was nothing else" is almost never the real reason.
+>
+> ```bash
+> cut -f1,5,8 CLIPPER/DELIVERED.tsv    # client · clip · verdict — read it BEFORE the contact sheet
+> ```
+>
+> Reusing a clip that has *earned* it, on a different client, is correct and encouraged. See
+> *Across clients* under Rule 11.
+
 ### The enactment test, in practice
 
 You are casting for a **verb**, not a mood. Write down the verb your caption's subject is doing
-with their body, then find the slug that does that verb:
+with their body, then find the slug that does that verb.
 
-| The caption's verb | Slugs that enact it |
-|---|---|
-| deflating / accepting a bad outcome | `my-disappointment-is-immeasurable-and-my-day-is-ruined`, `jonah-hill-sigh`, `girl-eyerolls` |
-| not understanding at all | `huh-cat`, `hangover-dog`, `zoolander-staring`, `nervous` |
-| the same thought on a loop | `my-brain-every-10-seconds`, `monkey-cymbal-jolly-chimp`, `zoning-out` |
-| smug, having solved it | `gigachad`, `chad-head-bopping`, `check-out-the-big-brain-on-brad` |
-| overreacting to something tiny | `neon-screaming`, `jontron-nooooooo`, `girl-fake-crying` |
-| telling you you're wrong | `jonathan-frakes-telling-you-youre-wrong-for-47-seconds`, `women-mocking` |
-| unbothered while it burns | `my-favorite-thing-in-the-world-to-do-is-nothing`, `boss-baby-chilling` |
+**The verb comes from a closed list of ten tokens.** Not because ten is the number of human
+feelings, but because a free-text verb is not comparable to anything — and the whole point of the
+enactment test is a comparison. A closed token makes "does the clip do what the caption does" a
+string equality instead of a judgement, which is the only form of it a gate can enforce:
+
+| Verb token | The body doing it | Slugs that enact it |
+|---|---|---|
+| `deflate` | shoulders drop, eyes go flat, the bad outcome is accepted without a fight | `my-disappointment-is-immeasurable-and-my-day-is-ruined`, `jonah-hill-sigh`, `girl-eyerolls` |
+| `blank` | total non-comprehension — head tilt, dead eyes, nothing processing | `huh-cat`, `hangover-dog`, `zoolander-staring`, `nervous` |
+| `loop` | the same thought going round again, mechanically, forever | `my-brain-every-10-seconds`, `monkey-cymbal-jolly-chimp`, `zoning-out` |
+| `smug` | arms folded, already solved it, insufferable about it | `gigachad`, `chad-head-bopping`, `check-out-the-big-brain-on-brad` |
+| `overreact` | a full-body scream, sob or flail at something trivial | `neon-screaming`, `jontron-nooooooo`, `girl-fake-crying` |
+| `correct` | turning to camera to tell you, patiently, that you are wrong | `jonathan-frakes-telling-you-youre-wrong-for-47-seconds`, `women-mocking` |
+| `unbothered` | the room is on fire and the body has not moved | `my-favorite-thing-in-the-world-to-do-is-nothing`, `boss-baby-chilling` |
+| `celebrate` | arms up, jumping, confetti-scale joy | 🔎 `celebration-dance`, `girl-dancing`, `jojo-siwa-dancing` — the natural win-pole verb |
+| `stare` | holding eye contact with the camera and saying nothing | 🔎 `cat-staring` (🟢), `mortal-kombat-1-shang-tsung` (🔴) — the `<Entity> watching me …` verb (Rule 1, tier 1) |
+| `wait` | still present, still waiting, visibly longer than is reasonable | 🔎 `wait-hold-on-wait` — for captions whose collapse is elapsed time |
+
+**The queries that produce this table are the `VERBS` dict in `meme-sweep.py` above** — the table is
+its cached output, not a separate list to maintain. Re-run the sweep and you regenerate it.
+
+> 🔎 **marks a slug found by the vector sweep and NOT yet confirmed on a contact sheet.** The first
+> seven rows were cast by hand and shipped; the last three were empty until the sweep filled them,
+> and the sweep ranks descriptions, not footage. **Build the sheet before you use one** — that rule
+> does not relax because a machine agreed with you.
+
+**Do not add an eleventh token** to avoid the work of choosing among ten. If a clip genuinely does
+something none of the ten covers, that is a real finding: add the token here, **with its body line
+and its vector query**, before you use it.
+
+> **The sweep also grades the token list.** `deflate` and `celebrate` came back with 20 and 19 clips
+> the other nine queries had not already found; `stare` and `wait` came back with 9 each. A verb
+> whose neighbourhood is that thin is a verb the shelf cannot really cast — treat a low count as a
+> warning that you are about to force a clip, not as a challenge.
 
 **Then confirm by eye.** Build a contact sheet before you commit — a slug promises an action the
 clip does not always deliver, and half these clips are 16:9 with the subject small at the bottom:
@@ -343,6 +696,63 @@ clip does not always deliver, and half these clips are 16:9 with the subject sma
 ffmpeg -v error -i meme.mp4 -vf "fps=1,scale=240:-1,tile=7x1" -frames:v 1 sheet.png
 ```
 
+### Declare the enactment — in the composition, where the gate can read it
+
+The two-cover test is a human act. What a script can enforce is that **you actually performed it**
+and that the answers are self-consistent. So the answers live in `composition.html`, at the top,
+above the first layer:
+
+```html
+<!-- meme-recaption: enactment
+  clip_slug:           my-disappointment-is-immeasurable-and-my-day-is-ruined
+  caption_verb:        deflate
+  clip_verb:           deflate
+  feeling_size:        small
+  clip_size:           large
+  clip_reads_blind:    a man in a suit goes flat and accepts something without arguing
+  caption_reads_blind: someone gives up on dinner after an hour and settles for pizza
+-->
+```
+
+**It is an HTML comment, not a layer, on purpose.** A text layer would count against
+`max_text_cards`, would need a `data-start`, and — worst — could render. This must never reach a
+pixel. It is build metadata that happens to live in the file the gate already reads, so there is
+no second file to lose.
+
+| Field | Rule | Why the gate can hold you to it |
+|---|---|---|
+| `clip_slug` | the raw's slug, as cast | Feeds `caption_does_not_borrow_lore` — the caption may not reuse a word from it |
+| `caption_verb` / `clip_verb` | both from the ten tokens, and **equal** | This is Test 3 as a string equality. Two different tokens is a declared mismatch and the build stops |
+| `feeling_size` / `clip_size` | `small` or `large`, and **different** | "Match the INTENSITY" made enforceable — see below |
+| `clip_reads_blind` | ≥5 words, written while the caption was covered, and it may **not reuse a content word from the caption** | The cover-the-caption step, on the record — and the one field the gate can genuinely interrogate |
+| `caption_reads_blind` | ≥5 words, written while the clip was covered, and not the same sentence as `clip_reads_blind` | The cover-the-visual step, on the record |
+
+#### Why `clip_reads_blind` may not borrow the caption's words
+
+This is the check with actual teeth, and the reason is the read-order problem again:
+
+> **If the only way you can describe the clip is with the caption's own nouns, one of two things is
+> true, and both are fatal.** Either you never saw the clip cold — you projected the caption onto
+> it, which is exactly the blindness the two covers exist to break — or the clip really does depict
+> the caption's nouns, which is a re-enactment and fails Rule 3.3.
+
+A correct pair reads with almost no vocabulary in common, because the two channels are *supposed*
+to be different worlds:
+
+- ✅ caption `when i've had 10 tabs open since 7pm for one scallop roll and we're getting pizza again`
+  · clip `a man in a suit goes flat and accepts something without arguing` — nothing shared, and
+  they are obviously one situation
+- ❌ clip `a guy who has had 10 tabs open gives up` — you wrote the caption again with "a guy" in
+  front of it. `clip_read_is_independent` fails
+
+> **What no gate can check, and this file will not claim otherwise:** whether the two sentences
+> describe the *same* situation. Lexical overlap does not measure it — an early draft of this
+> section required the two blind reads to share a word, and a correct pair shares none, so the
+> check would have fired on every good build and been switched off within a day. **The comparison
+> is gate 3. It always was.** What the declaration buys is that the comparison becomes a discrete
+> act with a written output, performed before you have seen the finished frame — not a feeling you
+> had at 2am with both channels already loaded in your head.
+
 ### Match the INTENSITY, not just the verb
 
 The enactment test gets you the right action. This gets you the right *size* of it — and it is
@@ -357,6 +767,17 @@ where the comedy actually comes from.
 - Matching a big feeling to a big reaction is not a joke, it is a re-enactment. Matching a small
   feeling to a small reaction is not anything at all.
 
+**Declare both sizes and they must differ.** `feeling_size` and `clip_size` in the enactment block
+are `small` or `large`, and `intensity_mismatched` fails when they are equal. Two coarse buckets,
+not a scale, because a scale invites a 3-vs-4 that means nothing; the question the format actually
+asks is only ever *"is the reaction the wrong size for the cause?"* — and the answer to that is
+binary.
+
+> **This does not contradict "the verb must match".** The verb is *what* the body does; the size is
+> *how much*. Enactment requires the same verb; comedy requires a different amount of it. A caption
+> about a mildly annoying evening (`small`) enacted by a man whose day is immeasurably ruined
+> (`large`) is both rules satisfied at once — same verb, wrong size — and it is the worked example.
+
 **Choose the pain or win that the clip's energy already fits, rather than fighting the footage.**
 You have 851 clips and one caption you have not written yet; it is far cheaper to pick the feeling
 that suits a great clip than to hunt for a clip that suits a feeling you are attached to. When a
@@ -395,21 +816,68 @@ class before you write a single ffmpeg command.**
 | Where the caption goes | On the background, above the subject | On a plate above the clip, outside the picture |
 | Share of the shelf | The large majority | A minority — check for burned-in text on the contact sheet |
 
-**Check the plate colour before you key anything.** These clips are re-encodes and the plate is not
-always what it looks like:
+### Decide the class MECHANICALLY, then read the plate
 
-```bash
-python3 -c "
-import subprocess,numpy as np
-p=subprocess.run(['ffmpeg','-v','error','-i','meme.mp4','-vf','fps=1,crop=200:200:20:20',
-                  '-pix_fmt','rgb24','-f','rawvideo','-'],capture_output=True)
-a=np.frombuffer(p.stdout,np.uint8).reshape(-1,200,200,3)
-m=a.reshape(-1,3).mean(0).astype(int); print('plate rgb',m,'hex %02X%02X%02X'%tuple(m))"
+> **The class is not a judgement call and it must not be one.** "Is there a plate" has to be
+> answered before "what colour is the plate", or you key a Class B clip against a muddy average of
+> somebody's living room and punch holes in it. **Nothing downstream catches that** — the key
+> "works", a subject is found, the render is quietly ruined, and `no_residual_green` passes because
+> there was never any green.
+
+Run this on every clip, before Appendix A. It answers both questions in the right order:
+
+```python
+#!/usr/bin/env python3
+"""plate-check.py <meme.mp4> — Class A or Class B, and the plate if there is one."""
+import subprocess, sys, numpy as np
+
+src, W, H = sys.argv[1], 320, 320
+p = subprocess.run(["ffmpeg", "-v", "error", "-i", src, "-vf", f"fps=2,scale={W}:{H}",
+                    "-pix_fmt", "rgb24", "-f", "rawvideo", "-"], capture_output=True)
+a = np.frombuffer(p.stdout, np.uint8)
+a = a[: len(a) // (W * H * 3) * (W * H * 3)].reshape(-1, H, W, 3).astype(np.int16)
+
+# All four corners, not just the top-left: on a keyed clip every corner is plate,
+# on a baked clip they are four different bits of a room.
+c = np.concatenate([a[:, :24, :24], a[:, :24, -24:],
+                    a[:, -24:, :24], a[:, -24:, -24:]], axis=2).reshape(-1, 3)
+plate = c.mean(0).astype(int)
+flat  = c.std(0).mean()                          # one colour, or a scene
+cover = (np.abs(a - plate).max(3) < 40).mean()   # how much of the frame IS plate
+sat   = int(plate.max() - plate.min())           # letterbox bars read flat too
+
+print(f"plate rgb {plate.tolist()} hex {'%02X%02X%02X' % tuple(plate)}  "
+      f"corner stdev {flat:.1f}  coverage {cover*100:.0f}%  saturation {sat}")
+
+if flat > 12 or cover < 0.25 or sat < 60:
+    sys.exit("CLASS B — no saturated flat plate. Do NOT key. Layout A, crop the burned-in text")
+
+digital = plate[1] > 240 and plate[0] < 40 and plate[2] < 40
+print("CLASS A — " + ("digital plate: chromakey 0.18:0.03, NO despill" if digital
+                      else "filmed plate: chromakey 0.30:0.08, light despill"))
 ```
 
-A pure `00FF00` reading means a digital plate: key tight (`0.18:0.03`) and **skip despill.** A
-reading like `1F D3 1F` means a filmed plate: key looser and despill lightly. Getting this backwards
-is the first defect in the list below.
+**The three thresholds and what each one is for:** `flat > 12` is a scene wearing a plate's
+costume, `cover < 0.25` is a plate too small to be the background, `sat < 60` is black or white
+letterbox bars, which are flat and are not a plate. All three are first-pass numbers measured on one
+shelf — **calibrate them against a clip you already agree about before you let them fail anything.**
+
+**Then read the colour, because these clips are re-encodes and the plate is not always what it looks
+like.** A pure `00FF00` reading means a digital plate: key tight (`0.18:0.03`) and **skip despill.**
+A reading like `1F D3 1F` means a filmed plate: key looser and despill lightly. Getting this
+backwards is the first defect in the list below.
+
+> **The shelf is overwhelmingly green, and the gate only knows green.** `no_residual_green` (gate 2)
+> tests a green hue, so it catches both defects that matter on this shelf — a fringe from a tight
+> key, and a key that never ran at all. `no_unkeyed_plate` sits beside it and is hue-agnostic, for
+> the blue or magenta plate the green test is blind to. **If `plate-check.py` prints a plate that is
+> not green, say so in the build log** — the named check is no longer the one protecting you.
+
+> **Why this harness does not use `vidfarm remove-greenscreen` for the video.** The skill's keying
+> surface (`remove-greenscreen --local` / `--smart`, `cutout`, `sticker-pack`) is the right answer
+> almost everywhere else, and it is a **transparent-output** surface. This format never needs
+> transparency in its output — it composites onto a background and ships an opaque MP4 — and the
+> alpha intermediate is where the free path breaks. See the warning under "Cost-saving mode".
 
 ### Class B — dealing with the burned-in text
 
@@ -713,10 +1181,14 @@ are checked (`offer_not_in_payoff`, `caption_does_not_resolve`).
 2. Is it still **≤20 words** with the offer in it?
 3. Does the offer read as a **character**, or as a sponsor who bought a slot?
 4. Does the **collapse still land on the person**?
-5. Would it still be funny to someone who has **never heard of the offer**?
+5. Would it still be funny to someone who has **never heard of the offer**, **did not see your last
+   post**, and has **never seen the source meme**? (Rule 10 — all four contexts, not just the
+   product)
 
 Question 5 is the one that catches most failures. If the joke needs the reader to know what the
 product does, the product is not a character — it is an explanation, and explanations are not funny.
+The same is true of the other three borrowed contexts: each one turns the caption into something
+that has to be introduced, and nobody introduces a meme.
 
 #### The handle (tier 2), specced
 
@@ -763,10 +1235,32 @@ the last clause; on the win pole it may be in both, and the discipline moves to
 of it. **If you did not decide the pole, you are on the pain pole** — it is the safer default and the
 one that travels.
 
-### Rule 3 — cast for the verb, not the mood
+### Rule 3 — the clip ENACTS the caption. Same verb, wrong size, different world
+
+Written above as the two-cover test; repeated here because it is the rule most often lost between
+casting and the timeline, and because "cast for the verb" alone was too easy to satisfy.
 
-Written above as the enactment test; repeated here because it is the rule most often lost between
-casting and the timeline. Name the physical action in the build log before you open the shelf.
+> **Amended.** Rule 3 used to read *"cast for the verb, not the mood"*, and that is still the first
+> half of it. It was not enough: a verb named only in the build log is a verb nobody compares, so
+> the rule passed every time it was read. Rule 3 is now three claims, all of which are declared in
+> the composition and two of which the gate can fail you on.
+
+1. **Same verb.** `caption_verb` and `clip_verb` are the same token from the closed list of ten.
+   Not similar. The same. — `enactment_verbs_match`
+2. **Wrong size.** `feeling_size` ≠ `clip_size`. The mismatch between the size of the cause and the
+   size of the reaction is where the comedy actually is. — `intensity_mismatched`
+3. **Different world.** The clip does the caption's verb; it must not depict the caption's nouns. A
+   clip that shows the thing the caption is about is a re-enactment, and the gap is the joke. —
+   partially caught by `caption_does_not_borrow_lore`
+
+**And the test you run before any of that:** cover the caption, cover the visual, write one
+sentence for each, compare the sentences. The failure it exists for is vibe-adjacency, and the
+reason it is written as two covers is that you read the caption first and can no longer see the
+clip cold. Both sentences go in the composition, and `clip_reads_blind` may not reuse a content
+word from the caption. — `enactment_declared`, `clip_read_is_independent`
+
+**The comparison itself is yours.** No script decides whether two sentences name one situation.
+The gate makes sure you wrote them, wrote them cold, and did not write the caption twice.
 
 ### Rule 4 — the action lands AFTER the caption is read, and frame 0 has a person on it
 
@@ -825,6 +1319,108 @@ same complaint — so ask for exactly that.
 > Post caption pattern: `<the caption's situation, restated in one line>. <one question inviting
 > their version>`
 
+### Rule 10 — the caption stands alone. Zero setup, zero borrowed context
+
+**A cold viewer with nothing gets it, or it does not ship.** Nothing they see was explained
+anywhere else, because nowhere else is reachable: the platform hands them one muted 7-second video
+between two strangers' videos, and everything the joke needs has to already be on that frame or
+already in their life.
+
+Four things you may not borrow — the product, your previous post, the source meme's lore, and your
+own private history. They are set out with their reasons under "The four contexts a viewer does not
+have". `iykyk` is banned outright, in the front matter, because it is the caption admitting it
+failed while excluding the people you needed.
+
+**Rule 10 is not a licence to go generic, and read carelessly it produces exactly that.** Context
+and detail are two separate dials: Rule 10 turns *context* to zero, the specificity ladder turns
+*detail* to maximum, and the caption gets more relatable, not less, as long as you **re-spend the
+words you win back.** Cutting `on resy` and stopping there leaves a weaker caption; cutting it and
+buying `since 7pm` leaves a stronger one. The one question that sorts a word into the right dial is
+**"who had to have been there?"** — see "Strictness vs relatability", which is the load-bearing
+half of this rule.
+
+Checked by `caption_no_context_debt` and `caption_does_not_borrow_lore`, and by the front matter's
+`forbid_text` list at gate 1.
+
+### Rule 11 — one client never gets the same meme, or the same joke, twice
+
+**This rule only applies when you are delivering to somebody** — a marketplace buyer, a retainer
+client, a customer's own account. On an account you own, ignore it and run the matrix.
+
+> **No two videos delivered to the same client may share a `clip_slug`, a caption frame, or a pain —
+> unless that client asked for a series, in writing.**
+
+Three separate keys, because this format repeats in three separate ways and only the first one is
+obvious:
+
+| Key | The repeat | Why it is fatal here specifically |
+|---|---|---|
+| `clip_slug` | the same borrowed clip twice | It is not *similar* footage, it is the **same footage**. The buyer recognises it instantly, and the second video looks like the first one with the words changed — which is exactly what it is |
+| the caption frame | `When I …` twice, or `<Entity> when they …` twice | There are only **eight**, so two pains in one frame land as one joke. The words differ and the shape does not, and the shape is what a viewer remembers |
+| the pain | the same complaint restaged | You sold one insight three times. This is the one the buyer notices last and resents most |
+
+**The rights tier compounds it.** 🟢 is the default for client work, which is a small shelf, so a
+clipper working one buyer for a month runs out of safe clips faster than they expect and starts
+reaching for one they already used. Cast against your delivery log, not against your memory. When
+the 🟢 shelf really is exhausted for that client, that is a signal to change the *pain* and cast
+fresh — not to re-run a clip.
+
+**Your style repeats. Your joke does not.** The caption plate, the font, the 62% band, the grade on
+the background, the handle — that is the visual identity the client hired and it should be identical
+across every delivery. Rule 11 is about the two ingredients at the top of this file: the meme and
+the caption. Nothing else.
+
+**The exception, and how narrow it is.** A client who asked for a series, a variant set, or "five
+cuts of this one joke" has asked for controlled repetition, and then repeating is the deliverable.
+It must be **written** — in the task payload, in the gig terms, or in their feedback on a proof they
+kept (`"More like this one."` counts). **An approval is not an ask.** A meme that worked is a reason
+to write another meme, not a reason to send the same one again.
+
+#### Across clients — reuse a great raw, retire a mid one
+
+Rule 11 is a hard rule *within* one client. Across clients it relaxes into a preference, and the
+thing that decides it is **not novelty, it is how the raw has actually performed.**
+
+> **A raw that lands is an asset. Carry it to the next buyer. A raw that was only ever okay gets one
+> outing, and then it is done.**
+
+Refusing to reuse a proven clip in the name of variety throws away the only edge casting gives you.
+Five buyers who each see `hangover-dog` once is five good videos. The failure is the other one, and
+it is specific: **one mediocre clip appearing in most of your recent deliveries**, because it was
+nearby and you had already keyed it. That is not a style, it is a rut, and it is visible to everyone
+except you.
+
+| What the raw has collected in `DELIVERED.tsv` | What you may do with it |
+|---|---|
+| nothing — never delivered | **one use.** It is unproven no matter how good the contact sheet looked |
+| an approval, no passes | **reuse it across other clients**, once each. This is what a proven raw is for |
+| passed on twice, never approved | **retire it.** Two buyers said no to that face. The third will too |
+| mixed | a fit question, not a quality one. Reuse it only where the pain genuinely matches |
+
+**The shelf is public, which makes this sharper than it looks.** You cast from `vidfarm public-raws`
+and so does every other clipper on the marketplace. A slug that is easy to find is easy for everyone
+to find, so the buyer may have seen it this week from somebody else — and 851 MemeScreens means the
+excuse "there was nothing else" is almost never true. **Run the diversity sweep before you reach for
+a clip you have already used**; it costs ten API calls and it deletes the excuse.
+
+**And note what "easy to find" now means.** Every clipper on this marketplace reads the same CLI, and
+the CLI shows everybody the same first 200. If you cast from that page you are competing for 200
+clips while 65% of the shelf sits unread. The sweep is not only how you avoid repeating *yourself* —
+it is how you avoid arriving at the buyer with the same clip as everyone who did not run it.
+
+**The number, if you want one:** the same `clip_slug` in more than about **3 of your last 20
+deliveries** is a signature you did not choose. Either it has the approvals to justify it, or you
+are casting from memory instead of from the shelf.
+
+```bash
+cut -f5 CLIPPER/DELIVERED.tsv | tail -20 | sort | uniq -c | sort -rn | head
+```
+
+**No gate checks this and none can.** Gate 1 sees one composition, gate 2 sees one MP4, and neither
+has ever seen the other videos you sent that buyer. It is a **ledger** rule, not a frame rule: one
+row per delivery, checked before you cast. The marketplace-wide version, with the file format, is
+`https://vidfarm.cc/marketplace.md` § *never send one client the same video twice*.
+
 ---
 
 ## Cost-saving mode — the whole build at $0
@@ -887,8 +1483,56 @@ interchangeable.
 is one ffmpeg command and the caption layer does not change. Do that before you write a second
 caption — you will learn more from five castings of one joke than from five jokes.
 
-Keep the index (Appendix C) and a `captions.tsv` of rung-3 lines. The pairing is the creative act;
-everything downstream is a loop.
+> ⚠️ **Take the five clips from five DIFFERENT verb neighbourhoods, not from the top five of one
+> query.** This is where a matrix quietly stops being an experiment. The top five of one vector
+> query are five near-neighbours — often the same performer in four crops — so the five videos
+> differ by almost nothing and the five data points are one data point with error bars. Pull one
+> clip per verb from `casting-pool.fresh.tsv` and the five castings actually span the shelf.
+
+Keep three files: the identity index (Appendix C), a fresh `casting-pool.fresh.tsv` from the sweep,
+and a `captions.tsv` of rung-3 lines. **The sweep is the only one of the three that goes stale** —
+re-run it per session, because it is also the file that has your delivery log subtracted from it.
+The pairing is the creative act; everything downstream is a loop.
+
+### ⚠️ The matrix is YOUR test set. It is not one client's inbox
+
+Everything above is a testing discipline for an account you own, where five castings of one joke are
+five data points and the audience never sees them as a set. **The moment these become proofs on the
+marketplace, that arithmetic inverts.** A buyer does not see five data points. They open a swipe deck
+and see the same joke five times from the same name, and the fifth card is not a fifth chance — it is
+the reason they stop opening your cards.
+
+> **Vary the clip if you are testing. Vary the JOKE if you are delivering.**
+
+| | You are testing (your own account, one client's paid campaign, an asked-for A/B set) | You are delivering (proofs to a buyer) |
+|---|---|---|
+| One caption × five clips | ✅ the point of the exercise | ❌ one idea in five costumes |
+| Five pains × one clip | ✅ | ❌ the buyer sees your one clip five times |
+| What varies between proofs | one variable, deliberately | the **pain**, the **caption**, and the **clip**, all three |
+| Who sees the set | an algorithm | one person, in one sitting, next to each other |
+
+**So build the matrix, ship one cell of it.** The matrix is still the right way to work — sit down
+with the testimonials, write ten pains, cast twenty clips, and pair them. Then send this buyer the
+one best pairing, and hold the rest for the next brief or the next buyer. The pairings you did not
+send are not waste; they are your inventory, and they are why the second delivery is fast.
+
+**This format repeats more invisibly than any other in the set, for two reasons.** The clip is
+borrowed, so two videos built from the same `slugId` are *literally the same footage* — not similar,
+identical. And the caption sits in one of only eight frames, so two different pains written in the
+same frame land as the same joke even when every word differs. `When I …` twice in a row is one
+voice; `When I …` then `<Entity> watching me …` is two.
+
+**Log the creative key on every delivery, per client.** Four fields, and no two proofs to one buyer
+may match on any of them (see Rule 11):
+
+```
+client · clip_slug · caption frame · pain
+```
+
+`clip_slug` is already in the enactment declaration and the frame and the pain are already in the
+caption, so logging this costs one line appended to `CLIPPER/DELIVERED.tsv` at submit time.
+**Read it back before you cast, not before you render** — the clip is the part you cannot edit, and
+finding the repeat after the composite is a rebuild.
 
 ---
 
@@ -899,9 +1543,15 @@ different things. **Running only the first one is the same as running none.**
 
 | Gate | Tool | Sees | Catches |
 |---|---|---|---|
-| 1. Markup | `vidfarm qa <dir> --harness ./experimental/meme-recaption.md` | the composition DOM | duration, aspect, font regime, banned strings, layer counts. **22 checks, zero pixels** |
-| 2. Render | `python3 meme-qa.py <render>.mp4 <composition>.html` (Appendix E) | the finished MP4 | blank thumbnail, empty tail, residual green, caption centring/balance/placement, background not pushed down, silent audio, caption grammar |
-| 3. Human | your eyes | the joke | the three-way lock. **No script will ever check whether it is funny** |
+| 1. Markup | `vidfarm qa <dir> --harness ./experimental/meme-recaption.md` | the composition DOM | duration, aspect, font regime, banned strings, layer counts. **Zero pixels.** One check per `forbid_text` phrase, so the total moves whenever that list grows — do not quote a number here, it will be wrong within a month |
+| 2. Render | `python3 meme-qa.py <render>.mp4 <composition>.html` (Appendix E) | the finished MP4 **and the enactment declaration** | blank thumbnail, empty tail, residual green, caption centring/balance/placement, background not pushed down, silent audio, caption grammar, context debt, borrowed lore, and the declared enactment |
+| 3. Human | your eyes, and a pen | the joke | **the two covers**, written down and compared — then the three-way lock. **No script will ever check whether it is funny** |
+
+**And one rule sits outside all three, on purpose: Rule 11.** Every gate here sees exactly one video.
+Whether you have already sent this client that clip, that caption frame or that pain is a fact about
+your *other* videos, so no check that opens this composition can ever reach it. It lives in
+`CLIPPER/DELIVERED.tsv` and it is checked **before you cast**, which is also the only moment it is
+cheap.
 
 > 🚨 **Gate 1 passes on a broken video.** Every defect this format actually produces is invisible to
 > a DOM check. During the run that produced this file, a build passed `vidfarm qa` **19/19 while
@@ -927,7 +1577,8 @@ What gate 2 enforces, and the number it uses:
 | Check | Threshold | The defect it exists for |
 |---|---|---|
 | `first_frame_has_subject` / `last_frame_has_subject` | lower-band stdev > 12 | Blank thumbnail / empty tail from un-trimmed plate |
-| `no_residual_green` | < 0.5% green pixels | A key that was too tight |
+| `no_residual_green` | < 0.5% green pixels | A key that was too tight — a fringe on the shelf's usual `00FF00` plate |
+| `no_unkeyed_plate` | largest flat saturated colour < 25% of frame, **or** `--flat-bg-ok` | The key never ran, or it ran on a blue/magenta plate the green test is blind to. Pass `--flat-bg-ok` only on ladder tier 6, where a flat brand plate really is the background |
 | `caption_horizontally_centred` | block centre 50% ± 3% | The flush-left plate with a lake of dead space |
 | `caption_side_margins` | > 4% and < 96% | A plate touching an edge |
 | `caption_vertical_placement` | inside 8–85% | Under the platform UI, or on the subject's face |
@@ -936,7 +1587,7 @@ What gate 2 enforces, and the number it uses:
 | `background_not_blown_out` | top-strip luma < 150 | A bright background eating a white caption |
 | `audio_level` | −20…−13 LUFS, **or** < −50 with `--silent-ok` | A silent clip shipped as if it had sound |
 | `caption_word_count` | 8–20 words | Slogan, or unreadable in 0.6s |
-| `caption_uses_a_frame` | one of the six | A caption that is a statement, not an experience |
+| `caption_uses_a_frame` | one of the **eight** frames | A caption that is a statement, not an experience |
 | `caption_no_cta_or_resolution` | no CTA strings, no `so i` / `then i found` | Rules 1 and 2 — the ad leaking back in |
 | `caption_lines_hand_broken` | a `<br>` is present | Renderer wrap landing mid-thought |
 | `offer_named_somewhere` | in the caption **or** in the handle | An untraceable meme that builds someone else's page. Also prints which tier you are on |
@@ -947,14 +1598,31 @@ What gate 2 enforces, and the number it uses:
 | `handle_is_dimmed` | alpha ≤0.85 *(only if a handle exists)* | Same |
 | `single_shot` | exactly 1 `<video>` | "There are no beats" |
 | `no_animation_on_caption` | no `animation` in `.memecap` | Kinetic captions, which break the read order |
+| `caption_no_context_debt` | none of `iykyk` / `if you know you know` / `you already know` / `part 2` / `as promised` / `like i said` / `see my last` … | Rule 10 — a caption asking the viewer for setup they were never given |
+| `enactment_declared` | the `<!-- meme-recaption: enactment -->` block, all seven fields, both blind reads ≥5 words and not the same sentence | Rule 3 — the two-cover test not run at all. An undeclared enactment is not a passing enactment |
+| `enactment_verbs_match` | `caption_verb` == `clip_verb`, both in the ten tokens | Rule 3.1 — vibe-adjacency, declared out loud. The clip does one thing and the caption is about another |
+| `intensity_mismatched` | `feeling_size` ≠ `clip_size`, both `small`/`large` | Rule 3.2 — a big feeling on a big reaction is a re-enactment; a small one on a small one is nothing |
+| `clip_read_is_independent` | `clip_reads_blind` shares no content word with the caption (stemmed, ≥4 chars, not a stopword) | Rule 3 — you described the clip with the caption's nouns, so either you never saw it cold or it is a re-enactment. **The gate cannot check that the two reads name one situation** — that stays gate 3 |
+| `caption_does_not_borrow_lore` | no content token of `clip_slug` (≥4 chars, stemmed, minus the offer's name) appears in the caption | Rule 10, context 3 — a joke that needs the source meme. Also catches the literal case, where the caption names what the clip already *is* |
 
 **Pass `--offer <domain>`** or the handle checks are skipped silently — an unset offer is not a
 passing offer. **Pass `--pole win`** only when the caption is deliberately a win meme; the gate
 defaults to `pain`, the stricter of the two, so nobody accidentally ships a resolution.
 
-**Two things gate 2 deliberately does NOT check**, because a script cannot: whether the meme enacts
-the caption's verb, and the rights tier. Those stay on the human checklist below, and the rights
-tier stays in the build log in writing.
+> **Amended — gate 2 now reaches into enactment, halfway.** This paragraph used to say gate 2
+> deliberately does not check *"whether the meme enacts the caption's verb, and the rights tier,
+> because a script cannot."* Half of that was true and half was an excuse. A script cannot judge a
+> match; it **can** hold you to a declaration and check the declaration against itself. So the
+> enactment block is now mandatory and five checks run on it, and the sentence is narrowed:
+>
+> **What gate 2 still cannot do** is tell you the declaration is *honest* — that the sentence you
+> wrote about the clip is what a stranger would actually write. That is gate 3, and it is why the
+> two covers stay on the human checklist below. **The rights tier is unchanged and remains
+> unchecked**, in the build log, in writing.
+>
+> Do not read the five green enactment lines as "the match is verified". Read them as "the
+> comparison was performed and its answers do not contradict each other". That is a much smaller
+> claim, and it is the one the gate is entitled to make.
 
 **Calibrate a checker before you trust it.** Two of these thresholds were wrong on their first
 version and fired on a correct build — `caption_lines_balanced` measured pixel rows instead of text
@@ -969,15 +1637,42 @@ you have already looked at and agree is good, and make it pass before you let it
 
 Run this **before** you build. An unchecked box is a rewrite, not a fix in the edit.
 
+**The client** — delivery work only. Skip the whole block on an account you own
+- [ ] `CLIPPER/DELIVERED.tsv` read for this client **before casting**, not before submitting
+- [ ] `clip_slug` not already delivered to them (Rule 11 — the same slug is the *same footage*)
+- [ ] Caption frame not already delivered to them — there are only eight
+- [ ] The pain not already delivered to them, restaged
+- [ ] If any of the three repeat: the client asked for a series **in writing**, and you can quote it
+- [ ] **Reusing this clip on a DIFFERENT client?** It has an approval on it, or it is unproven and
+      this is its one outing. Passed on twice with no approval = retired
+- [ ] This `clip_slug` is not in more than ~3 of your last 20 deliveries
+- [ ] **The diversity sweep ran this session** and you cast off `casting-pool.fresh.tsv`, not off
+      the CLI's first 200 and not off memory
+- [ ] The sweep's ranking was **live** — `vidfarm whoami` shows a login, a gemini/openai key is
+      saved, and two different verb queries returned two different top clips. No key = no ranking,
+      silently, with a full page of results to hide it
+- [ ] The style — plate, font, band, grade, handle — is **identical** to the last delivery. That part
+      is meant to repeat
+
 **The joke**
 - [ ] **Pole chosen and written down** — pain or win (default pain)
 - [ ] If win: the comedy is the size of the relief, not the feature
 - [ ] `WHO:` and `MOMENT:` are written at the top of the build log
-- [ ] Test 1 — someone who has never heard of the offer laughs
+- [ ] Test 1 — someone with no knowledge of the offer, your last post, or the source meme laughs
 - [ ] Test 2 — the experience named is one the product removes
-- [ ] Test 3 — the meme's physical verb IS the caption's feeling
-- [ ] The clip's INTENSITY mismatches the feeling's size (that mismatch is the joke)
+- [ ] Test 3 — **the two covers are written down**, not just felt:
+  - [ ] Cover the caption → `clip_reads_blind:` one sentence, what a stranger names in the clip
+  - [ ] Cover the visual → `caption_reads_blind:` one sentence, the situation the caption leaves
+  - [ ] The two sentences are **the same situation**, told twice. Not adjacent. Not compatible
+- [ ] `caption_verb` == `clip_verb`, both from the ten tokens
+- [ ] `feeling_size` ≠ `clip_size` — the clip's INTENSITY mismatches the feeling's (that is the joke)
+- [ ] The clip does the caption's **verb** but does not depict its **nouns** (no re-enactment)
+- [ ] `clip_reads_blind` reuses **none** of the caption's words (if it does, you projected)
+- [ ] All seven enactment fields are in `composition.html` as an HTML comment, not a layer
 - [ ] Cold-viewer test — cover the brand and every feature word; does it still read?
+- [ ] **Rule 10** — nothing borrowed from the product, your last post, the meme's lore, or your life
+- [ ] Every specific survived **"who had to have been there?"** — detail kept, context cut
+- [ ] Context cut, and the freed words **re-spent on detail** (not just deleted)
 - [ ] The caption is on rung 3: a number, a proper noun, a deflating outcome
 - [ ] The numbers and proper nouns are traceable to the customer's own copy
 - [ ] One of the eight frames, unmixed, subject first, 8–20 words, no end punctuation
@@ -985,6 +1680,8 @@ Run this **before** you build. An unchecked box is a rewrite, not a fix in the e
 
 **The clip**
 - [ ] Rights tier declared. 🟢 for client work, or a 🟢 alternate is built alongside
+- [ ] **`plate-check.py` run, and the class it printed is the class you built** — Class A keys and
+      needs a background, Class B is never keyed and needs the burned-in text cropped
 - [ ] Plate colour sampled, not assumed
 - [ ] Contact sheet built and looked at
 - [ ] The action lands 0.6–1.0s in, and frame 0 has the subject on it (`-vframes 1`, looked at)
@@ -1002,6 +1699,8 @@ Run this **before** you build. An unchecked box is a rewrite, not a fix in the e
 - [ ] 1080×1920, 30fps
 - [ ] The meme is NOT cropped to 9:16
 - [ ] Layout A or B chosen deliberately; in B the subject is bottom-anchored and full width
+- [ ] **Class A: the plate is gone and a background is behind the subject.** No green edge on the
+      hair or shoulders, no green in the gaps between limbs, nothing green in the last frame
 - [ ] Caption **block centred**, words left-aligned, lines hand-broken to near-equal length
 - [ ] Caption fully legible at frame 0, static, plated, clear of the subject's head
 - [ ] Poster layer present, so frame 0 is never bare background
@@ -1014,8 +1713,14 @@ Run this **before** you build. An unchecked box is a rewrite, not a fix in the e
 - [ ] Audio kept and normalised, measured on the render — or deliberately silent and said so
 - [ ] **Gate 1:** `vidfarm qa <dir> --harness ./experimental/meme-recaption.md`
 - [ ] **Gate 2:** `python3 meme-qa.py <render>.mp4 <dir>/composition.html` exits 0
-- [ ] **Gate 3:** you watched it
+- [ ] **Gate 3 — the whole-render pass, in this order:**
+  - [ ] Watch it muted with the caption covered. Does the clip still *do something namable*?
+  - [ ] Read the caption alone, out loud, cold. Is it already a complete joke?
+  - [ ] Watch it whole, once, at speed. Did the recognition fire, or did you only *approve* of it?
+  - [ ] Ask the last one honestly: **would a stranger need one question answered?** If yes, Rule 10
 - [ ] Post caption written, carrying the one comment ask
+- [ ] **Delivery work:** one row appended to `CLIPPER/DELIVERED.tsv` — `client · clip_slug · frame ·
+      pain`. An unlogged delivery is the repeat you will ship next week
 
 ---
 
@@ -1026,11 +1731,18 @@ Diagnose by charge. Do not declare the video bad.
 | Symptom | The weak charge | The actual cause, in order of likelihood |
 |---|---|---|
 | Almost no views | Hook | The first three words are generic · the frame-0 image is not weird enough · the caption is too long to read in 0.6s |
-| Views, everyone leaves at 3s | Loop / enactment | The action landed before the caption was read (Rule 4) · the meme does not enact the verb (Test 3) |
+| Views, everyone leaves at 3s | Loop / enactment | The action landed before the caption was read (Rule 4) · the meme does not enact the verb (Rule 3, test 3) |
+| **Watched to the end. Nothing. No leave, no laugh, no share** | **Enactment** | **Vibe-adjacency.** The clip was compatible with the caption instead of being the same event. This is the default cause and it is the one you cannot see, because you read the caption first. Run the two covers on the shipped video — write both sentences down before you look at them together |
 | Watched to the end, no reaction | Payoff / specificity | Rung 2. Add the number and the proper noun · or the joke resolves (Rule 2) |
+| Only your existing followers engaged; no cold reach | **Rule 10** | Context debt. The caption borrowed from your last post, or the product, or the meme's lore. The algorithm did try strangers; the strangers needed a briefing |
+| It reached people who love the meme, not people with the problem | Rule 10, context 3 | The joke was about the meme, not about their week. Ceiling = the meme's fandom (`caption_does_not_borrow_lore`) |
+| "True but not funny" · reads like a caption on a stock photo | Rule 3.2 / 3.3 | The sizes matched (a big feeling on a big reaction = re-enactment) · or the clip depicted the caption's nouns instead of its verb |
+| Nobody in the niche felt seen; it could be about anyone | **Strictness overshot** | You cut context and did not re-spend the words on detail. Rung 1. Go back to Rule 6 and take a sentence a real user said |
 | Good watch time, dead comments | Bait | No post caption ask · or the ask is a poll, not an invitation to add their own version |
 | Comments are "what is this an ad for" | Rule 1 | The product leaked in — a logo, a screenshot, a category noun in the caption |
 | Reach collapsed after 2 hours | Audio / rights | A music-sync meme got muted · a 🔴 clip got claimed |
+| **The client passed on a video that would have worked on its own** | **Rule 11** | Repetition. They already had this clip, this caption frame, or this pain from you. It is judged against your *last* delivery, not on its own — check `DELIVERED.tsv` for the collision, then change the pain and cast fresh |
+| The client's approvals dropped off across a batch, from the first card to the last | **Rule 11** | You shipped a row of the matrix instead of one video. Five castings of one joke is a test set, not a delivery |
 
 ---
 
@@ -1100,9 +1812,19 @@ def frames(path, w, h, vf):
     n = len(p.stdout) // (w * h * 3)
     return np.frombuffer(p.stdout, np.uint8)[:n * w * h * 3].reshape(n, h, w, 3).astype(np.int16)
 
-# --- 1. read the plate colour off the top-left corner, which is always plate ---
+# --- 1. confirm there IS a plate, THEN read its colour off the corner ---
+# The order is load-bearing. Handed a Class B clip (its own world, no plate),
+# every line below still runs: it keys against a muddy average of somebody's
+# living room, step 2 finds a "subject", and the render ships with holes punched
+# in it. Nothing catches that downstream — no_residual_green passes, because
+# there was never any green. So refuse here, not at render.
 corner = frames(meme, 200, 200, "fps=1,crop=200:200:20:20")
+flat = corner.reshape(-1, 3).std(0).mean()
 plate = corner.reshape(-1, 3).mean(0).astype(int)
+if flat > 12 or int(plate.max() - plate.min()) < 60:
+    sys.exit(f"corner stdev {flat:.1f}, plate {plate.tolist()} — not a flat saturated "
+             "chroma plate. This is CLASS B: do not key it. Use Layout A and crop "
+             "the burned-in text. (Run plate-check.py for the full read.)")
 digital = bool(plate[1] > 240 and plate[0] < 40 and plate[2] < 40)
 key_hex = "0x%02X%02X%02X" % tuple(plate)
 tol, soft, despill = (0.18, 0.03, False) if digital else (0.30, 0.08, True)
@@ -1178,11 +1900,21 @@ def probe_key(tol_try, soft_try, despill_try, t):
     lum = flat.mean(1)
     lit = flat[lum > max(lum.max() * 0.75, 1)]          # the subject's bright side
     green_left = ((flat[:, 1] - flat[:, 0] > 40) & (flat[:, 1] - flat[:, 2] > 40)).mean()
-    return lit.mean(), green_left
+    # A radius that erased the whole subject leaves NO bright pixels, and
+    # `lit.mean()` on an empty slice is nan, not 0. nan then loses every
+    # comparison below in silence: `nan > 0.88` is False, so the radius is
+    # rejected for the right reason by accident — but if the UN-keyed probe
+    # comes back nan too, every `keep` is nan, `best` stays None, and the run
+    # falls through to the sampled default with only a printed line. Return a
+    # real 0.0 so a dead frame scores like a dead frame.
+    return (float(lit.mean()) if lit.size else 0.0), green_left
 
 t_probe = START + DUR / 2
 # chromakey's similarity floor is 1e-05, not 0 — a literal 0 is a hard filter error
 src_lit, _ = probe_key(1e-5, 0.0, False, t_probe)       # ~nothing keyed = the truth
+if not src_lit:
+    sys.exit(f"the un-keyed probe frame at {t_probe:.2f}s has no bright pixels — "
+             "the clip is dark or the presence window is wrong. Check it by eye")
 best = None
 for tol_try in (0.34, 0.28, 0.22, 0.18, 0.14, 0.10, 0.07):
     r = probe_key(tol_try, soft, despill, t_probe)
@@ -1246,6 +1978,19 @@ A static, plated card: block centred, words left-aligned, no animation, `data-st
 This is the exact markup from the worked example, which measures 49.8% block centre.
 
 ```html
+<!-- meme-recaption: enactment
+     Rule 3 + Rule 10, on the record. A COMMENT, never a layer: a layer would count
+     against max_text_cards, would need a data-start, and could render. Gate 2 reads
+     it out of this file, so there is no second file to lose.
+  clip_slug:           my-disappointment-is-immeasurable-and-my-day-is-ruined
+  caption_verb:        deflate
+  clip_verb:           deflate
+  feeling_size:        small
+  clip_size:           large
+  clip_reads_blind:    a man in a suit goes flat and accepts something without arguing
+  caption_reads_blind: someone gives up on dinner after an hour and settles for pizza
+-->
+
 <!-- Layout B: caption on a translucent plate over the background, above the subject.
      The WRAPPER is full width and centres; the PLATE is an inline-block that rides
      that centre. left:7% would pin the plate to 7% and leave the frame lopsided. -->
@@ -1318,16 +2063,24 @@ ffmpeg -i media/scene.mp4 -vframes 1 -update 1 media/poster.png   # frame 0 of t
 
 ## Appendix C — build the shelf index once
 
-The shelf pages at 200, the CLI cannot follow the cursor, and the slugs are the index — so pull the
-whole thing once through the REST route and grep the file instead of re-querying.
+> **This is the IDENTITY index, and it is the second of the two tools.** `meme-sweep.py` (in
+> *The diversity sweep*, above) is how you **cast** — it ranks the whole shelf by what the body does
+> and hands you a fresh pool in ten calls. This appendix builds the full local mirror you **grep**:
+> for a slug you half-remember, for the rights tier of a name, for the ledger joins in Rule 11, and
+> for working with no login or no embedding key. Sweep to choose a clip. Index to look one up.
+
+The shelf pages at 200, the CLI cannot follow the cursor, and the slugs are the index of identity —
+so pull the whole thing once through the REST route and grep the file instead of re-querying.
 
 ```python
 #!/usr/bin/env python3
 """meme-index.py — pull every MemeScreens raw into one greppable TSV.
 
-The `--query` filter on this endpoint is thin and inconsistent (a search for
-"hungry food eating" returns nothing on a shelf full of people eating), and the
-AI descriptions are blind to the meme's identity. So: pull it all, index by slug.
+Note this pages with `q` unset entirely: the `q` filter is a LEXICAL substring
+match that runs BEFORE ranking, so any query here would silently shrink the
+mirror. Semantic search is a different parameter (`vector_q`) and lives in
+meme-sweep.py. The AI descriptions are blind to the meme's identity, so this
+file is indexed by slug.
 
 Paging note: `vidfarm public-raws` has NO --cursor flag and the server caps a
 shelf at 200 per call, so the CLI alone can only ever show you the first 200 of
@@ -1406,7 +2159,7 @@ MOMENT: the 40 minutes between the craving and giving up on it
 | | |
 |---|---|
 | Frame | `When I …` — the complaint is embarrassing, so first person |
-| Verb cast for | *deflating; accepting a bad outcome* |
+| Verb cast for | `deflate` — shoulders drop, the bad outcome is accepted without a fight |
 | Caption | `when i've had 10 tabs open` / `since 7pm for one scallop roll` / `and we're getting pizza again` |
 | Clip (🟡) | `my-disappointment-is-immeasurable-and-my-day-is-ruined` · 1280×720 · plate `0x00FF00` digital · key 0.34 |
 | Clip (🟢) | `hangover-dog` · 2160×3840 · plate `0x00DA00` filmed · key **0.22** |
@@ -1425,9 +2178,39 @@ and the object (scallop roll) are the customer's own words, per Rule 6.
 > the company. **When a real brand name is what makes your caption feel sharp, that is the signal to
 > replace it, not to keep it.**
 
-**Three-way lock:** *standalone* — 10 tabs since 7pm ending in pizza is funny with no context;
-*problem space* — deleting that hour is the product's entire pitch; *enactment* — both clips hold a
-deadpan while something disappointing is already true.
+**The enactment declaration, as shipped** (back-filled onto both builds when the block became
+mandatory):
+
+```
+clip_slug:           my-disappointment-is-immeasurable-and-my-day-is-ruined
+caption_verb:        deflate
+clip_verb:           deflate
+feeling_size:        small          # one annoying evening
+clip_size:           large          # a day that is immeasurably ruined
+clip_reads_blind:    a man in a suit goes flat and accepts something without arguing
+caption_reads_blind: someone gives up on dinner after an hour and settles for pizza
+```
+
+**Read the two blind lines against each other.** They share no vocabulary at all — no "tabs", no
+"flat", nothing — and they are plainly one situation. That is what a correct pair looks like, and
+it is why `clip_read_is_independent` bans overlap instead of requiring it: the clip's world (a man
+in a suit) and the caption's world (dinner, tabs, pizza) are *supposed* to be different. The verb
+is the only thing they have in common, and the verb is the one thing that is declared rather than
+described.
+
+**Sizes:** `small` vs `large`. One annoying evening arriving in the body of a man whose day is
+immeasurably ruined. Same verb, wrong size — Rule 3.1 and 3.2 at once, and that gap is the laugh.
+
+**Rule 10, checked field by field:** nothing here needs the product (`10 tabs`, `7pm`, `scallop
+roll` are the niche's week), nothing needs a previous post, nothing needs the source meme — the
+caption never says "disappointment", "immeasurable" or "ruined", so `caption_does_not_borrow_lore`
+passes — and nothing needs to have been *you*: **who had to have been there?** Anyone who has ever
+tried to pick dinner.
+
+**Three-way lock:** *standalone* — 10 tabs since 7pm ending in pizza is funny with no context, no
+previous post and no knowledge of the meme; *problem space* — deleting that hour is the product's
+entire pitch; *enactment* — both blind reads name one situation, both clips hold a deadpan while
+something disappointing is already true.
 
 **The background is the joke's world, not the product's.** An empty restaurant at night is the place
 they never got to. Blurred so it reads as a set, dark so the plate and the keyed subject both pop.
@@ -1435,6 +2218,12 @@ they never got to. Blurred so it reads as a set, dark so the plate and the keyed
 **Gates:** `vidfarm qa` 18/18 · `meme-qa.py` **26/26** on both builds (block centre measured at
 **49.8%**). The 🟢 build needs `--silent-ok`, and fails without it — which is the check working.
 
+> Those two counts are **historical**, from the run that produced this file. Both gates have grown
+> since: gate 1 gained five `forbid_text` phrases and gate 2 gained the six Rule 3 / Rule 10
+> checks. The builds still pass — the declaration above is what was back-filled to make that true —
+> but do not treat `18/18` or `26/26` as the number you should see. **A check count is not a
+> measurement of anything; the verdict is.**
+
 **Naming the offer — both tiers, built and measured.**
 
 | | **v003 — tier 1** ✅ preferred | **v001 / v002 — tier 2** |
@@ -1486,14 +2275,23 @@ names the product. All of those pass `vidfarm qa` today.
 
 This checks the finished MP4 and the composition text together, and EXITS 1.
 
+It also reads the `<!-- meme-recaption: enactment -->` declaration out of the
+composition (Rule 3, Rule 10). It cannot judge whether the clip enacts the
+caption — nothing can — but it CAN require that the two-cover test was performed
+and that its answers do not contradict each other. That is a smaller claim than
+"the match is verified", and it is the one this script is entitled to make.
+
 usage: meme-qa.py <render.mp4> <composition.html> [--offer dishcover.io]
-                  [--pole pain|win] [--silent-ok] [--json]
+                  [--pole pain|win] [--silent-ok] [--flat-bg-ok] [--json]
 """
 import json, re, subprocess, sys
 import numpy as np
 
 render, comp = sys.argv[1], sys.argv[2]
 SILENT_OK = "--silent-ok" in sys.argv
+# Ladder tier 6 only: a flat brand plate really is the background. Everywhere
+# else a slab of one saturated colour is a plate that never got keyed.
+FLAT_BG_OK = "--flat-bg-ok" in sys.argv
 OFFER = (sys.argv[sys.argv.index("--offer") + 1].strip().lower()
          if "--offer" in sys.argv else None)
 # The pole changes what the payoff is allowed to do (Rule 2). Default to PAIN:
@@ -1509,6 +2307,55 @@ def check(name, ok, detail, fatal=True):
     results.append({"check": name, "ok": bool(ok), "detail": detail, "fatal": fatal})
 
 
+# --------------------------------------------- word tools for Rule 3 / Rule 10
+# These decide FATAL checks, so they are deliberately crude in the direction of
+# UNDER-firing. A gate that cries wolf on a correct build gets switched off
+# within a day, which is worse than not having it — see "Calibrate a checker
+# before you trust it". Concretely: a 4-letter floor (so `cat`, `dog`, `huh` in
+# a slug are ignored), a stemmer that is a suffix chop and misses give/giving,
+# and a stopword list that gives up any word that is also ordinary English.
+STOP = {
+    "that", "this", "with", "when", "what", "your", "have", "from", "they", "them",
+    "their", "there", "then", "than", "into", "just", "been", "being", "will",
+    "would", "could", "should", "about", "over", "under", "some", "more", "most",
+    "very", "really", "going", "gonna", "still", "again", "like", "know", "make",
+    "made", "take", "took", "look", "time", "times", "thing", "things", "something",
+    "someone", "anyone", "everyone", "nothing", "anything", "everything", "without",
+    "while", "after", "before", "because", "which", "where", "here", "does", "much",
+    "many", "other", "another", "same", "each", "every", "both", "since", "getting",
+    "gets", "went", "goes", "want", "wants", "need", "needs", "keep", "keeps",
+    "meme", "clip", "screen", "green", "video", "person", "people", "guy", "girl",
+}
+
+
+def stem_word(w):
+    """A suffix chop, not a linguist. Enough to tie accepts/accepting together.
+
+    NOT called `stem`: section 7b binds a local `stem = OFFER.split(".")[0]` for
+    the offer's name, and a helper called `stem` gets shadowed by it halfway down
+    the file. The first run of this section died exactly there.
+    """
+    for suf in ("ies", "ing", "ed", "es", "s"):
+        if w.endswith(suf) and len(w) - len(suf) >= 4:
+            return w[: -len(suf)] + ("y" if suf == "ies" else "")
+    return w
+
+
+def content(text):
+    """Stemmed content words of >=4 LETTERS. Apostrophes and digits are dropped
+    on purpose: `i've`, `we're`, `10` and `7pm` carry no comparison value, and
+    the numbers are the caption's best specifics precisely because they are
+    shared, not private."""
+    out = set()
+    for w in re.findall(r"[a-z]{4,}", text.lower()):
+        if w in STOP:
+            continue
+        s = stem_word(w)
+        if s not in STOP:
+            out.add(s)
+    return out
+
+
 def probe(path, vf, w, h, pre=(), post=("-vframes", "1")):
     # -ss/-sseof are INPUT options and go before -i; -vframes is an OUTPUT option
     # and goes after. Getting that backwards decodes nothing and reports no frame.
@@ -1543,7 +2390,21 @@ for label, fr in (("first", first), ("last", last)):
     check(f"{label}_frame_has_subject", band.std() > 12,
           f"lower-band stdev {band.std():.1f} (>12)")
 
-# ------------------------------------------------------ 3. no residual green key
+# -------------------------------------------- 3. the plate is GONE, in any hue
+# Two checks, because these are two different defects. `no_residual_green` is a
+# FRINGE test on the shelf's usual 00FF00 plate — a key that was slightly too
+# tight. `no_unkeyed_plate` is hue-agnostic and catches the bigger, dumber one:
+# the key never ran, or it ran on a blue/magenta plate the green test cannot see.
+#
+# Measured on four fixtures: an unkeyed 00FF00 plate fails both; a photographic
+# background passes no_unkeyed_plate at 15%; a flat brand plate fails it at 79%
+# and needs --flat-bg-ok; an unkeyed MAGENTA plate reads 0.00% green and is
+# caught ONLY by no_unkeyed_plate. That last row is the whole reason it exists.
+#
+# Watch the green check if the joke's world is a lawn, a forest or a pool table:
+# 0.5% is tight, and a genuinely green BACKGROUND can trip it. That is a false
+# positive, not a bad key — confirm by eye, then pick a different world rather
+# than loosening the number.
 mid = probe(render, "scale=270:480", 270, 480, pre=("-ss", str(dur / 2)))
 if mid is not None:
     a = mid[0]
@@ -1551,6 +2412,23 @@ if mid is not None:
     green = ((g - r > 45) & (g - b > 45) & (g > 80)).mean()
     check("no_residual_green", green < 0.005, f"{green*100:.2f}% green pixels (<0.5%)")
 
+    # A quarter of the frame in ONE saturated colour is a plate, not a
+    # background: a background is a photograph, and photographs vary. The
+    # caption plate is white or black, so it is not saturated and not counted.
+    # Ladder tier 6 (a flat brand plate as the background) is a legitimate
+    # exception and the only one — pass --flat-bg-ok, the same way --silent-ok
+    # works, so the exception is a decision somebody made rather than a default.
+    sat_px = (a.max(2) - a.min(2)) > 60
+    if sat_px.any():
+        q = a[sat_px] // 32                                  # 8^3 colour buckets
+        keys = q[:, 0] * 64 + q[:, 1] * 8 + q[:, 2]
+        biggest = float(np.bincount(keys).max()) / a[..., 0].size
+    else:
+        biggest = 0.0
+    check("no_unkeyed_plate", FLAT_BG_OK or biggest < 0.25,
+          f"largest flat saturated colour = {biggest*100:.0f}% of frame (<25%)"
+          + (" [--flat-bg-ok]" if FLAT_BG_OK else ""))
+
 # ------------------------------------- 4. caption block is horizontally CENTRED
 # Find the caption plate in frame 0 by its own darkness against the background,
 # then compare its horizontal centre to the canvas centre.
@@ -1647,7 +2525,7 @@ else:
               r"^my \w+ when\b", r"^why my\b",
               r"^[\w][\w'.\- ]{0,24} (when|with|after|watching|reading|seeing|hearing) ")
     check("caption_uses_a_frame", any(re.search(f, text_cap, re.I) for f in FRAMES),
-          f"must open with one of the seven frames — got {' '.join(words[:4])!r}")
+          f"must open with one of the eight frames — got {' '.join(words[:4])!r}")
     check("caption_is_lowercase_start", text_cap[:1].islower(),
           "meme captions are typed, not headlined", fatal=False)
     # the product must not be in the video (Rule 1), and it must not resolve (Rule 2)
@@ -1659,6 +2537,19 @@ else:
     # hand-broken lines are required — the renderer's own wrap lands mid-thought
     check("caption_lines_hand_broken", "<br" in cap.group(1),
           "use <br> at the clause; never let the renderer wrap a meme caption")
+    # Rule 10 — CONTEXT DEBT. Each of these asks the viewer for something they were
+    # never given: a previous post, the source meme's lore, or a shared secret. The
+    # platform serves this video cold to strangers, on purpose, so the debt is never
+    # repaid — it just quietly costs you everyone who is not already following you.
+    # "again" is deliberately NOT here: `and we're getting pizza again` is the
+    # collapse of the worked example, and it borrows nothing.
+    DEBT = ("iykyk", "if you know you know", "you know the one", "you already know",
+            "part 2", "part two", "part 3", "part three", "as promised",
+            "like i said", "as i said", "as mentioned", "see my last",
+            "from my last", "same as last time", "remember when i said")
+    dhit = [d for d in DEBT if d in text_cap.lower()]
+    check("caption_no_context_debt", not dhit,
+          f"context debt {dhit} — the viewer has no previous slide and no briefing (Rule 10)")
 
 # ------------------------------------------------- 7b. naming the offer
 # The offer IS named on the video. Two ways, in priority order:
@@ -1734,6 +2625,80 @@ if OFFER:
         check("handle_is_dimmed", bool(dim) and float(dim.group(1)) <= 0.85,
               f"handle alpha {dim.group(1) if dim else 'opaque'} (<=0.85)", fatal=False)
 
+# ------------------------------------- 7c. the enactment declaration (Rule 3)
+# The two-cover test is a human act, and no script will ever judge whether a clip
+# enacts a caption. What a script CAN do is refuse a build where the test was
+# never performed, or where its own answers contradict each other. So the answers
+# live in the composition as an HTML COMMENT — a comment and not a layer, because
+# a layer counts against max_text_cards and could render, and this must never
+# reach a pixel.
+VERBS = {"deflate", "blank", "loop", "smug", "overreact",
+         "correct", "unbothered", "celebrate", "stare", "wait"}
+FIELDS = ("clip_slug", "caption_verb", "clip_verb", "feeling_size", "clip_size",
+          "clip_reads_blind", "caption_reads_blind")
+
+decl_m = re.search(r"<!--\s*meme-recaption:\s*enactment\b(.*?)-->", html, re.S)
+decl = {}
+if decl_m:
+    for line in decl_m.group(1).splitlines():
+        kv = re.match(r"\s*([a-z_]+)\s*:\s*(.+?)\s*$", line)
+        if kv and kv.group(1) in FIELDS:
+            decl[kv.group(1)] = re.sub(r"\s*#.*$", "", kv.group(2)).strip()
+
+missing = [f for f in FIELDS if not decl.get(f)]
+short = [f for f in ("clip_reads_blind", "caption_reads_blind")
+         if len(decl.get(f, "").split()) < 5]
+same = (decl.get("clip_reads_blind", "x").lower() ==
+        decl.get("caption_reads_blind", "y").lower())
+check("enactment_declared",
+      bool(decl_m) and not missing and not short and not same,
+      ("no <!-- meme-recaption: enactment --> block — run the two covers and write them down"
+       if not decl_m else
+       f"missing {missing}" if missing else
+       f"{short} must be a real sentence (>=5 words)" if short else
+       "the two blind reads are the same sentence — you wrote one and pasted it twice"
+       if same else "7 fields, both reads written"))
+
+if decl_m and not missing:
+    cv, kv_ = decl["caption_verb"].lower(), decl["clip_verb"].lower()
+    # Rule 3.1. Two different tokens is a mismatch you declared out loud; a token
+    # outside the ten is a verb nobody can compare, which is the same as no verb.
+    check("enactment_verbs_match",
+          cv in VERBS and kv_ in VERBS and cv == kv_,
+          f"caption_verb={cv!r} clip_verb={kv_!r} — must be the SAME token from {sorted(VERBS)}")
+    # Rule 3.2. Two coarse buckets on purpose: a 1-5 scale invites a 3-vs-4 that
+    # means nothing, and the only question the format asks is binary — is the
+    # reaction the wrong size for the cause?
+    fs, cs = decl["feeling_size"].lower(), decl["clip_size"].lower()
+    check("intensity_mismatched",
+          {fs, cs} == {"small", "large"},
+          f"feeling_size={fs!r} clip_size={cs!r} — must be small/large and DIFFERENT "
+          f"(matched sizes are a re-enactment, not a joke)")
+    # Rule 3.3 + the read-order problem. If the only way you can describe the clip
+    # is with the caption's own nouns, either you never saw it cold (you projected
+    # the caption onto it) or the clip really does depict the caption's nouns,
+    # which is a re-enactment. A correct pair shares NO vocabulary — the clip's
+    # world and the caption's world are supposed to be different. This is why the
+    # check bans overlap instead of requiring it: an earlier draft required the two
+    # reads to share a word, and every correct build failed.
+    if cap:
+        bleed = sorted(content(decl["clip_reads_blind"]) & content(text_cap))
+        check("clip_read_is_independent", not bleed,
+              f"clip_reads_blind reuses the caption's words {bleed} — describe the clip, "
+              f"not your plan for it")
+    # Rule 10, context 3 — the source meme's own lore. A word that comes from the
+    # meme's NAME comes from the meme's fandom, not from the audience's week, and
+    # it caps reach at people who recognise the clip. It also catches the literal
+    # case, where the caption names what the clip already is.
+    if cap:
+        offer_stem = OFFER.split(".")[0].lower() if OFFER else ""
+        slug_words = content(decl["clip_slug"].replace("-", " ").replace("_", " "))
+        slug_words.discard(stem_word(offer_stem))
+        lore = sorted(slug_words & content(text_cap))
+        check("caption_does_not_borrow_lore", not lore,
+              f"caption reuses slug words {lore} — the clip is borrowed equipment, "
+              f"not a shared reference (Rule 10)")
+
 # --------------------------------------------- 8. one shot, no brand chrome
 check("single_shot", len(re.findall(r"<video\b", html)) == 1,
       f"{len(re.findall(r'<video', html))} video layer(s) — a meme recaption is ONE shot")