@topy-ai/maggie 0.7.48 → 0.7.49

package/bundled-tools/clis/maggie_icon_glyph_check.py

@@ -0,0 +1,382 @@
+#!/usr/bin/env python3
+"""Collect rendered icon-glyph evidence in headless Chrome.
+
+Source-to-runtime inventory proves names, not pixels. This collector renders
+representative icons on each route and viewport and records, per icon:
+
+- whether its icon font is in ``document.fonts`` with status ``loaded``;
+- whether the glyph paints ink that differs from the browser fallback font
+  (a missing glyph falls back to another font or a blank box);
+- whether runtime CSS hides it (``display``, ``visibility``, ``opacity``,
+  zero size, or a ``content: none`` pseudo-element);
+- its family, accessible name, and the HTTP status of the icon font assets.
+
+The target is either a running host (``--base-url``, proxied through a local
+read-only GET proxy so the probe and fonts share one origin) or a static build
+(``--dist``). Only GET requests are forwarded; the report never stores page
+text beyond icon names and accessible labels.
+"""
+
+from __future__ import annotations
+
+import argparse
+import html as html_lib
+import json
+import re
+import shutil
+import subprocess
+import sys
+import threading
+from datetime import datetime, timezone
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from urllib.error import HTTPError, URLError
+from urllib.parse import urlsplit
+from urllib.request import Request, urlopen
+
+SCHEMA = "maggie-icon-browser-evidence.v1"
+COLLECTOR = "maggie-icon-glyph-check"
+DEFAULT_VIEWPORTS = {"mobile": (390, 844), "tablet": (768, 1024), "desktop": (1440, 900)}
+FONT_EXTENSIONS = (".woff2", ".woff", ".ttf", ".otf", ".eot")
+REPORT_ID = "maggie-icon-probe-report"
+DEFAULT_SELECTOR = (
+    "i[class*='ph'], span[class*='ph-'], [class^='ph-'], [class*=' ph-'], i[class*='fa-'], span[class*='fa-'], "
+    "[class*='lucide'], [data-icon], [data-glyph], .material-icons, .material-symbols-outlined, "
+    ".material-symbols-rounded, .bi, [class*='bi-']"
+)
+
+PROBE = r"""
+(() => {
+  const config = __CONFIG__;
+  const out = document.createElement('pre');
+  out.id = config.reportId; out.hidden = true;
+  const norm = (value) => String(value || '').split(',')[0].trim().replace(/^['"]|['"]$/g, '').toLowerCase();
+  const nameOf = (el) => {
+    const attr = el.getAttribute('data-icon') || el.getAttribute('data-glyph');
+    if (attr) return attr;
+    for (const token of Array.from(el.classList)) {
+      const match = token.match(/^(?:ph|fa|lucide|bi)-([a-z0-9-]+)$/i);
+      if (match && !/^(?:thin|light|regular|bold|fill|duotone|solid|brands|fw|lg|xl)$/i.test(match[1])) return match[1];
+    }
+    const text = (el.textContent || '').trim();
+    if (/material/.test(el.className) && text) return text;
+    return el.tagName.toLowerCase() === 'svg' ? (el.getAttribute('data-lucide') || 'svg') : (el.className || el.tagName).toString().slice(0, 60);
+  };
+  const hiddenBy = (el) => {
+    for (let node = el; node && node.nodeType === 1; node = node.parentElement) {
+      const style = getComputedStyle(node);
+      if (style.display === 'none') return node === el ? 'display:none' : 'ancestor display:none';
+      if (style.visibility === 'hidden' || style.visibility === 'collapse') return 'visibility:' + style.visibility;
+      if (Number(style.opacity) === 0) return node === el ? 'opacity:0' : 'ancestor opacity:0';
+      if (node === document.body) break;
+    }
+    return null;
+  };
+  const accessibleName = (el) => {
+    const direct = el.getAttribute('aria-label') || el.getAttribute('title');
+    if (direct && direct.trim()) return { name: direct.trim(), decorative: false };
+    const labelledby = el.getAttribute('aria-labelledby');
+    if (labelledby) {
+      const text = labelledby.split(/\s+/).map((id) => document.getElementById(id)?.textContent || '').join(' ').trim();
+      if (text) return { name: text, decorative: false };
+    }
+    const control = el.closest('a,button,[role=button],[role=link],label,summary');
+    if (control) {
+      const label = control.getAttribute('aria-label') || control.getAttribute('title') || (control.textContent || '').replace(/\s+/g, ' ').trim();
+      if (label) return { name: label.slice(0, 120), decorative: el.getAttribute('aria-hidden') === 'true' };
+    }
+    const parentText = (el.parentElement?.textContent || '').replace(/\s+/g, ' ').trim();
+    return { name: parentText.slice(0, 120), decorative: true };
+  };
+  const pixels = (font, text) => {
+    const canvas = document.createElement('canvas'); canvas.width = 64; canvas.height = 64;
+    const ctx = canvas.getContext('2d'); ctx.clearRect(0, 0, 64, 64); ctx.fillStyle = '#000';
+    ctx.textBaseline = 'middle'; ctx.font = font; ctx.fillText(text, 8, 32);
+    const data = ctx.getImageData(0, 0, 64, 64).data; let ink = 0; let hash = 0;
+    for (let i = 3; i < data.length; i += 4) { if (data[i]) ink += 1; hash = (hash * 31 + data[i]) | 0; }
+    return { ink, hash };
+  };
+  const glyphText = (el) => {
+    for (const pseudo of ['::before', '::after']) {
+      const style = getComputedStyle(el, pseudo);
+      const content = style.content;
+      if (content && content !== 'none' && content !== 'normal' && content !== '""') {
+        return { text: content.replace(/^["']|["']$/g, ''), style, pseudo };
+      }
+    }
+    const text = (el.textContent || '').trim();
+    return text ? { text, style: getComputedStyle(el), pseudo: null } : null;
+  };
+  const run = () => {
+    const icons = []; const seen = new Set();
+    for (const el of Array.from(document.querySelectorAll(config.selector))) {
+      const name = nameOf(el);
+      if (seen.has(name) || icons.length >= config.maxIcons) continue;
+      seen.add(name);
+      const rect = el.getBoundingClientRect();
+      const hidden = hiddenBy(el);
+      const label = accessibleName(el);
+      const record = { name, tag: el.tagName.toLowerCase(), width: Math.round(rect.width * 100) / 100, height: Math.round(rect.height * 100) / 100, hiddenBy: hidden, accessibleName: label.name, decorative: label.decorative };
+      if (el.tagName.toLowerCase() === 'svg' || el.querySelector('svg')) {
+        const svg = el.tagName.toLowerCase() === 'svg' ? el : el.querySelector('svg');
+        const box = svg.getBoundingClientRect();
+        record.kind = 'svg';
+        record.glyphPainted = box.width > 0 && box.height > 0 && !!svg.querySelector('path,circle,rect,line,polyline,polygon,use,ellipse');
+        record.fontLoaded = null; record.fontFamily = null;
+      } else if (el.tagName.toLowerCase() === 'img') {
+        record.kind = 'img';
+        record.glyphPainted = el.complete && el.naturalWidth > 0;
+        record.fontLoaded = null; record.fontFamily = null;
+      } else {
+        const glyph = glyphText(el);
+        record.kind = 'font';
+        if (!glyph) {
+          record.fontFamily = norm(getComputedStyle(el).fontFamily); record.fontLoaded = false; record.glyphPainted = false; record.hiddenBy = hidden || 'no glyph content';
+        } else {
+          const rawFamily = String(glyph.style.fontFamily || '').split(',')[0].trim().replace(/^['"]|['"]$/g, '');
+          const family = norm(rawFamily);
+          const weight = glyph.style.fontWeight || '400';
+          const faces = Array.from(document.fonts).filter((face) => norm(face.family) === family);
+          record.fontFamily = family;
+          record.fontLoaded = faces.some((face) => face.status === 'loaded');
+          record.fontStatus = faces.map((face) => face.status);
+          const icon = pixels(`${weight} 32px "${rawFamily}"`, glyph.text);
+          const fallback = pixels(`${weight} 32px "maggie-missing-font-probe"`, glyph.text);
+          record.glyphPainted = icon.ink > 0 && (icon.hash !== fallback.hash || icon.ink !== fallback.ink);
+          record.ink = icon.ink; record.fallbackInk = fallback.ink; record.glyphText = glyph.text.length <= 4 ? Array.from(glyph.text).map((c) => 'U+' + c.codePointAt(0).toString(16).toUpperCase().padStart(4, '0')).join(' ') : glyph.text.slice(0, 40);
+          if (glyph.pseudo && getComputedStyle(el, glyph.pseudo).display === 'none' && !record.hiddenBy) record.hiddenBy = glyph.pseudo + ' display:none';
+        }
+        const prefix = Object.keys(config.families).find((key) => (el.className || '').toString().split(/\s+/).some((token) => token === key || token.startsWith(key + '-')));
+        if (prefix) record.familyMatches = record.fontFamily === config.families[prefix].toLowerCase();
+      }
+      record.visible = !record.hiddenBy && record.width > 0 && record.height > 0;
+      icons.push(record);
+    }
+    out.textContent = JSON.stringify({ icons, fontsReady: document.fonts.status, faces: Array.from(document.fonts).map((face) => ({ family: norm(face.family), status: face.status })) });
+    document.body.appendChild(out);
+  };
+  const start = () => document.fonts.ready.then(() => setTimeout(run, config.settleMs));
+  if (document.readyState === 'complete') start(); else window.addEventListener('load', start);
+})();
+"""
+
+
+def _probe_script(selector: str, max_icons: int, families: dict[str, str], settle_ms: int) -> str:
+    config = {"reportId": REPORT_ID, "selector": selector, "maxIcons": max_icons, "families": families, "settleMs": settle_ms}
+    return "<script>" + PROBE.replace("__CONFIG__", json.dumps(config)) + "</script>"
+
+
+def inject(document: str, probe: str) -> str:
+    index = document.lower().rfind("</body>")
+    return document[:index] + probe + document[index:] if index >= 0 else document + probe
+
+
+class _ProbeServer:
+    """Serve a static build or proxy GET requests to a host, injecting the probe."""
+
+    def __init__(self, probe: str, base_url: str | None = None, dist: Path | None = None) -> None:
+        self.probe = probe; self.base_url = base_url.rstrip("/") if base_url else None; self.dist = dist.resolve() if dist else None
+        self.assets: list[dict] = []; self.lock = threading.Lock()
+        server = self
+
+        class Handler(BaseHTTPRequestHandler):
+            def log_message(self, *_args) -> None:  # silence request logging
+                return
+
+            def do_GET(self) -> None:  # noqa: N802 - stdlib handler name
+                status, content_type, body = server.fetch(self.path)
+                if status < 400 and "text/html" in content_type:
+                    body = inject(body.decode("utf-8", errors="replace"), server.probe).encode("utf-8")
+                path = urlsplit(self.path).path
+                if path.lower().endswith(FONT_EXTENSIONS) or "font" in content_type:
+                    with server.lock:
+                        server.assets.append({"path": path, "status": status, "contentType": content_type.split(";")[0]})
+                self.send_response(status)
+                self.send_header("Content-Type", content_type)
+                self.send_header("Content-Length", str(len(body)))
+                self.end_headers()
+                self.wfile.write(body)
+
+            def do_POST(self) -> None:  # noqa: N802 - writes are never forwarded
+                self.send_response(405); self.send_header("Content-Length", "0"); self.end_headers()
+
+            do_PUT = do_PATCH = do_DELETE = do_POST
+
+        self.httpd = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
+        self.thread = threading.Thread(target=self.httpd.serve_forever, daemon=True)
+
+    def fetch(self, raw_path: str) -> tuple[int, str, bytes]:
+        path = urlsplit(raw_path).path or "/"
+        if self.dist is not None:
+            relative = path.lstrip("/")
+            target = (self.dist / relative).resolve()
+            if not target.is_relative_to(self.dist):
+                return 403, "text/plain", b"forbidden"
+            if target.is_dir():
+                target = target / "index.html"
+            elif not target.exists() and (self.dist / (relative + ".html")).exists():
+                target = self.dist / (relative + ".html")
+            if not target.is_file():
+                return 404, "text/plain", b"not found"
+            return 200, _content_type(target.name), target.read_bytes()
+        request = Request(self.base_url + raw_path, headers={"Accept-Encoding": "identity", "User-Agent": "maggie-icon-glyph-check/1"})
+        try:
+            with urlopen(request, timeout=30) as response:
+                return response.status, response.headers.get("Content-Type", "application/octet-stream"), response.read()
+        except HTTPError as error:
+            return error.code, error.headers.get("Content-Type", "text/plain") if error.headers else "text/plain", error.read() or b""
+        except URLError as error:
+            return 502, "text/plain", f"upstream unavailable: {error.reason}".encode()
+
+    def __enter__(self) -> "_ProbeServer":
+        self.thread.start(); return self
+
+    def __exit__(self, *_exc) -> None:
+        self.httpd.shutdown(); self.httpd.server_close()
+
+    @property
+    def origin(self) -> str:
+        return f"http://127.0.0.1:{self.httpd.server_port}"
+
+
+def _content_type(name: str) -> str:
+    lower = name.lower()
+    for suffix, value in ((".html", "text/html; charset=utf-8"), (".css", "text/css"), (".js", "text/javascript"), (".mjs", "text/javascript"), (".svg", "image/svg+xml"), (".png", "image/png"), (".jpg", "image/jpeg"), (".webp", "image/webp"), (".json", "application/json"), (".woff2", "font/woff2"), (".woff", "font/woff"), (".ttf", "font/ttf"), (".otf", "font/otf")):
+        if lower.endswith(suffix):
+            return value
+    return "application/octet-stream"
+
+
+def find_chrome() -> str:
+    chrome = shutil.which("google-chrome") or shutil.which("chromium") or shutil.which("chromium-browser") or shutil.which("chrome")
+    if not chrome:
+        raise RuntimeError("google-chrome or chromium is required for icon-glyph-check")
+    return chrome
+
+
+def render(chrome: str, url: str, width: int, height: int, budget_ms: int) -> dict:
+    proc = subprocess.run([chrome, "--headless=new", "--no-sandbox", "--disable-gpu", "--hide-scrollbars", f"--window-size={width},{height}", f"--virtual-time-budget={budget_ms}", "--dump-dom", url], capture_output=True, text=True, timeout=180, check=False)
+    if proc.returncode != 0:
+        raise RuntimeError(f"headless chrome failed: {(proc.stderr or '')[-300:]}")
+    match = re.search(rf'<pre id="{REPORT_ID}"[^>]*>(.*?)</pre>', proc.stdout, re.S)
+    if not match:
+        raise RuntimeError("icon probe did not report; the page may block inline scripts or never finished loading")
+    return json.loads(html_lib.unescape(match.group(1)) or "{}")
+
+
+def _asset_status(icon: dict, assets: list[dict]) -> int:
+    if icon.get("kind") != "font":
+        return 200 if icon.get("glyphPainted") else 0
+    if icon.get("fontLoaded"):
+        return 200  # the face reached status "loaded", so its file was served
+    failing = [item["status"] for item in assets if item["status"] >= 400]
+    return min(failing) if failing else 0
+
+
+def collect(routes: list[str], viewports: dict[str, tuple[int, int]], base_url: str | None, dist: Path | None, selector: str, families: dict[str, str], max_icons: int, budget_ms: int, settle_ms: int) -> dict:
+    if bool(base_url) == bool(dist):
+        raise ValueError("exactly one of --base-url or --dist is required")
+    chrome = find_chrome()
+    probe = _probe_script(selector, max_icons, families, settle_ms)
+    icons: list[dict] = []; errors: list[str] = []; route_results: list[dict] = []
+    with _ProbeServer(probe, base_url=base_url, dist=dist) as server:
+        for route in routes:
+            if not route.startswith("/"):
+                raise ValueError(f"route must start with /: {route}")
+            for viewport, (width, height) in viewports.items():
+                before = len(server.assets)
+                try:
+                    report = render(chrome, server.origin + route, width, height, budget_ms)
+                except RuntimeError as error:
+                    errors.append(f"{route} @ {viewport}: {error}")
+                    route_results.append({"route": route, "viewport": viewport, "status": "error"})
+                    continue
+                assets = server.assets[before:] or server.assets
+                found = report.get("icons") or []
+                for icon in found:
+                    icon.update({"route": route, "viewport": viewport, "assetStatus": _asset_status(icon, assets)})
+                    icons.append(icon)
+                route_results.append({"route": route, "viewport": viewport, "status": "rendered", "iconCount": len(found), "fontsReady": report.get("fontsReady")})
+                if not found:
+                    errors.append(f"{route} @ {viewport}: no icons matched the selector")
+        font_assets = sorted({(item["path"], item["status"]) for item in server.assets})
+    failures = sorted({f"{icon['name']} @ {icon['route']} {icon['viewport']}" for icon in icons if icon_failure(icon)})
+    if failures:
+        errors.append("icons failed rendered-glyph checks: " + ", ".join(failures[:20]))
+    return {
+        "schemaVersion": SCHEMA, "collector": COLLECTOR, "passed": not errors,
+        "target": "dist" if dist else "base-url", "routes": routes, "viewports": {name: list(size) for name, size in viewports.items()},
+        "renders": route_results, "icons": icons,
+        "fontAssets": [{"path": path, "status": status} for path, status in font_assets],
+        "errors": errors, "generatedAt": datetime.now(timezone.utc).isoformat(), "mutation": "not executed",
+    }
+
+
+def icon_failure(icon: dict) -> str | None:
+    """Return why one collected icon fails, or ``None`` when it is proven painted."""
+    if icon.get("hiddenBy"):
+        return f"hidden by {icon['hiddenBy']}"
+    if not (isinstance(icon.get("width"), (int, float)) and icon["width"] > 0 and isinstance(icon.get("height"), (int, float)) and icon["height"] > 0):
+        return "zero size"
+    if icon.get("kind") == "font" and icon.get("fontLoaded") is not True:
+        return "icon font not loaded"
+    if icon.get("glyphPainted") is not True:
+        return "glyph not painted (fallback font or blank)"
+    if icon.get("familyMatches") is False:
+        return "unexpected font family"
+    if not str(icon.get("accessibleName") or "").strip():
+        return "no accessible name"
+    return None
+
+
+def _parse_viewports(values: list[str]) -> dict[str, tuple[int, int]]:
+    if not values:
+        return dict(DEFAULT_VIEWPORTS)
+    result: dict[str, tuple[int, int]] = {}
+    for value in values:
+        match = re.fullmatch(r"(?:([a-z0-9-]+)=)?(\d{3,4})x(\d{3,4})", value.strip(), re.I)
+        if not match:
+            raise ValueError(f"viewport must look like mobile=390x844 or 390x844: {value}")
+        name = match.group(1) or f"{match.group(2)}w"
+        result[name] = (int(match.group(2)), int(match.group(3)))
+    return result
+
+
+def _parse_families(values: list[str]) -> dict[str, str]:
+    result = {}
+    for value in values:
+        prefix, sep, family = value.partition("=")
+        if not sep or not prefix.strip() or not family.strip():
+            raise ValueError(f"--family must look like ph=Phosphor: {value}")
+        result[prefix.strip()] = family.strip()
+    return result
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--base-url", help="running host origin, e.g. http://localhost:4321 (GET-only proxy)")
+    parser.add_argument("--dist", type=Path, help="static build directory to serve locally")
+    parser.add_argument("--route", action="append", default=[], help="route to render; repeatable (default /)")
+    parser.add_argument("--viewport", action="append", default=[], help="name=WIDTHxHEIGHT; repeatable (default mobile, tablet, desktop)")
+    parser.add_argument("--selector", default=DEFAULT_SELECTOR, help="CSS selector for icon elements")
+    parser.add_argument("--family", action="append", default=[], help="expected font family per class prefix, e.g. ph=Phosphor")
+    parser.add_argument("--max-icons", type=int, default=60, help="representative icons per render (one per name)")
+    parser.add_argument("--budget-ms", type=int, default=8000)
+    parser.add_argument("--settle-ms", type=int, default=250)
+    parser.add_argument("--output", type=Path, required=True)
+    args = parser.parse_args(argv)
+    try:
+        report = collect(args.route or ["/"], _parse_viewports(args.viewport), args.base_url, args.dist, args.selector, _parse_families(args.family), args.max_icons, args.budget_ms, args.settle_ms)
+    except (OSError, ValueError, RuntimeError, json.JSONDecodeError) as error:
+        print(f"BLOCKED: maggie-design icon-glyph-check: {error}", file=sys.stderr)
+        return 2
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(json.dumps(report, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+    summary = {key: report[key] for key in ("schemaVersion", "collector", "passed", "routes", "errors")}
+    summary.update({"iconCount": len(report["icons"]), "output": str(args.output)})
+    print(json.dumps(summary, indent=2, ensure_ascii=False))
+    return 0 if report["passed"] else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/bundled-tools/clis/maggie_icon_release_gate.py

@@ -5,9 +5,12 @@ from __future__ import annotations
 
 import argparse
 import json
+import sys
 from pathlib import Path
 from typing import Any
 
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
 
 def validate(icon_report: object, browser_report: object) -> dict[str, Any]:
     errors: list[str] = []
@@ -40,6 +43,27 @@ def validate(icon_report: object, browser_report: object) -> dict[str, Any]:
             invalid.append(name)
     if invalid:
         errors.append("browser icon evidence has invisible, zero-size, inaccessible, or unserved glyphs")
+    # Evidence from `maggie design icon-glyph-check` also proves the icon font
+    # loaded and the glyph differs from the fallback font at every viewport.
+    # Hand-written legacy evidence cannot prove that, so it is only warned.
+    warnings: list[str] = []
+    glyph_proof = browser_report.get("collector") == "maggie-icon-glyph-check" or any(isinstance(icon, dict) and "glyphPainted" in icon for icon in icons)
+    glyph_failures: list[str] = []
+    if glyph_proof:
+        from maggie_icon_glyph_check import icon_failure
+
+        for icon in icons:
+            reason = icon_failure(icon) if isinstance(icon, dict) else "invalid icon record"
+            if reason:
+                glyph_failures.append(f"{icon.get('name', '?') if isinstance(icon, dict) else '?'} @ {icon.get('viewport', '?') if isinstance(icon, dict) else '?'}: {reason}")
+        expected_viewports = set((browser_report.get("viewports") or {}).keys()) if isinstance(browser_report.get("viewports"), dict) else set()
+        rendered = {icon.get("viewport") for icon in icons if isinstance(icon, dict)}
+        if expected_viewports and expected_viewports - rendered:
+            glyph_failures.append("no icon evidence for viewport(s): " + ", ".join(sorted(expected_viewports - rendered)))
+        if glyph_failures:
+            errors.append("rendered glyph proof failed: font not loaded, fallback glyph, hidden by CSS, or missing viewport")
+    else:
+        warnings.append("browser evidence does not prove font loading or glyph identity; collect it with `maggie design icon-glyph-check`")
     return {
         "schemaVersion": "maggie-icon-release-gate.v1",
         "passed": not errors,
@@ -47,9 +71,12 @@ def validate(icon_report: object, browser_report: object) -> dict[str, Any]:
         "checks": {
             "sourceRuntime": source_ok,
             "servedAssets": browser_ok and not bool(invalid),
-            "paintedGlyphs": bool(icons) and not bool(invalid),
+            "paintedGlyphs": bool(icons) and not bool(invalid) and not glyph_failures,
             "accessibility": bool(icons) and not bool(invalid),
         },
+        "glyphIdentityProven": glyph_proof and not glyph_failures,
+        "glyphFailures": glyph_failures[:50],
+        "warnings": warnings,
         "iconCount": len(icons),
         "invalidIcons": sorted(set(invalid)),
         "mutation": "not executed",

package/bundled-tools/clis/maggie_localization.py

@@ -15,6 +15,9 @@ sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "runtime"))
 from content_localization import LANGUAGES, MARKETS, OPERATIONS, parse_locale, protected_field_changes, stale, valid_locale, validate_operation_quality, validate_translation
 from localization_runner import generate, process_adapter
 
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import maggie_email_localization as email_localization
+
 
 def generate_job(args: argparse.Namespace) -> int:
     if not args.confirm:
@@ -395,6 +398,7 @@ def main() -> int:
     publish_parser.add_argument("job", type=Path); publish_parser.add_argument("--confirm", action="store_true")
     for name in ("stale", "glossary"):
         command = sub.add_parser(name); command.add_argument("--project", type=Path, default=Path("."))
+    email_localization.add_parsers(sub)
     args = parser.parse_args()
     try:
         if args.command == "generate": return generate_job(args)
@@ -406,6 +410,7 @@ def main() -> int:
         if args.command == "review": return review(args.job, args.reviewer, args.decision)
         if args.command == "publish": return publish(args.job, args.confirm)
         if args.command == "stale": return stale_jobs(args.project)
+        if args.command in ("email-matrix", "lifecycle"): return email_localization.run(args)
         return glossary(args.project)
     except (OSError, ValueError, json.JSONDecodeError) as error:
         print(f"ERROR: {error}", file=sys.stderr); return 1