super-ux 0.59.3 → 0.61.0

package/CHANGELOG.md

@@ -1,3 +1,42 @@
+## 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
+  `safaridriver`, Playwright `webkit` (`--browser webkit`,
+  `npx playwright install webkit`), Safari Web Inspector, and
+  `open -a Safari <url>` on macOS rather than the system default browser.
+  Chromium is a stated fallback for a task that needs Chrome itself (a Chrome-only
+  API, Lighthouse, a CDP trace, the chrome-devtools MCP), on Chrome Dev, with a
+  temporary profile and every started process closed. A screen checked only in
+  Chromium is reported as exactly that.
+- `ux-audit`: a RUNTIME browser check runs in WebKit first and names its engine;
+  the live pass walks scenarios in WebKit first; the capture record gains `engine`.
+- `funnel-research.md`: the funnel walk uses Playwright `webkit` or Safari first;
+  `chrome-devtools` / `claude-in-chrome` only as a stated fallback.
+- Per-skill copies synchronized (`ux-audit`, `ux-flows`, `ux-foundation`). Discovery
+  descriptions unchanged. New regression `test/audit_regressions/safari-first.py`
+  with drop mutations; text integrity only, no model eval.
+
 ## 0.59.3 — accountable journeys and explicit copy inputs
 
 - Journeys record an Owner, with `unknown` supported. `U086` advises migration

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.59.3",
+  "version": "0.61.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

@@ -2037,6 +2037,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)
@@ -2197,10 +2266,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 +2301,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.