riskrails 3.0.0 → 3.1.0

package/profiles/pro.json

@@ -8,12 +8,14 @@
     "claude-sonnet-5": { "effortLevel": "medium" },
     "claude-haiku-4-5-20251001": { "effortLevel": "high" }
   },
-  "autoCompactWindow": 300000,
   "riskrails": {
     "inherits": null,
     "plan": "pro",
     "label": "Pro",
     "runtime": "claude",
+    "economy": {
+      "autoCompactWindow": 300000
+    },
     "tiers": {
       "FAST": {
         "model": "haiku",

package/scripts/merge-codex-config.py

@@ -16,12 +16,19 @@ Exactly five keys are managed:
     agents.default_subagent_reasoning_effort
     agents.max_concurrent_threads_per_session
 
+and, with ``--status-context yes``, ``tui.status_line``: ``model-with-reasoning``
+and ``context-used`` are appended to a list the user set, when missing; the user's
+items are never removed or reordered. An unset key (Codex's own default items) and
+an empty list are left alone, with a note: writing ours would replace either.
+``--status-context no`` (the default) leaves the list alone.
+
 Safety contract: the file is parsed before and after the edit, and the write is
 abandoned unless the *only* difference between the two parses is inside that
 managed set. A prose key name inside a multi-line string cannot slip through
 that check, because it would show up as an unexpected difference.
 
   merge-codex-config.py <config.toml> --profile <codex-plus.json|codex-pro.json> [--dry-run] [--no-backup]
+                        [--status-context yes|no]
 """
 import argparse
 import json
@@ -37,6 +44,7 @@ MANAGED_AGENTS = (
     "default_subagent_reasoning_effort",
     "max_concurrent_threads_per_session",
 )
+STATUS_ITEMS = ("model-with-reasoning", "context-used")  # Codex 0.165 [tui] status_line ids
 TABLE_HEADER = re.compile(r"^\s*\[")
 
 
@@ -46,6 +54,8 @@ def die(message):
 
 
 def toml_value(value):
+    if isinstance(value, list):
+        return "[%s]" % ", ".join(toml_value(v) for v in value)
     if isinstance(value, bool):
         return "true" if value else "false"
     if isinstance(value, (int, float)):
@@ -100,6 +110,121 @@ def set_in_span(lines, start, end, key, value, changes):
     return end + 1
 
 
+def value_end(lines, at):
+    """One past the last line of the value assigned on line `at` (an array may span lines)."""
+    chunk = lines[at].split("=", 1)[1]
+    for j in range(at, len(lines)):
+        if j > at:
+            chunk += "\n" + lines[j]
+        try:
+            tomllib.loads("v = " + chunk)
+            return j + 1
+        except tomllib.TOMLDecodeError:
+            continue
+    return None
+
+
+def status_items(lines, before, changes, notes):
+    """Append STATUS_ITEMS to the user's [tui] status_line where missing; the user's
+    items keep their order. Returns the wanted list, or None when nothing is to change,
+    the key is unset or empty, or it lives somewhere this edit does not reach."""
+    current = before.get("tui.status_line")
+    if current is None or current == []:
+        # Unset is Codex's own default set, and [] a deliberate empty line: writing
+        # our two items would replace either.
+        notes.append("left [tui] status_line alone (%s; add %s to show them)"
+                     % ("not set: Codex's default items" if current is None else "empty on purpose",
+                        " and ".join(STATUS_ITEMS)))
+        return None
+    if not isinstance(current, list):
+        return None
+    missing = [item for item in STATUS_ITEMS if item not in current]
+    if not missing:
+        return None
+    value = current + missing
+    rendered = "status_line = %s" % toml_value(value)
+    span = table_span(lines, "tui")
+    at = key_line(lines, span[0] + 1, span[1], "status_line") if span else None
+    if at is None:
+        notes.append("left [tui] status_line alone (not a status_line key in a [tui] table)")
+        return None
+    end = value_end(lines, at)
+    if end is None:
+        return None
+    was = " ".join(line.strip() for line in lines[at:end])
+    kept = append_items(lines[at:end], missing)
+    try:
+        ok = kept is not None and tomllib.loads("\n".join(kept))["status_line"] == value
+    except (tomllib.TOMLDecodeError, KeyError):
+        ok = False
+    # The user's own lines and comments stay; one rendered line only when they cannot.
+    lines[at:end] = kept if ok else [rendered]
+    changes.append("set [tui] %s (was: %s)" % (rendered, was))
+    return value
+
+
+def array_marks(block):
+    """(line, col) of the closing ] of the array assigned on block[0], and of the last
+    character before it outside strings, comments and blanks; None for an array this
+    scan does not read (nested, or a multi-line string)."""
+    row, col = 0, block[0].index("=") + 1
+    depth, last, quote = 0, None, None
+    while row < len(block):
+        line = block[row]
+        while col < len(line):
+            ch = line[col]
+            if quote:
+                if quote == '"' and ch == "\\":
+                    col += 2
+                    continue
+                if ch == quote:
+                    quote = None
+                    last = (row, col)
+            elif ch in "\"'":
+                if line.startswith(ch * 3, col):
+                    return None
+                quote = ch
+            elif ch == "#":
+                break
+            elif ch == "[":
+                depth += 1
+                if depth > 1:
+                    return None
+                last = (row, col)
+            elif ch == "]":
+                return (row, col), last
+            elif not ch.isspace():
+                last = (row, col)
+            col += 1
+        if quote:
+            return None
+        row, col = row + 1, 0
+    return None
+
+
+def append_items(block, items):
+    """The lines of `block` (one `status_line = [...]` assignment) with `items` added
+    before its closing ], comments and layout kept; None when the scan cannot place them."""
+    marks = array_marks(block)
+    if marks is None or marks[1] is None:
+        return None
+    (row, col), (lrow, lcol) = marks
+    out = list(block)
+    comma = block[lrow][lcol] not in ",["
+    if block[row][:col].strip():
+        # ] shares its line with an item: `["a"]  # c` → `["a", "x", "y"]  # c`.
+        joined = ", ".join(toml_value(item) for item in items)
+        lead = ", " if comma else ("" if block[lrow][lcol] == "[" else " ")
+        out[row] = out[row][:col] + lead + joined + out[row][col:]
+    else:
+        # ] on its own line: one `"item",` line each, at the last item's indentation.
+        indent = re.match(r"\s*", block[lrow]).group(0) if lrow > 0 else re.match(r"\s*", block[row]).group(0) + "  "
+        out[row:row] = ["%s%s," % (indent, toml_value(item)) for item in items]
+        if comma:
+            out[lrow] = out[lrow][:lcol + 1] + "," + out[lrow][lcol + 1:]
+    return out
+
+
 def flatten(data, prefix=""):
     out = {}
     for key, value in data.items():
@@ -117,6 +242,7 @@ def main():
     parser.add_argument("--profile", required=True)
     parser.add_argument("--dry-run", action="store_true")
     parser.add_argument("--no-backup", action="store_true")
+    parser.add_argument("--status-context", choices=("yes", "no"), default="no")
     args = parser.parse_args()
 
     try:
@@ -182,6 +308,12 @@ def main():
             continue
         stop = set_in_span(lines, start + 1, stop, key, wanted["agents.%s" % key], changes)
 
+    notes = []
+    if args.status_context == "yes":
+        status = status_items(lines, before, changes, notes)
+        if status is not None:
+            wanted["tui.status_line"] = status
+
     text = "\n".join(lines)
     if trailing_newline or text:
         text = text.rstrip("\n") + "\n"
@@ -201,6 +333,8 @@ def main():
         if after.get(key) != value:
             die(f"refusing to write: {key} did not end up as {value!r}")
 
+    for note in notes:
+        print("codex config: %s" % note)
     if not changes:
         print("codex config: already set (model=%s, effort=%s)" % (wanted["model"], wanted["model_reasoning_effort"]))
         return 0

package/scripts/resolve-profile.py

@@ -21,9 +21,14 @@ Resolution:
   ``pro.json``, ``team-max`` resolves ``max.json``).
 * ``--fable yes|no`` records ``fable`` and drops ``architect_model_with_fable``
   when Fable is off, so a reader never has to know the flag.
+* ``--context default|economy`` (default ``default``) records ``context: {mode,
+  window}``. ``economy`` copies ``riskrails.economy.autoCompactWindow`` to the
+  settings' top level and into ``window``; ``default`` leaves the runtime its own
+  compaction, so ``window`` is null and settings carry no ``autoCompactWindow``.
 
   resolve-profile.py <name|path> [--src DIR] [--plan P] [--label L]
-                     [--fable yes|no] [--print full|settings|agentic]
+                     [--fable yes|no] [--context default|economy]
+                     [--print full|settings|agentic]
 
 ``settings`` prints the profile without ``riskrails``; ``agentic`` prints
 the resolved ``riskrails`` object; ``full`` (the default) prints both.
@@ -79,7 +84,7 @@ def codex_tiers(data):
     return tiers
 
 
-def resolve(src, name, plan=None, label=None, fable=None):
+def resolve(src, name, plan=None, label=None, fable=None, context="default"):
     data = load(src, name)
     agentic = data.get(KEY)
     if not isinstance(agentic, dict):
@@ -94,6 +99,12 @@ def resolve(src, name, plan=None, label=None, fable=None):
         agentic["fable"] = fable
         if not fable:
             agentic.get("tiers", {}).get("EXPERT", {}).pop("architect_model_with_fable", None)
+    window = None
+    if context == "economy":
+        window = (agentic.get("economy") or {}).get("autoCompactWindow")
+        if window:
+            data["autoCompactWindow"] = window
+    agentic["context"] = {"mode": context, "window": window}
     return data
 
 
@@ -105,12 +116,13 @@ def main(argv=None):
     ap.add_argument("--plan")
     ap.add_argument("--label")
     ap.add_argument("--fable", choices=("yes", "no"))
+    ap.add_argument("--context", choices=("default", "economy"), default="default")
     ap.add_argument("--print", dest="what", choices=("full", "settings", "agentic"), default="full")
     args = ap.parse_args(argv)
 
     fable = None if args.fable is None else args.fable == "yes"
     try:
-        data = resolve(args.src, args.profile, args.plan, args.label, fable)
+        data = resolve(args.src, args.profile, args.plan, args.label, fable, args.context)
     except (OSError, ValueError) as exc:
         print(f"resolve-profile: {exc}", file=sys.stderr)
         return 2

package/settings.common.json

@@ -26,13 +26,13 @@
         ]
       },
       {
-        "matcher": "Read|Edit|Write|MultiEdit|NotebookEdit|Bash",
+        "matcher": "*",
         "hooks": [
           {
             "type": "command",
             "command": "python3 -I -S \"$HOME/.claude/hooks/ai-guard.py\"",
             "timeout": 15,
-            "statusMessage": "Checking git, paths and scope"
+            "statusMessage": "Checking git, paths, scope and open decisions"
           }
         ]
       }
@@ -84,6 +84,43 @@
           }
         ]
       }
+    ],
+    "Notification": [
+      {
+        "matcher": "auth_success",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"$HOME/.claude/hooks/context-guard.py\"",
+            "timeout": 15
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "AskUserQuestion",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 -I -S \"$HOME/.claude/hooks/dialog-gate.py\"",
+            "timeout": 5,
+            "statusMessage": "Recording the dialog's answer"
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 -I -S \"$HOME/.claude/hooks/dialog-gate.py\"",
+            "timeout": 5,
+            "statusMessage": "Checking for an open decision"
+          }
+        ]
+      }
     ]
   }
 }

package/skills/AGENTS.md

@@ -1,6 +1,6 @@
-<!-- claude-agentic:rule:skills:start -->
+<!-- riskrails:rule:skills:start -->
 # Skills rules
 - Weigh a change by what it does to a user project's decisions, never by the skill being a process (constitution C6). The mode is what W gives (`state.py weight`); the rows below set the behaviour axis.
 - behaviour 0: skill or agent text, `usage-report`, no `state.py` refusal moves. behaviour 1: adds a `state.py` check, a sensor or a refusal. behaviour 2: weakens a refusal, changes the approval path (`approve`, `questions --sync`, `AI_UNATTENDED`, the review verdict transitions) or changes install and migration (the `project-update` merge; a migration also raises reversibility through its hint) — declare it, `--declare behaviour=2:"<the effect>"`. Start such a task with `start --mode full --by <name>`: its weight lands in guarded, and these effects keep a STRONG review and the gate.
-- A change to a shipped template or to `ai/` runs `tools/build-template-history.py` in the same task, or `tests/test-project-update.sh` goes red.
-<!-- claude-agentic:rule:skills:end -->
+- A change to a shipped template or to `ai/` runs `tools/build-template-history.py` in the same task, or `tests/test_project_update.py` (`test_history_covers_every_template`) goes red.
+<!-- riskrails:rule:skills:end -->

package/skills/CLAUDE.md

@@ -1,6 +1,6 @@
-<!-- claude-agentic:rule:skills:start -->
+<!-- riskrails:rule:skills:start -->
 # Skills rules
 - Weigh a change by what it does to a user project's decisions, never by the skill being a process (constitution C6). The mode is what W gives (`state.py weight`); the rows below set the behaviour axis.
 - behaviour 0: skill or agent text, `usage-report`, no `state.py` refusal moves. behaviour 1: adds a `state.py` check, a sensor or a refusal. behaviour 2: weakens a refusal, changes the approval path (`approve`, `questions --sync`, `AI_UNATTENDED`, the review verdict transitions) or changes install and migration (the `project-update` merge; a migration also raises reversibility through its hint) — declare it, `--declare behaviour=2:"<the effect>"`. Start such a task with `start --mode full --by <name>`: its weight lands in guarded, and these effects keep a STRONG review and the gate.
-- A change to a shipped template or to `ai/` runs `tools/build-template-history.py` in the same task, or `tests/test-project-update.sh` goes red.
-<!-- claude-agentic:rule:skills:end -->
+- A change to a shipped template or to `ai/` runs `tools/build-template-history.py` in the same task, or `tests/test_project_update.py` (`test_history_covers_every_template`) goes red.
+<!-- riskrails:rule:skills:end -->

package/skills/ai-init/templates/.ai/AGENTS.md

@@ -13,8 +13,8 @@ Everything else loads on demand; nothing here is worth reading twice.
    The task names the files it may touch; an edit outside them is refused —
    answer `SCOPE_CHANGE_REQUIRED` and widen the task in place with
    `state.py start --amend --files "+<path>" --why "…"`, never around the guard.
-3. No agent commits, pushes, merges or deploys. Approval is given by a human,
-   outside the agent.
+3. No agent merges or deploys; commit, push, approval only as the dialog's picked
+   command, or the human runs them outside the agent.
 4. Verify before reporting done: the verification command once, to the end,
    every failure fixed as one batch, the output shown. Run it through
    `state.py verify --scope all` — it caps the runs, keeps the log out of the
@@ -31,7 +31,7 @@ Everything else loads on demand; nothing here is worth reading twice.
 ## Shared files
 
 This `.ai/` holds `project/`, `rules/`, `state/`, `reports/`, `VERSION` and, in
-`policies/`, `risk-tiers.json`, `risk-tiers.md`, `path-guard.json`, `testing.md`,
+`policies/`, `weight.json`, `weight.md`, `path-guard.json`, `testing.md`,
 `coding.md`, `safety.md` and `security.md`. Every other path below ships with the
 plugin at `<home>/riskrails/ai/<path>`; `<home>` is `~/.claude`, or
 `$CODEX_HOME` (default `~/.codex`). A file at the same path here overrides it and

package/skills/ai-init/templates/.ai/VERSION

@@ -1 +1 @@
-8
+11

package/skills/ai-init/templates/.ai/policies/dialog.json

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

package/skills/ai-init/templates/.ai/policies/safety.md

@@ -23,8 +23,15 @@ is evidence; your intuition about how the code "should" look is not.
 - Read production secrets or customer data into the model context.
 
 If you find a problem outside the current task: **write it down, do not fix it.**
-Unrelated findings go to `.ai/project/known-risks.md` or into the report's
-"observations" section, and the human decides whether they become their own task.
+Unrelated findings are recorded with `state.py memory risk add` (in files mode it
+writes `.ai/project/known-risks.md`) or go into the report's "observations"
+section, and the human decides whether they become their own task.
+
+The compact record is the human's to switch: `state.py memory enable`, `disable`,
+`cleanup`, `pack`, `redact` and `migrate --move-logs` take the human route, as
+`approve` does, and `.ai/memory/` and `.ai/local/memory/` are written by
+`state.py` alone — an agent never edits them (`state.py memory --help`; the
+plugin's `docs/local-memory.md`).
 
 ## Scope
 
@@ -43,6 +50,16 @@ Codex has no hookable read tool, so the large-read cap is Claude-only there —
 an agent that behaves correctly only because a hook is watching is not behaving
 correctly. The rules above hold whether or not a hook enforces them.
 
+**The guards' threat model.** The guards defend against an agent's mistakes — a
+careless `rm`, a write to a frozen policy during a task, a commit with a
+secret — not against an agent that constructs a command to exhaust them. A
+command built to time the guard out is visible in the transcript and in the
+journal, and the human gate in full and full_irreversible mode is the boundary
+for anything that matters.
+Approval rests on a guard plus a ledger: a command the agent constructs to pass
+for the human's pick is outside the threat model, and `state.py consent audit`
+detects it afterwards.
+
 ## Evidence labels
 
 Anything an agent writes into `.ai/project/` carries one of four labels:
@@ -62,3 +79,6 @@ evidence for each, and let the human decide which is the bug.
 
 Stop and ask. An agent that pauses costs a message; an agent that guesses on a
 payment path costs an incident.
+
+Doubt on reversibility or domain is a blocker; other doubt is written to
+`task.md` and the work continues.

package/skills/ai-init/templates/.ai/policies/security.md

@@ -57,12 +57,18 @@ it, add its pattern to `deny_patterns` (a `dependency_instruction_patterns`
 list from an older `path-guard.json` is read as `deny_patterns`).
 
 Always read-only for an agent: the task's state under `.ai/state/`, its
-`task.md` and `events.jsonl`, `.ai/policies/*.json`, and the installed guards —
+`task.md` and `events.jsonl`, `.ai/policies/*.json`, the compact
+record under `.ai/memory/` and `.ai/local/memory/` (written by `state.py` alone),
+and the installed guards —
 their hooks, engine and `skills/ai-task/` under `.claude/` and `.codex/`. While a
 task is in flight the runtime's settings and this project's `.ai/policies/` are
 read-only too. Changing the rules a run is judged by, inside that run, is not a
 change an agent may make on its own.
 
+A review's evidence for a closed task is its record — `state.py memory show <id>`
+and `recall` — once cleanup has moved the report directory; an approval in the
+record authorises nothing.
+
 Project-specific additions go in `.ai/policies/path-guard.json`
 (`deny_patterns`, `allow_patterns`, `protected_config_patterns`,
 `task_protected_patterns`; allow wins over all of them). When a deny is wrong, widen the allow list in that file — do not

package/skills/ai-init/templates/.ai/policies/testing.md

@@ -47,13 +47,15 @@ else runs in between.
   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
+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.
 
@@ -66,6 +68,9 @@ Classify before fixing. The four answers are:
   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.
@@ -88,6 +93,7 @@ verify_command:      # the full fast suite, e2e excluded — e.g. make test   |
 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
@@ -99,12 +105,19 @@ 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 T2 change
-can skip its model review (`risk-tiers.json`, `sensors`). A **missing** line is
+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. `sensors.py detect` proposes the exact line
-from the config files it finds, and never runs what it detected.
+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

package/skills/ai-init/templates/.ai/policies/weight.json

@@ -40,6 +40,7 @@
   "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"],

package/skills/ai-init/templates/.ai/policies/weight.md

@@ -1,6 +1,6 @@
 # Weight table
 
-<!-- generated by `state.py weight --mirror` from weight.json; edit the JSON and regenerate. sha256: 7f3859c34035fe32abf937eebdd7240ac72ab32d254286cff7d939cf0cf6eaef -->
+<!-- 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`.
 
@@ -29,4 +29,4 @@ Six axes, 0–2 each; W is their sum. Why each rule is what it is: the plugin's
 
 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}
+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"}

package/skills/ai-init/templates/.ai/state/README.md

@@ -1,6 +1,6 @@
 # Task state
 
-`current.json` is the machine-readable record of the task in flight. It is
+`state.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.
@@ -10,15 +10,18 @@ Two other writers exist, and only these two. A schema migration in
 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
+touches `state.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 archive` moves it to
-`.ai/reports/<task-id>/state.json`, which **is** committed — that is the audit
-trail: which stages ran, in what order, who approved what, and when.
+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:
 
@@ -42,7 +45,7 @@ defaults.
 
 | File | Written by | Committed |
 |---|---|---|
-| `current.json` | `state.py`, and `update.py` during a migration | no |
+| `state.json` (legacy `current.json`, still read) | `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 |

package/skills/ai-init/templates/AGENTS.block.md

@@ -8,6 +8,6 @@ This repository runs an agentic pipeline under `.ai/`. Read `.ai/AGENTS.md` firs
 - 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 commits, merges or deploys; approval is given by a human outside the agent. 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).
+- 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/ai-init/templates/CLAUDE.block.md

@@ -8,6 +8,6 @@ This repository runs an agentic pipeline under `.ai/`. Read `.ai/AGENTS.md` firs
 - 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 commits, merges or deploys; approval is given by a human outside the agent. 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).
+- 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/ai-init/templates/GEMINI.block.md

@@ -8,6 +8,6 @@ This repository runs an agentic pipeline under `.ai/`. Read `.ai/AGENTS.md` firs
 - Changes run through the pipeline (`/rr-build` in Claude Code or Codex); without it, follow `.ai/policies/safety.md`, touch only the files the current task names, and answer questions in prose or by filling the file.
 
 - 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 commits, merges or deploys; approval is given by a human outside the agent. 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).
+- 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/ai-init/templates/gitignore.snippet

@@ -2,4 +2,5 @@
 .ai/state/*.json
 .ai/state/handoff.md
 .ai/state/*.tmp
+.ai/state/*.jsonl
 .ai/local/

package/skills/ai-init/templates/junie-guidelines.block.md

@@ -8,6 +8,6 @@ This repository runs an agentic pipeline under `.ai/`. Read `.ai/AGENTS.md` firs
 - Changes run through the pipeline (`/rr-build` in Claude Code or Codex); without it, follow `.ai/policies/safety.md`, touch only the files the current task names, and answer questions in prose or by filling the file.
 
 - 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 commits, merges or deploys; approval is given by a human outside the agent. 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).
+- 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 -->