riskrails 3.0.0 → 3.0.1

package/skills/project-update/history/index.json

@@ -9,7 +9,8 @@
   "31bb922076c8dadb4a84bb6a03d331dafc7157893aaf2f92b13792270fbece9b",
   "a13cb0db5372c3ce3e71470165c17a2db76e7a2415717ba27fccd1b0593c61c4",
   "54eefe3d8cd6cd1ed56764e7bd412a4c919a28fc64b56b69dcafeecd7a921678",
-  "fe513647c66e8883b326ea884a7e9cb045ce54c49b03d2e75a0b73c4756c423e"
+  "fe513647c66e8883b326ea884a7e9cb045ce54c49b03d2e75a0b73c4756c423e",
+  "8b3ef9586491a426767c01da5d01bdd6b0655c576c68c4cc6dfb093367817dc0"
  ],
  "ai-init/.ai/VERSION": [
   "4355a46b19d348dc2f57c046f8ef63d4538ebb936000f3c9ee954a27460dd865",
@@ -19,7 +20,8 @@
   "f0b5c2c2211c8d67ed15e75e656c7862d086e9245420892a7de62cd9ec582a06",
   "06e9d52c1720fca412803e3b07c4b228ff113e303f4c7ab94665319d832bbfb7",
   "10159baf262b43a92d95db59dae1f72c645127301661e0a3ce4e38b295a97c58",
-  "aa67a169b0bba217aa0aa88a65346920c84c42447c36ba5f7ea65f422c1fe5d8"
+  "aa67a169b0bba217aa0aa88a65346920c84c42447c36ba5f7ea65f422c1fe5d8",
+  "917df3320d778ddbaa5c5c7742bc4046bf803c36ed2b050f30844ed206783469"
  ],
  "ai-init/.ai/agents/context.md": [
   "a213099429aff491b00e885c8d556465be2405072efbb9a3a297890a15a5b4ca",
@@ -87,6 +89,9 @@
  "ai-init/.ai/policies/database.md": [
   "894a37936b769203bbb880ff842cc0a04e62d53e01deb07af83179f6b1359cf4"
  ],
+ "ai-init/.ai/policies/dialog.json": [
+  "164cd34c182de88c33de7df35beb29200d792419e1c13a5f0b2104f944e57be7"
+ ],
  "ai-init/.ai/policies/git.md": [
   "6bbcb8ea55726cdd49e0544725d224ac6d728cd1db757a269399342da92677ca"
  ],
@@ -119,7 +124,8 @@
   "9984ac1e1b1edb7217df58e256002ae09913fdc598da6f7773f1c01e5a3e55e2",
   "c392fd585241389355958099a95bd85358a80d9a10310301a430219f83c8962e",
   "edecd502e22395300781a3c653b56c3587b1b894ce4b96f60e19c601a5cdae46",
-  "91e924527f51c8c36fa1156a8f30af4c07adab2d324b8c5a879145a1641c413a"
+  "91e924527f51c8c36fa1156a8f30af4c07adab2d324b8c5a879145a1641c413a",
+  "6a3f34706c31fc91fdace8ea8729bd7a74065f983032204f5aad3ec80cf13ce0"
  ],
  "ai-init/.ai/policies/risk-tiers.json": [
   "01c32f8ff038787e49070b8b0eb160eb4b4704a020b050678292051fc73a4fc6",
@@ -154,7 +160,10 @@
  ],
  "ai-init/.ai/policies/safety.md": [
   "0f00cbb216a20c7f67749ffb88835bcaaa29cc1a4c15d468edb3c6039bd291d3",
-  "ae9a22907ba9acbb7e80fac1ba4e3d1ff09e5f1df5c4456afb9099d7090fcaa6"
+  "ae9a22907ba9acbb7e80fac1ba4e3d1ff09e5f1df5c4456afb9099d7090fcaa6",
+  "fae3064e648cdc55be4aeb1177525b302a5e34ebd752e4a904f47dc0f4557b96",
+  "e9adb7a9905eb719ac78ab96671f055da53e5001810f5ad6d6c94306b0323fe7",
+  "ae5ce131d6bae401199ff32d8c3dc4d8aec188010a9111624ac64506e2116ff4"
  ],
  "ai-init/.ai/policies/security.md": [
   "cc808d5b940109f1703abfb3ca0334a3fcfd34267feefb2323627d0decc8b89a",
@@ -175,10 +184,12 @@
   "2c6afb3518714d35eaf0119bf2ae2154782bbece632dfdbd68988351abde61f5"
  ],
  "ai-init/.ai/policies/weight.json": [
-  "7f3859c34035fe32abf937eebdd7240ac72ab32d254286cff7d939cf0cf6eaef"
+  "7f3859c34035fe32abf937eebdd7240ac72ab32d254286cff7d939cf0cf6eaef",
+  "5353ca529c46f2443e12947ec205a6887fb594a4de1f87f0eb1c0e6c0f826133"
  ],
  "ai-init/.ai/policies/weight.md": [
-  "e639e99d3f59015dc21472de081ca7766231135399ac3a6f439e841e458251f4"
+  "e639e99d3f59015dc21472de081ca7766231135399ac3a6f439e841e458251f4",
+  "5f65bc7ab3fc3c4e75ae05d49eaf4331fafc398c661abe33c69f7380a720344c"
  ],
  "ai-init/.ai/project/architecture.md": [
   "5cbaaabe2c8d0e24582877aab05eeaaf4d53cb5e9515e81cd18368d13d2fe79e"
@@ -222,7 +233,9 @@
   "962fd396da83337c3fadcc642d45e98429b18e79bb81f58915baaf2b9bffd3c5",
   "d7b96902bf9d2078df1e09901327b02f565b174777af34a2b24be660cad81d01",
   "ad4c4f81855725f7fe6e0e3d8f557df0de5fc063465d428546f69c54020c69d9",
-  "19b1a6390e96136619d23bc2ef9afed8f15e62107de7c1052bc5ea23e5bb5692"
+  "19b1a6390e96136619d23bc2ef9afed8f15e62107de7c1052bc5ea23e5bb5692",
+  "23a42febbacaa7b52a802d428033a99c0694391c81d51fe3b6e1dff608a641d5",
+  "7ee99edafe7cec45ff577376c0d0178fdb2690134d4656488f46e129aba3cc5a"
  ],
  "ai-init/.ai/templates/architecture-decision.md": [
   "78619b522826ba8f5f0422e9deb7359c8002553d1aeb29a3719da5ab11ff13a1"
@@ -246,7 +259,8 @@
   "515df0eab178b5f53b50f95bec2671e861efef35b487a6e65d80e80de42c4d0d"
  ],
  "ai-init/.ai/using-riskrails.md": [
-  "03282999978b2bfb5f65135e1884f9447f8a71021a88895d5436d377797b9acb"
+  "03282999978b2bfb5f65135e1884f9447f8a71021a88895d5436d377797b9acb",
+  "25d08ff01a4ab2069b0dd4e5ec52e888d33e00091dc467dd10d63f10223b6f80"
  ],
  "ai-init/.ai/workflows.md": [
   "500d93714106b1c4e21b13f248f7175c86073a9bcb6e0a849845f61f49b5a66d"
@@ -310,7 +324,8 @@
   "815d78ce95d18454cf0842335f81755bf3aceb87ee9d2197e121d3ff734cd2b5",
   "de0685f9bc2ac22c1b0178d6a1fc8d07fa23451f29d0c36571cbf85c69716fc2",
   "c735911eb1a744f78213a9f7577b425c1605843f6d05fed798d7f41b47fa1e0c",
-  "7eee4ea9f6e778ff691c263621e717c021505b86386034cc64f8ebbfc9d8fe65"
+  "7eee4ea9f6e778ff691c263621e717c021505b86386034cc64f8ebbfc9d8fe65",
+  "ca4499d829268c8766fb3b825a515e88dc55c237e9d202816b50959b4dac031f"
  ],
  "ai-init/AGENTS.minimal.md": [
   "b7b697fc987617449ba10634f12f70326281cc182f8b7f20f9e047a75f3f182b",
@@ -324,7 +339,8 @@
   "3775eed295a794dda73b14f88af70bc2c99b5590f81da53f165423e4337dceed",
   "ee7c8321fff228d967c5d200c316967195d93a26196383f57f474e837b1b3d33",
   "da848b831443484c831fa630666c004e07c1c9669dd247e8e4066979c8599080",
-  "c076d603cffc731823d2acf096bcc17cca1d99eee24b0aa313776d7d01571b4f"
+  "c076d603cffc731823d2acf096bcc17cca1d99eee24b0aa313776d7d01571b4f",
+  "1d1d907449ec74594d0ee923ac142ae746b9aedf0a1eda9469f075a44d23e3d7"
  ],
  "ai-init/CLAUDE.minimal.md": [
   "7578025c0ce0a64dd37fe4c999541db5681199763df8b373ed0bfba11e2f581e",
@@ -335,7 +351,8 @@
   "e8df28f07cb784d768bcafbced70fd15771afa61dbec7dc4c1c3f858f9002fec",
   "c9ddacab2a6943af94c927799ba314877c1f19d40949e927c2d3825689005288",
   "4d1f9073276936834747199393159f1badc0277b5bb394f78f408d52c36c4e35",
-  "65acd4be95c695d0cc20cb5f4faffe0f44e0873b385c124140b223c41328cb56"
+  "65acd4be95c695d0cc20cb5f4faffe0f44e0873b385c124140b223c41328cb56",
+  "935af1019931058ec3a0b834fe230e127ec914f75edcc4a6c589cfe733b0b979"
  ],
  "ai-init/GEMINI.minimal.md": [
   "933629cd5c872a11837046b13051a9b02bbc1033e3ba74f41966af2ed4edee5d"
@@ -348,7 +365,8 @@
   "e8df28f07cb784d768bcafbced70fd15771afa61dbec7dc4c1c3f858f9002fec",
   "c9ddacab2a6943af94c927799ba314877c1f19d40949e927c2d3825689005288",
   "4d1f9073276936834747199393159f1badc0277b5bb394f78f408d52c36c4e35",
-  "65acd4be95c695d0cc20cb5f4faffe0f44e0873b385c124140b223c41328cb56"
+  "65acd4be95c695d0cc20cb5f4faffe0f44e0873b385c124140b223c41328cb56",
+  "935af1019931058ec3a0b834fe230e127ec914f75edcc4a6c589cfe733b0b979"
  ],
  "ai-init/junie-guidelines.minimal.md": [
   "5551499579a0bceb74a79731d30213b1ddf9168b92f6d3dd0aecad91d8aff464"
@@ -371,7 +389,8 @@
   "a349aaad234825ea429df33cafb7928579c0cb5b1801f0a237e103aa8d159642"
  ],
  "project-init/constitution.md": [
-  "5e38d93c4f82300cc5d331f4ce3022d2872db15d108ae23bf33e2169a19b42f2"
+  "5e38d93c4f82300cc5d331f4ce3022d2872db15d108ae23bf33e2169a19b42f2",
+  "7be527cd648b27cca6e267de30f8e33a2ce17d5631a82694f23ae5c0623efe1f"
  ],
  "project-init/gitignore.snippet": [
   "965a03be82000866cb5275acda18ebb2172c9a50f0011df2fa475f74a1124c35",

package/skills/project-update/migrations/0009_state_file.py

@@ -0,0 +1,25 @@
+"""0009: the task's state file is `.ai/state/state.json`.
+
+R34's contract half. 0008 shipped the expand half: the guards and state.py of
+3.4b read `.ai/state/state.json` first and `current.json` otherwise, and write
+the file where it is. This migration, run once such a version is installed,
+moves a task in flight from `current.json` to `state.json`, and `state.py start`
+opens every new task in `state.json`.
+
+  * The move goes through MOVES like any other: no task in flight means no
+    file, and nothing happens; a project that already holds `state.json` keeps
+    it (a `current.json` beside it is a conflict for a human, not overwritten).
+  * The file's bytes are not touched: every field of the task survives.
+  * Reverting to 3.4b after the move still guards the task, because that
+    version reads `state.json`.
+"""
+
+VERSION = 9
+TITLE = "the task's state file is state.json"
+STATE_LEGACY = ".ai/state/current.json"
+STATE_NEW = ".ai/state/state.json"
+MOVES = [(STATE_LEGACY, STATE_NEW)]
+
+
+def plan(ctx):
+    ctx.move(STATE_LEGACY, STATE_NEW)

package/skills/project-update/migrations/0010_dialog_switch.py

@@ -0,0 +1,30 @@
+"""0010: the command-choice dialog is on (R36.1).
+
+`.ai/policies/dialog.json` is the project's switch for the dialog: the human
+picks a commit, push or approval command in the runtime's dialog and the agent
+runs that command, verbatim and once. This migration writes the switch, on, as
+the scaffold does for a new project.
+
+  * A project that already has the file keeps it, whatever it says: `create`
+    does not overwrite, and a human's `"enabled": false` stays off.
+  * A second run finds the file and does nothing, and prints nothing.
+  * The task's state is not touched: a task in flight survives.
+"""
+
+VERSION = 10
+TITLE = "the command-choice dialog switch"
+SWITCH = ".ai/policies/dialog.json"
+MOVES = []
+
+
+def plan(ctx):
+    if ctx.exists(SWITCH):
+        return
+    ctx.create(SWITCH, ctx.template(SWITCH))
+    ctx.hint("%s is new and the command-choice dialog is on; set \"enabled\": false in it to turn the dialog off"
+             % SWITCH)
+    ctx.hint("docs/sdlc/constitution.md C5 still says no agent commits, merges or deploys: if you keep the dialog "
+             "on, amend C5 to the new sentence (skills/project-init/templates/constitution.md, C5)")
+    if ctx.state is not None:
+        ctx.hint("a task is in flight: the dialog switch takes effect for it too; set \"enabled\": false in %s "
+                 "to turn it off" % SWITCH)

package/skills/project-update/migrations/README.md

@@ -16,7 +16,8 @@ this directory, named `NNNN_slug.py`, numbered contiguously from `0001`, with
 - A migration that deletes must retire the template in the same release,
   otherwise the next run re-creates the file.
 - `ctx.patch_state` is the only way to change a task in flight, and the only
-  writer of `.ai/state/current.json` other than `state.py`. A migration that
+  writer of the task's state file (`.ai/state/state.json`, `current.json` in a
+  project not yet at schema 9) other than `state.py`. A migration that
   moves a path a task's step may touch must patch it, or the scope guard will
   stop that task on a file that no longer exists.
 - Operations are planned, never written: the dry run must list everything.

package/skills/project-update/update.py

@@ -81,12 +81,18 @@ ROUTER_FILE = ".ai/AGENTS.md"
 SHARED_SECTION_RE = re.compile(rb"(?m)^## Shared files[ \t]*\r?$")
 SHARED_SCHEMA = 6  # the schema from which shared copies are overrides (0006)
 STATE_FILE = ".ai/state/state.json"
-LEGACY_STATE_FILE = ".ai/state/current.json"  # R34: the name until migration 0008 moves it
+LEGACY_STATE_FILE = ".ai/state/current.json"  # R34: the name until migration 0009 moves it
+
+
+# Templates a migration creates exactly once, on the step to the given schema.
+# From that schema on, a missing file is the human's choice (dialog.json missing
+# means the dialog is off), so the template walk must not re-create it.
+CREATE_ONCE = {".ai/policies/dialog.json": 10}
 
 
 def state_file(plan):
     """The task state's path as this run leaves the project: state.json once it
-    exists there (migration 0008 moved it, or the task started under it), else
+    exists there (migration 0009 moved it, or the task started under it), else
     the legacy current.json."""
     if not plan.exists(STATE_FILE) and plan.exists(LEGACY_STATE_FILE):
         return LEGACY_STATE_FILE
@@ -1263,6 +1269,8 @@ def build_plan(root, confirm_delete=None, confirm_via=None):
                 continue
             if rel in plan.removed:  # a migration moved it away in this run
                 continue
+            if rel in CREATE_ONCE and version >= CREATE_ONCE[rel] and not plan.exists(rel):
+                continue  # past the step that created it: its absence is the human's choice
             content = read(os.path.join(tpl, rel))
             if rel.startswith(".ai/project/") or rel.startswith(".ai/reports/"):
                 if not plan.exists(rel):
@@ -1433,7 +1441,8 @@ def apply_item(plan, item, written, recorded):
         if action == "move":
             check(plan, item, target, item["expect"], written)
             mode = os.stat(os.path.join(plan.root, source)).st_mode & 0o7777
-        keep_original(plan, source)
+        if not source.startswith(".ai/state/"):  # git-ignored task state: a move is byte-identical
+            keep_original(plan, source)
         recorded.append(target)
         # Recorded before the file is gone: an abort later must not lose the note
         # of what was taken away, or of who approved a deletion.

package/skills/rr-build/SKILL.md

@@ -38,6 +38,8 @@ $STATE handoff --print
   Trust it over a compaction summary; it is rendered from the state. If
   `$ARGUMENTS` asks for something else, say what is in flight and ask whether to
   finish it, or drop it with `$STATE close --abandon`. Never discard it silently.
+  A handoff line `Batch: on` means the task runs the loop of `/rr-build-all` —
+  parallel implementers and fixers, its own budgets — continue there.
 - **`Handed to <the other runtime>`:** every state change exits 7 until that
   runtime resumes it. Say where to resume; take it back with
   `$STATE handoff --to <this runtime>` only when asked. `Handed to <this
@@ -47,6 +49,11 @@ $STATE handoff --print
 
 ## 2. Edit, inside the task
 
+Before the first edit, recall what the record already holds about the task's
+files — open risks, residual findings, decisions and why, within a token budget,
+read-only: `$STATE recall --files "<the task's files>"` (`memory show <id>` for
+one task in full).
+
 Implement it yourself. The scope guard refuses an edit to a file the task does
 not name. That refusal is the plan being enforced, not an obstacle:
 
@@ -56,8 +63,9 @@ $STATE start --amend --files "+<path>" --why "<why the task needs it>"
 ```
 
 The amendment is journaled; the task is not re-planned. A file that belongs to
-a different change is not amended in — it is written into
-`.ai/project/known-risks.md` and left for its own task.
+a different change is not amended in — it is recorded with `$STATE memory risk
+add --title … --where "file:line" --label RISK --what …` (in files mode that
+writes `.ai/project/known-risks.md`) and left for its own task.
 
 Production behaviour is the source of truth: code that looks wrong may be
 load-bearing. Change only what the task asked for; a refactoring never rides
@@ -94,7 +102,7 @@ at `close` is finished by `close`.
 
 ## 4. Verify once, to the end
 
-After the last edit:
+After the last edit (after the last step: `$STATE step-done <id> && $STATE verify --scope all`):
 
 ```bash
 $STATE verify --scope all
@@ -118,10 +126,11 @@ fixed:
 $STATE verify --scope all --after-fix "<n> regressions: <one line each>"
 ```
 
-- An existing failure is recorded in `.ai/project/known-risks.md`, not fixed.
+- An existing failure is recorded with `$STATE memory risk add`, not fixed.
 - An environment failure gets one more run, not a code change.
 - Never edit a test to make it pass.
-- Two whole-suite runs are the budget (`tests.max_suite_runs`). The third
+- Two whole-suite runs are the budget (`tests.max_suite_runs`; in a batch task
+  `batch.max_suite_runs`). The third
   exits 6 `SUITE_BUDGET`: running it again is the human's decision, from their
   own terminal, with the command it prints — or the pick: with the dialog on it
   also prints `DIALOG_PENDING`, and you run the command the human picks,

package/skills/rr-build-all/SKILL.md

@@ -0,0 +1,190 @@
+---
+name: rr-build-all
+description: Run a whole programme plan as one task in a repository that has .ai/ — every row of docs/sdlc/plans/<slug>.md becomes a step with its files, tests and dependencies; the ready steps go to parallel implementer subagents on the BALANCED tier, serialized where one depends on another; after the last step the suite runs once to the end, every failure is recorded and fixed by parallel fixers as one batch, then one review at the mode's tier, its findings fixed by parallel fixers as one batch, then tests and the review again until it passes; the pass past the batch budget (three failed reviews) is the human's. Use on "/rr-build-all", "run the whole plan", "all points in one task", "sdlc-lite", "batch build".
+argument-hint: [<path to docs/sdlc/plans/<slug>.md>] | --resume
+---
+
+# /rr-build-all $ARGUMENTS
+
+One task for the whole plan — the loop a developer otherwise runs by hand: implement every
+row, test once, fix everything, review, fix everything, again, until the review passes. The
+mode (light, guarded, full) is still the weight's; batch only changes who implements, how
+failures are fixed, and how many rounds run before the human. Resolve the install root once:
+
+```bash
+for AI_HOME in "${CLAUDE_CONFIG_DIR:-$HOME/.claude}" "${CODEX_HOME:-$HOME/.codex}"; do
+  [ -d "$AI_HOME/skills/rr-build-all" ] && break
+done
+STATE="python3 $AI_HOME/skills/ai-task/state.py"
+```
+
+Shared files resolve through `"$AI_HOME/riskrails/ai-path" <path>`. Read `policies/safety.md`
+and `using-riskrails.md` once per session. Every rule of `/rr-build` holds here: nothing outside
+the task's files, no commit, a refusal names the way out and is never reworded around.
+
+## 1. Resume or start
+
+```bash
+$STATE handoff --print
+```
+
+- **A task in flight whose handoff says `Batch: on`:** continue at its stage — §3 while
+  `steps --ready` prints a step, §4 after the last `step-done`, §5 after a green verify.
+- **A task in flight without that line:** it runs the standard way — say so and hand over to
+  `/rr-build`. Only the human turns the loop on mid-task (`batch on`, §Switching).
+- **No task in flight:** §2.
+
+## 2. The plan → one task
+
+`$ARGUMENTS` is a programme plan (default: the newest `docs/sdlc/plans/*.md`). Its spec's
+**Flagged concerns** are resolved or accepted, as `/rr-plan` demands; a plan with an open
+blocking question is not started.
+
+1. **Rows → steps.** Every row of **Order of work** that an agent does becomes one step
+   `{"id", "files", "tests", "after"}`: the row's files, the tests it names, and in `after` the
+   rows it depends on — its *Consumes* line, a stated dependency, or an earlier row it builds
+   on. A refactoring row stays its own task (C3): leave it out and say so. A human row (G1, …)
+   is not a step: every row after it names in `after` every step before it, so nothing past
+   the human row is ready until the rows before it are done — and its question (3.) answered.
+2. **Weigh and start** — `/rr-plan`'s "A task" section, on the union of the steps' files, then:
+
+   ```bash
+   $STATE start --goal "<the plan's title>" --workflow feature --files "<every file of every step>" \
+     --tests "<every test>" [--declare …] --plan-file /path/steps.json \
+     --batch --by "<the human's name>" --why "/rr-build-all docs/sdlc/plans/<slug>.md" \
+     [--mode <higher> --by "<name>"]
+   ```
+
+   An `after` id must exist and form no cycle; two steps that name one file are ordered by
+   `start` itself (`ordered: s4 after s1 (shares …)`), so two implementers never hold one file.
+   In full mode the written plan is the programme plan the human already accepted. With
+   `batch.default` true in `.ai/policies/weight.json` the flag is implied; `--no-batch` opts out.
+3. **A human row** becomes a question the moment every step before it is done — asked
+   **before** the next wave is dispatched:
+   `$STATE ask "G1 is yours: <what>" --option "A: done" --option "B: not yet" --recommend A`,
+   then **stop**. Never dispatch while a question is pending (`step-done` and `close` exit 4;
+   `steps --ready` still answers); `/rr-build-all --resume` goes on once the human answered.
+
+## 3. Implement, by waves
+
+```bash
+$STATE steps --ready               # the next wave: the steps whose dependencies are done, one id per line
+$STATE steps --json                # batch_policy.tier and .parallel: the implementers' tier, how many at once
+$STATE profile --tier <that tier>  # the tier's model in this runtime (BALANCED as shipped)
+```
+
+**Resuming mid-wave** (after a compaction or a stop): before dispatching, compare
+`git status --short` with each ready step's files. A ready step whose files already changed
+was dispatched before and never recorded — do not send it again blind: brief its implementer
+with that partial diff to finish, or `step-done` it if its tests pass.
+
+Dispatch one subagent per ready step, at most `batch.parallel` (shipped 3) at once — under
+Claude Code a `general-purpose` agent with `model:` set to that tier's model; under Codex a
+spawn with no agent named, on that model. Its brief is the implementer contract,
+`agents/implementer.md` in the shared tree, filled in:
+
+- **Goal** — the row's text from the plan. **Allowed files** — the step's files, nothing else.
+  **Forbidden files** — every other step's files, "another implementer holds them".
+  **Required behaviour / behaviour that must not change** — from the row and the spec.
+  **Required tests** — the step's tests.
+- Its own tests, run directly: `step_test_command` from `.ai/policies/testing.md` with the
+  step's tests in place of `{files}`. **A subagent never calls `state.py`** — one state file,
+  one writer, this session.
+- It returns `## RESULT`, or `## SCOPE_CHANGE_REQUIRED`, or `## QUESTIONS_NEEDED`.
+
+After the wave, in this session:
+
+- `RESULT` → `$STATE step-done <id>` for each step. Exit 6 names a file outside the task:
+  `$STATE start --amend --files "+<path>" --why "…"`, then `step-done` again.
+- `SCOPE_CHANGE_REQUIRED` → amend as above and send the same step again. A file that belongs
+  to another change goes into `.ai/project/known-risks.md`, not into the task.
+- `QUESTIONS_NEEDED` → `$STATE ask --batch /path/questions.json`, show the questions, **stop**;
+  the human answers, and `/rr-build-all --resume` goes on from the handoff.
+
+Then `steps --ready` again. Nothing ready and nothing pending: §4. Keep this session small:
+read `## RESULT` blocks, never a subagent's diff; `git status --short` is the only view of the
+tree you need between waves.
+
+## 4. Tests once, failures fixed as one parallel batch
+
+After the last wave, `$STATE step-done <id> && $STATE verify --scope all`:
+
+```bash
+$STATE verify --scope all
+$STATE verify --scope all --e2e not-applicable "<why the change reaches no e2e flow>"
+```
+
+Green: §5. **Red:** a FAST `log-reader` reads the log by path and returns every failure
+classified — new regression, existing failure, environment, unknown (`testing.md`, "Reading a
+failure") — each with `file:line`. Then:
+
+- an existing failure → one entry in `.ai/project/known-risks.md`; an environment failure →
+  one more run, no code change;
+- the new regressions, grouped by the file they point at → one fixer subagent per group, in
+  parallel, at most `batch.parallel`, on the batch tier, briefed with the failures' excerpts
+  and the files it may touch (that group's files, inside the task's). Fix the code, never the
+  test; report `files_changed` and what stayed unfixed;
+- one run: `$STATE verify --scope all --after-fix "<n> regressions: <one line each>"`.
+
+Red again → the same once more. Exit 6 `SUITE_BUDGET` — past `batch.max_suite_runs`
+(shipped 8) — is the human's run: the pick in the dialog, or the command it prints, in their
+own terminal. **Stop.**
+
+## 5. Review, findings fixed as one parallel batch, again until it passes
+
+One `ai-reviewer` at the mode's tier, briefed as `/rr-review` §2 says: the whole diff since the
+task's base, the task's files, the tests, the last verify log; unbounded "look for" in full
+mode, the security focus when the domain axis is 2. Record it verbatim:
+
+```bash
+$STATE review --verdict <pass|pass_with_findings|blockers_open> --tier <BALANCED|STRONG> \
+  [--focus security] --report - <<'EOF'
+<the reviewer's FINDINGS and VERDICT, unchanged>
+EOF
+```
+
+- **pass** → §6.
+- **pass_with_findings** → the in-scope HIGHs, grouped by file, one fixer per group in
+  parallel; `$STATE verify --scope all --after-fix "H1,H2: …"`; `$STATE review --closes "H1,H2"`
+  → §6. Each MEDIUM and LOW is one `$STATE memory risk add`, not a fix; only a BLOCKER, a HIGH
+  or a regression buys an `--after-fix` run.
+- **blockers_open** → every in-scope BLOCKER and HIGH, grouped by file, one fixer per group in
+  parallel; `$STATE verify --scope all --after-fix "B1,H1: …"` (red: §4's batch); then
+  **§5 again, a full pass** — a fix batch across many files is a new change, not a scoped one.
+
+Exit 6 `REVIEW_BUDGET` after `batch.review_rounds_max` passes (shipped 3 — three failed
+reviews) — the next verdict is the human's: the pick in the dialog, or the command it prints,
+in their own terminal. Show the open findings and **stop**. A `verify` past its budget inside
+this loop is `SUITE_BUDGET`, handled the same way.
+
+## 6. Ship
+
+`/rr-ship` — `close` measures the two facts and, in full mode, asks the human to approve,
+exactly as for any task; for a documents-only change since the green suite it is
+`$STATE verify --scope step --files "<doc_tests>" && $STATE verify --scope e2e && $STATE close`. Suggest `/clear` after it.
+
+## Switching
+
+- **To the standard loop ("full" from here):** `$STATE batch off --by "<name>" --why "<why>"`.
+  The standard budgets apply from now, counting what was spent — with two passes behind you,
+  the next verdict is already the human's. The session implements the remaining steps itself;
+  continue with `/rr-build`, `/rr-review`, `/rr-ship`. Anyone may do this: it raises the rigor.
+- **To batch, mid-task:** lowers the rigor — the human's, in their own terminal:
+  `python3 <AI_HOME>/skills/ai-task/state.py --root <project> batch on --by "<name>"`. Never
+  from a tool call; the refusal (`APPROVAL_REFUSED`) prints that command.
+- **The project's default:** `batch.default` in `.ai/policies/weight.json`, beside
+  `batch.review_rounds_max`, `batch.max_suite_runs`, `batch.parallel` and `batch.tier`
+  (`/rr-setup --update` adds the section). A policy is the human's and is frozen during a task.
+
+## Rules
+
+- The mode is the weight's and only rises; the scope guard, the two facts, the gate and the
+  three nevers are untouched by batch.
+- Three or more parallel agents run at BALANCED, never above — `start` refuses `batch.tier`
+  above it when `batch.parallel` is three or more; one reviewer per pass, at the mode's tier;
+  the session writes every conclusion (`model-routing.md`).
+- One writer of the state: a subagent never calls `state.py`; this session records every step,
+  run and verdict.
+- Failures and findings are fixed as batches, never one at a time; a test is never edited to
+  make it pass; what is outside the task is written down, not fixed.
+- No commit, push, merge or deploy. The task ends at `/rr-ship`; approval is the human's.

package/skills/rr-plan/SKILL.md

@@ -38,7 +38,11 @@ When `$ARGUMENTS` is a spec (default: the newest `docs/sdlc/specs/*.md`):
 4. Copy the template to `docs/sdlc/plans/<slug>.md`, fill **Files that change /
    Order of work / Risks / Proof / Rollback**; Proof maps every requirement R<n>
    to a test or command. One round of corrections; suggest the commit
-   `plan: <title>`. Each row of the plan is later one task, planned below.
+   `plan: <title>`. Each row of the plan is later one task, planned below —
+   unless the whole plan runs as one task through `/rr-build-all` (the project's
+   `batch.default` in `weight.json`, or the developer's call): then every row
+   becomes one step of that task, so give each row its files and its *Consumes*
+   line (the rows it depends on) — that is what `/rr-build-all` reads.
 
 ## A task → weight, mode, plan, start
 
@@ -48,7 +52,10 @@ investigation — say which and why. `using-riskrails.md` in the shared tree
 `workflows.md#<kind>` say what each kind requires. A refactoring and a feature
 are never one task.
 
-**2. Name the files** from the request, confirmed with `grep -n`. Then weigh:
+**2. Name the files** from the request, confirmed with `grep -n`. Recall what
+the record holds about them — `$STATE recall --files "<a>,<b>"`: open risks,
+residual findings and earlier decisions are evidence for the weight and the
+plan. Then weigh:
 
 ```bash
 $STATE weight --files "<a>,<b>" --goal "<one sentence>" \
@@ -64,7 +71,7 @@ The table is `.ai/policies/weight.json` (`weight.md` mirrors it).
 
 **3. The mode is the weight's**, not yours: raising it is free
 (`--mode <m> --by "<name>"` on `start`); lowering it is the human's, from their
-own terminal. Shape the plan by it:
+own terminal, or the command they picked in the dialog. Shape the plan by it:
 
 | Mode | Plan | Who sees it before the first edit |
 |---|---|---|
@@ -92,6 +99,9 @@ $STATE start --goal "<one sentence>" --workflow <kind> --files "<a>,<b>" \
 
 `--plan-file` is a JSON list `[{"id": "s1", "files": [...], "tests": [...]}]`
 for a guarded or full plan with steps; a light task is one scope and needs none.
+A step may add `"after": ["s0"]`, the steps it waits for — `/rr-build-all` runs
+the rest in parallel — and `--batch --by "<name>"` (or `--no-batch`) sets that
+loop for the task; the default is `batch.default` in `weight.json`.
 `--files` lists every file of every step — the guard refuses an edit outside
 them. `--tests` names the task's own tests; a bugfix names its failing test. At
 guarded and full, run `start` only after the human accepted the plan.

package/skills/rr-review/SKILL.md

@@ -30,7 +30,10 @@ STATE="python3 $AI_HOME/skills/ai-task/state.py"
 (`review_rounds_max`): one full review and one scoped re-review. The pass past
 it exits 6 `REVIEW_BUDGET` — the next verdict is the human's, from their own
 terminal, with the command it prints, or the pick in the dialog (`DIALOG_PENDING`,
-then the picked command verbatim, once). Never a third pass.
+then the picked command verbatim, once). Never a third pass. A batch task
+(`/rr-build-all`) has its own budget, `batch.review_rounds_max` full passes
+(shipped three): after a `blockers_open` fix batch the next pass is a full one,
+and the pass past the budget is the human's the same way.
 
 ## 2. Brief one `ai-reviewer`
 
@@ -49,10 +52,11 @@ the tier, so name the tier in the brief. Give it paths, not pasted text:
 **Bounded inputs in light and guarded:** the goal, the diff, the named tests,
 and the project's own threat model (`.ai/policies/safety.md`, the guards'
 defaults, the test fixtures). A finding that needs anything outside them comes
-back `[INFO]` with `in_scope: no`; write it into `.ai/project/known-risks.md`
+back `[INFO]` with `in_scope: no`; record it with `$STATE memory risk add`
 as one entry — it never opens a fix. You may move a finding to
 `in_scope: yes`, never the other way. **In full mode** the reviewer's own "look
-for" list applies unbounded.
+for" list applies unbounded. Tell it the cap: about 40 tool calls in light and
+guarded, about 80 in full, then FINDINGS and VERDICT.
 
 Before you delegate, probe the change yourself for a minute: the few inputs its
 own threat model makes interesting, through the real code, and hand the
@@ -77,12 +81,16 @@ task's record (`task.md`), so there is no separate report to write.
 
 ## 4. After the verdict
 
-- **pass:** `/rr-ship`.
-- **pass_with_findings:** fix every in-scope HIGH (and the MEDIUMs worth it) in
-  one batch, then
+- **pass:** `/rr-ship`; the record and the close are one call,
+  `$STATE review --verdict pass … <<'EOF' && $STATE close`. `review` exits 0 for every
+  verdict, so the chain is for `pass` only.
+- **pass_with_findings:** fix every in-scope HIGH in one batch, then
   `$STATE verify --scope all --after-fix "H1,H2: <one line>"` and
   `$STATE review --closes "H1,H2"`. The findings close on that green run, on a
-  tree the fix changed — no second review.
+  tree the fix changed — no second review. Each MEDIUM and LOW is one
+  `$STATE memory risk add` (`.ai/project/known-risks.md` amended into the task
+  if missing), not a fix; only a BLOCKER, a HIGH or a regression buys an
+  `--after-fix` run.
 - **blockers_open:** fix every BLOCKER and HIGH together, `verify --scope all
   --after-fix "…"`, then **one scoped re-review** (`/rr-review B1,H1`): brief a fresh `ai-reviewer`
   with the named findings and the fix's diff only — do they close, and what did
@@ -94,6 +102,8 @@ The `verify` after a fix is often the task's third whole-suite run: past
 from their own terminal, with the command it prints, or the pick in the dialog.
 
 A finding whose cause is the plan goes back to `/rr-plan` for that part only. A
-real problem outside the task goes into `.ai/project/known-risks.md`. A mistake
+real problem outside the task is recorded with `$STATE memory risk add`; a
+fix in this task closes its risk with `$STATE memory risk close <rkey> --status
+fixed --why "…"`. A mistake
 this repository has seen before — the second time a review flags it — gets one
 line in the project instruction file, in this task.

package/skills/rr-ship/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: rr-ship
-description: Close the task — state.py close measures the two facts (a green whole-suite verify on the tree as it is now; every changed file inside the task's files), applies the mode table and either archives the task or, in full mode, requests the human's approval and prints the exact approve command for their own terminal. Writes the commit message body and suggests the commit; never commits, pushes or approves. Use on "/rr-ship", "close the task", "ship it", "ready for approval", after /rr-build or /rr-review.
+description: Close the task — state.py close measures the two facts (a green whole-suite verify on the tree as it is now; every changed file inside the task's files), applies the mode table and either archives the task or, in full mode, requests the human's approval and prints the exact approve command for their own terminal. Writes the commit message body and suggests the commit; never merges or deploys, and commits, pushes or approves only as the command the human picked in the dialog, verbatim, once. Use on "/rr-ship", "close the task", "ship it", "ready for approval", after /rr-build or /rr-review.
 argument-hint: [--abandon]
 ---
 
@@ -33,7 +33,8 @@ Then the mode table decides:
 |---|---|---|
 | 0, `closed` | archived: `task.md` holds the changes and the verdict | §3 |
 | 0, `ready for approval` | full mode: the gate is requested | §2 |
-| 2 `review required` | light with a red fact, or guarded/full without its review | `/rr-review` |
+| 2 `review required` whose text holds `only documents changed since run …` (read this row first) | a green suite, then documents only | `$STATE verify --scope step --files "<doc_tests>" && $STATE verify --scope e2e && $STATE close` — `close` prints the files comma-joined; use its text |
+| 2 `review required`, any other reason | light with a red fact, or guarded/full without its review | `/rr-review` |
 | 2 `verify required` | e2e owed, or not on this tree | `$STATE verify --scope all` (or `--scope e2e`, or `--e2e not-applicable "<why>"`) |
 | 4 | a question is pending | show it; §4 |
 | 5 `APPROVAL_REFUSED` | rejected, and nothing changed since | address the rejection, `verify --scope all`, close again |
@@ -54,9 +55,13 @@ Show the human the summary (§3), the open findings, the rollback, and that
 command **verbatim** — paths absolute and quoted, because they paste it into
 their own shell, where `$AI_HOME` is not set. Then **stop**.
 
-- **You cannot approve.** `approve` refuses without a terminal on stdin or
-  `AI_UNATTENDED` in its own environment — neither of which a tool call from this
-  session has — and the path guard denies it. Never try another route.
+- **You approve only through the dialog.** With `.ai/policies/dialog.json`
+  `enabled: true`, `close` offers the `approve` command in the runtime's dialog;
+  once the human picks it, run exactly that command, verbatim and once. With the
+  switch off, or no pick, you cannot approve: `approve` refuses without a terminal
+  on stdin or `AI_UNATTENDED` in its own environment — neither of which a tool
+  call from this session has — and the path guard denies it. Never try another
+  route.
 - **full_irreversible:** the command carries
   `--confirm "<what it does, naming DROP …>"`; the human names every operation
   the re-score found, in their own words.
@@ -91,11 +96,14 @@ Write the body from `.ai/reports/<task-id>/task.md` — no new opinion:
 - the verification command and its result (suite and e2e);
 - the review verdict, with any finding left open and why;
 - the rollback: `git revert <commit>`, plus anything a revert does not undo;
-- open risks, pointing at `.ai/project/known-risks.md`.
+- open risks: the ones this task recorded or closed with `state.py memory risk
+  add|close`, by rkey (`state.py memory risks` lists them).
 
 Suggest the commit command — `git add` of the task's files and its
-`.ai/reports/<task-id>/`, then `git commit` with that body — for the human to
-run. You never commit, push, merge or deploy.
+`.ai/reports/<task-id>/` (in packages mode also `.ai/memory/`, which holds the
+task's record — the pre-push check refuses a closed task without it), then
+`git commit` with that body — for the human to run. You never merge or deploy; you commit, push or
+approve only as the command the human picked in the dialog (§2), verbatim, once.
 
 ## 4. Pending questions