slipwai 1.3.0.dev32__tar.gz → 1.3.0.dev44__tar.gz

{slipwai-1.3.0.dev32 → slipwai-1.3.0.dev44}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: slipwai
-Version: 1.3.0.dev32
+Version: 1.3.0.dev44
 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
@@ -134,7 +134,8 @@ Four steps. You install a `slipwai` command and run it. You do not clone this re
 
 New here? Use the [generate learning path](docs/learn-generate.md), or
 [adopt](docs/learn-adopt.md) for an existing tree. Both cover install, first session, upgrade, migrate and
-`/catch-up`, with terminal screenshots.
+`/catch-up`, with terminal screenshots. The runsheets — [new project](docs/runsheet-greenfield.md) and
+[existing repository](docs/runsheet-brownfield.md) — are the same journeys as one ordered list of commands.
 
 [Scaffold a new project](docs/generating.md) is the full reference.
 [Tools required](docs/requirements.md) lists what each toolchain and `make` target needs.
@@ -428,9 +429,11 @@ is which, what each answer brings, and how a project answers a question again la
 |---|---|
 | [Generate a new project — learning path](docs/learn-generate.md) | Install, generate, upgrade, migrate and `/catch-up`, with terminal screenshots |
 | [Adopt an existing repository — learning path](docs/learn-adopt.md) — **experimental** | Install, adopt, upgrade, migrate and `/catch-up`, with terminal screenshots |
+| [Runsheet: a new project](docs/runsheet-greenfield.md) | Every command in order, from `slipwai generate` to `/cruise`, and the three steps that keep the project in tune with each slipwai release |
+| [Runsheet: an existing repository](docs/runsheet-brownfield.md) — **experimental** | Every command in order, from `slipwai adopt` through `/ground` to `/cruise`, how to revisit an answer, and how to take each slipwai release |
 | [Scaffold a new project](docs/generating.md) | The interactive and argument forms, one-shot semantics, the generated repository layout, and the event-sourcing boundary between the services and `apps/web` |
 | [Bring a generated project forward](docs/upgrading.md) | `slipwai migrate`: a newer factory's output merged over a project already generated. What comes through clean, what conflicts and should, the catch-up notes it leaves for what a merge cannot do, and the gate that proves it |
-| [Adopt an existing repository](docs/adopting.md) — **experimental** | `slipwai adopt`: the method installed around a repository the factory did not make. The survey, the questions with the findings as defaults, what is written beside the code and never over it, what `project.json` records with provenance, and what it forfeits for a language the factory cannot generate |
+| [Adopt an existing repository](docs/adopting.md) — **experimental** | `slipwai adopt`: the method installed around a repository the factory did not make. The survey, the candidates `/ground` confirms, what is written beside the code and never over it, what `project.json` records with provenance, and what it forfeits for a language the factory cannot generate |
 | [The two workflows](docs/two-workflows.md) | Generated and adopted side by side: the same delivery loop, where each starts on its ladders, the adoption phases woven into `/drive`, the convergence map, and `slipwai converge` as the point where the distinction ends |
 | [Project shape](docs/axes.md) | Profiles, target, language, frontend and the axes. What each answer brings, why an unimplementable combination is refused, and how a project answers an axis again later |
 | [Tools required](docs/requirements.md) | What scaffolding needs, and what each generated toolchain and `make` target needs |

{slipwai-1.3.0.dev32 → slipwai-1.3.0.dev44}/README.md

@@ -105,7 +105,8 @@ Four steps. You install a `slipwai` command and run it. You do not clone this re
 
 New here? Use the [generate learning path](docs/learn-generate.md), or
 [adopt](docs/learn-adopt.md) for an existing tree. Both cover install, first session, upgrade, migrate and
-`/catch-up`, with terminal screenshots.
+`/catch-up`, with terminal screenshots. The runsheets — [new project](docs/runsheet-greenfield.md) and
+[existing repository](docs/runsheet-brownfield.md) — are the same journeys as one ordered list of commands.
 
 [Scaffold a new project](docs/generating.md) is the full reference.
 [Tools required](docs/requirements.md) lists what each toolchain and `make` target needs.
@@ -399,9 +400,11 @@ is which, what each answer brings, and how a project answers a question again la
 |---|---|
 | [Generate a new project — learning path](docs/learn-generate.md) | Install, generate, upgrade, migrate and `/catch-up`, with terminal screenshots |
 | [Adopt an existing repository — learning path](docs/learn-adopt.md) — **experimental** | Install, adopt, upgrade, migrate and `/catch-up`, with terminal screenshots |
+| [Runsheet: a new project](docs/runsheet-greenfield.md) | Every command in order, from `slipwai generate` to `/cruise`, and the three steps that keep the project in tune with each slipwai release |
+| [Runsheet: an existing repository](docs/runsheet-brownfield.md) — **experimental** | Every command in order, from `slipwai adopt` through `/ground` to `/cruise`, how to revisit an answer, and how to take each slipwai release |
 | [Scaffold a new project](docs/generating.md) | The interactive and argument forms, one-shot semantics, the generated repository layout, and the event-sourcing boundary between the services and `apps/web` |
 | [Bring a generated project forward](docs/upgrading.md) | `slipwai migrate`: a newer factory's output merged over a project already generated. What comes through clean, what conflicts and should, the catch-up notes it leaves for what a merge cannot do, and the gate that proves it |
-| [Adopt an existing repository](docs/adopting.md) — **experimental** | `slipwai adopt`: the method installed around a repository the factory did not make. The survey, the questions with the findings as defaults, what is written beside the code and never over it, what `project.json` records with provenance, and what it forfeits for a language the factory cannot generate |
+| [Adopt an existing repository](docs/adopting.md) — **experimental** | `slipwai adopt`: the method installed around a repository the factory did not make. The survey, the candidates `/ground` confirms, what is written beside the code and never over it, what `project.json` records with provenance, and what it forfeits for a language the factory cannot generate |
 | [The two workflows](docs/two-workflows.md) | Generated and adopted side by side: the same delivery loop, where each starts on its ladders, the adoption phases woven into `/drive`, the convergence map, and `slipwai converge` as the point where the distinction ends |
 | [Project shape](docs/axes.md) | Profiles, target, language, frontend and the axes. What each answer brings, why an unimplementable combination is refused, and how a project answers an axis again later |
 | [Tools required](docs/requirements.md) | What scaffolding needs, and what each generated toolchain and `make` target needs |

slipwai-1.3.0.dev44/VERSION

@@ -0,0 +1 @@
+1.3.0.dev44

{slipwai-1.3.0.dev32 → slipwai-1.3.0.dev44}/assets/profiles/event-modelling/.specify/presets/event-modelling/templates/tasks-template.md

@@ -144,7 +144,7 @@ task whose GREEN would be empty — a proof over behaviour an earlier task built
 folds into the task that produces the behaviour it guards.
 
 - [ ] T033 [US1] **Happy path.** RED: boundary acceptance for the happy path, entering through the use case, asserting on what is observable there. The route gets its own `tests/edge/` test for parse, delegate, and outcome-to-status — it is a translation, not where the rule is proved. GREEN: the minimum that satisfies it — the event schema(s) this one scenario needs, `initialState` and `evolve`, `decide` for the one command, the driving port returning discriminated outcomes, the use case (load, fold, decide, append with expected version), the route handler, and the composition wiring
-- [ ] T034 [US1] **The white box, in its main state.** *Delete these three tasks only if this slice has no `ui` frame — which for a `state-change` or `state-view` slice means the model is wrong, not that there is no screen.* RED: a test at the project's UI level drives the surface the way its actor does — type into the labelled fields, click the button — and asserts what the actor sees. GREEN: the screen. **If the `ui` frame has `mockups`, that state's mock is the build target**; open it and build to it. **If it has none, design it here** — then commit the wireframe under `docs/event-model/mockups/` and add its `mockups` entry to the frame in the same commit, because a screen whose states are recorded nowhere is a screen whose gaps nobody can see. An HTTP test through the route is **not** evidence about this task; load `front-end-testing` (and `react-testing` if the project is React) for the lightest harness that proves a browser-observable claim
+- [ ] T034 [US1] **The white box, in its main state.** *Delete these three tasks only if this slice has no `ui` frame — which for a `state-change` or `state-view` slice means the model is wrong, not that there is no screen.* RED: a test at the project's UI level drives the surface the way its actor does — type into the labelled fields, click the button — and asserts what the actor sees. GREEN: the screen. **If the `ui` frame has `mockups`, that state's mock is the build target**; open it and build to it. **If it has none, design it here** — then commit the wireframe under `docs/event-model/mockups/` and add its `mockups` entry to the frame in the same commit, because a screen whose states are recorded nowhere is a screen whose gaps nobody can see. An HTTP test through the route is **not** evidence about this task; load `front-end-testing` (and `react-testing` if the project is React) for the lightest harness that proves a browser-observable claim. **Its design is part of this task, not a follow-on**: before the first RED, `/drive`'s *Screen design* rung — `docs/design.md`, then `skills/frontend-design`'s second pass over the plan; before the demo, its *Design review* rung — the rendered screen, screenshot per state, read against `skills/web-interface-guidelines` — each with whatever an extension block in `AGENTS.md` adds to that rung. A green gate is not the review. Both write their line under `## Design review` below
 - [ ] T035 [US1] **Every other state of the screen.** One increment per state — empty, error, submitting, forbidden, whatever the screen can actually be in. RED at the UI level per state, GREEN the rendering it needs. These are where the unmodelled states surface: a screen with one design has three states nobody decided. Each one ends up in `mockups` too, so the model carries what the screen can be rather than what somebody remembered to draw
 - [ ] T036 [US1] **The screen reaches the command.** RED: submitting drives the driving adapter with the actor's input and renders each outcome the use case can return — accepted, business rejection, schema failure. GREEN: the wiring. **If the path beneath the screen is not finished in this slice, the screen still ships** — its submit reaches whatever exists and its states are still built and tested. A white box deferred to a later slice makes this slice a layer, and Principle V's slice independence is about seeding from synthetic events, never about leaving the actor with nothing to use
 - [ ] T037 [US1] **First business rejection.** RED: one rejection at the boundary, with its reason and any detail the caller needs to explain it. GREEN: extend `decide` to reject in business vocabulary. **Each further rejection is its own increment** — repeat this cycle per rule, do not add them as a batch
@@ -174,6 +174,13 @@ not delay feedback on working behaviour.
 
 ---
 
+## Design review
+
+*Written by `/drive`, not by hand: a `Designed:` line per screen before its first RED, a `Reviewed:` line per
+screen before the demo — or `No screen in this slice`. A screen missing either line is not ready to show.*
+
+---
+
 ## Phase 4: Polish
 
 - [ ] Run `/adversary` and record the full attempt log; fix every confirmed violation of an existing

{slipwai-1.3.0.dev32 → slipwai-1.3.0.dev44}/assets/toolkit/scripts/agents/code_index.py

@@ -26,7 +26,8 @@ still editing: after each delegate returns rather than on CodeGraph's watcher, b
 the route that answers instead. A symbol is a name the index holds a definition for, or a name shaped like one
 (camelCase, PascalCase with a second hump, snake_case). Words and phrases are prose, and a search confined to
 documents is text search, which is right for them: `spec.md`, `decisions.md`, the PRD, `model.yaml`, a test's string.
-Once the agent has asked the index, its greps are its own business.
+Once the agent has asked the index, its greps are its own business, and a search of another checkout — where the
+hook's `cwd`, a Grep `path` or a `cd` puts it outside this repository — is never this index's to answer.
 
 Every route here runs the version the MCP server runs (`CODEGRAPH`), so two versions never write one database.
 Standard library only, like every script the toolkit ships. Nothing here fails a command it hooks: a hook that
@@ -319,11 +320,17 @@ def commands_of(command: str) -> list[list[list[str]]]:
     return [[words for words in pipeline if words] for pipeline in pipelines if any(pipeline)]
 
 
-def shell_searches(command: str) -> list[tuple[str, list[str], list[str]]]:
-    """Each search the command runs over files: its pattern, the paths it names and its include patterns. A search
-    reading another command's output — `git ls-files | grep Cue` — is over names, not source, and is not one."""
+def shell_searches(command: str) -> list[tuple[str, list[str], list[str], str]]:
+    """Each search the command runs over files: its pattern, the paths it names, its include patterns and the
+    directory it runs in — `.` until a `cd` moves it. A search reading another command's output — `git ls-files |
+    grep Cue` — is over names, not source, and is not one."""
     found = []
+    where = "."
     for pipeline in commands_of(command):
+        first = pipeline[0] if pipeline else []
+        if len(first) == 2 and first[0] in ("cd", "pushd"):
+            where = str(Path(where) / os.path.expandvars(os.path.expanduser(first[1])))
+            continue
         for position, words in enumerate(pipeline):
             while words and "=" in words[0] and not words[0].startswith("-"):
                 words = words[1:]
@@ -336,7 +343,7 @@ def shell_searches(command: str) -> list[tuple[str, list[str], list[str]]]:
                 scripts = [word for word in words[1:] if not word.startswith("-")]
                 address = re.match(r"^/((?:\\.|[^/])+)/", scripts[0]) if scripts else None
                 if address:
-                    found.append((address.group(1), scripts[1:], []))
+                    found.append((address.group(1), scripts[1:], [], where))
                 continue
             if program not in SEARCHERS:
                 continue
@@ -360,20 +367,37 @@ def shell_searches(command: str) -> list[tuple[str, list[str], list[str]]]:
                     paths.append(word)
                 index += 1
             if pattern is not None and (paths or position == 0):
-                found.append((pattern, paths, globs))
+                found.append((pattern, paths, globs, where))
     return found
 
 
-def symbol_search(tool: str, given: dict[str, Any]) -> str | None:
-    """The symbol a tool call searches the source for, or None where it searches documents, words, or nothing."""
+def outside(cwd: str | None, where: str, paths: list[str]) -> bool:
+    """Whether a search runs wholly outside this repository, so this index is not the one that could answer it.
+    A session opened here can search another checkout — `cd ~/other && grep -rn version src` — and a name this
+    repository happens to define is no reason to hold that search to an index of code it does not read."""
+    base = Path(cwd) if cwd else ROOT
+    targets = [base / where / os.path.expanduser(path) for path in paths] or [base / where]
+    try:
+        root = ROOT.resolve()
+        return all(not target.resolve().is_relative_to(root) for target in targets)
+    except (OSError, ValueError):
+        return False
+
+
+def symbol_search(tool: str, given: dict[str, Any], cwd: str | None = None) -> str | None:
+    """The symbol a tool call searches this repository's source for, or None where it searches documents, words,
+    nothing, or another directory than this repository. `cwd` is where the call runs, as the hook's event says."""
     if tool == "Grep":
         glob = given.get("glob") or (f"*.{given['type']}" if given.get("type") else "")
-        if documents_only([str(given.get("path") or "")], [str(glob)]):
+        path = str(given.get("path") or "")
+        if documents_only([path], [str(glob)]) or outside(cwd, ".", [path] if path else []):
             return None
         return symbol_of(str(given.get("pattern", "")))
     if tool == "Bash":
-        for pattern, paths, globs in shell_searches(str(given.get("command", ""))):
-            if not documents_only(paths, globs) and (symbol := symbol_of(pattern)):
+        for pattern, paths, globs, where in shell_searches(str(given.get("command", ""))):
+            if documents_only(paths, globs) or outside(cwd, where, paths):
+                continue
+            if symbol := symbol_of(pattern):
                 return symbol
     return None
 
@@ -424,7 +448,7 @@ def guard() -> int:
         return 0
     if who in asked:
         return 0
-    symbol = symbol_search(tool, given)
+    symbol = symbol_search(tool, given, str(happened.get("cwd") or "") or None)
     if symbol is None:
         return 0
     first = symbol.split("|")[0]

{slipwai-1.3.0.dev32 → slipwai-1.3.0.dev44}/assets/toolkit/scripts/agents/project.py

@@ -489,10 +489,16 @@ def hook_file(harness: dict[str, object]) -> tuple[Path, dict[str, object]] | No
     if not isinstance(projection, dict):
         return None
     path = ROOT / str(projection["where"])
-    script = f"python3 {PREFIX}scripts/agents/cruise.py"
+    # From the repository root, whatever directory the harness runs its hooks in: the script's path is the
+    # root's, and a session opened in a subdirectory ran it against a path that is not there — the hook failed
+    # silently rather than holding the turn. Claude Code's are written from `$CLAUDE_PROJECT_DIR`; a harness has
+    # no such variable in common, and Git does, so the command asks it. Spliced into the registry's JSON entry
+    # already escaped, since the quotes it carries would otherwise end the string they are put into.
+    script = f'cd "$(git rev-parse --show-toplevel)" && python3 {PREFIX}scripts/agents/cruise.py'
     events: dict[str, object] = {}
     for verb, event in dict(projection["events"]).items():  # type: ignore[call-overload]
-        entry = json.loads(json.dumps(projection["entry"]).replace("{command}", f"{script} {verb}"))
+        command = json.dumps(f"{script} {verb}")[1:-1]
+        entry = json.loads(json.dumps(projection["entry"]).replace("{command}", command))
         if verb == "stopping":
             entry.update(dict(projection.get("stopEntry") or {}))  # type: ignore[call-overload]
         events[str(event)] = [entry]

{slipwai-1.3.0.dev32 → slipwai-1.3.0.dev44}/assets/toolkit/scripts/extensions/codegraph/init.py

@@ -44,6 +44,13 @@ def project_root(script: Path, depth: int) -> Path:
 
 
 ROOT = project_root(Path(__file__).resolve(), 3)
+
+# Where `./init` actually is, from the repository root: beside this script's own tree at the root in a
+# generated project, and under `layout.delivery` where the method was installed beside an existing codebase.
+# Derived rather than written, because "run `./init --extension …`" is advice nobody can follow when the
+# file is `./delivery/init` — the first real adoption to meet it typed `./init` four times.
+DELIVERY = Path(__file__).resolve().parents[3]
+INIT = "./init" if DELIVERY == ROOT else f"./{DELIVERY.relative_to(ROOT).as_posix()}/init"
 MARKER_BEGIN = "<!-- extension:codegraph:begin -->"
 MARKER_END = "<!-- extension:codegraph:end -->"
 GUIDANCE = f"""
@@ -129,7 +136,7 @@ def main() -> int:
             "Install it:\n"
             "  curl -fsSL https://raw.githubusercontent.com/colbymchenry/codegraph/main/install.sh | sh\n"
             "Then adopt it here, which is what points the agent at it:\n"
-            "  ./init --extension codegraph",
+            f"  {INIT} --extension codegraph",
             file=sys.stderr,
         )
         return 0
@@ -141,7 +148,7 @@ def main() -> int:
         print(
             f"`codegraph install` exited {installed.returncode}: AGENTS.md is unchanged.\n"
             "Fix what it reported, then adopt it here:\n"
-            "  ./init --extension codegraph",
+            f"  {INIT} --extension codegraph",
             file=sys.stderr,
         )
         return 0

{slipwai-1.3.0.dev32 → slipwai-1.3.0.dev44}/assets/toolkit/scripts/extensions/uipro/init.py

@@ -47,6 +47,13 @@ def project_root(script: Path, depth: int) -> Path:
 
 
 ROOT = project_root(Path(__file__).resolve(), 3)
+
+# Where `./init` actually is, from the repository root: beside this script's own tree at the root in a
+# generated project, and under `layout.delivery` where the method was installed beside an existing codebase.
+# Derived rather than written, because "run `./init --extension …`" is advice nobody can follow when the
+# file is `./delivery/init` — the first real adoption to meet it typed `./init` four times.
+DELIVERY = Path(__file__).resolve().parents[3]
+INIT = "./init" if DELIVERY == ROOT else f"./{DELIVERY.relative_to(ROOT).as_posix()}/init"
 MARKER_BEGIN = "<!-- extension:uipro:begin -->"
 MARKER_END = "<!-- extension:uipro:end -->"
 GUIDANCE = f"""
@@ -54,9 +61,9 @@ GUIDANCE = f"""
 ## 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:
+it **at `/drive`'s *Screen design* rung, for a screen `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 .
@@ -66,7 +73,8 @@ made from, and the input the browser app's `tokens.css` is filled from — but i
 `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.
+brief for defaults that would appear whatever the product — before writing any code, and say on the screen's
+`Designed:` line which search the decision came from.
 
 **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
@@ -160,7 +168,7 @@ def main() -> int:
             "was installed and AGENTS.md is unchanged.\n"
             "Add one first, then adopt it here:\n"
             "  slipwai add-frontend web\n"
-            "  ./init --extension uipro",
+            f"  {INIT} --extension uipro",
             file=sys.stderr,
         )
         return 0
@@ -171,7 +179,7 @@ def main() -> int:
             "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",
+            f"  {INIT} --extension uipro",
             file=sys.stderr,
         )
         return 0
@@ -183,7 +191,7 @@ def main() -> int:
             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",
+                f"  {INIT} --extension uipro",
                 file=sys.stderr,
             )
             return 0
@@ -194,7 +202,7 @@ def main() -> int:
                 "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",
+                f"  {INIT} --extension uipro",
                 file=sys.stderr,
             )
             return 0

{slipwai-1.3.0.dev32 → slipwai-1.3.0.dev44}/assets/toolkit/scripts/extensions/ux-gates/init.py

@@ -52,6 +52,13 @@ def project_root(script: Path, depth: int) -> Path:
 
 
 ROOT = project_root(Path(__file__).resolve(), 3)
+
+# Where `./init` actually is, from the repository root: beside this script's own tree at the root in a
+# generated project, and under `layout.delivery` where the method was installed beside an existing codebase.
+# Derived rather than written, because "run `./init --extension …`" is advice nobody can follow when the
+# file is `./delivery/init` — the first real adoption to meet it typed `./init` four times.
+DELIVERY = Path(__file__).resolve().parents[3]
+INIT = "./init" if DELIVERY == ROOT else f"./{DELIVERY.relative_to(ROOT).as_posix()}/init"
 MARKER_BEGIN = "<!-- extension:ux-gates:begin -->"
 MARKER_END = "<!-- extension:ux-gates:end -->"
 GUIDANCE = f"""
@@ -73,11 +80,14 @@ the gates in it that are objective: a screen either passes or it does not.
   `scripts/check-ux-gates.py` or anything under `{KIT_DIR}/`: fix the screen, install the browser, or
   report the gate's own words.
 
-**Run `make check-ux-gates` before the demo stop of any slice with a screen**, and fix what it finds
-rather than carrying it as a note. For the judgement the gates cannot make, the kit's checklists are files:
-`{KIT_DIR}/accessibility/wcag-checklist.md` (POUR-organised, P0 first) and
-`{KIT_DIR}/workflows/design-review.md` (six weighted dimensions and Nielsen's heuristics), read alongside
-`skills/web-interface-guidelines`. Never state a contrast ratio you did not measure; the gates print theirs.
+**What this adds to `/drive`'s *Design review* rung.** Run `make check-ux-gates` first and fix what it
+finds rather than carrying it as a note. Then the review itself, which the gates are not: render the screen
+from its preview under `screens/` where it has one, and read the screenshots against
+`{KIT_DIR}/workflows/design-review.md` (six weighted dimensions and Nielsen's heuristics) and
+`{KIT_DIR}/accessibility/wcag-checklist.md` (POUR-organised, P0 first) as well as
+`skills/web-interface-guidelines`, and name all three on the screen's `Reviewed:` line. Every gate green is
+the objective half: screens have passed all of them and still shipped browser-default links and a raw
+identifier. Never state a contrast ratio you did not measure; the gates print theirs.
 
 **Check you can reach it before you trust it.** `{KIT_DIR}/` 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 kit. When
@@ -182,7 +192,7 @@ def main() -> int:
             "installed and AGENTS.md is unchanged.\n"
             "Add one first, then adopt it here:\n"
             "  slipwai add-frontend web\n"
-            "  ./init --extension ux-gates",
+            f"  {INIT} --extension ux-gates",
             file=sys.stderr,
         )
         return 0
@@ -191,7 +201,7 @@ def main() -> int:
             "`npx` was not found, so the ux-ui-agent-skills kit was not installed and AGENTS.md is "
             "unchanged.\n"
             "Install Node.js, then adopt it here, which is what points the agent at it:\n"
-            "  ./init --extension ux-gates",
+            f"  {INIT} --extension ux-gates",
             file=sys.stderr,
         )
         return 0
@@ -206,7 +216,7 @@ def main() -> int:
         print(
             f"`npx ux-ui-agent-skills@{KIT_VERSION} init` exited {installed.returncode}: AGENTS.md is "
             "unchanged.\nFix what it reported, then adopt it here:\n"
-            "  ./init --extension ux-gates",
+            f"  {INIT} --extension ux-gates",
             file=sys.stderr,
         )
         return 0
@@ -215,7 +225,7 @@ def main() -> int:
             f"The installer did not write {KIT_DIR}/scripts/lint_hardcodes.py, so AGENTS.md is unchanged.\n"
             f"This script knows ux-ui-agent-skills {KIT_VERSION}; a newer kit may lay its files out "
             "differently. Pin the version, or update this script, then:\n"
-            "  ./init --extension ux-gates",
+            f"  {INIT} --extension ux-gates",
             file=sys.stderr,
         )
         return 0

{slipwai-1.3.0.dev32 → slipwai-1.3.0.dev44}/changelog.d/a-wrapped-application-begins-as-a-candidate.md

@@ -1,8 +1,8 @@
 MINOR
 
-**Under `--experimental-intro`, `slipwai adopt` no longer wraps anything: every buildable directory the survey
-finds is recorded as a candidate, and which of them is an application is answered by the coding agent, with
-the code in front of it.** [ADR 0003](docs/adr/0003-a-wrapped-application-begins-as-a-candidate.md) has the reasoning and
+**`slipwai adopt` no longer wraps anything in a terminal: every buildable directory the survey finds is
+recorded as a candidate, and which of them is an application is answered by the coding agent, with the code in
+front of it.** [ADR 0003](docs/adr/0003-a-wrapped-application-begins-as-a-candidate.md) has the reasoning and
 the evidence. `Wrap it as the application …? [Y/n]` defaults to yes and is asked of somebody who has not read
 the directory; on the first real monorepo this met, that wrapped three asset bundles and a test suite as
 applications, under names taken from their directories, with every `purpose` left blank — and there was no way
@@ -26,8 +26,11 @@ a candidate with nothing recorded in its place. **`--next`** names confirming as
 `--yes` stays the unattended path it has always been: it confirms every candidate as found, and the report now
 says plainly that nobody looked.
 
-Default off. Without `--experimental-intro` (or `SLIPWAI_EXPERIMENTAL_INTRO=1`) `adopt` asks exactly what it
-asked before, wraps what it always wrapped, and writes no `candidates` key.
+This is the only intro. The per-directory interview it replaces — wrap it? language? kind? these commands?
+what does it own? the schema, the infrastructure, the release path, why — is gone, and in a terminal `adopt`
+now runs `./<delivery>/init` once its commit is made unless `--no-init` says otherwise. It arrived behind
+`--experimental-intro` and `SLIPWAI_EXPERIMENTAL_INTRO=1` while it was being built; the flag is still accepted
+and chooses nothing, so a script that passes it keeps working, and the variable is no longer read.
 
 **Catch-up.** Nothing. A repository adopted before this has its applications in `deployables` already, which is
 confirmation by an earlier factory and is left alone; it has no `candidates` key, which reads as an adoption

{slipwai-1.3.0.dev32 → slipwai-1.3.0.dev44}/changelog.d/adopt-next-and-intro-repair.md

@@ -17,9 +17,7 @@ was told `` `cd` is not on PATH here `` above a list of all fifteen of their tar
 really was missing a line among them. The tools a command runs are now every shell segment's program, past
 any leading `VAR=value`, and never one of the shell's own words.
 
-**`slipwai adopt --experimental-intro` turns on the reshaped adoption intro while it is being built.** The
-questions a terminal cannot answer well — what a directory is, what it is called, what it owns — are being
-moved to the coding agent, which can read the code before asking. The switch (or `SLIPWAI_EXPERIMENTAL_INTRO=1`)
-is how to walk that shape before it is the only one; today it removes the first of them, the language, which
-the line above it has already printed and which `--language NAME=LANGUAGE` still corrects. Default off:
-without it the interview asks exactly what it asked before. Experimental within an experiment (#74).
+**The questions a terminal cannot answer well move to the coding agent, which can read the code before
+asking.** What a directory is, what it is called, what it owns, and first of all the language, which the line
+above it had already printed. The candidate state is what finished the move; see the entry that introduces
+it.

slipwai-1.3.0.dev44/changelog.d/design-review-is-a-stage.md

@@ -0,0 +1,28 @@
+PATCH
+
+**A slice with a screen now has its design decided before it is built and reviewed on the rendered screen
+before the demo, as two `/drive` rungs, not as a sentence nothing asked anyone to act on.** Three new screens
+reached a demo with every `check-ux-gates` gate green and still showed default-blue links, labels crammed
+against their fields, a raw UUID and a diagram drawn as a bare rectangle: the design skills were installed and
+`AGENTS.md` named them, but no stage of the ladder asked for them, so a delegate briefed from the plan styled
+from the tokens, ran the gates and stopped. Where the project has a browser app:
+
+- **Screen design**, between *Plan and tasks* and *Implementation*: `docs/design.md` holds the decision each
+  screen needs, `skills/frontend-design`'s second pass has been over the plan, and `tasks.md` records a
+  `Designed:` line per screen under `## Design review`.
+- **Design review**, between *Implementation* and *Convergence*: each screen rendered, a screenshot per state,
+  read against `skills/web-interface-guidelines`, every finding fixed or given its reason on a `Reviewed:`
+  line. A green gate is evidence for this rung, never the rung.
+- A slice with no screen says `No screen in this slice` once, and both rungs are done.
+
+The ladder names only what every browser app ships with. The `uipro` extension's `AGENTS.md` block now puts its
+search into *Screen design*, and the `ux-gates` block puts `make check-ux-gates` and the kit's `design-review.md`
+and `wcag-checklist.md` into *Design review*, so a project that did not adopt them reads about neither. The
+`drive-tasks` brief and the event-modelling tasks template carry the steps inside the styling task and leave the
+`## Design review` heading. The demo stop checks the record. Under `/cruise`, `drive-hand` also looks at every
+screen on its browser walk and writes what it sees as `design:` notes in the demo log's **Feedback**.
+
+**Catch-up.** `slipwai migrate` brings the ladder, the brief and the template. A slice already past
+*Implementation* whose `tasks.md` has no `## Design review` enters `/drive` at *Screen design*: write the
+`Designed:` lines for the screens that were built, then run the review. In a project that adopted `uipro` or
+`ux-gates`, run `make agents` once so its `AGENTS.md` block names the rung, and commit the result.

{slipwai-1.3.0.dev32 → slipwai-1.3.0.dev44}/changelog.d/four-small-things-a-real-run-found.md

@@ -3,7 +3,7 @@ PATCH
 **A flag that describes the adoption is refused on a `--confirm` or `--decline` run, rather than read and
 thrown away.** `slipwai adopt --confirm shop --integration cursor` looked like it recorded a coding agent and
 recorded nothing: the settling path never reads those flags. It now names each one and says where it belongs —
-`--integration` after the method is installed is `./init`'s. The same rule the reshaped intro already applies
+`--integration` after the method is installed is `./init`'s. The same rule the intro already applies
 to flags that describe an application, and nothing that previously worked stops working: a flag that did
 nothing now says so.
 

slipwai-1.3.0.dev44/changelog.d/ground-records-answers-and-commits-once.md

@@ -0,0 +1,22 @@
+PATCH
+
+**`/ground` can record its answers one at a time and commit them once, as it says to.** `adopt --confirm`,
+`adopt --decline` and `adopt --refresh` refused any uncommitted change at all, so the first answer was refused
+by what `./init` had just left for the person to read, the second by the first, and the refresh by the rows it
+exists to follow — and the first repository taken end to end got through by committing after every answer. They
+now refuse only where they would write over somebody's work: a path they write, from the factory's `.written`
+listing or the survey's pages, holding an uncommitted change that is not what slipwai last left there. What
+slipwai left is recorded by digest in `.delivery-tools/written.json`, which every `.gitignore` the factory has
+written already ignores, so it belongs to the checkout and is never committed. It is kept out of `.git` on purpose: Codex runs an agent's
+commands in a sandbox that makes `.git` read-only, and a record there was silently never written.
+`project.json`, what `./init` wrote and a person's own source no longer stop anything, because none of them is
+written. `slipwai adopt` itself still refuses an unclean tree: it commits, and the `git reset --hard HEAD^` it
+offers as the undo would take uncommitted work with it.
+
+**The code-index guard holds only searches of its own repository.** A session opened in one repository searched
+another checkout and was refused, because `version` is a name the first repository's index defines — an index
+that cannot answer anything about code it never read. Where a search runs is now read from the hook's `cwd`, a
+Grep `path`, or a `cd` earlier in the shell command, and a search wholly outside the repository is allowed.
+
+Part of brownfield adoption, which is experimental (#74): what it offers may change in a MINOR, and what it
+gets wrong belongs on that issue.

slipwai-1.3.0.dev44/changelog.d/ground-says-what-an-application-is.md

@@ -0,0 +1,14 @@
+PATCH
+
+**`/ground`'s long form says what being an application commits you to, before it asks about the first one.**
+The question was "is this an application?", and the natural reading of the word is "something that gets
+deployed" — so a person could agree to put a directory's lint and tests in front of every change without knowing
+that was what they were agreeing to. In the long form the agent now says, once and in this repository's terms,
+that an application here is a directory whose build the gate holds: its commands join `make verify`, which every
+change has to pass, the person's and `/drive`'s and `/cruise`'s; the gate's CI runs it on every pull request;
+`/drive` can change it once somebody has recorded how it starts. It says what declining leaves behind, that
+leaving a directory a candidate is *not yet decided*, and that neither answer can be taken back by a command yet —
+so an unsure answer is best left open.
+
+Part of brownfield adoption, which is experimental (#74): what it offers may change in a MINOR, and what it
+gets wrong belongs on that issue.

slipwai-1.3.0.dev44/changelog.d/the-first-repository-somebody-else-adopted.md

@@ -0,0 +1,41 @@
+PATCH
+
+**A language somebody spoke brings its own toolchain.** The survey reads each directory once, by the first
+ecosystem that recognises it, so a directory with a `package.json` beside a `requirements.txt` is Node. Saying
+it is Python — with `--language`, or through the `--confirm` that `/ground` runs once it has read the code —
+moved the language and left `kind: node` behind it, and a refresh then put the reading back over the answer.
+The toolchain is what CI installs, so the record was describing a pipeline that cannot run. It now follows the
+language where the tree has a build in that language to follow, is left alone where it has none rather than
+invented, and a refresh holds what a person settled and says what the tree now reads instead.
+
+**Claude Code's hooks find their scripts from any directory.** They were written as repository-relative paths
+and run with whatever directory the session is in, so a session opened in a subdirectory ran
+`python3 delivery/scripts/agents/cruise.py` against a path that is not there — and a hook that fails is silent.
+They are written from `$CLAUDE_PROJECT_DIR` now, and the two other harnesses the factory writes hooks for —
+Cursor's `.cursor/hooks.json` and Gemini CLI's `.gemini/settings.json` — change to the root Git names
+(`cd "$(git rev-parse --show-toplevel)" && …`) before they run, since neither harness shares a variable
+for it. `make agents` rewrites them; nothing else is asked of a repository already generated.
+
+**A command that needs an application says that confirming one is the missing step.** Between `adopt` and the
+first confirmed candidate there is nothing for a frontend to sit beside, and `slipwai add-frontend web` — which
+is what `./init` had just said to run — answered "project.json names no deployables, so there is nothing to add
+a service to". True, and the same sentence a manifest that names none gets. It now names the candidates and the
+command that settles one.
+
+**An extension tells a wrapped repository to run the script it actually has.** `./init --extension codegraph`
+is advice nobody can follow where the adoption put `init` under `delivery/`. The three shipped extensions
+derive the path from where they are, in all ten places they print it.
+
+**`slipwai adopt --next` runs to the loop rather than stopping at a ready repository.** It ended at the
+strategy ADR — wrapped, gated and asked to do nothing — and the first person to take it end to end had to be
+told the rest in chat. It now names `/speckit-constitution` before the first spec, because `check-constitution`
+fails the moment `specs/` exists over the template it installed, then `/speckit-specify`, `/drive` once by
+hand, and `make cruise`. A constitution in a repository where `./init` has never run reports as pending, which
+is what it is.
+
+**`--command app:test=` records none, as `-` does.** An empty value is what a shell leaves when a variable is
+unset, and recording `""` wrote a target that runs nothing and reads as one somebody chose. The report now
+says what each target was vouched for with, so a written no is visible where it was decided.
+
+Part of brownfield adoption, which is experimental (#74): what it offers may change in a MINOR, and what it
+gets wrong belongs on that issue.

{slipwai-1.3.0.dev32 → slipwai-1.3.0.dev44}/changelog.d/the-record-catches-up-with-init.md

@@ -13,7 +13,7 @@ own, and the strongest one: a person answered `./init`, so it is recorded `confi
 the environment a run started in and what the tree reads, which are readings rather than answers. A record
 that already names a harness is left alone, and one a person overrode is never moved by a later step.
 
-Found by running the reshaped intro over PrestaShop, whose tree reads for Claude Code, GitHub Copilot and
+Found by running the candidate intro over PrestaShop, whose tree reads for Claude Code, GitHub Copilot and
 Gemini CLI at once — which is the case the ambiguity rule was written for, and the first time it has been met
 in the wild.
 

{slipwai-1.3.0.dev32 → slipwai-1.3.0.dev44}/src/slipwai/adopt.py

@@ -70,9 +70,9 @@ class Answers:
     # `{"harness": ..., "evidence": ..., "provenance": ...}` from `harness.py`: which coding agent `./init`
     # projects into. Empty means nobody said and nothing showed, and `./init` keeps its own question.
     agent: dict = field(default_factory=dict)
-    # Buildable directories found and not yet confirmed (ADR 0003). Under the reshaped intro this carries
-    # every one of them and `applications` is empty; under the interview it is empty and `applications`
-    # carries what the person confirmed in the terminal.
+    # Buildable directories found and not yet confirmed (ADR 0003). In a terminal this carries every one of
+    # them and `applications` is empty; under `--yes` it is empty and `applications` carries every one of
+    # them, wrapped unlooked-at.
     candidates: list = field(default_factory=list)
 
 

{slipwai-1.3.0.dev32 → slipwai-1.3.0.dev44}/src/slipwai/assets.py

@@ -29,6 +29,14 @@ VERSION = (ROOT / "VERSION").read_text().strip()
 # three of them need it — the module that writes the page, the `.gitignore` that keeps it out of the history,
 # and the command file that tells an agent where to look.
 NOTES = ".slipwai/catch-up.md"
+# What slipwai last left at each path it writes and has not seen committed, by digest, so that the next answer
+# `/ground` records can write over its own regeneration and still refuse a person's edit (`uncommitted.py`).
+# It is this checkout's state, never a record, so it lives under `.delivery-tools/`, which every `.gitignore`
+# the factory has ever written ignores — a repository adopted before this needs no new line to keep it out of
+# a `git add -A`. Not inside `.git`, where it was first: Codex runs an agent's commands in a sandbox that
+# makes `.git` read-only, the record was silently never written, and the second answer was refused as if a
+# person had edited the first answer's files.
+WRITTEN_RECORD = ".delivery-tools/written.json"
 TOOLKIT_ROOT = ROOT / "assets/toolkit"
 PROFILE_ROOT = ROOT / "assets/profiles"
 FRONTEND_ROOT = ROOT / "assets/frontends"