@topy-ai/maggie 0.7.9 → 0.7.10

package/README.md

@@ -218,8 +218,8 @@ artifact schemas.
 Recommended upgrade sequence for the current release:
 
 ```bash
-npx @topy-ai/maggie@0.7.9 update --project . --force
-npx @topy-ai/maggie@0.7.9 cleanup --project .
+npx @topy-ai/maggie@0.7.10 update --project . --force
+npx @topy-ai/maggie@0.7.10 cleanup --project .
 ```
 
 Maintainers should pass npm credentials through the repository helper, never
@@ -229,8 +229,11 @@ as a command-line argument:
 node scripts/publish-npm.mjs --maggie-env-file ../.env
 ```
 
-The 0.7.9 workflow adds nested section-field contracts, renderer-backed
-examples, stable-ID preservation during migration, and disjoint page
+The 0.7.10 workflow adds served-content equivalence checks, query-route
+baseline exclusions, changed-surface render evidence gates, generated skill
+catalogs, component-binding audits, and icon-family noise filtering. It also
+includes the 0.7.9 nested section-field contracts, renderer-backed examples,
+stable-ID preservation during migration, and disjoint page
 inventory guidance. It retains the shared Google integrations runbook and
 fail-closed provider capability matrix, alongside the installable MaggieDash admin distribution and
 audited CMS operations (`cms revisions`,
@@ -470,7 +473,6 @@ python3 tools/clis/maggie_design.py rebrand \
 | `maggie-feedback` | Collect redacted feedback drafts and explicitly submit them to the NoBlox feedback endpoint |
 | `maggie-auth-reference` | Generate and validate traditional email/password auth with secure server-side sessions |
 | `maggie-blog` | Run a provider-neutral blog lifecycle with stable identity, topics, feeds, settings, and rollback |
-| `maggie-google-capabilities` | Validate redacted Google provider evidence and separate read/report/edit/publish capability states |
 
 `maggie-design` can initialize native blog and service UI plans from a local,
 read-only structural reference:

package/bin/maggie.js

@@ -17,26 +17,18 @@ const MARKETPLACE_ROOT = join(PACKAGE_ROOT, "bundled-marketplace");
 const CONTRACTS_ROOT = join(PACKAGE_ROOT, "bundled-contracts");
 const TEMPLATES_ROOT = join(PACKAGE_ROOT, "bundled-templates");
 const STATE_DIR = ".maggie";
-const SKILL_NAMES = [
-  "maggie-blog-bootstrap",
-  "maggie-dash",
-  "maggie-clone",
-  "maggie-clone-to-template",
-  "maggie-marketplace",
-  "maggie-template",
-  "maggie-design",
-  "maggie-ops",
-  "maggie-deployment",
-  "maggie-project-context",
-  "maggie-seo-geo",
-  "maggie-social-share",
-  "maggie-service-booking",
-  "maggie-memory",
-  "maggie-content-localization",
-  "maggie-feedback",
-  "maggie-auth-reference",
-  "maggie-blog",
-];
+function loadSkillNames() {
+  try {
+    return JSON.parse(readFileSync(join(SKILLS_ROOT, "catalog.json"), "utf8")).skills.map((skill) => skill.name);
+  } catch {
+    // Local regression tests may invoke the wrapper before package assembly.
+    // Discover real frontmatter directories and never resurrect retired content.
+    return readdirSync(SKILLS_ROOT, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory() && entry.name !== "maggie-emdash" && existsSync(join(SKILLS_ROOT, entry.name, "SKILL.md")))
+      .map((entry) => entry.name).sort();
+  }
+}
+const SKILL_NAMES = loadSkillNames();
 const RETIRED_PATHS = [
   ".agents/skills/maggie-emdash",
   ".claude/skills/maggie-emdash",
@@ -66,7 +58,8 @@ Usage:
   maggie doctor [--project PATH]
   maggie bootstrap interview [project]
   maggie dash init|install|status|migrate|transition|variant|cms --project PATH [options]
-  maggie dash sections <validate|prompt|keys> [options]
+  maggie dash sections <validate|prompt|keys|remap-translations> [options]
+  maggie dash components-audit --bindings-file FILE --sections-file FILE --pages-file FILE
   maggie dash status --project PATH
   maggie dash migrate --project PATH --confirm
   maggie content FILE --source PROVIDER --project PATH --confirm

package/bundled-skills/README.md

@@ -13,7 +13,6 @@ Skills are the agent-facing workflows. They compose with the tools in
 | `maggie-template` | Discover, recommend, inspect, and apply a selected Astro homepage template | marketplace catalog, bootstrap state, template `DESIGN.md` |
 | `maggie-design` | Fully clone authorized interior pages, then reconcile them to the homepage header/footer shell | browser MCP, clone planner CLI, completed Maggie homepage |
 | `maggie-ops` | Build, connect, operate, upgrade, and verify the private blog operations dashboard | Ops dashboard contract, authenticated API bridge, host tests |
-| `maggie-google-capabilities` | Validate a redacted Google provider capability matrix without inferring write access | Google integrations runbook, provider evidence |
 | `maggie-deployment` | Deploy and verify a dynamic Maggie blog, Cloudflare-first | Cloudflare Workers, D1, R2, KV, Wrangler |
 | `maggie-project-context` | Sync Project, voice, site and CTA context | project-context CLI/API |
 | `maggie-seo-geo` | Plan, audit, create/rewrite and measure SEO/GEO | visibility, SEO audit, GSC/GA4, content quality |

package/bundled-skills/catalog.json

@@ -0,0 +1,78 @@
+{
+  "schemaVersion": "maggie-skill-catalog.v1",
+  "generatedFrom": "skills/*/SKILL.md",
+  "skills": [
+    {
+      "name": "maggie-auth-reference",
+      "description": "Generate and validate a provider-neutral traditional email/password auth reference with secure server sessions and production security gates."
+    },
+    {
+      "name": "maggie-blog",
+      "description": "Create and operate a provider-neutral blog with stable post identity, topics, draft approval, archive/post routes, RSS, sitemap, settings, and idempotent local ingest."
+    },
+    {
+      "name": "maggie-blog-bootstrap",
+      "description": "Establish a MaggieDash-backed Astro blog or complete a small SEO/GEO-ready blog in an existing project."
+    },
+    {
+      "name": "maggie-clone",
+      "description": "Reverse-engineer an authorized website homepage and create the Maggie homepage foundation inside an existing blog project. Use with /maggie-clone plus a homepage URL when the user wants to replicate the homepage structure, header, footer, assets, responsive behavior, and interactions."
+    },
+    {
+      "name": "maggie-clone-to-template",
+      "description": "Turn an authorized website URL and a design or copy prompt into a validated marketplace template through clone, asset, screenshot, comparison, revision, and packaging gates."
+    },
+    {
+      "name": "maggie-content-localization",
+      "description": "Manage translation, polish, rewrite, market localization, review, stale detection, and publishing for pages, guides, posts, services, products, and categories."
+    },
+    {
+      "name": "maggie-dash",
+      "description": "Manage the MaggieDash project foundation, local content store, and approval lifecycle."
+    },
+    {
+      "name": "maggie-deployment",
+      "description": "Deploy and operate Maggie blog projects with Cloudflare Workers as the default target, while preserving an adapter boundary for VPS, GCP, and AWS."
+    },
+    {
+      "name": "maggie-design",
+      "description": "Design authorized interior pages, review rendered responsive layouts, or explicitly rebrand a packaged homepage/template. Use rebrand only with a named source brand and target brand."
+    },
+    {
+      "name": "maggie-feedback",
+      "description": "Collect, review, and explicitly submit privacy-safe feedback about a Maggie skill run, workflow result, bug, or feature request."
+    },
+    {
+      "name": "maggie-marketplace",
+      "description": "Build, rebrand, localise, validate, version, and apply reusable Astro marketplace templates from an authorised preview URL or local HTML export. Use when adding a design template, creating a neutral demo, or preparing a stable homepage starter for an Astro project."
+    },
+    {
+      "name": "maggie-memory",
+      "description": "Persist and retrieve confirmed user preferences, project conventions, lessons from repaired mistakes, and structured error history across Maggie skill runs."
+    },
+    {
+      "name": "maggie-ops",
+      "description": "Build, connect, operate, upgrade, and verify a private Maggie Ops dashboard for blog content, API Pull, sitemap matching, rewrite approvals, reports, and integrations. Use when the user asks for Ops/admin functionality or lifecycle operations rather than public blog pages."
+    },
+    {
+      "name": "maggie-project-context",
+      "description": "Sync a site's safe AI CMO Project, selected brand voice, site settings, and CTA context into a local generated context file. Use when connecting a vibe-coded blog or existing website to AI CMO, refreshing brand context, or diagnosing missing CTA/project data."
+    },
+    {
+      "name": "maggie-seo-geo",
+      "description": "Plan, audit, create, rewrite, and measure content for AI CMO's paid SEO and GEO workflow. Use for topic opportunities, AI visibility, technical SEO, extractable article structure, sitemap-based rewrites, GSC readback, or SEO/GEO client reports."
+    },
+    {
+      "name": "maggie-service-booking",
+      "description": "Import, synchronise, validate, and design SPA service pages from a booking provider such as Fresha. Use for service catalogues, treatment variants, prices, durations, booking links, payment links, and booking-aware page generation."
+    },
+    {
+      "name": "maggie-social-share",
+      "description": "Turn approved AI CMO articles and content assets into platform-native social drafts, scheduled posts, and measured distribution. Use for Social Share planning, LinkedIn/Facebook copy, CTA mapping, calendars, approvals, publish retries, or social performance readback."
+    },
+    {
+      "name": "maggie-template",
+      "description": "Discover, recommend, inspect, and apply verified Astro homepage templates from the Maggie marketplace. Use when a user wants to start a site from a selected template, compare available designs, or choose a visual direction before maggie-clone or maggie-design."
+    }
+  ]
+}

package/bundled-skills/maggie-dash/SKILL.md

@@ -177,6 +177,10 @@ maggie dash sections validate --registry templates/maggiedash/section-registry.j
 maggie dash sections prompt --registry templates/maggiedash/section-registry.json
 maggie dash sections keys --registry templates/maggiedash/section-registry.json \
   --page-id <page-id> --sections-file .maggie/sections.json
+maggie dash sections remap-translations \
+  --translations-file .maggie/translations-legacy.json \
+  --mapping-file .maggie/section-translation-map.json \
+  --output .maggie/translations-v2.json --confirm
 ```
 
 The catalogue declares purpose, usage, placement, repeatability and layout
@@ -184,10 +188,15 @@ limits, renderer-owned examples, and the shape of repeated entries. A repeat
 may contain an object (`title`, `body`, `href`, and so on), not just a count;
 the nested limits are displayed to the planner and checked by `sections
 validate`. Over-limit copy is an editor note; unknown types fail validation.
-The starter registry is provider-neutral and extensible: a host may add its
-own renderer-backed bands, but every added band must have a real-renderer
-preview or an explicitly labelled example fallback at the supported
-breakpoints. Do not describe the vocabulary as a fixed number of bands.
+The registry is intentionally marked `catalogStatus: starter`, not presented
+as a production-complete vocabulary. Hosts commonly add renderer-backed bands
+such as `form`, `map`, `steps`, `checklist`, `compare`, `quote`, `timeline`,
+`gallery`, `stats`, `split`, `glossary`, `credentials`, `team`, `before-after`,
+`statement`, `features`, `scope`, `animated`, `opening`, `breadcrumb`, and
+`bound-collection`; the machine-readable registry lists these examples. Every
+added band must have a real-renderer preview or an explicitly labelled example
+fallback at the supported breakpoints. Do not describe the starter vocabulary
+as a fixed number of bands.
 
 Translation keys use stable section IDs, with an array-index fallback only
 until the ordered migration is complete. Migration preserves unique IDs that
@@ -195,6 +204,13 @@ already belong to the source section list; it generates a new ID only for a
 missing, duplicate, or target-conflicting ID. Never rebuild IDs from array
 position or overwrite existing translation keys.
 
+When copy already lives under another keyspace, generate an explicit prefix
+mapping from the converter and run `remap-translations`. The helper applies
+longest prefixes first, preserves unmapped keys for review, and fails on
+conflicting destinations. For a database adapter, apply the section rows and
+translation remap in one transaction with the same migration ID; the JSON CLI
+is the reviewable output form, not a substitute for the adapter's transaction.
+
 Keep data-owned values out of page copy. For example, a pricing band should
 store a service identifier or slug and let the live service/booking adapter
 render current options and prices. Inventory reports must classify each

package/bundled-skills/maggie-deployment/SKILL.md

@@ -30,6 +30,12 @@ errors, missing assets, or visual placeholders. The result follows
 `maggie-deployment-canary.v1`; never include cookies, authorization headers, or
 response bodies in it.
 
+When a release changes a visitor-facing HTML, CSS, component, or asset surface,
+the release preflight automatically requires both a passing icon inventory and
+rendered canary evidence. The canary must include screenshots, zero console or
+network errors, and zero placeholder matches. Query-driven routes belong in
+behavior/API checks, not static byte baselines.
+
 ## Automatic memory hook
 
 Follow [Maggie Memory Hook](../../references/memory-hook.md) at invocation and completion.

package/bundled-skills/maggie-design/SKILL.md

@@ -34,8 +34,10 @@ Use `missing`, `unknown`, and `coverage` from the versioned
 `maggie-icon-inventory.v1` report as the release gate. A binary font without a
 name map is reported as evidence only; it must not be treated as proof that a
 glyph exists. Fix the source token or add the runtime definition before
-shipping. Do not paste private source, URLs with credentials, or user data
-into the report.
+shipping. The inventory compares a scoped runtime icon family (`ph-*`, `fa-*`,
+or `lucide-*`), normalizes family prefixes, and ignores inline SVG IDs and font
+filename noise. Do not paste private source, URLs with credentials, or user
+data into the report.
 
 ## Automatic memory hook
 

package/bundled-skills/maggie-seo-geo/SKILL.md

@@ -83,8 +83,13 @@ automatically replace the baseline following failure. Dynamic dates, class
 names and copy can produce legitimate differences requiring review.
 
 This covers server-rendered sitemap pages, not CSS rendering, JavaScript-only
-content, database translation keys or browser interactions. A source key change
-is detected here only when it changes served content. Baselines contain site
+content, database translation keys or browser interactions. Query-string URLs
+are recorded as excluded from byte baselines because they often represent
+search/filter state; use browser or API-specific tests for those states. The
+baseline now compares a served-content contract (headings, paragraphs and
+links) alongside metadata and structure, so a section migration cannot pass
+merely because the HTML byte shape stayed similar. A source key change is
+detected here only when it changes served content. Baselines contain site
 metadata; do not publish private project contracts without permission.
 
 ## Browser behavior evidence

package/bundled-templates/maggiedash/section-registry.json

@@ -1,6 +1,8 @@
 {
   "schemaVersion": "maggiedash-section-registry.v1",
   "description": "The provider-neutral starter vocabulary used by page planners and editors. Hosts may extend it with renderer-backed section types.",
+  "catalogStatus": "starter",
+  "hostExtensionExamples": ["form", "map", "steps", "checklist", "compare", "quote", "timeline", "gallery", "stats", "split", "glossary", "credentials", "team", "before-after", "statement", "features", "scope", "animated", "opening", "breadcrumb", "bound-collection"],
   "sections": [
     {
       "type": "hero",

package/bundled-tools/clis/maggie_dash.py

@@ -23,7 +23,8 @@ sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "runtime"))
 from maggie_dash_store import MaggieDashStore  # noqa: E402
 from service_variants import ServiceVariantStore  # noqa: E402
 from maggie_dash_ui import load_and_validate  # noqa: E402
-from maggie_sections import catalogue, section_id_migration, validate_registry, copy_notes  # noqa: E402
+from maggie_sections import catalogue, remap_translations, section_id_migration, validate_registry, copy_notes  # noqa: E402
+from route_imports import classify_bindings  # noqa: E402
 
 
 def project_root(args: argparse.Namespace) -> Path:
@@ -319,6 +320,20 @@ def command_ui(args: argparse.Namespace) -> int:
 
 
 def command_sections(args: argparse.Namespace) -> int:
+    if args.sections_command == "remap-translations":
+        require_confirm(args)
+        translations = json.loads(Path(args.translations_file).resolve().read_text(encoding="utf-8"))
+        mappings = json.loads(Path(args.mapping_file).resolve().read_text(encoding="utf-8"))
+        result = remap_translations(translations, mappings)
+        if result["passed"]:
+            output = Path(args.output).resolve()
+            if output.exists() and not args.force:
+                raise ValueError(f"output exists; use --force to replace: {output}")
+            output.parent.mkdir(parents=True, exist_ok=True)
+            output.write_text(json.dumps(result["translations"], indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+            result["output"] = str(output)
+        emit(result)
+        return 0 if result["passed"] else 1
     registry = json.loads(Path(args.registry).resolve().read_text(encoding="utf-8"))
     checked = validate_registry(registry)
     if not checked["passed"]:
@@ -337,6 +352,23 @@ def command_sections(args: argparse.Namespace) -> int:
     return 0
 
 
+def command_components_audit(args: argparse.Namespace) -> int:
+    bindings = json.loads(Path(args.bindings_file).resolve().read_text(encoding="utf-8"))
+    sections = json.loads(Path(args.sections_file).resolve().read_text(encoding="utf-8"))
+    pages = json.loads(Path(args.pages_file).resolve().read_text(encoding="utf-8"))
+    result = classify_bindings(
+        bindings if isinstance(bindings, list) else bindings.get("bindings", []),
+        set(sections if isinstance(sections, list) else sections.get("paths", [])),
+        set(pages if isinstance(pages, list) else pages.get("paths", [])),
+    )
+    if args.output:
+        output = Path(args.output).resolve(); output.parent.mkdir(parents=True, exist_ok=True)
+        output.write_text(json.dumps(result, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+        result["output"] = str(output)
+    emit(result)
+    return 0 if result["passed"] else 1
+
+
 def variant_store(args: argparse.Namespace) -> ServiceVariantStore:
     return ServiceVariantStore(project_root(args) / ".maggie" / "service-variants.json")
 
@@ -449,7 +481,16 @@ def parser() -> argparse.ArgumentParser:
     sections_prompt.set_defaults(func=command_sections)
     sections_keys = sections_sub.add_parser("keys")
     sections_keys.add_argument("--registry", required=True); sections_keys.add_argument("--sections-file", required=True); sections_keys.add_argument("--page-id", required=True)
+    sections_remap = sections_sub.add_parser("remap-translations", help="move an existing translation keyspace into stable section keys")
+    sections_remap.add_argument("--translations-file", required=True); sections_remap.add_argument("--mapping-file", required=True); sections_remap.add_argument("--output", required=True); sections_remap.add_argument("--force", action="store_true"); sections_remap.add_argument("--confirm", action="store_true")
+    sections_remap.set_defaults(func=command_sections)
     sections_keys.set_defaults(func=command_sections)
+    components = sub.add_parser("components-audit", help="classify route component bindings against live section/page inventories")
+    components.add_argument("--bindings-file", required=True)
+    components.add_argument("--sections-file", required=True, help="JSON array/object of section-managed paths")
+    components.add_argument("--pages-file", required=True, help="JSON array/object of live page paths")
+    components.add_argument("--output")
+    components.set_defaults(func=command_components_audit)
     variant = sub.add_parser("variant", help="manage service variant lifecycle")
     variant_sub = variant.add_subparsers(dest="variant_command", required=True)
     create = variant_sub.add_parser("create"); create.add_argument("--project", default="."); create.add_argument("--service-id", required=True); create.add_argument("--variant-id", required=True); create.add_argument("--variant-type", required=True); create.add_argument("--locale", required=True); create.add_argument("--market", required=True); create.add_argument("--slug", required=True); create.add_argument("--title", required=True); create.add_argument("--facts", required=True); create.add_argument("--source-revision", required=True); create.add_argument("--canonical-variant-id"); create.add_argument("--cluster-link", action="append", default=[]); create.add_argument("--layout-family", default="service-default"); create.add_argument("--confirm", action="store_true")

package/bundled-tools/clis/maggie_icon_inventory.py

@@ -10,11 +10,19 @@ from pathlib import Path
 
 SOURCE_EXTENSIONS = {".astro", ".css", ".html", ".jsx", ".js", ".json", ".svelte", ".tsx", ".ts", ".vue"}
 IGNORE_NAMES = {"icon", "icons", "true", "false", "null", "undefined"}
+NOISE_NAME = re.compile(r"^(?:inline-)?svg[-_]\d+$|^(?:solid|regular|brands|light|thin|duotone)[-_]\d+$|^\d+$", re.I)
+
+
+def normalize_name(name: str) -> str:
+    """Return the family-neutral name used for source/runtime comparison."""
+    value = name.strip().lower().replace("/", ":")
+    value = re.sub(r"^(?:phosphor|ph|font-awesome|fa|lucide):", "", value)
+    return value
 
 
 def _add(found: dict[str, set[str]], name: str, file: Path, evidence: str) -> None:
-    name = name.strip().lower()
-    if not name or name in IGNORE_NAMES or len(name) > 80 or not re.fullmatch(r"[a-z0-9][a-z0-9._:/-]*", name):
+    name = normalize_name(name)
+    if not name or name in IGNORE_NAMES or NOISE_NAME.fullmatch(name) or len(name) > 80 or not re.fullmatch(r"[a-z0-9][a-z0-9._:-]*", name):
         return
     found.setdefault(name, set()).add(f"{file.as_posix()}:{evidence}")
 
@@ -31,7 +39,7 @@ def source_icons(root: Path, source_dir: Path) -> dict[str, set[str]]:
             _add(found, match.group(1), relative, "named-property")
         for match in re.finditer(r"data-(?:icon|glyph)\s*=\s*[\"']([^\"']+)", text, re.I):
             _add(found, match.group(1), relative, "data-attribute")
-        for match in re.finditer(r"(?:ph|fa|lucide|icon)-([a-z0-9][a-z0-9-]*)", text, re.I):
+        for match in re.finditer(r"(?:ph|fa|lucide)-([a-z0-9][a-z0-9-]*)", text, re.I):
             _add(found, match.group(1), relative, "icon-class")
         for match in re.finditer(r"(?:phosphor|lucide|icon)[:/]([a-z0-9][a-z0-9-]*)", text, re.I):
             _add(found, match.group(1), relative, "icon-token")
@@ -49,10 +57,14 @@ def runtime_icons(root: Path, runtime_paths: list[Path]) -> tuple[set[str], dict
             continue
         text = path.read_text(encoding="utf-8", errors="replace")
         relative = path.relative_to(root.resolve()) if path.is_relative_to(root.resolve()) else path
-        for match in re.finditer(r"\.(?:ph|fa|lucide|icon)-([a-z0-9][a-z0-9-]*)\b", text, re.I):
-            name = match.group(1).lower(); names.add(name); evidence.setdefault(name, set()).add(f"{relative}:css-class")
+        for match in re.finditer(r"\.(?:ph|fa|lucide)-([a-z0-9][a-z0-9-]*)\b", text, re.I):
+            name = normalize_name(match.group(1))
+            if not NOISE_NAME.fullmatch(name):
+                names.add(name); evidence.setdefault(name, set()).add(f"{relative}:css-class")
         for match in re.finditer(r"(?:data-(?:icon|glyph)|icon)\s*=\s*[\"']([^\"']+)", text, re.I):
-            name = match.group(1).lower(); names.add(name); evidence.setdefault(name, set()).add(f"{relative}:runtime-map")
+            name = normalize_name(match.group(1))
+            if name not in IGNORE_NAMES and not NOISE_NAME.fullmatch(name):
+                names.add(name); evidence.setdefault(name, set()).add(f"{relative}:runtime-map")
     return names, evidence, font_files
 
 

package/bundled-tools/clis/maggie_release.py

@@ -127,6 +127,60 @@ def evidence_gate(project: Path, environment: str) -> dict:
     return {"name": "durable-site-evidence", "passed": not errors, "exitCode": 0 if not errors else 1, "result": {"passed": not errors, "errors": errors, "evidence": summaries}, "stderr": ""}
 
 
+def changed_surface_gate(project: Path) -> dict:
+    """Require visual/runtime evidence when a visitor-facing surface changed."""
+    try:
+        changed = subprocess.run(
+            ["git", "-C", str(project), "diff", "--name-only"],
+            capture_output=True, text=True, check=True,
+        ).stdout.splitlines()
+    except (OSError, subprocess.CalledProcessError):
+        return {"name": "changed-surface-evidence", "passed": True, "exitCode": 0,
+                "result": {"passed": True, "changed": False, "reason": "project is not a git worktree"}, "stderr": ""}
+    visitor_suffixes = {".astro", ".css", ".scss", ".html", ".jsx", ".tsx", ".js", ".ts", ".svg", ".png", ".jpg", ".jpeg", ".webp"}
+    surfaces = sorted(path for path in changed if Path(path).suffix.lower() in visitor_suffixes)
+    if not surfaces:
+        return {"name": "changed-surface-evidence", "passed": True, "exitCode": 0,
+                "result": {"passed": True, "changed": False, "surfaces": []}, "stderr": ""}
+
+    candidates = {
+        "iconInventory": (project / "docs/icon-inventory.json", project / ".maggie/icon-inventory.json"),
+        "renderEvidence": (project / "docs/deployment-canary.json", project / ".maggie/deployment-canary.json", project / "docs/rendered-canary.json", project / ".maggie/rendered-canary.json"),
+    }
+    errors: list[str] = []
+    evidence: dict[str, dict[str, object]] = {}
+    for name, paths in candidates.items():
+        path = next((candidate for candidate in paths if candidate.exists()), None)
+        if path is None:
+            errors.append(f"missing {name} evidence")
+            continue
+        try:
+            payload = json.loads(path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError) as exc:
+            errors.append(f"{name}: {exc}")
+            continue
+        passed = payload.get("passed") is True or payload.get("status") in {"pass", "passed"}
+        evidence[name] = {"path": str(path.relative_to(project)), "passed": passed}
+        if not passed:
+            errors.append(f"{name} is not passed")
+        if name == "renderEvidence":
+            render = payload.get("render", payload)
+            screenshots = render.get("screenshots", render.get("screenshotEvidence", [])) if isinstance(render, dict) else []
+            console_errors = render.get("consoleErrors", []) if isinstance(render, dict) else []
+            network_errors = render.get("networkErrors", []) if isinstance(render, dict) else []
+            placeholders = render.get("placeholderMatches", render.get("placeholders", [])) if isinstance(render, dict) else []
+            if not screenshots:
+                errors.append("renderEvidence has no screenshot evidence")
+            if console_errors:
+                errors.append("renderEvidence contains console errors")
+            if network_errors:
+                errors.append("renderEvidence contains network errors")
+            if placeholders:
+                errors.append("renderEvidence contains placeholder matches")
+    return {"name": "changed-surface-evidence", "passed": not errors, "exitCode": 0 if not errors else 1,
+            "result": {"passed": not errors, "changed": True, "surfaces": surfaces, "evidence": evidence, "errors": errors}, "stderr": ""}
+
+
 def editorial_gate(project: Path) -> dict:
     """Require explicit editorial approval for every launch category.
 
@@ -224,6 +278,7 @@ def main() -> int:
         parser.error(f"project directory does not exist: {project}")
 
     gates = []
+    gates.append(changed_surface_gate(project))
     gates.append(build_gate(project))
     for name, command in build_gates(project, args.environment, args.target, not args.skip_compatibility):
         gates.append(run_gate(name, command, project))

package/bundled-tools/clis/site_audit.py

@@ -9,9 +9,8 @@ import json
 import re
 import sys
 from pathlib import Path
-from urllib.parse import urljoin
-from html.parser import HTMLParser
 from urllib.parse import urljoin, urlparse
+from html.parser import HTMLParser
 from urllib.request import Request, urlopen
 
 sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "runtime"))
@@ -39,6 +38,10 @@ class PageParser(HTMLParser):
         self.visible_text = []
         self.hidden_depth = 0
         self.templates = set()
+        self._content_capture = []
+        self.headings = []
+        self.paragraphs = []
+        self.links = []
 
     def handle_starttag(self, tag, attrs):
         data = dict(attrs)
@@ -49,6 +52,8 @@ class PageParser(HTMLParser):
         if not self.hidden_depth:
             self.structure.append(["start", tag, {key: data[key] for key in
                 ("class", "id", "role", "href", "src", "data-template", "data-section", "data-i18n") if key in data}])
+            if tag in {"h1", "h2", "h3", "h4", "h5", "h6", "p", "a"}:
+                self._content_capture.append({"tag": tag, "parts": [], "href": data.get("href", "")})
         if tag == "html":
             self.lang = data.get("lang", "")
         if tag == "meta" and data.get("name"):
@@ -74,6 +79,15 @@ class PageParser(HTMLParser):
             self.images.append({"src": data.get("src", ""), "alt": data.get("alt")})
 
     def handle_endtag(self, tag):
+        if not self.hidden_depth and self._content_capture and self._content_capture[-1]["tag"] == tag:
+            capture = self._content_capture.pop()
+            text = " ".join("".join(capture["parts"]).split())
+            if text and tag.startswith("h"):
+                self.headings.append(text)
+            elif text and tag == "p":
+                self.paragraphs.append(text)
+            elif tag == "a" and capture.get("href"):
+                self.links.append({"href": capture["href"], "text": text})
         if tag in {"script", "style", "noscript"}:
             self.hidden_depth = max(0, self.hidden_depth - 1)
         elif not self.hidden_depth:
@@ -91,6 +105,8 @@ class PageParser(HTMLParser):
     def handle_data(self, data):
         if not self.hidden_depth and data.strip():
             self.visible_text.append(" ".join(data.split()))
+            for capture in self._content_capture:
+                capture["parts"].append(data)
         if self.in_title:
             self.title += data.strip()
         if self._jsonld is not None:
@@ -148,6 +164,12 @@ def audit_page(url: str, html: str, status: int, content_type: str, expected_lan
             "structureHash": hashlib.sha256(json.dumps(page.structure, sort_keys=True).encode()).hexdigest(),
             "textHash": hashlib.sha256(" ".join(page.visible_text).encode()).hexdigest(),
         },
+        "contentContract": {
+            "headings": page.headings,
+            "paragraphs": page.paragraphs,
+            "links": [{"href": urljoin(url, link["href"]), "text": link["text"]} for link in page.links],
+            "contentHash": hashlib.sha256(json.dumps({"headings": page.headings, "paragraphs": page.paragraphs, "links": page.links}, sort_keys=True, ensure_ascii=False).encode()).hexdigest(),
+        },
         "robots": not robots or not any(token in {"noindex", "none", "nofollow"} for token in robots_tokens),
         "robots_directives": robots,
         "robots_conflict": len({token for token in robots_tokens if token in {"index", "noindex", "follow", "nofollow", "none"}} & {"index", "noindex"}) > 1 or len({token for token in robots_tokens if token in {"follow", "nofollow", "none"}} & {"follow", "nofollow"}) > 1,

package/bundled-tools/runtime/maggie_sections.py

@@ -12,6 +12,7 @@ from typing import Any, Iterable
 
 SCHEMA = "maggiedash-section-registry.v1"
 IDENTITY_SCHEMA = "maggiedash-section-identity.v1"
+TRANSLATION_REMAP_SCHEMA = "maggiedash-translation-remap.v1"
 
 
 def _validate_field(field: object, at: str, errors: list[str], *, nested: bool = False) -> None:
@@ -191,3 +192,37 @@ def section_id_migration(page_id: str, sections: list[dict[str, Any]]) -> dict[s
     identified = ensure_section_ids(sections)
     mappings = [{"from": f"page.{page_id}.sections.{index}.", "to": f"page.{page_id}.sections.{section['id']}."} for index, section in enumerate(identified)]
     return {"schemaVersion": IDENTITY_SCHEMA, "pageId": page_id, "sections": identified, "renameOrder": sorted(mappings, key=lambda item: len(item["from"]), reverse=True), "sourceChecksum": hashlib.sha256(json.dumps(sections, sort_keys=True, ensure_ascii=False, separators=(",", ":")).encode()).hexdigest()}
+
+
+def remap_translations(translations: object, mappings: object) -> dict[str, Any]:
+    """Move an existing translation keyspace without dropping unmapped keys."""
+    if not isinstance(translations, dict):
+        return {"schemaVersion": TRANSLATION_REMAP_SCHEMA, "passed": False, "errors": ["translations must be an object"]}
+    if isinstance(mappings, dict):
+        mappings = mappings.get("renameOrder") or mappings.get("mappings")
+    if not isinstance(mappings, list) or not mappings:
+        return {"schemaVersion": TRANSLATION_REMAP_SCHEMA, "passed": False, "errors": ["mappings must be a non-empty list"]}
+    valid = [item for item in mappings if isinstance(item, dict) and isinstance(item.get("from"), str) and isinstance(item.get("to"), str) and item["from"] and item["to"]]
+    if len(valid) != len(mappings):
+        return {"schemaVersion": TRANSLATION_REMAP_SCHEMA, "passed": False, "errors": ["every mapping needs non-empty from and to prefixes"]}
+    ordered = sorted(valid, key=lambda item: len(item["from"]), reverse=True)
+    result: dict[str, Any] = {}
+    applied: list[dict[str, str]] = []
+    unmapped: list[str] = []
+    collisions: list[str] = []
+    for key, value in translations.items():
+        source = str(key)
+        destination = next((item["to"] + source[len(item["from"]):] for item in ordered if source.startswith(item["from"])), None)
+        if destination is None:
+            destination = source
+            unmapped.append(source)
+        elif destination != source:
+            applied.append({"from": source, "to": destination})
+        if destination in result and result[destination] != value:
+            collisions.append(destination)
+            continue
+        result[destination] = value
+    errors = [f"translation key collision: {key}" for key in sorted(set(collisions))]
+    return {"schemaVersion": TRANSLATION_REMAP_SCHEMA, "passed": not errors, "errors": errors,
+            "translations": result, "applied": applied, "unmapped": sorted(unmapped),
+            "mappingCount": len(valid)}

package/bundled-tools/runtime/route_imports.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import hashlib
 import re
 from pathlib import Path
+from typing import Any
 
 
 IMPORT_RE = re.compile(r"(?:import\s+(?:[^;\n]*?\s+from\s+)?|export\s+[^;\n]*?\s+from\s+)[\"']([^\"']+)[\"']")
@@ -49,3 +50,25 @@ def imported_components(route: Path) -> list[dict[str, str | None]]:
             "fingerprint": hashlib.sha256(resolved.read_bytes()).hexdigest() if resolved else None,
         })
     return result
+
+
+def classify_bindings(bindings: list[dict[str, Any]], section_paths: set[str], page_paths: set[str]) -> dict[str, Any]:
+    """Classify component bindings against section and page route inventories.
+
+    Hosts supply the inventories from their renderer/database. This keeps the
+    report honest: a binding is not called "missing" merely because a legacy
+    component file still exists on disk.
+    """
+    records = []
+    for binding in bindings:
+        route = str(binding.get("route") or binding.get("path") or "")
+        component = str(binding.get("component") or "")
+        if route in section_paths or component in section_paths or binding.get("superseded") is True:
+            state = "superseded"
+        elif route in page_paths or binding.get("pageId"):
+            state = "migratable"
+        else:
+            state = "no-page-row"
+        records.append({**binding, "state": state})
+    counts = {state: sum(item["state"] == state for item in records) for state in ("superseded", "migratable", "no-page-row")}
+    return {"schemaVersion": "maggie-component-binding-audit.v1", "passed": not any(item["state"] == "no-page-row" for item in records), "counts": counts, "bindings": records}

package/bundled-tools/runtime/site_baseline.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 import json
 from datetime import datetime, timezone
 from pathlib import Path
+from urllib.parse import urlparse
 
 
 def snapshot(report: dict, reviewer: str) -> dict:
@@ -16,15 +17,25 @@ def snapshot(report: dict, reviewer: str) -> dict:
     if not pages or len(pages) != crawl.get("discovered_url_count"):
         raise ValueError("baseline page coverage is incomplete")
     contracts = {}
+    content = {}
+    excluded_query_urls = []
     for page in pages:
         if not page.get("passed") or not isinstance(page.get("contract"), dict):
             raise ValueError("baseline requires successful page contracts")
         if page["url"] in contracts:
             raise ValueError("duplicate page URL")
+        if urlparse(page["url"]).query:
+            excluded_query_urls.append(page["url"])
+            continue
         contracts[page["url"]] = page["contract"]
+        if isinstance(page.get("contentContract"), dict):
+            content[page["url"]] = page["contentContract"]
+    if not contracts:
+        raise ValueError("baseline has no non-query page contracts")
     return {"schemaVersion": "maggie-site-baseline.v1", "url": report["url"],
             "reviewer": reviewer.strip(), "createdAt": datetime.now(timezone.utc).isoformat(),
-            "pages": contracts}
+            "pages": contracts, "content": content,
+            "excludedQueryUrls": sorted(excluded_query_urls)}
 
 
 def compare(baseline: dict, report: dict) -> dict:
@@ -36,7 +47,10 @@ def compare(baseline: dict, report: dict) -> dict:
         errors.append("site origin/base URL differs from baseline")
     if not crawl.get("enabled") or not crawl.get("complete"):
         errors.append("complete sitemap crawl required")
-    current = {page["url"]: page.get("contract") for page in crawl.get("pages", [])}
+    crawl_pages = crawl.get("pages", [])
+    query_urls = sorted(page["url"] for page in crawl_pages if urlparse(page["url"]).query)
+    current = {page["url"]: page.get("contract") for page in crawl_pages if not urlparse(page["url"]).query}
+    current_content = {page["url"]: page.get("contentContract") for page in crawl_pages if not urlparse(page["url"]).query and isinstance(page.get("contentContract"), dict)}
     expected = baseline["pages"]
     added, removed = sorted(current.keys() - expected.keys()), sorted(expected.keys() - current.keys())
     changes = []
@@ -48,8 +62,20 @@ def compare(baseline: dict, report: dict) -> dict:
         fields = sorted(key for key in expected[url].keys() | actual.keys() if expected[url].get(key) != actual.get(key))
         if fields:
             changes.append({"url": url, "fields": fields})
-    return {"passed": not errors and not added and not removed and not changes,
-            "errors": errors, "added": added, "removed": removed, "changed": changes}
+    expected_content = baseline.get("content", {})
+    content_changes = []
+    if expected_content:
+        for url in sorted(expected_content.keys() & current_content.keys()):
+            fields = sorted(key for key in expected_content[url].keys() | current_content[url].keys() if expected_content[url].get(key) != current_content[url].get(key))
+            if fields:
+                content_changes.append({"url": url, "fields": fields})
+        missing_content = sorted(expected_content.keys() - current_content.keys())
+        if missing_content:
+            errors.append("missing content contract: " + ", ".join(missing_content))
+    return {"passed": not errors and not added and not removed and not changes and not content_changes,
+            "errors": errors, "added": added, "removed": removed, "changed": changes,
+            "contentChanged": content_changes,
+            "excludedQueryUrls": query_urls}
 
 
 def save(path: Path, baseline: dict) -> None:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@topy-ai/maggie",
-  "version": "0.7.9",
+  "version": "0.7.10",
   "description": "Install and manage Maggie Skills for AI coding agents",
   "license": "MIT",
   "type": "module",