@litfamily/lithermes 1.0.8 → 1.0.9

package/assets/lithermes-plugin/skills/lit-diagram-drawer/scripts/diagram_brief.py

@@ -0,0 +1,192 @@
+"""Brief-to-SVG checks for required content and trust-boundary membership."""
+
+from __future__ import annotations
+
+import re
+from typing import TypedDict
+
+from diagram_geometry import ParsedSvg, Shape, parse_svg
+
+
+class BriefEdge(TypedDict):
+    from_: str
+    to: str
+    label: str
+
+
+class BoundaryMembership(TypedDict):
+    declarationPresent: bool
+    declared: bool
+    internal: list[str]
+    external: list[str]
+
+
+class ParsedBrief(TypedDict):
+    nodes: list[str]
+    edges: list[BriefEdge]
+    language: str
+    allowedEnglishTerms: list[str]
+    boundaryMembership: BoundaryMembership
+
+
+class BoundaryReport(TypedDict):
+    declared: bool
+    boundaryCount: int
+    internal: list[str]
+    external: list[str]
+    issues: list[str]
+
+
+class BriefReport(TypedDict):
+    language: str
+    nodes: int
+    relationships: int
+    missingNodes: list[str]
+    missingLabels: list[str]
+    missingEdges: list[str]
+    unpairedLabels: list[str]
+    languageMismatches: list[str]
+    boundaryMembership: BoundaryReport
+
+
+def _terms(value: str) -> set[str]:
+    return {term.lower() for term in re.findall(r"[A-Za-z][A-Za-z0-9]*(?:[.+/#-][A-Za-z0-9]+)*", value)}
+
+
+def parse_brief(text: str) -> ParsedBrief:
+    """Parse the explicit node, route, language, and boundary brief fields."""
+    lines = [line.strip() for line in text.splitlines()]
+    nodes: list[str] = []
+    edges: list[BriefEdge] = []
+    for line in lines:
+        fact = re.match(r"^[-*]\s*(.+?)\s+participates in the labeled relationships below\.$", line)
+        relation = re.match(r"^[-*]\s*(.+?)\s+→\s+(.+?)\s+\((.+)\)$", line)
+        if fact:
+            nodes.append(fact.group(1))
+        elif relation:
+            edges.append({"from_": relation.group(1), "to": relation.group(2), "label": relation.group(3)})
+    unique_nodes = list(dict.fromkeys(nodes))
+    title = next((line[2:].strip() for line in lines if line.startswith("# ")), "")
+    title = re.sub(r"^(?:Diagram brief\s*[·:]\s*|Blind brief:\s*)", "", title, flags=re.IGNORECASE)
+    purpose = next((re.sub(r"^[-*]\s*Purpose:\s*", "", line, flags=re.IGNORECASE) for line in lines if re.match(r"^[-*]\s*Purpose:", line, re.IGNORECASE)), "")
+    content_parts = [title, purpose, *unique_nodes, *(part for edge in edges for part in (edge["from_"], edge["to"], edge["label"]))]
+    language_sample = " ".join(content_parts)
+    language = "ko" if len(re.findall(r"[\uac00-\ud7a3]", language_sample)) > len(re.findall(r"[A-Za-z]", language_sample)) else "en"
+    internal_line = next((line for line in lines if re.match(r"^[-*]\s*Trust boundary internal nodes:", line, re.IGNORECASE)), "")
+    external_line = next((line for line in lines if re.match(r"^[-*]\s*Trust boundary external nodes:", line, re.IGNORECASE)), "")
+
+    def members(line: str) -> list[str]:
+        return [name.strip() for name in line.split(":", 1)[1].split(";") if name.strip()] if line else []
+
+    allowed = _terms(" ".join(part for part in content_parts if part))
+    allowed.update(term.lower() for code in re.findall(r"`([^`]+)`", text) for term in _terms(code))
+    allowed.update(
+        term.lower()
+        for line in lines
+        if re.match(r"^[-*]\s*Allowed (?:English )?terms:", line, re.IGNORECASE)
+        for term in _terms(re.sub(r"^[-*]\s*Allowed (?:English )?terms:\s*", "", line, flags=re.IGNORECASE))
+    )
+    membership: BoundaryMembership = {
+        "declarationPresent": bool(internal_line or external_line),
+        "declared": bool(internal_line and external_line),
+        "internal": members(internal_line),
+        "external": members(external_line),
+    }
+    return {
+        "nodes": unique_nodes,
+        "edges": edges,
+        "language": language,
+        "allowedEnglishTerms": sorted(allowed),
+        "boundaryMembership": membership,
+    }
+
+
+def _boundary_membership(parsed: ParsedSvg, membership: BoundaryMembership) -> BoundaryReport:
+    boundary_shapes = [shape for shape in parsed.shapes if "data-trust-boundary" in shape.attributes]
+    issues: list[str] = []
+    declared = membership["declared"]
+    if not membership["declarationPresent"]:
+        if boundary_shapes:
+            issues.append("BOUNDARY_MEMBERSHIP_DECLARATION_MISSING")
+        return {"declared": False, "boundaryCount": len(boundary_shapes), "internal": [], "external": [], "issues": issues}
+    if not declared:
+        issues.append("BOUNDARY_MEMBERSHIP_DECLARATION_INCOMPLETE")
+    internal, external = membership["internal"], membership["external"]
+    if not internal:
+        issues.append("BOUNDARY_INTERNAL_LIST_EMPTY")
+    if not external:
+        issues.append("BOUNDARY_EXTERNAL_LIST_EMPTY")
+    for names in (internal, external):
+        seen: set[str] = set()
+        for name in names:
+            if name in seen:
+                issues.append(f"BOUNDARY_MEMBERSHIP_DUPLICATE name={name}")
+            seen.add(name)
+    external_names = set(external)
+    for name in internal:
+        if name in external_names:
+            issues.append(f"BOUNDARY_MEMBERSHIP_CONFLICT name={name}")
+    if len(boundary_shapes) != 1:
+        issues.append(f"BOUNDARY_COUNT expected=1 actual={len(boundary_shapes)}")
+        return {"declared": True, "boundaryCount": len(boundary_shapes), "internal": internal, "external": external, "issues": issues}
+    boundary = boundary_shapes[0].rect
+    if boundary.w <= 0 or boundary.h <= 0:
+        issues.append("BOUNDARY_GEOMETRY_INVALID")
+        return {"declared": True, "boundaryCount": 1, "internal": internal, "external": external, "issues": issues}
+    nodes = [shape for shape in parsed.shapes if shape.attributes.get("data-node-id")]
+    node_names = {shape.attributes["data-node-id"] for shape in nodes}
+    expected = set(internal + external)
+    for name in sorted(expected - node_names):
+        issues.append(f"BOUNDARY_NODE_MISSING name={name}")
+    for node in nodes:
+        name = node.attributes["data-node-id"]
+        rect = node.rect
+        if rect.w <= 0 or rect.h <= 0:
+            issues.append(f"BOUNDARY_NODE_GEOMETRY_INVALID name={name}")
+        elif name not in expected:
+            issues.append(f"BOUNDARY_NODE_UNDECLARED name={name}")
+        else:
+            inside = rect.x >= boundary.x and rect.y >= boundary.y and rect.right <= boundary.right and rect.bottom <= boundary.bottom
+            outside = rect.right <= boundary.x or rect.x >= boundary.right or rect.bottom <= boundary.y or rect.y >= boundary.bottom
+            if name in internal and not inside:
+                issues.append(f"BOUNDARY_NODE_NOT_INTERNAL name={name}")
+            if name in external_names and not outside:
+                issues.append(f"BOUNDARY_NODE_NOT_EXTERNAL name={name}")
+    return {"declared": True, "boundaryCount": 1, "internal": internal, "external": external, "issues": issues}
+
+
+def check_brief(source: str, brief: str) -> BriefReport:
+    """Compare visible labels and declared edge endpoints with an authored brief."""
+    contract = parse_brief(brief)
+    parsed = parse_svg(source)
+    texts = {text.label for text in parsed.texts}
+    allowed = set(contract["allowedEnglishTerms"])
+    mismatches = []
+    if contract["language"] == "ko":
+        for text in texts:
+            unapproved = [term for term in re.findall(r"[A-Za-z][A-Za-z0-9]*(?:[.+/#-][A-Za-z0-9]+)*", text) if term.lower() not in allowed]
+            if unapproved:
+                mismatches.append(f"{text}: {' | '.join(unapproved)}")
+    missing_nodes = [name for name in contract["nodes"] if name not in texts]
+    missing_labels = [edge["label"] for edge in contract["edges"] if edge["label"] not in texts]
+    missing_edges = [
+        f"{edge['from_']}->{edge['to']}:{edge['label']}"
+        for edge in contract["edges"]
+        if not any(route.from_id == edge["from_"] and route.to_id == edge["to"] and route.label == edge["label"] for route in parsed.routes)
+    ]
+    unpaired = [
+        edge["label"]
+        for edge in contract["edges"]
+        if not any(text.edge_for == f"{edge['from_']}|{edge['to']}" and text.label == edge["label"] for text in parsed.texts)
+    ]
+    return {
+        "language": contract["language"],
+        "nodes": len(contract["nodes"]),
+        "relationships": len(contract["edges"]),
+        "missingNodes": missing_nodes,
+        "missingLabels": missing_labels,
+        "missingEdges": missing_edges,
+        "unpairedLabels": unpaired,
+        "languageMismatches": mismatches,
+        "boundaryMembership": _boundary_membership(parsed, contract["boundaryMembership"]),
+    }

package/assets/lithermes-plugin/skills/lit-diagram-drawer/scripts/diagram_catalog.py

@@ -0,0 +1,135 @@
+"""Catalog closure, type identity, and reduced-motion checks."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+import re
+from typing import TypedDict
+
+from diagram_geometry import parse_svg
+from diagram_metrics import source_metrics
+from diagram_sequence import sequence_issues
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+
+
+class CatalogEntry(TypedDict):
+    id: str
+    reference: str
+    variants: list[str]
+    family: str
+
+
+class DiagramCatalog(TypedDict):
+    entries: list[CatalogEntry]
+
+
+class CatalogAudit(TypedDict):
+    issues: list[str]
+    entries: int
+    templates: int
+
+
+def audit_catalog(catalog: DiagramCatalog) -> CatalogAudit:
+    """Check reference and template closure and reject duplicate or missing types."""
+    issues: list[str] = []
+    expected_templates: set[str] = set()
+    seen: set[str] = set()
+    entries = catalog["entries"]
+    for entry in entries:
+        type_id = entry["id"]
+        if type_id in seen:
+            issues.append(f"DUPLICATE_ID {type_id}")
+        seen.add(type_id)
+        reference = SKILL_ROOT / "references" / entry["reference"]
+        if not reference.is_file():
+            issues.append(f"TYPE_GUIDE_MISSING {type_id} {entry['reference']}")
+        for variant in ("light", "dark", "full"):
+            if variant not in entry["variants"]:
+                issues.append(f"VARIANT_MISSING {type_id} {variant}")
+            template = f"assets/examples/type-{type_id}-{variant}.html"
+            expected_templates.add(template)
+            if not (SKILL_ROOT / template).is_file():
+                issues.append(f"TEMPLATE_MISSING {template}")
+    actual_templates = {
+        path.relative_to(SKILL_ROOT).as_posix()
+        for path in (SKILL_ROOT / "assets" / "examples").glob("type-*.html")
+    }
+    for orphan in sorted(actual_templates - expected_templates):
+        issues.append(f"TEMPLATE_ORPHAN {orphan}")
+    if not (SKILL_ROOT / "assets" / "fonts" / "OFL.txt").is_file():
+        issues.append("PRETENDARD_OFL_MISSING")
+    if not (SKILL_ROOT / "assets" / "fonts" / "PretendardVariable.woff2").is_file():
+        issues.append("PRETENDARD_FONT_MISSING")
+    if not (SKILL_ROOT / "assets" / "icons.html").is_file():
+        issues.append("ICON_SHEET_MISSING")
+    return {"issues": issues, "entries": len(entries), "templates": len(actual_templates)}
+
+
+def _catalog_entry(type_id: str) -> CatalogEntry | None:
+    catalog_path = SKILL_ROOT / "references" / "type-catalog.json"
+    catalog: DiagramCatalog = json.loads(catalog_path.read_text(encoding="utf-8"))
+    return next((entry for entry in catalog["entries"] if entry["id"] == type_id), None)
+
+
+def verify_type(source: str, type_id: str) -> list[str]:
+    """Check type ID, template variant, family minimums, and declared semantics."""
+    entry = _catalog_entry(type_id)
+    if entry is None:
+        return [f"TYPE_UNKNOWN {type_id}"]
+    parsed = parse_svg(source)
+    metrics = source_metrics(source)
+    issues: list[str] = []
+    type_markers = (f'data-type="{type_id}"', f"id=\"diagram-{type_id}-")
+    if not any(marker in source for marker in type_markers):
+        issues.append("TYPE_ID_MISMATCH")
+    if not (SKILL_ROOT / "references" / entry["reference"]).is_file():
+        issues.append("TYPE_GUIDE_MISSING")
+    has_variant = bool(re.search(r"data-variant\s*=\s*['\"](?:light|dark|full)['\"]", source, re.IGNORECASE))
+    has_variant = has_variant or bool(re.search(r"id=['\"]diagram-[a-z0-9-]+-(?:light|dark|full)['\"]", parsed.svg, re.IGNORECASE))
+    if not has_variant:
+        issues.append("VARIANT_MISSING")
+    if entry["family"] == "quantitative" and metrics["textCount"] < 3:
+        issues.append("QUANTITATIVE_LABELS_MISSING")
+    rectangle_count = len(re.findall(r"<rect\b", source, re.IGNORECASE))
+    circle_count = len(re.findall(r"<circle\b", source, re.IGNORECASE))
+    if type_id == "heatmap" and rectangle_count < 16:
+        issues.append("HEATMAP_GRID_TOO_SMALL")
+    if type_id == "treemap" and rectangle_count < 6:
+        issues.append("TREEMAP_TILES_TOO_FEW")
+    if type_id == "sankey" and not re.search(r"<path\b[^>]*stroke-width\s*=\s*['\"][1-9]", source, re.IGNORECASE):
+        issues.append("SANKEY_RIBBON_WIDTH_MISSING")
+    if type_id == "waterfall" and rectangle_count < 5:
+        issues.append("WATERFALL_STEPS_TOO_FEW")
+    if type_id == "beeswarm" and circle_count < 20:
+        issues.append("BEESWARM_MARKS_TOO_FEW")
+    if type_id == "bubble" and circle_count < 6:
+        issues.append("BUBBLE_MARKS_TOO_FEW")
+    if type_id in {"polar", "radar"} and not re.search(r"<polygon\b", source, re.IGNORECASE):
+        issues.append(f"{type_id.upper()}_SHAPE_MISSING")
+    if type_id in {"sequence", "sequence-oauth"}:
+        nodes = tuple(shape for shape in parsed.shapes if shape.attributes.get("data-node-id"))
+        issues.extend(f"SEQUENCE {issue}" for issue in sequence_issues(source, parsed, nodes))
+    semantic_terms = {
+        "policy-trace-animated": ("rule", "policy", "allow", "deny"),
+        "queue-animated": ("queue", "buffer", "drain", "fan-in"),
+        "paved-road-animated": ("boundary", "guardrail", "secure", "policy"),
+    }.get(type_id, ())
+    if semantic_terms and not re.search(r"\b(?:" + "|".join(semantic_terms) + r")\b", source, re.IGNORECASE):
+        issues.append(type_id.upper().replace("-", "_") + "_SEMANTIC_MISSING")
+    return issues
+
+
+def verify_motion(source: str) -> list[str]:
+    """Require static SVG and reduced-motion safeguards for authored animation."""
+    issues: list[str] = []
+    if re.search(r"<(?:animate|set)\b", source, re.IGNORECASE):
+        issues.append("SVG_ANIMATION_NOT_STATIC")
+    if re.search(r"animation\s*:\s*(?!none\b)[^;}]+", source, re.IGNORECASE) and not re.search(r"@media\s*\(prefers-reduced-motion\s*:\s*reduce\)[\s\S]*?animation\s*:\s*none", source, re.IGNORECASE):
+        issues.append("REDUCED_MOTION_RULE_MISSING")
+    if re.search(r"autoplay|infinite", source, re.IGNORECASE):
+        issues.append("UNBOUNDED_MOTION")
+    if re.search(r"<script\b", source, re.IGNORECASE) and not re.search(r"prefers-reduced-motion|matchMedia", source, re.IGNORECASE):
+        issues.append("MOTION_CONTROLLER_REDUCED_MOTION_MISSING")
+    return issues

package/assets/lithermes-plugin/skills/lit-diagram-drawer/scripts/diagram_checks.py

@@ -0,0 +1,123 @@
+"""Hermes-local verifier API backed by Python stdlib and LitHumanizer."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+import sys
+from typing import TypedDict
+
+_PLUGIN_ROOT = Path(__file__).resolve().parents[3]
+if str(_PLUGIN_ROOT) not in sys.path:
+    sys.path.insert(0, str(_PLUGIN_ROOT))
+
+import humanizer_detector
+from diagram_brief import BriefReport, check_brief
+from diagram_catalog import CatalogAudit, DiagramCatalog, audit_catalog, verify_motion, verify_type
+from diagram_metrics import DiagramMetrics, source_metrics
+from diagram_quality import quality_issues
+
+
+class HumanizerFinding(TypedDict):
+    file: str
+    rule: str
+    severity: str
+    line: int
+    line_end: int
+    match: str
+    excerpt: str
+
+
+class HumanizerSummary(TypedDict):
+    block: int
+    warn: int
+
+
+class VisibleTextReport(TypedDict):
+    findings: list[HumanizerFinding]
+    summary: HumanizerSummary
+
+
+class DiagramReport(TypedDict):
+    issues: list[str]
+    metrics: DiagramMetrics
+    visibleText: VisibleTextReport
+
+
+class CorpusReport(TypedDict):
+    issues: list[str]
+    templatesChecked: int
+    examplesChecked: int
+
+
+def check_visible_text(text: str) -> VisibleTextReport:
+    """Run the installed plugin's exact LitHumanizer rules on diagram text."""
+    raw = humanizer_detector.scan_text(text, rules=humanizer_detector.load_rules(), file="<stdin>")
+    findings: list[HumanizerFinding] = [
+        {
+            "file": str(item["file"]),
+            "rule": str(item["rule"]),
+            "severity": str(item["severity"]),
+            "line": int(item["line"]),
+            "line_end": int(item["line_end"]),
+            "match": str(item["match"]),
+            "excerpt": str(item["excerpt"]),
+        }
+        for item in raw
+    ]
+    return {
+        "findings": findings,
+        "summary": {
+            "block": sum(item["severity"] == "block" for item in findings),
+            "warn": sum(item["severity"] == "warn" for item in findings),
+        },
+    }
+
+
+def verify_diagram(source: str, source_path: str = "<stdin>", *, enforce_canvas: bool = False) -> DiagramReport:
+    """Run geometry, accessibility, and direct LitHumanizer checks for one source."""
+    metrics = source_metrics(source, source_path)
+    visible = check_visible_text(metrics["visibleText"])
+    issues = quality_issues(source, enforce_canvas=enforce_canvas)
+    blocks = [item for item in visible["findings"] if item["severity"] == "block"]
+    issues.extend(f"VISIBLE_TEXT_BLOCK {item['rule']} line={item['line']}" for item in blocks)
+    return {"issues": list(dict.fromkeys(issues)), "metrics": metrics, "visibleText": visible}
+
+
+def verify_corpus() -> CorpusReport:
+    """Check every catalog template and every approved after-example in the payload."""
+    catalog: DiagramCatalog = json.loads((Path(__file__).resolve().parents[1] / "references" / "type-catalog.json").read_text(encoding="utf-8"))
+    audit: CatalogAudit = audit_catalog(catalog)
+    issues = list(audit["issues"])
+    if len(catalog["entries"]) != 61:
+        issues.append(f"CATALOG_COUNT expected=61 actual={len(catalog['entries'])}")
+    skill_root = Path(__file__).resolve().parents[1]
+    template_count = 0
+    for entry in catalog["entries"]:
+        for variant in ("light", "dark", "full"):
+            path = skill_root / "assets" / "examples" / f"type-{entry['id']}-{variant}.html"
+            if not path.is_file():
+                continue
+            template_count += 1
+            source = path.read_text(encoding="utf-8")
+            report = verify_diagram(source, str(path))
+            issues.extend(f"{path.name}: {issue}" for issue in report["issues"])
+            issues.extend(f"{path.name}: {issue}" for issue in verify_type(source, entry["id"]))
+            issues.extend(f"{path.name}: {issue}" for issue in verify_motion(source))
+    if template_count != 183:
+        issues.append(f"TEMPLATE_COUNT expected=183 actual={template_count}")
+    examples = sorted((skill_root / "examples").glob("*/after.html"))
+    for path in examples:
+        source = path.read_text(encoding="utf-8")
+        report = verify_diagram(source, str(path), enforce_canvas=True)
+        issues.extend(f"{path.parent.name}: {issue}" for issue in report["issues"])
+        issues.extend(f"{path.parent.name}: {issue}" for issue in verify_motion(source))
+        brief_path = path.with_name("brief.md")
+        if brief_path.is_file():
+            brief = check_brief(source, brief_path.read_text(encoding="utf-8"))
+            for key in ("missingNodes", "missingLabels", "missingEdges", "unpairedLabels", "languageMismatches"):
+                issues.extend(f"{path.parent.name}: BRIEF_{key.upper()} {value}" for value in brief[key])
+            issues.extend(f"{path.parent.name}: {issue}" for issue in brief["boundaryMembership"]["issues"])
+    if len(examples) != 8:
+        issues.append(f"EXAMPLE_COUNT expected=8 actual={len(examples)}")
+    return {"issues": list(dict.fromkeys(issues)), "templatesChecked": template_count, "examplesChecked": len(examples)}

package/assets/lithermes-plugin/skills/lit-diagram-drawer/scripts/diagram_cli.py

@@ -0,0 +1,94 @@
+"""Command-line boundaries for the bundled deterministic diagram checks."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+import sys
+
+from diagram_checks import check_brief, check_visible_text, verify_corpus, verify_diagram, verify_motion, verify_type
+from diagram_metrics import source_metrics
+
+
+def _read_source(path: str) -> str:
+    return Path(path).expanduser().read_text(encoding="utf-8")
+
+
+def _emit_issues(label: str, issues: list[str]) -> int:
+    print(json.dumps({"result": label, "issues": issues}, ensure_ascii=False, indent=2))
+    return 1 if issues else 0
+
+
+def verify_diagram_main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Verify SVG geometry, accessibility, and visible text.")
+    parser.add_argument("source", help="diagram HTML or SVG")
+    parser.add_argument("--canvas", action="store_true", help="enforce title, font, and content-fill floors")
+    args = parser.parse_args(argv)
+    try:
+        report = verify_diagram(_read_source(args.source), args.source, enforce_canvas=args.canvas)
+    except OSError as error:
+        print(f"VERIFY_DIAGRAM_READ_ERROR {error}", file=sys.stderr)
+        return 2
+    print(json.dumps(report, ensure_ascii=False, indent=2))
+    return 1 if report["issues"] else 0
+
+
+def verify_type_main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Verify catalog identity and type-specific requirements.")
+    parser.add_argument("--type", required=True, help="catalog type ID")
+    parser.add_argument("source", help="diagram HTML or SVG")
+    args = parser.parse_args(argv)
+    try:
+        return _emit_issues("TYPE", verify_type(_read_source(args.source), args.type))
+    except OSError as error:
+        print(f"VERIFY_TYPE_READ_ERROR {error}", file=sys.stderr)
+        return 2
+
+
+def verify_brief_main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Check diagram content and trust-boundary membership against a brief.")
+    parser.add_argument("--brief", required=True, help="Markdown diagram brief")
+    parser.add_argument("source", help="diagram HTML or SVG")
+    args = parser.parse_args(argv)
+    try:
+        report = check_brief(_read_source(args.source), _read_source(args.brief))
+    except OSError as error:
+        print(f"VERIFY_BRIEF_READ_ERROR {error}", file=sys.stderr)
+        return 2
+    print(json.dumps(report, ensure_ascii=False, indent=2))
+    issues = [*report["missingNodes"], *report["missingLabels"], *report["missingEdges"], *report["unpairedLabels"], *report["languageMismatches"], *report["boundaryMembership"]["issues"]]
+    return 1 if issues else 0
+
+
+def verify_motion_main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Check SVG and CSS motion for bounded reduced-motion behavior.")
+    parser.add_argument("source", help="diagram HTML or SVG")
+    args = parser.parse_args(argv)
+    try:
+        return _emit_issues("MOTION", verify_motion(_read_source(args.source)))
+    except OSError as error:
+        print(f"VERIFY_MOTION_READ_ERROR {error}", file=sys.stderr)
+        return 2
+
+
+def check_visible_text_main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Run the product-local LitHumanizer detector on text or diagram HTML.")
+    parser.add_argument("source", help="text, diagram HTML, or SVG")
+    args = parser.parse_args(argv)
+    try:
+        source = _read_source(args.source)
+    except OSError as error:
+        print(f"CHECK_TEXT_READ_ERROR {error}", file=sys.stderr)
+        return 2
+    text = source_metrics(source, args.source)["visibleText"] if "<svg" in source.lower() else source
+    report = check_visible_text(text)
+    print(json.dumps(report, ensure_ascii=False, indent=2))
+    return 2 if report["summary"]["block"] else 1 if report["summary"]["warn"] else 0
+
+
+def verify_corpus_main(argv: list[str] | None = None) -> int:
+    argparse.ArgumentParser(description="Verify all 183 catalog templates and eight after-examples.").parse_args(argv)
+    report = verify_corpus()
+    print(json.dumps(report, ensure_ascii=False, indent=2))
+    return 1 if report["issues"] else 0