page-foundry 3.2.0 → 3.4.0

package/skills/page-foundry/scripts/run_audit.py

@@ -27,12 +27,23 @@ Exit code 0 = no HARD FAILs, 1 = HARD FAILs found, 2 = usage/environment error.
 """
 
 import hashlib
+import json
 import os
 import re
 import sys
 from datetime import date, datetime
 from pathlib import Path
 
+# Sibling stdlib script, imported in-process (no subprocess, no third-party dep)
+# so Gate 0 can RE-RUN the deterministic voice scan and catch a copy that never
+# went through the Gate 2 scan or shipped over its failures (#42 tier 1). Import
+# is side-effect-free: voice_scan only runs under `if __name__ == "__main__"`.
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+try:
+    import voice_scan  # noqa: E402
+except Exception:  # pragma: no cover - defensive: sibling missing/broken
+    voice_scan = None
+
 MODES = {"build", "explore", "handoff"}
 PUBLIC_PRICING_ARCHETYPES = {
     "pricing-page",
@@ -82,6 +93,12 @@ REQUIRED_FILES = (
     ("run", "copy/hero-candidates.md", 2),
     ("run", "copy/approved-draft.md", 4),
     ("run", "copy/copy-approved.md", 4),
+    # #42 tier 2: the LLM judgment passes leave first-class, auditable artifacts
+    # that carry specifics only a real run produces, so backfill costs more than
+    # "write plausible prose". humanizer.md must show the before/after diffs it
+    # made; red-team.md must carry the per-segment reader walks and bounce points.
+    ("run", "copy/humanizer.md", 4),
+    ("run", "red-team.md", 5),
     ("run", "conversion-audit.md", 4),
 )
 HANDOFF_FILES = (
@@ -115,9 +132,11 @@ CORE_ARTIFACT_COMPANION = {
     "persuasion-map.md": "marketing-psychology",
     "conversion-audit.md": "cro",
     "copy/hero-candidates.md": "copywriting",
-    # frontend-design (theme.css) and humanizer (voice pass) are core too but
-    # their outputs are checked elsewhere; impeccable's DESIGN.md is handled by a
-    # dedicated workspace-root check in audit_run (it is not run-dir-relative).
+    "copy/humanizer.md": "humanizer",
+    # frontend-design (theme.css) is core too but checked elsewhere; impeccable's
+    # DESIGN.md and detect scan are handled by dedicated workspace-root checks in
+    # audit_run (not run-dir-relative). red-team.md has no single companion owner
+    # (it is page-foundry's own Phase 3 / Gate 1 walk) and so is always required.
 }
 POINTER_RE = re.compile(
     r"(https?://|[A-Za-z0-9_./-]+:\d+|#[A-Za-z][\w:-]*|\b(?:PR|MR|GH-|JIRA-|PF-|BUG-|ISSUE-|TASK-|TICKET-)?[A-Z]+-\d+\b|\b[a-f0-9]{7,40}\b)",
@@ -283,6 +302,7 @@ def parse_preflight(text):
     # OUTPUT artifact mandatory.
     states = {}
     override = set()
+    taste = {}  # voice / design-reference status (the external taste inputs, #41)
     for raw in text.splitlines():
         line = raw.strip()
         m = re.match(r"^\|\s*([A-Za-z0-9_-]+)\s*\|\s*(core|enhancer)\s*\|\s*([A-Za-z-]+)\s*\|", line)
@@ -295,7 +315,13 @@ def parse_preflight(text):
                 for name in re.split(r"[,\s]+", val):
                     if name.strip():
                         override.add(name.strip().lower())
-    return states, override
+        tv = re.match(r"^voice:\s*(.+)$", line, re.I)
+        if tv:
+            taste["voice"] = tv.group(1).strip().lower()
+        td = re.match(r"^design-reference:\s*(.+)$", line, re.I)
+        if td:
+            taste["design-reference"] = td.group(1).strip().lower()
+    return states, override, taste
 
 
 def companion_available(states, override, companion):
@@ -309,6 +335,127 @@ def companion_available(states, override, companion):
     return state in ("present", "outdated")
 
 
+# Aliases the override line may use to waive each external taste input (#41).
+TASTE_OVERRIDE_ALIASES = {
+    "voice": {"voice"},
+    "design-reference": {"design-reference", "design", "design-ref", "reference"},
+}
+
+
+def check_taste_inputs(results, preflight_path, taste, override):
+    # #41: the two external taste inputs are what keep the page from being
+    # invented out of same-family model priors (the AI-default look). A run may
+    # legitimately proceed without one, but only as an honest PARTIAL: the
+    # absence is surfaced here as a WARN so the gate report and the banner say
+    # distinctiveness is not guaranteed. It is NOT a hard FAIL -- declining a
+    # taste input is a valid, user-approved state, not a broken chain. What IS a
+    # FAIL (a false claim) is handled by the degraded-claim cross-check; here we
+    # only read what preflight recorded.
+    #
+    # A missing line is treated as missing input, not as absent evidence: the
+    # preflight format (SKILL.md Phase -1) requires both lines, so an omitted
+    # line means the run never established the input.
+    voice = taste.get("voice", "").strip().lower()
+    design = taste.get("design-reference", "").strip().lower()
+
+    def overridden(key):
+        return bool(TASTE_OVERRIDE_ALIASES[key] & override)
+
+    # Voice: `default` (or absent) with no operator samples == no human register.
+    voice_present = voice in ("configured", "samples-supplied")
+    if not voice_present and not overridden("voice"):
+        emit(results, "WARN", preflight_path,
+             "voice taste input missing (voice: %s); run is PARTIAL, copy has no human "
+             "register to match -- gate report and banner must say distinctiveness is not "
+             "guaranteed (SKILL.md Phase -1 step 6, Phase 3)" % (voice or "unset"))
+
+    # Design reference: `none` (or absent) == taste invented from model priors.
+    design_present = bool(design) and design != "none"
+    if not design_present and not overridden("design-reference"):
+        emit(results, "WARN", preflight_path,
+             "design reference missing (design-reference: %s); run is PARTIAL, the "
+             "aesthetic is derived from model priors -- gate report and banner must say "
+             "distinctiveness is not guaranteed (SKILL.md Phase -1 step 6, Phase 4)"
+             % (design or "unset"))
+
+
+def rescan_voice(results, run_dir):
+    # #42 tier 1 (deterministic re-run): re-run the voice_scan tool IN-PROCESS
+    # over the frozen copy and fail if it finds FAIL-level violations. This is the
+    # un-fakeable half of the anti-backfill teeth -- a deterministic tool's output
+    # cannot be convincingly hand-authored, and here we do not even trust a stored
+    # report: we recompute the verdict from the shipped copy. A copy that carries
+    # banned phrases or em dashes means the Gate 2 scan never ran or shipped over
+    # its failures, whatever any evidence line claims. No subprocess, no network:
+    # voice_scan is a sibling stdlib module.
+    copy_path = run_dir / "copy" / "copy-approved.md"
+    if not copy_path.is_file():
+        return  # its absence is already a required-file FAIL elsewhere
+    if voice_scan is None:
+        emit(results, "WARN", copy_path,
+             "voice_scan module unavailable; could not re-run the Gate 2 scan (#42)")
+        return
+    try:
+        banned, judgment, patterns, cfg, _src = voice_scan.load_rules(None)
+        fails, _warns = voice_scan.scan_file(copy_path, banned, judgment, patterns, cfg)
+    except Exception as exc:  # pragma: no cover - defensive
+        emit(results, "WARN", copy_path, "voice re-scan errored (#42)", str(exc))
+        return
+    if fails:
+        first = fails[0]
+        emit(results, "FAIL", "%s:%s" % (copy_path, first[0]),
+             "shipped copy fails a fresh voice scan: %s -- the Gate 2 scan did not run "
+             "or shipped over its failures (#42 re-run)" % first[1],
+             (first[2] or "")[:80])
+    else:
+        emit(results, "PASS", copy_path, "fresh voice re-scan clean (#42)")
+
+
+def check_detect_scan(results, run_dir, workspace, pf_states, pf_override):
+    # #42 tier 1 for the impeccable detector. detect.mjs is a deterministic Node
+    # tool; its findings JSON is the artifact. run_audit is advertised stdlib-only
+    # with no subprocess (README.md:142, SECURITY.md), so it does NOT shell out to
+    # node -- it validates the stored scan's shape (proving the detector ran and
+    # produced parseable output, which a "never ran it" backfill will not have) and
+    # leaves the full node re-run+diff to Gate 5, which the skill performs with the
+    # tool itself. When impeccable was overridden at preflight, the scan's absence
+    # is advisory (honest PARTIAL), mirroring the DESIGN.md handling.
+    available = companion_available(pf_states, pf_override, "impeccable")
+    candidates = []
+    for base in ([workspace] if workspace else []) + [run_dir]:
+        candidates.append(base / ".impeccable" / "detect-scan.json")
+        candidates.append(base / "detect-scan.json")
+    scan_path = next((p for p in candidates if p.is_file()), None)
+    if scan_path is None:
+        if available:
+            emit(results, "FAIL", candidates[0],
+                 "impeccable is core and un-overridden, but no detect-scan.json on disk: "
+                 "Gate 5 must persist detect.mjs --json output as the design-gate artifact (#42)")
+        else:
+            emit(results, "WARN", candidates[0],
+                 "detect-scan.json absent (impeccable declined at preflight); design gate is degraded")
+        return
+    text = read_text(scan_path)
+    if isinstance(text, OSError):
+        emit(results, "FAIL", scan_path, "detect-scan.json unreadable", str(text))
+        return
+    try:
+        data = json.loads(text)
+    except ValueError as exc:
+        emit(results, "FAIL", scan_path,
+             "detect-scan.json is not valid JSON; a real detect.mjs --json run emits a "
+             "JSON array (empty = clean) (#42)", str(exc)[:80])
+        return
+    # detect.mjs --json emits an array of findings; empty array = clean (exit 0).
+    findings = data if isinstance(data, list) else data.get("findings") if isinstance(data, dict) else None
+    if findings is None:
+        emit(results, "FAIL", scan_path,
+             "detect-scan.json shape unexpected: detect.mjs --json emits a findings array (#42)")
+        return
+    emit(results, "PASS", scan_path,
+         "detect scan present and parseable (%d finding(s)) (#42)" % len(findings))
+
+
 def parse_voc(text):
     problems = []
     lines = text.splitlines()
@@ -413,6 +560,235 @@ def parse_persuasion_map(text):
     return problems
 
 
+def parse_humanizer(text):
+    # #42 tier 2: the humanizer artifact must show WHAT it changed, not merely
+    # that it ran. A diff-less file (prose saying "humanizer pass complete, reads
+    # clean") is the exact backfill this closes: it is cheap to fabricate and
+    # proves nothing. Require before/after diff structure -- labeled before/after
+    # pairs, or unified-diff -/+ line pairs, or a two-column before|after table.
+    # A pass that genuinely changed nothing still records the specific tells it
+    # inspected and cleared, which reads as before/after "kept" lines; a file with
+    # no diff structure at all fails.
+    problems = []
+    labeled = len(re.findall(r"(?im)^[\s>*_`|-]*before\s*:", text))
+    after = len(re.findall(r"(?im)^[\s>*_`|-]*after\s*:", text))
+    diff_pairs = min(labeled, after)
+    # Unified-diff style: a '-' line followed within a few lines by a '+' line.
+    minus = len(re.findall(r"(?m)^\s*-\s+\S", text))
+    plus = len(re.findall(r"(?m)^\s*\+\s+\S", text))
+    diff_pairs = max(diff_pairs, min(minus, plus))
+    # Two-column table: a header row naming before and after.
+    if re.search(r"(?im)^\s*\|?[^|\n]*\bbefore\b[^|\n]*\|[^|\n]*\bafter\b", text):
+        table_rows = len([r for r in text.splitlines()
+                          if r.count("|") >= 2 and not re.match(r"^\s*\|?[\s:|-]+\|?\s*$", r)])
+        diff_pairs = max(diff_pairs, table_rows - 1)  # minus the header row
+    if diff_pairs < 2:
+        problems.append("no before/after diffs; a humanizer artifact must show what it "
+                        "changed (labeled before/after, -/+ lines, or a before|after table), "
+                        "not just that it ran (#42)")
+    return problems
+
+
+def parse_red_team(text):
+    # #42 tier 2: the red-team read (Phase 3 / Gate 1) must carry the per-segment
+    # reader walks and where each reader bounces or converts -- the specifics a
+    # real walk produces, per rule 10 and TESTS #50 (including the anti-persona
+    # reader whose correct ending is self-disqualification). Structure floor: at
+    # least two reader/segment walks and at least one bounce/ending disposition.
+    problems = []
+    walks = len(re.findall(r"(?im)^[\s>*_#-]*(reader|segment|persona|entry[ -]?state)\b", text))
+    if walks < 2:
+        walks = max(walks, len(re.findall(r"(?i)\b(reader|segment|persona|entry[ -]?state)\b", text)) // 2)
+    endings = len(re.findall(r"(?i)\b(bounce|drops? off|leaves|disqualif|self-disqualif|converts?|reaches the cta|ending)\b", text))
+    if walks < 2:
+        problems.append("needs at least two per-segment reader walks (found ~%d)" % walks)
+    if endings < 1:
+        problems.append("needs a bounce/ending disposition per reader (found %d)" % endings)
+    return problems
+
+
+TASTE_AXIS_FAIL = {
+    "visual-engagement": {"flat", "wall", "text-wall", "text-document", "monotonous",
+                          "weak", "poor", "boring", "undifferentiated", "fail", "no"},
+    "property-specificity": {"generic", "skeleton", "average", "averaged", "template",
+                             "ai", "ai-generated", "interchangeable", "fail", "no"},
+}
+TASTE_AXIS_PASS = {
+    "visual-engagement": {"engaged", "structured", "strong", "rich", "varied", "scannable",
+                          "dynamic", "pass", "yes", "good"},
+    "property-specificity": {"specific", "distinctive", "property-specific", "only-this",
+                             "singular", "pass", "yes", "good"},
+}
+
+
+def parse_taste_judge(text):
+    # #44 established this artifact; #48 gives it teeth. It records a FRESH-context
+    # judge -- a cross-family model or a human, never a same-family pass (Claude
+    # blessing Claude's slop). The judge scores TWO named axes on the rendered
+    # page, each as a structured line:
+    #   visual-engagement: engaged | flat        (is the reading experience
+    #                                              structured, or a flat text wall?)
+    #   property-specificity: specific | generic  (could this only belong to this
+    #                                              product, or is it a skeleton?)
+    # A FAIL on either axis is a BLOCKING Gate 5 failure (#48): the flat wall of
+    # text that shipped on the 2026-07-27 dogfood had a cross-family "flat/skeleton"
+    # verdict and shipped anyway because the judge was advisory. The only escape is
+    # an explicit operator acceptance line (`accepted: <reason>`), the user's call
+    # in chat, never the builder's own. The honest "no independent judge available"
+    # clause still stands -- do not fake independence.
+    no_judge = re.search(
+        r"\b(no (cross-family|independent|fresh|human)\b.*\b(judge|context|review|check)"
+        r"|independence (was )?not (available|possible)"
+        r"|could not (be )?(judged|reviewed) (independently|cross-family))",
+        text, re.I)
+    if no_judge:
+        return []  # honest absence declared; nothing more to require
+    problems = []
+    accepted = re.search(r"(?im)^[\s>*_`-]*accepted\s*:\s*\S", text)
+    for axis in ("visual-engagement", "property-specificity"):
+        m = re.search(r"(?im)^[\s>*_`-]*" + axis + r"\s*:\s*([A-Za-z][\w-]*)", text)
+        if not m:
+            problems.append("taste-judge.md must carry a `%s:` verdict line (#48); a page "
+                            "with no verdict on this axis was not judged" % axis)
+            continue
+        verdict = m.group(1).strip().lower()
+        if verdict in TASTE_AXIS_FAIL[axis] and not accepted:
+            problems.append("taste judge FAILs on %s (verdict: %s); this is a blocking Gate 5 "
+                            "failure unless the operator accepts it in chat (add `accepted: "
+                            "<reason>`) (#48)" % (axis, verdict))
+        elif verdict not in TASTE_AXIS_PASS[axis] and verdict not in TASTE_AXIS_FAIL[axis]:
+            problems.append("taste-judge.md `%s:` verdict '%s' is not a recognized pass/fail "
+                            "value; say plainly whether the page passes this axis (#48)"
+                            % (axis, verdict))
+    has_tells = re.search(r"\b(tell|tells|no tells|giveaway|reads ai|reads generated|"
+                          r"specific to|only this)\b", text, re.I)
+    if not has_tells:
+        problems.append("taste-judge.md must name the tells behind the verdict (#44)")
+    return problems
+
+
+# Process/mechanics vocabulary for the #45 soft check: the pipeline talking about
+# its own plumbing rather than the buyer's outcome. Deliberately narrow -- generic
+# verbs are excluded so the flag fires on self-referential process language.
+MECHANICS_TELLS = re.compile(
+    r"\b(\d+\s+gates?|the gates?|ship gates?|clears? the gate|every phase|the pipeline|"
+    r"the spec(?:ification)?|MECLABS|voice[- ]scan|companion skills?|orchestrat\w*|"
+    r"the foundry|passes? (?:the|all|\d+) gates?)\b", re.I)
+
+
+def parse_mechanics_framing(copy_text, mechanics_is_value):
+    # #45 SOFT check (WARN, human-reviewed -- never an auto-fail). A defining AI
+    # tell is the tool selling its own MECHANICS (gates, phases, "9 gates", the
+    # spec, companion names) as the value prop instead of the buyer's outcome.
+    # But some products ARE their mechanics (a testing/security tool), which is
+    # why this is not a hard "never" rule: the per-product call is recorded in the
+    # Design-Strategy phase as `mechanics-as-value: yes`, and when that is set the
+    # check stays quiet. Absent that declaration the default is that outcomes are
+    # the value, so prevalent process language is surfaced for a human read.
+    if mechanics_is_value:
+        return None
+    hits = MECHANICS_TELLS.findall(copy_text)
+    # Threshold: one mention is fine ("passed the gates" as color); the PATTERN is
+    # the tell. Flag at 3+ so an incidental reference does not nag.
+    if len(hits) < 3:
+        return None
+    sample = ", ".join(sorted({h if isinstance(h, str) else h[0] for h in hits})[:4])
+    return ("%d process/mechanics references in the copy (e.g. %s); value claims may be "
+            "selling the pipeline's process, not the buyer's outcome -- confirm against the "
+            "Design-Strategy mechanics-as-value decision or reframe (#45, soft)" % (len(hits), sample))
+
+
+def parse_design_strategy(text):
+    # #46: the Design-Strategy artifact exists ONLY if it gates downstream phases;
+    # otherwise it is Phase 4 renamed. It is written before copy and design, is
+    # grounded in the EXTERNAL taste input (#41, not model priors), and both Phase
+    # 3 and Phase 4 consume it. Structure floor that proves it did the job it is
+    # for: the per-product mechanics-vs-outcome decision (consumed by the #45 soft
+    # check), a grounding in the named external reference (so the directions come
+    # from the reference, not the model's priors or the killed trend list), an
+    # anti-trope kill-list, and at least one named candidate direction.
+    problems = []
+    if not re.search(r"(?im)^[\s>*_`-]*mechanics-as-value\s*:", text):
+        problems.append("missing `mechanics-as-value: yes|no` decision (the #45 soft check reads it)")
+    grounded = re.search(r"\b(reference|grounded in|drawn from|anchor(ed)?|inspired by|"
+                         r"the .* site|the .* brand|committed theme)\b", text, re.I)
+    if not grounded:
+        problems.append("no grounding in the external taste input (#41): the directions must "
+                        "trace to the supplied reference, not model priors")
+    kill = re.search(r"\b(anti-trope|kill[- ]?list|avoid|reject|not this|tropes? to|do not use|"
+                     r"stay away from)\b", text, re.I)
+    if not kill:
+        problems.append("no anti-trope kill-list; an LLM told only to 'avoid tropes' rotates to "
+                        "a different predictable set")
+    directions = len(re.findall(r"(?im)^[\s>*_#-]*(direction|option|candidate|approach)\b", text))
+    if directions < 1 and not re.search(r"\bdirection\b", text, re.I):
+        problems.append("names no candidate design direction")
+    return problems
+
+
+def parse_copy_craft(text):
+    # #51: Gate 2 checks voice-CLEAN (no banned words, no AI patterns) -- both are
+    # ABSENCE checks. A page can be perfectly clean and still be generic and flat,
+    # which is what the dogfood shipped. This is the PRESENCE check: the copy is
+    # scored for craft, in the property's register (dry for a skeptical dev audience,
+    # never hype). Require the artifact to address at least three of the four craft
+    # dimensions, each with a specific on the page (not just the label).
+    dims = {
+        "specificity": r"\b(specific|concrete|real number|named result|exact|five seconds|"
+                       r"one command|no network|no subprocess)\b",
+        "through-line": r"\b(through[- ]line|model[- ]phrase|motif|refrain|recurring|tagline|"
+                        r"spec before pixels|the case before the page)\b",
+        "pacing": r"\b(pacing|short.*long|punchy|rhythm|cadence|varied|sentence length)\b",
+        "objection": r"\b(objection|pre[- ]?empt|anticipat|skeptic|doubt|answered where)\b",
+    }
+    present = [k for k, rx in dims.items() if re.search(rx, text, re.I)]
+    problems = []
+    if len(present) < 3:
+        problems.append("copy-craft.md must score at least three craft dimensions with a "
+                        "specific each (specificity, a memorable through-line, varied pacing, "
+                        "objection pre-emption); voice-clean is not voice-compelling (#51). "
+                        "Found: %s" % (", ".join(present) or "none"))
+    return problems
+
+
+def parse_imagery_plan(text):
+    # #49: "image-light by choice" was the loophole that produced the flat wall of
+    # text on the 2026-07-27 dogfood -- a section could declare itself text-only and
+    # pass with nothing carrying the visual load. Text is not the enemy; flat text
+    # is. So a section declared image-light/text-only must NAME the engagement
+    # mechanism that carries it instead of imagery (typographic hierarchy, emphasis,
+    # pull-quotes/callouts, numbered rhythm, visual breaks, varied pacing). A bare
+    # "no image by choice" with no mechanism anywhere fails.
+    declares_light = re.search(r"\b(image-light|no image|text-only|image-free|without imagery|"
+                               r"by choice|carries (?:its|the) (?:visual )?weight in type|"
+                               r"typographic(?:ally)? carries|type carries)\b", text, re.I)
+    if not declares_light:
+        return []
+    has_mechanism = re.search(r"\b(emphasis|bold(?:ed)?|italic|pull[- ]?quote|callout|"
+                              r"rhythm|hierarchy|cadence|numbered|visual break|scannab|"
+                              r"varied pacing|whitespace|type treatment|section marker|"
+                              r"typographic treatment|display type|oversized)\b", text, re.I)
+    if not has_mechanism:
+        return ["imagery-plan.md declares a section image-light but names no engagement "
+                "mechanism to carry it (emphasis, pull-quote, numbered rhythm, hierarchy, "
+                "visual break); 'no image by choice' is not a free pass (#49)"]
+    return []
+
+
+def read_mechanics_decision(run_dir):
+    # The per-product mechanics-as-value call lives in the Design-Strategy artifact
+    # (#46). Default False (outcomes are the value) when the file or line is absent,
+    # so the #45 soft check errs toward surfacing process language for a human.
+    for name in ("design-strategy.md", "design-strategy.md".upper()):
+        text = read_text(run_dir / name)
+        if isinstance(text, OSError):
+            continue
+        m = re.search(r"(?im)^[\s>*_`-]*mechanics-as-value\s*:\s*(\w+)", text)
+        if m:
+            return m.group(1).strip().lower() in ("yes", "true", "value", "on")
+    return False
+
+
 def parse_page_spec(text, archetype):
     problems = []
     if archetype.lower() not in text.lower():
@@ -497,6 +873,18 @@ def parse_conversion_audit(text):
     if missing_factors:
         warns.append("no compact factor breakdown (%s); documented for the log, not this file"
                      % ",".join(missing_factors))
+    # #50: the audit must score the READING EXPERIENCE, not just the argument. A
+    # wall of text is high friction to actually read; on the 2026-07-27 dogfood the
+    # audit scored Friction low on a page nobody would scan and passed it. `voc.md`
+    # says design decides whether the copy is read at all. Require an explicit
+    # scannability / reading-friction assessment against the rendered page.
+    reads = re.search(r"\b(scannab|reading friction|five[- ]second scan|5[- ]second scan|"
+                      r"scan the (rendered )?page|wall of text|skim|cold reader.*(scan|continue|"
+                      r"keep going)|visual(?:ly)? scan)\b", text, re.I)
+    if not reads:
+        problems.append("no reading-experience assessment: the audit must score whether a cold "
+                        "reader would scan the rendered page and want to continue (a flat text "
+                        "wall is a Friction finding), not just the argument (#50)")
     return problems, warns
 
 
@@ -801,11 +1189,12 @@ def audit_run(args):
     preflight_path = run_dir / "preflight.md"
     if preflight_path.is_file():
         pf_text = read_text(preflight_path)
-        pf_states, pf_override = parse_preflight(pf_text) if isinstance(pf_text, str) else ({}, set())
+        pf_states, pf_override, pf_taste = parse_preflight(pf_text) if isinstance(pf_text, str) else ({}, set(), {})
         emit(results, "PASS", preflight_path, "preflight recorded (%d companions, override: %s)"
              % (len(pf_states), ", ".join(sorted(pf_override)) or "none"))
+        check_taste_inputs(results, preflight_path, pf_taste, pf_override)
     else:
-        pf_states, pf_override = {}, set()
+        pf_states, pf_override, pf_taste = {}, set(), {}
         emit(results, "WARN", preflight_path,
              "preflight.md missing; degraded-claim cross-check unavailable, core artifacts held strict (SKILL.md Phase -1)")
 
@@ -884,6 +1273,33 @@ def audit_run(args):
                 required_infos.append(d_info)
         else:
             optional_file(results, design_path, "DESIGN.md (impeccable declined at preflight)", 5)
+        # #42 tier 1: the deterministic detector's stored JSON output is the
+        # design-gate artifact; validate its shape (node re-run stays a Gate 5 job).
+        check_detect_scan(results, run_dir, workspace, pf_states, pf_override)
+        # #44: the fresh/cross-family taste judge, mirroring Gate 1's cold score.
+        # Required in build/explore (a rendered page exists to judge); the verdict
+        # is advisory, the artifact's presence and honesty are enforced.
+        taste_info = require_file(results, run_dir / "taste-judge.md", "taste-judge.md", 3)
+        if taste_info:
+            required_infos.append(taste_info)
+        # #46: the Design-Strategy artifact, consumed by Phase 3 and Phase 4.
+        # Default-on; a user may decline it in chat, recorded on the preflight
+        # override line as `design-strategy`, in which case its absence is advisory.
+        if "design-strategy" in pf_override:
+            optional_file(results, run_dir / "design-strategy.md",
+                          "design-strategy.md (declined at preflight)", 4)
+        else:
+            ds_info = require_file(results, run_dir / "design-strategy.md", "design-strategy.md", 4)
+            if ds_info:
+                required_infos.append(ds_info)
+        # #51: the copy-craft judgment -- voice-compelling, not just voice-clean.
+        cc_info = require_file(results, run_dir / "copy-craft.md", "copy-craft.md", 3)
+        if cc_info:
+            required_infos.append(cc_info)
+
+    # #42 tier 1: re-run the voice scan in-process over the frozen copy. Runs in
+    # every mode -- the copy is written in Phase 3, which runs in handoff too.
+    rescan_voice(results, run_dir)
 
     if args["mode"] in ("build", "explore"):
         comp_info = require_file(results, run_dir / "comp" / "index.html", "comp/index.html", 3)
@@ -962,6 +1378,24 @@ def audit_run(args):
         elif path == run_dir / "persuasion-map.md":
             for why in parse_persuasion_map(text):
                 emit(results, "FAIL", path, why)
+        elif path == run_dir / "copy" / "humanizer.md":
+            for why in parse_humanizer(text):
+                emit(results, "FAIL", path, why)
+        elif path == run_dir / "red-team.md":
+            for why in parse_red_team(text):
+                emit(results, "FAIL", path, why)
+        elif path == run_dir / "taste-judge.md":
+            for why in parse_taste_judge(text):
+                emit(results, "FAIL", path, why)
+        elif path == run_dir / "design-strategy.md":
+            for why in parse_design_strategy(text):
+                emit(results, "FAIL", path, why)
+        elif path == run_dir / "imagery-plan.md":
+            for why in parse_imagery_plan(text):
+                emit(results, "FAIL", path, why)
+        elif path == run_dir / "copy-craft.md":
+            for why in parse_copy_craft(text):
+                emit(results, "FAIL", path, why)
         elif path == run_dir / "page-spec.md":
             for why in parse_page_spec(text, args["archetype"]):
                 emit(results, "FAIL", path, why)
@@ -979,6 +1413,13 @@ def audit_run(args):
     snapshot_title = None
     if not isinstance(snapshot_text, OSError):
         snapshot_title = extract_snapshot_title(snapshot_text)
+        # #45 soft check: is the copy selling the pipeline's mechanics instead of
+        # the buyer's outcome? WARN only, and silent when the Design-Strategy
+        # decision says the mechanics ARE the value (mechanics-as-value: yes).
+        mechanics_is_value = read_mechanics_decision(run_dir)
+        framing_warn = parse_mechanics_framing(snapshot_text, mechanics_is_value)
+        if framing_warn:
+            emit(results, "WARN", run_dir / "copy" / "copy-approved.md", framing_warn)
 
     if args["mode"] in ("build", "explore"):
         index_text = read_text(pages_dir / "index.html")
@@ -1072,6 +1513,14 @@ def audit_run(args):
     )
     if site_context_info:
         stale_edges.append((run_dir / "page-spec.md", run_dir / "site-context.md"))
+    # #46 consumption evidence: design-strategy is written BEFORE copy and design and
+    # steers both, so the copy draft (Phase 3) and the theme (Phase 4) postdate it.
+    # WARN-level, like every mtime edge -- an inversion means the strategy may have
+    # been written after the fact (referenced, not consumed), which a human reads.
+    if (run_dir / "design-strategy.md").is_file():
+        stale_edges.append((run_dir / "copy" / "approved-draft.md", run_dir / "design-strategy.md"))
+        if args["mode"] in ("build", "explore"):
+            stale_edges.append((pages_dir / "theme.css", run_dir / "design-strategy.md"))
     if token_source:
         stale_edges.append((run_dir / "comp" / "index.html", token_source))
         stale_edges.append((run_dir / "copy" / "copy-approved.md", token_source))

package/skills/page-foundry/tests/build_fixture.sh

@@ -29,9 +29,24 @@ cat > "$D/preflight.md" <<'E'
 | frontend-design | core | present | npx skills list |
 | humanizer | core | present | filesystem |
 | impeccable | core | present | npx impeccable |
+voice: configured
+design-reference: supplied: a real terminal instrument panel the owner named
 override: none
 E
 
+cat > "$D/design-strategy.md" <<'E'
+# Design strategy
+Written before copy and design; Phase 3 and Phase 4 both consume it.
+Grounded in the external reference the operator named (a real terminal instrument panel),
+not model priors and not a trend list.
+mechanics-as-value: no
+The buyer's outcome is the value here (a page that converts), not the gate count.
+## Candidate direction
+Direction A: instrument-panel restraint — mono display, hairline rules, one hot accent.
+## Anti-trope kill-list (avoid)
+- no brutalist-terminal cosplay, no quirky-serif pivot, no glassmorphism, no dark-by-default.
+E
+
 cat > "$D/voc.md" <<'E'
 # voc.md
 ## Verbatim
@@ -115,11 +130,61 @@ How: it writes the spec first, then builds from it.
 Install: one command.
 E
 
+cat > "$D/copy/humanizer.md" <<'E'
+# Humanizer pass — before/after
+The pass ran on approved-draft.md. Diffs it made, and the WARNs kept with reasons.
+before: In today's landscape, our robust platform seamlessly streamlines your workflow.
+after: You already know what an AI page looks like.
+before: We leverage cutting-edge orchestration to unlock synergy across every page.
+after: nobody can tell what it does.
+## Accepted WARNs
+- fragment cadence in the install steps: kept; the three commands are genuinely parallel.
+E
+
+cat > "$D/red-team.md" <<'E'
+# Red-team read (Phase 3 / Gate 1)
+Two entry states from voc.md, walked to their bounce or conversion point.
+## Reader: the skeptical solo builder (organic search, high intent)
+Lands on the hero, reads the case, reaches the CTA and converts on the one command.
+Bounce risk: the proof section is thin; if adoption stays TK he may drop off there.
+## Reader: the agency dev sent by a client (low intent, anti-persona)
+Correct ending is self-disqualification: this ships one page, not a site, so he leaves
+at the scope note rather than converting. That is the intended bounce, not a leak.
+E
+
+cat > "$D/copy-craft.md" <<'E'
+# Copy-craft judgment (voice-compelling, not just voice-clean)
+Scored on the built page in the property's dry register, no hype.
+## Specificity
+Concrete, checkable: "one command", "no network, no subprocess", the real artifact
+filenames on the page rather than vague claims.
+## Through-line
+A model-phrase recurs: "the spec before the page" opens the hero and closes the page.
+## Pacing
+Varied: short punchy openers next to longer explanation, not uniform paragraphs.
+## Objection pre-emption
+The safety doubt is answered where a skeptic raises it, not buried in a FAQ.
+E
+
+cat > "$D/taste-judge.md" <<'E'
+# Taste judge (fresh / cross-family)
+Judged by a cross-family model (codex/GPT) given only the rendered page and the
+design reference, never the author. Mirrors Gate 1's cold conversion score.
+## Verdict
+visual-engagement: engaged
+property-specificity: specific
+The instrument-panel motif could only belong to a terminal-native dev tool, and the
+reading experience is structured with real sections, not a flat wall of text.
+## Tells found
+- one weak tell: the eyebrow kicker cadence is slightly template-ish; noted, not blocking.
+No same-family self-review substituted.
+E
+
 cat > "$D/imagery-plan.md" <<'E'
 # Imagery plan
 Consistency rules: one grade (cool, high-contrast), 16:9 crops, hairline frames.
 - hero: real product screenshot, browser chrome cropped out, 16:9, cool grade.
-- proof: no image by choice; the gate report card carries the visual weight.
+- proof: no image by choice; the gate report card carries the visual weight through a bordered callout, numbered rhythm, and emphasis on the two scores.
 - how-it-works: a diagram of the real component flow, on-token line weights.
 Every image traces to a slot here; no product screenshot is a mockup.
 E
@@ -171,6 +236,11 @@ cat > "$ROOT/pages/demo/llms.txt" <<'E'
 The spec your page never got. Open source, MIT.
 E
 
+mkdir -p "$ROOT/.impeccable"
+cat > "$ROOT/.impeccable/detect-scan.json" <<'E'
+[]
+E
+
 cat > "$ROOT/DESIGN.md" <<'E'
 ---
 name: demo
@@ -194,6 +264,9 @@ The heuristic scored twice: the builder self-score from full context, then the
 score of record from a fresh agent given only the page and the brief.
 Self score: 31. Independent score: 27. Divergence: 4 points, concentrated on the
 install CTA which is the strongest lever and currently thinnest.
+Reading experience: a cold reader scans the rendered page in five seconds and the
+hero, the numbered stations, and the proof are all identifiable, so reading friction
+is low; this is not a flat wall of text. Scannability holds at 390 and 1440.
 E
 
 cat > "$D/foundry-log.md" <<'E'