eyes: default instance → lens/autolens_visualization; layered project-repo/organ prose (PyAutoMind#446)

AGENTS.md

@@ -24,7 +24,7 @@ Canonical boundaries live in `PyAutoBrain/ORGANISM.md`; the full body map
 | **Hands** | PyAutoHands | Packaging, tagging, notebook generation, PyPI release execution. |
 | **Nerves** | PyAutoNerves | The Nerves — the configuration/serialization layer connecting workspace conventions to libraries (layered config, version handshake, test_mode), delivered as the `autonerves` package. |
 | **Gut** | PyAutoGut | Owns the lifecycle of condemned self-material (stale branches, stashes, dead code/tests): holds it as durable, recoverable git refs through a transit window and voids it on a sweep. The storage mirror of Memory (retention vs release). |
-| **Eyes** | PyAutoEyes | The Eyes — where the organism sees what its figures look like: one rendered gallery per library (lens, galaxy, fit, cti) of every visualizer output on realistic data, the harness that renders them, the instance registry and the board that is the single point of contact for the visual behaviour of the whole ecosystem. Renders and holds figures; never judges them (the Brain's Eyes conductor does) and never edits library plot code (critiques route through intake). |
+| **Eyes** | PyAutoEyes | The Eyes — where the organism sees what its figures look like: the cross-project visualization dashboard over the `<lib>_visualization` project repos (autolens_visualization first) — the registry of those repos, the tracked-manifest read contract (`gallery/viz_manifest.yaml`) and the Pages board that links to their PNGs as the single point of contact for the visual behaviour of the whole ecosystem. Renders nothing and copies no figures (the project repos render and hold them); never judges them (the Brain's Eyes conductor does) and never edits library plot code (critiques route through intake). |
 
 Call chain (always this order): **Brain → Heart (gate) → Build (execute)**. Brain agents are **conductors** (front-door; a human drives them; they decide *and* act) or **faculties** (read-only opinions the conductors consult; they judge and stop). New capability grows as a faculty, not a new organ, unless it owns state or effects no existing organ can.
 

agents/conductors/eyes/AGENTS.md

@@ -4,11 +4,11 @@
 > function* — the organism's sense of its own appearance: it owns the
 > render → present → critique → delegate loop over a project's visualization
 > surface. It consults the read-only memory faculty for style/paper context
-> like every conductor; it never renders (the **PyAutoEyes** organ's harness
-> does — `gallery/gallery_run.sh` in each instance), never edits plot source,
-> and delegates every accepted change via intake → start_dev. The conductor
-> drives the Eyes organ exactly as vitals reads the Heart: the organ renders
-> and holds the figures, the conductor judges them with the human.
+> like every conductor; it never renders (each visualization project repo's
+> harness does — `gallery/gallery_run.sh`), never edits plot source, and
+> delegates every accepted change via intake → start_dev. The project repos
+> render and hold the figures, the **PyAutoEyes** organ is the dashboard over
+> them, and the conductor judges them with the human.
 
 Grown from demonstrated need: the organism produces rich visualizations
 (imaging / interferometer / point_source / multi / cluster) but had no formal
@@ -24,12 +24,19 @@ The deterministic core consumes any **visualization workspace**: a repo with
 visualization scripts, plus `output/gallery/` from its gallery builder. The
 workspace root is always a CLI argument — the `.py`/`.sh` here name no
 repositories (tenant firewall); the instance pointer lives in this prose and
-in the `/eyes` skill. Default instance: the **PyAutoEyes** lens gallery,
-`organs/PyAutoEyes/lens` (the organ holds one instance subtree per library —
-lens, galaxy, fit, cti; PyAutoEyes phase 1 moves today's flat checkout into
-`lens/`, so until it lands the instance root is `organs/PyAutoEyes` itself).
-`autolens_workspace_test` remains a secondary instance (its `gallery/`
-harness is retired by PyAutoEyes phase 5).
+in the `/eyes` skill. Default instance: the lens visualization project repo,
+**`lens/autolens_visualization`**. `autolens_workspace_test` remains a
+secondary instance (its `gallery/` harness is retired by PyAutoEyes phase 5).
+
+Two layers (human decision 2026-09-28): **project repos**
+`<lib>_visualization` (lens first: `lens/autolens_visualization`) make, store
+and track one library's figures — producers, datasets, tracked PNGs,
+`GALLERY.md`, a tracked `gallery/viz_manifest.yaml` and the
+`gallery/gallery_run.sh` harness; **the organ PyAutoEyes** is the
+cross-project dashboard that reads each project repo's tracked manifest and
+links to its PNGs — it renders nothing and copies no figures. The organ's
+`registry.yaml` listing every instance arrives in PyAutoEyes phase 1b/2;
+until then the instance is named here and in the `/eyes` skill.
 
 ## Modes
 
@@ -57,8 +64,9 @@ harness is retired by PyAutoEyes phase 5).
 ## Boundaries
 
 - Decision-only, stdlib-only core: reads the filesystem, writes nothing.
-- Rendering and figure regeneration belong to the Eyes organ (or the
-  workspace instance); the conductor only tells you they are stale.
+- Rendering and figure regeneration belong to the visualization project
+  repo (the instance); the PyAutoEyes organ only aggregates them on its
+  dashboard; the conductor only tells you they are stale.
 - Paper-informed passes (`review --against`): the reference figures are
   gathered by the session (PDF pages read directly, or panels extracted to a
   directory) — the core never fetches anything. The reviewing session reads

bin/clean_slate.sh

@@ -74,10 +74,14 @@ PACKAGING_REPOS=(PyAutoNerves PyAutoFit PyAutoArray PyAutoGalaxy PyAutoLens)
 # whose dataset/ is auto-simulated but whose results/ are tracked witnesses — it
 # is swept by its own tooling, never here. autolens_jax_joss was excluded here
 # for the same reason (JWST cosmos_web_ring); its local checkout was removed in
-# 2026-09 (PyAutoBrain#389) and the repo lives on GitHub only. The Eyes organ
-# (organs/PyAutoEyes) is excluded too: its instances' dataset/ trees are the
-# tracked realistic inputs its galleries are rendered from and its PNG renders
-# are the tracked record (re-rendered on library release only) — never wiped.
+# 2026-09 (PyAutoBrain#389) and the repo lives on GitHub only. The
+# visualization project repos (`<lib>_visualization`, category project in the
+# body map; the lens one sits under lens/) are excluded too: their dataset/
+# trees are the tracked realistic inputs their galleries are rendered from (the
+# lens hst imaging is a byte-identical copy of autolens_profiling's) and their
+# PNG renders are the tracked record (re-rendered on library release only) —
+# never wiped. The Eyes organ (organs/PyAutoEyes) is the cross-project dashboard
+# over such project repos and holds no datasets of its own to wipe.
 DATASET_REPOS=(autolens_workspace autogalaxy_workspace autofit_workspace \
                autocti_workspace HowToLens HowToGalaxy HowToFit)
 # Committed dataset files above this size are flagged as repo bloat.

docs/organs/eyes.md

@@ -1,9 +1,11 @@
 # Eyes — PyAutoEyes
 
-**What it owns:** the *perception lifecycle* — one **rendered gallery per
-library** (lens, galaxy, fit, cti) of every visualizer output on realistic
-data, the manifests that inventory them, the one harness that renders them,
-the instance registry and the board. The Eyes are the perception mirror of the
+**What it owns:** the *perception lifecycle* as a **cross-project dashboard**
+over the `<lib>_visualization` project repos (lens first:
+`autolens_visualization`) — the registry of those repos, the read contract of
+their tracked `gallery/viz_manifest.yaml` manifests and the board that links to
+their PNGs. The project repos render and hold the figures; the organ renders
+nothing and copies no figures. The Eyes are the perception mirror of the
 Heart: the Heart says whether the software is *healthy*; the Eyes show what it
 *shows*.
 
@@ -12,28 +14,32 @@ Heart: the Heart says whether the software is *healthy*; the Eyes show what it
 ## The defining function: seeing
 
 Every PyAuto library draws, on one shared plotting API — and the figures a
-library draws are the part of it a user sees first. The Eyes render each
-library's figures on fixed, realistic datasets (HST-scale imaging, an SMA-like
-interferometer, and their equivalents per library) and keep the PNGs **in
-git**, so a figure's history is a `git log` and a visual regression is a diff.
-Figures are **re-rendered on library release only**: a release is the moment
-the record changes.
+library draws are the part of it a user sees first. Each library's project
+repo renders its figures on fixed, realistic datasets (HST-scale imaging, an
+SMA-like interferometer, and their equivalents per library) and keeps the PNGs
+**in git**, so a figure's history is a `git log` and a visual regression is a
+diff. Figures are **re-rendered on library release only**: a release is the
+moment the record changes, and the project repo's render workflow then pings
+the organ (`repository_dispatch: eyes-refresh`) to refresh the board.
 
 ## Instances
 
-The organ holds one instance subtree per library, each with the same layout —
+Each instance is a project repo `<lib>_visualization` with the same layout —
 `scripts/<domain>/visualization.py` producers, `scripts/<domain>/images/`
-renders, `output/gallery/{gallery.html,viz_manifest.yaml}` and a `GALLERY.md`
-index. The lens instance (`lens/`) is the first; galaxy, fit and cti follow.
-An instance registry (`registry.yaml`) names every instance, its library and
-its domains, and the board shows each one's figure count, stale renders, gaps
-and open critiques — the single point of contact for the visual behaviour of
-the whole ecosystem.
+renders, a tracked `gallery/viz_manifest.yaml` (every figure's producer,
+domain, source type, path, size and content hash, plus the stack it was
+rendered with), `output/gallery/gallery.html` and a `GALLERY.md` index.
+`autolens_visualization` is the first; galaxy, fit and cti follow. The organ's
+instance registry (`registry.yaml`, PyAutoEyes phase 1b/2) names every
+instance, its library and its domains, and the board shows each one's figure
+count, stale renders, gaps and open critiques — the single point of contact
+for the visual behaviour of the whole ecosystem.
 
 ## The driver split
 
-The Eyes *render and hold* figures; they judge nothing. The Brain's **Eyes
-conductor** (`bin/pyauto-brain eyes`, `/eyes`) surveys an instance, prepares
+The project repos *render and hold* figures and the Eyes *show* them; neither
+judges anything. The Brain's **Eyes conductor** (`bin/pyauto-brain eyes`,
+`/eyes`) surveys an instance, prepares
 the review surface and walks the human through the figures — the same split
 as **Heart ↔ vitals** and **Gut ↔ hygiene**: the organ keeps the state, the
 conductor reasons over it.
@@ -52,10 +58,11 @@ conductor reasons over it.
 
 Like Mind, Cortex, Memory and Gut, the Eyes are an **instance organ** —
 inherently yours. You do not fork this repo's figures; you create your own
-Eyes with the same shape, rendering your own libraries.
+Eyes with the same shape, over your own libraries' visualization project
+repos.
 
 The birth of this organ is tracked in the `pyautoeyes-birth` epic
 ([PyAutoMind#437](https://github.com/PyAutoLabs/PyAutoMind/issues/437) is
-phase 0). The repo was renamed from `autolens_visualization`, so its lens
-gallery is already rendered; phase 1 moves it into the `lens/` instance and
-adds the harness package, registry and CLI.
+phase 0). Phase 1a (PyAutoMind#446) moved the lens gallery back into its own
+project repo, `autolens_visualization`, with the tracked manifest; phase 1b
+strips the organ to the dashboard skeleton and adds the registry.

skills/eyes/eyes.md

@@ -5,13 +5,20 @@ visualization surface, via PyAutoBrain's **Eyes Agent** (the *perceptive
 function*). You never name the Brain; this command is the door.
 
 Shared routing context: `PyAutoBrain/skills/COMMANDS.md`. The default
-visualization instance is the **PyAutoEyes** lens gallery,
-**`organs/PyAutoEyes/lens`** — the Eyes organ holds one rendered gallery per
-library (lens, galaxy, fit, cti). PyAutoEyes phase 1 moves today's flat
-checkout into `lens/`; until it lands, pass `organs/PyAutoEyes` itself.
-`autolens_workspace_test` (the original reference instance from epic
-PyAutoBrain#117 Phase 1) remains a secondary instance; pass a different
-instance root to review another project.
+visualization instance is the lens visualization project repo,
+**`lens/autolens_visualization`**. `autolens_workspace_test` (the original
+reference instance from epic PyAutoBrain#117 Phase 1) remains a secondary
+instance; pass a different instance root to review another project.
+
+Two layers (human decision 2026-09-28): **project repos**
+`<lib>_visualization` (lens first: `lens/autolens_visualization`) make, store
+and track one library's figures — producers, datasets, tracked PNGs,
+`GALLERY.md`, a tracked `gallery/viz_manifest.yaml` and the
+`gallery/gallery_run.sh` harness; **the organ PyAutoEyes** is the
+cross-project dashboard that reads each project repo's tracked manifest and
+links to its PNGs — it renders nothing and copies no figures. The organ's
+`registry.yaml` listing every instance arrives in PyAutoEyes phase 1b/2;
+until then the instance is named here and in the conductor's AGENTS.md.
 
 ## Do