slipwai 1.2.1.dev5__tar.gz → 1.2.1.dev8__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: slipwai
-Version: 1.2.1.dev5
+Version: 1.2.1.dev8
 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

{slipwai-1.2.1.dev5 → slipwai-1.2.1.dev8}/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

slipwai-1.2.1.dev8/VERSION

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

{slipwai-1.2.1.dev5 → slipwai-1.2.1.dev8}/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
@@ -1533,7 +1650,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.dev8}/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.dev8/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.dev8}/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.dev8/changelog.d/gates-are-not-the-runs-to-change.md

@@ -0,0 +1,30 @@
+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.
+
+**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.

{slipwai-1.2.1.dev5 → slipwai-1.2.1.dev8}/src/slipwai/project/agent_settings.py

@@ -33,6 +33,11 @@ def compaction_hooks(layout: Layout) -> dict[str, list[dict[str, object]]]:
         "PreCompact": [{"hooks": [{"type": "command", "command": f"python3 {script} compacting"}]}],
         "SessionStart": [{"matcher": "compact", "hooks": [{"type": "command", "command": f"python3 {script} resume"}]}],
         "Stop": [{"hooks": [{"type": "command", "command": f"python3 {script} stopping"}]}],
+        # The editing tools, in a session the runner started: an edit to a gate or a control of the run —
+        # `scripts/`, the Makefile, `tools/`, CI, this file — is refused before it lands; the runner compares the
+        # controls after every iteration for what the shell wrote (`docs/cruise.md`, *When it is blocked*).
+        "PreToolUse": [{"matcher": "Edit|Write|MultiEdit|NotebookEdit",
+                        "hooks": [{"type": "command", "command": f"python3 {script} guard"}]}],
     }
 
 

{slipwai-1.2.1.dev5 → slipwai-1.2.1.dev8}/src/slipwai/project/cruise_agents.py

@@ -134,7 +134,7 @@ preference, and stop at the first that works:
    or `detected` — you work on the survey's value as a stated assumption and never mark it `confirmed` —
    and a change strategy proceeds at `Proposed` on the recommendation.
 3. **Repair the run.** Rebase and resolve, verify a dead delegate's leftovers against the tree and finish or
-   revert them, find why a gate loops and fix the cause.
+   revert them, find why a gate loops and fix the cause in the tree the gate measures.
 
 Every move is an entry in `{DECISIONS}` with `Decided by: {BOSUN}`, its *Would reverse if* naming what a
 person must eventually supply, and a task in the next slice to remove the stub when they do. Commit on the
@@ -145,7 +145,15 @@ destroy data or history (drop a database or volume, rewrite or delete a shared b
 can recover); release what a person has not asked for (turn a flag on, deploy or promote to production,
 merge anything that reaches a real actor); spend or expose (pay for anything, create or reveal a secret,
 widen permissions); weaken security (bypass authentication, loosen a MUST about money, identity or a
-boundary in production code); or discard a person's commits to make a rebase go through. Return
-`unblocked: <what you did, and the entry's number>`, `catastrophic: <why>`, or `cannot: <what you tried>`,
-and the session that delegated you decides whether the run continues or parks.""",
+boundary in production code); discard a person's commits to make a rebase go through; or make a gate pass by
+changing the gate. **A gate is satisfied in the tree it measures, never by editing what measures it**: nothing
+under `scripts/` — the `check-*` gates, this runner — the `Makefile`, anything under `tools/`, CI, or a
+harness's hook settings is yours to touch, whatever it reports. A gate that fails because of the slice's own
+tree is a task in that tree. A gate that fails for a reason the tree cannot fix — a browser this machine has
+not got, a tool that is not installed, a script of the kit's that crashes — is `cannot: <the gate's name and
+its own last lines>`, and the run parks on those words; `{layout.make} verify` reporting a gate as skipped is not a
+failure and needs nothing from you. Claude Code refuses the edit before it lands (`PreToolUse`), and the
+runner parks the run at the end of any iteration that changed one of those files, whatever the last line
+said. Return `unblocked: <what you did, and the entry's number>`, `catastrophic: <why>`, or `cannot: <what
+you tried>`, and the session that delegated you decides whether the run continues or parks.""",
     }

{slipwai-1.2.1.dev5 → slipwai-1.2.1.dev8}/src/slipwai/project/cruise_unblock.py

@@ -20,6 +20,9 @@ CATASTROPHIC = (
     "weakening security — bypassing authentication, loosening a MUST about money, identity or a boundary in "
     "production code",
     "discarding a person's commits to make a checkout consistent",
+    "making a gate pass by changing the gate — anything under `scripts/`, the `Makefile`, anything under `tools/`, CI, "
+    "a harness's hook settings: a gate is satisfied in the tree it measures, or the run parks with the gate's own "
+    "output as the reason",
     "a run the bosun could not move — the blocker survived its attempt, or the attempt itself would need one of the above",
 )
 
@@ -52,4 +55,14 @@ and parks at once.
 
 A park is therefore rare, and it says which of those it met, or what the bosun tried. `python3 {script}
 status` shows a parked run's reason beside its checkpoint.
+
+**A failing gate is never repaired in the gate.** `make verify` red on the slice's own tree is the slice's
+work. Red for a reason the tree cannot fix — a browser this machine has not got, a tool not installed, a
+script of a kit's that crashes — is a park: `cruise: parked: <gate>: <its own last lines>`, so a person
+reads what the gate said and not what an iteration made of it. A gate reported as skipped is neither. This is
+not left to the text: on Claude Code, `python3 {script} guard` runs as the `PreToolUse` hook of every editing
+tool and refuses, in a runner's session, an edit under `scripts/`, `tools/`, the `Makefile`, CI or the hook
+settings before it lands; and the runner compares those files before and after every iteration, on every
+harness, and parks the run on any change — `controls_changed` on the log entry names the files — whatever
+the iteration's last line said. A file installed under `tools/` by `./init --extension` is not a change.
 """

slipwai-1.2.1.dev5/VERSION

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