riskrails 3.0.0 → 3.1.0

package/skills/ai-task/weight.py

@@ -294,7 +294,7 @@ def mirror(path):
                                       (policy.get("rules") or {}).get("hint_raises_by", 1), h.get("note", ""))
             for h in policy.get("hints") or []]
     out += ["", "Rules: " + json.dumps(policy.get("rules") or {}, ensure_ascii=False), "",
-            "Budgets: review_rounds_max %s · remediation_rounds %s · tests %s" % (
-                policy.get("review_rounds_max"), policy.get("remediation_rounds"),
-                json.dumps(policy.get("tests") or {}))]
+            "Budgets: review_rounds_max %s · remediation_rounds %s · tests %s%s" % (
+                policy.get("review_rounds_max"), policy.get("remediation_rounds"), json.dumps(policy.get("tests") or {}),
+                " · batch %s" % json.dumps(policy["batch"]) if isinstance(policy.get("batch"), dict) else "")]
     return "\n".join(out) + "\n"

package/skills/project-init/templates/constitution.md

@@ -7,7 +7,7 @@ C1. Production behaviour is the source of truth; what looks wrong may be load-be
 C2. A bugfix starts with the failing test; legacy behaviour gets a characterization test before it changes.
 C3. A refactoring changes no behaviour and is never mixed with a feature.
 C4. Every step names its files; scope grows only by amending the plan.
-C5. No agent commits, merges or deploys; a human approves outside the agent.
+C5. No agent merges or deploys; an agent commits, pushes or approves only by running, verbatim and once, a command a human picked in the dialog, as the harness recorded; else a human runs it outside.
 C6. <!-- project principle — filled by /ai-init from the survey, confirmed by you -->
 C7. <!-- project principle -->
 C8. <!-- project principle -->

package/skills/project-init/templates/sdlc-README.md

@@ -1,24 +1,30 @@
 # SDLC artefacts
 
-Feature work in this repo follows the AI-Native SDLC flow: **intent → spec → plan → build**.
-Each stage has a skill that produces one file here, and the next stage reads it.
+Work that needs a written intent and design before any code follows
+**spec → plan → build**. Each stage has a skill that produces one file here,
+and the next stage reads it.
 
 ```
- /sdlc-intent <topic>        →  docs/sdlc/intent/<slug>.md   (problem, outcome, constraints)
+ /rr-spec <idea | intent/<slug>.md>  →  docs/sdlc/specs/<slug>.md    (## Intent, requirements, design, Flagged concerns)
+        │                               docs/sdlc/intent/<slug>.questions.md  (the brainstorm, recorded by state.py)
+ /rr-plan specs/<slug>.md            →  docs/sdlc/plans/<slug>.md    (files that change, order, risks, proof, rollback)
         │
- /sdlc-spec  intent/<slug>.md →  docs/sdlc/specs/<slug>.md    (requirements, design, flagged concerns)
-        │
- /sdlc-plan  specs/<slug>.md  →  docs/sdlc/plans/<slug>.md    (files, order, risks, proof)
-        │
-      build (main session, one plan step at a time; `ai-reviewer` before commit)
+ /rr-build  — one row at a time (each row is one task, weighed and started by /rr-plan)
+ /rr-build-all plans/<slug>.md — the whole plan as one task: parallel implementers, one review loop
 ```
 
 | Folder | Produced by | Contains |
 |---|---|---|
-| `intent/` | `/sdlc-intent` | one file per idea; what and why, not how |
-| `specs/` | `/sdlc-spec` | requirements + design; ends with **Flagged concerns** |
-| `plans/` | `/sdlc-plan` | ordered implementation steps with verification |
-| `adr/` | you / `architect` | Architecture Decision Records (MADR style) |
+| `intent/` | `/rr-spec`'s brainstorm (`state.py ask --topic`) | `<slug>.questions.md`, one question at a time with the answer on record; an `intent/<slug>.md` written by hand is accepted instead of the brainstorm |
+| `specs/` | `/rr-spec`, `architect` on STRONG | `## Intent` (problem, outcome, affected users and systems, constraints, decisions taken), requirements, design; ends with **Flagged concerns**, which a human resolves or accepts before planning |
+| `plans/` | `/rr-plan` | Files that change / Order of work / Risks / Proof (every requirement to a test or command) / Rollback; each row carries its files and its *Consumes* line |
+| `adr/` | you, or `architect` | Architecture Decision Records (MADR style) |
+| `constitution.md` | `/rr-setup`, then you | the principles the project does not negotiate, cited as `C<n>` in specs, plans and reviews; at most 15 lines |
 
-Each folder holds a `TEMPLATE.md`; the skills copy it and fill it in. Commit the artefacts with the
-code they describe so the reasoning survives the pull request.
+The skills fill in the plugin's templates
+(`$AI_HOME/skills/project-init/templates/{intent,spec,plan,adr}.md`, in the
+installed plugin); to override one, copy it to `docs/sdlc/<folder>/TEMPLATE.md`
+and edit it — the skills read that one first. Commit the artefacts with the code they describe, so the
+reasoning survives the pull request. A task's own record — weight, plan, questions, verify runs, review,
+verdict — is not here but in `.ai/reports/<task-id>/task.md`, written by
+`state.py`.

package/skills/project-update/history/blobs/00289f98434fed230eebe768dfb3425f83d737866a3aebc97aa95167c4fa0c6e

@@ -0,0 +1,131 @@
+# Testing policy
+
+Tests describe behaviour. Coverage percentage is a side effect, not a goal.
+
+## Characterization first
+
+Before changing behaviour that is not covered by a test — which is most legacy
+behaviour — write a test that passes against the code **as it is today**. That
+test is the definition of what must not break. Only then change the code.
+
+```
+characterization test → refactor → verify identical behaviour → feature change
+```
+
+Never do those in one step, and never in one commit.
+
+## What to consider, by kind of change
+
+| Change touches | Also test |
+|---|---|
+| a shared service | the existing callers, not only the new one |
+| money, tax, fiscal | rounding, currency, negative and zero amounts, refunds |
+| a state machine | every transition that is now reachable, and the ones that must stay unreachable |
+| an async consumer | retry, double delivery, out-of-order delivery, poison message |
+| an external integration | timeout, 500, malformed response, partial write |
+| a write path | idempotency, concurrency, transaction boundaries |
+| authorization | the negative case, for every role |
+| a public API or event | the old shape still works |
+
+## Three scopes, three moments
+
+A task runs tests three times at most, and each run has its own scope. Nothing
+else runs in between.
+
+| When | What runs | Command |
+|---|---|---|
+| after each implementation step, before `step-done` | **only the tests the plan named for that step** — the files it touched, their direct callers' tests | `step_test_command` |
+| once, after the **last** step | the full fast suite — unit and integration, no e2e | `verify_command` |
+| once, at the **end of the task**, after the full suite is green | the end-to-end suite | `e2e_command` |
+
+- A step never runs the full suite, and **never** runs e2e. If the plan named
+  no test for a step, nothing runs for it.
+- A step's tests are scoped by path or filter, not by `--stop-on-failure`: the
+  scoped run still goes to the end, and its failures are fixed inside that step.
+- The e2e suite runs **once per task**, at the very end, never per step. Skip it
+  at T0/T1, and when the change cannot reach a flow the e2e suite covers — say
+  which, in one line; silence is not a verdict.
+- A failure in a step's own tests is fixed in that step, before `step-done`;
+  the batch rule below is for the two end-of-task runs.
+- After a green suite, a documents-only edit runs `doc_tests` (step scope), not the suite.
+
+## Reading a failure
+
+**Run to the end, then fix as one batch.** The verification command runs with
+no fail-fast flag and is never interrupted at the first failure. Collect every
+failure, classify each one, fix all the new regressions in one batch
+(`state.py start --amend` widens the task when a fix needs more files), and run the
+command once more. One failure never
+sends the task back to the start: the plan, the tier and the finished steps
+stand. At most two remediation rounds; a third means the human decides.
+
+Classify before fixing. The four answers are:
+
+- **EXISTING TEST FAILURE** — it failed before this change too. Say so, do not
+  fix it inside this task.
+- **NEW REGRESSION** — this change broke it. Fix the code, not the test.
+- **TEST ENVIRONMENT FAILURE** — database, fixtures, network, container. Say what
+  is missing.
+- **UNKNOWN** — you could not tell. Say what you tried.
+
+A review's MEDIUM and LOW findings are recorded with `state.py memory risk add`, not
+fixed in the task; only a BLOCKER, a HIGH or a regression buys an `--after-fix` run.
+
+**Never edit a test to make it pass when production behaviour changed
+unexpectedly.** A test that suddenly disagrees with the code is evidence, and
+deleting evidence is the worst available option.
+
+## Verification
+
+Three commands, one per scope. `verify_command` proves the project is healthy;
+`step_test_command` proves one step is; `e2e_command` proves the whole flow
+still works. Keep each to one command — chain the pieces in a Makefile or
+composer script if there are several — and make sure none of them stops at the
+first failure (`--stop-on-failure`, `-x`, `--bail`, `failfast` are off).
+
+`verify_command` must **exclude** the e2e suite: it is the fast loop run after
+the last step and again after a remediation batch. `e2e_command` runs once, at
+the end of the task. A bugfix still shows its new failing test first — that one
+test only, through `single_test`.
+
+```
+verify_command:      # the full fast suite, e2e excluded — e.g. make test   |   composer qa && vendor/bin/phpunit --exclude-group e2e
+step_test_command:   # the same runner, scoped to a path or filter — e.g. vendor/bin/phpunit {files} | pytest {files}
+e2e_command:         # the end-to-end suite, run once at the end of a task — e.g. make e2e | vendor/bin/behat | npx playwright test
+lint_command:        # e.g. vendor/bin/php-cs-fixer fix --dry-run | ruff check . | npm run lint — write `none` if the project has none
+doc_tests:           # the suites a documents-only edit runs after a green suite — e.g. tests/test_docs.py; `none` if the project has none
+typecheck_command:   # e.g. vendor/bin/phpstan analyse --no-progress | mypy . | npx tsc --noEmit — `none` if the project has none
+healthy_output:      # two or three lines of what a green run ends with
+runtime:             # roughly, for each command, so a hang is recognisable
+single_test:         # how to run one test, for the failing-test-first step of a bugfix
+```
+
+`step_test_command` may contain `{files}`, which is replaced by the paths the
+step names; without it the paths are appended. The placeholder is what lets
+`sensors.py` run a step's own tests for the "test must bite" check, so a runner
+that only takes a `--filter` gets `bite: unavailable` rather than a wrong answer.
+
+`bite_codes` (optional) lists the exit codes that mean "a test failed" when a
+test is shown failing before its fix; the default is `1`. Runners that exit
+differently say so here — `bite_codes: 1,2` for pytest (2 is a collection
+error, such as a missing import), `1,2` for phpunit, `101` for cargo. Any other
+code is the runner's own usage error and does not count as a bite.
+
+`lint_command` and `typecheck_command` are read by the deterministic sensors,
+never by a model. They decide, together with the test run, whether a light-mode change
+can skip its model review (`state.py close` measures them). A **missing** line is
+`unavailable` and keeps the review; only the literal `none`, written by a human,
+says the project has no such tool. Read the exact line from the project's
+config files (`package.json`, `composer.json`, `pyproject.toml`, `Makefile`), and
+never run a command just to find it out.
+
+If the project has no e2e suite, write `e2e_command: none` and say so — an
+empty line is read as "not written down yet" and the next task will go looking
+for it. Say which group, tag or directory marks the e2e tests and how
+`verify_command` excludes them, so a step's scoped run and the fast suite stay
+free of them.
+
+## Project specifics
+
+<!-- The real commands: how to run unit tests, integration tests, a single test.
+     Where fixtures live. What the CI runs. Cite the config. -->

package/skills/project-update/history/blobs/079a91f976ad69b5cf49ccb9a28849576e4735ddd9485fc26599e528a69fd2f4

@@ -0,0 +1,30 @@
+# SDLC artefacts
+
+Work that needs a written intent and design before any code follows
+**spec → plan → build**. Each stage has a skill that produces one file here,
+and the next stage reads it.
+
+```
+ /rr-spec <idea | intent/<slug>.md>  →  docs/sdlc/specs/<slug>.md    (## Intent, requirements, design, Flagged concerns)
+        │                               docs/sdlc/intent/<slug>.questions.md  (the brainstorm, recorded by state.py)
+ /rr-plan specs/<slug>.md            →  docs/sdlc/plans/<slug>.md    (files that change, order, risks, proof, rollback)
+        │
+ /rr-build  — one row at a time (each row is one task, weighed and started by /rr-plan)
+ /rr-build-all plans/<slug>.md — the whole plan as one task: parallel implementers, one review loop
+```
+
+| Folder | Produced by | Contains |
+|---|---|---|
+| `intent/` | `/rr-spec`'s brainstorm (`state.py ask --topic`) | `<slug>.questions.md`, one question at a time with the answer on record; an `intent/<slug>.md` written by hand is accepted instead of the brainstorm |
+| `specs/` | `/rr-spec`, `architect` on STRONG | `## Intent` (problem, outcome, affected users and systems, constraints, decisions taken), requirements, design; ends with **Flagged concerns**, which a human resolves or accepts before planning |
+| `plans/` | `/rr-plan` | Files that change / Order of work / Risks / Proof (every requirement to a test or command) / Rollback; each row carries its files and its *Consumes* line |
+| `adr/` | you, or `architect` | Architecture Decision Records (MADR style) |
+| `constitution.md` | `/rr-setup`, then you | the principles the project does not negotiate, cited as `C<n>` in specs, plans and reviews; at most 15 lines |
+
+The skills fill in the plugin's templates
+(`skills/project-init/templates/{spec,plan,adr}.md`); a folder holds a
+`TEMPLATE.md` only when this project overrides the plugin's, and the skills read
+that one first. Commit the artefacts with the code they describe, so the
+reasoning survives the pull request. A task's own record — weight, plan, questions, verify runs, review,
+verdict — is not here but in `.ai/reports/<task-id>/task.md`, written by
+`state.py`.

package/skills/project-update/history/blobs/07ff7fa6f93d471ff533f553b4e523e4105ccde1f3dab70132c5237728f68422

@@ -0,0 +1,13 @@
+<!-- riskrails:start -->
+## AI agent workflow
+
+This repository runs an agentic pipeline under `.ai/`. Read `.ai/AGENTS.md` first: it routes to the policies, workflows and rules, which load on demand; `.ai/policies/` is binding.
+
+- Production behaviour is the source of truth: document problems outside the task, do not fix them.
+
+- A change runs through `/rr-build <request>`; `/rr-status` shows where it stands. Each step names the files it may touch — an edit outside them is refused: answer `SCOPE_CHANGE_REQUIRED`.
+
+- Verify before reporting done: `verify_command` from `.ai/policies/testing.md` once, to the end, then `e2e_command` once; every failure fixed as one batch; show the output.
+- No agent merges or deploys; commit, push, approval only as the dialog picks and the harness records, else a human. When a review flags a mistake twice, the fix goes in this file.
+- Files, not chat, carry decisions: `.ai/reports/<task-id>/task.md` (answer by filling `[Answer]:`), `.ai/state/handoff.md` (read first when resuming), `docs/sdlc/constitution.md` (this project's principles).
+<!-- riskrails:end -->

package/skills/project-update/history/blobs/0ef4a360c76da290173dea0f8073949cb0f8113710a38df95acae5d96bdd1286

@@ -0,0 +1,123 @@
+# Testing policy
+
+Tests describe behaviour. Coverage percentage is a side effect, not a goal.
+
+## Characterization first
+
+Before changing behaviour that is not covered by a test — which is most legacy
+behaviour — write a test that passes against the code **as it is today**. That
+test is the definition of what must not break. Only then change the code.
+
+```
+characterization test → refactor → verify identical behaviour → feature change
+```
+
+Never do those in one step, and never in one commit.
+
+## What to consider, by kind of change
+
+| Change touches | Also test |
+|---|---|
+| a shared service | the existing callers, not only the new one |
+| money, tax, fiscal | rounding, currency, negative and zero amounts, refunds |
+| a state machine | every transition that is now reachable, and the ones that must stay unreachable |
+| an async consumer | retry, double delivery, out-of-order delivery, poison message |
+| an external integration | timeout, 500, malformed response, partial write |
+| a write path | idempotency, concurrency, transaction boundaries |
+| authorization | the negative case, for every role |
+| a public API or event | the old shape still works |
+
+## Three scopes, three moments
+
+A task runs tests three times at most, and each run has its own scope. Nothing
+else runs in between.
+
+| When | What runs | Command |
+|---|---|---|
+| after each implementation step, before `step-done` | **only the tests the plan named for that step** — the files it touched, their direct callers' tests | `step_test_command` |
+| once, after the **last** step | the full fast suite — unit and integration, no e2e | `verify_command` |
+| once, at the **end of the task**, after the full suite is green | the end-to-end suite | `e2e_command` |
+
+- A step never runs the full suite, and **never** runs e2e. If the plan named
+  no test for a step, nothing runs for it.
+- A step's tests are scoped by path or filter, not by `--stop-on-failure`: the
+  scoped run still goes to the end, and its failures are fixed inside that step.
+- The e2e suite runs **once per task**, at the very end, never per step. Skip it
+  at T0/T1, and when the change cannot reach a flow the e2e suite covers — say
+  which, in one line; silence is not a verdict.
+- A failure in a step's own tests is fixed in that step, before `step-done`;
+  the batch rule below is for the two end-of-task runs.
+- After a green suite, a documents-only edit runs `doc_tests` (step scope), not the suite.
+
+## Reading a failure
+
+**Run to the end, then fix as one batch.** The verification command runs with
+no fail-fast flag and is never interrupted at the first failure. Collect every
+failure, classify each one, fix all the new regressions in a single remediation
+step (`state.py remediate`), and run the command once more. One failure never
+sends the task back to the start: the plan, the tier and the finished steps
+stand. At most two remediation rounds; a third means the human decides.
+
+Classify before fixing. The four answers are:
+
+- **EXISTING TEST FAILURE** — it failed before this change too. Say so, do not
+  fix it inside this task.
+- **NEW REGRESSION** — this change broke it. Fix the code, not the test.
+- **TEST ENVIRONMENT FAILURE** — database, fixtures, network, container. Say what
+  is missing.
+- **UNKNOWN** — you could not tell. Say what you tried.
+
+A review's MEDIUM and LOW findings are recorded with `state.py memory risk add`, not
+fixed in the task; only a BLOCKER, a HIGH or a regression buys an `--after-fix` run.
+
+**Never edit a test to make it pass when production behaviour changed
+unexpectedly.** A test that suddenly disagrees with the code is evidence, and
+deleting evidence is the worst available option.
+
+## Verification
+
+Three commands, one per scope. `verify_command` proves the project is healthy;
+`step_test_command` proves one step is; `e2e_command` proves the whole flow
+still works. Keep each to one command — chain the pieces in a Makefile or
+composer script if there are several — and make sure none of them stops at the
+first failure (`--stop-on-failure`, `-x`, `--bail`, `failfast` are off).
+
+`verify_command` must **exclude** the e2e suite: it is the fast loop run after
+the last step and again after a remediation batch. `e2e_command` runs once, at
+the end of the task. A bugfix still shows its new failing test first — that one
+test only, through `single_test`.
+
+```
+verify_command:      # the full fast suite, e2e excluded — e.g. make test   |   composer qa && vendor/bin/phpunit --exclude-group e2e
+step_test_command:   # the same runner, scoped to a path or filter — e.g. vendor/bin/phpunit {files} | pytest {files}
+e2e_command:         # the end-to-end suite, run once at the end of a task — e.g. make e2e | vendor/bin/behat | npx playwright test
+lint_command:        # e.g. vendor/bin/php-cs-fixer fix --dry-run | ruff check . | npm run lint — write `none` if the project has none
+doc_tests:           # the suites a documents-only edit runs after a green suite — e.g. tests/test_docs.py; `none` if the project has none
+typecheck_command:   # e.g. vendor/bin/phpstan analyse --no-progress | mypy . | npx tsc --noEmit — `none` if the project has none
+healthy_output:      # two or three lines of what a green run ends with
+runtime:             # roughly, for each command, so a hang is recognisable
+single_test:         # how to run one test, for the failing-test-first step of a bugfix
+```
+
+`step_test_command` may contain `{files}`, which is replaced by the paths the
+step names; without it the paths are appended. The placeholder is what lets
+`sensors.py` run a step's own tests for the "test must bite" check, so a runner
+that only takes a `--filter` gets `bite: unavailable` rather than a wrong answer.
+
+`lint_command` and `typecheck_command` are read by the deterministic sensors,
+never by a model. They decide, together with the test run, whether a T2 change
+can skip its model review (`risk-tiers.json`, `sensors`). A **missing** line is
+`unavailable` and keeps the review; only the literal `none`, written by a human,
+says the project has no such tool. `sensors.py detect` proposes the exact line
+from the config files it finds, and never runs what it detected.
+
+If the project has no e2e suite, write `e2e_command: none` and say so — an
+empty line is read as "not written down yet" and the next task will go looking
+for it. Say which group, tag or directory marks the e2e tests and how
+`verify_command` excludes them, so a step's scoped run and the fast suite stay
+free of them.
+
+## Project specifics
+
+<!-- The real commands: how to run unit tests, integration tests, a single test.
+     Where fixtures live. What the CI runs. Cite the config. -->

package/skills/project-update/history/blobs/164cd34c182de88c33de7df35beb29200d792419e1c13a5f0b2104f944e57be7

@@ -0,0 +1 @@
+{ "version": 1, "enabled": true, "window_seconds": 120, "stop_blocks_max": 2 }

package/skills/project-update/history/blobs/18c7a2753ce9cb6f6d3d1e9d5d1125d75950b879d56b7325225b200869631b29

@@ -0,0 +1,15 @@
+# Constitution — {{PROJECT}}
+
+<!-- The 10–15 principles this project does not negotiate, one line each, numbered C1…;
+     /sdlc-spec and the planner cite them. Under 15: what is not here lives in .ai/policies/. -->
+
+C1. Production behaviour is the source of truth; what looks wrong may be load-bearing.
+C2. A bugfix starts with the failing test; legacy behaviour gets a characterization test before it changes.
+C3. A refactoring changes no behaviour and is never mixed with a feature.
+C4. Every step names its files; scope grows only by amending the plan.
+C5. No agent merges or deploys; an agent commits, pushes or approves only by running, verbatim and once, a command a human picked in the dialog, as the harness recorded; else a human runs it outside.
+C6. <!-- project principle — filled by /ai-init from the survey, confirmed by you -->
+C7. <!-- project principle -->
+C8. <!-- project principle -->
+C9. <!-- project principle -->
+C10. <!-- project principle -->

package/skills/project-update/history/blobs/1d1d907449ec74594d0ee923ac142ae746b9aedf0a1eda9469f075a44d23e3d7

@@ -0,0 +1,13 @@
+<!-- riskrails:start -->
+## AI agent workflow
+
+This repository runs an agentic pipeline under `.ai/`. Read `.ai/AGENTS.md` first: it routes to the policies, workflows and rules, which load on demand; `.ai/policies/` is binding.
+
+- Production behaviour is the source of truth: document problems outside the task, do not fix them.
+
+- A change runs through `/rr-build <request>`; `/rr-status` shows where it stands. Each step names the files it may touch — an edit outside them is refused: answer `SCOPE_CHANGE_REQUIRED`.
+
+- Verify before reporting done: `verify_command` from `.ai/policies/testing.md` once, to the end, then `e2e_command` once; every failure fixed as one batch; show the output.
+- No agent merges or deploys; commit, push, approval only as the dialog picks, else a human outside. When a review flags the same mistake twice, the correction goes into this file.
+- Files, not chat, carry decisions: `.ai/reports/<task-id>/task.md` (answer by filling `[Answer]:`), `.ai/state/handoff.md` (read first when resuming), `docs/sdlc/constitution.md` (this project's principles).
+<!-- riskrails:end -->

package/skills/project-update/history/blobs/23a42febbacaa7b52a802d428033a99c0694391c81d51fe3b6e1dff608a641d5

@@ -0,0 +1,67 @@
+# Task state
+
+`current.json` is the machine-readable record of the task in flight. It is
+written by `skills/ai-task/state.py` (atomically), read by `/ai-status`, and
+enforced by `ai-scope-guard`, which derives the files the current step may touch
+from it.
+
+Two other writers exist, and only these two. A schema migration in
+`/project-update` may change the state through `ctx.patch_state()`, with the
+same atomic write and a `schema_migrated` history entry — that is how a task in
+flight survives a change to the shape of this file. And `hooks/context-guard.py`
+writes `session.json`, the sidecar beside this file, and nothing else: it never
+touches `current.json`. Nothing else writes any of it — an agent never edits
+them by hand, and the path guard refuses when one tries.
+
+It is **not committed**: it describes a session, not the repository. The
+`.gitignore` entry added by `/ai-init` keeps it out of git.
+
+When a task closes, `state.py close` writes the final state to
+`.ai/state/logs/<task-id>/state.json`, beside the task's verify logs — local,
+**not** committed. What is committed is `.ai/reports/<task-id>/events.jsonl`
+and `task.md`, and in packages mode the task's compact record under
+`.ai/memory/` — that is the audit trail: which stages ran, in what order, who
+approved what, and when (the plugin's `docs/local-memory.md`).
+
+It holds facts, never transcripts:
+
+```
+task_id, goal, workflow, risk_tier, current_stage, affected_modules,
+context_summary_ref, approved_plan { ref, current_step_id, steps[] },
+completed_steps, test_status, e2e_status, review_status, security_status, open_risks,
+next_action, owner_runtime, resume_point { stage, step_id, next_action, at, runtime },
+questions { file, pending[] }, handoff { file, written_at, reason },
+human_approval { required, granted, granted_by, granted_at,
+                 requested_at, gate_id, requested_session, rejected_at, via, unattended },
+created_at, updated_at, history[]
+```
+
+`state.py` applies the schema-2 keys in memory as it loads, so a project that has
+not run `/project-update` yet still answers every command; `save()` then writes
+them. A reader that opens this file directly sees what is on disk, not those
+defaults.
+
+## The other files beside it
+
+| File | Written by | Committed |
+|---|---|---|
+| `current.json` | `state.py`, and `update.py` during a migration | no |
+| `session.json` | `context-guard.py`, on SessionStart and each prompt | no |
+| `handoff.md` | `state.py handoff` — never a model | no |
+| `../reports/<task-id>/task.md` §Questions | `state.py ask/answer/questions` | yes |
+| `../reports/<task-id>/events.jsonl` | `state.py` (`emit`), append-only | yes |
+
+`handoff.md` is the ≤ 30-line frame a session that lost its context reads first:
+the goal, the next action and its resume point, the pending questions, the latest
+decisions, rejected options and failed attempts, and the user's last instruction
+verbatim. It is rendered from the four sources above, so deleting it loses
+nothing — the next stage-moving command writes it again.
+
+`events.jsonl` is the journal: one line per state change, `history[]`'s facts
+with types beside them. It is best effort by contract — a line that cannot be
+written never fails the command that emitted it — so nothing depends on it being
+complete, and readers skip a line they cannot parse.
+
+If this file is corrupt, `state.py` refuses to read it rather than replacing it.
+Inspect it by hand: the scope guard's boundaries come from here, and a silently
+regenerated state file means an unbounded implementer.

package/skills/project-update/history/blobs/25d4f2a86deb5e2574bb3210b67bb24fcc4afb19f93a7b65a057daa874a9d18e

@@ -0,0 +1 @@
+11

package/skills/project-update/history/blobs/48d9950f16e31d55475f566a80dc95f64b35f1c804d2f51729e313a4f29bac8d

@@ -0,0 +1,13 @@
+<!-- riskrails:start -->
+## AI agent workflow
+
+This repository runs an agentic pipeline under `.ai/`. Read `.ai/AGENTS.md` first: it routes to the policies, workflows and rules, which load on demand; `.ai/policies/` is binding.
+
+- Production behaviour is the source of truth: document problems outside the task, do not fix them.
+
+- A change runs through `/rr-build <request>`; `/rr-status` shows where it stands. Each step names the files it may touch — an edit outside them is refused: answer `SCOPE_CHANGE_REQUIRED`. One `apply_patch` is checked file by file: a patch that reaches outside the step is refused whole.
+
+- Verify before reporting done: `verify_command` from `.ai/policies/testing.md` once, to the end, then `e2e_command` once; every failure fixed as one batch; show the output.
+- No agent merges or deploys; commit, push, approval only as the dialog picks and the harness records, else a human outside. When a review flags the same mistake twice, the correction goes into this file.
+- Files, not chat, carry decisions: `.ai/reports/<task-id>/task.md` (answer by filling `[Answer]:`), `.ai/state/handoff.md` (read first when resuming), `docs/sdlc/constitution.md`.
+<!-- riskrails:end -->

package/skills/project-update/history/blobs/5353ca529c46f2443e12947ec205a6887fb594a4de1f87f0eb1c0e6c0f826133

@@ -0,0 +1,49 @@
+{
+  "version": 1,
+  "axes": {
+    "scope": {"measure": "references", "bands": [0, 5], "hot_paths": ["hooks/**", "src/Shared/**"]},
+    "behaviour": {"measure": "session",
+                  "keywords": ["workflow", "transition", "state machine", "messenger", "queue", "async", "transaction"]},
+    "reversibility": {"measure": "paths+content",
+                      "needs_step": ["**/migrations/**", "**/Migrations/**", "config/**", "k8s/**", "**/env/**"],
+                      "irreversible": ["**/prod/**", "**/production/**", "deploy/**", "**/*.deploy.*"],
+                      "irreversible_content": ["DROP ", "TRUNCATE", "DELETE FROM", "ALTER .* DROP", "RENAME"]},
+    "domain": {"measure": "modules+session",
+               "modules": ["**/Payment/**", "**/Tax/**", "**/Invoice/**", "**/Security/**", "**/account/**"],
+               "customer_visible": ["templates/**", "**/Shop/**", "**/Resources/views/**"]},
+    "novelty": {"measure": "session",
+                "manifests": ["composer.json", "requirements*.txt", "package.json", "pyproject.toml", "Gemfile"]},
+    "coverage": {"measure": "tests-map",
+                 "code_globs": ["**/*.php", "**/*.py", "**/*.js", "**/*.ts", "**/*.sh"],
+                 "test_globs": ["tests/**", "spec/**", "**/*Test.php", "**/*.test.*", "**/*.spec.*", "**/test_*.py"],
+                 "map": {}}
+  },
+  "hints": [
+    {"paths": ["**/login*", "**/Security/**", "**/*Auth*"], "axis": "domain", "note": "auth-shaped path"},
+    {"paths": ["skills/project-update/migrations/**"], "axis": "reversibility", "note": "touches user trees"},
+    {"paths": [".ai/policies/**", ".claude/**", ".codex/**", "CLAUDE.md", "AGENTS.md"], "axis": "behaviour", "note": "pipeline"},
+    {"paths": ["composer.json", "package.json", "requirements*.txt"], "axis": "novelty", "note": "dependency manifest"}
+  ],
+  "modes": {
+    "light": {"max_w": 2, "plan": "inline", "review": "on_red_fact", "reviewer": "BALANCED",
+              "human_stops": 0, "suite": "verify", "e2e": false},
+    "guarded": {"max_w": 7, "plan": "plan_mode", "review": "one", "reviewer": "BALANCED",
+                "human_stops": 1, "suite": "verify+e2e", "e2e": true},
+    "full": {"min_w": 8, "hard_axes": ["reversibility", "domain"], "plan": "written", "review": "one",
+             "reviewer": "STRONG", "security_focus_when": "domain=2", "human_stops": 2, "suite": "verify+e2e", "e2e": true},
+    "full_irreversible": {"when": "reversibility=2 and domain=2, or irreversible_content",
+                          "human_stops": 3, "confirm_names_operation": true}
+  },
+  "rules": {"unknown_scores": 1, "hint_raises_by": 1, "hint_raises_once_per_axis": true,
+            "rescore_axes": ["reversibility", "domain"], "rescore_direction": "up", "lower_by": "human",
+            "steps_advice_over": 8},
+  "review_rounds_max": 2,
+  "remediation_rounds": 2,
+  "tests": {"max_suite_runs": 2, "timeout_seconds": 1800, "env_retries": 1, "log_max_bytes": 2097152},
+  "batch": {"default": false, "review_rounds_max": 3, "max_suite_runs": 8, "parallel": 3, "tier": "BALANCED"},
+  "examples": {
+    "light": ["a font or copy change in one template", "a test-only change", "a message-text change"],
+    "guarded": ["a regex fix in a hot guard script", "a dev-environment manifest", "a feature with a new screen and an additive migration"],
+    "full": ["a change in Payment/, Tax/ or Security/", "a migration that rewrites user trees", "a production manifest or secret"]
+  }
+}

package/skills/project-update/history/blobs/5a93f78b4ed4d416c171139b2ce610a117f9c1dd46fbb56ca86729cb4c53d10c

@@ -0,0 +1,6 @@
+# claude-agentic (.ai)
+.ai/state/*.json
+.ai/state/handoff.md
+.ai/state/*.tmp
+.ai/state/*.jsonl
+.ai/local/

package/skills/project-update/history/blobs/5f65bc7ab3fc3c4e75ae05d49eaf4331fafc398c661abe33c69f7380a720344c

@@ -0,0 +1,32 @@
+# Weight table
+
+<!-- generated by `state.py weight --mirror` from weight.json; edit the JSON and regenerate. sha256: 5353ca529c46f2443e12947ec205a6887fb594a4de1f87f0eb1c0e6c0f826133 -->
+
+Six axes, 0–2 each; W is their sum. Why each rule is what it is: the plugin's `docs/weight.md`.
+
+| Axis | Measured by | Table |
+|---|---|---|
+| scope | references | bands: [0, 5]; hot_paths: ["hooks/**", "src/Shared/**"] |
+| behaviour | session | keywords: ["workflow", "transition", "state machine", "messenger", "queue", "async", "transaction"] |
+| reversibility | paths+content | needs_step: ["**/migrations/**", "**/Migrations/**", "config/**", "k8s/**", "**/env/**"]; irreversible: ["**/prod/**", "**/production/**", "deploy/**", "**/*.deploy.*"]; irreversible_content: ["DROP ", "TRUNCATE", "DELETE FROM", "ALTER .* DROP", "RENAME"] |
+| domain | modules+session | modules: ["**/Payment/**", "**/Tax/**", "**/Invoice/**", "**/Security/**", "**/account/**"]; customer_visible: ["templates/**", "**/Shop/**", "**/Resources/views/**"] |
+| novelty | session | manifests: ["composer.json", "requirements*.txt", "package.json", "pyproject.toml", "Gemfile"] |
+| coverage | tests-map | code_globs: ["**/*.php", "**/*.py", "**/*.js", "**/*.ts", "**/*.sh"]; test_globs: ["tests/**", "spec/**", "**/*Test.php", "**/*.test.*", "**/*.spec.*", "**/test_*.py"]; map: {} |
+
+| Mode | When | Plan | Review | Reviewer | Human stops | Suite |
+|---|---|---|---|---|---|---|
+| light | W ≤ 2 | inline | on_red_fact | BALANCED | 0 | verify |
+| guarded | W ≤ 7 | plan_mode | one | BALANCED | 1 | verify+e2e |
+| full | W ≥ 8 or reversibility or domain = 2 | written | one | STRONG | 2 | verify+e2e |
+| full_irreversible | reversibility=2 and domain=2, or irreversible_content | as full | as full | as full | 3 | as full |
+
+| Hint paths | Axis | Note |
+|---|---|---|
+| `**/login*`, `**/Security/**`, `**/*Auth*` | domain +1 | auth-shaped path |
+| `skills/project-update/migrations/**` | reversibility +1 | touches user trees |
+| `.ai/policies/**`, `.claude/**`, `.codex/**`, `CLAUDE.md`, `AGENTS.md` | behaviour +1 | pipeline |
+| `composer.json`, `package.json`, `requirements*.txt` | novelty +1 | dependency manifest |
+
+Rules: {"unknown_scores": 1, "hint_raises_by": 1, "hint_raises_once_per_axis": true, "rescore_axes": ["reversibility", "domain"], "rescore_direction": "up", "lower_by": "human", "steps_advice_over": 8}
+
+Budgets: review_rounds_max 2 · remediation_rounds 2 · tests {"max_suite_runs": 2, "timeout_seconds": 1800, "env_retries": 1, "log_max_bytes": 2097152} · batch {"default": false, "review_rounds_max": 3, "max_suite_runs": 8, "parallel": 3, "tier": "BALANCED"}