Before any agent touches the codebase, we gather everything that exists about the system. Documentation if it exists. API specs. Database schemas. Architecture notes. If nothing exists — which is common — A-00 scans the system itself and builds the brief from what it finds. The brief tells every agent what the system is, what workflows it handles, what external systems it connects to, and what the team already knows. It is the difference between discovering a system blind and arriving with a mental map.

A-01 reads the mission brief and then traces every workflow from its server-side entry point — a route handler, a scheduled job, a queue consumer — through the call stack to its terminus. A DB write. An external API call. A response returned. The output is an ASCII trace: human readable, plain, permanent. Flow and I/O. Nothing else. A new developer can read it and immediately know what that process does.

A-02 reads the same workflows A-01 traced and finds where the user touches each one. It traces every screen, every input, every transition — and draws them as ASCII wireframes. Not design mockups. Not component diagrams. Simple screen layouts that show what the user sees, what they fill in, and what moves them forward. Screen by screen. Transition by transition. A matched pair to the server trace.

A-03 holds the server trace and the UI trace side by side for each workflow and asks one question: what was this actually trying to accomplish? Not what the code does. Not what the screen looks like. The intent. The output is a spec — plain language, structured, stack-agnostic. Intent, inputs, business rules, outputs, boundaries. This is the document the original system never had. It is what A-04 reads to choose the stack and what A-05 reads to build.

A-04 reads all the specs together and identifies what class of system this is. Then it matches the requirements against proven modern tools — not the newest, not the most fashionable, the most appropriate. Existing systems that work are retained. Standard problems get standard solutions. Custom elements — the logic that is genuinely unique — are flagged explicitly before build begins so they get deliberate attention rather than guesswork.

A-05 builds in six passes. Pass 1: the UI shell — every screen rendered, every transition wired, server calls stubbed. You navigate the whole system before a database exists. Pass 2: the API layer — real endpoints, real business rules, stub data. Pass 3: the data layer — real queries, real schema. Pass 4: external integrations — Stripe, SendGrid, whatever the spec named. Pass 5: background processes — jobs, queues, scheduled tasks. Pass 6: the test suite — unit tests for every function, integration tests for every workflow, generated from the specs. Human sign-off between every pass. Nothing proceeds without it.

A-06 runs four stages against every workflow. Stage 1: unit tests — every business rule from every spec has a corresponding passing test. Stage 2: integration tests — every workflow traced end to end with real data. Stage 3: Playwright — every screen renders, every transition fires, every input behaves. Stage 4: system tests — load testing, edge cases, behavioral equivalence to the original system. Binary outcome per workflow: certified or returned to A-05 with a precise gap report naming the exact rule, the exact failure, and the exact pass to fix it. The certification document is the evidence that everything was found and nothing was lost.