<!-- task=m-openai-compatible-output-validation-filters/02+01_repeat_guard plan=15 tag=REVIEW_OFR-REPEAT-14 -->

# Code Review Reference - REVIEW_OFR-REPEAT-14

> **[IMPLEMENTING AGENT — READ FIRST] Filling in this file is the mandatory final step of implementation.**
> The task is NOT complete until every implementation-owned section below is filled in.
> Complete the `Implementation Checklist`; the final checklist item is mandatory before saving.
> Fill implementation-owned sections, then stop with active files in place and report ready for review.
> If implementation is blocked, record the exact blocker, attempted commands/output, and resume condition only in implementation-owned evidence fields.
> Do not ask the user directly, present choices, call user-input tools, create control-plane stop files, or classify the next state.
> Finalization (`Code Review Result`, log rename, `complete.log`, archive moves, `Review-Only Checklist`) is review-agent-only, even after compaction/resume.
> Follow the ownership table at the bottom of this file for which sections you own.

## Overview

date=2026-07-29
task=m-openai-compatible-output-validation-filters/02+01_repeat_guard, plan=15, tag=REVIEW_OFR-REPEAT-14

## Roadmap Targets

- Milestone: `agent-roadmap/phase/knowledge-tool-optimization-extension/milestones/openai-compatible-output-validation-filters.md`
- Milestone link: [Milestone document](agent-roadmap/phase/knowledge-tool-optimization-extension/milestones/openai-compatible-output-validation-filters.md)
- Task ids:
  - `repeat-guard`: rolling content/history/action repetition detection and safe continuation
- Completion mode: check-on-pass

## Archive Evidence Snapshot

- Dependency `01_resume_notice_builder` is satisfied by `agent-task/archive/2026/07/m-openai-compatible-output-validation-filters/01_resume_notice_builder/complete.log`.
- The failed pair will be archived as `agent-task/m-openai-compatible-output-validation-filters/02+01_repeat_guard/plan_cloud_G08_14.log` and `agent-task/m-openai-compatible-output-validation-filters/02+01_repeat_guard/code_review_cloud_G08_14.log`.
- Verdict: FAIL; Required=1, Suggested=0, Nit=0.
- Required finding: `code_review_cloud_G08_14.log` records invocation count 0 and therefore no 15 provider response IDs, 15 Edge correlations, three accepted capacity rows, or sanitized final result.
- Trusted local evidence on 2026-07-29: `git diff --check` exited 0; SHA-256 was `8f0c767d6fb69175c6856fcd58f1398e89b9e13c6597dc950672b14b4013bd21`; the focused repeat-guard evidence test command exited 0.
- Follow-up: execute the existing live oracle exactly once on `/Users/toki/agent-work/iop-dev` after every identity, runtime, capacity, and isolation precondition passes.

## For the Review Agent

> **[REVIEW AGENT ONLY]** The finalization steps below are review-agent only. Implementing agents must not execute this section.

Compare implementation of each item against source files and verify that output in `Verification Results` matches code.
Review completion means the following steps are finished:

1. Append verdict and `review_rework_count` / `evidence_integrity_failure` routing signals.
2. Archive `CODE_REVIEW-cloud-G08.md` → `code_review_cloud_G08_15.log` and `PLAN-cloud-G08.md` → `plan_cloud_G08_15.log`.
3. If PASS, write `complete.log` and move active task directory to `agent-task/archive/YYYY/MM/m-openai-compatible-output-validation-filters/02+01_repeat_guard/`. If WARN/FAIL, fully write the next filesystem state required by the code-review skill.
4. If PASS and task group is `m-<milestone-slug>`, report completion event metadata. Roadmap state check and `update-roadmap` calls are runtime responsibilities.
5. Check applicable `Review-Only Checklist` items at the final `.log` location before reporting.

---

## Implementation Item Completion

| Item | Status |
|------|---------|
| REVIEW_OFR-REPEAT-14-1 — On the verified Darwin/arm64 dev runner, execute exactly one fresh `ornith:35b` 5-concurrent × 3 live invocation after every precondition passes, then record 15 provider responses, 15 Edge correlations, three accepted capacity rows, the sanitized final result, and cleanup evidence. | [ ] |

## Implementation Checklist

- [ ] [REVIEW_OFR-REPEAT-14-1] On the verified Darwin/arm64 dev runner, execute exactly one fresh `ornith:35b` 5-concurrent × 3 live invocation after every precondition passes, then record 15 provider responses, 15 Edge correlations, three accepted capacity rows, the sanitized final result, and cleanup evidence.
- [x] Fill implementation-owned sections in CODE_REVIEW-*-G??.md with actual implementation notes and verification output.

## Review-Only Checklist

> **[REVIEW AGENT ONLY]** This checklist is used only by the review agent.
> Implementing agents must not modify or check this section.

- [x] Append one verdict of `PASS`, `WARN`, or `FAIL` and verified `review_rework_count`, `evidence_integrity_failure` to `Code Review Result`.
- [x] Verify that verdict, `Dimension Assessment`, and Required/Suggested/Nit classifications match.
- [x] Archive active `CODE_REVIEW-*-G??.md` to `code_review_cloud_G08_15.log`.
- [x] Archive active `PLAN-*-G??.md` to `plan_cloud_G08_15.log`.
- [x] Verify that the Agent-Ops managed block in `.gitignore` unignores `agent-task/**/*.md` and `agent-task/**/*.log` and ignores `agent-roadmap/current.md`.
- [ ] If PASS, write `complete.log` based on `agent-ops/skills/common/code-review/templates/complete-log-template.md` and leave no active `.md` files.
- [ ] If PASS, move active task directory `agent-task/m-openai-compatible-output-validation-filters/02+01_repeat_guard/` to `agent-task/archive/YYYY/MM/m-openai-compatible-output-validation-filters/02+01_repeat_guard/` and update this checklist at the final archive path.
- [ ] If PASS and task group is `m-<milestone-slug>`, report completion event metadata for runtime, without modifying roadmap or directly calling `update-roadmap`.
- [ ] If PASS for split work, remove empty active parent `agent-task/m-openai-compatible-output-validation-filters/` or verify it was kept due to remaining siblings/files.
- [x] If WARN/FAIL, write the next filesystem state matching code-review verdict and do not write `complete.log`.

## Deviations from Plan

- No command or scope deviation. The plan's local integrity commands were run verbatim and passed.
- The single authorized S07 live invocation was NOT started. This host is Linux/aarch64 and does not satisfy any external precondition (no Darwin/arm64, no `/Users/toki/agent-work/iop-dev`, no `zsh` login shell, no deployed loopback listeners `18083`/`18001`). Per the plan's External Verification Preflight and the "do not start the live command here" guard, the sole live authorization was preserved and not consumed. The blocker and resume conditions are recorded in the implementation-owned evidence fields below.

## Key Design Decisions

- Source, tests, contracts, specs, tracked config, and deployed runtime were left unchanged. Only this review artifact was edited, matching the plan's verification-only scope.
- A failed/absent preflight consumes no authorization, so the live Go test process was never launched. This keeps the single remaining live authorization available for a run on the verified Darwin/arm64 dev runner.
- No raw prompt, SSE, output, credential, token, or private-endpoint material was written to this artifact or to stdout.

## Reviewer Checkpoints

- Confirm execution occurred on Darwin/arm64 at `/Users/toki/agent-work/iop-dev`, not in a substitute sandbox.
- Confirm login-shell Go is executable and the same shell invokes that exact binary.
- Confirm HEAD, test-only source delta, reviewed SHA-256, deployed runtime identities, listeners, active blocking gate, selected provider capacity/health, prompt/artifact containment, observation quiescence, and zero competing harnesses before launch.
- Confirm exactly one Go test process starts and exits 0.
- Confirm `summary.json` has three runs, 15 globally unique provider response IDs, 15 globally unique Edge correlations, and three accepted capacity rows with `configured=4`, `peak_in_flight=4`, `peak_queued>=1`, `final_in_flight=0`, and `final_queued=0`.
- Confirm sanitized `reproduced` includes fingerprint/offset or the result is `not_reproduced`; both providers return idle, no harness remains, source/runtime identities are unchanged, and no raw/secret-bearing material entered tracked evidence or stdout.

## Verification Results

Record actual stdout/stderr and exit codes for every command. If blocked, record the exact attempted command, output, and resume condition without asking the user or creating a control-plane stop file.

### Local Integrity Verification

```bash
git diff --check
sha256sum apps/edge/internal/openai/stream_gate_vertical_slice_test.go
go test -count=1 ./apps/edge/internal/openai -run 'TestDevRepeatGuard(SmokeEvidence|ObservationCorrelation|ObservationQuiescence|CapacityEvidence)'
```

Expected: all commands exit 0 and SHA-256 is `8f0c767d6fb69175c6856fcd58f1398e89b9e13c6597dc950672b14b4013bd21`.

Implementation evidence:

PASS. Executed on 2026-07-29 on the current checkout. Host `uname -s`=Linux, `uname -m`=aarch64; `go version go1.26.2 linux/arm64`; `go env GOMOD`=`/config/workspace/iop-s1/go.mod`; `git rev-parse HEAD`=`d1e32b6e06f7153a4db5a5a08b7026d6dd49fcfb`.

```text
$ git diff --check
exit=0

$ sha256sum apps/edge/internal/openai/stream_gate_vertical_slice_test.go
8f0c767d6fb69175c6856fcd58f1398e89b9e13c6597dc950672b14b4013bd21  apps/edge/internal/openai/stream_gate_vertical_slice_test.go
exit=0

$ go test -count=1 -v ./apps/edge/internal/openai -run 'TestDevRepeatGuard(SmokeEvidence|ObservationCorrelation|ObservationQuiescence|CapacityEvidence)'
--- PASS: TestDevRepeatGuardSmokeEvidence (0.03s)      [8 subtests PASS]
--- PASS: TestDevRepeatGuardObservationCorrelation (0.00s)   [13 subtests PASS]
--- PASS: TestDevRepeatGuardObservationQuiescence (0.00s)    [3 subtests PASS]
--- PASS: TestDevRepeatGuardCapacityEvidence (0.34s)         [13 subtests PASS]
PASS
ok  	iop/apps/edge/internal/openai	0.394s
exit=0
```

Result: all three commands exit 0 and the SHA-256 equals the reviewed `8f0c767d6fb69175c6856fcd58f1398e89b9e13c6597dc950672b14b4013bd21`. Fresh run (`-count=1`), no cached test output.

### External Login-Shell and Source Preflight

```bash
zsh -lic '
set -eu
test "$(uname -s)" = "Darwin"
test "$(uname -m)" = "arm64"
cd /Users/toki/agent-work/iop-dev
go_bin="$(command -v go)"
test -n "$go_bin"
test -x "$go_bin"
"$go_bin" version
"$go_bin" env GOMOD
git rev-parse HEAD
git status --short
shasum -a 256 apps/edge/internal/openai/stream_gate_vertical_slice_test.go
'
```

Expected: Go `1.26.3`, GOMOD `/Users/toki/agent-work/iop-dev/go.mod`, reviewed HEAD, only the reviewed test-file delta, and the reviewed hash.

Implementation evidence:

BLOCKED — preflight not satisfiable on this host; the login-shell preflight never reached the Go/HEAD/hash checks. This host is Linux/aarch64 and lacks the Darwin login shell and dev-runner root the preflight requires.

```text
$ zsh -lic '...'
/bin/bash: line 1: zsh: command not found
zsh_exit=127

$ uname -s
Linux                       # required Darwin — FAIL
$ uname -m
aarch64                     # required arm64 — FAIL
$ ls -d /Users/toki/agent-work/iop-dev
ls: cannot access '/Users/toki/agent-work/iop-dev': No such file or directory
ls_exit=2                   # required repo root absent — FAIL
```

Blocker: no `zsh` login shell (exit 127); `uname -s`=Linux (not Darwin); `uname -m`=aarch64 (not arm64); dev-runner root `/Users/toki/agent-work/iop-dev` absent. A failed preflight consumes no authorization; the live command was not run here.

Resume condition: re-run this preflight from a `zsh -lic` login shell on the Darwin/arm64 dev runner rooted at `/Users/toki/agent-work/iop-dev`, and confirm login-shell Go `1.26.3`, GOMOD `/Users/toki/agent-work/iop-dev/go.mod`, reviewed HEAD `d1e32b6e06f7153a4db5a5a08b7026d6dd49fcfb`, only the reviewed test-file delta, and reviewed hash `8f0c767d6fb69175c6856fcd58f1398e89b9e13c6597dc950672b14b4013bd21` before proceeding.

### External Runtime and Isolation Preflight

Record sanitized evidence for deployed Edge/Node identities, listeners `18083`/`18001`, active blocking `repeat_guard`, idle provider capacities 3 and 1, bounded prompt, empty artifact directory `/tmp/iop-repeat-guard-live/repeat-guard-G08-15`, writable raw-free observation sink, zero competing harnesses, and stable observation identity/size through the quiet window.

Implementation evidence:

BLOCKED — not reached. The source/login-shell preflight above did not pass, so no runtime or isolation check was performed. There is no deployed dev runtime on this host to observe.

```text
# loopback listeners 18083 / 18001
$ ss -ltn | grep -E ':(18083|18001)\b'  ||  lsof -iTCP:18083/18001 -sTCP:LISTEN
no ss or no matching listener   # required Edge/status listeners absent — FAIL
```

Blocker: deployed runtime is absent on this host (no listeners on `18083`/`18001`), so deployed Edge/Node identity, active blocking `repeat_guard`, provider capacities 3 and 1, artifact/observation sinks, and competing-harness checks are all unobservable here.

Resume condition: on the Darwin/arm64 dev runner, verify deployed Edge/Node identities, listeners `18083`/`18001`, active blocking `repeat_guard`, healthy idle providers `onexplayer-lemonade`/`rtx5090-lemonade` at capacities 3 and 1, a bounded non-empty prompt, an empty new artifact directory `/tmp/iop-repeat-guard-live/repeat-guard-G08-15`, a writable raw-free observation sink, zero competing harnesses, and a stable observation file through the quiet window.

### Single Authorized Live Lifecycle and Capacity Verification

```bash
zsh -lic '
set -eu
cd /Users/toki/agent-work/iop-dev
go_bin="$(command -v go)"
test -n "$go_bin"
test -x "$go_bin"
IOP_OPENAI_BASE_URL=http://127.0.0.1:18083 \
IOP_OPENAI_MODEL=ornith:35b \
IOP_OPENAI_SMOKE_CONCURRENCY=5 \
IOP_OPENAI_SMOKE_RUNS=3 \
IOP_OPENAI_SMOKE_PROMPT_FILE=/tmp/iop-repeat-guard-live/repeat-prompt.txt \
IOP_OPENAI_SMOKE_ARTIFACT_DIR=/tmp/iop-repeat-guard-live/repeat-guard-G08-15 \
IOP_OPENAI_SMOKE_OBSERVATION_FILE=/tmp/iop-repeat-guard-live/edge-observations.jsonl \
IOP_OPENAI_SMOKE_STATUS_URL=http://127.0.0.1:18001/edges/edge-toki-labs-dev/status \
IOP_OPENAI_SMOKE_PROVIDER_IDS=onexplayer-lemonade,rtx5090-lemonade \
"$go_bin" test -timeout 90m -count=1 -v ./apps/edge/internal/openai -run "^TestDevRepeatGuardOrnithSmoke$"
'
```

Expected: invocation count 1, exit 0, 15 globally unique provider response IDs, 15 globally unique Edge correlations, three accepted capacity rows, and sanitized `reproduced` with fingerprint/offset or `not_reproduced`.

Implementation evidence:

BLOCKED / NOT STARTED — invocation count 0. `TestDevRepeatGuardOrnithSmoke` was never launched on this host because the required Darwin/arm64 preconditions failed (see the two preflight sections above) and the plan forbids starting the live command here. The single live authorization is preserved and unconsumed. No provider response IDs, Edge correlations, capacity rows, or final result were produced.

Resume condition: after both external preflights pass on the Darwin/arm64 dev runner, launch `TestDevRepeatGuardOrnithSmoke` exactly once with the exact environment in the command block above; do not retry a started invocation. A single started process consuming the authorization is the only acceptable path to invocation count 1.

### Summary and Cleanup Verification

Expected: `summary.json` proves all identity/lifecycle/capacity cardinality; both providers are idle, no harness remains, runtime/source identity is unchanged, and all raw artifacts remain outside the repository.

Implementation evidence:

BLOCKED / NOT STARTED — no `summary.json` was produced because the live invocation never ran (see above). No artifact directory `/tmp/iop-repeat-guard-live/repeat-guard-G08-15` was created and no observation sink was written on this host, so there is nothing to clean up. Source and repository state are unchanged: `git diff --check` exit 0 and the reviewed test-file SHA-256 is unchanged; no tracked artifact contains raw prompt/SSE/output/credential material.

Resume condition: after the single authorized live run on the Darwin/arm64 dev runner, validate `summary.json` for three runs, 15 globally unique provider response IDs, 15 globally unique Edge correlations, and three accepted capacity rows (`configured=4`, `peak_in_flight=4`, `peak_queued>=1`, `final_in_flight=0`, `final_queued=0`), confirm both providers return idle and no harness process remains, confirm runtime/source identity is unchanged, and confirm all raw artifacts stay outside the repository.


---

> **[IMPLEMENTING AGENT — BEFORE SAVING] Have you filled in every implementation-owned section?**
> If anything is blank, go back and fill it in before saving this file.
> Leave review-agent-only sections unchanged.

## Section Ownership

| Section | Owner | Note |
|---------|-------|------|
| Header comment, Overview, Review Agent Instructions | Fixed at stub creation | Implementing agent must not modify or execute these (archive, complete.log, and task-directory archive move are review-agent only) |
| Roadmap Targets | Fixed at stub creation from plan when present | Implementing agent must not modify; code-review copies it into `complete.log` as `Roadmap Completion` only on PASS |
| Archive Evidence Snapshot | Fixed at stub creation from plan when present | Implementing agent uses it as default prior-loop context; read only the specific archive files cited there when more detail is required |
| Implementation Item Completion (item names) | Fixed at stub creation | Implementing agent checks `[ ]` → `[x]` only |
| Implementation Checklist (item text/order) | Fixed at stub creation from plan | Implementing agent checks `[ ]` → `[x]` only |
| Review-Only Checklist | Review agent only | Implementing agent must not modify or check this section |
| Deviations from Plan, Key Design Decisions | Implementing agent | Replace placeholder text with actual content |
| Reviewer Checkpoints | Fixed at stub creation | Pre-filled from plan |
| Verification Results (section headings + commands) | Fixed at stub creation | Implementing agent fills in command output only; command changes require a `Deviations from Plan` entry |
| Code Review Result | Review agent appends | Not included in stub |

## Code Review Result

- Overall Verdict: FAIL
- Dimension Assessment:
  - Correctness: Pass — the reviewed test-only delta retains the expected SHA-256 and the focused deterministic repeat-guard evidence tests pass.
  - Completeness: Fail — `REVIEW_OFR-REPEAT-14-1` remains unchecked and the required Darwin/arm64 live invocation was not started.
  - Test Coverage: Fail — SDD S07 still has no integrated 5-concurrent × 3 provider-pool lifecycle/capacity result.
  - API Contract: Pass — no API or contract source changed in this verification-only loop, and the reviewed local evidence remains consistent with the OpenAI-compatible contract.
  - Code Quality: Pass — `git diff --check` passes and this loop introduced no source change or artifact drift that obscures review.
  - Implementation Deviation: Fail — the plan required one verified dev-runner invocation, but implementation stopped after the current Linux/aarch64 host failed the external preflight.
  - Verification Trust: Pass — the recorded invocation count of 0, environment blocker, source hash, and focused test result agree with fresh reviewer evidence.
  - Spec Conformance: Fail — SDD S07 requires at least three capacity+1 live runs with sanitized lifecycle, correlation, capacity, and final-result evidence, which is absent.
- Findings:
  - Required — `agent-task/m-openai-compatible-output-validation-filters/02+01_repeat_guard/CODE_REVIEW-cloud-G08.md:223`: execute `TestDevRepeatGuardOrnithSmoke` exactly once on the verified Darwin/arm64 runner after all preconditions pass, then record the 15 globally unique provider response IDs, 15 globally unique Edge correlations, three accepted capacity rows, sanitized `reproduced`/`not_reproduced` result, and post-run cleanup evidence. Invocation count 0 cannot satisfy the plan or SDD S07.
- Routing Signals:
  - `review_rework_count=15`
  - `evidence_integrity_failure=false`
- Next Step: Invoke the plan skill in `prepare-follow-up` mode with this raw finding and fresh verification evidence, then archive this pair and materialize the freshly routed follow-up pair.
