factorforge-cds 3.3.1__tar.gz → 3.3.2__tar.gz

{factorforge_cds-3.3.1 → factorforge_cds-3.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: factorforge-cds
-Version: 3.3.1
+Version: 3.3.2
 Summary: FactorForge - open-source CDS design and pre-synthesis sequence review by Eijex.
 Author-email: Eijex <eijex.lab@gmail.com>
 License-Expression: AGPL-3.0-only
@@ -93,7 +93,7 @@ FactorForge outputs are **in-silico only** and have not been experimentally vali
 ## Citing
 
 ```
-FactorForge v3.3.1 (2026). Open-source constraint-based CDS design and sequence review.
+FactorForge v3.3.2 (2026). Open-source constraint-based CDS design and sequence review.
 Eijex. https://github.com/eijex/factorforge-cds
 ```
 

{factorforge_cds-3.3.1 → factorforge_cds-3.3.2}/README.md

@@ -60,7 +60,7 @@ FactorForge outputs are **in-silico only** and have not been experimentally vali
 ## Citing
 
 ```
-FactorForge v3.3.1 (2026). Open-source constraint-based CDS design and sequence review.
+FactorForge v3.3.2 (2026). Open-source constraint-based CDS design and sequence review.
 Eijex. https://github.com/eijex/factorforge-cds
 ```
 

{factorforge_cds-3.3.1 → factorforge_cds-3.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "factorforge-cds"
-version = "3.3.1"
+version = "3.3.2"
 description = "FactorForge - open-source CDS design and pre-synthesis sequence review by Eijex."
 readme = "README.md"
 license = "AGPL-3.0-only"

{factorforge_cds-3.3.1 → factorforge_cds-3.3.2}/src/factorforge/__init__.py

@@ -4,7 +4,7 @@ FactorForge - Codon Optimization Platform
 profile: constraint-aware rule/profile engine
 """
 
-__version__ = "3.3.1"
+__version__ = "3.3.2"
 __author__ = "Eijex"
 
 # Auto-register engines (safe when running from source tree)

{factorforge_cds-3.3.1 → factorforge_cds-3.3.2}/src/factorforge/analysis/feasibility.py

@@ -51,6 +51,7 @@ def _cai_from_log(log_sum: float, codon_count: int) -> float:
 def _candidate_summary(
     dna_sequence: str | None,
     codon_weights: dict[str, float],
+    cai_authority: dict[str, Any],
 ) -> dict[str, Any] | None:
     if dna_sequence is None:
         return None
@@ -59,6 +60,7 @@ def _candidate_summary(
     return {
         "dna_sequence": dna_sequence,
         "cai": calculate_cai(dna_sequence, codon_weights),
+        "cai_authority": dict(cai_authority),
         "gc": calculate_gc(dna_sequence),
         "first_region_gc": calculate_first_region_gc(dna_sequence),
         "gc_window_min": min(window_values) if window_values else 0.0,
@@ -66,6 +68,20 @@ def _candidate_summary(
     }
 
 
+def _build_cai_authority(codon_reference_id: str | None) -> dict[str, Any]:
+    if codon_reference_id is None:
+        return {
+            "reference_id": None,
+            "reference_role": "cai_evaluation",
+            "reference_relationship": "unresolved",
+        }
+    return {
+        "reference_id": codon_reference_id,
+        "reference_role": "cai_evaluation",
+        "reference_relationship": "same_as_generation_reference",
+    }
+
+
 def _best_gc_under_gc_range(
     states: dict[int, float],
     protein_length: int,
@@ -104,6 +120,7 @@ def analyze_feasibility(
     target_gc_low: float = DEFAULT_GC_LOW,
     target_gc_high: float = DEFAULT_GC_HIGH,
     gc_ranges: list[tuple[float, float]] | None = None,
+    codon_reference_id: str | None = None,
 ) -> dict[str, Any]:
     """Compute exact CAI/GC feasibility over synonymous codon choices.
 
@@ -160,6 +177,7 @@ def analyze_feasibility(
 
     protein_length = len(protein)
     total_bases = protein_length * 3
+    cai_authority = _build_cai_authority(codon_reference_id)
     best_any_gc = max(states, key=lambda gc_count: states[gc_count])
     best_any_log_sum = states[best_any_gc]
     best_any_sequence = _reconstruct_sequence(backrefs, best_any_gc)
@@ -180,7 +198,7 @@ def analyze_feasibility(
             range_results[key] = {
                 "feasible": True,
                 "max_cai": _cai_from_log(states[gc_count], protein_length),
-                "best_candidate": _candidate_summary(sequence, codon_weights),
+                "best_candidate": _candidate_summary(sequence, codon_weights, cai_authority),
             }
 
     target_cai_possible = (
@@ -192,8 +210,13 @@ def analyze_feasibility(
         "protein_length": protein_length,
         "minimum_possible_gc": (min_gc_count / total_bases) * 100.0,
         "maximum_possible_gc": (max_gc_count / total_bases) * 100.0,
+        "cai_authority": dict(cai_authority),
         "maximum_achievable_cai_without_gc": _cai_from_log(best_any_log_sum, protein_length),
-        "best_candidate_without_gc": _candidate_summary(best_any_sequence, codon_weights),
+        "best_candidate_without_gc": _candidate_summary(
+            best_any_sequence,
+            codon_weights,
+            cai_authority,
+        ),
         "ranges": range_results,
         "target": {
             "cai": target_cai,
@@ -206,7 +229,11 @@ def analyze_feasibility(
                 else None
             ),
             "best_candidate": (
-                _candidate_summary(_reconstruct_sequence(backrefs, target_gc_count), codon_weights)
+                _candidate_summary(
+                    _reconstruct_sequence(backrefs, target_gc_count),
+                    codon_weights,
+                    cai_authority,
+                )
                 if target_gc_count is not None
                 else None
             ),

{factorforge_cds-3.3.1 → factorforge_cds-3.3.2}/src/factorforge/cli/main.py

@@ -154,6 +154,7 @@ def _build_dp_result(
     gc_max: float,
     cai_target: float = DEFAULT_CAI_TARGET,
     codon_table_path: Path | None = None,
+    codon_reference_id: str | None = None,
 ):
     """Run the constraint-based DP feasibility engine for a single protein sequence."""
     if objective != "feasibility_best":
@@ -171,6 +172,7 @@ def _build_dp_result(
         target_cai=cai_target,
         target_gc_low=gc_min,
         target_gc_high=gc_max,
+        codon_reference_id=codon_reference_id,
     )
     best = result["target"]["best_candidate"]
     feasible = best is not None
@@ -222,7 +224,10 @@ def _format_profile_fasta(sequence_id: str, profile: str, result) -> str:
     cai = float(result.metrics.get("cai", 0.0))
     gc = float(result.metrics.get("gc_percent", result.metrics.get("gc_content", 0.0)))
     score = float(result.metrics.get("score", 0.0))
-    header = f">{sequence_id}|profile={profile}|cai={cai:.3f}|gc={gc:.2f}|score={score:.3f}"
+    header = (
+        f">{sequence_id}|engine=profile|profile={profile}|"
+        f"cai={cai:.3f}|gc={gc:.2f}|score={score:.3f}"
+    )
     return f"{header}\n{_wrap_sequence(result.sequence)}\n"
 
 
@@ -399,7 +404,10 @@ def optimize(
             if reference_table_path is not None:
                 from factorforge.engines.profile.optimizer import RuleBasedOptimizer
 
-                optimizer = RuleBasedOptimizer(codon_table_path=str(reference_table_path))
+                optimizer = RuleBasedOptimizer(
+                    codon_table_path=str(reference_table_path),
+                    generation_reference_id=reference_id,
+                )
             else:
                 optimizer = EngineRegistry.get("profile")
             profile_results = []
@@ -436,7 +444,10 @@ def optimize(
             if reference_table_path is not None and engine == "profile":
                 from factorforge.engines.profile.optimizer import RuleBasedOptimizer
 
-                optimizer = RuleBasedOptimizer(codon_table_path=str(reference_table_path))
+                optimizer = RuleBasedOptimizer(
+                    codon_table_path=str(reference_table_path),
+                    generation_reference_id=reference_id,
+                )
             else:
                 optimizer = EngineRegistry.get(engine)
             payload = [{"id": seq_id, "sequence": seq} for seq_id, seq in fasta_records]
@@ -465,14 +476,9 @@ def optimize(
             combined_fasta = []
             for idx, result in enumerate(results):
                 seq_id = payload[idx]["id"]
-                cai = result.metrics.get("cai", 0.0)
-                gc = result.metrics.get("gc_percent", result.metrics.get("gc_content", 0.0))
-                score = result.metrics.get("score", 0.0)
-                header = (
-                    f">{seq_id}|profile={profile}|cai={float(cai):.3f}|"
-                    f"gc={float(gc):.2f}|score={float(score):.3f}"
+                combined_fasta.append(
+                    _format_profile_fasta(seq_id, profile, result).rstrip()
                 )
-                combined_fasta.append(f"{header}\n{_wrap_sequence(result.sequence)}")
             out_content = "\n".join(combined_fasta) + "\n"
 
             if output:
@@ -497,6 +503,7 @@ def optimize(
                 gc_max=gc_max,
                 cai_target=cai_target,
                 codon_table_path=reference_table_path,
+                codon_reference_id=reference_id,
             )
             dna_sequence = best["dna_sequence"]
             cai = float(best["cai"])
@@ -566,7 +573,10 @@ def optimize(
             if reference_table_path is not None and engine == "profile":
                 from factorforge.engines.profile.optimizer import RuleBasedOptimizer
 
-                optimizer = RuleBasedOptimizer(codon_table_path=str(reference_table_path))
+                optimizer = RuleBasedOptimizer(
+                    codon_table_path=str(reference_table_path),
+                    generation_reference_id=reference_id,
+                )
             else:
                 optimizer = EngineRegistry.get(engine)
 

{factorforge_cds-3.3.1 → factorforge_cds-3.3.2}/src/factorforge/core/interfaces/optimizer.py

@@ -16,7 +16,7 @@ class OptimizationResult:
     def __init__(
         self,
         sequence: str,
-        metrics: dict[str, float],
+        metrics: dict[str, Any],
         metadata: dict[str, Any] | None = None,
     ) -> None:
         self.sequence = sequence

{factorforge_cds-3.3.1 → factorforge_cds-3.3.2}/src/factorforge/data/nbenthamiana_golden_set.json

@@ -1,6 +1,10 @@
 {
     "organism": "Nicotiana benthamiana",
+    "reference_id": "nbenthamiana_golden_set_v1",
+    "reference_role": "cai_evaluation",
+    "reference_version": "1",
     "source": "N. benthamiana high-expression CDS frequencies (70%, Kazusa CodonUsage DB / NCBI) blended with RNA-seq expression-weighted codon frequencies (30%, Grosse-Holz et al. 2018 Plant Biotechnology Journal; Prudhomme et al. 2024 Plant Biotechnology Journal / PRIDE PXD042916)",
+    "source_basis": "N. benthamiana high-expression CDS frequencies (70%, Kazusa CodonUsage DB / NCBI) blended with RNA-seq expression-weighted codon frequencies (30%, Grosse-Holz et al. 2018 Plant Biotechnology Journal; Prudhomme et al. 2024 Plant Biotechnology Journal / PRIDE PXD042916)",
     "description": "Codon usage frequencies weighted toward highly expressed N. benthamiana genes (RuBisCO, ribosomal proteins, histones). Used as CAI reference weights per Sharp & Li (1987). All source data is publicly available.",
     "blend_ratio": 0.7,
     "optimal_gc_content": 42.5,

{factorforge_cds-3.3.1 → factorforge_cds-3.3.2}/src/factorforge/engines/__init__.py

@@ -13,7 +13,7 @@ def register_builtin_engines() -> None:
         "profile",
         RuleBasedOptimizer,
         metadata={
-            "version": "3.3.1",
+            "version": "3.3.2",
             "engine_type": "profile_rule_based",
             "role": "stable_profile_engine",
             "stable": True,

{factorforge_cds-3.3.1 → factorforge_cds-3.3.2}/src/factorforge/engines/profile/__init__.py

@@ -5,7 +5,7 @@ Production system (2026)
 Plant-specific rule-based optimization
 """
 
-__version__ = "3.3.1"
+__version__ = "3.3.2"
 
 from .optimizer import RuleBasedOptimizer
 from .pipeline import OptimizationPipeline

{factorforge_cds-3.3.1 → factorforge_cds-3.3.2}/src/factorforge/engines/profile/optimizer.py

@@ -20,9 +20,13 @@ class RuleBasedOptimizer(OptimizerEngine):
     """Profile-based rule optimization engine."""
 
     name = "Profile-based"
-    version = "3.3.1"
+    version = "3.3.2"
 
-    def __init__(self, codon_table_path: str | None = None) -> None:
+    def __init__(
+        self,
+        codon_table_path: str | None = None,
+        generation_reference_id: str | None = None,
+    ) -> None:
         """
         Args:
             codon_table_path: Optional path to a codon usage table JSON used for
@@ -31,6 +35,8 @@ class RuleBasedOptimizer(OptimizerEngine):
                 product `optimize` CLI and the registered engine ever take, so
                 their behavior is unchanged. Injection is used by the benchmark
                 harness to drive design with alternative source-profile tables.
+            generation_reference_id: Explicit manifest reference id when the
+                injected design table is also the CAI evaluation reference.
         """
         self.validator = InputValidator()
         self._codon_table_path = codon_table_path
@@ -43,6 +49,8 @@ class RuleBasedOptimizer(OptimizerEngine):
         self.translator = ReverseTranslator(
             codon_table_path=codon_table_path,
             golden_set_path=codon_table_path,
+            generation_reference_id=generation_reference_id,
+            _allow_golden_set_metadata_fallback=codon_table_path is not None,
         )
         self.rule_engine = RuleEngine()
         self.exporter = SequenceExporter()
@@ -127,7 +135,8 @@ class RuleBasedOptimizer(OptimizerEngine):
             candidates = [{"sequence": optimized_dna, "cai": cai, "gc": gc, "score": score}]
         else:
             translate_kwargs = {
-                k: v for k, v in kwargs.items()
+                k: v
+                for k, v in kwargs.items()
                 if k not in ("scan_mode", "scan_include", "scan_exclude")
             }
             candidates = translator.generate_candidates(
@@ -151,6 +160,7 @@ class RuleBasedOptimizer(OptimizerEngine):
         # 5. Build result
         metrics = {
             "cai": candidates[0]["cai"],
+            "cai_authority": dict(translator.cai_authority),
             # Keep both names for compatibility across existing tests/callers.
             "gc_content": candidates[0]["gc"],
             "gc_percent": candidates[0]["gc"],
@@ -165,9 +175,7 @@ class RuleBasedOptimizer(OptimizerEngine):
             metrics.update(
                 {
                     "gc_target_reached": (
-                        requested_gc_min_percent
-                        <= achieved_gc_percent
-                        <= requested_gc_max_percent
+                        requested_gc_min_percent <= achieved_gc_percent <= requested_gc_max_percent
                     ),
                     "requested_gc_min_percent": requested_gc_min_percent,
                     "requested_gc_max_percent": requested_gc_max_percent,

{factorforge_cds-3.3.1 → factorforge_cds-3.3.2}/src/factorforge/engines/profile/pipeline.py

@@ -187,16 +187,25 @@ class OptimizationPipeline:
                 f"Unknown profile: {effective_profile}. Supported profiles: {supported}"
             ) from exc
 
+        candidate_metrics: dict[str, Any]
         if seq_type == "dna":
             optimized_dna = processed
             expected_protein = translate_dna(processed).rstrip("*")
             cai = translator.calculate_cai(optimized_dna)
             gc = translator.calculate_gc_content(optimized_dna)
             score = calculate_composite_score(
-                cai=cai, gc=gc, sequence=optimized_dna, profile=effective_profile,
+                cai=cai,
+                gc=gc,
+                sequence=optimized_dna,
+                profile=effective_profile,
                 host=effective_host,
             )
-            candidate_metrics = {"cai": cai, "gc": gc, "score": score}
+            candidate_metrics = {
+                "cai": cai,
+                "cai_authority": dict(translator.cai_authority),
+                "gc": gc,
+                "score": score,
+            }
         else:
             expected_protein = processed.rstrip("*")
             logger.debug(f"Generating candidates with profile: {opt_profile.value}")
@@ -207,6 +216,7 @@ class OptimizationPipeline:
             optimized_dna = candidates[0]["sequence"]
             candidate_metrics = {
                 "cai": candidates[0]["cai"],
+                "cai_authority": dict(translator.cai_authority),
                 "gc": candidates[0]["gc"],
                 "score": candidates[0]["score"],
             }
@@ -216,9 +226,7 @@ class OptimizationPipeline:
             )
 
         # Fast pre-check avoids an expensive full rule scan before PolyA fixing.
-        has_polya_signal = any(
-            pattern in optimized_dna for pattern in rule_engine.POLYA_PATTERNS
-        )
+        has_polya_signal = any(pattern in optimized_dna for pattern in rule_engine.POLYA_PATTERNS)
         if has_polya_signal:
             logger.debug("Potential PolyA signal detected; attempting iterative fix")
             polya_fix = rule_engine.fix_polya_iterative(optimized_dna)
@@ -239,15 +247,19 @@ class OptimizationPipeline:
             dinu_fix = rule_engine.fix_dinucleotides(optimized_dna, mode="balanced")
             if dinu_fix["success"]:
                 optimized_dna = dinu_fix["modified_seq"]
-                candidate_metrics["cai"] = round(translator.calculate_cai(optimized_dna), 4)
-                candidate_metrics["gc"] = translator.calculate_gc_content(optimized_dna)
-                candidate_metrics["score"] = calculate_composite_score(
-                    cai=candidate_metrics["cai"],
-                    gc=candidate_metrics["gc"],
+                cai_after_dinucleotide_fix = round(translator.calculate_cai(optimized_dna), 4)
+                gc_after_dinucleotide_fix = translator.calculate_gc_content(optimized_dna)
+                score_after_dinucleotide_fix = calculate_composite_score(
+                    cai=cai_after_dinucleotide_fix,
+                    gc=gc_after_dinucleotide_fix,
                     sequence=optimized_dna,
                     profile=effective_profile,
                     host=effective_host,
                 )
+                candidate_metrics["cai"] = cai_after_dinucleotide_fix
+                candidate_metrics["cai_authority"] = dict(translator.cai_authority)
+                candidate_metrics["gc"] = gc_after_dinucleotide_fix
+                candidate_metrics["score"] = score_after_dinucleotide_fix
                 logger.info(
                     f"Dinucleotide reduction [{dinu_fix['mode']}]: "
                     f"{dinu_fix['initial_count']} -> "
@@ -287,9 +299,7 @@ class OptimizationPipeline:
         template_name = construct_template or self.construct_template
         if template_name:
             if self.construct_builder is None:
-                template_dir = (
-                    self.template_dir or get_data_path() / "templates"
-                )
+                template_dir = self.template_dir or get_data_path() / "templates"
                 self.construct_builder = ConstructBuilder(template_dir)
             construct_record = self.construct_builder.generate_construct(
                 gene_sequence=domesticated_sequence,

{factorforge_cds-3.3.1 → factorforge_cds-3.3.2}/src/factorforge/engines/profile/rules/reverse_translator.py

@@ -13,7 +13,7 @@ import random
 import secrets
 from enum import Enum
 from pathlib import Path
-from typing import Any, cast
+from typing import Any, TypedDict, cast
 
 from factorforge.engines.profile.scoring import (
     calculate_composite_score,
@@ -23,7 +23,6 @@ from factorforge.engines.profile.utils import (
     build_aa_to_codons_map,
     calculate_gc,
     get_data_path,
-    load_golden_set,
     resolve_host_codon_table_path,
 )
 from factorforge.utils.exceptions import EmptyCandidateError
@@ -31,6 +30,16 @@ from factorforge.utils.exceptions import EmptyCandidateError
 logger = logging.getLogger(__name__)
 
 
+class CaiAuthority(TypedDict, total=False):
+    """JSON-serializable CAI reference authority metadata."""
+
+    reference_id: str | None
+    reference_role: str
+    reference_version: str | None
+    reference_relationship: str
+    fallback_used: bool
+
+
 class OptimizationProfile(Enum):
     """Optimization profile"""
 
@@ -58,6 +67,8 @@ class ReverseTranslator:
         codon_table_path: str | Path | None = None,
         golden_set_path: str | Path | None = None,
         host: str = "nbenthamiana",
+        generation_reference_id: str | None = None,
+        _allow_golden_set_metadata_fallback: bool = False,
     ) -> None:
         """
         Args:
@@ -65,6 +76,8 @@ class ReverseTranslator:
             golden_set_path: Path to golden set JSON for CAI reference weights.
                              If None, attempts to load default golden set.
             host: Host codon table name used when codon_table_path is not provided.
+            generation_reference_id: Explicit manifest reference id when the CAI
+                reference is intentionally the same table used for generation.
         """
         self.host = host
         if codon_table_path is None:
@@ -76,13 +89,38 @@ class ReverseTranslator:
         self.aa_to_codons: dict[str, list[tuple[str, float]]] = self._build_aa_to_codons_map()
 
         # Load golden set for CAI reference weights
-        if golden_set_path is not None:
-            self.golden_set_table: dict[str, Any] = self._load_codon_table(golden_set_path)
-        else:
-            try:
-                self.golden_set_table = load_golden_set()
-            except (FileNotFoundError, json.JSONDecodeError):
-                self.golden_set_table = self.codon_table
+        try:
+            if golden_set_path is not None:
+                self.golden_set_table = self._load_codon_table(golden_set_path)
+            else:
+                self.golden_set_table = self._load_codon_table(
+                    get_data_path() / "nbenthamiana_golden_set.json"
+                )
+            if generation_reference_id is not None:
+                self.cai_authority = self._build_generation_reference_cai_authority(
+                    generation_reference_id
+                )
+            else:
+                try:
+                    self.cai_authority = self._build_cai_authority(self.golden_set_table)
+                except ValueError:
+                    if not _allow_golden_set_metadata_fallback:
+                        raise
+                    self.golden_set_table = self.codon_table
+                    self.cai_authority = {
+                        "reference_id": self.codon_table.get("reference_id"),
+                        "reference_role": "cai_evaluation",
+                        "reference_relationship": "fallback_to_generation_reference",
+                        "fallback_used": True,
+                    }
+        except (FileNotFoundError, json.JSONDecodeError):
+            self.golden_set_table = self.codon_table
+            self.cai_authority = {
+                "reference_id": self.codon_table.get("reference_id"),
+                "reference_role": "cai_evaluation",
+                "reference_relationship": "fallback_to_generation_reference",
+                "fallback_used": True,
+            }
 
         # Pre-compute relative adaptiveness weights from golden set (Sharp & Li 1987)
         self.golden_ref_weights: dict[str, float] = self._build_ref_weights(self.golden_set_table)
@@ -132,6 +170,37 @@ class ReverseTranslator:
         with open(path, "r", encoding="utf-8") as f:
             return cast(dict[str, Any], json.load(f))
 
+    @staticmethod
+    def _build_cai_authority(golden_set_table: dict[str, Any]) -> CaiAuthority:
+        """Validate and expose golden-set CAI authority metadata."""
+        required_fields = ("reference_id", "reference_role", "reference_version")
+        missing = [field for field in required_fields if not golden_set_table.get(field)]
+        if missing:
+            raise ValueError(
+                "Golden-set CAI authority metadata is missing required field(s): "
+                + ", ".join(missing)
+            )
+        if golden_set_table["reference_role"] != "cai_evaluation":
+            raise ValueError("Golden-set CAI authority reference_role must be 'cai_evaluation'.")
+
+        return {
+            "reference_id": str(golden_set_table["reference_id"]),
+            "reference_role": "cai_evaluation",
+            "reference_version": str(golden_set_table["reference_version"]),
+            "reference_relationship": "distinct_from_generation_reference",
+            "fallback_used": False,
+        }
+
+    @staticmethod
+    def _build_generation_reference_cai_authority(reference_id: str) -> CaiAuthority:
+        """Expose explicit generation-reference reuse as intentional, not fallback."""
+        return {
+            "reference_id": reference_id,
+            "reference_role": "cai_evaluation",
+            "reference_relationship": "same_as_generation_reference",
+            "fallback_used": False,
+        }
+
     def _build_aa_to_codons_map(self) -> dict[str, list[tuple[str, float]]]:
         """
         Build amino-acid-to-codons map
@@ -520,7 +589,9 @@ class ReverseTranslator:
         last_seq = ""
 
         balanced_kwargs = {
-            k: v for k, v in kwargs.items() if k in ("target_gc_min", "target_gc_max", "max_gc_attempts")
+            k: v
+            for k, v in kwargs.items()
+            if k in ("target_gc_min", "target_gc_max", "max_gc_attempts")
         }
         balanced_kwargs["preferred_ratio"] = 0.6
 

{factorforge_cds-3.3.1 → factorforge_cds-3.3.2}/src/factorforge_cds.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: factorforge-cds
-Version: 3.3.1
+Version: 3.3.2
 Summary: FactorForge - open-source CDS design and pre-synthesis sequence review by Eijex.
 Author-email: Eijex <eijex.lab@gmail.com>
 License-Expression: AGPL-3.0-only
@@ -93,7 +93,7 @@ FactorForge outputs are **in-silico only** and have not been experimentally vali
 ## Citing
 
 ```
-FactorForge v3.3.1 (2026). Open-source constraint-based CDS design and sequence review.
+FactorForge v3.3.2 (2026). Open-source constraint-based CDS design and sequence review.
 Eijex. https://github.com/eijex/factorforge-cds
 ```
 

{factorforge_cds-3.3.1 → factorforge_cds-3.3.2}/src/factorforge_cds.egg-info/SOURCES.txt

@@ -78,6 +78,7 @@ src/factorforge_cds.egg-info/entry_points.txt
 src/factorforge_cds.egg-info/requires.txt
 src/factorforge_cds.egg-info/top_level.txt
 tests/test_baselines.py
+tests/test_benchmark_cli_output_guard.py
 tests/test_benchmark_codon_table_metadata.py
 tests/test_benchmark_regression.py
 tests/test_benchmark_scoring.py

factorforge_cds-3.3.2/tests/test_benchmark_cli_output_guard.py

@@ -0,0 +1,87 @@
+"""CLI output-directory safety tests for the benchmark runner."""
+
+from __future__ import annotations
+
+import hashlib
+import sys
+from pathlib import Path
+
+import pytest
+
+import benchmarks.run_benchmark as run_benchmark
+
+
+def _invoke_main(monkeypatch: pytest.MonkeyPatch, args: list[str], fake_run) -> None:
+    monkeypatch.setattr(sys, "argv", ["run_benchmark.py", *args])
+    monkeypatch.setattr(run_benchmark, "run", fake_run)
+    run_benchmark.main()
+
+
+def test_cli_default_output_dir_stays_v320(monkeypatch: pytest.MonkeyPatch) -> None:
+    captured: dict[str, Path] = {}
+
+    def fake_run(**kwargs) -> None:
+        captured["out_csv"] = kwargs["out_csv"]
+        captured["out_md"] = kwargs["out_md"]
+
+    _invoke_main(monkeypatch, ["--force"], fake_run)
+
+    assert captured["out_csv"] == run_benchmark.DEFAULT_RESULTS_DIR.resolve() / "benchmark_results.csv"
+    assert captured["out_md"] == run_benchmark.DEFAULT_RESULTS_DIR.resolve() / "benchmark_summary.md"
+
+
+def test_cli_refuses_existing_results_without_force(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    output_dir = tmp_path / "existing"
+    output_dir.mkdir()
+    existing_csv = output_dir / "benchmark_results.csv"
+    existing_json = output_dir / "benchmark_summary.json"
+    existing_csv.write_text("do-not-overwrite\n", encoding="utf-8")
+    existing_json.write_text('{"status": "do-not-overwrite"}\n', encoding="utf-8")
+    before_csv_hash = hashlib.sha256(existing_csv.read_bytes()).hexdigest()
+    before_json_hash = hashlib.sha256(existing_json.read_bytes()).hexdigest()
+    before_csv_mtime = existing_csv.stat().st_mtime_ns
+    before_json_mtime = existing_json.stat().st_mtime_ns
+
+    def fail_run(**_kwargs) -> None:
+        raise AssertionError("run() must not be called when overwrite guard fails")
+
+    with pytest.raises(SystemExit) as exc_info:
+        _invoke_main(monkeypatch, ["--out-dir", str(output_dir)], fail_run)
+
+    message = str(exc_info.value)
+    assert "Pass --force" in message
+    assert "benchmark_results.csv" in message
+    assert "benchmark_summary.json" in message
+    assert hashlib.sha256(existing_csv.read_bytes()).hexdigest() == before_csv_hash
+    assert hashlib.sha256(existing_json.read_bytes()).hexdigest() == before_json_hash
+    assert existing_csv.stat().st_mtime_ns == before_csv_mtime
+    assert existing_json.stat().st_mtime_ns == before_json_mtime
+
+
+def test_cli_force_allows_existing_results_overwrite(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    output_dir = tmp_path / "existing"
+    output_dir.mkdir()
+    (output_dir / "benchmark_results.csv").write_text("old\n", encoding="utf-8")
+    (output_dir / "benchmark_summary.json").write_text('{"status": "old"}\n', encoding="utf-8")
+
+    def fake_run(**kwargs) -> None:
+        kwargs["out_csv"].write_text("new\n", encoding="utf-8")
+        kwargs["out_md"].write_text("# new\n", encoding="utf-8")
+        (kwargs["out_md"].parent / "benchmark_summary.json").write_text(
+            '{"status": "new"}\n',
+            encoding="utf-8",
+        )
+
+    _invoke_main(monkeypatch, ["--out-dir", str(output_dir), "--force"], fake_run)
+
+    assert (output_dir / "benchmark_results.csv").read_text(encoding="utf-8") == "new\n"
+    assert (output_dir / "benchmark_summary.md").read_text(encoding="utf-8") == "# new\n"
+    assert (output_dir / "benchmark_summary.json").read_text(encoding="utf-8") == (
+        '{"status": "new"}\n'
+    )