super-ux 0.60.0 → 0.62.0

package/CHANGELOG.md

@@ -1,3 +1,65 @@
+## 0.62.0 (2026-10-19): retrieval crawlers, the audit's brief, landing promises, Copylot sweep
+
+- **`B050` judges retrieval agents only.** The AI-search contradiction is a block
+  of `OAI-SearchBot`, `ChatGPT-User`, `Claude-SearchBot`, `Claude-User`,
+  `PerplexityBot` or `Perplexity-User` while `channels.md` declares AI search a
+  target. Training and dataset tokens (`GPTBot`, `ClaudeBot`, `CCBot`,
+  `Google-Extended`) are a separate decision and are never reported; before
+  this release a `GPTBot` block was an error and an `OAI-SearchBot` block was
+  invisible. robots.txt is read in RFC 9309 groups: shared `User-agent` lines,
+  the `*` fallback for an agent with no group of its own, case-insensitive
+  tokens, and an equal-length `Allow: /` beating `Disallow: /`. Each purpose is
+  cited from the vendor's own crawler page in the code and the contract.
+  Fifteen new fixtures, each defect planted in the linter and watched red.
+- **`seo-aeo-safety.md`:** a "Crawler policy: two decisions" section with the
+  vendor table; the technical floor replaced by a pointer to seo-aeo-audit's
+  brief mode (`references/build-time.md`, ships with seo-aeo-audit 0.28); no
+  `FAQPage`/`HowTo` markup for rich results (Google's changelog: HowTo removed
+  in 2023, FAQ rich results gone from 7 May 2026); the keyword-stuffing text now
+  states what `B051` enforces (pages of 40 or more words, a word repeated 5 or
+  more times above a 4% share, registered terms exempt, advisory) instead of
+  the retired 1% rule; Claude's row in the engine table reflects web search.
+- **`landing-pages.md` LP-21..LP-24:** an offer condition next to its claim and
+  the same in the ad; lead with the problem and name AI only where it changes
+  the outcome; a "works with X" claim waits for a measured acceptance test in
+  `facts.md`; one job per page and creatives judged by the qualified-step rate,
+  not CTR. Readiness-check commands for LP-21, LP-23 and LP-24; LP-22 stays a
+  reading. Each rule cites the regulator or platform policy it rests on.
+- **`copywriting`:** runs `copylot.check` beside the brand linter when the tool
+  is in the session (target `register: web`, `format: web-page`; until
+  Copylot's schema lists them, `marketing` and no format, said out loud) and
+  prints a fallback line when it is absent.
+- **Synthetic respondents are hypotheses:** `research-evidence.md`,
+  `ux-foundation` and `ux-scenarios` say a synthetic persona or LLM "digital
+  twin" is never evidence for a persona or scenario decision (cited: Nielsen
+  Norman Group, 2024). `audit-depth.md` adds the quarterly fresh-user walk:
+  clean install or new account, from the ad or landing page to paid use with a
+  real payment method, on the smallest supported screen, findings recorded
+  against scenarios.
+- Contract copies synchronized with `python3 test/sync_references.py`; seeded
+  `docs/brand/lint.py` re-copied. Discovery descriptions unchanged.
+
+## 0.61.0 (2026-10-18): no em dash in new text
+
+Owner decision, 2026-10-18: text an agent writes carries no em dash (U+2014), in
+any language, and no substitute for one. The family hub carries the same rule as
+an always-on line for every host; this release makes product text agree with it.
+
+- `ai-tells.md` AT-06 is now a hard ban, not a frequency target. The dash rule has
+  two layers: the glyph (no em dash in newly authored text) and the role (the
+  rhetorical dash is banned in every spelling; the grammatical Russian dash is
+  allowed only where no rewrite reads naturally). Ranges take an en dash.
+- New lint code `B067` (`brand_lint.py`, seeded `docs/brand/lint.py`): an em dash
+  joining a range errors; an em dash opening a line where the locale has no
+  dialogue dash errors; a lone dash in a locale with a grammatical one warns, so
+  the writer decides whether the grammar needs it. Never a second finding beside
+  `B062`. Five fixtures, each watched failing with `B067` stubbed out.
+- `copywriting`: the em dash is a Non-negotiable and the one exception to the
+  advisory humanization pass; the status-line examples no longer use a dash.
+  `brand-voice` seeds the invariant into `voice.md`; the brand hard rule
+  (`templates/claude-rule.md` and its embedded copies) and the Cursor rule say so.
+- Contract copies synchronized with `python3 test/sync_references.py`.
+
 ## 0.60.0 — a rendered screen is checked in WebKit (Safari) first
 
 - New shared contract `references/browser-engine.md`: Safari through

package/README.md

@@ -161,10 +161,10 @@ Commands: `/brand` (status → one recommended action), `/brand-init`,
 python3 docs/brand/lint.py
 ```
 
-48 deterministic checks (`B001`..`B073`): banned words, one action under two names, a figure
+49 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
+a rhetorical dash or an em dash in new text, a title that ends in a full stop, a locale that lags
 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)`.
 

package/cursor/rules/copywriting.mdc

@@ -54,9 +54,14 @@ Could this sentence sit unchanged on a competitor's page? Then it says
 nothing. Rewrite it until it could not.
 
 Machine-made tells to strip: tricolons that add nothing, "seamless /
-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.
+effortless / unlock / elevate / robust", "it's not just X, it's Y", hedges
+stacked two deep, and a closing sentence that summarizes what was just said.
+
+**No em dash (U+2014) in text you write, in any language** (owner decision,
+2026-10-18). A hard ban, not a count: no substitute either (`--`, an en dash
+or a spaced hyphen doing a dash's job). Use a full stop, a comma, a colon or
+brackets, or rewrite. The rare exception is a dash Russian grammar needs where
+no rewrite reads naturally; quotations, code, commands and paths keep theirs.
 
 ## Short video
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "super-ux",
-  "version": "0.60.0",
+  "version": "0.62.0",
   "scripts": {
     "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"

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

@@ -1794,7 +1794,79 @@ def _ios_keywords(path: str, fields: dict, raw: str) -> list[Finding]:
     return findings
 
 
-AI_AGENTS = ("GPTBot", "ClaudeBot", "PerplexityBot", "Google-Extended")
+# B050 judges RETRIEVAL agents only: the ones that fetch a page to show, cite
+# or answer from it. Blocking one while AI search is a declared target is the
+# contradiction. Each purpose is the vendor's own wording, read 2026-10-19:
+#   OAI-SearchBot  "surface websites in search results in ChatGPT's search
+#                  features"; ChatGPT-User  user-initiated fetches
+#                  (https://developers.openai.com/api/docs/bots)
+#   Claude-SearchBot  indexes content for search; Claude-User  retrieves a
+#                  page in response to a user query
+#                  (https://support.claude.com/en/articles/8896518)
+#   PerplexityBot  "surface and link websites in search results on
+#                  Perplexity"; Perplexity-User  fetches for a user's question
+#                  (https://docs.perplexity.ai/guides/bots)
+RETRIEVAL_AGENTS = (
+    "OAI-SearchBot", "ChatGPT-User", "Claude-SearchBot", "Claude-User",
+    "PerplexityBot", "Perplexity-User",
+)
+# TRAINING and dataset tokens: blocking them is a separate decision with no
+# effect on AI search, so B050 never reports them. GPTBot and ClaudeBot are
+# the vendors' training crawlers (same pages); Google-Extended controls Gemini
+# training and grounding and "does not impact a site's inclusion in Google
+# Search" (https://developers.google.com/crawling/docs/crawlers-fetchers/google-common-crawlers);
+# CCBot builds Common Crawl's open archive (https://commoncrawl.org/ccbot).
+TRAINING_AGENTS = ("GPTBot", "ClaudeBot", "CCBot", "Google-Extended")
+# Whole-site paths and their rule length. Google's matcher ignores a trailing
+# `*` (so `/*` and a bare `*` weigh what `/` weighs) and reads `$` as the end
+# of the path; the longer rule wins and Allow wins a tie (RFC 9309 2.2.2).
+# So `Disallow: /*` against `Allow: /` is a tie Allow wins, while
+# `Disallow: /*$` (3 octets) outranks `Allow: /`.
+FULL_PATHS = {"/": 1, "/*": 1, "*": 1, "/*$": 3}
+
+
+def robots_groups(text: str) -> list[tuple[list[str], list[tuple[str, str]]]]:
+    """RFC 9309 groups: consecutive `User-agent` lines share the rules after
+    them, and a `User-agent` line after a rule opens a new group. Tokens are
+    lower-cased, because product tokens match case-insensitively, and cut to
+    their leading [a-z_-] run, as Google's matcher does, so `OAI-SearchBot/1.0`
+    still names OAI-SearchBot. A UTF-8 BOM before the first line is dropped."""
+    text = text.lstrip("\ufeff")
+    groups: list[tuple[list[str], list[tuple[str, str]]]] = []
+    agents: list[str] = []
+    rules: list[tuple[str, str]] = []
+    for raw in text.splitlines():
+        line = raw.split("#", 1)[0].strip()
+        m = re.match(r"^(user-agent|allow|disallow)\s*:\s*(.*?)\s*$", line, re.I)
+        if not m:
+            continue
+        key, value = m.group(1).lower(), m.group(2)
+        if key == "user-agent":
+            if rules:
+                groups.append((agents, rules))
+                agents, rules = [], []
+            token = re.match(r"\*(?=\s|$)|[a-z_-]*", value.lower()).group(0)
+            agents.append(token or value.lower())
+        elif agents:
+            rules.append((key, value))
+    if agents:
+        groups.append((agents, rules))
+    return groups
+
+
+def robots_blocks(text: str, token: str) -> bool:
+    """True when robots.txt shuts `token` out of the whole site. The agent
+    obeys the groups naming it, or the `*` groups when none does; an
+    equal-length `Allow` beats `Disallow` (RFC 9309 section 2.2.2)."""
+    groups = robots_groups(text)
+    own = [r for a, r in groups if token.lower() in a]
+    rules = [rule for rs in (own or [r for a, r in groups if "*" in a])
+             for rule in rs]
+    def longest(kind: str) -> int:
+        return max((FULL_PATHS[v] for k, v in rules
+                    if k == kind and v in FULL_PATHS), default=0)
+    disallow, allow = longest("disallow"), longest("allow")
+    return disallow > 0 and disallow > allow
 
 FILLER_OPENERS = (
     "in today's digital landscape", "in the ever-evolving world",
@@ -2037,6 +2109,75 @@ def dash_findings(code: str, path: str, text: str, strict: bool) -> list[Finding
     return findings
 
 
+# AT-06's hard layer, owner-decided 2026-10-18: newly authored text carries no
+# em dash (U+2014) in any language. B062 above judges the dash's ROLE; this
+# judges the glyph B062 leaves alone. It never reports a sentence B062
+# already reports, so one dash is one finding.
+EM_DASH = "—"
+EM_DASH_RANGE_RE = re.compile(rf"\d\s*{EM_DASH}\s*\d")
+
+
+def em_dash_findings(code: str, path: str, text: str, strict: bool) -> list[Finding]:
+    """The em dash the rhetorical check cannot see, and the Russian dash it allows.
+
+    Three cases, each one the B062 branches pass over in silence:
+
+    - a range written with an em dash, in any language: an error, because a
+      range takes an en dash (U+2013) and a rewrite never costs anything;
+    - an em dash opening a line where the locale has no dialogue dash: an
+      error, because there it is decoration, not the speech convention;
+    - a lone dash, in any spelling, where the locale has a grammatical dash:
+      a warning. The copula (AT-06-E1) is allowed only where no rewrite reads
+      naturally, and only the writer can judge that, so the linter asks and
+      never blocks on grammar it cannot parse.
+    """
+    findings: list[Finding] = []
+    raw = prose_only(text)
+    # Length-preserving like the B062 normaliser, so quotes come from `raw`.
+    cells = TABLE_CELL_DASH_RE.sub(r"\1 \2", raw)  # AT-06-E4
+    body = normalise_dash_spelling(raw)
+    if DASH not in body:
+        return findings
+
+    def line_of(sentence: str) -> int:
+        at = body.find(sentence[:40])
+        return body.count("\n", 0, at) + 1 if at >= 0 else 0
+
+    for sentence, cell, original in zip(sentences(body), sentences(cells), sentences(raw)):
+        if DASH not in sentence:
+            continue
+        line = line_of(sentence)
+        if EM_DASH_RANGE_RE.search(cell):
+            findings.append(Finding(
+                code, SEVERITY_ERROR, path, line,
+                f"an em dash joins a range; write the range with an en dash "
+                f'(U+2013) or the word "to": "{_around(sentence, original)}"',
+            ))
+            continue
+        speech = DASH_SPEECH_RE.match(sentence)
+        if strict:
+            # B062 reports every other bare dash in this locale.
+            if speech and cell.lstrip().startswith(EM_DASH):
+                findings.append(Finding(
+                    code, SEVERITY_ERROR, path, line,
+                    f"an em dash opens the line, and this locale has no dialogue "
+                    f'dash; drop it or use a list: "{_around(sentence, original)}"',
+                ))
+            continue
+        if speech:  # AT-06-E3
+            continue
+        bare = sentence.count(DASH) - len(DASH_RANGE_RE.findall(sentence))
+        if bare <= 0 or bare >= 2 or DASH_CONJ_RE.search(sentence):
+            continue  # a range, or B062's own error
+        findings.append(Finding(
+            code, SEVERITY_WARN, path, line,
+            f"a dash in new text is allowed only where the grammar needs it "
+            f"(AT-06-E1) and no rewrite reads naturally; otherwise use a full "
+            f'stop, a comma, a colon or brackets: "{_around(sentence, original)}"',
+        ))
+    return findings
+
+
 def markdown_title(text: str) -> str:
     """Read common inline heading markup as the displayed label."""
     text = re.sub(r"!?\[([^\]]+)\]\([^)]*\)", r"\1", text)
@@ -2090,21 +2231,15 @@ def check_bot_safety(brand_dir: Path, sources: dict) -> list[Finding]:
             (p, {}, "") for p in sources["robots"]
         ]:
             robots = read(brand_dir.parent.parent / path) or ""
-            blocks = []
-            agent = None
-            for line in robots.splitlines():
-                head = re.match(r"^User-agent:\s*(.+?)\s*$", line, re.I)
-                if head:
-                    agent = head.group(1).strip()
-                elif re.match(r"^Disallow:\s*/\s*$", line, re.I) and agent:
-                    if agent in AI_AGENTS:
-                        blocks.append(agent)
+            blocks = [t for t in RETRIEVAL_AGENTS if robots_blocks(robots, t)]
             if blocks:
                 findings.append(Finding(
                     "B050", SEVERITY_ERROR, path, 0,
-                    f"channels.md declares AI search a target while "
-                    f"{', '.join(blocks)} is blocked here -- content quality "
-                    f"is irrelevant to a crawler that never arrives",
+                    f"channels.md declares AI search a target while the "
+                    f"retrieval agent(s) {', '.join(blocks)} are blocked here. "
+                    f"An answer engine cannot cite a page it may not fetch. "
+                    f"Training crawlers ({', '.join(TRAINING_AGENTS)}) are a "
+                    f"separate decision and are not judged here",
                 ))
 
     records = surfaces(brand_dir)
@@ -2197,10 +2332,11 @@ def check_bot_safety(brand_dir: Path, sources: dict) -> list[Finding]:
 
 
 def check_ai_tells(brand_dir: Path, sources: dict) -> list[Finding]:
-    """B060-B063 -- machine-drafting markers, and the one absolute ban.
+    """B060-B063 and B067 -- machine-drafting markers, and the absolute bans.
 
     B060 counts vocabulary markers, B061 bans levity where the user is
-    losing something, B062 is AT-06 (the rhetorical dash) and B063 is AT-07
+    losing something, B062 is AT-06 (the rhetorical dash), B067 is AT-06's
+    hard layer (the em dash glyph in new text) and B063 is AT-07
     (a title that ends in a full stop) outside the string registry, which
     B026 already covers. The grades and the reasoning are in
     `references/ai-tells.md`; this file carries only the provable subset.
@@ -2231,12 +2367,15 @@ def check_ai_tells(brand_dir: Path, sources: dict) -> list[Finding]:
             text = f"{fields.get('title', '')}\n{body}"
             strict = not grammatical_dash_language(text, primary)
             findings.extend(dash_findings("B062", path, body, strict))
+            # B067 -- the em dash glyph B062 does not judge (AT-06, hard layer).
+            findings.extend(em_dash_findings("B067", path, body, strict))
 
     for row in registry(brand_dir):
         if row["kind"] == "layout":
             continue
         strict = not grammatical_dash_language(row["text"], primary)
         findings.extend(dash_findings("B062", row["location"], row["text"], strict))
+        findings.extend(em_dash_findings("B067", row["location"], row["text"], strict))
 
     # B063 -- AT-07 outside the registry: document titles and the headings
     # inside them. B026 owns the same rule for `strings.md`, and the two are

package/templates/brand/voice.md

@@ -40,6 +40,8 @@ Promise:      <one line, checkable against a row in facts.md>
 What survives translation. Breaking one of these is a finding on any surface,
 in any locale.
 
+- No em dash (U+2014) in new text, in any language; the grammatical Russian
+  dash only where no rewrite reads naturally (owner decision, 2026-10-18)
 - <e.g. never hedges>
 - <e.g. never claims a number that is not in facts.md>
 

package/templates/claude-rule.md

@@ -48,14 +48,16 @@
   notification and accessible name. Search `strings.md` before naming one.
 - **No humor, exclamation marks or emoji** on error, destructive confirm,
   billing or paywall surfaces, in any voice.
-- **No rhetorical dash, and no full stop after a title.** A dash standing in
-  for a full stop, a comma or a colon is the loudest machine-drafting marker
-  the pack has, and a heading, button, menu item or page title is a name
-  rather than a statement. The dash a language requires stays: the Russian
-  copula, numeric ranges, direct speech. Choose the replacement from the
-  meaning, because a comma, a colon and a full stop state three different
-  relationships and find-and-replace picks the wrong one. `B062` and `B063`
-  catch what a machine can prove; the rest is in the skill's `ai-tells.md`.
+- **No em dash in new text, no rhetorical dash, and no full stop after a
+  title.** Text you write carries no em dash (U+2014) in any language (owner
+  decision, 2026-10-18), and no dash in any spelling stands in for a full
+  stop, a comma or a colon. A heading, button, menu item or page title is a
+  name rather than a statement. The dash Russian grammar needs (the copula,
+  direct speech) stays only where no rewrite reads naturally; a range takes
+  an en dash. Choose the replacement from the meaning, because a comma, a
+  colon and a full stop state three different relationships and
+  find-and-replace picks the wrong one. `B062`, `B063` and `B067` catch what
+  a machine can prove; the rest is in the skill's `ai-tells.md`.
 - Run `python3 docs/brand/lint.py` after any text change and before calling
   work done. It must exit 0 — an error blocks and a warning is advice, which
   is the same policy the UX linter has; `--strict` makes warnings block too.