programgarden 1.23.0__tar.gz → 1.24.0__tar.gz

{programgarden-1.23.0 → programgarden-1.24.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: programgarden
-Version: 1.23.0
+Version: 1.24.0
 Summary: ProgramGarden - 노드 기반 자동매매 DSL 실행 엔진
 Author: 프로그램동산
 Author-email: coding@programgarden.com
@@ -15,7 +15,7 @@ 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.13.8,<2.0.0)
-Requires-Dist: programgarden-core (>=1.14.4,<2.0.0)
+Requires-Dist: programgarden-core (>=1.15.0,<2.0.0)
 Requires-Dist: programgarden-finance (>=1.6.10,<2.0.0)
 Requires-Dist: psutil (>=6.0.0,<7.0.0)
 Requires-Dist: psycopg2-binary (>=2.9.11,<3.0.0)

{programgarden-1.23.0 → programgarden-1.24.0}/programgarden/__init__.py

@@ -14,6 +14,17 @@ from programgarden.executor import WorkflowExecutor
 from programgarden.context import ExecutionContext
 from programgarden.client import ProgramGarden
 from programgarden.node_runner import NodeRunner
+from programgarden.semantic_rules import (
+    analyze_workflow_semantics,
+    normalize_severities,
+    DEFAULT_SEMANTIC_SEVERITIES,
+    STRICT_SEMANTIC_SEVERITIES,
+    ALL_RULES,
+    RULE_ORDER_QTY_FROM_AI,
+    RULE_STRUCTURED_OUTPUT_NO_SCHEMA,
+    RULE_HARDCODED_ORDER_QTY,
+    RULE_ORDER_IGNORED_FIELD,
+)
 from programgarden_core.bases.listener import (
     NodeState,
     EdgeState,
@@ -140,4 +151,14 @@ __all__ = [
     "get_events",
     "get_job_summary",
     "analyze_performance",
+    # Semantic / safety layer (deep_validate R1~R4)
+    "analyze_workflow_semantics",
+    "normalize_severities",
+    "DEFAULT_SEMANTIC_SEVERITIES",
+    "STRICT_SEMANTIC_SEVERITIES",
+    "ALL_RULES",
+    "RULE_ORDER_QTY_FROM_AI",
+    "RULE_STRUCTURED_OUTPUT_NO_SCHEMA",
+    "RULE_HARDCODED_ORDER_QTY",
+    "RULE_ORDER_IGNORED_FIELD",
 ]

{programgarden-1.23.0 → programgarden-1.24.0}/programgarden/client.py

@@ -80,6 +80,7 @@ class ProgramGarden:
         *,
         fixtures: Optional[Dict[str, Any]] = None,
         timeout: float = 15.0,
+        semantic_rules: Optional[Dict[str, Any]] = None,
     ) -> ValidationResult:
         """Deep-validate a workflow via virtual full-execution (never raises).
 
@@ -96,6 +97,11 @@ class ProgramGarden:
             fixtures: Optional per-node fixture overrides, keyed by node id or
                 node type (merged shallowly on top of the default fixture).
             timeout: Hard timeout (seconds) for the single validation pass.
+            semantic_rules: Optional per-rule severity config for the configurable
+                semantic/safety layer (R1~R4). ``None`` (default) skips the layer;
+                pass ``programgarden.semantic_rules.STRICT_SEMANTIC_SEVERITIES`` (or
+                a ``{rule_id: "error"|"warning"|"off"}`` dict) to opt in. See
+                ``WorkflowExecutor.deep_validate`` for details.
 
         Returns:
             ValidationResult — ``errors`` carry structured per-node ErrorInfo;
@@ -109,7 +115,12 @@ class ProgramGarden:
             ...         print(err.short())
         """
         return _run_coro_sync(
-            self.executor.deep_validate(definition, fixtures=fixtures, timeout=timeout)
+            self.executor.deep_validate(
+                definition,
+                fixtures=fixtures,
+                timeout=timeout,
+                semantic_rules=semantic_rules,
+            )
         )
 
     def run(

{programgarden-1.23.0 → programgarden-1.24.0}/programgarden/deep_fixtures.py

@@ -361,6 +361,77 @@ def broker_connection_fixture(
     }
 
 
+def _schema_default_value(schema: Any) -> Any:
+    """Best-effort default value for one ``output_schema`` entry.
+
+    An entry is either a bare type string (``"number"``) or a JSON-schema-ish
+    dict (``{"type": "...", "enum": [...], "items": {...}, "properties": {...}}``)
+    — the two shapes ``AIAgentNodeExecutor._build_output_instruction`` /
+    ``_validate_structured`` already accept. Returns a type-correct placeholder
+    so a downstream ``{{ nodes.<agent>.response.<field> }}`` binding resolves to a
+    real value (an enum field resolves to its first allowed value, an object to
+    its declared properties, an array to a single shaped element).
+    """
+    if isinstance(schema, str):
+        type_name, spec = schema, {}
+    elif isinstance(schema, dict):
+        type_name, spec = str(schema.get("type", "string")), schema
+    else:
+        return "deep_validate"
+
+    enum_vals = spec.get("enum") if isinstance(spec, dict) else None
+    if enum_vals:
+        return enum_vals[0]
+
+    if type_name in ("string", "str"):
+        return "deep_validate"
+    if type_name in ("number", "float"):
+        return 1.0
+    if type_name in ("integer", "int"):
+        return 1
+    if type_name in ("boolean", "bool"):
+        return True
+    if type_name == "array":
+        items = spec.get("items") if isinstance(spec, dict) else None
+        if isinstance(items, (dict, str)):
+            return [_schema_default_value(items)]
+        return []
+    if type_name in ("object", "dict"):
+        props = spec.get("properties") if isinstance(spec, dict) else None
+        if isinstance(props, dict):
+            return {key: _schema_default_value(sub) for key, sub in props.items()}
+        return {}
+    return "deep_validate"
+
+
+def ai_agent_fixture(config: Dict[str, Any]) -> Dict[str, Any]:
+    """AIAgentNode deep fixture — schema-shaped ``{"response": ...}``, no LLM call.
+
+    A deep run must never hit a live LLM (cost, non-determinism, network) nor
+    silently swallow a failed model call. This builds the ``response`` output
+    port directly from the node's declared ``output_format`` / ``output_schema``
+    so downstream consumers see the same shape they would at runtime:
+
+    - ``"structured"`` + ``output_schema`` → a dict with every declared field
+      populated by a type-correct placeholder (enum → first value, nested
+      object/array shaped recursively). This is what makes
+      ``{{ nodes.<agent>.response.<field> }}`` bindings resolve in deep mode.
+    - ``"json"`` → an empty dict (no schema to shape it).
+    - ``"text"`` / anything else → a placeholder string.
+    """
+    output_format = config.get("output_format", "text")
+    output_schema = config.get("output_schema")
+    if output_format == "structured" and isinstance(output_schema, dict) and output_schema:
+        response: Any = {
+            key: _schema_default_value(spec) for key, spec in output_schema.items()
+        }
+    elif output_format == "json":
+        response = {}
+    else:  # "text" or unknown → raw string
+        response = "deep_validate: AIAgentNode response (virtual run, no live LLM call)"
+    return {"response": response}
+
+
 def apply_override(default: Dict[str, Any], override: Optional[Dict[str, Any]]) -> Dict[str, Any]:
     """Shallow-merge a caller override on top of a default fixture.
 

{programgarden-1.23.0 → programgarden-1.24.0}/programgarden/executor.py

@@ -11,6 +11,8 @@ Workflow execution engine
 from typing import Optional, Dict, Any, List, Callable, Awaitable, Set, Tuple
 from datetime import datetime
 import asyncio
+import ast
+import re
 import uuid
 import logging
 
@@ -37,6 +39,50 @@ from programgarden_core.nodes.base import BaseMessagingNode
 logger = logging.getLogger("programgarden.executor")
 
 
+# lib reserved iteration variable roots — valid ONLY mid-iteration.
+# `{{ item.* }}` (auto-iterate per-item) and `{{ row.* }}` (ConditionNode
+# items.extract) only resolve while the executor has an iteration context set;
+# before auto-iterate they legitimately fail to evaluate. These are lib
+# *identifiers* (single source of the engine's iteration binding), NOT
+# language keywords — the deep-validate recorder uses them as a structural
+# signal (AST free-variable roots) to avoid false-rejecting correct examples
+# whose nested config holds `{{ item.symbol }}` etc.
+_RESERVED_ITERATION_ROOTS: frozenset = frozenset({"item", "row"})
+
+_INLINE_EXPR_PATTERN = re.compile(r"\{\{\s*(.+?)\s*\}\}")
+
+
+def _free_root_names(text: str) -> Set[str]:
+    """Return the set of free-variable root identifiers referenced (ctx=Load) by
+    every ``{{ ... }}`` expression embedded in ``text``.
+
+    Used by the deep-validate binding recorder to decide whether an unresolved
+    expression is iteration-scoped (root in :data:`_RESERVED_ITERATION_ROOTS`)
+    and therefore expected to be deferred — not a real defect.
+
+    - ``{{ nodes.split.item }}`` → root ``nodes`` (``item`` is an attribute,
+      not a root) → NOT iteration-scoped.
+    - ``{{ x | length }}`` (unsupported pipe filter) → roots ``{x, length}``
+      → NOT iteration-scoped → recorded (desired).
+    - A genuinely malformed expression (SyntaxError) yields a sentinel
+      ``__syntax_error__`` root so the recorder treats it as a real defect.
+    """
+    roots: Set[str] = set()
+    for match in _INLINE_EXPR_PATTERN.findall(text):
+        try:
+            tree = ast.parse(match, mode="eval")
+        except (SyntaxError, ValueError):
+            # SyntaxError = genuine malformed expression.
+            # ValueError (incl. UnicodeEncodeError on surrogate chars) = the
+            # source cannot even be parsed/encoded — treat the same way so the
+            # expression is recorded (not dropped → no false-negative).
+            return roots | {"__syntax_error__"}
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Name) and isinstance(node.ctx, ast.Load):
+                roots.add(node.id)
+    return roots
+
+
 def _build_reconnect_hooks(
     tracker: Any,
     context: "ExecutionContext",
@@ -14524,6 +14570,31 @@ class AIAgentNodeExecutor(NodeExecutorBase):
         import json as json_module
         from programgarden.providers import LLMProvider
 
+        # === 0. deep_validate: 실 LLM/ReAct 루프를 절대 돌리지 않는다 ===
+        # 가짜(스키마-shaped) response 를 주입해 다운스트림 {{ nodes.X.response[.field] }}
+        # 바인딩이 풀리고 flow 무결성이 검증되도록 한다(네트워크·모델비용 0). 실 LLM
+        # 호출 실패를 {"error":...} 로 삼키던 silent-fail 경로 자체를 제거한다.
+        # preset 을 먼저 적용해 output_format/output_schema 가 런타임과 동일하게 반영되도록 함.
+        if getattr(context, "is_deep_validate", False):
+            from programgarden import deep_fixtures as _df
+            _deep_config = config
+            _preset_id = config.get("preset")
+            if _preset_id and _preset_id != "custom":
+                try:
+                    from programgarden_core.presets import PresetLoader
+                    _deep_config = PresetLoader.apply_preset(_preset_id, config)
+                except Exception:
+                    _deep_config = config
+            fixture = _df.ai_agent_fixture(_deep_config)
+            override = context.get_deep_fixture(node_id, node_type)
+            fixture = _df.apply_override(fixture, override)
+            context.log(
+                "info",
+                "[deep_validate] AIAgentNode response simulated (no live LLM call)",
+                node_id,
+            )
+            return fixture
+
         # === 1. ai_model 엣지에서 LLM connection 주입 ===
         workflow = kwargs.get("workflow")
         if not workflow:
@@ -15506,6 +15577,7 @@ class WorkflowExecutor:
         *,
         fixtures: Optional[Dict[str, Any]] = None,
         timeout: float = 15.0,
+        semantic_rules: Optional[Dict[str, Any]] = None,
     ) -> ValidationResult:
         """Deep-validate a workflow via virtual full-execution (never raises).
 
@@ -15525,6 +15597,15 @@ class WorkflowExecutor:
             timeout: Hard timeout (seconds) for the single validation pass. On
                 timeout the partial result so far is returned with a flow-broken
                 error appended.
+            semantic_rules: Optional per-rule severity config for the configurable
+                semantic/safety layer (R1~R4 — order-quantity-from-AI, schema-less
+                structured output, hardcoded quantity, ignored broker field). A
+                ``{rule_id: "error"|"warning"|"off"}`` dict; only named rules are
+                overridden, the rest stay off. ``None`` (default) skips the layer
+                entirely, so the default deep_validate pass is unchanged. Pass
+                ``programgarden.semantic_rules.STRICT_SEMANTIC_SEVERITIES`` to opt
+                into the chatbot anti-pattern checks. Findings carry ``SEMANTIC_*``
+                codes with the same ErrorInfo shape as every other error.
 
         Returns:
             ValidationResult — ``errors`` carry structured per-node ErrorInfo
@@ -15552,6 +15633,19 @@ class WorkflowExecutor:
                 )
             )
             return result
+
+        # 1b) Configurable semantic/safety layer (R1~R4) — off unless the caller
+        # opts in. Added before the static-validity gate so its findings ride
+        # along with structure errors too (the chatbot cascade combined both).
+        # Pure / never-raising, so a failure here never breaks deep_validate.
+        if semantic_rules:
+            try:
+                from .semantic_rules import analyze_workflow_semantics
+                for info in analyze_workflow_semantics(definition, semantic_rules):
+                    result.add(info)
+            except Exception:  # pragma: no cover - defensive
+                pass
+
         if not static.is_valid:
             # Hand back the structure errors verbatim (same ErrorInfo shape).
             for err in static.errors:
@@ -16749,7 +16843,7 @@ class WorkflowJob:
                     break  # 첫 번째 상위 노드만 사용
             
             # Resolve expressions in config ({{ input.xxx }}, {{ nodeId.port }})
-            config = self._resolve_config_expressions(config)
+            config = self._resolve_config_expressions(config, node_id)
 
             # Auto-inject connection from matching BrokerNode (Phase 5)
             config = self._auto_inject_connection(node_id, node, config)
@@ -16877,6 +16971,43 @@ class WorkflowJob:
                     if new_skips:
                         print(f"  🔀 IfNode {node_id}: branch={taken}, skipping {new_skips}")
 
+                # deep_validate: a node that *returns* a sole-`error` dict (rather
+                # than raising) would otherwise be stored as a COMPLETED output and
+                # silently swallowed — its downstream consumers then read a node
+                # with no real output port. Promote it to a blocking structured
+                # error so the chatbot learns why/where instead of looping on a
+                # validation that wrongly passed (feedback_chatbot_error_clarity).
+                # Scoped to a *sole* `error` key so nodes that legitimately return
+                # `{"...": [], "error": ...}` partial payloads keep flowing as before.
+                if (
+                    getattr(self.context, "is_deep_validate", False)
+                    and isinstance(outputs, dict)
+                    and set(outputs.keys()) == {"error"}
+                    and isinstance(outputs.get("error"), str)
+                    and node_id not in self._node_error_infos
+                ):
+                    from programgarden_core import (
+                        ErrorCode,
+                        ErrorLocation,
+                        build_error,
+                    )
+                    _emsg = outputs["error"]
+                    self._node_error_infos[node_id] = build_error(
+                        ErrorCode.DEEP_VALIDATION_NODE_ERROR,
+                        f"Node '{node_id}' ({node.node_type}) returned an error "
+                        f"instead of producing output: {_emsg}",
+                        location=ErrorLocation(node_id=node_id, node_type=node.node_type),
+                        suggestion=(
+                            "이 노드가 정상 출력 대신 오류를 돌려줬습니다. 위 사유를 보고 "
+                            "노드 설정(연결된 입력·자격증명·필수 필드)을 점검하세요."
+                        ),
+                        details={
+                            "raw_message": _emsg,
+                            "deep_validate": True,
+                            "stage": "node_error_return",
+                        },
+                    )
+
                 # Store outputs
                 for out_port_name, value in outputs.items():
                     self.context.set_output(node_id, out_port_name, value)
@@ -17034,7 +17165,7 @@ class WorkflowJob:
             self.context.set_iteration_context(current_item, idx, total)
 
             # config 내 표현식 평가 ({{ item.xxx }}, {{ index }} 등)
-            item_config = self._resolve_config_expressions(config)
+            item_config = self._resolve_config_expressions(config, node_id)
 
             # 진행 상황 로그
             item_label = current_item.get("symbol", str(current_item)) if isinstance(current_item, dict) else str(current_item)
@@ -17428,7 +17559,7 @@ class WorkflowJob:
 
             # Prepare config
             config = dict(node.config)
-            config = self._resolve_config_expressions(config)
+            config = self._resolve_config_expressions(config, node_id)
             config = self._auto_inject_connection(node_id, node, config)
 
             # Connect inputs from upstream
@@ -17481,7 +17612,7 @@ class WorkflowJob:
         )
 
         config = dict(node.config)
-        config = self._resolve_config_expressions(config)
+        config = self._resolve_config_expressions(config, aggregate_id)
 
         try:
             outputs = await self.executor.execute_node(
@@ -17606,7 +17737,11 @@ class WorkflowJob:
         # 매칭 실패 시 원본 반환 (노드 executor에서 에러 처리)
         return config
 
-    def _resolve_config_expressions(self, config: Dict[str, Any]) -> Dict[str, Any]:
+    def _resolve_config_expressions(
+        self,
+        config: Dict[str, Any],
+        node_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
         """
         Config 내의 {{ }} 표현식을 resolve.
 
@@ -17619,6 +17754,17 @@ class WorkflowJob:
 
         Note: items 키는 제외 (ConditionNode의 _process_items_with_extract에서 별도 처리).
               items 내부에 {{ row.xxx }} 같은 지연 평가 표현식이 있어 여기서 평가하면 실패함.
+
+        Deep-validate 동작 (node_id 가 주어졌을 때만):
+            정상(runtime/dry_run) 모드는 한 필드라도 실패하면 전체 try/except 로
+            삼키고 원본을 유지한다(동작 불변). deep_validate 모드에서는 이 전체삼킴
+            경로가 미해결 ``{{ }}`` 표현식(잘못된 필드 경로·미정의 변수·미지원 pipe
+            filter 등)을 검증에서 그대로 통과시킨다 — 일부 executor 가
+            evaluate_all_bindings 를 부르지 않아 그 노드 표현식이 여기서만 평가되기
+            때문이다. 그래서 deep 모드 + node_id 가 있으면 leaf 단위 on_error
+            콜백으로 평가해 실패 leaf 를 record_deep_unresolved_binding 에 기록한다
+            (C1 가드 통과 시에만). 비-deep 모드 또는 node_id 가 없으면 기존
+            전체삼킴 경로 그대로다.
         """
         from programgarden_core.expression import ExpressionEvaluator
 
@@ -17634,13 +17780,48 @@ class WorkflowJob:
                 if isinstance(v, str) and "{{ item" in v:
                     deferred[k] = config_copy.pop(k)
 
-        try:
-            expr_context = self.context.get_expression_context()
-            evaluator = ExpressionEvaluator(expr_context)
-            resolved = evaluator.evaluate_fields(config_copy)
-        except Exception as e:
-            self.context.log("warning", f"Expression resolve failed: {e}")
-            resolved = config_copy
+        deep_mode = bool(getattr(self.context, "is_deep_validate", False))
+        if deep_mode and node_id is not None:
+            # deep_validate: leaf 단위로 평가하고 미해결 binding 을 기록.
+            def _recorder(expr: str, exc: Exception) -> None:
+                # C1 가드 — iteration 컨텍스트가 없을 때, 표현식이 lib 예약
+                # iteration 변수(item/row)를 자유변수 루트로 참조하면 기록 제외.
+                # `{{ item.* }}`(auto-iterate)·`{{ row.* }}`(items.extract)는
+                # iteration 시점에만 유효하고, top-level `{{ item`은 위에서 이미
+                # deferred 되지만 nested dict/list 안의 `{{ item.symbol }}`은
+                # deferred 를 빠져나가 auto-iterate 전 여기서 실패한다. 기록하면
+                # 정답 예제(30/31-liquidate-* 등)가 false-reject 된다.
+                if self.context._iteration_item is None:
+                    roots = _free_root_names(expr)
+                    if roots & _RESERVED_ITERATION_ROOTS:
+                        return
+                try:
+                    self.context.record_deep_unresolved_binding(
+                        node_id, expr, str(exc)
+                    )
+                except Exception:  # pragma: no cover - defensive
+                    pass
+
+            # NOTE: evaluator 구성(get_expression_context / ExpressionEvaluator
+            # → to_dict)도 try 안에 둔다 — 컨텍스트 자체가 손상돼 raise 하면 leaf
+            # on_error 가 아니라 여기서 터지므로, 기존 전체삼킴 경로와 동일하게
+            # 원본 config 를 유지해야 한다(동작 불변).
+            try:
+                expr_context = self.context.get_expression_context()
+                evaluator = ExpressionEvaluator(expr_context)
+                resolved = evaluator.evaluate_fields(config_copy, on_error=_recorder)
+            except Exception as e:  # pragma: no cover - on_error 가 leaf 에서 흡수
+                self.context.log("warning", f"Expression resolve failed: {e}")
+                resolved = config_copy
+        else:
+            # 정상 모드(또는 node_id 없음): 기존 전체삼킴 경로 (동작 불변).
+            try:
+                expr_context = self.context.get_expression_context()
+                evaluator = ExpressionEvaluator(expr_context)
+                resolved = evaluator.evaluate_fields(config_copy)
+            except Exception as e:
+                self.context.log("warning", f"Expression resolve failed: {e}")
+                resolved = config_copy
 
         # 지연 평가 필드 복원
         resolved.update(deferred)
@@ -17942,7 +18123,7 @@ class WorkflowJob:
                                 )
                 
                 # Resolve expressions in config
-                config_with_source = self._resolve_config_expressions(config_with_source)
+                config_with_source = self._resolve_config_expressions(config_with_source, node_id)
 
                 # Auto-inject connection from matching BrokerNode (Phase 5)
                 config_with_source = self._auto_inject_connection(node_id, node, config_with_source)

{programgarden-1.23.0 → programgarden-1.24.0}/programgarden/resolver.py

@@ -783,6 +783,90 @@ class WorkflowResolver:
                 return _extract_field_names(dyn_schema.outputs, port_name)
             return None
 
+        # ── Phase 2: cross-port TYPE compatibility ──────────────────────────
+        # Field *existence* is handled above. This adds a conservative type
+        # check: a binding that is the WHOLE value of a numeric/boolean-typed
+        # consuming field must not read an output sub-field of a *different*
+        # concrete scalar type (e.g. feeding a `string` symbol into a `number`
+        # balance field). Only strong scalar classes are compared; object /
+        # array / enum / json / `any` and string-consuming fields (freely
+        # coercible) are left open to keep false-rejects at zero.
+        _SCALAR_CLASS = {
+            "number": "num", "integer": "num", "int": "num",
+            "float": "num", "decimal": "num",
+            "string": "str", "str": "str",
+            "boolean": "bool", "bool": "bool",
+        }
+
+        def _scalar_class(type_str: Any) -> Optional[str]:
+            if not type_str:
+                return None
+            return _SCALAR_CLASS.get(str(type_str).strip().lower())
+
+        def _extract_field_type(outputs: Any, port_name: str, field_name: str) -> Optional[str]:
+            for out in (outputs or []):
+                if isinstance(out, dict):
+                    nm = out.get("name")
+                    fields = out.get("fields")
+                else:
+                    nm = getattr(out, "name", None)
+                    fields = getattr(out, "fields", None)
+                if nm != port_name:
+                    continue
+                for f in (fields or []):
+                    if isinstance(f, dict):
+                        fn, ft = f.get("name"), f.get("type")
+                    else:
+                        fn, ft = getattr(f, "name", None), getattr(f, "type", None)
+                    if fn == field_name:
+                        return ft
+            return None
+
+        def _output_field_type(node_type: str, port_name: str, field_name: str) -> Optional[str]:
+            if not node_type:
+                return None
+            schema = registry.get_schema(node_type)
+            if schema:
+                return _extract_field_type(schema.outputs, port_name, field_name)
+            dyn_schema = dynamic_registry.get_schema(node_type)
+            if dyn_schema:
+                return _extract_field_type(dyn_schema.outputs, port_name, field_name)
+            return None
+
+        def _consuming_scalar_class(node_type: str, field_key: str) -> Optional[str]:
+            """Strong scalar class expected by a consuming node's top-level
+            config field, or None when the field is open/structured (skip).
+
+            `expected_type == 'any'` (e.g. IfNode.left/right) is explicitly open
+            and must never be type-checked; struct-shaped `expected_type`
+            (``{...}``) is object-like → skip; a concrete scalar `expected_type`
+            wins, otherwise fall back to the FieldType enum.
+            """
+            node_class = registry.get(node_type) if node_type else None
+            if node_class is None:
+                return None
+            try:
+                fs = node_class.get_field_schema()
+            except Exception:
+                return None
+            sch = fs.get(field_key) if isinstance(fs, dict) else None
+            if sch is None:
+                return None
+            expected = getattr(sch, "expected_type", None)
+            if expected is not None:
+                exp_s = str(expected).strip().lower()
+                if exp_s in ("any", ""):
+                    return None
+                cls = _scalar_class(exp_s)
+                # Concrete scalar expected_type → use it; struct/other → skip.
+                return cls
+            ftype = getattr(sch, "type", None)
+            ftype = getattr(ftype, "value", ftype)
+            return _scalar_class(ftype)
+
+        # Whole-value single-expression matcher (no surrounding text / arithmetic).
+        _whole_expr = re.compile(r"^\s*\{\{\s*nodes\.[\w.]+\s*\}\}\s*$")
+
         # nodes.<id>(.<attr>)* — capture the full dotted path so nested
         # field typos (e.g. {{ nodes.account.balance.orderabl_amount }})
         # are also caught when OutputPort.fields declares the shape.
@@ -856,34 +940,87 @@ class WorkflowResolver:
                         continue
                     nested = attrs[1]
                     field_names = _field_names_for(source_type, attr)
-                    if field_names is None or nested in field_names:
-                        continue
-                    # Underscore-prefixed keys are reserved for internal
-                    # metadata (e.g. _partial_failure on balance dicts).
-                    # Treat them as known so consumers can branch on them
-                    # without forcing every metadata addition to update
-                    # BALANCE_FIELDS in lockstep.
-                    if nested.startswith("_"):
-                        continue
-                    result.add(
-                        build_error(
-                            ErrorCode.INVALID_EXPRESSION_REF,
-                            f"Expression field '{nested}' is not a declared field of "
-                            f"port '{attr}' on node '{ref_id}' ({source_type})",
-                            location=ErrorLocation(
-                                node_id=node_id,
-                                node_type=node_type_by_id.get(node_id),
-                                field_path=field_path,
-                                expression=value,
-                                output_port=attr,
-                            ),
-                            available_values=suggest_close_match(nested, field_names) or sorted(field_names),
-                            suggestion=(
-                                f"Pick a field that exists on '{attr}' "
-                                "(see OutputPort.fields in the node schema)."
-                            ),
-                        )
+                    field_exists = (
+                        field_names is None
+                        or nested in field_names
+                        # Underscore-prefixed keys are reserved for internal
+                        # metadata (e.g. _partial_failure on balance dicts).
+                        # Treat them as known so consumers can branch on them
+                        # without forcing every metadata addition to update
+                        # BALANCE_FIELDS in lockstep.
+                        or nested.startswith("_")
                     )
+                    if not field_exists:
+                        result.add(
+                            build_error(
+                                ErrorCode.INVALID_EXPRESSION_REF,
+                                f"Expression field '{nested}' is not a declared field of "
+                                f"port '{attr}' on node '{ref_id}' ({source_type})",
+                                location=ErrorLocation(
+                                    node_id=node_id,
+                                    node_type=node_type_by_id.get(node_id),
+                                    field_path=field_path,
+                                    expression=value,
+                                    output_port=attr,
+                                ),
+                                available_values=suggest_close_match(nested, field_names) or sorted(field_names),
+                                suggestion=(
+                                    f"Pick a field that exists on '{attr}' "
+                                    "(see OutputPort.fields in the node schema)."
+                                ),
+                            )
+                        )
+                        continue
+
+                    # ── Phase 2: type compatibility on the valid-field path ──
+                    # Only when this binding is the WHOLE value of a TOP-LEVEL
+                    # config field and the field shape is known. Nested consumer
+                    # paths (field_path with '.'/'[' → object-typed parent) and
+                    # interpolated strings are intentionally skipped (ceiling).
+                    if (
+                        field_names is not None
+                        and not is_call
+                        and len(attrs) == 2
+                        and "." not in field_path
+                        and "[" not in field_path
+                        and _whole_expr.match(value)
+                    ):
+                        consumer_type = node_type_by_id.get(node_id)
+                        cin = _consuming_scalar_class(consumer_type, field_path)
+                        if cin in ("num", "bool"):
+                            out_type = _output_field_type(source_type, attr, nested)
+                            cout = _scalar_class(out_type)
+                            if cout is not None and cout != cin:
+                                result.add(
+                                    build_error(
+                                        ErrorCode.INVALID_FIELD_TYPE,
+                                        f"Field '{field_path}' on node '{node_id}' "
+                                        f"({consumer_type}) expects a {cin} value, but "
+                                        f"the expression reads '{attr}.{nested}' from "
+                                        f"'{ref_id}' ({source_type}) which is declared "
+                                        f"{out_type}.",
+                                        location=ErrorLocation(
+                                            node_id=node_id,
+                                            node_type=consumer_type,
+                                            field_path=field_path,
+                                            expression=value,
+                                            output_port=attr,
+                                        ),
+                                        suggestion=(
+                                            f"'{field_path}' 필드에는 {cin} 타입 값이 필요합니다. "
+                                            f"'{ref_id}' 노드의 '{attr}.{nested}' 출력은 타입이 달라 "
+                                            f"맞지 않습니다 — 타입이 호환되는 출력 필드로 바꾸세요."
+                                        ),
+                                        details={
+                                            "consumer_field": field_path,
+                                            "consumer_class": cin,
+                                            "ref_node_id": ref_id,
+                                            "ref_port": attr,
+                                            "ref_field": nested,
+                                            "ref_field_type": out_type,
+                                        },
+                                    )
+                                )
             elif isinstance(value, dict):
                 for k, v in value.items():
                     find_refs(v, node_id, f"{field_path}.{k}")

programgarden-1.24.0/programgarden/semantic_rules.py

@@ -0,0 +1,404 @@
+"""Configurable semantic / safety rule layer for ``deep_validate`` (R1~R4).
+
+Single source for the chatbot anti-pattern checks that used to live client-side
+in ``programgarden_ai``'s ``workflow_semantic_lint``. This module exists because
+structure-validation, ``dry_run`` and the Phase 2 port-type checks all pass for
+workflows that are still *semantically* wrong or *unsafe* — they validate
+*executability*, never *intent* or *safety*.
+
+The four ground-truth anti-patterns (verified against the canonical example
+workflows shipped in ``programgarden/examples/workflows`` and the live node
+registry):
+
+  * **R1 — order quantity bound to an AIAgent response.** An AIAgent
+    sentiment/decision output wired straight into an order quantity risks a
+    0 / negative / nonsense size. ``BaseOrderNode`` declares ``order: Any`` so
+    structure-validate accepts it. (Blocking when enabled.)
+  * **R2 — AIAgent ``output_format='structured'`` with no ``output_schema``.**
+    The ``response`` output port is declared ``type='any'`` with no sub-fields,
+    so port-type validation cannot constrain it; an unconstrained structured
+    output is one downstream consumers cannot rely on. (Blocking when enabled.)
+    NOTE: the *harmful* case (a downstream binding to a specific sub-field) is
+    already caught by ``deep_validate``'s runtime binding-resolution pass — the
+    schema-less fixture yields no such field, so the binding is reported as
+    ``DEEP_VALIDATION_BINDING_UNRESOLVED``. This rule adds *upfront* clarity
+    (say why/how before a field-miss happens), per ``feedback_chatbot_error_clarity``.
+  * **R3 — hardcoded literal order quantity with no PositionSizingNode.**
+    Always trades the same size regardless of balance/risk. (Advisory.)
+  * **R4 — order node carrying ``paper_trading``.** That field is a *broker*
+    field; on an order node it is silently ignored. (Advisory.)
+
+Design contract
+---------------
+* **Pure** — no network, no LLM, no DB; never raises (a malformed DSL is
+  defensively coerced, never crashes the validator).
+* **Structural signals only.** Node identity (order / AIAgent) is resolved from
+  the node *registry class hierarchy* (``BaseOrderNode`` / ``BaseModifyOrderNode``
+  / ``AIAgentNode``), never from natural-language keyword arrays
+  (project rule ``feedback_no_keyword_hardcoding_in_ai``). The binding graph is
+  read from the DSL ``{{ nodes.<id>.<path> }}`` templates.
+* **Off by default.** ``deep_validate`` only runs this layer when the caller
+  passes a ``semantic_rules`` config, so the sandbox / editor default path is
+  byte-for-byte unchanged (zero false-reject regression on the example corpus).
+* **Per-rule configurable severity** — ``"error"`` (blocks), ``"warning"``
+  (surfaced, non-blocking), or ``"off"`` (skipped).
+
+All Korean ``suggestion`` strings are clear beginner-investor guidance the
+chatbot can relay verbatim (``feedback_chatbot_error_clarity``).
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any, Dict, List, Optional
+
+from programgarden_core import (
+    ErrorCode,
+    ErrorInfo,
+    ErrorLocation,
+    ErrorSeverity,
+    build_error,
+)
+
+# ---------------------------------------------------------------------------
+# Rule identifiers + severity presets
+# ---------------------------------------------------------------------------
+
+RULE_ORDER_QTY_FROM_AI = "order_qty_from_ai_response"            # R1
+RULE_STRUCTURED_OUTPUT_NO_SCHEMA = "structured_output_missing_schema"  # R2
+RULE_HARDCODED_ORDER_QTY = "hardcoded_order_quantity"            # R3
+RULE_ORDER_IGNORED_FIELD = "order_ignored_field"                # R4
+
+ALL_RULES: tuple[str, ...] = (
+    RULE_ORDER_QTY_FROM_AI,
+    RULE_STRUCTURED_OUTPUT_NO_SCHEMA,
+    RULE_HARDCODED_ORDER_QTY,
+    RULE_ORDER_IGNORED_FIELD,
+)
+
+_RULE_CODE: Dict[str, ErrorCode] = {
+    RULE_ORDER_QTY_FROM_AI: ErrorCode.SEMANTIC_ORDER_QTY_FROM_AI,
+    RULE_STRUCTURED_OUTPUT_NO_SCHEMA: ErrorCode.SEMANTIC_STRUCTURED_OUTPUT_NO_SCHEMA,
+    RULE_HARDCODED_ORDER_QTY: ErrorCode.SEMANTIC_HARDCODED_ORDER_QTY,
+    RULE_ORDER_IGNORED_FIELD: ErrorCode.SEMANTIC_ORDER_IGNORED_FIELD,
+}
+
+# Everything off — the default when no config is supplied.
+DEFAULT_SEMANTIC_SEVERITIES: Dict[str, str] = {r: "off" for r in ALL_RULES}
+
+# Chatbot strict preset — reproduces the legacy ``workflow_semantic_lint``
+# behavior exactly (R1/R2 block, R3/R4 advise). Callers opt in with this.
+STRICT_SEMANTIC_SEVERITIES: Dict[str, str] = {
+    RULE_ORDER_QTY_FROM_AI: "error",
+    RULE_STRUCTURED_OUTPUT_NO_SCHEMA: "error",
+    RULE_HARDCODED_ORDER_QTY: "warning",
+    RULE_ORDER_IGNORED_FIELD: "warning",
+}
+
+_SEVERITY_MAP: Dict[str, ErrorSeverity] = {
+    "error": ErrorSeverity.ERROR,
+    "warning": ErrorSeverity.WARNING,
+}
+
+# ---------------------------------------------------------------------------
+# DSL field shapes (verified against the canonical examples — flat node dict)
+# ---------------------------------------------------------------------------
+
+_ORDER_FIELD = "order"
+_QUANTITY_KEY = "quantity"
+# ``paper_trading`` is a legitimate BrokerNode field; on an order node it is
+# silently ignored. Scoped denylist (not a broad unknown-field sweep) to avoid
+# false positives on legitimately-varied order fields.
+_ORDER_IGNORED_FIELDS: frozenset[str] = frozenset({"paper_trading"})
+
+# Binding template: "{{ nodes.<node_id>.<rest...> }}" (spaces optional).
+_NODE_REF_RE = re.compile(r"\{\{\s*nodes\.([A-Za-z0-9_\-]+)\.")
+
+
+# ---------------------------------------------------------------------------
+# Structural node identity (registry class hierarchy — no keyword arrays)
+# ---------------------------------------------------------------------------
+
+def _order_base_classes() -> tuple:
+    """Order-family base classes from the registry (placing OR mutating quantity).
+
+    ``BaseOrderNode`` = New orders (carry an ``order.quantity``); ``BaseModifyOrderNode``
+    = Modify/Cancel. Imported lazily so importing this module never forces the
+    (heavy) node package at import time.
+    """
+    from programgarden_core.nodes.order import BaseOrderNode, BaseModifyOrderNode
+    return (BaseOrderNode, BaseModifyOrderNode)
+
+
+def _aiagent_base_class():
+    from programgarden_core.nodes.ai import AIAgentNode
+    return AIAgentNode
+
+
+def _node_class(node_type: Any):
+    """Resolve a node ``type`` string to its registered class, or None.
+
+    None for unknown / dynamic / community types and for non-str types (a
+    malformed DSL may carry a list/dict ``type``) — callers treat None as
+    "neither order nor AI", keeping the lint never-raising.
+    """
+    if not isinstance(node_type, str):
+        return None
+    try:
+        from programgarden_core.registry.node_registry import NodeTypeRegistry
+        return NodeTypeRegistry().get(node_type)
+    except Exception:  # pragma: no cover - defensive
+        return None
+
+
+def _is_order_node(node_type: Any) -> bool:
+    cls = _node_class(node_type)
+    if cls is None:
+        return False
+    try:
+        return issubclass(cls, _order_base_classes())
+    except Exception:  # pragma: no cover - defensive
+        return False
+
+
+def _is_aiagent_node(node_type: Any) -> bool:
+    cls = _node_class(node_type)
+    if cls is None:
+        return False
+    try:
+        return issubclass(cls, _aiagent_base_class())
+    except Exception:  # pragma: no cover - defensive
+        return False
+
+
+# ---------------------------------------------------------------------------
+# Binding helpers
+# ---------------------------------------------------------------------------
+
+def _is_binding(value: Any) -> bool:
+    return isinstance(value, str) and "{{" in value and "}}" in value
+
+
+def _referenced_node_ids(value: Any) -> List[str]:
+    if not isinstance(value, str):
+        return []
+    return _NODE_REF_RE.findall(value)
+
+
+def _order_quantity_value(node: Dict[str, Any]) -> tuple[bool, Any]:
+    """Return ``(present, value)`` for an order's quantity.
+
+    Order shape (canonical examples): ``order`` is either a literal dict
+    ``{"quantity": <int>, ...}`` or a whole-order binding ``"{{ nodes.X.order }}"``.
+    ``value`` is the quantity expression when ``order`` is a dict, else the whole
+    ``order`` value. ``present`` is False only when there is no quantity to check
+    (no ``order`` field, or a dict ``order`` without ``quantity`` — e.g. cancel).
+    """
+    if _ORDER_FIELD not in node:
+        return False, None
+    order = node.get(_ORDER_FIELD)
+    if isinstance(order, dict):
+        if _QUANTITY_KEY in order:
+            return True, order.get(_QUANTITY_KEY)
+        return False, None
+    return True, order
+
+
+# ---------------------------------------------------------------------------
+# Config normalization
+# ---------------------------------------------------------------------------
+
+def normalize_severities(config: Any) -> Dict[str, str]:
+    """Merge a caller config over the all-off default → ``{rule: severity}``.
+
+    ``config`` may be a partial ``{rule_id: "error"|"warning"|"off"}`` dict (only
+    the named rules are overridden), one of the preset dicts, or None (→ all off).
+    Unknown rule keys and invalid severities are ignored defensively.
+    """
+    merged = dict(DEFAULT_SEMANTIC_SEVERITIES)
+    if isinstance(config, dict):
+        for rule, sev in config.items():
+            if rule in merged and isinstance(sev, str) and sev in ("error", "warning", "off"):
+                merged[rule] = sev
+    return merged
+
+
+def _enabled(severities: Dict[str, str], rule: str) -> Optional[ErrorSeverity]:
+    """ErrorSeverity for an enabled rule, or None when the rule is 'off'."""
+    return _SEVERITY_MAP.get(severities.get(rule, "off"))
+
+
+# ---------------------------------------------------------------------------
+# Public entry point
+# ---------------------------------------------------------------------------
+
+def analyze_workflow_semantics(
+    definition: Dict[str, Any],
+    config: Any = None,
+) -> List[ErrorInfo]:
+    """Run the configurable semantic/safety layer over a workflow definition.
+
+    Pure, never-raising. Returns a list of ``ErrorInfo`` (the same structured
+    shape as every other validation error — ``code`` / ``severity`` /
+    ``location{node_id,node_type,field_path,expression}`` / ``message`` /
+    ``suggestion``), so consumers handle these uniformly with structure/deep
+    errors. Severity per finding follows ``config`` (see ``normalize_severities``).
+
+    Args:
+        definition: Workflow definition (JSON dict) with ``nodes`` / ``edges``.
+        config: Per-rule severity config; None → all rules off → ``[]``.
+    """
+    severities = normalize_severities(config)
+    # Fast exit: nothing enabled → no work, no node-class resolution.
+    if all(v == "off" for v in severities.values()):
+        return []
+
+    nodes = definition.get("nodes") if isinstance(definition, dict) else None
+    if not isinstance(nodes, list):
+        return []
+
+    sev_r1 = _enabled(severities, RULE_ORDER_QTY_FROM_AI)
+    sev_r2 = _enabled(severities, RULE_STRUCTURED_OUTPUT_NO_SCHEMA)
+    sev_r3 = _enabled(severities, RULE_HARDCODED_ORDER_QTY)
+    sev_r4 = _enabled(severities, RULE_ORDER_IGNORED_FIELD)
+
+    # Index node id → node, and whether any PositionSizingNode exists (R3).
+    nodes_by_id: Dict[str, Dict[str, Any]] = {}
+    has_position_sizing = False
+    for n in nodes:
+        if not isinstance(n, dict):
+            continue
+        nid = n.get("id")
+        if isinstance(nid, str):
+            nodes_by_id[nid] = n
+        if n.get("type") == "PositionSizingNode":
+            has_position_sizing = True
+
+    errors: List[ErrorInfo] = []
+
+    for node in nodes:
+        if not isinstance(node, dict):
+            continue
+        node_type = node.get("type")
+        node_id = node.get("id") if isinstance(node.get("id"), str) else "?"
+
+        # ── R2: AIAgent structured output with no schema (and no preset) ──
+        if sev_r2 is not None and _is_aiagent_node(node_type):
+            if node.get("output_format") == "structured":
+                schema = node.get("output_schema")
+                # missing / None / empty dict / empty string all = "no schema".
+                # FALSE-REJECT GUARD: shipped examples 33/34 use structured + no
+                # schema + a built-in ``preset`` (risk_manager / technical_analyst);
+                # the lib treats schema-less structured as a non-fatal fallback to
+                # raw JSON and a preset carries a behavior contract — so only the
+                # truly-unconstrained case (no schema AND no preset) is flagged.
+                if not schema and not node.get("preset"):
+                    errors.append(build_error(
+                        ErrorCode.SEMANTIC_STRUCTURED_OUTPUT_NO_SCHEMA,
+                        "AIAgentNode output_format='structured' has no output_schema, "
+                        "so the structured output is unconstrained and downstream "
+                        "nodes cannot rely on its shape.",
+                        severity=sev_r2,
+                        location=ErrorLocation(
+                            node_id=node_id, node_type=node_type, field_path="output_schema"
+                        ),
+                        suggestion=(
+                            "output_schema 를 제공하거나(예: action/quantity 등 필드와 "
+                            "타입을 명시), 구조가 필요 없으면 output_format=text 로 바꾸세요."
+                        ),
+                        details={"rule": RULE_STRUCTURED_OUTPUT_NO_SCHEMA},
+                    ))
+
+        # ── Order-node rules (R1 / R3 / R4) ──────────────────────────────
+        if _is_order_node(node_type):
+            present, qty_value = _order_quantity_value(node)
+
+            # R1: order quantity bound to an AIAgent response → block.
+            r1_hit = False
+            if sev_r1 is not None and present and _is_binding(qty_value):
+                ref_ids = _referenced_node_ids(qty_value)
+                ai_ref = next(
+                    (rid for rid in ref_ids
+                     if _is_aiagent_node(nodes_by_id.get(rid, {}).get("type"))),
+                    None,
+                )
+                if ai_ref is not None:
+                    r1_hit = True
+                    errors.append(build_error(
+                        ErrorCode.SEMANTIC_ORDER_QTY_FROM_AI,
+                        f"Order quantity is bound to AIAgent '{ai_ref}' output; an AI "
+                        "sentiment/decision response wired straight into quantity risks "
+                        "a 0 / negative / nonsense order size.",
+                        severity=sev_r1,
+                        location=ErrorLocation(
+                            node_id=node_id, node_type=node_type,
+                            field_path="order.quantity",
+                            expression=qty_value if isinstance(qty_value, str) else None,
+                        ),
+                        suggestion=(
+                            "수량은 PositionSizingNode 로 산출하고 order.quantity 는 그 "
+                            "출력을 바인딩하세요. AI 감성/신호 응답을 주문 수량에 직결하면 "
+                            "0/음수/엉뚱한 수량 위험이 있습니다 (주문 안티패턴 #1)."
+                        ),
+                        details={"rule": RULE_ORDER_QTY_FROM_AI, "ai_node_id": ai_ref},
+                    ))
+
+            # R3: hardcoded literal quantity AND no PositionSizingNode → advise.
+            # Never on a binding (a binding is not a hardcoded literal). bool is
+            # an int subclass — exclude it.
+            if (
+                sev_r3 is not None and not r1_hit and present
+                and isinstance(qty_value, int) and not isinstance(qty_value, bool)
+                and not has_position_sizing
+            ):
+                errors.append(build_error(
+                    ErrorCode.SEMANTIC_HARDCODED_ORDER_QTY,
+                    f"Order quantity is hardcoded ({qty_value}) and the workflow has no "
+                    "PositionSizingNode — it always trades the same size regardless of "
+                    "account balance or risk.",
+                    severity=sev_r3,
+                    location=ErrorLocation(
+                        node_id=node_id, node_type=node_type, field_path="order.quantity"
+                    ),
+                    suggestion=(
+                        "계정/리스크 기반 수량은 PositionSizingNode 사용을 권장합니다 "
+                        "(고정 수량이 의도라면 그대로 두어도 됩니다)."
+                    ),
+                    details={"rule": RULE_HARDCODED_ORDER_QTY, "quantity": qty_value},
+                ))
+
+            # R4: order node carries a silently-ignored broker field → advise.
+            if sev_r4 is not None:
+                for field in _ORDER_IGNORED_FIELDS:
+                    if field in node:
+                        errors.append(build_error(
+                            ErrorCode.SEMANTIC_ORDER_IGNORED_FIELD,
+                            f"Order node carries '{field}', which the order schema does "
+                            "not define and silently ignores; real/paper is decided at "
+                            "the broker/credential level, not on the order node.",
+                            severity=sev_r4,
+                            location=ErrorLocation(
+                                node_id=node_id, node_type=node_type, field_path=field
+                            ),
+                            suggestion=(
+                                f"'{field}' 는 주문 노드에서 무시됩니다. 실전/모의 구분은 "
+                                "BrokerNode 의 paper_trading 또는 모의 credential 로 "
+                                "결정하세요."
+                            ),
+                            details={"rule": RULE_ORDER_IGNORED_FIELD, "field": field},
+                        ))
+
+    return errors
+
+
+__all__ = [
+    "RULE_ORDER_QTY_FROM_AI",
+    "RULE_STRUCTURED_OUTPUT_NO_SCHEMA",
+    "RULE_HARDCODED_ORDER_QTY",
+    "RULE_ORDER_IGNORED_FIELD",
+    "ALL_RULES",
+    "DEFAULT_SEMANTIC_SEVERITIES",
+    "STRICT_SEMANTIC_SEVERITIES",
+    "normalize_severities",
+    "analyze_workflow_semantics",
+]

{programgarden-1.23.0 → programgarden-1.24.0}/pyproject.toml

@@ -5,7 +5,7 @@ authors = [
 homepage = "https://programgarden.com"
 requires-python = ">=3.12"
 name = "programgarden"
-version = "1.23.0"
+version = "1.24.0"
 description = "ProgramGarden - 노드 기반 자동매매 DSL 실행 엔진"
 readme = "README.md"
 
@@ -28,7 +28,7 @@ lxml = "^6.0.2"
 pytickersymbols = {version = ">=1.17.5", python = ">=3.12,<4.0"}
 aiosqlite = "^0.20.0"
 litellm = ">=1.40.0"
-programgarden-core = "^1.14.4"
+programgarden-core = "^1.15.0"
 programgarden-finance = "^1.6.10"
 programgarden-community = "^1.13.8"