@topy-ai/maggie 0.7.37 → 0.7.40

package/bundled-tools/clis/maggie_contracts.py

@@ -0,0 +1,282 @@
+#!/usr/bin/env python3
+"""Small, deterministic validators for the cross-skill design/SEO contracts.
+
+The commands consume sanitized evidence produced by a browser/build adapter. They
+never fetch a third-party site and never write host source files implicitly.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import html as html_lib
+import json
+import re
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from urllib.parse import urlparse
+
+
+def now() -> str:
+    return datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
+
+
+def read_json(path: Path) -> dict:
+    value = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(value, dict):
+        raise ValueError(f"{path} must contain a JSON object")
+    return value
+
+
+def write_json(path: Path | None, value: dict) -> None:
+    if path:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(json.dumps(value, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+
+
+def result(schema: str, errors: list[str], **details: object) -> dict:
+    return {"schemaVersion": schema, "passed": not errors, "errors": errors, **details}
+
+
+def emit_and_exit(value: dict, output: Path | None = None) -> int:
+    write_json(output, value)
+    print(json.dumps(value, indent=2, ensure_ascii=False))
+    return 0 if value.get("passed") else 1
+
+
+def require_confirm(args: argparse.Namespace) -> None:
+    if not args.confirm:
+        raise ValueError("CONFIRMATION_REQUIRED: rerun with --confirm")
+
+
+def slug(value: str) -> str:
+    return re.sub(r"[^a-z0-9]+", "-", value.lower()).strip("-") or "contract"
+
+
+def init_plan(args: argparse.Namespace, mode: str, defaults: dict) -> int:
+    require_confirm(args)
+    project = Path(args.project).resolve()
+    seed = f"{project}:{mode}:{getattr(args, 'route', '')}:{now()}".encode()
+    ident = f"{mode}-{hashlib.sha256(seed).hexdigest()[:12]}"
+    output = project / ".maggie" / "design" / mode / ident / "plan.json"
+    plan = {"schemaVersion": f"maggie-{mode}-surface.v1", "id": ident, "mode": mode, "createdAt": now(), **defaults}
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.write_text(json.dumps(plan, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+    print(json.dumps({"plan": str(output), "id": ident, "mode": mode}, indent=2))
+    return 0
+
+
+def validate_progressive(args: argparse.Namespace) -> int:
+    evidence = read_json(Path(args.evidence))
+    errors: list[str] = []
+    if evidence.get("schemaVersion") != "maggie-progressive-enhancement.v1":
+        errors.append("evidence schemaVersion must be maggie-progressive-enhancement.v1")
+    region = evidence.get("region") if isinstance(evidence.get("region"), dict) else {}
+    if not region.get("id") or not region.get("selector"):
+        errors.append("region id and selector are required")
+    if region.get("swapScope") != "smallest-changed-region":
+        errors.append("swapScope must be smallest-changed-region")
+    initial = evidence.get("initial") if isinstance(evidence.get("initial"), dict) else {}
+    initial_requests = set(initial.get("thirdPartyRequests") or [])
+    initial_ids = initial.get("identities") if isinstance(initial.get("identities"), dict) else {}
+    states = evidence.get("states")
+    if not isinstance(states, list) or not states:
+        errors.append("states must be a non-empty array")
+        states = []
+    for state in states:
+        if not isinstance(state, dict):
+            errors.append("each state must be an object")
+            continue
+        new_requests = sorted(set(state.get("thirdPartyRequests") or []) - initial_requests)
+        if new_requests:
+            errors.append(f"state {state.get('name', 'unknown')} introduced third-party requests: {', '.join(new_requests)}")
+        identities = state.get("identities") if isinstance(state.get("identities"), dict) else {}
+        for identity, token in initial_ids.items():
+            if identities.get(identity) != token:
+                errors.append(f"state {state.get('name', 'unknown')} changed identity {identity}")
+        if state.get("outsideRegionStable") is not True:
+            errors.append(f"state {state.get('name', 'unknown')} lacks outsideRegionStable=true")
+    return emit_and_exit(result("maggie-progressive-enhancement.v1", errors, checkedStates=len(states), region=region), Path(args.output) if args.output else None)
+
+
+def css_escape(token: str) -> str:
+    return "".join((f"\\{char}" if char in r":[]()./%#" else char) for char in token)
+
+
+def validate_css(args: argparse.Namespace) -> int:
+    errors: list[str] = []
+    missing: list[str] = []
+    classes: list[str] = []
+    if args.evidence:
+        evidence = read_json(Path(args.evidence))
+        if evidence.get("schemaVersion") != "maggie-css-utility-evidence.v1":
+            errors.append("evidence schemaVersion must be maggie-css-utility-evidence.v1")
+        for element in evidence.get("elements") or []:
+            if not isinstance(element, dict):
+                errors.append("each CSS evidence element must be an object")
+                continue
+            for declaration in element.get("declarations") or []:
+                winner = declaration.get("winningSource") if isinstance(declaration.get("winningSource"), dict) else {}
+                if winner.get("layer") == "unlayered" or winner.get("projectRule") is True:
+                    errors.append(f"utility declaration {declaration.get('property', 'unknown')} is won by unlayered project CSS")
+    else:
+        source_html = Path(args.html).read_text(encoding="utf-8")
+        source_css = Path(args.css).read_text(encoding="utf-8")
+        for raw in re.findall(r'class=["\']([^"\']+)', source_html, re.I):
+            classes.extend(item for item in html_lib.unescape(raw).split() if ":" in item or "[" in item)
+        classes.extend(args.required_class or [])
+        for token in dict.fromkeys(classes):
+            if token not in source_css and css_escape(token) not in source_css:
+                missing.append(token)
+        if missing:
+            errors.append("compiled CSS is missing required utility classes: " + ", ".join(missing))
+    return emit_and_exit(result("maggie-css-utility-evidence.v1", errors, missingClasses=missing, checkedClasses=list(dict.fromkeys(classes))), Path(args.output) if args.output else None)
+
+
+def validate_dashboard(args: argparse.Namespace) -> int:
+    plan = read_json(Path(args.plan))
+    evidence = read_json(Path(args.evidence))
+    errors: list[str] = []
+    required = {"desktop", "tablet", "mobile", "collapsed-rail", "mobile-drawer", "modal"}
+    observed = set(evidence.get("screenshots") or []) | set(evidence.get("states") or [])
+    if plan.get("schemaVersion") != "maggie-dashboard-surface.v1":
+        errors.append("dashboard plan schemaVersion is invalid")
+    if not required <= observed:
+        errors.append("dashboard evidence is missing: " + ", ".join(sorted(required - observed)))
+    if evidence.get("route") != plan.get("route"):
+        errors.append("dashboard evidence route does not match plan")
+    return emit_and_exit(result("maggie-dashboard-surface.v1", errors, observed=sorted(observed)), Path(args.output) if args.output else None)
+
+
+def validate_sample(args: argparse.Namespace) -> int:
+    plan = read_json(Path(args.plan))
+    evidence = read_json(Path(args.evidence))
+    errors: list[str] = []
+    if plan.get("schemaVersion") != "maggie-sample-surface.v1":
+        errors.append("sample plan schemaVersion is invalid")
+    if evidence.get("noindex") is not True:
+        errors.append("sample route must be noindex")
+    if evidence.get("sitemapIncluded") is not False:
+        errors.append("sample route must be excluded from the sitemap")
+    if not str(evidence.get("banner") or "").strip():
+        errors.append("sample route needs an explicit layout-sample banner")
+    if not isinstance(evidence.get("placeholders"), list) or not evidence.get("placeholders"):
+        errors.append("sample evidence needs placeholder lines")
+    if not isinstance(evidence.get("finishChecklist"), list) or not evidence.get("finishChecklist"):
+        errors.append("sample evidence needs a finish checklist")
+    return emit_and_exit(result("maggie-sample-surface.v1", errors, route=plan.get("route")), Path(args.output) if args.output else None)
+
+
+def validate_privacy(args: argparse.Namespace) -> int:
+    evidence = read_json(Path(args.evidence))
+    errors: list[str] = []
+    if evidence.get("schemaVersion") != "maggie-privacy-origin-evidence.v1":
+        errors.append("evidence schemaVersion must be maggie-privacy-origin-evidence.v1")
+    observed: set[str] = set()
+    for page in evidence.get("pages") or []:
+        observed.update(str(origin) for origin in (page.get("origins") or []))
+    declared = set(str(origin) for origin in evidence.get("policyOrigins") or [])
+    if observed - declared:
+        errors.append("unlisted third-party origins: " + ", ".join(sorted(observed - declared)))
+    if declared - observed and evidence.get("requireObservedPolicyOrigins", True):
+        errors.append("privacy policy origins not observed in rendered pages: " + ", ".join(sorted(declared - observed)))
+    return emit_and_exit(result("maggie-privacy-origin-evidence.v1", errors, observedOrigins=sorted(observed), policyOrigins=sorted(declared)), Path(args.output) if args.output else None)
+
+
+def validate_structure(args: argparse.Namespace) -> int:
+    model = read_json(Path(args.model))
+    evidence = read_json(Path(args.evidence))
+    errors: list[str] = []
+    if model.get("schemaVersion") != "maggie-site-structure.v1":
+        errors.append("model schemaVersion must be maggie-site-structure.v1")
+    entries = {str(item.get("route")): item for item in model.get("pages") or [] if isinstance(item, dict) and item.get("route")}
+    seen = set()
+    for item in evidence.get("pages") or []:
+        if not isinstance(item, dict) or not item.get("route"):
+            errors.append("each rendered page evidence row needs a route")
+            continue
+        route = str(item["route"])
+        seen.add(route)
+        expected = entries.get(route)
+        if not expected:
+            errors.append(f"rendered route is absent from site structure model: {route}")
+            continue
+        for field in ("template", "source"):
+            if expected.get(field) != item.get(field):
+                errors.append(f"{route}: {field} does not match the model")
+        if set(expected.get("bands") or []) != set(item.get("bands") or []):
+            errors.append(f"{route}: band identities do not match the model")
+    for route in sorted(set(entries) - seen):
+        errors.append(f"model route has no rendered evidence: {route}")
+    return emit_and_exit(result("maggie-site-structure.v1", errors, checkedRoutes=sorted(seen)), Path(args.output) if args.output else None)
+
+
+def validate_capabilities(args: argparse.Namespace) -> int:
+    manifest = read_json(Path(args.manifest))
+    errors: list[str] = []
+    if manifest.get("schemaVersion") != "maggie-host-capabilities.v1":
+        errors.append("manifest schemaVersion must be maggie-host-capabilities.v1")
+    endpoints = manifest.get("endpoints")
+    if not isinstance(endpoints, list) or not endpoints:
+        errors.append("endpoints must be a non-empty array")
+        endpoints = []
+    seen: set[str] = set()
+    for endpoint in endpoints:
+        if not isinstance(endpoint, dict):
+            errors.append("each capability endpoint must be an object")
+            continue
+        ident = str(endpoint.get("id") or "")
+        if not ident or ident in seen:
+            errors.append("capability endpoint ids must be non-empty and unique")
+        seen.add(ident)
+        if not isinstance(endpoint.get("enabled"), bool):
+            errors.append(f"{ident or 'unknown'}: enabled must be boolean")
+        if not str(endpoint.get("path") or "").startswith("/"):
+            errors.append(f"{ident or 'unknown'}: path must start with /")
+    return emit_and_exit(result("maggie-host-capabilities.v1", errors, enabled=sum(1 for item in endpoints if isinstance(item, dict) and item.get("enabled") is True), endpointCount=len(endpoints)), Path(args.output) if args.output else None)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(prog="maggie contracts")
+    sub = parser.add_subparsers(dest="command", required=True)
+    progressive = sub.add_parser("progressive-check")
+    progressive.add_argument("--evidence", required=True); progressive.add_argument("--output")
+    progressive.set_defaults(func=validate_progressive)
+    css = sub.add_parser("css-check")
+    css.add_argument("--evidence"); css.add_argument("--html"); css.add_argument("--css"); css.add_argument("--required-class", action="append", default=[]); css.add_argument("--output")
+    css.set_defaults(func=validate_css)
+    cascade = sub.add_parser("css-cascade-check")
+    cascade.add_argument("--evidence", required=True); cascade.add_argument("--output")
+    cascade.set_defaults(func=validate_css)
+    dash_init = sub.add_parser("dash-init")
+    dash_init.add_argument("--project", default="."); dash_init.add_argument("--route", required=True); dash_init.add_argument("--confirm", action="store_true")
+    dash_init.set_defaults(func=lambda args: init_plan(args, "dashboard", {"route": args.route, "operatorJourneys": ["first-person task completion"], "shell": {"rail": True, "workArea": True, "tabs": True, "modal": True}, "requiredEvidence": ["desktop", "tablet", "mobile", "collapsed-rail", "mobile-drawer", "modal"], "publicWrite": False}))
+    dash_validate = sub.add_parser("dash-validate")
+    dash_validate.add_argument("--plan", required=True); dash_validate.add_argument("--evidence", required=True); dash_validate.add_argument("--output")
+    dash_validate.set_defaults(func=validate_dashboard)
+    sample_init = sub.add_parser("sample-init")
+    sample_init.add_argument("--project", default="."); sample_init.add_argument("--route", required=True); sample_init.add_argument("--purpose", required=True); sample_init.add_argument("--confirm", action="store_true")
+    sample_init.set_defaults(func=lambda args: init_plan(args, "sample", {"route": args.route, "purpose": args.purpose, "noindex": True, "sitemapIncluded": False, "bannerRequired": True, "placeholderPolicy": "unwritten lines must remain explicit placeholders", "finishChecklist": ["replace placeholder copy", "replace media", "run accessibility and SEO checks"], "publicWrite": False}))
+    sample_validate = sub.add_parser("sample-validate")
+    sample_validate.add_argument("--plan", required=True); sample_validate.add_argument("--evidence", required=True); sample_validate.add_argument("--output")
+    sample_validate.set_defaults(func=validate_sample)
+    privacy = sub.add_parser("privacy-check")
+    privacy.add_argument("--evidence", required=True); privacy.add_argument("--output")
+    privacy.set_defaults(func=validate_privacy)
+    structure = sub.add_parser("structure-validate")
+    structure.add_argument("--model", required=True); structure.add_argument("--evidence", required=True); structure.add_argument("--output")
+    structure.set_defaults(func=validate_structure)
+    capabilities = sub.add_parser("capabilities-validate")
+    capabilities.add_argument("--manifest", required=True); capabilities.add_argument("--output")
+    capabilities.set_defaults(func=validate_capabilities)
+    args = parser.parse_args()
+    try:
+        return args.func(args)
+    except (OSError, ValueError, json.JSONDecodeError) as error:
+        print(f"BLOCKED: maggie contract validation: {error}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/bundled-tools/clis/maggie_dash.py

@@ -192,9 +192,10 @@ def merge_astro_middleware(path: Path) -> dict[str, object]:
     """Add the stable Maggie paths to an existing conventional Astro middleware.
 
     The installer must preserve host-owned auth/redirect logic. This narrow
-    merge only handles the common `onRequest = defineMiddleware((context,
-    next) => { ... })` shape and is idempotent. Unknown middleware shapes are
-    reported to the caller instead of being rewritten heuristically.
+    merge handles the common `onRequest = defineMiddleware((context, next) =>
+    { ... })` shape and the equivalent destructured context form. Unknown
+    middleware shapes are reported to the caller instead of being rewritten
+    heuristically.
     """
     try:
         content = path.read_text(encoding="utf-8")
@@ -209,8 +210,6 @@ def merge_astro_middleware(path: Path) -> dict[str, object]:
         r"export\s+const\s+onRequest\s*=\s*defineMiddleware\(\s*\(\s*context\s*,\s*next\s*\)\s*=>\s*\{",
         content,
     )
-    if not match:
-        return {"status": "manual", "reason": "middleware is not the supported defineMiddleware((context, next) => {}) shape"}
     block = r'''
   // maggie-auto-rewrite-v1: generated by `maggie booking install`; keep host auth below.
   const maggieRewrites: Array<[RegExp, (path: string) => string]> = [
@@ -228,7 +227,24 @@ def merge_astro_middleware(path: Path) -> dict[str, object]:
     }
   }
 '''
-    merged = content[:match.end()] + block + content[match.end():]
+    if match:
+        merged = content[:match.end()] + block + content[match.end():]
+    else:
+        # Astro examples commonly destructure the request context in the
+        # parameter list: `(({ url, request }, next) => { ... })`. Normalize
+        # only this explicit shape so the generated rewrite block can use the
+        # full context while preserving the host's existing variable names.
+        destructured = re.search(
+            r"(?P<prefix>export\s+const\s+onRequest\s*=\s*defineMiddleware\(\s*\()\s*\{(?P<properties>[^{}]+)\}\s*,\s*(?P<next>[A-Za-z_$][\w$]*)\s*\)\s*=>\s*\{",
+            content,
+        )
+        if not destructured:
+            return {"status": "manual", "reason": "middleware is not a supported defineMiddleware((context, next) => {}) shape"}
+        properties = destructured.group("properties").strip()
+        next_name = destructured.group("next")
+        replacement = f"{destructured.group('prefix')}context, {next_name}) => {{\n  const {{ {properties} }} = context;"
+        normalized = content[:destructured.start()] + replacement + content[destructured.end():]
+        merged = normalized[:destructured.start() + len(replacement)] + block + normalized[destructured.start() + len(replacement):]
     try:
         path.write_text(merged, encoding="utf-8")
     except OSError as error:
@@ -262,6 +278,12 @@ def manifest_host_file_pairs(source: Path, manifest: dict[str, object], root: Pa
     for path in sorted(source_item.rglob("*")):
         if path.is_file():
             child = path.relative_to(source_item)
+            # A deployment config is host-owned. The default Node config is
+            # useful for a blank Astro project, but adding a second config to
+            # a host that already has astro.config.ts/cloudflare/etc. can make
+            # Astro ambiguous or change its deployment target.
+            if framework == "astro" and child.name == "astro.config.mjs" and any(root.glob("astro.config.*")):
+                continue
             pairs.append((path, root / target_relative / child, source_relative / child))
     return pairs
 

package/bundled-tools/clis/maggie_design.py

@@ -532,9 +532,31 @@ def design_job_path(project: Path, job_id: str) -> Path:
     return project / ".maggie" / "design-jobs" / f"{job_id}.json"
 
 
-def save_design_job(project: Path, job: dict[str, object]) -> None:
+def design_job_candidates(project: Path, job_id: str) -> list[Path]:
+    """Return every supported location for a resumable design job.
+
+    In-place jobs historically live under ``design-jobs`` while first-party
+    author jobs are briefs under ``.maggie/design``. Both are Maggie design
+    jobs and the progress commands must treat them identically.
+    """
+    root = project.resolve() / ".maggie"
+    return [
+        root / "design-jobs" / f"{job_id}.json",
+        root / "design" / f"{job_id}.json",
+    ]
+
+
+def find_design_job_path(project: Path, job_id: str) -> Path:
+    for candidate in design_job_candidates(project, job_id):
+        if candidate.is_file():
+            return candidate
+    expected = design_job_path(project.resolve(), job_id)
+    raise ValueError(f"design job not found: {expected}")
+
+
+def save_design_job(project: Path, job: dict[str, object], path: Path | None = None) -> None:
     job["updated_at"] = datetime.now(timezone.utc).isoformat()
-    path = design_job_path(project, str(job["id"]))
+    path = path or design_job_path(project, str(job["id"]))
     path.parent.mkdir(parents=True, exist_ok=True)
     path.write_text(json.dumps(job, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
 
@@ -599,17 +621,13 @@ def run_design_job(urls: list[str], project: Path, clone_run: str, force: bool =
 
 
 def design_status(project: Path, job_id: str) -> int:
-    path = design_job_path(project.resolve(), job_id)
-    if not path.exists():
-        raise ValueError(f"design job not found: {path}")
+    path = find_design_job_path(project, job_id)
     print(path.read_text(encoding="utf-8"), end="")
     return 0
 
 
 def design_resume(project: Path, job_id: str) -> int:
-    path = design_job_path(project.resolve(), job_id)
-    if not path.exists():
-        raise ValueError(f"design job not found: {path}")
+    path = find_design_job_path(project, job_id)
     job = json.loads(path.read_text(encoding="utf-8"))
     return run_design_job(job["urls"], project, job["clone_run"], force=True)[0]
 
@@ -620,9 +638,7 @@ def _step_records(names: list[str]) -> list[dict[str, object]]:
 
 def design_step(project: Path, job_id: str, step: str, evidence: str) -> int:
     """Record one piece of implementation evidence and make progress durable."""
-    path = design_job_path(project.resolve(), job_id)
-    if not path.exists():
-        raise ValueError(f"design job not found: {path}")
+    path = find_design_job_path(project, job_id)
     job = json.loads(path.read_text(encoding="utf-8"))
     steps = job.get("steps", [])
     target = next((item for item in steps if item.get("name") == step), None)
@@ -774,8 +790,9 @@ def author_job(project: Path, route: str, purpose: str, audience: str, brief_fil
     brief = {"schemaVersion": "maggie-page-brief.v1", "route": route, "purpose": purpose.strip() or source_brief["purpose"], "audience": audience.strip() or source_brief["audience"], "contentBrief": source_brief.get("contentBrief", ""), "shell": "homepage-canonical", "status": "draft", "sourceEvidence": None, "approval": {"status": "pending", "actor": None}, "createdAt": datetime.now(timezone.utc).isoformat()}
     digest = hashlib.sha256((str(project) + "\n" + route).encode()).hexdigest()[:12]
     output = project / ".maggie" / "design" / "briefs" / f"{relative.replace('/', '-')}.json"; output.parent.mkdir(parents=True, exist_ok=True); output.write_text(json.dumps(brief, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+    required_steps = ["inspect-shell", "implement-page", "capture-responsive-screenshots", "accessibility-check", "build-check", "approval"]
     plan_path = project / ".maggie" / "design" / f"author-{digest}.json"
-    plan_path.write_text(json.dumps({"id": f"author-{digest}", "workflow": "maggie-design", "mode": "author", "phase": "ready", "brief": str(output), "designContract": contract, "sourceUrlRequired": False, "shellSourceOfTruth": "homepage-canonical", "approvalRequired": True, "requiredSteps": ["inspect-shell", "implement-page", "capture-responsive-screenshots", "accessibility-check", "build-check", "approval"]}, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+    plan_path.write_text(json.dumps({"id": f"author-{digest}", "workflow": "maggie-design", "mode": "author", "phase": "ready", "brief": str(output), "designContract": contract, "sourceUrlRequired": False, "shellSourceOfTruth": "homepage-canonical", "approvalRequired": True, "requiredSteps": required_steps, "required_steps": required_steps, "steps": _step_records(required_steps), "history": [{"phase": "ready", "at": datetime.now(timezone.utc).isoformat()}]}, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
     print(json.dumps({"brief": str(output), "plan": str(plan_path), "phase": "ready"}, indent=2)); return 0
 
 

package/bundled-tools/clis/maggie_service_booking.py

@@ -222,7 +222,24 @@ def make_record(provider, source, pid, name, description, variants, booking, lin
     if not booking:
         for href,_ in links:
             if any(x in href.lower() for x in ("book","appointment","checkout")): booking=urljoin(source,href); break
-    return {"id":f"{provider}:{pid}","provider":provider,"providerServiceId":pid,"slug":slug(name),"title":name,"description":description.strip(),"sourceUrl":source,"category":{"level1":"Uncategorised","level2":None},"variants":variants,"bookingUrl":booking,"paymentUrl":None,"status":"active","supplyState":"live","displayState":"published","firstSeenAt":NOW(),"lastSeenAt":NOW()}
+    record = {"id":f"{provider}:{pid}","provider":provider,"providerServiceId":pid,"slug":slug(name),"title":name,"description":description.strip(),"sourceUrl":source,"category":{"level1":"Uncategorised","level2":None},"variants":variants,"bookingUrl":booking,"paymentUrl":None,"status":"active","supplyState":"live","displayState":"published","firstSeenAt":NOW(),"lastSeenAt":NOW()}
+    # A treatment is one catalogue entry. Duration/price choices belong to
+    # variants so the same treatment is not presented as four products.
+    durations = [int(item["durationMinutes"]) for item in variants if isinstance(item, dict) and isinstance(item.get("durationMinutes"), (int, float)) and item["durationMinutes"] > 0]
+    priced = [item.get("price", {}) for item in variants if isinstance(item, dict) and isinstance(item.get("price"), dict) and isinstance(item.get("price", {}).get("amountMinor"), int)]
+    currencies = {item.get("currency") for item in priced if item.get("currency")}
+    from_price = None
+    if priced and len(currencies) == 1:
+        lowest = min(priced, key=lambda item: item["amountMinor"])
+        from_price = {"amountMinor": lowest["amountMinor"], "currency": lowest["currency"]}
+    record["treatmentGroup"] = {
+        "id": record["id"],
+        "title": name,
+        "variantCount": len(variants),
+        "durationRange": {"minMinutes": min(durations), "maxMinutes": max(durations)} if durations else None,
+        "fromPrice": from_price,
+    }
+    return record
 
 def root(args): return Path(args.project).resolve()
 def path(project): return project/".maggie"/"booking"/"services.json"
@@ -1263,6 +1280,36 @@ def cmd_resolver_audit(args):
     print(json.dumps({"status": report["status"], "report": str(output), "counts": counts, "errors": errors}, indent=2)); return 0 if not errors else 1
 
 
+def cmd_treatment_group_audit(args):
+    """Require one treatment record with explicit duration/price variants."""
+    data = load(root(args))
+    errors = []
+    groups = {}
+    for service in data.get("services", []):
+        group = service.get("treatmentGroup") if isinstance(service.get("treatmentGroup"), dict) else {}
+        group_id = str(group.get("id") or "")
+        if not group_id:
+            errors.append(f"{service.get('id', 'unknown')}: missing treatmentGroup.id")
+            continue
+        if group_id in groups:
+            errors.append(f"duplicate treatment group: {group_id}")
+        groups[group_id] = service.get("id")
+        variants = service.get("variants") if isinstance(service.get("variants"), list) else []
+        if not variants:
+            errors.append(f"{service.get('id', 'unknown')}: treatment group has no variants")
+        if group.get("variantCount") != len(variants):
+            errors.append(f"{service.get('id', 'unknown')}: treatmentGroup.variantCount is stale")
+        durations = [item.get("durationMinutes") for item in variants if isinstance(item, dict) and isinstance(item.get("durationMinutes"), (int, float))]
+        duration_range = group.get("durationRange")
+        if durations and (not isinstance(duration_range, dict) or duration_range.get("minMinutes") != min(durations) or duration_range.get("maxMinutes") != max(durations)):
+            errors.append(f"{service.get('id', 'unknown')}: treatmentGroup.durationRange is stale")
+    report = {"schemaVersion": "maggie-treatment-groups.v1", "passed": not errors, "errors": errors, "treatments": len(groups), "variants": sum(len(item.get("variants", [])) for item in data.get("services", []))}
+    if args.output:
+        output = (root(args) / args.output).resolve() if not Path(args.output).is_absolute() else Path(args.output)
+        output.parent.mkdir(parents=True, exist_ok=True); output.write_text(json.dumps(report, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+    print(json.dumps(report, indent=2, ensure_ascii=False))
+    return 0 if report["passed"] else 1
+
 def main():
     p=argparse.ArgumentParser(); sub=p.add_subparsers(dest="command",required=True)
     for name in ("import","sync","run"):
@@ -1279,6 +1326,7 @@ def main():
     q=sub.add_parser("category-hash"); q.add_argument("--project",default="."); q.add_argument("--copy-data",required=True); q.add_argument("--apply",action="store_true",help="backfill deterministic provenance hashes in this generated artifact")
     q=sub.add_parser("fact-audit"); q.add_argument("--project",default="."); q.add_argument("--backfill-source",action="store_true",help="copy the catalogue sourceUrl into records that have no sourceUrl"); q.add_argument("--overrides",help="JSON of human-approved, evidenced descriptions for provider gaps"); q.add_argument("--apply-overrides",action="store_true",help="apply only approved fact overrides to the draft catalogue")
     q=sub.add_parser("catalogue-check"); q.add_argument("source"); q.add_argument("--project",default="."); q.add_argument("--provider",default="fresha",choices=["fresha"]); q.add_argument("--treatment",action="append",required=True,help="provider treatment name; repeat for multiple checks")
+    q=sub.add_parser("treatment-group-audit", help="ensure each treatment is one entry with duration/price variants"); q.add_argument("--project",default="."); q.add_argument("--output")
     q=sub.add_parser("retirement-audit"); q.add_argument("--project",default="."); q.add_argument("--catalogue",default=".maggie/booking/services.json"); q.add_argument("--evidence",required=True,help="sanitized runtime retirement evidence JSON"); q.add_argument("--output",default="docs/service-retirement-audit.json")
     q=sub.add_parser("capability-audit", help="validate provider variant declarations and fixture evidence"); q.add_argument("--project",default="."); q.add_argument("--provider"); q.add_argument("--catalogue",default=".maggie/booking/services.json"); q.add_argument("--capabilities-file",default=".maggie/booking/provider-capabilities.json"); q.add_argument("--fixture",help="sanitized provider fixture JSON"); q.add_argument("--output")
     q=sub.add_parser("category-context"); q.add_argument("--project",default="."); q.add_argument("--output")
@@ -1306,6 +1354,7 @@ def main():
     if a.command=="category-hash": return cmd_category_hash(a)
     if a.command=="fact-audit": return cmd_fact_audit(a)
     if a.command=="catalogue-check": return cmd_catalogue_check(a)
+    if a.command=="treatment-group-audit": return cmd_treatment_group_audit(a)
     if a.command=="retirement-audit": return cmd_retirement_audit(a)
     if a.command=="capability-audit": return cmd_capability_audit(a)
     if a.command=="category-context": return cmd_category_context(a)

package/bundled-tools/clis/site_audit.py

@@ -69,9 +69,20 @@ class PageParser(HTMLParser):
         self.paragraphs = []
         self.links = []
         self.fragment_ids = set()
+        self.primary_navigation_links = []
+        self._header_depth = 0
+        self._nav_depth = 0
+        self._primary_nav_depth = 0
 
     def handle_starttag(self, tag, attrs):
         data = dict(attrs)
+        if tag == "header":
+            self._header_depth += 1
+        if tag == "nav":
+            self._nav_depth += 1
+            label = f"{data.get('aria-label', '')} {data.get('id', '')} {data.get('class', '')}".lower()
+            if self._header_depth or any(token in label for token in ("primary", "main", "navigation")):
+                self._primary_nav_depth += 1
         if data.get("id"):
             self.fragment_ids.add(data["id"])
         if tag == "a" and data.get("name"):
@@ -106,6 +117,8 @@ class PageParser(HTMLParser):
             self._jsonld = []
         elif tag == "a" and data.get("href"):
             self.anchors += 1
+            if self._primary_nav_depth:
+                self.primary_navigation_links.append(data.get("href", ""))
         elif tag == "img":
             self.images.append({"src": data.get("src", ""), "alt": data.get("alt")})
 
@@ -132,6 +145,12 @@ class PageParser(HTMLParser):
             except json.JSONDecodeError:
                 self.jsonld_values.append(None)
             self._jsonld = None
+        if tag == "nav":
+            self._nav_depth = max(0, self._nav_depth - 1)
+            if self._primary_nav_depth:
+                self._primary_nav_depth -= 1
+        elif tag == "header":
+            self._header_depth = max(0, self._header_depth - 1)
 
     def handle_data(self, data):
         if not self.hidden_depth and data.strip():
@@ -193,6 +212,7 @@ def audit_page(url: str, html: str, status: int, content_type: str, expected_lan
             "lang": page.lang, "hreflang": page.hreflang, "robots": robots,
             "jsonld": page.jsonld_values, "images": page.images,
             "fragmentIds": sorted(page.fragment_ids),
+            "primaryNavigationLinks": page.primary_navigation_links,
             "structureHash": hashlib.sha256(json.dumps(stable_structure(page.structure), sort_keys=True).encode()).hexdigest(),
             "textHash": hashlib.sha256(" ".join(page.visible_text).encode()).hexdigest(),
         },
@@ -215,9 +235,37 @@ def audit_page(url: str, html: str, status: int, content_type: str, expected_lan
         "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,
+        "primary_navigation_links": page.primary_navigation_links,
     }
 
 
+def primary_navigation_check(base: str, page: PageParser, fetcher=fetch) -> dict:
+    """Ensure links presented as primary navigation are indexable destinations."""
+    origin = urlparse(base).netloc
+    routes = []
+    for href in page.primary_navigation_links:
+        target = urljoin(base + "/", href)
+        parsed = urlparse(target)
+        if parsed.scheme not in {"http", "https"} or parsed.netloc != origin:
+            continue
+        target = urlunparse((parsed.scheme, parsed.netloc, parsed.path or "/", "", "", ""))
+        if target not in routes:
+            routes.append(target)
+    violations = []
+    for target in routes:
+        try:
+            status, content_type, body = fetcher(target)
+            destination = PageParser(); destination.feed(body)
+            directives = [item.lower() for item in destination.robots_directives]
+            tokens = [token.strip().rsplit(":", 1)[-1] for directive in directives for token in directive.split(",")]
+            blocked = sorted(set(tokens) & {"noindex", "nofollow", "none"})
+            if blocked:
+                violations.append({"url": target, "status": status, "directives": directives, "blocked": blocked})
+        except Exception as exc:
+            violations.append({"url": target, "error": type(exc).__name__})
+    return {"ok": not violations, "links": routes, "violations": violations}
+
+
 def summarize_crawl(pages: list[dict]) -> dict:
     """Count captured evidence, preserving regional/script locale distinctions."""
     groups = {}
@@ -470,6 +518,7 @@ def main() -> int:
         checks["jsonld"] = {"ok": page.jsonld > 0 and all(item is not None for item in page.jsonld_values), "count": page.jsonld}
         checks["entity_jsonld"] = {"ok": any(isinstance(item, dict) and item.get("@type") and (item.get("url") or item.get("@id")) for item in page.jsonld_values), "count": page.jsonld}
         checks["crawlable_links"] = {"ok": page.anchors > 0, "count": page.anchors}
+        checks["primary_navigation_indexability"] = primary_navigation_check(base, page)
         robots_tokens = [token.strip() for directive in page.robots_directives for token in directive.split(",")]
         checks["robots_directive"] = {"ok": not page.robots_directives or not any(token in {"noindex", "none", "nofollow"} for token in robots_tokens), "directives": page.robots_directives}
         checks["robots_conflict"] = {"ok": not (len({token for token in robots_tokens if token in {"index", "noindex"}}) > 1 or len({token for token in robots_tokens if token in {"follow", "nofollow"}}) > 1), "directives": page.robots_directives}

package/package.json

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