@topy-ai/maggie 0.6.9 → 0.7.1

package/bundled-templates/maggiedash/dashboard-ui-contract.json

@@ -0,0 +1,31 @@
+{
+  "schemaVersion": "maggiedash-dashboard-ui.v1",
+  "shell": {
+    "reference": "users-workspace",
+    "navigation": "sidebar-plus-content-tabs",
+    "rules": [
+      "render one workspace bar per route",
+      "render one content tab bar per route",
+      "do not duplicate sidebar navigation in page content",
+      "do not hide duplicate navigation with CSS"
+    ]
+  },
+  "components": [
+    {
+      "name": "WorkspaceBar",
+      "props": ["workspaceName", "activeSection", "actions", "children"],
+      "forbiddenProps": []
+    },
+    {
+      "name": "WorkspaceCard",
+      "props": ["title", "children"],
+      "forbiddenProps": []
+    },
+    {
+      "name": "ContentTabs",
+      "props": ["tabs", "active", "actions", "children"],
+      "forbiddenProps": ["title", "description"]
+    }
+  ],
+  "accessibility": ["active tab exposes aria-selected", "actions have accessible names", "workspace navigation has a landmark"]
+}

package/bundled-tools/clis/maggie_analytics.py

@@ -10,6 +10,9 @@ import re
 import subprocess
 from pathlib import Path
 from urllib.parse import urlsplit
+import sys
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "runtime"))
+from analytics_traffic import audit_events  # noqa: E402
 
 
 GA4_ID = re.compile(r"^G-[A-Z0-9]+$", re.I)
@@ -107,7 +110,7 @@ def release_gate(args: argparse.Namespace) -> int:
 
 def main() -> int:
     parser = argparse.ArgumentParser()
-    parser.add_argument("command", nargs="?", choices=("release-gate",))
+    parser.add_argument("command", nargs="?", choices=("release-gate", "traffic-audit"))
     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")
@@ -117,12 +120,22 @@ 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("--events", help="redacted JSON array of analytics events for traffic-audit")
     args = parser.parse_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):
             parser.error("release-gate requires --contract, --render-report, --network-report, --provider-report, and --smoke-report")
         return release_gate(args)
+    if args.command == "traffic-audit":
+        if not args.events:
+            parser.error("traffic-audit requires --events")
+        value = json.loads(Path(args.events).read_text(encoding="utf-8"))
+        if not isinstance(value, list):
+            parser.error("--events must contain a JSON array")
+        result = audit_events(value)
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+        return 0
     project = Path(args.project).resolve()
     env = parse_env(Path(args.env_file).resolve()) if args.env_file else parse_env(project / ".env.example")
     env.update({key: value for key, value in os.environ.items() if key in {"PUBLIC_GA4_MEASUREMENT_ID", "PUBLIC_ANALYTICS_ENABLED", "PUBLIC_ANALYTICS_CONSENT_REQUIRED", "GSC_SITE_URL", "GSC_VERIFICATION_TOKEN"}})

package/bundled-tools/clis/maggie_blog.py

@@ -10,11 +10,19 @@ from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "runtime"))
 from maggie_blog import BlogStore  # noqa: E402
+from localization_runner import process_adapter
+from integration_state import integration_state  # noqa: E402
 
 
 def main() -> int:
     parser = argparse.ArgumentParser(prog="maggie blog")
     sub = parser.add_subparsers(dest="command", required=True)
+    translate = sub.add_parser("translate-pending")
+    translate.add_argument("--project", type=Path, default=Path.cwd())
+    translate.add_argument("--adapter-command", required=True, help="trusted provider JSON argv array")
+    translate.add_argument("--timeout", type=int, default=120)
+    translate.add_argument("--character-budget", type=int, default=8000)
+    translate.add_argument("--confirm", action="store_true")
     init = sub.add_parser("init"); init.add_argument("--project", type=Path, default=Path.cwd()); init.add_argument("--base-path", default="/our-blogs"); init.add_argument("--posts-per-page", type=int, default=9); init.add_argument("--confirm", action="store_true")
     inspect = sub.add_parser("inspect"); inspect.add_argument("--project", type=Path, default=Path.cwd())
     ingest = sub.add_parser("ingest"); ingest.add_argument("--project", type=Path, default=Path.cwd()); ingest.add_argument("--input", type=Path, required=True); ingest.add_argument("--source", default="local"); ingest.add_argument("--confirm", action="store_true")
@@ -22,13 +30,21 @@ def main() -> int:
     publish = sub.add_parser("publish"); publish.add_argument("--project", type=Path, default=Path.cwd()); publish.add_argument("--slug", required=True); publish.add_argument("--actor", required=True); publish.add_argument("--reason", required=True); publish.add_argument("--confirm", action="store_true")
     sitemap = sub.add_parser("sitemap"); sitemap.add_argument("--project", type=Path, default=Path.cwd())
     settings = sub.add_parser("settings"); settings.add_argument("--project", type=Path, default=Path.cwd())
+    state = sub.add_parser("integration-state"); state.add_argument("--configured", action="store_true"); state.add_argument("--consent-required", action="store_true"); state.add_argument("--consent", action="store_true"); state.add_argument("--authorized", action="store_true"); state.add_argument("--error")
     rollback = sub.add_parser("rollback"); rollback.add_argument("--project", type=Path, default=Path.cwd()); rollback.add_argument("--backup"); rollback.add_argument("--confirm", action="store_true")
     args = parser.parse_args()
+    if args.command == "integration-state":
+        result = integration_state(configured=args.configured, consent_required=args.consent_required, consent=args.consent, authorized=args.authorized, error=args.error)
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+        return 0 if result["status"] != "error" else 1
     store = BlogStore(args.project.resolve())
-    if args.command in {"init", "ingest", "publish", "rollback"} and not args.confirm:
+    if args.command in {"init", "ingest", "publish", "rollback", "translate-pending"} and not args.confirm:
         print("CONFIRMATION_REQUIRED: rerun with --confirm", file=sys.stderr); return 2
     try:
         if args.command == "init": result = store.init(args.base_path, args.posts_per_page)
+        elif args.command == "translate-pending":
+            adapter = process_adapter(json.loads(args.adapter_command), args.project, args.timeout)
+            result = store.translate_pending(adapter, args.character_budget)
         elif args.command == "inspect": result = {"settings": store.settings(), "posts": store.posts(), "runs": json.loads(store.runs_path.read_text(encoding="utf-8")) if store.runs_path.exists() else []}
         elif args.command == "ingest":
             payload = json.loads(args.input.read_text(encoding="utf-8"));
@@ -42,6 +58,8 @@ def main() -> int:
     except (OSError, ValueError, json.JSONDecodeError) as error:
         print(f"maggie-blog: {error}", file=sys.stderr); return 1
     print(json.dumps(result, indent=2, ensure_ascii=False))
+    if args.command in {"ingest", "translate-pending"} and result.get("status") == "partial":
+        return 1
     return 0 if args.command != "validate" or result.get("valid") else 1
 
 

package/bundled-tools/clis/maggie_browser_audit.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+"""Capture real viewport/scroll evidence using an installed gstack browse CLI."""
+import argparse
+import json
+import subprocess
+import sys
+from pathlib import Path
+from urllib.parse import urlparse
+
+RUNTIME = Path(__file__).resolve().parents[1] / "runtime"
+sys.path.insert(0, str(RUNTIME))
+from browser_behavior import validate_samples
+from localization_runner import checkpoint
+
+
+def audit(args):
+    if urlparse(args.url).scheme not in {"http", "https", "file"}:
+        raise ValueError("URL must use http, https or file")
+    if not args.required:
+        raise ValueError("at least one --required selector is necessary")
+    output = args.output.resolve()
+    output.mkdir(parents=True, exist_ok=True)
+    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"}
+    try:
+        for index, viewport in enumerate(args.viewport or ["390x844", "768x1024", "1440x900"]):
+            width, height = [int(value) for value in viewport.split("x")]
+            if min(width, height) < 100:
+                raise ValueError("viewport dimensions must be at least 100")
+            call("viewport", viewport)
+            call("goto", args.url)
+            selectors = list(dict.fromkeys(args.required + args.sticky))
+            call("js", "window.__maggieAuditSelectors=" + json.dumps(selectors))
+            samples = []
+            for step, fraction in enumerate([0, 0.5, 0.9]):
+                call("js", f"window.scrollTo(0, (document.documentElement.scrollHeight-innerHeight)*{fraction})")
+                # Two animation frames allow layout/scroll handlers to settle.
+                call("js", "new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(() => resolve(true))))")
+                sample = output / f"viewport-{index}-sample-{step}.json"
+                call("eval", str(RUNTIME / "browser_geometry.js"), "--out", str(sample), "--raw")
+                samples.append(json.loads(sample.read_text()))
+            screenshot = output / f"viewport-{index}.png"
+            call("screenshot", "--viewport", str(screenshot))
+            if not screenshot.is_file():
+                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"])
+    finally:
+        checkpoint(output / "report.json", report)
+    print(json.dumps(report, indent=2))
+    return 0 if report["passed"] else 1
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("url")
+    parser.add_argument("--browse", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True, help="new directory for evidence")
+    parser.add_argument("--viewport", action="append")
+    parser.add_argument("--required", action="append", default=[])
+    parser.add_argument("--sticky", action="append", default=[])
+    args = parser.parse_args()
+    try:
+        return audit(args)
+    except (ValueError, OSError, subprocess.TimeoutExpired) as error:
+        print(f"browser-audit: {error}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/bundled-tools/clis/maggie_dash.py

@@ -16,6 +16,8 @@ from pathlib import Path
 
 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
 
 
 def project_root(args: argparse.Namespace) -> Path:
@@ -92,6 +94,72 @@ def command_transition(args: argparse.Namespace) -> int:
         store.close()
 
 
+def command_cms(args: argparse.Namespace) -> int:
+    require_confirm(args)
+    store = store_for(project_root(args))
+    try:
+        if args.cms_command == "revisions":
+            result = store.list_revisions(args.project_id, args.document_id)
+        elif args.cms_command == "trash":
+            result = store.trash(args.project_id, args.document_id, args.actor, args.reason)
+        elif args.cms_command == "restore":
+            result = store.restore(args.project_id, args.document_id, args.actor, args.reason)
+        elif args.cms_command == "schedule":
+            result = store.schedule_publish(args.project_id, args.document_id, args.publish_at, args.actor, args.reason)
+        elif args.cms_command == "duplicate":
+            result = store.duplicate(args.project_id, args.document_id, args.new_id, args.new_slug, args.actor, args.reason)
+        elif args.cms_command == "redirect":
+            result = store.add_redirect(args.project_id, args.from_path, args.to_path, args.actor, args.reason, args.status_code)
+        elif args.cms_command == "preview":
+            result = store.issue_preview(args.project_id, args.document_id, args.secret, args.ttl)
+        else:
+            raise ValueError(f"unknown CMS command: {args.cms_command}")
+        emit(result)
+        return 0
+    finally:
+        store.close()
+
+
+def command_ui(args: argparse.Namespace) -> int:
+    result = load_and_validate(Path(args.contract).resolve(), [Path(value).resolve() for value in args.source])
+    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")
+
+
+def command_variant(args: argparse.Namespace) -> int:
+    require_confirm(args)
+    store = variant_store(args)
+    if args.variant_command == "create":
+        result = store.create(service_id=args.service_id, variant_id=args.variant_id,
+            variant_type=args.variant_type, locale=args.locale, market=args.market,
+            slug=args.slug, title=args.title, facts=json.loads(args.facts),
+            source_revision=args.source_revision, canonical_variant_id=args.canonical_variant_id,
+            cluster_links=args.cluster_link, layout_family=args.layout_family)
+    elif args.variant_command == "edit":
+        result = store.edit(args.variant_id, title=args.title, facts=json.loads(args.facts),
+            source_revision=args.source_revision, actor=args.actor, reason=args.reason)
+    elif args.variant_command == "translate":
+        result = store.translate(args.source_variant_id, variant_id=args.variant_id,
+            locale=args.locale, market=args.market, title=args.title, facts=json.loads(args.facts),
+            source_revision=args.source_revision, actor=args.actor)
+    elif args.variant_command in {"review", "preview", "publish", "archive"}:
+        target = {"review": "review", "preview": "preview", "publish": "published", "archive": "archived"}[args.variant_command]
+        result = store.transition(args.variant_id, target, args.actor, args.reason, preview_url=getattr(args, "preview_url", None))
+    elif args.variant_command == "validate":
+        render_report = json.loads(Path(args.render_report).read_text(encoding="utf-8")) if args.render_report else None
+        result = store.validate(args.variant_id, args.source_text, render_report)
+    elif args.variant_command == "slug-plan":
+        result = store.plan_slug_change(args.variant_id, args.new_slug, args.actor)
+    else:
+        result = [item for item in store.data["variants"] if not args.variant_id or item["id"] == args.variant_id]
+    emit(result)
+    return 0 if not isinstance(result, dict) or result.get("passed", True) else 1
+
+
 def parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(prog="maggie dash", description=__doc__)
     sub = parser.add_subparsers(dest="command", required=True)
@@ -120,6 +188,39 @@ def parser() -> argparse.ArgumentParser:
     transition.add_argument("--reason", required=True)
     transition.add_argument("--confirm", action="store_true")
     transition.set_defaults(func=command_transition)
+    cms = sub.add_parser("cms", help="manage revisions, trash, scheduling, redirects and previews")
+    cms_sub = cms.add_subparsers(dest="cms_command", required=True)
+    for name in ("revisions", "trash", "restore"):
+        command = cms_sub.add_parser(name)
+        command.add_argument("--project", default="."); command.add_argument("--project-id", default="local-project")
+        command.add_argument("--document-id", required=True); command.add_argument("--actor", default="cli"); command.add_argument("--reason", default="CMS operation"); command.add_argument("--confirm", action="store_true")
+    schedule = cms_sub.add_parser("schedule")
+    schedule.add_argument("--project", default="."); schedule.add_argument("--project-id", default="local-project"); schedule.add_argument("--document-id", required=True); schedule.add_argument("--publish-at", required=True); schedule.add_argument("--actor", default="cli"); schedule.add_argument("--reason", required=True); schedule.add_argument("--confirm", action="store_true")
+    duplicate = cms_sub.add_parser("duplicate")
+    duplicate.add_argument("--project", default="."); duplicate.add_argument("--project-id", default="local-project"); duplicate.add_argument("--document-id", required=True); duplicate.add_argument("--new-id", required=True); duplicate.add_argument("--new-slug", required=True); duplicate.add_argument("--actor", default="cli"); duplicate.add_argument("--reason", required=True); duplicate.add_argument("--confirm", action="store_true")
+    redirect = cms_sub.add_parser("redirect")
+    redirect.add_argument("--project", default="."); redirect.add_argument("--project-id", default="local-project"); redirect.add_argument("--from-path", required=True); redirect.add_argument("--to-path", required=True); redirect.add_argument("--status-code", type=int, default=301); redirect.add_argument("--actor", default="cli"); redirect.add_argument("--reason", required=True); redirect.add_argument("--confirm", action="store_true")
+    preview = cms_sub.add_parser("preview")
+    preview.add_argument("--project", default="."); preview.add_argument("--project-id", default="local-project"); preview.add_argument("--document-id", required=True); preview.add_argument("--secret", required=True); preview.add_argument("--ttl", type=int, default=900); preview.add_argument("--confirm", action="store_true")
+    cms.set_defaults(func=command_cms)
+    ui = sub.add_parser("ui", help="validate MaggieDash dashboard chrome")
+    ui_sub = ui.add_subparsers(dest="ui_command", required=True)
+    ui_validate = ui_sub.add_parser("validate")
+    ui_validate.add_argument("--contract", required=True)
+    ui_validate.add_argument("--source", action="append", default=[])
+    ui_validate.set_defaults(func=command_ui)
+    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")
+    edit = variant_sub.add_parser("edit"); edit.add_argument("--project", default="."); edit.add_argument("--variant-id", required=True); edit.add_argument("--title", required=True); edit.add_argument("--facts", required=True); edit.add_argument("--source-revision", required=True); edit.add_argument("--actor", required=True); edit.add_argument("--reason", required=True); edit.add_argument("--confirm", action="store_true")
+    translate = variant_sub.add_parser("translate"); translate.add_argument("--project", default="."); translate.add_argument("--source-variant-id", required=True); translate.add_argument("--variant-id", required=True); translate.add_argument("--locale", required=True); translate.add_argument("--market", required=True); translate.add_argument("--title", required=True); translate.add_argument("--facts", required=True); translate.add_argument("--source-revision", required=True); translate.add_argument("--actor", required=True); translate.add_argument("--confirm", action="store_true")
+    for name in ("review", "preview", "publish", "archive"):
+        command = variant_sub.add_parser(name); command.add_argument("--project", default="."); command.add_argument("--variant-id", required=True); command.add_argument("--actor", required=True); command.add_argument("--reason", required=True); command.add_argument("--confirm", action="store_true")
+        if name == "preview": command.add_argument("--preview-url", required=True)
+    validate = variant_sub.add_parser("validate"); validate.add_argument("--project", default="."); validate.add_argument("--variant-id", required=True); validate.add_argument("--source-text"); validate.add_argument("--render-report"); validate.add_argument("--confirm", action="store_true")
+    plan_slug = variant_sub.add_parser("slug-plan"); plan_slug.add_argument("--project", default="."); plan_slug.add_argument("--variant-id", required=True); plan_slug.add_argument("--new-slug", required=True); plan_slug.add_argument("--actor", required=True); plan_slug.add_argument("--confirm", action="store_true")
+    inspect = variant_sub.add_parser("inspect"); inspect.add_argument("--project", default="."); inspect.add_argument("--variant-id"); inspect.add_argument("--confirm", action="store_true")
+    variant.set_defaults(func=command_variant)
     return parser
 
 

package/bundled-tools/clis/maggie_deployment.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import argparse
 import json
 import re
+import subprocess
 from datetime import datetime, timezone
 from pathlib import Path
 
@@ -106,6 +107,7 @@ def vps_plan(domain: str, service: str, release_root: str, node_port: int) -> di
             "restart": f"systemctl restart {service}",
             "verify": f"systemctl is-active {service} && curl -fsS https://{domain}/robots.txt && curl -fsS https://{domain}/sitemap.xml",
             "rollback": f"ln -sfn {root}/releases/<previous-release> {current} && systemctl restart {service}",
+            "data_rollback": "restore the matching data checkpoint before restarting the previous code release",
         },
         "files": {
             "systemd": f"{service}.service",
@@ -130,10 +132,36 @@ def validate_data_checkpoint(path: Path) -> dict:
     if isinstance(required, list) and isinstance(current, dict):
         missing = [table for table in required if table not in current]
         if missing: errors.append("currentCounts is missing required tables")
+        empty = [table for table in required if table in current and (not isinstance(current[table], int) or current[table] <= 0)]
+        if empty: errors.append("currentCounts has empty required tables: " + ", ".join(empty))
     if not value.get("release") or not value.get("checkedAt"): errors.append("release and checkedAt are required")
+    rollback = value.get("rollback")
+    if not isinstance(rollback, dict) or not rollback.get("backupId") or not rollback.get("restoreCommand"):
+        errors.append("rollback.backupId and rollback.restoreCommand are required for data rollback")
     return {"passed": not errors, "declared": True, "errors": errors}
 
 
+def validate_scheduler_request(method: str, origin: str | None, has_auth: bool) -> dict:
+    errors = []
+    if method.upper() == "POST":
+        if not origin or not re.fullmatch(r"https?://[^/\s]+", origin): errors.append("POST scheduler requests require an explicit Origin header")
+        if not has_auth: errors.append("POST scheduler requests require the configured auth contract")
+    return {"schemaVersion": "maggie-deployment-request.v1", "method": method.upper(), "originPresent": bool(origin), "authPresent": bool(has_auth), "passed": not errors, "errors": errors}
+
+
+def verify_infrastructure(units_dir: Path | None, service: str, timer: str | None = None) -> dict:
+    timer_name = timer or f"maggie-{service}.timer"
+    service_name = f"maggie-{service}.service" if not service.endswith(".service") else service
+    declared = bool(units_dir and (units_dir / service_name).is_file() and (units_dir / timer_name).is_file())
+    systemd = {"service": False, "timer": False}
+    for unit, key in ((service_name, "service"), (timer_name, "timer")):
+        try:
+            systemd[key] = subprocess.run(["systemctl", "is-enabled", unit], capture_output=True, text=True, check=False, timeout=5).returncode == 0
+        except (OSError, subprocess.SubprocessError):
+            systemd[key] = False
+    return {"schemaVersion": "maggie-deployment-infra.v1", "service": service_name, "timer": timer_name, "declaredArtifacts": declared, "systemdEnabled": systemd, "passed": declared or all(systemd.values()), "errors": [] if declared or all(systemd.values()) else ["systemd service/timer are not declared or enabled"]}
+
+
 def retention_plan(release_root: str, current_link: str, keep: int) -> dict:
     if keep < 2 or keep > 5:
         raise ValueError("keep must be between 2 and 5")
@@ -206,6 +234,13 @@ def main() -> int:
     parser.add_argument("--retention-plan", action="store_true", help="create a read-only release prune candidate plan")
     parser.add_argument("--current-link", help="current symlink for --retention-plan")
     parser.add_argument("--keep-releases", type=int, default=2)
+    parser.add_argument("--verify-infra", action="store_true", help="verify declared or installed systemd service/timer")
+    parser.add_argument("--units-dir", help="directory containing generated .service and .timer units")
+    parser.add_argument("--timer", help="systemd timer unit name")
+    parser.add_argument("--validate-request", action="store_true", help="validate a scheduler request contract")
+    parser.add_argument("--method", default="POST")
+    parser.add_argument("--origin")
+    parser.add_argument("--has-auth", action="store_true")
     args = parser.parse_args()
     try:
         if args.vps_plan:
@@ -226,6 +261,14 @@ def main() -> int:
                 output.write_text(json.dumps(plan, indent=2) + "\n", encoding="utf-8")
             print(json.dumps(plan, indent=2, ensure_ascii=False))
             return 0
+        if args.validate_request:
+            result = validate_scheduler_request(args.method, args.origin, args.has_auth)
+            print(json.dumps(result, indent=2, ensure_ascii=False))
+            return 0 if result["passed"] else 1
+        if args.verify_infra:
+            result = verify_infrastructure(Path(args.units_dir).resolve() if args.units_dir else None, args.service, args.timer)
+            print(json.dumps(result, indent=2, ensure_ascii=False))
+            return 0 if result["passed"] else 1
         result = preflight(Path(args.project).resolve(), args.target, args.environment)
         if args.output:
             Path(args.output).parent.mkdir(parents=True, exist_ok=True)

package/bundled-tools/clis/maggie_feedback.py

@@ -34,6 +34,21 @@ def project_fingerprint(project: Path) -> str:
     return hashlib.sha256(str(project.resolve()).encode()).hexdigest()[:16]
 
 
+def installed_version(project: Path) -> str:
+    """Resolve the version from the runtime wrapper or project install state."""
+    if os.environ.get("MAGGIE_VERSION"):
+        return safe_text(os.environ["MAGGIE_VERSION"])
+    for path in (project / ".maggie" / "install.json", project / "VERSION"):
+        try:
+            value = json.loads(path.read_text(encoding="utf-8")) if path.suffix == ".json" else path.read_text(encoding="utf-8").strip()
+            if isinstance(value, dict): value = value.get("version", "")
+            if re.fullmatch(r"\d+\.\d+\.\d+(?:[-+][A-Za-z0-9.-]+)?", str(value)):
+                return str(value)
+        except (OSError, ValueError, json.JSONDecodeError):
+            continue
+    return "unknown"
+
+
 def feedback_id(project: Path) -> str:
     timestamp = datetime.now(timezone.utc).strftime("%Y%m%d%H%M%S")
     return f"fb-{timestamp}-{project_fingerprint(project)[:6]}-{secrets.token_hex(3)}"
@@ -68,7 +83,7 @@ def collect(args: argparse.Namespace) -> int:
         "feedbackId": feedback_id(project),
         "createdAt": now(),
         "source": "maggie-cli",
-        "maggieVersion": os.environ.get("MAGGIE_VERSION", "unknown"),
+        "maggieVersion": installed_version(project),
         "type": args.type,
         "skill": skill,
         "runId": run_id,

package/bundled-tools/clis/maggie_localization.py

@@ -13,6 +13,27 @@ from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "runtime"))
 from content_localization import LANGUAGES, MARKETS, OPERATIONS, parse_locale, protected_field_changes, stale, valid_locale, validate_translation
+from localization_runner import generate, process_adapter
+
+
+def generate_job(args: argparse.Namespace) -> int:
+    if not args.confirm:
+        raise ValueError("generate requires --confirm: the adapter receives source text and may incur provider costs")
+    command = json.loads(args.adapter_command)
+    adapter = process_adapter(command, args.project, args.timeout)
+    job = load(args.job)
+    errors = validate_job(args.job, args.source)["errors"]
+    if errors:
+        raise ValueError("; ".join(errors))
+    source = load(args.source)
+    contract = {key: job.get(key) for key in (
+        "jobId", "contentId", "sourceRevision", "sourceLanguage", "targetLanguage",
+        "targetLocale", "market", "operation", "generationContract")}
+
+    state = generate(source["strings"], contract, args.output, adapter, args.character_budget)
+    print(json.dumps({"status": state["status"], "strings": len(state["translations"]),
+                      "output": str(args.output), "publish": False}))
+    return 0
 
 
 def now() -> str:
@@ -318,6 +339,15 @@ def glossary(project: Path) -> int:
 def main() -> int:
     parser = argparse.ArgumentParser(description=__doc__)
     sub = parser.add_subparsers(dest="command", required=True)
+    generate_parser = sub.add_parser("generate", help="Generate resumable draft strings using a trusted provider process")
+    generate_parser.add_argument("job", type=Path)
+    generate_parser.add_argument("--project", type=Path, default=Path("."))
+    generate_parser.add_argument("--source", type=Path, required=True)
+    generate_parser.add_argument("--output", type=Path, required=True)
+    generate_parser.add_argument("--adapter-command", required=True, help="JSON argv array; executed without a shell")
+    generate_parser.add_argument("--character-budget", type=int, default=8000)
+    generate_parser.add_argument("--timeout", type=int, default=120)
+    generate_parser.add_argument("--confirm", action="store_true")
     plan_parser = sub.add_parser("plan")
     plan_parser.add_argument("--project", type=Path, default=Path("."))
     plan_parser.add_argument("--content", type=Path, required=True)
@@ -346,6 +376,7 @@ def main() -> int:
         command = sub.add_parser(name); command.add_argument("--project", type=Path, default=Path("."))
     args = parser.parse_args()
     try:
+        if args.command == "generate": return generate_job(args)
         if args.command == "plan": return plan_job(args)
         if args.command == "preview": return preview(args.job)
         if args.command == "validate":

package/bundled-tools/clis/maggie_memory.py

@@ -13,6 +13,9 @@ from runtime import maggie_memory as memory
 
 
 def output(value: object) -> None:
+    if isinstance(value, dict) and value.get("status") == "candidate" and value.get("id"):
+        value = dict(value)
+        value["notice"] = "Saved as candidate; excluded from search/context until reviewed and transitioned to active. Inspect with: maggie memory list --status candidate"
     print(json.dumps(value, indent=2, ensure_ascii=False))
 
 
@@ -82,7 +85,7 @@ def main() -> int:
             output(memory.transition(args.project, args.kind, args.item_id, args.status))
         elif args.command in {"context", "search", "list"}:
             query = args.query if args.command == "search" else getattr(args, "query", "")
-            result = memory.relevant(args.project, skill=getattr(args, "skill", ""), query=query)
+            result = memory.relevant(args.project, skill=getattr(args, "skill", ""), query=query, status=getattr(args, "status", None))
             if args.command == "list" and args.kind:
                 result = {args.kind: result[args.kind]}
             if args.command == "list" and args.status:

package/bundled-tools/clis/maggie_ops.py

@@ -9,6 +9,10 @@ import sys
 from datetime import datetime, timezone
 from pathlib import Path
 
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "runtime"))
+from dependency_lock import audit as audit_lockfiles
+from seed_evidence import validate_manifest
+
 
 REQUIRED_ROUTES = (
     "/ops", "/ops/posts", "/ops/sitemap", "/ops/reports",
@@ -132,14 +136,30 @@ def command_verify(args: argparse.Namespace) -> int:
     return 0 if result["checks"]["ready"] and result["stateFile"] else 1
 
 
+def command_lockfiles(args: argparse.Namespace) -> int:
+    result = audit_lockfiles(root(args))
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+    return 0 if result["passed"] else 1
+
+
+def command_seed_manifest(args: argparse.Namespace) -> int:
+    value = read_json(Path(args.manifest).resolve())
+    result = validate_manifest(value)
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+    return 0 if result["passed"] else 1
+
+
 def main() -> int:
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument("--project", default=".")
     sub = parser.add_subparsers(dest="command", required=True)
-    for name, handler in (("audit", command_audit), ("preflight", command_preflight), ("status", command_status), ("verify", command_verify)):
+    for name, handler in (("audit", command_audit), ("preflight", command_preflight), ("status", command_status), ("verify", command_verify), ("lockfiles", command_lockfiles)):
         command = sub.add_parser(name)
         if name == "preflight": command.add_argument("--write", action="store_true")
         command.set_defaults(func=handler)
+    seed = sub.add_parser("seed-manifest", help="validate explicit sanitized development fixtures")
+    seed.add_argument("--manifest", required=True)
+    seed.set_defaults(func=command_seed_manifest)
     record = sub.add_parser("record", help="record an explicitly authorised operation")
     record.add_argument("operation", choices=("sync", "sitemap-match", "rewrite-queue", "rewrite-approve", "publish", "migration"))
     record.add_argument("--dry-run", action="store_true")

package/bundled-tools/clis/maggie_service_booking.py

@@ -10,6 +10,9 @@ from pathlib import Path
 from urllib.parse import quote, urljoin, urlsplit
 from urllib.request import Request, urlopen
 
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "runtime"))
+from route_imports import imported_components  # noqa: E402
+
 NOW = lambda: datetime.now(timezone.utc).isoformat()
 MONEY = re.compile(r"(?:£|GBP\s*)\s*([0-9]+(?:[.,][0-9]{1,2})?)", re.I)
 DURATION = re.compile(r"(\d{2,3})\s*(?:min|mins|minutes?)", re.I)
@@ -751,7 +754,7 @@ def inventory_candidates(project, pages_root):
     found={}
     for page in pages_root.rglob("*") if pages_root.exists() else []:
         if page.is_file() and page.suffix.lower() in {".astro",".md",".mdx",".html"} and page.stem not in {"index","404"}:
-            found["/"+str(page.relative_to(project)).replace("\\","/")]={"path":"/"+str(page.relative_to(project)).replace("\\","/"),"text":page_text(page),"canonical":None,"pageType":"filesystem"}
+            found["/"+str(page.relative_to(project)).replace("\\","/")]={"path":"/"+str(page.relative_to(project)).replace("\\","/"),"text":page_text(page),"canonical":None,"pageType":"filesystem","imports":imported_components(page)}
     for name in ("pages.json","page-content.json"):
         source=project/"docs"/name
         if not source.exists(): continue
@@ -762,7 +765,7 @@ def inventory_candidates(project, pages_root):
             if not isinstance(item,dict): continue
             value=item.get("path") or item.get("url") or item.get("route")
             if not value: continue
-            current=found.setdefault(value,{"path":value,"text":"","canonical":None,"pageType":"inventory"}); current["text"]+=" "+str(item.get("content") or item.get("text") or item.get("title") or ""); current["canonical"]=item.get("canonicalUrl") or item.get("canonical") or current["canonical"]; current["pageType"]=item.get("pageType") or current["pageType"]
+            current=found.setdefault(value,{"path":value,"text":"","canonical":None,"pageType":"inventory","imports":[]}); current["text"]+=" "+str(item.get("content") or item.get("text") or item.get("title") or ""); current["canonical"]=item.get("canonicalUrl") or item.get("canonical") or current["canonical"]; current["pageType"]=item.get("pageType") or current["pageType"]
     return list(found.values())
 def cmd_match_pages_review(args):
     project=root(args); data=load(project); candidates=inventory_candidates(project,(project/args.pages_dir).resolve()); aliases={"lymphatic drainage":{"lymphatic","lymph drainage","lymphdrainage","manual lymphatic","ml d"},"deep tissue":{"deep tissue","therapeutic massage"},"thai":{"thai massage","thai"},"postpartum":{"postpartum","new mom"},"facial":{"facial","hydra facial","hydrafacial"},"massage":{"massage"}}
@@ -779,7 +782,7 @@ def cmd_match_pages_review(args):
         matches=[]
         for page in candidates:
             path_slug=slug(page["path"].rsplit("/",1)[-1].rsplit(".",1)[0]); page_words=page_tokens(path_slug+" "+page["text"][:2000]); exact=path_slug==service.get("slug"); overlap=len(expanded & page_words)/max(1,len(expanded)); generic=bool(concepts & {"massage","facial","acupuncture","waxing"}) and overlap<0.75; score=1.0 if exact else min(0.49 if generic else overlap,0.99)
-            if score>=0.45: matches.append({"path":page["path"],"role":"supporting","pageType":page["pageType"],"canonicalUrl":page["canonical"],"matchedConcepts":sorted(expanded & page_words),"method":"slug" if exact else "semantic-concepts","confidence":round(score,3)})
+            if score>=0.45: matches.append({"path":page["path"],"role":"supporting","pageType":page["pageType"],"canonicalUrl":page["canonical"],"matchedConcepts":sorted(expanded & page_words),"imports":page.get("imports",[]),"method":"slug" if exact else "semantic-concepts","confidence":round(score,3)})
         matches.sort(key=lambda x:(-x["confidence"],x["path"])); report.append({"serviceId":service["id"],"title":service["title"],"candidates":matches})
         for path_value in selections.get(service["id"], []):
             if path_value in {m["path"] for m in matches}: selected.append((service,path_value))