web3skill 0.1.0

package/dist/skills/web3-native-operator/scripts/render_operator_bundle.py

@@ -0,0 +1,800 @@
+#!/usr/bin/env python3
+"""Render a stable multi-workflow Web3 operator bundle."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+import sys
+
+from render_execution_bundle import (
+    build_execution_bundle,
+    resolve_risk_gate,
+    resolve_simulation,
+    validate_merged_context,
+)
+
+
+RESEARCH_CONCLUSIONS = (
+    "watch",
+    "investigate-more",
+    "ready-for-risk-gate",
+    "avoid-for-now",
+)
+RESEARCH_FRESHNESS_VALUES = ("fresh", "mixed", "stale")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="Render a multi-workflow Web3 operator bundle.")
+    subparsers = parser.add_subparsers(dest="workflow_kind", required=True)
+
+    execution = subparsers.add_parser("execution")
+    execution.add_argument("--intent", required=True)
+    execution.add_argument("--chain", required=True)
+    execution.add_argument("--risk-decision", choices=("ALLOW", "WARN", "BLOCK"))
+    execution.add_argument("--risk-coverage", choices=("complete", "partial", "missing"))
+    execution.add_argument("--risk-input-file", action="append", default=[])
+    execution.add_argument(
+        "--simulation-status",
+        choices=("PASS", "WARN", "FAIL", "NO_SIMULATION"),
+    )
+    execution.add_argument(
+        "--simulation-readiness",
+        choices=("ready", "needs-confirmation", "blocked"),
+    )
+    execution.add_argument("--simulation-venue")
+    execution.add_argument("--simulation-input-file", action="append", default=[])
+    execution.add_argument("--reason", action="append", default=[])
+    execution.add_argument("--follow-up-skill", action="append", default=[])
+
+    audit = subparsers.add_parser("audit")
+    audit.add_argument(
+        "--review-state",
+        choices=(
+            "scope-locked",
+            "context-built",
+            "evidence-collected",
+            "candidate-findings-triaged",
+            "confirmed-findings-written",
+            "retest-or-residual-risk",
+        ),
+        required=True,
+    )
+    audit.add_argument(
+        "--static-status",
+        choices=("complete", "partial", "blocked", "not-run"),
+        default="not-run",
+    )
+    audit.add_argument(
+        "--fuzz-status",
+        choices=("ready", "partial", "blocked", "not-run"),
+        default="not-run",
+    )
+    audit.add_argument("--candidate-count", type=int, default=0)
+    audit.add_argument("--confirmed-count", type=int, default=0)
+    audit.add_argument("--reason", action="append", default=[])
+    audit.add_argument("--follow-up-skill", action="append", default=[])
+
+    research = subparsers.add_parser("research")
+    research.add_argument(
+        "--conclusion",
+        choices=("watch", "investigate-more", "ready-for-risk-gate", "avoid-for-now"),
+        required=True,
+    )
+    research.add_argument("--freshness", choices=("fresh", "mixed", "stale"), default="mixed")
+    research.add_argument("--reason", action="append", default=[])
+    research.add_argument("--follow-up-skill", action="append", default=[])
+
+    watch = subparsers.add_parser("watch")
+    watch.add_argument(
+        "--watch-status",
+        choices=("ACTIVE", "TRIGGERED", "CLEARED", "UNAVAILABLE"),
+        required=True,
+    )
+    watch.add_argument(
+        "--watch-kind",
+        choices=("research", "portfolio", "posttrade", "trace", "venue", "execution"),
+        required=True,
+    )
+    watch.add_argument("--subject", required=True)
+    watch.add_argument("--trigger-source", default="")
+    watch.add_argument(
+        "--severity",
+        choices=("low", "medium", "high", "critical"),
+        default="medium",
+    )
+    watch.add_argument("--next-check-hint", default="")
+    watch.add_argument("--schedule-hint", default="")
+    watch.add_argument("--recommended-adapter", default="")
+    watch.add_argument("--reason", action="append", default=[])
+    watch.add_argument("--follow-up-skill", action="append", default=[])
+
+    pretrade = subparsers.add_parser("pretrade")
+    pretrade.add_argument("--intent", required=True)
+    pretrade.add_argument("--chain", required=True)
+    pretrade.add_argument("--research-input-file")
+    pretrade.add_argument(
+        "--research-conclusion",
+        choices=RESEARCH_CONCLUSIONS,
+    )
+    pretrade.add_argument("--research-freshness", choices=RESEARCH_FRESHNESS_VALUES)
+    pretrade.add_argument("--research-question", default="")
+    pretrade.add_argument("--research-source", action="append", default=[])
+    pretrade.add_argument("--research-evidence", action="append", default=[])
+    pretrade.add_argument("--research-cross-check", action="append", default=[])
+    pretrade.add_argument("--research-next-step", action="append", default=[])
+    pretrade.add_argument("--risk-decision", choices=("ALLOW", "WARN", "BLOCK"))
+    pretrade.add_argument("--risk-coverage", choices=("complete", "partial", "missing"))
+    pretrade.add_argument("--risk-input-file", action="append", default=[])
+    pretrade.add_argument(
+        "--simulation-status",
+        choices=("PASS", "WARN", "FAIL", "NO_SIMULATION"),
+    )
+    pretrade.add_argument(
+        "--simulation-readiness",
+        choices=("ready", "needs-confirmation", "blocked"),
+    )
+    pretrade.add_argument("--simulation-venue")
+    pretrade.add_argument("--simulation-input-file", action="append", default=[])
+    pretrade.add_argument("--reason", action="append", default=[])
+    pretrade.add_argument("--follow-up-skill", action="append", default=[])
+
+    posttrade = subparsers.add_parser("posttrade")
+    posttrade.add_argument("--venue", required=True)
+    posttrade.add_argument(
+        "--receipt-status",
+        choices=("SUBMITTED", "PENDING", "CONFIRMED", "FILLED", "FAILED", "REVERTED"),
+        required=True,
+    )
+    posttrade.add_argument("--settlement", choices=("evm", "venue"), required=True)
+    posttrade.add_argument("--reference-id", default="")
+    posttrade.add_argument("--reason", action="append", default=[])
+    posttrade.add_argument("--follow-up-skill", action="append", default=[])
+
+    portfolio = subparsers.add_parser("portfolio")
+    portfolio.add_argument(
+        "--portfolio-status",
+        choices=("COMPLETE", "PARTIAL", "UNAVAILABLE"),
+        required=True,
+    )
+    portfolio.add_argument("--coverage", choices=("complete", "partial", "missing"), default="partial")
+    portfolio.add_argument("--source-class", choices=("wallet", "address", "venue"), required=True)
+    portfolio.add_argument("--provider", required=True)
+    portfolio.add_argument("--venue", default="none")
+    portfolio.add_argument("--reason", action="append", default=[])
+    portfolio.add_argument("--follow-up-skill", action="append", default=[])
+
+    trace = subparsers.add_parser("trace")
+    trace.add_argument(
+        "--trace-status",
+        choices=("COMPLETE", "PARTIAL", "UNAVAILABLE"),
+        required=True,
+    )
+    trace.add_argument(
+        "--backend-readiness",
+        choices=("ready", "partial", "missing"),
+        required=True,
+    )
+    trace.add_argument(
+        "--reentry-target",
+        choices=("execution", "audit", "research"),
+        required=True,
+    )
+    trace.add_argument("--reason", action="append", default=[])
+    trace.add_argument("--follow-up-skill", action="append", default=[])
+
+    return parser
+
+
+def parse_research_evidence(entries: list[str]) -> list[dict[str, str]]:
+    parsed = []
+    for entry in entries:
+        adapter, sep, detail = entry.partition(":")
+        if sep:
+            parsed.append({"adapter": adapter.strip(), "detail": detail.strip()})
+        else:
+            parsed.append({"adapter": "unknown", "detail": entry})
+    return parsed
+
+
+def default_research_question(intent: str, chain: str) -> str:
+    return f"Should intent '{intent}' on {chain} advance to risk gate?"
+
+
+def load_json_payload(path: str) -> dict[str, object]:
+    if path == "-":
+        return json.load(sys.stdin)
+    return json.loads(Path(path).read_text(encoding="utf-8"))
+
+
+def extract_research_brief(payload: dict[str, object]) -> dict[str, object]:
+    brief = payload.get("research_brief")
+    if isinstance(brief, dict):
+        return brief
+    if {"conclusion", "freshness"}.issubset(payload):
+        return payload
+    raise ValueError("input payload does not contain research_brief")
+
+
+def normalize_research_brief(
+    brief: dict[str, object],
+    intent: str,
+    chain: str,
+) -> dict[str, object]:
+    conclusion = str(brief.get("conclusion", ""))
+    freshness = str(brief.get("freshness", "mixed"))
+    if conclusion not in RESEARCH_CONCLUSIONS:
+        raise ValueError(f"unsupported research conclusion: {conclusion}")
+    if freshness not in RESEARCH_FRESHNESS_VALUES:
+        raise ValueError(f"unsupported research freshness: {freshness}")
+
+    sources = brief.get("sources_used", [])
+    evidence = brief.get("evidence", [])
+    cross_checks = brief.get("cross_checks", [])
+    next_steps = brief.get("next_steps", [])
+    version = brief.get("version", 1)
+    return {
+        "version": int(version) if isinstance(version, int) else 1,
+        "question": str(brief.get("question", "")) or default_research_question(intent, chain),
+        "freshness": freshness,
+        "sources_used": [str(item) for item in sources if isinstance(item, str)],
+        "evidence": [item for item in evidence if isinstance(item, dict)],
+        "cross_checks": [str(item) for item in cross_checks if isinstance(item, str)],
+        "conclusion": conclusion,
+        "next_steps": [str(item) for item in next_steps if isinstance(item, str)],
+    }
+
+
+def build_research_brief(
+    intent: str,
+    chain: str,
+    conclusion: str,
+    freshness: str,
+    question: str,
+    sources: list[str],
+    evidence: list[str],
+    cross_checks: list[str],
+    next_steps: list[str],
+) -> dict[str, object]:
+    return {
+        "version": 1,
+        "question": question or default_research_question(intent, chain),
+        "freshness": freshness,
+        "sources_used": sources,
+        "evidence": parse_research_evidence(evidence),
+        "cross_checks": cross_checks,
+        "conclusion": conclusion,
+        "next_steps": next_steps,
+    }
+
+
+def resolve_research_brief(
+    intent: str,
+    chain: str,
+    research_input_file: str | None,
+    research_conclusion: str | None,
+    research_freshness: str | None,
+    research_question: str,
+    research_source: list[str],
+    research_evidence: list[str],
+    research_cross_check: list[str],
+    research_next_step: list[str],
+) -> tuple[str, str, dict[str, object]]:
+    if research_input_file:
+        research_brief = normalize_research_brief(
+            extract_research_brief(load_json_payload(research_input_file)),
+            intent,
+            chain,
+        )
+        loaded_conclusion = str(research_brief["conclusion"])
+        loaded_freshness = str(research_brief["freshness"])
+        if research_conclusion and research_conclusion != loaded_conclusion:
+            raise ValueError(
+                "explicit research conclusion "
+                f"{research_conclusion} conflicts with loaded research_brief {loaded_conclusion}"
+            )
+        if research_freshness and research_freshness != loaded_freshness:
+            raise ValueError(
+                "explicit research freshness "
+                f"{research_freshness} conflicts with loaded research_brief {loaded_freshness}"
+            )
+        return loaded_conclusion, loaded_freshness, research_brief
+
+    if not research_conclusion:
+        raise ValueError("research conclusion is required unless --research-input-file is provided")
+    resolved_freshness = research_freshness or "mixed"
+    return (
+        research_conclusion,
+        resolved_freshness,
+        build_research_brief(
+            intent=intent,
+            chain=chain,
+            conclusion=research_conclusion,
+            freshness=resolved_freshness,
+            question=research_question,
+            sources=research_source,
+            evidence=research_evidence,
+            cross_checks=research_cross_check,
+            next_steps=research_next_step,
+        ),
+    )
+
+
+def wants_risk_context(args: argparse.Namespace) -> bool:
+    return bool(args.risk_input_file or args.risk_decision or args.risk_coverage)
+
+
+def wants_simulation_context(args: argparse.Namespace) -> bool:
+    return bool(
+        args.simulation_input_file
+        or args.simulation_status
+        or args.simulation_readiness
+        or args.simulation_venue
+    )
+
+
+def choose_audit_route(
+    review_state: str,
+    static_status: str,
+    fuzz_status: str,
+    follow_up_skills: list[str],
+) -> tuple[str, str, str]:
+    if static_status != "complete":
+        return "collect-evidence", "web3-static-analysis-runner", "route"
+    if fuzz_status != "ready":
+        return "collect-evidence", "web3-fuzzing-and-invariants", "route"
+    if review_state in ("candidate-findings-triaged",):
+        next_adapter = follow_up_skills[0] if follow_up_skills else "web3-audit-orchestrator"
+        return "triage-findings", next_adapter, "investigate"
+    if review_state in ("confirmed-findings-written", "retest-or-residual-risk"):
+        return "report-and-retest", "web3-audit-reporting", "route"
+    next_adapter = follow_up_skills[0] if follow_up_skills else "web3-audit-orchestrator"
+    return "collect-evidence", next_adapter, "route"
+
+
+def build_audit_bundle(args: argparse.Namespace) -> dict[str, object]:
+    state, next_adapter, execution_mode = choose_audit_route(
+        args.review_state,
+        args.static_status,
+        args.fuzz_status,
+        args.follow_up_skill,
+    )
+    return {
+        "version": 1,
+        "workflow_kind": "audit",
+        "state": state,
+        "next_adapter": next_adapter,
+        "execution_mode": execution_mode,
+        "requires_user_confirmation": False,
+        "inputs": {
+            "review_state": args.review_state,
+            "static_status": args.static_status,
+            "fuzz_status": args.fuzz_status,
+            "candidate_count": args.candidate_count,
+            "confirmed_count": args.confirmed_count,
+        },
+        "follow_up_skills": args.follow_up_skill,
+        "reasons": args.reason,
+    }
+
+
+def build_research_bundle(args: argparse.Namespace) -> dict[str, object]:
+    if args.conclusion == "avoid-for-now":
+        state = "avoid"
+        next_adapter = "none"
+        execution_mode = "stop"
+    elif args.conclusion == "ready-for-risk-gate":
+        state = "ready-to-gate"
+        next_adapter = "web3-risk-gate"
+        execution_mode = "route"
+    elif args.conclusion == "watch":
+        state = "watch"
+        next_adapter = args.follow_up_skill[0] if args.follow_up_skill else "none"
+        execution_mode = "monitor"
+    else:
+        state = "investigate-more"
+        next_adapter = (
+            args.follow_up_skill[0]
+            if args.follow_up_skill
+            else "web3-research-and-market-intel"
+        )
+        execution_mode = "investigate"
+    return {
+        "version": 1,
+        "workflow_kind": "research",
+        "state": state,
+        "next_adapter": next_adapter,
+        "execution_mode": execution_mode,
+        "requires_user_confirmation": False,
+        "inputs": {
+            "conclusion": args.conclusion,
+            "freshness": args.freshness,
+        },
+        "follow_up_skills": args.follow_up_skill,
+        "reasons": args.reason,
+    }
+
+
+def default_watch_adapter(watch_kind: str) -> str:
+    return {
+        "research": "web3-research-and-market-intel",
+        "portfolio": "web3-research-and-market-intel",
+        "posttrade": "web3-trace-and-state-analysis",
+        "trace": "web3-trace-and-state-analysis",
+        "venue": "hyperliquid",
+        "execution": "web3-risk-gate",
+    }[watch_kind]
+
+
+def build_watch_bundle(args: argparse.Namespace) -> dict[str, object]:
+    next_adapter = (
+        args.recommended_adapter
+        or (args.follow_up_skill[0] if args.follow_up_skill else "")
+        or default_watch_adapter(args.watch_kind)
+    )
+
+    if args.watch_status == "UNAVAILABLE":
+        state = "investigate-watch"
+        execution_mode = "investigate"
+    elif args.watch_status == "CLEARED":
+        state = "watch-cleared"
+        next_adapter = "none"
+        execution_mode = "stop"
+    elif args.severity in ("high", "critical"):
+        state = "triggered-high-severity"
+        execution_mode = "investigate"
+    elif args.watch_status == "TRIGGERED":
+        state = "watch-triggered"
+        execution_mode = "monitor"
+    else:
+        state = "monitor-watch"
+        execution_mode = "monitor"
+
+    return {
+        "version": 1,
+        "workflow_kind": "watch",
+        "state": state,
+        "next_adapter": next_adapter,
+        "execution_mode": execution_mode,
+        "requires_user_confirmation": False,
+        "inputs": {
+            "watch_status": args.watch_status,
+            "watch_kind": args.watch_kind,
+            "subject": args.subject,
+            "trigger_source": args.trigger_source,
+            "severity": args.severity,
+            "next_check_hint": args.next_check_hint,
+            "schedule_hint": args.schedule_hint,
+            "recommended_adapter": args.recommended_adapter,
+        },
+        "follow_up_skills": args.follow_up_skill,
+        "reasons": args.reason,
+    }
+
+
+def build_pretrade_bundle(
+    args: argparse.Namespace,
+    research_conclusion: str | None = None,
+    research_freshness: str | None = None,
+    risk_decision: str | None = None,
+    risk_coverage: str | None = None,
+    simulation_status: str | None = None,
+    simulation_readiness: str | None = None,
+    simulation_venue: str | None = None,
+) -> dict[str, object]:
+    resolved_research_conclusion = research_conclusion or args.research_conclusion
+    resolved_research_freshness = research_freshness or args.research_freshness or "mixed"
+    resolved_risk_decision = risk_decision or args.risk_decision
+    resolved_risk_coverage = risk_coverage or args.risk_coverage
+    if resolved_risk_coverage is None and resolved_risk_decision is not None:
+        resolved_risk_coverage = "complete"
+    resolved_simulation_status = simulation_status or args.simulation_status
+    resolved_simulation_readiness = simulation_readiness or args.simulation_readiness
+    if resolved_simulation_readiness is None and resolved_simulation_status is not None:
+        resolved_simulation_readiness = "needs-confirmation"
+    resolved_simulation_venue = simulation_venue if simulation_venue is not None else (args.simulation_venue or "")
+    if resolved_research_conclusion == "avoid-for-now":
+        state = "blocked-by-research"
+        next_adapter = "none"
+        execution_mode = "stop"
+        requires_confirmation = False
+    elif resolved_research_conclusion != "ready-for-risk-gate":
+        state = "research-incomplete"
+        next_adapter = (
+            args.follow_up_skill[0]
+            if args.follow_up_skill
+            else "web3-research-and-market-intel"
+        )
+        execution_mode = "investigate"
+        requires_confirmation = False
+    elif resolved_risk_decision == "BLOCK":
+        state = "blocked-by-risk"
+        next_adapter = "none"
+        execution_mode = "stop"
+        requires_confirmation = False
+    elif resolved_risk_coverage != "complete" or resolved_simulation_status == "NO_SIMULATION":
+        state = "investigate-more"
+        next_adapter = (
+            args.follow_up_skill[0]
+            if args.follow_up_skill
+            else "web3-trace-and-state-analysis"
+        )
+        execution_mode = "investigate"
+        requires_confirmation = False
+    elif (
+        resolved_risk_decision == "WARN"
+        or resolved_simulation_status == "WARN"
+        or resolved_simulation_readiness == "needs-confirmation"
+    ):
+        state = "needs-confirmation"
+        next_adapter = resolved_simulation_venue or "web3-transaction-simulator"
+        execution_mode = "confirm_then_route"
+        requires_confirmation = True
+    else:
+        state = "ready-to-route"
+        next_adapter = resolved_simulation_venue or "web3-transaction-simulator"
+        execution_mode = "route"
+        requires_confirmation = False
+    return {
+        "version": 1,
+        "workflow_kind": "pretrade",
+        "intent": args.intent,
+        "chain": args.chain,
+        "state": state,
+        "next_adapter": next_adapter,
+        "execution_mode": execution_mode,
+        "requires_user_confirmation": requires_confirmation,
+        "inputs": {
+            "research_conclusion": resolved_research_conclusion,
+            "research_freshness": resolved_research_freshness,
+            "risk_decision": resolved_risk_decision,
+            "risk_coverage": resolved_risk_coverage,
+            "simulation_status": resolved_simulation_status,
+            "simulation_readiness": resolved_simulation_readiness,
+            "simulation_venue": resolved_simulation_venue,
+        },
+        "follow_up_skills": args.follow_up_skill,
+        "reasons": args.reason,
+    }
+
+
+def build_posttrade_bundle(args: argparse.Namespace) -> dict[str, object]:
+    if args.receipt_status in ("FAILED", "REVERTED"):
+        state = "trade-failed"
+        execution_mode = "investigate"
+    elif args.receipt_status in ("SUBMITTED", "PENDING"):
+        state = "monitor-settlement"
+        execution_mode = "monitor"
+    else:
+        state = "verify-outcome"
+        execution_mode = "route"
+
+    if args.follow_up_skill:
+        next_adapter = args.follow_up_skill[0]
+    elif args.settlement == "evm":
+        next_adapter = "web3-trace-and-state-analysis"
+    else:
+        next_adapter = args.venue
+
+    return {
+        "version": 1,
+        "workflow_kind": "posttrade",
+        "state": state,
+        "next_adapter": next_adapter,
+        "execution_mode": execution_mode,
+        "requires_user_confirmation": False,
+        "inputs": {
+            "receipt_status": args.receipt_status,
+            "venue": args.venue,
+            "settlement": args.settlement,
+            "reference_id": args.reference_id,
+        },
+        "follow_up_skills": args.follow_up_skill,
+        "reasons": args.reason,
+    }
+
+
+def build_portfolio_bundle(args: argparse.Namespace) -> dict[str, object]:
+    if args.portfolio_status == "UNAVAILABLE" or args.coverage == "missing":
+        state = "investigate-portfolio"
+        next_adapter = (
+            args.follow_up_skill[0]
+            if args.follow_up_skill
+            else "web3-research-and-market-intel"
+        )
+        execution_mode = "investigate"
+    elif args.source_class == "venue" and args.venue == "hyperliquid":
+        state = "venue-position-check"
+        next_adapter = "hyperliquid"
+        execution_mode = "route"
+    elif args.source_class == "wallet":
+        state = "monitor-portfolio"
+        next_adapter = "debank"
+        execution_mode = "route"
+    elif args.source_class == "address":
+        state = "address-holdings-check"
+        next_adapter = "query-address-info"
+        execution_mode = "route"
+    else:
+        state = "investigate-portfolio"
+        next_adapter = (
+            args.follow_up_skill[0]
+            if args.follow_up_skill
+            else "web3-research-and-market-intel"
+        )
+        execution_mode = "investigate"
+    return {
+        "version": 1,
+        "workflow_kind": "portfolio",
+        "state": state,
+        "next_adapter": next_adapter,
+        "execution_mode": execution_mode,
+        "requires_user_confirmation": False,
+        "inputs": {
+            "portfolio_status": args.portfolio_status,
+            "coverage": args.coverage,
+            "source_class": args.source_class,
+            "provider": args.provider,
+            "venue": args.venue,
+        },
+        "follow_up_skills": args.follow_up_skill,
+        "reasons": args.reason,
+    }
+
+
+def build_trace_bundle(args: argparse.Namespace) -> dict[str, object]:
+    if args.trace_status == "UNAVAILABLE" or args.backend_readiness == "missing":
+        state = "investigate-backend"
+        next_adapter = args.follow_up_skill[0] if args.follow_up_skill else "evm-mcp-playbook"
+        execution_mode = "investigate"
+    elif args.reentry_target == "execution":
+        state = "re-enter-execution"
+        if args.trace_status == "COMPLETE" and args.backend_readiness == "ready":
+            next_adapter = (
+                args.follow_up_skill[0]
+                if args.follow_up_skill
+                else "web3-transaction-simulator"
+            )
+            execution_mode = "route"
+        else:
+            next_adapter = args.follow_up_skill[0] if args.follow_up_skill else "web3-risk-gate"
+            execution_mode = "investigate"
+    elif args.reentry_target == "audit":
+        state = "re-enter-audit"
+        next_adapter = (
+            args.follow_up_skill[0]
+            if args.follow_up_skill
+            else "web3-audit-orchestrator"
+        )
+        execution_mode = "route" if args.trace_status == "COMPLETE" else "investigate"
+    else:
+        state = "re-enter-research"
+        next_adapter = (
+            args.follow_up_skill[0]
+            if args.follow_up_skill
+            else "web3-research-and-market-intel"
+        )
+        execution_mode = "route" if args.trace_status == "COMPLETE" else "investigate"
+    return {
+        "version": 1,
+        "workflow_kind": "trace",
+        "state": state,
+        "next_adapter": next_adapter,
+        "execution_mode": execution_mode,
+        "requires_user_confirmation": False,
+        "inputs": {
+            "trace_status": args.trace_status,
+            "backend_readiness": args.backend_readiness,
+            "reentry_target": args.reentry_target,
+        },
+        "follow_up_skills": args.follow_up_skill,
+        "reasons": args.reason,
+    }
+
+
+def main() -> int:
+    parser = build_parser()
+    args = parser.parse_args()
+    payload: dict[str, object]
+    research_brief: dict[str, object] | None = None
+    merged_gate: dict[str, object] | None = None
+    merged_simulation: dict[str, object] | None = None
+    if args.workflow_kind == "execution":
+        try:
+            risk_decision, risk_coverage, merged_gate = resolve_risk_gate(
+                args.risk_decision,
+                args.risk_coverage,
+                args.risk_input_file,
+            )
+            simulation_status, simulation_readiness, simulation_venue, merged_simulation = resolve_simulation(
+                args.simulation_status,
+                args.simulation_readiness,
+                args.simulation_venue,
+                args.simulation_input_file,
+            )
+            validate_merged_context(args.intent, args.chain, merged_gate, merged_simulation)
+        except ValueError as exc:
+            parser.error(str(exc))
+        bundle = build_execution_bundle(
+            intent=args.intent,
+            chain=args.chain,
+            risk_decision=risk_decision,
+            risk_coverage=risk_coverage,
+            simulation_status=simulation_status,
+            simulation_readiness=simulation_readiness,
+            simulation_venue=simulation_venue,
+            reasons=args.reason,
+            follow_up_skills=args.follow_up_skill,
+        )
+    elif args.workflow_kind == "audit":
+        bundle = build_audit_bundle(args)
+    elif args.workflow_kind == "watch":
+        bundle = build_watch_bundle(args)
+    elif args.workflow_kind == "pretrade":
+        try:
+            research_conclusion, research_freshness, research_brief = resolve_research_brief(
+                intent=args.intent,
+                chain=args.chain,
+                research_input_file=args.research_input_file,
+                research_conclusion=args.research_conclusion,
+                research_freshness=args.research_freshness,
+                research_question=args.research_question,
+                research_source=args.research_source,
+                research_evidence=args.research_evidence,
+                research_cross_check=args.research_cross_check,
+                research_next_step=args.research_next_step,
+            )
+            risk_decision = None
+            risk_coverage = None
+            simulation_status = None
+            simulation_readiness = None
+            simulation_venue = None
+            if research_conclusion == "ready-for-risk-gate" or wants_risk_context(args):
+                risk_decision, risk_coverage, merged_gate = resolve_risk_gate(
+                    args.risk_decision,
+                    args.risk_coverage,
+                    args.risk_input_file,
+                )
+            if research_conclusion == "ready-for-risk-gate" or wants_simulation_context(args):
+                simulation_status, simulation_readiness, simulation_venue, merged_simulation = resolve_simulation(
+                    args.simulation_status,
+                    args.simulation_readiness,
+                    args.simulation_venue,
+                    args.simulation_input_file,
+                )
+            validate_merged_context(args.intent, args.chain, merged_gate, merged_simulation)
+        except ValueError as exc:
+            parser.error(str(exc))
+        bundle = build_pretrade_bundle(
+            args,
+            research_conclusion=research_conclusion,
+            research_freshness=research_freshness,
+            risk_decision=risk_decision,
+            risk_coverage=risk_coverage,
+            simulation_status=simulation_status,
+            simulation_readiness=simulation_readiness,
+            simulation_venue=simulation_venue,
+        )
+    elif args.workflow_kind == "posttrade":
+        bundle = build_posttrade_bundle(args)
+    elif args.workflow_kind == "portfolio":
+        bundle = build_portfolio_bundle(args)
+    elif args.workflow_kind == "trace":
+        bundle = build_trace_bundle(args)
+    else:
+        bundle = build_research_bundle(args)
+    payload = {"operator_bundle": bundle}
+    if research_brief is not None:
+        payload["research_brief"] = research_brief
+    if merged_gate is not None:
+        payload["risk_gate"] = merged_gate
+    if merged_simulation is not None:
+        payload["simulation"] = merged_simulation
+    json.dump(payload, sys.stdout, ensure_ascii=False, indent=2)
+    sys.stdout.write("\n")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())