slipwai 1.3.0.dev15__tar.gz → 1.3.0.dev32__tar.gz

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

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

slipwai-1.3.0.dev32/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.dev32/changelog.d/a-wrapped-application-begins-as-a-candidate.md

@@ -0,0 +1,37 @@
+MINOR
+
+**Under `--experimental-intro`, `slipwai adopt` no longer wraps anything: 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.
+
+Default off. Without `--experimental-intro` (or `SLIPWAI_EXPERIMENTAL_INTRO=1`) `adopt` asks exactly what it
+asked before, wraps what it always wrapped, and writes no `candidates` key.
+
+**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.dev32/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.dev32/changelog.d/adopt-next-and-intro-repair.md

@@ -0,0 +1,25 @@
+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.
+
+**`slipwai adopt --experimental-intro` turns on the reshaped adoption intro while it is being built.** The
+questions a terminal cannot answer well — what a directory is, what it is called, what it owns — are being
+moved to the coding agent, which can read the code before asking. The switch (or `SLIPWAI_EXPERIMENTAL_INTRO=1`)
+is how to walk that shape before it is the only one; today it removes the first of them, the language, which
+the line above it has already printed and which `--language NAME=LANGUAGE` still corrects. Default off:
+without it the interview asks exactly what it asked before. Experimental within an experiment (#74).

slipwai-1.3.0.dev32/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 reshaped 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.

slipwai-1.3.0.dev32/changelog.d/ground-asks-how-much-to-explain.md

@@ -0,0 +1,18 @@
+PATCH
+
+**`/ground` asks, before anything about the repository, how much each answer should explain itself — and holds
+to the answer.** Spelling out what every option writes, what moves because of it and what it costs is what
+somebody meeting a codebase or this method for the first time needs to answer safely; it is also how a
+question set becomes a wall to skim for somebody on their second adoption who already knows what confirming
+an application does. So it is asked once, the agent says which it would pick for this person and why, and
+either form can be changed at any question. The short form drops the elaboration and not the honesty: what
+the agent thinks and why, from what it read, stays, and *I don't know* stays an answer on offer.
+
+**And `slipwai adopt --refresh` no longer drops the outstanding candidates and the recorded agent.** A
+re-survey reads the tree, and neither is a fact about the tree — a candidate is a question nobody has
+answered yet, and which coding agent gets the material is `./init`'s. Rebuilding the record without them left
+`project.json` holding two candidates while the `/ground` regenerated in the same run had lost the section
+that asks about them: a generated file disagreeing with the record it is generated from, which is the one
+thing this must not do. Found by running the command over a real adoption mid-way through.
+
+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.dev32/changelog.d/ground-says-what-an-answer-does.md

@@ -0,0 +1,18 @@
+PATCH
+
+**`/ground` now has to say what each answer on offer will do, not just what it is called.** The first real run
+of the command over a brownfield monorepo produced a page of sound reasoning per candidate and then collapsed
+it into option labels — *Yes — hold its lint*, *Yes, as recommended* — and the person answering it replied
+"Not sure, what do you think?" and, once, "check yourself". A person reads the options, not the paragraph
+above them, so that is where the consequence has to be: each answer names what it writes, what moves because
+of it, and what it costs. Three rules go with it: a question the tree can settle is read and settled rather
+than put as a menu; a recommendation always comes with the reasoning that produced it, never a bare list; and
+*I don't know* is offered as one of the answers every time rather than merely accepted when volunteered,
+because a question that does not offer it manufactures an answer.
+
+**And a runtime past its end of life is named once, however many applications run it.** The platform record
+holds a row per application per product, so a repository whose four npm packages all run Node 20 had the same
+sentence four times under the strategy's `because` and four more under its `before`. The reader needs the
+products; a product is its title and its version.
+
+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.dev32/changelog.d/the-gate-is-green-after-ground.md

@@ -0,0 +1,18 @@
+PATCH
+
+**`slipwai adopt --confirm` and `--refresh` now re-derive the harness projections, so `make verify` is not red
+the moment `/ground` finishes.** Confirming a candidate changes which languages the record names, which
+rewrites the skills' prose, which makes every copy under `.claude/skills/` differ from its canonical source —
+and `check-agents` fails. Both real adoptions hit it and fixed it by hand with `make agents`. The factory
+writes the canonical files, so the factory re-derives what copies them, exactly as `migrate` already does
+after a merge. A projector that cannot run is reported rather than raised: the record is written and good
+either way.
+
+**And the typecheck the survey proposes for a TypeScript directory with no script of its own now passes
+`--skipLibCheck`.** A bare `tsc --noEmit` gave seventeen errors on a real adoption, every one of them inside
+`node_modules` where two dependencies ship disagreeing types — nothing the project can fix, and the ratchet
+baselines the whole failure as a blanket excuse for the check. With lib types skipped the same tree is green,
+and a type error the project actually wrote is what turns it red. A directory with its own `typecheck` script
+keeps it, whatever it says.
+
+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.dev32/changelog.d/the-ratchet-sees-findings-below-the-root.md

@@ -0,0 +1,19 @@
+PATCH
+
+**The ratchet now sees findings in an application that is not at the repository root — which, until now, it
+never did.** A tool prints the paths it found relative to the directory it ran in, and a wrapped application's
+build runs in its own: `cd admin-dev/themes/new-theme && npm exec -- tsc`. Every path it reported was resolved
+against the repository root alone, where nothing of that name exists, so the run found no findings at all and
+fell back to comparing the exit code — which passes a second error tomorrow exactly as it passed the first.
+On a real adoption a plain type error in the project's own source was invisible to it. That is the ratchet
+failing at the one thing it exists for, silently, on precisely the repositories it was written for: the ones
+whose applications live in subdirectories. A path is now resolved against the directory the build runs in as
+well as the root — `project.json` records it — and recorded root-relative either way, so a finding compares
+the same however the tool that printed it spelled it.
+
+**Catch-up.** An adopted repository with an application below its root should re-record: its `lint` or
+`typecheck` entry in `baseline.json` is almost certainly `{"exit": N, "findings": []}`, which excused the whole
+command. `make ratchet-tighten` after reading what the command actually reports replaces it with the findings
+that are really there, and the gate holds to no new ones from then on.
+
+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.dev32/changelog.d/the-record-catches-up-with-init.md

@@ -0,0 +1,20 @@
+PATCH
+
+**`slipwai adopt` no longer names `./init` as the next step and then runs it two lines later.** Where
+`--init` is going to run it, the report says it is running now and what that leaves for you to commit; the
+rest of the sequence is unchanged, since only the first line was ever about that step.
+
+**And where `adopt` could not tell which coding agent the material was for, the record now catches up with
+the answer `./init` collected.** Handing the question on was right — a tree that reads for three harnesses is
+a decision and not a guess — but the answer then existed only in Spec Kit's own file while `project.json`
+still said nobody had established one, and `slipwai adopt --next` went on offering `--integration` for a
+question somebody had already answered. `harness.py` now reads `.specify/integration.json` as a source of its
+own, and the strongest one: a person answered `./init`, so it is recorded `confirmed`, and it outranks both
+the environment a run started in and what the tree reads, which are readings rather than answers. A record
+that already names a harness is left alone, and one a person overrode is never moved by a later step.
+
+Found by running the reshaped intro over PrestaShop, whose tree reads for Claude Code, GitHub Copilot and
+Gemini CLI at once — which is the case the ambiguity rule was written for, and the first time it has been met
+in the wild.
+
+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.dev15 → slipwai-1.3.0.dev32}/src/slipwai/adopt.py

@@ -67,6 +67,13 @@ class Answers:
     # stands as `detected`, or as `unrecorded` where the tree said nothing.
     ci: dict = field(default_factory=dict)
     release: dict = field(default_factory=dict)
+    # `{"harness": ..., "evidence": ..., "provenance": ...}` from `harness.py`: which coding agent `./init`
+    # projects into. Empty means nobody said and nothing showed, and `./init` keeps its own question.
+    agent: dict = field(default_factory=dict)
+    # Buildable directories found and not yet confirmed (ADR 0003). Under the reshaped intro this carries
+    # every one of them and `applications` is empty; under the interview it is empty and `applications`
+    # carries what the person confirmed in the terminal.
+    candidates: list = field(default_factory=list)
 
 
 def check_repository(root: Path) -> None:
@@ -128,6 +135,31 @@ def proposed(found: Survey, name: str) -> list[App]:
     return apps
 
 
+def candidates_of(found: Survey, name: str) -> list[dict]:
+    """Every buildable directory the survey found, as a candidate record: what `proposed` would have made an
+    application of, plus the evidence that found it, and confirmed by nobody.
+
+    The same directories `proposed` reads, so that confirming one produces exactly the application the old
+    interview would have recorded had somebody pressed Enter knowing what they were pressing it over.
+    """
+    return [
+        {
+            "name": app.name,
+            "path": app.path,
+            "language": app.language,
+            "kind": app.kind,
+            "commands": dict(app.commands or {}),
+            "toolchain": dict(app.toolchain or {}),
+            "evidence": root.found.evidence,
+            # What the tree said the directory is for, where it said anything. A candidate whose `kind` is
+            # `application` with nothing here is one nobody and nothing has placed — the commonest case, and
+            # the one the confirming agent has to read the directory to answer.
+            **({"roleEvidence": root.role_evidence} if root.role_evidence else {}),
+        }
+        for app, root in zip(proposed(found, name), found.roots, strict=True)
+    ]
+
+
 def facts(found: Survey, answers: Answers, layout: Layout) -> Adoption:
     """The project-level record: the person's answers where given, the survey's proposal where not — and where
     the tree said nothing and nobody was asked, `unrecorded`, which is a fact about the record and not a guess."""
@@ -176,6 +208,8 @@ def facts(found: Survey, answers: Answers, layout: Layout) -> Adoption:
             "ci": list(found.ci), "containers": list(found.containers),
             "makefile": found.makefile, "readme": found.readme, "quickWins": list(found.quick_wins),
         },
+        agent=answers.agent,
+        candidates=answers.candidates,
     )
 
 
@@ -195,7 +229,7 @@ def adopt(root: Path, answers: Answers, found: Survey | None = None) -> Adopted:
     found = survey(root) if found is None else found
     layout = Layout(answers.delivery)
     apps = answers.applications
-    if not apps:
+    if not apps and not answers.candidates:
         raise GenerationError("no application to install the method around: adopt wraps at least one")
     adoption = with_recommendation(root, layout, with_platform(root, facts(found, answers, layout), apps), apps)
     files = project_files(answers.name, answers.profile, answers.target, apps, layout, adoption)
@@ -261,4 +295,4 @@ def manifest_of(root: Path) -> dict:
     return json.loads((root / "project.json").read_text())
 
 
-__all__ = ["Adopted", "Answers", "WRITTEN", "adopt", "manifest_of", "proposed", "report"]
+__all__ = ["Adopted", "Answers", "WRITTEN", "adopt", "candidates_of", "manifest_of", "proposed", "report"]

{slipwai-1.3.0.dev15 → slipwai-1.3.0.dev32}/src/slipwai/adopt_report.py

@@ -11,6 +11,7 @@ from pathlib import Path
 
 from .assets import VERSION
 from .convergence import summary
+from .harness import name_of
 from .layout import Layout
 from .origin import Adoption
 from .programme import expired, phrase, unplaced
@@ -131,7 +132,7 @@ def quick_wins_table(findings: tuple[dict, ...]) -> str:
     )
 
 
-def report(done: Adopted) -> str:
+def report(done: Adopted, running_init: bool = False) -> str:
     """What was written, what it forfeits, and the next steps in order — the first line says experimental, and the
     first step is always `init`, as it is in a generated project's README: the agent before the gate."""
     wrapped = wrapped_of(done.apps)
@@ -148,7 +149,40 @@ def report(done: Adopted) -> str:
             f"  {app.name}: {app.path} ({app.language}; {what}), {recorded} of {len(app.commands or {})} targets "
             "have a command; the rest are written no's"
         )
-    if not wrapped:
+    # Nothing a person said stands behind an application every one of whose facts is still the survey's own
+    # reading, which is what `--yes` leaves. Said once, plainly, rather than left to be inferred from the word
+    # `detected` in a file nobody opens: the whole point of the candidate state is that a record says whether
+    # somebody looked, and a record that says nobody did has to be as readable as one that says somebody did.
+    unlooked = [app for app in wrapped if set(app.provenance.values()) <= {"detected", "unrecorded"}]
+    if unlooked and len(unlooked) == len(wrapped):
+        lines.append(
+            f"  Nobody has looked at {'either' if len(unlooked) == 2 else 'any'} of these: every fact above is "
+            "the survey's own reading, recorded `detected`. /ground asks about each, and `/survey` refreshes "
+            "what stays the tree's word."
+            if len(unlooked) > 1 else
+            "  Nobody has looked at it: every fact above is the survey's own reading, recorded `detected`. "
+            "/ground asks, and `/survey` refreshes what stays the tree's word."
+        )
+    candidates = done.adoption.candidates or []
+    if candidates:
+        one = len(candidates) == 1
+        lines.append(
+            f"  {len(candidates)} buildable director{'y' if one else 'ies'}, "
+            + ("which is not recorded as an application yet" if one else "none of them recorded as an "
+               "application yet")
+            + " — what each is, what it is called and what it owns are questions the code answers:"
+        )
+        for row in candidates:
+            answered = sum(1 for command in (row.get("commands") or {}).values() if command)
+            lines.append(
+                f"    {row['path']} ({row['language']}, from {row['evidence']}), "
+                f"{answered} of {len(row.get('commands') or {})} targets have a command"
+            )
+        lines.append(
+            "  Until one is confirmed, `verify` refuses rather than passing over nothing: /ground asks about "
+            "each with the code in front of it, and `slipwai adopt --confirm <name>` records the answer."
+        )
+    elif not wrapped:
         lines.append("  no buildable directory was found; the gate is the method's own checks alone")
     lines += ci_lines(done.adoption, done.layout)
     at, below, unrecorded = summary(done.adoption.convergence)
@@ -202,13 +236,36 @@ def report(done: Adopted) -> str:
     lines += missing_tools(wrapped, done.layout)
     verify = "make" if done.makefile_written else done.layout.make
     init = f"./{done.layout.delivery}/init"
+    named = recorded_agent(done)
+    # `--init` runs it below, so naming it as the next step and then doing it reads as two different
+    # instructions about the same thing. What is left after it is what the rest of this list is for.
+    # `--init` runs it below, so naming it as the next step and then doing it reads as two instructions
+    # about one thing. What is left after it is what the rest of this list is for.
+    init_line = (
+        f"Next: {init} is running now — it installs Spec Kit and projects the skills and commands; what it "
+        "writes is left uncommitted for you to read."
+        if running_init
+        else f"Next: {init} — installs Spec Kit and " + (
+            f"projects the skills and commands into {name_of(named)}, which this record already "
+            f"names, so it asks nothing ({init} --integration <agent> changes it)"
+            if named
+            else f"asks which coding agent gets the skills and commands (or name it: {init} --integration claude)"
+        ) + ". Add --extension codegraph to index the code for that agent."
+    )
     lines += [
         "",
-        f"Next: {init} — installs Spec Kit and asks which coding agent gets the skills and commands (or name it: "
-        f"{init} --integration claude). Add --extension codegraph to index the code for that agent.",
-        "Then: /ground, in the agent — it asks what the tree could not say, one row of the map at a time, and records "
-        "each answer with its provenance; what --yes left unrecorded is settled there.",
-        f"Then: {verify} verify — the gate. Its first run records the lint and typecheck findings that are there as "
+        init_line,
+        "Then: /ground, in the agent — it asks what the tree could not say" + (
+            ", starting with which of the directories above is an application, what it is called and what it "
+            "owns; then one row of the map at a time"
+            if done.adoption.candidates
+            else ", one row of the map at a time"
+        ) + ", and records each answer with its provenance; what --yes left unrecorded is settled there.",
+        f"Then: {verify} verify — the gate" + (
+            ", once a candidate above has been confirmed: it refuses while nothing is, because a gate with "
+            "nothing to hold has not been given its subject yet"
+            if done.adoption.candidates else ""
+        ) + ". Its first run records the lint and typecheck findings that are there as "
         f"the baseline; commit {done.layout.delivery}/baseline.json with what init wrote. A test suite that is red "
         "stops that run and says so: read the failures, then `make ratchet-tighten` quarantines it deliberately.",
         *([] if done.makefile_written else [
@@ -217,10 +274,18 @@ def report(done: Adopted) -> str:
         f"Read {done.layout.delivery}/docs/adoption.md — what was wrapped, what that forfeits, and where each fact "
         f"came from — and {done.layout.delivery}/docs/convergence.md, where this repository stands and what is next; "
         f"{done.layout.delivery}/survey/survey.md is the survey with its evidence.",
+        "This list scrolls away, and the sequence it names takes longer than one sitting: `slipwai adopt --next` "
+        "says where you are in it, read off the tree rather than remembered.",
     ]
     return "\n".join(lines)
 
 
+def recorded_agent(done: Adopted) -> str | None:
+    """The harness the record names, or None where the question is still `./init`'s to ask."""
+    harness = (done.adoption.agent or {}).get("harness")
+    return harness if isinstance(harness, str) and harness else None
+
+
 def ci_lines(adoption: Adoption, layout: Layout) -> list[str]:
     """What the report says about the gate's CI configuration and the release path: which forge was recorded, what
     was written for it — or that nothing was, and what to run instead — and how a change reaches production."""