programgarden 2.2.0__tar.gz → 2.4.0__tar.gz

{programgarden-2.2.0 → programgarden-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: programgarden
-Version: 2.2.0
+Version: 2.4.0
 Summary: ProgramGarden - 노드 기반 자동매매 DSL 실행 엔진
 License-Expression: AGPL-3.0-or-later
 Author: 프로그램동산
@@ -15,8 +15,8 @@ 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 (>=2.1.0,<3.0.0)
-Requires-Dist: programgarden-core (>=2.2.0,<3.0.0)
+Requires-Dist: programgarden-community (>=2.2.0,<3.0.0)
+Requires-Dist: programgarden-core (>=2.4.0,<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)

{programgarden-2.2.0 → programgarden-2.4.0}/programgarden/context.py

@@ -236,11 +236,6 @@ class ExecutionContext:
         # Realtime data buffer
         self._realtime_data: Dict[str, Any] = {}
 
-        # Market status cache (JIF 기반, MarketStatusNode 전용)
-        # key=market canonical name (e.g. "US"), value=dict(jstatus, label,
-        # is_open, is_regular_open, is_extended_open, updated_at, jangubun)
-        self._market_status_cache: Dict[str, Dict[str, Any]] = {}
-
         # Providers
         self._data_provider: Optional[DataProvider] = None
         self._account_provider: Optional[AccountProvider] = None
@@ -796,47 +791,6 @@ class ExecutionContext:
         """Get realtime data"""
         return self._realtime_data.get(key)
 
-    # === Market Status (JIF-based) ===
-
-    def update_market_status(self, market: str, status: Dict[str, Any]) -> None:
-        """Update the cached status snapshot for a canonical market key.
-
-        Called by MarketStatusNodeExecutor on each JIF event. ``market``
-        is one of the 12 canonical keys (KOSPI, US, HK_AM, ...). Unknown
-        codes are stored as-is so debugging can still inspect them.
-        """
-
-        self._market_status_cache[market] = status
-
-    def get_market_status(self, market: str) -> Optional[Dict[str, Any]]:
-        """Return the latest status snapshot for ``market`` or None if
-        no JIF event has been received yet for that market."""
-
-        return self._market_status_cache.get(market)
-
-    def is_market_open(
-        self, market: str, include_extended: bool = False
-    ) -> Optional[bool]:
-        """Convenience helper for ``{{ ... is_market_open("US") }}``.
-
-        Returns ``None`` when no event has been received for the market
-        (distinct from ``False``, which means an event said the market
-        is closed). Honours the ``include_extended`` flag to cover
-        pre/after-market sessions.
-        """
-
-        status = self._market_status_cache.get(market)
-        if not status:
-            return None
-        if include_extended:
-            return bool(status.get("is_extended_open", False))
-        return bool(status.get("is_regular_open", False))
-
-    def get_all_market_statuses(self) -> Dict[str, Dict[str, Any]]:
-        """Shallow copy of the full market status snapshot cache."""
-
-        return dict(self._market_status_cache)
-
     # === Data Query (Provider Delegation) ===
 
     async def get_price(self, symbol: str) -> Optional[float]:
@@ -3395,10 +3349,11 @@ class ExecutionContext:
         Also provides `input` variable for workflow inputs.
 
         Available variables in expressions:
-        - {{ nodeId.port }}: Node output values
-        - {{ nodes.nodeId.method() }}: Node output with method chaining 
-        - {{ item }}, {{ item.field }}: Current iteration item 
-        - {{ index }}, {{ total }}: Iteration context 
+        - {{ nodes.nodeId.port }}: Node output values (the `nodes.` prefix is
+          required — a bare `{{ nodeId.port }}` is an undefined variable)
+        - {{ nodes.nodeId.method() }}: Node output with method chaining
+        - {{ item }}, {{ item.field }}: Current iteration item
+        - {{ index }}, {{ total }}: Iteration context
         - {{ input.xxx }}: Workflow input parameters
         - {{ context.xxx }}: Runtime context parameters
         """

{programgarden-2.2.0 → programgarden-2.4.0}/programgarden/deep_fixtures.py

@@ -441,19 +441,6 @@ def futures_contract_fixture(
     }
 
 
-def market_status_fixture(config: Dict[str, Any]) -> Dict[str, Any]:
-    """MarketStatusNode deep fixture (markets open).
-
-    Real shape: ``{"statuses": [{market, status}]}``.
-    """
-    return {
-        "statuses": [
-            {"market": "NASDAQ", "status": "OPEN"},
-            {"market": "NYSE", "status": "OPEN"},
-        ],
-    }
-
-
 def broker_connection_fixture(
     node_type: str,
     config: Dict[str, Any],

{programgarden-2.2.0 → programgarden-2.4.0}/programgarden/executor.py

@@ -2253,8 +2253,10 @@ class ScheduleNodeExecutor(NodeExecutorBase):
         cron_expr = cron_expr.strip()
         tz_name = config.get("timezone", "America/New_York")
         enabled = config.get("enabled", True)
-        count = config.get("count", 1000)  # 최대 반복 횟수 (M-6: 기본값 축소; 모델 필드로 편입)
-        max_duration_hours = config.get("max_duration_hours", 24.0)
+        # None/absent = unbounded: run until the workflow is stopped (owner
+        # 2026-09-26). A provided value is enforced as a cap in the loop below.
+        count = config.get("count")  # None → no cycle cap
+        max_duration_hours = config.get("max_duration_hours")  # None → no wall-clock cap
         
         if not enabled:
             context.log("info", f"Schedule disabled: {cron_expr}", node_id)
@@ -2289,7 +2291,8 @@ class ScheduleNodeExecutor(NodeExecutorBase):
             import time as _time
             cnt = 0
             start_mono = _time.monotonic()
-            max_duration_sec = max_duration_hours * 3600
+            # None = unbounded; only compute a wall-clock cap when a bound was set.
+            max_duration_sec = max_duration_hours * 3600 if max_duration_hours is not None else None
             try:
                 # second_at_beginning=True로 초 단위 cron도 지원
                 try:
@@ -2297,7 +2300,7 @@ class ScheduleNodeExecutor(NodeExecutorBase):
                 except TypeError:
                     itr = croniter(cron_expr, datetime.now(tz))
 
-                while cnt < count and context.is_running:
+                while (count is None or cnt < count) and context.is_running:
                     # dry_run: 루프 진입 즉시 1회 emit 후 종료
                     if context.is_dry_run:
                         cnt += 1
@@ -2317,8 +2320,9 @@ class ScheduleNodeExecutor(NodeExecutorBase):
                             },
                         )
                         break
-                    # M-6: max_duration_hours 초과 시 스케줄 종료
-                    if (_time.monotonic() - start_mono) >= max_duration_sec:
+                    # M-6: max_duration_hours 초과 시 스케줄 종료 (한도가 설정된 경우에만;
+                    # None 이면 사용자가 워크플로우를 멈출 때까지 계속 실행)
+                    if max_duration_sec is not None and (_time.monotonic() - start_mono) >= max_duration_sec:
                         context.log(
                             "warning",
                             f"Schedule max_duration_hours={max_duration_hours}h 초과 - "
@@ -9635,356 +9639,6 @@ class RealOrderEventNodeExecutor(NodeExecutorBase):
             context.log("error", f"Korea stock order event error: {e}", node_id)
             return {"error": str(e)}
 
-class MarketStatusNodeExecutor(NodeExecutorBase):
-    """MarketStatusNode executor — JIF 기반 실시간 시장 상태 추적.
-
-    Broker credential type 무관(해외주식/해외선물/국내주식 중 아무 BrokerNode).
-    broker의 기존 WSS 세션과 별도로 ``Common.real()`` 공용 WebSocket 세션을
-    생성하여 JIF TR 하나를 구독합니다. token_manager 는 broker 로그인에서
-    재사용하므로 중복 로그인 없음.
-
-    stay_connected=True (기본): 구독 유지하며 콜백마다 context._market_status_cache
-    + set_output 갱신. 워크플로우 종료 시 cleanup_jif_subscriptions 에서 해제.
-
-    stay_connected=False: 최대 5초 기다리며 수신된 이벤트 반영한 snapshot 반환
-    후 즉시 tr_type=4 해제. AI Agent Tool 일회성 조회용.
-    """
-
-    # {f"{job_id}::{node_id}": {"jif": RealJIF, "real": Real, "stay_connected": bool}}
-    _active_subscriptions: Dict[str, Any] = {}
-
-    # Canonical market list for the convenience boolean ports. Updated in
-    # lock-step with the OutputPort definitions on ``MarketStatusNode``.
-    _SOLO_MARKET_PORTS = (
-        ("US", "us_is_open"),
-        ("KOSPI", "kospi_is_open"),
-        ("KOSDAQ", "kosdaq_is_open"),
-        ("KRX_FUTURES", "krx_futures_is_open"),
-    )
-
-    _COMBO_MARKET_PORTS = (
-        ("hk_is_open", "HK_AM", "HK_PM"),
-        ("cn_is_open", "CN_AM", "CN_PM"),
-        ("jp_is_open", "JP_AM", "JP_PM"),
-    )
-
-    async def cleanup_jif_subscriptions(self, job_id: str) -> None:
-        """Unsubscribe every active JIF stream registered for the given job.
-
-        Mirrors ``BrokerNodeExecutor.cleanup_fill_subscriptions`` so the
-        executor's shutdown sequence can wipe market-status subscriptions
-        without touching unrelated real-time feeds.
-        """
-
-        keys_to_remove = []
-        for key, info in self._active_subscriptions.items():
-            if not key.startswith(f"{job_id}::"):
-                continue
-            jif = info.get("jif")
-            real = info.get("real")
-            if jif is not None:
-                try:
-                    jif.on_remove_jif_message()
-                except (RuntimeError, AttributeError):
-                    pass
-                except Exception as e:
-                    logger.warning(f"JIF unsubscribe failed for {key}: {e}")
-            if real is not None:
-                try:
-                    await real.close()
-                except Exception as e:
-                    logger.warning(f"Common.real close failed for {key}: {e}")
-            keys_to_remove.append(key)
-
-        for key in keys_to_remove:
-            del self._active_subscriptions[key]
-            logger.debug(f"Cleaned up JIF subscription: {key}")
-
-    async def execute(
-        self,
-        node_id: str,
-        node_type: str,
-        config: Dict[str, Any],
-        context: ExecutionContext,
-        **kwargs,
-    ) -> Dict[str, Any]:
-        import asyncio
-        from datetime import datetime
-
-        from programgarden_core.exceptions import ConnectionError, ValidationError
-
-        # deep_validate: return a fixture market-status (markets open) so the
-        # flow keeps flowing instead of skipping (no WebSocket/JIF subscription).
-        if context.is_deep_validate:
-            from programgarden import deep_fixtures as _df
-            config = evaluate_all_bindings(config, context, node_id)
-            fixture = _df.market_status_fixture(config)
-            override = context.get_deep_fixture(node_id, node_type)
-            return _df.apply_override(fixture, override)
-
-        # dry_run skip — WebSocket 불가
-        if context.is_dry_run:
-            context.log(
-                "warning",
-                f"[dry_run] MarketStatusNode skipped (realtime WebSocket disabled)",
-                node_id,
-            )
-            return {"status": "skipped_dry_run", "dry_run": True}
-
-        # 1. broker_connection 획득
-        # MarketStatusNode 는 product_scope=ALL 이므로 auto-injection 에서 제외.
-        # 여기서 직접 find_parent_output(...) 로 아무 BrokerNode 나 수용.
-        broker_connection = config.get("connection")
-        if not broker_connection:
-            for broker_type in (
-                "OverseasStockBrokerNode",
-                "KoreaStockBrokerNode",
-                "OverseasFuturesBrokerNode",
-            ):
-                candidates = context.find_parent_outputs(node_id, broker_type)
-                if candidates:
-                    _bnode_id, _dist, outputs = candidates[0]
-                    broker_connection = outputs.get("connection")
-                    if broker_connection:
-                        context.log(
-                            "debug",
-                            f"MarketStatusNode: broker_connection resolved from "
-                            f"{broker_type}/{_bnode_id} (distance={_dist})",
-                            node_id,
-                        )
-                        break
-
-        if not broker_connection:
-            raise ConnectionError(
-                "MarketStatusNode: BrokerNode 연결이 필요합니다. "
-                "OverseasStockBrokerNode / OverseasFuturesBrokerNode / "
-                "KoreaStockBrokerNode 중 아무거나 상위에 배치하세요."
-            )
-
-        # 2. LS 로그인 (broker 와 동일 instance 재사용)
-        # 🔐 자격증명은 시크릿 저장소에서 — `connection` 출력에는 더 이상 싣지 않는다.
-        appkey, appsecret, paper_trading = _resolve_broker_credentials(broker_connection, context)
-        paper_trading = bool(paper_trading)
-        broker_product = broker_connection.get("product", "overseas_stock")
-
-        ls, success, error = ensure_ls_login(
-            appkey, appsecret, paper_trading, context, node_id, broker_product,
-            caller_name="MarketStatusNode",
-        )
-        if not success:
-            raise ConnectionError(f"MarketStatusNode LS login failed: {error}")
-
-        # 3. Common.real() — broker WSS 와 독립된 공용 세션
-        from programgarden_finance.ls.common import Common
-
-        common = Common(token_manager=ls.token_manager)
-        real = common.real()
-        await real.connect()
-        context.log(
-            "info",
-            f"JIF WebSocket connected via Common.real (paper_trading={paper_trading})",
-            node_id,
-        )
-
-        # 4. 구독 설정
-        markets_filter = config.get("markets", []) or []
-        stay_connected = bool(config.get("stay_connected", True))
-        include_extended = bool(config.get("include_extended_hours", False))
-        trigger_nodes = config.get("_trigger_on_update_nodes", [])
-
-        jif = real.JIF()
-        loop = asyncio.get_running_loop()
-
-        # Track subscription for cleanup (registered even for stay_connected=False
-        # so that an error between subscribe and unsubscribe still gets cleaned up)
-        sub_key = f"{context.job_id}::{node_id}"
-        MarketStatusNodeExecutor._active_subscriptions[sub_key] = {
-            "jif": jif,
-            "real": real,
-            "stay_connected": stay_connected,
-        }
-
-        def _is_open(market: str) -> bool:
-            flag = context.is_market_open(market, include_extended=include_extended)
-            return bool(flag) if flag is not None else False
-
-        def _compute_conv_booleans() -> Dict[str, bool]:
-            conv: Dict[str, bool] = {}
-            for market, port_name in self._SOLO_MARKET_PORTS:
-                conv[port_name] = _is_open(market)
-            for port_name, am_key, pm_key in self._COMBO_MARKET_PORTS:
-                conv[port_name] = bool(_is_open(am_key) or _is_open(pm_key))
-            return conv
-
-        def on_jif_message(resp):
-            """JIFRealResponse 수신 콜백 — cache/output/notification 일괄 갱신."""
-
-            try:
-                if context.is_shutdown:
-                    return
-                body = getattr(resp, "body", None)
-                if body is None:
-                    # ACK payload (rsp_cd only). Ignore.
-                    return
-
-                jangubun = str(getattr(body, "jangubun", "") or "")
-                jstatus = str(getattr(body, "jstatus", "") or "")
-                if not jangubun:
-                    return
-
-                # Canonical market key + open-state derivations (core 레이어)
-                from programgarden_core.nodes.market_status import (
-                    JANGUBUN_TO_MARKET,
-                    is_extended_open,
-                    is_regular_open,
-                )
-                from programgarden_finance.ls.common.real.JIF.constants import (
-                    resolve_jstatus,
-                )
-
-                market = JANGUBUN_TO_MARKET.get(jangubun, jangubun)
-
-                # markets 필터 (설정됐으면 구독 자체가 서버측 제약은 아니므로
-                # 여기서 클라이언트 필터링 적용)
-                if markets_filter and market not in markets_filter:
-                    return
-
-                status_info = resolve_jstatus(jstatus)
-                reg_open = is_regular_open(jstatus)
-                ext_open = is_extended_open(jstatus)
-
-                new_status = {
-                    "market": market,
-                    "jangubun": jangubun,
-                    "jstatus": jstatus,
-                    "jstatus_label": status_info["label"],
-                    "is_regular_open": reg_open,
-                    "is_extended_open": ext_open,
-                    "is_open": ext_open if include_extended else reg_open,
-                    "updated_at": datetime.now().isoformat(),
-                }
-
-                # 이전 상태 조회 (transition 감지용)
-                prev_status = context.get_market_status(market)
-                prev_jstatus = prev_status.get("jstatus") if prev_status else None
-                prev_label = prev_status.get("jstatus_label") if prev_status else None
-                is_transition = prev_jstatus is not None and prev_jstatus != jstatus
-
-                # Cache update
-                context.update_market_status(market, new_status)
-
-                # Output update — 바인딩 리졸버가 이 값을 읽음
-                all_statuses = list(context.get_all_market_statuses().values())
-                outputs = {
-                    "statuses": all_statuses,
-                    "event": {
-                        "market": market,
-                        "jstatus": jstatus,
-                        "jstatus_label": status_info["label"],
-                        "prev_jstatus": prev_jstatus,
-                        "prev_jstatus_label": prev_label,
-                        "transitioned_at": new_status["updated_at"],
-                    },
-                    **_compute_conv_booleans(),
-                }
-
-                for port_name, port_value in outputs.items():
-                    context.set_output(node_id, port_name, port_value)
-
-                # SSE broadcast
-                asyncio.run_coroutine_threadsafe(
-                    context.notify_output_update(
-                        node_id=node_id,
-                        node_type="MarketStatusNode",
-                        outputs=outputs,
-                    ),
-                    loop,
-                )
-
-                # 전이 notification (prev != new)
-                if is_transition:
-                    asyncio.run_coroutine_threadsafe(
-                        context.send_notification(
-                            category=NotificationCategory.SCHEDULE_STARTED,
-                            severity=NotificationSeverity.INFO,
-                            title=f"Market status change: {market}",
-                            message=(
-                                f"{market}: {prev_label or prev_jstatus} → "
-                                f"{status_info['label']} "
-                                f"(jstatus {prev_jstatus} → {jstatus})"
-                            ),
-                            node_id=node_id,
-                            node_type="MarketStatusNode",
-                            data={
-                                "market": market,
-                                "jangubun": jangubun,
-                                "prev_jstatus": prev_jstatus,
-                                "jstatus": jstatus,
-                                "jstatus_label": status_info["label"],
-                                "is_regular_open": reg_open,
-                                "is_extended_open": ext_open,
-                            },
-                        ),
-                        loop,
-                    )
-
-                # Trigger downstream nodes
-                if trigger_nodes:
-                    asyncio.run_coroutine_threadsafe(
-                        context.emit_event(
-                            event_type="market_status",
-                            source_node_id=node_id,
-                            data=outputs,
-                            trigger_nodes=trigger_nodes,
-                        ),
-                        loop,
-                    )
-            except Exception as e:
-                context.log("warning", f"JIF message parse error: {e}", node_id)
-
-        jif.on_jif_message(on_jif_message)
-        context.log(
-            "info",
-            f"JIF subscription started "
-            f"(markets={markets_filter or 'all 12'}, "
-            f"stay_connected={stay_connected}, "
-            f"include_extended_hours={include_extended})",
-            node_id,
-        )
-
-        # One-shot 모드: 5초 대기 → 수신된 이벤트 반영 후 해제
-        if not stay_connected:
-            wait_timeout = 5.0
-            check_interval = 0.1
-            deadline = loop.time() + wait_timeout
-            while loop.time() < deadline:
-                if context.get_all_market_statuses():
-                    break
-                await asyncio.sleep(check_interval)
-
-            try:
-                jif.on_remove_jif_message()
-            except Exception:
-                pass
-            MarketStatusNodeExecutor._active_subscriptions.pop(sub_key, None)
-            try:
-                await real.close()
-            except Exception:
-                pass
-
-        # 초기/최종 output (stay_connected=True 에서는 현재까지 수신된 snapshot,
-        # False 에서는 해제 직전 snapshot 을 그대로 반환)
-        initial_statuses = list(context.get_all_market_statuses().values())
-        initial_outputs: Dict[str, Any] = {
-            "statuses": initial_statuses,
-            "event": None,
-            **_compute_conv_booleans(),
-        }
-        for port_name, port_value in initial_outputs.items():
-            context.set_output(node_id, port_name, port_value)
-
-        return initial_outputs
-
 
 class DisplayNodeExecutor(NodeExecutorBase):
     """
@@ -12574,7 +12228,7 @@ class HistoricalDataNodeExecutor(NodeExecutorBase):
                 "interval": config.get("interval", "1d"),
             }
         
-        # 기간 설정 ({{ today_yyyymmdd() }}, {{ days_ago_yyyymmdd(100) }} 바인딩 사용)
+        # 기간 설정 ({{ date.today(format='yyyymmdd') }}, {{ date.ago(100, format='yyyymmdd') }} 바인딩 사용)
         start_date = config.get("start_date", "")
         end_date = config.get("end_date", "")
         interval = config.get("interval", "1d")  # 1d, 1w, 1m, 1min 등
@@ -20670,10 +20324,6 @@ class WorkflowExecutor:
             # Data nodes
             "SQLiteNode": SQLiteNodeExecutor(),
             "CodeNode": CodeNodeExecutor(),  # custom Python code (subprocess-isolated)
-            # External market data nodes (credential 불필요, 외부 API)
-            "CurrencyRateNode": GenericNodeExecutor(),
-            # Market Status (JIF, broker credential type 무관)
-            "MarketStatusNode": MarketStatusNodeExecutor(),
             # AI nodes
             "LLMModelNode": LLMModelNodeExecutor(),
             "AIAgentNode": AIAgentNodeExecutor(),
@@ -21775,8 +21425,6 @@ class WorkflowJob:
         finally:
             # Cleanup broker fill subscriptions (SDK 콜백 해제)
             await self._cleanup_broker_fill_subscriptions()
-            # Cleanup MarketStatusNode JIF subscriptions
-            await self._cleanup_jif_subscriptions()
             # Cleanup persistent nodes (shutdown flag 설정 + 구독 해제 + WebSocket close)
             await self.context.cleanup_persistent_nodes()
             # Cleanup listeners
@@ -21932,7 +21580,7 @@ class WorkflowJob:
                     config["_source_node_id"] = edge.from_node_id
                     break  # 첫 번째 상위 노드만 사용
             
-            # Resolve expressions in config ({{ input.xxx }}, {{ nodeId.port }})
+            # Resolve expressions in config ({{ input.xxx }}, {{ nodes.nodeId.port }})
             config = self._resolve_config_expressions(config, node_id)
 
             # Auto-inject connection from matching BrokerNode (Phase 5)
@@ -22349,7 +21997,7 @@ class WorkflowJob:
     # 브로커/외부 API 제한**을 모델링한 것이라, 호출 자체가 없는 dry_run 모의 노드에는
     # 순수 낭비다 — 실측: 모의 주문 16건 × 5초 = 75초가 60초 빌드 타임아웃을 넘겼다
     # (prod 대화 f2eed93c, 2026-08-28). dry_run 에서도 **실제 호출하는** 노드
-    # (HTTPRequestNode 1초·CurrencyRateNode 30초)는 이 집합에 넣지 말 것 — 간격을 지켜야 한다.
+    # (HTTPRequestNode 1초)는 이 집합에 넣지 말 것 — 간격을 지켜야 한다.
     DRY_RUN_SIMULATED_NODE_TYPES = frozenset({
         # 주문 — NewOrderNodeExecutor / ModifyOrderNodeExecutor / CancelOrderNodeExecutor
         "OverseasStockNewOrderNode", "OverseasStockModifyOrderNode", "OverseasStockCancelOrderNode",
@@ -23653,7 +23301,8 @@ class WorkflowJob:
 
         지원 표현식:
         - {{ input.xxx }}: 워크플로우 inputs 파라미터
-        - {{ nodeId.port }}: 이전 노드 출력값
+        - {{ nodes.nodeId.port }}: 이전 노드 출력값 (`nodes.` 접두사 필수 — 접두사 없는
+          `{{ nodeId.port }}` 는 정의되지 않은 변수 오류)
         - {{ context.xxx }}: 실행 컨텍스트 값
 
         Note: items 키는 제외 (ConditionNode의 _process_items_with_extract에서 별도 처리).
@@ -24280,14 +23929,6 @@ class WorkflowJob:
         except Exception as e:
             logger.warning(f"Failed to cleanup broker fill subscriptions: {e}")
 
-    async def _cleanup_jif_subscriptions(self) -> None:
-        """MarketStatusNode의 JIF 구독 SDK 콜백 정리."""
-        try:
-            ms_executor = MarketStatusNodeExecutor()
-            await ms_executor.cleanup_jif_subscriptions(self.job_id)
-        except Exception as e:
-            logger.warning(f"Failed to cleanup JIF subscriptions: {e}")
-
     async def stop(self) -> None:
         """Stop execution gracefully"""
         logger.info(f"Stopping job {self.job_id}")
@@ -24318,7 +23959,6 @@ class WorkflowJob:
         # 리밋·불필요 호출 유발). cleanup_* 는 끝에서 딕셔너리를 비우므로 _run 의 정상완료
         # 경로가 먼저 정리했더라도 여기서 다시 불려도 빈 순회 = no-op(멱등).
         await self._cleanup_broker_fill_subscriptions()
-        await self._cleanup_jif_subscriptions()
         await self.context.cleanup_persistent_nodes()
         await self.context.cleanup_flow_end_nodes()
 
@@ -24357,7 +23997,6 @@ class WorkflowJob:
 
         # Cleanup
         await self._cleanup_broker_fill_subscriptions()
-        await self._cleanup_jif_subscriptions()
         await self.context.cleanup_persistent_nodes()
         await self.context.cleanup_flow_end_nodes()
 
@@ -24422,7 +24061,6 @@ class WorkflowJob:
 
         # 모든 리소스 정리
         await self._cleanup_broker_fill_subscriptions()
-        await self._cleanup_jif_subscriptions()
         await self.context.cleanup_persistent_nodes()
         await self.context.cleanup_flow_end_nodes()
 

{programgarden-2.2.0 → programgarden-2.4.0}/programgarden/replay_events.py

@@ -128,7 +128,13 @@ async def replay_events(job, runner, fixture, outcome):
             if now != expected:
                 raise ContractViolation(source_id, "Recorded tick is not the next configured cron instant")
             count = schedule_counts.get(source_id, 0) + 1
-            if count > config.get("count", 1000) or (now - origin).total_seconds() > config.get("max_duration_hours", 24.0) * 3600:
+            # count / max_duration_hours are optional (None/absent = unbounded,
+            # run until the workflow is stopped). Only enforce a bound that was set.
+            cfg_count = config.get("count")
+            cfg_max_dur = config.get("max_duration_hours")
+            if (cfg_count is not None and count > cfg_count) or (
+                cfg_max_dur is not None and (now - origin).total_seconds() > cfg_max_dur * 3600
+            ):
                 raise ContractViolation(source_id, "Recorded ticks exceed schedule safety limits")
             schedule_instants[source_id], schedule_counts[source_id] = now, count
         else:

{programgarden-2.2.0 → programgarden-2.4.0}/programgarden/replay_external.py

@@ -111,8 +111,13 @@ def request_identity(node_type, config):
         raise ContractViolation("request", "Invalid resolved recording request", "REPLAY_FIXTURE_INVALID") from exc
     # Reject unknown parameters instead of letting BaseModel's extra policy
     # silently remove a field the live executor may consume.
-    if set(config) - set(node_class.model_fields) - {"connection"} - _SCHEDULER_FIELDS - _PRESENTATION_FIELDS:
-        raise ContractViolation("request", "Unknown recording request fields", "REPLAY_FIXTURE_INVALID")
+    unknown = sorted(set(config) - set(node_class.model_fields) - {"connection"} - _SCHEDULER_FIELDS - _PRESENTATION_FIELDS)
+    if unknown:
+        # Name the keys: a builder that wrote `fields: ["price"]` on a market-data node
+        # (dev 5d9961de, 2026-09-25) retried the same config twice on the bare message.
+        accepted = sorted(set(node_class.model_fields) - _PRESENTATION_FIELDS - {"id", "type", "name", "description", "position", "category"})
+        raise ContractViolation("request", "Unknown recording request fields: " + ", ".join(unknown)
+                                + " (" + node_type + " accepts: " + ", ".join(accepted) + ")", "REPLAY_FIXTURE_INVALID")
     result = node.model_dump(mode="json", exclude=_PRESENTATION_FIELDS | _SCHEDULER_FIELDS | {"connection"})
     connection = config.get("connection")
     if connection is not None:

{programgarden-2.2.0 → programgarden-2.4.0}/programgarden/replay_semantics.py

@@ -349,8 +349,9 @@ def _time_rules(node_type: str, role: str) -> List[Dict[str, Any]]:
             {"id": "timezone_iana", "field": "timezone",
              "default": "America/New_York", "invalid": "replay_rejects"},
             {"id": "disabled_emits_nothing", "field": "enabled"},
-            {"id": "limits", "count": {"default": 1000, "min": 1},
-             "max_duration_hours": {"default": 24.0, "gt": 0}, "pin": "range_not_const"},
+            {"id": "limits", "optional": True, "absent_means": "unbounded",
+             "count": {"default": None, "min": 1},
+             "max_duration_hours": {"default": None, "gt": 0}, "pin": "range_not_const"},
         ]
     if node_type == "SessionGateNode":
         return [{"id": "evaluate_at_fixture_instant"}]   # validation_replay.py:276-283
@@ -607,8 +608,10 @@ def _schedule_time_lines(lines: List[str]) -> None:
     lines.append("A recorded tick must equal the cron's next firing instant after "
                  "the prior frame in this timezone: a whole minute, at least one "
                  "minute later.")
-    lines.append("count and max_duration_hours are safety limits (defaults 1000 and "
-                 "24.0); a contract bounds them with a range, never a const.")
+    lines.append("count and max_duration_hours are optional safety limits; omit both "
+                 "and the schedule runs until the workflow is stopped. When provided, "
+                 "count must be >= 1 and max_duration_hours > 0, and a contract bounds "
+                 "them with a range, never a const.")
     lines.append("Set the cron time in the target market's timezone. Market "
                  "operating hours by product:")
     pe = product_execution()

{programgarden-2.2.0 → programgarden-2.4.0}/programgarden/replay_sources.py

@@ -4,13 +4,12 @@ These records are scenario assumptions, not evidence of provider availability.
 The independent suite owns the inputs. No adapter reads a live file or transport.
 """
 from copy import deepcopy
-from pathlib import PurePosixPath
 
 from programgarden.replay_contracts import ContractViolation, check_contract
 from programgarden.replay_external import external_record
 from programgarden.replay_triggers import fixture_instant
 
-SOURCE_NODES = frozenset({"FileReaderNode", "FearGreedIndexNode", "MarketUniverseNode",
+SOURCE_NODES = frozenset({"MarketUniverseNode",
     "FuturesContractNode", "ScreenerNode", "OverseasFuturesOrderableQuantityNode"})
 
 
@@ -30,16 +29,6 @@ def source_contract_catalog():
             "type": "array", "items": {"type": "object", "properties": {
                 "google": {"type": "string"}, "currency": {"type": "string"}}}}}}
     return {
-        "FearGreedIndexNode": {"source_schema": {"type": "object", "required": ["fear_and_greed"],
-            "properties": {"fear_and_greed": {"type": "object", "required": ["score"], "properties": {
-                "score": {"type": "number", "minimum": 0, "maximum": 100},
-                "previous_close": {"type": "number"}}}}},
-            "notes": "Native parser maps score to value/label and reads previous_close. Synthetic inputs only."},
-        "FileReaderNode": {"source_schema": {"type": "object", "properties": {"files": {
-            "type": "object", "additionalProperties": {"type": "string"}}}},
-            "notes": "files maps each requested relative upload path to base64 encoded bytes. The native "
-                     "format parser reads those bytes; do not supply parsed data. Inline file_data uses "
-                     "native configuration. Absolute paths and parent traversal are forbidden."},
         "MarketUniverseNode": {"source_schema": {"type": "object", "required": ["index", "stocks"],
             "properties": {"index": {"type": "string"}, "stocks": {"type": "array", "items": stock}}},
             "index_mapping": dict(MarketUniverseNodeExecutor.INDEX_MAPPING),
@@ -92,33 +81,6 @@ async def execute_source(node, config, fixture, context):
     source = deepcopy(record["source"])
     if not isinstance(source, dict):
         raise ContractViolation(node.id, "Source envelope must be an object")
-    if node.type == "FearGreedIndexNode":
-        check_contract(source, {"type": "object", "required": ["fear_and_greed"], "properties": {
-            "fear_and_greed": {"type": "object", "required": ["score"], "properties": {
-                "score": {"type": "number", "minimum": 0, "maximum": 100}}}}}, node.id)
-        return node.parse_response(source)
-    if node.type == "FileReaderNode":
-        # Materialize the exact recorded bytes through the native base64 path.
-        # Preserve format/name selection; never read /app/data or a host path.
-        paths, data, names = node._normalize_inputs()
-        files = source.get("files", {})
-        for index, path in enumerate(paths):
-            if not path:
-                continue
-            parsed = PurePosixPath(path)
-            if parsed.is_absolute() or ".." in parsed.parts:
-                raise ContractViolation(node.id, "Replay file paths must stay relative to the upload directory")
-            if path not in files or not isinstance(files[path], str):
-                raise ContractViolation(node.id, "Requested file has no recorded bytes", "REPLAY_FIXTURE_REQUIRED")
-            while len(data) <= index:
-                data.append("")
-            while len(names) <= index:
-                names.append("")
-            data[index] = files[path]
-            names[index] = names[index] or PurePosixPath(path).name
-        local = node.model_copy(update={"file_paths": [], "file_path": None,
-            "file_data_list": data, "file_data": None, "file_names": names, "file_name": None})
-        return await local.execute(context)
     if node.type == "MarketUniverseNode":
         from programgarden.executor import MarketUniverseNodeExecutor
         executor = MarketUniverseNodeExecutor()

{programgarden-2.2.0 → programgarden-2.4.0}/programgarden/replay_triggers.py

@@ -49,8 +49,13 @@ async def schedule_startup(node, config, context):
         ZoneInfo(node.timezone)
     except (ValueError, KeyError):
         raise ContractViolation(node.id, "Invalid schedule timezone") from None
-    if node.count < 1 or node.max_duration_hours <= 0:
-        raise ContractViolation(node.id, "Schedule safety limits must be positive")
+    # count / max_duration_hours are optional (None = unbounded, run until the
+    # workflow is stopped). Only a provided value is bounded (count >= 1,
+    # max_duration_hours > 0).
+    if (node.count is not None and node.count < 1) or (
+        node.max_duration_hours is not None and node.max_duration_hours <= 0
+    ):
+        raise ContractViolation(node.id, "Schedule safety limits must be positive when set")
     proxy = _StartupContext(context)
     try:
         return await ScheduleNodeExecutor().execute(node.id, node.type, config, proxy)

{programgarden-2.2.0 → programgarden-2.4.0}/programgarden/validation_recommender.py

@@ -72,7 +72,6 @@ ACCOUNT_NODES: Set[str] = {
 EXTERNAL_API_NODES: Set[str] = {
     "HTTPRequestNode",
     "TelegramNode",
-    "FearGreedIndexNode",
 }
 
 AGGREGATE_NODES: Set[str] = {"AggregateNode", "FieldMappingNode", "ConditionNode", "SplitNode"}

{programgarden-2.2.0 → programgarden-2.4.0}/programgarden/validation_replay.py

@@ -39,7 +39,7 @@ FIXTURE_NODES = frozenset({
     for kind in ("Broker", "Account", "RealAccount", "MarketData", "HistoricalData",
                  "Fundamental", "SymbolQuery", "OpenOrders", "RealMarketData", "RealOrderEvent")
     if not (product == "OverseasFutures" and kind == "Fundamental")
-}) | {"HTTPRequestNode", "LLMModelNode", "AIAgentNode", "MarketStatusNode", "CurrencyRateNode", "TelegramNode"}
+}) | {"HTTPRequestNode", "LLMModelNode", "AIAgentNode", "TelegramNode"}
 
 
 def content_hash(value: Any) -> str:
@@ -251,6 +251,19 @@ class ReplayExecutor(WorkflowExecutor):
                         raise ContractViolation(node_id,"Completion evidence requires an existing request and broker observation node")
                     self.orders.apply_events(record["order_events"], node_type)
                 output = deepcopy(record["output"])
+                if isinstance(output, dict):
+                    # The live executor returns its ports in declaration order and the
+                    # auto-iteration fallback source is a node's FIRST output; a recording
+                    # written as {"count": 1, "open_orders": [...]} must not make replay pick
+                    # `count` where live picks the list (dev 5d9961de, 2026-09-25).
+                    from programgarden_core import NodeTypeRegistry
+                    try:
+                        declared = [port["name"] for port in NodeTypeRegistry().get_schema(node_type).outputs]
+                    except Exception:  # noqa: BLE001 — unknown schema keeps the recorded order
+                        declared = []
+                    ordered = {name: output[name] for name in declared if name in output}
+                    ordered.update({k: v for k, v in output.items() if k not in ordered})
+                    output = ordered
                 check_contract(output, record["contract"], f"{node_id}.output")
                 if node_type.endswith("OpenOrdersNode"):
                     # The snapshot SHAPE (unique non-empty order_ids, count == rows)

{programgarden-2.2.0 → programgarden-2.4.0}/pyproject.toml

@@ -5,7 +5,7 @@ authors = [
 homepage = "https://programgarden.com"
 requires-python = ">=3.12"
 name = "programgarden"
-version = "2.2.0"
+version = "2.4.0"
 license = "AGPL-3.0-or-later"
 description = "ProgramGarden - 노드 기반 자동매매 DSL 실행 엔진"
 readme = "README.md"
@@ -36,9 +36,9 @@ litellm = ">=1.40.0"
 # 로 통째 실패한다(1.35.1 의 조용한 TypeError 보다 강한 모듈 로드 실패).
 # (1.26.0 이후로도 context.py 는 WorkflowPnLEvent(**event_data) 에 personal_metrics
 #  를 무조건 실으므로 그 하한 근거도 이 상한에 포함된다.)
-programgarden-core = "^2.2.0"
+programgarden-core = "^2.4.0"
 programgarden-finance = "^2.0.1"
-programgarden-community = "^2.1.0"
+programgarden-community = "^2.2.0"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^8.0.0"