slipwai 1.3.0.dev15__tar.gz → 1.3.0.dev41__tar.gz

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

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

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

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

{slipwai-1.3.0.dev15 → slipwai-1.3.0.dev41}/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.dev15 → slipwai-1.3.0.dev41}/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.dev15 → slipwai-1.3.0.dev41}/assets/toolkit/scripts/agents/code_index.py

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

{slipwai-1.3.0.dev15 → slipwai-1.3.0.dev41}/assets/toolkit/scripts/agents/project.py

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

{slipwai-1.3.0.dev15 → slipwai-1.3.0.dev41}/assets/toolkit/scripts/extensions/codegraph/init.py

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

{slipwai-1.3.0.dev15 → slipwai-1.3.0.dev41}/assets/toolkit/scripts/extensions/uipro/init.py

@@ -47,6 +47,13 @@ def project_root(script: Path, depth: int) -> Path:
 
 
 ROOT = project_root(Path(__file__).resolve(), 3)
+
+# Where `./init` actually is, from the repository root: beside this script's own tree at the root in a
+# generated project, and under `layout.delivery` where the method was installed beside an existing codebase.
+# Derived rather than written, because "run `./init --extension …`" is advice nobody can follow when the
+# file is `./delivery/init` — the first real adoption to meet it typed `./init` four times.
+DELIVERY = Path(__file__).resolve().parents[3]
+INIT = "./init" if DELIVERY == ROOT else f"./{DELIVERY.relative_to(ROOT).as_posix()}/init"
 MARKER_BEGIN = "<!-- extension:uipro:begin -->"
 MARKER_END = "<!-- extension:uipro:end -->"
 GUIDANCE = f"""
@@ -160,7 +167,7 @@ def main() -> int:
             "was installed and AGENTS.md is unchanged.\n"
             "Add one first, then adopt it here:\n"
             "  slipwai add-frontend web\n"
-            "  ./init --extension uipro",
+            f"  {INIT} --extension uipro",
             file=sys.stderr,
         )
         return 0
@@ -171,7 +178,7 @@ def main() -> int:
             "Install one:\n"
             f"  npm install -g ui-ux-pro-max-cli@{CLI_VERSION}\n"
             "Then adopt it here, which is what points the agent at it:\n"
-            "  ./init --extension uipro",
+            f"  {INIT} --extension uipro",
             file=sys.stderr,
         )
         return 0
@@ -183,7 +190,7 @@ def main() -> int:
             print(
                 f"`{' '.join(command)} init` exited {installed.returncode}: AGENTS.md is unchanged.\n"
                 "Fix what it reported, then adopt it here:\n"
-                "  ./init --extension uipro",
+                f"  {INIT} --extension uipro",
                 file=sys.stderr,
             )
             return 0
@@ -194,7 +201,7 @@ def main() -> int:
                 "AGENTS.md is unchanged.\n"
                 f"This script knows ui-ux-pro-max-cli {CLI_VERSION}; a newer CLI may lay its files out "
                 "differently. Pin the version, or update this script, then:\n"
-                "  ./init --extension uipro",
+                f"  {INIT} --extension uipro",
                 file=sys.stderr,
             )
             return 0

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

@@ -52,6 +52,13 @@ def project_root(script: Path, depth: int) -> Path:
 
 
 ROOT = project_root(Path(__file__).resolve(), 3)
+
+# Where `./init` actually is, from the repository root: beside this script's own tree at the root in a
+# generated project, and under `layout.delivery` where the method was installed beside an existing codebase.
+# Derived rather than written, because "run `./init --extension …`" is advice nobody can follow when the
+# file is `./delivery/init` — the first real adoption to meet it typed `./init` four times.
+DELIVERY = Path(__file__).resolve().parents[3]
+INIT = "./init" if DELIVERY == ROOT else f"./{DELIVERY.relative_to(ROOT).as_posix()}/init"
 MARKER_BEGIN = "<!-- extension:ux-gates:begin -->"
 MARKER_END = "<!-- extension:ux-gates:end -->"
 GUIDANCE = f"""
@@ -182,7 +189,7 @@ def main() -> int:
             "installed and AGENTS.md is unchanged.\n"
             "Add one first, then adopt it here:\n"
             "  slipwai add-frontend web\n"
-            "  ./init --extension ux-gates",
+            f"  {INIT} --extension ux-gates",
             file=sys.stderr,
         )
         return 0
@@ -191,7 +198,7 @@ def main() -> int:
             "`npx` was not found, so the ux-ui-agent-skills kit was not installed and AGENTS.md is "
             "unchanged.\n"
             "Install Node.js, then adopt it here, which is what points the agent at it:\n"
-            "  ./init --extension ux-gates",
+            f"  {INIT} --extension ux-gates",
             file=sys.stderr,
         )
         return 0
@@ -206,7 +213,7 @@ def main() -> int:
         print(
             f"`npx ux-ui-agent-skills@{KIT_VERSION} init` exited {installed.returncode}: AGENTS.md is "
             "unchanged.\nFix what it reported, then adopt it here:\n"
-            "  ./init --extension ux-gates",
+            f"  {INIT} --extension ux-gates",
             file=sys.stderr,
         )
         return 0
@@ -215,7 +222,7 @@ def main() -> int:
             f"The installer did not write {KIT_DIR}/scripts/lint_hardcodes.py, so AGENTS.md is unchanged.\n"
             f"This script knows ux-ui-agent-skills {KIT_VERSION}; a newer kit may lay its files out "
             "differently. Pin the version, or update this script, then:\n"
-            "  ./init --extension ux-gates",
+            f"  {INIT} --extension ux-gates",
             file=sys.stderr,
         )
         return 0

slipwai-1.3.0.dev41/changelog.d/a-refusal-comes-before-the-work.md

@@ -0,0 +1,10 @@
+PATCH
+
+**`slipwai adopt` refuses an unclean tree, a directory that is not a Git repository, or one already holding a
+`project.json` before it surveys anything or asks anything — not after.** The check ran as `adopt` began
+writing, which is the right place for it to be enforced but the wrong place to find out: on a repository of
+twelve thousand files it meant waiting through the survey, answering the interview, and only then being told
+that none of it could be kept. `adopt` still checks when it writes, because it is a library function and that
+contract is its own; the command line now checks first as well.
+
+Part of brownfield adoption, which is experimental (#74): what it offers may change in a MINOR, and what it gets wrong belongs on that issue.

slipwai-1.3.0.dev41/changelog.d/a-wrapped-application-begins-as-a-candidate.md

@@ -0,0 +1,40 @@
+MINOR
+
+**`slipwai adopt` no longer wraps anything in a terminal: every buildable directory the survey finds is
+recorded as a candidate, and which of them is an application is answered by the coding agent, with the code in
+front of it.** [ADR 0003](docs/adr/0003-a-wrapped-application-begins-as-a-candidate.md) has the reasoning and
+the evidence. `Wrap it as the application …? [Y/n]` defaults to yes and is asked of somebody who has not read
+the directory; on the first real monorepo this met, that wrapped three asset bundles and a test suite as
+applications, under names taken from their directories, with every `purpose` left blank — and there was no way
+back, because a re-survey reports an unwrapped directory but has never removed a record.
+
+So `project.json` gained the state it was missing. `deployables` says what somebody has established;
+`candidates` says what was merely found, with the path, the language, the commands the build answers and the
+file that found it. It is the same distinction `unrecorded` already draws for every row of the convergence
+map, and it is why no un-wrap command had to be written: nothing is wrapped, so nothing needs unwrapping.
+
+What follows from it: **`make verify` refuses while nothing is confirmed** and names what confirms one, because
+a gate with nothing to hold has not been given its subject and a green run over zero applications is the false
+assurance this exists to prevent. **The terminal asks one question** — the forge — and shows the rest as facts;
+the language, the kind, the commands, what each directory owns, where the schema and the infrastructure live,
+how a change reaches production and why the work is happening all move to the agent or to a conversation.
+**`/ground` opens with the candidates**, one at a time, saying what it thinks each is and why from what it
+read, before asking. **`slipwai adopt --confirm <name>`** records the answer — with `--as` for a name that is
+not the directory's, and `--kind`, `--purpose`, `--command` and `--hexagonal` for the rest — builds the entry
+and regenerates everything that reads it, so `deployables` is never edited by hand; **`--decline <name>`** drops
+a candidate with nothing recorded in its place. **`--next`** names confirming as the step before the map's rows.
+`--yes` stays the unattended path it has always been: it confirms every candidate as found, and the report now
+says plainly that nobody looked.
+
+This is the only intro. The per-directory interview it replaces — wrap it? language? kind? these commands?
+what does it own? the schema, the infrastructure, the release path, why — is gone, and in a terminal `adopt`
+now runs `./<delivery>/init` once its commit is made unless `--no-init` says otherwise. It arrived behind
+`--experimental-intro` and `SLIPWAI_EXPERIMENTAL_INTRO=1` while it was being built; the flag is still accepted
+and chooses nothing, so a script that passes it keeps working, and the variable is no longer read.
+
+**Catch-up.** Nothing. A repository adopted before this has its applications in `deployables` already, which is
+confirmation by an earlier factory and is left alone; it has no `candidates` key, which reads as an adoption
+with nothing outstanding, and `--confirm` says so rather than inventing work. Two readers of an adopted record
+— `--next` and `--refresh` — now tolerate a manifest with no deployables, which is the honest state between
+`adopt` and the first confirmation; `add-service` still refuses one, since it needs an application to take a
+language and a port from.

slipwai-1.3.0.dev41/changelog.d/adopt-knows-which-agent.md

@@ -0,0 +1,29 @@
+MINOR
+
+**`slipwai adopt` establishes which coding agent the material is for, instead of leaving it to a question
+`./init` asks one step too late.** `./init` projects the canonical skills, commands and agent types into one
+harness's native locations, and it has always asked which — after `adopt` had already finished. That ordering
+makes the answer useless to the adoption itself, because the questions worth handing to a coding agent are the
+ones asked before there is one. It was also mostly answerable without asking: a run started from inside a
+harness is told so by its environment, and a repository whose team already uses one says so in the tree
+(`.claude/skills`, `.gemini/commands`, `.github/copilot-instructions.md`). `adopt` now reads both and records
+the answer in `project.json` under `agent`, with the evidence and `detected` provenance; `--integration <agent>`
+names it outright, recorded `overridden`, and `./init` asks nothing where the record already says. What nothing
+establishes stays `unrecorded` and is said out loud — a directory two harnesses read names neither, a tree that
+reads for two records neither, and a thirty-six-row list is not a question a terminal can ask well — so `./init`
+keeps its own question for exactly the case it is still needed in.
+
+**Catch-up.** Nothing. A repository adopted by an earlier factory has no `agent` key, which reads as the
+question still being open, and `./init --integration <agent>` answers it the way it always did. A re-survey
+carries the key as recorded rather than re-reading it: which agent gets the material is not something the tree
+says.
+
+**`slipwai adopt --init` runs `./init` once the adoption is committed, so a terminal adoption can end in one
+step rather than four.** Off unless asked for: `./init` reaches Spec Kit's source, and making every `--yes` in
+a script or a test need the network to finish would be a poor trade for saving a line. It runs last and never
+inside the commit, so an unreachable source costs the adoption nothing — the commit is already made, the
+failure says so, and `slipwai adopt --next` keeps naming `./init` as the step you are on. What it writes is
+left uncommitted and yours to read, exactly as in a project the factory generated. `--no-init` is the default
+said out loud.
+
+Part of brownfield adoption, which is experimental (#74): what it offers may change in a MINOR, and what it gets wrong belongs on that issue.

slipwai-1.3.0.dev41/changelog.d/adopt-next-and-intro-repair.md

@@ -0,0 +1,23 @@
+MINOR
+
+**`slipwai adopt --next` says where an adopted repository stands in the sequence the adoption report names —
+what is done, what is next, and why — so the plan survives the scrollback.** That report is printed once, at
+the end of the longest output this factory produces, and the sequence it names spans days and four tools;
+`docs/adoption.md` carries the same list but is introduced there as a record of what was wrapped rather than
+as the plan. Nothing is remembered now: every step leaves a mark, and `--next` reads them. Spec Kit writes
+`.specify/integration.json`, the first gate run writes the ratchet baseline, `/ground` moves a row of the
+convergence map off `unrecorded`, the root Makefile gains its `-include`, and a strategy is an accepted ADR
+with a `Strategy:` line. It writes nothing itself, and it names the applications nobody has yet proved start.
+A repository adopted by an earlier version needs nothing: the marks are the ones it was already leaving.
+
+**A recorded command that changes directory first no longer reports the shell's `cd` as a tool this machine
+is missing.** Every build that is not at the repository root is recorded as `cd <dir> && <build>`, and the
+report read the first word off that line and asked the PATH for it — so a repository with four such builds
+was told `` `cd` is not on PATH here `` above a list of all fifteen of their targets, with the one tool that
+really was missing a line among them. The tools a command runs are now every shell segment's program, past
+any leading `VAR=value`, and never one of the shell's own words.
+
+**The questions a terminal cannot answer well move to the coding agent, which can read the code before
+asking.** What a directory is, what it is called, what it owns, and first of all the language, which the line
+above it had already printed. The candidate state is what finished the move; see the entry that introduces
+it.

slipwai-1.3.0.dev41/changelog.d/four-small-things-a-real-run-found.md

@@ -0,0 +1,26 @@
+PATCH
+
+**A flag that describes the adoption is refused on a `--confirm` or `--decline` run, rather than read and
+thrown away.** `slipwai adopt --confirm shop --integration cursor` looked like it recorded a coding agent and
+recorded nothing: the settling path never reads those flags. It now names each one and says where it belongs —
+`--integration` after the method is installed is `./init`'s. The same rule the intro already applies
+to flags that describe an application, and nothing that previously worked stops working: a flag that did
+nothing now says so.
+
+**`check-codegraph` no longer fails a repository for files CodeGraph deliberately declined.** It inferred what
+should be indexed from the suffixes already in the index, so a vendored `bootstrap.min.js` beside a `src/app.js`
+read as a hole in the graph — and a real adoption failed a gate that `codegraph sync` said was already up to
+date, the two tools calling each other wrong. Which files belong in the index is CodeGraph's decision; a file
+the index has never seen is now a finding only where it appeared *after* the index last ran, which is the
+question the check was always asking.
+
+**A harness that cannot be projected says where its skills live instead of only that they are elsewhere.** The
+registry already records the reason — Hermes keeps them at `~/.hermes/skills` — and the refusal now quotes it,
+because a person told "outside the repository" still has to go and find out where.
+
+**`docs/change-strategy.md` stopped opening by asserting that `make verify` is green.** It is written before
+any gate has run, and on a repository whose build tool is not on the machine it is not true. The page says what
+the gate actually does instead: runs the build's own commands, green where the ratchet has a baseline to hold
+them to and plainly red where it does not.
+
+Part of brownfield adoption, which is experimental (#74): what it offers may change in a MINOR, and what it gets wrong belongs on that issue.