The bridge that selects what feeds the validator — audited by the validator

The claim, stated narrowly

AI Design Blueprint's `architect.validate` tool grades agentic code against the 10-principle doctrine. The cohort-bridge orchestrator is the code that converts an applicant's public GitHub repository into validate-compatible input. That orchestrator was submitted to the validator it serves, fourteen times in one evening — first-pass validate plus second-pass cert review on the final iteration.

Layer 1: validator scores its own source (cert-confirmed self-audit, 13 prior rounds). Layer 2: validator scores a governed agent (canary baseline 100/A clean, 18/F injected). Layer 3: validator scores the bridge that selects what to feed it — this case study. Three layers, each auditing the layer below, each with public receipts.

Cert-confirmed receipt

Iter14 second-pass cert summary, verbatim from the persisted review:

CERT CONFIRMED

The first-pass production_ready verdict is confirmed: the code shows durable job states, explicit terminal/blocked/aborted handling, retry paths, and no specific missed defect that would currently cause a real user silent wrong results, crash, or trust-boundary bypass.

What the trajectory reveals

Score-as-snapshot misses the iteration story. The bridge hit production_ready three times (iter8, iter9, iter10) before iter11 regressed to emerging on identical code — a single LLM-variance event that promoted P10 from hardening_recommended to production_blocker. The fix path then required four more iterations: durable steering primitives (iter12), step-aware recovery + terminal-status guards (iter13), and the post-validate abort re-check that closed P10 definitively (iter14).

The cert reviewer's iter10 downgrade caught a real bug — but in the submission discipline, not the underlying code. The excerpt sent to validate was missing `from app.db.session import Base`. The actual repo file always had it. The cert reviewer's verdict prose said so explicitly. Iter11 restored the import; the regression that immediately followed was the variance event, not a code change.

The doctrine the validator applies is the same doctrine that runs inside Claude Code via MCP. Every recommendation in every iteration is mechanism-specific (named identifiers, named files, named race conditions). None are template-generic. The iter14 cert summary names which terminal states and retry paths confirm the verdict.

Verbatim from iter2 — the P7 finding the iter1 review hadn't reached

DRAFT

The audit envelope is a substantial improvement: `audit_object` records `schema_version`, `captured_at`, source `repo_url`/`commit_sha`, selected file hashes, skipped reads, `bundle_sha256`, validator latency, and shape-only log signals. However, the bridge still constructs the validator payload by concatenating raw untrusted repo content in `_build_implementation_context()` via `chunks.append(f"# === FILE: {path} ===\n{content}\n")` and then sends it as `ValidationRequest(code=bundle, ...)`. This file does not establish or record an inert untrusted-input boundary, so repo comments or filenames containing instruction-like text could steer the validator unless a hidden downstream service compensates.

Verbatim from iter14 — P10 steering, finally aligned

CERT CONFIRMED

Steering primitives are now present for both validation and onboarding recovery. `request_abort()` persists `abort_requested=True`; `_execute_with_job()` checks for abort before validation and, in the Iter14 change, refreshes the job and re-checks `job.abort_requested` immediately after `asyncio.run(validate_code_against_principles(...))` returns and before creating `UserValidationRun` or calling `mark_completed()`, discarding validator output on abort. `retry_failed_validation_job()` requires the latest job to be terminal and `retry_eligible`, while `retry_onboarding_handoff()` preserves the failed state (`firebase_user_failed`, `sign_in_link_failed`, or `approval_email_failed`) and clears only `onboarding_failure_reason`, allowing `approve()` to re-enter step-aware recovery.

What the bridge is now

An end-to-end orchestration surface that converts an arbitrary public GitHub repository into a validator-compatible bundle, with durable workflow state, typed file-envelope boundaries, step-aware operator recovery, post-validate abort honoring, and a cert-confirmed production_ready badge that any reader can verify by re-fetching the run_id. The first 10 cohort applicants this week will be onboarded through this code.

Three case studies, three facets

This is the self-validation facet of the recursive-integrity triad. The other two facets are public: the substrate-validation scan on Anthropic's own agent-SDK demo code, and the reference-honesty scan on our own A2A protocol example. Same doctrine, three code surfaces, three different verdicts.

Receipts

Every claim above is replayable from the public run URLs. The 10-principle doctrine fingerprint stayed constant across all fourteen iterations (validator confirmed `same_doctrine` on every baseline comparison). No mid-stream rule changes; the same rubric scored every run.