The committer staged only the implementer's self-declared changed_files, so an incomplete declaration silently left part of the approved change uncommitted. The runner already records the run's real changed paths by comparing the working tree around each step; publish that set to the committer. - runState gains an unbounded, deduplicated, first-seen-ordered captured path accumulator (capturedPaths/capturedSeen), distinct from the bounded changedPaths sample used only by the UI-surface skip reason. - recordChanges folds each captured FileChange path into it in the existing single pass, so no second walk and no new I/O. - publishServerChangedFiles writes the set into the input memory value as input.server_changed_files, called before memoryInput so the binding always resolves (an empty list when nothing was captured) and only stages that select it receive it. rebuildRunState rebuilds it from persisted completed steps, so a resumed run hands the committer the same evidence. - Tests prove the committer receives the captured set distinct from and additive to the implementer's declared changed_files, that an omitted path is still present, and that the field is an empty list when nothing was captured. - control.md and orchestration.md document the reserved field and instruct the committer to select input.server_changed_files alongside the declared changed_files and stage their union. Commands run: go build ./...; go vet ./...; go test -count=1 ./internal/server/... ./internal/stage/...; go test -count=1 ./internal/author/...; go test -count=1 -run TestCommitterReceivesServerCapturedChangedPaths ./internal/server/. All passed. go.mod/go.sum unchanged.
3.5 KiB
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.
```limits
{"max_visits":3,"on":["rejected"]}
```
```memory
{"task":"input.prompt","checks":"planner.checks"}
```
```edges
approved -> #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.
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.