ReleaseLeaf

Inspiration

A green pipeline can be reassuring until you discover that it belongs to an older commit. ReleaseLeaf helps an individual builder see which release facts belong to the exact candidate and which still need evidence. The calm interface presents a small set of checks and clear next steps.

What it does

ReleaseLeaf combines a private GitLab Duo custom reviewer with a deterministic Node.js checker and a public GitLab evidence verifier. It reviews the work after coding: candidate identity, completed CI jobs, test results, file inventory, setup notes, MIT license markers and limited scan coverage. Missing evidence stays unknown; a mismatched pipeline blocks review. Its reports are drafts for a person. It cannot publish, merge or deploy an application.

GitLab Duo Agent Platform: Path A / Assisted

This original project started on October 13, 2026. The custom agent, ReleaseLeaf reviewer, is enabled in the officially provisioned contest project. Its configuration is included as agent-config.json and AGENT-PROMPT.txt; the JSON is a manual reproduction reference, not an executable import schema. The private hosted agent requires project membership. Others can reproduce its prompt and tools in their own eligible project.

The agent has read tools for project, commit, repository files, pipeline, jobs, artifacts and logs, plus CI linting. No write, merge, deployment, issue-creation or publishing tools are enabled. It treats repository content and logs as untrusted data and receives a go-ahead between read stages. The owner explicitly approved the invoking-user project-read scope; the coding assistant operated the bounded evaluation on this public project. A human remains responsible for the release decision.

In actual GitLab Duo Chat session 9449203, the agent retrieved the exact commit, README, LICENSE, CI configuration, completed pipeline, jobs, TAP file and evidence artifacts. It confirmed 15 passing tests, zero failed or skipped, noticed stale documentation, and correctly retained unknown for hash computations its read tools could not perform. It did not invent a successful release or silently replace missing proof with confidence.

Independent evidence verification

The Node verifier reads the public GitLab.com HTTPS API without credentials. It matches a completed successful pipeline and both required jobs to the exact candidate. It retrieves the evidence artifact, then independently downloads five committed source files and computes their SHA256 hashes and byte counts. An artifact cannot provide its own trusted expected manifest. The prototype compares committed static assets; a transformed build would need a separately trusted build manifest.

Requests are bounded by count, size and time, with no redirects or retries. The local collector scans only its five allowlisted files. This is a limited pattern scan, not a comprehensive security audit.

Actual validation

• Reference candidate 82d6570373acf6e45327791bb4de8b04a9788cc3: successful pipeline 2946611771, real Duo review and separate independent source-hash verification.
• After correcting the documentation and synchronizing the agent configuration, candidate e2a5981b743b326f0d4a3c6317af4610c70347f0 passed pipeline 2946725286 and independent verification: seven checks passed, ready-for-human-review.
• A separate real API check paired the reference pipeline with an older commit and correctly returned PIPELINE_COMMIT_MISMATCH. This was a Node verifier check, not a Duo evaluation.
• Fifteen injected tests cover the core and GitLab adapter, including stale commits, inconsistent tests, unsafe paths, artifact mismatches, foreign jobs, malformed responses and rate limits. Injected tests are distinguished from live service checks. Failed-job scenarios are not claimed as live Duo evaluations.

These recorded results apply to their named commits. Later candidates require fresh matching evidence. Passing tests do not establish test adequacy or replace a person's setup and security review.

October 15 improvement: one-screen live review

Version 0.3 adds a guarded loopback HTTP server and a browser form for the existing verifier. It uses public GET requests only, requires no token, and does not invoke Duo or consume AI credits. Candidate 83ceddec7baf9c84ebe36bdc677e5e94b05e9def passed pipeline 2952382214: 19 tests and the evidence collector. The real Chrome -> local server -> GitLab flow returned seven passing checks for that candidate. The older reference was correctly marked as needing fresh evidence, and a mismatched SHA was blocked. Four new HTTP tests cover the form route, input/origin limits, sanitized errors, cancellation and concurrent requests; their injected verifier is not presented as a live GitLab test. This new API verification is separate from the recorded October 14 Duo session and original video.

Challenges and learning

The main challenge was separating a claim from evidence. A job that redirects TAP output can succeed without putting the actual test totals in its log. A collector running inside a pipeline cannot attest that pipeline's eventual status. File text returned to an agent is not automatically an independently computed byte hash. ReleaseLeaf handles these boundaries explicitly and keeps unresolved work visible.

How to try it

The public MIT GitLab repository contains all original application code, the CI configuration, agent prompt, tool configuration and reproduction runbook. Node.js 22.19+ is required; the local checker and public verifier need no npm dependencies, account token, paid plan or card. Follow the README to run tests, collect local evidence, and verify a completed public pipeline. Run node server.mjs and open http://127.0.0.1:8840/. The Polish interface now lets a reviewer enter the project ID, completed pipeline ID and full candidate SHA, then invoke the independent public GitLab verifier directly. Editing the target clears the old result and cancels any pending request. Uploaded JSON remains explicitly untrusted user-supplied evidence.

The 2:22 English demo includes a real moving capture of pipeline 2946826626 running both CI jobs, followed by genuine captures of the earlier completed Duo reference review. CI playback at 2x speed, shortened pauses, a held final frame and synthetic English narration are explicitly labelled. The earlier Duo review is not presented as a new live response. Implementation and materials were developed with substantial AI coding assistance; the participant selected the calm direction, configured participant access and approved consequential actions.

What's next

Broaden meaningful checks and make the assisted review easier to reproduce, while keeping unknowns visible and release decisions with a person.

Built With

• css3
• gitlab
• gitlab-duo
• html5
• javascript
• node.js
• sha256