I direct and release every change. Coding agents build it inside a workflow I designed.

A script checks that every skill package, stored as a link, resolves. The runbook's reason: a stale brief is recoverable, but a quietly broken skill bundle invalidates the audit itself. Added after a 47-day silent degradation nobody noticed.

The coordinator pulls the latest official Solana development skill from the Solana Foundation's public repository. Network failure or a partial download warns and continues.

The recovery files on disk are compared with the archive. Clean: proceed. Stale after an archive: pause and ask me. In flight: hard stop until I choose resume, archive or abandon. It exists because a research brief for task A was once used to audit the plan for task B.

The work is classified: analytics, trading engine, on-chain program, both Solana codebases, workflow hardening. This one label later decides which test harness fires, which expert skills are injected and whether the money-path gates apply. The current commit ID is pinned so a later gate can detect the code moving underneath the audit.

The coordinator reads the navigation index, finds the matching entry, follows it into the 19,514-line architecture map, and then reads the actual source files it names. No production query is allowed yet.

An architecture-understanding block must be written, including what a healthy state looks like for this subsystem. “Do not proceed if any box is unchecked.” Navigation and server commands may not run in parallel.

Live processes, configuration flags, recent critical errors and a row count from the production database are read and saved as the system state for the run.

A headless browser captures a screenshot, the JavaScript error count and the list of API calls. The after-picture at the end of the run is compared with this.

The complexity assessment and recommended route are shown in plain and technical language, then the run stops. If the task auto-escalated for security reasons, such as keys, wallets or fund movement, the downgrade option is withheld: the complex route is mandatory.

A script re-exports the production database schema and the recent error log so that planning happens against today's reality.

A researcher agent maps affected files, callers, consumers, data sources and user-facing paths, reading vendor documentation from the vendors' own live documentation servers first. The coordinator validates every finding against local knowledge and records what was accepted and what was rejected. Mandatory for every moderate and complex task.

A hard gate: if the research brief is missing or empty, stop.

A validator agent re-reads every claim in the brief against the code. A failure re-runs the researcher. The reason, in the runbook: a brief once said a function had 18 signals; reality was 9 stale ones; nobody verified; three hours and forty-five minutes and a full revert were lost.

The brief must contain a feature impact map with explicit full or partial coverage flags, so a change cannot fan out into consumers nobody listed.

A script decides whether the change touches the boundary between the operator's own view and any other account view. If it does, the brief must classify every changed path, and the canonical separation contract governs.

The coordinator queries production for an actual sample of every data source the task touches. Hard gate on mismatch. The incident: a dashboard showed three of five signals; reality was zero of thirteen; nobody had queried production before planning.

Complex work, a database migration, a new value written into a shared column, or a new background loop each require a data-flow trace at plan time. Written after run 37 shipped two catastrophic data-loss bugs that all four internal reviewers missed and only the external reviewer caught.

A planner agent is told it is not executing the research brief blindly: it must independently re-read navigation, architecture and source. The plan includes tests, rollback, dependencies and a mandatory section naming the skills it used, with the file and lines actually opened.

Completeness, pattern adherence, scope, integration, skills, and whether every database table the plan names was actually verified by the research. The reason: run 42's plan named five tables that did not exist and three same-lineage reviewers approved it.

A script extracts every table, column, route, file path and environment variable in the plan's code blocks and checks each exists, with batched database queries and file tests. Deliberately not an AI. Complex runs only.

Existing patterns, SDK rules, cross-system contracts, database integration and explicit preservation of existing features are checked and scored.

Major issues go back to the planner with its memory intact. A reject verdict first sends the researcher back for missing ground truth. Audit-driven revision rounds later in the run are recorded by name; the deepest recorded is nine.

A plan auditor and an architecture reviewer (Claude, maximum effort on complex runs), an OpenAI Codex lane and an xAI Grok lane through their wrappers, the coordinator's own verdict, and a cross-validator when dependencies or documentation servers change. Grok is explicitly non-blocking while it earns its place.

No verdict until at least three of the four lanes have returned. A reviewer that omits the mandatory harness-patterns section is re-spawned once, then excluded from quorum; if quorum drops, the run blocks and asks me.

When a trace is required, the architecture reviewer's trace is extracted between explicit markers and checked: non-empty, exactly five sections, no placeholder text.

A mandatory to-do item: independently validate every plan-audit finding by reading the code and verifying the claim before acting on it.

Each repository's commit ID is recorded before implementation. It is never re-stamped on a resume or a fix round, so the diff the external reviewer later sees is cumulative.

The coding agent's model and turn budget come from a tier matrix; blockchain work always gets the strongest tier. The implementer follows the plan exactly and adds nothing; if the code differs from the plan's assumptions it stops and the plan is revised rather than the scope silently expanded. It must return a skills-applied section naming the specific rule used per skill. If it runs out of turns it hands over to a continuation implementer, at most three deep.

If the implementer's report is missing or older than the plan, which happens when the coordinator applies fix-round edits itself, either a fresh implementer is spawned or a sentinel with per-skill file-and-line citations is written. Neither: the scoring pass must mark the skills checkpoints as failed, not as unverified.

The recorded diff is checked for every file the implementer claims to have changed. The tenant-separation flag is re-affirmed from the real diff. The last three runs' recurring bugs are grepped for.

The incident: a helper referenced a column that did not exist and 17 review rounds approved the code.

The incident: a value was loaded from the database and never wired to the page; 17 review rounds approved; the user saw blank rows.

A code auditor, the architecture reviewer, OpenAI Codex and xAI Grok in parallel; on traced runs a data-flow tracer joins, with fresh eyes: it does not read the plan-phase findings. Same quorum rule.

Each reviewer's numeric trace is extracted; line numbers are checked to exist; values are checked against the live database; expected values must have a real source. Then the coordinator performs its own independent trace and cross-checks the reviewers against each other. Explicit anti-gaming measures; hard gates prevent a pass.

The fix itself is re-audited, by a different lane than the one that found the problem.

On blockchain runs the code and security reviewers must table every individual rule of the injected skills with a code location and a verdict. Any unmapped or violated row forbids approval. The incident: code shipped with an unchecked token freeze authority while the security report claimed to have applied the very skill section that forbids it.

Write-and-time code is dry-run against the real database. New read helpers are run against a known canary entity. A zero-row mismatch or a missing canary on a complex run blocks.

A test runner must produce a transcript keyed to the run. The gate then re-extracts the cited test bodies from disk, cross-checks pass counts against the framework's own totals, and hashes the raw log against the archive. Missing transcript, count drift, empty proofs or zero entry-point coverage all block. The comment trail shows this gate re-hardened a dozen times against ways a forged transcript could slip through.

A non-trivial assertion and proof of reachability with no early exit. The incident: four patterns were flipped to satisfied by editing a count; one cited test asserted that true is true, fourteen others exited before reaching the code they claimed to test.

If the repository has moved since the commit pinned at step 1.5, the findings may be stale and the run blocks. Then a recommendation: security-relevant work spawns a security auditor that itself spawns three sub-auditors, blinded to its own findings to prevent anchoring. I always have the final say.

The origin: run 37's rollback bug would have wiped 22,102 production records and was caught only by the operator's external reviewer, while all four internal lanes approved. The money-path trigger became unconditional after 15 consecutive runs in which the external round caught what the internal panel missed.

The in-scope state is committed and its commit ID recorded. The brief builder refuses to render from dirty files. It pulls plan, brief, trace, changed files, implementer output and navigation ranges, and replaces every server address, private network address, database identifier, key path and dashboard credential with redaction tokens before writing, stamping a receipt of how many replacements it made.

The default channel preserves full process independence: I paste the brief into a separate OpenAI Codex session and paste the verdict back. A fallback where the coordinator spawns the external model itself is labelled reduced independence and can only be launched by a script that refuses to run without my verbatim authorising words, logged before spawning.

Any inline production access, unresolved template slot, wrong skill bundle for the system type, or empty navigation range blocks. If the checker script is missing, the run still blocks.

Freshness of the brief's commit, format conformance, artefact shape, degraded-round detection, then each finding validated mechanically. On money-moving work, downgrading an external critical or high finding requires a code receipt and, where traced, a runtime receipt proving the neutralising path executes. A second external auditor agreeing with the downgrade does not satisfy the gate, because that has happened and production disproved it within a day.

A reconcile gate runs once per deployed repository and blocks if a foreign or missing file appears. Then pull and restart on the servers by script, a release build for the Rust engine or an on-chain deploy for the program, and ten minutes of monitoring.

The browser is driven for real; console errors and network calls are compared with the baseline from step 3.0B. Added after a run whose 3.7-megabyte transcript contained no browser tool call at all.

For data-pipeline work, the harness cross-checks figures across pages and filter combinations. It evolves after every run.

Before I see anything, every checklist item is tagged as browser-verifiable or human-only, and the coordinator runs every automatable item itself. I get only what genuinely needs a human. Then a hard wait: the run does not advance until I report back.

Artefacts, audit files, changed files, both five-way verdict sets, an executed-versus-read ledger, gate evidence, skills evidence, external-round evidence, post-deploy issues.

A fresh agent succeeded at this one time in four across earlier runs, so the coordinator does it itself: read the changed source files, not the plan; rewrite the affected sections as current state; sync any canonical contract whose domain was touched; regenerate the navigation index from section markers; run the drift test; spot-check two or three documented flows against the code.

A hard gate that the session record exists and has content, plus a pre-archive guard for blockchain artefacts.

An archive agent creates the dated archive, copies every artefact including the raw session transcript, and writes the report with a mandatory harness-enforcement stamp. If no artefact proves the gate fired, it must write “not found”, never infer it did.

The progress review scores the run and every reviewer lane, classifies each post-deploy bug as preventable or new, records gaps with an ID, a severity and a proposed rule, and checks that every red recommendation is shipped with evidence or retired with my words quoted. Four consecutive runs once skipped this step; the skip cost weeks of drift.