docs/EXECUTION_PLAN.md

# Full-release 96-cell execution plan

## Objective

Publish and verify one Docker image for every frozen task-tier cell in
`manifests/task_matrix.csv`: 48 tasks times `lite` and `standard`, for 96
images total.

The Lite release is the packaging reference: downloadable Docker archives are
grouped by track. The Full release preserves its stricter isolation and data
policy: task images contain code, prompts, contracts, and provenance only.
Dataset bytes are mounted at runtime and are never embedded in an uploaded
image.

## Artifact layout

- Build one immutable task image per matrix row, tagged under the
  `automedbench-full/` namespace and locked to one task and one tier.
- Retain the common agent runtime and seven track evaluator runtimes.
- Group exports into the same seven per-track paths and archive names used by
  AutoMedBench-Lite. Each archive contains all task-tier images for its track;
  the largest contains 28 images. The already-published runtime archive
  supplies the shared agent and seven evaluator images.
- Process upload archives serially. Keep each local archive until the private
  Hugging Face remote reports the same size and SHA-256, then remove only that
  verified archive and its uniquely namespaced task tags.
- Never run a global Docker prune or remove unrelated images, containers,
  volumes, or caches.

## Dataset resolution

For every task, record one of these outcomes with source revision, license,
selected IDs, layout checksum, and evidence:

1. `staged_verified`: authorized source data were deterministically staged and
   scanned.
2. `acquisition_ready`: the source and staging recipe are frozen, but an
   authorized user must supply gated data.
3. `externally_blocked`: access approval, a DUA, or upstream clarification is
   required and cannot be substituted by a private upload.

Restricted or unclear-license data may be used locally only when access is
already authorized. They must not be uploaded. Synthetic inputs may verify a
container contract, but never change a task's dataset readiness status.

## Verification gates

Each of the 96 cells must pass:

1. task schema, internal checksums, path safety, and credential scan;
2. Docker build with a digest-pinned base and immutable task/tier labels;
3. non-root container self-test and task/tier identity check;
4. prompt and output-contract rendering against a staged or synthetic public
   item;
5. a bounded ChatGPT API workflow smoke run covering S1 and S2 only;
6. termination before S3 validation starts;
7. exported-archive OCI graph, layer digest, tag inventory, and secret scan;
8. private remote size and SHA-256 equality after upload.

S1-S2 smoke results are launch/readiness evidence only. They are not benchmark
scores and must not be presented as task completion.

## Execution order

1. Audit local/remote access, disk, Docker, GPU visibility, and credentials
   without printing sensitive values.
2. Resolve public datasets first; freeze acquisition recipes for gated tasks;
   update readiness records from evidence.
3. Implement and test the task-image builder, S1-S2 verification mode, archive
   exporter, and remote verifier.
4. Build and verify all 96 images.
5. Run S1-S2 smoke verification in bounded batches, stopping before S3.
6. Export and upload one track at a time, verifying the remote before cleanup.
7. Audit the final 96-image inventory and update release documentation.

## Known environmental constraints at plan freeze

- LLM verification uses the configured remote ChatGPT-compatible API only;
  host GPUs are intentionally not used.
- Docker is available through passwordless `sudo`; the user is not in the
  `docker` group.
- The Docker daemon does not currently have NVIDIA Container Toolkit support.
  This is not a release blocker because the requested S1-S2 verification is
  CPU-safe and uses the remote API; verification launches omit `--gpus`.
- The configured ChatGPT-compatible endpoint and private Hugging Face token
  both authenticate successfully.
- Gated/DUA datasets remain external dependencies even when the build and
  upload pipeline is otherwise complete.