@topy-ai/maggie 0.6.9 → 0.7.1

package/bundled-tools/runtime/maggie_blog.py

@@ -8,6 +8,8 @@ import re
 import shutil
 from datetime import datetime, timezone
 from pathlib import Path
+from localization_runner import checkpoint, generate
+from content_localization import valid_locale
 
 STATUSES = ("draft", "review", "approved", "published", "archived")
 DEFAULTS = {
@@ -20,6 +22,8 @@ DEFAULTS = {
     "pullIntervalMinutes": 120,
     "maxPerRun": 1,
     "fallbackImageMode": "gradient",
+    "autoTranslateEnabled": False,
+    "translationLocales": [],
 }
 
 
@@ -65,7 +69,62 @@ class BlogStore:
         return json.loads(self.posts_path.read_text(encoding="utf-8"))
 
     def _write(self, path: Path, value: object) -> None:
-        path.write_text(json.dumps(value, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+        checkpoint(path, value)
+
+    def reconcile_translations(self) -> list[dict]:
+        """Recover missing scheduling intents from persisted source, without re-pull."""
+        settings = self.settings()
+        if not settings.get("autoTranslateEnabled"):
+            return []
+        locales = settings.get("translationLocales", [])
+        if not isinstance(locales, list) or not locales or any(not isinstance(locale, str) or not valid_locale(locale) for locale in locales):
+            raise ValueError("auto translation requires supported translationLocales")
+        tasks = []
+        for post in self.posts():
+            for locale in sorted(set(locales)):
+                contract = {"projectId": post["projectId"], "contentId": post["contentId"],
+                            "sourceRevision": checksum({key: post[key] for key in
+                                ("title", "excerpt", "body", "topics", "source")}
+                                | {"images": post.get("images", [])}),
+                            "targetLocale": locale, "operation": "translate"}
+                identity = checksum(contract).split(":")[1]
+                path = self.root / "translations" / (identity + ".json")
+                if not path.exists():
+                    self._write(path, {"id": identity, "contract": contract, "status": "pending",
+                                      "attempts": 0, "isIndexable": False})
+                tasks.append(json.loads(path.read_text(encoding="utf-8")))
+        return tasks
+
+    def translate_pending(self, adapter, character_budget: int = 8000) -> dict:
+        """Single-worker draft translation; every caller uses reconciliation first."""
+        tasks = self.reconcile_translations()
+        posts = {post["contentId"]: post for post in self.posts()}
+        for task in tasks:
+            if task["status"] == "succeeded":
+                continue
+            post = posts[task["contract"]["contentId"]]
+            strings = [{"id": key, "text": text} for key, text in (
+                ("title", post["title"]), ("excerpt", post["excerpt"]),
+                ("body", post["body"].get("value", ""))) if isinstance(text, str) and text.strip()]
+            strings.extend({"id": "topic:" + str(index), "text": topic["label"]}
+                           for index, topic in enumerate(post["topics"]))
+            strings.extend({"id": "alt:" + str(index), "text": image["alt"]}
+                           for index, image in enumerate(post.get("images", []))
+                           if isinstance(image.get("alt"), str) and image["alt"].strip())
+            path = self.root / "translations" / (task["id"] + ".json")
+            task.update(status="running", attempts=task["attempts"] + 1)
+            self._write(path, task)
+            try:
+                result = generate(strings, task["contract"],
+                    self.root / "translations" / "checkpoints" / (task["id"] + ".json"),
+                    adapter, character_budget)
+                task.update(status="succeeded", draft=result["translations"], isIndexable=False)
+                task.pop("errorCategory", None)
+            except Exception as error:
+                task.update(status="failed", errorCategory=type(error).__name__)
+            self._write(path, task)
+        return {"status": "partial" if any(task["status"] != "succeeded" for task in tasks) else "completed",
+                "tasks": [{key: task[key] for key in ("id", "status", "attempts")} for task in tasks]}
 
     def _backup(self) -> None:
         if self.posts_path.exists():
@@ -91,6 +150,8 @@ class BlogStore:
                 "slug": old["slug"] if old else slugify(raw_slug),
                 "title": title,
                 "excerpt": str(item.get("excerpt") or ""),
+                "images": [{"src": image.get("src", ""), "alt": image.get("alt", "")}
+                           for image in item.get("images", []) if isinstance(image, dict)],
                 "body": item.get("body") if isinstance(item.get("body"), dict) else {"format": str(item.get("format") or "markdown"), "value": str(item.get("body") or item.get("content") or "")},
                 "topics": [{"slug": slugify(str(topic)), "label": str(topic)} for topic in item.get("topics", item.get("keywords", []))],
                 # Provider input can suggest a status, but cannot bypass the
@@ -111,8 +172,12 @@ class BlogStore:
         slugs = [post["slug"] for post in result]
         if len(slugs) != len(set(slugs)): raise ValueError("slug collision detected; provide unique slugs")
         self._backup(); self._write(self.posts_path, result)
+        translation_tasks = self.reconcile_translations()
         runs = json.loads(self.runs_path.read_text(encoding="utf-8")) if self.runs_path.exists() else []
         run = {"id": "pull:" + hashlib.sha256((now() + provider).encode()).hexdigest()[:12], "provider": provider, "status": "completed", "delivered": len(payload), "changed": changed, "finishedAt": now()}
+        run["translationTasks"] = len(translation_tasks)
+        if any(task["status"] != "succeeded" for task in translation_tasks):
+            run["status"] = "partial"
         runs.append(run); self._write(self.runs_path, runs)
         return run
 

package/bundled-tools/runtime/maggie_dash_store.py

@@ -4,10 +4,12 @@
 from __future__ import annotations
 
 import hashlib
+import base64
+import hmac
 import json
 import sqlite3
 import uuid
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Any
 
@@ -55,6 +57,20 @@ class MaggieDashStore:
               created_at TEXT NOT NULL, updated_at TEXT NOT NULL,
               UNIQUE(project_id, slug)
             );
+            CREATE TABLE IF NOT EXISTS maggiedash_document_revisions (
+              id TEXT PRIMARY KEY, document_id TEXT NOT NULL REFERENCES maggiedash_documents(id),
+              revision INTEGER NOT NULL, title TEXT NOT NULL, slug TEXT NOT NULL,
+              locale TEXT NOT NULL, excerpt TEXT NOT NULL, content_json TEXT NOT NULL,
+              canonical_url TEXT, provenance_json TEXT NOT NULL, checksum TEXT NOT NULL,
+              created_at TEXT NOT NULL, created_by TEXT NOT NULL,
+              UNIQUE(document_id, revision)
+            );
+            CREATE TABLE IF NOT EXISTS maggiedash_redirects (
+              id TEXT PRIMARY KEY, project_id TEXT NOT NULL REFERENCES maggiedash_projects(id),
+              from_path TEXT NOT NULL, to_path TEXT NOT NULL, status_code INTEGER NOT NULL DEFAULT 301,
+              reason TEXT NOT NULL, actor_id TEXT NOT NULL, created_at TEXT NOT NULL,
+              UNIQUE(project_id, from_path)
+            );
             CREATE TABLE IF NOT EXISTS maggiedash_approvals (
               id TEXT PRIMARY KEY, document_id TEXT NOT NULL REFERENCES maggiedash_documents(id),
               from_status TEXT NOT NULL, to_status TEXT NOT NULL, actor_id TEXT NOT NULL,
@@ -68,6 +84,15 @@ class MaggieDashStore:
             );
             """
         )
+        self._ensure_column("maggiedash_documents", "trashed_at", "TEXT")
+        self._ensure_column("maggiedash_documents", "trashed_from_status", "TEXT")
+        self._ensure_column("maggiedash_documents", "publish_at", "TEXT")
+        self.connection.commit()
+
+    def _ensure_column(self, table: str, column: str, definition: str) -> None:
+        columns = {row[1] for row in self.connection.execute(f"PRAGMA table_info({table})")}
+        if column not in columns:
+            self.connection.execute(f"ALTER TABLE {table} ADD COLUMN {column} {definition}")
 
     def close(self) -> None:
         self.connection.close()
@@ -97,22 +122,27 @@ class MaggieDashStore:
             raise ValueError(f"invalid document status: {status}")
         stable = {key: value for key, value in document.items() if key not in {"provenance", "checksum"}}
         document_checksum = document.get("provenance", {}).get("checksum") or checksum(stable)
-        existing = self.connection.execute("SELECT status FROM maggiedash_documents WHERE id=?", (document["id"],)).fetchone()
+        existing = self.connection.execute("SELECT * FROM maggiedash_documents WHERE id=?", (document["id"],)).fetchone()
         if existing and existing["status"] != status:
             raise ValueError("status changes must use transition()")
+        if existing and existing["checksum"] != document_checksum:
+            self._store_revision(existing, actor_id)
         self.connection.execute(
             """INSERT INTO maggiedash_documents
-            (id,project_id,kind,title,slug,locale,status,excerpt,content_json,canonical_url,provenance_json,checksum,created_at,updated_at)
-            VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+            (id,project_id,kind,title,slug,locale,status,excerpt,content_json,canonical_url,provenance_json,checksum,created_at,updated_at,publish_at)
+            VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
             ON CONFLICT(id) DO UPDATE SET title=excluded.title, slug=excluded.slug,
               locale=excluded.locale, excerpt=excluded.excerpt, content_json=excluded.content_json,
               canonical_url=excluded.canonical_url, provenance_json=excluded.provenance_json,
-              checksum=excluded.checksum, updated_at=excluded.updated_at""",
+              checksum=excluded.checksum, updated_at=excluded.updated_at,
+              publish_at=excluded.publish_at, trashed_at=NULL, trashed_from_status=NULL""",
             (document["id"], project_id, document["kind"], document["title"], document["slug"], document["locale"],
              status, document.get("excerpt", ""), json.dumps(document["content"], ensure_ascii=False),
              document.get("canonicalUrl"), json.dumps(document["provenance"], ensure_ascii=False), document_checksum,
-             timestamp, timestamp),
+             timestamp, timestamp, document.get("publishAt")),
         )
+        if not existing:
+            self._store_revision(self.connection.execute("SELECT * FROM maggiedash_documents WHERE id=?", (document["id"],)).fetchone(), actor_id)
         self._audit(project_id, "document.upserted", "document", document["id"], actor_id, "draft content stored")
         self.connection.commit()
         return self.get_document(project_id, document["id"]) or {}
@@ -125,8 +155,122 @@ class MaggieDashStore:
         result["content"] = json.loads(result.pop("content_json"))
         result["provenance"] = json.loads(result.pop("provenance_json"))
         result["canonicalUrl"] = result.pop("canonical_url")
+        result["trashedAt"] = result.pop("trashed_at")
+        result["trashedFromStatus"] = result.pop("trashed_from_status")
+        result["publishAt"] = result.pop("publish_at")
         return result
 
+    def _store_revision(self, row: sqlite3.Row, actor_id: str) -> None:
+        revision = self.connection.execute(
+            "SELECT COALESCE(MAX(revision), 0) + 1 FROM maggiedash_document_revisions WHERE document_id=?",
+            (row["id"],),
+        ).fetchone()[0]
+        self.connection.execute(
+            "INSERT INTO maggiedash_document_revisions VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)",
+            (str(uuid.uuid4()), row["id"], revision, row["title"], row["slug"], row["locale"], row["excerpt"],
+             row["content_json"], row["canonical_url"], row["provenance_json"], row["checksum"], row["updated_at"], actor_id),
+        )
+
+    def list_revisions(self, project_id: str, document_id: str) -> list[dict[str, Any]]:
+        if not self.get_document(project_id, document_id):
+            raise ValueError("document not found")
+        rows = self.connection.execute(
+            "SELECT * FROM maggiedash_document_revisions WHERE document_id=? ORDER BY revision DESC", (document_id,)
+        ).fetchall()
+        return [dict(row) for row in rows]
+
+    def trash(self, project_id: str, document_id: str, actor_id: str, reason: str) -> dict[str, Any]:
+        row = self.connection.execute("SELECT status, trashed_at FROM maggiedash_documents WHERE project_id=? AND id=?", (project_id, document_id)).fetchone()
+        if not row:
+            raise ValueError("document not found")
+        if row["trashed_at"]:
+            return self.get_document(project_id, document_id) or {}
+        timestamp = now()
+        self.connection.execute("UPDATE maggiedash_documents SET trashed_at=?, trashed_from_status=?, updated_at=? WHERE id=?", (timestamp, row["status"], timestamp, document_id))
+        self._audit(project_id, "document.trashed", "document", document_id, actor_id, reason)
+        self.connection.commit()
+        return self.get_document(project_id, document_id) or {}
+
+    def restore(self, project_id: str, document_id: str, actor_id: str, reason: str) -> dict[str, Any]:
+        row = self.connection.execute("SELECT trashed_at, trashed_from_status FROM maggiedash_documents WHERE project_id=? AND id=?", (project_id, document_id)).fetchone()
+        if not row:
+            raise ValueError("document not found")
+        if not row["trashed_at"]:
+            return self.get_document(project_id, document_id) or {}
+        status = row["trashed_from_status"] if row["trashed_from_status"] in STATUSES else "draft"
+        timestamp = now()
+        self.connection.execute("UPDATE maggiedash_documents SET status=?, trashed_at=NULL, trashed_from_status=NULL, updated_at=? WHERE id=?", (status, timestamp, document_id))
+        self._audit(project_id, "document.restored", "document", document_id, actor_id, reason)
+        self.connection.commit()
+        return self.get_document(project_id, document_id) or {}
+
+    def schedule_publish(self, project_id: str, document_id: str, publish_at: str, actor_id: str, reason: str) -> dict[str, Any]:
+        try:
+            target = datetime.fromisoformat(publish_at.replace("Z", "+00:00"))
+        except ValueError as exc:
+            raise ValueError("publish_at must be an ISO-8601 timestamp") from exc
+        if target.tzinfo is None:
+            raise ValueError("publish_at must include a timezone")
+        document = self.get_document(project_id, document_id)
+        if not document:
+            raise ValueError("document not found")
+        if document["status"] not in {"approved", "scheduled"}:
+            raise ValueError("only approved documents can be scheduled")
+        if document["status"] == "approved":
+            self.transition(project_id, document_id, "scheduled", actor_id, reason)
+        self.connection.execute("UPDATE maggiedash_documents SET publish_at=?, updated_at=? WHERE id=?", (publish_at, now(), document_id))
+        self._audit(project_id, "document.publish_scheduled", "document", document_id, actor_id, reason)
+        self.connection.commit()
+        return self.get_document(project_id, document_id) or {}
+
+    def duplicate(self, project_id: str, document_id: str, new_id: str, new_slug: str, actor_id: str, reason: str) -> dict[str, Any]:
+        source = self.get_document(project_id, document_id)
+        if not source:
+            raise ValueError("document not found")
+        if self.connection.execute("SELECT 1 FROM maggiedash_documents WHERE project_id=? AND slug=?", (project_id, new_slug)).fetchone():
+            raise ValueError("new slug already exists")
+        copy = dict(source)
+        copy.update({"id": new_id, "slug": new_slug, "status": "draft", "provenance": {**source["provenance"], "duplicatedFrom": document_id}})
+        copy.pop("trashedAt", None); copy.pop("trashedFromStatus", None); copy.pop("publishAt", None)
+        result = self.put_document(project_id, copy, actor_id)
+        self._audit(project_id, "document.duplicated", "document", new_id, actor_id, reason)
+        self.connection.commit()
+        return result
+
+    def add_redirect(self, project_id: str, from_path: str, to_path: str, actor_id: str, reason: str, status_code: int = 301) -> dict[str, Any]:
+        if not from_path.startswith("/") or not to_path.startswith("/") or from_path == to_path:
+            raise ValueError("redirect paths must be distinct absolute paths")
+        if status_code not in {301, 302, 307, 308}:
+            raise ValueError("status_code must be 301, 302, 307 or 308")
+        record = (str(uuid.uuid4()), project_id, from_path, to_path, status_code, reason, actor_id, now())
+        self.connection.execute("INSERT INTO maggiedash_redirects VALUES (?,?,?,?,?,?,?,?) ON CONFLICT(project_id,from_path) DO UPDATE SET to_path=excluded.to_path, status_code=excluded.status_code, reason=excluded.reason, actor_id=excluded.actor_id, created_at=excluded.created_at", record)
+        self._audit(project_id, "redirect.upserted", "redirect", from_path, actor_id, reason)
+        self.connection.commit()
+        row = self.connection.execute("SELECT * FROM maggiedash_redirects WHERE project_id=? AND from_path=?", (project_id, from_path)).fetchone()
+        return dict(row)
+
+    def issue_preview(self, project_id: str, document_id: str, secret: str, ttl_seconds: int = 900) -> dict[str, Any]:
+        if not secret:
+            raise ValueError("preview secret is required")
+        if not self.get_document(project_id, document_id):
+            raise ValueError("document not found")
+        expires = int((datetime.now(timezone.utc) + timedelta(seconds=ttl_seconds)).timestamp())
+        payload = f"{project_id}:{document_id}:{expires}".encode()
+        encoded = base64.urlsafe_b64encode(payload).decode().rstrip("=")
+        signature = hmac.new(secret.encode(), encoded.encode(), hashlib.sha256).hexdigest()
+        return {"token": f"{encoded}.{signature}", "expiresAt": datetime.fromtimestamp(expires, timezone.utc).isoformat().replace("+00:00", "Z")}
+
+    @staticmethod
+    def verify_preview(token: str, secret: str, project_id: str, document_id: str) -> bool:
+        try:
+            encoded, signature = token.split(".", 1)
+            expected = hmac.new(secret.encode(), encoded.encode(), hashlib.sha256).hexdigest()
+            payload = base64.urlsafe_b64decode(encoded + "=" * (-len(encoded) % 4)).decode()
+            token_project, token_document, expires = payload.split(":", 2)
+            return hmac.compare_digest(signature, expected) and token_project == project_id and token_document == document_id and int(expires) >= int(datetime.now(timezone.utc).timestamp())
+        except (ValueError, TypeError, UnicodeDecodeError):
+            return False
+
     def transition(self, project_id: str, document_id: str, target: str, actor_id: str, reason: str) -> dict[str, Any]:
         if target not in STATUSES:
             raise ValueError(f"invalid target status: {target}")

package/bundled-tools/runtime/maggie_dash_ui.py

@@ -0,0 +1,60 @@
+"""Validate the provider-neutral MaggieDash dashboard chrome contract."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Iterable
+
+
+SCHEMA = "maggiedash-dashboard-ui.v1"
+
+
+def _component_source(name: str, source: str) -> str:
+    match = re.search(rf"(?:function\s+{re.escape(name)}\s*\([^)]*\)|const\s+{re.escape(name)}\s*=\s*\([^)]*\))(?P<body>[\s\S]{{0,12000}})", source)
+    return match.group(0) if match else ""
+
+
+def validate(contract: object, sources: Iterable[str] = ()) -> dict:
+    errors: list[str] = []
+    if not isinstance(contract, dict):
+        return {"schemaVersion": SCHEMA, "passed": False, "errors": ["contract must be an object"]}
+    if contract.get("schemaVersion") != SCHEMA:
+        errors.append(f"schemaVersion must be {SCHEMA}")
+    shell = contract.get("shell")
+    if not isinstance(shell, dict):
+        errors.append("shell is required")
+    elif shell.get("reference") != "users-workspace" or shell.get("navigation") != "sidebar-plus-content-tabs":
+        errors.append("shell must declare the users-workspace reference and sidebar-plus-content-tabs navigation")
+    components = contract.get("components")
+    if not isinstance(components, list) or not components:
+        errors.append("components must be a non-empty list")
+        components = []
+    source = "\n".join(str(item) for item in sources)
+    for component in components:
+        if not isinstance(component, dict) or not component.get("name"):
+            errors.append("each component needs a name")
+            continue
+        name = str(component["name"])
+        component_source = _component_source(name, source)
+        if source and not component_source:
+            errors.append(f"component source is missing: {name}")
+            continue
+        props = [str(prop) for prop in component.get("props", [])]
+        forbidden = [str(prop) for prop in component.get("forbiddenProps", [])]
+        if component_source:
+            signature = component_source.split("=>", 1)[0] if "=>" in component_source else component_source[:500]
+            for prop in props:
+                if len(re.findall(rf"\b{re.escape(prop)}\b", component_source)) < 2:
+                    errors.append(f"{name}.{prop} is declared but not evidenced in rendered output")
+            for prop in forbidden:
+                if re.search(rf"\b{re.escape(prop)}\b", signature):
+                    errors.append(f"{name} declares forbidden dead prop: {prop}")
+    return {"schemaVersion": SCHEMA, "passed": not errors, "errors": errors, "components": [item.get("name") for item in components if isinstance(item, dict)]}
+
+
+def load_and_validate(contract_path: Path, source_paths: Iterable[Path] = ()) -> dict:
+    import json
+    contract = json.loads(contract_path.read_text(encoding="utf-8"))
+    sources = [path.read_text(encoding="utf-8", errors="replace") for path in source_paths]
+    return validate(contract, sources)

package/bundled-tools/runtime/maggie_memory.py

@@ -171,12 +171,17 @@ def _active(item: dict[str, Any], project_id: str = "") -> bool:
     return not expires or expires > now()
 
 
-def relevant(project: str | Path, *, skill: str = "", query: str = "", project_id: str = "") -> dict[str, list[dict[str, Any]]]:
+def relevant(project: str | Path, *, skill: str = "", query: str = "", project_id: str = "", status: str | None = None) -> dict[str, list[dict[str, Any]]]:
     terms = set(re.findall(r"[a-z0-9_-]+", f"{skill} {query}".lower()))
     result: dict[str, list[dict[str, Any]]] = {kind: [] for kind in KINDS}
     for kind in KINDS:
         for item in read(project, kind)["items"]:
-            if kind != "errors" and not _active(item, project_id or root(project).name):
+            if status is not None:
+                if item.get("status") != status:
+                    continue
+                if item.get("scope") == "project" and item.get("projectId") not in {project_id or root(project).name, ""}:
+                    continue
+            elif kind != "errors" and not _active(item, project_id or root(project).name):
                 continue
             haystack = " ".join(str(item.get(key, "")) for key in ("type", "title", "rule", "problem", "solution", "prevention", "skill", "message", "fingerprint", "triggers")).lower()
             if not terms or terms & set(re.findall(r"[a-z0-9_-]+", haystack)):

package/bundled-tools/runtime/maggie_sitemap.py

@@ -55,6 +55,12 @@ def filter_routes(routes: list[dict[str, str]], origin: str, content_types: set[
             reason = "content type not enabled"
         elif not absolute_url(url, origin):
             reason = "URL must be an absolute HTTP(S) URL on the approved origin"
+        elif route.get("indexable") is False:
+            reason = "route is explicitly non-indexable"
+        elif route.get("canonicalUrl") and route.get("canonicalUrl") != url:
+            reason = "route canonical URL does not self-canonicalize"
+        elif route.get("searchable") is False:
+            reason = "route is explicitly not searchable"
         elif EXCLUDED_PATHS.search(parsed.path) or any(key in parse_qs(parsed.query) for key in ("q", "search", "filter", "page")):
             reason = "search, filter, or non-canonical route"
         elif route.get("type", "").lower() in {"rss", "atom", "feed"}:
@@ -86,12 +92,12 @@ def build_plan(routes: list[dict[str, str]], origin: str, content_types: set[str
     for content_type in sorted(content_types):
         chunks = []
         entries = groups.get(content_type, []) or []
-        for index in range(0, max(len(entries), 1), chunk_target):
+        for index in range(0, len(entries), chunk_target):
             chunk_entries = entries[index:index + chunk_target]
             filename = f"sitemap-{content_type}-{index // chunk_target + 1}.xml"
             xml = xml_file(chunk_entries)
             url = origin.rstrip("/") + "/" + filename
-            chunks.append({"filename": filename, "url": url, "entries": len(chunk_entries), "bytes": len(xml.encode()), "sha256": hashlib.sha256(xml.encode()).hexdigest(), "xml": xml})
+            chunks.append({"filename": filename, "url": url, "entries": len(chunk_entries), "routes": chunk_entries, "bytes": len(xml.encode()), "sha256": hashlib.sha256(xml.encode()).hexdigest(), "xml": xml})
             sitemap_urls.append(url)
         group_plans.append({"contentType": content_type, "chunks": chunks})
     index_xml = '<?xml version="1.0" encoding="UTF-8"?>\n<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">' + "".join(f"<sitemap><loc>{escape(url)}</loc></sitemap>" for url in sitemap_urls) + "</sitemapindex>\n"
@@ -103,7 +109,7 @@ def build_plan(routes: list[dict[str, str]], origin: str, content_types: set[str
     return plan
 
 
-def validate_plan_data(plan: dict) -> dict:
+def validate_plan_data(plan: dict, strict_semantic: bool = False) -> dict:
     errors = []
     warnings = []
     origin = plan.get("origin", "")
@@ -117,6 +123,21 @@ def validate_plan_data(plan: dict) -> dict:
                 errors.append(f"chunk exceeds URL limit: {chunk.get('filename')}")
             if chunk.get("bytes", 0) > HARD_BYTES_LIMIT:
                 errors.append(f"chunk exceeds byte limit: {chunk.get('filename')}")
+            for route in chunk.get("routes", []):
+                if route.get("indexable") is False or route.get("searchable") is False:
+                    errors.append(f"non-indexable/searchable route was emitted: {route.get('url')}")
+                if route.get("canonicalUrl") and route.get("canonicalUrl") != route.get("url"):
+                    errors.append(f"non-self-canonical route was emitted: {route.get('url')}")
+                if "contentWords" in route and int(route.get("contentWords") or 0) < 1:
+                    errors.append(f"route has no searchable content evidence: {route.get('url')}")
+                if "title" in route and not str(route.get("title") or "").strip():
+                    errors.append(f"route has no title evidence: {route.get('url')}")
+                if route.get("lastmod") and route.get("lastmodSource") in {"updated_at", "sync", "pull", "deploy"}:
+                    errors.append(f"lastmod is derived from an operational timestamp: {route.get('url')}")
+                if route.get("lastmod") and route.get("lastmodSource") not in {None, "content-change", "source-revision"}:
+                    errors.append(f"lastmod provenance is not a content change: {route.get('url')}")
+                if route.get("lastmod") and strict_semantic and route.get("lastmodSource") not in {"content-change", "source-revision"}:
+                    errors.append(f"lastmod evidence is required for strict semantic validation: {route.get('url')}")
             try:
                 root = ElementTree.fromstring(chunk.get("xml", ""))
                 locs = [element.text or "" for element in root.iter() if element.tag.endswith("loc")]
@@ -140,5 +161,30 @@ def validate_plan_data(plan: dict) -> dict:
     except ElementTree.ParseError:
         errors.append("sitemap index is not valid XML")
     if not expected_urls:
-        warnings.append("no sitemap chunks generated")
+        warnings.append("no sitemap chunks generated; empty content types are not advertised")
+    if strict_semantic:
+        for group in plan.get("groups", []):
+            for chunk in group.get("chunks", []):
+                for route in chunk.get("routes", []):
+                    if not str(route.get("title") or "").strip(): warnings.append(f"semantic title evidence missing: {route.get('url')}")
+                    if "contentWords" not in route: warnings.append(f"semantic content evidence missing: {route.get('url')}")
+        if warnings:
+            errors.extend(warnings)
     return {"status": "pass" if not errors else "fail", "errors": errors, "warnings": warnings}
+
+
+def agent_files(routes: list[dict[str, str]], origin: str, locale: str = "en") -> dict[str, str]:
+    """Generate compact, locale-aware agent discovery documents."""
+    visible = [route for route in routes if route.get("indexable") is not False and route.get("searchable") is not False and absolute_url(route.get("url", ""), origin)]
+    visible.sort(key=lambda route: route.get("url", ""))
+    lines = [f"# {origin} ({locale})", "", "This file lists indexable public routes for agent discovery.", "", "## Routes"]
+    for route in visible:
+        label = route.get("title") or route.get("url", "").rstrip("/").rsplit("/", 1)[-1] or "home"
+        lines.append(f"- [{label}]({route['url']})")
+    sitemap = [f"# Sitemap ({locale})", "", f"- XML sitemap: {origin.rstrip('/')}/sitemap.xml", "", "## Public routes"]
+    sitemap.extend(f"- {route['url']}" for route in visible)
+    insights = [f"# Content insights ({locale})", "", f"- Indexable routes: {len(visible)}", f"- Content types: {', '.join(sorted({str(route.get('type', 'unknown')) for route in visible})) or 'none'}", "", "## Freshness"]
+    for route in visible:
+        if route.get("lastmod"):
+            insights.append(f"- {route['url']}: last content change {route['lastmod']}")
+    return {"llms.txt": "\n".join(lines) + "\n", "sitemap.md": "\n".join(sitemap) + "\n", "insights.md": "\n".join(insights) + "\n"}

package/bundled-tools/runtime/route_imports.py

@@ -0,0 +1,51 @@
+"""Resolve route components from source imports, never from sibling basenames."""
+
+from __future__ import annotations
+
+import hashlib
+import re
+from pathlib import Path
+
+
+IMPORT_RE = re.compile(r"(?:import\s+(?:[^;\n]*?\s+from\s+)?|export\s+[^;\n]*?\s+from\s+)[\"']([^\"']+)[\"']")
+EXTENSIONS = ("", ".astro", ".tsx", ".jsx", ".ts", ".js", ".vue", ".svelte", ".html")
+
+
+def resolve_import(route: Path, specifier: str) -> Path | None:
+    if not specifier.startswith("."):
+        return None
+    base = (route.parent / specifier).resolve()
+    candidates = [base]
+    candidates.extend(Path(str(base) + extension) for extension in EXTENSIONS[1:])
+    candidates.extend(base / f"index{extension}" for extension in EXTENSIONS)
+    for candidate in candidates:
+        if candidate.is_file():
+            return candidate
+    return None
+
+
+def imported_components(route: Path) -> list[dict[str, str | None]]:
+    """Return only source imports that resolve inside the project.
+
+    Bare package imports are intentionally recorded without a local path; they
+    are dependencies, not route-local components. The route source remains
+    the authority, so a same-named sibling file is never selected implicitly.
+    """
+    try:
+        source = route.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return []
+    result = []
+    seen = set()
+    for specifier in IMPORT_RE.findall(source):
+        resolved = resolve_import(route, specifier)
+        key = (specifier, str(resolved) if resolved else None)
+        if key in seen:
+            continue
+        seen.add(key)
+        result.append({
+            "specifier": specifier,
+            "path": str(resolved) if resolved else None,
+            "fingerprint": hashlib.sha256(resolved.read_bytes()).hexdigest() if resolved else None,
+        })
+    return result

package/bundled-tools/runtime/seed_evidence.py

@@ -0,0 +1,25 @@
+"""Validation for explicit, sanitized development fixture evidence."""
+
+from __future__ import annotations
+
+import re
+
+
+SECRET = re.compile(r"(?:secret|token|password|api[_-]?key|database_url)", re.I)
+
+
+def validate_manifest(value: object) -> dict:
+    errors = []
+    if not isinstance(value, dict):
+        return {"schemaVersion": "maggie-seed-manifest.v1", "passed": False, "errors": ["manifest must be an object"]}
+    if value.get("schemaVersion") != "maggie-seed-manifest.v1": errors.append("unsupported schemaVersion")
+    if value.get("optIn") is not True: errors.append("optIn must be true")
+    if value.get("sanitized") is not True: errors.append("sanitized must be true")
+    fixtures = value.get("fixtures")
+    if not isinstance(fixtures, list) or not fixtures: errors.append("fixtures must be a non-empty list")
+    for item in fixtures if isinstance(fixtures, list) else []:
+        if not isinstance(item, dict) or not item.get("name") or not item.get("rows"):
+            errors.append("each fixture requires name and non-empty rows")
+        if SECRET.search(str(item)):
+            errors.append("fixture contains a secret-like field")
+    return {"schemaVersion": "maggie-seed-manifest.v1", "passed": not errors, "errors": errors, "fixtureCount": len(fixtures) if isinstance(fixtures, list) else 0}