ἔλεγχος / elenchos
CLOUD RUN | Catalog flow 1.4.1
kill test: reading
WORKSPACE / 01

Executive Command Center

Your pipeline's green check is a claim,
not a control.

Elenchos pushes a canary through a gate you own that checks for it, so the director finds the green run that should have gone red.

Three recorded runs on the original GitHub repository

The same three arms on GitLab: before 2950216951, repaired 2950219881, clean 2950222473.

  1. Reading the recorded bundle and checking its digests.

Open the evidence

GITLAB SUPERVISED LOOP LIVE VERIFIED
CONFIRMED
Issue #2 → MR !7 → Arm 2958863173
builder-authored self-test, 31 scenarios SELF-TEST
31 / 31
12 Injection · 9 Confirm · 10 Malformed
CANARY PROOF ARMS GITLAB + GITHUB
3 + 3 ARMS
Before (Green) · Repaired (Red) · Clean
MODEL CHECK SYNTHESIS SCORED OFFLINE
16 / 20
Design B Run 1 · 14 vs 0 Rule Majority
CORPUS SCOPE & MASKS BASE-RATE FLOOR
21 / 47
Narrow scope · 18 / 120 static masks
DEVSECOPS PIPELINE ENFORCING
5 STAGES
7 Jobs · allow_failure: false
PLATFORM WORKSPACE LAUNCHPAD · DEDICATED MODULE VIEWS
8 DEDICATED WORKSPACES ZERO-SCROLL CONSOLE ARCHITECTURE
02 5-Layer Agent Harness Runtime (builder-authored self-test, 31 scenarios) SELF-TEST

Inspect L1 8 KiB context isolation, L2 Tier 0/1 pre-tool governance, L3 SHA-256 verification, L4 TurnBudget(20), and run the builder-authored self-test, 31 scenarios.

03 CI Synthesizer & Auto-Remediation DIFF + SAST JSON

Audit custom .gitlab-ci.yml files, auto-remediate allow_failure: true, piped masks, and upstream templates, and emit GitLab SAST v15.0.7 reports.

05 4-Stage Simulator & Live GitLab Scan LIVE FORGE API

Replay the 4-stage pipeline reader, scan pasted workflows locally, or audit and auto-remediate any public GitLab.com project ref live.

06 200-Repository Estate Matrix NIS2 ART. 21 & 32

Filter real-world third-party findings and the 200-repository engineering lead triage queue across GitHub Actions, GitLab CI, and Azure DevOps.

1. SYSTEM TRIGGER A project pipeline-passed trigger started the recorded loop. The configured trigger (3050395) filters for successful pipelines and runs the flow as its service account when enabled. It is paused during the submission freeze.
2. DUO AGENT LOOP (2026-10-14..15) Recorded loop (before 2026-10-18, before the harness was added): filed Issue #2 (2026-10-14); on 2026-10-15 (2950197588 → flow 2950211507) ran 3-arm proof (2950216951, 2950219881, 2950222473) & opened MR !7. Opened by the flow's service account (project activity, 2026-10-15 09:41:27 UTC). Its commit cd7b5229 is authored by Elenchos; the maintainer rebased it before merging. GitLab lists the maintainer as author.
3. HUMAN APPROVAL (2026-10-16) Engineering Lead reviewed the single-line diff and merged MR !7 on 2026-10-16 (a58762a0; flow run 2954734016 did not produce the confirm).
4. DUO AGENT CONFIRM (2026-10-17) On 2026-10-17 on main at 733d12cc, pipeline 2958855350 fired flow 2958861516 & confirm arm 2958863173, posting CONFIRMED_ENFORCING on !7 and #2.

On GitLab, the public GitLab showcase repository ships .gitlab/duo/flows/elenchos.yaml (catalog version 1.4.1, published 2026-10-18, Duo platform default model, not pinned by the flow) and scripts/duo_loop.py, backed by the live Google Cloud Run service. A Pipeline events (Passed) trigger started the flow on every passed pipeline from 2026-10-14 until this entry was frozen. Recorded loop, 2026-10-14 to 2026-10-17: it ran on flow definitions published before 2026-10-18, before the harness was added. Issue #2 was filed on 2026-10-14. On 2026-10-15 (2950197588 → flow run 2950211507) the flow's agent steps ran scripts/duo_loop.py, which pushed the three arms (2950216951, 2950219881, and 2950222473); the reporter step opened MR !7. Opened by the flow's service account (project activity, 2026-10-15 09:41:27 UTC). Its commit cd7b5229 is authored by Elenchos; the maintainer rebased it before merging. GitLab lists the maintainer as author. MR !7 was merged on 2026-10-16 (a58762a0; flow run 2954734016 after the merge did not produce the confirm). The confirm ran on 2026-10-17 on main at 733d12cc, after two router fixes: main pipeline 2958855350 (started through the API), flow run 2958861516, confirm arm 2958863173 (CONFIRMED_ENFORCING). Current definition: catalog version 1.4.1, published 2026-10-18. Until this entry was frozen it fired on passed pipelines and made no changes, because nothing was left to prove.

What the director sees on every pull request Committed report + Live GitLab MR !7

Elenchos is a GitHub Action and GitLab Duo Agent Platform gate: added to a pull request or merge request workflow, it reads the pipeline against the policy from the base commit, and writes its finding into the run's job summary. Below is that report on this repository, committed, beside the install. Anything unassessed collapses into one line, never clean.

GitLab Duo Agent Platform Merge Request Governance (Project 87516596 · Issue #2 → MR !7)
Before (4991f8e6)1 Mask (.gitlab-ci.yml:45)
After MR !7 (main)0 Masks (Enforcing)
Confirm ArmPipeline 2958863173
5-Layer HarnessCONFIRM -> ALLOW
Reading the committed summary...

Download this summary JSON

The install that produces it

- uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262
  with:
    fetch-depth: 0
- uses: upgradedev/elenchos@YOUR-REVIEWED-ELENCHOS-COMMIT
  with:
    policy: .elenchos-controls.json
    fail-on-finding: "false"

GitLab CI & Duo Agent Platform flow install (.gitlab-ci.yml)

elenchos-mr-governance: stage: gates allow_failure: false script: - python -m elenchos control --file .gitlab-ci.yml --policy .elenchos-controls.json --dialect gitlab artifacts: reports: sast: gl-sast-report.json

Commit a .elenchos-controls.json policy, then add those lines to a merge request or pull request workflow. elenchos policy init drafts the policy from a workflow file; a human sets each entry to blocking or reporting before elenchos control reads it.

Scripted examples, read by the real reader Read-only synthetic examples

Select a read-only workflow example and replay its scripted illustration. The presets take no input: they replay without parsing text, calling a model or executing a workflow. The historical receipt and recorded repair experiment in Receipts are separate evidence.

The four stages, replayed ASSESS never calls the model; only elenchos provision does
Ready to replay
1
1. YAML reader
Parses the file; no model
2
2. Check Synthesis
Nemotron 3 Super
3
3. Sandbox run
ConTree VM isolation · declared, not deployed
4
4. Content address
SHA-256 of the example text
Example file C mandatory CI step

            

Read-only synthetic example; no execution.

Example policy, recorded and not interpreted:
Every pull request runs at least one secret-scanning step
Scripted illustration; no model call
Scripted illustration, not a recorded model response or new execution
1. ASSESS · YAML reader Step 1
Names steps whose name promises a check and whose failure is masked.
2. PROVISION · Nemotron Synthesis Step 2
Writes the shell check that must fail on the canary and pass on clean input.
3. PROVE · sandbox execution, simulated Step 3
Runs canary in isolated VM and checks exit codes against forge response.
4. WATCH · replay over existing history Step 4
Illustrates the flow; no history is read and no proof is archived.
What the forge reported, and what the runner did Scripted example · no execution. Three recorded runs are in Receipts.
What the forge reported
✓ Workflow Status: Success
Commit: 9762a80 | Branch: canary/audit
[✓] Run security scan: Succeeded (0s)
All required checks have passed. Merge button is green.
What the runner did
Reading the reader's recorded output from playground.json.
Try pasted text Narrow static scan

Literal mask lines only: continue-on-error, continueOnError, allow_failure set to true. It misses piped masks like Preset 3 above, whose piped scan carries no literal mask line, and it never judges values it cannot read. Never a verdict; run the full command under the result for one.

Full static read: python -m elenchos assess <owner>/<repo> --file <workflow>

Scan & Auto-Remediate a Live Public GitLab.com Repository (/api/assess & /api/remediate-gitlab-ci) Live GitLab REST API + AST Reader + Auto-Patch
Ready to scan or auto-remediate public GitLab repository via Cloud Run API
Found in the wild Read only, reproducible, third party

Not our repositories and not a simulation. Each line was produced by elenchos assess, then opened in the file at the commit that was read. Run the command yourself and compare. Re-checked against the command's own output on 2026-09-26, and the FaserF row again on 2026-09-28. These repositories keep changing, so each link is pinned to the commit that was read: a re-run later may report a different line number.

📝 MarkdownLint
continue-on-error: true, so its failure cannot block the pipeline; the comment above it says that is intended, which is why the reader asks for an expectation instead of calling it broken
Audit pre-agent workspace
continue-on-error: true, on a step whose name promises an audit, in a file gh-aw generated (its line 3 says so), so the mask is the generator's output

A neighbouring step in that same file also carries continue-on-error and is deliberately not reported, because its name promises nothing. A step that makes no claim cannot exceed it, which is why the count is a floor rather than an estimate.

This card used to show the Platinum Compliance Check at orchestrator-ci.yaml:388 as a step whose failure cannot block the pipeline. That was wrong: line 419, in the same job, runs exit 1 when the compliance script fails. The reader now prints that shape as re-raised downstream and does not count it.

git clone https://gitlab.com/gitlab-ai-hackathon/transcend-october-2026/43277567/showcase.git elenchos
cd elenchos
python -m venv .venv
. .venv/bin/activate
python -m pip install -e .
elenchos estate home-assistant --limit 12 --data-mode cloud --allow-provider github --accept-egress

Needs Python 3.11 through 3.14 and git, as in the README Quickstart. On Windows, activate with .venv\Scripts\activate instead. Set GITHUB_TOKEN (or GH_TOKEN) to a token that can read public repositories before the estate command: without one GitHub can refuse the reads, and the output counts every repository it could not read separately, never as clean. The README's recorded estate output was taken with GH_TOKEN set.

What the published guidance says about a step that cannot fail, and the day it was read. Tavily fetched it on the builder's machine, through the adapter behind elenchos assess --cite. This page shows the recorded result and makes no Tavily call, so opening it spends no credit. The citation never changes a verdict: one pinned input gave the same exit code and the same 3 findings with and without it (docs/J8_TAVILY_DECISION.md).

Loading the recorded citation...

Estate view The buyer runs 200 repositories. The panel below is his situation, not our data

Illustrative repositories for an engineering lead's review queue. Static names and error masks identify candidates for an explicit-policy experiment; they do not establish enforcement or protection. Each row's line and reason is the recorded output of elenchos assess --file on a synthetic file in web/playground/estate/, which prefixes every finding with "Blocking/reporting expectation is not supplied."

200 Repositories in the buyer's hypothetical estate
44.7% Historical name/body review (21/47 repositories in lexical/corpus.json, labelled by language-model agents in one pass, no second labeller, counted by python lexical/lexical_baseline.py --counts); not an enforcement failure rate
18 / 120 Historical static mask candidates, labelled 2026-08-31, before e339796 (python lexical/lexical_baseline.py --counts); blocking intent requires review
· Kill-test result loading. See every rule the model was scored on.
Repository Name Forge Claimed Step Reader output Static Review Action
Reading the reader's recorded output from playground.json.
Run a reviewed control experiment Three recorded runs on the original GitHub repository · owned synthetic fixture

Supply an explicit blocking policy. Review a plan from an immutable commit, then require the original gate to detect the canary while staying green, the repaired gate to reject that same canary, and the clean control to pass. Missing context stays unknown.

elenchos control --file .github/workflows/canary-target.yml --policy .elenchos-controls.json
elenchos plan --repo YOUR-OWNER/YOUR-REPO --base YOUR-COMMIT-SHA --slug demo --out plan.json --data-mode cloud --allow-provider github --accept-egress
elenchos approve-plan plan.json --accept PLAN_ID --source-ref main --approval-db approvals.sqlite --grant-out grant.json
elenchos prove plan.json --accept PLAN_ID --source-ref main --approval-db approvals.sqlite --grant-file grant.json --out proof.json --data-mode cloud --allow-provider github --accept-egress
elenchos verify proof.json --online --data-mode cloud --allow-provider github --accept-egress

The plan command only reads. The approve-plan command stages a short-lived, one-use local grant for that exact plan ID; keep grant.json private, and give prove the same approvals.sqlite. The prove command consumes the grant before its first write, then creates three explicit canary branches in your authorized repository and records the run, job, step, commit and runner image. It does not merge a repair. Offline verification checks integrity only.

Setup and exact scope. This Cloud Run page displays recorded runs on owned synthetic inputs; the source repository and GitHub Pages are separate. The playground is scripted; the three-arm packet below is the current complete recorded case. The older single-canary receipt is separate.

What this control reading actually covers

The recorded static scope below keeps scanner output, expected blocking, YAML failure handling, and merge protection separate. Rulesets and permission to merge are unverified. The recorded GitHub experiment further down tests only our owned synthetic marker.

Reading the versioned scope...

Download this scope JSON

Reading recorded control evidence...

Recorded GitLab Duo Agent Platform case

On GitLab, python -m elenchos.cli prove --allow-provider gitlab and scripts/duo_loop.py ran the same three-arm canary proof on .gitlab-ci.yml in the public GitLab showcase project: original neutered arm pipeline 2950216951 (allow_failure: true stayed green on the canary), repaired arm pipeline 2950219881 (allow_failure: false failed on the same canary), and clean control arm pipeline 2950222473 (passed without the canary). Issue #2 was filed on 2026-10-14; on 2026-10-15 (2950197588 → flow run 2950211507) the reporter step opened MR !7; MR !7 was merged on 2026-10-16 (a58762a0; flow run 2954734016 did not produce the confirm); and on 2026-10-17 on main at 733d12cc, pipeline 2958855350 fired confirm workload (pipeline 2958861516), which planted confirm canary arm pipeline 2958863173 and recorded CONFIRMED_ENFORCING on both threads.

More evidence

PR review

Accessible pull request diff review

Synthetic source · local dry run

Read the change in words with exact old and new line numbers. Then stage a request-changes note for the shown head. The local confirmation refuses a changed PR, base, head, file, diff, or note and consumes its single-use grant. This browser example makes no GitHub read or write.

Download the synthetic source JSON

Reading synthetic source...

This editable field simulates a refreshed PR head; it is not fetched from GitHub.

Reading synthetic source...

Blind review

Blind-first control review

Synthetic receipts · no live PR read

The first stage reads the complete change, workflow at base and head, and maintainer policy at base. GitHub's PR identity response also carries the title and body, but the static code judgment does not use them. Author prose and commit messages enter the comparison after that finding is sealed. Reveal the second stage to see the conflict and why a green CI claim does not lower it. These SHA-shaped fixture IDs are not GitHub commits.

Download first-stage input and finding

Reading synthetic first-stage receipt...

Historical receipt
Audit receipt, content addressed and not signed SHA-256 Content-Addressed

This separate historical single-canary receipt records a human-authored check. It is content addressed, not signed and not tamper proof: a digest detects drift only against a copy the reader already holds. The complete repair experiment above binds its own source commit and three runs; neither record demonstrates a human pilot or live Sandbox execution.

Loading packaged historical receipt; no live GitHub read...
Loading the receipt...

Data notice: this page loads packaged evidence from its own site. Copy puts the recorded receipt on your clipboard; download saves a copy on your device. Neither button calls the model, Tavily, Sandbox or your forge. Delete downloaded copies in your browser or file manager. The separate CLI requires an explicit local/cloud provider policy before external calls.

MCP tool definition
Model Context Protocol (MCP) tool live · stdio · runs on your machine

The tool an MCP client calls. It is a local command, python -m elenchos.mcp, speaking newline delimited JSON-RPC over stdio: it runs on your machine and not on ours, with a YAML parser, and it makes no model call, opens no network connection and writes nothing. This card published the definition before anything answered it. Now src/elenchos/mcp/server.py answers it, and a gate fails the build if the two drift apart.


            

Where the model earns its place Recorded · scored offline

Reading the recorded kill-test results and checking each score against its exit codes.

The four stages, and where each runs What runs, and where
1. ASSESS live in the CLI, read only, no model
Deterministic reader parses workflow YAML and names the steps whose failure cannot block the pipeline. A rule text, if given, is recorded, not interpreted.
2. PROVISION scored offline on 20 rules; CLI awaits Sandbox
NVIDIA Nemotron 3 Super writes the shell check a rule needs: it must fail on the canary and pass on clean input. It does not write the canary. The 20 rules were scored with the kill test's prompt; elenchos provision now sends the same contract, has not been scored, and waits on a Sandbox that has not run.
Every rule and draw it was scored on
3. PROVE recorded on GitHub, three real runs
Proves whether the pipeline turns red or falsely stays green. The canary runs as a real commit: three recorded GitHub runs and three GitLab pipelines (2950216951, 2950219881, 2950222473). Token Factory Sandbox VM isolation is requested and not deployed, so it is drawn here as the roadmap it is.
Open the recorded case
4. WATCH live in the CLI, replay on request
Compares immutable workflow versions against one fixed explicit team policy. Reports the first static failure-mask transition in the requested window; missing policy or unreadable context stays UNKNOWN. Runtime enforcement is untested. No daemon; author attribution is opt-in.
Base-rate counts Source beside each figure
21 / 47 Public repos where custom security script is narrower than step name, labelled by language-model agents in one pass, no second labeller (python lexical/lexical_baseline.py --counts)
18 / 120 Historical static mask candidates, labelled 2026-08-31, before e339796 (python lexical/lexical_baseline.py --counts); blocking intent requires review
6% Published secret scanner recall across 97,479 labeled secrets (Basak et al. 2023, arXiv 2307.00714, Table III)
Supported CI/CD Forges
GitHub Actions: live, read and prove (Run 33625228654) Azure DevOps: read only, live GitLab CI and Duo Agent Platform: live, read, prove and confirm (Pipeline 2958863173) Bitbucket Pipelines: static read of a local file, no forge adapter