research: env-profile + validation-gate redesign — make the failure class structurally hard

[Jammy2211]

Overview

Phase 3 of the build-chain integrity campaign (#155). A design task: one missing YAML line held nightly-release red for five nights (autofit_workspace_test #44→#45, superseded by #46→#47), and understanding why exposed eight observed failure modes in the env-profile + validation-gate system (silent overrides, vacuous tests, hand-maintained lists, release config untestable at PR time, inconsistent siblings, silent pattern over-match, duplicated resolvers, layered duplicate env reads). The job is a system redesign that makes these structurally hard — not a patch, not a lint rule.

Plan

• Verify (and correct) the brief's map: the two env profiles per workspace, the two meanings of "smoke", the duplicated resolvers (autobuild/env_config.py vs run_smoke.py), the pattern-match semantics, the three-layer use_jax contract.
• Re-measure the per-repo use_jax=True vs resolved-JAX tables under both profiles; triage the remaining genuine JAX-OFF scripts; settle the open ag/al mode=release-validates-NumPy question (reconcile with Phase 2's audit).
• Produce the target design (one concept per name; one resolver; derive-don't-enumerate; loud failures; PR-time config checks; one PYAUTO_DISABLE_JAX reader) + an incremental migration path + rejected alternatives + open human decisions (including the use_jax sentinel API question).

Research (Model: Fable, supervised): design doc first; implementation lands as separate green steps.

Detailed implementation plan

Work Classification

Research (workspaces + PyAutoBuild infrastructure)

Affected Repositories

• autofit/autogalaxy/autolens_workspace_test (profiles, scripts)
• PyAutoBuild (env_config.py, runner), PyAutoHeart (workspace-validation), PyAutoFit (use_jax contract)

Branch Survey (2026-07-16)

Repository	Current Branch	Dirty?
./PyAutoBuild	main	clean

Suggested branch: feature/env-profile-redesign (doc lands in PyAutoBuild docs/, alongside the Phase 1 audit)
Worktree root: ~/Code/PyAutoLabs-wt/env-profile-redesign/

Constraints (binding, from the brief)

• Do NOT copy autofit_workspace_test's DISABLE_JAX: "0" reasoning to ag/al (use_jax defaults differ; the var is load-bearing there).
• Do NOT grow smoke_tests.txt. Releases are gated by this system — nothing lands that cannot be shown green.
• Re-derive load-bearing claims; the brief's own map may be wrong ("Trust nothing here": four wrong conclusions listed).

Original Prompt

Click to expand starting prompt

Redesign the env-profile + validation-gate system so this class of bug cannot happen

Type: research
Target: workspaces
Repos:

• autofit_workspace_test
• autolens_workspace_test
• autogalaxy_workspace_test
• PyAutoBuild
• PyAutoHeart
• PyAutoFit
  Difficulty: large
  Autonomy: supervised
  Priority: normal
  Status: formalised
  Model: Fable

What this is

A design task, not a fix task. On 2026-07-15 a single missing line in one YAML file held
nightly-release red for five nights. Fixing it was ten minutes. Understanding why the system
let it happen, stay hidden, and be misdiagnosed twice took the rest of the day, and turned up a
family of related traps rather than one bug.

Your job is to sweep that whole surface — the env profiles, the validation gates, the runners,
and the use_jax contract underneath them — and design something structurally less able to
produce these failures. Not a patch. Not a lint rule bolted on the side. A cleaner system.

Take the time this needs. Read the code, resolve configs, run scripts, run the test suites,
run things twice with different env to compare. If a claim in this document is load-bearing for
your design, re-derive it yourself — see "Trust nothing here" below. A design that is right is
worth many hours; a design that is plausible is worth nothing, and this document is itself
evidence of how easy plausible-but-wrong is here.

What happened (the seed incident)

• autofit_workspace_test/scripts/searches/MultiStartAdam.py landed (refactor: drop PYAUTO_DISABLE_CRITICAL_CAUSTICS in favor of PYAUTO_FAST_PLOTS #43) as a JAX-native search.
• The mode=release profile (config/build/env_vars_release.yaml) pinned PYAUTO_TEST_MODE: "0"
  (real searches, no bypass) and PYAUTO_DISABLE_JAX: "1" (forces use_jax=False).
• MultiStartAdam hard-guards on the backend and raised → the autofit_test/searches shard failed
  → Stage 3 of nightly-release failed. Five consecutive nights.
• Nobody noticed for five nights because the only signal was a red nightly.
• Fixed in fix: correct env var name and skip removed search packages #44 / PR fix: auto-update dependency version pins during release #45 (add the missing overrides), then superseded by Rename PYAUTOFIT_TEST_MODE → PYAUTO_TEST_MODE #46 / PR Skip EmceePlotter / NautilusPlotter under PYAUTO_TEST_MODE=2 #47 (delete the
  override list entirely — the release default was buying nothing in that repo).

Read these in full; the comments carry the evidence and the dead ends:

• autofit_workspace_test fix: correct env var name and skip removed search packages #44 and PR fix: auto-update dependency version pins during release #45 — the incident and the symptom fix
• autofit_workspace_test Rename PYAUTOFIT_TEST_MODE → PYAUTO_TEST_MODE #46 and PR Skip EmceePlotter / NautilusPlotter under PYAUTO_TEST_MODE=2 #47 — the structural fix, and why the alternatives lost
• PyAutoFit #1372 — the use_jax/PYAUTO_DISABLE_JAX three-layer inconsistency, and the
  adversarial review that killed a fix I had already built and was about to ship

The system as it currently stands

Verify this map; it was assembled quickly and parts of it may be wrong or already stale.

Two env profiles per workspace, similar names, different consumers:

file	profile	consumed by	typical defaults
config/build/env_vars.yaml	smoke	Heart workspace-validation.yml mode=smoke (all scripts, weekly Mon 03:00 UTC) and the per-PR runner	TEST_MODE: "2" (bypass sampler), DISABLE_JAX: "1"
config/build/env_vars_release.yaml	release	Heart workspace-validation.yml mode=release (all scripts, wheels, release fidelity)	TEST_MODE: "0", DISABLE_JAX varies per repo

"Smoke" means two different things, which is its own trap:

1. the per-PR gate — .github/workflows/smoke_tests.yml → .github/scripts/run_smoke.py,
   running the curated smoke_tests.txt list (11 of 42 scripts in autofit_workspace_test);
2. the smoke env profile — env_vars.yaml, above.

They are not the same mechanism and do not cover the same scripts.

Two independent implementations of the same env resolution:

• PyAutoBuild/autobuild/env_config.py::build_env_for_script
• autofit_workspace_test/.github/scripts/run_smoke.py::build_env

They currently agree (defaults → per-pattern unset:/set:). Nothing enforces that they keep
agreeing.

Pattern matching (both copies): a pattern containing / is a substring match against the
full path including extension; otherwise it matches the file stem exactly. So
searches/Nautilus silently also matches Nautilus_jax.py.

The use_jax contract, across three layers:

layer	use_jax default	reads PYAUTO_DISABLE_JAX?
af.Analysis	False	yes (analysis.py, in __init__)
ag.* (AnalysisDataset, AnalysisImaging, AnalysisInterferometer, ellipse)	True	no
al.AnalysisDataset, al.point	True	yes — duplicating af, and before super().__init__()

PYAUTO_DISABLE_JAX is read in exactly two places across all five libraries (af.Analysis and
al.AnalysisDataset). It does not affect SimulatorImaging.

The failure modes to design against

Each of these is observed, not hypothesised.

1. Silent override. Analysis.__init__ downgrades an explicit use_jax=True to False with
   no signal. Three lines below, the other way use_jax=True can fail (JAX not installed) warns
   loudly in a box. Only the env-var path is silent.
2. Vacuous tests. A script that declares use_jax=True and asserts JAX behaviour, but runs on
   numpy, passes. searches/Dynesty_jax and searches/Nautilus_jax did this for their entire
   existence. MultiStartAdam failed loudly only because it happens to carry its own guard. The
   scripts with a guard scream; the ones without lie.
3. Hand-maintained "remember to add your script" lists — env_vars*.yaml overrides,
   no_run.yaml, smoke_tests.txt. Forgetting an entry does not fail loudly; it degrades
   silently. This is the direct cause of the seed incident.
4. Config drift is untestable at PR time. run_smoke.py hardcodes
   ENV_VARS_FILE = config/build/env_vars.yaml; the per-PR gate never reads the release profile.
   A release-profile error can only surface in the nightly — a ~24h feedback loop, and the only
   signal is one red job.
5. Inconsistent siblings. autofit_workspace pinned DISABLE_JAX: "0" ("release fidelity");
   autofit_workspace_test pinned "1". Same organisation, same release, opposite stance, no
   stated reason.
6. Silent over-match. The substring/extension pattern rule can quietly capture a script you
   did not mean (Nautilus → Nautilus_jax).
7. Duplicated resolvers that can drift apart unnoticed.
8. Layered duplicate env reads. al.AnalysisDataset re-implements the base class's env check
   and applies it earlier, so the base class cannot see that an override happened. This is
   failure mode 1 recurring one layer up — the pattern reproduces itself.

What was already tried and rejected — do not redo these blind

Re-test them if your design depends on it, but know the evidence:

• Promote the script into smoke_tests.txt → rejected. Would not have caught it: the per-PR
  gate never reads the release profile (failure mode 4). Also cuts against the standing "smoke
  tests are a small curated subset; don't mass-promote" preference.
• Static config guard ("every script with use_jax=True must resolve DISABLE_JAX=0 in the
  release profile") → rejected. The naive string-matching rule false-positives:
  autolens_workspace_test/scripts/imaging/simulator_use_jax_parity.py contains use_jax=True
  but constructs SimulatorImaging, which does not read the env var — its parity test is valid.
  The correct rule ("constructs an Analysis with use_jax=True") is brittle to detect statically
  across AnalysisImaging / TwoLatentAnalysis / custom subclasses.
• A loud warning in af.Analysis when the env overrides an explicit use_jax=True → built,
  tested, and then killed by adversarial review. Two reasons, both proven empirically:
  (a) PyAutoLens flips use_jax before super().__init__(), so the warning never fires for the
  ~54 autolens scripts; (b) ag.*/al.* default use_jax=True, so it fires on default
  constructions claiming JAX "was requested" when it was not. Silent where it mattered, noisy
  where it did not. Nothing was pushed.
• Write the trap down → rejected, with the strongest evidence of the lot. A memory note
  recording this exact two-profile trap already existed, written the day before, and the trap
  was still walked into the next morning. Documentation does not fire at the moment of the
  mistake. Prefer deleting the thing-to-remember.

Measured facts (re-measure; do not inherit)

Scripts containing use_jax=True, resolved through
autobuild.env_config.build_env_for_script against each repo's release profile, as of
2026-07-15 (before PR #47):

repo	declares use_jax=True	JAX actually ON	resolves JAX OFF
autofit_workspace_test	7	6	1
autolens_workspace_test	54	50	4
autogalaxy_workspace_test	36	34	2

Of the 7 JAX-OFF, ~2 are false positives (the simulator_use_jax_parity.py pair). The remainder
are genuine and untriaged:

• autofit_workspace_test/scripts/features/latent_nan_robustness.py (resolved by PR Skip EmceePlotter / NautilusPlotter under PYAUTO_TEST_MODE=2 #47; verified
  it passes with JAX on)
• autolens_workspace_test/scripts/imaging/visualization.py
• autolens_workspace_test/scripts/latent/latent_nan_robustness.py
• autogalaxy_workspace_test/scripts/imaging/visualization.py
• autogalaxy_workspace_test/scripts/latent/latent_nan_robustness.py

latent_nan_robustness.py deliberately builds both a numpy and a JAX analysis, so only its
JAX half is vacuous — triage it, do not blindly override it.

Note the undercount. That survey string-matches use_jax=True, but ag.*/al.* default to
True. So in autolens/autogalaxy, scripts that never mention use_jax also get JAX by default
and are also forced to numpy by DISABLE_JAX: "1". Whether mode=release validating the numpy
path for most of the autolens/autogalaxy surface is intended is an open question worth your
attention — it may be a much larger fidelity gap than the seed incident, or it may be
deliberate. Find out; don't assume either way.

Trust nothing here

This document was written by the agent that made the mistakes. Several of its conclusions were
wrong today and were caught only by an explicit adversarial pass:

• "PYAUTO_DISABLE_JAX has exactly one consumer" — false, missed the PyAutoLens one by
  grepping only three of five libraries.
• "use_jax defaults to False, so truthiness means explicitly requested" — false for the
  entire ag/al surface.
• "The fix works, I ran it on a real script" — the script exercised the one path where the
  assumption held.
• "The smoke change lets the per-PR gate catch this" — false, asserted without checking
  smoke_tests.txt.

Every one had the same shape: verifying the path already assumed, and calling it proof. Treat
this document as a lead sheet, not a source of truth. Where it matters, check.

What to produce

A design document (propose where it lives — PyAutoMind/research/ or a docs/ page in the owning
repo), covering:

1. A verified map of the current system: profiles, gates, runners, resolvers, consumers, and
   who reads what. Correct this document's map where it is wrong.
2. A target design that makes the failure modes above structurally hard. Explicit goals worth
   weighing (argue with them if you disagree — these are hypotheses, not requirements):
   • one concept per name — kill the "smoke means two things" collision;
   • one resolver, one pattern semantics, no duplicate implementations;
   • derive rather than enumerate — a script's env should follow from what it is, not from
     remembering to list it;
   • a missing/forgotten entry should fail loudly rather than degrade to a vacuous pass;
   • config errors should be catchable before the nightly;
   • one place reads PYAUTO_DISABLE_JAX, and an overridden explicit request is never invisible;
   • sibling repos should not silently disagree about release fidelity.
3. A migration path that is landable incrementally, each step green on its own. This system is
   live and gates real releases; a big-bang rewrite is not acceptable.
4. What you rejected and why, with evidence. Include anything from "already tried" you think
   was rejected wrongly — that judgement may well be wrong.
5. Open decisions for the human, separated cleanly from what you're confident about. In
   particular: the autolens/autogalaxy mode=release numpy question (above), and whether
   use_jax needs a sentinel (Optional[bool] = None) threaded through af/ag/al so that
   "explicitly requested" becomes knowable at all — a real cross-repo API change.

Method — and please actually do this

• Run things. Resolve every script's env under both profiles in all three test workspaces.
  Execute scripts both ways and diff the outcome. Run pytest test_autofit/ (~75s). Nothing here
  is expensive; the expensive thing is being wrong.
• Prove no-ops empirically. "Provably inert" is the phrase that preceded being wrong today.
  Run it both ways.
• Pick the falsifying case. If a change touches a base class, exercise a subclass from each
  downstream library — the base-class path is the one that already agrees with you.
• Grep all five libraries (PyAuto{Conf,Fit,Array,Galaxy,Lens}), and don't filter out tests
  when the question is "how many consumers are there?".
• Adversarial pass before concluding. For each load-bearing claim: what would have to be true
  for this to be false, and have I looked? Then look. That pass cost ~15 minutes today and caught
  a fix that was about to ship broken.
• Prefer deleting the trap to documenting it, and prefer the lean existing lever to new
  machinery. If a proposal's rationale is "and we'll remember to keep this in sync", it is the
  trap wearing a new hat. PR Skip EmceePlotter / NautilusPlotter under PYAUTO_TEST_MODE=2 #47 is the shape to aim for: it deleted 31 lines of config and a
  whole bug class by noticing the dangerous setting was buying nothing.

Constraints

• Do not copy autofit_workspace_test's DISABLE_JAX: "0" reasoning to
  autolens/autogalaxy_workspace_test without re-deriving it. It holds there only because
  af.Analysis defaults use_jax=False, making the var inert for non-opt-in scripts. ag/al
  default True, so the var is not inert there and flipping it is a real behaviour change
  across the whole surface.
• Do not grow smoke_tests.txt to make a gate feel stronger. It is deliberately small.
• Releases are gated by this system. Nothing lands that cannot be shown green.
• Design first. Plan approval before implementation, per the usual workflow.

[Jammy2211]

Map verification — session 1 (2026-07-16, read-only)

Verified against today's repos (the brief is from 2026-07-15; several cells have already moved):

• Both profiles still exist in all three _test workspaces, but the release profiles now pin only PYAUTO_TEST_MODE: \"0\" — no DISABLE_JAX pins remain in any release profile (the Skip EmceePlotter / NautilusPlotter under PYAUTO_TEST_MODE=2 #47 shape spread to ag/al siblings). The smoke profiles still pin TEST_MODE: \"2\" + DISABLE_JAX: \"1\" with per-pattern unset: lists (failure mode 3, hand-maintained lists, still live).
• The headline open question may be MOOT already: with no DISABLE_JAX in the release profiles and none set globally by workspace-validation.yml or the runner (grep: zero hits outside comments), mode=release should now run ag/al's default use_jax=True path. Needs one empirical confirmation (resolve + run one ag script under the release profile and check the backend) before declaring the fidelity gap closed — verifying the path we did not assume.
• PYAUTO_DISABLE_JAX readers: exactly 2 (autofit/non_linear/analysis/analysis.py, autolens/analysis/analysis/dataset.py) — the brief's corrected count confirmed; the layered-duplicate-read (failure mode 8) is still live in al.
• Resolver duplication (failure mode 7) is still live and the copies have drifted (autobuild/env_config.py vs run_smoke.py::build_env — first-24-line diff non-empty; drift extent not yet characterised, could be cosmetic).

Session-2 legs (the brief's deep execution): characterise the resolver drift precisely; re-measure the per-repo use_jax-vs-resolved tables under both profiles; run the falsifying ag/al release-mode script; triage the remaining vacuous-JAX scripts; then the target design + migration doc (home: PyAutoBuild docs/, alongside the Phase 1 audit).

[Jammy2211]

Correction + the measured answer to the headline question (session 2)

My session-1 claim "no DISABLE_JAX pins remain in any release profile — the question may be moot" was WRONG. It came from a grep | head -4 that saw only the defaults block's first lines — the exact verify-the-assumed-path shape this campaign catalogues. Caught by the falsifying probe (resolving imaging/visualization.py's release env returned PYAUTO_DISABLE_JAX='1' — which is why the brief listed that script as genuinely JAX-OFF).

The real state, full files read:

• autofit_workspace_test release: PYAUTO_DISABLE_JAX: "0" in defaults, overrides: [] — JAX ON across the surface (the Skip EmceePlotter / NautilusPlotter under PYAUTO_TEST_MODE=2 #47 outcome).
• autogalaxy/autolens_workspace_test release: PYAUTO_DISABLE_JAX: "1" in defaults — NumPy forced for the whole surface — with 9-10 hand-listed folder overrides re-enabling JAX (jax_likelihood_functions/, jax_grad/, *_visualization_jax, *_jit, …).

So the headline question stands, sharpened into a policy decision for the human: in production, ag/al default use_jax=True — users run JAX. mode=release validates the NumPy path for everything outside the enumerated JAX folders. The profile comments show this is a deliberate authoring choice ("force use_jax=False by default; JAX-specific folders re-enable below"), but its consequence is that the release gate exercises the non-default backend for most of the ag/al surface, via exactly the hand-maintained-list mechanism (failure mode 3) that caused the seed incident. The Phase 3 design hinges on which invariant is wanted:
(a) release fidelity = production defaults → flip ag/al release to JAX-on-by-default with a (small) NumPy-parity list instead, or
(b) NumPy is the deliberately-validated reference path → keep the current shape but derive the JAX list rather than enumerate it, and state the policy where the verdict can cite it.

Resolver drift characterised: build_env cores are line-identical; drift is in load_env_config (run_smoke tolerates a missing file → empty config, and hardcodes ENV_VARS_FILE=config/build/env_vars.yaml — failure mode 4 structurally confirmed: the PR gate can never read the release profile) and in match target (relative path vs full path — no behavioural difference for current patterns). One more measured layering fact: build_env* starts from os.environ.copy(), so profile absence of a var means "whatever the runner's ambient env carries", not a defined value — worth closing in the design.

Session 3: the per-repo use_jax tables under both profiles, then the design doc built around whichever (a)/(b) the human picks.

[Jammy2211]

Design deliverable at PR-open: #162 (docs/env_profile_redesign.md, pending-release). Built on the decided invariant (human, 2026-07-16): NumPy stays the validated release reference for ag/al — option (a) rejected on the over-reach guard + the measured JIT-compile cost (autolens_profiling#71) — and the mechanism is fixed: derivation rule (jax_*/*_jax/*_jit) replaces the hand lists (only database/scrape/ doesn't match — decided at migration step 4), marker/env mismatch = loud runner error, one resolver + scrubbed baseline, PR-time validate_env_profiles, profile rename. Eight-step migration, each green on its own; steps land as separate planned tasks after the doc merges.

[Jammy2211]

Migration step 1 at PR-open: #163 (validate_env_profiles, pending-release; 122/122). First run against the real repos delivered step 4's gap analysis for free:

• 3 dead patterns in autogalaxy_workspace_test (quantity/visualization.py + quantity/visualization_jax in both profiles — stale entries silently matching nothing).
• The vacuous-JAX class is 3× the brief's estimate: 15 scripts (11 autolens + 4 autogalaxy) carry JAX markers (profiles_jit.py, tracer_jax.py, …) but sit outside every enumerated folder and resolve NumPy under mode=release.

Both are workspace-side fixes for migration step 4 (the derivation rule makes the 15 self-registering; the dead patterns just die). Next steps after merge: wire the check into the three workspace_test PR gates, then step 2 (single resolver).

[Jammy2211]

Migration step 2 MERGED — one resolver, across all three workspace_test repos (autofit_workspace_test#52, autogalaxy_workspace_test#74, autolens_workspace_test#174; smoke gates green on 3.12+3.13, i.e. this step was exercised by the very gate it changes).

Findings worth keeping:

• The three forks were byte-identical to each other — one fork copied three times, already drifted from canonical (their load_env_config hardcoded env_vars.yaml, which is what made the PR gate structurally unable to read the release profile).
• No infrastructure was needed: PyAutoHeart's reusable smoke-tests.yml already clones PyAutoBuild and puts autobuild/ on PYTHONPATH (lines 54/90). The duplication bought nothing.
• Resolve-diff gate (§8) satisfied by measurement: every smoke script in all three repos resolved both ways — old fork loaded verbatim from git show HEAD:, against the real workspaces — 61/61 byte-identical, 0 mismatches.
• Precision note: ENV_VARS_FILE remains as an explicit argument (the smoke runner legitimately runs the smoke profile). What died is the resolver's inability to be pointed elsewhere.

Remaining on this issue: step 3 (scrubbed baseline), step 4 (derivation rule — its gap analysis is already done: 3 dead patterns + 15 vacuous-JAX scripts, see #163's findings), step 5 (marker guard flip), step 6 (rename), steps 7-8 (library one-reader fold; Optional[bool] sentinel — both human-gated).

[Jammy2211]

Step 3 (scrubbed baseline): STARTED, then re-scoped by measurement — NOT shipped

Attempted the scrubbed base env from the design doc §5. Measurement killed it, and corrected the doc. Findings:

1. The doc's §5 "allowlist base" is the wrong shape — deny-by-default would have to enumerate every infra var a script needs (PATH/HOME/PYTHONPATH/caches/JAX/conda/…); a miss breaks the least-exercised, highest-consequence release path. A deny-list of managed keys is the safe equivalent.

2. But a naive PYAUTO_ deny-list BREAKS SMOKE.* There are two parallel mechanisms setting PYAUTO_ behavioural vars — the profile files AND workflow-level env: injections:

   • PyAutoHeart workspace-validation.yml:85 injects PYAUTO_SKIP_WORKSPACE_VERSION_CHECK (smoke + release)
   • PyAutoBuild python_matrix.yml:85-87 and release.yml:270-273,623 inject PYAUTO_TEST_MODE / SMALL_DATASETS / FAST_PLOTS / SKIP_WORKSPACE_VERSION_CHECK
     The smoke profiles do NOT set SKIP_WORKSPACE_VERSION_CHECK (measured: set=0 in all three smoke env_vars.yaml; only the release profiles set it). Smoke relies entirely on the CI env: injection — the workflow comment says without it "every script fails fast with WorkspaceVersionMismatchError." A blanket PYAUTO_ scrub strips it → smoke red on all three repos.

3. Near-miss disclosure: my first resolve-diff proof passed (65/65 clean, leak fixed) because it used a synthetic clean env that omitted the one PYAUTO_ var CI actually injects. Reproducing against the real CI env surfaced the break. (The campaign's own "reproduce in the real env, not a model" lesson — third variant.)

Re-scoped step 3 = the discovery is that PYAUTO_ behavioural vars have TWO sources of truth (profiles + workflow env:), which is the same "one concept per name" duplication Phase 3 targets. The correct step 3 is: fold the CI-env:-injected PYAUTO_ vars into the profiles (add SKIP_WORKSPACE_VERSION_CHECK to the smoke profiles; drop the env: injections), THEN the deny-list scrub is safe. That touches all three smoke profiles + release.yml, and autolens_workspace_test is currently claimed (dpie-lenstool) → this step is BLOCKED until that frees. The env_config-only shortcuts are each unshippable: managed-only scrub = no-op for current profiles; blanket scrub = breaks smoke; exemption-list = the maintained-list trap Phase 3 exists to delete.

Nothing shipped; branch abandoned. Recorded so the eventual implementer does not repeat the near-miss.

[Jammy2211]

Step 3 VERIFIED CORRECT, but HELD on a pre-existing autolens regression. Four PRs open (PyAutoBuild#165 scrub + afwt#54/agwt#75/alwt#180 profiles).

Smoke gates: autofit#54 green, autogalaxy#75 green (3.12+3.13). autolens#180 red — but on potential_correction/subhalo_recovery.py (iterative dkappa correlation 0.032 vs 0.3), which is byte-identical red on autolens_workspace_test main (run 29597679558) since dpie-lenstool's release ~13:39. My change is a no-op for PYAUTO_ vars on CI; it merely surfaced the regression by running the gate. Filed: PyAutoMind/draft/bug/autolens/subhalo_recovery_iterative_dkappa_collapsed.md.

Why held rather than merge-3-of-4: the scrub + the three profile changes are a coordinated set — merging the PyAutoBuild scrub without the autolens profile's SKIP_WORKSPACE_VERSION_CHECK would strip the mega-run's ambient injection and break autolens mega-run smoke. So all four merge together, once alwt#180 goes green (i.e. once subhalo_recovery is fixed on autolens main). PRs stay open, pending-release.

[Jammy2211]

Step 3 MERGED — all 4 PRs (PyAutoBuild#165 scrub + afwt#54/agwt#75/alwt#180 profiles), library-first, all smoke gates green. autolens went green once the pre-existing subhalo_recovery regression was fixed (autolens_workspace_test#181, warm-start iterative potential-correction) — my env change was a no-op for PYAUTO_ vars on CI throughout; it only surfaced that regression by running the gate.

Migration progress on #161: step 1 (validator #163) ✔ · step 2 (single resolver, ×3 #52/#74/#180-era) ✔ · step 3 (scrubbed base env) ✔. Remaining: step 4 (derivation rule — the gap analysis is done: 3 dead patterns + 15 vacuous-JAX scripts from #163), step 5 (marker guard flip), step 6 (profile rename), steps 7-8 (library one-reader fold; Optional[bool] sentinel — human-gated).