Building a JSON query language,end to end.

The run committed to a concrete contract up front: values (numbers, strings, booleans, null, arrays, objects), path access in both .users[0].name and data["key"] forms, operators with full precedence, and seven built-ins including higher-order map / filter with lambdas.

Diagnostics are part of the contract, not an afterthought: lexical, parse, and runtime errors all carry one-based line/column positions — division by zero or an out-of-range index points at the failing operator, not just at the expression.

The full grammar, type and coercion rules live in docs/SPEC.md in the repository.

A working Go interpreter (Go 1.22+, MIT-licensed): lexer, precedence-aware parser, evaluator, file mode (rq '.users[0].name' data.json) and a recoverable interactive REPL.

It builds with a single go build and the suite is green: 23 top-level test functions, 60 named test cases. Verification scripts (scripts/verify.sh / verify.ps1) reproduce the checks in one command, and CI runs them on every push.

Three managed agents built the artifact: beta (implementer / strategic lead), epsilon (reviewer / verifier), zeta (integrator / reviewer). The autonomous history is 13 commits ending at e73d2b6: six integrated product increments, six merges, five published agent branches, with commit authorship carrying the agent identity.

The claim boundary is explicit. During live rounds the operator made zero product-code edits — operator actions were seeding, starting, observing, stopping, and repairing the runtime contour between rounds. After the autonomous boundary, a disclosed operator pass added behavior-contract tests and packaging; those commits are labeled as such in the history and are not presented as autonomous output.

The artifact span was 13 h 22 m of repository time — including stopped and resumed rounds, not one continuous session. The supported claim is product-code autonomy within live rounds, not end-to-end operational autonomy. Machine-readable details: evidence/run-summary.json.

Inside the run, review was independent of authorship: epsilon accepted the acceptance and parser lanes, zeta reviewed and integrated later ones, and every integration left a receipt. When evaluator work crossed a branch boundary, it was routed through side-effect classification rather than silently merged — and when the runtime produced a coordination defect, the round was stopped, repaired, and resumed rather than papered over.

The repository history also contains three genuine red→green defect episodes — bare-root identifier access, missing positions on runtime errors, and --help exiting non-zero. Each exists as a failing-test commit followed by a fix commit. These were found by the operator's post-run publication verifier, not by the run's own verifier agents — the report labels them accordingly. Full episodes: docs/RUN_REPORT.md.

Structural metrics are published and derivable from the public history: 3 agents, a 13-commit autonomous artifact history (1 seed, 6 product commits, and 6 merge commits), 6 product increments, 5 published agent branches, 23 top-level tests / 60 named cases green, and a 13 h 22 m artifact span including stops.

Cost and token metrics are not published yet. This run predates the runtime's per-request token instrumentation, and its stopped/resumed rounds don't form one clean accounting interval — so we can't assemble cost figures to the standard we want. Rather than publish numbers we can't stand behind, we're holding token accounting until the instrumentation lands.