slipwai 1.1.1.dev4__tar.gz → 1.2.0.dev7__tar.gz

{slipwai-1.1.1.dev4 → slipwai-1.2.0.dev7}/NOTICE

@@ -18,9 +18,11 @@ notices:
 - event-modeling — current adaptation under the root MIT licence; its NOTICE
   records the CC0-1.0 starting point
 - find-skills — MIT; copyright Vercel, Inc.
+- frontend-design — Apache-2.0; copyright Anthropic, PBC
 - improve-codebase-architecture — MIT; copyright Matt Pocock
 - reduce-system-complexity — MIT; copyright Adam Bulmer
 - technical-writing — MIT; copyright Adam Bulmer
+- web-interface-guidelines — MIT (references/guidelines.md); copyright Vercel, Inc.
 - wtf — MIT; copyright Adam Bulmer
 
 The applicable licence notice and exact provenance for each adaptation remain

{slipwai-1.1.1.dev4 → slipwai-1.2.0.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: slipwai
-Version: 1.1.1.dev4
+Version: 1.2.0.dev7
 Summary: One-shot scaffolder for product monorepos: a walking skeleton, a verify gate, a path to production, and a repository set up for coding agents.
 Project-URL: Homepage, https://github.com/ROBCOATVG/slipwai
 Project-URL: Repository, https://git.treyco.dev/ROBCOATVG/slipwai
@@ -18,9 +18,11 @@ License-File: assets/toolkit/skills/codebase-design/LICENSE
 License-File: assets/toolkit/skills/diagrams/NOTICE
 License-File: assets/toolkit/skills/event-modeling/NOTICE
 License-File: assets/toolkit/skills/find-skills/LICENSE
+License-File: assets/toolkit/skills/frontend-design/LICENSE
 License-File: assets/toolkit/skills/improve-codebase-architecture/LICENSE
 License-File: assets/toolkit/skills/reduce-system-complexity/LICENSE
 License-File: assets/toolkit/skills/technical-writing/LICENSE
+License-File: assets/toolkit/skills/web-interface-guidelines/LICENSE
 License-File: assets/toolkit/skills/wtf/LICENSE
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -197,8 +199,8 @@ Spec Kit is deliberately absent until you ask for it. From inside the generated
 ```
 
 That installs Spec Kit. It then asks which coding agent to project `skills/`, `commands/` and `agents/`
-into — any of [36 harnesses](docs/spec-kit.md). It then offers optional extensions as a checkbox menu, of
-which CodeGraph is the first.
+into — any of [36 harnesses](docs/spec-kit.md). It then offers optional extensions as a checkbox menu:
+CodeGraph, UI/UX Pro Max and the UX gates.
 
 `--integration <name>` and `--extension <key>` skip those questions. `--extension` also adds one later. See
 [Extensions](docs/extensions.md).
@@ -227,7 +229,7 @@ Everything below is in a generated repository from its first commit.
 | | |
 |---|---|
 | **[The delivery loop](docs/delivery-loop.md)** | `/drive`'s ten-stage ladder on top of Spec Kit. It is resumable, because it reads artifacts rather than conversation memory. Fifteen workflow commands, thirteen of them in `standard`. Story splitting and example mapping are first-class stages with real heuristics behind them. Hooks apply the method even to a session that never typed `/drive` |
-| **[Up to 49 skills](docs/skills.md)** | The part of the delivery catalogue this project can use, owned by the project: TDD, testing, hexagonal architecture, DDD, ubiquitous language, API and BFF design, observability, secure OAuth/OIDC, refactoring, debugging and more. Code examples are rendered in the languages this project's services are actually written in |
+| **[Up to 51 skills](docs/skills.md)** | The part of the delivery catalogue this project can use, owned by the project: TDD, testing, hexagonal architecture, DDD, ubiquitous language, API and BFF design, observability, secure OAuth/OIDC, refactoring, debugging and more. Code examples are rendered in the languages this project's services are actually written in |
 | **[The global event model](docs/event-model.md)** | *Event profile.* One cumulative model for the whole system, in `model.yaml`. `make model` renders the timeline, the per-segment diagrams and a self-contained browsable page. `make check-model` fails when the code and the model disagree |
 | **[The read side](docs/what-you-get.md#the-read-side)** | *Event profile.* The machinery a view is *maintained* with, finished in every backend rather than left as the greenfield half: a unit of work on the event store; a `CheckpointStore` port with memory, SQLite and Postgres adapters behind a contract suite of its own; a catch-up runner that advances the checkpoint inside the view's own transaction; a rebuild; whatever each framework already schedules a pass with; and a tag index derived from the log, so a conditional append can hold a boundary one stream cannot |
 | **[Gates](docs/verification.md)** | `make verify` runs native checks, tests, architecture direction, agent and Spec Kit drift, constitution coverage, and the event model. It is identical locally and in CI, and never needs Docker. Integration, adversarial, mutation and audit checks sit deliberately outside it |
@@ -236,7 +238,7 @@ Everything below is in a generated repository from its first commit.
 | **[Generated documentation](docs/what-you-get.md#documentation-written-for-this-project)** | Thirteen pages written for this project's actual shape rather than copied, and an index built from the files that shipped |
 | **[Services and bounded contexts](docs/services.md)** | One list of applications, each with its own language, framework and answers. `add-service` and `add-frontend` grow it. Contexts are found rather than declared |
 | **[A path to production](docs/aws-target.md)** | `--target aws` or `--target azure` gives you `infra/` in OpenTofu, one deployable per application released blue/green, a pipeline from every push to `main` through staging to production, and a one-command rollback. The same promise on either cloud. [The Azure page](docs/azure-target.md) is where they are compared |
-| **[Extensions](docs/extensions.md)** | Optional dev tooling, adopted with `./init --extension <key>`. CodeGraph is the first. None of them changes the generated skeleton's code |
+| **[Extensions](docs/extensions.md)** | Optional dev tooling, adopted with `./init --extension <key>`: a code index, a design-system generator, and objective UX gates in `make verify`. None of them changes the generated skeleton's code |
 
 ### The commands a project gets
 
@@ -313,7 +315,7 @@ Beyond the profile, each role is a separate question, answered independently:
 | HTTP transport | `--http` | `none`, `fastify`, `fastapi`, `net-http`, `quarkus-rest`, `spring-web` |
 | Staff authentication | `--auth` | `none`, `keycloak` (local only), `cognito` (AWS), `entra` (Azure), `auth0` (either cloud) |
 | Customer authentication | `--users` | `none`, `keycloak` (local only), `cognito` (AWS), `auth0` (either cloud) |
-| Dev tooling | `--extension` | `codegraph` |
+| Dev tooling | `--extension` | `codegraph`, `uipro`, `ux-gates` |
 
 The default is `event-modelling` with `typescript`, the `react-vite` frontend, a Postgres event store, and
 the HTTP transport that backend has.
@@ -352,7 +354,7 @@ is which, what each answer brings, and how a project answers a question again la
 |---|---|
 | [What a generated repository gets for free](docs/what-you-get.md) | The tour: the layout, the generated documentation, the agent harnesses, and how to run it |
 | [The delivery loop](docs/delivery-loop.md) | The `/drive` ladder and the diagram behind it, the fifteen commands, story splitting and example mapping with worked examples, the Spec Kit hooks, the preset layer, and the constitution floor |
-| [The skill catalogue](docs/skills.md) | The 49 skills grouped by what they are for, why a project is given only the ones whose subject it has, how examples are rendered in your own languages, and where to edit them |
+| [The skill catalogue](docs/skills.md) | The 51 skills grouped by what they are for, why a project is given only the ones whose subject it has, how examples are rendered in your own languages, and where to edit them |
 | [The global event model](docs/event-model.md) | Why the model is global, what `make model` renders, the status ladder `make check-model` enforces, and how the browsable page is published |
 | [Gates](docs/verification.md) | What `make verify` runs, what is deliberately outside it, and why the split falls where it does |
 | [Bootstrap Spec Kit](docs/spec-kit.md) | `./init`, the 36 agent integrations, how Spec Kit is obtained, and the constitution floor gated from both sides |

{slipwai-1.1.1.dev4 → slipwai-1.2.0.dev7}/README.md

@@ -170,8 +170,8 @@ Spec Kit is deliberately absent until you ask for it. From inside the generated
 ```
 
 That installs Spec Kit. It then asks which coding agent to project `skills/`, `commands/` and `agents/`
-into — any of [36 harnesses](docs/spec-kit.md). It then offers optional extensions as a checkbox menu, of
-which CodeGraph is the first.
+into — any of [36 harnesses](docs/spec-kit.md). It then offers optional extensions as a checkbox menu:
+CodeGraph, UI/UX Pro Max and the UX gates.
 
 `--integration <name>` and `--extension <key>` skip those questions. `--extension` also adds one later. See
 [Extensions](docs/extensions.md).
@@ -200,7 +200,7 @@ Everything below is in a generated repository from its first commit.
 | | |
 |---|---|
 | **[The delivery loop](docs/delivery-loop.md)** | `/drive`'s ten-stage ladder on top of Spec Kit. It is resumable, because it reads artifacts rather than conversation memory. Fifteen workflow commands, thirteen of them in `standard`. Story splitting and example mapping are first-class stages with real heuristics behind them. Hooks apply the method even to a session that never typed `/drive` |
-| **[Up to 49 skills](docs/skills.md)** | The part of the delivery catalogue this project can use, owned by the project: TDD, testing, hexagonal architecture, DDD, ubiquitous language, API and BFF design, observability, secure OAuth/OIDC, refactoring, debugging and more. Code examples are rendered in the languages this project's services are actually written in |
+| **[Up to 51 skills](docs/skills.md)** | The part of the delivery catalogue this project can use, owned by the project: TDD, testing, hexagonal architecture, DDD, ubiquitous language, API and BFF design, observability, secure OAuth/OIDC, refactoring, debugging and more. Code examples are rendered in the languages this project's services are actually written in |
 | **[The global event model](docs/event-model.md)** | *Event profile.* One cumulative model for the whole system, in `model.yaml`. `make model` renders the timeline, the per-segment diagrams and a self-contained browsable page. `make check-model` fails when the code and the model disagree |
 | **[The read side](docs/what-you-get.md#the-read-side)** | *Event profile.* The machinery a view is *maintained* with, finished in every backend rather than left as the greenfield half: a unit of work on the event store; a `CheckpointStore` port with memory, SQLite and Postgres adapters behind a contract suite of its own; a catch-up runner that advances the checkpoint inside the view's own transaction; a rebuild; whatever each framework already schedules a pass with; and a tag index derived from the log, so a conditional append can hold a boundary one stream cannot |
 | **[Gates](docs/verification.md)** | `make verify` runs native checks, tests, architecture direction, agent and Spec Kit drift, constitution coverage, and the event model. It is identical locally and in CI, and never needs Docker. Integration, adversarial, mutation and audit checks sit deliberately outside it |
@@ -209,7 +209,7 @@ Everything below is in a generated repository from its first commit.
 | **[Generated documentation](docs/what-you-get.md#documentation-written-for-this-project)** | Thirteen pages written for this project's actual shape rather than copied, and an index built from the files that shipped |
 | **[Services and bounded contexts](docs/services.md)** | One list of applications, each with its own language, framework and answers. `add-service` and `add-frontend` grow it. Contexts are found rather than declared |
 | **[A path to production](docs/aws-target.md)** | `--target aws` or `--target azure` gives you `infra/` in OpenTofu, one deployable per application released blue/green, a pipeline from every push to `main` through staging to production, and a one-command rollback. The same promise on either cloud. [The Azure page](docs/azure-target.md) is where they are compared |
-| **[Extensions](docs/extensions.md)** | Optional dev tooling, adopted with `./init --extension <key>`. CodeGraph is the first. None of them changes the generated skeleton's code |
+| **[Extensions](docs/extensions.md)** | Optional dev tooling, adopted with `./init --extension <key>`: a code index, a design-system generator, and objective UX gates in `make verify`. None of them changes the generated skeleton's code |
 
 ### The commands a project gets
 
@@ -286,7 +286,7 @@ Beyond the profile, each role is a separate question, answered independently:
 | HTTP transport | `--http` | `none`, `fastify`, `fastapi`, `net-http`, `quarkus-rest`, `spring-web` |
 | Staff authentication | `--auth` | `none`, `keycloak` (local only), `cognito` (AWS), `entra` (Azure), `auth0` (either cloud) |
 | Customer authentication | `--users` | `none`, `keycloak` (local only), `cognito` (AWS), `auth0` (either cloud) |
-| Dev tooling | `--extension` | `codegraph` |
+| Dev tooling | `--extension` | `codegraph`, `uipro`, `ux-gates` |
 
 The default is `event-modelling` with `typescript`, the `react-vite` frontend, a Postgres event store, and
 the HTTP transport that backend has.
@@ -325,7 +325,7 @@ is which, what each answer brings, and how a project answers a question again la
 |---|---|
 | [What a generated repository gets for free](docs/what-you-get.md) | The tour: the layout, the generated documentation, the agent harnesses, and how to run it |
 | [The delivery loop](docs/delivery-loop.md) | The `/drive` ladder and the diagram behind it, the fifteen commands, story splitting and example mapping with worked examples, the Spec Kit hooks, the preset layer, and the constitution floor |
-| [The skill catalogue](docs/skills.md) | The 49 skills grouped by what they are for, why a project is given only the ones whose subject it has, how examples are rendered in your own languages, and where to edit them |
+| [The skill catalogue](docs/skills.md) | The 51 skills grouped by what they are for, why a project is given only the ones whose subject it has, how examples are rendered in your own languages, and where to edit them |
 | [The global event model](docs/event-model.md) | Why the model is global, what `make model` renders, the status ladder `make check-model` enforces, and how the browsable page is published |
 | [Gates](docs/verification.md) | What `make verify` runs, what is deliberately outside it, and why the split falls where it does |
 | [Bootstrap Spec Kit](docs/spec-kit.md) | `./init`, the 36 agent integrations, how Spec Kit is obtained, and the constitution floor gated from both sides |

slipwai-1.2.0.dev7/VERSION

@@ -0,0 +1 @@
+1.2.0.dev7

{slipwai-1.1.1.dev4 → slipwai-1.2.0.dev7}/assets/frontends/react-vite/app/src/styles/base.css

@@ -144,8 +144,8 @@ a {
 }
 
 :focus-visible {
-  outline: 2px solid var(--colour-accent);
-  outline-offset: 2px;
+  outline: var(--focus-ring);
+  outline-offset: var(--focus-ring-offset);
 }
 
 button,

{slipwai-1.1.1.dev4 → slipwai-1.2.0.dev7}/assets/frontends/react-vite/app/src/styles/tokens.css

@@ -53,6 +53,9 @@
   --radius-large: 10px;
   --border: 1px solid var(--colour-border);
   --shadow: 0 1px 2px rgb(22 25 29 / 8%);
+  /* The one ring every focusable element shows: a token so no rule below carries a literal width. */
+  --focus-ring: 2px solid var(--colour-accent);
+  --focus-ring-offset: 2px;
 
   /* The reading column. Wider than this and prose stops being readable. */
   --measure: 68ch;

slipwai-1.2.0.dev7/assets/toolkit/scripts/check-ux-gates.py

@@ -0,0 +1,168 @@
+#!/usr/bin/env python3
+"""Run the adopted UX gates over every browser app, and fail when one of them does.
+
+The gates are plugin87's ux-ui-agent-skills kit, installed under `tools/ux-gates/` by `./init --extension
+ux-gates`. Two kinds run here. The file gate always: `lint_hardcodes.py` over each browser app's `src/`,
+which fails on a literal colour, pixel size or duration that is not a token — the rule `docs/design.md`
+states, measured. The render gates when they can: over every `*.html` under each browser app's `screens/`,
+in a real headless browser, contrast in light and dark across default, hover and focus, visible focus,
+target size, overflow at phone widths, and axe. The kit's own scripts skip with a line when Playwright is
+not resolvable, and this gate reports that as skipped, never as passed.
+
+Three states are not failures, and each is said out loud. Not adopted: the extension is optional, and a
+project that never asked for it has nothing to run. Adopted but not installed here: `tools/ux-gates/` is
+ignored by Git, so a fresh clone or a CI runner has the election and not the kit — reported as skipped,
+or as a failure when `UX_GATES_REQUIRE=1`, which is what to set wherever the kit is expected. No browser
+app: nothing to measure.
+
+Standard library only, like every gate script here; the kit's scripts are run as subprocesses.
+"""
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+KEY = "ux-gates"
+KIT = "tools/ux-gates"
+# Directory-wide render gates, then per-file ones; each with the flags that make light and dark both count.
+DIRECTORY_GATES = (
+    ("verify_responsive.mjs", ()),
+    ("verify_target_size.mjs", ()),
+    ("measure_render.mjs", ()),
+    ("measure_render.mjs", ("--dark",)),
+)
+FILE_GATES = (
+    ("axe_audit.mjs", ()),
+    ("axe_audit.mjs", ("--dark",)),
+    ("verify_states.mjs", ()),
+    ("verify_states.mjs", ("--dark",)),
+)
+
+
+def project_root(script: Path, depth: int) -> Path:
+    """The nearest parent holding `project.json`, with a source-tree fallback."""
+    for candidate in script.parents:
+        if (candidate / "project.json").is_file():
+            return candidate
+    return script.parents[depth]
+
+
+ROOT = project_root(Path(__file__).resolve(), 1)
+
+
+def adopted() -> bool:
+    """Elected in the committed record, or marked in `AGENTS.md` by a project older than the record."""
+    record = ROOT / ".slipwai/extensions.json"
+    if record.is_file():
+        try:
+            document = json.loads(record.read_text())
+        except ValueError:
+            document = {}
+        if KEY in (document.get("extensions") or []):
+            return True
+    agents = ROOT / "AGENTS.md"
+    return agents.is_file() and f"<!-- extension:{KEY}:begin -->" in agents.read_text()
+
+
+def browser_apps() -> list[Path]:
+    manifest = ROOT / "project.json"
+    if not manifest.is_file():
+        return []
+    deployables = json.loads(manifest.read_text()).get("deployables")
+    if not isinstance(deployables, dict):
+        return []
+    return [
+        ROOT / str(deployable["path"])
+        for deployable in deployables.values()
+        if isinstance(deployable, dict)
+        and "frontend" in deployable.get("capabilities", [])
+        and (ROOT / str(deployable.get("path", ""))).is_dir()
+    ]
+
+
+def say(line: str) -> None:
+    """Flushed, so this script's lines land in order with the kit's, which write straight to the terminal."""
+    print(line, flush=True)
+
+
+def run(script: str, *arguments: str) -> tuple[int, bool]:
+    """One kit script, from the kit's own directory so its relative imports resolve. Its output is passed
+    through, and read for the one word the kit uses when a gate could not open a browser: a skipped gate
+    exits 0 upstream, and this script refuses to count that as a pass."""
+    kit = ROOT / KIT
+    interpreter = [sys.executable] if script.endswith(".py") else ["node"]
+    environment = dict(os.environ)
+    if environment.get("UX_GATES_REQUIRE") == "1":
+        environment["DS_REQUIRE_BROWSER"] = "1"  # the kit's own switch for the same demand
+    completed = subprocess.run(
+        [*interpreter, str(kit / "scripts" / script), *arguments],
+        cwd=kit, env=environment, check=False, text=True, capture_output=True,
+    )
+    sys.stdout.write(completed.stdout)
+    sys.stderr.write(completed.stderr)
+    sys.stdout.flush()
+    return completed.returncode, "SKIPPED" in completed.stdout
+
+
+def main() -> int:
+    if not adopted():
+        say("check-ux-gates: not adopted (./init --extension ux-gates); nothing to check")
+        return 0
+    kit = ROOT / KIT
+    required = os.environ.get("UX_GATES_REQUIRE") == "1"
+    if not (kit / "scripts/lint_hardcodes.py").is_file():
+        say(
+            f"check-ux-gates: adopted, but {KIT}/ is not installed in this checkout — "
+            + ("REQUIRED, FAILING" if required else "SKIPPED, not passed")
+            + "; `./init --extension ux-gates` installs it"
+        )
+        return 1 if required else 0
+    apps = browser_apps()
+    if not apps:
+        say("check-ux-gates: no browser app to measure")
+        return 0
+    failures: list[str] = []
+    skipped = 0
+    for app in apps:
+        relative = app.relative_to(ROOT).as_posix()
+        source = app / "src"
+        if source.is_dir():
+            say(f"check-ux-gates: {relative}/src — literal values outside the tokens")
+            if run("lint_hardcodes.py", str(source))[0] != 0:
+                failures.append(f"{relative}/src carries literal values the tokens should own")
+        screens = sorted((app / "screens").glob("*.html")) if (app / "screens").is_dir() else []
+        if not screens:
+            say(f"check-ux-gates: {relative}/screens/ has no previews; the render gates have nothing to open")
+            continue
+        if shutil.which("node") is None:
+            say(f"check-ux-gates: {relative}/screens/ — node not found, render gates SKIPPED, not passed")
+            skipped += len(DIRECTORY_GATES) + len(FILE_GATES) * len(screens)
+            continue
+        say(f"check-ux-gates: {relative}/screens/ — {len(screens)} preview(s) through the render gates")
+        gates = [(script, flags, str(app / "screens")) for script, flags in DIRECTORY_GATES]
+        gates += [(script, flags, str(screen)) for screen in screens for script, flags in FILE_GATES]
+        for script, flags, target in gates:
+            status, was_skipped = run(script, target, *flags)
+            if status != 0:
+                failures.append(f"{Path(target).relative_to(ROOT).as_posix()}: {script} {' '.join(flags)}".rstrip())
+            elif was_skipped:
+                skipped += 1
+    if failures:
+        say("check-ux-gates: FAILED\n  - " + "\n  - ".join(failures))
+        return 1
+    if skipped:
+        say(
+            f"check-ux-gates: passed where a gate could run; {skipped} render gate(s) SKIPPED, not passed — "
+            "Playwright and a browser are not resolvable from the project root"
+        )
+        return 1 if required else 0
+    say("check-ux-gates: every gate passed")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

slipwai-1.2.0.dev7/assets/toolkit/scripts/extensions/uipro/init.py

@@ -0,0 +1,209 @@
+#!/usr/bin/env python3
+"""`./init --extension uipro`: install the ui-ux-pro-max skill into `skills/`, and point the agent at it.
+
+UI/UX Pro Max (https://github.com/nextlevelbuilder/ui-ux-pro-max-skill) is a design-system generator that
+runs offline: a Python search over local CSV data — styles, palettes, type pairings, chart types, UX rules
+and stack notes keyed by product type — that answers "what should this product's screens look like" with
+a coherent system rather than a guess. It ships as a skill with its own installer, and the installer's
+job is to write fifteen per-harness copies; this script asks it for the one harness-neutral copy instead,
+and puts that in the project's root `skills/`, which is the canonical catalogue `make agents` projects into
+every harness and `check-agents` holds the projections to. The copy is ignored by Git (see `ignore` in
+`catalog.json`): it is an installed tool, pinned by the CLI version below and reproducible from this one
+command, not source this project maintains — the same footing as CodeGraph's index.
+
+Only the `ui-ux-pro-max` skill is taken. The installer also writes `ui-styling` (Tailwind and shadcn, which
+the generated browser app deliberately does not use), `design-system`, `design`, `brand`, `banner-design`
+and `slides`, none of which is about a delivery project's screens.
+
+A project with no browser app has nothing for it to design, so it is refused politely with the command
+that would change that. Never fails `./init`: a missing CLI, a failed install or an unexpected layout is
+reported, not fatal. See docs/extensions.md for what every extension's `init.py` owes.
+"""
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+sys.dont_write_bytecode = True
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+from guidance import record_extension, replace_block  # noqa: E402
+
+CLI_VERSION = "2.15.0"
+SKILL = "ui-ux-pro-max"
+INSTALLED_AT = ".agents/skills"  # where `uipro init --ai universal` writes, and the path its text names
+
+
+def project_root(script: Path, depth: int) -> Path:
+    """The repository root: the nearest directory above this script holding `project.json`."""
+    for candidate in script.parents:
+        if (candidate / "project.json").is_file():
+            return candidate
+    return script.parents[depth]
+
+
+ROOT = project_root(Path(__file__).resolve(), 3)
+MARKER_BEGIN = "<!-- extension:uipro:begin -->"
+MARKER_END = "<!-- extension:uipro:end -->"
+GUIDANCE = f"""
+{MARKER_BEGIN}
+## UI/UX Pro Max
+`skills/{SKILL}/` is a design-system generator that runs offline: a search over local data that answers
+which pattern, style, palette, type pairing, chart types and UX rules fit a product of this kind. Reach for
+it **before the first screen of a slice that `docs/design.md` has no decision for**, and for one focused
+question — a component, a chart, a stack rule — with a single `--domain` or `--stack` search. Read the
+skill's own `SKILL.md` for the query contract; the short form is:
+
+    python3 skills/{SKILL}/scripts/search.py "<product type> <industry> <keywords>" --design-system \\
+        -p "<project name>" --persist --output-dir .
+
+`--persist` writes `design-system/<slug>/MASTER.md`. **Commit it.** It is the evidence the decision was
+made from, and the input the browser app's `tokens.css` is filled from — but it is not the decision.
+`docs/design.md` stays the page every slice with a screen reads first: write what was chosen and why
+there, in the same commit as the tokens, link the `MASTER.md` it came from, and where the two disagree the
+page wins. Then take the plan through `skills/frontend-design`'s second pass — the review against the
+brief for defaults that would appear whatever the product — before writing any code.
+
+**Check you can reach it before you trust it.** The search is standard-library Python 3 and travels with
+the skill, so the only two ways it is unreachable are a checkout without the skill and a machine without
+Python. `skills/{SKILL}/` is ignored by Git and installed by this extension, so a fresh clone, a
+container or a CI runner has the pointer and not the tool: when `skills/{SKILL}/scripts/search.py` is
+absent, or `command -v python3` fails, say so in as many words ("the extension is adopted here, the skill
+is not installed, so this is a decision from `docs/design.md` and `skills/frontend-design` alone") and work
+as a project without it would. Restore it with `./init --extension uipro`, which reinstalls the pinned
+version. Say which route you used when you report a design decision.
+
+**A sub-agent does not inherit this session's checks.** A fresh delegate looks for the script itself
+before it claims to have searched, and says the skill is unavailable rather than inventing a palette.
+{MARKER_END}
+"""
+
+
+def browser_apps() -> list[str]:
+    """The deployables that declare a `frontend` capability and are still here."""
+    manifest = ROOT / "project.json"
+    if not manifest.is_file():
+        return []
+    deployables = json.loads(manifest.read_text()).get("deployables")
+    if not isinstance(deployables, dict):
+        return []
+    return [
+        str(deployable.get("path"))
+        for deployable in deployables.values()
+        if isinstance(deployable, dict)
+        and "frontend" in deployable.get("capabilities", [])
+        and (ROOT / str(deployable.get("path", ""))).is_dir()
+    ]
+
+
+def installer() -> list[str] | None:
+    """The installed CLI when there is one, otherwise the pinned package through `npx`, otherwise nothing."""
+    if shutil.which("uipro") is not None:
+        return ["uipro"]
+    if shutil.which("npx") is not None:
+        return ["npx", "-y", f"ui-ux-pro-max-cli@{CLI_VERSION}"]
+    return None
+
+
+def relocated(text: str) -> str:
+    """The skill's own text names the path its installer wrote it to; here it lives at the root."""
+    return text.replace(f"{INSTALLED_AT}/{SKILL}", f"skills/{SKILL}")
+
+
+def with_capability(skill_md: str) -> str:
+    """Declare `capabilities: frontend`, so `check-agents` names the skill if the browser app ever goes."""
+    if not skill_md.startswith("---\n"):
+        return skill_md
+    front, separator, rest = skill_md[4:].partition("\n---\n")
+    if not separator or "\ncapabilities:" in f"\n{front}":
+        return skill_md
+    return f"---\n{front}\ncapabilities: frontend\n---\n{rest}"
+
+
+def install(source: Path, destination: Path) -> None:
+    if destination.exists():
+        shutil.rmtree(destination)
+    shutil.copytree(source, destination)
+    for page in destination.rglob("*.md"):
+        page.write_text(relocated(page.read_text()))
+    skill_md = destination / "SKILL.md"
+    skill_md.write_text(with_capability(skill_md.read_text()))
+
+
+def reproject() -> None:
+    """`./init` projected `skills/` before this ran; the new skill has to reach the harness too.
+
+    `./init` names the harness it chose in `SLIPWAI_INTEGRATION`; run by hand later, the projector reads
+    the one Spec Kit recorded. Either way a failure is reported by the projector and `make agents` retries.
+    """
+    projector = ROOT / "scripts/agents/project.py"
+    if not projector.is_file():
+        return
+    chosen = os.environ.get("SLIPWAI_INTEGRATION", "")
+    subprocess.run([sys.executable, str(projector), *([chosen] if chosen else [])], cwd=ROOT, check=False)
+
+
+def project_guidance() -> None:
+    """Record this election and make its factory-owned guidance region current."""
+    record_extension("uipro")
+    replace_block("uipro", GUIDANCE)
+
+
+def main() -> int:
+    if not browser_apps():
+        print(
+            "UI/UX Pro Max designs screens, and this project has no browser app for it to design: nothing "
+            "was installed and AGENTS.md is unchanged.\n"
+            "Add one first, then adopt it here:\n"
+            "  slipwai add-frontend web\n"
+            "  ./init --extension uipro",
+            file=sys.stderr,
+        )
+        return 0
+    command = installer()
+    if command is None:
+        print(
+            "Neither the `uipro` CLI nor `npx` was found: nothing was installed and AGENTS.md is unchanged.\n"
+            "Install one:\n"
+            f"  npm install -g ui-ux-pro-max-cli@{CLI_VERSION}\n"
+            "Then adopt it here, which is what points the agent at it:\n"
+            "  ./init --extension uipro",
+            file=sys.stderr,
+        )
+        return 0
+    with tempfile.TemporaryDirectory() as staging:
+        # `check=False`: an extension may not fail `./init` (docs/extensions.md), and a raised error here
+        # would also skip the pointer below, leaving the half-adopted state this script exists to avoid.
+        installed = subprocess.run([*command, "init", "--ai", "universal", "--force"], cwd=staging, check=False)
+        if installed.returncode != 0:
+            print(
+                f"`{' '.join(command)} init` exited {installed.returncode}: AGENTS.md is unchanged.\n"
+                "Fix what it reported, then adopt it here:\n"
+                "  ./init --extension uipro",
+                file=sys.stderr,
+            )
+            return 0
+        source = Path(staging) / INSTALLED_AT / SKILL
+        if not (source / "SKILL.md").is_file():
+            print(
+                f"The installer did not write {INSTALLED_AT}/{SKILL}/SKILL.md, so nothing was copied and "
+                "AGENTS.md is unchanged.\n"
+                f"This script knows ui-ux-pro-max-cli {CLI_VERSION}; a newer CLI may lay its files out "
+                "differently. Pin the version, or update this script, then:\n"
+                "  ./init --extension uipro",
+                file=sys.stderr,
+            )
+            return 0
+        install(source, ROOT / "skills" / SKILL)
+    project_guidance()
+    reproject()
+    print(f"UI/UX Pro Max installed at skills/{SKILL}/ (ignored by Git; `./init --extension uipro` reinstalls it).")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())