programgarden 1.41.2__tar.gz → 2.0.1__tar.gz

{programgarden-1.41.2 → programgarden-2.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: programgarden
-Version: 1.41.2
+Version: 2.0.1
 Summary: ProgramGarden - 노드 기반 자동매매 DSL 실행 엔진
 License-Expression: AGPL-3.0-or-later
 Author: 프로그램동산
@@ -15,12 +15,12 @@ Requires-Dist: aiosqlite (>=0.20.0,<0.21.0)
 Requires-Dist: croniter (>=6.0.0,<7.0.0)
 Requires-Dist: litellm (>=1.40.0)
 Requires-Dist: lxml (>=6.0.2,<7.0.0)
-Requires-Dist: programgarden-community (>=1.15.3,<2.0.0)
-Requires-Dist: programgarden-core (>=1.31.0,<2.0.0)
-Requires-Dist: programgarden-finance (>=1.10.5,<2.0.0)
+Requires-Dist: programgarden-community (>=2.0.1,<3.0.0)
+Requires-Dist: programgarden-core (>=2.0.1,<3.0.0)
+Requires-Dist: programgarden-finance (>=2.0.1,<3.0.0)
 Requires-Dist: psutil (>=6.0.0,<7.0.0)
 Requires-Dist: psycopg2-binary (>=2.9.11,<3.0.0)
-Requires-Dist: pydantic (>=2.0.0,<3.0.0)
+Requires-Dist: pydantic (>=2.0.1,<3.0.0)
 Requires-Dist: python-dotenv (>=1.1.0,<2.0.0)
 Requires-Dist: pytickersymbols (>=1.17.5) ; python_version >= "3.12" and python_version < "4.0"
 Requires-Dist: tzdata (>=2025.2,<2026.0)

{programgarden-1.41.2 → programgarden-2.0.1}/programgarden/code_worker.py

@@ -73,7 +73,7 @@ class _SandboxedContext:
             DateNamespace, FinanceNamespace, StatsNamespace,
             FormatNamespace, ListNamespace,
         )
-        self.date = DateNamespace()
+        self.date = DateNamespace(as_of=snapshot.get("validation_as_of"))
         self.finance = FinanceNamespace()
         self.stats = StatsNamespace()
         self.format = FormatNamespace()

{programgarden-1.41.2 → programgarden-2.0.1}/programgarden/executor.py

@@ -10946,7 +10946,7 @@ class ConditionNodeExecutor(NodeExecutorBase):
                         # the risk → order → notify branch is exercised.
                         if getattr(context, "is_deep_validate", False) and positions and not _passed:
                             _passed = [
-                                {"symbol": p.get("symbol"), "exchange": p.get("exchange", "UNKNOWN")}
+                                dict(p)
                                 for p in positions if isinstance(p, dict) and p.get("symbol")
                             ]
                             context.log(
@@ -11018,6 +11018,7 @@ class ConditionNodeExecutor(NodeExecutorBase):
                 )
 
             # === 플러그인 required_fields 검증 ===
+            required_fields = []
             if plugin_schema and hasattr(plugin_schema, 'required_fields'):
                 required_fields = plugin_schema.required_fields or []
                 extract = items_config.get("extract", {})
@@ -11057,6 +11058,20 @@ class ConditionNodeExecutor(NodeExecutorBase):
                     "values": [],
                 }
 
+            if context.is_deep_validate:
+                # Wrapper rows can have the right keys but no OHLCV values.
+                # A fixture's missing fields are wiring failures, not no-signal.
+                missing_values = [
+                    key for key in required_fields
+                    if all(row.get(key) in (None, "") for row in data)
+                ]
+                if missing_values:
+                    raise ValueError(
+                        f"ConditionNode '{node_id}' extracted no values for "
+                        f"{missing_values}. Bind items.from to the bar array "
+                        "(for example item.time_series), not per-symbol wrappers."
+                    )
+
             # symbols 자동 추출 (data에서)
             symbols = []
             seen = set()
@@ -11210,9 +11225,13 @@ class ConditionNodeExecutor(NodeExecutorBase):
                 values = result.get("values", [])
                 
             except PluginTimeoutError as e:
+                if context.is_deep_validate:
+                    raise
                 context.log("error", f"Plugin timeout: {e}", node_id)
                 failed_symbols = normalized_symbols
             except Exception as e:
+                if context.is_deep_validate:
+                    raise
                 context.log("error", f"Plugin error: {e}", node_id)
                 import traceback
                 context.log("debug", f"Plugin traceback: {traceback.format_exc()}", node_id)
@@ -11242,6 +11261,18 @@ class ConditionNodeExecutor(NodeExecutorBase):
         # "no signal this pass"). Deep validation's job is flow/field/type
         # integrity, not reproducing a market signal, so guarantee at least the
         # input symbols flow through. Runtime / dry_run are untouched.
+        if (
+            context.is_deep_validate
+            and symbol_results
+            and all(row.get("error") for row in symbol_results)
+        ):
+            raise ValueError(
+                f"ConditionNode '{node_id}' could not evaluate any symbol: "
+                f"{sorted({str(row['error']) for row in symbol_results})}. "
+                "Check extracted bar fields and indicator lookback. If the default "
+                "fixture is too short, provide a longer deep-validation fixture."
+            )
+
         if getattr(context, "is_deep_validate", False) and normalized_symbols and not passed_symbols:
             passed_symbols = list(normalized_symbols)
             failed_symbols = []
@@ -14509,6 +14540,14 @@ class PositionSizingNodeExecutor(NodeExecutorBase):
         )
         
         # 방법별 수량 계산
+        if context.is_deep_validate and any(
+            not self._get_price(row.get("symbol", ""), row, price_data, context, node_id)
+            for row in symbols
+        ):
+            raise ValueError(
+                "Position sizing has candidates without usable prices. Bind market_data "
+                "to matching quote rows or retain price on each candidate."
+            )
         if method == "fixed_percent":
             result = self._calc_fixed_percent(
                 symbols, available_balance, max_percent, price_data, context, node_id
@@ -15555,6 +15594,25 @@ class NewOrderNodeExecutor(NodeExecutorBase):
 
         # dry_run: LS API 미호출, 모의 응답 반환
         if context.is_dry_run:
+            if context.is_deep_validate:
+                # Exercise the actual payload contract before simulating success.
+                # Do not enter connection, balance, quote or broker request paths.
+                config = evaluate_all_bindings(config, context, node_id)
+                if not self._normalize_order(config.get("order"), config, context, node_id):
+                    upstream = _input_namespace(context, node_id)
+                    if (
+                        config.get("order") is None
+                        and isinstance(upstream, dict)
+                        and upstream.get("reason") == EmptyOrderReason.NO_SIGNAL.value
+                        and self._extract_upstream_error(upstream) is None
+                    ):
+                        return self._empty_result(EmptyOrderReason.NO_SIGNAL)
+                    raise ValueError(
+                        f"{node_type} requires order to resolve to an object with "
+                        "a symbol and a positive whole-share/contract quantity. "
+                        "Use the current sizing order item or a position retaining "
+                        "quantity; a symbol string alone is not an order."
+                    )
             import uuid
             order_id = f"DRYRUN-{uuid.uuid4()}"
             context.log(
@@ -20394,6 +20452,9 @@ class CodeNodeExecutor(NodeExecutorBase):
             "iteration_total": int(getattr(context, "_iteration_total", 0) or 0),
             "risk": {},
         }
+        validation_as_of = getattr(context, "validation_as_of", None)
+        if validation_as_of is not None:
+            snap["validation_as_of"] = validation_as_of
         try:
             rt = context.risk_tracker
             if rt is not None and hasattr(rt, "get_all_hwm"):
@@ -20471,6 +20532,30 @@ class CodeNodeExecutor(NodeExecutorBase):
 
         value = env.get("value")
 
+        if context.is_deep_validate or getattr(context, "is_replay_validation", False):
+            from programgarden.replay_contracts import ContractViolation, check_contract, check_codenode_ports
+            ports = config.get("outputs", [])
+            try:
+                check_codenode_ports(ports)
+                for index, port in enumerate(ports):
+                    name = port["name"]
+                    if isinstance(value, dict):
+                        if name not in value:
+                            raise ContractViolation(f"{node_id}.{name}", "Declared output is absent")
+                        item = value[name]
+                    elif len(ports) == 1:
+                        # The existing single-port scalar mapping is explicit
+                        # public behavior; validate its value without coercion.
+                        item = value
+                    else:
+                        raise ContractViolation(node_id, "Multiple declared ports require a result object")
+                    if port.get("type", "any") != "any":
+                        check_contract(item, {"type":port["type"]}, f"{node_id}.{name}")
+            except ContractViolation as exc:
+                raise CodeNodeError(ErrorCode.CODE_NODE_EXEC_ERROR, str(exc),
+                    suggestion="Return every declared output with its declared JSON type; do not substitute missing values with zero.",
+                    details=exc.as_dict()) from exc
+
         # Map return → declared ports. No declared ports → whole value on result.
         if not declared:
             return {"result": value}
@@ -22078,6 +22163,20 @@ class WorkflowJob:
                         },
                     )
 
+                if (
+                    self.context.is_deep_validate
+                    and node.node_type == "PositionSizingNode"
+                    and outputs.get("reason") in {"no_symbol", "fetch_failed"}
+                ):
+                    from programgarden_core import ErrorCode, ErrorLocation, build_error
+                    self._node_error_infos[node_id] = build_error(
+                        ErrorCode.DEEP_VALIDATION_NODE_ERROR,
+                        f"Position sizing inputs are invalid: {outputs.get('detail', '')}",
+                        location=ErrorLocation(node_id=node_id, node_type=node.node_type),
+                        suggestion="Bind symbols, balance and price data required by the sizing method.",
+                        details={"stage": "sizing_inputs", "reason": outputs["reason"]},
+                    )
+
                 # An order node that failed did NOT raise — it returned
                 # order_result.success=False. Reporting that as COMPLETED leaves
                 # errors_count=0 / last_error=None, i.e. every observable surface
@@ -22687,6 +22786,16 @@ class WorkflowJob:
                     all_results.append(outputs)
                 except Exception as e:
                     self.context.log("warning", f"Auto-iterate [{idx+1}/{total}] failed: {e}", node_id)
+                    if getattr(self.context, "is_deep_validate", False):
+                        from programgarden_core import ErrorCode, ErrorLocation, build_error
+                        # A later successful item must not erase an earlier failure.
+                        self._node_error_infos.setdefault(node_id, build_error(
+                            ErrorCode.DEEP_VALIDATION_NODE_ERROR,
+                            f"Node '{node_id}' failed at iteration {idx + 1}/{total}: {e}",
+                            location=ErrorLocation(node_id=node_id, node_type=node.node_type),
+                            suggestion="Check this item's input fields and bindings before executing the workflow.",
+                            details={"stage": "auto_iteration", "iteration_index": idx},
+                        ))
                     # continue_on_error: 기본적으로 계속 진행
                     all_results.append({"error": str(e), "item": current_item})
                 finally:
@@ -22735,12 +22844,32 @@ class WorkflowJob:
         """
         if total <= 1 or not isinstance(current_item, dict):
             return item_config
+        # These executors already select one symbol from the iteration context.
+        # Keep the generic warning for other consumers and conflicting overrides.
+        if (
+            not self.context.is_deep_validate
+            and node_type in {
+                "OverseasStockMarketDataNode", "OverseasFuturesMarketDataNode",
+                "KoreaStockMarketDataNode", "OverseasStockHistoricalDataNode",
+                "OverseasFuturesHistoricalDataNode", "KoreaStockHistoricalDataNode",
+            }
+            and current_item.get("symbol")
+            and all(
+                not override or self._same_symbol_entry(override, current_item)
+                for override in (
+                    item_config.get("symbol"),
+                    self.context.get_output(f"_input_{node_id}", "symbol"),
+                )
+            )
+        ):
+            return item_config
         narrowed = None
         for port in self._WHOLE_ARRAY_REEVAL_PORTS:
             value = item_config.get(port)
             if not isinstance(value, list) or len(value) != total:
                 continue
-            if not any(self._same_symbol_entry(entry, current_item) for entry in value):
+            matching = [entry for entry in value if self._same_symbol_entry(entry, current_item)]
+            if not matching:
                 continue
             simulated = bool(getattr(self.context, "is_dry_run", False))
             self.context.log(
@@ -22754,7 +22883,11 @@ class WorkflowJob:
             if simulated:
                 if narrowed is None:
                     narrowed = dict(item_config)
-                narrowed[port] = [current_item]
+                # Preserve the configured projection and quantity. The upstream
+                # item can contain quotes or other numeric fields that are not
+                # inputs to this node (e.g. a symbol-only market-data contract).
+                # Substituting that raw item changed valid bindings in validation.
+                narrowed[port] = [matching[0]]
         return narrowed if narrowed is not None else item_config
 
     def _merge_iterate_results(self, results: list) -> Dict[str, Any]:
@@ -23545,7 +23678,7 @@ class WorkflowJob:
         if self.context._iteration_item is None:
             for k in list(config_copy.keys()):
                 v = config_copy[k]
-                if isinstance(v, str) and "{{ item" in v:
+                if self._references_iteration_item(v):
                     deferred[k] = config_copy.pop(k)
 
         deep_mode = bool(getattr(self.context, "is_deep_validate", False))

programgarden-2.0.1/programgarden/replay_contracts.py

@@ -0,0 +1,218 @@
+"""Deterministic contracts at replay input, mapping and output boundaries.
+
+Contracts use an intentionally bounded JSON-schema subset. Unknown constraints
+fail closed; values are never coerced, defaulted, renamed or replaced with zero.
+Semantic identity is explicit contract data, not inferred from field names.
+"""
+from __future__ import annotations
+
+from datetime import datetime
+from decimal import Decimal, InvalidOperation
+import math
+import re
+from typing import Any
+
+CONTRACT_VERSION = "replay-contract-1"
+_KEYS = frozenset({"type", "nullable", "required", "properties", "items", "enum",
+                   "minimum", "maximum", "minItems", "maxItems", "minLength",
+                   "maxLength", "const", "additionalProperties", "format",
+                   "decimalPlaces", "description"})
+_TYPES = {"object": dict, "array": list, "string": str, "number": (int, float),
+          "integer": int, "boolean": bool, "null": type(None)}
+
+
+class ContractViolation(ValueError):
+    def __init__(self, path: str, reason: str, code: str = "REPLAY_CONTRACT_FAILED"):
+        self.path, self.reason, self.code = path, reason, code
+        super().__init__(f"{path}: {reason}")
+
+    def as_dict(self) -> dict[str, str]:
+        return {"code": self.code, "path": self.path, "message": str(self)}
+
+
+def finite_json(value: Any, path: str = "$", depth: int = 0) -> None:
+    if depth > 40:
+        raise ContractViolation(path, "JSON nesting exceeds the validation limit")
+    if value is None or type(value) in (str, int, bool):
+        return
+    if type(value) is float:
+        if not math.isfinite(value):
+            raise ContractViolation(path, "NaN and Infinity are not valid evidence")
+        return
+    if type(value) is dict:
+        for key, item in value.items():
+            if not isinstance(key, str):
+                raise ContractViolation(path, "Object keys must be strings")
+            finite_json(item, f"{path}.{key}", depth + 1)
+        return
+    if type(value) is list:
+        for index, item in enumerate(value):
+            finite_json(item, f"{path}[{index}]", depth + 1)
+        return
+    raise ContractViolation(path, "Expected finite JSON data")
+
+
+def check_contract(value: Any, schema: dict[str, Any], path: str = "$") -> None:
+    """Validate a finite JSON value without coercion; raise at the first defect."""
+    finite_json(value, path)
+    finite_json(schema, "contract")
+    _validate_schema(schema, "contract", 0)
+    _check(value, schema, path, 0)
+
+
+def _literal_equal(left, right):
+    """JSON identities do not coerce nested True/1 or False/0 values."""
+    if type(left) in (int,float) and type(right) in (int,float):
+        return Decimal(str(left))==Decimal(str(right))
+    if type(left) is not type(right):
+        return False
+    if isinstance(left, dict):
+        return left.keys()==right.keys() and all(_literal_equal(left[key],right[key]) for key in left)
+    if isinstance(left, list):
+        return len(left)==len(right) and all(_literal_equal(a,b) for a,b in zip(left,right))
+    return left==right
+
+
+def _validate_schema(schema: Any, path: str, depth: int) -> None:
+    def invalid(reason):
+        raise ContractViolation(path, reason, "REPLAY_CONTRACT_UNSUPPORTED")
+    if depth > 40 or type(schema) is not dict or set(schema) - _KEYS:
+        invalid("Unsupported contract")
+    kinds = schema.get("type")
+    kinds = kinds if type(kinds) is list else [kinds]
+    if not kinds or any(type(k) is not str or k not in _TYPES for k in kinds):
+        invalid("Explicit supported type required")
+    if len(kinds) != len(set(kinds)):
+        invalid("Duplicate types are not supported")
+    for key in ("nullable", "additionalProperties"):
+        if key in schema and type(schema[key]) is not bool:
+            invalid(f"{key} must be boolean")
+    if "enum" in schema and (type(schema["enum"]) is not list or not schema["enum"]):
+        invalid("enum must be a nonempty array")
+    for key in ("minItems", "maxItems", "minLength", "maxLength", "decimalPlaces"):
+        if key in schema and (type(schema[key]) is not int or schema[key] < 0):
+            invalid(f"{key} must be a nonnegative integer")
+    if schema.get("decimalPlaces", 0) > 18:
+        invalid("decimalPlaces must not exceed 18")
+    for key in ("minimum", "maximum"):
+        if key in schema and type(schema[key]) not in (int, float):
+            invalid(f"{key} must be a finite number")
+    for lower, upper in (("minimum", "maximum"), ("minItems", "maxItems"), ("minLength", "maxLength")):
+        if lower in schema and upper in schema and schema[lower] > schema[upper]:
+            invalid(f"{lower} exceeds {upper}")
+    applicable = {"object": {"properties", "required", "additionalProperties"},
+                  "array": {"items", "minItems", "maxItems"},
+                  "string": {"minLength", "maxLength", "format"},
+                  "number": {"minimum", "maximum", "decimalPlaces"},
+                  "integer": {"minimum", "maximum", "decimalPlaces"}}
+    allowed = {"type", "nullable", "const", "enum", "description"}
+    for kind in kinds:
+        allowed |= applicable.get(kind, set())
+    if set(schema) - allowed:
+        invalid("Constraint does not apply to the declared type")
+    if "description" in schema and type(schema["description"]) is not str:
+        invalid("description must be a string")
+    if "format" in schema and schema["format"] != "date-time":
+        invalid("Unsupported format")
+    if "properties" in schema:
+        if type(schema["properties"]) is not dict:
+            invalid("properties must be an object")
+        for name, child in schema["properties"].items():
+            _validate_schema(child, f"{path}.properties.{name}", depth + 1)
+    if "required" in schema:
+        required = schema["required"]
+        if type(required) is not list or any(type(k) is not str for k in required):
+            invalid("required must contain field names")
+        if len(required) != len(set(required)):
+            invalid("required contains duplicates")
+    if "items" in schema:
+        _validate_schema(schema["items"], f"{path}.items", depth + 1)
+
+
+def _check(value: Any, schema: dict[str, Any], path: str, depth: int) -> None:
+    if depth > 40 or not isinstance(schema, dict) or set(schema) - _KEYS:
+        raise ContractViolation(path, "Unsupported contract", "REPLAY_CONTRACT_UNSUPPORTED")
+    kind = schema.get("type")
+    kinds = kind if isinstance(kind, list) else [kind]
+    if not kinds or any(not isinstance(k, str) or k not in _TYPES for k in kinds):
+        raise ContractViolation(path, "Explicit supported type required", "REPLAY_CONTRACT_UNSUPPORTED")
+    matches = (value is None and schema.get("nullable") is True) or any(isinstance(value, _TYPES[k]) and
+                  not (k in ("number", "integer") and isinstance(value, bool)) for k in kinds)
+    if not matches:
+        raise ContractViolation(path, f"Expected {kind}, received {type(value).__name__}")
+    if "const" in schema and not _literal_equal(value,schema["const"]):
+        raise ContractViolation(path, "Value does not match the required identity")
+    if "enum" in schema and not any(_literal_equal(value,v) for v in schema["enum"]):
+        raise ContractViolation(path, "Value is outside the allowed enumeration")
+    if isinstance(value, dict):
+        properties, required = schema.get("properties", {}), schema.get("required", [])
+        if not isinstance(properties, dict) or not isinstance(required, list) or any(not isinstance(k, str) for k in required):
+            raise ContractViolation(path, "Invalid object contract", "REPLAY_CONTRACT_UNSUPPORTED")
+        for key in required:
+            if key not in value:
+                raise ContractViolation(f"{path}.{key}", "Required field is absent")
+        for key, item in value.items():
+            if key in properties:
+                _check(item, properties[key], f"{path}.{key}", depth + 1)
+            elif schema.get("additionalProperties") is False:
+                raise ContractViolation(f"{path}.{key}", "Undeclared field")
+    elif isinstance(value, list):
+        for key, valid in (("minItems", len(value) >= schema.get("minItems", 0)),
+                           ("maxItems", len(value) <= schema.get("maxItems", len(value)))):
+            if not valid:
+                raise ContractViolation(path, f"Array violates {key}")
+        if "items" in schema:
+            for index, item in enumerate(value):
+                _check(item, schema["items"], f"{path}[{index}]", depth + 1)
+    elif type(value) in (float, int):
+        if value < schema.get("minimum", value) or value > schema.get("maximum", value):
+            raise ContractViolation(path, "Number is outside the allowed range")
+        if "decimalPlaces" in schema:
+            places = schema["decimalPlaces"]
+            if type(places) is not int or not 0 <= places <= 18:
+                raise ContractViolation(path, "Invalid precision contract", "REPLAY_CONTRACT_UNSUPPORTED")
+            try:
+                precision = max(0, -Decimal(str(value)).normalize().as_tuple().exponent)
+            except InvalidOperation as exc:
+                raise ContractViolation(path, "Invalid decimal") from exc
+            if precision > places:
+                raise ContractViolation(path, "Number exceeds the allowed decimal precision")
+    elif isinstance(value, str):
+        if not schema.get("minLength", 0) <= len(value) <= schema.get("maxLength", len(value)):
+            raise ContractViolation(path, "String length violates the contract")
+        if "format" in schema:
+            if schema["format"] != "date-time":
+                raise ContractViolation(path, "Unsupported format", "REPLAY_CONTRACT_UNSUPPORTED")
+            try:
+                parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
+            except ValueError as exc:
+                raise ContractViolation(path, "Expected an ISO timestamp") from exc
+            if parsed.tzinfo is None or parsed.utcoffset() is None:
+                raise ContractViolation(path, "Timestamp must include its timezone")
+
+
+def check_observation_identity(actual: dict[str, Any], expected: dict[str, Any]) -> None:
+    """Check explicit units and time identity at a data boundary.
+
+    The caller supplies only the semantics consumed by this boundary. A currency
+    conversion is a separate transformation with its own tested output contract.
+    Missing metadata is unverified, not inferred as USD/UTC from node names.
+    """
+    allowed = {"symbol", "market", "currency", "timeframe", "as_of"}
+    if not expected or set(expected) - allowed:
+        raise ContractViolation("metadata", "Unsupported semantic identity", "REPLAY_CONTRACT_UNSUPPORTED")
+    for field, value in expected.items():
+        check_contract(actual.get(field), {"type": "string", "const": value,
+                       **({"format": "date-time"} if field == "as_of" else {})}, f"metadata.{field}")
+
+
+def check_codenode_ports(ports: Any) -> None:
+    if not isinstance(ports, list):
+        raise ContractViolation("outputs", "Declared CodeNode ports must be a list of objects")
+    names: set[str] = set()
+    for index, port in enumerate(ports):
+        if not isinstance(port, dict) or not isinstance(port.get("name"), str) or not re.fullmatch(r"[A-Za-z_][A-Za-z0-9_]*", port["name"]):
+            raise ContractViolation(f"outputs[{index}]", "Invalid declared output port")
+        if port["name"] in names or port.get("type", "any") not in {*_TYPES, "any"}:
+            raise ContractViolation(f"outputs[{index}]", "Duplicate name or unsupported output type")
+        names.add(port["name"])

{programgarden-1.41.2 → programgarden-2.0.1}/programgarden/resolver.py

@@ -193,7 +193,14 @@ class WorkflowResolver:
                     f"Unknown node type '{node_type}'",
                     location=ErrorLocation(node_id=node_id, node_type=node_type),
                     available_values=suggest_close_match(node_type or "", known_types),
-                    suggestion="Pick a node type from the registered list.",
+                    suggestion=(
+                        "FundamentalDataNode (FMP) was removed. For LS overseas-stock PER/EPS, "
+                        "use OverseasStockFundamentalNode and rebind its value/values outputs. "
+                        "It does not supply financial statements or cash-flow history; "
+                        "do not silently substitute missing data."
+                        if node_type == "FundamentalDataNode" else
+                        "Pick a node type from the registered list."
+                    ),
                 )
             )
 
@@ -328,6 +335,9 @@ class WorkflowResolver:
         # 10.8 Display 노드 columns 키가 상류 출력 스키마에 실재하는지 (없는 키는 표에 '-' 만 찍힌다)
         self._validate_display_columns(workflow, registry, result)
 
+        # Order routing choices are literals, never prices or item bindings.
+        self._validate_order_enums(workflow, registry, result)
+
         # 11. Static recommendations (topology analysis)
         for rec in run_static_recommendation_rules(
             workflow,
@@ -344,6 +354,39 @@ class WorkflowResolver:
 
         return result
 
+    def _validate_order_enums(self, workflow, registry, result) -> None:
+        """Enforce fixed price/order types without changing dynamic close sides."""
+        from programgarden_core.models.field_binding import ExpressionMode
+
+        for node in workflow.nodes:
+            node_type = node.get("type", "")
+            if not node_type.endswith(("NewOrderNode", "ModifyOrderNode", "CancelOrderNode")):
+                continue
+            node_class = registry.get(node_type)
+            if node_class is None:
+                continue
+            for name, field in node_class.get_field_schema().items():
+                if (
+                    name not in {"price_type", "order_type"}
+                    or name not in node
+                    or field.expression_mode != ExpressionMode.FIXED_ONLY
+                    or not field.enum_values
+                    or node[name] in field.enum_values
+                ):
+                    continue
+                result.add(build_error(
+                    ErrorCode.INVALID_FIELD_ENUM,
+                    f"Order field '{name}' requires a fixed value from its enum.",
+                    location=ErrorLocation(
+                        node_id=node.get("id"), node_type=node_type, field_path=name,
+                    ),
+                    available_values=field.enum_values,
+                    suggestion=(
+                        "Use a listed literal value. Put an order's numeric price in "
+                        "order.price, not price_type or order_type."
+                    ),
+                ))
+
     def _attach_inline_recommendations(self, result: ValidationResult, workflow) -> None:
         """Augment specific ErrorInfo entries with related Recommendation hints.
 
@@ -1040,6 +1083,18 @@ class WorkflowResolver:
                 continue
             node_id = node.get("id")
 
+            # A mapping-shaped declaration was previously silently ignored by
+            # the executor, wrapping a named result twice and disabling signals.
+            from programgarden.replay_contracts import ContractViolation, check_codenode_ports
+            try:
+                check_codenode_ports(node.get("outputs", []))
+            except ContractViolation as exc:
+                result.add(build_error(
+                    ErrorCode.INVALID_FIELD_TYPE, str(exc),
+                    location=ErrorLocation(node_id=node_id, node_type="CodeNode", field_path="outputs"),
+                    suggestion="Use a list such as [{\"name\":\"result\",\"type\":\"object\"}], or omit outputs for one whole-result port.",
+                ))
+
             # 1. credential_id ban
             if node.get("credential_id"):
                 result.add(

{programgarden-1.41.2 → programgarden-2.0.1}/programgarden/validation_recommender.py

@@ -72,7 +72,6 @@ ACCOUNT_NODES: Set[str] = {
 EXTERNAL_API_NODES: Set[str] = {
     "HTTPRequestNode",
     "TelegramNode",
-    "FundamentalDataNode",
     "FearGreedIndexNode",
 }
 

{programgarden-1.41.2 → programgarden-2.0.1}/pyproject.toml

@@ -5,7 +5,7 @@ authors = [
 homepage = "https://programgarden.com"
 requires-python = ">=3.12"
 name = "programgarden"
-version = "1.41.2"
+version = "2.0.1"
 license = "AGPL-3.0-or-later"
 description = "ProgramGarden - 노드 기반 자동매매 DSL 실행 엔진"
 readme = "README.md"
@@ -17,7 +17,7 @@ packages = [
 exclude = ["examples", "tests", "**/__pycache__"]
 
 [tool.poetry.dependencies]
-pydantic = ">=2.0.0,<3.0.0"
+pydantic = ">=2.0.1,<3.0.0"
 croniter = "^6.0.0"
 python-dotenv = "^1.1.0"
 tzdata = "^2025.2"
@@ -36,9 +36,9 @@ litellm = ">=1.40.0"
 # 로 통째 실패한다(1.35.1 의 조용한 TypeError 보다 강한 모듈 로드 실패).
 # (1.26.0 이후로도 context.py 는 WorkflowPnLEvent(**event_data) 에 personal_metrics
 #  를 무조건 실으므로 그 하한 근거도 이 상한에 포함된다.)
-programgarden-core = "^1.31.0"
-programgarden-finance = "^1.10.5"
-programgarden-community = "^1.15.3"
+programgarden-core = "^2.0.1"
+programgarden-finance = "^2.0.1"
+programgarden-community = "^2.0.1"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^8.0.0"
@@ -50,5 +50,5 @@ uvicorn = "^0.40.0"
 
 
 [build-system]
-requires = ["poetry-core>=2.0.0,<3.0.0"]
+requires = ["poetry-core>=2.0.1,<3.0.0"]
 build-backend = "poetry.core.masonry.api"