@senpi/runtime 3.0.9-dev.20260710204324 → 3.0.9-dev.feat-strategy-compos.20260716233548

package/dist/composer/authoring/emit.py

@@ -0,0 +1,264 @@
+"""emit — render a built graph into teaching YAML (D7 step 3; the machine-generated anchor).
+
+The emitted graph must be a COMPLETE, VALID, COMPILING artifact before any edit (the
+zero-edit oracle), and it must teach in place so a small model can move it toward the edge
+by editing marked slots only (D7). This renderer therefore does three things beyond dumping
+data:
+
+  * slot comments — every bespoke slot (weights, thresholds, fn bodies) carries a
+    ``# TODO(edit): ...`` comment in the hand-written examples' voice, WITH a working
+    default already in place so the graph validates and compiles unedited.
+  * verbatim edge — the user's EDGE free-text is emitted as a comment block directly above
+    the scoring slot; the machine never interprets it (that is the model's only job).
+  * content marker — a ``metadata.generated.content_hash`` over the emitted text (with the
+    hash field itself blanked). ``composer new`` uses it for no-clobber: an unchanged file
+    re-hashes to its stored marker (regenerable), an edited one does not (refused; D7 step 5).
+
+Determinism is a hard property (the byte-identical oracle): the renderer is a pure function
+of the builder + answers, emits dicts/lists in a fixed order, and carries no timestamps.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import re
+
+from .answers import Answers
+from .builder import BuiltNode, GraphBuilder
+
+_HASH_PLACEHOLDER = "0" * 64
+_HASH_RE = re.compile(r'(content_hash: ")([0-9a-f]{64})(")')
+
+_PLAIN_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_.-]*$")
+_YAML_KEYWORDS = {"true", "false", "null", "yes", "no", "on", "off", "~"}
+
+
+# --------------------------------------------------------------------------- scalars
+
+def _dq(s: str) -> str:
+    escaped = s.replace("\\", "\\\\").replace('"', '\\"')
+    escaped = escaped.replace("\n", "\\n").replace("\r", "\\r").replace("\t", "\\t")
+    return '"' + escaped + '"'
+
+
+def _plain_ok(s: str) -> bool:
+    return bool(_PLAIN_RE.match(s)) and s.lower() not in _YAML_KEYWORDS
+
+
+def _float(v: float) -> str:
+    """Render a float so PyYAML parses it back as a float (D6: YAML authored, JSON canonical).
+
+    PyYAML's implicit float resolver requires a decimal point in the mantissa, so bare
+    scientific notation (``repr(1e-7) == '1e-07'``) round-trips as a STRING and fails schema
+    typing. Insert the missing ``.0`` into the mantissa (e.g. ``1e-07`` -> ``1.0e-07``).
+    """
+    s = repr(v)
+    if "e" in s or "E" in s:
+        mant, _, exp = s.replace("E", "e").partition("e")
+        if "." not in mant:
+            mant += ".0"
+        return f"{mant}e{exp}"
+    return s
+
+
+def _scalar(v) -> str:
+    """A single YAML scalar. Strings are emitted plain when unambiguous, else double-quoted;
+    types like ``list[str]`` (which carry brackets) fall to the quoted branch automatically."""
+    if v is None:
+        return "null"
+    if isinstance(v, bool):
+        return "true" if v else "false"
+    if isinstance(v, int):
+        return str(v)
+    if isinstance(v, float):
+        return _float(v)
+    s = str(v)
+    return s if _plain_ok(s) else _dq(s)
+
+
+def _inline(v) -> str:
+    """A value in YAML flow style (used for `with:` params, ports, and leaf test maps).
+
+    Strings are always quoted here (matches the hand-written examples' `dex: "xyz"` /
+    `interval: "4h"` aesthetic); numbers/bools bare; dicts/lists recurse in flow style.
+    """
+    if isinstance(v, dict):
+        if not v:
+            return "{}"
+        items = [f"{_key(k)}: {_inline(val)}" for k, val in v.items()]
+        return "{ " + ", ".join(items) + " }"
+    if isinstance(v, (list, tuple)):
+        if not v:
+            return "[]"
+        return "[" + ", ".join(_inline(x) for x in v) + "]"
+    if isinstance(v, str):
+        return _dq(v)
+    return _scalar(v)
+
+
+def _key(k) -> str:
+    ks = str(k)
+    return ks if _plain_ok(ks) else _dq(ks)
+
+
+# --------------------------------------------------------------------------- block emitter
+
+def _emit_kv(key, value, indent: int) -> list[str]:
+    """Emit `key: value` in block style; dicts recurse, scalar-lists inline, and lists of
+    mappings become `- ` items. Used for metadata and pure_fn inline tests."""
+    pad = " " * indent
+    if isinstance(value, dict):
+        if not value:
+            return [f"{pad}{_key(key)}: {{}}"]
+        out = [f"{pad}{_key(key)}:"]
+        for k, v in value.items():
+            out.extend(_emit_kv(k, v, indent + 2))
+        return out
+    if isinstance(value, (list, tuple)):
+        if not value:
+            return [f"{pad}{_key(key)}: []"]
+        if all(_is_scalar(x) for x in value):
+            return [f"{pad}{_key(key)}: {_inline(list(value))}"]
+        out = [f"{pad}{_key(key)}:"]
+        for item in value:
+            item_lines: list[str] = []
+            for k, v in item.items():
+                item_lines.extend(_emit_kv(k, v, indent + 4))
+            out.append(f"{pad}  - " + item_lines[0].strip())
+            out.extend(item_lines[1:])
+        return out
+    return [f"{pad}{_key(key)}: {_scalar(value)}"]
+
+
+def _is_scalar(x) -> bool:
+    return x is None or isinstance(x, (str, int, float, bool))
+
+
+# --------------------------------------------------------------------------- ports/params
+
+def _inline_port(p: dict) -> str:
+    return f"{{ name: {_scalar(p['name'])}, type: {_scalar(p['type'])}, doc: {_dq(p.get('doc', ''))} }}"
+
+
+def _inline_pure_param(p: dict) -> str:
+    parts = [f"name: {_scalar(p['name'])}", f"type: {_scalar(p['type'])}"]
+    if "default" in p:
+        parts.append(f"default: {_inline(p['default'])}")
+    parts.append(f"doc: {_dq(p.get('doc', ''))}")
+    return "{ " + ", ".join(parts) + " }"
+
+
+# --------------------------------------------------------------------------- node emitter
+
+def _emit_node(bn: BuiltNode) -> list[str]:
+    lines: list[str] = []
+    for h in bn.header:
+        lines.append(f"  # {h}")
+    lines.append(f"  - id: {bn.id}")
+
+    if bn.kind == "pure_fn":
+        lines.append("    kind: pure_fn")
+        lines.append("    inputs:")
+        for p in bn.inputs:
+            lines.append(f"      - {_inline_port(p)}")
+        lines.append("    outputs:")
+        for p in bn.outputs:
+            lines.append(f"      - {_inline_port(p)}")
+        if bn.pure_params:
+            lines.append("    params:")
+            for p in bn.pure_params:
+                lines.append(f"      - {_inline_pure_param(p)}")
+        lines.append("    fn: |")
+        for fl in (bn.fn or "").rstrip("\n").split("\n"):
+            lines.append(f"      {fl}" if fl.strip() else "")
+        if bn.tests:
+            for line in _emit_kv("tests", list(bn.tests), 4):
+                lines.append(line)
+        return lines
+
+    lines.append(f"    node: {bn.node}")
+    if bn.params:
+        lines.append("    with:")
+        for k, v in bn.params.items():
+            line = f"      {_key(k)}: {_inline(v)}"
+            comment = bn.param_comments.get(k)
+            if comment:
+                line += f"   # {comment}"
+            lines.append(line)
+    return lines
+
+
+# --------------------------------------------------------------------------- driver
+
+def render(builder: GraphBuilder, answers: Answers, banner: list[str]) -> str:
+    """Render the built graph to teaching YAML text with a stamped content hash."""
+    lines: list[str] = []
+    for b in banner:
+        lines.append(f"# {b}" if b else "#")
+    lines.append("")
+    lines.append("version: 1")
+    lines.append("")
+
+    # --- metadata (D7: the spec file IS the state — answers live here) ---
+    lines.append("metadata:")
+    meta = {
+        "archetype": answers.archetype,
+        "strategy": answers.strategy,
+        "generated": {"by": "composer new", "content_hash": _HASH_PLACEHOLDER},
+        "answers": answers.metadata_block(),
+    }
+    for k, v in meta.items():
+        lines.extend(_emit_kv(k, v, 2))
+    if answers.edge:
+        lines.append(
+            f"  # EDGE (verbatim, machine never interprets): {_dq(answers.edge)}"
+        )
+    lines.append("")
+
+    # --- nodes ---
+    lines.append("nodes:")
+    for bn in builder.nodes:
+        if builder.edge_anchor == bn.id and answers.edge:
+            lines.append("  # ---------------------------------------------------------------")
+            lines.append("  # EDGE (verbatim — the machine did NOT interpret this; encode it")
+            lines.append("  # by editing the TODO slots on this scoring node):")
+            for eline in answers.edge.split("\n"):
+                lines.append(f"  #   {eline}")
+            lines.append("  # ---------------------------------------------------------------")
+        lines.extend(_emit_node(bn))
+    lines.append("")
+
+    # --- edges ---
+    lines.append("edges:")
+    for e in builder.edges:
+        if e.section:
+            lines.append(f"  # {e.section}")
+        lines.append(f"  - {{ from: {e.frm}, to: {e.to} }}")
+
+    text = "\n".join(ln.rstrip() for ln in lines).rstrip("\n") + "\n"
+    digest = hashlib.sha256(text.encode("utf-8")).hexdigest()
+    return text.replace(_HASH_PLACEHOLDER, digest, 1)
+
+
+# --------------------------------------------------------------------------- no-clobber
+
+def stored_hash(text: str):
+    """The content_hash marker in an emitted file, or None if it carries none."""
+    m = _HASH_RE.search(text)
+    return m.group(2) if m else None
+
+
+def is_unedited_generated(text: str):
+    """True if ``text`` is an unmodified composer-generated graph, False if edited, None if
+    it is not a composer-generated file at all (no marker).
+
+    Recomputes the hash the generator would have produced for this exact content (with the
+    marker blanked) and compares to the stored marker: equal => nobody touched it since
+    generation (safe to regenerate over); unequal => hand-edited (refuse without --force).
+    """
+    stored = stored_hash(text)
+    if stored is None:
+        return None
+    blanked = _HASH_RE.sub(rf"\g<1>{_HASH_PLACEHOLDER}\g<3>", text, count=1)
+    recomputed = hashlib.sha256(blanked.encode("utf-8")).hexdigest()
+    return recomputed == stored

package/dist/composer/authoring/gaps.py

@@ -0,0 +1,115 @@
+"""gaps — feasibility gap report at `new` time (D7 step 4; D4 made mechanical).
+
+Feasibility is enforced BEFORE anything is written: an answer that references a source or
+capability the registry does not have does not crash and does not silently emit a broken
+graph — it produces a structured, printable, ``--json``-able gap report naming each missing
+capability, and ``composer new`` writes no file.
+
+This is D4 ("the agent can authoritatively know what is impossible") turned into a build
+step: the closed registry vocabulary is the oracle, so "can this strategy be built?" is a
+set-membership check, not a judgement call. The report is a teaching artifact in the same
+spirit as the validator's errors — for each missing capability it names what was asked for,
+what kind of node it would be, why the strategy needs it, and the nearest things the
+registry DOES have — so the boundary reads as an honest "here is what's pending", exactly
+the whalehunter paper-exercise story (its ~6 tier-3 pieces are deliberately absent).
+"""
+
+from __future__ import annotations
+
+import difflib
+from dataclasses import dataclass, field
+
+from composer.registry import NODES_BY_NAME
+
+from .answers import Answers
+
+
+@dataclass(frozen=True)
+class Gap:
+    """One missing capability: what was asked for and the nearest registry alternatives."""
+
+    name: str
+    kind: str
+    need: str
+    nearest: tuple[str, ...] = ()
+
+    def render(self) -> str:
+        head = f"  - {self.name} ({self.kind})"
+        if self.need:
+            head += f": {self.need}"
+        near = (
+            f"      nearest in registry: {', '.join(self.nearest)}"
+            if self.nearest
+            else "      nearest in registry: (nothing comparable — this is a new capability)"
+        )
+        return head + "\n" + near
+
+    def to_dict(self) -> dict:
+        return {
+            "name": self.name,
+            "kind": self.kind,
+            "need": self.need,
+            "nearest": list(self.nearest),
+        }
+
+
+@dataclass
+class GapReport:
+    """The result of the feasibility check: every capability the registry lacks."""
+
+    strategy: str
+    archetype: str
+    gaps: list[Gap] = field(default_factory=list)
+
+    @property
+    def ok(self) -> bool:
+        return not self.gaps
+
+    def render(self) -> str:
+        if self.ok:
+            return (
+                f"OK: every capability {self.strategy!r} references is in the registry "
+                f"(no gaps)."
+            )
+        n = len(self.gaps)
+        lines = [
+            f"GAP REPORT: strategy {self.strategy!r} (archetype {self.archetype!r}) "
+            f"references {n} capabilit{'ies' if n != 1 else 'y'} the registry does not have.",
+            "Nothing was written — these must be added to the registry (runtime-owned) first:",
+            "",
+        ]
+        for gap in self.gaps:
+            lines.append(gap.render())
+        lines.append("")
+        lines.append(
+            f"{n} pending capabilit{'ies' if n != 1 else 'y'}. Run `composer catalog` to "
+            f"see what IS available; a strategy that needs these is not yet buildable."
+        )
+        return "\n".join(lines) + "\n"
+
+    def to_json(self) -> dict:
+        return {
+            "strategy": self.strategy,
+            "archetype": self.archetype,
+            "ok": self.ok,
+            "gap_count": len(self.gaps),
+            "gaps": [g.to_dict() for g in self.gaps],
+        }
+
+
+def detect_gaps(answers: Answers) -> GapReport:
+    """Check every registry-name reference in the answers against the closed vocabulary.
+
+    Only the ``requires`` list is checked here: an archetype template supplies its own
+    (known-good) nodes, so the only place an answer can name a capability the machine cannot
+    provide is when it explicitly declares a needed capability that the archetype cannot
+    cover. Each unknown name becomes a :class:`Gap` with the nearest registry alternatives.
+    """
+    valid = sorted(NODES_BY_NAME)
+    gaps: list[Gap] = []
+    for cap in answers.requires:
+        if cap.name in NODES_BY_NAME:
+            continue
+        nearest = tuple(difflib.get_close_matches(cap.name, valid, n=3, cutoff=0.3))
+        gaps.append(Gap(name=cap.name, kind=cap.kind, need=cap.need, nearest=nearest))
+    return GapReport(strategy=answers.strategy, archetype=answers.archetype, gaps=gaps)

package/dist/composer/authoring/generate.py

@@ -0,0 +1,131 @@
+"""generate — the `composer new` orchestration (D7 mechanics, all five steps in order).
+
+    1. answers in (typed; the interview output) — see ``answers``.
+    2. archetype templates are CODE — see ``archetypes`` (build the graph object).
+    3. mechanically-bindable values bound / bespoke slots TODO-marked with working defaults,
+       edge verbatim above the scoring slot — see ``builder`` + ``emit``.
+    4. feasibility gap report BEFORE anything is written — see ``gaps``; enforced here first.
+    5. no-clobber (refuse to overwrite an EDITED graph without --force) + off-map skeleton —
+       enforced here.
+
+``compose_new`` is a pure planning function: it produces a :class:`NewResult` describing
+what SHOULD happen (the rendered text, a gap report, or a clobber refusal) and never touches
+the filesystem except the single read needed to detect an edited target. The CLI does the
+write, so the behaviour is unit-testable without disk.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+from . import emit
+from .answers import Answers
+from .archetypes import ARCHETYPES, SKELETON
+from .gaps import GapReport, detect_gaps
+
+
+@dataclass
+class NewResult:
+    """The outcome of planning a `composer new` invocation."""
+
+    ok: bool                                 # true == a graph is ready to write (yaml_text set)
+    yaml_text: Optional[str] = None
+    output_path: Optional[str] = None        # where it would be written (may already exist)
+    gap_report: Optional[GapReport] = None   # set (and ok=False) when feasibility fails
+    clobber_refused: bool = False            # set (and ok=False) when the target is edited
+    used_skeleton: bool = False              # true when the archetype was off-map
+    message: str = ""
+
+    def to_json(self) -> dict:
+        out: dict = {
+            "ok": self.ok,
+            "output_path": self.output_path,
+            "used_skeleton": self.used_skeleton,
+            "clobber_refused": self.clobber_refused,
+            "message": self.message,
+        }
+        if self.gap_report is not None:
+            out["gap_report"] = self.gap_report.to_json()
+        return out
+
+
+def _bind_protection_default(answers: Answers) -> Answers:
+    """PROTECTION BY DEFAULT (slice 9 policy): `composer new` BINDS ``protected_standard`` when
+    the author left ``exit_preset`` unset and did not opt out via ``unmanaged``. Overriding
+    (a chosen preset) or opting out (``unmanaged=true``) are both honoured untouched. Returns a
+    (possibly) updated copy so the emitted graph metadata carries the bound value."""
+    from .presets import DEFAULT_PRESET
+    if not answers.unmanaged and answers.exit_preset is None:
+        return answers.model_copy(update={"exit_preset": DEFAULT_PRESET})
+    return answers
+
+
+def render_graph(answers: Answers) -> tuple[str, bool]:
+    """Build + render the graph for these answers; returns (yaml_text, used_skeleton)."""
+    answers = _bind_protection_default(answers)
+    module = ARCHETYPES.get(answers.archetype)
+    used_skeleton = module is None
+    if used_skeleton:
+        module = SKELETON
+    builder = module.build(answers)
+    return emit.render(builder, answers, module.BANNER), used_skeleton
+
+
+def compose_new(
+    answers: Answers,
+    output_path: str | Path,
+    *,
+    force: bool = False,
+) -> NewResult:
+    """Plan a `composer new` (does not write). See the module docstring for step order."""
+    path = Path(output_path)
+
+    # Step 4 — feasibility FIRST: a strategy referencing capabilities the registry lacks is
+    # not built and nothing is written (D4/D7). This wins over everything below.
+    gap_report = detect_gaps(answers)
+    if not gap_report.ok:
+        return NewResult(
+            ok=False,
+            output_path=str(path),
+            gap_report=gap_report,
+            message=(
+                f"{len(gap_report.gaps)} capability gap(s); nothing written. "
+                f"Add the missing runtime-owned nodes to the registry first."
+            ),
+        )
+
+    # Steps 2+3+5(off-map) — build (archetype or skeleton) and render.
+    yaml_text, used_skeleton = render_graph(answers)
+
+    # Step 5 — no-clobber: refuse to overwrite a HAND-EDITED graph without --force. An
+    # unedited generated file (its stored content hash still matches) is safe to regenerate.
+    if path.exists() and not force:
+        existing = path.read_text(encoding="utf-8")
+        state = emit.is_unedited_generated(existing)
+        if state is not True:
+            reason = (
+                "the existing file was hand-edited since it was generated"
+                if state is False
+                else "the existing file was not produced by `composer new` (no content marker)"
+            )
+            return NewResult(
+                ok=False,
+                output_path=str(path),
+                clobber_refused=True,
+                used_skeleton=used_skeleton,
+                message=(
+                    f"refusing to overwrite {path.name}: {reason}. "
+                    f"Re-run with --force to overwrite (you will lose those edits)."
+                ),
+            )
+
+    verb = "skeleton (off-map archetype)" if used_skeleton else f"archetype {answers.archetype!r}"
+    return NewResult(
+        ok=True,
+        yaml_text=yaml_text,
+        output_path=str(path),
+        used_skeleton=used_skeleton,
+        message=f"generated a valid graph from {verb}.",
+    )

package/dist/composer/authoring/presets.py

@@ -0,0 +1,168 @@
+"""presets — the exit/risk presets as CI-checked CODE (slice 9 step 2; the PROTECTION policy).
+
+Exits live entirely in `runtime.yaml` (never on the scanner's entry-only signal, see
+`exits-dsl-recon.md`), and the runtime schema legally allows an exit-LESS config — positions
+would then run completely unmanaged (no stop-loss, no trailing, no time-cut). That is the
+disease the composer cures: **PROTECTION BY DEFAULT.** `composer new` binds
+``exit_preset=protected_standard`` unless overridden; a unit with no exit and no explicit
+``unmanaged: true`` opt-out is RED at check (CMP120).
+
+Same "as-code, CI-checked" discipline as the archetype templates
+(``composer.authoring.archetypes``): each preset is a frozen object with a `dsl_preset` block
+(re-validated LIVE by the real Zod+DSL oracle in the slice-9 test suite — a preset that ever
+stopped parsing fails CI, not a live deploy) and a `guard_rails` default. Derived from the
+whole-corpus medians + the archetype exemplars (`runtime-unit-design.md` §2; the recon table
+in `exits-dsl-recon.md`):
+
+  * protected_standard (DEFAULT) — corpus-median, thesis-shaped: balanced let-it-work + recycle.
+  * protected_tight              — hawk-shaped: cut failed entries fast (tight P1).
+  * protected_wide               — stag/bison-shaped: let runners breathe (wide P1, long timeout).
+
+LIVE vs TODO(edit): the preset SELECTION and its phase1 / time-cut scalars are bound live
+(they validate immediately). The phase2 tier ladder and phase1.max_loss_pct carry
+``# TODO(edit)`` slot comments in the emitted runtime.yaml (the ratchet is the most
+thesis-specific knob) while holding the preset default — a small model can tune them without
+ever producing an invalid preset. See ``composer.authoring.runtime_emit``.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ExitPreset(BaseModel):
+    """One named exit+risk preset (protection profile). Frozen, constructed at import — a
+    malformed preset fails at construction (CI), never at a live deploy."""
+
+    model_config = ConfigDict(extra="forbid", frozen=True)
+
+    name: str
+    intent: str
+    interval_seconds: int = 60
+    # The DSL exit preset block (shape validated LIVE by the Zod+DSL oracle in the tests).
+    dsl_preset: dict = Field(default_factory=dict)
+    # risk.guard_rails defaults for this preset (answers knobs override per-field, §4).
+    guard_rails: dict = Field(default_factory=dict)
+
+
+def _tiers(*pairs: tuple[int, int]) -> list[dict]:
+    return [{"trigger_pct": t, "lock_hw_pct": l} for t, l in pairs]
+
+
+# --------------------------------------------------------------------------- the three presets
+
+EXIT_PRESETS: dict[str, ExitPreset] = {
+    "protected_standard": ExitPreset(
+        name="protected_standard",
+        intent="corpus-median balanced protection (thesis-shaped): let it work + recycle.",
+        interval_seconds=60,
+        dsl_preset={
+            "hard_timeout": {"enabled": True, "interval_in_minutes": 4320},   # 3d
+            "weak_peak_cut": {"enabled": True, "interval_in_minutes": 240, "min_value": 2.0},  # 4h
+            "dead_weight_cut": {"enabled": False, "interval_in_minutes": 480},
+            "phase1": {
+                "enabled": True,
+                "max_loss_pct": 15.0,
+                "retrace_threshold": 8,
+                "consecutive_breaches_required": 1,
+            },
+            "phase2": {
+                "enabled": True,
+                "tiers": _tiers((10, 0), (22, 40), (40, 60), (75, 75), (120, 90)),
+            },
+        },
+        guard_rails={
+            "daily_loss_limit_pct": 12,
+            "max_consecutive_losses": 3,
+            "cooldown_seconds": 3600,
+            "drawdown_halt_pct": 20,
+            "drawdown_reset_on_day_rollover": False,
+        },
+    ),
+    "protected_tight": ExitPreset(
+        name="protected_tight",
+        intent="hawk-shaped: TIGHT phase 1 cuts failed entries fast; wide phase-2 runner ladder.",
+        interval_seconds=60,
+        dsl_preset={
+            "hard_timeout": {"enabled": True, "interval_in_minutes": 1440},   # 24h
+            "weak_peak_cut": {"enabled": True, "interval_in_minutes": 60, "min_value": 3.0},  # 60m
+            "dead_weight_cut": {"enabled": False, "interval_in_minutes": 60},
+            "phase1": {
+                "enabled": True,
+                "max_loss_pct": 8.0,
+                "retrace_threshold": 5,
+                "consecutive_breaches_required": 1,
+            },
+            "phase2": {
+                "enabled": True,
+                "tiers": _tiers((10, 0), (20, 25), (30, 40), (50, 60), (75, 75), (100, 85)),
+            },
+        },
+        guard_rails={
+            "daily_loss_limit_pct": 15,
+            "max_consecutive_losses": 3,
+            "cooldown_seconds": 3600,
+            "drawdown_halt_pct": 18,
+            "drawdown_reset_on_day_rollover": False,
+        },
+    ),
+    "protected_wide": ExitPreset(
+        name="protected_wide",
+        intent="stag/bison-shaped: WIDE phase 1 + long timeout — let a runner breathe.",
+        interval_seconds=60,
+        dsl_preset={
+            "hard_timeout": {"enabled": True, "interval_in_minutes": 20160},  # 14d
+            "weak_peak_cut": {"enabled": False, "interval_in_minutes": 240},
+            "dead_weight_cut": {"enabled": False, "interval_in_minutes": 480},
+            "phase1": {
+                "enabled": True,
+                "max_loss_pct": 25.0,
+                "retrace_threshold": 15,
+                "consecutive_breaches_required": 2,
+            },
+            "phase2": {
+                "enabled": True,
+                "tiers": _tiers((15, 0), (30, 30), (60, 55), (120, 72), (250, 85)),
+            },
+        },
+        guard_rails={
+            "daily_loss_limit_pct": 15,
+            "max_consecutive_losses": 4,
+            "cooldown_seconds": 3600,
+            "drawdown_halt_pct": 25,
+            "drawdown_reset_on_day_rollover": False,
+        },
+    ),
+}
+
+DEFAULT_PRESET = "protected_standard"
+
+# guard_rails keys an answers `risk.*` knob overrides (design §4): each is a declarative
+# runtime.yaml field the runtime enforces. answer-field -> guard_rails key.
+RISK_OVERRIDE_KEYS = {
+    "drawdown_halt_pct": "drawdown_halt_pct",
+    "max_consecutive_losses": "max_consecutive_losses",
+    "cooldown_seconds": "cooldown_seconds",
+    "max_entries_per_day": "max_entries_per_day",
+}
+
+
+def preset_names() -> list[str]:
+    """Sorted preset names — used by the catalog surface and error hints. Byte-stable."""
+    return sorted(EXIT_PRESETS)
+
+
+def resolve_guard_rails(preset: ExitPreset, risk_overrides: Optional[dict] = None) -> dict:
+    """The preset's guard_rails with any answer-supplied risk knobs layered on top (§4).
+
+    ``risk_overrides`` is a plain dict of the answers ``Risk`` pause knobs; a ``None`` value
+    means "not set — use the preset default". Returns an ordered dict for deterministic emit.
+    """
+    out = dict(preset.guard_rails)
+    for ans_key, gr_key in RISK_OVERRIDE_KEYS.items():
+        val = (risk_overrides or {}).get(ans_key)
+        if val is not None:
+            out[gr_key] = val
+    return out