programgarden 2.6.7__tar.gz → 2.7.0__tar.gz

{programgarden-2.6.7 → programgarden-2.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: programgarden
-Version: 2.6.7
+Version: 2.7.0
 Summary: ProgramGarden - 노드 기반 자동매매 DSL 실행 엔진
 License-Expression: AGPL-3.0-or-later
 Author: 프로그램동산
@@ -15,9 +15,9 @@ 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.3.1,<3.0.0)
-Requires-Dist: programgarden-core (>=2.6.3,<3.0.0)
-Requires-Dist: programgarden-finance (>=2.0.5,<3.0.0)
+Requires-Dist: programgarden-community (>=2.3.2,<3.0.0)
+Requires-Dist: programgarden-core (>=2.7.0,<3.0.0)
+Requires-Dist: programgarden-finance (>=2.0.6,<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.1,<3.0.0)

{programgarden-2.6.7 → programgarden-2.7.0}/programgarden/database/workflow_position_tracker.py

@@ -2725,7 +2725,7 @@ class WorkflowPositionTracker:
         with sqlite3.connect(self.db_path) as conn:
             cursor = conn.cursor()
             cursor.execute("""
-                SELECT order_no, order_date, symbol, exchange, side, quantity
+                SELECT order_no, order_date, symbol, exchange, side, quantity, product
                 FROM workflow_orders
                 WHERE trading_mode = ? AND (price = 0 OR price IS NULL)
                 ORDER BY created_at DESC
@@ -2739,6 +2739,7 @@ class WorkflowPositionTracker:
                     "exchange": row[3],
                     "side": row[4],
                     "quantity": row[5],
+                    "product": row[6],
                 }
                 for row in cursor.fetchall()
             ]

{programgarden-2.6.7 → programgarden-2.7.0}/programgarden/deep_fixtures.py

@@ -79,7 +79,8 @@ def _config_symbols(config: Dict[str, Any]) -> Any:
 _FIXTURE_BARS = 64
 
 
-def _ohlcv_series(symbol: str, *, n: int = _FIXTURE_BARS, base: float = 100.0) -> List[Dict[str, Any]]:
+def _ohlcv_series(symbol: str, *, n: int = _FIXTURE_BARS, base: float = 100.0,
+                  minute_step: Optional[int] = None) -> List[Dict[str, Any]]:
     """Build a deterministic OHLCV series for one symbol (oldest bar first).
 
     The close path rises for the first ~⅔ of the window then declines into the
@@ -93,6 +94,9 @@ def _ohlcv_series(symbol: str, *, n: int = _FIXTURE_BARS, base: float = 100.0) -
     price = base
     for i in range(n):
         day = _FIXTURE_ANCHOR + timedelta(days=i)
+        if minute_step:
+            # Minute bars carry YYYYMMDDHHMMSS stamps, like the live g3203/o3103 rows.
+            day = _FIXTURE_ANCHOR.replace(hour=9, minute=30) + timedelta(minutes=i * minute_step)
         # Rise toward the peak, then ease back down — a gentle mean-reverting arc.
         if i <= peak:
             price = base + i * 0.8
@@ -101,7 +105,7 @@ def _ohlcv_series(symbol: str, *, n: int = _FIXTURE_BARS, base: float = 100.0) -
         price = max(price, base * 0.5)
         bars.append(
             {
-                "date": day.strftime("%Y%m%d"),
+                "date": day.strftime("%Y%m%d%H%M%S" if minute_step else "%Y%m%d"),
                 "open": round(price - 0.5, 2),
                 "high": round(price + 1.0, 2),
                 "low": round(price - 1.0, 2),
@@ -112,7 +116,8 @@ def _ohlcv_series(symbol: str, *, n: int = _FIXTURE_BARS, base: float = 100.0) -
     return bars
 
 
-def _time_series_entries(config: Dict[str, Any], symbols_raw: Any = None) -> List[Dict[str, Any]]:
+def _time_series_entries(config: Dict[str, Any], symbols_raw: Any = None,
+                         minute_step: Optional[int] = None) -> List[Dict[str, Any]]:
     """Build the per-symbol ``{symbol, exchange, time_series:[bars]}`` list that
     HistoricalDataNode emits at runtime. Downstream ConditionNode auto-iterates
     this list, so each entry must carry the keys its ``items.extract`` reads
@@ -125,7 +130,7 @@ def _time_series_entries(config: Dict[str, Any], symbols_raw: Any = None) -> Lis
             {
                 "symbol": entry["symbol"],
                 "exchange": entry["exchange"],
-                "time_series": _ohlcv_series(entry["symbol"], base=100.0 + idx * 10),
+                "time_series": _ohlcv_series(entry["symbol"], base=100.0 + idx * 10, minute_step=minute_step),
             }
         )
     return entries
@@ -179,7 +184,8 @@ def market_data_fixture(config: Dict[str, Any], symbols_raw: Any = None, *, prod
     return {"values": values}
 
 
-def historical_data_fixture(config: Dict[str, Any], symbols_raw: Any = None) -> Dict[str, Any]:
+def historical_data_fixture(config: Dict[str, Any], symbols_raw: Any = None, *,
+                            minute_step: Optional[int] = None) -> Dict[str, Any]:
     """HistoricalDataNode deep fixture.
 
     Real shape (executor.py ``HistoricalDataNodeExecutor.execute`` return):
@@ -195,7 +201,7 @@ def historical_data_fixture(config: Dict[str, Any], symbols_raw: Any = None) ->
     """
     if symbols_raw is None:
         symbols_raw = config.get("symbol") or _config_symbols(config)
-    entries = _time_series_entries(config, symbols_raw)
+    entries = _time_series_entries(config, symbols_raw, minute_step=minute_step)
     single = entries[0] if len(entries) == 1 else None
     return {
         "value": single,

{programgarden-2.6.7 → programgarden-2.7.0}/programgarden/executor.py

@@ -1012,6 +1012,12 @@ class LSClientManager:
             (ls_instance, success: bool, error_message: str | None)
         """
         from programgarden_finance import LS
+        from programgarden_finance.ls.replay_transport import active_transport, replay_client
+
+        # Offline replay (ls_tape) only: a client whose REST TRs are answered from
+        # the recording. No login, no token provider, never cached or reused.
+        if active_transport() is not None:
+            return replay_client(paper_trading), True, None
         
         # 이미 해당 product의 인스턴스가 있고 로그인된 경우
         if product in cls._instances:
@@ -1102,6 +1108,54 @@ def _resolve_broker_credentials(
     return appkey, appsecret, paper_trading
 
 
+FUTURES_FILL_PRICE_LOOKBACK_DAYS = 1  # today and the previous local day
+
+
+def _futures_fill_price_memo(context: Any) -> Dict[str, Any]:
+    """Per-run memory of the futures fill-price recovery (kept on the context)."""
+    memo = getattr(context, "_futures_fill_price_memo", None)
+    if not isinstance(memo, dict):
+        memo = {"attempted": set(), "failures": 0}
+        try:
+            setattr(context, "_futures_fill_price_memo", memo)
+        except Exception:
+            pass
+    return memo
+
+
+def _futures_fill_price_candidates(orders: Any, context: Any) -> Dict[str, Dict[str, Any]]:
+    """Unpriced futures orders worth one CIDBQ01800 read, by order date.
+
+    Keeps orders of a futures product (rows without a product are kept: the
+    caller already chose the product), dated today or yesterday, with a broker
+    order number, that this run has not looked up yet.
+    """
+    from datetime import date, timedelta
+    from programgarden_finance.ls.overseas_futureoption.extension.execution_history import (
+        normalize_broker_identity,
+    )
+
+    today = date.today()
+    window = {
+        (today - timedelta(days=days)).strftime("%Y%m%d")
+        for days in range(FUTURES_FILL_PRICE_LOOKBACK_DAYS + 1)
+    }
+    attempted = _futures_fill_price_memo(context)["attempted"]
+    wanted: Dict[str, Dict[str, Any]] = {}
+    for order in orders or []:
+        if not isinstance(order, Mapping):
+            continue
+        product = order.get("product")
+        if product is not None and product not in FUTURES_PRODUCTS:
+            continue
+        identity = normalize_broker_identity(order.get("order_no"))
+        order_date = str(order.get("order_date") or "")
+        if not identity or order_date not in window or (order_date, identity) in attempted:
+            continue
+        wanted.setdefault(order_date, {})[identity] = order
+    return wanted
+
+
 def ensure_ls_login(
     appkey: str,
     appsecret: str,
@@ -5582,7 +5636,20 @@ class BrokerNodeExecutor(NodeExecutorBase):
             orders_without_price = context.get_workflow_orders_without_fill_price()
             if not orders_without_price:
                 return
-            
+            if product == "overseas_futures":
+                # Bounded (2.7.0): only today's/yesterday's futures orders that
+                # this run has not read yet. The broker node re-runs every
+                # scheduled cycle, and unpriced rows stay in the ledger forever
+                # (an order cancelled before any fill keeps price 0), so without
+                # this every cycle would log in and read again.
+                orders_without_price = [
+                    order
+                    for by_identity in _futures_fill_price_candidates(orders_without_price, context).values()
+                    for order in by_identity.values()
+                ]
+                if not orders_without_price:
+                    return
+
             context.log("info", f"Found {len(orders_without_price)} orders without fill price - syncing from history", node_id)
             
             from programgarden_finance import LS
@@ -5717,37 +5784,82 @@ class BrokerNodeExecutor(NodeExecutorBase):
         context: ExecutionContext,
         node_id: str,
     ) -> None:
-        """해외선물 체결내역에서 가격 동기화"""
+        """Recover missing futures fill prices from CIDBQ01800 order rows.
+
+        Bounded, because the broker node re-runs every scheduled cycle and
+        starts this read again while unpriced rows stay in the ledger forever
+        (an order cancelled before any fill keeps price 0):
+
+        - only futures orders dated today or yesterday (local dates, the clock
+          the futures order path stamps the ledger with);
+        - each order is looked up at most once per run: one CIDBQ01800 read per
+          order date that has an unpriced order this run has not read yet, so
+          a new unpriced order on a date already read causes one more read;
+        - the first failed read of a run is a warning, later ones are debug.
+
+        A row supplies a price only for the same broker order — OvrsFutsOrdNo
+        compared as the integer identity, because CIDBQ01800 zero-pads it
+        ("0000000614") while the order TRs answer "614" — on the same symbol
+        when the ledger row has one, with an executed quantity and a positive
+        AbrdFutsExecPrc (LS paper 2026-10-15: ``ExecQty=1``,
+        ``AbrdFutsExecPrc="24114.00000000000"``). The stored order number and
+        date are written back unchanged.
+
+        Until 2.7.0 this called a method that does not exist, so every attempt
+        ended in a logged warning before any request and no price was ever
+        recovered.
+        """
         try:
-            from programgarden_finance import CIDBQ01800
-            
-            # 오늘 날짜 기준 체결내역 조회
-            today = datetime.now().strftime("%Y%m%d")
-            
-            response = ls.overseas_futureoption().accno().해외선물체결내역조회(
-                body=CIDBQ01800.CIDBQ01800InBlock(
-                    QryDt=today,
-                )
+            from programgarden_finance.ls.overseas_futureoption.accno.CIDBQ01800.blocks import (
+                CIDBQ01800InBlock1,
             )
-            result = await response.req_async()
-            
-            if not result or not hasattr(result, 'block1') or not result.block1:
+            from programgarden_finance.ls.overseas_futureoption.extension.execution_history import (
+                normalize_broker_identity,
+            )
+
+            wanted = _futures_fill_price_candidates(orders, context)
+            if not wanted:
                 return
-            
-            # 체결내역에서 주문번호별 가격 추출
+            memo = _futures_fill_price_memo(context)
+
+            accno = ls.overseas_futureoption().accno()
             fill_history = []
-            for item in result.block1:
-                fill_history.append({
-                    "order_no": str(getattr(item, 'OrdNo', '')),
-                    "order_date": today,
-                    "fill_price": float(getattr(item, 'ExecPrc', 0)),
-                })
-            
+            for order_date, by_identity in wanted.items():
+                # Mark before the read: a failed or empty answer is not retried
+                # by the next cycles of this run.
+                memo["attempted"].update((order_date, identity) for identity in by_identity)
+                result = await accno.CIDBQ01800(body=CIDBQ01800InBlock1(
+                    RecCnt=1, IsuCodeVal="", OrdDt=order_date, ThdayTpCode="",
+                    OrdStatCode="0", BnsTpCode="0", QryTpCode="1", OrdPtnCode="00",
+                    OvrsDrvtFnoTpCode="A",
+                )).req_async()
+                if getattr(result, "error_msg", None):
+                    level = "warning" if memo["failures"] == 0 else "debug"
+                    memo["failures"] += 1
+                    context.log(level, f"CIDBQ01800 fill price read failed ({order_date}): {result.error_msg}", node_id)
+                    continue
+                for row in getattr(result, "block2", None) or []:
+                    order = by_identity.get(normalize_broker_identity(getattr(row, "OvrsFutsOrdNo", None)))
+                    price = getattr(row, "AbrdFutsExecPrc", None)
+                    executed = getattr(row, "ExecQty", 0) or 0
+                    if (order is None or isinstance(price, bool) or not isinstance(price, (int, float))
+                            or not math.isfinite(price) or price <= 0 or executed <= 0):
+                        continue
+                    ledger_symbol = str(order.get("symbol") or "").strip().upper()
+                    row_symbol = str(getattr(row, "IsuCodeVal", "") or "").strip().upper()
+                    if ledger_symbol and row_symbol and ledger_symbol != row_symbol:
+                        continue
+                    fill_history.append({
+                        "order_no": order["order_no"],
+                        "order_date": order["order_date"],
+                        "fill_price": float(price),
+                    })
+
             if fill_history:
                 updated = context.sync_workflow_fill_prices_from_history(fill_history)
                 if updated > 0:
                     context.log("info", f"Synced {updated} order fill prices from futures history", node_id)
-                    
+
         except Exception as e:
             context.log("warning", f"Failed to sync futures fill prices: {e}", node_id)
     
@@ -12486,7 +12598,7 @@ class HistoricalDataNodeExecutor(NodeExecutorBase):
     HistoricalDataNode executor - 과거 OHLCV 데이터 조회
     
     LS Finance Chart API를 사용하여 과거 차트 데이터를 조회합니다.
-    - Overseas stock: g3204 (daily/weekly/monthly/yearly; no intraday)
+    - Overseas stock: g3204 (daily/weekly/monthly/yearly), g3203 (1/5/10/15/30/60-minute bars)
     - 해외선물: o3108 (일봉), o3103 (분봉)
     """
 
@@ -12512,10 +12624,12 @@ class HistoricalDataNodeExecutor(NodeExecutorBase):
         # The broker-specific fetch repeats this guard for direct/legacy callers.
         connection = config.get("connection")
         product = connection.get("product") if isinstance(connection, dict) else None
+        stock_minute_step = None
         if node_type == "OverseasStockHistoricalDataNode" or (
             node_type == "HistoricalDataNode" and product in (None, "overseas_stock")
         ):
-            self._stock_history_gubun(config.get("interval", "1d"))
+            tr_code, selector = self._stock_history_request(config.get("interval", "1d"))
+            stock_minute_step = selector if tr_code == "g3203" else None
         if node_type == "OverseasFuturesHistoricalDataNode" or (
             node_type == "HistoricalDataNode" and product in FUTURES_PRODUCTS
         ):
@@ -12536,7 +12650,7 @@ class HistoricalDataNodeExecutor(NodeExecutorBase):
                 _seed = _cfg_sym or _in_sym
             except Exception:
                 _seed = None
-            fixture = _df.historical_data_fixture(config, _seed)
+            fixture = _df.historical_data_fixture(config, _seed, minute_step=stock_minute_step)
             override = context.get_deep_fixture(node_id, node_type)
             return _df.apply_override(fixture, override)
 
@@ -12765,17 +12879,38 @@ class HistoricalDataNodeExecutor(NodeExecutorBase):
         # 파싱 실패 시 오늘 날짜 반환
         return datetime.now().strftime("%Y%m%d")
 
-    @staticmethod
-    def _stock_history_gubun(interval: str) -> str:
-        """Reject unsupported periods instead of relabeling daily bars."""
-        periods = {"1d": "2", "1w": "3", "1M": "4", "1Y": "5"}
-        if not isinstance(interval, str) or interval not in periods:
+    # LS g3204 period selectors (gubun) and g3203 bar sizes (ncnt, minutes).
+    # Every ncnt below answered rsp_cd 00000 with bars of exactly that step on a
+    # live platform call (2026-10-18, NVDA): 1, 5, 10, 15, 30 and 60.
+    STOCK_PERIOD_GUBUN = {"1d": "2", "1w": "3", "1M": "4", "1Y": "5"}
+    STOCK_MINUTE_NCNT = {"1m": 1, "5m": 5, "10m": 10, "15m": 15, "30m": 30, "60m": 60}
+
+    @classmethod
+    def _stock_history_request(cls, interval: str) -> tuple:
+        """``("g3204", gubun)`` for a period, ``("g3203", ncnt)`` for minute bars.
+
+        Unknown values are refused instead of relabeling daily bars.
+        """
+        if isinstance(interval, str) and interval in cls.STOCK_PERIOD_GUBUN:
+            return "g3204", cls.STOCK_PERIOD_GUBUN[interval]
+        if isinstance(interval, str) and interval in cls.STOCK_MINUTE_NCNT:
+            return "g3203", cls.STOCK_MINUTE_NCNT[interval]
+        raise ValueError(
+            "UNSUPPORTED_STOCK_HISTORY_INTERVAL: OverseasStockHistoricalDataNode "
+            "supports 1d, 1w, 1M and 1Y through LS g3204 and 1m, 5m, 10m, 15m, 30m "
+            "and 60m minute bars through LS g3203; select a supported interval explicitly."
+        )
+
+    @classmethod
+    def _stock_history_gubun(cls, interval: str) -> str:
+        """The g3204 period selector; minute intervals and unknown values are refused."""
+        tr_code, selector = cls._stock_history_request(interval)
+        if tr_code != "g3204":
             raise ValueError(
-                "UNSUPPORTED_STOCK_HISTORY_INTERVAL: OverseasStockHistoricalDataNode "
-                "supports 1d, 1w, 1M and 1Y through LS g3204. "
-                "Intraday g3203 is not supported; select a supported period explicitly."
+                "UNSUPPORTED_STOCK_HISTORY_INTERVAL: g3204 reads 1d, 1w, 1M and 1Y; "
+                f"{interval} is a g3203 minute interval."
             )
-        return periods[interval]
+        return selector
 
     async def _fetch_overseas_stock(
         self,
@@ -12789,7 +12924,7 @@ class HistoricalDataNodeExecutor(NodeExecutorBase):
         symbol_exchange_map: Dict[str, str] = None,
         symbols_raw: List[Dict[str, Any]] = None,
     ) -> List[Dict[str, Any]]:
-        """해외주식 차트 데이터 조회 (g3204)
+        """해외주식 차트 데이터 조회 (g3204 기간봉 / g3203 분봉)
         
         g3204 API 사용 (sdate, edate, qrycnt 지원):
         - g3103: date 기준 최근 30개만 반환 (제한적)
@@ -12799,7 +12934,9 @@ class HistoricalDataNodeExecutor(NodeExecutorBase):
         """
         
         # Validate before credential access or login, outside the soft-failure handler.
-        gubun = self._stock_history_gubun(interval)
+        tr_code, selector = self._stock_history_request(interval)
+        gubun = selector if tr_code == "g3204" else None
+        ncnt = selector if tr_code == "g3203" else None
 
         credential = context.get_credential()
         if not credential:
@@ -12808,6 +12945,7 @@ class HistoricalDataNodeExecutor(NodeExecutorBase):
         
         try:
             from programgarden_finance.ls.overseas_stock.chart.g3204.blocks import G3204InBlock
+            from programgarden_finance.ls.overseas_stock.chart.g3203.blocks import G3203InBlock
             
             ls, success, error = ensure_ls_login(
                 credential.get("appkey"),
@@ -12861,6 +12999,25 @@ class HistoricalDataNodeExecutor(NodeExecutorBase):
                     exchange = symbol_to_exchange.get(symbol) or exchcd_to_exchange.get(exchcd, "NASDAQ")
                     
                     keysymbol = f"{exchcd}{symbol}"
+
+                    if ncnt is not None:
+                        bars = await self._fetch_overseas_stock_minutes(
+                            api, G3203InBlock(
+                                delaygb="R",
+                                comp_yn="N",
+                                keysymbol=keysymbol,
+                                exchcd=exchcd,
+                                symbol=symbol,
+                                ncnt=ncnt,
+                                qrycnt=500,  # LS cap for an uncompressed page
+                                sdate=start_date,
+                                edate=end_date,
+                                cts_date="",
+                                cts_time="",
+                            ), symbol, context, node_id,
+                        )
+                        result_list.append({"symbol": symbol, "exchange": exchange, "time_series": bars})
+                        continue
                     
                     # g3204 API 사용 (sdate, edate, qrycnt 지원)
                     body = G3204InBlock(
@@ -12925,6 +13082,41 @@ class HistoricalDataNodeExecutor(NodeExecutorBase):
             context.log("error", f"Historical data fetch error: {e}", node_id)
             return self._empty_historical_result(symbols, f"i18n:errors.HISTORICAL_DATA_FETCH_ERROR|error={e}")
 
+    async def _fetch_overseas_stock_minutes(self, api, body, symbol: str, context, node_id: str) -> List[Dict[str, Any]]:
+        """Read one g3203 page of overseas-stock N-minute bars, oldest first.
+
+        LS answers the newest ``qrycnt`` bars at or before ``edate`` within
+        ``sdate..edate`` (observed 2026-10-18: ascending rows, ``tr_cont=Y`` when
+        older bars exist). This reads that first page only, like the futures
+        o3103 path: the requested range is not guaranteed to be complete.
+        ``date`` is ``YYYYMMDD`` + ``loctime`` (``YYYYMMDDHHMMSS``, the exchange
+        local time label exactly as LS returns it); ``volume`` is ``exevol``.
+        Bars outside the regular session are kept as LS returns them; no
+        completion or finality flag is added.
+        """
+        result = await api.chart().g3203(body=body).req_async()
+        if getattr(result, "error_msg", None):
+            context.log("warning", f"g3203 {symbol}: {result.error_msg}", node_id)
+            return []
+        bars = []
+        for item in result.block1 or []:
+            day = getattr(item, "date", "") or ""
+            clock = getattr(item, "loctime", "") or ""
+            bars.append({
+                "date": f"{day}{clock}" if day and clock else day,
+                "open": float(item.open) if item.open else 0,
+                "high": float(item.high) if item.high else 0,
+                "low": float(item.low) if item.low else 0,
+                "close": float(item.close) if item.close else 0,
+                "volume": int(item.exevol) if item.exevol else 0,
+            })
+        bars.sort(key=lambda x: x["date"])
+        if not bars:
+            context.log("warning", f"No minute data for {symbol}", node_id)
+        else:
+            context.log("debug", f"Fetched {len(bars)} g3203 bars for {symbol} (ncnt={body.ncnt})", node_id)
+        return bars
+
     async def _fetch_overseas_futures(
         self,
         symbols: List[str],

{programgarden-2.6.7 → programgarden-2.7.0}/programgarden/replay_external.py

@@ -176,10 +176,54 @@ def source_recording(node_type, config, source, contract, *, as_of, item=None):
     return result
 
 
+def per_item_key(node_type, item):
+    """The key of one per-item recording in ``record["items"]``.
+
+    A symbol item is keyed ``EXCHANGE:SYMBOL`` (a domestic node's item without
+    an exchange is ``KRX:SYMBOL``, as the domestic schemas accept ``{symbol}``).
+    Any other item (a position row without an exchange, a number, a text, a
+    nested object) is keyed by its ``content_hash``. Recording authors use this
+    function so the worker and the author compute the same key.
+    """
+    from programgarden.validation_replay import content_hash
+    if isinstance(item, dict) and isinstance(item.get("symbol"), str) and item["symbol"]:
+        exchange = item.get("exchange")
+        if not exchange and node_type.startswith("KoreaStock"):
+            exchange = "KRX"
+        if isinstance(exchange, str) and exchange:
+            return exchange + ":" + item["symbol"]
+    return content_hash(item)
+
+
+def branch_item(context, config):
+    """``(split_id, index, item)`` for a node running inside a SplitNode branch, else None.
+
+    The branch runner passes ``_branch_scope = "<split_id>#<index>"`` in the
+    node config and publishes the whole array once on the split's ``items``
+    port before the first item runs. The item is read from that array by index,
+    never from the split's ``item`` port or ``_split_context`` state: parallel
+    branches overwrite those single slots while another item is still running.
+    """
+    scope = config.get("_branch_scope") if isinstance(config, dict) else None
+    if not isinstance(scope, str) or "#" not in scope:
+        return None
+    split_id, _, raw_index = scope.rpartition("#")
+    try:
+        index = int(raw_index)
+    except ValueError:
+        return None
+    items = context.get_output(split_id, "items")
+    if not isinstance(items, list) or not 0 <= index < len(items):
+        raise ContractViolation(split_id, "The split item of this branch is not available",
+                                "REPLAY_FIXTURE_REQUIRED")
+    return split_id, index, items[index]
+
+
 def external_record(fixture, node_id, node_type, config, context):
     record = fixture.get("nodes", {}).get(node_id)
     if not isinstance(record, dict):
         raise ContractViolation(node_id, "An explicit external recording is required", "REPLAY_FIXTURE_REQUIRED")
+    expected_item = None
     if context._iteration_total:
         item = context._iteration_item
         if not isinstance(item, dict) or not isinstance(item.get("symbol"), str) or not item["symbol"]:
@@ -191,6 +235,21 @@ def external_record(fixture, node_id, node_type, config, context):
         if not isinstance(exchange, str) or not exchange:
             raise ContractViolation(node_id, "An overseas recording requires exchange identity", "REPLAY_FIXTURE_REQUIRED")
         record = record.get("items", {}).get(exchange + ":" + item["symbol"])
+        expected_item = item
+    elif isinstance(record.get("items"), dict):
+        # A per-item group inside a SplitNode branch (a basket): select this
+        # item's recording. A flat recording (no "items") keeps its meaning: one
+        # request identity for every item, with no item bound (item null).
+        branch = branch_item(context, config)
+        if branch is None:
+            raise ContractViolation(node_id, "A per-item recording runs only for an iterated or split item",
+                                    "REPLAY_FIXTURE_REQUIRED")
+        split_id, index, expected_item = branch
+        key = per_item_key(node_type, expected_item)
+        record = record["items"].get(key)
+        if not isinstance(record, dict):
+            raise ContractViolation(node_id, f"No recording for split item {key} ({split_id}#{index})",
+                                    "REPLAY_FIXTURE_REQUIRED", {"split": split_id, "index": index, "key": key})
     if not isinstance(record, dict):
         raise ContractViolation(node_id, "No matching per-item recording", "REPLAY_FIXTURE_REQUIRED")
     if "request" not in record or "as_of" not in record or "item" not in record:
@@ -211,7 +270,7 @@ def external_record(fixture, node_id, node_type, config, context):
         raise ContractViolation(node_id, _mismatch_message(
             "Recording does not match the shared replay clock", ["as_of"]),
             "REPLAY_FIXTURE_MISMATCH", detail)
-    item = context._iteration_item if context._iteration_total else None
+    item = expected_item
     if content_hash(record["item"]) != content_hash(item):
         detail = mismatch_detail(record["item"], item)
         raise ContractViolation(node_id, _mismatch_message(

programgarden-2.7.0/programgarden/replay_responders.py

@@ -0,0 +1,148 @@
+"""Request-independent responders: answers built for the request the node actually makes.
+
+Some external nodes bind values that exist only at run time (a price a CodeNode
+computes, an order result, an AI prompt built from indicators), so no recording
+made before execution can match their request. A responder recording answers
+whatever request the node resolves, through the node's real parser, and is
+labelled a scenario assumption (``ReplayResult.assumptions``), never broker or
+provider evidence::
+
+    {"kind": "responder", "as_of": "<fixture clock>", ...}
+
+- ``TelegramNode``: renders the message exactly as the live node would, never
+  sends it, returns ``{"sent": True, "message_id": "replay-N"}`` and appends
+  ``{node_id, text, parse_mode}`` to ``ReplayResult.outbox``.
+- ``LLMModelNode``: the live executor's non-secret ``connection`` output
+  (no credential is read; ``api_key`` stays ``None``).
+- ``AIAgentNode``: ``answer`` (or ``answers`` keyed by
+  ``replay_external.per_item_key`` of the iterated/split item) is the raw text a
+  model would write; the live parser (``output_format``/``output_schema``,
+  presets applied) produces ``response``. No model is called.
+- ``OverseasFuturesOrderableQuantityNode``: ``orderable_quantity`` (an integer
+  >= 0) is the scenario's stated capacity. A CIDBQ01400 response echoing the
+  ACTUAL resolved request is built and read by the live parser.
+"""
+from __future__ import annotations
+
+from decimal import Decimal
+import json
+from typing import Any, Dict
+
+from programgarden.replay_contracts import ContractViolation
+
+RESPONDER_NODES = frozenset({"TelegramNode", "LLMModelNode", "AIAgentNode",
+                             "OverseasFuturesOrderableQuantityNode"})
+_PROMPT_PREVIEW = 2000
+
+
+def _check_clock(node_id: str, record: Dict[str, Any], context) -> None:
+    if not context.validation_as_of or record.get("as_of") != context.validation_as_of:
+        raise ContractViolation(node_id, "Recording does not match the shared replay clock; differs at as_of",
+                                "REPLAY_FIXTURE_MISMATCH", {"recorded": {"as_of": record.get("as_of")},
+                                "resolved": {"as_of": context.validation_as_of}, "differing": ["as_of"]})
+
+
+def _current_item(node_type: str, config: Dict[str, Any], context):
+    """(found, item) of the iteration or split branch this execution runs for."""
+    from programgarden.replay_external import branch_item
+    if context._iteration_total:
+        return True, context._iteration_item
+    branch = branch_item(context, config)
+    return (True, branch[2]) if branch is not None else (False, None)
+
+
+def _telegram(runner, node_id, config, context, record):
+    template = config.get("template") or ""
+    # Same text rule as TelegramNode.execute (no render_template on the engine context).
+    text = template if isinstance(template, str) and template.strip() else "ProgramGarden notification"
+    outbox = runner.outcome.outbox
+    outbox.append({"node_id": node_id, "text": text, "parse_mode": "HTML",
+                   "scope": config.get("_branch_scope")})
+    return {"sent": True, "message_id": f"replay-{len(outbox)}"}
+
+
+def _llm_model(runner, node_id, config, context, record):
+    return {"connection": {
+        "provider": config.get("provider", "openai"), "model": config.get("model", "gpt-4o"),
+        "api_key": None, "_llm_node_id": node_id, "base_url": config.get("base_url"),
+        "organization": config.get("organization"), "api_version": config.get("api_version"),
+        "temperature": config.get("temperature", 0.7), "max_tokens": config.get("max_tokens", 1000),
+        "seed": config.get("seed"), "streaming": config.get("streaming", False)}}
+
+
+def _ai_agent(runner, node_id, config, context, record):
+    from programgarden.executor import AIAgentNodeExecutor
+    from programgarden.replay_external import per_item_key
+
+    if "answers" in record:
+        found, item = _current_item("AIAgentNode", config, context)
+        answers = record["answers"]
+        key = per_item_key("AIAgentNode", item) if found else None
+        if not isinstance(answers, dict) or key not in answers:
+            raise ContractViolation(node_id, f"No responder answer for item {key}", "REPLAY_FIXTURE_REQUIRED")
+        raw = answers[key]
+    elif "answer" in record:
+        raw = record["answer"]
+    else:
+        raise ContractViolation(node_id, "An AI responder needs answer or answers", "REPLAY_FIXTURE_INVALID")
+    if not isinstance(raw, str):
+        raise ContractViolation(node_id, "A responder answer is the raw text a model writes",
+                                "REPLAY_FIXTURE_INVALID")
+    preset = config.get("preset")
+    if preset and preset != "custom":
+        from programgarden_core.presets import PresetLoader
+        config = PresetLoader.apply_preset(preset, config)
+    parsed = AIAgentNodeExecutor()._parse_output(
+        raw, config.get("output_format", "text"), config.get("output_schema"), context, node_id)
+    prompt = config.get("user_prompt", "")
+    if not isinstance(prompt, str):
+        prompt = json.dumps(prompt, ensure_ascii=False, default=str)
+    runner.outcome.assumptions.append({"node_id": node_id, "kind": "responder", "node_type": "AIAgentNode",
+                                       "prompt_preview": prompt[:_PROMPT_PREVIEW],
+                                       "label": record.get("label")})
+    return {"response": parsed}
+
+
+def _orderable_quantity(runner, node_id, config, context, record):
+    from programgarden.futures_orderable import (
+        FuturesCapacityEvidenceError, build_orderable_request, read_orderable_quantity)
+    from programgarden_finance.ls.overseas_futureoption.accno.CIDBQ01400.blocks import CIDBQ01400Response
+
+    quantity = record.get("orderable_quantity")
+    if isinstance(quantity, bool) or not isinstance(quantity, int) or quantity < 0:
+        raise ContractViolation(node_id, "orderable_quantity must be an integer >= 0", "REPLAY_FIXTURE_INVALID")
+    try:
+        request = build_orderable_request(config)
+    except FuturesCapacityEvidenceError as exc:
+        raise ContractViolation(node_id, str(exc), "REPLAY_CONTRACT_FAILED") from exc
+    echo = request.model_dump()
+    echo["OvrsDrvtOrdPrc"] = str(Decimal(str(echo["OvrsDrvtOrdPrc"])))  # LS echoes price as text
+    response = CIDBQ01400Response.model_validate({
+        "header": None, "block1": {**echo, "AcntNo": ""}, "block2": {"RecCnt": 1, "OrdAbleQty": quantity},
+        "status_code": 200, "rsp_cd": "00000", "rsp_msg": "scenario answer", "error_msg": None})
+    try:
+        value = read_orderable_quantity(response, request)
+    except FuturesCapacityEvidenceError as exc:  # pragma: no cover - built to match
+        raise ContractViolation(node_id, str(exc), "REPLAY_CONTRACT_FAILED") from exc
+    runner.outcome.assumptions.append({"node_id": node_id, "kind": "responder",
+                                       "node_type": "OverseasFuturesOrderableQuantityNode",
+                                       "request": {"symbol": echo["IsuCodeVal"], "side": echo["BnsTpCode"],
+                                                   "price": echo["OvrsDrvtOrdPrc"]},
+                                       "orderable_quantity": quantity, "label": record.get("label")})
+    return {"quantity": value, "verified": True, "error": None}
+
+
+_RESPONDERS = {"TelegramNode": _telegram, "LLMModelNode": _llm_model, "AIAgentNode": _ai_agent,
+               "OverseasFuturesOrderableQuantityNode": _orderable_quantity}
+
+
+def respond(runner, node_id: str, node_type: str, config: Dict[str, Any], context,
+            record: Dict[str, Any]) -> Dict[str, Any]:
+    _check_clock(node_id, record, context)
+    handler = _RESPONDERS.get(node_type)
+    if handler is None:
+        raise ContractViolation(node_id, "No responder for this node type", "REPLAY_CAPABILITY_BLOCKED")
+    if node_type == "TelegramNode":
+        runner.outcome.assumptions.append({"node_id": node_id, "kind": "responder", "node_type": node_type,
+                                           "note": "message collected in outbox, not sent"})
+    return handler(runner, node_id, config, context, record)

programgarden-2.7.0/programgarden/replay_tape.py

@@ -0,0 +1,182 @@
+"""Replay LS REST read nodes through their real executors over recorded HTTP answers.
+
+A recording ``{"kind": "ls_tape", "as_of": ..., "tape": [entry, ...]}`` lets the
+validation worker run the node's own executor and the finance TR parser over
+scenario answers. Each entry is one recorded HTTP answer::
+
+    {"tr": "COSOQ00201",                          # LS tr_cd
+     "request": {"COSOQ00201InBlock1": {...}},    # the JSON body the node sends
+     "ignore": ["COSOQ00201InBlock1.BaseDt"],     # optional: paths not compared
+     "tr_cont": "N", "tr_cont_key": "",           # optional continuation header
+     "status": 200,                               # optional, default 200
+     "headers": {"tr_cont": "N"},                 # optional response headers
+     "json": {"rsp_cd": "00000", ...}}            # the response body
+
+A request is answered by the first entry with the same ``tr``, continuation
+header and body (exactly, apart from the listed ``ignore`` paths, which exist
+for request fields the executor fills from the wall clock, such as a query
+date). A request no entry answers fails the node with
+``REPLAY_FIXTURE_REQUIRED`` naming the TR. Order TRs, token issuance and token
+reissue are refused (``REPLAY_CAPABILITY_BLOCKED``). The node never sees a
+credential: it reads a non-secret placeholder, and its LS client is a fresh
+replay client with no login (``programgarden_finance.ls.replay_transport``).
+
+Tape answers are scenario assumptions written by the suite author, never broker
+evidence. Realtime (websocket) nodes and order nodes are not tape nodes.
+"""
+from __future__ import annotations
+
+from copy import deepcopy
+import json
+from typing import Any, Dict, List, Optional
+
+from programgarden.replay_contracts import ContractViolation
+
+TAPE_NODES = frozenset({
+    f"{product}{kind}Node"
+    for product in ("OverseasStock", "OverseasFutures", "KoreaStock")
+    for kind in ("Account", "MarketData", "HistoricalData", "Fundamental", "SymbolQuery", "OpenOrders")
+    if not (product == "OverseasFutures" and kind == "Fundamental")
+}) | {"KoreaStockRankingNode", "OverseasStockRankingNode", "FuturesContractNode",
+      "OverseasFuturesContractInfoNode", "OverseasFuturesOrderableQuantityNode"}
+
+_DEFAULT_HEADERS = {"Content-Type": "application/json; charset=utf-8", "tr_cont": "N", "tr_cont_key": ""}
+_MAX_REPORTED = 8
+
+
+def _canon(value: Any) -> str:
+    return json.dumps(value, sort_keys=True, ensure_ascii=False, separators=(",", ":"), allow_nan=False)
+
+
+def _without(body: Any, paths: List[str]) -> Any:
+    """``body`` with the dotted ``paths`` removed (a copy)."""
+    result = deepcopy(body)
+    for path in paths:
+        parts = path.split(".")
+        node = result
+        for part in parts[:-1]:
+            node = node.get(part) if isinstance(node, dict) else None
+        if isinstance(node, dict):
+            node.pop(parts[-1], None)
+    return result
+
+
+class LsTape:
+    """The installed replay transport of one tape node execution."""
+
+    def __init__(self, node_id: str, record: Dict[str, Any], paper_trading: bool):
+        entries = record.get("tape")
+        if not isinstance(entries, list) or not entries:
+            raise ContractViolation(node_id, "An ls_tape recording needs a non-empty tape list",
+                                    "REPLAY_FIXTURE_INVALID")
+        self.node_id = node_id
+        self.paper_trading = bool(paper_trading)
+        self.entries: List[Dict[str, Any]] = []
+        for index, entry in enumerate(entries):
+            where = f"{node_id}.tape[{index}]"
+            if not isinstance(entry, dict) or not isinstance(entry.get("tr"), str) or not entry["tr"]:
+                raise ContractViolation(where, "A tape entry needs its tr code", "REPLAY_FIXTURE_INVALID")
+            if not isinstance(entry.get("request"), dict) or not isinstance(entry.get("json"), dict):
+                raise ContractViolation(where, "A tape entry needs a request body and a json answer",
+                                        "REPLAY_FIXTURE_INVALID")
+            ignore = entry.get("ignore", [])
+            if not isinstance(ignore, list) or not all(isinstance(p, str) and p for p in ignore):
+                raise ContractViolation(where, "ignore must list dotted request paths", "REPLAY_FIXTURE_INVALID")
+            status = entry.get("status", 200)
+            if isinstance(status, bool) or not isinstance(status, int):
+                raise ContractViolation(where, "status must be an integer", "REPLAY_FIXTURE_INVALID")
+            _canon(entry["request"]), _canon(entry["json"])  # finite JSON only
+            self.entries.append(entry)
+        self.calls: List[Dict[str, Any]] = []
+        self.misses: List[Dict[str, Any]] = []
+        self.refusals: List[Dict[str, Any]] = []
+
+    # -- transport protocol (programgarden_finance.ls.replay_transport) ---------
+    def answer(self, tr_cd: str, url: str, header: Dict[str, Any], body: Dict[str, Any]):
+        from programgarden_finance.ls.replay_transport import ReplayTransportRefused
+
+        if url.rstrip("/").endswith("/order"):
+            self.refusals.append({"kind": "order", "tr": tr_cd})
+            raise ReplayTransportRefused(f"order TR {tr_cd} is not answered by a tape")
+        cont = (str(header.get("tr_cont") or "N"), str(header.get("tr_cont_key") or ""))
+        nearest: Optional[Dict[str, Any]] = None
+        for index, entry in enumerate(self.entries):
+            if entry["tr"] != tr_cd:
+                continue
+            if (str(entry.get("tr_cont", "N")), str(entry.get("tr_cont_key", ""))) != cont:
+                continue
+            ignore = entry.get("ignore", [])
+            if _canon(_without(body, ignore)) == _canon(_without(entry["request"], ignore)):
+                self.calls.append({"tr": tr_cd, "entry": index})
+                headers = {**_DEFAULT_HEADERS, "tr_cd": tr_cd, **(entry.get("headers") or {})}
+                return entry.get("status", 200), deepcopy(entry["json"]), headers
+            if nearest is None:
+                nearest = entry
+        from programgarden.replay_external import mismatch_detail
+        miss: Dict[str, Any] = {"tr": tr_cd, "tr_cont": cont[0]}
+        if nearest is not None:
+            miss.update(mismatch_detail(_without(nearest["request"], nearest.get("ignore", [])),
+                                        _without(body, nearest.get("ignore", []))))
+        self.misses.append(miss)
+        raise ReplayTransportRefused(f"no tape answer for TR {tr_cd}")
+
+    def refused(self, kind: str, detail: str) -> None:
+        self.refusals.append({"kind": kind, "detail": str(detail)[:200]})
+
+
+class _TapeContext:
+    """The replay context as a live read node sees it under a tape.
+
+    Live read paths run (no dry-run or deep-validation shortcut) and the node
+    reads a non-secret placeholder credential instead of the context secrets.
+    """
+
+    is_dry_run = False
+    is_deep_validate = False
+
+    def __init__(self, context, tape: LsTape):
+        object.__setattr__(self, "_context", context)
+        object.__setattr__(self, "_tape", tape)
+
+    def __getattr__(self, name):
+        return getattr(self._context, name)
+
+    def __setattr__(self, name, value):
+        setattr(self._context, name, value)
+
+    def get_credential(self, credential_id: str = "credential_id"):
+        return {"appkey": "REPLAY", "appsecret": "REPLAY", "paper_trading": self._tape.paper_trading}
+
+
+def _paper_trading(config: Dict[str, Any]) -> bool:
+    connection = config.get("connection")
+    return bool(connection.get("paper_trading")) if isinstance(connection, dict) else False
+
+
+async def execute_tape(runner, node_id: str, node_type: str, config: Dict[str, Any], context,
+                       record: Dict[str, Any], kwargs: Dict[str, Any]) -> Dict[str, Any]:
+    """Run the node's live executor with its LS REST TRs answered from ``record``."""
+    from programgarden.executor import WorkflowExecutor
+    from programgarden_finance.ls.replay_transport import use_replay_transport
+
+    if not context.validation_as_of or record.get("as_of") != context.validation_as_of:
+        raise ContractViolation(node_id, "Recording does not match the shared replay clock; differs at as_of",
+                                "REPLAY_FIXTURE_MISMATCH", {"recorded": {"as_of": record.get("as_of")},
+                                "resolved": {"as_of": context.validation_as_of}, "differing": ["as_of"]})
+    tape = LsTape(node_id, record, _paper_trading(config))
+    with use_replay_transport(tape):
+        output = await WorkflowExecutor.execute_node(runner, node_id, node_type, config,
+                                                     _TapeContext(context, tape), **kwargs)
+    if tape.refusals:
+        raise ContractViolation(node_id, "The node asked for a call a tape never makes: "
+                                + ", ".join(sorted({r["kind"] for r in tape.refusals})),
+                                "REPLAY_CAPABILITY_BLOCKED", {"refused": tape.refusals[:_MAX_REPORTED]})
+    if tape.misses:
+        trs = ", ".join(sorted({m["tr"] for m in tape.misses}))
+        first = tape.misses[0]
+        suffix = f"; differs at {', '.join(first['differing'][:6])}" if first.get("differing") else ""
+        raise ContractViolation(node_id, f"No ls_tape answer for TR {trs}{suffix}", "REPLAY_FIXTURE_REQUIRED",
+                                {"misses": tape.misses[:_MAX_REPORTED]})
+    runner.outcome.assumptions.append({"node_id": node_id, "kind": "ls_tape",
+                                       "trs": [call["tr"] for call in tape.calls][:32]})
+    return output

{programgarden-2.6.7 → programgarden-2.7.0}/programgarden/resolver.py

@@ -379,13 +379,13 @@ class WorkflowResolver:
                 continue
             result.add(build_error(
                 ErrorCode.INVALID_FIELD_ENUM,
-                "Stock historical intervals require a supported LS g3204 period; "
-                "intraday g3203 is not supported.",
+                "Stock historical intervals are 1d, 1w, 1M, 1Y (LS g3204) or the "
+                "1m, 5m, 10m, 15m, 30m, 60m minute bars (LS g3203).",
                 location=ErrorLocation(
                     node_id=node.get("id"), node_type=node_type, field_path="interval",
                 ),
                 available_values=field.enum_values,
-                suggestion="Choose 1d, 1w, 1M or 1Y explicitly; do not substitute daily bars for an intraday strategy.",
+                suggestion="Choose one of the listed intervals explicitly (60m, not 1h); do not substitute daily bars for an intraday strategy.",
             ))
 
     def _validate_futures_history_contract(self, workflow, registry, result) -> None:

{programgarden-2.6.7 → programgarden-2.7.0}/programgarden/validation_replay.py

@@ -115,6 +115,12 @@ class ReplayResult:
     # no events (or the main flow raised) — consumers then fall back to the final state.
     main_outputs: dict[str, Any] | None = None
     main_executed: list[str] | None = None
+    # Messages notification responders would have sent (never sent), in order:
+    # {node_id, text, parse_mode, scope}. Scenario output, not delivery evidence.
+    outbox: list[dict[str, Any]] = field(default_factory=list)
+    # Which nodes were answered by scenario assumptions (ls_tape, responder),
+    # so a reader never mistakes them for broker or provider evidence.
+    assumptions: list[dict[str, Any]] = field(default_factory=list)
 
     @property
     def initial_outputs(self) -> dict[str, Any]:
@@ -242,7 +248,28 @@ class ReplayExecutor(WorkflowExecutor):
             rules = self.fixture.get("contracts", {}).get(node_id, {})
             if "input" in rules:
                 check_contract(config, rules["input"], f"{node_id}.input")
-            if node_type in FIXTURE_NODES:
+            own_record = self.fixture.get("nodes", {}).get(node_id)
+            record_kind = own_record.get("kind") if isinstance(own_record, dict) else None
+            if record_kind == "ls_tape":
+                from programgarden.replay_tape import TAPE_NODES, execute_tape
+                if node_type not in TAPE_NODES:
+                    raise ContractViolation(node_id, "An ls_tape recording serves LS REST read nodes only",
+                                            "REPLAY_CAPABILITY_BLOCKED")
+                output = await execute_tape(self, node_id, node_type, config, context, own_record, kwargs)
+                if node_type.endswith("OpenOrdersNode") and isinstance(output, dict):
+                    # Same snapshot/book rules as a node-output recording.
+                    from programgarden.replay_order_adapter import check_open_orders_snapshot
+                    if self.orders is not None:
+                        self.orders.check_open_orders(output, node_type)
+                    else:
+                        check_open_orders_snapshot(output)
+            elif record_kind == "responder":
+                from programgarden.replay_responders import RESPONDER_NODES, respond
+                if node_type not in RESPONDER_NODES:
+                    raise ContractViolation(node_id, "No responder for this node type",
+                                            "REPLAY_CAPABILITY_BLOCKED")
+                output = respond(self, node_id, node_type, config, context, own_record)
+            elif node_type in FIXTURE_NODES:
                 from programgarden.replay_external import external_record
                 from programgarden.replay_order_adapter import check_open_orders_snapshot, check_order_events_shape
                 record = external_record(self.fixture, node_id, node_type, config, context)

{programgarden-2.6.7 → programgarden-2.7.0}/pyproject.toml

@@ -5,7 +5,7 @@ authors = [
 homepage = "https://programgarden.com"
 requires-python = ">=3.12"
 name = "programgarden"
-version = "2.6.7"
+version = "2.7.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.6.3"
-programgarden-finance = "^2.0.5"
-programgarden-community = "^2.3.1"
+programgarden-core = "^2.7.0"
+programgarden-finance = "^2.0.6"
+programgarden-community = "^2.3.2"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^8.0.0"