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

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

package/dist/composer/authoring/runtime_emit.py

@@ -0,0 +1,266 @@
+"""runtime_emit — render the COMPLETE standalone `runtime.yaml` (slice 9 step 3).
+
+The composer no longer stages a bare scanner (entry-less, exit-less — the incomplete unit
+`exits-dsl-recon.md` flagged). It emits a full, Zod-valid, PROTECTED-by-default runtime unit:
+``strategy`` / ``scanners`` / ``actions`` / ``exit`` / ``risk`` as SIBLING top-level sections
+(NOT nodes in the DAG — they are consumed by the DslPlugin / ActionRegistry at runtime boot,
+a different lifecycle than the ``nodes``/``edges`` compiled into ``scan.py``; design §6).
+
+Everything derives from the graph's ``metadata.answers`` (the single source of truth both
+artifacts share, D7), so recompiling regenerates ``scan.py`` AND ``runtime.yaml``
+byte-identically. LIVE bindings: strategy sizing, the scanner cadence, the exit preset
+SELECTION and its phase1 / time-cut scalars, the guard_rails. TODO(edit) slots (working
+default in place, still valid): ``exit.dsl_preset.phase1.max_loss_pct`` and each
+``exit.dsl_preset.phase2.tiers`` entry (the ratchet is the most thesis-specific knob).
+
+``unmanaged=True`` emits NO ``exit`` section plus a loud warning banner — the deliberate,
+explicit opt-out of protection (a graph that reaches here with ``unmanaged=False`` and no
+exit is impossible: the preset always resolves; the CMP120 gate lives at ``check`` time).
+"""
+
+from __future__ import annotations
+
+import re
+
+from .answers import Answers
+from .presets import DEFAULT_PRESET, EXIT_PRESETS, resolve_guard_rails
+
+# housekeeping window (corpus median 72h); a fixed, sensible default (design §4).
+_DATA_RETENTION_SECONDS = 259200
+# built-in position_tracker cadence (corpus ships ~10s); the DSL twin that mirrors the book.
+_POSITION_TRACKER_INTERVAL = 10
+# external_scanner cadence + signal TTL (corpus 300s / 600s; §0 minimal unit).
+_SCAN_INTERVAL_SECONDS = 300
+_SIGNAL_VALIDITY_SECONDS = 600
+_ENTRY_EXECUTION_TIMEOUT = 45   # design §3: corpus 30–60; use 45.
+
+_UNMANAGED_BANNER = [
+    "!! UNMANAGED — NO EXIT PROTECTION. You passed unmanaged=true, so this runtime ships",
+    "!! WITHOUT a DSL exit: positions run with NO stop-loss, NO trailing floor, NO time-cut.",
+    "!! A loss can run to liquidation. Remove `unmanaged` (or set exit_preset) to restore",
+    "!! protection-by-default (protected_standard). This is a deliberate, explicit opt-out.",
+]
+
+
+def _env_wallet(strategy: str) -> str:
+    slug = re.sub(r"[^0-9a-zA-Z]+", "_", strategy).strip("_").upper() or "STRATEGY"
+    return "${" + f"{slug}_WALLET" + "}"
+
+
+def _dq(s: str) -> str:
+    return '"' + str(s).replace("\\", "\\\\").replace('"', '\\"') + '"'
+
+
+def _num(v) -> str:
+    if isinstance(v, bool):
+        return "true" if v else "false"
+    if isinstance(v, float) and v.is_integer():
+        return str(int(v))
+    return str(v)
+
+
+def _tier_inline(tier: dict) -> str:
+    return "{ " + f"trigger_pct: {_num(tier['trigger_pct'])}, lock_hw_pct: {_num(tier['lock_hw_pct'])}" + " }"
+
+
+def _strategy_name(answers: Answers) -> str:
+    return str(answers.strategy or "unnamed")
+
+
+def _description(answers: Answers, has_exit: bool) -> str:
+    """A substantive top-level description (the runtime registers it; senpi-portfolio reads it
+    back as the strategy's mandate — must be meaningful, >= 40 chars). The verbatim EDGE leads
+    when present; the exit posture is always stated so the mandate names how it protects."""
+    strategy = _strategy_name(answers)
+    if answers.unmanaged:
+        exit_clause = "Runs UNMANAGED (no DSL exit) by explicit opt-out — positions are unprotected."
+    elif has_exit:
+        exit_clause = f"Protected by the '{answers.exit_preset}' DSL exit ({EXIT_PRESETS[answers.exit_preset].intent})"
+    else:
+        exit_clause = "No exit preset set (INCOMPLETE — composer check is RED, CMP120)."
+    edge = (answers.edge or "").strip().replace("\n", " ")
+    lead = edge if edge else (
+        f"A composer-authored {answers.archetype} strategy ({strategy}) that scans its universe "
+        f"each tick and opens signal-gated positions."
+    )
+    return f"{lead} {exit_clause}"
+
+
+def scanner_name(answers: Answers) -> str:
+    return f"{_strategy_name(answers)}_signals"
+
+
+def runtime_name(answers: Answers) -> str:
+    return f"{_strategy_name(answers)}-main"
+
+
+def render_runtime_yaml(answers: Answers) -> str:
+    """Render the complete standalone runtime.yaml text for these answers. Deterministic."""
+    strategy = _strategy_name(answers)
+    sig = scanner_name(answers)
+    has_exit = (not answers.unmanaged) and (answers.exit_preset is not None)
+    lines: list[str] = []
+
+    # --- banner ---
+    if answers.unmanaged:
+        for b in _UNMANAGED_BANNER:
+            lines.append(f"# {b}")
+    elif has_exit:
+        preset = EXIT_PRESETS[answers.exit_preset]
+        lines.append(f"# {strategy} — complete standalone strategy runtime (composer deploy).")
+        lines.append("#")
+        lines.append("# PROTECTED BY DEFAULT: the exit: section below is the resolved preset")
+        lines.append(f"# '{answers.exit_preset}' — {preset.intent}")
+        lines.append("# A standalone runtime in its own funded wallet; ops mints the wallet + installs")
+        lines.append("# (one wallet per instance). Edit ONLY the TODO(edit) slots to tune the exit.")
+    else:
+        # exit_preset unset AND not opted out — the CMP120 contradiction (check flags it RED).
+        lines.append(f"# {strategy} — runtime with NO exit preset set and NO unmanaged opt-out.")
+        lines.append("# This unit is INCOMPLETE by composer policy: `composer check` will be RED (CMP120).")
+        lines.append("# Set an exit_preset, or pass unmanaged=true to deliberately opt out.")
+    lines.append("")
+
+    # --- identity ---
+    lines.append(f"name: {runtime_name(answers)}")
+    lines.append(f"group: {strategy}")
+    lines.append(f"description: {_dq(_description(answers, has_exit))}")
+    lines.append("")
+
+    # --- strategy (only wallet is required; the rest are LIVE from answers.risk) ---
+    lines.append("strategy:")
+    lines.append(f"  wallet: {_dq(_env_wallet(strategy))}")
+    lines.append("  slots: 1")
+    lines.append(f"  margin_pct: {_num(answers.risk.margin_pct)}")
+    lines.append(f"  default_leverage: {_num(answers.risk.leverage)}")
+    lines.append("  trading_risk: moderate")
+    lines.append("  enabled: true")
+    lines.append("")
+
+    # --- scanners: the DSL position twin + the compiled external scanner ---
+    lines.append("scanners:")
+    lines.append("  - name: position_tracker")
+    lines.append("    type: position_tracker")
+    lines.append(f"    interval_seconds: {_POSITION_TRACKER_INTERVAL}")
+    lines.append(f"  - name: {sig}")
+    lines.append("    type: external_scanner")
+    lines.append("    path: ./scanners")
+    lines.append("    entrypoint: scan.py")
+    lines.append(f"    interval_seconds: {_SCAN_INTERVAL_SECONDS}")
+    lines.append(f"    default_signal_validity_seconds: {_SIGNAL_VALIDITY_SECONDS}")
+    lines.append("    signal_data_schema:")
+    lines.append("      score: { type: number }")
+    lines.append("      reasons: { type: array, required: false }")
+    lines.append("")
+
+    # --- actions: 100% mechanical (design §3) — POSITION_TRACKER + OPEN_POSITION ---
+    lines.append("actions:")
+    lines.append("  - name: position_tracker_action")
+    lines.append("    action_type: POSITION_TRACKER")
+    lines.append("    decision_mode: rule")
+    lines.append("    scanners: [position_tracker]")
+    lines.append(f"  - name: {strategy}_entry")
+    lines.append("    action_type: OPEN_POSITION")
+    lines.append("    decision_mode: rule")             # the scan already applied every gate
+    lines.append(f"    scanners: [{sig}]")
+    lines.append("    params:")
+    lines.append("      order_type: FEE_OPTIMIZED_LIMIT")
+    lines.append("      fee_optimized_limit_options:")
+    lines.append("        ensure_execution_as_taker: true")
+    lines.append(f"        execution_timeout_seconds: {_ENTRY_EXECUTION_TIMEOUT}")
+    lines.append("    context:")
+    lines.append("      - type: signal")
+    lines.append(f"        scanner: {sig}")
+    lines.append("")
+
+    # --- exit: the resolved DSL preset (LIVE scalars; tiers + max_loss are TODO slots) ---
+    if has_exit:
+        preset = EXIT_PRESETS[answers.exit_preset]
+        dp = preset.dsl_preset
+        lines.append(f"# EXIT — DSL preset '{preset.name}': {preset.intent}")
+        lines.append("exit:")
+        lines.append("  engine: dsl")
+        lines.append(f"  interval_seconds: {preset.interval_seconds}")
+        lines.append("  order_type: FEE_OPTIMIZED_LIMIT")
+        lines.append("  fee_optimized_limit_options:")
+        lines.append("    ensure_execution_as_taker: true")   # exit closes MUST happen
+        lines.append(f"    execution_timeout_seconds: {_ENTRY_EXECUTION_TIMEOUT}")
+        lines.append("  dsl_preset:")
+        for cut in ("hard_timeout", "weak_peak_cut", "dead_weight_cut"):
+            block = dp[cut]
+            lines.append(f"    {cut}:")
+            lines.append(f"      enabled: {_num(block['enabled'])}")
+            lines.append(f"      interval_in_minutes: {_num(block['interval_in_minutes'])}")
+            if "min_value" in block:
+                lines.append(f"      min_value: {_num(block['min_value'])}")
+        p1 = dp["phase1"]
+        lines.append("    phase1:")
+        lines.append(f"      enabled: {_num(p1['enabled'])}")
+        lines.append(
+            f"      max_loss_pct: {_num(p1['max_loss_pct'])}"
+            "   # TODO(edit): phase-1 hard-floor loss cap (%). Preset default; tighten/loosen for your edge."
+        )
+        lines.append(f"      retrace_threshold: {_num(p1['retrace_threshold'])}")
+        lines.append(f"      consecutive_breaches_required: {_num(p1['consecutive_breaches_required'])}")
+        p2 = dp["phase2"]
+        lines.append("    phase2:")
+        lines.append(f"      enabled: {_num(p2['enabled'])}")
+        lines.append("      tiers:                                # TODO(edit): the phase-2 ratchet — trigger_pct -> lock_hw_pct.")
+        for i, tier in enumerate(p2["tiers"]):
+            note = "  # TODO(edit): tier — lock-in floor at this ROE" if i == 0 else ""
+            lines.append(f"        - {_tier_inline(tier)}{note}")
+        lines.append("")
+
+    # --- risk.guard_rails: the automated pause / circuit breaker (design §4) ---
+    # Present even when unmanaged: the drawdown-halt circuit breaker is independent of the
+    # per-position DSL exit, so an unmanaged unit still ships guard rails from the default preset.
+    guard_rails = resolve_guard_rails(
+        EXIT_PRESETS[answers.exit_preset or DEFAULT_PRESET],
+        {
+            "drawdown_halt_pct": answers.risk.drawdown_halt_pct,
+            "max_consecutive_losses": answers.risk.max_consecutive_losses,
+            "cooldown_seconds": answers.risk.cooldown_seconds,
+            "max_entries_per_day": answers.risk.max_entries_per_day,
+        },
+    )
+    lines.append("# RISK guard rails — the automated pause / circuit breaker (composer owns policy; ops owns manual stop).")
+    lines.append("risk:")
+    lines.append(f"  data_retention_seconds: {_DATA_RETENTION_SECONDS}")
+    lines.append("  guard_rails:")
+    # deterministic key order
+    for key in (
+        "daily_loss_limit_pct",
+        "max_entries_per_day",
+        "max_consecutive_losses",
+        "cooldown_seconds",
+        "drawdown_halt_pct",
+        "drawdown_reset_on_day_rollover",
+    ):
+        if key in guard_rails:
+            lines.append(f"    {key}: {_num(guard_rails[key])}")
+
+    return "\n".join(ln.rstrip() for ln in lines).rstrip("\n") + "\n"
+
+
+def answers_from_metadata(metadata: dict) -> Answers:
+    """Reconstruct :class:`Answers` from a graph's ``metadata`` (the SoT both artifacts derive
+    from). Used by ``check``/``deploy`` to emit runtime.yaml from the graph.
+
+    Two shapes are accepted:
+      * ``composer new`` output carries a full ``metadata.answers`` block -> construct from it.
+      * A hand-authored example carries only top-level ``metadata`` keys (archetype, strategy,
+        and optionally ``exit_preset`` / ``unmanaged``) -> construct a minimal Answers, letting
+        the exit_preset default to protected_standard (PROTECTION BY DEFAULT).
+    """
+    metadata = metadata or {}
+    block = metadata.get("answers")
+    if isinstance(block, dict) and block:
+        return Answers(**block)
+    kwargs: dict = {
+        "archetype": str(metadata.get("archetype") or "skeleton"),
+        "strategy": str(metadata.get("strategy") or "unnamed"),
+    }
+    if metadata.get("exit_preset") is not None:
+        kwargs["exit_preset"] = metadata["exit_preset"]
+    if metadata.get("unmanaged") is not None:
+        kwargs["unmanaged"] = bool(metadata["unmanaged"])
+    return Answers(**kwargs)

package/dist/composer/authoring/strategy_manifest.py

@@ -0,0 +1,94 @@
+"""strategy_manifest — emit the `strategy.yaml` catalog + funding manifest (slice 9 step 8).
+
+The THIN package manifest (design §7; shape = `skills/strategies/<id>/strategy.yaml`): the
+single source of truth for ``id`` / ``version`` / catalog facets / ``instances[]``. It carries
+NO tunables (those live in the instance's runtime.yaml) — only what the ops handoff reads:
+
+  * ``catalog:`` facets — name / thesis / tier / assets / tags. ``thesis`` carries the verbatim
+    EDGE (the machine never interprets it; it is the user's own words).
+  * ``requires.runtime: ">=3.0.0"`` — the runtime-major compatibility boundary.
+  * ``instances:`` — a SINGLE instance for the POC (``funding_share: 1.0``); multi-instance
+    packages (magpie's two books) are out of scope. ``wallet_env`` matches the ``${...}``
+    placeholder the runtime.yaml binds, so ops can mint one wallet per instance and fund by share.
+
+The composer's scope ENDS at emitting this manifest + the staged unit; it never creates
+wallets, moves money, or installs — that is ``senpi-strategy-ops`` (design §7 scope boundary).
+"""
+
+from __future__ import annotations
+
+import re
+
+from .answers import Answers
+from .runtime_emit import _dq  # reuse the shared double-quote helper
+
+
+def _slug_env(strategy: str) -> str:
+    return (re.sub(r"[^0-9a-zA-Z]+", "_", strategy).strip("_").upper() or "STRATEGY") + "_WALLET"
+
+
+def _assets(answers: Answers) -> list[str]:
+    u = answers.universe
+    if u.whitelist:
+        return list(u.whitelist)
+    combined = list(u.long_basket) + list(u.short_basket)
+    if combined:
+        return combined
+    if u.discover:
+        return []  # discovered each tick — no fixed asset list
+    return []
+
+
+def _tags(answers: Answers) -> list[str]:
+    tags = [answers.archetype]
+    if answers.universe.discover:
+        tags.append("discovery")
+    tags.append("composer-authored")
+    if answers.unmanaged:
+        tags.append("unmanaged")
+    else:
+        tags.append("protected")
+    # dedupe preserving order
+    seen: set[str] = set()
+    return [t for t in tags if not (t in seen or seen.add(t))]
+
+
+def render_strategy_yaml(answers: Answers, *, version: str = "0.1.0") -> str:
+    """Render the strategy.yaml manifest text for these answers. Deterministic."""
+    strategy = str(answers.strategy or "unnamed")
+    thesis = (answers.edge or "").strip().replace("\n", " ") or (
+        f"A composer-authored {answers.archetype} strategy."
+    )
+    assets = _assets(answers)
+    tags = _tags(answers)
+
+    lines: list[str] = []
+    lines.append(f"# {strategy} — strategy package manifest (composer deploy). THIN: id/version/")
+    lines.append("# catalog facets + instances[] only. Ops mints one wallet per instance + installs.")
+    lines.append("schema_version: 1")
+    lines.append("")
+    lines.append(f"id: {strategy}")
+    lines.append(f"version: {_dq(version)}")
+    lines.append("")
+    lines.append("catalog:")
+    lines.append(f"  name: {_dq(strategy)}")
+    lines.append(f"  archetype: {_dq(answers.archetype)}")
+    lines.append(f"  thesis: {_dq(thesis)}")
+    lines.append("  tier: starter")
+    lines.append("  risk_level: moderate")
+    if assets:
+        lines.append(f"  assets: [{', '.join(_dq(a) for a in assets)}]")
+    else:
+        lines.append("  assets: []                    # discovered each tick (no fixed universe)")
+    lines.append(f"  tags: [{', '.join(tags)}]")
+    lines.append("")
+    lines.append("requires:")
+    lines.append("  runtime: \">=3.0.0\"")
+    lines.append("")
+    lines.append("instances:")
+    lines.append("  - name: main")
+    lines.append("    runtime: main/runtime.yaml")
+    lines.append(f"    wallet_env: {_slug_env(strategy)}")
+    lines.append("    funding_share: 1.0")
+
+    return "\n".join(ln.rstrip() for ln in lines).rstrip("\n") + "\n"