slipwai 1.2.0.dev19__tar.gz → 1.2.0.dev23__tar.gz

{slipwai-1.2.0.dev19 → slipwai-1.2.0.dev23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: slipwai
-Version: 1.2.0.dev19
+Version: 1.2.0.dev23
 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
@@ -82,7 +82,8 @@ It is not a one-way door. You can run the factory again inside a project it made
 
 - **`slipwai add-service` and `slipwai add-frontend`** read `project.json` and regenerate only the files
   that list the project's applications. The factory derives that set by generating the project twice and
-  comparing the results, so it cannot drift from a hand-kept list.
+  comparing the results, so it cannot drift from a hand-kept list. **`slipwai describe-service`** records
+  what a service already there is for — its purpose and its bounded contexts — and regenerates the same way.
 - **`./init`** answers the event store, HTTP, staff identity and customer identity questions again, by
   removing what the old answers brought.
 

{slipwai-1.2.0.dev19 → slipwai-1.2.0.dev23}/README.md

@@ -53,7 +53,8 @@ It is not a one-way door. You can run the factory again inside a project it made
 
 - **`slipwai add-service` and `slipwai add-frontend`** read `project.json` and regenerate only the files
   that list the project's applications. The factory derives that set by generating the project twice and
-  comparing the results, so it cannot drift from a hand-kept list.
+  comparing the results, so it cannot drift from a hand-kept list. **`slipwai describe-service`** records
+  what a service already there is for — its purpose and its bounded contexts — and regenerates the same way.
 - **`./init`** answers the event store, HTTP, staff identity and customer identity questions again, by
   removing what the old answers brought.
 

slipwai-1.2.0.dev23/VERSION

@@ -0,0 +1 @@
+1.2.0.dev23

{slipwai-1.2.0.dev19 → slipwai-1.2.0.dev23}/assets/profiles/event-modelling/docs/speckit-preset.md

@@ -38,6 +38,13 @@ add it to `.specify/presets/event-modelling/templates/` and declare it under `pr
 unquoted `version: 1.0` parses as a float and Spec Kit reports the whole preset as corrupted without naming
 the field.
 
+From Spec Kit 1.0.9 on, its bash scripts compose the templates a preset declares with PyYAML, on the bare
+`python3` they call — without it, `.specify/scripts/bash/create-new-feature.sh` stops with "PyYAML is
+required to resolve preset template composition". `./init` checks for that after installing Spec Kit and
+installs it where it can: into the user site, or — where this Python refuses pip outside a venv (PEP 668:
+Homebrew's, Debian's) — into a venv at `.delivery-tools/venv` that shares the system's packages, printing the
+`PATH` line that puts it first. Rerun `./init` after changing the Python on your PATH.
+
 `make check-speckit` enforces all of this and runs inside `make verify` — in-place edits, deleted managed
 files, a preset with no or invalid `preset.yml`, and a declared override whose file is missing (which
 silently falls back to the core template). It reads the committed manifests directly rather than shelling

{slipwai-1.2.0.dev19 → slipwai-1.2.0.dev23}/assets/profiles/standard/docs/speckit-preset.md

@@ -37,6 +37,13 @@ add it to `.specify/presets/standard/templates/` and declare it under `provides.
 unquoted `version: 1.0` parses as a float and Spec Kit reports the whole preset as corrupted without naming
 the field.
 
+From Spec Kit 1.0.9 on, its bash scripts compose the templates a preset declares with PyYAML, on the bare
+`python3` they call — without it, `.specify/scripts/bash/create-new-feature.sh` stops with "PyYAML is
+required to resolve preset template composition". `./init` checks for that after installing Spec Kit and
+installs it where it can: into the user site, or — where this Python refuses pip outside a venv (PEP 668:
+Homebrew's, Debian's) — into a venv at `.delivery-tools/venv` that shares the system's packages, printing the
+`PATH` line that puts it first. Rerun `./init` after changing the Python on your PATH.
+
 `make check-speckit` enforces all of this and runs inside `make verify` — in-place edits, deleted managed
 files, a preset with no or invalid `preset.yml`, and a declared override whose file is missing (which
 silently falls back to the core template). It reads the committed manifests directly rather than shelling

{slipwai-1.2.0.dev19 → slipwai-1.2.0.dev23}/assets/toolkit/scripts/agents/cruise.py

@@ -14,6 +14,12 @@ fresh context, until the last line of an iteration says `done`, a person stops i
     python3 scripts/agents/cruise.py status      # what the log says the run is doing
     python3 scripts/agents/cruise.py resume      # print the checkpoint into a compacted context; nothing when none
     python3 scripts/agents/cruise.py compacting  # stamp the checkpoint before the harness compacts
+    python3 scripts/agents/cruise.py loop        # what is reading this session's last line: the runner, or nobody
+    python3 scripts/agents/cruise.py stopping    # Claude Code's Stop hook: refuse to end a turn mid-iteration
+
+`run` marks every session it starts with `CRUISE_RUNNER=1` and `CRUISE_ITERATION=<n>`, which is how `loop` and
+`stopping` tell a runner's iteration from a `/cruise` a person typed — where nothing reads the last line, so
+`continue` is not an end the ladder has, and the session goes on to the next unit instead.
 
 A person stops a run with `touch .specify/cruise.stop`, or by interrupting this script: the iteration under
 way is killed, its increment commits are on the slice branch, and the next iteration re-derives from disk.
@@ -54,6 +60,15 @@ CHECKPOINT = ROOT / "specs/cruise-checkpoint.md"
 RESUME = ("cruise: this session is a /cruise iteration whose context was compacted. The checkpoint below is what "
           "the summary lost; read it before acting, then commands/cruise.md for the rules it names — run "
           "commands/drive.md as written, decide at its stops by the stop table, end with one of the four last lines.")
+# The two variables `run` sets in every session it starts: what tells a runner's iteration from a typed one.
+RUNNER_VARIABLE, ITERATION_VARIABLE = "CRUISE_RUNNER", "CRUISE_ITERATION"
+# What a session is told when nothing reads its last line — the same words `commands/cruise.md` carries.
+UNREAD = ("no outer loop is reading this: `cruise: continue` is not an end here, so the ladder goes on to the next "
+          "unit in this session and ends only with `done`, `parked` or `stopped`; `make cruise` runs it unattended")
+# How many times the Stop hook holds a turn against one checkpoint before it lets go: the command rewrites the
+# checkpoint at every stage boundary, so a checkpoint held this often without a rewrite is a session that is
+# not moving, and a hook that never let go would spend tokens forever on it.
+HOLD_LIMIT = 3
 REGISTRY = Path(__file__).with_name("registry.json")
 INTEGRATION = ROOT / ".specify/integration.json"
 # Every setting: the values it takes — a tuple of words, or a kind — its default, and what it controls. The
@@ -237,9 +252,10 @@ def child_environment(harness: dict[str, Any]) -> dict[str, str]:
     return environment
 
 
-def iterate(template: str, prompt: str, environment: dict[str, str]) -> str | None:
-    """Run one iteration, echoing its output, and return its last line."""
+def iterate(template: str, prompt: str, environment: dict[str, str], iteration: int) -> str | None:
+    """Run one iteration, marked as the runner's, echoing its output, and return its last line."""
     command = template.replace("{prompt}", shlex.quote(prompt))
+    environment = {**environment, RUNNER_VARIABLE: "1", ITERATION_VARIABLE: str(iteration)}
     last = None
     with subprocess.Popen(command, shell=True, cwd=ROOT, text=True, stdout=subprocess.PIPE,
                           stderr=subprocess.STDOUT, env=environment) as process:
@@ -270,6 +286,91 @@ def compacting() -> None:
             handle.write(f"- **Compacted:** {now()}\n")
 
 
+def loop() -> None:
+    """Say what is reading this session's last line, so an iteration knows what its end means."""
+    if os.environ.get(RUNNER_VARIABLE):
+        print(f"cruise: the outer loop (scripts/agents/cruise.py run) started this session as iteration "
+              f"{os.environ.get(ITERATION_VARIABLE, '?')} and reads its last line")
+    else:
+        print(f"cruise: {UNREAD}")
+
+
+def last_assistant_text(transcript: Path) -> str | None:
+    """The text of the last assistant message in a Claude Code transcript, or None where there is none."""
+    text = None
+    for line in transcript.read_text(errors="replace").splitlines():
+        try:
+            entry = json.loads(line)
+        except ValueError:
+            continue
+        if entry.get("type") != "assistant":
+            continue
+        content = (entry.get("message") or {}).get("content")
+        if isinstance(content, str):
+            text = content
+        elif isinstance(content, list):
+            texts = [block.get("text", "") for block in content if isinstance(block, dict) and block.get("type") == "text"]
+            if texts:
+                text = texts[-1]
+    return text
+
+
+def stopping() -> None:
+    """Claude Code's Stop hook: hold the turn while an iteration is in flight and this is not its end.
+
+    Prose in a command file is not a control — the same session ended an iteration after the upstream stages
+    and, later, on a report that said "continuing now" — so the end of a turn is checked here, where the harness
+    lets a hook refuse it. The hook reads the event Claude Code hands it on stdin, and holds the turn (a
+    `block` decision, with the reason the model reads next) when a checkpoint says an iteration is in flight,
+    no stop file says a person ended it, and the last assistant message does not end on one of the four last
+    lines — or ends on `continue` in a session no runner started, where that line reaches nobody. A turn that
+    ends on `done` or `stopped` takes the checkpoint with it, the way the runner would. Every hold is stamped
+    on the checkpoint, and the hook lets go after HOLD_LIMIT holds with no rewrite in between — below the
+    harness's own cap on consecutive blocks, so it is this script that decides when to let go, and says so.
+    """
+    if not CHECKPOINT.is_file() or STOP.is_file():
+        return
+    try:
+        event = json.loads(sys.stdin.read() or "{}")
+    except ValueError:
+        event = {}
+    # The message the turn ends on, as the event carries it; the transcript otherwise, which can lag the event.
+    text = event.get("last_assistant_message")
+    if not isinstance(text, str) or not text.strip():
+        transcript = Path(str(event.get("transcript_path") or ""))
+        if not transcript.is_file():
+            return
+        text = last_assistant_text(transcript)
+    last = (text or "").rstrip().splitlines()[-1].strip() if (text or "").strip() else ""
+    ended = LAST_LINE.match(last) is not None
+    if ended and last in ("cruise: done", "cruise: stopped: human"):
+        CHECKPOINT.unlink(missing_ok=True)
+        return
+    if ended and (last != "cruise: continue" or os.environ.get(RUNNER_VARIABLE)):
+        return
+    checkpoint = CHECKPOINT.read_text()
+    if checkpoint.count("- **Held:**") >= HOLD_LIMIT:
+        print(f"cruise: held {HOLD_LIMIT} times against a checkpoint nothing rewrote; letting the turn end",
+              file=sys.stderr)
+        return
+    next_step = next((line.strip() for line in checkpoint.splitlines() if line.strip().startswith("- **Next:**")),
+                     "- **Next:** (the checkpoint names no next step; read it and commands/cruise.md)")
+    if last == "cruise: continue":
+        why = (f"`cruise: continue` reaches nobody: no runner started this session ({RUNNER_VARIABLE} is unset), "
+               "so the ladder continues here and the iteration ends only with `cruise: done`, "
+               "`cruise: parked: <why>` or `cruise: stopped: human`.")
+    else:
+        why = ("an iteration is in flight (specs/cruise-checkpoint.md) and this turn did not end on one of its "
+               "four last lines. An iteration ends only on `cruise: continue`, `cruise: done`, "
+               "`cruise: parked: <why>` or `cruise: stopped: human`; a message that says what it is about to do "
+               "next is a stop, whatever it says.")
+    with CHECKPOINT.open("a") as handle:
+        handle.write(f"- **Held:** {now()} — {last or 'no last line'!r}\n")
+    reason = (f"cruise: {why} Continue from the checkpoint: {next_step}. A person ends the run with "
+              f"`touch {STOP.relative_to(ROOT)}`.")
+    print(json.dumps({"decision": "block", "reason": reason}))
+
+
 def park(reason: str, no_park: bool, poll: float, seen: str) -> None:
     """Wait for a person: the stop file ends the run, a change under specs/ resumes it, `--no-park` exits 3."""
     print(f"cruise: parked — {reason}")
@@ -318,7 +419,7 @@ def run(arguments: list[str]) -> None:
             return
         iteration = len(entries()) + 1
         started = now()
-        last = iterate(template, ask, environment)
+        last = iterate(template, ask, environment, iteration)
         iterations_this_run += 1
         seen = fingerprint()
         fingerprints.append(seen)
@@ -386,6 +487,12 @@ def main() -> None:
     if arguments[:1] == ["compacting"]:
         compacting()
         return
+    if arguments[:1] == ["loop"]:
+        loop()
+        return
+    if arguments[:1] == ["stopping"]:
+        stopping()
+        return
     if "--set" in arguments:
         table = json.loads(CONFIG.read_text())
         assignments = arguments[arguments.index("--set") + 1:]

{slipwai-1.2.0.dev19 → slipwai-1.2.0.dev23}/changelog.d/cruise.md

@@ -18,6 +18,16 @@ settings, `/cruise-settings` changes them checked, and it ships disabled: a proj
 `.specify/models.json` gains a `skipper` role and the `skipper`, `hand` and `bosun` stages, and the benchmark records
 `driver=cruise` on every stage a run bracketed.
 
+Three things the first runs taught it. An iteration has a unit before the split exists — the upstream stages
+together, through to the first ready set — and ends only on one of its four last lines: on Claude Code,
+`.claude/settings.json` runs `scripts/agents/cruise.py stopping` as the `Stop` hook, which refuses a turn that
+ends mid-iteration on anything else, or on `continue` in a session no runner started (the runner marks its
+sessions with `CRUISE_RUNNER`; `cruise.py loop` says which kind a session is), handing back the checkpoint's
+`Next:` line. And the session running `/cruise` allocates every identifier a decision carries — the `D<n>`
+goes out in the skipper's brief, the entry comes back and is appended in number order, requirements and
+criteria are numbered after concurrent delegates return — so four delegates deciding at once cannot come
+back as two `D3`s with overlapping requirement ranges.
+
 **Catch-up.** `slipwai migrate` brings the command, the three agent types, the settings file and the two new rows
 of `.specify/models.json`; then `./init` reprojects the agent types and, as with every new type, the harness
 reads them at its next session start. Nothing runs until `enabled` is set with `/cruise-settings enabled=true`.

slipwai-1.2.0.dev23/changelog.d/describe-service.md

@@ -0,0 +1,12 @@
+MINOR
+
+**A service's purpose and bounded contexts can be recorded after the scaffold: `slipwai describe-service`.**
+`purpose` and `contexts` are what the delivery loop places a slice against, and `generate` and `add-service`
+take them at scaffold time — but a purpose is often left unsaid at the start, and the contexts are found later,
+in the model's lanes or the specification's vocabulary, which is where `/drive` says to record them. Until now
+that meant editing `project.json` by hand against a file the factory owns, while `docs/architecture.md` went on
+saying "no purpose recorded yet". `describe-service <name> --purpose "..." --context <name>` edits the entry in
+place — a field given replaces what was recorded, one not given is kept — and regenerates every file that
+prints the two fields, derived the same way `add-service` derives its set. `/drive`, `/cruise`, the
+architecture page and the `add-service` report now name it wherever they say a purpose or a context is
+recorded.

slipwai-1.2.0.dev23/changelog.d/init-pyyaml.md

@@ -0,0 +1,14 @@
+PATCH
+
+**`./init` checks that Spec Kit's scripts have the PyYAML they compose the preset templates with, and puts it
+right where it can.** From Spec Kit 1.0.9 its bash scripts read a preset's `preset.yml` through the bare
+`python3` they call, and a project whose python3 lacks the module learned so at its first `/speckit-specify`:
+"PyYAML is required to resolve preset template composition", with no remedy — and on a Homebrew or Debian
+Python the obvious `pip install` is refused too (PEP 668). Where the installed Spec Kit's scripts mention it
+and `python3` cannot import it, `./init` now installs it into the user site, or, where that Python refuses
+pip outside a venv, into a venv at `.delivery-tools/venv` that shares the system's packages and prints the
+`PATH` line that puts it first; where neither is possible it says exactly what to install. Never fatal, and
+silent on a Spec Kit whose scripts never mention it. `docs/speckit-preset.md` says the same.
+
+**Catch-up.** `slipwai migrate` brings the new `./init`; rerun it once after the merge on a machine whose
+`python3` lacks PyYAML.

{slipwai-1.2.0.dev19 → slipwai-1.2.0.dev23}/src/slipwai/add_service.py

@@ -20,6 +20,13 @@ cannot inherit Fastify, so it gets FastAPI).
 and the same regeneration of what the list drives — which is also how a project generated with
 `--frontend none` gets its first browser app.
 
+`describe-service <name> --purpose ... --context ...` records, after the fact, what a service the list already
+has is for — the two fields the delivery loop places a slice against, which `generate` and `add-service` take
+at scaffold time and which are otherwise found later, when the model's lanes or the specification's vocabulary
+say what the contexts are. It scaffolds nothing: `project.json`'s entry is edited in place and every file
+whose content the two fields reach — the architecture page, the agent guidance, the commands that list the
+applications — is regenerated, the same way as above, so the file an agent reads says what was recorded.
+
 Nothing is committed. The tree has to be clean first so that `git checkout .` and `git clean -fd` undo the
 whole thing, and the command says what it wrote and what to run next.
 """
@@ -27,6 +34,7 @@ from __future__ import annotations
 
 import json
 import subprocess
+from dataclasses import replace
 from pathlib import Path
 
 from .assets import PRUNER
@@ -37,7 +45,7 @@ from .manifest import apps_from_manifest, check_known, read_manifest, wrote_here
 from .origin import adoption_of
 from .scaffold import project_files
 from .selection import Selection, resolve_selection
-from .services import App, add_service, add_web, contexts_phrase, frontend_of, services_of
+from .services import App, add_service, add_web, checked_contexts, contexts_phrase, frontend_of, services_of
 from .targets import managed, offered_backends
 from .toolkit import executable_paths
 
@@ -140,26 +148,79 @@ def grow(
             f"{app.path} already exists but project.json does not list it; move it aside, or register it "
             "by hand if it is an application"
         )
+    keep, settled = pruning_state(root, asked)
+    added, rewritten, manifest = regenerate(root, document, apps, with_new, asked, new_path=app.path)
+
+    # The manifest is edited in place rather than regenerated, so anything else it carries survives; the
+    # `frontend` field follows the browser apps, so a project that had none now says which framework it has.
+    document["deployables"][app.name] = manifest["deployables"][app.name]
+    document["frontend"] = frontend_of(with_new)
+    rewritten.append(record(root, document))
+    PRUNER.prune(root, keep, settled=settled, log=lambda _message: None)
+    return app, added, sorted(rewritten)
+
+
+def describe_service_in(
+    root: Path, name: str, purpose: str | None = None, contexts: list[str] | None = None
+) -> tuple[App, list[str]]:
+    """Record what a service already on the list is for, and rewrite every file that says so.
+
+    A field given replaces what was recorded; one not given is left as it was. Nothing under `apps/` is
+    touched: the two fields are read by the delivery loop and the pages that print them, never by the
+    scaffold.
+    """
+    if purpose is None and contexts is None:
+        raise GenerationError("nothing to record: say --purpose, --context (once per context), or both")
+    document = read_manifest(root)
+    apps = apps_from_manifest(document)
+    check_known(apps)
+    named = [app for app in apps if app.name == name]
+    if not named:
+        raise GenerationError(
+            f"project.json lists no application named '{name}'; it has {', '.join(app.name for app in apps)}"
+        )
+    app = named[0]
+    if not app.is_service:
+        raise GenerationError(f"'{name}' is a browser app; a purpose and bounded contexts are a service's to record")
+    revised = replace(
+        app,
+        purpose=(purpose or None) if purpose is not None else app.purpose,
+        contexts=checked_contexts(contexts) if contexts is not None else app.contexts,
+    )
+    if revised.purpose == app.purpose and revised.contexts == app.contexts:
+        raise GenerationError(f"'{name}' already records exactly that; nothing to write")
+    described = [revised if candidate is app else candidate for candidate in apps]
+    refuse_uncommitted(root)
+    keep, settled = pruning_state(root, set())
+    _added, rewritten, manifest = regenerate(root, document, apps, described, set())
+    entry = document["deployables"][name]
+    for key in ("purpose", "contexts"):
+        if key in manifest["deployables"][name]:
+            entry[key] = manifest["deployables"][name][key]
+        else:
+            entry.pop(key, None)
+    rewritten.append(record(root, document))
+    PRUNER.prune(root, keep, settled=settled, log=lambda _message: None)
+    return revised, sorted(rewritten)
+
+
+def regenerate(
+    root: Path, document: dict, apps: list[App], revised: list[App], asked: set[str], new_path: str | None = None
+) -> tuple[list[str], list[str], dict]:
+    """Write every file whose regenerated content differs between the list as it was and as it is — and
+    every file under `new_path`, the application being added — and return the added paths, the rewritten
+    ones, and the manifest the revised list generates, for the caller to take its entry from."""
     layout, adoption = layout_of(document), adoption_of(document)
     arguments = (document["name"], document["profile"], document["target"])
     before = project_files(*arguments, apps, layout, adoption)
-    after = project_files(*arguments, with_new, layout, adoption)
-    executables = {layout.place(path) for path in executable_paths(document["profile"], with_new)}
-
-    # What this project actually has, read off its disk rather than off the recorded selections: a later
-    # `./init` may have taken a feature away, and the new application must not bring it back — unless it was
-    # asked for.
-    existing = PRUNER.project_services(root)
-    installed = PRUNER.features_installed(root, existing)
-    present = PRUNER.features_present(root, existing)
-    keep = installed | asked
-
+    after = project_files(*arguments, revised, layout, adoption)
+    executables = {layout.place(path) for path in executable_paths(document["profile"], revised)}
     added: list[str] = []
     rewritten: list[str] = []
     for relative, content in after.items():
         if relative == "project.json":
             continue
-        new = relative.startswith(f"{app.path}/")
+        new = new_path is not None and relative.startswith(f"{new_path}/")
         # A file whose regenerated content is unchanged is left alone — unless it carries a region of a
         # feature asked for by name. `.env.example` reads the same whichever services a project has, so its
         # earlier prune is the only reason a newly asked feature's keys would be missing from it; written
@@ -171,19 +232,25 @@ def grow(
         path.write_text(content, newline="")
         path.chmod(0o755 if relative in executables else 0o644)
         (added if new else rewritten).append(relative)
+    return sorted(added), rewritten, json.loads(after["project.json"])
 
-    # The manifest is edited in place rather than regenerated, so anything else it carries survives; the
-    # `frontend` field follows the browser apps, so a project that had none now says which framework it has.
-    document["deployables"][app.name] = json.loads(after["project.json"])["deployables"][app.name]
-    document["frontend"] = frontend_of(with_new)
+
+def pruning_state(root: Path, asked: set[str]) -> tuple[set[str], set[str]]:
+    """What this project actually has, read off its disk before anything is written rather than off the
+    recorded selections: a later `./init` may have taken a feature away, and a regenerated file must not
+    bring it back — unless it was asked for. The features to keep, and the ones an earlier `./init` settled
+    (their files here, their markers gone), whose fresh markers the prune strips again."""
+    existing = PRUNER.project_services(root)
+    installed = PRUNER.features_installed(root, existing)
+    present = PRUNER.features_present(root, existing)
+    return installed | asked, installed - present
+
+
+def record(root: Path, document: dict) -> str:
+    """Write the manifest, edited in place, with this factory stamped as the last to write here."""
     document["generator"] = wrote_here(document.get("generator"))
     (root / "project.json").write_text(json.dumps(document, indent=2) + "\n")
-    rewritten.append("project.json")
-
-    # Features whose files are here but whose markers are gone were settled by an earlier `./init`; the
-    # regenerated files carry fresh markers for them, and the prune strips those again.
-    PRUNER.prune(root, keep, settled=installed - present, log=lambda _message: None)
-    return app, sorted(added), sorted(rewritten)
+    return "project.json"
 
 
 def carries_any(content: str, features: set[str]) -> bool:
@@ -213,7 +280,7 @@ def report(app: App, added: list[str], rewritten: list[str], target: str = "none
         )
         if not app.purpose:
             lines.append(
-                "no purpose recorded: say what it owns (add-service --purpose, or `purpose` in project.json), "
+                f"no purpose recorded: say what it owns (`slipwai describe-service {app.name} --purpose \"...\"`), "
                 "or /drive will ask before it places a slice here"
             )
     if managed(CATALOG, target) and app.is_service:
@@ -229,3 +296,13 @@ def report(app: App, added: list[str], rewritten: list[str], target: str = "none
         "Next: make verify",
     ]
     return "\n".join(lines)
+
+
+def described_report(app: App, rewritten: list[str]) -> str:
+    """What was recorded and which files now say it, for the person who ran `describe-service`."""
+    regenerated = ", ".join(path for path in rewritten if path != "project.json") or "nothing else"
+    return "\n".join([
+        f"recorded for {app.path}: it holds the bounded {contexts_phrase(app)}"
+        + (f" and owns: {app.purpose}" if app.purpose else " (no purpose recorded)"),
+        f"written to project.json; regenerated from it: {regenerated}",
+    ])

{slipwai-1.2.0.dev19 → slipwai-1.2.0.dev23}/src/slipwai/cli.py

@@ -12,6 +12,7 @@ from .cli_add import (
     add_frontend_main,
     add_service_main,
     converge_main,
+    describe_service_main,
     migrate_main,
     replay_main,
     resolve_requested_backend,
@@ -38,14 +39,15 @@ from .services import FIRST_SERVICE, FIRST_WEB, default_apps
 from .targets import check_project_name, offered_backends
 from .upgrade import main as upgrade_main
 
-VERBS = ("generate", "add-service", "add-frontend", "migrate", "replay", "upgrade", "adopt", "converge")
+VERBS = ("generate", "add-service", "add-frontend", "describe-service", "migrate", "replay", "upgrade", "adopt",
+         "converge")
 
 
 def main() -> None:
     """`slipwai <verb>`: `generate` from anywhere, naming a project that does not exist yet; `add-service`,
-    `add-frontend`, `migrate` and `replay` from inside one that does; `upgrade` from anywhere, about the
-    command itself rather than about any project. Each verb owns its parser, so `slipwai generate --help` is
-    the generator's flags and nothing else's."""
+    `add-frontend`, `describe-service`, `migrate` and `replay` from inside one that does; `upgrade` from
+    anywhere, about the command itself rather than about any project. Each verb owns its parser, so
+    `slipwai generate --help` is the generator's flags and nothing else's."""
     validate_catalog(CATALOG)
     argv = sys.argv[1:]
     if argv[:1] == ["generate"]:
@@ -57,6 +59,9 @@ def main() -> None:
     if argv[:1] == ["add-frontend"]:
         add_frontend_main(argv[1:])
         return
+    if argv[:1] == ["describe-service"]:
+        describe_service_main(argv[1:])
+        return
     if argv[:1] == ["migrate"]:
         migrate_main(argv[1:])
         return

{slipwai-1.2.0.dev19 → slipwai-1.2.0.dev23}/src/slipwai/cli_add.py

@@ -11,7 +11,7 @@ import argparse
 import sys
 from pathlib import Path
 
-from .add_service import add_frontend_to, add_service_to, report
+from .add_service import add_frontend_to, add_service_to, describe_service_in, described_report, report
 from .assets import VERSION
 from .catalog import CATALOG, families, family_of, resolve_backend
 from .converge import check as converge_check
@@ -105,6 +105,38 @@ def add_service_main(argv: list[str]) -> None:
     print(report(service, added, rewritten, read_manifest(Path.cwd())["target"]))
 
 
+def describe_service_main(argv: list[str]) -> None:
+    """`describe-service <name>`, run inside a generated project: what a service already there is for.
+
+    `generate` and `add-service` take `--purpose` and `--context` at scaffold time, but the contexts are found
+    later — in the model's lanes, in the specification's vocabulary — and a purpose nobody gave at the start is
+    the first question `/drive` asks. This is where the answer goes: the manifest, and every page that prints
+    it, so the file an agent reads says what was recorded rather than "no purpose recorded yet".
+    """
+    parser = argparse.ArgumentParser(
+        prog="slipwai describe-service",
+        description="Record what a service of the generated project in the current directory is for: what it "
+        "owns, the bounded contexts it holds, or both. Nothing is scaffolded; project.json and the files that "
+        "print the two fields are rewritten.",
+    )
+    parser.add_argument("name", help="the service, as project.json names it")
+    parser.add_argument(
+        "--purpose", default=None, metavar="TEXT",
+        help="what this service owns, in a sentence or two; replaces the purpose recorded before",
+    )
+    parser.add_argument(
+        "--context", action="append", default=None, metavar="NAME",
+        help="a bounded context this service holds; repeat for each. Together they replace the list recorded "
+        "before",
+    )
+    args = parser.parse_args(argv)
+    try:
+        service, rewritten = describe_service_in(Path.cwd(), args.name, purpose=args.purpose, contexts=args.context)
+    except GenerationError as error:
+        parser.error(str(error))
+    print(described_report(service, rewritten))
+
+
 def add_frontend_main(argv: list[str]) -> None:
     """`add-frontend <name>`, run inside a generated project: one more browser app.
 

{slipwai-1.2.0.dev19 → slipwai-1.2.0.dev23}/src/slipwai/project/add_commands.py

@@ -152,6 +152,7 @@ files that name it, and misses the tenth.
   slice belongs to: a service added without one is a directory the loop cannot place work in, and it will
   stop to ask before it does. A context is one already on the list above, or a new one; without any the
   service is a context of its own. A context may span several services; the tree stays `apps/<name>`.
+  A service already listed is described after the fact: `<factory> describe-service <name> --purpose "..." --context <name>`.
 
 The language, the store, and what the service owns are product decisions. When the request does not name
 them, ask; taking `{first.name}`'s answers is the default for the first two, and saying so is part of

{slipwai-1.2.0.dev19 → slipwai-1.2.0.dev23}/src/slipwai/project/agent_settings.py

@@ -16,17 +16,22 @@ MAVEN_PERMISSIONS = ["./mvnw *"]
 
 
 def compaction_hooks(layout: Layout) -> dict[str, list[dict[str, object]]]:
-    """What Claude Code runs around compaction, so a `/cruise` iteration resumes from its checkpoint.
+    """What Claude Code runs around compaction and at the end of a turn, so a `/cruise` iteration resumes
+    from its checkpoint and cannot end anywhere but on one of its four last lines.
 
     `SessionStart` with the `compact` matcher runs when the session continues after compaction and its
-    stdout is added to the context; `PreCompact` runs just before. Both call the cruise script, which prints
-    nothing unless an iteration is in flight, so a plain `/drive` session never sees them. The other
-    harnesses' equivalents, where one exists, are the registry's `compaction` rows.
+    stdout is added to the context; `PreCompact` runs just before. `Stop` runs when the model tries to end
+    its turn, and a hook there can refuse: `stopping` does, while a checkpoint says an iteration is in flight
+    and the turn's last line is not an end the contract knows — the one control a command file's prose is
+    not. All three call the cruise script, which does nothing unless an iteration is in flight, so a plain
+    `/drive` session never sees them. The other harnesses' equivalents, where one exists, are the registry's
+    `compaction` rows.
     """
     script = layout.under("scripts/agents/cruise.py")
     return {
         "PreCompact": [{"hooks": [{"type": "command", "command": f"python3 {script} compacting"}]}],
         "SessionStart": [{"matcher": "compact", "hooks": [{"type": "command", "command": f"python3 {script} resume"}]}],
+        "Stop": [{"hooks": [{"type": "command", "command": f"python3 {script} stopping"}]}],
     }
 
 

{slipwai-1.2.0.dev19 → slipwai-1.2.0.dev23}/src/slipwai/project/commands.py

@@ -61,9 +61,10 @@ def drive_command(
    never default to the first service or the first context. Which contexts there are is found here, not
    declared up front: before slices go to `modelled`, apply Conway's law to the model
    (`skills/event-modeling/references/nine-steps.md`, end of Step 9) — lanes with vocabularies of their
-   own, joined only by the events one publishes and another reads, are bounded contexts. Record them as
-   `contexts` on the service in `project.json`, with the user, and place each slice with `context:`. One
-   vocabulary is one context; say so and move on."""
+   own, joined only by the events one publishes and another reads, are bounded contexts. Record them on
+   the service, with the user, as `slipwai describe-service <name> --context <context>` (once per
+   context; `--purpose` records what the service owns the same way), and place each slice with
+   `context:`. One vocabulary is one context; say so and move on."""
         )
     stages.append(
         """**Split** — the work is ordered vertical slices rather than one undivided outcome. Otherwise run
@@ -93,9 +94,9 @@ def drive_command(
    found in a project without an event model: read the specification's vocabulary the way
    `skills/domain-driven-design/resources/bounded-contexts.md` describes under *The Language Test* — the
    same word meaning two things, qualifiers creeping in ("billing customer", "shipping customer"), rules
-   that change for different reasons. Two vocabularies are two bounded contexts: record them as `contexts`
-   on the service in `project.json`, with the user, and put each context's code under its own
-   `src/<context>/` behind a `public` module — `make check-imports` keeps them apart from then on. One
+   that change for different reasons. Two vocabularies are two bounded contexts: record them on the
+   service, with the user, as `slipwai describe-service <name> --context <context>` (once per context), and
+   put each context's code under its own `src/<context>/` behind a `public` module — `make check-imports` keeps them apart from then on. One
    vocabulary is one context, and saying so is the whole decision. Neither is a reason for a new service;
    `docs/architecture.md`, *Bounded contexts*, says what is."""
     )