td-ai-tools 1.1.7 → 1.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "td-ai-tools",
-  "version": "1.1.7",
+  "version": "1.1.8",
   "description": "Install agent skills and packs into your project",
   "type": "module",
   "scripts": {

package/skills/README.md

@@ -1,6 +1,7 @@
 # skills
 
 ## Available Skills
+- `barrage`: Convert a group of Basecamp todos or cards into a td-barrage queue.json task file.
 - `basecamp`: Interact with Basecamp via the Basecamp CLI.
 - `cache-reset`: Clear and warm Laravel and Statamic caches (including Statamic Glide image caches) after content or template…
 - `car-ticket-generator`: Generate a ticket for the codex-auto-runner queue
@@ -12,6 +13,7 @@
 - `pull-request`: Generates well-structured GitHub pull request descriptions for Shopify theme development teams by analyzing…
 - `pull-request-statamic`: Generates GitHub pull request descriptions for Statamic and Laravel development by analyzing git diffs and…
 - `record-changes`: Update `docs/changes.md` by summarizing the current branch against the primary development branch.
+- `scry`: Single-site visual regression workflow for comparing a live URL against a preview/staging URL in Playwright…
 - `stylesheet-migration`: Migrate Shopify Liquid `{% stylesheet %}` blocks into theme CSS assets using bundled Python scripts.
 - `td-js-vanilla-rules`: Theory Digital vanilla JavaScript standards for Shopify theme work.
 - `td-review`: Run parallel code review agents on a PR (including TD theme compliance) and produce a synthesized findings…

package/skills/barrage/SKILL.md

@@ -0,0 +1,180 @@
+---
+name: barrage
+description: |
+  Convert a group of Basecamp todos or cards into a td-barrage queue.json task
+  file. Fetches the items via the Basecamp CLI, maps each title -> task id and
+  description -> prompt, and writes queue.json into this skill's directory. Use
+  when the user wants to turn Basecamp work into a barrage queue, build a
+  td-barrage queue from Basecamp, or run a todolist/card table through td-barrage.
+invocable: true
+argument-hint: "[basecamp todolist/card-table/column URL] [--timeout-mins N]"
+---
+
+# /barrage — Basecamp → td-barrage queue builder
+
+Turns a user-specified group of Basecamp todos or cards into a `queue.json` in the
+format consumed by **td-barrage**, a batch task runner (see
+[Output: the td-barrage queue.json format](#output-the-td-barrage-queuejson-format)
+below for the full schema — this skill emits that format directly and needs no
+other repo installed).
+
+## Input: the expected Basecamp item shape
+
+This skill is designed for Basecamp items whose **titles carry a trailing `[Nh]`
+estimate suffix** — e.g. `Build the checkout page [2h]` or `Fix nav [1.5h]`. That
+convention comes from an estimation workflow (the **td-augury** generator produces
+titles in exactly this shape), but nothing here requires that tool: any Basecamp
+todo or card works. Titles *without* a suffix are used verbatim; titles *with* one
+have it stripped from the task id by default (see `--keep-estimate`).
+
+Concretely, each item is read from the Basecamp CLI's JSON output, which exposes:
+
+- `title` — the display title (todos and cards)
+- `content` — for todos this equals the title; for cards it holds the card body (HTML)
+- `description` — the long-form body when present (preferred for the prompt)
+
+## What it produces
+
+Each Basecamp item becomes one td-barrage task:
+
+| td-barrage field | Source | Notes |
+|------------------|--------|-------|
+| `id`        | item **title** | trailing `[Nh]` estimate suffix stripped; deduped if needed |
+| `prompt`    | item **description** | HTML flattened to plain text |
+| `success`   | constant | always `{ "strategy": "default" }` |
+| `timeoutMs` | constant | `35` minutes → `2100000` ms, unless the user specifies otherwise |
+| `maxAttempts` | constant | `2` |
+
+> The user may refer to these as `barrage_id`, `success_criteria`, `timeout`, and
+> `max_attempts`. The actual td-barrage schema uses `id`, `success.strategy`,
+> `timeoutMs` (**milliseconds**), and `maxAttempts` — this skill emits the real
+> field names (documented in full below).
+
+The file is written to **this skill's directory** as `queue.json`
+(`build_queue.py` resolves that path from its own location, so it lands next to the
+script regardless of which skills copy is invoked).
+
+## Workflow
+
+### 1. Determine the group and item type
+
+Ask the user (if not already clear) for the Basecamp group to convert and whether
+it is **todos** or **cards**. A "group" is normally one of:
+
+- a **todolist** URL  → its todos
+- a **card table** URL → all its cards
+- a **column** URL     → the cards in that column
+- a whole **project**  → all todos or all cards in it
+
+### 2. Resolve IDs from the URL
+
+Always parse a URL first to extract the project and recording IDs:
+
+```bash
+basecamp url parse "<url>" --json
+```
+
+This returns `project_id`, `type`, and `recording_id`.
+
+### 3. Fetch the items as JSON
+
+Use the matching list command. **Always pass `--json`.**
+
+```bash
+# Todos in a specific todolist
+basecamp todos list --list <todolist_id> --in <project_id> --json > items.json
+
+# All todos in a project
+basecamp todos list --in <project_id> --json > items.json
+
+# Cards in a specific card table (required flag if a project has >1 table)
+basecamp cards list --card-table <table_id> --in <project_id> --json > items.json
+
+# Cards in a single column
+basecamp cards list --column <column_id> --in <project_id> --json > items.json
+```
+
+The CLI returns an envelope `{ ok, data, ... }`; the converter reads `data`
+automatically (it also accepts a bare array or `--agent` raw output). By default
+all (non-completed) items are returned — add `--all` for large lists, or filter
+(e.g. `--status`) if the user only wants some.
+
+### 4. Convert to queue.json
+
+Pipe the fetched JSON into the converter (or pass `--input`):
+
+```bash
+python3 "$SKILL_DIR/scripts/build_queue.py" --input items.json
+# or
+basecamp todos list --list <id> --in <proj> --json \
+  | python3 "$SKILL_DIR/scripts/build_queue.py"
+```
+
+`$SKILL_DIR` is the directory containing this `SKILL.md`. The script writes
+`queue.json` into that directory and prints a summary plus any per-item warnings
+(skipped items with no description, deduped ids, etc.).
+
+Options:
+
+- `--timeout-mins N` — override the 35-minute default (the script converts to ms).
+- `--max-attempts N` — override the default of 2.
+- `--keep-estimate` — keep the `[Nh]` suffix in the id instead of stripping it.
+- `--output PATH` — write somewhere other than `<skill>/queue.json`.
+
+### 5. Report
+
+Tell the user where `queue.json` was written, how many tasks it contains, and
+surface any warnings the script printed (skipped or renamed items).
+
+## Output: the td-barrage queue.json format
+
+td-barrage validates the file with a Zod schema. This skill emits the minimal
+valid subset; the runner fills in the rest with the defaults shown below. The full
+task schema is:
+
+```jsonc
+{
+  "tasks": [
+    {
+      "id": "string",              // required, non-empty; must be unique across the file
+      "prompt": "string",          // required, non-empty
+      "dependsOn": ["string"],     // optional, default []  (ids of prerequisite tasks)
+      "maxAttempts": 2,            // optional, integer >= 1
+      "timeoutMs": 2100000,        // optional, positive integer (MILLISECONDS)
+      "success": {                 // optional, default { "strategy": "default" }
+        "strategy": "default"      //   one of: "default" | "file_exists" | "result_json"
+        // "file_exists" also needs: "path": "string"
+        // "result_json" also needs: "path": "string"
+      },
+      "cwd": "string",             // optional, working directory for the task
+      "resultPath": "string"       // optional, where the task writes its result
+    }
+  ]
+}
+```
+
+The top-level value may be either `{ "tasks": [...] }` (what this skill writes) or a
+bare `[...]` array of tasks. Runtime-managed fields (`status`, `attempts`, `error`,
+`startedAt`, `finishedAt`, `recoveryNotes`) are set by td-barrage and should not be
+authored here.
+
+Validation rules enforced by the runner:
+
+- **Unique ids** — duplicate `id` values are rejected (`Duplicate task id`). The
+  converter pre-empts this by renaming collisions to `"<title> (2)"`.
+- **No self-dependency** — a task cannot list its own id in `dependsOn`.
+- **No dangling dependencies** — every id in `dependsOn` must match another task's id.
+
+## Notes & caveats
+
+- **Empty descriptions are skipped.** td-barrage requires a non-empty `prompt`, so
+  items with no description cannot become tasks. The script warns for each one —
+  relay this so the user can add descriptions in Basecamp and re-run if needed.
+- **Duplicate titles** would make td-barrage reject the whole file
+  (`Duplicate task id`). The script renames collisions to `"<title> (2)"` and
+  warns; prefer fixing the source titles when that happens.
+- **No dependencies are emitted.** Every task is independent (`dependsOn` defaults
+  to `[]`). If the user wants an execution order, edit `queue.json` afterward to add
+  `dependsOn` arrays referencing other task ids.
+- The Basecamp CLI is already authenticated; verify with
+  `basecamp auth status --json` if a fetch fails.

package/skills/barrage/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Barrage"
+  short_description: "Build a td-barrage queue.json from Basecamp todos or cards"
+  default_prompt: "Use $barrage to convert a group of Basecamp todos or cards into a td-barrage queue.json task file."

package/skills/barrage/scripts/build_queue.py

@@ -0,0 +1,276 @@
+#!/usr/bin/env python3
+"""Convert Basecamp todos/cards into a td-barrage queue.json.
+
+Reads the JSON emitted by the Basecamp CLI (`basecamp todos list ... --json`,
+`basecamp cards list ... --json`, or their `--agent` raw form) and writes a
+td-barrage task file. The only runtime dependency is the Basecamp CLI that
+produced the input; the queue.json format it writes is documented in ../SKILL.md
+("Output: the td-barrage queue.json format") so no other repo need be installed.
+
+Field mapping (see ../SKILL.md):
+  - id        <- the item title, with any trailing `[Nh]` estimate suffix stripped
+  - prompt    <- the item description (HTML stripped to plain text)
+  - success   <- {"strategy": "default"} on every item
+  - timeoutMs <- --timeout-mins * 60 * 1000   (default 35 minutes)
+  - maxAttempts <- --max-attempts             (default 2)
+
+The Basecamp CLI normalizes both todos and cards to expose `title`, `content`,
+and `description`. For todos `content == title`; for cards the body lives in
+`content` (HTML). We therefore prefer `description` for the prompt and only fall
+back to `content` when it differs from the title.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from html.parser import HTMLParser
+from pathlib import Path
+from typing import Any
+
+# Skill root is the parent of this script's directory (scripts/ -> <skill>/).
+SKILL_DIR = Path(__file__).resolve().parent.parent
+
+# Matches a trailing estimate suffix like " [2h]" or " [1.5h]" (case-insensitive).
+# Basecamp titles produced by an estimation workflow carry this suffix (the
+# td-augury generator appends "[<hours>h]"); we strip it from the task id so the
+# id reads as a plain title. Titles without a suffix are unaffected.
+ESTIMATE_SUFFIX_RE = re.compile(r"\s*\[\d+(?:\.\d+)?h\]\s*$", re.IGNORECASE)
+
+# Block-level tags whose close (or self-close) should become a line break when
+# flattening an HTML card body to plain text.
+_BLOCK_TAGS = {
+    "p", "div", "br", "li", "ul", "ol", "tr", "h1", "h2", "h3", "h4", "h5", "h6",
+    "blockquote", "pre", "section", "article", "header", "footer",
+}
+
+
+class _TextExtractor(HTMLParser):
+    """Collapse an HTML fragment to readable plain text, preserving line breaks."""
+
+    def __init__(self) -> None:
+        super().__init__(convert_charrefs=True)
+        self._parts: list[str] = []
+
+    def handle_data(self, data: str) -> None:
+        self._parts.append(data)
+
+    def handle_starttag(self, tag: str, attrs: Any) -> None:
+        if tag == "br":
+            self._parts.append("\n")
+
+    def handle_endtag(self, tag: str) -> None:
+        if tag in _BLOCK_TAGS:
+            self._parts.append("\n")
+
+    def text(self) -> str:
+        return "".join(self._parts)
+
+
+def html_to_text(value: str) -> str:
+    """Strip HTML tags/entities and normalize whitespace.
+
+    Plain-text input passes through unchanged apart from whitespace cleanup, so
+    it is safe to run on both todo descriptions (plain) and card bodies (HTML).
+    """
+    parser = _TextExtractor()
+    parser.feed(value)
+    text = parser.text()
+    # Collapse runs of blank lines and trim trailing spaces on each line.
+    lines = [line.strip() for line in text.splitlines()]
+    out: list[str] = []
+    blank = False
+    for line in lines:
+        if line:
+            out.append(line)
+            blank = False
+        elif not blank and out:
+            out.append("")
+            blank = True
+    return "\n".join(out).strip()
+
+
+def first_nonempty(record: dict[str, Any], keys: tuple[str, ...]) -> str:
+    for key in keys:
+        value = record.get(key)
+        if isinstance(value, str) and value.strip():
+            return value.strip()
+    return ""
+
+
+def extract_title(record: dict[str, Any]) -> str:
+    """The display title (before estimate-suffix stripping)."""
+    return first_nonempty(record, ("title", "content", "name"))
+
+
+def extract_description(record: dict[str, Any], title: str) -> str:
+    """The prompt body, HTML-flattened.
+
+    Prefer the dedicated `description` field. Fall back to `content` only when it
+    differs from the title, so a todo (where content == title) does not get its
+    own title echoed back as the prompt.
+    """
+    desc = first_nonempty(record, ("description",))
+    if not desc:
+        content = first_nonempty(record, ("content",))
+        if content and content != title:
+            desc = content
+    return html_to_text(desc)
+
+
+def make_id(title: str, keep_estimate: bool) -> str:
+    if keep_estimate:
+        return title
+    return ESTIMATE_SUFFIX_RE.sub("", title).strip()
+
+
+def unwrap_items(payload: Any) -> list[dict[str, Any]]:
+    """Accept the CLI envelope, the --agent raw form, a bare array, or one item."""
+    if isinstance(payload, dict):
+        if "data" in payload:  # standard --json envelope: {ok, data, ...}
+            payload = payload["data"]
+        elif "tasks" in payload:  # already a queue file
+            payload = payload["tasks"]
+        else:  # a single recording object
+            return [payload]
+    if isinstance(payload, list):
+        return [item for item in payload if isinstance(item, dict)]
+    raise SystemExit("Unrecognized input JSON: expected an envelope, array, or object.")
+
+
+def build_tasks(
+    items: list[dict[str, Any]],
+    *,
+    timeout_ms: int,
+    max_attempts: int,
+    keep_estimate: bool,
+) -> tuple[list[dict[str, Any]], list[str]]:
+    tasks: list[dict[str, Any]] = []
+    warnings: list[str] = []
+    seen: dict[str, int] = {}
+
+    for index, record in enumerate(items):
+        title = extract_title(record)
+        if not title:
+            warnings.append(f"Item #{index} (id={record.get('id')}): no title; skipped.")
+            continue
+
+        prompt = extract_description(record, title)
+        if not prompt:
+            warnings.append(
+                f"Item #{index} {title!r}: empty description; skipped "
+                "(td-barrage requires a non-empty prompt)."
+            )
+            continue
+
+        task_id = make_id(title, keep_estimate)
+        if not task_id:
+            task_id = title  # estimate-only title edge case
+
+        # De-duplicate ids so the file stays loadable (td-barrage rejects dupes).
+        if task_id in seen:
+            seen[task_id] += 1
+            deduped = f"{task_id} ({seen[task_id]})"
+            warnings.append(f"Duplicate id {task_id!r}; renamed to {deduped!r}.")
+            task_id = deduped
+        else:
+            seen[task_id] = 1
+
+        tasks.append(
+            {
+                "id": task_id,
+                "prompt": prompt,
+                "timeoutMs": timeout_ms,
+                "maxAttempts": max_attempts,
+                "success": {"strategy": "default"},
+            }
+        )
+
+    return tasks, warnings
+
+
+def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--input",
+        type=Path,
+        help="Path to the Basecamp CLI JSON. Reads stdin if omitted.",
+    )
+    parser.add_argument(
+        "--output",
+        type=Path,
+        default=SKILL_DIR / "queue.json",
+        help="Where to write the queue file (default: <skill>/queue.json).",
+    )
+    parser.add_argument(
+        "--timeout-mins",
+        type=float,
+        default=35.0,
+        help="Per-task timeout in minutes (default: 35).",
+    )
+    parser.add_argument(
+        "--max-attempts",
+        type=int,
+        default=2,
+        help="Per-task max attempts (default: 2).",
+    )
+    parser.add_argument(
+        "--keep-estimate",
+        action="store_true",
+        help="Keep the trailing [Nh] estimate suffix in the id (stripped by default).",
+    )
+    return parser.parse_args(argv)
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = parse_args(argv)
+
+    raw = args.input.read_text() if args.input else sys.stdin.read()
+    if not raw.strip():
+        print("No input JSON provided.", file=sys.stderr)
+        return 1
+
+    try:
+        payload = json.loads(raw)
+    except json.JSONDecodeError as exc:
+        print(f"Failed to parse input JSON: {exc}", file=sys.stderr)
+        return 1
+
+    if isinstance(payload, dict) and payload.get("ok") is False:
+        print(f"Basecamp CLI returned an error: {payload.get('error')}", file=sys.stderr)
+        return 1
+
+    items = unwrap_items(payload)
+    if not items:
+        print("Input contained no items.", file=sys.stderr)
+        return 1
+
+    timeout_ms = int(round(args.timeout_mins * 60 * 1000))
+    tasks, warnings = build_tasks(
+        items,
+        timeout_ms=timeout_ms,
+        max_attempts=args.max_attempts,
+        keep_estimate=args.keep_estimate,
+    )
+
+    for warning in warnings:
+        print(f"warning: {warning}", file=sys.stderr)
+
+    if not tasks:
+        print("No usable tasks produced (every item lacked a title or description).", file=sys.stderr)
+        return 1
+
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(json.dumps({"tasks": tasks}, indent=2) + "\n")
+
+    print(
+        f"Wrote {len(tasks)} task(s) to {args.output} "
+        f"(timeout={args.timeout_mins}m / {timeout_ms}ms, maxAttempts={args.max_attempts})."
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/skills/barrage/tests/test_build_queue.py

@@ -0,0 +1,135 @@
+"""Tests for build_queue.py — verifies the Basecamp -> td-barrage mapping.
+
+Run: python3 -m pytest .agents/skills/barrage/tests/  (or just `python3 test_build_queue.py`).
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import json
+import sys
+from pathlib import Path
+
+_SCRIPT = Path(__file__).resolve().parent.parent / "scripts" / "build_queue.py"
+_spec = importlib.util.spec_from_file_location("build_queue", _SCRIPT)
+assert _spec and _spec.loader
+bq = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(bq)
+
+
+# Shapes mirror what the Basecamp CLI actually returns (verified against the live
+# CLI): todos expose title == content plus a separate description; cards carry the
+# body in an HTML `content` field.
+TODO = {
+    "id": 1,
+    "title": "Design — Search [2h]",
+    "content": "Design — Search [2h]",
+    "description": "Build the search UI and wire it to the API.",
+}
+CARD = {
+    "id": 2,
+    "title": "Implement parser [1.5h]",
+    "content": "<div>Parse the file.</div><div>Emit JSON.</div>",
+    "description": "",
+}
+
+
+def build(items, **kw):
+    defaults = {"timeout_ms": 2_100_000, "max_attempts": 2, "keep_estimate": False}
+    defaults.update(kw)
+    return bq.build_tasks(items, **defaults)
+
+
+def test_todo_mapping():
+    tasks, warnings = build([TODO])
+    assert warnings == []
+    assert tasks == [
+        {
+            "id": "Design — Search",  # [2h] stripped
+            "prompt": "Build the search UI and wire it to the API.",
+            "timeoutMs": 2_100_000,
+            "maxAttempts": 2,
+            "success": {"strategy": "default"},
+        }
+    ]
+
+
+def test_card_html_body_becomes_prompt():
+    tasks, _ = build([CARD])
+    assert tasks[0]["id"] == "Implement parser"
+    # HTML flattened, block tags -> line breaks.
+    assert tasks[0]["prompt"] == "Parse the file.\nEmit JSON."
+
+
+def test_default_success_timeout_attempts():
+    tasks, _ = build([TODO], timeout_ms=999, max_attempts=5)
+    assert tasks[0]["success"] == {"strategy": "default"}
+    assert tasks[0]["timeoutMs"] == 999
+    assert tasks[0]["maxAttempts"] == 5
+
+
+def test_keep_estimate_suffix():
+    tasks, _ = build([TODO], keep_estimate=True)
+    assert tasks[0]["id"] == "Design — Search [2h]"
+
+
+def test_empty_description_is_skipped_with_warning():
+    item = {"id": 9, "title": "No body", "content": "No body", "description": ""}
+    tasks, warnings = build([item])
+    assert tasks == []
+    assert any("empty description" in w for w in warnings)
+
+
+def test_todo_title_not_echoed_as_prompt():
+    # content == title and no description -> must NOT use title as the prompt.
+    item = {"id": 9, "title": "Echo", "content": "Echo", "description": ""}
+    tasks, _ = build([item])
+    assert tasks == []
+
+
+def test_duplicate_ids_are_renamed():
+    a = {"id": 1, "title": "Same", "content": "Same", "description": "first"}
+    b = {"id": 2, "title": "Same", "content": "Same", "description": "second"}
+    tasks, warnings = build([a, b])
+    ids = [t["id"] for t in tasks]
+    assert ids == ["Same", "Same (2)"]
+    assert any("Duplicate" in w for w in warnings)
+
+
+def test_unwrap_envelope_array_and_object():
+    assert bq.unwrap_items({"ok": True, "data": [TODO]}) == [TODO]
+    assert bq.unwrap_items([TODO]) == [TODO]
+    assert bq.unwrap_items(TODO) == [TODO]
+    assert bq.unwrap_items({"tasks": [TODO]}) == [TODO]
+
+
+def test_end_to_end_via_main(tmp_path):
+    src = tmp_path / "items.json"
+    src.write_text(json.dumps({"ok": True, "data": [TODO, CARD]}))
+    out = tmp_path / "queue.json"
+    rc = bq.main(["--input", str(src), "--output", str(out)])
+    assert rc == 0
+    data = json.loads(out.read_text())
+    assert [t["id"] for t in data["tasks"]] == ["Design — Search", "Implement parser"]
+    assert all(t["success"] == {"strategy": "default"} for t in data["tasks"])
+    assert all(t["timeoutMs"] == 2_100_000 for t in data["tasks"])
+
+
+if __name__ == "__main__":
+    failures = 0
+    for name, fn in sorted(globals().items()):
+        if name.startswith("test_") and callable(fn):
+            try:
+                # crude tmp_path for direct (non-pytest) runs
+                if "tmp_path" in fn.__code__.co_varnames[: fn.__code__.co_argcount]:
+                    import tempfile
+
+                    with tempfile.TemporaryDirectory() as d:
+                        fn(Path(d))
+                else:
+                    fn()
+                print(f"ok   {name}")
+            except AssertionError as exc:
+                failures += 1
+                print(f"FAIL {name}: {exc}")
+    sys.exit(1 if failures else 0)

package/skills/scry/SKILL.md

@@ -0,0 +1,74 @@
+---
+name: scry
+version: 1.0.0
+description: Single-site visual regression workflow for comparing a live URL against a preview/staging URL in Playwright UI mode. Use when the user provides or asks to compare two links, one live/baseline link and one preview link, wants fresh or reused live snapshots, or needs an ad hoc visual check that stores generated paths and baselines inside the skill folder rather than adding a normal CI site.
+---
+
+# Scry
+
+Use `scry` for temporary visual regression checks between one live site and one preview site.
+It keeps state in this skill folder so the workflow is separate from the repo's regular `sites/` configs.
+
+## Workflow
+
+1. Confirm the two URLs: live first, preview second.
+2. Ask the user whether to refresh live baselines before comparing unless they already said yes/no.
+3. Run the bundled script from the repository root:
+
+```bash
+python3 .agents/skills/scry/scripts/scry.py <live-url> <preview-url> --refresh
+```
+
+Use `--reuse` instead of `--refresh` when the user wants to compare against existing baselines.
+The script opens Playwright UI mode by default.
+
+## What The Script Does
+
+- Writes `.agents/skills/scry/config.json` with the latest live and preview URLs.
+- On first run, generates `.agents/skills/scry/paths.json` from the live URL's sitemap.
+- Reuses `.agents/skills/scry/paths.json` on later runs unless `--regenerate-paths` is passed.
+- Stores live baseline screenshots in `.agents/skills/scry/baselines/`.
+- Generates runtime Playwright files under `.agents/skills/scry/runtime/`.
+- Runs `npx playwright test --ui` against the generated runtime config.
+
+If sitemap generation fails on the first run, the script falls back to a homepage-only `paths.json`.
+After generation, inspect `paths.json` and trim duplicate template paths when the sitemap is large.
+
+## Commands
+
+Refresh baselines and open UI comparison:
+
+```bash
+python3 .agents/skills/scry/scripts/scry.py https://example.com https://preview.example.com --refresh
+```
+
+Reuse existing baselines:
+
+```bash
+python3 .agents/skills/scry/scripts/scry.py https://example.com https://preview.example.com --reuse
+```
+
+Regenerate paths from the live sitemap:
+
+```bash
+python3 .agents/skills/scry/scripts/scry.py https://example.com https://preview.example.com --refresh --regenerate-paths
+```
+
+Run headless instead of UI mode:
+
+```bash
+python3 .agents/skills/scry/scripts/scry.py https://example.com https://preview.example.com --refresh --no-ui
+```
+
+Useful options:
+
+- `--browser=chromium` limits the run to one browser. Repeat it for multiple browsers.
+- `--max-diff=0.02` changes the allowed pixel ratio.
+- `--sitemap=https://example.com/custom-sitemap.xml` uses a custom sitemap.
+- `--path=/about --path=/products/example` overrides sitemap paths for the current run and writes them to `paths.json`.
+- `--wait-until=networkidle` changes navigation waiting; default is `domcontentloaded`.
+
+## Playwright CLI
+
+If the comparison fails or needs manual investigation, use `$playwright-cli` after the UI run to inspect pages directly.
+Prefer `--browser=chromium` or the existing Playwright CLI config in this repo when opening manual sessions.

package/skills/scry/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Scry"
+  short_description: "Compare live and preview sites visually."
+  default_prompt: "Use $scry to compare a live site URL against a preview URL."

package/skills/scry/scripts/scry.py

@@ -0,0 +1,542 @@
+#!/usr/bin/env python3
+"""Ad hoc visual regression runner for the scry skill.
+
+The Python entrypoint owns URL/path discovery and writes the runtime Playwright
+files used for comparison. Playwright still runs through `npx playwright test`
+because the generated test suite is JavaScript and uses @playwright/test.
+"""
+
+from __future__ import annotations
+
+import argparse
+import html
+import json
+import os
+import re
+import subprocess
+import sys
+import urllib.error
+import urllib.parse
+import urllib.request
+import xml.etree.ElementTree as ET
+from datetime import datetime, timezone
+from pathlib import Path, PurePosixPath
+from typing import Any
+
+
+SCRIPT_DIR = Path(__file__).resolve().parent
+SKILL_DIR = SCRIPT_DIR.parent
+PATHS_FILE = SKILL_DIR / "paths.json"
+CONFIG_FILE = SKILL_DIR / "config.json"
+BASELINE_DIR = SKILL_DIR / "baselines"
+RUNTIME_DIR = SKILL_DIR / "runtime"
+
+DEFAULT_BROWSERS = ("chromium", "firefox", "webkit")
+WAIT_UNTIL_CHOICES = ("domcontentloaded", "networkidle")
+
+
+PLAYWRIGHT_SPEC = r'''const { test, expect } = require("@playwright/test");
+const fs = require("fs");
+const path = require("path");
+
+const config = JSON.parse(fs.readFileSync(process.env.SCRY_CONFIG, "utf8"));
+const paths = JSON.parse(fs.readFileSync(process.env.SCRY_PATHS, "utf8"));
+const refresh = process.env.SCRY_REFRESH === "1";
+
+function joinUrl(baseUrl, pagePath) {
+  const base = new URL(baseUrl);
+  const normalizedPath = pagePath.startsWith("/") ? pagePath : "/" + pagePath;
+  const joined = new URL(normalizedPath, base.origin);
+  if (base.pathname !== "/" && base.pathname !== "") {
+    joined.pathname = path.posix.join(base.pathname, joined.pathname);
+  }
+  return joined.toString();
+}
+
+async function blockThirdPartyScripts(context, allowedUrl) {
+  const allowedHost = new URL(allowedUrl).hostname;
+  await context.route("**/*", async (route) => {
+    const request = route.request();
+    const resourceType = request.resourceType();
+    let requestHost = "";
+    try {
+      requestHost = new URL(request.url()).hostname;
+    } catch {
+      await route.continue();
+      return;
+    }
+    if (["script", "font", "media"].includes(resourceType) && requestHost !== allowedHost) {
+      await route.abort();
+      return;
+    }
+    await route.continue();
+  });
+}
+
+async function hidePopups(page) {
+  for (const selector of config.popupSelectors || []) {
+    await page.locator(selector).evaluateAll((elements) => {
+      for (const element of elements) {
+        element.style.setProperty("display", "none", "important");
+        element.style.setProperty("visibility", "hidden", "important");
+      }
+    }).catch(() => {});
+  }
+}
+
+async function freezeMedia(page) {
+  await page.addStyleTag({
+    content: "*,*::before,*::after{animation-delay:0s!important;animation-duration:0s!important;transition-duration:0s!important;scroll-behavior:auto!important} video,iframe{visibility:hidden!important}",
+  }).catch(() => {});
+  await page.evaluate(() => {
+    for (const video of document.querySelectorAll("video")) {
+      video.pause();
+      video.currentTime = 0;
+    }
+  }).catch(() => {});
+}
+
+async function waitForStability(page) {
+  for (const selector of config.readySelectors || []) {
+    await page.locator(selector).first().waitFor({
+      state: "visible",
+      timeout: config.settleTimeoutMs,
+    }).catch(() => {});
+  }
+
+  await page.evaluate(async () => {
+    if (document.fonts?.ready) await document.fonts.ready;
+    for (const img of document.images) {
+      img.loading = "eager";
+      img.fetchPriority = "high";
+    }
+    const height = Math.max(document.body.scrollHeight, document.documentElement.scrollHeight);
+    const step = Math.max(300, Math.floor(window.innerHeight * 0.8));
+    for (let y = 0; y < height; y += step) {
+      window.scrollTo(0, y);
+      await new Promise((resolve) => setTimeout(resolve, 80));
+    }
+    window.scrollTo(0, 0);
+    await Promise.all(Array.from(document.images).map((img) => {
+      if (img.complete && img.naturalWidth > 0) return Promise.resolve();
+      return new Promise((resolve) => {
+        img.addEventListener("load", resolve, { once: true });
+        img.addEventListener("error", resolve, { once: true });
+        setTimeout(resolve, 3000);
+      });
+    }));
+  }).catch(() => {});
+
+  await page.waitForTimeout(config.settleQuietWindowMs);
+}
+
+async function preparePage(page) {
+  await hidePopups(page);
+  await freezeMedia(page);
+  await waitForStability(page);
+}
+
+for (const pathEntry of paths) {
+  test(pathEntry.name + " visual comparison", async ({ browser }, testInfo) => {
+    const snapshotName = pathEntry.name + ".png";
+    const snapshotPath = testInfo.snapshotPath(snapshotName);
+    fs.mkdirSync(path.dirname(snapshotPath), { recursive: true });
+
+    if (refresh || !fs.existsSync(snapshotPath)) {
+      const liveContext = await browser.newContext({ reducedMotion: "reduce" });
+      await blockThirdPartyScripts(liveContext, config.liveUrl);
+      const livePage = await liveContext.newPage();
+      await livePage.goto(joinUrl(config.liveUrl, pathEntry.path), { waitUntil: config.waitUntil });
+      await preparePage(livePage);
+      const screenshot = await livePage.screenshot({
+        fullPage: true,
+        animations: "disabled",
+        scale: "css",
+      });
+      fs.writeFileSync(snapshotPath, screenshot);
+      await liveContext.close();
+    }
+
+    const previewContext = await browser.newContext({ reducedMotion: "reduce" });
+    await blockThirdPartyScripts(previewContext, config.previewUrl);
+    const previewPage = await previewContext.newPage();
+    await previewPage.goto(joinUrl(config.previewUrl, pathEntry.path), { waitUntil: config.waitUntil });
+    await preparePage(previewPage);
+
+    await expect(previewPage).toHaveScreenshot(snapshotName, {
+      fullPage: true,
+      animations: "disabled",
+      scale: "css",
+      maxDiffPixelRatio: config.maxDiffPixelRatio,
+    });
+
+    await previewContext.close();
+  });
+}
+'''
+
+
+def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        prog="scry.py",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        description=(
+            "Compare a live URL against a preview URL with generated "
+            "Playwright visual regression tests."
+        ),
+    )
+    parser.add_argument("live_url")
+    parser.add_argument("preview_url")
+
+    refresh_group = parser.add_mutually_exclusive_group()
+    refresh_group.add_argument(
+        "--refresh",
+        dest="refresh",
+        action="store_true",
+        default=None,
+        help="Capture new live baselines before comparing.",
+    )
+    refresh_group.add_argument(
+        "--reuse",
+        dest="refresh",
+        action="store_false",
+        help="Reuse existing live baselines.",
+    )
+
+    parser.add_argument(
+        "--regenerate-paths",
+        action="store_true",
+        help="Rebuild paths.json from the live sitemap.",
+    )
+    parser.add_argument(
+        "--path",
+        dest="explicit_paths",
+        action="append",
+        default=[],
+        help="Use an explicit path; repeat for multiple paths.",
+    )
+    parser.add_argument(
+        "--browser",
+        dest="browsers",
+        action="append",
+        default=[],
+        help="Limit browsers; repeat for multiple browsers.",
+    )
+    parser.add_argument("--sitemap", dest="sitemap_url", help="Use a custom sitemap URL.")
+    parser.add_argument(
+        "--max-diff",
+        type=float,
+        default=0.02,
+        help="Allowed visual diff ratio, from 0 to 1.",
+    )
+    parser.add_argument(
+        "--wait-until",
+        choices=WAIT_UNTIL_CHOICES,
+        default="domcontentloaded",
+        help="Navigation wait condition.",
+    )
+    parser.add_argument(
+        "--no-ui",
+        dest="ui",
+        action="store_false",
+        default=True,
+        help="Run headless instead of Playwright UI mode.",
+    )
+
+    args = parser.parse_args(argv)
+    if not 0 <= args.max_diff <= 1:
+        parser.error("--max-diff must be a number between 0 and 1.")
+    if not args.browsers:
+        args.browsers = list(DEFAULT_BROWSERS)
+    args.explicit_paths = [normalize_url_path(path) for path in args.explicit_paths]
+    return args
+
+
+def normalize_url(value: str, label: str) -> str:
+    parsed = urllib.parse.urlsplit(value)
+    if parsed.scheme not in {"http", "https"} or not parsed.netloc:
+        raise ValueError(f"{label} must be a valid http or https URL: {value}")
+    path = parsed.path or "/"
+    return urllib.parse.urlunsplit(
+        (parsed.scheme, parsed.netloc, path, parsed.query, parsed.fragment)
+    )
+
+
+def normalize_url_path(value: str) -> str:
+    if not value or value == "/":
+        return "/"
+    parsed = urllib.parse.urlsplit(value)
+    path = parsed.path if parsed.scheme in {"http", "https"} else value
+    if not path or path == "/":
+        return "/"
+    with_slash = path if path.startswith("/") else f"/{path}"
+    return with_slash.rstrip("/") or "/"
+
+
+def path_name(url_path: str) -> str:
+    if url_path == "/":
+        return "homepage"
+    name = "-".join(part for part in url_path.strip("/").split("/") if part)
+    name = re.sub(r"[^a-zA-Z0-9_-]+", "-", name)
+    name = re.sub(r"-+", "-", name)
+    return name.strip("-") or "homepage"
+
+
+def default_sitemap_url(live_url: str) -> str:
+    return f"{live_url.rstrip('/')}/sitemap.xml"
+
+
+def fetch_xml(url: str) -> str:
+    print(f"Fetching sitemap: {url}")
+    request = urllib.request.Request(
+        url,
+        headers={
+            "User-Agent": "ScryVisualRegression/1.0",
+            "Accept": "application/xml, text/xml, */*",
+        },
+    )
+    try:
+        with urllib.request.urlopen(request, timeout=30) as response:
+            charset = response.headers.get_content_charset() or "utf-8"
+            return response.read().decode(charset, errors="replace")
+    except urllib.error.HTTPError as exc:
+        raise RuntimeError(f"{exc.code} {exc.reason}") from exc
+    except urllib.error.URLError as exc:
+        raise RuntimeError(str(exc.reason)) from exc
+
+
+def local_name(tag: str) -> str:
+    return tag.rsplit("}", 1)[-1].lower()
+
+
+def extract_loc_values(xml: str) -> list[str]:
+    try:
+        root = ET.fromstring(xml)
+    except ET.ParseError:
+        return [
+            html.unescape(match.group(1).strip())
+            for match in re.finditer(r"<loc\b[^>]*>\s*([\s\S]*?)\s*</loc>", xml, re.I)
+            if match.group(1).strip()
+        ]
+
+    values: list[str] = []
+    for element in root.iter():
+        if local_name(element.tag) == "loc" and element.text and element.text.strip():
+            values.append(element.text.strip())
+    return values
+
+
+def is_sitemap_index(xml: str) -> bool:
+    try:
+        root = ET.fromstring(xml)
+    except ET.ParseError:
+        return bool(re.search(r"<sitemapindex\b", xml, re.I))
+    return local_name(root.tag) == "sitemapindex"
+
+
+def parse_sitemap(
+    sitemap_url: str,
+    live_url: str,
+    seen: set[str] | None = None,
+) -> list[dict[str, str]]:
+    seen = seen or set()
+    if sitemap_url in seen:
+        return []
+    seen.add(sitemap_url)
+
+    xml = fetch_xml(sitemap_url)
+    loc_values = extract_loc_values(xml)
+
+    if is_sitemap_index(xml):
+        paths: list[dict[str, str]] = []
+        for loc in loc_values:
+            paths.extend(parse_sitemap(loc, live_url, seen))
+        return paths
+
+    live_parts = urllib.parse.urlsplit(live_url)
+    live_origin = (live_parts.scheme, live_parts.netloc)
+    paths = []
+    for loc in loc_values:
+        url = urllib.parse.urlsplit(loc)
+        if (url.scheme, url.netloc) != live_origin:
+            continue
+        relative_path = normalize_url_path(url.path)
+        paths.append({"name": path_name(relative_path), "path": relative_path})
+    return paths
+
+
+def unique_sorted_paths(paths: list[dict[str, str]]) -> list[dict[str, str]]:
+    by_path: dict[str, dict[str, str]] = {}
+    for entry in paths:
+        normalized = normalize_url_path(entry["path"])
+        if normalized not in by_path:
+            by_path[normalized] = {
+                "name": entry.get("name") or path_name(normalized),
+                "path": normalized,
+            }
+    return sorted(by_path.values(), key=lambda entry: entry["name"])
+
+
+def write_json(path: Path, value: Any) -> None:
+    path.write_text(f"{json.dumps(value, indent=2)}\n", encoding="utf-8")
+
+
+def read_json(path: Path) -> Any:
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def ensure_paths(live_url: str, args: argparse.Namespace) -> list[dict[str, str]]:
+    if args.explicit_paths:
+        paths = unique_sorted_paths(
+            [{"name": path_name(entry_path), "path": entry_path} for entry_path in args.explicit_paths]
+        )
+        write_json(PATHS_FILE, paths)
+        return paths
+
+    if PATHS_FILE.exists() and not args.regenerate_paths:
+        return read_json(PATHS_FILE)
+
+    sitemap_url = args.sitemap_url or default_sitemap_url(live_url)
+    try:
+        generated = unique_sorted_paths(parse_sitemap(sitemap_url, live_url))
+        if not generated:
+            raise RuntimeError("No same-origin URLs found in sitemap.")
+        write_json(PATHS_FILE, generated)
+        return generated
+    except Exception as exc:
+        if PATHS_FILE.exists():
+            raise
+        print(f"Could not generate sitemap paths ({exc}); using homepage only.", file=sys.stderr)
+        fallback = [{"name": "homepage", "path": "/"}]
+        write_json(PATHS_FILE, fallback)
+        return fallback
+
+
+def resolve_refresh_choice(args: argparse.Namespace) -> bool:
+    if isinstance(args.refresh, bool):
+        return args.refresh
+    if not sys.stdin.isatty():
+        raise RuntimeError("Choose --refresh or --reuse. In non-interactive runs, scry will not guess.")
+    answer = input("Refresh live baselines before comparing? [Y/n] ")
+    return not re.match(r"^n(o)?$", answer.strip(), re.I)
+
+
+def browser_project(browser: str) -> str:
+    device = {
+        "firefox": "Desktop Firefox",
+        "webkit": "Desktop Safari",
+    }.get(browser, "Desktop Chrome")
+    return f'    {{ name: "{browser}", use: {{ ...devices["{device}"] }} }}'
+
+
+def write_runtime_files(config: dict[str, Any]) -> Path:
+    RUNTIME_DIR.mkdir(parents=True, exist_ok=True)
+
+    spec_path = RUNTIME_DIR / "scry.spec.cjs"
+    playwright_config_path = RUNTIME_DIR / "playwright.config.cjs"
+
+    spec_path.write_text(PLAYWRIGHT_SPEC, encoding="utf-8")
+    browser_projects = ",\n".join(browser_project(browser) for browser in config["browsers"])
+    snapshot_dir = str(PurePosixPath(BASELINE_DIR))
+    playwright_config_path.write_text(
+        f'''const {{ defineConfig, devices }} = require("@playwright/test");
+
+module.exports = defineConfig({{
+  testDir: __dirname,
+  timeout: 90000,
+  fullyParallel: true,
+  workers: 1,
+  reporter: "html",
+  use: {{
+    trace: "on-first-retry",
+    contextOptions: {{ reducedMotion: "reduce" }},
+  }},
+  snapshotDir: {json.dumps(snapshot_dir)},
+  snapshotPathTemplate: "{{snapshotDir}}/{{projectName}}/{{arg}}{{ext}}",
+  projects: [
+{browser_projects}
+  ],
+}});
+''',
+        encoding="utf-8",
+    )
+    return playwright_config_path
+
+
+def run_playwright(playwright_config_path: Path, ui: bool, refresh: bool) -> int:
+    args = ["npx", "playwright", "test", "--config", str(playwright_config_path)]
+    if ui:
+        args.append("--ui")
+
+    env = os.environ.copy()
+    env.update(
+        {
+            "SCRY_CONFIG": str(CONFIG_FILE),
+            "SCRY_PATHS": str(PATHS_FILE),
+            "SCRY_BASELINE_DIR": str(BASELINE_DIR),
+            "SCRY_REFRESH": "1" if refresh else "0",
+        }
+    )
+    try:
+        completed = subprocess.run(args, env=env)
+    except FileNotFoundError as exc:
+        raise RuntimeError("npx was not found; install Node.js/npm before running scry.") from exc
+    return completed.returncode
+
+
+def build_config(
+    live_url: str,
+    preview_url: str,
+    args: argparse.Namespace,
+    path_count: int,
+) -> dict[str, Any]:
+    return {
+        "liveUrl": live_url,
+        "previewUrl": preview_url,
+        "sitemapUrl": args.sitemap_url or default_sitemap_url(live_url),
+        "waitUntil": args.wait_until,
+        "popupSelectors": [],
+        "readySelectors": ["main"],
+        "settleTimeoutMs": 10000,
+        "settleQuietWindowMs": 700,
+        "maxDiffPixelRatio": args.max_diff,
+        "browsers": args.browsers,
+        "pathCount": path_count,
+        "updatedAt": datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"),
+    }
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = parse_args(argv)
+    live_url = normalize_url(args.live_url, "live URL")
+    preview_url = normalize_url(args.preview_url, "preview URL")
+    if args.sitemap_url:
+        args.sitemap_url = normalize_url(args.sitemap_url, "sitemap URL")
+
+    refresh = resolve_refresh_choice(args)
+    paths = ensure_paths(live_url, args)
+
+    BASELINE_DIR.mkdir(parents=True, exist_ok=True)
+    config = build_config(live_url, preview_url, args, len(paths))
+    write_json(CONFIG_FILE, config)
+    playwright_config_path = write_runtime_files(config)
+
+    print(f"Scry paths: {PATHS_FILE} ({len(paths)} paths)")
+    print(f"Scry baselines: {BASELINE_DIR}")
+    print(
+        "Refreshing live baselines during this run."
+        if refresh
+        else "Reusing existing live baselines."
+    )
+
+    return run_playwright(playwright_config_path, args.ui, refresh)
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main())
+    except KeyboardInterrupt:
+        sys.exit(130)
+    except Exception as exc:
+        print(f"scry: {exc}", file=sys.stderr)
+        sys.exit(1)

package/skills/scry/tests/test_scry.py

@@ -0,0 +1,96 @@
+"""Tests for scry.py helper behavior.
+
+Run: python3 skills/scry/tests/test_scry.py
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import sys
+from pathlib import Path
+
+
+_SCRIPT = Path(__file__).resolve().parent.parent / "scripts" / "scry.py"
+_spec = importlib.util.spec_from_file_location("scry", _SCRIPT)
+assert _spec and _spec.loader
+scry = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(scry)
+
+
+def test_normalize_url_adds_origin_slash():
+    assert scry.normalize_url("https://example.com", "live URL") == "https://example.com/"
+
+
+def test_normalize_url_rejects_non_http():
+    try:
+        scry.normalize_url("ftp://example.com", "live URL")
+    except ValueError as exc:
+        assert "http or https" in str(exc)
+    else:
+        raise AssertionError("Expected ValueError")
+
+
+def test_normalize_url_path_and_name():
+    assert scry.normalize_url_path("about/team/") == "/about/team"
+    assert scry.normalize_url_path("https://example.com/products/widget/") == "/products/widget"
+    assert scry.path_name("/") == "homepage"
+    assert scry.path_name("/products/widget!") == "products-widget"
+
+
+def test_unique_sorted_paths_dedupes_by_path():
+    paths = scry.unique_sorted_paths(
+        [
+            {"name": "z", "path": "/about/"},
+            {"name": "a", "path": "/"},
+            {"name": "duplicate", "path": "/about"},
+        ]
+    )
+    assert paths == [
+        {"name": "a", "path": "/"},
+        {"name": "z", "path": "/about"},
+    ]
+
+
+def test_parse_sitemap_index_recurses_and_filters_origin():
+    fixtures = {
+        "https://example.com/sitemap.xml": """<?xml version="1.0"?>
+          <sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+            <sitemap><loc>https://example.com/pages.xml</loc></sitemap>
+          </sitemapindex>""",
+        "https://example.com/pages.xml": """<?xml version="1.0"?>
+          <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+            <url><loc>https://example.com/about/</loc></url>
+            <url><loc>https://external.example.com/ignore/</loc></url>
+          </urlset>""",
+    }
+    original_fetch_xml = scry.fetch_xml
+    try:
+        scry.fetch_xml = lambda url: fixtures[url]
+        assert scry.parse_sitemap(
+            "https://example.com/sitemap.xml",
+            "https://example.com/",
+        ) == [{"name": "about", "path": "/about"}]
+    finally:
+        scry.fetch_xml = original_fetch_xml
+
+
+def test_parse_args_defaults_browsers():
+    args = scry.parse_args(["https://a.test", "https://b.test", "--reuse"])
+    assert args.refresh is False
+    assert args.browsers == ["chromium", "firefox", "webkit"]
+
+
+if __name__ == "__main__":
+    failures = 0
+    for name, fn in sorted(globals().items()):
+        if name.startswith("test_") and callable(fn):
+            try:
+                fn()
+                print(f"ok   {name}")
+            except AssertionError as exc:
+                failures += 1
+                print(f"FAIL {name}: {exc}")
+            except Exception as exc:
+                failures += 1
+                print(f"ERROR {name}: {exc}")
+    sys.exit(1 if failures else 0)