slipwai 1.3.0.dev8__tar.gz → 1.3.0.dev32__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: slipwai
-Version: 1.3.0.dev8
+Version: 1.3.0.dev32
 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
@@ -458,7 +458,7 @@ is which, what each answer brings, and how a project answers a question again la
 | Document | Covers |
 |---|---|
 | [Work on the factory](docs/maintaining.md) | `make verify` and the gates it runs, how `src/slipwai/` is laid out and the check that keeps it that way, browsing generated starters, and regenerating dependency locks |
-| [Architecture decisions](docs/adr/) | The factory's own decisions, in the shape its `architecture-decisions` skill asks of a generated project. Here that mostly means the shape of something a project persists, because a project's log is the one thing no version of this factory can migrate for it. [`0001`](docs/adr/0001-a-dcb-capable-log.md) covers the log's derived tag index and why stream-per-aggregate stays the default write path. [`0002`](docs/adr/0002-the-guard-a-slice-declares.md) covers the guard a slice declares, and identity modelled while tags are not |
+| [Architecture decisions](docs/adr/) | The factory's own decisions, in the shape its `architecture-decisions` skill asks of a generated project. Here that mostly means the shape of something a project persists, because a project's log is the one thing no version of this factory can migrate for it. [`0001`](docs/adr/0001-a-dcb-capable-log.md) covers the log's derived tag index and why stream-per-aggregate stays the default write path. [`0002`](docs/adr/0002-the-guard-a-slice-declares.md) covers the guard a slice declares, and identity modelled while tags are not; and, for what an *adopted* repository persists, [`0003`](docs/adr/0003-a-wrapped-application-begins-as-a-candidate.md), a wrapped application beginning as a candidate the coding agent confirms |
 | [The canonical toolkit](assets/README.md) | The asset tree: where to edit skills, docs, gate scripts, language and frontend packs, and axis adapters |
 | [What a backend owes](docs/backend-obligations.md) | The checklist behind adding a language or a framework: every axis, every `make` target and which gate runs it, every per-backend table, the choices that belong to the ecosystem rather than to this repository, and what a framework that owns startup provides instead of a hand-written adapter |
 | [Publish the factory to Gitea](docs/publishing.md) | `scripts/publish-to-gitea.py`, cutting a release with `make release`, and the local `pages` server |

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

@@ -429,7 +429,7 @@ is which, what each answer brings, and how a project answers a question again la
 | Document | Covers |
 |---|---|
 | [Work on the factory](docs/maintaining.md) | `make verify` and the gates it runs, how `src/slipwai/` is laid out and the check that keeps it that way, browsing generated starters, and regenerating dependency locks |
-| [Architecture decisions](docs/adr/) | The factory's own decisions, in the shape its `architecture-decisions` skill asks of a generated project. Here that mostly means the shape of something a project persists, because a project's log is the one thing no version of this factory can migrate for it. [`0001`](docs/adr/0001-a-dcb-capable-log.md) covers the log's derived tag index and why stream-per-aggregate stays the default write path. [`0002`](docs/adr/0002-the-guard-a-slice-declares.md) covers the guard a slice declares, and identity modelled while tags are not |
+| [Architecture decisions](docs/adr/) | The factory's own decisions, in the shape its `architecture-decisions` skill asks of a generated project. Here that mostly means the shape of something a project persists, because a project's log is the one thing no version of this factory can migrate for it. [`0001`](docs/adr/0001-a-dcb-capable-log.md) covers the log's derived tag index and why stream-per-aggregate stays the default write path. [`0002`](docs/adr/0002-the-guard-a-slice-declares.md) covers the guard a slice declares, and identity modelled while tags are not; and, for what an *adopted* repository persists, [`0003`](docs/adr/0003-a-wrapped-application-begins-as-a-candidate.md), a wrapped application beginning as a candidate the coding agent confirms |
 | [The canonical toolkit](assets/README.md) | The asset tree: where to edit skills, docs, gate scripts, language and frontend packs, and axis adapters |
 | [What a backend owes](docs/backend-obligations.md) | The checklist behind adding a language or a framework: every axis, every `make` target and which gate runs it, every per-backend table, the choices that belong to the ecosystem rather than to this repository, and what a framework that owns startup provides instead of a hand-written adapter |
 | [Publish the factory to Gitea](docs/publishing.md) | `scripts/publish-to-gitea.py`, cutting a release with `make release`, and the local `pages` server |

slipwai-1.3.0.dev32/VERSION

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

{slipwai-1.3.0.dev8 → slipwai-1.3.0.dev32}/assets/adoption/docs/change-strategy.md

@@ -3,10 +3,11 @@
 > **Experimental.** This page arrived with brownfield adoption and will change as real programmes teach it
 > what it gets wrong. What surprised you belongs on the public issue tracker.
 
-The delivery method is installed. `make verify` is green, the survey says what is here, and `/characterise`
-can pin any behaviour before it changes. Nothing on this page had to be decided for that to happen, and that
-was the point: the method makes every later step safe for an agent to attempt, and only now is the question
-*which* step. This page is the Choose and Slice stages — three strategies, the order to change in, what
+The delivery method is installed. The survey says what is here, `/characterise` can pin any behaviour before
+it changes, and `make verify` runs the build's own commands — green on the day it arrives where the ratchet
+has a baseline to hold them to, and saying plainly what is red where it does not. Nothing on this page had to
+be decided for that to happen, and that was the point: the method makes every later step safe for an agent to
+attempt, and only now is the question *which* step. This page is the Choose and Slice stages — three strategies, the order to change in, what
 to do about data and infrastructure, and the one rule that holds all of it together.
 
 ## Three strategies, not two

{slipwai-1.3.0.dev8 → slipwai-1.3.0.dev32}/assets/adoption/scripts/ratchet.py

@@ -13,7 +13,9 @@ never makes anything else fail, and `make ratchet-tighten` re-records the curren
 A finding is a line of the command's output that names a file in this repository *at a position* — `src/a.js:3:7`,
 `Foo.cs(3,7)` — which is how every linter and type checker reports one; the position is then dropped, so that
 editing above a known finding does not make it look new, and a line that merely mentions a file (`> node
-lint.js`) is not a finding. A test runner names the test rather than a file — `--- FAIL: TestX`, `not ok 3 - adds`,
+lint.js`) is not a finding. A path is resolved against the directory the build runs in as well as the root —
+`project.json` records it, and a wrapped application's commands usually start `cd <its directory> &&` — and
+recorded root-relative either way, so a finding compares the same however the tool that printed it spelled it. A test runner names the test rather than a file — `--- FAIL: TestX`, `not ok 3 - adds`,
 `FAILED tests/test_a.py::test_b`, Surefire's `[ERROR]   ShopTest.adds:42` — and each of those is a finding too,
 `test: <name>`, so that a second failure beside a known one is new and named. Where a red command's output has
 neither, this cannot tell new findings from old: the exit code is compared instead, and the report says so. A
@@ -88,9 +90,37 @@ ROOT = project_root(SCRIPT)
 BASELINE = SCRIPT.parents[1] / "baseline.json"
 
 
-def findings_in(output: str, root: Path) -> list[str]:
+def application_directory(application: str) -> Path:
+    """Where this application's build runs, as `project.json` records it — the repository root for one at `.`.
+
+    A tool prints the paths it found relative to the directory it ran in, and a wrapped application's build
+    usually runs in its own: `cd admin-dev/themes/new-theme && npm exec -- tsc`. Resolving those against the
+    repository root alone found nothing, so every finding in every application not at the root was invisible
+    and the run fell back to comparing the exit code — which passes a second error tomorrow exactly as it
+    passed the first. That is the ratchet not doing the one thing it exists for, silently, on precisely the
+    repositories it was written for.
+    """
+    manifest = ROOT / "project.json"
+    if not manifest.is_file():
+        return ROOT
+    try:
+        recorded = json.loads(manifest.read_text()).get("deployables", {}).get(application, {}).get("path")
+    except (OSError, json.JSONDecodeError, AttributeError):
+        return ROOT
+    if not isinstance(recorded, str) or recorded in ("", "."):
+        return ROOT
+    directory = (ROOT / recorded).resolve()
+    return directory if directory.is_dir() else ROOT
+
+
+def findings_in(output: str, root: Path, where: Path | None = None) -> list[str]:
     """Every line of `output` that names a file in the repository at a position, positions dropped, and every failed
-    test a runner names (`test: <name>`), once each."""
+    test a runner names (`test: <name>`), once each.
+
+    `where` is the directory the command ran in, where that is not the root. A path is looked for under the
+    root first and under `where` second, and either way the key is written root-relative, so a finding reads
+    and compares the same however the tool that reported it spelled it.
+    """
     found: list[str] = []
     for line in output.splitlines():
         if NOT_A_FINDING.match(line):
@@ -100,9 +130,18 @@ def findings_in(output: str, root: Path) -> list[str]:
         def replace(match: re.Match[str]) -> str:
             nonlocal names_a_file
             path = match.group("path")
-            if match.group("position") and (root / path).is_file():
+            if not match.group("position"):
+                return match.group(0)
+            if (root / path).is_file():
                 names_a_file = True
                 return path
+            if where is not None and (where / path).is_file():
+                try:
+                    spelled = (where / path).resolve().relative_to(root).as_posix()
+                except ValueError:  # the command reached outside the repository; not ours to hold
+                    return match.group(0)
+                names_a_file = True
+                return spelled
             return match.group(0)
 
         key = " ".join(LOCATION.sub(replace, line).split())
@@ -172,7 +211,7 @@ def main(argv: list[str]) -> int:
             write_baseline(baseline)
         return 0
 
-    findings = findings_in(output, ROOT)
+    findings = findings_in(output, ROOT, application_directory(application))
     baseline = read_baseline()
     entry = baseline.get(application, {}).get(target)
     if entry is None or os.environ.get("RATCHET_TIGHTEN"):

{slipwai-1.3.0.dev8 → slipwai-1.3.0.dev32}/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.dev32}/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.dev32}/assets/toolkit/scripts/agents/project.py

@@ -760,7 +760,11 @@ def main() -> None:
         if harness is None:
             raise RuntimeError(f'unknown Spec Kit integration "{key}"')
         if harness.get("projectable") is False:
-            raise RuntimeError(f'{harness["name"]} keeps its skills outside the repository and cannot be projected')
+            # The registry's own reason, not a paraphrase of it: a person told "outside the repository" still
+            # has to go and find out *where*, and the row already says. `~/.hermes/skills` is the whole
+            # answer to what to do instead.
+            reason = harness.get("unprojectableReason") or "it cannot be projected into a repository"
+            raise RuntimeError(f'{harness["name"]} cannot be projected: {reason}')
         project(harness)
         if not CHECK:
             done = ("Extension pointers projected" if CONTEXT_ONLY

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

@@ -157,6 +157,7 @@ def drift() -> tuple[dict[str, tuple[str, float]], list[str], list[str]] | None:
     # indexed here as the answer keeps this check from inventing a language table of its own — and
     # from reporting every committed PNG as a hole in the graph.
     suffixes = {Path(path).suffix for path in rows} - {""}
+    last = max((at for _, at in rows.values()), default=0.0)
     missing, changed = [], []
     for path in paths:
         if Path(path).suffix not in suffixes:
@@ -166,6 +167,14 @@ def drift() -> tuple[dict[str, tuple[str, float]], list[str], list[str]] | None:
             continue
         row = rows.get(path)
         if row is None:
+            # A file the index has never seen is a hole only where it appeared *after* the index last ran.
+            # Matching the suffix is not enough: CodeGraph declines files of a language it indexes — a
+            # vendored `bootstrap.min.js` beside a `src/app.js` it read — and which ones is its decision,
+            # not this script's. Reported anyway, a real repository's vendored bundles failed a gate that
+            # `codegraph sync` said was already up to date, and the two tools called each other wrong. The
+            # index records milliseconds and the filesystem seconds.
+            if last and absolute.stat().st_mtime * 1000 <= last:
+                continue
             missing.append(path)
         elif row[0] and digest(absolute) != row[0]:
             changed.append(path)
@@ -190,7 +199,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.dev32}/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.dev32}/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.dev32}/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:]])