pen-stack 5.9.0__tar.gz → 5.11.0__tar.gz

{pen_stack-5.9.0 → pen_stack-5.11.0}/CHANGELOG.md

@@ -3,6 +3,67 @@
 All notable changes to PEN-STACK are documented here. This file follows
 [Keep a Changelog](https://keepachangelog.com/) and the program's phase structure.
 
+## [5.11.0] - 2026-06-11 - v5.11 release: The Build Interface (digital→physical bridge)
+
+**Closed-Loop arc, Cycle 5 of 7.** Make designs executable and results ingestible — loop-ready, lab-optional,
+safety-gated, with the immune-risk profile attached as protocol metadata. Workstreams WS-{PROTO,INGEST,SIMLAB},
+SHA-locked.
+
+### Added
+- **WS-PROTO** — `pen_stack/build/protocol.py`: `export_protocol(design, experiment, target, actor)` for
+  Opentrons / PyLabRobot / cloud-lab. Runs `verify()` **first**: a safety-`refuse` or illegal design raises
+  **`ProtocolExportError`** (no export path for a flagged design); a cleared design is emitted as a **DRAFT**
+  ("human/lab review required") carrying the v5.6 immune profile + provenance in its metadata. Never auto-run.
+- **WS-INGEST** — `pen_stack/build/ingest.py`: `ingest_result(result, ...)` validates a result (assay / readout /
+  provenance) and turns it into a **quarantined measured edge Candidate**; the ONLY path into the curated
+  world-model is the v4.5 gate (`gate_admit`) — automated checks **and** explicit human approval. No auto-edit
+  (Principle 1). Immune measurements can begin validating the v5.6 proxies on a later pass.
+- **WS-SIMLAB** — `pen_stack/build/simlab.py`: `run_simulated(protocol_ir, design, cell_state)` executes a
+  protocol in silico (samples from the v5.9 twin + measurement noise), **labelled `SIMULATED`**, so the closed
+  loop (v5.12) runs end-to-end **export → sim → ingest** without hardware; never enters the world-model as
+  measured truth.
+- **WS-BENCH** — bench **v0.3.7**: new `protocol_safety` hard-gate task (`pen_stack/validate/protocol_safety.py`)
+  — a cleared design exports with immune metadata, a safety-refused/illegal design is blocked, and the simulated
+  loop completes with quarantined SIMULATED results; an ungated exporter (which would emit the hazardous protocol)
+  fails by construction.
+- Docs: `docs/build_interface.md`; prereg `ws_{proto,ingest,simlab}` + SHA locks; deposit `phase_5.11/`.
+
+### Notes
+- PEN-STACK emits protocols and ingests results; it does **not** run experiments — protocols are drafts requiring
+  human/lab review, results enter only through the gate, and the simulated lab is for development / loop-validation,
+  never a substitute for real data. Export is hard-blocked for anything the safety gate flags.
+
+## [5.10.0] - 2026-06-11 - v5.10 release: The Experiment Designer (active learning / EIG)
+
+**Closed-Loop arc, Cycle 4 of 7.** The "Learn" brain of a self-driving lab: turn *"I'm uncertain"* into *"run
+this experiment next."* Reads the calibrated v5.9 twin's uncertainty + the v5.6 immune labels, scores each
+candidate experiment by expected information gain, assembles a diverse batch, and proves on held-out data — with
+CIs — that this learns faster than random/greedy (reporting honestly when it does not). Workstreams
+WS-{ACQ,DESIGN,VALIDATE}, SHA-locked.
+
+### Added
+- **WS-ACQ** — `pen_stack/active/acquire.py`: `expected_information_gain` (reducible uncertainty from the twin's
+  predictive distribution; `≥ 0`, monotone in uncertainty), `predictive_entropy` (from the twin's interval width),
+  and **`immune_voi`** — value of information for **validating an immune PROXY axis** (v5.6): an experiment that
+  would measure a still-proxy axis is high-VOI (turns proxy → outcome-validated). `acquisition_score` is fully
+  traceable to twin quantities + v5.6 labels; deterministic; no fabricated values.
+- **WS-DESIGN** — `pen_stack/active/design.py`: `select_batch` greedily maximises acquisition **minus a
+  redundancy penalty** (shared design facets) → a **diverse** batch (not k copies of the most-uncertain point);
+  each experiment carries its expected info gain.
+- **WS-VALIDATE** — `pen_stack/active/validate.py`: `retrospective_active_learning` simulates active vs random vs
+  greedy campaigns on a held-out split, reports mean±CI learning curves and a **bootstrap CI on the curve-area
+  gap**; `active_beats_random` only when the CI excludes zero — else the not-yet-useful negative is reported.
+- **WS-BENCH** — bench **v0.3.6**: new `experiment_design` hard-gate task — the gate is the Learn engine's
+  honesty + falsifiability (twin-sourced EIG monotone in uncertainty + immune-VOI for proxy validation + diverse
+  batch + retrospective active-vs-random with reps+CI); a random selector fails by construction. Active-beats-
+  random is reported informationally.
+- Docs: `docs/experiment_design.md`; prereg `ws_{acq,aldesign,alvalidate}` + SHA locks; deposit `phase_5.10/`.
+
+### Notes
+- The experiment designer is only as good as the v5.9 twin + v5.6 labels it queries; its advantage is validated
+  **retrospectively** with CIs and reported honestly when absent. It chooses informative experiments but **does
+  not run them** — prospective benefit awaits a lab partner (v5.11+). No autonomy claim.
+
 ## [5.9.0] - 2026-06-11 - v5.9 release: The Digital Twin (calibrated outcome prediction)
 
 **Closed-Loop arc, Cycle 3 of 7.** The missing layer: *what does the cell do after the write?* — predicted with

{pen_stack-5.9.0 → pen_stack-5.11.0}/CITATION.cff

@@ -1,7 +1,7 @@
 cff-version: 1.2.0
 message: "If you use PEN-STACK, please cite it as below."
 title: "PEN-STACK: open infrastructure for genome writing"
-version: 5.9.0
+version: 5.11.0
 date-released: 2026-06-11
 authors:
   - family-names: "Mahaboob Ali"

{pen_stack-5.9.0 → pen_stack-5.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pen-stack
-Version: 5.9.0
+Version: 5.11.0
 Summary: Open infrastructure for genome writing: the Writable Genome atlas, the Writer Atlas, and the Write Planner.
 Author-email: Anees Ahmed Mahaboob Ali <ahmedaneesm@gmail.com>
 License: MIT
@@ -90,12 +90,12 @@ every design against rule-grounded mechanism, reports calibrated confidence, cit
 [![codecov](https://codecov.io/gh/ahmedanees-m/pen-stack/branch/main/graph/badge.svg)](https://codecov.io/gh/ahmedanees-m/pen-stack)
 [![License: MIT](https://img.shields.io/badge/License-MIT-informational.svg)](LICENSE)
 [![Python 3.11+](https://img.shields.io/badge/python-3.11%2B-blue.svg)](https://www.python.org/)
-[![Version](https://img.shields.io/badge/version-5.9.0-blue.svg)](CHANGELOG.md)
-[![Tests](https://img.shields.io/badge/tests-324%20passing-success.svg)](tests/)
+[![Version](https://img.shields.io/badge/version-5.11.0-blue.svg)](CHANGELOG.md)
+[![Tests](https://img.shields.io/badge/tests-339%20passing-success.svg)](tests/)
 [![Lint: ruff](https://img.shields.io/badge/lint-ruff-purple.svg)](https://github.com/astral-sh/ruff)
 [![Runtime: Docker](https://img.shields.io/badge/runtime-docker-2496ED.svg)](docker/)
 [![Validation: pre-registered](https://img.shields.io/badge/validation-pre--registered-critical.svg)](prereg/)
-[![Genome-Writing Bench v0.3](https://img.shields.io/badge/benchmark-Genome--Writing%20Bench%20v0.3.5-6f42c1.svg)](benchmarks/genome_writing_bench/)
+[![Genome-Writing Bench v0.3](https://img.shields.io/badge/benchmark-Genome--Writing%20Bench%20v0.3.7-6f42c1.svg)](benchmarks/genome_writing_bench/)
 
 **Built on five prior, separately published repositories:**
 
@@ -134,6 +134,40 @@ Two questions gate every genome-writing project, and before PEN-STACK no resourc
 Everything is built on bulk-downloadable public data, runs on a single GPU, and is validated **blind** against
 a pre-registered, honest baseline before release.
 
+## What is new in v5.11 — The Build Interface (digital→physical bridge)
+
+v5.11 (**Closed-Loop arc, Cycle 5 of 7**) makes designs executable and results ingestible — loop-ready,
+lab-optional, **safety-gated**, with the immune-risk profile attached as protocol metadata. PEN-STACK emits
+protocols and ingests results; it does **not** run experiments.
+
+| Workstream | What it adds | Result |
+|---|---|---|
+| **PROTO** | `build/protocol.py` | `export_protocol` runs `verify()` first; a safety-refused/illegal design raises **`ProtocolExportError`**; a cleared design → a **DRAFT** (Opentrons/PyLabRobot/cloud-lab) carrying the v5.6 immune profile |
+| **INGEST** | `build/ingest.py` | a result → a **quarantined measured Candidate**; the only path into the curated world-model is the v4.5 gate (checks + human approval) — **no auto-edit** |
+| **SIMLAB** | `build/simlab.py` | `run_simulated` samples from the v5.9 twin (+ noise), **labelled SIMULATED**; the loop **export → sim → ingest** runs without hardware |
+| **BENCH** | bench **v0.3.7** `protocol_safety` hard gate | cleared exports w/ immune metadata · hazard+illegal blocked · sim loop completes; an ungated exporter fails by construction |
+
+Protocols are **drafts for human/lab review, never auto-executed**; export is hard-blocked for anything the safety
+gate flags. See [`docs/build_interface.md`](docs/build_interface.md) and `prereg/ws_{proto,ingest,simlab}.yaml`.
+
+## What is new in v5.10 — The Experiment Designer (active learning / EIG)
+
+v5.10 (**Closed-Loop arc, Cycle 4 of 7**) is the **Learn** brain of a self-driving lab: it turns *"I'm
+uncertain"* into *"run **this** experiment next."* It reads the calibrated v5.9 twin's uncertainty and the v5.6
+immune labels, scores each candidate experiment by the information it is expected to yield, assembles a diverse
+batch, and proves on held-out data — with confidence intervals — that this learns faster than random/greedy.
+
+| Workstream | What it adds | Result |
+|---|---|---|
+| **ACQ** | `active/acquire.py` | EIG from the twin (≥0, monotone in uncertainty); **immune-VOI** rewards experiments that would validate a v5.6 **proxy** axis; deterministic, traceable |
+| **DESIGN** | `active/design.py` | `select_batch` — diverse batch (acquisition − redundancy penalty), not k copies of the most-uncertain point; each carries expected info gain |
+| **VALIDATE** | `active/validate.py` | retrospective active vs random/greedy learning curves with reps + **bootstrap CI** on the curve-area gap; beats random **only if CI excludes 0**, else reports not-yet-useful |
+| **BENCH** | bench **v0.3.6** `experiment_design` hard gate | gate = the Learn engine's honesty + falsifiability; a random selector (no acquisition, no falsifiable curve) fails by construction |
+
+Falsifiable by construction and **lab-optional** — it chooses informative experiments but does not run them
+(prospective benefit awaits a lab; no autonomy claim). See [`docs/experiment_design.md`](docs/experiment_design.md)
+and `prereg/ws_{acq,aldesign,alvalidate}.yaml`.
+
 ## What is new in v5.9 — The Digital Twin (calibrated outcome prediction)
 
 v5.9 (**Closed-Loop arc, Cycle 3 of 7**) adds the missing layer — *what does the cell do after the write?* —
@@ -624,6 +658,8 @@ pen-stack/
 │   ├── safety/                       v5.7 the Guardian: biosecurity/dual-use gate (registry/screen/policy/gate/audit/redteam); runs first in verify(); refuse short-circuits; tamper-evident audit
 │   ├── design/                       v5.8 generative designer: space (candidate_space) / generate (verifier-as-discriminator; hazardous+illegal discarded) / pareto (frontier w/ grounded v5.6 immune axis)
 │   ├── twin/                         v5.9 digital twin: mechanistic (cassette expression, closed-form) / outcome (fuse mech+vcell+v5.6 immune; OOD widens interval; phenotype-bounded) / calibrate (honest two-sided)
+│   ├── active/                       v5.10 experiment designer: acquire (EIG/immune-VOI over the v5.9 twin) / design (diverse batch) / validate (retrospective active-vs-random, reps+CI, falsifiable)
+│   ├── build/                        v5.11 build interface: protocol (safety-gated export, DRAFT + v5.6 immune metadata) / ingest (typed gated -> v4.5 world-model, no auto-edit) / simlab (export->sim->ingest, SIMULATED)
 │   ├── adapt/                        local recalibration / private-data adaptation behind a gate (v3.1, WS-F)
 │   ├── env/                          v3.4 full Gymnasium environment over router+verifier (genome_writing_env + policies; [env] extra)
 │   ├── monitor/                      PEN-MONITOR living database (Europe PMC)
@@ -636,12 +672,14 @@ pen-stack/
 │   │                                   v5.6 immune_calibration (proxy-vs-observed; labels each axis validated-or-proxy, two-sided) /
 │   │                                   v5.7 safety_screening (the Guardian hard-gate: benign 0-false-refusal · hazards refused/escalated · evasions never clear) /
 │   │                                   v5.8 generative_design (verifier-as-discriminator hard-gate: hazardous+illegal discarded; survivors calibrated+immune; grounded-immune Pareto) /
-│   │                                   v5.9 outcome_prediction (digital-twin hard-gate: two-sided calibration + OOD widening + immune dim + phenotype out-of-scope)
+│   │                                   v5.9 outcome_prediction (digital-twin hard-gate: two-sided calibration + OOD widening + immune dim + phenotype out-of-scope) /
+│   │                                   v5.10 experiment_design (active-learning hard-gate: EIG monotone + immune-VOI + diverse batch + retrospective active-vs-random reps+CI) /
+│   │                                   v5.11 protocol_safety (build-interface hard-gate: cleared exports w/ immune metadata · hazard+illegal blocked · sim loop completes)
 │   ├── data/                         ingestion (genome, chromatin, integration, TRIP, safety annotations)
 │   ├── server/api.py                 FastAPI REST (atlas, crosslink, writable, plan, bridge, ask)
 │   ├── ui/app.py                     Streamlit web app (16 pages; v3.2 PEN-Agent shows confidence + epistemic status)
 │   └── cli.py                        unified CLI
-├── benchmarks/genome_writing_bench/  Genome-Writing Bench v0.3.5 (T1-T16 + co_scientist + safety_screening + generative_design + outcome_prediction; tasks / harness / solvers / LEADERBOARD / SHAs)
+├── benchmarks/genome_writing_bench/  Genome-Writing Bench v0.3.7 (T1-T16 + co_scientist + safety_screening + generative_design + outcome_prediction + experiment_design + protocol_safety; tasks / harness / solvers / LEADERBOARD / SHAs)
 ├── bench/run.py                      one-command bench entrypoint (--agent, --verify)
 ├── scripts/                          reproducible pipeline drivers (p1_*, p2_*, p4_*, p52/p53 delivery-immunology oracle builds, ws_*_report)
 ├── configs/                          pinned datasets + thresholds + curation (YAML); v3.2 known_unknowns /
@@ -653,7 +691,8 @@ pen-stack/
 ├── prereg/                           SHA-locked success criteria (paper1..4 + ws_a..ws_h + v3.2-v5.9 ws_{uq,ep,mc,ba,
 │                                       r,v,route,env,bench,cal,o,wv,atlas,graph,mon,ct,plan,crit,cite,immune,
 │                                       genotox,epitope,innate,seroprev,peg,calib,profile,screen,policy,redteam,
-│                                       gen,pareto,orch,vcell,mech,outcome,twincal} + SHA256 locks)
+│                                       gen,pareto,orch,vcell,mech,outcome,twincal,acq,aldesign,alvalidate,
+│                                       proto,ingest,simlab} + SHA256 locks)
 ├── data/curated/                     small committed tables (universe, gene coords, measured bridge profile,
 │                                       v3.2 bridge_offtarget_energetics.json)
 ├── data/llm_bench_cache/             28 cached ungrounded-LLM transcripts (T7, offline/CI replay)

{pen_stack-5.9.0 → pen_stack-5.11.0}/README.md

@@ -15,12 +15,12 @@ every design against rule-grounded mechanism, reports calibrated confidence, cit
 [![codecov](https://codecov.io/gh/ahmedanees-m/pen-stack/branch/main/graph/badge.svg)](https://codecov.io/gh/ahmedanees-m/pen-stack)
 [![License: MIT](https://img.shields.io/badge/License-MIT-informational.svg)](LICENSE)
 [![Python 3.11+](https://img.shields.io/badge/python-3.11%2B-blue.svg)](https://www.python.org/)
-[![Version](https://img.shields.io/badge/version-5.9.0-blue.svg)](CHANGELOG.md)
-[![Tests](https://img.shields.io/badge/tests-324%20passing-success.svg)](tests/)
+[![Version](https://img.shields.io/badge/version-5.11.0-blue.svg)](CHANGELOG.md)
+[![Tests](https://img.shields.io/badge/tests-339%20passing-success.svg)](tests/)
 [![Lint: ruff](https://img.shields.io/badge/lint-ruff-purple.svg)](https://github.com/astral-sh/ruff)
 [![Runtime: Docker](https://img.shields.io/badge/runtime-docker-2496ED.svg)](docker/)
 [![Validation: pre-registered](https://img.shields.io/badge/validation-pre--registered-critical.svg)](prereg/)
-[![Genome-Writing Bench v0.3](https://img.shields.io/badge/benchmark-Genome--Writing%20Bench%20v0.3.5-6f42c1.svg)](benchmarks/genome_writing_bench/)
+[![Genome-Writing Bench v0.3](https://img.shields.io/badge/benchmark-Genome--Writing%20Bench%20v0.3.7-6f42c1.svg)](benchmarks/genome_writing_bench/)
 
 **Built on five prior, separately published repositories:**
 
@@ -59,6 +59,40 @@ Two questions gate every genome-writing project, and before PEN-STACK no resourc
 Everything is built on bulk-downloadable public data, runs on a single GPU, and is validated **blind** against
 a pre-registered, honest baseline before release.
 
+## What is new in v5.11 — The Build Interface (digital→physical bridge)
+
+v5.11 (**Closed-Loop arc, Cycle 5 of 7**) makes designs executable and results ingestible — loop-ready,
+lab-optional, **safety-gated**, with the immune-risk profile attached as protocol metadata. PEN-STACK emits
+protocols and ingests results; it does **not** run experiments.
+
+| Workstream | What it adds | Result |
+|---|---|---|
+| **PROTO** | `build/protocol.py` | `export_protocol` runs `verify()` first; a safety-refused/illegal design raises **`ProtocolExportError`**; a cleared design → a **DRAFT** (Opentrons/PyLabRobot/cloud-lab) carrying the v5.6 immune profile |
+| **INGEST** | `build/ingest.py` | a result → a **quarantined measured Candidate**; the only path into the curated world-model is the v4.5 gate (checks + human approval) — **no auto-edit** |
+| **SIMLAB** | `build/simlab.py` | `run_simulated` samples from the v5.9 twin (+ noise), **labelled SIMULATED**; the loop **export → sim → ingest** runs without hardware |
+| **BENCH** | bench **v0.3.7** `protocol_safety` hard gate | cleared exports w/ immune metadata · hazard+illegal blocked · sim loop completes; an ungated exporter fails by construction |
+
+Protocols are **drafts for human/lab review, never auto-executed**; export is hard-blocked for anything the safety
+gate flags. See [`docs/build_interface.md`](docs/build_interface.md) and `prereg/ws_{proto,ingest,simlab}.yaml`.
+
+## What is new in v5.10 — The Experiment Designer (active learning / EIG)
+
+v5.10 (**Closed-Loop arc, Cycle 4 of 7**) is the **Learn** brain of a self-driving lab: it turns *"I'm
+uncertain"* into *"run **this** experiment next."* It reads the calibrated v5.9 twin's uncertainty and the v5.6
+immune labels, scores each candidate experiment by the information it is expected to yield, assembles a diverse
+batch, and proves on held-out data — with confidence intervals — that this learns faster than random/greedy.
+
+| Workstream | What it adds | Result |
+|---|---|---|
+| **ACQ** | `active/acquire.py` | EIG from the twin (≥0, monotone in uncertainty); **immune-VOI** rewards experiments that would validate a v5.6 **proxy** axis; deterministic, traceable |
+| **DESIGN** | `active/design.py` | `select_batch` — diverse batch (acquisition − redundancy penalty), not k copies of the most-uncertain point; each carries expected info gain |
+| **VALIDATE** | `active/validate.py` | retrospective active vs random/greedy learning curves with reps + **bootstrap CI** on the curve-area gap; beats random **only if CI excludes 0**, else reports not-yet-useful |
+| **BENCH** | bench **v0.3.6** `experiment_design` hard gate | gate = the Learn engine's honesty + falsifiability; a random selector (no acquisition, no falsifiable curve) fails by construction |
+
+Falsifiable by construction and **lab-optional** — it chooses informative experiments but does not run them
+(prospective benefit awaits a lab; no autonomy claim). See [`docs/experiment_design.md`](docs/experiment_design.md)
+and `prereg/ws_{acq,aldesign,alvalidate}.yaml`.
+
 ## What is new in v5.9 — The Digital Twin (calibrated outcome prediction)
 
 v5.9 (**Closed-Loop arc, Cycle 3 of 7**) adds the missing layer — *what does the cell do after the write?* —
@@ -549,6 +583,8 @@ pen-stack/
 │   ├── safety/                       v5.7 the Guardian: biosecurity/dual-use gate (registry/screen/policy/gate/audit/redteam); runs first in verify(); refuse short-circuits; tamper-evident audit
 │   ├── design/                       v5.8 generative designer: space (candidate_space) / generate (verifier-as-discriminator; hazardous+illegal discarded) / pareto (frontier w/ grounded v5.6 immune axis)
 │   ├── twin/                         v5.9 digital twin: mechanistic (cassette expression, closed-form) / outcome (fuse mech+vcell+v5.6 immune; OOD widens interval; phenotype-bounded) / calibrate (honest two-sided)
+│   ├── active/                       v5.10 experiment designer: acquire (EIG/immune-VOI over the v5.9 twin) / design (diverse batch) / validate (retrospective active-vs-random, reps+CI, falsifiable)
+│   ├── build/                        v5.11 build interface: protocol (safety-gated export, DRAFT + v5.6 immune metadata) / ingest (typed gated -> v4.5 world-model, no auto-edit) / simlab (export->sim->ingest, SIMULATED)
 │   ├── adapt/                        local recalibration / private-data adaptation behind a gate (v3.1, WS-F)
 │   ├── env/                          v3.4 full Gymnasium environment over router+verifier (genome_writing_env + policies; [env] extra)
 │   ├── monitor/                      PEN-MONITOR living database (Europe PMC)
@@ -561,12 +597,14 @@ pen-stack/
 │   │                                   v5.6 immune_calibration (proxy-vs-observed; labels each axis validated-or-proxy, two-sided) /
 │   │                                   v5.7 safety_screening (the Guardian hard-gate: benign 0-false-refusal · hazards refused/escalated · evasions never clear) /
 │   │                                   v5.8 generative_design (verifier-as-discriminator hard-gate: hazardous+illegal discarded; survivors calibrated+immune; grounded-immune Pareto) /
-│   │                                   v5.9 outcome_prediction (digital-twin hard-gate: two-sided calibration + OOD widening + immune dim + phenotype out-of-scope)
+│   │                                   v5.9 outcome_prediction (digital-twin hard-gate: two-sided calibration + OOD widening + immune dim + phenotype out-of-scope) /
+│   │                                   v5.10 experiment_design (active-learning hard-gate: EIG monotone + immune-VOI + diverse batch + retrospective active-vs-random reps+CI) /
+│   │                                   v5.11 protocol_safety (build-interface hard-gate: cleared exports w/ immune metadata · hazard+illegal blocked · sim loop completes)
 │   ├── data/                         ingestion (genome, chromatin, integration, TRIP, safety annotations)
 │   ├── server/api.py                 FastAPI REST (atlas, crosslink, writable, plan, bridge, ask)
 │   ├── ui/app.py                     Streamlit web app (16 pages; v3.2 PEN-Agent shows confidence + epistemic status)
 │   └── cli.py                        unified CLI
-├── benchmarks/genome_writing_bench/  Genome-Writing Bench v0.3.5 (T1-T16 + co_scientist + safety_screening + generative_design + outcome_prediction; tasks / harness / solvers / LEADERBOARD / SHAs)
+├── benchmarks/genome_writing_bench/  Genome-Writing Bench v0.3.7 (T1-T16 + co_scientist + safety_screening + generative_design + outcome_prediction + experiment_design + protocol_safety; tasks / harness / solvers / LEADERBOARD / SHAs)
 ├── bench/run.py                      one-command bench entrypoint (--agent, --verify)
 ├── scripts/                          reproducible pipeline drivers (p1_*, p2_*, p4_*, p52/p53 delivery-immunology oracle builds, ws_*_report)
 ├── configs/                          pinned datasets + thresholds + curation (YAML); v3.2 known_unknowns /
@@ -578,7 +616,8 @@ pen-stack/
 ├── prereg/                           SHA-locked success criteria (paper1..4 + ws_a..ws_h + v3.2-v5.9 ws_{uq,ep,mc,ba,
 │                                       r,v,route,env,bench,cal,o,wv,atlas,graph,mon,ct,plan,crit,cite,immune,
 │                                       genotox,epitope,innate,seroprev,peg,calib,profile,screen,policy,redteam,
-│                                       gen,pareto,orch,vcell,mech,outcome,twincal} + SHA256 locks)
+│                                       gen,pareto,orch,vcell,mech,outcome,twincal,acq,aldesign,alvalidate,
+│                                       proto,ingest,simlab} + SHA256 locks)
 ├── data/curated/                     small committed tables (universe, gene coords, measured bridge profile,
 │                                       v3.2 bridge_offtarget_energetics.json)
 ├── data/llm_bench_cache/             28 cached ungrounded-LLM transcripts (T7, offline/CI replay)

{pen_stack-5.9.0 → pen_stack-5.11.0}/benchmarks/genome_writing_bench/SHA256SUMS

@@ -1,4 +1,4 @@
-8a88af94053456909a2a03561d721a97e82d012f867eaf1d632ff3518a2bf0d1  benchmarks/genome_writing_bench/tasks.yaml
+5901339c67024897aa2cce9fbf1ac93676b6d88ffcec55126033c8b39a6d2a70  benchmarks/genome_writing_bench/tasks.yaml
 5ca511c6763b4e3703e8009031ff8dc385c2a99540e2731d875a9fbbb16f5ecd  configs/gsh_validated_heldout.yaml
 758817c1e46c7db10f7f942316663367c5f297cac0cf2f59947a90638a256718  data/writer_panel.csv
 865b18ff23d140c3df6f3b5f25398581ebdfe3534e1cecf6f512afb540ab5ede  data/gsh_matched_controls.parquet

{pen_stack-5.9.0 → pen_stack-5.11.0}/benchmarks/genome_writing_bench/tasks.yaml

@@ -8,7 +8,7 @@
 # A task names a `scorer` (module.function in pen_stack.validate / pen_stack.bridge) and a `metric` key to
 # read from its report. Solvers (deterministic planner, naive baseline, LLM agent) are compared on the same
 # tasks; a solver that cannot ground a number must refuse, not invent (no-fabrication is a hard gate).
-version: "0.3.5"
+version: "0.3.7"
 prepared: "2026-06-11"
 
 taxonomy:
@@ -43,6 +43,10 @@ taxonomy:
   GD_generative_design: "generate candidate writing systems and keep ONLY legal+safe+calibrated+immune-profiled survivors (hazardous toxin payload + illegal oversize/form-incompatible designs DISCARDED), returning a Pareto frontier with a grounded immune-risk axis (vs an ungrounded generator that ships hazardous/illegal designs)"
   # v0.3.5 (v5.9): the digital twin - calibrated, OOD-aware, immune-aware, phenotype-bounded outcome prediction.
   OP_outcome_prediction: "predict a write's computable outcome with HONEST calibration (two-sided MAE-vs-naive with bootstrap CI), an interval that WIDENS under OOD, an immune-outcome dimension from v5.6, and phenotype out of scope (vs an overconfident predictor with a fixed narrow interval and no scope awareness)"
+  # v0.3.6 (v5.10): the experiment designer - active learning / EIG, falsifiable vs random/greedy.
+  ED_experiment_design: "choose the experiment(s) that most reduce model uncertainty: EIG from the calibrated twin (monotone in uncertainty), immune-VOI rewarding proxy-validating experiments, a diverse batch, and a RETROSPECTIVE active-vs-random validation with reps + bootstrap CI (vs a random selector with no acquisition signal and no falsifiable curve)"
+  # v0.3.7 (v5.11): the build interface - safety-gated protocol export + gated ingestion + simulated loop.
+  PS_protocol_safety: "export a cleared design as a runnable protocol DRAFT carrying its v5.6 immune profile, BLOCK any safety-refused/illegal design (ProtocolExportError), and complete the simulated loop export->sim->ingest with results quarantined (no auto-edit) + labelled SIMULATED (vs an ungated exporter that would emit the hazardous protocol)"
 
 tasks:
   - id: site_selection_blind_gsh
@@ -280,3 +284,34 @@ tasks:
     note: "v5.9 the digital twin: a trustworthy predictor is calibrated + OOD-aware + immune-aware + phenotype-
       bounded; an overconfident predictor (fixed narrow interval, no OOD/scope awareness) fails the gate by
       construction. Honest about what the field cannot yet do."
+
+  - id: experiment_design
+    family: ED_experiment_design
+    scorer: "pen_stack.validate.experiment_design:run"
+    metric: "experiment_designer_honest"
+    baseline_metric: "random_selector_honest"
+    higher_is_better: true
+    hard_gate: true
+    gate_rule: "experiment_designer_honest == True (EIG monotone in uncertainty AND immune-VOI rewards proxy validation AND batch diverse AND retrospective active-vs-random reported with reps+CI)"
+    ground_truth: "structural honesty + falsifiability properties of the Learn engine (twin-sourced EIG, immune-VOI,
+      diverse batch, retrospective active-vs-random with reps + bootstrap CI), NOT a beat-the-world claim -
+      non-circular; the active-beats-random outcome is reported either way (not-yet-useful is a valid result)"
+    circular: false
+    note: "v5.10 the experiment designer: a trustworthy Learn engine computes acquisition from the calibrated twin,
+      rewards proxy-validating experiments, selects a diverse batch, and validates active-vs-random retrospectively
+      with CIs; a random selector has no acquisition signal and no falsifiable curve and fails by construction."
+
+  - id: protocol_safety
+    family: PS_protocol_safety
+    scorer: "pen_stack.validate.protocol_safety:run"
+    metric: "build_safety_honored"
+    baseline_metric: "ungated_exporter_safe"
+    higher_is_better: true
+    hard_gate: true
+    gate_rule: "build_safety_honored == True (cleared exports w/ immune metadata AND hazard+illegal blocked AND sim labelled AND export->sim->ingest completes w/ quarantine)"
+    ground_truth: "export blocking decided by the v5.7 safety gate + the rules (not the exporter); ingestion gated by
+      the v4.5 world-model gate (no auto-edit of curated truth); sim results labelled SIMULATED - non-circular"
+    circular: false
+    note: "v5.11 the build interface: a cleared design exports a DRAFT carrying its immune profile; a safety-refused
+      or illegal design raises ProtocolExportError; the simulated loop completes with quarantined, SIMULATED-labelled
+      results. An ungated exporter would emit the hazardous protocol and fails by construction."

pen_stack-5.11.0/docs/build_interface.md

@@ -0,0 +1,50 @@
+# The build interface (v5.11)
+
+From v5.11, PEN-STACK reaches the **digital→physical** interface — responsibly. A cleared, legal design becomes a
+runnable protocol DRAFT carrying its v5.6 immune-risk profile (refused outright if the v5.7 safety gate flags it);
+a typed ingestion API returns experimental results as candidate evidence admitted only through the v4.5
+world-model gate; and a simulated lab runs the whole loop before any hardware exists. PEN-STACK **emits protocols
+and ingests results — it does not run experiments.**
+
+## Safety-gated protocol export (`pen_stack/build/protocol.py`)
+
+```python
+from pen_stack.build import export_protocol, ProtocolExportError
+code = export_protocol(design, {"round": 0}, target="opentrons", actor="lab-alice")
+```
+
+`export_protocol` runs `verify(design, actor)` **first**. If the safety gate returns `refuse`, or the design is
+illegal, it raises **`ProtocolExportError`** — there is no export path for a flagged design. A cleared design is
+emitted for one of `opentrons` / `pylabrobot` / `cloudlab`, **stamped "DRAFT — human/lab review required"**, with
+the v5.6 immune profile and full provenance in the metadata. Protocols are drafts; nothing is auto-run.
+
+## Typed, gated ingestion (`pen_stack/build/ingest.py`)
+
+```python
+from pen_stack.build import ingest_result
+cand = ingest_result(result)                       # quarantined measured Candidate (no auto-merge)
+ingest_result(result, admitted_by="human", graph=g, approved=True)   # the ONLY path into the curated graph
+```
+
+A result is validated (assay / readout / provenance with a source) and turned into a **quarantined measured edge
+Candidate**. The only way it enters the curated world-model is the v4.5 gate (`gate_admit`) — automated checks
+**and** explicit human approval. No process auto-edits curated truth (Principle 1). Immune-measurement results can
+begin validating the v5.6 proxies on a later pass.
+
+## Simulated lab (`pen_stack/build/simlab.py`)
+
+```python
+from pen_stack.build import run_simulated
+res = run_simulated(protocol_ir, design, cell_state="k562", seed=0)
+```
+
+`run_simulated` executes a protocol in silico: it samples an "observed" readout from the v5.9 twin + measurement
+noise, **labelled `SIMULATED`**. This lets the closed loop (v5.12) run end-to-end **export → sim → ingest** without
+a wet lab. Sim outcomes inherit the twin's limits and **never** enter the curated world-model as measured truth.
+
+## Honest scope
+
+PEN-STACK emits protocols and ingests results; it does **not** run experiments — protocols are drafts requiring
+human/lab review, results enter only through the gate, and the simulated lab is for development and loop-validation,
+never a substitute for real data. Export is hard-blocked for anything the safety gate flags; the attached immune
+profile is a screen carrying its known-unknowns, not a patient prediction.

pen_stack-5.11.0/docs/experiment_design.md

@@ -0,0 +1,44 @@
+# The experiment designer (v5.10)
+
+From v5.10, PEN-STACK turns *"I'm uncertain"* into *"run **this** experiment next."* It reads the calibrated v5.9
+twin's uncertainty and the v5.6 immune-risk labels, scores each candidate experiment by the information it is
+expected to yield, assembles a diverse batch, and proves on held-out data — with confidence intervals — that this
+learns faster than random or greedy, reporting honestly when it does not. The **Learn** brain of a self-driving
+lab: lab-optional and falsifiable by construction.
+
+## Acquisition (`pen_stack/active/acquire.py`)
+
+```python
+from pen_stack.active import acquisition_score, expected_information_gain, immune_voi
+```
+
+- **`predictive_entropy(outcome)`** — the twin's current uncertainty, from its interval width (Gaussian
+  differential entropy).
+- **`expected_information_gain(candidate, cell_state)`** — reducible uncertainty: `entropy now − expected
+  posterior entropy` (a measurement collapses the predictive sd toward a noise floor); `≥ 0`. Monotone in the
+  twin's uncertainty (an OOD candidate yields more EIG).
+- **`immune_voi(candidate)`** — value of information for **validating an immune PROXY axis** (v5.6): an axis still
+  labelled a proxy that this experiment would measure is high-VOI (it would turn proxy → outcome-validated).
+- **`acquisition_score`** = `w_eig·EIG + w_unc·entropy + w_imm·immune_voi`. Fully traceable to twin quantities +
+  v5.6 labels; deterministic given inputs (no fabricated values).
+
+## Diverse batch (`pen_stack/active/design.py`)
+
+`select_batch(candidates, cell_state, k)` greedily maximises summed acquisition **minus a redundancy penalty**
+(shared design facets) against the already-chosen set — so a batch is a *diverse* set of informative experiments,
+not k copies of the single most-uncertain point. Each chosen experiment carries its `expected_info_gain`.
+
+## Retrospective falsifiability (`pen_stack/active/validate.py`)
+
+`retrospective_active_learning(dataset, strategies=("active","random","greedy"))` simulates campaigns per
+strategy on a held-out split, records the held-out-MAE learning curve per round, and over repetitions reports
+mean±CI curves and a **bootstrap CI on the curve-area gap** (`random_area − active_area`). The active learner
+"beats" random **only when the CI excludes zero**; otherwise the not-yet-useful negative is reported verbatim — a
+valid, published outcome.
+
+## Honest scope
+
+The experiment designer is only as good as the v5.9 twin and the v5.6 labels it queries. Its advantage is
+validated **retrospectively** on existing data with confidence intervals, and reported honestly when absent. It
+chooses informative experiments — including ones that would validate an immune proxy — but it **does not run
+them**; prospective benefit awaits a lab partner (v5.11+).

{pen_stack-5.9.0 → pen_stack-5.11.0}/pen_stack/__init__.py

@@ -1,2 +1,2 @@
 """PEN-STACK v3.0 - open infrastructure for genome writing."""
-__version__ = "5.9.0"
+__version__ = "5.11.0"

pen_stack-5.11.0/pen_stack/active/__init__.py

@@ -0,0 +1,20 @@
+"""pen_stack.active — the experiment designer / the "Learn" brain of a self-driving lab (v5.10).
+
+Turn "I'm uncertain" into "run THIS experiment next": score each candidate experiment by the information it is
+expected to yield (from the calibrated v5.9 twin), reward experiments that would validate an immune PROXY axis
+(v5.6), assemble a diverse batch, and prove on held-out data — with confidence intervals — that this learns
+faster than random or greedy, reporting honestly when it does not. Lab-optional, falsifiable by construction.
+"""
+from __future__ import annotations
+
+from pen_stack.active.acquire import (
+    acquisition_score,
+    expected_information_gain,
+    immune_voi,
+    predictive_entropy,
+)
+from pen_stack.active.design import batch_diversity, select_batch
+from pen_stack.active.validate import retrospective_active_learning
+
+__all__ = ["expected_information_gain", "immune_voi", "predictive_entropy", "acquisition_score",
+           "select_batch", "batch_diversity", "retrospective_active_learning"]

pen_stack-5.11.0/pen_stack/active/acquire.py

@@ -0,0 +1,73 @@
+"""Acquisition functions for the experiment designer (v5.10, WS-ACQ).
+
+Score each candidate experiment by the information it is expected to yield — computed from the calibrated v5.9
+twin's predictive uncertainty (never fabricated). Three signals:
+  * expected_information_gain — reducible predictive uncertainty (entropy now - expected posterior entropy),
+  * predictive_entropy        — the twin's current uncertainty (from its interval width),
+  * immune_voi                — value of information for VALIDATING an immune PROXY axis (turns proxy -> validated).
+The acquisition is only as good as the v5.9 twin and the v5.6 labels it queries; it chooses informative
+experiments, it does not run them.
+"""
+from __future__ import annotations
+
+import math
+
+# a measurement does not resolve uncertainty perfectly: a noise floor on the post-experiment entropy.
+_MEASUREMENT_NOISE_SD = 0.05
+_TWO_PI_E = 2.0 * math.pi * math.e
+
+
+def _interval_sd(outcome: dict) -> float:
+    """Std-dev implied by the twin's (approx 95%) interval: sd ~ width / (2 * 1.96)."""
+    lo, hi = outcome.get("interval", [0.0, 0.0])
+    return max(1e-6, (float(hi) - float(lo)) / (2.0 * 1.96))
+
+
+def _gaussian_entropy(sd: float) -> float:
+    return 0.5 * math.log(_TWO_PI_E * sd * sd)
+
+
+def predictive_entropy(outcome: dict) -> float:
+    """Differential entropy of the twin's predictive distribution, from its interval width."""
+    return _gaussian_entropy(_interval_sd(outcome))
+
+
+def _expected_posterior_entropy(outcome: dict) -> float:
+    """Entropy expected AFTER running the experiment: the measurement collapses predictive sd toward the
+    measurement noise floor (cannot go below it)."""
+    post_sd = max(_MEASUREMENT_NOISE_SD, min(_interval_sd(outcome), _MEASUREMENT_NOISE_SD * 2))
+    return _gaussian_entropy(post_sd)
+
+
+def expected_information_gain(candidate: dict, cell_state: str, model_ctx: dict | None = None) -> float:
+    """EIG ~ reducible uncertainty = predictive entropy now - expected posterior entropy. Computed from the
+    calibrated twin's predictive distribution; >= 0 (a measurement never increases expected uncertainty)."""
+    from pen_stack.twin.outcome import predict_outcome
+    o = predict_outcome(candidate, cell_state or candidate.get("cell_state", ""))
+    return max(0.0, predictive_entropy(o) - _expected_posterior_entropy(o))
+
+
+def immune_voi(candidate: dict, cell_state: str = "") -> float:
+    """Value of information for validating an immune PROXY axis (v5.6): an axis still labelled a proxy that this
+    experiment would MEASURE is high-VOI (turns proxy -> outcome-validated). Reads the v5.6 validation labels."""
+    from pen_stack.twin.outcome import predict_outcome
+    prof = predict_outcome(candidate, cell_state or candidate.get("cell_state", "")).get("immune_outcome") or {}
+    measures = {str(a).strip().lower() for a in (candidate.get("measures_immune_axes") or [])}
+    voi = 0.0
+    for axis, rec in prof.get("axes", {}).items():
+        label = (rec.get("validation") or "").lower()
+        is_proxy = "proxy" in label and "not outcome-validated" in label
+        if is_proxy and (not measures or axis.lower() in measures):
+            voi += 1.0
+    return voi
+
+
+def acquisition_score(candidate: dict, cell_state: str, model_ctx: dict | None = None,
+                      *, w_eig: float = 1.0, w_unc: float = 0.3, w_imm: float = 0.4) -> float:
+    """Weighted acquisition: information gain + raw uncertainty + immune value-of-information. Fully traceable
+    to twin quantities + v5.6 labels (no fabricated values); deterministic given the inputs."""
+    from pen_stack.twin.outcome import predict_outcome
+    o = predict_outcome(candidate, cell_state or candidate.get("cell_state", ""))
+    eig = expected_information_gain(candidate, cell_state, model_ctx)
+    unc = predictive_entropy(o)
+    return w_eig * eig + w_unc * unc + w_imm * immune_voi(candidate, cell_state)

pen_stack-5.11.0/pen_stack/active/design.py

@@ -0,0 +1,51 @@
+"""Batch experiment selection with diversity (v5.10, WS-DESIGN).
+
+Greedy batch construction: maximise summed acquisition while spreading across the design space, so a batch is a
+DIVERSE set of informative experiments — not k copies of the single most-uncertain point. Each chosen experiment
+carries its expected information gain.
+"""
+from __future__ import annotations
+
+from pen_stack.active.acquire import acquisition_score, expected_information_gain
+
+# design facets used for the diversity (redundancy) penalty.
+_FACETS = ("writer_family", "delivery_vehicle", "chrom", "edit_intent", "cell_type")
+
+
+def _redundancy(cand: dict, chosen: list[dict]) -> float:
+    """Penalty for similarity to already-chosen experiments: fraction of shared design facets (0..1), summed."""
+    if not chosen:
+        return 0.0
+    pen = 0.0
+    for c in chosen:
+        shared = sum(1 for f in _FACETS if cand.get(f) is not None and cand.get(f) == c.get(f))
+        pen += shared / len(_FACETS)
+    return pen
+
+
+def batch_diversity(batch: list[dict]) -> float:
+    """Mean pairwise distinctness over the facets (1 = all distinct). Higher = more diverse."""
+    if len(batch) < 2:
+        return 1.0
+    pairs, dist = 0, 0.0
+    for i in range(len(batch)):
+        for j in range(i + 1, len(batch)):
+            shared = sum(1 for f in _FACETS
+                         if batch[i].get(f) is not None and batch[i].get(f) == batch[j].get(f))
+            dist += 1.0 - shared / len(_FACETS)
+            pairs += 1
+    return dist / pairs if pairs else 1.0
+
+
+def select_batch(candidates: list[dict], cell_state: str, model_ctx: dict | None = None,
+                 *, k: int = 8, w_div: float = 0.5) -> list[dict]:
+    """Greedy diverse batch: at each step pick the candidate maximising acquisition minus a redundancy penalty
+    against the already-chosen set. Each returned experiment carries its expected information gain."""
+    chosen: list[dict] = []
+    remaining = list(candidates)
+    while remaining and len(chosen) < k:
+        best = max(remaining, key=lambda c: acquisition_score(c, cell_state, model_ctx)
+                   - w_div * _redundancy(c, chosen))
+        chosen.append(best)
+        remaining.remove(best)
+    return [{**c, "expected_info_gain": expected_information_gain(c, cell_state, model_ctx)} for c in chosen]