feat: build autocti_assistant — the CTI calibration assistant cell

[Jammy2211]

Overview

Build autocti_assistant, the science-assistant cell for CTI calibration with
PyAutoCTI, seeded from autolens_assistant via the Clone Agent. This follows the
CTI resurrection epic (all six phases merged 2026-07-17), which left PyAutoCTI,
autocti_workspace (118 validated scripts) and autocti_workspace_test fully
modern — making the domain assistant the natural next organ of the CTI cell line.

Planning surfaced a blocker that gates every future assistant birth, not just
this one: pyauto-brain clone --apply hard-fails (exit 4) because 39 tracked
files in the reference cell match no template-boundary pattern. Phase 0 clears it
and adds the guard that stops it recurring.

Scope note (intake trap): this is a new assistant cell. PyAutoCTI is a
consumed dependency, not an edit target — bare "PyAutoCTI" mentions must not
steal the classification Target. Filed on PyAutoBrain per the clone-epic
precedent (pyautoscientist-3b-clone → PyAutoBrain#73).

Plan

• Phase 0 — unblock the birth. Classify the 39 unclassified reference files
  (the euclid mode, the JOSS paper/, .mcp.json, the cosmos_web_ring scripts —
  all shipped after the boundary was last written) in both places that must
  agree: the owning prose and the executable patterns. Add a guard test so the
  next feature landing in the reference can't silently re-block births.
• Phase 1 — birth the seed. Human gate on repo name/owner/visibility, then
  --apply --mode lightweight-seed. Born private; flips public after Heart's
  publish gate. Register in the body map.
• Phase 2 — the ac_* skills. Grounded per-skill against the 118 validated
  workspace scripts, never API memory.
• Phase 3 — wiki + project profile. core/ reference pages and a
  literature/ corpus rebuilt from public sources with verified citations.
• Phase 4 — demonstrations + validation. End-to-end fits that recover input
  trap models, plus citation/link/cold-chat gates.

Each phase is its own PR (the CTI resurrection phase0..phase5 precedent).

Clone Agent decision

bin/pyauto-brain clone PyAutoCTI --workspace autocti_workspace --reference autolens_assistant:

• Library: PyAutoCTI @ eca130ca (74 public symbols) · Workspace: 118 scripts
• Partition: generic 51 · domain 257 · mixed 93 · unclassified 39
• Mode: lightweight-seed — forced, not merely preferred. _clone.py gates
  --apply on --mode lightweight-seed; exact-clone and
  differentiated-sibling are v2 and unimplemented (exit 5). The agent's own
  next-action recommends seed-first, and the prompt's scope sketch (no
  benchmarks/, paper/, modes/, hpc/) is already seed-shaped.

Two decisions worth recording

1. Visibility. The human answered public, and public is the end state — but
   PyAutoBuild/autobuild/clone_seed.py creates the newborn private and flips
   it public only after Heart's publish gate
   (PyAutoHeart/docs/newborn_validation.md, legs 1–3). That is the machinery's
   own gate and matches this prompt's constraint that a newborn is not announced
   before its validation legs pass. Because the repo ends public, the privacy
   seam stays fully in force: PyAutoMemory wiki/cti/ is consulted for pointers
   and structure only, never copied.
2. PyAutoMemory wiki/cti/ is thin — 1 concept, 2 entities, 8 sources. It is a
   bibliography pointer, not a corpus. Phase 3 is real research, not transcription.

Detailed implementation plan

Affected Repositories

• PyAutoBrain (primary) — Clone Agent profile + guard test + stale docs
• autolens_assistant — the reference cell's template boundary (Phase 0)
• autocti_assistant — the newborn (does not exist until Phase 1)
• PyAutoMind — body-map registration (Phase 1)
• PyAutoCTI, autocti_workspace — read-only grounding sources

Branch Survey

Repository	Current Branch	Dirty?
./PyAutoBrain	main	clean
./autolens_assistant	main	clean
./PyAutoMind	main	clean
./PyAutoCTI	main	clean
./autocti_workspace	main	clean

No worktree claims collide (ep-projection-weights, potential-correction-port
are unrelated).

Suggested branch: feature/autocti-assistant
Worktree: ~/Code/PyAutoLabs-wt/autocti-assistant/

Implementation Steps

Phase 0 — unblock the birth (autolens_assistant + PyAutoBrain)

The gate, in agents/conductors/clone/_clone.py:

sets = partition(reference_root, profile)
if sets["unclassified"]:
    fail(4, "unclassified reference files — fix the boundary before a birth")

The boundary lives in two places that must agree: the prose in
autolens_assistant/modes/maintainer.md ("Assistant-as-template", which owns
the boundary) and the executable patterns in _clone.py's REFERENCE_PROFILES.

1. PyAutoBrain/agents/conductors/clone/_clone.py — extend the
   autolens_assistant profile:
   • skills/euclid_*.md, .claude/skills/euclid_*.md, wiki/euclid/* →
     domain (Euclid strong-lensing science; a newborn regrows its own)
   • paper/* → domain (autolens's own JOSS paper)
   • scripts/*_cosmos_web_ring.py → domain (lensing science scripts)
   • .mcp.json → mixed (results-inspector MCP: structure generic, values domain)
2. autolens_assistant/modes/maintainer.md — mirror the same four judgments into
   the "Assistant-as-template" prose.
3. PyAutoBrain/tests/test_clone_conductor.py — add the guard: assert
   partition() over the real autolens_assistant checkout yields zero
   unclassified. No such guard exists today; its absence is exactly why three
   separate features (euclid mode, JOSS paper, MCP) silently re-blocked births.
   Make the trap loud at PR time rather than documenting it.
4. Docs drift rider — PyAutoBrain/AGENTS.md and
   agents/conductors/clone/AGENTS.md both claim the Clone Agent is
   "analysis-only v0 … writes nothing". --apply --mode lightweight-seed is
   implemented and hands a plan to Build. Correct both.

Phase 1 — birth the seed (autocti_assistant)

• Human interactive gate first — confirm name / owner / visibility (default
  PyAutoLabs/autocti_assistant). Never gh repo create unprompted.
• bin/pyauto-brain clone PyAutoCTI --workspace autocti_workspace --apply --mode lightweight-seed
  → 51 generic + 93 mixed files copied with substitutions
  (autolens_assistant→autocti_assistant, al_→ac_, PyAutoLens→PyAutoCTI,
  autolens→autocti); 257 domain files become the PENDING.md growth queue.
  The al_→ac_ derivation is pkg[0]+pkg[4] — autocti[4] is c, so the
  prompt's ac_* naming falls out correctly.
• Heart publish gate legs 1–3 (symbol audit, link sweep, wiki-currency) → flip public.
• Register in PyAutoMind/repos.yaml (category: assistant), then
  python3 scripts/repos_sync.py --write to regenerate the routing tables.

Phase 2 — the ac_* skills

Grounded per-skill against the 118 validated autocti_workspace/scripts/ and
PyAutoCTI/AGENTS.md — never API memory. Ground truth the skills must teach
(all post-resurrection):

• Plotting is the matplotlib function API (aplt.subplot_dataset_1d,
  aplt.subplot_imaging_ci, aplt.plot_cti_1d, *_list). There are no
  *Plotter / MatPlot* / Visuals* objects.
• Multi-dataset fits are factor graphs: af.AnalysisFactor(prior_model=model, analysis=...) per dataset → af.FactorGraphModel(*factors) →
  search.fit(model=fg.global_prior_model, analysis=fg); results come back as a
  list. Analysis summing (analysis + analysis) no longer exists.
• arcticpy install (a guaranteed top-3 user question): needs libgsl-dev + a
  C++ toolchain; pip install numpy cython first, then
  pip install arcticpy==2.6 --no-build-isolation --no-deps — a naive pip install
  downgrades numpy below 2.0. No-root workaround in PyAutoCTI/AGENTS.md; CI
  form in autocti_workspace_test/.github/scripts/smoke_install.sh.
• PYAUTO_TEST_MODE is the knob (2 = sampler bypass). PYAUTOFIT_TEST_MODE
  does not exist. Known artifact: identical-prior ordered-trap models tie at
  prior medians under the bypass and raise their own assertion; real runs are fine.
• Clocker1D(express=, roe=) vs Clocker2D(parallel_express=, parallel_roe=)
  — different kwargs.
• Domain surface: Dataset1D/ImagingCI, Layout1D/Layout2DCI + Region
  objects, FPR/EPER extraction (layout.extract, "fpr"/"eper" in 1D,
  "parallel_fpr"… in 2D), CTI1D/CTI2D, trap species + CCDPhase,
  remove_cti, noise scaling / hyper fits, ac.agg.Dataset1DAgg over the
  consolidated dataset.fits format.

Skills: install (incl. arcticpy), simulate 1D + charge injection, compose+fit
(single and factor-graph), masking + FPR/EPER extraction, correction, plotting,
results + aggregator, workspace navigation, test-mode conventions.

Phase 3 — wiki + project profile

• wiki/core/ — what CTI is, trap physics, FPR/EPER anatomy, the arctic
  algorithm, calibration strategy, parallel vs serial.
• wiki/literature/ — Massey/Israel-line CTI correction, the arctic papers,
  Euclid VIS calibration, HST ACS CTI history, trap pumping, CTI as a weak-lensing
  shape systematic. Public sources only; every citation verified; bib entries
  verbatim from the literature (the autolens_assistant PR#41/Checkpoint-and-continue: supervised runs batch questions instead of blocking #42 pattern).
• wiki/project/profile.md — resurrection state, what is/isn't wired (release
  train pending: draft/release/autocti/cti_release_train_wiring.md), Euclid
  heritage in autocti_workspace_test/legacy/.

Phase 4 — demonstrations + validation

Demonstrations double as validation — the assistant must drive these end-to-end:

1. simulate + calibrate a 1D dataset, recovering input trap density/timescale;
2. simulate + calibrate a small charge-injection image;
3. correct a dataset and show the residual improvement;
4. load results through the aggregator and plot.

Gates: --check-citations clean, link CI green, the demonstration fits actually
run, and Heart leg 4 — the cold-session smoke ("new Opus session + this repo
only" answers an install question and a calibration question correctly).

Key Files

• PyAutoBrain/agents/conductors/clone/_clone.py — REFERENCE_PROFILES
  (boundary patterns), partition(), apply_seed()
• PyAutoBrain/tests/test_clone_conductor.py — the new unclassified guard
• autolens_assistant/modes/maintainer.md — "Assistant-as-template" (owns the boundary)
• PyAutoBuild/autobuild/clone_seed.py — the Hands primitive that executes the birth
• PyAutoHeart/docs/newborn_validation.md — the publish gate (legs 1–4)
• PyAutoMind/repos.yaml + scripts/repos_sync.py — body-map registration
• autocti_workspace/scripts/ — the 118 validated grounding scripts

Verification

• Phase 0: bin/pyauto-brain clone PyAutoCTI --workspace autocti_workspace
  reports unclassified 0 and exits 0; the new guard test fails when a file is
  unclassified; --apply --mode lightweight-seed --no-push builds a seed tree in
  scratch without creating a repo.
• Phase 1: newborn passes Heart legs 1–3; repos_sync.py --write clean.
• Phase 2/3: python autoassistant/audit_skill_apis.py clean;
  --check-citations clean; link CI green.
• Phase 4: the four demonstration fits run and recover input trap models; the
  cold chat-surface smoke answers install + calibration questions correctly.

Original Prompt

Click to expand starting prompt

# Build autocti_assistant — the CTI calibration domain assistant cell

Type: feature
Target: autocti_assistant
Repos:
- @autocti_assistant
- @PyAutoBrain
Difficulty: large
Autonomy: supervised
Priority: normal
Status: formalised

Build **autocti_assistant**, the science-assistant cell for CTI calibration with
PyAutoCTI, seeded from the mature reference assistant cells. This follows the
CTI resurrection epic (all six phases merged 2026-07-17 — PyAutoCTI,
autocti_workspace and autocti_workspace_test are fully modern:
`complete/2026/07/cti-resurrection-phase{0..5}.md`), which makes the domain
assistant the natural next organ of the CTI cell line.

## Original request (verbatim)

> can you draft the prompt to write the autocti_assistant, which il will run in
> opus

## Routing / gates (read before starting)

- **Route through the Clone Agent** (`/clone`) at start_dev time for the
  CloneDecision: exact-clone vs sibling vs seed. `autolens_assistant` is the
  mature reference cell (library-domain assistant, closest shape);
  `autofit_assistant` and the ic50_assistant build
  (`complete/2026/07/build_ic50_assistant_from_autofit_assistant.md`) are the
  precedent runs of this playbook.
- **Repo creation is a human interactive gate** — ask name / org / visibility
  as a dedicated question before any `gh repo create`. Suggested default:
  `PyAutoLabs/autocti_assistant`, public (matching autolens_assistant /
  autofit_assistant).
- **Privacy seam**: PyAutoMemory (`wiki/cti/` — trap physics, the arctic
  algorithm, Euclid VIS / HST ACS heritage, per-topic source bibliographies) is
  the user's private knowledge base. Consult it (via the memory faculty) for
  *pointers and structure*, but a public assistant wiki must be **rebuilt from
  the public literature** with verifiable citations — never copy PyAutoMemory
  pages into a public repo. Bib entries verbatim from the literature; validate
  with the assistant `--check-citations` tooling + link CI (the
  autolens_assistant PR#41/#42 pattern).
- **Intake-classification trap** (hit on the ic50 build): bare library mentions
  steal Target — this is a **new assistant cell**, not a PyAutoCTI change.
  PyAutoCTI is a consumed dependency.
- **Judgment tier throughout**: skills and wiki prose are the product (this is
  why it runs in Opus). Mechanical validation runs may be delegated.

## Ground truth the assistant must teach (post-resurrection API only)

Everything is grounded against the live stack — grep
`autocti_workspace/scripts/` (all 118 scripts validated 2026-07-17) and
`PyAutoCTI/AGENTS.md`, never memory of the old API:

- **Plotting is the matplotlib function API**: `aplt.subplot_dataset_1d`,
  `aplt.subplot_imaging_ci`, `aplt.figure_*`, `aplt.plot_array`/`plot_yx`,
  `aplt.plot_cti_1d`, `*_list` combined subplots. There are **no**
  `*Plotter` / `MatPlot*` / `Visuals*` objects.
- **Multi-dataset fits are factor graphs**: `af.AnalysisFactor(prior_model=
  model, analysis=...)` per dataset → `af.FactorGraphModel(*factors)` →
  `search.fit(model=factor_graph.global_prior_model, analysis=factor_graph)`;
  results come back as a list (`result_list[0].max_log_likelihood_fit`).
  Analysis summing (`analysis + analysis`) no longer exists.
- **arcticpy install recipe** (a top-3 user question, guaranteed): needs
  `libgsl-dev` + a C++ toolchain; `pip install numpy cython` first, then
  `pip install arcticpy==2.6 --no-build-isolation --no-deps` — a naive pip
  install **downgrades numpy below 2.0**. No-root header workaround in
  `PyAutoCTI/AGENTS.md`; CI form in
  `autocti_workspace_test/.github/scripts/smoke_install.sh`.
- **Test/fast-mode conventions**: the knob is `PYAUTO_TEST_MODE` (2 = sampler
  bypass; `PYAUTOFIT_TEST_MODE` does not exist). Known artifact: identical-
  prior ordered-trap models tie at prior medians under the bypass and raise
  their own assertion (filed autofit issue) — real runs are fine.
- **Domain surface**: `Dataset1D` / `ImagingCI`, `Layout1D`/`Layout2DCI` +
  Region objects, FPR/EPER extraction (`layout.extract`, region strings
  `"fpr"/"eper"` in 1D and `"parallel_fpr"`… in 2D), `Clocker1D(express=, roe=)`
  vs `Clocker2D(parallel_express=, parallel_roe=)` (different kwargs!),
  `CTI1D`/`CTI2D`, trap species + `CCDPhase`, correction
  (`remove_cti`), noise scaling / hyper fits, the aggregator
  (`ac.agg.Dataset1DAgg` etc. over the consolidated `dataset.fits` format).

## Scope sketch (to be firmed at start_dev / clone-agent time; expect phases)

1. **Seed the cell** from the CloneDecision's reference: AGENTS.md (persona:
   CTI-calibration assistant; include the chat handshake — "chat use requires
   the GitHub connector; tell me if you can actually read the repo"),
   CLAUDE.md pointer, config, citation/link tooling, Makefile/activate
   conventions (mind the venv trap: clear PYTHONPATH).
2. **Skills** (`skills/ac_*.md`, grounded per-skill against
   autocti_workspace's validated scripts): install (incl. arcticpy),
   simulate 1D + charge injection, compose + fit a CTI model (single and
   factor-graph multi-dataset), masking + FPR/EPER extraction, correction,
   plotting (function API), results + aggregator, workspace navigation,
   test-mode/fast-run conventions.
3. **Wiki**: `wiki/core/` (what CTI is, trap physics, FPR/EPER anatomy, the
   arctic algorithm, calibration strategy, parallel vs serial) and
   `wiki/literature/` (concepts/entities/sources for: Massey/Israel-line CTI
   correction, the arctic papers, Euclid VIS CTI calibration, HST ACS CTI
   history, trap pumping, CTI as a weak-lensing shape systematic) — public
   sources only, every citation verified.
4. **Project profile** (`wiki/project/profile.md`): the resurrection state,
   what is and is not wired (release-train wiring pending —
   `draft/release/autocti/cti_release_train_wiring.md`), Euclid heritage in
   `autocti_workspace_test/legacy/`.
5. **Demonstrations** (the assistant must be able to drive these end-to-end,
   and they double as its validation): simulate + calibrate a 1D dataset
   (recover the input trap density/timescale), simulate + calibrate a small
   charge injection image, correct a dataset and show the residual
   improvement, load results through the aggregator and plot.
6. **Validation**: `--check-citations` clean, link CI green, the demonstration
   fits run, and a cold-session smoke ("new Opus session + this repo only"
   answers an install question and a calibration question correctly).

[Jammy2211]

Phase 0 shipped — the birth is unblocked

Two PRs open, merge in this order:

1. feat(clone): classify the reference boundary and guard it per-PR #137 — profile patterns, check_boundary.py, tests, docs
2. docs(maintainer): classify the euclid mode, paper/ and .mcp.json; guard the boundary in CI autolens_assistant#76 — the boundary prose + the per-PR CI guard

#76's boundary job is expected to fail until #137 merges (it runs #137's
check_boundary.py, which isn't on main yet). Re-run its checks after #137 lands.

What was wrong

clone --apply hard-failed at exit 4 — 39 tracked files in autolens_assistant
matched no template-boundary pattern. The euclid mode, the JOSS paper, the
results-inspector MCP wiring and the cosmos_web_ring scripts each shipped after
the boundary was last written. This blocked every assistant birth, not just this
epic's; it went unnoticed because nothing checks until a birth is attempted, and by
then the person blocked is not the person who added the file.

The four judgments

What	Verdict	Why
euclid mode (skills/euclid_*.md + wiki/euclid/*)	domain	survey-specific register; lensing science throughout
paper/*	domain	this assistant's own JOSS paper; a newborn writes its own
scripts/*.py	domain	bundled science scripts for a named lens
.mcp.json	generic (shared)	only wires autoassistant.mcp, already generic tooling — carries no domain

.mcp.json was planned as mixed; reading it showed otherwise. The Clone Agent's
own rule — "an unclassified file is a gap to fix… never guessed past" — applies to
the person fixing it too.

Verification

• pytest tests/ → 136 passed (11 new hermetic cases pinning the judgments)
• clone PyAutoCTI --workspace autocti_workspace → exit 0, unclassified 0 (was exit 4 / 39)
• both references clean: autolens 52·295·93·0, autofit 104·20·21·0; totals reconcile at 440
• --apply --mode lightweight-seed --no-push → seed built: 145 copied, 388 PENDING; al_→ac_ substitution correct
• check_boundary.py proven on all four paths: passes / fails on an unclassified file / skips on a non-reference (what a newborn inherits) / errors on a --reference typo

Two corrections to the approved plan, made during implementation

1. The guard moved repos. PyAutoBrain has 10+ test files and no CI that runs
   pytest at all, so a guard there would never fire automatically. It now runs in
   autolens_assistant's CI, where the drift originates — so the author who adds a
   file classifies it. (The PyAutoBrain-has-no-test-CI gap is worth its own prompt.)
2. The docs drift was wider than two files — six places claimed "analysis-only
   v0 / writes nothing", including skills/clone/SKILL.md, whose description is
   what a session reads before invoking /clone. --apply --mode lightweight-seed
   has been live since v1.

⚠️ Ship gate: Heart RED, human-authorised override

Shipped to PR-open only on explicit human authorisation. Heart's verdict, verbatim:

- PyAutoLens: 1 uncommitted source change(s)
- workspace validation not passing (3 failed, 2026-07-09T09-48-30Z)
- 58 stale parked script(s)
- manifest drift: tenant firewall (organ code) — 7 mismatch(es) vs PyAutoMind/repos.yaml
- release validation stale: source moved since rehearsal (PyAutoConf, PyAutoFit, PyAutoArray, PyAutoGalaxy, PyAutoLens)

None involve this change: PyAutoBrain is clean on main in Heart's own scan, and
autolens_assistant is not among the 25 repos Heart tracks. Merge stays human.

Next — Phase 1 (birth the seed)

Blocked on merging both PRs, then:

• Human gate: repo name / owner / visibility (default PyAutoLabs/autocti_assistant).
  You answered public — note clone_seed.py births private and flips public
  only after Heart's publish gate (legs 1–3, PyAutoHeart/docs/newborn_validation.md).
  End state is public, so the privacy seam stays in force: PyAutoMemory wiki/cti/
  for pointers only, never copied.
• Then --apply --mode lightweight-seed, Heart legs 1–3, flip public, register in
  repos.yaml + repos_sync.py --write.

[Jammy2211]

Phase 0 MERGED — the birth is unblocked ✅

• PyAutoBrain#137 merged → 8db0c8e
• autolens_assistant#76 merged → dfa07b1

The guard proved itself on the way in

#76's boundary job went from fail (its checker didn't exist on main yet) to
pass the moment #137 landed — and it graded rather than skipped:

check_boundary: autolens_assistant boundary complete — generic 53 · domain 295 · mixed 93

That is the whole mechanism working end-to-end, in CI, on a real PR. From now on a
file landing in autolens_assistant that falls on neither side of the template
boundary fails its own PR, naming the file and the two places that must agree —
instead of silently blocking every future assistant birth until someone tries one.

Verified on clean main (post-merge)

Check	Before Phase 0	Now
clone PyAutoCTI --workspace autocti_workspace	exit 4, 39 unclassified	exit 0, unclassified 0
Risk list	"39 reference file(s) unclassified"	gone
check_boundary.py ../autolens_assistant	(did not exist)	boundary complete, 53·295·93
pytest tests/test_clone_conductor.py	16 passed	27 passed

Phase 0 scope, as merged

• All 39 files classified in both places that must agree — _clone.py's
  REFERENCE_PROFILES and modes/maintainer.md's owning prose.
• check_boundary.py + clone-boundary.yml — the per-PR guard.
• Six stale "analysis-only v0 / writes nothing" docs claims corrected;
  --apply --mode lightweight-seed has been live since v1. skills/clone/SKILL.md
  now advertises seed births instead of telling sessions the agent "must not
  generate files".

---

Next: Phase 1 — birth the seed

Blocked on one human gate: repo name / owner / visibility
(default PyAutoLabs/autocti_assistant). Nothing is created before that answer.

Then: clone PyAutoCTI --workspace autocti_workspace --apply --mode lightweight-seed
→ born private → Heart legs 1–3 (PyAutoHeart/docs/newborn_validation.md) →
flip public → register in repos.yaml + repos_sync.py --write.

Dry run already confirms what Phase 1 will produce: 145 files copied
(53 generic + 93 mixed… now 146 with the new workflow) and 388 PENDING entries,
with al_ → ac_ substitution correct.

Follow-up found during Phase 0 (unfiled, worth its own prompt)

PyAutoBrain has 10+ test files and no CI that runs pytest — only docs.yml and
nightly-release.yml. Its whole suite is local-only. That is why Phase 0's guard had
to live in autolens_assistant's CI rather than here.

[Jammy2211]

Phase 1 — the cell is born 🎉 (private; publish gate 2/3)

PyAutoLabs/autocti_assistant exists
— 3a7a382, private, 151 tracked files (146 copied + scaffolds), 388 PENDING
entries. Registered in PyAutoMind/repos.yaml (category: assistant).

Substitution landed cleanly: activate.sh swapped PyAutoLens→PyAutoCTI and
al_setup_environment→ac_setup_environment; PENDING lists ac_* skills.

Phase 0's guard paid off immediately

The newborn inherited clone-boundary.yml (.github/* is generic), and the
skip-when-unprofiled path added in #137 is what saves it:

check_boundary: autocti_assistant is not a clone reference — nothing to grade  (exit 0)

Without that, this cell's first CI run would have failed on arrival.

Heart publish gate (PyAutoHeart/docs/newborn_validation.md)

Leg	Result
1 — symbol audit	✅ 10/10 resolve, 0 missing
2 — link sweep	✅ 0 dangling across 37 markdown files
3 — wiki-currency	❌ fails — see below
4 — chat smoke	deferred (needs the public URL)

Leg 1 needed care to be honest. It first reported 3 failures — all
ModuleNotFoundError: autocti, because the ambient PYTHONPATH carries the editable
checkouts but omits PyAutoCTI. Setting PYTHONPATH=.../PyAutoCTI replaced that path
and silently dropped autoarray/autofit to older site-packages (2026.4.5.3) — a pass
against a stack nobody runs. Appending instead of replacing gives the real gate: autocti
from source against autoarray/autoconf/autofit/autogalaxy = 2026.7.9.1, 10/10 clean.

⚠️ Leg 3 blocks publish — and it is an inherited-content problem, not a seed bug

The copied wiki-currency.yml installs the released stack from PyPI
(pip install autocti==$VER). That is the autolens shape, where the library is released.
For CTI it produces:

versions: autoconf=2024.11.13.2, autoarray=2024.11.13.2, autofit=2024.11.13.2
missing from this interpreter: autogalaxy
autocti import failed: ModuleNotFoundError: No module named 'arcticpy'
[install] IMPORT FAILED   → exited 3, so the checks never ran

Three distinct faults, all from the same root — .github/* is classified blanket-generic,
but this workflow's install step encodes the lensing stack:

1. arcticpy is never installed. It is a hard import of autocti but not a pip dependency
   (source-only sdist; needs libgsl-dev + cython; its own requirements downgrade numpy
   below 2.0). Known-good recipe already exists in
   autocti_workspace_test/.github/scripts/smoke_install.sh.
2. PyPI autocti is a stale 2024 wheel. The CTI release train is not wired
   (draft/release/autocti/cti_release_train_wiring.md, human-required), so "latest
   released" is pre-resurrection. Grading modern docs against it would pass vacuously.
   Note leg 3's own spec says "sources clone @ main, doc-pin truth, not the release
   wheel" — the inherited workflow contradicts the gate it is meant to satisfy.
3. autogalaxy is expected but is not a CTI dependency.

This is a boundary finding worth carrying back to the reference: .github/* as
blanket-generic is too coarse — a workflow's install step is domain content. Same shape as
the 39 files Phase 0 fixed, found one layer deeper, and only surfaceable by an actual birth.

State: safe and parked

The cell is private and the gate is doing its job — nothing is published on a red leg.
Legs 1–2 pass. Flipping public needs leg 3, which needs a decision (adapt the newborn's
wiki-currency to install from source + arcticpy, vs wait on the CTI release train). Next
session should take that decision before Phase 2 skills.

[Jammy2211]

Phase 1 follow-up — seed infra fixed to the CTI stack (autocti_assistant#1)

Investigating leg 3 revealed the seed's inherited "generic" infrastructure carries
lensing-stack assumptions — the same boundary leak Phase 0 fixed for file
classification, one layer deeper: a workflow's install step and an audit's
module list are domain content, not framework. Two fixes, both verified:

1. wiki-currency.yml install — was pip install autocti from PyPI (autolens
   shape). Now installs from the main source clones + the arcticpy recipe
   (mirrored from the proven autocti_workspace_test/.../smoke_install.sh), with a
   pinned-PyPI path kept for a future release-time workflow_call. PyAutoGalaxy no
   longer cloned.
2. audit_skill_apis.py — autogalaxy was in the stack module lists (autolens
   sits on autogalaxy; autocti's deps are autoconf/autoarray/autofit only). It made
   --check-version exit not_installed for a correctly configured CTI user at
   session start — the check AGENTS.md runs every code session. Removed from the
   four hardcoded stack tuples.

Verified: --check-version now reaches the honest "no baseline — run
--write-baseline first" instead of "import failed / autogalaxy missing";
--scope all still 10/10.

The important reframe: leg 3 green is a Phase 2-3 milestone, not an infra fix

The seed is bare — 0 ac_* skills, wiki/core is a lone README, no
api_audit_baseline.json. So even with the install fixed, --check-version
legitimately fails on no baseline. The baseline is a domain artifact written
(via --write-baseline) once real skills are validated against the stack — i.e.
Phase 2-3. Writing one now against an empty seed would be gaming the gate
(a vacuous green), which is worse than an honest red.

So: leg 3's infrastructure is now correct and green-able; its remaining
redness is content-not-yet-authored. The newborn stays private until Phase 2-3
give it skills + wiki + an honest baseline. That is the right outcome — an empty
CTI assistant that can answer nothing should not be published.

Publish-gate status

Leg	State
1 symbol audit	✅ pass
2 link sweep	✅ pass
3 wiki-currency	🟡 infra fixed; honestly red on "no baseline" → Phase 2-3
4 chat smoke	deferred (needs public URL)

Boundary finding for the reference (systemic follow-up)

autolens_assistant's "generic" tier has absorbed lensing-stack assumptions in
several places: autogalaxy in the audit; the PyPI-install shape in
wiki-currency; _bootstrap_skill.md and maintainer.md naming PyAutoGalaxy. The
durable fix is reference-side — domain-parameterize or reclassify these so
future births (autogalaxy_assistant, …) don't each re-hit it. Worth its own
prompt against autolens_assistant + _clone.py.

[Jammy2211]

Phase 2 — the seed is now a working assistant (autocti_assistant#2)

Nine ac_* skills covering the CTI calibration pipeline end-to-end, each
grounded in a validated autocti_workspace script (not API memory) and
verified against the live stack:

ac_setup_environment (arcticpy!), ac_workspace_navigation,
ac_simulate_dataset_1d, ac_simulate_imaging_ci, ac_mask_and_extract,
ac_fit_cti_model (the factor-graph joint fit — the core), ac_correct_cti,
ac_plot (function API), ac_load_results (aggregator).

Wired: .claude/skills/ symlinks, a rewritten honest skills/README.md (the
old one was the autolens catalogue — 45 listed, 13 existed), PENDING pruned.

Grounding corrected the seed prompt twice

• Aggregator is ac.agg.CTIAgg, not Dataset1DAgg (both exist; scripts use CTIAgg).
• Plot scripts live at scripts/plot/, not per-geometry — the citation check caught my first draft.

Every wiki-currency check now green (locally)

--scope all  PASS · --check-citations PASS · --lint-idioms PASS
--check-provenance PASS · --check-version PASS (baseline written)

The audit caught, and I fixed: aplt.Output / analysis + analysis written in
prose to say they're gone (parser can't tell), a wildcard token, wrong plot
paths, and the last _style.md lensing-path leak.

Publish gate

Leg	State
1 symbol audit	✅
2 link sweep	✅
3 wiki-currency	✅ expected green — baseline written, all 5 checks pass (CI running on #2)
4 chat smoke	Phase 4 (needs public URL)

Legs 1–3 are on track to all pass — which is the gate for going public. But
Phase 3 (wiki) and Phase 4 (demonstrations + cold smoke) come first; the
newborn stays private until it has a reference wiki and its demonstration
fits are proven. Publishing a skills-only assistant with an empty wiki/core/
would be premature.

Next

• Phase 3 — wiki/core/ (CTI physics, trap model, FPR/EPER anatomy, the
  arctic algorithm, parallel vs serial) + wiki/literature/ (public sources,
  verified citations) + wiki/project/profile.md.
• Phase 4 — the four demonstrations (simulate+calibrate 1D recovering input
  traps; simulate+calibrate a CI image; correct + show residual; aggregate+plot)
  and the cold-session smoke, then flip public.

[Jammy2211]

Phase 2 MERGED — autocti_assistant#2 (557ba0b). wiki-currency went green in CI (the baseline held against CI's fresh main install — no version drift), and boundary skips. Publish-gate legs 1–3 all pass.

The assistant now has 9 grounded, CI-validated CTI skills on main. It stays private pending Phase 3 (wiki) + Phase 4 (demonstrations + cold smoke) — legs 1–3 green is the gate to publish, but an assistant with an empty wiki/core/ and no proven demonstration fits shouldn't go public yet.

[Jammy2211]

Phase 3 — the knowledge layer (autocti_assistant#3, CI running)

The wiki the skills cite into is now written.

• wiki/core/ — CTI reference: index + 6 concept pages (what CTI is, trap
  physics, FPR/EPER anatomy, the arctic algorithm, calibration strategy, parallel
  vs serial), grounded in the library + workspace.
• wiki/literature/ — a corpus built from public sources only, every
  citation verified via web search against arXiv/ADS (privacy seam held: I
  consulted PyAutoMemory wiki/cti/ for structure/pointers only, then wrote all
  content from public knowledge — never copied). 8-paper bibliography (Massey
  2010/2013/2014, Anderson & Bedin 2010, Israel 2015, Short 2013, Skottfelt 2017),
  6 topic source pages, 3 entities, schema.
• wiki/project/state.md — resurrection state, the unwired release train, the
  legacy/ heritage. Kept out of profile.md (that's the on-demand user
  profile — session-start reads it).

Three findings worth recording

1. Web verification corrected my memory three times (Short 2013 is
   arXiv:1302.1416; Israel is 1506.07831). The "never fabricate metadata" rule is
   real — I verified rather than trusted memory, and it mattered.
2. --check-citations does not check markdown links — only Project:path
   code citations. A separate link sweep caught systematic relative-path depth
   errors in the 3-deep concepts//sources//entities/ pages. Both checks are
   needed.
3. profile.md is the on-demand user profile (AGENTS.md reads it at session
   start to calibrate depth). Project state therefore went in state.md, not
   profile.md as the prompt's wording suggested — putting it in profile.md
   would break that semantics.

Also de-lensed two generic seed files that had leaked lensing content (the wiki/
README's non-existent euclid/ row; wiki/project/README's lensing slugs).

Validation

--scope all · --check-citations · --lint-idioms · --check-provenance ·
--check-version all pass; wiki link sweep 0 dangling.

Publish gate

Legs 1–3 remain green. Phase 4 next — the four demonstrations (recover input
trap models) + the cold-session smoke, then flip public. Newborn stays private.

[Jammy2211]

Phase 3 MERGED — autocti_assistant#3 (f061651). wiki-currency green in CI, boundary skips; publish-gate legs 1–3 still all pass with the full wiki on main. Only Phase 4 remains (demonstrations + cold smoke → flip public); newborn stays private.

[Jammy2211]

Phase 4 — the assistant proves it works (autocti_assistant#4, CI running)

Four runnable demonstrations, all run for real against the live stack (arctic
clocking, real Nautilus fits), each asserting its result:

Demo	Result
calibrate 1D — recover input traps	density 0.1300 → 0.1323, release 1.2500 → 1.2608 ✅
calibrate 2D charge-injection	density 0.1300 → 0.1334, release 1.2500 → 1.3123 ✅
correct CTI	EPER trail 3.9× suppressed ✅
aggregate results	model round-trips from disk ✅

Two caught real issues I fixed rather than hid:

• Factor-graph aggregation: a factor-graph fit stores results per-factor, so
  the aggregator's max_log_likelihood_instance is None — the reloaded instance
  is indexed (instance[0].cti). Demo 4 uses the samples path.
• Demo 2 honesty: my first over-trimmed version recovered density but not the
  release timescale (1.25 → 2.90). Genuine under-constraint — I fixed the data
  (three cleaner injection levels), not the assertion.

Cold-session front door: de-lensed llms.txt (it said "for doing strong-lens
science" / "explain lensing"); now frames CTI and routes to the reference. The two
cold-start questions (install, calibration) are answerable from the repo alone.

Validation: all five audit checks pass.

Remaining lensing leak

scripts/AGENTS.md still describes lensing SLaM pipelines — a bigger CTI-pipeline
rewrite, flagged with the systemic reference-side boundary finding (generic files
that absorbed lensing content: the audit's autogalaxy, the PyPI-install shape,
_bootstrap_skill.md, now scripts/AGENTS.md).

Publish gate — legs 1–4 substantively complete

The demonstrations run and recover; the cold front door is honest; legs 1–3 stay
green. The final act — flipping the repo public — is deliberately left for your
explicit approval. The epic is otherwise complete: a working, documented,
validated CTI assistant.

[Jammy2211]

Phase 4 MERGED — autocti_assistant#4 (1337a68), wiki-currency green. All four phases are now on main. The repo is confirmed still private.

The epic is substantively complete: a working, documented, validated CTI assistant — 9 grounded skills, a CTI reference + verified literature wiki, four demonstrations that recover input traps, and an honest cold-session front door. Publish-gate legs 1–3 pass in CI; the demonstrations are leg 4's substance.

The one remaining act — flipping the repo public — is left for explicit human approval (outward-facing, effectively irreversible). Noted for that decision: scripts/AGENTS.md still carries lensing SLaM-pipeline content (the last of the systemic generic-file lensing leaks; needs a CTI-pipeline rewrite).

[Jammy2211]

Epic COMPLETE and closing. PyAutoLabs/autocti_assistant is now public (flipped on approval after Heart newborn-validation legs 1–4). All 5 phases merged; a working, documented, validated CTI assistant — 9 grounded skills, a CTI reference + web-verified literature wiki, and 4 demonstrations that recover input traps. Completion record: PyAutoMind/complete/2026/07/autocti-assistant.md. Open follow-ups noted there (reference-side de-lensing, scripts/AGENTS.md, PyAutoBrain CI, the CTI release train).