slipwai 1.0.1.dev8__tar.gz → 1.1.0.dev13__tar.gz

{slipwai-1.0.1.dev8 → slipwai-1.1.0.dev13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: slipwai
-Version: 1.0.1.dev8
+Version: 1.1.0.dev13
 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
@@ -54,7 +54,7 @@ You do not clone this repository to scaffold or adopt a product. Install once, t
 One-shot scaffolder for new product monorepos, and the ramp they leave from: *slipwai* is said *slipway*,
 the slope a finished hull slides down into the water, after which the yard has nothing more to do with it.
 Answer a few questions and you get a fresh Git repository containing a walking skeleton, an executable test,
-a `verify` gate that runs locally and in CI, and a complete delivery method — Spec Kit, up to 49 skills, thirteen
+a `verify` gate that runs locally and in CI, and a complete delivery method — Spec Kit, up to 49 skills, fifteen
 workflow commands, a global event model that renders itself, and generated documentation — set up for coding
 agents to work in from the first commit.
 
@@ -265,7 +265,7 @@ again later.
 | Document | Covers |
 |---|---|
 | [What a generated repository gets for free](docs/what-you-get.md) | The tour: the layout, the generated documentation, the agent harnesses, and how to run it |
-| [The delivery loop](docs/delivery-loop.md) | The `/drive` ladder and the diagram behind it, the thirteen commands, story splitting and example mapping with worked examples, the Spec Kit hooks, the preset layer, and the constitution floor |
+| [The delivery loop](docs/delivery-loop.md) | The `/drive` ladder and the diagram behind it, the fifteen commands, story splitting and example mapping with worked examples, the Spec Kit hooks, the preset layer, and the constitution floor |
 | [The skill catalogue](docs/skills.md) | The 49 skills grouped by what they are for, why a project is given only the ones whose subject it has, how examples are rendered in your own languages, and where to edit them |
 | [The global event model](docs/event-model.md) | Why the model is global, what `make model` renders, the status ladder `make check-model` enforces, and how the browsable page is published |
 | [Gates](docs/verification.md) | What `make verify` runs, what is deliberately outside it, and why the split falls where it does |

{slipwai-1.0.1.dev8 → slipwai-1.1.0.dev13}/README.md

@@ -27,7 +27,7 @@ You do not clone this repository to scaffold or adopt a product. Install once, t
 One-shot scaffolder for new product monorepos, and the ramp they leave from: *slipwai* is said *slipway*,
 the slope a finished hull slides down into the water, after which the yard has nothing more to do with it.
 Answer a few questions and you get a fresh Git repository containing a walking skeleton, an executable test,
-a `verify` gate that runs locally and in CI, and a complete delivery method — Spec Kit, up to 49 skills, thirteen
+a `verify` gate that runs locally and in CI, and a complete delivery method — Spec Kit, up to 49 skills, fifteen
 workflow commands, a global event model that renders itself, and generated documentation — set up for coding
 agents to work in from the first commit.
 
@@ -238,7 +238,7 @@ again later.
 | Document | Covers |
 |---|---|
 | [What a generated repository gets for free](docs/what-you-get.md) | The tour: the layout, the generated documentation, the agent harnesses, and how to run it |
-| [The delivery loop](docs/delivery-loop.md) | The `/drive` ladder and the diagram behind it, the thirteen commands, story splitting and example mapping with worked examples, the Spec Kit hooks, the preset layer, and the constitution floor |
+| [The delivery loop](docs/delivery-loop.md) | The `/drive` ladder and the diagram behind it, the fifteen commands, story splitting and example mapping with worked examples, the Spec Kit hooks, the preset layer, and the constitution floor |
 | [The skill catalogue](docs/skills.md) | The 49 skills grouped by what they are for, why a project is given only the ones whose subject it has, how examples are rendered in your own languages, and where to edit them |
 | [The global event model](docs/event-model.md) | Why the model is global, what `make model` renders, the status ladder `make check-model` enforces, and how the browsable page is published |
 | [Gates](docs/verification.md) | What `make verify` runs, what is deliberately outside it, and why the split falls where it does |

slipwai-1.1.0.dev13/VERSION

@@ -0,0 +1 @@
+1.1.0.dev13

{slipwai-1.0.1.dev8 → slipwai-1.1.0.dev13}/assets/profiles/event-modelling/.specify/presets/event-modelling/templates/constitution-template.md

@@ -121,28 +121,41 @@ events → outbox → event sourcing) is a plan-time decision recorded with its
 - **What is NOT a GWT scenario**: format and structure validation. That belongs in the type system,
   which MUST make invalid states unrepresentable. If the compiler can reject it, do not write a scenario.
 - **Cycle**: RED-GREEN-REFACTOR. Tests written after the code they cover MUST be sent back.
-- **One increment at a time (NON-NEGOTIABLE).** One failing test, the smallest code that passes it,
-  refactor on green. The next test MUST NOT be written until the current one is green and refactored.
-  **Writing a slice's scenarios up front as a batch and then implementing against them is
+- **One increment at a time (NON-NEGOTIABLE).** The unit of an increment is **one rule** — one numbered
+  rule of the slice's example map, with the examples that belong to it — taken RED-GREEN-REFACTOR: its
+  examples failing, the smallest code that passes them, refactor on green. Within a rule the examples MAY be written
+  together and implemented against, or taken one at a time, as the implementer judges; an increment MUST
+  NOT span rules, and the next rule's examples MUST NOT be written until the current rule is green and
+  refactored. **Writing a slice's scenarios up front as a batch and then implementing against them is
   prohibited**, however faithfully those scenarios were modelled — it is a planning artifact executed as
-  code, not a test-driven cycle.
-- At most **one** test may be failing at a time. Each cycle MUST leave the quickest relevant tests in its
-  file or area green. Commit each completed cycle locally; do not push those commits until the actor has
-  accepted the demo. The whole suite MUST be green immediately before that first implementation push,
-  which is what may land on trunk. A row of pending tests is not RED; it is an unintegrated batch of the
-  kind X exists to prevent.
-- A test MUST be observed failing, **and failing for the stated reason**, before the code that satisfies
-  it is written. A test that passes the moment it is written is evidence of nothing and MUST be treated as
-  a defect in the test.
+  code, not a test-driven cycle. A task that produces no behaviour — a proof over what an earlier increment
+  already built — is a rule cut too small, and belongs inside the increment that produces the behaviour it
+  guards.
+- At most **one rule's** examples may be failing at a time. Each cycle MUST leave the quickest relevant
+  tests in its file or area green. Commit each completed cycle locally; do not push those commits until the
+  actor has accepted the demo. The whole suite MUST be green immediately before that first implementation push,
+  which is what may land on trunk. A row of pending tests is not RED; it is an unintegrated batch of
+  the kind X exists to prevent.
+- **RED is a failing assertion, not a failing build.** Whatever an example names — function, method, type,
+  field — MUST exist far enough to compile against before that example is written, as a no-op or a default
+  return; that fixes the shape while saying nothing about the behaviour. A red build is not a red test, and
+  "it does not compile yet" is never the stated reason a test fails.
+- Every example MUST be observed failing, **and failing for its own stated reason, distinct from its
+  siblings'**, before the code that satisfies it is written. Examples that all fail for one shared cause
+  have been observed once rather than once each, and every one beyond the first is unproven. A test that
+  passes the moment it is written is evidence of nothing until it has been observed failing: where the
+  behaviour already exists, that observation is the behaviour changed and restored, and the report says so.
 - REFACTOR is a step, not an option. It happens on green, before the next test, and it MUST NOT change
   observable behaviour.
 
 Rationale for the increment rule: writing every scenario first looks like rigour and removes the thing
 that makes TDD work. Each test is supposed to be a design experiment whose result changes what you write
 next; a batch fixes the design before the first result arrives. It also destroys the attribution that
-makes a failure cheap — with one red test you know exactly which change broke it, and with nine you are
-debugging. The scenarios discovered during modelling are the *list* of increments to drive, not a body of
-code to author in one sitting.
+makes a failure cheap — with one rule red you know exactly which change broke it, and with nine rules you
+are debugging. The rules discovered during modelling are the *list* of increments to drive, their examples
+the tests inside each — not a body of code to author in one sitting. The rule is the unit because it is the
+smallest thing the example map agrees on: cut finer, the offcuts are tasks that prove what an earlier task
+built and produce nothing, and each is a red test that cannot be made red.
 - **Behaviour, not structure.** Tests MUST NOT assert private functions, internal call ordering, or mock
   invocation counts where an observable outcome exists. Renaming an internal function MUST NOT break a
   test.

{slipwai-1.0.1.dev8 → slipwai-1.1.0.dev13}/assets/profiles/event-modelling/.specify/presets/event-modelling/templates/tasks-template.md

@@ -14,7 +14,7 @@ test tasks, so without it the test tasks get invented here instead of derived fr
 
 **Tests**: **REQUIRED, not optional.** The constitution's Principle V mandates Given-When-Then acceptance
 criteria observed failing before implementation, binding at the application boundary. Within the slice
-phase this is enforced increment by increment: one failing test, the code that passes it, refactor,
+phase this is enforced increment by increment: one rule's examples failing, the code that passes them, refactor,
 commit — never a batch of tests followed by a batch of implementation. This overrides any template
 default that tests are optional.
 
@@ -116,18 +116,20 @@ concurrency ceiling and MUST be explicit, not incidental]
       `/example-map <id>`: the increments below drive its scenarios, and inventing them here instead means
       building against a guess
 
-### Increments for this slice — one RED-GREEN-REFACTOR at a time ⚠️
+### Increments for this slice — one rule per RED-GREEN-REFACTOR cycle ⚠️
 
-**Each task below is one full cycle, not a test to be batched with the others.** Write its single test,
-observe it failing *and failing for the stated reason*, write the smallest code that makes it pass,
-refactor on green, and run the quickest relevant tests in the same file or area. Then start the next one.
+**Each task below is one rule of `slices/<id>/examples.md` with the examples that belong to it — one full
+cycle, not a test to be batched with the others.** Stub whatever the rule's examples name so the suite
+builds, write its examples — together or one at a time, as the implementer judges — observe each failing
+*and failing for its own stated reason*, write the smallest code that makes them pass, refactor on green, and
+run the quickest relevant tests in the same file or area. Then start the next rule.
 
-**Do not write the next increment's test until the current increment is green and refactored** (Principle
+**Do not write the next rule's examples until the current rule is green and refactored** (Principle
 V). Commit each increment locally. Do not push those commits until the actor has accepted the demo; that is
 when the full suite runs. The history choice never permits writing this whole list as tests first and then
 implementing against them: that fixes the design before the first test result arrives and turns a one-line
-attribution into a debugging session. The modelled scenarios are the list of increments to drive — not a
-body of test code to author in one sitting.
+attribution into a debugging session. The map's rules are the list of increments to drive, their examples the
+tests inside each — not a body of test code to author in one sitting.
 
 The order is deliberate. The first increment pays the structural cost of reaching every layer; each later
 one adds a rule to code that already exists.
@@ -137,7 +139,9 @@ Decider, `VS-` for a view fold — and the test's own title carries that id. Two
 grep proves every agreed example has a test, and a test with no id is either a scenario missing from the map
 or behaviour being invented at the keyboard. If an increment has no scenario to cite, the map is incomplete —
 go back to `/example-map` rather than filling the gap here. Replace the generic increments below with one per
-scenario the map actually holds; the list is a checklist of *kinds*, not a quota to meet.
+rule the map actually holds, each citing its `R<n>`; the list is a checklist of *kinds*, not a quota to meet. A
+task whose GREEN would be empty — a proof over behaviour an earlier task built — is a rule cut too small, and
+folds into the task that produces the behaviour it guards.
 
 - [ ] T033 [US1] **Happy path.** RED: boundary acceptance for the happy path, entering through the use case, asserting on what is observable there. The route gets its own `tests/edge/` test for parse, delegate, and outcome-to-status — it is a translation, not where the rule is proved. GREEN: the minimum that satisfies it — the event schema(s) this one scenario needs, `initialState` and `evolve`, `decide` for the one command, the driving port returning discriminated outcomes, the use case (load, fold, decide, append with expected version), the route handler, and the composition wiring
 - [ ] T034 [US1] **The white box, in its main state.** *Delete these three tasks only if this slice has no `ui` frame — which for a `state-change` or `state-view` slice means the model is wrong, not that there is no screen.* RED: a test at the project's UI level drives the surface the way its actor does — type into the labelled fields, click the button — and asserts what the actor sees. GREEN: the screen. **If the `ui` frame has `mockups`, that state's mock is the build target**; open it and build to it. **If it has none, design it here** — then commit the wireframe under `docs/event-model/mockups/` and add its `mockups` entry to the frame in the same commit, because a screen whose states are recorded nowhere is a screen whose gaps nobody can see. An HTTP test through the route is **not** evidence about this task; load `front-end-testing` (and `react-testing` if the project is React) for the lightest harness that proves a browser-observable claim

slipwai-1.1.0.dev13/assets/profiles/event-modelling/commands/example-map.md

@@ -0,0 +1,44 @@
+---
+description: Turn one event-model slice into concrete rules, examples, and executable scenarios
+argument-hint: [slice-id]
+---
+
+# Example map
+
+Read the slice in `docs/event-model/model.yaml` and use `skills/event-modeling/SKILL.md`. Work with four
+items: story, rules, concrete examples, and unresolved questions. Do not invent an event, field, command,
+stream identity, or policy to close a product question. Write the agreed Given/When/Then scenarios and link
+their path from the slice's `gwt` field. Preserve the Event Modeling/event-sourcing contract as one unit.
+
+## Rules own their examples
+
+Write the map as numbered rules, `R1`…`Rn`, each heading carrying its own examples and their scenarios —
+not every rule in one section and every scenario in another. The rule is the unit of a RED-GREEN-REFACTOR
+increment (Principle V), so the grouping here is the boundary the tasks are cut on and the verdicts cite:
+without a stated grouping there is no agreed rule boundary, and whoever writes the tasks invents one.
+
+```markdown
+## Story
+Buyer places an order for the items in their cart and gets a confirmation.
+
+## R1 — An order cannot be placed from an empty cart
+- empty cart → rejected, nothing recorded
+
+### Scenario: Cannot place order with empty cart (CS-1)
+**Given** CartCreated { cartId: "CART-001" } · **When** PlaceOrder { cartId: "CART-001" } ·
+**Then** error "cart CART-001 contains no items", no events
+
+## R2 — The order total is the sum of the cart's line totals at the moment it is placed
+- 2 x £29.99 → order total £59.98, and later price changes do not move it
+
+### Scenario: Successfully place an order (CS-2)
+…
+
+## Questions
+- Does a cart expire, and if so does expiry reject or silently empty it? → for the product owner
+```
+
+Never renumber a rule once a task or a verdict cites it: a new rule takes the next number, and a dropped one
+keeps its number with a line saying it was dropped and why. Do not retrofit this shape onto a map that is
+already agreed and implemented — the format applies from the next slice mapped, and an older map is read
+as it stands.

{slipwai-1.0.1.dev8 → slipwai-1.1.0.dev13}/assets/profiles/standard/.specify/presets/standard/templates/constitution-template.md

@@ -108,28 +108,42 @@ still a choice.
 - **What is NOT a GWT scenario**: format and structure validation. That belongs in the type system,
   which MUST make invalid states unrepresentable. If the compiler can reject it, do not write a scenario.
 - **Cycle**: RED-GREEN-REFACTOR. Tests written after the code they cover MUST be sent back.
-- **One increment at a time (NON-NEGOTIABLE).** One failing test, the smallest code that passes it,
-  refactor on green. The next test MUST NOT be written until the current one is green and refactored.
-  **Writing a slice's scenarios up front as a batch and then implementing against them is
+- **One increment at a time (NON-NEGOTIABLE).** The unit of an increment is **one rule** —
+  one numbered rule of the slice's example map, or one acceptance criterion where there is no map,
+  with the examples that belong to it — taken RED-GREEN-REFACTOR: its examples
+  failing, the smallest code that passes them, refactor on green. Within a rule the examples MAY be written
+  together and implemented against, or taken one at a time, as the implementer judges; an increment MUST
+  NOT span rules, and the next rule's examples MUST NOT be written until the current rule is green and
+  refactored. **Writing a slice's scenarios up front as a batch and then implementing against them is
   prohibited**, however carefully those scenarios were specified — it is a planning artifact executed as
-  code, not a test-driven cycle.
-- At most **one** test may be failing at a time. Each cycle MUST leave the quickest relevant tests in its
-  file or area green. Commit each completed cycle locally; do not push those commits until the actor has
-  accepted the demo. The whole suite MUST be green immediately before that first implementation push,
-  which is what may land on trunk. A row of pending tests is not RED; it is an unintegrated batch of the
-  kind IX exists to prevent.
-- A test MUST be observed failing, **and failing for the stated reason**, before the code that satisfies
-  it is written. A test that passes the moment it is written is evidence of nothing and MUST be treated as
-  a defect in the test.
+  code, not a test-driven cycle. A task that produces no behaviour — a proof over what an earlier increment
+  already built — is a rule cut too small, and belongs inside the increment that produces the behaviour it
+  guards.
+- At most **one rule's** examples may be failing at a time. Each cycle MUST leave the quickest relevant
+  tests in its file or area green. Commit each completed cycle locally; do not push those commits until the
+  actor has accepted the demo. The whole suite MUST be green immediately before that first implementation push,
+  which is what may land on trunk. A row of pending tests is not RED; it is an unintegrated batch of
+  the kind IX exists to prevent.
+- **RED is a failing assertion, not a failing build.** Whatever an example names — function, method, type,
+  field — MUST exist far enough to compile against before that example is written, as a no-op or a default
+  return; that fixes the shape while saying nothing about the behaviour. A red build is not a red test, and
+  "it does not compile yet" is never the stated reason a test fails.
+- Every example MUST be observed failing, **and failing for its own stated reason, distinct from its
+  siblings'**, before the code that satisfies it is written. Examples that all fail for one shared cause
+  have been observed once rather than once each, and every one beyond the first is unproven. A test that
+  passes the moment it is written is evidence of nothing until it has been observed failing: where the
+  behaviour already exists, that observation is the behaviour changed and restored, and the report says so.
 - REFACTOR is a step, not an option. It happens on green, before the next test, and it MUST NOT change
   observable behaviour.
 
 Rationale for the increment rule: writing every scenario first looks like rigour and removes the thing
 that makes TDD work. Each test is supposed to be a design experiment whose result changes what you write
 next; a batch fixes the design before the first result arrives. It also destroys the attribution that
-makes a failure cheap — with one red test you know exactly which change broke it, and with nine you are
-debugging. The scenarios discovered during specification are the *list* of increments to drive, not a body
-of code to author in one sitting.
+makes a failure cheap — with one rule red you know exactly which change broke it, and with nine rules you
+are debugging. The rules discovered during specification are the *list* of increments to drive, their examples
+the tests inside each — not a body of code to author in one sitting. The rule is the unit because it is the
+smallest thing the example map agrees on: cut finer, the offcuts are tasks that prove what an earlier task
+built and produce nothing, and each is a red test that cannot be made red.
 
 - **Behaviour, not structure.** Tests MUST NOT assert private functions, internal call ordering, or mock
   invocation counts where an observable outcome exists. Renaming an internal function MUST NOT break a

{slipwai-1.0.1.dev8 → slipwai-1.1.0.dev13}/assets/toolkit/docs/agent-harnesses.md

@@ -90,7 +90,7 @@ the tool arrives *deferred*, a bare name the delegate has to load through the ha
 before it can call it. `registry.json` records all of that under `agentFile.mcp`, with the source and the date
 it was read, and every projection's stamp carries it, so a route a harness withholds is one somebody can read.
 
-Because the model lives in these files on five of the six harnesses, `/who-runs` rewrites them as part of the
+Because the model lives in these files on five of the six harnesses, `/model-delegation-settings` rewrites them as part of the
 change — the line saying so is part of its output — and `check-agents` reads a type that drifted from its
 canonical source the same way it reads a drifted skill.
 
@@ -102,7 +102,7 @@ identifiers per harness; `host` is the model running `/drive` itself. `python3 s
 resolves both into the line `/drive` reads before a stage — the model to delegate to and how, or why the stage
 runs on the host model — and `make models` prints the whole table. A harness with a `null` row runs every stage
 on the host model, and the line says so. Edit the roles for your harness — only Claude Code's `fast` is seeded —
-and `make check-agents` checks the shape. Change it whenever you like: `/who-runs implement=strong claude.fast=haiku` (the
+and `make check-agents` checks the shape. Change it whenever you like: `/model-delegation-settings implement=strong claude.fast=haiku` (the
 command over `python3 scripts/agents/models.py --set`) writes a checked edit, `/drive` reads the table before every stage so the
 change takes effect at the next one, and `slipwai migrate` merges a newer factory's table over yours rather than
 replacing it.

{slipwai-1.0.1.dev8 → slipwai-1.1.0.dev13}/assets/toolkit/docs/delegated-agent-safety.md

@@ -12,7 +12,16 @@ brief from carrying an incomplete copy of either.
   implementation delegate may edit only the files its manifest names. Stop and report when another change
   is needed.
 - Preserve work already in the checkout. Never use `git stash`, never use `git checkout` without the exact
-  path and intent, and never copy a tracked file aside as a backup.
+  path and intent, and never copy a tracked file aside as a backup. The one sanctioned way to observe a
+  failure without leaving the tree dirty — to check an assertion has teeth, or to see a RED on code that
+  already exists — is to change the production file, run the test, and restore that file with
+  `git checkout -- <exact path>`. A prohibition with no legal route gets routed around by exactly the
+  delegates trying hardest to do the job well; this is the route.
+- A delegate that edits the tree as part of its *method* rather than its output — a converge pass mutating
+  code to prove a finding, an implementation delegate checking an assertion discriminates — owns leaving it
+  clean on every exit path, including being stopped: branch or commit before the first such edit, restore
+  each file before the next, and report what was touched. A stopped pass once left a mutation live in the
+  tree the demo was next to run from.
 - Do not stop processes by command-line pattern: `pkill -f <pattern>` can match the shell issuing it. Stop only
   a PID the task started and recorded.
 - Leave existing long-lived processes running, including development servers, demos, watchers and backing

{slipwai-1.0.1.dev8 → slipwai-1.1.0.dev13}/assets/toolkit/scripts/agents/benchmark.py

@@ -21,7 +21,8 @@ with the reason where it does not; which model ran, from the same lines; the tas
 converge pass; how many times converge ran; a stage re-entered after implementation; files and lines from
 `git diff`. What nothing on disk can supply is passed to `end` as `key=value`: `gaps=N`, `findings=N`,
 `seams=N`, `mutation_score=…` copied from the tool's line, `verify_failures=N`, `outcome=accepted|behaviour|implementation`,
-and `model=` or `agent=` only where no transcript could say. A number that was not read is not written.
+`delegate=<boundary>` and `cycle=<unit>` for how an implement entry was delegated and driven with `split=N` for
+how many groups its delegate fanned out into, and `model=` or `agent=` only where no transcript could say. A number that was not read is not written.
 """
 
 from __future__ import annotations
@@ -60,8 +61,8 @@ OUTCOMES = ("accepted", "behaviour", "implementation")
 # Converge passes beyond which the overview says something: one pass to find work and one to confirm it
 # closed is the shape of a slice that converged, so the third is the first that is worth reading about.
 REPEATED = 3
-COUNTS = ("gaps", "findings", "seams", "verify_failures")
-WORDS = ("mutation_score", "outcome", "model", "agent", "note")
+COUNTS = ("gaps", "findings", "seams", "verify_failures", "split")
+WORDS = ("mutation_score", "outcome", "model", "agent", "note", "delegate", "cycle")
 COMMENT = (
     "What each stage of /drive cost this slice and how well it did, one entry per stage run, appended by "
     "scripts/agents/benchmark.py at the stage's start and end. Tokens come from the harness's own transcript or are "
@@ -535,6 +536,14 @@ def summarise(record: dict[str, Any]) -> dict[str, Any]:
         "findings": sum(entry["signals"].get("findings", 0) for entry in ended),
         "seams": sum(entry["signals"].get("seams", 0) for entry in ended),
         "verify_failures": sum(entry["signals"].get("verify_failures", 0) for entry in ended),
+        # How each implement entry was delegated and driven, `delegate/cycle`: one shape is a comparable slice,
+        # two is a slice that ran as both and compares with neither (`commands/drive.md`, *How implementation
+        # is delegated*).
+        "delegation": sorted({
+            f"{entry['signals'].get('delegate', '?')}/{entry['signals'].get('cycle', '?')}"
+            for entry in ended if {"delegate", "cycle"} & set(entry.get("signals", {}))
+        }),
+        "split": sum(entry["signals"].get("split", 0) for entry in ended),
         "rework": rework, "shape": record.get("shape"),
     }
 
@@ -544,7 +553,7 @@ def records() -> list[tuple[Path, dict[str, Any]]]:
     return [(path, json.loads(path.read_text())) for path in sorted(specs.rglob(RECORD))] if specs.is_dir() else []
 
 
-COLUMNS = ("slice", "wall", "in", "out", "models", "sessions", "converge", "+tasks", "gaps", "mutation",
+COLUMNS = ("slice", "delegate/cycle", "wall", "in", "out", "models", "sessions", "converge", "+tasks", "gaps", "mutation",
            "adversary", "demo", "verify✗", "rework", "tasks", "files", "±lines")
 
 
@@ -553,7 +562,7 @@ def row(summary: dict[str, Any]) -> list[str]:
     shape = summary.get("shape") or {}
     unknown = f" (+{summary['usage_unknown']} unread)" if summary["usage_unknown"] else ""
     return [
-        summary["slice"] or "(feature)", summary_wall(summary),
+        summary["slice"] or "(feature)", ", ".join(summary["delegation"]) or "—", summary_wall(summary),
         compact(tokens["input"] + tokens["cache_read"] + tokens["cache_creation"]) + unknown, compact(tokens["output"]),
         ", ".join(summary["models"]) or "—", str(summary["sessions"]) or "—",
         str(summary["converge_passes"]), str(summary["tasks_appended"]),
@@ -570,7 +579,7 @@ def table(rows: list[list[str]]) -> str:
                      for line in [list(COLUMNS), *rows])
 
 
-LEGEND = ("in = input + cache read + cache creation tokens; gaps = before/after converge; +tasks = tasks converge "
+LEGEND = ("delegate/cycle = how implementation was delegated and driven; in = input + cache read + cache creation tokens; gaps = before/after converge; +tasks = tasks converge "
           "appended; sessions = harness sessions read; a stage's tokens are a floor (the turn that ends it is partly "
           "uncounted); a trailing + makes wall a floor because an unbracketed stage is missing; tokens are not prices")
 READING = """These numbers compare the slices of this project on this harness, and one slice before and after a change
@@ -603,6 +612,8 @@ def notes(summaries: list[dict[str, Any]], records_: list[dict[str, Any]]) -> li
               for summary in summaries if summary["slice"] and summary["converge_passes"] >= REPEATED]
     lines += [f"{summary['slice']}: re-entered {', '.join(summary['rework'])} after implementation"
               for summary in summaries if summary["slice"] and summary["rework"]]
+    lines += [f"{summary['slice']}: implemented as {' and '.join(summary['delegation'])} — its wall compares with "
+              "neither" for summary in summaries if summary["slice"] and len(summary["delegation"]) > 1]
     for record in records_:
         for entry in record.get("stages", []):
             usage = entry.get("usage")

slipwai-1.1.0.dev13/assets/toolkit/scripts/agents/drive.py

@@ -0,0 +1,121 @@
+#!/usr/bin/env python3
+"""How `/drive` hands implementation to `drive-implement`: the boundary a delegate is handed, and the cycle it runs.
+
+`.specify/drive.json` holds both — `delegate`: how much one delegate is handed, every rule of one user story, one
+rule, or one task; `cycle`: how many RED tests one RED-GREEN-REFACTOR cycle opens with, a rule's examples together
+or one at a time. This reads the file and says what the settings are and mean, checks a hand edit, and changes them
+through `--set`, refusing anything the ladder could not act on. `commands/drive.md`, *How implementation is
+delegated*, says which veto overrides a setting on a slice; nothing here decides that.
+
+    python3 scripts/agents/drive.py                                   # both settings and what each means
+    python3 scripts/agents/drive.py --check                           # well-formed; `make check-agents` runs this
+    python3 scripts/agents/drive.py --set delegate=rule cycle=example # change them, checked, any time
+
+A change takes effect at the next implementation stage `/drive` runs: the file is read before every one and
+cached nowhere. `slipwai migrate` merges a newer factory's file over an edited one rather than replacing it.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+
+def project_root(script: Path, depth: int) -> Path:
+    """The repository root: the nearest directory above this script holding `project.json` (see models.py)."""
+    for candidate in script.parents:
+        if (candidate / "project.json").is_file():
+            return candidate
+    return script.parents[depth]
+
+
+ROOT = project_root(Path(__file__).resolve(), 2)
+CONFIG = ROOT / ".specify/drive.json"
+DELEGATES = {
+    "story": "every rule of one user story, each rule its own cycle in one context",
+    "rule": "one rule with its examples",
+    "task": "one task as the tasks stage cut it",
+}
+CYCLES = {
+    "rule": "a rule's examples written together, each failing for its own stated reason, then the code",
+    "example": "one failing test, then the code that passes it",
+}
+DEFAULTS = {"delegate": "story", "cycle": "rule"}
+# Every rule of a story red before any is implemented is the batch Principle V prohibits: not a value.
+REFUSED = {"cycle": {"story": "a story is never a cycle unit — every rule of a story red before any is implemented "
+                              "is the batch Principle V prohibits; `cycle=rule` is the widest cycle there is"}}
+VETOES = ("on a slice whose tasks carry no story tag, `story` falls to `rule`; on a map that does not number its "
+          "rules, the boundary falls to `task` and the cycle to `example` (commands/drive.md, *How implementation is "
+          "delegated*)")
+ABSENT = (f"no {CONFIG.relative_to(ROOT)}: /drive delegates per {DEFAULTS['delegate']} and cycles per "
+          f"{DEFAULTS['cycle']}, the defaults; `slipwai migrate` writes the file")
+
+
+def check(table: object) -> list[str]:
+    """Everything a hand edit can break, each as one finding."""
+    if not isinstance(table, dict):
+        return ["the file is not a JSON object"]
+    findings = []
+    for key, known in (("delegate", DELEGATES), ("cycle", CYCLES)):
+        value = table.get(key)
+        if value not in known:
+            refused = REFUSED.get(key, {}).get(value)
+            findings.append(f"`{key}` is {value!r}; {refused}" if refused
+                            else f"`{key}` must be one of {', '.join(known)}, not {value!r}")
+    return findings
+
+
+def assign(table: dict[str, Any], assignment: str) -> str:
+    """Apply one `delegate=…` or `cycle=…` in place and say what changed; `check` decides whether it stands."""
+    key, separator, value = assignment.partition("=")
+    if not separator or key not in DEFAULTS or not value:
+        raise RuntimeError(f"--set takes delegate=story|rule|task or cycle=rule|example, not {assignment!r}")
+    table[key] = value
+    return f"{key} = {value}"
+
+
+def describe(table: dict[str, Any]) -> str:
+    return "\n".join((
+        f"delegate: {table['delegate']} — {DELEGATES[table['delegate']]}",
+        f"cycle: {table['cycle']} — {CYCLES[table['cycle']]}",
+        f"vetoes: {VETOES}",
+    ))
+
+
+def main() -> None:
+    arguments = sys.argv[1:]
+    if not CONFIG.is_file():
+        print(ABSENT)
+        return
+    table = json.loads(CONFIG.read_text())
+    if "--set" in arguments:
+        assignments = arguments[arguments.index("--set") + 1:]
+        if not assignments:
+            raise RuntimeError("--set takes delegate=story|rule|task or cycle=rule|example")
+        changed = [assign(table, assignment) for assignment in assignments]
+        findings = check(table)
+        if findings:
+            raise RuntimeError("not written — the change would leave the file malformed:\n  - " + "\n  - ".join(findings))
+        CONFIG.write_text(json.dumps(table, indent=2, ensure_ascii=False) + "\n")
+        for line in changed:
+            print(line)
+        print(f"{CONFIG.relative_to(ROOT)} written; it takes effect at the next implementation stage /drive runs. "
+              "Commit it: the choice is versioned with the project.")
+        return
+    findings = check(table)
+    if findings:
+        raise RuntimeError(f"{CONFIG.relative_to(ROOT)}:\n  - " + "\n  - ".join(findings))
+    if "--check" in arguments:
+        print(f"check-drive: {CONFIG.relative_to(ROOT)} delegates per {table['delegate']} and cycles per {table['cycle']}")
+        return
+    print(describe(table))
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except (OSError, ValueError, RuntimeError, KeyError) as error:
+        print(f"drive: {error}", file=sys.stderr)
+        raise SystemExit(1) from None

{slipwai-1.0.1.dev8 → slipwai-1.1.0.dev13}/assets/toolkit/scripts/agents/project.py

@@ -246,7 +246,7 @@ def agent_model(stage: str, harness: dict[str, object]) -> tuple[str | None, str
 
     The agent file is a *projection* of `.specify/models.json`, never a second place a model is written: five
     of the six harnesses that can give a sub-task its own model can only do it here, so if this file decided
-    for itself, `/who-runs` would stop being the answer to "which model runs implement".
+    for itself, `/model-delegation-settings` would stop being the answer to "which model runs implement".
     """
     if stage == NO_STAGE:
         return None, ("this type runs a whole slice and reads the table stage by stage inside itself, so it "
@@ -656,6 +656,9 @@ def main() -> None:
                     if isinstance(harness.get("agentFile"), dict)
                     else "Project skills and commands installed")
             print(f'{done} for {harness["name"]} ({key}).')
+            if isinstance(harness.get("agentFile"), dict) and not CONTEXT_ONLY:
+                print("A harness reads its agent types once, at session start: restart the session before "
+                      "delegating, or the first delegation cannot use the types just projected.")
     if CHECK:
         if FINDINGS:
             raise RuntimeError("agent projection drift:\n  - " + "\n  - ".join(FINDINGS))

{slipwai-1.0.1.dev8 → slipwai-1.1.0.dev13}/assets/toolkit/scripts/event-model/render.ts

@@ -78,19 +78,32 @@ function mermaidCli(): string {
   return bin;
 }
 
+/**
+ * Runs mermaid-cli once. Chromium refuses to start as root without `--no-sandbox`, which is how every rootless
+ * container fails here; when that is the situation and no Puppeteer config was given, say which variable
+ * fixes it before rethrowing, rather than leaving Chromium's own message to be searched for.
+ */
+function runMermaid(args: string[]): void {
+  try {
+    execFileSync(mermaidCli(), [...args, ...PUPPETEER_FLAGS], { cwd: ROOT, stdio: 'inherit' });
+  } catch (error) {
+    if (PUPPETEER_FLAGS.length === 0 && typeof process.getuid === 'function' && process.getuid() === 0) {
+      process.stderr.write(
+        'render: running as root, and Chromium will not start without --no-sandbox. Point MERMAID_PUPPETEER_CONFIG '
+          + 'at a JSON file such as {"args": ["--no-sandbox", "--disable-dev-shm-usage"]} and rerun; the generated '
+          + 'CI workflow does exactly this.\n',
+      );
+    }
+    throw error;
+  }
+}
+
 function mermaidToSvg(input: string, output: string): void {
-  execFileSync(mermaidCli(), ['--input', input, '--output', output, '--width', WIDTH, ...PUPPETEER_FLAGS], {
-    cwd: ROOT,
-    stdio: 'inherit',
-  });
+  runMermaid(['--input', input, '--output', output, '--width', WIDTH]);
 }
 
 function mermaidToPng(input: string, output: string): void {
-  execFileSync(
-    mermaidCli(),
-    ['--input', input, '--output', output, '--width', WIDTH, '--backgroundColor', 'white', ...PUPPETEER_FLAGS],
-    { cwd: ROOT, stdio: 'inherit' },
-  );
+  runMermaid(['--input', input, '--output', output, '--width', WIDTH, '--backgroundColor', 'white']);
 }
 
 /**

slipwai-1.1.0.dev13/changelog.d/drive-bounded-convergence.md

@@ -0,0 +1,20 @@
+PATCH
+
+**`/drive` bounds its convergence loop, checks the branch before it reads the artifacts, and gives a
+delegate the one legal way to watch a test fail.** Measured on a project running the generated workflow:
+convergence and the rework it ordered cost one slice 12.9 times its implementation, because the stage's exit
+condition was the judgement of the model being looped and nothing bounded it; a `/drive` on a branch
+fifty-seven commits behind trunk wrote a second example map for a slice that had shipped, because every
+artifact the ladder reads is a property of the commit it is on; and two delegates in a row reached for
+`git stash` and a copied-aside backup, both forbidden, because they needed to observe a failure without
+dirtying the tree and the safety page forbade the routes without naming one. Now the convergence rung stops
+at two passes by default and appends what is still open as Phase 4 tasks, only a `CRITICAL` or `HIGH` finding
+re-opens it and only a `CRITICAL` re-opens it past the bound, the first pass is handed every abstraction level to account for, the tree is checked clean after
+every pass including a stopped one, and a stopped pass's last line is a lead to re-run rather than a finding
+to file. The entry-stage evidence names the branch, its head and its distance from trunk, and an unreachable
+remote reads as *could not verify*, never as *current* or as every slice unclaimed. The implement brief and
+the safety page name the sanctioned move — change the production file, run the test, restore that one path —
+and ask whether each RED was observed before the implementation existed. A brief may name where a fact lives
+without asserting what it says, the host derives concurrency from disjoint manifests rather than waiting for a
+`[P]` the task list only applies to production-code contention, and `./init` says to restart the session
+before delegating, since a harness reads its agent types once.