super-ux 0.56.2 → 0.57.0

package/CHANGELOG.md

@@ -1,3 +1,73 @@
+## 0.57.0 — short video gets a playbook, a hook filter and a caption linter
+
+`copywriting` covered posts for X, Reddit and LinkedIn and nothing that moves:
+no Reels, Shorts or TikTok physics, no hook, no script, no caption rules, and
+an X playbook asserting two ranking rules the open ranker does not contain.
+This release fills that from the family's 2026-10-07 research, every rule with
+its source and the date it was read.
+
+- **Three new references, linked from `copywriting`.** `video-script.md`: the
+  angle in one sentence, the modular hook, body and ask, six organic and ten
+  ad structures, words per second for English, the shot list, gates G2–G4,
+  reading the retention chart. **Russian timing is measured by reading aloud,
+  and the file carries no coefficient**: the research proposed one as its
+  author's assumption, and a table would have made it a rule nobody re-measures.
+  `hooks.md`: the mechanics (frame 0, text by about 0.5 s, works muted, the body
+  pays), the triple (frame 0, on-screen text of ten words or fewer, first line),
+  a taxonomy, 26 formulas and 40 templates, each template with its source.
+  `research-outliers.md`: views ÷ the account's median, 3× a signal, under 1.5×
+  noise, a sample within 10× of your size, with a worked example.
+- **`channel-playbooks.md`.** New `Instagram` (the 125-character feed window,
+  five hashtags since 2025-12-18, links that do not click, one ask, sends as
+  the signal for non-followers) and `Short video` (platform signals, originality,
+  AI labelling, safe zones, length, pace, the loop, trial reels). **X is re-read
+  against `xai-org/x-algorithm@e62790c`**: the published weights (share via
+  copy link 20, reply, quote and share via DM 5, a reply from a mutual follow
+  +15, follow 4, like 0.5, report −234, mute −58.8) and the 48-hour window are
+  in; "bookmarks weigh heavily" and "more than two hashtags is penalised" are
+  out, because neither is in the ranker; link suppression stays as practice,
+  marked unverified. The seeded `channels.md` X record no longer carries them.
+- **Four new codes, 42 → 46.** `B044` filters short-video hooks: five checks,
+  0.6 × mean + 0.4 × minimum, −15 per dealbreaker, and on-screen text over ten
+  words. It is a filter, not a predictor, and its row says so in numbers (AUC
+  0.83 at catching a bad hook, 0.56 at picking a winner); a hook in Cyrillic is
+  not scored against English vocabulary. `B045` and `B046` read two new
+  physics tokens, `fold N` and `one ask`. `B066` is the new marker AT-16:
+  invisible and look-alike-space characters, eighteen named classes plus any
+  other format character, seven numbered exemptions with a fixture each, and
+  it never examines a dash or a quotation mark. `B030` now reads the `hook` and
+  `on-screen` fields as public copy. `B042`'s message no longer assumes every
+  surface's reason is reach.
+- **New surfaces:** `Instagram`, `TikTok`, `YouTube Shorts` and `short video`.
+- **A gate for the shelf itself.** `validate_short_video_shelf` counts HF-01..26
+  and HT-01..40, refuses a template without a source URL, a short-video or
+  Instagram rule without one, the two removed X claims coming back, and
+  recomputes every multiple and reading in the outlier example. Each was
+  watched failing on a planted defect.
+- Because `channel-playbooks.md` links the three new files, the closure ships
+  them inside `brand-voice` (13) and `ux-audit` (24) as well; their reference
+  sentences were recounted from the tree.
+- Provenance: the 26 formula names, the scoring arithmetic, the dealbreakers,
+  the caption mechanics, the outlier method and the eighteen character classes
+  come from `Jakeschincariol/instagram-agent-skill` at `d03c56b` (MIT); shapes,
+  examples, word lists and code are rewritten and no text is reproduced.
+
+## 0.56.3 — check the heading the reader sees
+
+The no-title-period rule already existed, but its linter read Markdown headings
+only and let multi-sentence titles escape. It now reads HTML headings, inline
+markup and line-break fragments, with source-line evidence. HTML registry checks
+read visible text rather than attribute fragments. Paragraph punctuation,
+questions, abbreviations, versions and URLs keep their meaning.
+
+- `--fail-on B063` makes selected warnings block without promoting unrelated
+  advice; default warning behavior and JSON output remain compatible.
+- `B009` blocks unmatched declared source globs. Brace patterns advertised by
+  the contract now expand; seed projects must replace placeholder sources.
+- Copywriting now verifies rendered roles, generators, actual linter paths and
+  gate coverage. The contract no longer describes advisory B060 as an error.
+- Regression receipts and scope limits: [DC-01](docs/evidence/audits/2026-10-01-display-copy/report.md).
+
 ## 0.56.2 — the closure says it is a closure
 
 Hygiene from the 2026-09-13 family audit (HK-11). Five skills ship more contracts than

package/README.md

@@ -157,11 +157,12 @@ Commands: `/brand` (status → one recommended action), `/brand-init`,
 python3 docs/brand/lint.py
 ```
 
-41 deterministic checks (`B001`..`B073`): banned words, one action under two names, a figure
+46 deterministic checks (`B001`..`B073`): banned words, one action under two names, a figure
 with no sourced fact, a field over its limit with the locale coefficient
 applied, blocked AI crawlers, keyword stuffing, humor on a billing screen,
 a rhetorical dash, a title that ends in a full stop, a locale that lags
-without saying so. Exit 0 clean **or warnings only**, 1 warnings under `--strict`, 2 any error. That is the policy `docs/ux/lint.py` has always had, and one pack cannot hold two opposite meanings for a warning: this linter returned 1 on warnings alone until 2026-08-20, so 13 of its 39 codes turned a build red while printing `0 error(s), 1 warning(s)`.
+without saying so, a short-video hook the filter calls weak, a caption that
+spends the feed window or asks twice, an invisible character pasted in. Exit 0 clean **or warnings only**, 1 warnings under `--strict`, 2 any error. That is the policy `docs/ux/lint.py` has always had, and one pack cannot hold two opposite meanings for a warning: this linter returned 1 on warnings alone until 2026-08-20, so 13 of its 39 codes turned a build red while printing `0 error(s), 1 warning(s)`.
 
 Clean means *checkable*, not *good*: tone drift, unproven claims and a voice
 that has overshot its own failure mode are judged by `/ux-audit copy`.
@@ -243,7 +244,7 @@ to is a skill nobody runs.
 | skill `ux-scenarios` | `docs/ux/scenarios.md`: use-case scenarios (action → observable response, alt and error paths) covering every flow node and edge, `Traces:` to stories and flows, validated for conflicts, coverage and traceability |
 | skill `ux-audit` | Batched audit with full context: code vs every scenario plus its story's acceptance criteria; verdicts PASS / PARTIAL / FAIL / BLOCKED with `file:line` evidence; depths `quick` / `standard` / `deep`; a `coverage` scope that audits the chain itself |
 | skill `brand-voice` | `docs/brand/`: the pack and its five axes, the words the product owns and bans, canonical facts, the per-surface register, locales, plus six shipped voice packs, each declaring the degeneration it collapses into when overdone |
-| skill `copywriting` | Writes in that voice and never writes *to* it: interface strings, errors, empty states, landing and pricing pages, posts, changelogs, store listings, ads, lifecycle email. A missing term or an unsourced number is reported, never invented |
+| skill `copywriting` | Writes in that voice and never writes *to* it: interface strings, errors, empty states, landing and pricing pages, posts and captions, short-video scripts and hooks, changelogs, store listings, ads, lifecycle email. A missing term or an unsourced number is reported, never invented |
 | `/ux` | **The one command**: sets up whatever is missing, reports status across every layer, then offers only the applicable actions with one marked recommended. Idempotent |
 | `/vision` `/ux-init` `/ux-foundation` `/ux-flows` `/ux-update` `/ux-audit` `/ux-rule` `/ux-lint` `/ux-doctor` · `/brand` `/brand-init` `/brand-update` `/brand-lint` `/copy` | Direct controls for when you know exactly what you want; `/ux-rule` installs both hard rules and seeds `lint.py` + `doctor.py`; `/brand-init` seeds `docs/brand/` and its linter |
 | `docs/ux/lint.py` + `/ux-lint` | The deterministic half: missing Figma frames, unresolved SCR/story traces, orphans, built screens without coverage, index desync, ID gaps, broken links. Stdlib-only, exit 1 on problems, so wire it into CI and drift can't merge |

package/cursor/rules/copywriting.mdc

@@ -1,5 +1,5 @@
 ---
-description: "Write or rewrite any text a user reads (interface strings, errors, empty states, landing and pricing pages, posts, changelogs, store listings, ads, email): apply when asked to write copy, rewrite a headline or CTA, fix microcopy, or when a draft reads machine-made"
+description: "Write or rewrite any text a user reads (interface strings, errors, empty states, landing and pricing pages, posts and captions, short-video scripts and hooks, changelogs, store listings, ads, email): apply when asked to write copy, rewrite a headline or CTA, fix microcopy, or when a draft reads machine-made"
 alwaysApply: false
 ---
 
@@ -16,12 +16,18 @@ Read the pack: `docs/brand/voice.md`, `terminology.md`, and the
 `/brand-init`.** Guessing the voice and being wrong costs more than the
 pause.
 
-**Never write to `docs/brand/`.** A term missing from the dictionary, or a
-number with no row in `facts.md`, is **reported** — never invented to finish
-the sentence. Adding it is `brand-voice`'s decision, not this pass's.
+Ownership is by file: `brand-voice` owns voice, terms, facts, channels and
+locale policy. Missing terms or facts are reported, never invented. This pass
+owns product text and `strings.md` rows (`Status: proposed`); claim coordinated
+files before editing. A file living in `docs/brand/` does not forbid the edit.
 
 ## Rules that hold in every voice
 
+- **No decorative full stop in headings or labels**, even when inline markup
+  or line breaks split the title. “Your agents. Your tools.” is still a title.
+  Keep questions, ellipses, abbreviations, versions, URLs and paragraph punctuation.
+  Apply a project's explicit hero/caption policy to those additional roles.
+
 - **Every figure comes from `facts.md`.** No sourced fact, no number. Never
   fabricate a statistic, a quote, or an expert.
 - **One action keeps one name** across button, confirmation, toast, history,
@@ -48,6 +54,17 @@ effortless / unlock / elevate / robust", em-dash cadence in every paragraph,
 "it's not just X, it's Y", hedges stacked two deep, and a closing sentence
 that summarizes what was just said.
 
+## Short video
+
+A hook is three things at once, about one thing: frame 0, on-screen text of
+ten words or fewer, and the first spoken line. The body pays the promise
+before the middle. Write the angle first ("for [persona], who wants
+[desire], we show [proof]"), time the script by reading it aloud (never
+convert a word count into another language), and give every figure in the
+hook its `facts.md` row. `B044` filters weak hooks; it is a filter, never a
+predictor of which hook wins. A caption fits the feed window and makes one
+ask (`B045`, `B046`).
+
 ## Localization
 
 A locale is not a translation of the English: the length coefficient, the
@@ -56,10 +73,15 @@ lags the primary says so rather than pretending to be current.
 
 ## Check
 
-```bash
-python3 docs/brand/lint.py
-```
+Resolve the actual linter: use `docs/brand/lint.py` if present, otherwise locate
+`brand_lint.py` in the installed super-ux scripts directory and pass the project's
+brand directory. If neither exists, state the missing tool and manual coverage.
+Confirm Sources patterns match the touched files and copy projections retain
+heading roles. Inspect rendered output and generators; static checks cannot
+resolve external CSS or runtime text.
 
-Exit 0 clean **or warnings only**, 1 warnings under `--strict`, 2 any error. That is the policy `docs/ux/lint.py` has always had, and one pack cannot hold two opposite meanings for a warning: this linter returned 1 on warnings alone until 2026-08-20, so 13 of its 39 codes turned a build red while printing `0 error(s), 1 warning(s)`. Clean means *checkable*, not *good* —
-tone drift, unproven claims and a voice that overshot its declared failure
-mode are judged by `/ux-audit copy`.
+Run the resolved script with `--fail-on B063` when title punctuation must block.
+An older script rejecting the flag needs updating, not a retry that drops the gate.
+Exit 0 means clean or advisory warnings; selected warnings exit 1; errors exit 2.
+`--strict` selects every warning. Report actual surfaces, warnings and command.
+Tone, grounding and voice still require `/ux-audit copy`.

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "super-ux",
-  "version": "0.56.2",
+  "version": "0.57.0",
   "scripts": {
-    "test": "python3 test/validate.py && python3 test/brand_lint_test.py && python3 test/ux_lint_test.py && python3 docs/ux/lint.py && python3 docs/brand/lint.py && node test/installer_test.js && npm run test:audit",
+    "test": "python3 test/validate.py && python3 test/brand_lint_test.py && python3 test/display_copy_test.py && python3 test/ux_lint_test.py && python3 docs/ux/lint.py && python3 docs/brand/lint.py && node test/installer_test.js && npm run test:audit",
     "test:audit": "for t in test/audit_regressions/*.py; do python3 \"$t\" || exit 1; done"
   },
   "description": "Scenario-driven UI development for AI agents (Claude Code, Cursor, 70+ agents): a versioned design chain in docs/ux/, a scenario-first hard rule, a deterministic drift linter, and evidence-backed UX audits. This package is the installer CLI.",

package/plugins/super-ux/scripts/brand_lint.py

@@ -20,7 +20,10 @@ Read-only by default. `--fix` applies only the changes that cannot be wrong.
     python3 brand_lint.py [path] --json    # machine-readable findings
     python3 brand_lint.py [path] --strict  # warnings block too
 
-Exit codes: 0 clean or warnings only, 1 warnings under `--strict`, 2 any error.
+    python3 brand_lint.py [path] --fail-on B063  # selected warnings block
+
+Exit codes: 0 clean or advisory warnings, 1 selected warnings (`--strict` or
+`--fail-on`), 2 any error. JSON remains an array of findings.
 
 One pack, one policy: `ux_lint.py` has always blocked on errors and needed
 `--strict` before a warning could fail a build, and this file returned 1 for
@@ -36,6 +39,8 @@ import argparse
 import json
 import re
 import sys
+from html import unescape
+from html.parser import HTMLParser
 from collections import namedtuple
 from pathlib import Path
 
@@ -76,6 +81,7 @@ STRING_KINDS = ("copy", "layout")
 
 SEVERITY_ERROR = "error"
 SEVERITY_WARN = "warn"
+WARNING_CODES = set("B003 B005 B007 B022 B025 B026 B031 B043 B044 B045 B046 B051 B053 B054 B060 B063 B064 B066 B071 B072".split())
 
 Finding = namedtuple("Finding", "code severity path line message")
 
@@ -240,7 +246,7 @@ def load_sources(brand_dir: Path) -> dict[str, list[str]]:
     The linter cannot guess where a project keeps its text, and guessing
     wrong produces the worst possible output: a clean report about a surface
     that was never read. So an absent block is a finding (B006) and an
-    absent key means its checks are skipped and counted as skipped.
+    absent key means its checks are not run (not a passed coverage verdict).
     """
     text = read(brand_dir / "README.md") or ""
     block = re.search(r"^Sources:\s*$(.*?)(?=^\S|\Z)", text, re.M | re.S)
@@ -248,7 +254,7 @@ def load_sources(brand_dir: Path) -> dict[str, list[str]]:
         return {}
     sources: dict[str, list[str]] = {}
     for line in block.group(1).splitlines():
-        entry = re.match(r"^\s+(\w+):\s*(.+?)\s*$", line)
+        entry = re.match(r"^\s+(\w+):\s*(.*?)\s*$", line)
         if not entry:
             continue
         key, value = entry.group(1), entry.group(2)
@@ -714,7 +720,7 @@ def check_consistency(brand_dir: Path, sources: dict) -> list[Finding]:
         text = row["text"].rstrip()
         if not text.endswith(".") or text.endswith("..") or text.endswith("…"):
             continue
-        if ". " in text:      # genuinely several sentences -- a different defect
+        if not title_full_stop(text):
             continue
         findings.append(Finding(
             "B026", SEVERITY_WARN, "strings.md", 0,
@@ -734,11 +740,13 @@ def check_consistency(brand_dir: Path, sources: dict) -> list[Finding]:
             continue
 
         body = read(target) or ""
-        literals = [
+        html = html_copy(body) if target.suffix.lower() in HTML_SUFFIXES else None
+        source_copy = " ".join(html.blocks) if html is not None else body
+        literals = html.interface_texts if html is not None else [
             lit for lit in code_literals(_strip_comments(body, target.suffix))
             if _looks_like_copy(lit)
         ]
-        if literals:
+        if literals or html is not None:
             # The registry records what a reader sees, so the built page is the
             # authority whenever there is one. Source is the fallback and stays
             # byte-exact for projects that do not build.
@@ -760,9 +768,9 @@ def check_consistency(brand_dir: Path, sources: dict) -> list[Finding]:
             # would then refuse, which is a check with no passing answer. It
             # compares the same wording across a newline the reader never sees,
             # which is exactly what the rendered-page branch above already does.
-            elif row["text"] not in body \
-                    and row["text"].strip() not in body \
-                    and normalise(row["text"]) not in normalise(body):
+            elif row["text"] not in source_copy \
+                    and row["text"].strip() not in source_copy \
+                    and normalise(row["text"]) not in normalise(source_copy):
                 findings.append(Finding(
                     "B021", SEVERITY_ERROR, location, 0,
                     f"`{row['key']}` is \"{row['text']}\" in the registry, "
@@ -889,6 +897,157 @@ CODE_SUFFIXES = {
     ".py", ".go", ".rb", ".rs", ".java", ".kt", ".swift", ".php",
 }
 
+HTML_SUFFIXES = {".html", ".htm"}
+
+
+class HTMLCopy(HTMLParser):
+    """Static visible text and heading fragments, never attribute values.
+
+    Inline CSS/hidden/template exclusions are knowable from this source. External
+    CSS, scripts and responsive visibility still need a browser review.
+    aria-hidden is deliberately not excluded: it does not hide visual text.
+    """
+    VOID = {"area", "base", "br", "col", "embed", "hr", "img", "input",
+            "link", "meta", "param", "source", "track", "wbr"}
+    BLOCK = {"p", "div", "section", "article", "main", "li", "ul", "ol",
+             "header", "footer", "nav", "button", "figcaption", "td", "tr"}
+    OMIT = {"script", "style", "template", "noscript", "head"}
+    PHRASING = {"p", "h1", "h2", "h3", "h4", "h5", "h6", "blockquote",
+                "li", "dt", "dd", "td", "th", "figcaption", "label", "summary"}
+    CONTROLS = {"a", "button", "label", "legend", "summary", "option"}
+    INTERFACE_ROLES = {"button", "link", "menuitem", "tab", "option", "checkbox",
+                       "radio", "switch", "alert", "status"}
+
+    def __init__(self):
+        super().__init__(convert_charrefs=True)
+        self.stack = []
+        self.parts = []
+        self.headings = []
+        self.heading = None
+        self.last_anchor_end = None
+        self.controls = []
+        self.interface_texts = []
+
+    @property
+    def blocked(self):
+        return bool(self.stack and self.stack[-1][1])
+
+    def handle_starttag(self, tag, attrs):
+        attrs = dict(attrs)
+        hidden = self.blocked or tag in self.OMIT or "hidden" in attrs or bool(
+            re.search(r"(?:^|;)\s*(?:display\s*:\s*none|visibility\s*:\s*hidden)\s*(?:!important\s*)?(?:;|$)",
+                      attrs.get("style", ""), re.I))
+        if not hidden:
+            if tag in self.CONTROLS or attrs.get("role", "").lower() in self.INTERFACE_ROLES:
+                self.controls.append((tag, len(self.stack), []))
+            if tag == "br" or tag in self.BLOCK or re.fullmatch(r"h[1-6]", tag):
+                for control in self.controls:
+                    control[2].append(" ")
+            # Adjacent navigation/CTA anchors are separate labels, even when
+            # minified HTML has no intervening whitespace. A link within prose
+            # stays inline; turning every <a> into a block splits sentences.
+            if tag == "a" and self.last_anchor_end is not None \
+                    and not any(parent[0] in self.PHRASING for parent in self.stack) \
+                    and not any(part.strip() for part in self.parts[self.last_anchor_end:]):
+                self.parts.append("\n")
+            if re.fullmatch(r"h[1-6]", tag):
+                self.parts.append("\n")
+                self.heading = (tag, self.getpos()[0], [])
+            elif tag in self.BLOCK:
+                self.parts.append("\n")
+            elif tag == "br":
+                self.parts.append("\n")
+                if self.heading:
+                    self.heading[2].append("\n")
+        if tag not in self.VOID:
+            self.stack.append((tag, hidden))
+
+    def handle_startendtag(self, tag, attrs):
+        self.handle_starttag(tag, attrs)
+        if tag not in self.VOID:
+            self.handle_endtag(tag)
+
+    def handle_endtag(self, tag):
+        if not self.blocked and (tag in self.BLOCK or re.fullmatch(r"h[1-6]", tag)):
+            for control in self.controls:
+                control[2].append(" ")
+        # Registry candidates are interface controls/messages, not every
+        # marketing paragraph on a page that contains one registered action.
+        for control in list(self.controls):
+            if control[0] == tag and control[1] == len(self.stack) - 1:
+                text = " ".join("".join(control[2]).split())
+                if text:
+                    self.interface_texts.append(text)
+                self.controls.remove(control)
+        if tag == "a" and not self.blocked:
+            self.last_anchor_end = len(self.parts)
+        if self.heading and tag == self.heading[0]:
+            _, line, parts = self.heading
+            for fragment in "".join(parts).split("\n"):
+                text = " ".join(fragment.split())
+                if text:
+                    self.headings.append((line, text))
+            self.heading = None
+        if not self.blocked and (tag in self.BLOCK or re.fullmatch(r"h[1-6]", tag)):
+            self.parts.append("\n")
+        for index in range(len(self.stack) - 1, -1, -1):
+            if self.stack[index][0] == tag:
+                del self.stack[index:]
+                break
+
+    def handle_data(self, data):
+        if not self.blocked:
+            self.parts.append(re.sub(r"\s+", " ", data))
+            for control in self.controls:
+                control[2].append(data)
+            if self.heading:
+                # Source wrapping does not create a displayed line break.
+                self.heading[2].append(re.sub(r"\s+", " ", data))
+
+    @property
+    def blocks(self):
+        return [" ".join(line.split()) for line in "".join(self.parts).split("\n")
+                if line.strip()]
+
+
+def html_copy(text: str) -> HTMLCopy:
+    parser = HTMLCopy()
+    parser.feed(text)
+    parser.close()
+    return parser
+
+
+def source_paths(root: Path, pattern: str) -> list[Path]:
+    """Expand comma braces advertised by the brand contract, then glob."""
+    brace = re.search(r"\{([^{}]+)\}", pattern)
+    if brace and "," in brace.group(1):
+        return sorted({path for choice in brace.group(1).split(",")
+                       for path in source_paths(root, pattern[:brace.start()] + choice
+                                                + pattern[brace.end():])})
+    return sorted(path for path in root.glob(pattern) if path.is_file())
+
+
+def check_source_coverage(brand_dir: Path, sources: dict) -> list[Finding]:
+    root = brand_dir.parent.parent
+    findings = []
+    for key, patterns in sources.items():
+        if key == "robots":  # Missing robots is handled by the crawler policy.
+            continue
+        for pattern in patterns or [""]:
+            if not pattern:
+                findings.append(Finding(
+                    "B009", SEVERITY_ERROR, "README.md", 0,
+                    f"Sources {key}: no pattern declared; configure the source or remove its key",
+                ))
+                continue
+            if not source_paths(root, pattern):
+                findings.append(Finding(
+                    "B009", SEVERITY_ERROR, "README.md", 0,
+                    f"Sources {key}: `{pattern}` matches no files; correct the "
+                    "path or remove the source declaration. No copy was scanned",
+                ))
+    return findings
+
 # `${...}` in a template literal is a value, not a word.
 #
 # Replaced by a space rather than dropped, so `founder of ${n} products` does not
@@ -974,12 +1133,16 @@ def documents(brand_dir: Path, sources: dict, key: str) -> list[tuple]:
     """(relative path, front matter, body) for one declared source key."""
     root = brand_dir.parent.parent
     out = []
+    seen = set()
     for pattern in sources.get(key, []):
-        for path in sorted(root.glob(pattern)):
-            if not path.is_file():
+        for path in source_paths(root, pattern):
+            if path in seen:
                 continue
+            seen.add(path)
             fields, body = _front_matter(read(path) or "")
-            if path.suffix in CODE_SUFFIXES:
+            if path.suffix.lower() in HTML_SUFFIXES:
+                body = "\n\n".join(html_copy(body).blocks)
+            elif path.suffix in CODE_SUFFIXES:
                 body = _copy_in_code(body, path.suffix)
             out.append((path.relative_to(root).as_posix(), fields, body))
     return out
@@ -1206,7 +1369,13 @@ def check_facts(brand_dir: Path, sources: dict) -> list[Finding]:
                 f"`{row['fact']}` was due for review on {row['review']}",
             ))
 
-    for path, _fields, body in documents(brand_dir, sources, "marketing"):
+    for path, fields, body in documents(brand_dir, sources, "marketing"):
+        # A short-video hook is the first public sentence anyone hears, so its
+        # figure needs a row exactly as a body figure does (video-script.md).
+        spoken = [v for k, v in fields.items()
+                  if HOOK_FIELD_RE.match(k) or re.match(r"^on-screen(?:-\d+)?$", k)]
+        if spoken:
+            body = body + "\n\n" + "\n\n".join(spoken)
         for m in NUMBER_RE.finditer(body):
             number = m.group(0)
             digits = re.sub(r"\s+", "", number)
@@ -1298,9 +1467,23 @@ def check_channels(brand_dir: Path, sources: dict) -> list[Finding]:
             if "link in body" in physics and re.search(r"https?://", body):
                 findings.append(Finding(
                     "B042", SEVERITY_ERROR, path, 0,
-                    "link in the post body -- this surface suppresses reach "
-                    "for it; the convention is the first reply",
+                    "link in the post body, which this surface's physics "
+                    "forbid -- it suppresses reach or does not click there; "
+                    "put it where channels.md says (first reply, bio, DM)",
                 ))
+            fold = re.search(r"fold (\d+)", physics)
+            if fold:
+                findings.extend(_feed_window(path, body, int(fold.group(1))))
+            if "one ask" in physics:
+                asks = caption_asks(body)
+                if len(asks) != 1:
+                    findings.append(Finding(
+                        "B046", SEVERITY_WARN, path, 0,
+                        (f"{len(asks)} asks ({', '.join(asks)}) -- two asks "
+                         f"split one reader's single action" if asks else
+                         "no ask -- decide what this post is for and ask for "
+                         "that one thing"),
+                    ))
             cap = re.search(r"max (\d+) hashtags", physics)
             if cap:
                 used = re.findall(r"(?<!\w)#\w+", body)
@@ -1317,6 +1500,236 @@ def check_channels(brand_dir: Path, sources: dict) -> list[Finding]:
     return findings
 
 
+# B045 -- the feed window. Instagram shows roughly the first 125 characters of
+# a caption before "... more", so the first line either fits the window or is
+# cut mid-thought, and a tag or a mention spent there is a hook not written.
+# The window size is declared per surface (`fold N`) because it is platform
+# physics that moves, and the number belongs in channels.md, not in this file.
+# Method: `skills/ig-caption/caption.py` in Jakeschincariol/instagram-agent-skill
+# @d03c56b (MIT), re-implemented here; see channel-playbooks.md#instagram.
+HASHTAG_TOKEN_RE = re.compile(r"(?<![\w&])#\w+")
+
+
+def _feed_window(path: str, body: str, fold: int) -> list[Finding]:
+    text = body.strip()
+    if not text:
+        return []
+    first = text.splitlines()[0].strip()
+    window = text[:fold]
+    reasons = []
+    if first[:1] in ("#", "@"):
+        reasons.append(f"it opens with `{first.split()[0]}`")
+    if HASHTAG_TOKEN_RE.search(window) and first[:1] != "#":
+        reasons.append("a hashtag sits inside the window")
+    if len(first) > fold:
+        reasons.append(f"the first line is {len(first)} characters and the "
+                       f"feed cuts it at {fold}")
+    if not reasons:
+        return []
+    shown = window.split("\n")[0] if len(first) > fold else first
+    return [Finding(
+        "B045", SEVERITY_WARN, path, 0,
+        f"the feed window ({fold} characters before \"... more\"): "
+        f"{'; '.join(reasons)}. The feed shows: \"{shown[:fold]}\"",
+    )]
+
+
+# B046 -- one ask per post. Patterns are the asks a caption actually makes;
+# a question mark alone is not an ask, because most captions ask nothing by
+# asking a rhetorical question. English after caption.py's eight (re-written),
+# Russian as their direct equivalents.
+CAPTION_ASKS = (
+    (re.compile(r"(?i)\bcomment (?:the word )?[\"']?[A-Z0-9]{2,}\b"), "comment a keyword"),
+    (re.compile(r"(?i)\b(?:dm|message) (?:me|us)\b"), "DM"),
+    (re.compile(r"(?i)\bsave (?:this|it)\b"), "save this"),
+    (re.compile(r"(?i)\b(?:share|send) (?:this|it)\b"), "share this"),
+    (re.compile(r"(?i)\bfollow (?:me|us|for)\b"), "follow"),
+    (re.compile(r"(?i)\blink in (?:my |our |the )?bio\b"), "link in bio"),
+    (re.compile(r"(?i)\b(?:swipe|tap) (?:through|left|right|for|to)\b"), "swipe or tap"),
+    (re.compile(r"(?i)\btell me\b|\bwhat would you\b|\bwhich one\b"), "answer a question"),
+    (re.compile(r"(?i)напиши(?:те)? в комментари|коммент(?:арий)? [А-ЯЁA-Z0-9]{2,}"), "comment a keyword"),
+    (re.compile(r"(?i)напиши(?:те)? (?:мне|нам) в (?:директ|личку|лс)"), "DM"),
+    (re.compile(r"(?i)\bсохрани(?:те)?\b"), "save this"),
+    (re.compile(r"(?i)\b(?:отправь|отправьте|перешли|перешлите)\b"), "share this"),
+    (re.compile(r"(?i)\bподпиши(?:сь|тесь)\b"), "follow"),
+    (re.compile(r"(?i)ссылк[аиу] в (?:профиле|шапке|био)"), "link in bio"),
+)
+
+
+def caption_asks(body: str) -> list[str]:
+    """The asks a caption makes, one entry per distinct kind."""
+    return [name for pattern, name in CAPTION_ASKS if pattern.search(body)]
+
+
+# B044 -- the hook filter. A FILTER, never a predictor, and the reference says
+# so in numbers: on its author's corpus of 74 real short-form hooks the method
+# separates written-to-be-bad hooks from real ones at AUC 0.83 and a creator's
+# hits from the same creator's misses at AUC 0.56, where 0.50 is a coin. So
+# B044 warns on what it catches well (greetings, preambles, a line with
+# nothing concrete or nothing at stake) and never ranks two decent hooks.
+#
+# Method and arithmetic: `skills/ig-reel/hookscore.py` in
+# Jakeschincariol/instagram-agent-skill @d03c56b (MIT) -- five checks 0..100,
+# overall = 0.6 * mean + 0.4 * min - 15 per dealbreaker, STRONG at >= 70 with
+# no check under 55 and no dealbreaker, WEAK under 50. The vocabularies below
+# are this file's own and shorter, so a score can differ by a few points from
+# the original's. They are English, so a hook in another script is not scored
+# at all; only the two script-independent dealbreakers apply to it.
+HOOK_WORD_RE = re.compile(r"[A-Za-z0-9$%'’-]+")
+HOOK_FIGURE_RE = re.compile(
+    r"[$€£]\s?\d[\d,]*(?:\.\d+)?"
+    r"|\b\d[\d,]*(?:\.\d+)?\s?(?:%|k\b|x\b|hours?\b|hrs?\b|minutes?\b|mins?\b"
+    r"|days?\b|weeks?\b|months?\b|years?\b)?",
+    re.I,
+)
+HOOK_PROPER_RE = re.compile(r"(?<!^)\b[A-Z][a-z]{2,}\b")
+HOOK_SPOKEN_FIGURES = {
+    "zero", "two", "three", "four", "five", "six", "seven", "eight", "nine",
+    "ten", "twelve", "twenty", "thirty", "fifty", "hundred", "thousand",
+    "million", "billion", "dozen", "half", "twice", "triple",
+    "dollars", "dollar", "bucks", "grand", "percent", "revenue", "salary",
+    "profit", "rent",
+}
+HOOK_STAKES = {
+    "stop", "never", "wrong", "mistake", "mistakes", "lose", "lost", "losing",
+    "cost", "costs", "broke", "failed", "fail", "nobody", "no", "not", "don't",
+    "can't", "won't", "didn't", "quit", "fired", "deleted", "killed",
+    "replaced", "cut", "free", "paid", "saved", "banned", "worst", "hate",
+    "wasted", "waste", "scam", "lied", "truth", "secret", "hidden", "before",
+    "until", "instead", "but", "unless", "problem", "risk", "warning",
+    "regret", "only", "without", "versus", "vs", "actually", "forgot",
+}
+HOOK_WEAK_OPENERS = (
+    "so", "ok", "okay", "hey", "hi", "hello", "guys", "welcome", "today",
+    "basically", "honestly", "just", "let's", "lets", "um", "i wanted",
+    "i want", "have you", "do you", "did you", "are you", "in this",
+    "in today", "this is", "there is", "there are", "it is", "you know",
+)
+HOOK_IMPERATIVES = {
+    "stop", "steal", "copy", "delete", "try", "watch", "read", "save", "use",
+    "build", "make", "write", "send", "start", "quit", "never", "always",
+    "don't", "check", "cancel",
+}
+HOOK_EMOJI_RE = re.compile("[\U0001F300-\U0001FAFF☀-➿]")
+HOOK_DEALBREAKERS = (
+    ("stop-scrolling", re.compile(r"(?i)^\s*(?:stop scrolling|don'?t scroll)")),
+    ("preamble", re.compile(r"(?i)\b(?:in (?:this|today'?s) (?:video|reel)"
+                            r"|i'?m going to show you|i'?ll show you how)\b")),
+    ("greeting", re.compile(r"(?i)^\s*(?:hey|hi|hello|what'?s up|welcome)\b")),
+    ("hashtag", re.compile(r"(?:^|\s)#\w+")),
+    ("emoji", HOOK_EMOJI_RE),
+)
+# Applied to a hook in any script: neither depends on the vocabulary.
+SCRIPT_INDEPENDENT_DEALBREAKERS = ("hashtag", "emoji")
+
+
+def _hook_words(text: str) -> list[str]:
+    return HOOK_WORD_RE.findall(re.sub(r"(?<=\d),(?=\d)", "", text))
+
+
+def hook_score(text: str) -> dict:
+    """Score one spoken hook. `verdict` is None for a hook not in Latin script.
+
+    Returns {score, verdict, checks: {LENGTH, SPECIFICITY, STAKES, FRONTLOAD,
+    ADDRESS}, flags: [dealbreaker ids]}.
+    """
+    flags = [name for name, pattern in HOOK_DEALBREAKERS if pattern.search(text)]
+    if CYRILLIC_RE.search(text) or not re.search(r"[A-Za-z]", text):
+        return {"score": None, "verdict": None, "checks": {},
+                "flags": [f for f in flags if f in SCRIPT_INDEPENDENT_DEALBREAKERS]}
+    words = _hook_words(text)
+    low = [w.lower().strip("'’") for w in words]
+
+    n = len(words)
+    length = 100.0 if 5 <= n <= 12 else (100 - (5 - n) * 20 if n < 5
+                                         else 100 - (n - 12) * 11)
+    if len(text.strip()) > 60:  # two lines of large on-screen text
+        length -= 12
+
+    figures = [m for m in HOOK_FIGURE_RE.findall(text) if m.strip()]
+    hits = len(figures) + len(set(HOOK_PROPER_RE.findall(text))) \
+        + sum(1 for w in low if w in HOOK_SPOKEN_FIGURES)
+    specificity = 15.0 if hits == 0 else 45 + 30 * hits
+
+    markers = set(w for w in low if w in HOOK_STAKES)
+    if re.search(r"[$€£]\s?\d", text):
+        markers.add("a price")
+    stakes = {0: 20.0, 1: 70.0}.get(len(markers), 100.0)
+
+    opener = " ".join(low[:2])
+    penalty = 30 if any(opener.startswith(w) or (low and low[0] == w)
+                        for w in HOOK_WEAK_OPENERS) else 0
+    payload = next((i for i, w in enumerate(low)
+                    if w in HOOK_STAKES or w in HOOK_SPOKEN_FIGURES
+                    or HOOK_FIGURE_RE.match(words[i])
+                    or (i and HOOK_PROPER_RE.match(words[i]))), None)
+    frontload = (30.0 if payload is None else 100.0 if payload <= 3
+                 else 70.0 if payload <= 6 else 40.0) - penalty
+
+    lowered = text.lower()
+    if re.search(r"\b(?:you|your|you're|yourself)\b", lowered):
+        address = 100.0
+    elif low and low[0] in HOOK_IMPERATIVES:
+        address = 90.0
+    elif re.search(r"\b(?:i|my|me|we|our)\b", lowered):
+        address = 70.0
+    else:
+        address = 35.0
+
+    clamp = lambda v: max(0.0, min(100.0, float(v)))  # noqa: E731
+    checks = {"LENGTH": clamp(length), "SPECIFICITY": clamp(specificity),
+              "STAKES": clamp(stakes), "FRONTLOAD": clamp(frontload),
+              "ADDRESS": clamp(address)}
+    parts = list(checks.values())
+    score = clamp(0.6 * sum(parts) / len(parts) + 0.4 * min(parts)
+                  - 15 * len(flags))
+    verdict = ("STRONG" if score >= 70 and min(parts) >= 55 and not flags
+               else "OK" if score >= 50 else "WEAK")
+    return {"score": score, "verdict": verdict, "checks": checks, "flags": flags}
+
+
+HOOK_FIELD_RE = re.compile(r"^hook(?:-\d+)?$")
+ON_SCREEN_LIMIT = 10
+
+
+def check_short_video(brand_dir: Path, sources: dict) -> list[Finding]:
+    """B044 -- every `hook` / `hook-N` field, and its on-screen companion."""
+    findings: list[Finding] = []
+    for key in ("marketing", "store"):
+        for path, fields, _body in documents(brand_dir, sources, key):
+            for name in sorted(f for f in fields if HOOK_FIELD_RE.match(f)):
+                hook = fields[name]
+                if not hook:
+                    continue
+                got = hook_score(hook)
+                reasons = []
+                if got["verdict"] == "WEAK":
+                    weakest = min(got["checks"], key=got["checks"].get)
+                    reasons.append(f"scores {got['score']:.0f} (WEAK); weakest "
+                                   f"check {weakest} at "
+                                   f"{got['checks'][weakest]:.0f}")
+                if got["flags"]:
+                    reasons.append(f"dealbreaker(s): {', '.join(got['flags'])}")
+                if reasons:
+                    findings.append(Finding(
+                        "B044", SEVERITY_WARN, path, 0,
+                        f"`{name}`: \"{hook}\" {'; '.join(reasons)}. A filter, "
+                        f"not a predictor: AUC 0.83 at catching a bad hook, "
+                        f"0.56 at picking a winner (hooks.md)",
+                    ))
+            for name in sorted(f for f in fields
+                               if re.match(r"^on-screen(?:-\d+)?$", f)):
+                words = fields[name].split()
+                if len(words) > ON_SCREEN_LIMIT:
+                    findings.append(Finding(
+                        "B044", SEVERITY_WARN, path, 0,
+                        f"`{name}` is {len(words)} words; on-screen hook text "
+                        f"is read in about half a second, {ON_SCREEN_LIMIT} "
+                        f"words at most (hooks.md)",
+                    ))
+    return findings
+
+
 def _ios_keywords(path: str, fields: dict, raw: str) -> list[Finding]:
     """B041 -- the four rules that recover a third of the 100-character field."""
     findings = []
@@ -1589,15 +2002,45 @@ def dash_findings(code: str, path: str, text: str, strict: bool) -> list[Finding
     return findings
 
 
+def markdown_title(text: str) -> str:
+    """Read common inline heading markup as the displayed label."""
+    text = re.sub(r"!?\[([^\]]+)\]\([^)]*\)", r"\1", text)
+    text = re.sub(r"\s+#+\s*$", "", text)
+    if re.search(r"</?[A-Za-z][^>]*>", text):
+        text = " ".join(html_copy(text).blocks)
+    return unescape(re.sub(r"[*_~`]", "", text)).strip()
+
+
+def markdown_headings(text: str) -> list[tuple[int, str]]:
+    """ATX headings with source lines; fences are examples, inline code is a label."""
+    out = []
+    match = FRONT_MATTER_RE.match(text)
+    if match:
+        text = "\n" * match.group(0).count("\n") + text[match.end():]
+    fence = None
+    for number, line in enumerate(text.splitlines(), 1):
+        marker = re.match(r"^\s{0,3}(`{3,}|~{3,})", line)
+        if marker:
+            current = marker.group(1)
+            if fence is None:
+                fence = current
+            elif current[0] == fence[0] and len(current) >= len(fence):
+                fence = None
+            continue
+        if fence is None and (match := re.match(r"^ {0,3}#{1,6}\s+(.+?)\s*$", line)):
+            out.append((number, markdown_title(match.group(1))))
+    return out
+
+
 def title_full_stop(title: str) -> bool:
     """AT-07. True when a title ends in a full stop that is a full stop."""
     text = title.strip()
+    if text == "." or text.endswith(" ."):
+        return False  # A standalone current-directory token is not punctuation.
     if not text.endswith("."):
         return False
     if text.endswith("..") or text.endswith("…"):
         return False
-    if ". " in text:            # several sentences -- a different defect
-        return False
     return not ABBREVIATION_RE.search(text)
 
 
@@ -1773,10 +2216,15 @@ def check_ai_tells(brand_dir: Path, sources: dict) -> list[Finding]:
                     f'the title ends in a full stop: "{title.strip()}". '
                     f"A title is a name, not a statement",
                 ))
-            for heading in re.findall(r"^#{1,6}\s+(.+?)\s*$", prose_only(body), re.M):
+            source = brand_dir.parent.parent / path
+            if source.suffix.lower() in HTML_SUFFIXES:
+                headings = html_copy(read(source) or "").headings
+            else:
+                headings = markdown_headings(read(source) or "")
+            for line, heading in headings:
                 if title_full_stop(heading):
                     findings.append(Finding(
-                        "B063", SEVERITY_WARN, path, 0,
+                        "B063", SEVERITY_WARN, path, line,
                         f'a heading ends in a full stop: "{heading.strip()}". '
                         f"A heading is a name, not a statement",
                     ))
@@ -1800,6 +2248,141 @@ def check_ai_tells(brand_dir: Path, sources: dict) -> list[Finding]:
     return findings
 
 
+# AT-16 / B066 -- invisible and look-alike-space characters. They render as
+# nothing or as an ordinary space, survive every paste, and break search,
+# hyphenation and exact-match checks downstream. The eighteen named classes
+# are the ones the humanizer in Jakeschincariol/instagram-agent-skill @d03c56b
+# strips (`skills/ig-human/slop.json`); any other Unicode format character
+# (category Cf -- bidi embeddings, overrides and isolates among them) is
+# reported by the catch-all. This check REPORTS; it does not rewrite, because
+# every class below has a context where it is correct, and those contexts are
+# the numbered exemptions in ai-tells.md (AT-16-E1..E7).
+#
+# What it deliberately does NOT port from that humanizer: the typography pass
+# that turns an em dash into ", ", an en dash into "-" and curly quotes into
+# straight ones. In Russian the dash is normative and «ёлочки» are the
+# quotation marks; a rule that rewrote them would make correct text wrong.
+# The rhetorical dash is AT-06 / B062, which knows the difference.
+import unicodedata  # noqa: E402
+
+INVISIBLE_NAMED = {
+    0x200B: "zero-width", 0x200C: "zero-width", 0x200D: "zero-width",
+    0x2060: "zero-width", 0xFEFF: "zero-width", 0x00AD: "zero-width",
+    0x180E: "zero-width", 0x2063: "zero-width",
+    0x061C: "bidi", 0x200E: "bidi", 0x200F: "bidi",
+    0x00A0: "space", 0x202F: "space", 0x2009: "space", 0x2007: "space",
+    0x2003: "space", 0x2002: "space",
+}
+TAG_RANGE = range(0xE0000, 0xE0080)
+BIDI_ISOLATES = range(0x2066, 0x206A)
+RTL_RE = re.compile("[֐-ࣿיִ-﷿ﹰ-ﻼ]")
+# Locales whose own typography puts a no-break or narrow space where a writer
+# means one: «в пятницу», «1 000», « Prix : ». Short on purpose, like
+# COPULA_LOCALES: a wrong entry silences the space class for a whole language.
+TYPOGRAPHIC_SPACE_LOCALES = ("ru", "uk", "be", "fr")
+
+
+def _is_pictograph(char: str) -> bool:
+    cp = ord(char)
+    return (0x1F000 <= cp <= 0x1FAFF or 0x2600 <= cp <= 0x27BF
+            or 0x2300 <= cp <= 0x23FF or cp == 0xFE0F)
+
+
+def _needs_joiner(char: str) -> bool:
+    """A letter of a script that spells with ZWJ/ZWNJ (Arabic, Persian, Indic…)."""
+    return 0x0590 <= ord(char) < 0x2000 and char.isalpha() \
+        and not CYRILLIC_RE.match(char) and not ("Ͱ" <= char <= "Ͽ")
+
+
+def invisible_chars(text: str, locale: str | None = None) -> list[tuple]:
+    """(index, code point, name, class) for every reportable character.
+
+    Exemptions, numbered in ai-tells.md: E1 a joiner inside an emoji sequence,
+    E2 a joiner beside a letter of a script that needs it, E3 a direction mark
+    or isolate in text that carries right-to-left letters, E4 tag characters
+    inside a flag sequence, E5 typographic spaces in a locale whose typography
+    uses them, E6 dashes and quotation marks (never examined), E7 a byte-order
+    mark opening the file.
+    """
+    rtl = any(c.isalpha() for c in RTL_RE.findall(text))  # letters, not marks
+    spaces_ok = bool(CYRILLIC_RE.search(text)) or (
+        bool(locale) and locale.split("-")[0].lower() in TYPOGRAPHIC_SPACE_LOCALES)
+    hits = []
+    for i, char in enumerate(text):
+        cp = ord(char)
+        if cp in INVISIBLE_NAMED:
+            cls = INVISIBLE_NAMED[cp]
+        elif cp in TAG_RANGE:
+            cls = "tag"
+        elif unicodedata.category(char) == "Cf":
+            cls = "format"
+        else:
+            continue
+        prev = text[i - 1] if i else ""
+        nxt = text[i + 1] if i + 1 < len(text) else ""
+        if cp == 0xFEFF and i == 0:                                  # E7
+            continue
+        if cp == 0x200D and prev and nxt and _is_pictograph(prev) \
+                and _is_pictograph(nxt):                             # E1
+            continue
+        if cp in (0x200C, 0x200D) and ((prev and _needs_joiner(prev))
+                                       or (nxt and _needs_joiner(nxt))):  # E2
+            continue
+        if rtl and (cls == "bidi" or cp in BIDI_ISOLATES):           # E3
+            continue
+        if cls == "tag":                                             # E4
+            start = i
+            while start and ord(text[start - 1]) in TAG_RANGE:
+                start -= 1
+            end = i
+            while end + 1 < len(text) and ord(text[end + 1]) in TAG_RANGE:
+                end += 1
+            if start and text[start - 1] == "\U0001F3F4" and ord(text[end]) == 0xE007F:
+                continue
+        if cls == "space" and spaces_ok:                             # E5
+            continue
+        name = unicodedata.name(char, f"U+{cp:04X}")
+        hits.append((i, cp, name, cls))
+    return hits
+
+
+def check_invisible(brand_dir: Path, sources: dict) -> list[Finding]:
+    """B066 -- AT-16 over every declared copy source, read as raw text.
+
+    Raw on purpose: a literal character is what travels into a paste, while
+    an HTML entity such as `&nbsp;` is markup someone typed deliberately and
+    is not reported. One finding per file and class, at the first line.
+    """
+    findings: list[Finding] = []
+    primary, _ = declared_locales(brand_dir)
+    root = brand_dir.parent.parent
+    seen: set = set()
+    for key in ("ui", "marketing", "store", "locales"):
+        for pattern in sources.get(key, []):
+            for path in source_paths(root, pattern):
+                if path in seen or not path.is_file():
+                    continue
+                seen.add(path)
+                text = read(path) or ""
+                fields, _ = _front_matter(text)
+                hits = invisible_chars(text, fields.get("locale") or primary)
+                grouped: dict = {}
+                for index, cp, name, cls in hits:
+                    grouped.setdefault((cls, cp, name), []).append(index)
+                rel = path.relative_to(root).as_posix()
+                for (cls, cp, name), where in sorted(grouped.items(),
+                                                     key=lambda kv: kv[1][0]):
+                    line = text.count("\n", 0, where[0]) + 1
+                    findings.append(Finding(
+                        "B066", SEVERITY_WARN, rel, line,
+                        f"U+{cp:04X} {name} ({cls} class) x{len(where)} -- "
+                        f"invisible in the editor and carried into every "
+                        f"paste. Remove it, or keep it where ai-tells.md "
+                        f"AT-16 names the context that needs it",
+                    ))
+    return findings
+
+
 def declared_locales(brand_dir: Path) -> tuple[str | None, list[str]]:
     """(primary, others) from voice.md's `Locales:` line."""
     text = read(brand_dir / "voice.md") or ""
@@ -1844,7 +2427,7 @@ def check_locales(brand_dir: Path, sources: dict) -> list[Finding]:
     if primary and limit and "locales" in sources:
         catalogues: dict[str, set] = {}
         for pattern in sources["locales"]:
-            for path in sorted(root.glob(pattern)):
+            for path in source_paths(root, pattern):
                 try:
                     data = json.loads(read(path) or "{}")
                 except json.JSONDecodeError:
@@ -1961,12 +2544,15 @@ def run(brand_dir: Path, fix: bool = False) -> list[Finding]:
     sources = load_sources(brand_dir)
     findings: list[Finding] = []
     findings.extend(check_contract(brand_dir))
+    findings.extend(check_source_coverage(brand_dir, sources))
     findings.extend(check_terminology(brand_dir))
     findings.extend(check_consistency(brand_dir, sources))
     findings.extend(check_facts(brand_dir, sources))
     findings.extend(check_channels(brand_dir, sources))
+    findings.extend(check_short_video(brand_dir, sources))
     findings.extend(check_bot_safety(brand_dir, sources))
     findings.extend(check_ai_tells(brand_dir, sources))
+    findings.extend(check_invisible(brand_dir, sources))
     findings.extend(check_locales(brand_dir, sources))
     return findings
 
@@ -1997,11 +2583,16 @@ def main(argv: list[str] | None = None) -> int:
     parser.add_argument("--fix", action="store_true")
     parser.add_argument("--brief", action="store_true")
     parser.add_argument("--json", action="store_true")
+    parser.add_argument("--fail-on", action="append", default=[], metavar="CODE",
+                        help="make selected warning codes block (repeat or comma-separate)")
     parser.add_argument(
         "--strict", action="store_true",
         help="let warnings fail the run too (same meaning as ux_lint.py --strict)",
     )
     args = parser.parse_args(argv)
+    fail_on = {code.strip() for value in args.fail_on for code in value.split(",")}
+    if fail_on - WARNING_CODES:
+        parser.error("--fail-on expects a warning code: " + ", ".join(sorted(WARNING_CODES)))
 
     brand_dir = Path(args.path)
     if not brand_dir.is_dir():
@@ -2020,7 +2611,7 @@ def main(argv: list[str] | None = None) -> int:
     # A warning is advice about a judgement a person still has to make -- an
     # unregistered string, a fact past review, a label naming no outcome. It
     # blocks only when the caller asks, which is what `--strict` is for.
-    return 1 if (args.strict and findings) else 0
+    return 1 if ((args.strict and findings) or any(f.code in fail_on for f in findings)) else 0
 
 
 if __name__ == "__main__":

package/templates/brand/README.md

@@ -22,7 +22,7 @@ Owned by the `brand-voice` skill. Written by `copywriting`. Checked by
 
 **Fill this in before anything else.** The linter scans nothing outside these
 paths, and refuses to report a clean run over a surface it never read
-(`B006`). Delete the keys this project does not have — a declared-but-absent
+(`B006` for no block, `B009` for an unmatched glob). Delete the keys this project does not have — a declared-but-absent
 source is worse than an omitted one.
 
 ```
@@ -34,6 +34,12 @@ Sources:
   locales:   src/locales/*.json
 ```
 
+For a website, list the HTML under `marketing` or retain heading markers in a
+copy projection. Flat paragraphs cannot prove heading coverage. To make the
+no-title-period rule a required gate, run the resolved brand linter with
+`--fail-on B063`; default warnings remain advisory. The placeholder source
+patterns above must be replaced before the first real lint run.
+
 `ui` and `marketing` also classify findings — several checks apply to only
 one of the two.
 

package/templates/brand/channels.md

@@ -103,14 +103,36 @@ Locales:    <coefficient applies to both limits>
 Register:   density +1, distance -1
 Format:     one idea; threads 5-12 posts, each standing alone
 Limits:     280
-Forbidden:  physics: link in body suppresses reach; >2 hashtags penalised;
-            editing within 30 minutes resets distribution
-            | brand: <engagement bait, fake urgency>
+Forbidden:  physics: link in body (practice; unverified in the open ranker) | brand: <engagement bait, fake urgency>
 CTA:        <in the first reply, not the post>
 Proof:      <one figure, sourced>
 Locales:    <…>
 ```
 
+### Instagram
+
+```
+Register:   distance -1
+Format:     a caption; the first line is the window the feed shows
+Limits:     body 2200
+Forbidden:  physics: link in body, max 5 hashtags, fold 125, one ask | brand: <engagement bait>
+CTA:        one, spoken in the video as well
+Proof:      <one figure, sourced>
+Locales:    <…>
+```
+
+### short video
+
+```
+Register:   distance -1, density +1
+Format:     hook triple (frame 0, on-screen text, first line), body, one ask
+Limits:     <running time; Russian and other locales timed by reading aloud>
+Forbidden:  physics: none | brand: <fabricated testimonials, unlabelled synthetic people>
+CTA:        one, or a loop back to the first line
+Proof:      <one figure, sourced>
+Locales:    <…>
+```
+
 ### Reddit
 
 ```
@@ -125,5 +147,5 @@ Locales:    <…>
 ```
 
 <add the remaining marketing surfaces this product uses: landing body,
-pricing, blog, changelog, LinkedIn, HN and Product Hunt, App Store,
-Google Play, ads, lifecycle email>
+pricing, blog, changelog, TikTok, YouTube Shorts, LinkedIn, HN and Product
+Hunt, App Store, Google Play, ads, lifecycle email>