Pressure-testing Ota on Outline: keeping lean verification truthful in a service-heavy repo

Outline was a useful pressure repo because it mixes two very different truths:

• lean contributor verification paths such as linting, type-checking, and app/shared tests
• heavier service-backed paths such as make up and full server test flows

That makes it a good honesty test.

The real question was not whether Ota could run commands in the repo.

It was whether Ota could keep the default verification path lean and truthful without collapsing it into the repo's heavier infra-mutating development flows.

Outline did not force another large Ota core widening.

Instead, it proved that several of the newer Ota surfaces are now strong enough to model this repo cleanly:

• structured Yarn dependency hydration instead of raw install shell
• aggregate verification for the lean PR-safe path
• explicit workflow intent separation between checks, server testing, and full local development
• honest native versus container mode support without pretending every host can execute every container lane

That is a different kind of pressure value.

It is less about exposing a missing parser rule and more about confirming that the stronger contract surfaces now keep repo truth cleaner than shell glue would.

The contract moved the dependency setup lane onto first-class Ota ownership:

tasks:  setup:    description: Install Yarn dependencies exactly from the lockfile    prepare:      kind: dependency_hydration      medium: package_dependencies      source:        kind: node_package_manager        cwd: .        manager: yarn        mode: install        frozen_lockfile: true

That is better than a raw corepack yarn install --immutable string because the contract now owns:

• manager identity
• strict lockfile intent
• the hydration write boundary
• network semantics

The lean contributor verification path is also modeled structurally instead of via fake shell:

tasks:  verify:    description: Run the lean PR-safe verification path    aggregate:      tasks:        - lint        - typecheck        - test:app        - test:shared

And the heavier paths stay separate:

workflows:  checks:    intent: ci_validation    setup:      task: setup    run:      task: verify   server:    intent: ci_validation    setup:      task: setup    run:      task: test:server   app:    intent: local_development    run:      task: dev

That split matters.

If the default workflow had quietly absorbed make up or the Makefile-owned full test path, the contract would have looked simpler while becoming less truthful.

The matrix shape is honest about host capability:

• Ubuntu runs the fuller native and container proof lanes
• macOS and Windows still exercise contract gates, task discovery, dry-run planning, and native smoke paths
• non-Docker-capable lanes assert a blocked container dry-run instead of pretending those hosts can prove the same runtime path

That is the right pressure posture for this repo.

The latest retained green run for the Outline branch is #27870466525, completed on June 20, 2026.

Outline helped confirm an important Ota product rule:

default verification should be the safest truthful path, not the heaviest available path.

A service-heavy repo does not become better-governed by shoving Docker-backed startup and database-reset flows into the default check lane.

It becomes better-governed when the contract makes the boundaries explicit:

• what is PR-safe
• what mutates infra
• what is default
• what requires a stronger host

That is exactly what this pressure pass demonstrated.

• Contract: outline ota.yaml
• Matrix workflow: test-ota-contract-matrix.yml
• Green matrix run: #27870466525