pen-stack 5.7.0__tar.gz → 5.8.0__tar.gz

{pen_stack-5.7.0 → pen_stack-5.8.0}/CHANGELOG.md

@@ -3,6 +3,39 @@
 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.8.0] - 2026-06-11 - v5.8 release: The Live Agent & Generative Designer
+
+**Closed-Loop arc, Cycle 2 of 7.** PEN-STACK turns from a *checker* into a grounded *designer*: it generates
+candidate end-to-end writing systems, keeps only those that pass safety + legality + calibration
+(verifier-as-discriminator), and returns the **Pareto frontier** of real tradeoffs — in which immunogenicity-risk
+is, for the first time, a **grounded** axis sourced from the v5.6 profile rather than a placeholder. Workstreams
+WS-{ORCH,GEN,PARETO,BENCH}, SHA-locked.
+
+### Added
+- **WS-GEN** — `pen_stack/design/{space,generate}.py`: `generate_designs(goal|candidates)` PROPOSES candidates
+  (`candidate_space` = the validated Phase-3 planner × the compatible delivery palette) and the v3.3 `verify()`
+  — now **safety-gated (v5.7)** + legality + calibration + immune-profiled — DISPOSES. A candidate survives only
+  if **legal AND safe** (`clear`/`flag`); hazardous (`refuse`/`escalate`) and illegal proposals are **discarded,
+  never returned** (the `as_claim()` guard generalised to whole designs). Survivors carry calibrated confidence,
+  the v5.6 immune profile, the safety decision, and `output_kind="candidate"` — never asserted to work.
+- **WS-PARETO** — `pen_stack/design/pareto.py`: `pareto_front(designs)` over `(efficiency, durability, safety,
+  deliverability, neg_immune_risk, neg_cost)`. **`neg_immune_risk` is grounded by the v5.6 profile** — the
+  worst-case per-axis in-scope score with the per-axis uncertainty carried as a band; the profile is never
+  collapsed into one number and the in-vivo magnitude stays scope-flagged (`in_vivo_magnitude_unknown`).
+- **WS-ORCH** — `pen_stack/agent/orchestrator_live.py`: `orchestrate(goal)` — plan → generate → call an oracle
+  (cache-first/replayable) for a critique signal → dispose via `verify()` → refine. Every number is tool-sourced;
+  a seed-locked replay reproduces the trace (replay is the CI default); no fabrication.
+- **WS-BENCH** — bench **v0.3.4**: new `generative_design` hard-gate task (`pen_stack/validate/generative_design.py`)
+  — on a frozen mixed pool (benign + hazardous ricin payload + illegal oversize/mRNA-incompatible), the grounded
+  designer returns only legal+safe+calibrated+immune-profiled survivors on a grounded-immune-axis Pareto frontier,
+  while an ungrounded generator ships hazardous/illegal designs and fails by construction.
+- Docs: `docs/generative_design.md`; prereg `ws_{gen,pareto,orch}` + SHA locks; deposit `phase_5.8/`.
+
+### Notes
+- A generated output is a **candidate, never a claim**; novelty is bounded by the oracles' validity and the
+  rules' legality, and never asserted to work. The immune-risk Pareto axis is a worst-case **screen** — the
+  per-axis v5.6 profile (with its validation labels) remains authoritative; in-vivo magnitude is a known-unknown.
+
 ## [5.7.0] - 2026-06-11 - v5.7 release: The Guardian (biosecurity / dual-use safety gate)
 
 Opens the **Closed-Loop arc (Cycle 1 of 7)**. Before PEN-STACK moves toward "build", it is made **safe by

{pen_stack-5.7.0 → pen_stack-5.8.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.7.0
+version: 5.8.0
 date-released: 2026-06-11
 authors:
   - family-names: "Mahaboob Ali"

{pen_stack-5.7.0 → pen_stack-5.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pen-stack
-Version: 5.7.0
+Version: 5.8.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.7.0-blue.svg)](CHANGELOG.md)
-[![Tests](https://img.shields.io/badge/tests-307%20passing-success.svg)](tests/)
+[![Version](https://img.shields.io/badge/version-5.8.0-blue.svg)](CHANGELOG.md)
+[![Tests](https://img.shields.io/badge/tests-317%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.3-6f42c1.svg)](benchmarks/genome_writing_bench/)
+[![Genome-Writing Bench v0.3](https://img.shields.io/badge/benchmark-Genome--Writing%20Bench%20v0.3.4-6f42c1.svg)](benchmarks/genome_writing_bench/)
 
 **Built on five prior, separately published repositories:**
 
@@ -134,6 +134,23 @@ 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.8 — The Live Agent & Generative Designer
+
+v5.8 (**Closed-Loop arc, Cycle 2 of 7**) turns PEN-STACK from a *checker* into a grounded *designer*: it
+**generates** candidate end-to-end writing systems, keeps only those that pass safety + legality + calibration
+(**verifier-as-discriminator**), and returns the **Pareto frontier** of real tradeoffs — with immunogenicity-risk
+now a **grounded** axis sourced from the v5.6 profile, not a placeholder.
+
+| Workstream | What it adds | Result |
+|---|---|---|
+| **GEN** | `design/{space,generate}.py` | generate → `verify()` discriminates; **hazardous + illegal candidates discarded, never returned**; survivors are calibrated, immune-profiled, `output_kind="candidate"` |
+| **PARETO** | `design/pareto.py` | non-dominated frontier over efficiency/durability/safety/deliverability/**neg_immune_risk**/neg_cost; immune axis = worst-case per-axis from v5.6 (uncertainty band carried, in-vivo magnitude flagged) |
+| **ORCH** | `agent/orchestrator_live.py` | plan → generate → oracle critique (cache-first) → `verify()` → refine; every number tool-sourced; **seed-locked replay reproduces the trace** |
+| **BENCH** | bench **v0.3.4** `generative_design` hard gate | grounded designer keeps only legal+safe+calibrated+immune survivors on a grounded-immune Pareto frontier; an ungrounded generator ships hazardous/illegal designs and fails by construction |
+
+A generated output is a **candidate, never a claim**; novelty is bounded by the oracles' validity and the rules'
+legality. See [`docs/generative_design.md`](docs/generative_design.md) and `prereg/ws_{gen,pareto,orch}.yaml`.
+
 ## What is new in v5.7 — The Guardian (biosecurity / dual-use safety gate)
 
 v5.7 opens the **Closed-Loop arc (Cycle 1 of 7)** by making PEN-STACK **safe by construction**: every design
@@ -579,13 +596,14 @@ pen-stack/
 │   │                                   + v5.6 immune_profile (unified per-axis immune-risk vector; never collapsed)
 │   ├── bridge/                       bridge off-target engine (Paper 4): offtarget / fold_qc / guide_qc / pipeline / cli
 │   │                                   + v3.2 offtarget_energetics (position x substitution; held-out 0.88, ships)
-│   ├── agent/                        agentic platform: tools / orchestrator / pen_agent / mcp_server / guardrails; v5.0 co_scientist + cite (multi-strategy, self-critique, cited rationale, scope ledger)
+│   ├── agent/                        agentic platform: tools / orchestrator / pen_agent / mcp_server / guardrails; v5.0 co_scientist + cite (multi-strategy, self-critique, cited rationale, scope ledger); v5.8 orchestrator_live (live, cache-replayable, generate→oracle→verify→refine)
 │   │                                   + v3.2 epistemic (3-tier status) / scope (known-unknowns matcher)
 │   ├── graph/                        v4.5 living world-model knowledge graph (schema/build/query/ingest/cell_types); typed provenanced edges; gated living loop (propose-only)
 │   ├── oracles/                      v4.0 L1 oracle mesh: OracleResult contract + adapters (genome/structure/protein_design/rna/energetics) over the foundation models; version-pinned cache; v5.2-5.6 delivery-immunology scope cards (delivery_genotoxicity/capsid_epitope/innate_sensing/seroprevalence/antipeg)
 │   ├── rules/                        v3.3 machine-readable rules engine (schema/evaluators/loader/solver) over configs/rules/*.yaml
 │   ├── verify/                       v3.3 verification service: verify(design) -> Verdict (legal+reasons+confidence+scope; v4.0 writer_critique; v5.1 delivery_profile; v5.6 immune_profile per-axis vector; v5.7 safety SafetyVerdict)
 │   ├── 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)
 │   ├── 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)
@@ -596,12 +614,13 @@ pen-stack/
 │   │                                   out_of_scope_refusal / target_site_controls / offtarget_energetics_eval /
 │   │                                   v3.3 bench_rule_tasks (T12) / v3.4 bench_writetype_tasks + bench_adversarial_tasks (T13-16) + outcome_calibration /
 │   │                                   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.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)
 │   ├── 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.3 (T1-T16 + co_scientist + safety_screening; tasks / harness / solvers / LEADERBOARD / SHAs)
+├── benchmarks/genome_writing_bench/  Genome-Writing Bench v0.3.4 (T1-T16 + co_scientist + safety_screening + generative_design; 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 /
@@ -610,9 +629,10 @@ pen-stack/
 │                                       seroprevalence / antipeg + oracles/scope_cards (+ v5.6 known_unknowns:
 │                                       cd4_mhcii_help / preexisting_capsid_tcell / complement_carpa);
 │                                       v5.7 safety/{hazard_registry,policy,probes} (Guardian; function/family/taxon-level only)
-├── prereg/                           SHA-locked success criteria (paper1..4 + ws_a..ws_h + v3.2-v5.7 ws_{uq,ep,mc,ba,
+├── prereg/                           SHA-locked success criteria (paper1..4 + ws_a..ws_h + v3.2-v5.8 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} + SHA256 locks)
+│                                       genotox,epitope,innate,seroprev,peg,calib,profile,screen,policy,redteam,
+│                                       gen,pareto,orch} + 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.7.0 → pen_stack-5.8.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.7.0-blue.svg)](CHANGELOG.md)
-[![Tests](https://img.shields.io/badge/tests-307%20passing-success.svg)](tests/)
+[![Version](https://img.shields.io/badge/version-5.8.0-blue.svg)](CHANGELOG.md)
+[![Tests](https://img.shields.io/badge/tests-317%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.3-6f42c1.svg)](benchmarks/genome_writing_bench/)
+[![Genome-Writing Bench v0.3](https://img.shields.io/badge/benchmark-Genome--Writing%20Bench%20v0.3.4-6f42c1.svg)](benchmarks/genome_writing_bench/)
 
 **Built on five prior, separately published repositories:**
 
@@ -59,6 +59,23 @@ 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.8 — The Live Agent & Generative Designer
+
+v5.8 (**Closed-Loop arc, Cycle 2 of 7**) turns PEN-STACK from a *checker* into a grounded *designer*: it
+**generates** candidate end-to-end writing systems, keeps only those that pass safety + legality + calibration
+(**verifier-as-discriminator**), and returns the **Pareto frontier** of real tradeoffs — with immunogenicity-risk
+now a **grounded** axis sourced from the v5.6 profile, not a placeholder.
+
+| Workstream | What it adds | Result |
+|---|---|---|
+| **GEN** | `design/{space,generate}.py` | generate → `verify()` discriminates; **hazardous + illegal candidates discarded, never returned**; survivors are calibrated, immune-profiled, `output_kind="candidate"` |
+| **PARETO** | `design/pareto.py` | non-dominated frontier over efficiency/durability/safety/deliverability/**neg_immune_risk**/neg_cost; immune axis = worst-case per-axis from v5.6 (uncertainty band carried, in-vivo magnitude flagged) |
+| **ORCH** | `agent/orchestrator_live.py` | plan → generate → oracle critique (cache-first) → `verify()` → refine; every number tool-sourced; **seed-locked replay reproduces the trace** |
+| **BENCH** | bench **v0.3.4** `generative_design` hard gate | grounded designer keeps only legal+safe+calibrated+immune survivors on a grounded-immune Pareto frontier; an ungrounded generator ships hazardous/illegal designs and fails by construction |
+
+A generated output is a **candidate, never a claim**; novelty is bounded by the oracles' validity and the rules'
+legality. See [`docs/generative_design.md`](docs/generative_design.md) and `prereg/ws_{gen,pareto,orch}.yaml`.
+
 ## What is new in v5.7 — The Guardian (biosecurity / dual-use safety gate)
 
 v5.7 opens the **Closed-Loop arc (Cycle 1 of 7)** by making PEN-STACK **safe by construction**: every design
@@ -504,13 +521,14 @@ pen-stack/
 │   │                                   + v5.6 immune_profile (unified per-axis immune-risk vector; never collapsed)
 │   ├── bridge/                       bridge off-target engine (Paper 4): offtarget / fold_qc / guide_qc / pipeline / cli
 │   │                                   + v3.2 offtarget_energetics (position x substitution; held-out 0.88, ships)
-│   ├── agent/                        agentic platform: tools / orchestrator / pen_agent / mcp_server / guardrails; v5.0 co_scientist + cite (multi-strategy, self-critique, cited rationale, scope ledger)
+│   ├── agent/                        agentic platform: tools / orchestrator / pen_agent / mcp_server / guardrails; v5.0 co_scientist + cite (multi-strategy, self-critique, cited rationale, scope ledger); v5.8 orchestrator_live (live, cache-replayable, generate→oracle→verify→refine)
 │   │                                   + v3.2 epistemic (3-tier status) / scope (known-unknowns matcher)
 │   ├── graph/                        v4.5 living world-model knowledge graph (schema/build/query/ingest/cell_types); typed provenanced edges; gated living loop (propose-only)
 │   ├── oracles/                      v4.0 L1 oracle mesh: OracleResult contract + adapters (genome/structure/protein_design/rna/energetics) over the foundation models; version-pinned cache; v5.2-5.6 delivery-immunology scope cards (delivery_genotoxicity/capsid_epitope/innate_sensing/seroprevalence/antipeg)
 │   ├── rules/                        v3.3 machine-readable rules engine (schema/evaluators/loader/solver) over configs/rules/*.yaml
 │   ├── verify/                       v3.3 verification service: verify(design) -> Verdict (legal+reasons+confidence+scope; v4.0 writer_critique; v5.1 delivery_profile; v5.6 immune_profile per-axis vector; v5.7 safety SafetyVerdict)
 │   ├── 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)
 │   ├── 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)
@@ -521,12 +539,13 @@ pen-stack/
 │   │                                   out_of_scope_refusal / target_site_controls / offtarget_energetics_eval /
 │   │                                   v3.3 bench_rule_tasks (T12) / v3.4 bench_writetype_tasks + bench_adversarial_tasks (T13-16) + outcome_calibration /
 │   │                                   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.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)
 │   ├── 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.3 (T1-T16 + co_scientist + safety_screening; tasks / harness / solvers / LEADERBOARD / SHAs)
+├── benchmarks/genome_writing_bench/  Genome-Writing Bench v0.3.4 (T1-T16 + co_scientist + safety_screening + generative_design; 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 /
@@ -535,9 +554,10 @@ pen-stack/
 │                                       seroprevalence / antipeg + oracles/scope_cards (+ v5.6 known_unknowns:
 │                                       cd4_mhcii_help / preexisting_capsid_tcell / complement_carpa);
 │                                       v5.7 safety/{hazard_registry,policy,probes} (Guardian; function/family/taxon-level only)
-├── prereg/                           SHA-locked success criteria (paper1..4 + ws_a..ws_h + v3.2-v5.7 ws_{uq,ep,mc,ba,
+├── prereg/                           SHA-locked success criteria (paper1..4 + ws_a..ws_h + v3.2-v5.8 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} + SHA256 locks)
+│                                       genotox,epitope,innate,seroprev,peg,calib,profile,screen,policy,redteam,
+│                                       gen,pareto,orch} + 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.7.0 → pen_stack-5.8.0}/benchmarks/genome_writing_bench/SHA256SUMS

@@ -1,4 +1,4 @@
-61903ba95b3ac8fd132a9507341ebc975a21d834ff01b76f2fb1376a4a494e07  benchmarks/genome_writing_bench/tasks.yaml
+d5d306cdd81cb6f0c67e88de4741610da1898cdb7a2a097e6acfa9226b0c7024  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.7.0 → pen_stack-5.8.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.3"
+version: "0.3.4"
 prepared: "2026-06-11"
 
 taxonomy:
@@ -39,6 +39,8 @@ taxonomy:
   CS_co_scientist:      "end-to-end grounded design: multiple materially-distinct legal confidence-tagged strategies, each citation-grounded + scope-ledgered, no-fabrication across the full reasoning stack (vs an ungrounded agent producing none of these)"
   # v0.3.3 (v5.7): the Guardian - biosecurity / dual-use screening as a hard gate.
   SF_safety_screening:  "screen a design for select-agent / pandemic-pathogen / controlled-toxin signatures: benign therapeutics pass (0 false refusals), hazards refused/escalated, AI-homolog + chimera + reframing evasions never `clear` (vs a no-safety baseline that clears everything)"
+  # v0.3.4 (v5.8): the generative designer - verifier-as-discriminator over a mixed candidate pool.
+  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)"
 
 tasks:
   - id: site_selection_blind_gsh
@@ -243,3 +245,19 @@ tasks:
     note: "v5.7 the Guardian: the no-safety baseline clears everything (passes benign, fails every hazard +
       evasion), so the gate beats it by construction. Function/chimera screens catch AI-homologs homology alone
       would miss; re-framing cannot flip refuse->clear (the artifact decides)."
+
+  - id: generative_design
+    family: GD_generative_design
+    scorer: "pen_stack.validate.generative_design:run"
+    metric: "grounded_designer_valid"
+    baseline_metric: "ungrounded_designer_valid"
+    higher_is_better: true
+    hard_gate: true
+    gate_rule: "grounded_designer_valid == True (survivors all legal+safe+calibrated+immune; hazard+illegal discarded; Pareto immune axis grounded)"
+    ground_truth: "frozen mixed candidate pool (benign FIX-style + hazardous ricin payload + illegal oversize/
+      mRNA-incompatible); validity decided by verify() (safety+legality+calibration+immune), NOT the generator's
+      own claim - non-circular"
+    circular: false
+    note: "v5.8 verifier-as-discriminator: the ungrounded generator returns the raw pool (ships hazardous +
+      illegal designs) and fails by construction; the grounded designer discards them and returns calibrated,
+      immune-profiled candidates on a Pareto frontier with a grounded immune-risk axis."

pen_stack-5.8.0/docs/generative_design.md

@@ -0,0 +1,63 @@
+# The generative designer (v5.8)
+
+From v5.8, PEN-STACK does not only *score* a design you give it — it *generates* candidate end-to-end writing
+systems and returns the **Pareto frontier** of real tradeoffs, with every candidate passing safety, legality,
+and calibration or being discarded. Generation proposes; `verify()` disposes.
+
+## Verifier-as-discriminator (`pen_stack/design/generate.py`)
+
+```python
+from pen_stack.design import generate_designs
+survivors = generate_designs({"gene": "AAVS1", "intent": "safe_harbour_insertion",
+                              "cargo_bp": 3000, "cell_type": "k562"})
+```
+
+Each candidate is run through the v3.3 `verify()` — now **safety-gated (v5.7)**, legality-checked (v3.3),
+calibrated (v3.2), and immune-profiled (v5.6). A candidate **survives only if it is legal AND its safety
+decision is `clear`/`flag`**; hazardous (`refuse`/`escalate`) and illegal candidates are **discarded, never
+returned as claims**. Survivors carry:
+
+- `confidence` + `interval` — calibrated (or an explicit `None` abstention),
+- `immune_profile` — the v5.6 per-axis vector (`collapsed_score` stays `None`),
+- `safety_decision`, `scope_flags`,
+- `output_kind: "candidate"` — never asserted to work.
+
+This generalises the v4.0 `as_claim()` guard from single oracle outputs to whole designs. A novel writer
+sequence in a candidate routes to v4.0 writer-verification (critiqued, never claimed).
+
+Pass an explicit `candidates=[...]` pool to discriminate a known set (atlas-independent); otherwise candidates
+are enumerated by `candidate_space(goal)` — the validated Phase-3 planner (`plan_write`) crossed with every
+compatible delivery vehicle.
+
+## Pareto frontier with a grounded immune-risk axis (`pen_stack/design/pareto.py`)
+
+```python
+from pen_stack.design import pareto_front
+front = pareto_front(survivors)        # non-dominated set
+```
+
+Axes (higher is better on each): `efficiency` (writer activity), `durability` (TRIP model), `safety`
+(genotoxicity-risk), `deliverability` (capacity headroom), **`neg_immune_risk`**, `neg_cost`.
+
+`neg_immune_risk` is **grounded by the v5.6 profile, not a placeholder**: it is the **worst-case per-axis
+in-scope score** (lower score = higher risk) with the largest per-axis uncertainty carried as a **band** — the
+profile is never collapsed into one confident number, and the in-vivo magnitude stays scope-flagged
+(`in_vivo_magnitude_unknown`). Each frontier design exposes `neg_immune_risk_detail` (value + band + axes used +
+flag); the per-axis profile remains the source of truth.
+
+## Live orchestration (`pen_stack/agent/orchestrator_live.py`)
+
+```python
+from pen_stack.agent.orchestrator_live import orchestrate
+run = orchestrate(goal)                # plan -> generate -> oracle critique -> verify -> refine
+```
+
+The agent picks *which* oracle to call; the *number* always comes from the oracle (cache-first, version-pinned,
+**replayable** — replay is the CI default). A seed-locked replay reproduces the trace exactly. No stage
+fabricates a value.
+
+## Honest scope
+
+Generation explores within the oracles' validity and the rules' legality; novelty is bounded and **never
+asserted to work**. The immune-risk Pareto axis is a worst-case **screen** over per-axis proxies — the per-axis
+profile (with its validation labels) is authoritative, and in-vivo magnitude remains a known-unknown.

{pen_stack-5.7.0 → pen_stack-5.8.0}/pen_stack/__init__.py

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

pen_stack-5.8.0/pen_stack/agent/orchestrator_live.py

@@ -0,0 +1,56 @@
+"""Live foundation-model orchestration (v5.8, WS-ORCH).
+
+A reasoning loop that GENERATES grounded candidates, calls oracles (cache-first / replayable) for a critique
+signal, and disposes via `verify()` (safety + legality + immune). The agent picks WHICH oracle to call; the
+NUMBER always comes from the oracle/tool, never invented. Live calls are cache-keyed and version-pinned, so a
+seed-locked replay reproduces a run from the committed cache (replay is the CI default).
+"""
+from __future__ import annotations
+
+from typing import Any
+
+
+def _oracle_critique(design: dict, *, seed: int = 0) -> dict:
+    """A grounded critique number for the top candidate, sourced from an oracle adapter (cache-first). When the
+    candidate carries a writer sequence, use the structure-consistency oracle; otherwise abstain (no fabricated
+    value). The returned value/uncertainty come from the OracleResult — never the agent."""
+    seq = design.get("writer_candidate_seq") or design.get("writer_seq")
+    if not seq:
+        return {"oracle": None, "value": None, "available": False, "note": "no sequence supplied; abstaining"}
+    from pen_stack.oracles.structure import consistency
+    r = consistency(seq)
+    return {"oracle": "structure.consistency", "value": (r.value or {}),
+            "available": bool(r.available), "cached": bool(getattr(r, "cached", False)),
+            "source": getattr(r, "source", None), "output_kind": r.output_kind}
+
+
+def orchestrate(goal: dict, *, candidates: list[dict] | None = None, max_rounds: int = 4,
+                seed: int = 0) -> dict[str, Any]:
+    """Plan -> generate grounded candidates -> call an oracle (cache-first) -> critique via verify() -> refine.
+    Returns the chosen design + a trace in which every number is tool-sourced. Deterministic given the inputs +
+    seed (replayable from cache). No stage fabricates a value."""
+    from pen_stack.design.generate import generate_designs
+    from pen_stack.verify import verify
+
+    state: dict[str, Any] = {"goal": goal, "design": None, "candidates": []}
+    trace: list[dict] = []
+    for r in range(max_rounds):
+        cands = generate_designs(goal, candidates=candidates, keep=5, actor="orchestrator")
+        if not cands:
+            trace.append({"round": r, "action": "generate", "n": 0,
+                          "note": "no surviving candidates (atlas absent or all discarded by the discriminator)"})
+            break
+        top = cands[0]
+        oracle = _oracle_critique(top, seed=seed)
+        v = verify(dict(top), actor="orchestrator")
+        trace.append({"round": r, "action": "generate+oracle+verify", "n": len(cands),
+                      "oracle": oracle, "verdict": v.summary(), "legal": v.legal,
+                      "safety": (v.safety.decision if v.safety is not None else None),
+                      "confidence": v.confidence})
+        state["design"], state["candidates"] = top, cands
+        if v.legal is True and v.safety is not None and v.safety.decision in ("clear", "flag"):
+            break
+        # refine: on a non-passing round, narrow the pool to the survivors for the next iteration
+        candidates = cands
+    return {"goal": goal, "design": state["design"], "trace": trace,
+            "no_fabrication": True, "replayable": True}

pen_stack-5.8.0/pen_stack/design/__init__.py

@@ -0,0 +1,14 @@
+"""pen_stack.design — the grounded generative designer (v5.8).
+
+Generate candidate end-to-end writing systems, keep only those that pass safety + legality + calibration
+(verifier-as-discriminator), and return the Pareto frontier of real tradeoffs — including an immune-risk axis
+grounded in the v5.6 profile. Nothing unvalidated is asserted: every survivor is `output_kind="candidate"`.
+"""
+from __future__ import annotations
+
+from pen_stack.design.generate import generate_designs
+from pen_stack.design.pareto import AXES, neg_immune_risk, pareto_front
+from pen_stack.design.space import candidate_space, deliverability_score
+
+__all__ = ["generate_designs", "candidate_space", "deliverability_score",
+           "pareto_front", "neg_immune_risk", "AXES"]

pen_stack-5.8.0/pen_stack/design/generate.py

@@ -0,0 +1,48 @@
+"""Generative inverse design — verifier-as-discriminator (v5.8, WS-GEN).
+
+Generation PROPOSES candidate end-to-end writing systems; the v3.3 `verify()` — now safety-gated (v5.7),
+legality-checked (v3.3), calibrated (v3.2), and immune-profiled (v5.6) — DISPOSES. A candidate that is hazardous
+(safety refuse/escalate) or illegal is DISCARDED, never returned as a claim: the `as_claim()` guard generalised
+to whole designs. Survivors are explicitly `output_kind="candidate"` — calibrated and immune-profiled, but never
+asserted to work.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from pen_stack.design.space import candidate_space
+from pen_stack.verify import verify
+
+# a survivor must be legal AND safe (cleared or low-severity advisory); refuse/escalate are discarded.
+_SAFE_DECISIONS = {"clear", "flag"}
+
+
+def _confidence_key(d: dict) -> tuple:
+    c = d.get("confidence")
+    return (c is not None, c if c is not None else -1.0)
+
+
+def generate_designs(goal: dict | None = None, *, candidates: list[dict] | None = None,
+                     n: int = 200, keep: int = 25, actor: str = "generator") -> list[dict[str, Any]]:
+    """Generate -> discriminate with `verify()`. Returns the surviving candidates, each carrying a calibrated
+    confidence (or explicit abstention), the v5.6 immune profile, the safety decision, and scope flags, sorted
+    by confidence. Hazardous (refuse/escalate) or illegal proposals are discarded, never returned.
+
+    Pass an explicit ``candidates`` list to discriminate a known pool (atlas-independent); otherwise candidates
+    are enumerated from ``goal`` via the planner-backed candidate space."""
+    pool = candidates if candidates is not None else candidate_space(goal or {}, n=n)
+    survivors: list[dict] = []
+    for d in pool:
+        v = verify(dict(d), actor=actor)
+        decision = v.safety.decision if v.safety is not None else "clear"
+        if v.legal is not True or decision not in _SAFE_DECISIONS:
+            continue                                              # discarded by the discriminator
+        survivors.append({
+            **d,
+            "confidence": v.confidence, "interval": v.interval,
+            "immune_profile": v.immune_profile,                   # v5.6 grounded per-axis vector
+            "safety_decision": decision, "legal": v.legal,
+            "scope_flags": v.scope_flags, "output_kind": "candidate",
+        })
+    survivors.sort(key=_confidence_key, reverse=True)
+    return survivors[:keep]

pen_stack-5.8.0/pen_stack/design/pareto.py

@@ -0,0 +1,70 @@
+"""Multi-objective Pareto frontier with a GROUNDED immune-risk axis (v5.8, WS-PARETO).
+
+Returns the non-dominated set of generated candidates over the design tradeoff axes. The `neg_immune_risk` axis
+is sourced from the v5.6 immune profile (no longer a placeholder): it is the WORST-CASE per-axis in-scope score
+(lower score = higher risk) with the per-axis uncertainty carried as a band — never collapsing the profile into
+one confident number, and keeping the in-vivo magnitude scope-flagged. Unknown axes enter as flagged bounds,
+never fabricated points; the per-axis profile remains the source of truth.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+# higher is better for every axis (neg_* are already oriented so that higher = better).
+AXES = ("efficiency", "durability", "safety", "deliverability", "neg_immune_risk", "neg_cost")
+_COST_CAP_BP = 10000
+
+
+def neg_immune_risk(design: dict) -> dict:
+    """Aggregate the v5.6 immune profile into ONE Pareto axis WITHOUT collapsing it into a confident number:
+    worst-case per-axis in-scope value + the largest per-axis uncertainty as a band. Returns the value (or None
+    when no axis is in scope) + the band + which axes were used + the standing in-vivo scope flag."""
+    prof = (design.get("immune_profile") or {}).get("axes", {})
+    in_scope = {k: a for k, a in prof.items()
+                if a.get("in_scope") and a.get("value") is not None}
+    worst = min((a["value"] for a in in_scope.values()), default=None)   # lower score = higher risk
+    band = max((a.get("uncertainty") or 0.0 for a in in_scope.values()), default=0.0)
+    return {"value": worst, "uncertainty": band, "axes_used": sorted(in_scope),
+            "scope_flag": "in_vivo_magnitude_unknown"}
+
+
+def _scores(design: dict) -> dict[str, float | None]:
+    cargo = float(design.get("cargo_bp") or 0)
+    nir = neg_immune_risk(design)
+    return {
+        "efficiency": _f(design.get("writer_activity")),
+        "durability": _f(design.get("p_durable")),
+        "safety": _f(design.get("safety")),
+        "deliverability": _f(design.get("deliverability")),
+        "neg_immune_risk": nir["value"],
+        "neg_cost": max(0.0, 1.0 - min(cargo, _COST_CAP_BP) / _COST_CAP_BP),
+    }
+
+
+def _f(x) -> float | None:
+    try:
+        return float(x)
+    except (TypeError, ValueError):
+        return None
+
+
+def _dominates(a: dict, b: dict) -> bool:
+    """`a` dominates `b` iff a is >= on every COMPARABLE axis and strictly > on at least one. Axes that are
+    None (unknown) on either design are skipped (a flagged bound never fabricates a winning point)."""
+    comparable = [k for k in AXES if a["scores"][k] is not None and b["scores"][k] is not None]
+    if not comparable:
+        return False
+    ge = all(a["scores"][k] >= b["scores"][k] for k in comparable)
+    gt = any(a["scores"][k] > b["scores"][k] for k in comparable)
+    return ge and gt
+
+
+def pareto_front(designs: list[dict]) -> list[dict[str, Any]]:
+    """Non-dominated set over AXES. Each returned design gets a `scores` dict and a `neg_immune_risk_detail`
+    (value + uncertainty band + axes used + in-vivo scope flag). The immune axis is grounded by v5.6."""
+    enriched = []
+    for d in designs:
+        d = {**d, "scores": _scores(d), "neg_immune_risk_detail": neg_immune_risk(d)}
+        enriched.append(d)
+    front = [d for d in enriched if not any(_dominates(o, d) for o in enriched if o is not d)]
+    return front

pen_stack-5.8.0/pen_stack/design/space.py

@@ -0,0 +1,85 @@
+"""Candidate-space generation for the generative designer (v5.8, WS-GEN support).
+
+`candidate_space(goal)` enumerates candidate end-to-end writing systems — writer x site x cargo x delivery —
+by wrapping the validated Phase-3 inverse-design planner (`plan_write`) for the site x writer x scores, then
+pairing each with every *compatible* delivery vehicle from the curated palette (cargo fits the vehicle
+capacity). Every candidate carries the planner's grounded scores (safety / p_durable / writer_activity) so the
+verifier-as-discriminator can compute a calibrated confidence and the v5.6 immune profile downstream.
+
+Atlas-dependent: when the Phase-1 writability atlas is absent (e.g. a bare laptop checkout), `plan_write`
+yields nothing and `candidate_space` returns []. The discriminator/Pareto logic is independent of the atlas and
+is exercised on explicit candidates (tests/bench fixtures); the atlas path runs on the VM/with data.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from pen_stack.planner.delivery_vehicles import names as _vehicle_names
+from pen_stack.planner.delivery_vehicles import vehicle as _vehicle
+
+# edit-intent -> write_type (the router/verifier dispatches on write_type)
+_INTENT_WRITE_TYPE = {
+    "safe_harbour_insertion": "insertion",
+    "high_durability_insertion": "insertion",
+    "knock_in_with_disruption": "insertion",
+    "landing_pad_insertion": "landing_pad",
+    "regulatory_element_excision": "excision",
+    "repeat_excision": "excision",
+    "regulatory_rewrite": "regulatory_rewrite",
+}
+
+
+def _compatible_vehicles(cargo_bp: int) -> list[str]:
+    """Vehicles whose curated cargo capacity fits the cargo (capacity None = no DNA-packaging limit)."""
+    out = []
+    for n in _vehicle_names():
+        cap = (_vehicle(n) or {}).get("cargo_capacity_bp")
+        if cap is None or cargo_bp <= cap:
+            out.append(n)
+    return out
+
+
+def deliverability_score(vehicle_name: str, cargo_bp: int) -> float:
+    """Grounded deliverability proxy: capacity headroom (more spare capacity = more deliverable),
+    clipped to [0,1]. Vehicles with no packaging limit score 1.0. NOT a clinical claim."""
+    cap = (_vehicle(vehicle_name) or {}).get("cargo_capacity_bp")
+    if cap is None:
+        return 1.0
+    if cargo_bp > cap:
+        return 0.0
+    return max(0.0, min(1.0, (cap - cargo_bp) / cap))
+
+
+def candidate_space(goal: dict, *, n: int = 200, k: int = 8) -> list[dict[str, Any]]:
+    """Enumerate candidate designs for a goal {gene, intent, cargo_bp, cell_type}. Each candidate is a plain
+    dict consumable by `verify()` and carries the planner's grounded scores. Returns [] if the atlas is absent."""
+    gene = goal["gene"]
+    intent = goal.get("intent") or goal.get("edit_intent") or "safe_harbour_insertion"
+    cargo_bp = int(goal.get("cargo_bp") or goal.get("payload_bp") or 3000)
+    ct = goal.get("cell_type") or goal.get("ct") or "k562"
+    write_type = _INTENT_WRITE_TYPE.get(intent, "insertion")
+
+    from pen_stack.planner.pipeline import plan_write
+    try:
+        plans = plan_write(gene, intent, cargo_bp, ct, k=k)
+    except Exception:                       # atlas/data absent -> no candidates (discriminator/Pareto unaffected)
+        return []
+
+    vehicles = _compatible_vehicles(cargo_bp)
+    cands: list[dict] = []
+    for p in plans:
+        for veh in vehicles:
+            cands.append({
+                "write_type": write_type, "gene": gene, "chrom": p["site"]["chrom"],
+                "edit_intent": intent, "writer_family": p["writer"], "cargo_bp": cargo_bp,
+                "cell_type": ct, "delivery_vehicle": veh,
+                # grounded planner scores (model_extra) -> verify() calibrated confidence + downstream:
+                "safety": p["safety"], "p_durable": p["durability"], "writer_activity": p["writer_activity"],
+                "on_target": p["on_target"], "reachability_tier": p.get("reachability_tier"),
+                "deliverability": deliverability_score(veh, cargo_bp),
+                "_planner_score": p["score"],
+                "provenance": {**p.get("provenance", {}), "candidate_space": "v5.8 plan_write x delivery palette"},
+            })
+            if len(cands) >= n:
+                return cands
+    return cands