@topy-ai/maggie 0.7.8 → 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.8 update --project . --force
-npx @topy-ai/maggie@0.7.8 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,7 +229,12 @@ as a command-line argument:
 node scripts/publish-npm.mjs --maggie-env-file ../.env
 ```
 
-The 0.7.8 workflow adds the shared Google integrations runbook and
+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`,
 `trash`, `restore`, `schedule`, `publish-due`, `duplicate`, `redirect`, and
@@ -468,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-contracts/maggiedash/README.md

@@ -25,6 +25,15 @@ frontend framework.
 - [`translation-cache-policy-v1.json`](translation-cache-policy-v1.json):
   restart-after-out-of-band-write evidence.
 
+The section registry is an adapter input rather than a fixed six-band list.
+Each registry entry must describe its purpose and limits, include a
+renderer-compatible `example`, and describe object-shaped repeated fields
+under `repeats.of`. Host-specific bands are valid when the host supplies the
+matching renderer and a preview at its real supported breakpoints. Template
+inventory adapters must count published pages once using disjoint page
+classes; child records such as service price options and saved arrangements
+must not be reported as pages.
+
 MaggieDash owns these contracts. Provider adapters may add namespaced metadata,
 but they may not change the required identity, status, provenance, or approval
 fields. Unknown fields must be preserved or reported as unsupported during

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,12 +177,45 @@ 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
-limits. Over-limit copy is an editor note; unknown types fail validation.
+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 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.
+until the ordered migration is complete. Migration preserves unique IDs that
+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
+published page once into disjoint groups; price options, arrangements, and
+other child records are counts, not pages.
 
 After any script or direct adapter write to translation data, invalidate the
 running process before verification. Record the restart and run the rendering

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,12 +1,86 @@
 {
   "schemaVersion": "maggiedash-section-registry.v1",
-  "description": "The machine-readable section vocabulary used by page planners and editors.",
+  "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", "purpose": "Says what the page is about and offers the one important action.", "usage": "First on the page; once.", "position": "opening", "repeatable": false, "fields": [{"name": "title", "usage": "Plain words a visitor would search for.", "limit": 70, "required": true}, {"name": "intro", "usage": "Who it is for and what it does.", "limit": 220}, {"name": "ctaLabel", "usage": "The action as a verb.", "limit": 30}]},
-    {"type": "prose", "purpose": "Explains a topic at length, optionally beside an image.", "usage": "Use in the body for explanation.", "position": "body", "repeatable": true, "fields": [{"name": "heading", "usage": "The argument in a sentence.", "limit": 90}, {"name": "paragraphs", "usage": "Two or three standalone paragraphs.", "limit": 400, "repeats": {"min": 1, "max": 4}}]},
-    {"type": "cards", "purpose": "Presents parallel points side by side.", "usage": "Use for steps or genuinely parallel points.", "position": "body", "repeatable": true, "fields": [{"name": "heading", "usage": "What the cards share.", "limit": 90}, {"name": "items", "usage": "The parallel points.", "limit": 220, "repeats": {"min": 3, "max": 3}}]},
-    {"type": "links", "purpose": "Sends the reader to related pages.", "usage": "Near the end after the page has done its job.", "position": "closing", "repeatable": true, "fields": [{"name": "heading", "usage": "What the links have in common.", "limit": 90}, {"name": "items", "usage": "Real related pages on this site.", "limit": 160, "repeats": {"min": 2, "max": 6}}]},
-    {"type": "faq", "purpose": "Answers questions a visitor would otherwise ask.", "usage": "Once near the end; use real visitor questions.", "position": "closing", "repeatable": false, "fields": [{"name": "heading", "usage": "The question topic.", "limit": 90}, {"name": "items", "usage": "Direct questions and answers.", "limit": 600, "repeats": {"min": 2, "max": 8}}]},
-    {"type": "cta", "purpose": "Makes the closing ask.", "usage": "Last on the page; once.", "position": "closing", "repeatable": false, "fields": [{"name": "heading", "usage": "The invitation in a sentence.", "limit": 90, "required": true}, {"name": "body", "usage": "What happens next.", "limit": 220}, {"name": "label", "usage": "The action as a verb.", "limit": 30, "required": true}]}
+    {
+      "type": "hero",
+      "purpose": "Says what the page is about and offers the one important action.",
+      "usage": "First on the page; once.",
+      "position": "opening",
+      "repeatable": false,
+      "fields": [
+        {"name": "title", "usage": "Plain words a visitor would search for.", "limit": 70, "required": true},
+        {"name": "intro", "usage": "Who it is for and what it does.", "limit": 220},
+        {"name": "image", "usage": "The hero image rendered beside or behind the copy.", "limit": 500},
+        {"name": "imageAlt", "usage": "What the hero image shows for a reader who cannot see it.", "limit": 160},
+        {"name": "ctaLabel", "usage": "The action as a verb.", "limit": 30}
+      ],
+      "example": {"type": "hero", "title": "A clearer way to plan your next step", "intro": "Useful guidance for people who want to move forward with confidence.", "image": "https://images.unsplash.com/photo-1497366754035-f200968a6e72", "imageAlt": "A bright workspace with a table and plants", "ctaLabel": "Get started"}
+    },
+    {
+      "type": "prose",
+      "purpose": "Explains a topic at length, optionally beside an image.",
+      "usage": "Use in the body for explanation.",
+      "position": "body",
+      "repeatable": true,
+      "fields": [
+        {"name": "heading", "usage": "The argument in a sentence.", "limit": 90},
+        {"name": "paragraphs", "usage": "Standalone paragraphs.", "limit": 0, "repeats": {"min": 1, "max": 4, "of": [{"name": "paragraph", "usage": "One paragraph of plain prose.", "limit": 400}]}},
+        {"name": "image", "usage": "An optional supporting image.", "limit": 500},
+        {"name": "imageAlt", "usage": "What the supporting image shows.", "limit": 160}
+      ],
+      "example": {"type": "prose", "heading": "Make the important part easier to understand", "paragraphs": ["Start with the decision your reader is trying to make.", "Then give them the context, evidence and next step in that order."]}
+    },
+    {
+      "type": "cards",
+      "purpose": "Presents parallel points side by side.",
+      "usage": "Use for steps or genuinely parallel points.",
+      "position": "body",
+      "repeatable": true,
+      "fields": [
+        {"name": "heading", "usage": "What the cards share.", "limit": 90},
+        {"name": "items", "usage": "The parallel points.", "limit": 0, "repeats": {"min": 3, "max": 3, "of": [{"name": "title", "usage": "The point in a few words.", "limit": 60, "required": true}, {"name": "body", "usage": "One or two sentences.", "limit": 220}]}}
+      ],
+      "example": {"type": "cards", "heading": "A simple path from question to action", "items": [{"title": "Understand", "body": "See the essential context in one place."}, {"title": "Choose", "body": "Compare the options that fit your situation."}, {"title": "Act", "body": "Take the next step with a clear expectation."}]}
+    },
+    {
+      "type": "links",
+      "purpose": "Sends the reader to related pages.",
+      "usage": "Near the end after the page has done its job.",
+      "position": "closing",
+      "repeatable": true,
+      "fields": [
+        {"name": "heading", "usage": "What the links have in common.", "limit": 90},
+        {"name": "items", "usage": "Real related pages on this site.", "limit": 0, "repeats": {"min": 2, "max": 6, "of": [{"name": "label", "usage": "The destination page name.", "limit": 60, "required": true}, {"name": "href", "usage": "A real path on this site.", "limit": 200, "required": true}, {"name": "body", "usage": "One sentence on what is there.", "limit": 160}]}}
+      ],
+      "example": {"type": "links", "heading": "Keep exploring", "items": [{"label": "How it works", "href": "/how-it-works/", "body": "See the process from start to finish."}, {"label": "Frequently asked questions", "href": "/faq/", "body": "Find concise answers to common questions."}]}
+    },
+    {
+      "type": "faq",
+      "purpose": "Answers questions a visitor would otherwise ask.",
+      "usage": "Once near the end; use real visitor questions.",
+      "position": "closing",
+      "repeatable": false,
+      "fields": [
+        {"name": "heading", "usage": "The question topic.", "limit": 90},
+        {"name": "items", "usage": "Direct questions and answers.", "limit": 0, "repeats": {"min": 2, "max": 8, "of": [{"name": "question", "usage": "A question a real visitor asks.", "limit": 140, "required": true}, {"name": "answer", "usage": "A direct, useful answer.", "limit": 600, "required": true}]}}
+      ],
+      "example": {"type": "faq", "heading": "Questions, answered", "items": [{"question": "What happens next?", "answer": "You will see the relevant options and can choose the next step."}, {"question": "Can I ask for help?", "answer": "Yes. Use the contact route and include the decision you are making."}]}
+    },
+    {
+      "type": "cta",
+      "purpose": "Makes the closing ask.",
+      "usage": "Last on the page; once.",
+      "position": "closing",
+      "repeatable": false,
+      "fields": [
+        {"name": "heading", "usage": "The invitation in a sentence.", "limit": 90, "required": true},
+        {"name": "body", "usage": "What happens next.", "limit": 220},
+        {"name": "label", "usage": "The action as a verb.", "limit": 30, "required": true}
+      ],
+      "example": {"type": "cta", "heading": "Ready to take the next step?", "body": "Start with the option that best matches your goal.", "label": "Get started"}
+    }
   ]
 }

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,36 @@ 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:
+    if not isinstance(field, dict) or not field.get("name"):
+        errors.append(f"{at} needs a name")
+        return
+    if not isinstance(field.get("limit"), int) or field["limit"] < 0:
+        errors.append(f"{at}.limit must be a non-negative integer")
+    if not str(field.get("usage") or "").strip():
+        errors.append(f"{at}.usage is required")
+    repeats = field.get("repeats")
+    if repeats is None:
+        return
+    if not isinstance(repeats, dict) or not isinstance(repeats.get("min"), int) or not isinstance(repeats.get("max"), int) or repeats["min"] < 0 or repeats["min"] > repeats["max"]:
+        errors.append(f"{at}.repeats must declare valid min/max")
+        return
+    item_fields = repeats.get("of")
+    if not isinstance(item_fields, list) or not item_fields:
+        errors.append(f"{at}.repeats.of must be a non-empty field list")
+        return
+    nested_names: set[str] = set()
+    for item_index, item_field in enumerate(item_fields):
+        item_at = f"{at}.repeats.of[{item_index}]"
+        _validate_field(item_field, item_at, errors, nested=True)
+        if isinstance(item_field, dict) and item_field.get("name"):
+            name = str(item_field["name"])
+            if name in nested_names:
+                errors.append(f"duplicate repeated field: {name}")
+            nested_names.add(name)
 
 
 def validate_registry(value: object) -> dict[str, Any]:
@@ -57,13 +87,10 @@ def validate_registry(value: object) -> dict[str, Any]:
             if name in field_names:
                 errors.append(f"duplicate field: {section_type}.{name}")
             field_names.add(name)
-            if not isinstance(field.get("limit"), int) or field["limit"] < 0:
-                errors.append(f"{field_at}.limit must be a non-negative integer")
-            if not str(field.get("usage") or "").strip():
-                errors.append(f"{field_at}.usage is required")
-            repeats = field.get("repeats")
-            if repeats is not None and (not isinstance(repeats, dict) or not isinstance(repeats.get("min"), int) or not isinstance(repeats.get("max"), int) or repeats["min"] < 0 or repeats["min"] > repeats["max"]):
-                errors.append(f"{field_at}.repeats must declare valid min/max")
+            _validate_field(field, field_at, errors)
+        example = section.get("example")
+        if not isinstance(example, dict) or example.get("type") != section_type:
+            errors.append(f"{at}.example must be an object with type {section_type}")
     return {"schemaVersion": SCHEMA, "passed": not errors, "errors": errors, "sectionTypes": sorted(seen)}
 
 
@@ -74,11 +101,39 @@ def catalogue(registry: dict[str, Any]) -> str:
         lines.append(f"{section['type']} — {section['purpose']} | when: {section['usage']} | place: {section['position']} | {'repeatable' if section['repeatable'] else 'once'}")
         for field in section.get("fields", []):
             repeat = field.get("repeats")
-            suffix = f" [{repeat['min']}-{repeat['max']} entries]" if isinstance(repeat, dict) else ""
+            suffix = ""
+            if isinstance(repeat, dict):
+                count = repeat["min"] if repeat["min"] == repeat["max"] else f"{repeat['min']}-{repeat['max']}"
+                nested = ", ".join(f"{item['name']} ≤{item['limit']}" for item in repeat.get("of", []) if isinstance(item, dict))
+                suffix = f" [{count} entries" + (f" of {{{nested}}}" if nested else "") + "]"
             lines.append(f"  - {field['name']} ≤{field['limit']} chars{suffix}: {field['usage']}")
     return "\n".join(lines)
 
 
+def _copy_notes(value: object, fields: list[dict[str, Any]], path: str, notes: list[dict[str, Any]]) -> None:
+    """Check a field value, including object-shaped repeated entries."""
+    for field in fields:
+        name = str(field.get("name"))
+        child = value.get(name) if isinstance(value, dict) else None
+        limit = int(field.get("limit", 0))
+        if isinstance(child, str) and limit and len(child) > limit:
+            notes.append({"at": f"{path}.{name}", "message": f"{len(child)} characters; layout limit is about {limit}"})
+        repeats = field.get("repeats")
+        if not isinstance(repeats, dict) or not isinstance(child, list):
+            continue
+        if not repeats["min"] <= len(child) <= repeats["max"]:
+            notes.append({"at": f"{path}.{name}", "message": f"{len(child)} entries; layout expects {repeats['min']}-{repeats['max']}"})
+        item_fields = [item for item in repeats.get("of", []) if isinstance(item, dict)]
+        for item_index, item in enumerate(child):
+            item_path = f"{path}.{name}[{item_index}]"
+            if isinstance(item, dict):
+                _copy_notes(item, item_fields, item_path, notes)
+            elif len(item_fields) == 1 and isinstance(item, str):
+                item_limit = int(item_fields[0].get("limit", 0))
+                if item_limit and len(item) > item_limit:
+                    notes.append({"at": item_path, "message": f"{len(item)} characters; layout limit is about {item_limit}"})
+
+
 def copy_notes(registry: dict[str, Any], sections: object) -> dict[str, Any]:
     """Return advisory copy/shape notes; over-limit copy is not rejected."""
     errors: list[str] = []
@@ -95,15 +150,7 @@ def copy_notes(registry: dict[str, Any], sections: object) -> dict[str, Any]:
         if not spec:
             errors.append(f"unknown section type: {section_type}")
             continue
-        for field in spec.get("fields", []):
-            name = str(field.get("name"))
-            value = section.get(name)
-            limit = int(field.get("limit", 0))
-            if isinstance(value, str) and limit and len(value) > limit:
-                notes.append({"at": f"sections[{index}].{name}", "message": f"{len(value)} characters; layout limit is about {limit}"})
-            repeats = field.get("repeats")
-            if isinstance(repeats, dict) and isinstance(value, list) and not repeats["min"] <= len(value) <= repeats["max"]:
-                notes.append({"at": f"sections[{index}].{name}", "message": f"{len(value)} entries; layout expects {repeats['min']}-{repeats['max']}"})
+        _copy_notes(section, [field for field in spec.get("fields", []) if isinstance(field, dict)], f"sections[{index}]", notes)
     return {"passed": not errors, "errors": errors, "notes": notes}
 
 
@@ -117,12 +164,16 @@ def new_section_id(existing: Iterable[str] = ()) -> str:
 
 def ensure_section_ids(sections: list[dict[str, Any]], existing: Iterable[str] = ()) -> list[dict[str, Any]]:
     result = copy.deepcopy(sections)
-    existing_ids = set(existing)
-    taken = set(existing_ids)
+    reserved = {str(item) for item in existing if str(item)}
+    taken: set[str] = set()
     for section in result:
         current = str(section.get("id") or "")
-        if not current or current in existing_ids or current in taken:
-            section["id"] = new_section_id(taken)
+        # Existing IDs belong to the source section list and must survive a
+        # migration. Only absent, duplicated, or target-conflicting IDs get a
+        # replacement. The old implementation put current IDs in `taken`
+        # before inspecting them and consequently rewrote every section.
+        if not current or current in taken or current in reserved:
+            section["id"] = new_section_id(taken | reserved)
         taken.add(str(section["id"]))
     return result
 
@@ -141,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.8",
+  "version": "0.7.10",
   "description": "Install and manage Maggie Skills for AI coding agents",
   "license": "MIT",
   "type": "module",