programgarden 1.37.6__tar.gz → 1.37.8__tar.gz

{programgarden-1.37.6 → programgarden-1.37.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: programgarden
-Version: 1.37.6
+Version: 1.37.8
 Summary: ProgramGarden - 노드 기반 자동매매 DSL 실행 엔진
 License-Expression: AGPL-3.0-or-later
 Author: 프로그램동산
@@ -96,12 +96,23 @@ Broker account trackers belong to the workflow job. Normal completion, `stop()`,
 account polling, and close each tracker's dedicated WebSocket. Late account PnL
 callbacks do not restart work after shutdown. This cleanup also covers partially
 initialized trackers and leaves other jobs running.
+Scheduled cycles reuse the same broker account tracker, including pending startup.
+A failed startup stops its tracker and closes its connection before a later cycle
+may try again; no immediate retry or extra workflow node is introduced.
 Already queued or in-flight PnL notifications have up to one second to finish
 after account trackers stop, before listeners close. On timeout, cleanup logs the
 pending count and cancels those tasks, allowing another 0.25 seconds for cancellation.
 A listener that suppresses cancellation is reported and remains tracked; it cannot
 hold job shutdown indefinitely. Delivery beyond this bounded grace is not guaranteed.
 
+Overseas-stock OpenOrdersNode treats the observed terminal COSAQ00102 `02679`
+empty envelope as `open_orders=[]` / `count=0` without an error. The echoed date,
+market and filters must match its current-day pending query, the empty detail
+array must be explicitly present, and continuation must be terminal. This follows
+the finance package's observed-response reference and StockAccountTracker;
+`02679` is not a generic success code. Missing, malformed, mismatched and failed
+reads retain `error` / `reason=fetch_failed` so workflows can block new entries.
+
 For one-shot workflows, an unhandled `order_result.success=False` returned directly
 by a main-flow node makes the final job status `failed` and emits `WORKFLOW_FAILED`.
 The original broker message remains in node diagnostics and the failure statistics.

{programgarden-1.37.6 → programgarden-1.37.8}/README.md

@@ -67,12 +67,23 @@ Broker account trackers belong to the workflow job. Normal completion, `stop()`,
 account polling, and close each tracker's dedicated WebSocket. Late account PnL
 callbacks do not restart work after shutdown. This cleanup also covers partially
 initialized trackers and leaves other jobs running.
+Scheduled cycles reuse the same broker account tracker, including pending startup.
+A failed startup stops its tracker and closes its connection before a later cycle
+may try again; no immediate retry or extra workflow node is introduced.
 Already queued or in-flight PnL notifications have up to one second to finish
 after account trackers stop, before listeners close. On timeout, cleanup logs the
 pending count and cancels those tasks, allowing another 0.25 seconds for cancellation.
 A listener that suppresses cancellation is reported and remains tracked; it cannot
 hold job shutdown indefinitely. Delivery beyond this bounded grace is not guaranteed.
 
+Overseas-stock OpenOrdersNode treats the observed terminal COSAQ00102 `02679`
+empty envelope as `open_orders=[]` / `count=0` without an error. The echoed date,
+market and filters must match its current-day pending query, the empty detail
+array must be explicitly present, and continuation must be terminal. This follows
+the finance package's observed-response reference and StockAccountTracker;
+`02679` is not a generic success code. Missing, malformed, mismatched and failed
+reads retain `error` / `reason=fetch_failed` so workflows can block new entries.
+
 For one-shot workflows, an unhandled `order_result.success=False` returned directly
 by a main-flow node makes the final job status `failed` and emits `WORKFLOW_FAILED`.
 The original broker message remains in node diagnostics and the failure statistics.

{programgarden-1.37.6 → programgarden-1.37.8}/programgarden/context.py

@@ -2865,6 +2865,19 @@ class ExecutionContext:
             logger.warning(f"Failed to update order fill price: {e}")
             return False
 
+    async def _annotate_workflow_fill_currency(self, *, currency: str, **fill_kwargs: Any) -> bool:
+        """Preserve post-refresh currency without replaying the AS1 execution."""
+        tracker = self._workflow_position_tracker
+        if tracker is None:
+            return False
+        fill_kwargs["fill_time"] = fill_kwargs.get("fill_time") or UNKNOWN_FILL_TIME
+        try:
+            return await tracker.annotate_fill_currency(currency=currency, **fill_kwargs)
+        except ValueError:
+            # Unusable/conflicting identity must never cause another fill write.
+            logger.warning("Cannot attach currency evidence to the retained execution")
+            return False
+
     async def record_workflow_fill(
         self,
         order_no: str,
@@ -2879,6 +2892,7 @@ class ExecutionContext:
         *,
         execution_id: Optional[str | int] = None,
         account_avg_price: Optional[float] = None,
+        currency: Optional[str] = None,
     ) -> str:
         """Record fill event for FIFO position tracking.
         
@@ -2904,6 +2918,7 @@ class ExecutionContext:
             execution_id: Optional broker execution number, preserved for durable replay detection.
             account_avg_price: Optional account average purchase price for this
                 symbol at fill time; only a workflow sell's residual tail uses it.
+            currency: Explicit broker unit at fill time; no product default.
 
         Returns:
             분류 결과: "workflow" | "manual" | "unknown_api" | "pending"
@@ -2976,6 +2991,8 @@ class ExecutionContext:
                 # 재시도에도 유지한다 — identity 축이 아니고, 매도 잔량 추정의
                 # 유일한 근거다.
                 base_kwargs["account_avg_price"] = account_avg_price
+            if currency is not None:
+                base_kwargs["currency"] = currency
 
             try:
                 result = await self._workflow_position_tracker.record_fill(

{programgarden-1.37.6 → programgarden-1.37.8}/programgarden/database/fill_reconciler.py

@@ -227,6 +227,7 @@ async def reconcile_workflow_fills(
                     # 빈 값이면 트래커가 '우리 주문과 일치하는가' 로만 분류한다.
                     commda_code="",
                     account_avg_price=avg_price,
+                    currency=hit.get("currency"),
                 )
             except Exception as exc:
                 report.errors.append(f"record_fill_failed[{order_no}]: {exc}")

{programgarden-1.37.6 → programgarden-1.37.8}/programgarden/database/workflow_position_tracker.py

@@ -183,6 +183,9 @@ class PendingFill:
     # read from the broker snapshot before it refreshes. Used only to estimate a
     # workflow sell's residual tail (see _process_sell_fifo); None → no estimate.
     account_avg_price: Optional[float] = None
+    # An explicit broker unit, never inferred from the product or exchange.
+    currency: Optional[str] = None
+    currency_conflict: bool = False
 
 
 class ExecutionIdentityError(ValueError):
@@ -535,6 +538,12 @@ class WorkflowPositionTracker:
             for column in ("execution_id", "normalized_order_no", "execution_payload"):
                 if column not in columns:
                     cursor.execute(f"ALTER TABLE trade_history ADD COLUMN {column} TEXT")
+            if "currency" not in columns:
+                cursor.execute("ALTER TABLE trade_history ADD COLUMN currency TEXT")
+            if "currency_conflict" not in columns:
+                cursor.execute(
+                    "ALTER TABLE trade_history ADD COLUMN currency_conflict INTEGER NOT NULL DEFAULT 0"
+                )
             # Additive columns for the account-average-price sell estimate. A
             # workflow sell that empties the strategy's own lots and still has a
             # tail records that tail here (the residual quantity, the account
@@ -722,6 +731,7 @@ class WorkflowPositionTracker:
         *,
         execution_id: Optional[str | int] = None,
         account_avg_price: Optional[float] = None,
+        currency: Optional[str] = None,
     ) -> str:
         """
         체결 기록 및 FIFO 처리
@@ -743,6 +753,8 @@ class WorkflowPositionTracker:
             account_avg_price: Optional account average purchase price for this
                 symbol at fill time. Only a workflow sell whose own lots run out
                 uses it, to estimate the residual tail. None → no estimate.
+            currency: Explicit broker currency for this fill. Missing/invalid
+                values remain unknown and never change fill identity or amounts.
             execution_id: Optional broker execution identity. Positive numeric
                 strings/integers ignore padding; opaque strings retain case.
                 None, blank, and zero mean no identity and retain legacy replay
@@ -765,6 +777,7 @@ class WorkflowPositionTracker:
             exchange=exchange, side=side, quantity=quantity, price=price,
             fill_time=fill_time, commda_code=commda_code, received_at=datetime.now(),
             execution_id=execution_id, account_avg_price=account_avg_price,
+            currency=self._currency_code(currency),
         )
         identity = self._execution_key(fill)
         notifications: list = []
@@ -879,6 +892,59 @@ class WorkflowPositionTracker:
             "commda_code": fill.commda_code,
         }
 
+    @staticmethod
+    def _currency_code(value: Any) -> Optional[str]:
+        if not isinstance(value, str):
+            return None
+        value = value.strip().upper()
+        return value if re.fullmatch(r"[A-Z]{3}", value) else None
+
+    async def annotate_fill_currency(self, *, currency: str, **fill_kwargs: Any) -> bool:
+        """Attach a contemporaneous broker unit to an exact retained execution.
+
+        Called after the existing AS1 account refresh, never to reconstruct old
+        history. No identity means no annotation. Check all canonical facts and
+        hold the ledger write lock, but do not create a fill, consume a lot, emit
+        another fill notification or alter the deduplication payload. Conflicting
+        units permanently make the unit unknown until separately investigated.
+        """
+        unit = self._currency_code(currency)
+        if unit is None or self.product != "overseas_stock":
+            return False
+        fill = PendingFill(**fill_kwargs, received_at=datetime.now(), currency=unit)
+        identity = self._execution_key(fill)
+        if identity is None:
+            return False
+        changed = False
+        async with self._buffer_lock:
+            for pending in self._pending_fills.values():
+                if self._execution_key(pending) == identity:
+                    self._assert_same_execution(pending, fill)
+                    if pending.currency_conflict or pending.currency == unit:
+                        return False
+                    pending.currency_conflict = pending.currency is not None
+                    pending.currency = None if pending.currency_conflict else unit
+                    return True
+            with sqlite3.connect(self.db_path) as conn:
+                conn.execute("BEGIN IMMEDIATE")
+                cursor = conn.cursor()
+                if self._find_execution(cursor, fill) is None:
+                    return False
+                where = """product=? AND provider=? AND trading_mode=? AND order_date=?
+                    AND normalized_order_no=? AND execution_id=?"""
+                stored, conflict = cursor.execute(
+                    f"SELECT currency, currency_conflict FROM trade_history WHERE {where}", identity
+                ).fetchone()
+                if not conflict and stored != unit:
+                    cursor.execute(
+                        f"UPDATE trade_history SET currency=?, currency_conflict=? WHERE {where}",
+                        (unit if stored is None else None, int(stored is not None), *identity),
+                    )
+                    changed = True
+            if changed:
+                self.fill_revision += 1
+        return changed
+
     def _assert_same_execution(self, previous: PendingFill, fill: PendingFill) -> None:
         if self._execution_facts(previous) != self._execution_facts(fill):
             raise ExecutionIdentityConflictError("Conflicting fill facts for an existing execution identity")
@@ -984,8 +1050,9 @@ class WorkflowPositionTracker:
                 (product, provider, order_no, order_date, symbol, exchange, side, quantity, price,
                  fill_datetime, classification, commda_code, realized_pnl, trading_mode, created_at,
                  execution_id, normalized_order_no, execution_payload,
-                 unmatched_qty, estimate_basis_price, estimate_source, estimated_pnl)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                 unmatched_qty, estimate_basis_price, estimate_source, estimated_pnl,
+                 currency, currency_conflict)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
             """, (
                 self.product, self.provider,
                 fill.order_no, fill.order_date, fill.symbol, fill.exchange,
@@ -996,6 +1063,8 @@ class WorkflowPositionTracker:
                 estimate["estimate_basis_price"] if estimate else None,
                 estimate["estimate_source"] if estimate else None,
                 estimate["estimated_pnl"] if estimate else None,
+                fill.currency,
+                int(fill.currency_conflict),
             ))
 
             conn.commit()
@@ -1960,8 +2029,9 @@ class WorkflowPositionTracker:
     def personal_metrics(self) -> Dict[str, Any]:
         """Read retained workflow executions without claiming account performance.
 
-        Historical FIFO rows have no currency or fee evidence. Keep their amounts
-        per symbol/exchange and reject mixed ownership or an incomplete FIFO basis.
+        Historical FIFO rows have no currency or fee evidence. New rows can carry
+        an explicit broker unit; old units are never backfilled. Keep amounts
+        per symbol/exchange and reject contradictory units or an incomplete basis.
         Futures FIFO is not a monetary ledger. No equity/MDD basis is inferred.
 
         Version 2 adds closed-trade outcomes. One closed trade = one sell fill,
@@ -1986,8 +2056,8 @@ class WorkflowPositionTracker:
         plus the estimated tail). Any other residual is an incomplete basis.
 
         Counts aggregate across symbols because a count carries no currency.
-        Amounts do not: with `currency` unproven per row, summing gross profit
-        across symbols would invent the very unit this method refuses to claim.
+        Amounts do not: the API may sum groups only when every group carries the
+        same explicit currency. Missing evidence never inherits an account unit.
         So gross amounts stay inside each group, and the top-level profit/loss
         ratio is published only when a single group carries the whole ledger —
         the one case where "the currency is the same" needs no evidence.
@@ -2025,6 +2095,8 @@ class WorkflowPositionTracker:
 
         realized = []
         for (symbol, exchange), fills in sorted(groups.items()):
+            units = {self._currency_code(fill.get("currency")) for fill in fills}
+            unit_conflict = any(fill.get("currency_conflict") for fill in fills)
             reason = None
             amount = None
             outcome = None
@@ -2036,6 +2108,9 @@ class WorkflowPositionTracker:
                 reason = "futures_fifo_not_monetary"
             elif not symbol:
                 reason = "missing_symbol"
+            elif len(units - {None}) > 1 or unit_conflict:
+                # Contradictory units cannot establish a comparable FIFO basis.
+                reason = "incomplete_fifo_basis"
             else:
                 # The old mixed_fifo_ownership pre-check is gone: a workflow sell
                 # now consumes only workflow lots, so it can never have realized a
@@ -2137,7 +2212,10 @@ class WorkflowPositionTracker:
                 status = "available"
                 basis = "fifo"
                 estimated_quantity = 0
-            entry = {"symbol": symbol, "exchange": exchange, "currency": None,
+            unit = (next(iter(units)) if len(units) == 1 and None not in units
+                    and not unit_conflict
+                    and self.product != "overseas_futures" else None)
+            entry = {"symbol": symbol, "exchange": exchange, "currency": unit,
                      "amount": amount, "status": status, "reason": reason,
                      "basis": basis, "estimated_quantity": estimated_quantity}
             # A rejected group publishes no outcome: its trades are unknown, and

{programgarden-1.37.6 → programgarden-1.37.8}/programgarden/executor.py

@@ -165,6 +165,24 @@ def _whole_unit_quantity(value: Any) -> Optional[int]:
     return int(number) if number.is_integer() else None
 
 
+def _stock_position_fill_currency(position: Any, symbol: str, market_code: str) -> Optional[str]:
+    """Use only explicitly populated COSOQ00201 position fields for this symbol.
+
+    AS1 has no currency. StockPositionItem defaults to USD, so a model default
+    is insufficient evidence. No quote currency or account-wide default is used.
+    """
+    from programgarden_finance.ls.overseas_stock.extension.models import StockPositionItem
+
+    if not isinstance(position, StockPositionItem):
+        return None
+    if not {"symbol", "market_code", "currency_code"} <= position.model_fields_set:
+        return None
+    if position.symbol != symbol or not market_code or position.market_code != market_code:
+        return None
+    unit = position.currency_code.strip().upper()
+    return unit if re.fullmatch(r"[A-Z]{3}", unit) else None
+
+
 def _usable_execution_identity(order_no: Any, order_date: Any) -> bool:
     """체결 프레임의 (주문번호, 주문일자)가 원장 execution identity 키로 쓸 수 있나.
 
@@ -4881,10 +4899,12 @@ class BrokerNodeExecutor(NodeExecutorBase):
                     # 읽는다. 캐시는 아직 이번 매도가 반영되기 전이라 '매도 직전 평단'.
                     # 캐시에 없으면 None → 추정 없음(오늘처럼 unavailable).
                     account_avg_price = None
+                    currency = None
                     if tracker_info and "tracker" in tracker_info:
                         acct_tracker = tracker_info["tracker"]
                         positions = getattr(acct_tracker, "_positions", None)
                         pos = positions.get(symbol) if isinstance(positions, dict) else None
+                        currency = _stock_position_fill_currency(pos, symbol, market_code)
                         buy_price = getattr(pos, "buy_price", None) if pos is not None else None
                         if buy_price is not None:
                             try:
@@ -4892,7 +4912,7 @@ class BrokerNodeExecutor(NodeExecutorBase):
                             except (TypeError, ValueError):
                                 account_avg_price = None
 
-                    await context.record_workflow_fill(
+                    fill_kwargs = dict(
                         order_no=order_no,
                         order_date=order_date,
                         symbol=symbol,
@@ -4912,12 +4932,20 @@ class BrokerNodeExecutor(NodeExecutorBase):
                         ),
                         account_avg_price=account_avg_price,
                     )
+                    await context.record_workflow_fill(currency=currency, **fill_kwargs)
 
                     # AccountTracker refresh로 PnL 이벤트 강제 트리거
                     if tracker_info and "tracker" in tracker_info:
                         tracker = tracker_info["tracker"]
                         if hasattr(tracker, 'refresh_now'):
                             await tracker.refresh_now()
+                            positions = getattr(tracker, "_positions", None)
+                            pos = positions.get(symbol) if isinstance(positions, dict) else None
+                            refreshed_currency = _stock_position_fill_currency(pos, symbol, market_code)
+                            if refreshed_currency is not None:
+                                await context._annotate_workflow_fill_currency(
+                                    currency=refreshed_currency, **fill_kwargs
+                                )
                             logger.debug(f"📊 AccountTracker refreshed after fill")
 
                 asyncio.run_coroutine_threadsafe(record_and_refresh(), loop)
@@ -5491,6 +5519,11 @@ class BrokerNodeExecutor(NodeExecutorBase):
         로그인이라, 더미 secret 으로 도는 기기(트레이앱 검증 잡·서버 발급 모드)의 실제 실행에서
         추적기만 403 으로 죽고 error 로그 뒤 추적 없이 진행됐다.
         """
+        tracker_key = f"{context.job_id}_{node_id}"
+        # Scheduled cycles revisit the broker. Keep its existing tracker (also
+        # while startup awaits connect) instead of orphaning polling/WS resources.
+        if context.is_shutdown or tracker_key in self._active_trackers:
+            return
         try:
             from programgarden_finance import LS
             
@@ -5527,6 +5560,18 @@ class BrokerNodeExecutor(NodeExecutorBase):
                 
         except Exception as e:
             context.log("error", f"Failed to start account tracking: {e}", node_id)
+            # Failed startup must not leave an unusable entry that prevents a
+            # later scheduled cycle from trying again. No immediate retry.
+            info = self._active_trackers.get(tracker_key)
+            if info is not None:
+                for resource, method in ((info.get("tracker"), "stop"), (info.get("real"), "close")):
+                    if resource is not None:
+                        try:
+                            await getattr(resource, method)()
+                        except Exception as cleanup_error:
+                            logger.warning("Account tracker startup cleanup failed: %s", type(cleanup_error).__name__)
+                if self._active_trackers.get(tracker_key) is info:
+                    self._active_trackers.pop(tracker_key)
     
     async def _start_overseas_stock_tracker(
         self,
@@ -6541,14 +6586,39 @@ class OpenOrdersNodeExecutor(NodeExecutorBase):
 
         rows = response.block3 or []
         usable_rows = [item for item in rows if item.OrdNo and item.OrdNo > 0]
-        # The SDK defaults a missing detail block to []; it is not empty-result
-        # evidence. Unknown codes remain unclassified, even with echo blocks.
-        valid_empty = (
+        # Match StockAccountTracker's observed pending-query envelope. The SDK
+        # defaults missing details to []; only an explicit empty array is evidence.
+        complete_empty = (
             not rows
-            and diagnostics["rsp_cd"] == "00000"
-            and getattr(response, "block1", None) is not None
-            and getattr(response, "block2", None) is not None
+            and "block3" in response.model_fields_set
+            and response.block1 is not None
+            and response.block2 is not None
         )
+        echo = response.block1
+        header = response.header
+        # 02679 is not a generic success code. This exact terminal response was
+        # observed for market 00 (echoed as %) and this current-day pending query;
+        # see finance/docs/observed_broker_responses.md (2026-09-09).
+        observed_no_data = (
+            complete_empty and status == 200 and diagnostics["rsp_cd"] == "02679"
+            and echo.OrdDt == today and echo.OrdMktCode == "%"
+            and echo.ThdayBnsAppYn == "1" and echo.BnsTpCode == "0"
+            and echo.CrcyCode == "000"
+            and all(
+                str(getattr(echo, name)) == expected
+                for name, expected in (
+                    ("QryTpCode", "1"), ("BkseqTpCode", "1"),
+                    ("IsuNo", ""), ("SrtOrdNo", "999999999"),
+                    ("ExecYn", "2"), ("LoanBalHldYn", "0"),
+                )
+                if name in echo.model_fields_set
+            )
+            and header is not None and header.tr_cont == "N"
+            and not header.tr_cont_key
+        )
+        valid_empty = complete_empty and (diagnostics["rsp_cd"] == "00000" or observed_no_data)
+        if diagnostics["rsp_cd"] == "02679" and not observed_no_data:
+            return unavailable()
         if not usable_rows and not valid_empty:
             return unavailable()
 
@@ -16963,9 +17033,11 @@ class NewOrderNodeExecutor(NodeExecutorBase):
                 p = float(getattr(item, "OvrsExecPrc", 0) or getattr(item, "OvrsOrdPrc", 0) or 0)
                 row = out.setdefault(order_no, {
                     "filled_qty": 0, "_amount": 0.0, "symbol": "", "fill_time": "",
+                    "_currencies": set(),
                 })
                 row["filled_qty"] += q
                 row["_amount"] += q * p
+                row["_currencies"].add(str(item.CrcyCode or "").strip().upper())
                 # 🔴 LS 는 TR 마다 같은 뜻의 필드 이름이 다르고, 이 블록에는 `ShtnIsuNo`
                 #    (단축종목번호)와 `IsuNo`(종목번호)가 **둘 다** 있다. 이 저장소의 관행은
                 #    ShtnIsuNo 우선·IsuNo 폴백이다(잔고·체결 파싱이 전부 그렇게 한다).
@@ -16981,6 +17053,9 @@ class NewOrderNodeExecutor(NodeExecutorBase):
             for row in out.values():
                 qty = row["filled_qty"]
                 row["avg_price"] = (row.pop("_amount") / qty) if qty > 0 else 0.0
+                units = row.pop("_currencies")
+                unit = next(iter(units)) if len(units) == 1 else ""
+                row["currency"] = unit if re.fullmatch(r"[A-Z]{3}", unit) else None
             return out
         except Exception as e:
             context.log("debug", f"COSAQ00102 batch fill query exception: {e}", node_id)

{programgarden-1.37.6 → programgarden-1.37.8}/pyproject.toml

@@ -5,7 +5,7 @@ authors = [
 homepage = "https://programgarden.com"
 requires-python = ">=3.12"
 name = "programgarden"
-version = "1.37.6"
+version = "1.37.8"
 license = "AGPL-3.0-or-later"
 description = "ProgramGarden - 노드 기반 자동매매 DSL 실행 엔진"
 readme = "README.md"