# Runner-owned limits and shared memory Use these blocks for bounded feedback loops. Never ask a model to count visits, increment revision counters, or enforce retry caps. Model verdicts concern current work only. Counters are runner audit data, not model input. A fresh session alone does not guarantee independent review: explicitly select its input fields. ````markdown ```limits {"max_visits":3,"on":["rejected"]} ``` ```memory {"task":"input.prompt","checks":"planner.checks"} ``` ```edges approved -> #success advisory -> #success rejected -> implement error -> #failure ``` ```` These blocks accompany a normal review stage's prompt/output/tools/configs. Pipelines counts actual visits, ignoring model-generated counters. On visit three, `approved` can succeed; `rejected` retains its verdict but routes to `#failure`. `rejected` is for a must-fix finding with a concrete location, evidence and remedy; `advisory` carries non-blocking notes and continues the run without another implementer visit, so an advisory-only review never buys a full re-implementation. An implementer may likewise declare `blocked_retryable -> implementer` for a transient environment, tooling or device problem a fresh attempt could survive, keeping `blocked -> #failure` for an acceptance criterion that genuinely cannot be met. `max_visits` caps every visit of that stage, including re-entries from the reviewer's `rejected` edge, so an implementer that is also the rejection target must use a cap at least as large as the reviewer's budget; the published pipelines use `{"max_visits":5,"on":["blocked_retryable"]}`. A lower implementer cap stops the loop before the reviewer's own cap fires, making the reviewer's `rejected` control unreachable. Both edges need only the existing visit counting and cap; neither the reviewer nor the implementer counts visits, and no stage invents edits or checks to appear busy. Visit count, limit decision and original target are retained in `inspect --json` and run metadata. `max_visits` accepts 1–5. Every `on` outcome must declare a nonterminal edge. Without `on`, entering beyond the cap fails before execution. Global 30-step/five-visits-per-stage safety limits still apply. `memory` maps input aliases to `input.FIELD` (original input) or `STAGE.FIELD` (latest completed output of that stage **in this run**). A memory block replaces previous-stage input with only those fields. Without it, previous output remains input. Reads retain source and visit sequence. Missing required fields fail before execution. Append `?` to omit an unavailable field, e.g. `"feedback":"review.findings?"` for implement's first visit. Self-memory is rejected. Limits: 50 bindings; 1 MiB per retained in-memory value map. Implementers can receive task, plan and optional findings. Independent reviewers should receive task/acceptance criteria and inspect actual artifacts—not previous verdicts, counters, or implementation conversations. Select acceptance, design, reuse and research references from the planning stage (for example `"acceptance_checks":"planner.acceptance_checks"`) rather than from the implementer, so an implementer's output cannot overwrite the agreed criteria; take only factual implementer fields such as `changed_files`, `implementation_summary` and `evidence` as claims. Selected content remains untrusted data; this cannot prove semantic independence or prevent all injection. `input.server_changed_files` is a reserved field the runner publishes: the run's full, deduplicated, first-seen set of server-captured changed paths (observed filediff evidence, never a model's claim). Select it with `"server_changed_files":"input.server_changed_files"`. It is always resolvable — an empty list when nothing was captured — and reflects every completed step, including the persisted steps of a resumed run. Only a stage that selects it receives it; other stages' input is unchanged. A committer should select it alongside the implementer's declared `changed_files` and stage the union of the captured paths that still exist and the declared paths, keeping every existing exclusion and empty-commit rule, and record in the commit body what it reconciled. Declared lists come from the model and are frequently incomplete; the server-captured set is the authoritative evidence of what this run changed. Memory is run-local; persisted completed outputs/read provenance are its audit. There is no cross-run memory, restart/resume, or hidden replay. New runs/retries start fresh. Arbitrary prose is not executable policy. Future AI-assisted guidelines validation is **not implemented**; structural validation does not recognize every unreliable counting instruction.