@topy-ai/maggie 0.7.47 → 0.7.49

package/bundled-tools/clis/maggie_feedback.py

@@ -10,6 +10,7 @@ import os
 import platform
 import re
 import secrets
+import subprocess
 import sys
 from datetime import datetime, timezone
 from pathlib import Path
@@ -41,6 +42,14 @@ EVIDENCE_KINDS = {"test", "report", "screenshot", "command", "deployment", "issu
 RELATION_KINDS = {"related", "same-run", "same-fingerprint", "duplicates", "validates", "remediates", "caused-by"}
 ACKNOWLEDGEMENT_KEYS = ("status", "feedbackId", "requestId")
 REPO_ROOT = Path(__file__).resolve().parents[2]
+FEEDBACK_TYPES = ("bug", "feature", "quality", "improvement", "general")
+# The hosted endpoint accepts these types. Local-only types are submitted as a
+# hosted type with the original kept in `subtype`, so no endpoint change is needed.
+HOSTED_TYPES = {"bug", "feature", "quality", "general"}
+HOSTED_TYPE_FALLBACK = {"improvement": "feature"}
+REVIEW_MARKER = "REVIEW:"
+FIX_SUBJECT_RE = re.compile(r"^(?:fix|bugfix|hotfix)(?:\([^)]*\))?!?:\s*|^(?:fix|fixes|fixed)\b\s*", re.IGNORECASE)
+FEATURE_SUBJECT_RE = re.compile(r"^(?:feat|perf|refactor)(?:\([^)]*\))?!?:\s*", re.IGNORECASE)
 
 
 def now() -> str:
@@ -230,6 +239,8 @@ def collect(args: argparse.Namespace) -> int:
         # Persist one canonical representation so batch review and the hosted
         # API do not have to guess which indexing convention was used.
         batch_index -= batch_base
+    if args.type not in FEEDBACK_TYPES:
+        raise ValueError(f"type must be one of: {', '.join(FEEDBACK_TYPES)}")
     priority = safe_text(getattr(args, "priority", "") or "normal").lower()
     if priority not in {"low", "normal", "high", "critical"}:
         raise ValueError("priority must be low, normal, high, or critical")
@@ -321,6 +332,16 @@ def preview(args: argparse.Namespace) -> int:
     return 0
 
 
+def hosted_payload(data: dict) -> dict:
+    """Map local-only feedback types onto the hosted contract without losing them."""
+    payload = dict(data)
+    local_type = payload.get("type")
+    if local_type not in HOSTED_TYPES:
+        payload["type"] = HOSTED_TYPE_FALLBACK.get(local_type, "general")
+        payload["subtype"] = local_type
+    return payload
+
+
 def submit(args: argparse.Namespace) -> int:
     if not args.confirm:
         raise ValueError("submit requires --confirm; feedback is never sent implicitly")
@@ -330,7 +351,7 @@ def submit(args: argparse.Namespace) -> int:
     parsed = urlparse(endpoint)
     if parsed.scheme != "https" or not parsed.netloc:
         raise ValueError("endpoint must be an absolute HTTPS URL")
-    payload = dict(data)
+    payload = hosted_payload(data)
     payload["projectContext"] = data.get("projectContext") if data.get("privacy", {}).get("projectContextAllowed") else None
     request = Request(endpoint, data=json.dumps(payload, ensure_ascii=False).encode(), headers={"Content-Type": "application/json", "Accept": "application/json", "User-Agent": "MaggieFeedback/0.1"}, method="POST")
     try:
@@ -352,7 +373,7 @@ def list_feedback(args: argparse.Namespace) -> int:
     for path in sorted(directory.glob("*.json")):
         try:
             data = read_feedback(path)
-            records.append({"feedbackId": data.get("feedbackId"), "skill": data.get("skill"), "status": data.get("submission", {}).get("status", "draft"), "path": str(path)})
+            records.append({"feedbackId": data.get("feedbackId"), "skill": data.get("skill"), "type": data.get("type"), "status": data.get("submission", {}).get("status", "draft"), "path": str(path)})
         except (OSError, ValueError):
             continue
     print(json.dumps(records, indent=2, ensure_ascii=False))
@@ -361,7 +382,14 @@ def list_feedback(args: argparse.Namespace) -> int:
 
 def collect_batch(args: argparse.Namespace) -> int:
     """Create one privacy-safe draft per item while retaining shared batch context."""
-    manifest = load_json(Path(args.batch_file).expanduser().resolve())
+    if args.batch_file == "-":
+        # Reading JSON from stdin lets a quoted heredoc carry multiline text and
+        # backticks without shell interpolation.
+        manifest = json.loads(sys.stdin.read())
+        if not isinstance(manifest, dict):
+            raise ValueError("batch input must be a JSON object")
+    else:
+        manifest = load_json(Path(args.batch_file).expanduser().resolve())
     batch_id = safe_text(manifest.get("batchId"))
     if not SAFE_BATCH_ID_RE.fullmatch(batch_id):
         raise ValueError("batch file requires a safe batchId")
@@ -383,6 +411,9 @@ def collect_batch(args: argparse.Namespace) -> int:
     for index, item in enumerate(items):
         if not isinstance(item, dict):
             raise ValueError(f"items[{index}] must be an object")
+        unedited = [field for field in ("summary", "expected", "actual", "resolution", "validation") if REVIEW_MARKER in str(item.get(field) or "")]
+        if unedited:
+            raise ValueError(f"items[{index}] still has {REVIEW_MARKER} placeholders in: {', '.join(unedited)}; edit or remove the item before creating drafts")
         values = {
             "project": args.project,
             "run_report": None,
@@ -422,6 +453,75 @@ def collect_batch(args: argparse.Namespace) -> int:
     return 0
 
 
+def session_summary(args: argparse.Namespace) -> int:
+    """Draft a reviewable batch file from commit subjects; nothing is collected or submitted."""
+    repo = Path(args.repo).expanduser().resolve()
+    since = str(args.since).strip()
+    if not since or since.startswith("-") or not re.fullmatch(r"[A-Za-z0-9._/@{}~^:-]{1,200}", since):
+        raise ValueError("--since must be a git revision such as a tag, branch, or commit")
+    batch_id = safe_text(args.batch_id) or f"session-{datetime.now(timezone.utc).strftime('%Y%m%d-%H%M%S')}"
+    if not SAFE_BATCH_ID_RE.fullmatch(batch_id):
+        raise ValueError("batch ID is invalid")
+    completed = subprocess.run(
+        ["git", "-C", str(repo), "log", "--no-merges", "--format=%h%x1f%s", f"{since}..HEAD"],
+        capture_output=True, text=True, check=False,
+    )
+    if completed.returncode:
+        raise ValueError("git log failed; check --repo and --since")
+    items = []
+    skipped = 0
+    for line in completed.stdout.splitlines():
+        sha, _, subject = line.partition("\x1f")
+        subject = safe_text(subject)[:200]
+        if not sha or not subject:
+            continue
+        if FIX_SUBJECT_RE.match(subject):
+            kind, text = "bug", FIX_SUBJECT_RE.sub("", subject, count=1)
+        elif FEATURE_SUBJECT_RE.match(subject):
+            kind, text = "improvement", FEATURE_SUBJECT_RE.sub("", subject, count=1)
+        else:
+            skipped += 1
+            continue
+        text = text[:1].upper() + text[1:] if text else subject
+        items.append({
+            "type": kind,
+            "summary": text,
+            "expected": f"{REVIEW_MARKER} what the skill or CLI should have done",
+            "actual": f"{REVIEW_MARKER} what happened before commit {sha}",
+            "fixed": True,
+            "resolution": text,
+            "validation": f"{REVIEW_MARKER} the test or check that verified commit {sha}",
+            "evidence": [f"commit:{sha}"],
+        })
+        if len(items) >= 49:
+            break
+    items.append({
+        "type": "feature",
+        "summary": f"{REVIEW_MARKER} describe an open ask from this session, or delete this item",
+        "expected": "",
+        "actual": "",
+    })
+    manifest = {
+        "batchId": batch_id,
+        "skill": safe_text(args.skill),
+        "runId": safe_text(args.run_id),
+        "phase": safe_text(args.phase) or "session-summary",
+        "reviewRequired": True,
+        "note": "Draft only. Remove items unrelated to Maggie skills or CLIs, replace every REVIEW: and delete the open-ask placeholder if unused. `maggie feedback batch` rejects unedited REVIEW: fields.",
+        "items": items,
+    }
+    project = Path(args.project).resolve()
+    output = Path(args.output) if args.output else project / ".maggie" / "feedback" / "batches" / f"{batch_id}-draft.json"
+    if not output.is_absolute():
+        output = project / output
+    if output.exists():
+        raise ValueError("output already exists; choose another --output or --batch-id")
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.write_text(json.dumps(manifest, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+    print(json.dumps({"status": "draft-written", "batchId": batch_id, "items": len(items), "skippedCommits": skipped, "output": str(output), "submitted": False}, ensure_ascii=False))
+    return 0
+
+
 def batch_review(args: argparse.Namespace) -> int:
     """Aggregate one bounded batch without exposing raw payloads or paths."""
     project = Path(args.project).resolve()
@@ -534,7 +634,7 @@ def main() -> int:
     collect_parser.add_argument("--skill", default="")
     collect_parser.add_argument("--run-id", default="")
     collect_parser.add_argument("--run-report")
-    collect_parser.add_argument("--type", choices=("bug", "feature", "quality", "general"), default="bug")
+    collect_parser.add_argument("--type", choices=FEEDBACK_TYPES, default="bug", help="improvement: a proposal to improve a skill or CLI (submitted as feature with subtype)")
     collect_parser.add_argument("--phase", default="")
     collect_parser.add_argument("--summary", required=True)
     collect_parser.add_argument("--expected", default="")
@@ -562,7 +662,16 @@ def main() -> int:
     collect_parser.add_argument("--relationship", dest="relationships", action="append", default=[], help="safe relation=target pointer")
     batch_parser = sub.add_parser("batch")
     batch_parser.add_argument("--project", default=argparse.SUPPRESS)
-    batch_parser.add_argument("--batch-file", required=True)
+    batch_parser.add_argument("--batch-file", required=True, help="batch JSON file, or - to read JSON from stdin")
+    summary_parser = sub.add_parser("session-summary", help="draft batch items from git commit subjects for review")
+    summary_parser.add_argument("--project", default=argparse.SUPPRESS)
+    summary_parser.add_argument("--since", required=True, help="git revision; commits after it are summarized")
+    summary_parser.add_argument("--repo", default=".", help="git repository to read (default: current directory)")
+    summary_parser.add_argument("--batch-id", default="")
+    summary_parser.add_argument("--skill", default="")
+    summary_parser.add_argument("--run-id", default="")
+    summary_parser.add_argument("--phase", default="")
+    summary_parser.add_argument("--output")
     review_parser = sub.add_parser("batch-review")
     review_parser.add_argument("--project", default=argparse.SUPPRESS)
     review_parser.add_argument("--batch-id", required=True)
@@ -581,6 +690,7 @@ def main() -> int:
         if args.command == "collect": return collect(args)
         if args.command == "batch": return collect_batch(args)
         if args.command == "batch-review": return batch_review(args)
+        if args.command == "session-summary": return session_summary(args)
         if args.command == "preview": return preview(args)
         if args.command == "submit": return submit(args)
         return list_feedback(args)

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",