slipwai 1.2.1.dev8__tar.gz → 1.2.1.dev11__tar.gz

{slipwai-1.2.1.dev8 → slipwai-1.2.1.dev11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: slipwai
-Version: 1.2.1.dev8
+Version: 1.2.1.dev11
 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
@@ -260,6 +260,7 @@ changes. What changes is who answers.
 /cruise-settings enabled=true            # switch it on; commits .specify/cruise.json
 /cruise use the PRD in docs/prd.md       # start the runner, detached, and watch it from this session
 /cruise-status                           # is it running, how the last iteration ended, the feed's tail
+/cruise-watch                            # sit back down at the watch seat, where the feed left off
 /cruise-tell take the payments feature next   # queued for the next iteration; --now ends the one in flight
 /cruise-stop                             # end the run after the iteration in flight; `now` ends it now
 ```
@@ -317,8 +318,8 @@ the paths and toolchains named in them are real.
 |---|---|
 | `/drive` | Takes one slice from wherever it stands to a demo the actor can see |
 | `/cruise` | Runs `/drive` on its own, deciding as the product owner and demoing as the actor, until the specification is satisfied. Stops only for a person. `/cruise <kick-off>` gives the first iteration a brief; the session then watches the run and answers you |
-| `/whats-next` | Says what is next — one slice, one stage, one command. Reads the disk and changes nothing |
-| `/where-are-we` | Shows the progress board: what works, what is in progress, what is still to come |
+| `/whats-next` | Says what is next — one slice, one stage, one command. Reads the disk and changes nothing; beside a running `/cruise`, says what the runner is on instead |
+| `/where-are-we` | Shows the progress board: what works, what is in progress, what is still to come; beside a running `/cruise`, the next row is the runner's |
 | `/gaps` | Reviews an artifact for holes, before they become rewritten tests |
 | `/example-map` | *Event profile.* Turns one slice of the event model into rules, examples and executable scenarios |
 | `/validate-code-against-model` | *Event profile.* Checks that the code and the event model still agree |
@@ -335,6 +336,7 @@ the paths and toolchains named in them are real.
 | `/cruise-status` | Says whether a `/cruise` runner is running, how its last iteration ended, and shows the tail of its feed |
 | `/cruise-stop` | Ends a `/cruise` run after the iteration in flight, or at once with `now` |
 | `/cruise-tell` | Queues a message for a running `/cruise`, which the next iteration carries; `--now` ends the iteration in flight for it |
+| `/cruise-watch` | Takes the watch seat beside a running `/cruise`: prints the feed as it is written and watches again, starting nothing |
 
 [The delivery loop](docs/delivery-loop.md) describes each one in full, and the ladder they sit on.
 

{slipwai-1.2.1.dev8 → slipwai-1.2.1.dev11}/README.md

@@ -231,6 +231,7 @@ changes. What changes is who answers.
 /cruise-settings enabled=true            # switch it on; commits .specify/cruise.json
 /cruise use the PRD in docs/prd.md       # start the runner, detached, and watch it from this session
 /cruise-status                           # is it running, how the last iteration ended, the feed's tail
+/cruise-watch                            # sit back down at the watch seat, where the feed left off
 /cruise-tell take the payments feature next   # queued for the next iteration; --now ends the one in flight
 /cruise-stop                             # end the run after the iteration in flight; `now` ends it now
 ```
@@ -288,8 +289,8 @@ the paths and toolchains named in them are real.
 |---|---|
 | `/drive` | Takes one slice from wherever it stands to a demo the actor can see |
 | `/cruise` | Runs `/drive` on its own, deciding as the product owner and demoing as the actor, until the specification is satisfied. Stops only for a person. `/cruise <kick-off>` gives the first iteration a brief; the session then watches the run and answers you |
-| `/whats-next` | Says what is next — one slice, one stage, one command. Reads the disk and changes nothing |
-| `/where-are-we` | Shows the progress board: what works, what is in progress, what is still to come |
+| `/whats-next` | Says what is next — one slice, one stage, one command. Reads the disk and changes nothing; beside a running `/cruise`, says what the runner is on instead |
+| `/where-are-we` | Shows the progress board: what works, what is in progress, what is still to come; beside a running `/cruise`, the next row is the runner's |
 | `/gaps` | Reviews an artifact for holes, before they become rewritten tests |
 | `/example-map` | *Event profile.* Turns one slice of the event model into rules, examples and executable scenarios |
 | `/validate-code-against-model` | *Event profile.* Checks that the code and the event model still agree |
@@ -306,6 +307,7 @@ the paths and toolchains named in them are real.
 | `/cruise-status` | Says whether a `/cruise` runner is running, how its last iteration ended, and shows the tail of its feed |
 | `/cruise-stop` | Ends a `/cruise` run after the iteration in flight, or at once with `now` |
 | `/cruise-tell` | Queues a message for a running `/cruise`, which the next iteration carries; `--now` ends the iteration in flight for it |
+| `/cruise-watch` | Takes the watch seat beside a running `/cruise`: prints the feed as it is written and watches again, starting nothing |
 
 [The delivery loop](docs/delivery-loop.md) describes each one in full, and the ladder they sit on.
 

slipwai-1.2.1.dev11/VERSION

@@ -0,0 +1 @@
+1.2.1.dev11

{slipwai-1.2.1.dev8 → slipwai-1.2.1.dev11}/assets/toolkit/scripts/agents/cruise.py

@@ -1641,8 +1641,63 @@ def status() -> None:
         print(line)
 
 
+def checkpoint_fields() -> dict[str, str]:
+    """The checkpoint's labelled fields — Feature, Slice, Stage, Written, Delegates out, Open question, Next — as
+    the command writes them (`CHECKPOINT_ENTRY`), or nothing where no checkpoint is written."""
+    if not CHECKPOINT.is_file():
+        return {}
+    fields: dict[str, str] = {}
+    label: str | None = None
+    for line in CHECKPOINT.read_text().splitlines():
+        found = re.findall(r"\*\*([A-Za-z ]+):\*\* (.*?)(?= · \*\*|$)", line)
+        if found:
+            for label, value in found:
+                fields[label] = value.strip()
+        elif label is not None and line.startswith("  ") and label in ("Delegates out", "Open question", "Next"):
+            fields[label] = f"{fields[label]} {line.strip()}"
+    return fields
+
+
+def where() -> None:
+    """Where a run stands, for `/where-are-we` and `/whats-next` typed beside it — and nothing at all where no runner
+    is running, so that both commands answer exactly as they do without `/cruise`. With a runner alive: the run,
+    the iteration in flight or the park it waits in, the checkpoint's slice, stage and next step, and what a
+    person can do from here, which is never to run a stage themselves."""
+    running = running_pid()
+    if running is None:
+        return
+    log = entries()
+    tail = RUN_LOG.read_text(errors="replace").rstrip().splitlines()[-2:] if RUN_LOG.is_file() else []
+    parked = next((line.removeprefix("cruise: parked — ") for line in tail if line.startswith("cruise: parked — ")),
+                  None) if tail and tail[-1].startswith("cruise: waiting;") else None
+    print(f"cruise: a run is going here — runner pid {running[0]} since {running[1]}, {len(log)} iteration(s) logged, "
+          + (f"parked after iteration {len(log)}" if parked else f"iteration {len(log) + 1} in flight"))
+    fields = checkpoint_fields()
+    if fields:
+        print(f"cruise: feature {fields.get('Feature', '?')} · slice {fields.get('Slice', '?')} · stage "
+              f"{fields.get('Stage', '?')} · checkpoint written {fields.get('Written', '?')}")
+        for label in ("Open question", "Delegates out"):
+            if fields.get(label) and fields[label].lower() != "none":
+                print(f"cruise: {label.lower()} — {fields[label]}")
+        print(f"cruise: next — {fields.get('Next', '(the checkpoint names no next step)')}")
+    else:
+        print("cruise: no checkpoint written yet — the iteration has not reached its first stage boundary")
+    if parked:
+        print(f"cruise: parked — {parked}")
+        print("cruise: nothing to run from here — a person provides what the park names; `/cruise-tell` with it resumes "
+              "the run, `/cruise-stop` ends it")
+    else:
+        print("cruise: nothing to run from here — the runner is on it; `/cruise` watches it, `/cruise-tell` steers it, "
+              "`/cruise-stop` ends it")
+
+
 def main() -> None:
     arguments = sys.argv[1:]
+    if arguments[:1] == ["where"]:
+        # Before the settings check: a project with no `/cruise` settings has no run, and the commands that ask
+        # this read silence as "answer as without /cruise".
+        where()
+        return
     if not CONFIG.is_file():
         print(ABSENT)
         return

{slipwai-1.2.1.dev8 → slipwai-1.2.1.dev11}/changelog.d/gates-are-not-the-runs-to-change.md

@@ -25,6 +25,18 @@ session before it exits, which takes a moment, and a `start` typed the moment `s
 runner still alive and declined to start one — after which nobody was running and the watch seat found nobody to
 watch. It now waits for the runner to be gone, up to thirty seconds, and says so if it is still ending after that.
 
+**`/where-are-we` and `/whats-next` answer beside a running `/cruise`.** Both used to answer as if the person's
+session were about to take the next slice — "Run: /drive S13" while the runner was on S13. Each now runs
+`scripts/agents/cruise.py where` first, a read that prints the runner's iteration, the checkpoint's slice, stage
+and next step, and a park's reason, and puts those lines in the reply; the step for a person is then the runner's,
+with `/cruise`, `/cruise-tell` and `/cruise-stop` as what they can do. Where no runner is running the verb prints
+nothing and both commands answer exactly as before, so nothing changes outside a run.
+
+**`/cruise-watch` takes the watch seat on its own.** `/cruise-status` reads once and stops, and a session that
+typed it to answer a question had left the seat; the way back was `/cruise`, which reads as starting a run.
+`/cruise-watch` sits back down where the feed left off and starts nothing, with the seat's rules — its words
+and `commands/cruise.md`'s are one text — and `make cruise-watch` stays the same seat from a terminal.
+
 **Catch-up.** `slipwai migrate` brings the hook, the runner, the gate and the command text. A run that already
 carries a patched gate is found by `git log -- scripts/` and reverted by hand; the runner parks on the next
 change, not on the standing one.

{slipwai-1.2.1.dev8 → slipwai-1.2.1.dev11}/src/slipwai/project/commands.py

@@ -11,7 +11,7 @@ from .adversary import adversary_command
 from .benchmark import benchmark_command, what_each_stage_costs
 from .converge_stage import convergence_stage
 from .cruise import cruise_command, cruise_settings_command
-from .cruise_seat import cruise_status_command, cruise_stop_command, cruise_tell_command
+from .cruise_seat import cruise_status_command, cruise_stop_command, cruise_tell_command, cruise_watch_command
 from .demo_stop import demo_stop
 from .drive_adoption import adoption_ladder
 from .drive_settings import drive_settings_command, implementation_section
@@ -310,7 +310,8 @@ than an open question.
 # three reaching back out to the factory. One list, so the documentation and the files cannot disagree.
 BASE_COMMANDS = ("drive", "where-are-we", "whats-next", "gaps", "adversary", "mutation", "constitution-coverage",
                  "model-delegation-settings", "drive-settings", "benchmark", "cruise", "cruise-settings",
-                 "cruise-status", "cruise-stop", "cruise-tell", "add-service", "add-frontend", "catch-up")
+                 "cruise-status", "cruise-stop", "cruise-tell", "cruise-watch", "add-service", "add-frontend",
+                 "catch-up")
 # Copied whole from `assets/profiles/event-modelling/commands/`; listed because the documentation names them in order.
 EVENT_COMMANDS = ("example-map", "validate-code-against-model")
 
@@ -331,6 +332,7 @@ def command_files(
         "commands/cruise-status.md": cruise_status_command(layout),
         "commands/cruise-stop.md": cruise_stop_command(layout),
         "commands/cruise-tell.md": cruise_tell_command(layout),
+        "commands/cruise-watch.md": cruise_watch_command(layout),
         "commands/where-are-we.md": where_are_we_command(event, target),
         "commands/whats-next.md": whats_next_command(event),
         "commands/gaps.md": gaps_command(event),

{slipwai-1.2.1.dev8 → slipwai-1.2.1.dev11}/src/slipwai/project/cruise.py

@@ -17,13 +17,12 @@ from ..origin import Adoption
 from ..services import App
 from .cruise_agents import DECISIONS, OWNER_BRIEF, SKIPPER
 from .cruise_hand import hand_section
-from .cruise_record import ADR_RULE, CHECKPOINT, CHECKPOINT_ENTRY, DECISION_ENTRY, STOP_FILE
+from .cruise_record import ADR_RULE, CHECKPOINT, CHECKPOINT_ENTRY, CONFIG, DECISION_ENTRY, SCRIPT, STOP_FILE
+from .cruise_seat import watch_seat_body
 from .cruise_stops import LOG, REPORT, stop_table
-from .cruise_told import boundary_asks, seat_queues, told_argument
+from .cruise_told import boundary_asks, told_argument
 from .cruise_unblock import unblock_section
 
-CONFIG = ".specify/cruise.json"
-SCRIPT = "scripts/agents/cruise.py"
 # The last line of every iteration: the one thing the outer loop reads.
 LAST_LINES = ("cruise: continue", "cruise: done", "cruise: parked: <what a person must provide>",
               "cruise: stopped: human")
@@ -145,25 +144,7 @@ says when a run makes no progress (*Blocked: the bosun protocol*, below). {told_
 
 ## The watch seat
 
-After `start` — or where `start` said a runner is already running — run `python3 {SCRIPT} watch`. It prints
-what the iteration does as it happens, one line per command, file, and delegate out and back, and returns at
-the iteration's end, a park, the run's end, once the feed has gone quiet for a moment, or after a minute and a
-half with nothing new; its last line says which. **Put every line it printed in your reply, unchanged, in a
-fenced block, before anything else** — the harness folds a command's output, so the feed reaches a person only
-through your reply — **and where it says the run continues, or the iteration is in flight, run `watch` again
-at once**; where it says parked, ended, or no runner, repeat what it said and end the turn. A watch the
-harness cut short — a tool timeout, with no last line from `watch` — is watched again, not asked about. Where
-the harness can run a command in the background and re-invoke this session with its output when it returns,
-run `watch` that way, so the turn ends between watches and a person can type in the gap. Watching is only ever
-reading — the runner needs nothing from this session, and a turn that ends here ends nothing else — so it is
-never a reason to run a stage of the ladder in this session.
-
-**A person typing here is talking to you, not stopping the run.** Answer them — what the feed shows, what
-`{CONFIG}` says (`python3 {SCRIPT}` prints every setting and what it controls), what `python3 {SCRIPT} status`
-says, what `{DECISIONS}` records — and change a setting through `/cruise-settings` where they ask; it takes
-effect at the next iteration. {seat_queues(SCRIPT)} Then watch again. Only `touch {STOP_FILE}`, `python3 {SCRIPT} stop`, or
-`{layout.make} cruise-stop` ends the run, and only when they ask for that.
-
+After `start` — or where `start` said a runner is already running — {watch_seat_body(layout)}
 ## Run the ladder, and answer at its stops
 
 Run `commands/drive.md` from *Enter at the first incomplete stage* to its end, exactly as written — the entry

{slipwai-1.2.1.dev8 → slipwai-1.2.1.dev11}/src/slipwai/project/cruise_record.py

@@ -20,6 +20,9 @@ RUNNER_LOG = ".specify/cruise-run.log"
 # The harness's raw event stream the feed in the run log was rendered from, and how far the watch seat has read.
 RUNNER_STREAM = ".specify/cruise-stream.jsonl"
 WATCH_CURSOR = ".specify/cruise-watch.cursor"
+# Where `/cruise` is configured, and the runner every seat command speaks to; `cruise.py` re-exports both.
+CONFIG = ".specify/cruise.json"
+SCRIPT = "scripts/agents/cruise.py"
 LAST_RESPONSE = ".specify/cruise-last-response.txt"
 # What a person queued for the run through `tell`, until an iteration takes it; and what an iteration was given,
 # until the runner writes it into that iteration's log entry.

{slipwai-1.2.1.dev8 → slipwai-1.2.1.dev11}/src/slipwai/project/cruise_seat.py

@@ -1,4 +1,5 @@
-"""The three commands a person types beside a running `/cruise`: `/cruise-status`, `/cruise-stop` and `/cruise-tell`.
+"""The commands a person types beside a running `/cruise` — `/cruise-watch`, `/cruise-status`, `/cruise-stop`,
+`/cruise-tell` — and the watch seat itself, whose words `commands/cruise.md` and `/cruise-watch` both render.
 
 Each is a shell command and the rule for what to do with what it printed. The rule matters more than the
 command: a harness folds a command's output to a few lines, so a status or a feed reaches a person only through
@@ -7,8 +8,9 @@ the reply, and each of these says so in the same words the watch seat in `comman
 from __future__ import annotations
 
 from ..layout import AT_ROOT, Layout
-from .cruise import SCRIPT
-from .cruise_record import INBOX, RUNNER_LOG, STOP_FILE
+from .cruise_agents import DECISIONS
+from .cruise_record import CONFIG, INBOX, RUNNER_LOG, SCRIPT, STOP_FILE
+from .cruise_told import seat_queues, seat_stands
 
 # The rule every seat command shares: the harness folds a command's output, so the reply carries it.
 VERBATIM = ("Put every line it printed in your reply, unchanged, in a fenced block, before anything else: the harness "
@@ -96,3 +98,58 @@ lists it, and every message an iteration was given is in that iteration's entry
 is not a setting: `/cruise-settings` is still how a rule of the run changes. `{layout.make} cruise-tell
 MSG="…"` is the same from a terminal, `CRUISE_FLAGS=--now` for the immediate form.
 """
+
+
+def under_cruise_section() -> str:
+    """The section `/where-are-we` and `/whats-next` end with: how the answer changes while a `/cruise` runner is
+    going, and — by the verb printing nothing otherwise — how it does not change at all where none is."""
+    return f"""## Under a `/cruise` run
+
+Run `python3 {SCRIPT} where` first. It reads the run's pid file, log and checkpoint, changes nothing, and
+prints **nothing where no runner is running** — then everything above stands exactly as written, and this
+section does not apply. Where it printed lines, a run is going. {VERBATIM} Then the answer changes in one
+place: the step for a person — **Run:** here, the board's ➡️ *Next* row there — is not a command to type,
+because the runner is on it, at the slice and stage those lines name. Say so, and say what a person can do
+from here: `/cruise` watches the run, `/cruise-tell` steers it, `/cruise-stop` ends it; where the lines say
+the run is parked, the step is what the park names, and `/cruise-tell` with it resumes the run. Nothing else
+changes: the board is read from the same artifacts, and a slice the runner holds is one in progress, never
+one to take.
+"""
+
+
+def watch_seat_body(layout: Layout = AT_ROOT) -> str:
+    """The watch seat's rules, from the words `run watch` on: what the seat prints, when it watches again, when it
+    ends the turn, and how a person typing there is answered. One text, so `commands/cruise.md` — which leads into
+    it after `start` — and `/cruise-watch` — the seat on its own — cannot say two different things."""
+    return f"""run `python3 {SCRIPT} watch`. It prints
+what the iteration does as it happens, one line per command, file, and delegate out and back, and returns at
+the iteration's end, a park, the run's end, once the feed has gone quiet for a moment, or after a minute and a
+half with nothing new; its last line says which. **Put every line it printed in your reply, unchanged, in a
+fenced block, before anything else** — the harness folds a command's output, so the feed reaches a person only
+through your reply — **and where it says the run continues, or the iteration is in flight, run `watch` again
+at once**; where it says parked, ended, or no runner, repeat what it said and end the turn. A watch the
+harness cut short — a tool timeout, with no last line from `watch` — is watched again, not asked about. Where
+the harness can run a command in the background and re-invoke this session with its output when it returns,
+run `watch` that way, so the turn ends between watches and a person can type in the gap. Watching is only ever
+reading — the runner needs nothing from this session, and a turn that ends here ends nothing else — so it is
+never a reason to run a stage of the ladder in this session.
+
+**A person typing here is talking to you, not stopping the run.** Answer them — what the feed shows, what
+`{CONFIG}` says (`python3 {SCRIPT}` prints every setting and what it controls), what `python3 {SCRIPT} status`
+says, what `{DECISIONS}` records — and change a setting through `/cruise-settings` where they ask; it takes
+effect at the next iteration. {seat_queues(SCRIPT)} Then watch again. Only `touch {STOP_FILE}`, `python3 {SCRIPT} stop`, or
+`{layout.make} cruise-stop` ends the run, and only when they ask for that. {seat_stands()}"""
+
+
+def cruise_watch_command(layout: Layout = AT_ROOT) -> str:
+    """`/cruise-watch`: the watch seat on its own, without starting anything."""
+    return f"""---
+description: Take the watch seat beside a running /cruise — print the feed as the runner writes it, return at each boundary and watch again, answer a person typing here — without starting anything
+---
+# Cruise watch
+
+The watch seat on its own. `/cruise` takes it after starting the runner, and a `/cruise-status` between reads it
+once and stops; this sits back down where the feed left off, in this session, and starts nothing — where no
+runner is running, `watch` says so and this ends. `{layout.make} cruise-watch` is the same seat from a terminal.
+To take it: {watch_seat_body(layout)}
+"""

{slipwai-1.2.1.dev8 → slipwai-1.2.1.dev11}/src/slipwai/project/cruise_told.py

@@ -39,3 +39,9 @@ def boundary_asks(script: str) -> str:
 `/cruise-tell` since this iteration started, one `told:` line each, or nothing — and what it printed is acted on
 before the next stage, exactly as a `told:` argument would have been; it is taken as it is printed, so the next
 iteration is not given it again, and the runner puts it in this iteration's log entry."""
+
+
+def seat_stands() -> str:
+    """The sentence the watch seat carries about the two questions a person asks most, answered from disk."""
+    return ("Where they ask where the run stands or what is next, `/where-are-we` and `/whats-next` read the "
+            "runner's state first (`where`) and answer from it — never by sending the question down to the iteration.")

{slipwai-1.2.1.dev8 → slipwai-1.2.1.dev11}/src/slipwai/project/whats_next.py

@@ -9,6 +9,7 @@ derives its entry stage. It runs nothing, edits nothing, and never invents a sli
 """
 from __future__ import annotations
 
+from .cruise_seat import under_cruise_section
 from .demo_stop import board_sources
 
 
@@ -64,4 +65,5 @@ verified as current.
 - **Invents nothing.** No slice the split does not name, no stage the artifacts do not select. Where the
   artifacts cannot say, the line reads `unknown` with the artifact that would have said, and **Run:** is
   `/where-are-we`.
-"""
+
+{under_cruise_section()}"""

{slipwai-1.2.1.dev8 → slipwai-1.2.1.dev11}/src/slipwai/project/where_are_we.py

@@ -12,6 +12,7 @@ from __future__ import annotations
 
 from ..catalog import CATALOG
 from ..targets import managed
+from .cruise_seat import under_cruise_section
 from .demo_stop import board_sources
 
 
@@ -90,4 +91,5 @@ specification, {"event model, " if event else ""}split — and what the next sta
 - **Does not demo.** It hands over no command to paste and asks no question: that is the demo stop's job,
   and it belongs to `/drive`. Where the board shows a converged slice waiting for its demo, say so, and say
   that `/drive` is what runs it.
-"""
+
+{under_cruise_section()}"""

slipwai-1.2.1.dev8/VERSION

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