@topy-ai/maggie 0.7.3 → 0.7.5

package/bundled-tools/clis/maggie_dash.py

@@ -23,6 +23,7 @@ sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "runtime"))
 from maggie_dash_store import MaggieDashStore  # noqa: E402
 from service_variants import ServiceVariantStore  # noqa: E402
 from maggie_dash_ui import load_and_validate  # noqa: E402
+from maggie_sections import catalogue, section_id_migration, validate_registry, copy_notes  # noqa: E402
 
 
 def project_root(args: argparse.Namespace) -> Path:
@@ -77,8 +78,59 @@ def copy_dashboard_tree(source: Path, target: Path, force: bool) -> tuple[list[s
     return installed, preserved
 
 
+def manifest_file_pairs(source: Path, manifest: dict[str, object], target: Path) -> list[tuple[Path, Path, Path]]:
+    """Return source, install-target, and manifest-relative file paths."""
+    pairs: list[tuple[Path, Path, Path]] = []
+    for item in manifest.get("files", []):
+        relative = Path(str(item))
+        source_item = source / relative
+        if source_item.is_file():
+            relative_target = Path(*relative.parts[1:]) if relative.parts and relative.parts[0] == "admin" else relative
+            pairs.append((source_item, target / relative_target, relative))
+            continue
+        for path in sorted(source_item.rglob("*")):
+            if not path.is_file():
+                continue
+            child = path.relative_to(source_item)
+            relative_target = Path(*relative.parts[1:]) / child if relative.parts and relative.parts[0] == "admin" else relative / child
+            pairs.append((path, target / relative_target, relative / child))
+    return pairs
+
+
+def command_install_diff(source: Path, manifest: dict[str, object], target: Path, compare_dir: Path | None, force: bool) -> dict[str, object]:
+    pairs = manifest_file_pairs(source, manifest, target)
+    files: list[dict[str, str]] = []
+    source_relative = {relative for _, _, relative in pairs}
+    for source_file, destination, relative in pairs:
+        if compare_dir:
+            compare_relative = Path(*relative.parts[2:]) if relative.parts[:2] == ("admin", "src") else (Path(*relative.parts[1:]) if relative.parts and relative.parts[0] == "admin" else relative)
+            compare_file = compare_dir / compare_relative
+        else:
+            compare_file = destination
+        if not compare_file.exists():
+            action = "add"
+        elif compare_file.read_bytes() == source_file.read_bytes():
+            action = "unchanged"
+        else:
+            action = "update" if force else "preserve"
+        files.append({"path": str(relative), "action": action, "comparePath": str(compare_file)})
+    if compare_dir and compare_dir.exists():
+        for existing in sorted(compare_dir.rglob("*")):
+            if not existing.is_file():
+                continue
+            relative = existing.relative_to(compare_dir)
+            manifest_relative = Path("admin", "src", *relative.parts)
+            if manifest_relative not in source_relative:
+                files.append({"path": str(manifest_relative), "action": "unmanaged-existing", "comparePath": str(existing)})
+    summary: dict[str, int] = {}
+    for item in files:
+        summary[item["action"]] = summary.get(item["action"], 0) + 1
+    return {"status": "dry-run", "version": manifest.get("version"), "target": str(target), "compareDir": str(compare_dir) if compare_dir else None, "summary": summary, "files": files}
+
+
 def command_install(args: argparse.Namespace) -> int:
-    require_confirm(args)
+    if not args.dry_run and not args.diff:
+        require_confirm(args)
     root = project_root(args)
     source_value = args.source or os.environ.get("MAGGIE_DASH_SOURCE") or DEFAULT_DASH_SOURCE
     ref = args.ref
@@ -112,6 +164,15 @@ def command_install(args: argparse.Namespace) -> int:
             raise RuntimeError("unsupported MaggieDash distribution schema")
         if manifest.get("target") != "_maggie/admin" and args.target == "_maggie/admin":
             raise RuntimeError("MaggieDash manifest target is not ./_maggie/admin")
+        compare_dir = None
+        if args.existing_dir:
+            compare_dir = Path(args.existing_dir).expanduser()
+            if not compare_dir.is_absolute():
+                compare_dir = root / compare_dir
+            compare_dir = compare_dir.resolve()
+        if args.dry_run or args.diff:
+            emit(command_install_diff(source, manifest, target, compare_dir, args.force))
+            return 0
         installed: list[str] = []
         preserved: list[str] = []
         for item in manifest.get("files", []):
@@ -228,12 +289,21 @@ def command_cms(args: argparse.Namespace) -> int:
             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 == "publish-due":
+            result = store.publish_due(args.project_id, args.now, 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)
+        elif args.cms_command == "preset-save":
+            sections = json.loads(Path(args.sections_file).resolve().read_text(encoding="utf-8"))
+            result = store.save_section_preset(args.project_id, args.preset_id, args.name, sections, args.actor, args.description)
+        elif args.cms_command == "preset-list":
+            result = store.list_section_presets(args.project_id)
+        elif args.cms_command == "preset-insert":
+            result = store.insert_section_preset(args.project_id, args.preset_id, args.existing_id, args.actor, args.reason)
         else:
             raise ValueError(f"unknown CMS command: {args.cms_command}")
         emit(result)
@@ -248,6 +318,25 @@ def command_ui(args: argparse.Namespace) -> int:
     return 0 if result["passed"] else 1
 
 
+def command_sections(args: argparse.Namespace) -> int:
+    registry = json.loads(Path(args.registry).resolve().read_text(encoding="utf-8"))
+    checked = validate_registry(registry)
+    if not checked["passed"]:
+        emit(checked)
+        return 1
+    if args.sections_command == "prompt":
+        print(catalogue(registry))
+        return 0
+    if args.sections_command == "validate":
+        sections = json.loads(Path(args.sections_file).resolve().read_text(encoding="utf-8"))
+        result = {**checked, "copy": copy_notes(registry, sections)}
+        emit(result)
+        return 0 if result["copy"]["passed"] else 1
+    sections = json.loads(Path(args.sections_file).resolve().read_text(encoding="utf-8"))
+    emit(section_id_migration(args.page_id, sections))
+    return 0
+
+
 def variant_store(args: argparse.Namespace) -> ServiceVariantStore:
     return ServiceVariantStore(project_root(args) / ".maggie" / "service-variants.json")
 
@@ -299,6 +388,9 @@ def parser() -> argparse.ArgumentParser:
     install.add_argument("--ref", default="main", help="Git ref when installing from a remote source")
     install.add_argument("--target", default="_maggie/admin", help="installation target relative to the project")
     install.add_argument("--force", action="store_true", help="replace existing dashboard files")
+    install.add_argument("--dry-run", action="store_true", help="show the install plan without writing files")
+    install.add_argument("--diff", action="store_true", help="show the install plan and compare with an existing workspace")
+    install.add_argument("--existing-dir", help="existing dashboard source directory to compare during --diff")
     install.add_argument("--confirm", action="store_true")
     install.set_defaults(func=command_install)
     status = sub.add_parser("status", help="inspect project and documents")
@@ -326,12 +418,20 @@ def parser() -> argparse.ArgumentParser:
         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")
+    publish_due = cms_sub.add_parser("publish-due", help="publish approved scheduled content whose time has arrived")
+    publish_due.add_argument("--project", default="."); publish_due.add_argument("--project-id", default="local-project"); publish_due.add_argument("--now"); publish_due.add_argument("--actor", default="scheduler"); publish_due.add_argument("--reason", default="scheduled publish tick"); publish_due.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")
+    preset_save = cms_sub.add_parser("preset-save", help="save a reusable ordered section arrangement")
+    preset_save.add_argument("--project", default="."); preset_save.add_argument("--project-id", default="local-project"); preset_save.add_argument("--preset-id", required=True); preset_save.add_argument("--name", required=True); preset_save.add_argument("--sections-file", required=True); preset_save.add_argument("--description", default=""); preset_save.add_argument("--actor", default="cli"); preset_save.add_argument("--confirm", action="store_true")
+    preset_list = cms_sub.add_parser("preset-list", help="list reusable section arrangements")
+    preset_list.add_argument("--project", default="."); preset_list.add_argument("--project-id", default="local-project"); preset_list.add_argument("--confirm", action="store_true")
+    preset_insert = cms_sub.add_parser("preset-insert", help="expand an arrangement with fresh section IDs")
+    preset_insert.add_argument("--project", default="."); preset_insert.add_argument("--project-id", default="local-project"); preset_insert.add_argument("--preset-id", required=True); preset_insert.add_argument("--existing-id", action="append", default=[]); preset_insert.add_argument("--actor", default="cli"); preset_insert.add_argument("--reason", required=True); preset_insert.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)
@@ -339,6 +439,17 @@ def parser() -> argparse.ArgumentParser:
     ui_validate.add_argument("--contract", required=True)
     ui_validate.add_argument("--source", action="append", default=[])
     ui_validate.set_defaults(func=command_ui)
+    sections = sub.add_parser("sections", help="validate section registry and stable section identities")
+    sections_sub = sections.add_subparsers(dest="sections_command", required=True)
+    sections_validate = sections_sub.add_parser("validate")
+    sections_validate.add_argument("--registry", required=True); sections_validate.add_argument("--sections-file", required=True)
+    sections_validate.set_defaults(func=command_sections)
+    sections_prompt = sections_sub.add_parser("prompt")
+    sections_prompt.add_argument("--registry", required=True)
+    sections_prompt.set_defaults(func=command_sections)
+    sections_keys = sections_sub.add_parser("keys")
+    sections_keys.add_argument("--registry", required=True); sections_keys.add_argument("--sections-file", required=True); sections_keys.add_argument("--page-id", required=True)
+    sections_keys.set_defaults(func=command_sections)
     variant = sub.add_parser("variant", help="manage service variant lifecycle")
     variant_sub = variant.add_subparsers(dest="variant_command", required=True)
     create = variant_sub.add_parser("create"); create.add_argument("--project", default="."); create.add_argument("--service-id", required=True); create.add_argument("--variant-id", required=True); create.add_argument("--variant-type", required=True); create.add_argument("--locale", required=True); create.add_argument("--market", required=True); create.add_argument("--slug", required=True); create.add_argument("--title", required=True); create.add_argument("--facts", required=True); create.add_argument("--source-revision", required=True); create.add_argument("--canonical-variant-id"); create.add_argument("--cluster-link", action="append", default=[]); create.add_argument("--layout-family", default="service-default"); create.add_argument("--confirm", action="store_true")

package/bundled-tools/clis/maggie_deployment.py

@@ -219,6 +219,54 @@ WantedBy=multi-user.target
     (output_dir / f"{domain}.conf").write_text(nginx, encoding="utf-8")
 
 
+def release_runner(plan: dict) -> str:
+    """Render the ordered, reviewable VPS runner for one release."""
+    root = plan["release_root"]
+    service = plan["service"]
+    domain = plan["domain"]
+    current = plan["current_release"]
+    return f'''#!/usr/bin/env bash
+set -euo pipefail
+
+# Migration precedes the symlink flip; later releases carry agent state.
+: "${{RELEASE_ID:?set RELEASE_ID to an immutable release name}}"
+RELEASE_ROOT="{root}"
+CURRENT="{current}"
+RELEASE="$RELEASE_ROOT/releases/$RELEASE_ID"
+PREVIOUS="$(readlink -f "$CURRENT" 2>/dev/null || true)"
+mkdir -p "$RELEASE"
+cd "$RELEASE"
+
+npm ci
+npm run typecheck
+npm run migrate
+npm run build
+
+if [ -d "$CURRENT/.agents" ]; then cp -a "$CURRENT/.agents" "$RELEASE/.agents"; fi
+if [ -d "$CURRENT/.claude" ]; then cp -a "$CURRENT/.claude" "$RELEASE/.claude"; fi
+
+ln -sfn "$RELEASE" "$CURRENT"
+systemctl restart "{service}"
+systemctl is-active --quiet "{service}"
+curl -fsS "https://{domain}/robots.txt" >/dev/null
+curl -fsS "https://{domain}/sitemap.xml" >/dev/null
+
+# Keep current plus one rollback candidate, and prune only after health checks.
+mapfile -t RELEASES < <(find "$RELEASE_ROOT/releases" -mindepth 1 -maxdepth 1 -type d -printf '%T@ %p\\n' | sort -nr | cut -d' ' -f2-)
+for candidate in "${{RELEASES[@]:2}}"; do
+  [ "$candidate" = "$PREVIOUS" ] && continue
+  [ "$candidate" = "$RELEASE" ] && continue
+  rm -rf -- "$candidate"
+done
+'''
+
+
+def write_release_runner(path: Path, plan: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(release_runner(plan), encoding="utf-8")
+    path.chmod(0o750)
+
+
 def main() -> int:
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument("project", nargs="?", default=".")
@@ -231,6 +279,7 @@ def main() -> int:
     parser.add_argument("--release-root", default="/var/www/maggie-site", help="immutable release root")
     parser.add_argument("--node-port", type=int, default=4321)
     parser.add_argument("--plan-dir", help="directory for generated VPS artifacts")
+    parser.add_argument("--runner-output", help="write a reviewable ordered VPS release runner")
     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)
@@ -249,6 +298,8 @@ def main() -> int:
             plan = vps_plan(args.domain, args.service, args.release_root, args.node_port)
             if args.plan_dir:
                 write_vps_plan(Path(args.plan_dir).resolve(), plan)
+            if args.runner_output:
+                write_release_runner(Path(args.runner_output).resolve(), plan)
             print(json.dumps(plan, indent=2, ensure_ascii=False))
             return 0
         if args.retention_plan:

package/bundled-tools/clis/maggie_ops.py

@@ -12,6 +12,8 @@ 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
+from agent_runtime import preflight as agent_preflight
+from restart_gate import validate as validate_restart_gate
 
 
 REQUIRED_ROUTES = (
@@ -149,6 +151,20 @@ def command_seed_manifest(args: argparse.Namespace) -> int:
     return 0 if result["passed"] else 1
 
 
+def command_agent_preflight(args: argparse.Namespace) -> int:
+    result = agent_preflight(release_dir=args.release_dir)
+    if args.output:
+        write_json(Path(args.output).resolve(), result)
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+    return 0
+
+
+def command_restart_gate(args: argparse.Namespace) -> int:
+    result = validate_restart_gate(read_json(Path(args.manifest).resolve()))
+    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=".")
@@ -160,6 +176,13 @@ def main() -> int:
     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)
+    agent = sub.add_parser("agent-preflight", help="report agent runtime and deployment gotchas")
+    agent.add_argument("--output")
+    agent.add_argument("--release-dir")
+    agent.set_defaults(func=command_agent_preflight)
+    restart = sub.add_parser("restart-gate", help="validate restart-after-out-of-band-write evidence")
+    restart.add_argument("--manifest", required=True)
+    restart.set_defaults(func=command_restart_gate)
     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_verification.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python3
+"""Validate changed route surfaces and locales from explicit evidence."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+import sys
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "runtime"))
+from surface_coverage import compare  # noqa: E402
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    sub = parser.add_subparsers(dest="command", required=True)
+    coverage = sub.add_parser("coverage")
+    coverage.add_argument("--contract", type=Path, required=True)
+    coverage.add_argument("--evidence", type=Path, required=True)
+    args = parser.parse_args()
+    if args.command == "coverage":
+        contract = json.loads(args.contract.resolve().read_text(encoding="utf-8"))
+        evidence = json.loads(args.evidence.resolve().read_text(encoding="utf-8"))
+        observations = evidence.get("observations") if isinstance(evidence, dict) else evidence
+        result = compare(contract, observations)
+        print(json.dumps(result, ensure_ascii=False, indent=2))
+        return 0 if result["passed"] else 1
+    return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/bundled-tools/runtime/agent_runtime.py

@@ -0,0 +1,38 @@
+"""Operational checks for running agent CLIs from a deployed workspace."""
+
+from __future__ import annotations
+
+import os
+import re
+from pathlib import Path
+
+
+ANSI = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
+
+
+def strip_ansi(value: str) -> str:
+    return ANSI.sub("", value)
+
+
+def preflight(environment: dict[str, str] | None = None, release_dir: str | None = None) -> dict:
+    env = environment or dict(os.environ)
+    warnings = [
+        "strip ANSI terminal escapes before parsing URLs, codes, or stored transcripts",
+        "use device authentication on a headless host and confirm the account prerequisite before launch",
+        "carry agent installs and conversation state outside immutable release directories",
+        "put the resume subcommand before agent flags so the CLI cannot treat it as a new prompt",
+    ]
+    risks = []
+    if env.get("NO_COLOR") != "1" or env.get("TERM") not in {"dumb", ""}:
+        risks.append("terminal color may be enabled; parser must still strip ANSI")
+    if release_dir and Path(release_dir).name in {"current", "releases"}:
+        risks.append("agent state must not be stored only inside an immutable release")
+    return {
+        "schemaVersion": "maggie-agent-runtime.v1",
+        "passed": True,
+        "warnings": warnings,
+        "risks": risks,
+        "auth": "device",
+        "resume": {"codex": ["resume", "--last"], "claude": ["--continue"]},
+        "statePolicy": "outside-release-directory",
+    }

package/bundled-tools/runtime/analytics_traffic.py

@@ -17,13 +17,18 @@ def is_tool_traffic(event: dict) -> bool:
     return bool(TOOL_USER_AGENT.search(str(event.get("userAgent") or "")))
 
 
+def should_record_measurement(event: dict) -> bool:
+    """Apply the same exclusion before every counter or event logger."""
+    return not is_tool_traffic(event)
+
+
 def audit_events(events: Iterable[dict]) -> dict:
     totals = Counter()
     excluded = Counter()
     included = 0
     for event in events:
         totals[str(event.get("event") or "unknown")] += 1
-        if is_tool_traffic(event):
+        if not should_record_measurement(event):
             excluded[str(event.get("event") or "unknown")] += 1
         else:
             included += 1

package/bundled-tools/runtime/maggie_dash_store.py

@@ -13,8 +13,10 @@ from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Any
 
+from maggie_sections import ensure_section_ids
 
-STATUSES = ("draft", "review", "approved", "scheduled", "published", "archived")
+
+STATUSES = ("draft", "review", "approved", "scheduled", "published", "archived", "trashed")
 TRANSITIONS = {
     "draft": {"review"},
     "review": {"approved", "draft"},
@@ -22,6 +24,7 @@ TRANSITIONS = {
     "scheduled": {"published", "draft"},
     "published": {"archived"},
     "archived": set(),
+    "trashed": set(),
 }
 
 
@@ -82,6 +85,12 @@ class MaggieDashStore:
               actor_id TEXT NOT NULL, reason TEXT NOT NULL, correlation_id TEXT NOT NULL,
               created_at TEXT NOT NULL
             );
+            CREATE TABLE IF NOT EXISTS maggiedash_section_presets (
+              id TEXT PRIMARY KEY, project_id TEXT NOT NULL REFERENCES maggiedash_projects(id),
+              name TEXT NOT NULL, description TEXT, body_json TEXT NOT NULL,
+              created_by TEXT, created_at TEXT NOT NULL, updated_at TEXT NOT NULL,
+              UNIQUE(project_id, name)
+            );
             """
         )
         self._ensure_column("maggiedash_documents", "trashed_at", "TEXT")
@@ -120,8 +129,15 @@ class MaggieDashStore:
         status = document.get("status", "draft")
         if status not in STATUSES:
             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)
+        stable = {
+            "id": document["id"], "kind": document["kind"], "title": document["title"],
+            "slug": document["slug"], "locale": document["locale"], "status": status,
+            "excerpt": document.get("excerpt", ""), "content": document["content"],
+            "canonicalUrl": document.get("canonicalUrl"), "publishAt": document.get("publishAt"),
+        }
+        # Provenance is evidence about the source, not the content identity. A
+        # provider checksum must never turn a no-op save into a new revision.
+        document_checksum = checksum(stable)
         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()")
@@ -183,10 +199,10 @@ class MaggieDashStore:
         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"]:
+        if row["trashed_at"] or row["status"] == "trashed":
             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.connection.execute("UPDATE maggiedash_documents SET status='trashed', 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 {}
@@ -195,15 +211,38 @@ class MaggieDashStore:
         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"]:
+        if not row["trashed_at"] and row["trashed_from_status"] is None:
             return self.get_document(project_id, document_id) or {}
         status = row["trashed_from_status"] if row["trashed_from_status"] in STATUSES else "draft"
+        if status == "trashed":
+            status = "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 publish_due(self, project_id: str, now_value: str | None = None, actor_id: str = "scheduler", reason: str = "scheduled publish tick") -> list[dict[str, Any]]:
+        """Publish scheduled documents whose timestamp has arrived.
+
+        The status predicate is intentional: a trashed document may retain an
+        old publish timestamp, but it is never eligible for promotion.
+        """
+        current = datetime.fromisoformat((now_value or now()).replace("Z", "+00:00"))
+        rows = self.connection.execute(
+            "SELECT id, publish_at FROM maggiedash_documents WHERE project_id=? AND status='scheduled' AND publish_at IS NOT NULL ORDER BY id",
+            (project_id,),
+        ).fetchall()
+        published: list[dict[str, Any]] = []
+        for row in rows:
+            try:
+                scheduled = datetime.fromisoformat(str(row["publish_at"]).replace("Z", "+00:00"))
+            except ValueError:
+                continue
+            if scheduled.tzinfo is not None and scheduled <= current:
+                published.append(self.transition(project_id, row["id"], "published", actor_id, reason))
+        return published
+
     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"))
@@ -237,11 +276,61 @@ class MaggieDashStore:
         self.connection.commit()
         return result
 
+    def save_section_preset(self, project_id: str, preset_id: str, name: str, sections: list[dict[str, Any]], actor_id: str, description: str = "") -> dict[str, Any]:
+        """Save an ordered arrangement without leaking page-specific IDs."""
+        name = name.strip()
+        if not name:
+            raise ValueError("preset name is required")
+        if not isinstance(sections, list) or not sections or not all(isinstance(section, dict) and section.get("type") for section in sections):
+            raise ValueError("preset sections must be a non-empty typed list")
+        body = []
+        for section in sections:
+            copy = json.loads(json.dumps(section, ensure_ascii=False))
+            copy.pop("id", None)
+            body.append(copy)
+        timestamp = now()
+        self.connection.execute(
+            "INSERT INTO maggiedash_section_presets (id,project_id,name,description,body_json,created_by,created_at,updated_at) VALUES (?,?,?,?,?,?,?,?) "
+            "ON CONFLICT(id) DO UPDATE SET name=excluded.name, description=excluded.description, body_json=excluded.body_json, updated_at=excluded.updated_at",
+            (preset_id, project_id, name, description.strip(), json.dumps(body, ensure_ascii=False), actor_id, timestamp, timestamp),
+        )
+        self._audit(project_id, "section-preset.saved", "section_preset", preset_id, actor_id, "ordered arrangement saved")
+        self.connection.commit()
+        return self.get_section_preset(project_id, preset_id) or {}
+
+    def get_section_preset(self, project_id: str, preset_id: str) -> dict[str, Any] | None:
+        row = self.connection.execute("SELECT * FROM maggiedash_section_presets WHERE project_id=? AND id=?", (project_id, preset_id)).fetchone()
+        if not row:
+            return None
+        result = dict(row)
+        result["body"] = json.loads(result.pop("body_json"))
+        return result
+
+    def list_section_presets(self, project_id: str) -> list[dict[str, Any]]:
+        rows = self.connection.execute("SELECT id FROM maggiedash_section_presets WHERE project_id=? ORDER BY updated_at DESC", (project_id,)).fetchall()
+        return [self.get_section_preset(project_id, row["id"]) for row in rows]
+
+    def insert_section_preset(self, project_id: str, preset_id: str, existing_ids: list[str], actor_id: str, reason: str) -> list[dict[str, Any]]:
+        preset = self.get_section_preset(project_id, preset_id)
+        if not preset:
+            raise ValueError("section preset not found")
+        result = ensure_section_ids(preset["body"], existing_ids)
+        self._audit(project_id, "section-preset.inserted", "section_preset", preset_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:
+        if not from_path.startswith("/") or not to_path.startswith("/") or self._normalise_path(from_path) == self._normalise_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")
+        destination = self._normalise_path(to_path)
+        chain = self.connection.execute(
+            "SELECT 1 FROM maggiedash_redirects WHERE project_id=? AND ((from_path=? OR rtrim(from_path, '/')=?) OR (to_path=? OR rtrim(to_path, '/')=?)) LIMIT 1",
+            (project_id, destination, destination, from_path, self._normalise_path(from_path)),
+        ).fetchone()
+        if chain:
+            raise ValueError("redirect destination must not already redirect")
         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)
@@ -249,6 +338,22 @@ class MaggieDashStore:
         row = self.connection.execute("SELECT * FROM maggiedash_redirects WHERE project_id=? AND from_path=?", (project_id, from_path)).fetchone()
         return dict(row)
 
+    @staticmethod
+    def _normalise_path(path: str) -> str:
+        path = path.split("?", 1)[0].split("#", 1)[0]
+        return path.rstrip("/") or "/"
+
+    def resolve_redirect(self, project_id: str, path: str, response_status: int) -> dict[str, Any] | None:
+        """Consult redirects only after the route has already returned 404."""
+        if response_status != 404:
+            return None
+        normalised = self._normalise_path(path)
+        row = self.connection.execute(
+            "SELECT * FROM maggiedash_redirects WHERE project_id=? AND (from_path=? OR rtrim(from_path, '/')=?) ORDER BY CASE WHEN from_path=? THEN 0 ELSE 1 END LIMIT 1",
+            (project_id, path, normalised, path),
+        ).fetchone()
+        return dict(row) if row else None
+
     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")
@@ -258,7 +363,15 @@ class MaggieDashStore:
         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")}
+        return {
+            "token": f"{encoded}.{signature}",
+            "expiresAt": datetime.fromtimestamp(expires, timezone.utc).isoformat().replace("+00:00", "Z"),
+            "headers": {
+                "Cache-Control": "no-store",
+                "X-Robots-Tag": "noindex, nofollow",
+                "metaRobots": "noindex, nofollow",
+            },
+        }
 
     @staticmethod
     def verify_preview(token: str, secret: str, project_id: str, document_id: str) -> bool: