slipwai 1.3.0.dev8__tar.gz → 1.3.0.dev15__tar.gz

{slipwai-1.3.0.dev8 → slipwai-1.3.0.dev15}/PKG-INFO

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

slipwai-1.3.0.dev15/VERSION

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

{slipwai-1.3.0.dev8 → slipwai-1.3.0.dev15}/assets/toolkit/scripts/agents/benchmark.py

@@ -12,7 +12,7 @@ slice loop, `specs/<feature>/benchmark.json`. `/drive` opens an entry before a s
     python3 scripts/agents/benchmark.py overview [shop]                   # writes specs/<feature>/benchmark.md; `/benchmark`
     python3 scripts/agents/benchmark.py --json
     python3 scripts/agents/benchmark.py cut-off "<why>"                   # close what an iteration left open; the runner's
-    python3 scripts/agents/benchmark.py check                             # the gate: nothing open, every done slice recorded
+    python3 scripts/agents/benchmark.py check                             # warns: anything open, a done slice unrecorded
 
 Everything that a transcript, `tasks.md`, git or the record itself can say is read from there, never asked:
 wall time; the agent type each delegate ran as, where the transcript attributes one; tokens by model, from the
@@ -605,33 +605,55 @@ def cut_off(reason: str) -> None:
             save(path.parent, record)
 
 
-def done_slices(feature: Path) -> set[str]:
-    """The slices this feature has finished, as the ladder marks them: a row in the register at
-    `slices/README.md`, or `status: implemented` in the event model (`commands/drive.md`, *Ready-set selection*)."""
-    done: set[str] = set()
-    register = feature / "slices/README.md"
-    if register.is_file():
-        for line in register.read_text().splitlines():
-            if not line.strip().startswith("|"):
-                continue
-            first = line.strip().strip("|").split("|")[0].strip().strip("`")
-            found = re.match(r"([A-Za-z]+\d+)\b", first)
-            if found:
-                done.add(found.group(1))
+def implemented() -> list[tuple[str, str | None]]:
+    """Every slice `docs/event-model/model.yaml` marks `status: implemented`, with the feature it names: the
+    `specs/<feature>/` its `spec` or `gwt` path is under, or None where it names none. The model is the whole
+    project's, so a slice in it belongs to one feature, not to every feature that asks."""
     model = ROOT / "docs/event-model/model.yaml"
+    found: list[tuple[str, str | None]] = []
     if model.is_file():
         for block in re.split(r"^\s*- id:\s*", model.read_text(), flags=re.M)[1:]:
             ident = block.split("\n", 1)[0].strip().strip("'\"")
             if ident and re.search(r"^\s*status:\s*implemented\s*$", block, re.M):
-                done.add(ident)
+                named = re.search(r"^\s*(?:spec|gwt):\s*['\"]?specs/([^/\s'\"]+)/", block, re.M)
+                found.append((ident, named.group(1) if named else None))
+    return found
+
+
+def done_slices(feature: Path) -> set[str]:
+    """The slices this feature has finished, as the ladder marks them (`commands/drive.md`, *Ready-set selection*):
+    a row in its register at `slices/README.md`, or `status: implemented` in the event model on a slice that names
+    this feature, or names none and has its folder at `slices/<id>/` here."""
+    done: set[str] = set()
+    register = feature / "slices/README.md"
+    if register.is_file():
+        for line in register.read_text().splitlines():
+            if line.strip().startswith("|"):
+                first = line.strip().strip("|").split("|")[0].strip().strip("`")
+                found = re.match(r"([A-Za-z]+\d+)\b", first)
+                if found:
+                    done.add(found.group(1))
+    for ident, named in implemented():
+        if named == feature.name or (named is None and (feature / "slices" / ident).is_dir()):
+            done.add(ident)
     return done
 
 
+def unowned() -> list[str]:
+    """Implemented slices no feature holds: the model names no feature for them and no `specs/*/slices/<id>/`
+    exists. Not charged to any feature — said, so the model can be given its `spec` or the id corrected."""
+    features = [path for path in (ROOT / "specs").iterdir() if path.is_dir()] if (ROOT / "specs").is_dir() else []
+    return sorted(ident for ident, named in implemented()
+                  if named is None and not any((feature / "slices" / ident).is_dir() for feature in features))
+
+
 def check() -> list[str]:
-    """What the gate holds: no entry left open, a record for every slice the ladder calls done, that record
-    closed, and a feature record once any slice is done — because a delivered slice with no benchmark cannot say
-    what it cost, and the brackets can only be taken at the time."""
-    findings = []
+    """What `check-benchmark` warns of: an entry left open, a slice the ladder calls done with no record or an
+    unclosed one, a feature with done slices and no record above the slice loop, and an implemented slice in the
+    model that no feature holds — because a delivered slice with no benchmark cannot say what it cost."""
+    findings = [f"docs/event-model/model.yaml: {ident} is implemented but names no feature (`spec`/`gwt` under "
+                "specs/<feature>/) and has no specs/*/slices/ folder, so no feature's record is asked for it"
+                for ident in unowned()]
     for path, record in records():
         for entry in record.get("stages", []):
             if "ended" not in entry:
@@ -959,10 +981,14 @@ def main() -> None:
         cut_off(" ".join(rest))
         return
     if command == "check":
+        # A warning, never a failure: the brackets can only be taken at the time, so a slice finished without
+        # one can never be made to pass honestly, and a gate that nothing true satisfies stops every push.
         findings = check()
         if findings:
-            print("\n".join(f"check-benchmark: {finding}" for finding in findings), file=sys.stderr)
-            raise SystemExit(1)
+            print("\n".join(f"check-benchmark: warning: {finding}" for finding in findings), file=sys.stderr)
+            print(f"check-benchmark: {len(findings)} warning(s) above — what was not measured stays unmeasured; "
+                  "not failing verify")
+            return
         held = records()
         print(f"check-benchmark: {len(held)} record(s), nothing open, every done slice recorded and closed"
               if held else "check-benchmark: no record and no done slice yet — nothing to hold")

{slipwai-1.3.0.dev8 → slipwai-1.3.0.dev15}/assets/toolkit/scripts/agents/code_index.py

@@ -92,19 +92,48 @@ def adopted() -> bool:
         return False
 
 
+# Why a machine with Node can still have no `npx` on PATH: a hook's shell, and any non-interactive one, sources no
+# profile, so a Node that nvm, volta or fnm put there is not found by name.
+NO_ROUTE = ("neither `npx` nor `codegraph` is on PATH, nor under nvm, volta or fnm — a hook's or non-interactive "
+            "shell sources no profile, so a Node one of those manages is found only where it keeps its versions")
+
+
+def version_of(directory: Path) -> tuple[int, ...]:
+    return tuple(int(part) for part in re.findall(r"\d+", directory.name)[:3])
+
+
+def managed_node() -> Path | None:
+    """The `bin/` holding `npx` of the newest Node that nvm, volta or fnm installed, or None where none did."""
+    home = Path.home()
+    nvm = Path(os.environ.get("NVM_DIR") or home / ".nvm") / "versions/node"
+    fnm = [Path(os.environ["FNM_DIR"])] if os.environ.get("FNM_DIR") else []
+    fnm += [home / ".local/share/fnm", home / "Library/Application Support/fnm", home / ".fnm"]
+    candidates = sorted(nvm.glob("*/bin"), key=lambda found: version_of(found.parent), reverse=True)
+    candidates.append(Path(os.environ.get("VOLTA_HOME") or home / ".volta") / "bin")
+    for root in fnm:
+        candidates += sorted((root / "node-versions").glob("*/installation/bin"),
+                             key=lambda found: version_of(found.parent.parent), reverse=True)
+    return next((found for found in candidates if (found / "npx").is_file()), None)
+
+
 def route() -> list[str] | None:
-    """How to run the pinned CLI: through `npx` where Node is, or an installed `codegraph` where it is not."""
+    """How to run the pinned CLI: through `npx` where Node is, or an installed `codegraph` where it is not. A Node
+    that nvm, volta or fnm manages counts: its `bin/` goes on this process's PATH, so `npx` finds its `node`."""
     if shutil.which("npx"):
         return ["npx", "-y", CODEGRAPH]
     if shutil.which("codegraph"):
         return ["codegraph"]
-    return None
+    found = managed_node()
+    if found is None:
+        return None
+    os.environ["PATH"] = f"{found}{os.pathsep}{os.environ.get('PATH', '')}"
+    return ["npx", "-y", CODEGRAPH]
 
 
 def cli(*arguments: str, seconds: int = SYNC_SECONDS) -> tuple[bool, str]:
     command = route()
     if command is None:
-        return False, "neither `npx` nor `codegraph` is on PATH"
+        return False, NO_ROUTE
     try:
         done = subprocess.run([*command, *arguments], cwd=ROOT, text=True, capture_output=True, timeout=seconds,
                               stdin=subprocess.DEVNULL, env={**os.environ, "CODEGRAPH_NO_UPDATE_CHECK": "1"})
@@ -116,13 +145,30 @@ def cli(*arguments: str, seconds: int = SYNC_SECONDS) -> tuple[bool, str]:
     return done.returncode == 0, said[-1].strip("│└● ").strip() if said else ""
 
 
+class Unopened(Exception):
+    """The database could not be opened to be checked at all — which says nothing about whether it is sound."""
+
+
 def damage() -> str | None:
-    """Why the database cannot be trusted — it does not open, or SQLite's integrity check fails — or None."""
-    try:
-        with sqlite3.connect(f"{DATABASE.as_uri()}?mode=ro", uri=True) as connection:
-            verdict = connection.execute("PRAGMA integrity_check").fetchone()
-    except sqlite3.Error as error:
-        return str(error)
+    """Why the database cannot be trusted — SQLite's integrity check fails, or the file is not a database — or None.
+    Raises `Unopened` when no read-only open succeeds: that is the environment, not the index.
+
+    A WAL database left with no `-shm` beside it — how CodeGraph leaves one once its daemon exits — is refused by
+    some SQLite builds on a plain read-only open (macOS's system Python: "unable to open database file"), and by any
+    build where the directory is not writable. `immutable=1` reads it without the `-shm`, so the check tries that
+    before it concludes anything; an open failure alone never has a sound database moved aside."""
+    refused: list[str] = []
+    for mode in ("mode=ro", "immutable=1"):
+        try:
+            with sqlite3.connect(f"{DATABASE.as_uri()}?{mode}", uri=True) as connection:
+                verdict = connection.execute("PRAGMA integrity_check").fetchone()
+            break
+        except sqlite3.OperationalError as error:  # cannot open, cannot lock, read-only: no reading of the file
+            refused.append(f"{mode}: {error}")
+        except sqlite3.Error as error:  # the file was read, and it is not a sound database
+            return str(error)
+    else:
+        raise Unopened("; ".join(refused))
     if verdict and verdict[0] == "ok":
         return None
     # SQLite reports every damaged cell on its own line; the first says what kind of damage, the count how much.
@@ -160,6 +206,14 @@ def set_aside() -> str:
     return (ASIDE.relative_to(ROOT)).as_posix()
 
 
+def checked() -> str | Unopened | None:
+    """`damage()`, with an open failure returned rather than raised."""
+    try:
+        return damage()
+    except Unopened as error:
+        return error
+
+
 def health() -> dict[str, Any]:
     """Make the index one an iteration can query, and say what that took: `current`, `synced`, `built`, `rebuilt`,
     `unreachable` (no route to the CLI) or `failed` (the step ran and the index is still not right). Nothing where
@@ -169,14 +223,16 @@ def health() -> dict[str, Any]:
     began = time.monotonic()
     result: dict[str, Any] = {}
     if route() is None:
-        result = {"state": "unreachable", "detail": "neither `npx` nor `codegraph` is on PATH, so nothing can "
-                                                    "maintain or query the index"}
+        result = {"state": "unreachable", "detail": f"{NO_ROUTE}; so nothing can maintain or query the index"}
     elif not DATABASE.is_file():
         done, said = cli("init", "-y", ".", seconds=BUILD_SECONDS)
         result = {"state": "built", "detail": "there was no database; built it with `codegraph init`"}
         if not done:
             result = {"state": "failed", "detail": f"no database, and `codegraph init` failed: {said}"}
-    elif (problem := damage()) is not None:
+    elif isinstance(problem := checked(), Unopened):
+        result = {"state": "failed", "detail": f"the database could not be opened to be checked ({problem}); left "
+                                               "it where it is, since an open failure says nothing about the index"}
+    elif problem is not None:
         where = set_aside()
         done, said = cli("init", "-y", ".", seconds=BUILD_SECONDS)
         result = {"state": "rebuilt", "detail": f"the database failed its integrity check ({problem}); moved it "
@@ -195,7 +251,7 @@ def health() -> dict[str, Any]:
         else:
             result = {"state": "current", "detail": "opens, passes its integrity check, and describes the tree"}
     if result["state"] in ("built", "rebuilt", "synced"):
-        problem, stale = (damage() if DATABASE.is_file() else "no database was written"), None
+        problem, stale = (checked() if DATABASE.is_file() else "no database was written"), None
         if problem is None:
             stale = behind()
         if problem is not None or stale:
@@ -212,13 +268,16 @@ def symbols(names: list[str]) -> set[str]:
     """Which of these names the index holds a definition of."""
     if not names or not DATABASE.is_file():
         return set()
-    try:
-        with sqlite3.connect(f"{DATABASE.as_uri()}?mode=ro", uri=True) as connection:
-            marks = ",".join("?" * len(names))
-            return {row[0] for row in connection.execute(
-                f"SELECT DISTINCT name FROM nodes WHERE kind NOT IN ('file', 'import') AND name IN ({marks})", names)}
-    except sqlite3.Error:
-        return set()
+    marks = ",".join("?" * len(names))
+    for mode in ("mode=ro", "immutable=1"):  # the second for a WAL database with no `-shm`, as `damage()` says
+        try:
+            with sqlite3.connect(f"{DATABASE.as_uri()}?{mode}", uri=True) as connection:
+                return {row[0] for row in connection.execute(
+                    f"SELECT DISTINCT name FROM nodes WHERE kind NOT IN ('file', 'import') AND name IN ({marks})",
+                    names)}
+        except sqlite3.Error:
+            continue
+    return set()
 
 
 def symbol_of(pattern: str) -> str | None:

{slipwai-1.3.0.dev8 → slipwai-1.3.0.dev15}/assets/toolkit/scripts/check-codegraph.py

@@ -190,7 +190,13 @@ def main() -> int:
               "check")
         return 0
     tooling = code_index()
-    problem = tooling.damage()
+    try:
+        problem = tooling.damage()
+    except tooling.Unopened as error:
+        print(f"check-codegraph: .codegraph/codegraph.db could not be opened to be checked ({error}). That is "
+              "this environment's SQLite or the directory's permissions, not damage, so the database was left "
+              "alone; `codegraph status` says whether the index itself is current", file=sys.stderr)
+        return 1
     repairing = os.environ.get("CODEGRAPH_GATE_NO_SYNC") != "1" and tooling.route() is not None
     repaired = ""
     if problem is not None and repairing:

{slipwai-1.3.0.dev8 → slipwai-1.3.0.dev15}/assets/toolkit/scripts/check-decisions.py

@@ -23,7 +23,13 @@ an unwritten row is a pass that has to be run again, and until now nothing notic
   **Evidence**, **Feedback**; every **Evidence** path exists, beside the log or from the root, or is `none`;
 - every slice the ladder calls done — a row in `specs/<feature>/slices/README.md`, or `status: implemented` in
   `docs/event-model/model.yaml` — has a `## <slice-id> · …` row in `specs/<feature>/adversary-log.md`: the attack,
-  or the recorded skip, that `/adversary` writes after every acceptance.
+  or the recorded skip, that `/adversary` writes after every acceptance. The model is the whole project's, so a
+  slice in it counts for the feature its `spec` or `gwt` path is under, or, naming none, the one holding
+  `slices/<id>/`; an implemented slice no feature holds is noted, not charged to every feature.
+
+`python3 scripts/check-decisions.py --adversary-baseline` is for a project that migrated across that last rule: it
+writes, once, a `## <id> · predates the adversary gate · <date>` row for every done slice without one, which the gate accepts
+and which says the slice was never attacked. A second baseline is refused.
 
 A project with no record anywhere passes and says so: the gate runs in `make verify` from the first commit.
 """
@@ -32,6 +38,7 @@ from __future__ import annotations
 
 import re
 import sys
+from datetime import date
 from pathlib import Path
 
 
@@ -149,8 +156,25 @@ def check_demo_log(path: Path) -> list[str]:
     return findings
 
 
+def implemented() -> list[tuple[str, str | None]]:
+    """Every slice `docs/event-model/model.yaml` marks `status: implemented`, with the feature it names: the
+    `specs/<feature>/` its `spec` or `gwt` path is under, or None where it names none. The model is the whole
+    project's, so a slice in it belongs to one feature, not to every feature that asks."""
+    model = ROOT / "docs/event-model/model.yaml"
+    found: list[tuple[str, str | None]] = []
+    if model.is_file():
+        for block in re.split(r"^\s*- id:\s*", model.read_text(), flags=re.M)[1:]:
+            ident = block.split("\n", 1)[0].strip().strip("'\"")
+            if ident and re.search(r"^\s*status:\s*implemented\s*$", block, re.M):
+                named = re.search(r"^\s*(?:spec|gwt):\s*['\"]?specs/([^/\s'\"]+)/", block, re.M)
+                found.append((ident, named.group(1) if named else None))
+    return found
+
+
 def done_slices(feature: Path) -> set[str]:
-    """The slices this feature has finished, as the ladder marks them (`commands/drive.md`, *Ready-set selection*)."""
+    """The slices this feature has finished, as the ladder marks them (`commands/drive.md`, *Ready-set selection*):
+    a row in its register at `slices/README.md`, or `status: implemented` in the event model on a slice that names
+    this feature, or names none and has its folder at `slices/<id>/` here."""
     done: set[str] = set()
     register = feature / "slices/README.md"
     if register.is_file():
@@ -160,15 +184,20 @@ def done_slices(feature: Path) -> set[str]:
                 found = re.match(r"([A-Za-z]+\d+)\b", first)
                 if found:
                     done.add(found.group(1))
-    model = ROOT / "docs/event-model/model.yaml"
-    if model.is_file():
-        for block in re.split(r"^\s*- id:\s*", model.read_text(), flags=re.M)[1:]:
-            ident = block.split("\n", 1)[0].strip().strip("'\"")
-            if ident and re.search(r"^\s*status:\s*implemented\s*$", block, re.M):
-                done.add(ident)
+    for ident, named in implemented():
+        if named == feature.name or (named is None and (feature / "slices" / ident).is_dir()):
+            done.add(ident)
     return done
 
 
+def unowned() -> list[str]:
+    """Implemented slices no feature holds: the model names no feature for them and no `specs/*/slices/<id>/`
+    exists. Not charged to any feature — said, so the model can be given its `spec` or the id corrected."""
+    features = [path for path in (ROOT / "specs").iterdir() if path.is_dir()] if (ROOT / "specs").is_dir() else []
+    return sorted(ident for ident, named in implemented()
+                  if named is None and not any((feature / "slices" / ident).is_dir() for feature in features))
+
+
 def check_adversary_rows() -> list[str]:
     """A finished slice with no row in the adversary log was never attacked and never recorded as skipped."""
     findings: list[str] = []
@@ -185,7 +214,47 @@ def check_adversary_rows() -> list[str]:
     return findings
 
 
+PREDATES = "predates the adversary gate"
+
+
+def baseline() -> int:
+    """Write, once, a row for every done slice the adversary log lacks, saying it was finished before this gate held
+    finished slices to the log — which is true, and which no later slice may cite as an attack. For a project that
+    migrated across the gate, whose history cannot be attacked honestly after the fact; refused where any log
+    already carries a baseline row, so it is the done set at one moment and not a way past the gate afterwards."""
+    logs = sorted(SPECS.glob(f"*/{ADVERSARY_LOG}")) if SPECS.is_dir() else []
+    taken = [log for log in logs if f"· {PREDATES}" in log.read_text()]
+    if taken:
+        print(f"check-decisions: a baseline was already taken ({taken[0].relative_to(ROOT).as_posix()}); a slice "
+              "finished since is held to a row `/adversary` writes", file=sys.stderr)
+        return 1
+    written = 0
+    today = date.today().isoformat()
+    for feature in sorted(SPECS.iterdir()) if SPECS.is_dir() else []:
+        if not (feature / "slices").is_dir():
+            continue
+        log = feature / ADVERSARY_LOG
+        text = log.read_text() if log.is_file() else f"# Adversary log — {feature.name}\n"
+        missing = sorted(done_slices(feature) - set(re.findall(r"^## (\S+) · ", text, re.M)))
+        if not missing:
+            continue
+        rows = "".join(f"\n## {ident} · {PREDATES} · {today}\n\nFinished before `check-decisions` held every done "
+                       "slice to a row here. Never attacked by `/adversary`, so no slice may cite this row as "
+                       "coverage.\n" for ident in missing)
+        log.write_text(text.rstrip("\n") + "\n" + rows)
+        written += len(missing)
+        print(f"check-decisions: {log.relative_to(ROOT).as_posix()}: {len(missing)} baseline row(s)")
+    print(f"check-decisions: baselined {written} done slice(s)" if written
+          else "check-decisions: every done slice already has a row — nothing to baseline")
+    return 0
+
+
 def main() -> int:
+    if sys.argv[1:] == ["--adversary-baseline"]:
+        return baseline()
+    for ident in unowned():
+        print(f"check-decisions: note: {ident} is implemented in docs/event-model/model.yaml but names no feature "
+              "and has no specs/*/slices/ folder, so no adversary log is asked for it")
     decisions = sorted(SPECS.glob(f"*/{DECISIONS}")) if SPECS.is_dir() else []
     logs = sorted(SPECS.glob(f"*/slices/*/{DEMO_LOG}")) if SPECS.is_dir() else []
     findings: list[str] = check_adversary_rows()

{slipwai-1.3.0.dev8 → slipwai-1.3.0.dev15}/assets/toolkit/scripts/check-ux-gates.py

@@ -47,8 +47,8 @@ import sys
 import tempfile
 import threading
 from concurrent.futures import ThreadPoolExecutor
-from dataclasses import dataclass
 from pathlib import Path
+from typing import NamedTuple
 
 KEY = "ux-gates"
 KIT = "tools/ux-gates"
@@ -156,9 +156,10 @@ def say(line: str) -> None:
         print(line, flush=True)
 
 
-@dataclass(frozen=True)
-class Gate:
-    """One run of one kit script: over an app's `src/`, its `screens/` directory, or one preview in it."""
+class Gate(NamedTuple):
+    """One run of one kit script: over an app's `src/`, its `screens/` directory, or one preview in it. A tuple
+    rather than a dataclass, which looks its module up in `sys.modules`: a project's test that loads this file with
+    `importlib` and does not register it there would crash on the class instead of testing it."""
 
     app: Path
     script: str
@@ -340,7 +341,8 @@ def main() -> int:
     if spec:
         sharded = shard(gates, spec)
         if sharded is None:
-            say(f"check-ux-gates: UX_GATES_SHARD={spec} is not k/n with 1 <= k <= n — FAILING rather than guessing")
+            say(f"check-ux-gates: UX_GATES_SHARD={spec} is not k/n with 1 <= k <= n — FAILING rather than guessing; "
+                "leave it unset to run every gate")
             return 1
         gates = sharded
         say(f"check-ux-gates: shard {spec} — {len(gates)} of {whole} gate(s)")

{slipwai-1.3.0.dev8 → slipwai-1.3.0.dev15}/assets/toolkit/scripts/codegraph

@@ -17,12 +17,12 @@ from pathlib import Path
 
 sys.dont_write_bytecode = True
 sys.path.insert(0, str(Path(__file__).resolve().parent / "agents"))
-from code_index import ROOT, route  # noqa: E402
+from code_index import NO_ROUTE, ROOT, route  # noqa: E402
 
 command = route()
 if command is None:
-    sys.exit("scripts/codegraph: neither `npx` nor `codegraph` is on PATH, so the index cannot be asked here; install "
-             "Node, and say that the answer you give instead is a text search")
+    sys.exit(f"scripts/codegraph: {NO_ROUTE}. The index cannot be asked here; install Node (or put the one you have "
+             "on PATH), and say that the answer you give instead is a text search")
 os.chdir(ROOT)
 os.environ.setdefault("CODEGRAPH_NO_UPDATE_CHECK", "1")
 os.execvp(command[0], [*command, *sys.argv[1:]])

slipwai-1.3.0.dev15/changelog.d/gates-a-migration-can-pass.md

@@ -0,0 +1,33 @@
+MINOR
+
+**A migration no longer lands on gates nothing true can satisfy: `check-benchmark` warns rather than fails, the one
+event model charges a slice to its own feature, and a project's slice history can be baselined for the adversary
+log once.** A project migrating from a 1.2.0 snapshot met two gates that arrived in 1.2.0 without a word in its
+catch-up note. `check-benchmark` failed on every slice finished before benchmark records existed, and those records
+can only be taken at the time, so the only ways to pass were to invent them or never push again. It now prints
+each of those findings as a `warning:` and passes, and its own self-test is still what fails it. Both it and
+`check-decisions` counted every `status: implemented` slice in `docs/event-model/model.yaml`, which is the whole
+project's, against every feature they checked: a second feature failed for the first feature's slices, and
+nothing done inside the second could fix that. A slice now counts only for the feature its `spec` or `gwt` path
+is under, or, where it names none, the feature holding `slices/<id>/`. An implemented slice that no feature holds
+is reported once. `python3 scripts/check-decisions.py --adversary-baseline` writes, once, a `## <id> · predates
+the adversary gate · <date>` row for every done slice with no row. The gate accepts that row. The row says the
+slice was never attacked, and `/adversary` never relies on it. A second baseline is refused.
+
+Four smaller fixes, found on the same migration. `make verify` now runs `check-python` first, and it names the
+interpreter when `python3` is older than the 3.10 the gate scripts need. Before this, a non-interactive macOS
+shell that found `/usr/bin/python3` (3.9) first died inside whichever gate first used a newer feature.
+`check-codegraph` and `code_index.py health` now tell a database they cannot open apart from a damaged one. On
+macOS's system SQLite, CodeGraph's WAL database with no `-shm` beside it refuses a read-only open. It is now
+read with `immutable=1`, and an open failure is reported as one and never moves the database aside, so `health`
+no longer rebuilds a sound index in a loop. The code index finds a Node that nvm, volta or fnm installed when a
+hook's shell has none on `PATH`, and says that is the likely cause when it finds none. `check-ux-gates.py` can
+now be loaded with `importlib` without being registered in `sys.modules`, and it says to unset an
+`UX_GATES_SHARD` value it refuses.
+
+**Catch-up.** These gates are new or stricter since 1.1: `check-benchmark` (warns since this release),
+`check-decisions`' adversary rows (1.2.0), `check-deploy-role` on `aws` (1.3.0), `check-ux-gates` sharding and
+its CI job (1.3.0), and `check-python` (1.3.0). If `check-decisions` reports `no row for` slices finished
+before you migrated, run `python3 scripts/check-decisions.py --adversary-baseline` once and commit the rows it
+writes. Slices finished after that need the row `/adversary` writes. Make sure the `python3` your shell finds
+first is 3.10 or newer. Nothing else needs doing: the rest arrives whole with the merge.

{slipwai-1.3.0.dev8 → slipwai-1.3.0.dev15}/changelog.d/ux-gates-at-scale.md

@@ -14,4 +14,8 @@ on a pull request and whole on `main`. Until now the generated CI never installe
 were reported skipped there on every run; they are now measured before a deploy, which waits on `verify`.
 
 **Catch-up.** Run `./init --extension ux-gates` once in a project that adopted the gates, and commit the job it
-adds to `.github/workflows/verify.yml`. A project that wrote its own UX-gate job should remove it first.
+adds to `.github/workflows/verify.yml`. A project that wrote its own UX-gate job should remove it first. A project that patched the gate should know
+what the upstream script no longer takes: `UX_GATES_SHARD` accepts only `k/n` (`1 <= k <= n`), and any other
+value — `none` included — fails the gate, so unset it to run every gate; and `check-ux-gates.py`'s entry points
+are `main()` and the `UX_GATES_*` variables, its helpers are not a contract, and a test that loads it with
+`importlib` should call `main()` with the environment set rather than reach into them.

{slipwai-1.3.0.dev8 → slipwai-1.3.0.dev15}/src/slipwai/project/adversary.py

@@ -113,7 +113,9 @@ Findings: none | …
 
 Each selected seam records its file manifest, the type that ran it, its model, and `delegated, fresh
 context`; each omitted seam records why it was not spawned. A skip is a row too, naming the rows it relied
-on, with `Spawned:` empty. Findings include **no findings**, since an empty result is exactly what makes the
+on, with `Spawned:` empty. A `predates the adversary gate` row — written once by `check-decisions.py
+--adversary-baseline` for slices finished before the log was held — records that nothing was attacked, and is
+never a row a skip may rely on. Findings include **no findings**, since an empty result is exactly what makes the
 next slice's skip decidable.
 
 Once every adversary has reported, triage each finding as confirmed, question, duplicate or declined, then

{slipwai-1.3.0.dev8 → slipwai-1.3.0.dev15}/src/slipwai/project/agent_targets.py

@@ -2,7 +2,9 @@
 
 Its own module because `makefile.py` sits at the line budget `scripts/check-structure.py` holds every module
 to, and because these targets are about the method rather than any service's toolchain: nothing here is per
-backend. `check-agents` is where every settings file the ladder reads is held to its shape — the models table,
+backend. `check-python` comes first on `verify` because every gate is a `python3 scripts/…` line, and which
+interpreter a shell finds first decides whether they run: one older than the scripts is named once, rather than
+as whichever gate first uses a newer feature. `check-agents` is where every settings file the ladder reads is held to its shape — the models table,
 `drive.json` and `cruise.json` — so a hand edit that would leave `/drive` or `/cruise` reading nonsense fails
 the gate rather than the run. `check-decisions` holds the decision log and demo log `/cruise` writes to their
 shape, and sits on `verify` because a person overrides a decision by editing that file.
@@ -12,7 +14,9 @@ from __future__ import annotations
 
 def agent_targets() -> str:
     """The `.PHONY` block between the npm workspace targets and the native gate targets."""
-    return """.PHONY: agents agents-list check-extensions check-agents models check-benchmark benchmark cruise cruise-watch cruise-status cruise-stop cruise-tell check-decisions
+    return """.PHONY: check-python agents agents-list check-extensions check-agents models check-benchmark benchmark cruise cruise-watch cruise-status cruise-stop cruise-tell check-decisions
+check-python: ## Fail, first, when python3 is older than the 3.10 every gate script is written for
+\t@python3 -c "import sys; sys.exit(0 if sys.version_info >= (3, 10) else 'check-python: ' + sys.executable + ' is Python ' + sys.version.split()[0] + ', and the gate scripts need 3.10 or newer; put a newer python3 first on PATH (a non-interactive macOS shell finds /usr/bin/python3, which is 3.9, before Homebrew)')"
 agents: ## Refresh elected extensions, then skills, commands and agent types in every installed agent harness
 \tpython3 scripts/extensions/project.py
 \tpython3 scripts/agents/project.py
@@ -25,7 +29,7 @@ check-agents: ## Fail when an initialized agent projection has drifted, or .spec
 \tpython3 scripts/agents/models.py --check && python3 scripts/agents/drive.py --check && python3 scripts/agents/cruise.py --check
 models: ## Show which model runs each stage of /drive for the installed harness, and why
 \tpython3 scripts/agents/models.py
-check-benchmark: ## Fail when a benchmark entry is left open, a done slice has no record, or the script's own behaviour regresses
+check-benchmark: ## Fail when the benchmark script's own behaviour regresses; warn of an entry left open or a done slice with no record
 \tpython3 scripts/test_benchmark.py && python3 scripts/agents/benchmark.py check
 benchmark: ## Show what each slice cost and how each stage of /drive did, from the records under specs/
 \tpython3 scripts/agents/benchmark.py

{slipwai-1.3.0.dev8 → slipwai-1.3.0.dev15}/src/slipwai/project/benchmark.py

@@ -67,8 +67,9 @@ the bracket whose stage owns the type that ran them, so a skipper round during i
 and not the implementers. An entry a session leaves open is cut off — by the `/cruise` runner when the iteration
 ends, and by the next `start` in the same record — with the reason, its tokens read from the transcript it left,
 and no signals: nothing will close it truthfully afterwards. `{layout.make}
-check-benchmark`, in `{layout.make} verify`, fails on an entry still open, on a slice the ladder calls done with no
-record or an unclosed one, and on a feature with done slices and no record above the slice loop. Close
+check-benchmark`, in `{layout.make} verify`, warns of an entry still open, a slice the ladder calls done with no
+record or an unclosed one, and a feature with done slices and no record above the slice loop — warns, never fails,
+because a bracket missed cannot be taken afterwards. Close
 `adversary` after its findings are triaged and before any fix, passing `findings=N` and `seams=N`; each
 failing test and fix belongs to a new
 `implement` entry. Bracket `demo` around the actor's session, not the note afterwards, and `mutation` around the

{slipwai-1.3.0.dev8 → slipwai-1.3.0.dev15}/src/slipwai/project/docs.py

@@ -108,7 +108,7 @@ other direction \u2014 that minimum CD and the practices the skills teach are st
 
 `make verify` is the deterministic local and CI entry point. It runs {gate}{(" plus Biome, TypeScript and React component tests for " + web_paths if web else "")}, architecture direction,
 agent-projection and Spec Kit manifest drift, constitution coverage, event-model validation in the event profile,
-and `check-benchmark`, which fails on a benchmark entry left open or a done slice with no record, and
+and `check-benchmark`, which warns of a benchmark entry left open or a done slice with no record, and
 keeps missing measurements visibly unbracketed. `make help` lists integration,
 adversarial, mutation, model, benchmark and dependency-audit targets. Mutation and dependency audit remain
 explicit end-of-phase/CI operations, not hidden costs in every local increment.

{slipwai-1.3.0.dev8 → slipwai-1.3.0.dev15}/src/slipwai/project/makefile.py

@@ -158,7 +158,7 @@ def makefile(project_name: str, profile: str, apps: list[App], target: str = "no
     if formatting:
         formatting = f"format: ## Rewrite this project's own code the way `make lint` expects to find it\n\t{formatting}\n"
     verify_dependencies = (
-        "lint typecheck check-imports check-migrations check-slice-scope check-extensions check-agents check-speckit "
+        "check-python lint typecheck check-imports check-migrations check-slice-scope check-extensions check-agents check-speckit "
         "check-codegraph check-ux-gates check-constitution check-benchmark check-decisions test"
     )
     style_target = ""

slipwai-1.3.0.dev8/VERSION

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