@topy-ai/maggie 0.7.40 → 0.7.41

package/bundled-references/browser-inspection.md

@@ -27,6 +27,27 @@ interaction states and triggers
 responsive differences
 ```
 
+Behavioral checks may be declared instead of hidden in a bespoke script. The
+manifest is safe to commit because input values are not copied into evidence:
+
+```json
+{
+  "schemaVersion": "maggie-browser-interactions.v1",
+  "steps": [
+    {"id": "open", "action": "click", "selector": "[data-menu]"},
+    {"id": "visible", "action": "assert-visible", "selector": "[data-drawer]"},
+    {"id": "styles", "action": "assert-style", "selector": "[data-drawer]", "property": "display", "value": "block"},
+    {"id": "privacy", "action": "assert-no-request", "origin": "third-party.example"}
+  ]
+}
+```
+
+Run it with `maggie browser-audit ... --interactions .maggie/interactions.json`.
+Supported actions cover click, fill, type, select, press, wait, visibility and
+state assertions, computed-style assertions, and new-request assertions. The
+browser adapter owns the session and the audit records only step IDs and
+redacted outcomes.
+
 If a target requires login, a bot challenge, a consent interaction, or a
 private browser profile, stop at that boundary and ask the user to provide
 authorized access. Do not bypass access controls or record cookies in project

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

@@ -103,3 +103,15 @@ maggie blog integration-state --configured --authorized  # ready
 
 Provider adapters should preserve the same `not-configured`,
 `awaiting-consent`, `awaiting-authorization`, `ready`, and `error` semantics.
+
+Content evidence should also capture the Git source revision before an agent
+writes or publishes a post:
+
+```bash
+maggie provenance --project . --source src/content/post.md \
+  --output .maggie/content-provenance.json
+```
+
+The report records commit, branch, dirty state, and authoring boundary. Host
+write paths should reject stale writes unless the source revision still
+matches; private paths and secrets are never included.

package/bundled-skills/maggie-blog-bootstrap/SKILL.md

@@ -116,3 +116,26 @@ The project must have a passing foundation state, a real public route graph,
 published-only sitemap/canonical metadata, responsive UI evidence, an explicit
 Ops decision, and a documented rollback/deployment plan. A rendered button or
 mock editor is not evidence that a backend operation works.
+
+### Authenticated browser QA and CDN safety
+
+Authenticated browser evidence must use a host-owned short-lived session
+contract. The host mints and revokes the session, passwords never enter the
+browser harness, TTL is bounded, and the token is never written to Maggie
+artifacts. Validate the contract with:
+
+```bash
+maggie dash session-check --manifest .maggie/browser-session.json
+```
+
+Public HTML must be identical across sessions so a CDN cannot cache an
+administrator control for anonymous visitors. Keep the real session cookie
+`httpOnly`; use a non-authoritative readable hint cookie only to decide whether
+the browser should request identity client-side. Validate evidence with:
+
+```bash
+maggie dash cache-boundary-check --evidence .maggie/public-session-cache.json
+```
+
+If a host cannot provide these routes, record the browser session feature as
+deferred rather than inserting a database session from a shared CLI.

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

@@ -191,6 +191,21 @@ placeholders, owner/admin/manager access, audit and idempotency requirements,
 and the server-only provider/recipient privacy boundary. It does not connect to
 Resend, send a message, or expose customer data.
 
+The selected transactional delivery boundary is Resend for email and Twilio
+for SMS. Validate the host policy before wiring provider adapters:
+
+```bash
+maggie booking-delivery \
+  --policy .maggie/booking-delivery-policy.json
+```
+
+The policy requires provider acknowledgement before a booking can display a
+confirmed state, uses a bounded exponential-jitter retry with an idempotency
+key per booking event and channel, and moves exhausted work to a dead-letter
+queue. Replay is an explicit manager action and must be audited. `RESEND_API_KEY`
+and `TWILIO_AUTH_TOKEN` remain server-only host secrets; this gate never sends
+email or SMS.
+
 After the first owner signs in, the Booking Overview includes the same
 secret-safe readiness path: Stripe connection status, test/live mode, and a
 copyable `/api/maggie/booking/webhooks/stripe` URL. The preferred path is still

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

@@ -41,6 +41,19 @@ Each run persists `manifest.json`, `state.json`, and phase outputs under
 `failed` and must be resumed after the defect is fixed; an incomplete run must
 not be presented as a successful clone.
 
+Replay approved interaction states with the same manifest used by
+`maggie browser-audit`:
+
+```bash
+maggie clone interactions --project <project-root> --run-id <stable-run-id> \
+  --browse <browse-cli> --interactions .maggie/browser-interactions.json
+```
+
+The adapter replays at desktop, tablet, and mobile viewports and writes a
+redacted `maggie-clone-interaction-state.v1` evidence file. It never stores
+typed values, credentials, or raw provider payloads. A clone is not
+interaction-complete until every approved step passes at all three viewports.
+
 An exported local HTML file is also a valid source, for example:
 
 ```text

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

@@ -414,3 +414,9 @@ both units being enabled in systemd. Data-dependent releases additionally
 require `rollback.backupId` and `rollback.restoreCommand` in
 `.maggie/deployment/data-release.json`, because switching code alone does not
 restore incompatible data.
+
+`maggie update --help` is read-only. Help flags must be handled before project
+discovery, install-manifest writes, or file synchronization. For fixture-backed
+browser QA, the host owns the isolated dev server and data source; document a
+second port/process and fixture mode in the host runbook instead of making the
+shared updater or deployment CLI start an unmanaged daemon.

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

@@ -95,9 +95,20 @@ fallback. Mobile evidence must not assume that `preload="none"` will emit
 `canplaythrough` without user interaction. Record poster visibility, playback
 state, console errors, network errors, and a screenshot per viewport.
 
-This contract is provider-neutral. It does not claim that Maggie can generate
-video assets; generated-video planning, continuation, safety review, retries,
-and cost approval remain separate product/provider work.
+The playback contract is provider-neutral, while the selected generation
+policy is Google Gemini: `gemini-omni-1.1-flash` for the default hero-video
+route and `veo-3.1-generate-preview` for specialized continuation/frame
+control. Validate the policy and job evidence separately:
+
+```bash
+maggie media video-policy \
+  --policy contracts/maggie-media/video-generation-policy-v1.json
+maggie media video-job --job .maggie/video-job.json
+```
+
+Generation remains host-owned. The host must supply cost budget, rights and
+moderation evidence, idempotency, object storage, and a redacted provenance
+record before a generated asset is used in a release.
 
 ## Automatic memory hook
 
@@ -531,3 +542,18 @@ utilities. Dashboard plans require operator journeys and desktop/tablet/mobile,
 collapsed-rail, mobile-drawer, and modal evidence. Sample plans require
 noindex, sitemap exclusion, a visible sample banner, placeholders, and a
 finish checklist.
+
+For generated or converted pages, run the markup gate before handing the page
+to a host editor:
+
+```bash
+maggie design markup-check --html src/pages/about.astro --require-content-keys
+maggie design style-check --manifest .maggie/style-editing.json
+```
+
+Editable copy uses stable `data-maggie-content-key` values. Never key prices,
+durations, opening times, contact details, entity identifiers, or mixed markup
+without an explicit host contract. Decode HTML entities exactly once; unknown
+or double-escaped entities stop the check. Optional empty attributes such as
+`style=""` must be omitted. Codemods using compiler positions must anchor at
+the opening `<tag` before slicing source text.

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

@@ -60,6 +60,18 @@ requires HTTP 200, a readable square image, and an engine-supported ICO, PNG,
 or GIF response. A logo-shaped source filename is only an unverified source
 candidate; it is never evidence that the public favicon route works.
 
+For npm 11 installation or package release work, run the safe preflight before
+an install mutation:
+
+```bash
+maggie npm11 --project . --output .maggie/npm11-preflight.json
+```
+
+The gate records the observed Node/npm versions, lockfile policy, lifecycle
+script policy, and an ignore-scripts-first smoke boundary. A project with
+`install`, `preinstall`, or `postinstall` scripts requires an explicit
+maintainer decision; Maggie never runs an untrusted install script implicitly.
+
 If the user does not name a mode, inspect the project and propose the smallest
 mode that satisfies the request. Do not rebuild the public blog or change its
 framework just to add Ops.

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

@@ -104,6 +104,29 @@ The strict flag is for a review window where a crawler request is expected; it
 fails only when the supplied log contains no sitemap request. Never upload raw
 logs or include IPs, credentials, or query data in feedback or reports.
 
+### GSC readiness release gate
+
+GSC readiness is part of the existing analytics release gate, not an implied
+result of having a sitemap. Produce redacted evidence for the property,
+verification, canonical origin, robots, sitemap, read-only authorization,
+query/readback, and production smoke:
+
+```bash
+maggie analytics gsc-readiness \
+  --gsc-evidence .maggie/gsc-readiness.json
+maggie analytics release-gate --project . --environment staging \
+  --contract .maggie/analytics-contract.json \
+  --render-report .maggie/analytics-browser.json \
+  --network-report .maggie/analytics-network.json \
+  --provider-report .maggie/analytics-provider.json \
+  --smoke-report .maggie/analytics-smoke.json \
+  --gsc-evidence .maggie/gsc-readiness.json --require-gsc
+```
+
+Use `contracts/maggie-seo/gsc-readiness-v1.schema.json` as the evidence
+boundary. Credentials and mutation scopes remain host-owned; a passing local
+contract is not proof of property ownership or live readback.
+
 ## Freeze and compare a reviewed site
 
 ```bash
@@ -393,3 +416,13 @@ same-origin page linked from primary navigation when it is `noindex`,
 `nofollow`, or `none`. The privacy check fails in both directions: an embedded
 origin missing from the policy, or a policy origin never observed in rendered
 pages, requires review.
+
+Noindex pages are still audited structurally. The crawl reports
+`indexabilityIfIndexed` with title, description, canonical, heading, and
+JSON-LD checks that would fail if the route became indexable. This is
+diagnostic evidence only; it does not change robots directives or sitemap
+membership. Baseline drift recapture requires a reviewer reason and records an
+expiring acknowledgement (`--reason-ttl-days`, default 30 days).
+
+Internal-link extraction is DOM-only. Text inside `script`, `style`,
+`noscript`, and comments is never treated as an anchor or link target.

package/bundled-tools/clis/maggie_analytics.py

@@ -48,6 +48,33 @@ def load_json(path: Path, label: str) -> tuple[dict | None, list[str]]:
     return value, []
 
 
+def gsc_checks(evidence: dict) -> dict[str, bool]:
+    required = {
+        "property": isinstance(evidence.get("property"), dict) and bool(evidence["property"].get("siteUrl")),
+        "verification": isinstance(evidence.get("verification"), dict) and evidence["verification"].get("passed") is True,
+        "canonical": isinstance(evidence.get("canonical"), dict) and evidence["canonical"].get("passed") is True,
+        "robots": isinstance(evidence.get("robots"), dict) and evidence["robots"].get("passed") is True,
+        "sitemap": isinstance(evidence.get("sitemap"), dict) and evidence["sitemap"].get("passed") is True,
+        "authorization": isinstance(evidence.get("authorization"), dict) and evidence["authorization"].get("readOnly") is True and evidence["authorization"].get("authorized") is True,
+        "query-readback": isinstance(evidence.get("queryReadback"), dict) and evidence["queryReadback"].get("passed") is True,
+        "production-smoke": isinstance(evidence.get("productionSmoke"), dict) and evidence["productionSmoke"].get("passed") is True,
+    }
+    return required
+
+
+def gsc_readiness(args: argparse.Namespace) -> int:
+    evidence, errors = load_json(Path(args.evidence).resolve(), "gsc evidence")
+    checks = gsc_checks(evidence or {})
+    failed = [name for name, passed in checks.items() if not passed]
+    errors.extend(failed)
+    if evidence and evidence.get("schemaVersion") != "maggie-gsc-readiness.v1":
+        errors.append("schemaVersion must be maggie-gsc-readiness.v1")
+    result = {"schemaVersion": "maggie-gsc-readiness-report.v1", "passed": not errors, "checks": checks, "failedChecks": failed, "errors": errors, "readOnly": True}
+    return_code = 0 if result["passed"] else 1
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+    return return_code
+
+
 def release_gate(args: argparse.Namespace) -> int:
     project = Path(args.project).resolve()
     checks: dict[str, dict] = {}
@@ -87,6 +114,14 @@ def release_gate(args: argparse.Namespace) -> int:
     errors.extend(provider_errors)
     smoke, smoke_errors = load_json(Path(args.smoke_report).resolve(), "smoke-report")
     errors.extend(smoke_errors)
+    if args.gsc_evidence:
+        gsc, gsc_errors = load_json(Path(args.gsc_evidence).resolve(), "gsc-evidence")
+        errors.extend(gsc_errors)
+        checks.update({f"gsc-{name}": {"passed": passed, "evidence": "maggie-gsc-readiness.v1"} for name, passed in gsc_checks(gsc or {}).items()})
+        if gsc and gsc.get("schemaVersion") != "maggie-gsc-readiness.v1":
+            errors.append("gsc-evidence-schema")
+    elif args.require_gsc:
+        errors.append("gsc-evidence-required")
     if browser:
         check("browser-schema", browser.get("schemaVersion") == "maggie-analytics-browser.v1", "versioned browser evidence", checks)
         check("browser-render", browser.get("passed") is True and isinstance(browser.get("routes"), list) and bool(browser["routes"]), "routes rendered without a browser failure", checks)
@@ -144,7 +179,7 @@ def release_gate(args: argparse.Namespace) -> int:
 
 def main() -> int:
     parser = argparse.ArgumentParser()
-    parser.add_argument("command", nargs="?", choices=("release-gate", "traffic-audit"))
+    parser.add_argument("command", nargs="?", choices=("release-gate", "traffic-audit", "gsc-readiness"))
     parser.add_argument("--project", default=".")
     parser.add_argument("--environment", choices=("development", "staging", "production"), default="staging")
     parser.add_argument("--env-file", help="optional env file; values are never printed")
@@ -154,8 +189,15 @@ def main() -> int:
     parser.add_argument("--network-report", help="redacted network evidence for release-gate")
     parser.add_argument("--provider-report", help="read-only provider evidence for release-gate")
     parser.add_argument("--smoke-report", help="production smoke evidence for release-gate")
+    parser.add_argument("--gsc-evidence", help="versioned GSC readiness evidence for release-gate")
+    parser.add_argument("--require-gsc", action="store_true", help="require GSC readiness evidence in release-gate")
     parser.add_argument("--events", help="redacted JSON array of analytics events for traffic-audit")
     args = parser.parse_args()
+    if args.command == "gsc-readiness":
+        if not args.gsc_evidence:
+            parser.error("gsc-readiness requires --gsc-evidence")
+        args.evidence = args.gsc_evidence
+        return gsc_readiness(args)
     if args.command == "release-gate":
         required = ("contract", "render_report", "network_report", "provider_report", "smoke_report")
         if any(not getattr(args, name) for name in required):

package/bundled-tools/clis/maggie_browser_audit.py

@@ -13,6 +13,98 @@ from browser_behavior import validate_samples
 from localization_runner import checkpoint
 
 
+INTERACTION_ACTIONS = {
+    "click", "fill", "type", "select", "press", "wait",
+    "assert-visible", "assert-enabled", "assert-disabled", "assert-checked",
+    "assert-editable", "assert-text", "assert-style", "assert-no-request",
+}
+
+
+def load_interactions(path: Path | None) -> list[dict]:
+    if not path:
+        return []
+    value = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(value, dict) or value.get("schemaVersion") != "maggie-browser-interactions.v1":
+        raise ValueError("interaction manifest schemaVersion must be maggie-browser-interactions.v1")
+    steps = value.get("steps")
+    if not isinstance(steps, list) or not steps:
+        raise ValueError("interaction manifest steps must be a non-empty array")
+    for step in steps:
+        if not isinstance(step, dict) or step.get("action") not in INTERACTION_ACTIONS:
+            raise ValueError("each interaction step must use a supported action")
+        if step.get("action") not in {"wait", "press", "assert-no-request"} and not str(step.get("selector") or "").strip():
+            raise ValueError("interaction step selector is required")
+    return steps
+
+
+def js_value(call, expression: str):
+    raw = call("js", expression).strip()
+    try:
+        return json.loads(raw)
+    except json.JSONDecodeError:
+        return raw.strip('"')
+
+
+def resource_urls(call) -> set[str]:
+    value = js_value(call, "JSON.stringify(performance.getEntriesByType('resource').map(entry => entry.name))")
+    return set(value if isinstance(value, list) else [])
+
+
+def run_interactions(call, steps: list[dict]) -> list[dict]:
+    baseline = resource_urls(call)
+    evidence = []
+    for step in steps:
+        action = step["action"]
+        selector = str(step.get("selector") or "")
+        record = {"id": str(step.get("id") or f"step-{len(evidence) + 1}"), "action": action, "selector": selector, "status": "passed"}
+        try:
+            if action == "click":
+                call("click", selector)
+            elif action == "fill":
+                call("fill", selector, str(step.get("value") or ""))
+            elif action == "type":
+                call("click", selector)
+                call("type", str(step.get("text") or ""))
+            elif action == "select":
+                call("select", selector, str(step.get("value") or ""))
+            elif action == "press":
+                call("press", str(step.get("key") or "Enter"))
+            elif action == "wait":
+                call("wait", str(step.get("target") or "--load"))
+            elif action.startswith("assert-") and action in {"assert-visible", "assert-enabled", "assert-disabled", "assert-checked", "assert-editable"}:
+                call("is", action.removeprefix("assert-"), selector)
+            elif action == "assert-text":
+                expected = str(step.get("text") or "")
+                expression = f"(() => {{ const node = document.querySelector({json.dumps(selector)}); return Boolean(node && node.textContent.includes({json.dumps(expected)})); }})()"
+                if js_value(call, expression) is not True:
+                    raise ValueError("text assertion failed")
+            elif action == "assert-style":
+                prop = str(step.get("property") or "")
+                expected = str(step.get("value") or "")
+                if not prop:
+                    raise ValueError("style assertion property is required")
+                expression = f"(() => {{ const node = document.querySelector({json.dumps(selector)}); return node ? getComputedStyle(node)[{json.dumps(prop)}] : null; }})()"
+                actual = js_value(call, expression)
+                if actual != expected:
+                    raise ValueError("style assertion failed")
+            elif action == "assert-no-request":
+                forbidden = str(step.get("origin") or step.get("url") or "")
+                if not forbidden:
+                    raise ValueError("request assertion origin is required")
+                new_urls = sorted(url for url in resource_urls(call) - baseline if forbidden in url)
+                if new_urls:
+                    raise ValueError("third-party request assertion failed")
+            else:
+                raise ValueError("unsupported interaction action")
+        except (OSError, ValueError, subprocess.TimeoutExpired) as error:
+            record["status"] = "failed"
+            record["error"] = str(error)
+            evidence.append(record)
+            break
+        evidence.append(record)
+    return evidence
+
+
 def audit(args):
     if urlparse(args.url).scheme not in {"http", "https", "file"}:
         raise ValueError("URL must use http, https or file")
@@ -20,13 +112,15 @@ def audit(args):
         raise ValueError("at least one --required selector is necessary")
     output = args.output.resolve()
     output.mkdir(parents=True, exist_ok=True)
+    interactions = load_interactions(args.interactions)
     def call(*command):
         result = subprocess.run([str(args.browse), *command], capture_output=True, text=True, timeout=45)
         if result.returncode:
             raise ValueError("browser command failed: " + command[0])
         return result.stdout
     report = {"schemaVersion": "maggie-browser-audit.v1", "url": args.url,
-              "passed": False, "viewports": [], "evidence": "browser-captured"}
+              "passed": False, "viewports": [], "evidence": "browser-captured",
+              "interactionManifest": str(args.interactions.resolve()) if args.interactions else None}
     try:
         for index, viewport in enumerate(args.viewport or ["390x844", "768x1024", "1440x900"]):
             width, height = [int(value) for value in viewport.split("x")]
@@ -36,6 +130,7 @@ def audit(args):
             call("goto", args.url)
             selectors = list(dict.fromkeys(args.required + args.sticky))
             call("js", "window.__maggieAuditSelectors=" + json.dumps(selectors))
+            interaction_evidence = run_interactions(call, interactions) if interactions else []
             samples = []
             for step, fraction in enumerate([0, 0.5, 0.9]):
                 call("js", f"window.scrollTo(0, (document.documentElement.scrollHeight-innerHeight)*{fraction})")
@@ -50,8 +145,8 @@ def audit(args):
                 raise ValueError("browser did not create screenshot")
             finding = validate_samples(samples, args.required, args.sticky)
             report["viewports"].append({"viewport": viewport, "samples": samples,
-                "screenshot": str(screenshot), **finding})
-        report["passed"] = all(item["passed"] for item in report["viewports"])
+                "screenshot": str(screenshot), "interactionEvidence": interaction_evidence, **finding})
+        report["passed"] = all(item["passed"] and all(step["status"] == "passed" for step in item.get("interactionEvidence", [])) for item in report["viewports"])
     finally:
         checkpoint(output / "report.json", report)
     print(json.dumps(report, indent=2))
@@ -66,6 +161,7 @@ def main():
     parser.add_argument("--viewport", action="append")
     parser.add_argument("--required", action="append", default=[])
     parser.add_argument("--sticky", action="append", default=[])
+    parser.add_argument("--interactions", type=Path, help="declarative interaction/assertion manifest")
     args = parser.parse_args()
     try:
         return audit(args)

package/bundled-tools/clis/maggie_clone.py

@@ -316,6 +316,48 @@ def command_verify(args):
     return 0
 
 
+def command_interactions(args):
+    """Replay the shared browser-audit manifest for every clone target/viewport."""
+    root, manifest = read_manifest(args.project.resolve(), args.run_id)
+    interaction_path = args.interactions.resolve()
+    try:
+        interaction_manifest = json.loads(interaction_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as error:
+        raise ValueError(f"cannot read interaction manifest: {error}") from error
+    if interaction_manifest.get("schemaVersion") != "maggie-browser-interactions.v1" or not isinstance(interaction_manifest.get("steps"), list) or not interaction_manifest["steps"]:
+        raise ValueError("interaction manifest must be a non-empty maggie-browser-interactions.v1 document")
+    evidence_root = root / "interactions"
+    evidence_root.mkdir(parents=True, exist_ok=True)
+    reports = []
+    states = []
+    audit_cli = Path(__file__).with_name("maggie_browser_audit.py")
+    for target in manifest["targets"]:
+        output = evidence_root / target["page_key"]
+        selectors = {str(step.get("selector")) for step in interaction_manifest["steps"] if step.get("selector")}
+        command = [sys.executable, str(audit_cli), target.get("capture_url", target["source_url"]), "--browse", str(args.browse), "--output", str(output), "--interactions", str(interaction_path), "--required", "body"]
+        for selector in sorted(selectors):
+            command.extend(["--required", selector])
+        for viewport in VIEWPORTS:
+            command.extend(["--viewport", f"{VIEWPORTS[viewport][0]}x{VIEWPORTS[viewport][1]}"])
+        completed = subprocess.run(command, capture_output=True, text=True, check=False)
+        report_path = output / "report.json"
+        reports.append({"pageKey": target["page_key"], "status": "passed" if completed.returncode == 0 else "failed", "report": str(report_path), "stderr": "browser audit failed" if completed.returncode else None})
+        try:
+            audit_report = json.loads(report_path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            audit_report = {}
+        for viewport, viewport_report in zip(("desktop", "tablet", "mobile"), audit_report.get("viewports") or []):
+            for step in interaction_manifest["steps"]:
+                step_evidence = next((item for item in viewport_report.get("interactionEvidence", []) if item.get("id") == step.get("id")), {})
+                states.append({"viewport": viewport, "stepId": step["id"], "status": step_evidence.get("status", "failed"), "screenshot": viewport_report.get("screenshot"), "error": step_evidence.get("error")})
+    evidence = {"schemaVersion": "maggie-clone-interaction-state.v1", "sourceRunId": manifest["run_id"], "interactionManifest": str(interaction_path), "viewports": list(VIEWPORTS), "states": states, "redacted": True, "reports": reports, "passed": bool(reports) and bool(states) and all(item["status"] == "passed" for item in reports) and all(item["status"] == "passed" for item in states)}
+    save_json(evidence_root / "evidence.json", evidence)
+    manifest["interactionEvidence"] = str(evidence_root / "evidence.json")
+    save_json(root / "manifest.json", manifest)
+    print(json.dumps(evidence, indent=2, ensure_ascii=False))
+    return 0 if evidence["passed"] else 1
+
+
 def command_status(args):
     root = run_root(args.project.resolve(), args.run_id)
     manifest_path = root / "manifest.json"
@@ -373,13 +415,16 @@ def main():
     status_parser.add_argument("--project", type=Path, default=Path.cwd())
     status_parser.add_argument("--run-id", required=True)
     status_parser.set_defaults(func=command_status)
-    commands = {"init": command_init, "capture": command_capture, "extract": command_extract, "assets": command_assets, "compare": command_compare, "verify": command_verify}
+    commands = {"init": command_init, "capture": command_capture, "extract": command_extract, "assets": command_assets, "compare": command_compare, "verify": command_verify, "interactions": command_interactions}
     for name, func in commands.items():
         cmd = sub.add_parser(name); cmd.add_argument("--project", type=Path, default=Path.cwd()); cmd.add_argument("--run-id", required=True); cmd.add_argument("--force", action="store_true")
         if name == "init": cmd.add_argument("urls", nargs="+")
         if name == "assets": cmd.add_argument("--max-bytes", type=int, default=20_000_000)
         if name == "compare": cmd.add_argument("--local-url", required=True)
         if name == "verify": cmd.add_argument("--allow-uncompared", action="store_true")
+        if name == "interactions":
+            cmd.add_argument("--browse", type=Path, required=True)
+            cmd.add_argument("--interactions", type=Path, required=True, help="shared maggie-browser-interactions.v1 manifest")
         cmd.set_defaults(func=func)
     args = parser.parse_args()
     try: return int(args.func(args) or 0)

package/bundled-tools/clis/maggie_contracts.py

@@ -237,6 +237,105 @@ def validate_capabilities(args: argparse.Namespace) -> int:
     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 validate_style_editing(args: argparse.Namespace) -> int:
+    """Validate a closed, host-rendered style editing contract."""
+    manifest = read_json(Path(args.manifest))
+    errors: list[str] = []
+    if manifest.get("schemaVersion") != "maggie-style-editing.v1":
+        errors.append("manifest schemaVersion must be maggie-style-editing.v1")
+    properties = manifest.get("properties")
+    if not isinstance(properties, list) or not properties:
+        errors.append("properties must be a non-empty array")
+        properties = []
+    allowed: set[str] = set()
+    patterns: dict[str, str] = {}
+    dangerous = re.compile(r"(?:;|url\s*\(|expression\s*\(|<|>|javascript:)", re.I)
+    for item in properties:
+        if not isinstance(item, dict):
+            errors.append("each style property must be an object")
+            continue
+        name = str(item.get("name") or "")
+        pattern = str(item.get("pattern") or "")
+        if not re.fullmatch(r"[A-Za-z][A-Za-z0-9-]*", name):
+            errors.append(f"invalid style property name: {name or 'unknown'}")
+        if name in allowed:
+            errors.append(f"duplicate style property: {name}")
+        allowed.add(name)
+        if not pattern:
+            errors.append(f"style property {name or 'unknown'} needs a value pattern")
+        else:
+            try:
+                re.compile(pattern)
+                patterns[name] = pattern
+            except re.error:
+                errors.append(f"style property {name or 'unknown'} has an invalid value pattern")
+    for template in manifest.get("templates") or []:
+        if not isinstance(template, dict) or not str(template.get("id") or ""):
+            errors.append("each style template needs an id")
+            continue
+        for name, value in (template.get("styles") or {}).items():
+            if name not in allowed:
+                errors.append(f"style template {template['id']} uses undeclared property: {name}")
+                continue
+            if not isinstance(value, str) or dangerous.search(value) or not re.fullmatch(patterns[name], value):
+                errors.append(f"style template {template['id']} has an unsafe value for {name}")
+    return emit_and_exit(result("maggie-style-editing.v1", errors, properties=sorted(allowed), templates=len(manifest.get("templates") or [])), Path(args.output) if args.output else None)
+
+
+def validate_content_overrides(args: argparse.Namespace) -> int:
+    manifest = read_json(Path(args.manifest))
+    errors: list[str] = []
+    if manifest.get("schemaVersion") != "maggie-content-overrides.v1":
+        errors.append("manifest schemaVersion must be maggie-content-overrides.v1")
+    expected = {
+        "readAtRequestTime": True,
+        "sourceLiteralIsFallback": True,
+        "writesCreateRevision": True,
+        "conflictRequiresSourceRevision": True,
+        "orphanPolicy": "report-and-never-publish",
+    }
+    for key, value in expected.items():
+        if manifest.get(key) != value:
+            errors.append(f"{key} must be {value!r}")
+    if not isinstance(manifest.get("protectedFields"), list) or not manifest.get("protectedFields"):
+        errors.append("protectedFields must list factual fields that cannot be overridden")
+    return emit_and_exit(result("maggie-content-overrides.v1", errors, protectedFields=manifest.get("protectedFields", [])), Path(args.output) if args.output else None)
+
+
+def validate_session_contract(args: argparse.Namespace) -> int:
+    manifest = read_json(Path(args.manifest))
+    errors: list[str] = []
+    if manifest.get("schemaVersion") != "maggie-browser-session.v1":
+        errors.append("manifest schemaVersion must be maggie-browser-session.v1")
+    if manifest.get("mintingBoundary") != "host-adapter":
+        errors.append("mintingBoundary must be host-adapter")
+    if manifest.get("passwordHandling") != "never-exposed":
+        errors.append("passwordHandling must be never-exposed")
+    ttl = manifest.get("ttlMinutes")
+    if not isinstance(ttl, int) or not 1 <= ttl <= 240:
+        errors.append("ttlMinutes must be between 1 and 240")
+    for key in ("mintRoute", "revokeRoute"):
+        if not str(manifest.get(key) or "").startswith("/"):
+            errors.append(f"{key} must be a relative host route")
+    return emit_and_exit(result("maggie-browser-session.v1", errors, ttlMinutes=ttl), Path(args.output) if args.output else None)
+
+
+def validate_cache_boundary(args: argparse.Namespace) -> int:
+    evidence = read_json(Path(args.evidence))
+    errors: list[str] = []
+    if evidence.get("schemaVersion") != "maggie-public-session-cache.v1":
+        errors.append("evidence schemaVersion must be maggie-public-session-cache.v1")
+    if evidence.get("publicHtmlVariesBySession") is not False:
+        errors.append("publicHtmlVariesBySession must be false")
+    if evidence.get("sessionCookieHttpOnly") is not True:
+        errors.append("sessionCookieHttpOnly must be true")
+    if evidence.get("identityHintCookieReadable") is not True:
+        errors.append("identityHintCookieReadable must be true")
+    if evidence.get("identityRequestWhenHintAbsent") is not False:
+        errors.append("identityRequestWhenHintAbsent must be false")
+    return emit_and_exit(result("maggie-public-session-cache.v1", errors), 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)
@@ -270,6 +369,18 @@ def main() -> int:
     capabilities = sub.add_parser("capabilities-validate")
     capabilities.add_argument("--manifest", required=True); capabilities.add_argument("--output")
     capabilities.set_defaults(func=validate_capabilities)
+    style = sub.add_parser("style-check")
+    style.add_argument("--manifest", required=True); style.add_argument("--output")
+    style.set_defaults(func=validate_style_editing)
+    overrides = sub.add_parser("content-overrides-check")
+    overrides.add_argument("--manifest", required=True); overrides.add_argument("--output")
+    overrides.set_defaults(func=validate_content_overrides)
+    session = sub.add_parser("session-check")
+    session.add_argument("--manifest", required=True); session.add_argument("--output")
+    session.set_defaults(func=validate_session_contract)
+    cache = sub.add_parser("cache-boundary-check")
+    cache.add_argument("--evidence", required=True); cache.add_argument("--output")
+    cache.set_defaults(func=validate_cache_boundary)
     args = parser.parse_args()
     try:
         return args.func(args)