标签：#pressuretesting

The finding EventCatalog exposes a common monorepo failure mode: generated code may exist, its producer may be green, and the real downstream consumer can still fail. Its Langium language server generates AST, grammar, module, and syntax files; a sibling VS Code extension consumes that output alongside the workspace SDK and visualiser. The useful question is therefore not "did generation finish?" It is whether the repository can execute the complete consumer closure from declared dependency hydration through the package that needs the generated result. The contract boundary Ota models the generated output separately from the tasks that establish and consume it: artifacts : language-server-ast : kind : generated_source producer : language-server:generate paths : - packages/language-server/src/generated/ast.ts - packages/language-server/src/generated/grammar.ts - packages/language-server/src/generated/module.ts - packages/language-server/syntaxes/ec.tmLanguage.json - packages/vscode-extension/syntaxes/ec.tmLanguage.json inputs : - packages/language-server/src/ec.langium - packages/language-server/langium-config.json tasks : vscode-extension:build : depends_on : - language-server:generate - language-server:build - sdk:build - visualiser:build requires_artifacts : - language-server-ast The setup task owns typed, frozen-lockfile pnpm hydration with the language-server package filter. That removes bespoke install shell glue without pretending the dependency path is harmless: it reaches the package registry, so the selected closure is intentionally not routine agent-safe execution. Humans and CI can run the declared verification workflow; unattended agents cannot silently acquire that networked setup authority. What Ota had to learn This pressure case made two platform requirements concrete. Generated-source lineage had to remain visible at consumer admission and in execution evidence, rather than surfacing only after a build failure. And pnpm dependency hydration needed a

Overview Open WebUI exposed a real Ota lifecycle boundary. This was not mainly a parsing or contract-shape repo. The contract was already strong enough to model: source-checkout verification packaged native runtime through uv run open-webui serve frontend development runtime default Docker Compose runtime What the repo exposed was operational truth after proof: a successful native proof still left a host workload alive the first cleanup fix then widened too far and treated a Compose-owned runtime as the same class of host workload That made Open WebUI a valuable pressure repo. It forced Ota to get more precise about cleanup ownership instead of treating all successful runtime proof as one generic teardown problem. The current pressure contract pins released Ota v1.6.24 . Its latest green matrix run proves the release surface at the exact contract and workflow revision linked below. What Open WebUI exposed in Ota This repo exposed four meaningful weaknesses. 1. proof success was weaker than it looked The first issue was not that runtime proof failed. It was that runtime proof succeeded and still left the native workload alive afterward. In this repo, the packaged native workflow launches: serve:native : launch : kind : command exe : uv args : - run - open-webui - serve - --host - 0.0.0.0 - --port - " 8080" Ota proved that workflow, but the launched process tree was still alive after proof completed. In GitHub Actions, that surfaced through setup-uv post-job cleanup, which blocked while the uv cache was still in use. That was an Ota gap. If proof succeeds but leaves behind repo-owned runtime state that later breaks CI cleanup, the proof surface is still incomplete. 2. native service cleanup widened past its real ownership boundary The first core fix made Ota clean selected native service workloads after successful proof. That was directionally correct, but Open WebUI immediately exposed the next boundary. The Docker workflow uses a native task shape to launch Compose:

Overview lead-quorum was a strong pilot repo because it was small enough to reason about and real enough to fail honestly. It has: repo-local Python environment ownership pinned dependency installation env bootstrap from example truth a deterministic local test surface live external verification a local web runtime a distributed demo path a Docker build lane That is exactly the kind of repo where a contract can look clean while still hiding real setup and execution drift. Why this repo mattered The useful pressure here was not “can Ota run one Python command.” The useful pressure was whether Ota could stay truthful when the repo itself owns: the .venv the dependency install lane the local executable path the runtime listener truth If Ota probes or fulfills those in the wrong order, the contract is not trustworthy even if the repo itself is valid. That is what made lead-quorum valuable. What the contract now models The final contract is explicit about the repo’s real setup split. Setup is not one opaque shell step. It is three different ownership surfaces: copy .env from .env.example only if missing create the repo-local virtual environment hydrate dependencies through typed uv requirements-file installation That looks like this in the contract: setup : aggregate : tasks : - setup:env - setup:venv - setup:deps setup:env : action : kind : copy_if_missing from : .env.example to : .env setup:venv : action : kind : ensure_virtualenv path : .venv python : " 3.12" setup:deps : prepare : kind : dependency_hydration medium : package_dependencies source : kind : uv cwd : . mode : pip_requirements requirements_file : requirements.txt The contract also keeps verification and external-runtime claims separate: verify for deterministic local validation live for Gemini-backed end-to-end testing app for the local web service distributed for the A2A demo path That matters because a working local scoring test and a live distributed runtime are not the same readiness claim. What lead-q