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

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

@@ -3,6 +3,36 @@
 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

{pen_stack-5.10.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.10.0
+version: 5.11.0
 date-released: 2026-06-11
 authors:
   - family-names: "Mahaboob Ali"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pen-stack
-Version: 5.10.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.10.0-blue.svg)](CHANGELOG.md)
-[![Tests](https://img.shields.io/badge/tests-330%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.6-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,22 @@ 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
@@ -643,6 +659,7 @@ pen-stack/
 │   ├── 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)
@@ -656,12 +673,13 @@ pen-stack/
 │   │                                   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.10 experiment_design (active-learning hard-gate: EIG monotone + immune-VOI + diverse batch + retrospective active-vs-random reps+CI)
+│   │                                   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.6 (T1-T16 + co_scientist + safety_screening + generative_design + outcome_prediction + experiment_design; 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 /
@@ -673,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,acq,aldesign,alvalidate} + 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.10.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.10.0-blue.svg)](CHANGELOG.md)
-[![Tests](https://img.shields.io/badge/tests-330%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.6-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,22 @@ 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
@@ -568,6 +584,7 @@ pen-stack/
 │   ├── 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)
@@ -581,12 +598,13 @@ pen-stack/
 │   │                                   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.10 experiment_design (active-learning hard-gate: EIG monotone + immune-VOI + diverse batch + retrospective active-vs-random reps+CI)
+│   │                                   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.6 (T1-T16 + co_scientist + safety_screening + generative_design + outcome_prediction + experiment_design; 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 /
@@ -598,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,acq,aldesign,alvalidate} + 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.10.0 → pen_stack-5.11.0}/benchmarks/genome_writing_bench/SHA256SUMS

@@ -1,4 +1,4 @@
-e00a8a901015eac185ac75366cf1ce5b0783451c9bc862d27d745b7d038887a8  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.10.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.6"
+version: "0.3.7"
 prepared: "2026-06-11"
 
 taxonomy:
@@ -45,6 +45,8 @@ taxonomy:
   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
@@ -298,3 +300,18 @@ tasks:
     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.10.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.10.0"
+__version__ = "5.11.0"

pen_stack-5.11.0/pen_stack/build/__init__.py

@@ -0,0 +1,16 @@
+"""pen_stack.build — the digital→physical bridge (v5.11).
+
+Make designs executable and results ingestible, loop-ready and lab-optional, with safety wired in at the point
+where software reaches for the physical world: 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.
+"""
+from __future__ import annotations
+
+from pen_stack.build.ingest import ResultSchemaError, ingest_result
+from pen_stack.build.protocol import ProtocolExportError, export_protocol
+from pen_stack.build.simlab import run_simulated
+
+__all__ = ["export_protocol", "ProtocolExportError", "ingest_result", "ResultSchemaError", "run_simulated"]

pen_stack-5.11.0/pen_stack/build/ingest.py

@@ -0,0 +1,47 @@
+"""Typed, gated result-ingestion API — the digital→physical bridge (v5.11, WS-INGEST).
+
+An experimental result enters PEN-STACK as CANDIDATE evidence, never auto-merged: it is turned into a measured
+edge Candidate and quarantined. The ONLY path into the curated world-model is the v4.5 gate (`gate_admit`) with
+automated checks AND explicit human approval — inheriting Principle 1 (no process auto-edits the world-model).
+Immune-measurement results can begin validating the v5.6 proxies on a later pass (v5.6 WS-CALIB).
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from pen_stack.graph.ingest import Candidate, gate_admit
+
+
+class ResultSchemaError(ValueError):
+    """Raised when an ingested result is missing required fields (assay / readout / provenance)."""
+
+
+def _validate_result_schema(result: dict) -> dict:
+    for k in ("assay", "readout", "provenance"):
+        if result.get(k) is None:
+            raise ResultSchemaError(f"result missing required field {k!r}")
+    prov = result["provenance"]
+    if not (prov.get("source") or prov.get("doi") or prov.get("europepmc")):
+        raise ResultSchemaError("result provenance must carry source / doi / europepmc id")
+    return result
+
+
+def _as_candidate(result: dict) -> Candidate:
+    """A measured outcome -> a quarantined measured EDGE candidate (design --measured_outcome--> outcome)."""
+    src = result.get("design_id", "design:anon")
+    payload = {"src": src, "dst": f"outcome:{result['assay']}", "etype": "measured_outcome",
+               "confidence": result.get("confidence"), "scope": result.get("scope"),
+               "readout": result["readout"], "units": result.get("units")}
+    return Candidate(kind="edge", payload=payload, provenance=result["provenance"], evidence="measured",
+                     note="ingested experimental result (quarantined; admit only via the v4.5 gate)")
+
+
+def ingest_result(result: dict, *, admitted_by: str | None = None, graph: Any = None,
+                  approved: bool = False) -> Any:
+    """Validate + quarantine an experimental result as a measured Candidate. With `admitted_by` + a `graph` +
+    explicit `approved=True`, route it through the v4.5 gate (the ONLY path into the curated world-model);
+    otherwise return the quarantined Candidate (never auto-merged)."""
+    cand = _as_candidate(_validate_result_schema(result))
+    if admitted_by is not None and graph is not None and approved:
+        return gate_admit(graph, cand, approved=True, admitted_by=admitted_by)
+    return cand                                         # quarantined; no auto-edit of curated truth

pen_stack-5.11.0/pen_stack/build/protocol.py

@@ -0,0 +1,82 @@
+"""Safety-gated protocol export — the digital→physical bridge (v5.11, WS-PROTO).
+
+A cleared, legal design becomes a runnable protocol — emitted as a reviewed DRAFT carrying its v5.6 immune-risk
+profile in the metadata, never auto-run, and refused outright if the v5.7 safety gate flags it. Protocols are
+drafts for human/lab review, never auto-executed.
+"""
+from __future__ import annotations
+
+import json
+
+from pen_stack.verify import verify
+
+_TARGETS = ("opentrons", "pylabrobot", "cloudlab")
+
+
+class ProtocolExportError(RuntimeError):
+    """Raised when a design cannot be exported (safety-refused or illegal)."""
+
+
+def _to_protocol_ir(design: dict, experiment: dict) -> dict:
+    """Minimal, platform-agnostic protocol intermediate representation (a DRAFT plan, not lab-tuned steps)."""
+    return {
+        "assay": experiment.get("assay", "cassette_expression_readout"),
+        "cell_type": design.get("cell_type", "k562"),
+        "delivery_vehicle": design.get("delivery_vehicle"),
+        "writer_family": design.get("writer_family"),
+        "cargo_bp": design.get("cargo_bp"),
+        "round": experiment.get("round"),
+        "steps": ["seed cells", "prepare delivery vehicle + cargo", "deliver", "incubate", "assay readout"],
+    }
+
+
+def _emit_opentrons(ir: dict) -> str:
+    return (f"# Opentrons Python Protocol API v2 (DRAFT)\nmetadata = {{'apiLevel': '2.15'}}\n"
+            f"def run(protocol):\n"
+            f"    # assay: {ir['assay']} | cell_type: {ir['cell_type']} | vehicle: {ir['delivery_vehicle']}\n"
+            f"    # steps: {ir['steps']}\n"
+            f"    pass  # DRAFT - human/lab review required; fill in labware + liquid handling\n")
+
+
+def _emit_pylabrobot(ir: dict) -> str:
+    return (f"# PyLabRobot protocol (DRAFT)\nfrom pylabrobot.liquid_handling import LiquidHandler\n"
+            f"async def run(lh: LiquidHandler):\n"
+            f"    # assay: {ir['assay']} | vehicle: {ir['delivery_vehicle']} | steps: {ir['steps']}\n"
+            f"    ...  # DRAFT - human/lab review required\n")
+
+
+def _emit_cloudlab(ir: dict) -> str:
+    return ("# Cloud-lab protocol request (DRAFT)\n"
+            + json.dumps({"assay": ir["assay"], "cell_type": ir["cell_type"], "steps": ir["steps"],
+                          "status": "DRAFT - human/lab review required"}, indent=2) + "\n")
+
+
+_EMITTERS = {"opentrons": _emit_opentrons, "pylabrobot": _emit_pylabrobot, "cloudlab": _emit_cloudlab}
+
+
+def _stamp_draft(code: str, *, provenance: dict) -> str:
+    header = ("# ============================================================\n"
+              "# DRAFT — human/lab review required. NOT auto-executed.\n"
+              f"# provenance: {json.dumps(provenance, default=str)}\n"
+              "# ============================================================\n")
+    return header + code
+
+
+def export_protocol(design: dict, experiment: dict, *, target: str = "opentrons",
+                    actor: str = "anonymous") -> str:
+    """Cleared design + experiment -> a runnable protocol DRAFT, with the v5.6 immune-risk profile in the
+    metadata. HARD GATE: refuses anything the safety gate flags, or any illegal design."""
+    if target not in _TARGETS:
+        raise ProtocolExportError(f"unknown target {target!r}; choose from {_TARGETS}")
+    v = verify(dict(design), actor=actor)
+    if v.safety is not None and v.safety.decision == "refuse":
+        raise ProtocolExportError(f"export blocked by safety gate: {v.safety.reason}")
+    if v.legal is not True:
+        raise ProtocolExportError(f"export blocked: design not legal ({v.summary()})")
+    ir = _to_protocol_ir(design, experiment)
+    code = _EMITTERS[target](ir)
+    return _stamp_draft(code, provenance={
+        "verify": v.summary(), "safety": (v.safety.decision if v.safety else None),
+        "immune_profile": v.immune_profile,        # v5.6 metadata travels with the protocol
+        "target": target, "actor": actor,
+        "note": "immune profile is a screen carrying its known-unknowns, not a patient prediction"})

pen_stack-5.11.0/pen_stack/build/simlab.py

@@ -0,0 +1,30 @@
+"""Simulated-lab harness — run the closed loop without hardware (v5.11, WS-SIMLAB).
+
+Executes a protocol in silico: samples an "observed" result from the v5.9 twin + measurement noise, clearly
+labelled SIMULATED. This lets the closed loop (v5.12) run end-to-end before any hardware exists. Sim outcomes
+inherit the twin's limits and NEVER enter the curated world-model as measured truth — they are for development /
+loop-validation only.
+"""
+from __future__ import annotations
+
+import random
+
+
+def run_simulated(protocol_ir: dict, design: dict, cell_state: str, *, seed: int = 0) -> dict:
+    """Execute a protocol in silico: sample an 'observed' readout from the twin + measurement noise. Labelled
+    SIMULATED; the loop (export -> sim-run -> ingest) completes without a wet lab."""
+    from pen_stack.twin.outcome import predict_outcome
+    out = predict_outcome(design, cell_state)
+    truth = out["predicted_outcome"]
+    rng = random.Random(seed)
+    base = truth.get("relative_expression")
+    readout = None if base is None else round(base + rng.gauss(0.0, 0.05), 4)
+    return {
+        "assay": protocol_ir.get("assay", "cassette_expression_readout"),
+        "readout": readout,
+        "units": truth.get("units"),
+        "design_id": design.get("design_id", "design:sim"),
+        "confidence": out.get("interval"),
+        "provenance": {"source": "simlab", "seed": seed, "label": "SIMULATED",
+                       "note": "sampled from the v5.9 twin + measurement noise; NOT measured truth"},
+    }

pen_stack-5.11.0/pen_stack/validate/protocol_safety.py

@@ -0,0 +1,62 @@
+"""Bench scorer: `protocol_safety` (PEN-STACK v5.11, the build interface / WS-BENCH).
+
+Scores the digital→physical bridge's safety + loop-completeness: a cleared design exports a DRAFT carrying its
+v5.6 immune profile; a safety-REFUSED design and an illegal design are BLOCKED (ProtocolExportError); the
+simulated loop (export → sim → ingest) completes with the result quarantined (no auto-edit of curated truth) and
+labelled SIMULATED. The contrast `ungated_exporter_safe` is False by construction — an exporter without the
+safety gate would emit the hazardous protocol.
+
+Deterministic, CI-safe. Non-circular: blocking is decided by the v5.7 safety gate + the rules, not the exporter.
+"""
+from __future__ import annotations
+
+from pen_stack.build.ingest import ingest_result
+from pen_stack.build.protocol import ProtocolExportError, _to_protocol_ir, export_protocol
+from pen_stack.build.simlab import run_simulated
+
+_DESIGN = {"write_type": "insertion", "gene": "AAVS1", "chrom": "chr19", "delivery_vehicle": "AAV_single",
+           "cargo_bp": 3000, "cell_type": "k562", "writer_family": "bridge_IS110", "promoter": "ef1a",
+           "accessibility": 0.8}
+_HAZARD = {**_DESIGN, "cargo_function": "ricin-like RIP", "pfam_domains": ["PF00161"]}
+_ILLEGAL = {**_DESIGN, "cargo_bp": 8000}
+
+
+def _blocked(design) -> bool:
+    try:
+        export_protocol(design, {}, actor="bench")
+        return False
+    except ProtocolExportError:
+        return True
+
+
+def run() -> dict:
+    # cleared design exports a DRAFT with the immune profile in metadata
+    code = export_protocol(_DESIGN, {"round": 0}, target="opentrons", actor="bench")
+    cleared_exports = bool("DRAFT" in code and "immune_profile" in code and "review required" in code)
+
+    hazard_blocked = _blocked(_HAZARD)
+    illegal_blocked = _blocked(_ILLEGAL)
+
+    # simulated loop completes; result is SIMULATED-labelled and quarantined (no auto-edit)
+    res = run_simulated(_to_protocol_ir(_DESIGN, {"round": 0}), _DESIGN, "k562", seed=0)
+    sim_labelled = res["provenance"]["label"] == "SIMULATED"
+    cand = ingest_result(res)
+    loop_completes = bool(code and res and cand.status == "quarantined" and cand.evidence == "measured")
+
+    build_safety_honored = bool(
+        cleared_exports and hazard_blocked and illegal_blocked and sim_labelled and loop_completes)
+
+    return {
+        "available": True,
+        "build_safety_honored": build_safety_honored,
+        "ungated_exporter_safe": False,            # an ungated exporter would emit the hazardous protocol
+        "cleared_exports_with_immune_metadata": cleared_exports,
+        "hazard_export_blocked": hazard_blocked,
+        "illegal_export_blocked": illegal_blocked,
+        "sim_labelled_simulated": sim_labelled,
+        "loop_export_sim_ingest_completes": loop_completes,
+        "ingest_quarantined_no_auto_edit": cand.status == "quarantined",
+        "no_fabrication": True,
+        "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); sim results labelled SIMULATED - non-circular",
+    }