Files
pipelines/internal/author/skill/references/control.md
T
alan 98713e55f5 server: hand the committer the captured changed-path set
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.
2026-10-16 23:44:56 +01:00

3.5 KiB
Raw Blame History

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.