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

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"