slipwai 1.2.1.dev5__tar.gz → 1.2.1.dev11__tar.gz

{slipwai-1.2.1.dev5 → slipwai-1.2.1.dev11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: slipwai
-Version: 1.2.1.dev5
+Version: 1.2.1.dev11
 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
@@ -244,6 +244,10 @@ changes. What changes is who answers.
 - **It never invents a fact.** A credential, an external system, a person's approval: the slice is marked
   blocked, the run takes the next ready slice, and a strong delegate works around the block — a fake behind
   the port, recorded as a fake, or the narrower reading that keeps every rule — and writes down what it did.
+- **It never makes a gate pass by changing the gate.** `scripts/`, the `Makefile`, `tools/`, CI and the hook
+  settings are not an iteration's to edit: Claude Code refuses the edit before it lands, and the runner parks
+  the run on any change to them, on every harness. A gate the tree cannot satisfy parks the run with the
+  gate's own words as the reason.
 - **Every merge is dark.** Under the default release setting each slice ships behind a flag seeded off.
   Nothing the run merged reaches a real actor until you turn a key on.
 - **Done means the specification is satisfied.** When the split runs out, an audit reads the specification
@@ -256,6 +260,7 @@ changes. What changes is who answers.
 /cruise-settings enabled=true            # switch it on; commits .specify/cruise.json
 /cruise use the PRD in docs/prd.md       # start the runner, detached, and watch it from this session
 /cruise-status                           # is it running, how the last iteration ended, the feed's tail
+/cruise-watch                            # sit back down at the watch seat, where the feed left off
 /cruise-tell take the payments feature next   # queued for the next iteration; --now ends the one in flight
 /cruise-stop                             # end the run after the iteration in flight; `now` ends it now
 ```
@@ -313,8 +318,8 @@ the paths and toolchains named in them are real.
 |---|---|
 | `/drive` | Takes one slice from wherever it stands to a demo the actor can see |
 | `/cruise` | Runs `/drive` on its own, deciding as the product owner and demoing as the actor, until the specification is satisfied. Stops only for a person. `/cruise <kick-off>` gives the first iteration a brief; the session then watches the run and answers you |
-| `/whats-next` | Says what is next — one slice, one stage, one command. Reads the disk and changes nothing |
-| `/where-are-we` | Shows the progress board: what works, what is in progress, what is still to come |
+| `/whats-next` | Says what is next — one slice, one stage, one command. Reads the disk and changes nothing; beside a running `/cruise`, says what the runner is on instead |
+| `/where-are-we` | Shows the progress board: what works, what is in progress, what is still to come; beside a running `/cruise`, the next row is the runner's |
 | `/gaps` | Reviews an artifact for holes, before they become rewritten tests |
 | `/example-map` | *Event profile.* Turns one slice of the event model into rules, examples and executable scenarios |
 | `/validate-code-against-model` | *Event profile.* Checks that the code and the event model still agree |
@@ -331,6 +336,7 @@ the paths and toolchains named in them are real.
 | `/cruise-status` | Says whether a `/cruise` runner is running, how its last iteration ended, and shows the tail of its feed |
 | `/cruise-stop` | Ends a `/cruise` run after the iteration in flight, or at once with `now` |
 | `/cruise-tell` | Queues a message for a running `/cruise`, which the next iteration carries; `--now` ends the iteration in flight for it |
+| `/cruise-watch` | Takes the watch seat beside a running `/cruise`: prints the feed as it is written and watches again, starting nothing |
 
 [The delivery loop](docs/delivery-loop.md) describes each one in full, and the ladder they sit on.
 

{slipwai-1.2.1.dev5 → slipwai-1.2.1.dev11}/README.md

@@ -215,6 +215,10 @@ changes. What changes is who answers.
 - **It never invents a fact.** A credential, an external system, a person's approval: the slice is marked
   blocked, the run takes the next ready slice, and a strong delegate works around the block — a fake behind
   the port, recorded as a fake, or the narrower reading that keeps every rule — and writes down what it did.
+- **It never makes a gate pass by changing the gate.** `scripts/`, the `Makefile`, `tools/`, CI and the hook
+  settings are not an iteration's to edit: Claude Code refuses the edit before it lands, and the runner parks
+  the run on any change to them, on every harness. A gate the tree cannot satisfy parks the run with the
+  gate's own words as the reason.
 - **Every merge is dark.** Under the default release setting each slice ships behind a flag seeded off.
   Nothing the run merged reaches a real actor until you turn a key on.
 - **Done means the specification is satisfied.** When the split runs out, an audit reads the specification
@@ -227,6 +231,7 @@ changes. What changes is who answers.
 /cruise-settings enabled=true            # switch it on; commits .specify/cruise.json
 /cruise use the PRD in docs/prd.md       # start the runner, detached, and watch it from this session
 /cruise-status                           # is it running, how the last iteration ended, the feed's tail
+/cruise-watch                            # sit back down at the watch seat, where the feed left off
 /cruise-tell take the payments feature next   # queued for the next iteration; --now ends the one in flight
 /cruise-stop                             # end the run after the iteration in flight; `now` ends it now
 ```
@@ -284,8 +289,8 @@ the paths and toolchains named in them are real.
 |---|---|
 | `/drive` | Takes one slice from wherever it stands to a demo the actor can see |
 | `/cruise` | Runs `/drive` on its own, deciding as the product owner and demoing as the actor, until the specification is satisfied. Stops only for a person. `/cruise <kick-off>` gives the first iteration a brief; the session then watches the run and answers you |
-| `/whats-next` | Says what is next — one slice, one stage, one command. Reads the disk and changes nothing |
-| `/where-are-we` | Shows the progress board: what works, what is in progress, what is still to come |
+| `/whats-next` | Says what is next — one slice, one stage, one command. Reads the disk and changes nothing; beside a running `/cruise`, says what the runner is on instead |
+| `/where-are-we` | Shows the progress board: what works, what is in progress, what is still to come; beside a running `/cruise`, the next row is the runner's |
 | `/gaps` | Reviews an artifact for holes, before they become rewritten tests |
 | `/example-map` | *Event profile.* Turns one slice of the event model into rules, examples and executable scenarios |
 | `/validate-code-against-model` | *Event profile.* Checks that the code and the event model still agree |
@@ -302,6 +307,7 @@ the paths and toolchains named in them are real.
 | `/cruise-status` | Says whether a `/cruise` runner is running, how its last iteration ended, and shows the tail of its feed |
 | `/cruise-stop` | Ends a `/cruise` run after the iteration in flight, or at once with `now` |
 | `/cruise-tell` | Queues a message for a running `/cruise`, which the next iteration carries; `--now` ends the iteration in flight for it |
+| `/cruise-watch` | Takes the watch seat beside a running `/cruise`: prints the feed as it is written and watches again, starting nothing |
 
 [The delivery loop](docs/delivery-loop.md) describes each one in full, and the ladder they sit on.
 

slipwai-1.2.1.dev11/VERSION

@@ -0,0 +1 @@
+1.2.1.dev11

{slipwai-1.2.1.dev5 → slipwai-1.2.1.dev11}/assets/toolkit/scripts/agents/cruise.py

@@ -129,8 +129,26 @@ WATCH_QUIET_SECONDS = 20.0
 # checkpoint at every stage boundary, so a checkpoint held this often without a rewrite is a session that is
 # not moving, and a hook that never let go would spend tokens forever on it.
 HOLD_LIMIT = 3
+# How long `stop --now` waits for the runner it signalled to be gone before it returns: the runner ends the
+# iteration's session first, and a harness session shutting down takes a moment.
+STOP_WAIT_SECONDS = 30.0
 REGISTRY = SCRIPT.with_name("registry.json")
 INTEGRATION = ROOT / ".specify/integration.json"
+# What a run may never change to get moving — the gates that judge it and the controls that hold it: `make
+# verify`'s scripts and everything beside them, the Makefile that runs them, the tools they run (`tools/`, ignored by
+# Git and installed by an extension), CI, and the hook files the harnesses read this script from. A gate is
+# satisfied in the tree it measures; an iteration that changed one of these instead has the run parked with the
+# change as the reason (`controls_changed` on its log entry), and Claude Code's `PreToolUse` hook (`guard`) refuses
+# the edit before it lands. Under `tools/` a file added is an install, which `./init --extension` does; a file
+# changed or removed is an edit.
+CONTROL_PATHS = (DELIVERY / "Makefile", DELIVERY / "scripts", ROOT / "Makefile", ROOT / "tools",
+                 ROOT / ".github/workflows", ROOT / ".gitea/workflows", ROOT / ".claude/settings.json")
+INSTALLED = ROOT / "tools"
+SKIPPED_DIRECTORIES = {".git", "__pycache__", "node_modules"}
+GUARD_REASON = ("cruise: `{path}` is a gate or a control of this run, and an iteration never edits one — a gate is "
+                "satisfied in the tree it measures, or the run parks with the gate's own output as the reason "
+                "(`cruise: parked: <gate>: <what it said>`). The bosun's brief and commands/cruise.md, *Blocked: the "
+                "bosun protocol*, say so; the runner parks the run at the end of an iteration that changed one anyway.")
 # Every setting: the values it takes — a tuple of words, or a kind — its default, and what it controls. The
 # factory writes the same list into `.specify/cruise.json` and `commands/cruise-settings.md`.
 CHOICES: dict[str, tuple[str, ...]] = {
@@ -488,6 +506,82 @@ def child_environment(harness: dict[str, Any] | None) -> dict[str, str]:
     return environment
 
 
+def control_paths() -> list[Path]:
+    """Every gate and control the run is held by, present or not: the fixed ones, and the hook file of every harness
+    whose registry row projects one."""
+    paths = list(CONTROL_PATHS)
+    for row in registry().values():
+        projection = (row.get("hooks") or {}).get("projection") if isinstance(row.get("hooks"), dict) else None
+        if isinstance(projection, dict) and projection.get("where"):
+            paths.append(ROOT / str(projection["where"]))
+    return list(dict.fromkeys(paths))
+
+
+def controls_signature() -> dict[str, str]:
+    """Every file under the controls by its content, taken before an iteration and compared after it."""
+    signature: dict[str, str] = {}
+    for control in control_paths():
+        if control.is_file():
+            files = [control]
+        elif control.is_dir():
+            files = []
+            for directory, names, filenames in os.walk(control):
+                names[:] = sorted(name for name in names if name not in SKIPPED_DIRECTORIES)
+                files += [Path(directory) / name for name in sorted(filenames)]
+        else:
+            continue
+        for path in files:
+            try:
+                if path.is_file():
+                    signature[path.relative_to(ROOT).as_posix()] = hashlib.sha256(path.read_bytes()).hexdigest()
+            except OSError:
+                continue
+    return signature
+
+
+def controls_changed(before: dict[str, str], after: dict[str, str]) -> list[str]:
+    """What an iteration did to the controls, each with its kind — except a file installed under `tools/`."""
+    installed = INSTALLED.relative_to(ROOT).as_posix() + "/"
+    changes = []
+    for path in sorted(set(before) | set(after)):
+        if path in before and path in after:
+            if before[path] != after[path]:
+                changes.append(f"{path} (modified)")
+        elif path in before:
+            changes.append(f"{path} (deleted)")
+        elif not path.startswith(installed):
+            changes.append(f"{path} (added)")
+    return changes
+
+
+def guard() -> None:
+    """Claude Code's `PreToolUse` hook on the editing tools — Edit, Write, MultiEdit, NotebookEdit: in a session the
+    runner started, refuse an edit to a gate or a control before it lands, with the reason on stderr and exit 2,
+    which is how that harness reads a refusal (a 2.1.281 print session, probed 2026-09-24: the tool result carries
+    the reason, the model reads it, the file is not written). Outside a runner's iteration the hook does nothing, so
+    a person's `/drive` session edits what it likes. The shell is not covered here — a command can write anything —
+    which is why the runner compares the controls after every iteration too."""
+    if not os.environ.get(RUNNER_VARIABLE):
+        return
+    event = read_event()
+    given = event.get("tool_input") if isinstance(event.get("tool_input"), dict) else {}
+    target = given.get("file_path") or given.get("notebook_path")
+    if not target:
+        return
+    path = Path(str(target))
+    if not path.is_absolute():
+        path = Path(str(event.get("cwd") or ROOT)) / path
+    path = path.resolve()
+    for control in control_paths():
+        if path == control or control in path.parents:
+            try:
+                shown = path.relative_to(ROOT).as_posix()
+            except ValueError:
+                shown = str(path)
+            print(GUARD_REASON.format(path=shown), file=sys.stderr)
+            raise SystemExit(2)
+
+
 def stream_of(harness: dict[str, Any] | None) -> str | None:
     """Which event stream the harness's headless command emits, for the feed: `CRUISE_HARNESS_STREAM` where set
     (a rehearsal against a fake harness), else the headless row's `stream`, else none — plain text, echoed."""
@@ -1135,6 +1229,7 @@ def drive(table: dict[str, Any], harness: dict[str, Any] | None, template: str,
         INTERRUPTED = False
         print(f"cruise: iteration {iteration} started {started}, running `{ask}`", flush=True)
         began = time.monotonic()
+        controls_before = controls_signature()
         # The model flag is read with the settings, so `/cruise-settings model=…` holds from the next iteration.
         last = iterate(template + model_flags(harness, table["model"]), ask, environment, iteration, stream)
         if INTERRUPTED:
@@ -1151,6 +1246,9 @@ def drive(table: dict[str, Any], harness: dict[str, Any] | None, template: str,
                                  "last_line": last or "no last line", "fingerprint": seen}
         if attempt is not None:
             entry["attempt"] = attempt
+        changed = controls_changed(controls_before, controls_signature())
+        if changed:
+            entry["controls_changed"] = changed
         given = delivered()
         if given:
             entry["told"] = [str(each["text"]) for each in given]
@@ -1164,6 +1262,13 @@ def drive(table: dict[str, Any], harness: dict[str, Any] | None, template: str,
         # The boundary `watch` returns on: the iteration, what it ended on, and how long it took.
         print(f"cruise: iteration {iteration} ended — {last or 'no last line'} ({duration(time.monotonic() - began)})",
               flush=True)
+        if changed:
+            # A gate made to pass is no pass, whatever the last line says: the run parks on the change itself, and a
+            # person reverts it, or keeps it on purpose and resumes with a message.
+            park(f"iteration {iteration} changed a gate or a control of the run — {', '.join(changed)} — and a gate "
+                 "is satisfied in the tree it measures, never edited; revert the change, or keep it on purpose and "
+                 "resume with a message", no_park, poll, seen)
+            continue
         if INTERRUPTED:
             # Ended for a message, not by its own last line: the next iteration is where the message goes, and it
             # starts now — there is nothing to park on and nothing to count.
@@ -1376,6 +1481,18 @@ def stop(arguments: list[str]) -> None:
         return
     if "--now" in arguments:
         os.kill(running[0], signal.SIGTERM)
+        # Said once it has ended, not once it was told to. The runner ends the iteration's session before it goes,
+        # and a `start` typed the moment this returned found the old runner still alive and declined to start one
+        # — after which nobody was running, and the watch seat found nobody to watch.
+        for _ in range(int(STOP_WAIT_SECONDS / 0.05)):
+            if running_pid() is None:
+                break
+            time.sleep(0.05)
+        else:
+            print(f"cruise: {relative(STOP)} written and the runner (pid {running[0]}) told to end; it is still ending "
+                  f"the iteration in flight after {STOP_WAIT_SECONDS:g}s — `python3 scripts/agents/cruise.py status` "
+                  "says when it has gone")
+            return
         print(f"cruise: {relative(STOP)} written and the runner (pid {running[0]}) terminated with the iteration "
               "in flight; its increment commits are on the slice branch, and the next run re-derives from disk")
         return
@@ -1524,8 +1641,63 @@ def status() -> None:
         print(line)
 
 
+def checkpoint_fields() -> dict[str, str]:
+    """The checkpoint's labelled fields — Feature, Slice, Stage, Written, Delegates out, Open question, Next — as
+    the command writes them (`CHECKPOINT_ENTRY`), or nothing where no checkpoint is written."""
+    if not CHECKPOINT.is_file():
+        return {}
+    fields: dict[str, str] = {}
+    label: str | None = None
+    for line in CHECKPOINT.read_text().splitlines():
+        found = re.findall(r"\*\*([A-Za-z ]+):\*\* (.*?)(?= · \*\*|$)", line)
+        if found:
+            for label, value in found:
+                fields[label] = value.strip()
+        elif label is not None and line.startswith("  ") and label in ("Delegates out", "Open question", "Next"):
+            fields[label] = f"{fields[label]} {line.strip()}"
+    return fields
+
+
+def where() -> None:
+    """Where a run stands, for `/where-are-we` and `/whats-next` typed beside it — and nothing at all where no runner
+    is running, so that both commands answer exactly as they do without `/cruise`. With a runner alive: the run,
+    the iteration in flight or the park it waits in, the checkpoint's slice, stage and next step, and what a
+    person can do from here, which is never to run a stage themselves."""
+    running = running_pid()
+    if running is None:
+        return
+    log = entries()
+    tail = RUN_LOG.read_text(errors="replace").rstrip().splitlines()[-2:] if RUN_LOG.is_file() else []
+    parked = next((line.removeprefix("cruise: parked — ") for line in tail if line.startswith("cruise: parked — ")),
+                  None) if tail and tail[-1].startswith("cruise: waiting;") else None
+    print(f"cruise: a run is going here — runner pid {running[0]} since {running[1]}, {len(log)} iteration(s) logged, "
+          + (f"parked after iteration {len(log)}" if parked else f"iteration {len(log) + 1} in flight"))
+    fields = checkpoint_fields()
+    if fields:
+        print(f"cruise: feature {fields.get('Feature', '?')} · slice {fields.get('Slice', '?')} · stage "
+              f"{fields.get('Stage', '?')} · checkpoint written {fields.get('Written', '?')}")
+        for label in ("Open question", "Delegates out"):
+            if fields.get(label) and fields[label].lower() != "none":
+                print(f"cruise: {label.lower()} — {fields[label]}")
+        print(f"cruise: next — {fields.get('Next', '(the checkpoint names no next step)')}")
+    else:
+        print("cruise: no checkpoint written yet — the iteration has not reached its first stage boundary")
+    if parked:
+        print(f"cruise: parked — {parked}")
+        print("cruise: nothing to run from here — a person provides what the park names; `/cruise-tell` with it resumes "
+              "the run, `/cruise-stop` ends it")
+    else:
+        print("cruise: nothing to run from here — the runner is on it; `/cruise` watches it, `/cruise-tell` steers it, "
+              "`/cruise-stop` ends it")
+
+
 def main() -> None:
     arguments = sys.argv[1:]
+    if arguments[:1] == ["where"]:
+        # Before the settings check: a project with no `/cruise` settings has no run, and the commands that ask
+        # this read silence as "answer as without /cruise".
+        where()
+        return
     if not CONFIG.is_file():
         print(ABSENT)
         return
@@ -1533,7 +1705,7 @@ def main() -> None:
              "watch": lambda: watch(arguments[1:]), "stop": lambda: stop(arguments[1:]), "status": status,
              "tell": lambda: tell(arguments[1:]), "told": told,
              "denials": denials, "resume": resume, "compacting": compacting, "loop": loop, "stopping": stopping,
-             "responded": responded}
+             "responded": responded, "guard": guard}
     if arguments and arguments[0] in verbs:
         verbs[arguments[0]]()
         return

{slipwai-1.2.1.dev5 → slipwai-1.2.1.dev11}/assets/toolkit/scripts/agents/registry.json

@@ -216,7 +216,7 @@
       },
       "hooks": {
         "holds": true,
-        "how": "`Stop` runs when the model tries to end its turn; a hook printing {\"decision\": \"block\", \"reason\": \"...\"} refuses the end and the reason is read next; the event carries `last_assistant_message` and `transcript_path`. Hooks run in `-p` sessions. Source: the installed Claude Code 2.1.278's hook events and the Stop hook decision it acted on during /cruise runs, read 2026-09-22.",
+        "how": "`Stop` runs when the model tries to end its turn; a hook printing {\"decision\": \"block\", \"reason\": \"...\"} refuses the end and the reason is read next; the event carries `last_assistant_message` and `transcript_path`. Hooks run in `-p` sessions. Source: the installed Claude Code 2.1.278's hook events and the Stop hook decision it acted on during /cruise runs, read 2026-09-22. `PreToolUse` runs before a tool call, with `tool_name` and `tool_input` (`file_path` for Edit, Write and MultiEdit, `notebook_path` for NotebookEdit) in the event; a hook command that exits 2 refuses the call, its stderr is the tool's result the model reads, and the refusal is listed under `permission_denials` in the final `result` event — from a 2.1.281 print session under `acceptEdits --allowedTools Bash` in an untrusted workspace, where the project's `.claude/settings.json` hook still ran with the runner's environment variables inherited, probed 2026-09-24; `scripts/agents/cruise.py guard` runs there.",
         "projection": null,
         "why": "the factory writes `.claude/settings.json` itself, hooks included (Stop, PreCompact, SessionStart); Grok Build reads that file too"
       },

slipwai-1.2.1.dev11/assets/toolkit/scripts/check-ux-gates.py

@@ -0,0 +1,245 @@
+#!/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. Which browser is asked once, before any of them runs: the
+kit launches Chrome (`channel: 'chrome'`), and in 2.8.0 two of its scripts — `verify_responsive.mjs` and
+`verify_target_size.mjs` — crash where Chrome is not installed instead of falling back to Playwright's own
+Chromium the way the other three do. So where Chrome is absent and that Chromium opens, every render gate
+runs with a Node preload that retries a launch without the channel; where no browser opens, or Playwright
+is not resolvable, the render gates are reported as skipped, never as passed, and a gate that still could
+not open a browser is reported the same way rather than as a failure.
+
+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
+import tempfile
+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",)),
+)
+# Which browser the kit's scripts can open, Playwright resolved from the kit's directory the way its scripts resolve
+# it from `scripts/` beneath — the same `node_modules` chain — and answered in one word: `chrome` (the channel the kit asks for), `bundled` (Playwright's own Chromium, which
+# `npx playwright install chromium` puts in place), `none`, or `no-playwright`.
+PROBE = """
+let chromium;
+try { ({ chromium } = await import("playwright")); }
+catch { console.log("no-playwright"); process.exit(0); }
+if (!chromium) { console.log("no-playwright"); process.exit(0); }
+for (const [word, options] of [["chrome", { channel: "chrome" }], ["bundled", {}]]) {
+  try { const browser = await chromium.launch(options); await browser.close(); console.log(word); process.exit(0); }
+  catch {}
+}
+console.log("none");
+"""
+# What every render gate is started with where only the bundled Chromium opens: the same Playwright the kit imports,
+# its `chromium.launch` retried without the channel when the channel is what failed. A CommonJS preload runs before
+# an ES module entry, and the kit's `import('playwright')` returns the same object this patched.
+PRELOAD = """
+const { createRequire } = require("node:module");
+const playwright = createRequire({scripts})("playwright");
+const launch = playwright.chromium.launch.bind(playwright.chromium);
+playwright.chromium.launch = async (options = {}) => {
+  try { return await launch(options); }
+  catch (error) {
+    if (!options.channel) throw error;
+    const { channel, ...rest } = options;
+    return launch(rest);
+  }
+};
+"""
+# The words Playwright's launch failure carries, on stderr, when a kit script could not open a browser.
+LAUNCH_FAILED = "browserType.launch"
+
+
+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 browser() -> str:
+    """Which browser the render gates can open, asked once: `chrome`, `bundled`, `none` or `no-playwright`. A probe
+    that could not answer — node failing before the question — is `none`, with what it said on stderr."""
+    completed = subprocess.run(["node", "--input-type=module", "-e", PROBE], cwd=ROOT / KIT, check=False,
+                               text=True, capture_output=True)
+    word = completed.stdout.strip().splitlines()[-1] if completed.stdout.strip() else ""
+    if completed.returncode == 0 and word in ("chrome", "bundled", "none", "no-playwright"):
+        return word
+    sys.stderr.write(completed.stderr)
+    return "none"
+
+
+def run(script: str, *arguments: str, preload: Path | None = None) -> str:
+    """One kit script, from the kit's own directory so its relative imports resolve, started with the preload where
+    one is given. Its output is passed through, and the verdict is one of three words: `passed`, `failed`, or
+    `skipped` — the kit's own word when a gate could not open a browser, which exits 0 upstream and is refused as
+    a pass here, or a launch failure on stderr, which is the same fact told as a crash."""
+    kit = ROOT / KIT
+    interpreter = [sys.executable] if script.endswith(".py") else ["node"]
+    if preload is not None and script.endswith(".mjs"):
+        interpreter += ["--require", str(preload)]
+    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()
+    if completed.returncode != 0 and LAUNCH_FAILED in completed.stderr:
+        say(f"check-ux-gates: {script} could not open a browser — SKIPPED, not passed")
+        return "skipped"
+    if completed.returncode != 0:
+        return "failed"
+    return "skipped" if "SKIPPED" in completed.stdout else "passed"
+
+
+def render_gates(app: Path, screens: list[Path], opened: str, preload: Path | None) -> tuple[list[str], int]:
+    """Every render gate over one app's previews, or all of them counted as skipped where no browser opens."""
+    relative = app.relative_to(ROOT).as_posix()
+    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]
+    if opened in ("none", "no-playwright"):
+        why = ("playwright is not resolvable from the kit" if opened == "no-playwright"
+               else "no browser opens — neither Chrome nor Playwright's Chromium (`npx playwright install chromium`)")
+        say(f"check-ux-gates: {relative}/screens/ — {why}; {len(gates)} render gate(s) SKIPPED, not passed")
+        return [], len(gates)
+    say(f"check-ux-gates: {relative}/screens/ — {len(screens)} preview(s) through the render gates"
+        + (" on Playwright's Chromium, Chrome not being installed" if opened == "bundled" else ""))
+    failures, skipped = [], 0
+    for script, flags, target in gates:
+        verdict = run(script, target, *flags, preload=preload)
+        if verdict == "failed":
+            failures.append(f"{Path(target).relative_to(ROOT).as_posix()}: {script} {' '.join(flags)}".rstrip())
+        elif verdict == "skipped":
+            skipped += 1
+    return failures, skipped
+
+
+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
+    opened: str | None = None  # asked the first time a preview needs a browser, and once
+    with tempfile.TemporaryDirectory() as scratch:
+        preload = Path(scratch) / "preload.cjs"
+        preload.write_text(PRELOAD.replace("{scripts}", json.dumps(str(kit / "scripts/preload.cjs"))))
+        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)) == "failed":
+                    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
+            opened = browser() if opened is None else opened
+            failed, unopened = render_gates(app, screens, opened, preload if opened == "bundled" else None)
+            failures += failed
+            skipped += unopened
+    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 — "
+            "each says above what it could not open")
+        return 1 if required else 0
+    say("check-ux-gates: every gate passed")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{slipwai-1.2.1.dev5 → slipwai-1.2.1.dev11}/assets/toolkit/scripts/extensions/ux-gates/init.py

@@ -54,12 +54,15 @@ the gates in it that are objective: a screen either passes or it does not.
 - **Always:** `{KIT_DIR}/scripts/lint_hardcodes.py` over each browser app's `src/`. A literal colour,
   pixel size or duration outside `tokens.css` fails the build; it is the rule `docs/design.md` already
   states, now measured. A justified exception carries a `ds-allow-hardcode` comment on its line.
-- **Where a browser is present** (`node`, and `playwright` resolvable from the project root): the render
-  gates over every `*.html` under each browser app's `screens/` — contrast in light and dark across
-  default, hover and focus states, visible focus, target size, no overflow at 280/320/414px, and axe. A
-  screen preview under `screens/` is what puts a screen under those gates; the live routes are not
-  rendered, because the gates read files and the app needs its API. With no browser the render gates are
-  reported as skipped, never as passed.
+- **Where a browser is present** (`node`, `playwright` resolvable from the project root, and Chrome or
+  Playwright's own Chromium — `npx playwright install chromium`): the render gates over every `*.html`
+  under each browser app's `screens/` — contrast in light and dark across default, hover and focus states,
+  visible focus, target size, no overflow at 280/320/414px, and axe. A screen preview under `screens/` is
+  what puts a screen under those gates; the live routes are not rendered, because the gates read files and
+  the app needs its API. With no browser the render gates are reported as skipped, never as passed, and the
+  gate says which browser it ran on. A gate that fails or crashes is never made to pass by editing
+  `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:

slipwai-1.2.1.dev11/changelog.d/gates-are-not-the-runs-to-change.md

@@ -0,0 +1,42 @@
+PATCH
+
+**A `/cruise` run can no longer make a gate pass by changing the gate.** A run met `check-ux-gates` failing
+because two of the kit's scripts crash where Chrome is not installed, and the bosun patched
+`scripts/check-ux-gates.py` to report that as skipped, committed it, and went on. Its brief now forbids
+touching anything under `scripts/`, the `Makefile`, anything under `tools/`, CI or a harness's hook settings,
+and says what a gate the tree cannot satisfy becomes: a park with the gate's own words as the reason. The rule
+is held in two places rather than said louder. `.claude/settings.json` runs `scripts/agents/cruise.py guard`
+as Claude Code's `PreToolUse` hook on every editing tool, and in a session the runner started it refuses an
+edit to any of those paths before it lands. And the runner takes the content of every gate and control before
+each iteration and compares it after, on every harness: a file modified, deleted or added — a file installed
+under `tools/` excepted — parks the run at once, names the files on the log entry as `controls_changed`, and
+counts the iteration's last line for nothing. A person's own session meets neither.
+
+**`check-ux-gates` runs on Playwright's own Chromium where Chrome is not installed, and never reports a
+crash as a pass or a failure.** The gate now asks once which browser Playwright can open — Chrome, its bundled
+Chromium, or neither — and where only the bundled one opens, starts every render gate with a Node preload that
+retries the kit's `channel: 'chrome'` launch without the channel, so `verify_responsive.mjs` and
+`verify_target_size.mjs` run there like the kit's other three. Where no browser opens, or Playwright is not
+resolvable, the render gates are counted skipped without running one, and a gate that still fails on its launch
+is reported skipped rather than as a finding; `UX_GATES_REQUIRE=1` still makes every skip a failure.
+
+**`stop --now` returns once the runner has gone, not once it was told to go.** The runner ends the iteration's
+session before it exits, which takes a moment, and a `start` typed the moment `stop --now` returned found the old
+runner still alive and declined to start one — after which nobody was running and the watch seat found nobody to
+watch. It now waits for the runner to be gone, up to thirty seconds, and says so if it is still ending after that.
+
+**`/where-are-we` and `/whats-next` answer beside a running `/cruise`.** Both used to answer as if the person's
+session were about to take the next slice — "Run: /drive S13" while the runner was on S13. Each now runs
+`scripts/agents/cruise.py where` first, a read that prints the runner's iteration, the checkpoint's slice, stage
+and next step, and a park's reason, and puts those lines in the reply; the step for a person is then the runner's,
+with `/cruise`, `/cruise-tell` and `/cruise-stop` as what they can do. Where no runner is running the verb prints
+nothing and both commands answer exactly as before, so nothing changes outside a run.
+
+**`/cruise-watch` takes the watch seat on its own.** `/cruise-status` reads once and stops, and a session that
+typed it to answer a question had left the seat; the way back was `/cruise`, which reads as starting a run.
+`/cruise-watch` sits back down where the feed left off and starts nothing, with the seat's rules — its words
+and `commands/cruise.md`'s are one text — and `make cruise-watch` stays the same seat from a terminal.
+
+**Catch-up.** `slipwai migrate` brings the hook, the runner, the gate and the command text. A run that already
+carries a patched gate is found by `git log -- scripts/` and reverted by hand; the runner parks on the next
+change, not on the standing one.