programgarden 1.34.0__tar.gz → 1.35.0__tar.gz

{programgarden-1.34.0 → programgarden-1.35.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: programgarden
-Version: 1.34.0
+Version: 1.35.0
 Summary: ProgramGarden - 노드 기반 자동매매 DSL 실행 엔진
 License-Expression: AGPL-3.0-or-later
 Author: 프로그램동산

{programgarden-1.34.0 → programgarden-1.35.0}/programgarden/context.py

@@ -2011,7 +2011,14 @@ class ExecutionContext:
                     "timestamp": now,
                     
                     # 워크플로우 기본 (전체)
+                    # 🔴 `.get(..., 0.0)` 의 기본값은 **키가 아예 없을 때만** 쓰인다.
+                    # 계산부는 값을 못 낼 때 키를 빼지 않고 `None` 을 담는다 — 그래서
+                    # None 이 그대로 흐른다. **키를 빼는 순간 0.0 이 되살아나** "모름" 이
+                    # 다시 "실측 0%" 가 된다. 계산부를 고칠 때 이 규약을 깨지 말 것.
                     "workflow_pnl_rate": base_workflow_result.get("workflow_pnl_rate", 0.0),
+                    "workflow_rate_unavailable_reason": base_workflow_result.get(
+                        "workflow_rate_unavailable_reason"
+                    ),
                     "workflow_eval_amount": base_workflow_result.get("workflow_eval_amount", 0.0),
                     "workflow_buy_amount": base_workflow_result.get("workflow_buy_amount", 0.0),
                     "workflow_pnl_amount": base_workflow_result.get("workflow_pnl_amount", 0.0),
@@ -2184,7 +2191,11 @@ class ExecutionContext:
             total_pnl_rate = ((total_eval - total_buy) / total_buy * 100) if total_buy > 0 else 0.0
             
             return {
-                "workflow_pnl_rate": 0.0,
+                # 🔴 트래커가 없다 = **어느 포지션이 이 워크플로우 것인지 판정할 근거가 0**.
+                # 종전엔 그 상태에서 `0.0` 을 발행해 "이 워크플로우는 0% 로 측정됐다" 로
+                # 읽히게 했다. 워크플로우 몫을 모르는 것이지 0인 게 아니다.
+                "workflow_pnl_rate": None,
+                "workflow_rate_unavailable_reason": "no_tracker",
                 "workflow_eval_amount": 0.0,
                 "workflow_buy_amount": 0.0,
                 "workflow_pnl_amount": 0.0,
@@ -2217,17 +2228,22 @@ class ExecutionContext:
                 start_date=start_date,  # 날짜 필터
             )
         except Exception as e:
-            logger.warning(f"calculate_workflow_pnl failed: {e}")
+            # 🔴 계산이 실패한 것을 **"수익률 0%" 라는 측정값**으로 바꿔 내보내던 자리다.
+            # 가장 조용한 거짓말 경로 — 예외를 삼키고 0 을 발행하면 아래 계층 어디에서도
+            # 실패였다는 사실을 알 수 없다. 비율은 None(모름), 금액만 0 으로 남긴다.
+            # (금액 0 은 "포지션 없음" 과 같은 모양이라 하류 합산을 깨지 않는다.)
+            logger.exception("calculate_workflow_pnl failed: %s", e)
             return {
-                "workflow_pnl_rate": 0.0,
+                "workflow_pnl_rate": None,
+                "workflow_rate_unavailable_reason": "computation_failed",
                 "workflow_eval_amount": 0.0,
                 "workflow_buy_amount": 0.0,
                 "workflow_pnl_amount": 0.0,
-                "other_pnl_rate": 0.0,
+                "other_pnl_rate": None,
                 "other_eval_amount": 0.0,
                 "other_buy_amount": 0.0,
                 "other_pnl_amount": 0.0,
-                "total_pnl_rate": 0.0,
+                "total_pnl_rate": None,
                 "total_eval_amount": 0.0,
                 "total_buy_amount": 0.0,
                 "total_pnl_amount": 0.0,
@@ -2596,6 +2612,7 @@ class ExecutionContext:
         commda_code: str = "40",
         *,
         execution_id: Optional[str | int] = None,
+        account_avg_price: Optional[float] = None,
     ) -> str:
         """Record fill event for FIFO position tracking.
         
@@ -2610,9 +2627,11 @@ class ExecutionContext:
             quantity: 체결 수량
             price: 체결 가격
             fill_time: 체결시각 (HHMMSSsss)
-            commda_code: 매체구분코드 ("40"=OPEN API, 기타=수동)
+            commda_code: 매체구분코드 (프레임 값 그대로; "40"=OPEN API, 기타=수동/HTS)
             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.
+
         Returns:
             분류 결과: "workflow" | "manual" | "unknown_api" | "pending"
         """
@@ -2622,6 +2641,8 @@ class ExecutionContext:
         
         try:
             identity_kwargs = {"execution_id": execution_id} if execution_id is not None else {}
+            if account_avg_price is not None:
+                identity_kwargs["account_avg_price"] = account_avg_price
             result = await self._workflow_position_tracker.record_fill(
                 order_no=order_no,
                 order_date=order_date,

{programgarden-1.34.0 → programgarden-1.35.0}/programgarden/database/workflow_position_tracker.py

@@ -87,12 +87,47 @@ class PendingFill:
     commda_code: str
     received_at: datetime
     execution_id: Optional[str | int] = None
+    # Account average purchase price for this symbol at the moment of the fill,
+    # 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
 
 
 class ExecutionIdentityConflictError(ValueError):
     """An explicit execution identity was replayed with different fill facts."""
 
 
+# LS 통신매체코드(CommdaCode / MdaCode) — 출처: src/finance/docs/cidbq02400_contract.md:74-77
+# "The published media map is 00=branch, 22=iPhone, 23=Android, 41=API, 43=Robo API,
+#  85=HTS, 96=final settlement, LP=loss cut, SK=CashCall and SO=conditional order.
+#  The example uses 40, which the table does not map. Preserve it as returned;
+#  do not classify it by guessing a nearby code."
+# '40' 은 표에 없지만 우리 OPEN API 주문이 실제로 받는 값이다(dev verified_fills 실측 4건 +
+# 2026-09-12 해외주식 AS1 실측: 우리 매도 주문 244 → 40) — 표의 41/43 과 함께 API 묶음으로 둔다.
+# 🔴 해외주식 AS1 실측(2026-09-12, 실계좌 NIO 1주씩): HTS → 85(표와 일치) · iPhone 투혼앱 → **51**
+# (표의 22 아님) · 투혼 웹 → **03**(표에 없음). 표는 해외선물 TR 문서라 해외주식 푸시와 앱/웹 코드가
+# 다르다. 관측된 값만 사람 채널에 추가한다 — 표에 없고 관측도 안 된 값은 여전히 "other".
+MEDIA_CODES_HUMAN = frozenset({"85", "22", "23", "00", "51", "03"})   # HTS · iPhone(표) · Android(표) · 지점 · 투혼앱(실측) · 투혼웹(실측)
+MEDIA_CODES_API = frozenset({"40", "41", "43"})                       # OPEN API(실측) · API · Robo API
+
+
+def media_channel(commda_code: str | None) -> str:
+    """Map a broker media code to "human" | "api" | "unknown" | "other".
+
+    unknown = blank/None (the frame said nothing); other = a code the published
+    table does not attribute to a person or an API client (96/LP/SK/SO …) or one
+    the table does not list at all. Neither is ever asserted to be a person.
+    """
+    code = (commda_code or "").strip()
+    if not code:
+        return "unknown"
+    if code in MEDIA_CODES_HUMAN:
+        return "human"
+    if code in MEDIA_CODES_API:
+        return "api"
+    return "other"
+
+
 class WorkflowPositionTracker:
     """
     워크플로우 포지션 FIFO 추적기
@@ -251,6 +286,19 @@ 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")
+            # 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
+            # average purchase price it was estimated against, the source label,
+            # and the estimated PnL). realized_pnl stays FIFO-matched only; these
+            # never enter _execution_facts / conflict detection. NULL on every
+            # row that carries no estimate (buys, fully matched sells, old rows).
+            for column, coltype in (("unmatched_qty", "REAL"),
+                                    ("estimate_basis_price", "REAL"),
+                                    ("estimate_source", "TEXT"),
+                                    ("estimated_pnl", "REAL")):
+                if column not in columns:
+                    cursor.execute(f"ALTER TABLE trade_history ADD COLUMN {column} {coltype}")
             cursor.execute("""
                 CREATE UNIQUE INDEX IF NOT EXISTS uq_trade_history_execution_v1
                 ON trade_history(product, provider, trading_mode, order_date,
@@ -386,6 +434,7 @@ class WorkflowPositionTracker:
         commda_code: str,
         *,
         execution_id: Optional[str | int] = None,
+        account_avg_price: Optional[float] = None,
     ) -> str:
         """
         체결 기록 및 FIFO 처리
@@ -401,7 +450,12 @@ class WorkflowPositionTracker:
             quantity: 수량
             price: 체결가
             fill_time: 체결시각 (HHMMSSsss)
-            commda_code: 매체구분코드 (40=OPEN API)
+            commda_code: 매체구분코드 (40=OPEN API). 프레임에서 온 값을 그대로
+                받는다 — 우리 주문과 일치하면 매체코드와 무관하게 workflow 로,
+                일치하지 않는 fill 만 매체코드로 manual(HTS)/unknown_api 를 가른다.
+            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.
             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
@@ -417,13 +471,13 @@ class WorkflowPositionTracker:
         This is a persistence prerequisite, not broker-history/TC3 integration.
             
         Returns:
-            분류 결과: "workflow" | "manual" | "unknown_api" | "pending"
+            분류 결과: "workflow" | "manual" | "unknown_api" | "other" | "pending"
         """
         fill = PendingFill(
             order_no=order_no, order_date=order_date, symbol=symbol,
             exchange=exchange, side=side, quantity=quantity, price=price,
             fill_time=fill_time, commda_code=commda_code, received_at=datetime.now(),
-            execution_id=execution_id,
+            execution_id=execution_id, account_avg_price=account_avg_price,
         )
         identity = self._execution_key(fill)
         async with self._buffer_lock:
@@ -437,11 +491,35 @@ class WorkflowPositionTracker:
                 if previous is not None:
                     return previous
 
-            if commda_code != "40":
-                return await self._process_fill_internal(fill, "manual")
+            # A fill that matches one of our recorded workflow orders is ours,
+            # whatever communication-media code the broker stamped on it — the
+            # recorded order is the authoritative ownership signal, so it is
+            # checked first. (Now that the real media code is forwarded instead
+            # of a hardcoded '40', our own OPEN-API fills may not carry '40'; the
+            # old media-first ordering would then misfile them as manual.)
             if self._is_workflow_fill(fill):
                 return await self._process_fill_internal(fill, "workflow")
-
+            # No matching order. Classify by the published media table
+            # (MEDIA_CODES_* above) — never by "not 40":
+            #   human (85 HTS / 22 iPhone / 23 Android / 00 branch) → "manual"
+            #   other (96/LP/SK/SO or unlisted)                    → "other"
+            #   api (40/41/43) or blank                            → buffer below
+            channel = media_channel(commda_code)
+            if channel == "human":
+                return await self._process_fill_internal(fill, "manual")
+            if channel == "other":
+                # A code the table does not attribute — more of these exist than
+                # we have measured (only 40/51/85/03 are live-observed so far).
+                # Log it so the table can grow from evidence, never from guesses.
+                logger.info("Unlisted media code %r on fill %s/%s — classified other",
+                            commda_code, order_date, order_no)
+                return await self._process_fill_internal(fill, "other")
+
+            # An API code or an empty media code ("medium unknown"): buffer to
+            # give a lagging order record a chance to arrive, then
+            # _process_timeout_fill files it as workflow (matched) or unknown_api
+            # (unmatched). An unknown medium is never asserted to be a person's
+            # HTS trade, so it floors to unknown_api rather than manual.
             self._next_pending_fill += 1
             key = self._next_pending_fill
             self._pending_fills[key] = fill
@@ -554,6 +632,7 @@ class WorkflowPositionTracker:
                     "reported_execution_id": fill.execution_id,
                 }, sort_keys=True)
             realized_pnl = 0.0
+            estimate = None
 
             if fill.side == "buy":
                 # 매수: 새 로트 생성
@@ -570,8 +649,9 @@ class WorkflowPositionTracker:
                 ))
             else:
                 # 매도: FIFO 청산 (현재 trading_mode 내에서만)
-                realized_pnl = self._process_sell_fifo(
-                    cursor, fill.symbol, fill.quantity, fill.price, classification
+                realized_pnl, estimate = self._process_sell_fifo(
+                    cursor, fill.symbol, fill.quantity, fill.price, classification,
+                    account_avg_price=fill.account_avg_price,
                 )
 
             # 체결 내역 저장
@@ -579,14 +659,19 @@ class WorkflowPositionTracker:
                 INSERT INTO trade_history
                 (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)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                 execution_id, normalized_order_no, execution_payload,
+                 unmatched_qty, estimate_basis_price, estimate_source, estimated_pnl)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
             """, (
                 self.product, self.provider,
                 fill.order_no, fill.order_date, fill.symbol, fill.exchange,
                 fill.side, fill.quantity, fill.price, fill_datetime,
                 classification, fill.commda_code, realized_pnl, self.trading_mode, datetime.now().isoformat(),
                 identity[5] if identity else None, identity[4] if identity else None, payload,
+                estimate["unmatched_qty"] if estimate else None,
+                estimate["estimate_basis_price"] if estimate else None,
+                estimate["estimate_source"] if estimate else None,
+                estimate["estimated_pnl"] if estimate else None,
             ))
 
             conn.commit()
@@ -605,62 +690,97 @@ class WorkflowPositionTracker:
         quantity: int,
         sell_price: float,
         classification: str,
-    ) -> float:
+        account_avg_price: Optional[float] = None,
+    ) -> Tuple[float, Optional[Dict[str, Any]]]:
         """
         FIFO 매도 처리
-        
+
         fill_datetime 순으로 정렬하여 선입선출 방식으로 청산합니다.
-        
+
+        classification 이 'workflow' 인 매도는 **workflow 로트만** 소진한다. 수동/타
+        API 로트를 먹으면 이 전략이 열지 않은 포지션의 손익까지 실현한 셈이 되기
+        때문이다. workflow 로트가 바닥난 뒤 남는 수량(remaining)은 이 전략이 여기서
+        사지 않은 물량을 판 것이므로, 계좌 평균매입가(account_avg_price)가 주어지면
+        그 잔량을 추정손익으로 매도 행에 기록한다(realized_pnl 은 FIFO 매칭분만 유지).
+        non-workflow 매도는 종전과 동일하게 분류 무관 로트를 FIFO 소진한다.
+
         Args:
             cursor: DB 커서
             symbol: 종목코드
             quantity: 매도 수량
             sell_price: 매도가
-            classification: 분류 (로깅용)
-            
+            classification: 분류 ("workflow" 면 workflow 로트만 소진)
+            account_avg_price: 계좌 평균매입가 (workflow 매도의 잔량 추정용, 없으면 추정 없음)
+
         Returns:
-            실현 손익
+            (실현 손익 FIFO 매칭분, 추정 정보 dict 또는 None)
         """
         remaining_to_sell = quantity
         total_realized_pnl = 0.0
-        
-        # fill_datetime 순으로 정렬 (FIFO, 현재 trading_mode 내에서만)
-        cursor.execute("""
-            SELECT id, buy_price, remaining_qty, classification
-            FROM workflow_position_lots
-            WHERE symbol = ? AND remaining_qty > 0 AND trading_mode = ?
-            ORDER BY fill_datetime ASC
-        """, (symbol, self.trading_mode))
-        
+
+        # fill_datetime 순으로 정렬 (FIFO, 현재 trading_mode 내에서만).
+        # workflow 매도는 workflow 로트로 소진 대상을 좁힌다.
+        if classification == "workflow":
+            cursor.execute("""
+                SELECT id, buy_price, remaining_qty, classification
+                FROM workflow_position_lots
+                WHERE symbol = ? AND remaining_qty > 0 AND trading_mode = ?
+                  AND classification = 'workflow'
+                ORDER BY fill_datetime ASC
+            """, (symbol, self.trading_mode))
+        else:
+            cursor.execute("""
+                SELECT id, buy_price, remaining_qty, classification
+                FROM workflow_position_lots
+                WHERE symbol = ? AND remaining_qty > 0 AND trading_mode = ?
+                ORDER BY fill_datetime ASC
+            """, (symbol, self.trading_mode))
+
         lots = cursor.fetchall()
-        
+
         for lot_id, buy_price, remaining_qty, lot_classification in lots:
             if remaining_to_sell <= 0:
                 break
-            
+
             sell_qty = min(remaining_to_sell, remaining_qty)
             new_remaining = remaining_qty - sell_qty
-            
+
             # 로트 업데이트
             cursor.execute("""
                 UPDATE workflow_position_lots
                 SET remaining_qty = ?
                 WHERE id = ?
             """, (new_remaining, lot_id))
-            
+
             # 실현 손익 계산
             pnl = (sell_price - buy_price) * sell_qty
             total_realized_pnl += pnl
-            
+
             remaining_to_sell -= sell_qty
-            
+
             logger.debug(f"FIFO sell: lot {lot_id} ({lot_classification}), "
                         f"qty={sell_qty}, pnl={pnl:.2f}")
-        
+
+        estimate: Optional[Dict[str, Any]] = None
         if remaining_to_sell > 0:
-            logger.warning(f"Sell without enough position: {symbol} remaining={remaining_to_sell}")
-        
-        return total_realized_pnl
+            if (classification == "workflow" and account_avg_price is not None
+                    and account_avg_price > 0):
+                # 이 전략이 여기서 사지 않은 잔량 — 같은 종목을 계좌의 다른 경로로
+                # 사둔 것으로 보고 계좌 평균매입가 기준 추정손익을 기록한다.
+                # realized_pnl(FIFO 매칭분)에는 넣지 않고 별도 컬럼으로만 남긴다.
+                estimated_pnl = (sell_price - account_avg_price) * remaining_to_sell
+                estimate = {
+                    "unmatched_qty": float(remaining_to_sell),
+                    "estimate_basis_price": float(account_avg_price),
+                    "estimate_source": "account_balance_avg_price",
+                    "estimated_pnl": float(estimated_pnl),
+                }
+                logger.debug(f"Estimated sell tail: {symbol} qty={remaining_to_sell} "
+                             f"@avg={account_avg_price} est_pnl={estimated_pnl:.2f}")
+            else:
+                logger.warning(f"Sell without enough position: {symbol} remaining={remaining_to_sell}")
+
+        return total_realized_pnl, estimate
     
     def _check_workflow_order(self, order_no: str, order_date: str) -> bool:
         """워크플로우 주문 여부 확인 (현재 trading_mode 기준)"""
@@ -877,9 +997,20 @@ class WorkflowPositionTracker:
         wf_buy = Decimal(0)
         wf_pnl = Decimal(0)
         wf_details: List[PositionDetail] = []
+        # 증거 카운터 — 비율을 **발행해도 되는지** 를 결정한다(금액은 영향 없음).
+        wf_unpriced = 0   # 현재가를 관측하지 못해 평단으로 대체한 종목 수
+        wf_unbased = 0    # 평단이 0 이하라 매수근거가 없는 종목 수
 
         for symbol, pos in workflow_positions.items():
-            current_price = prices.get(symbol, pos.avg_price)
+            observed_price = prices.get(symbol)
+            if observed_price is None or observed_price <= 0:
+                wf_unpriced += 1
+            if pos.avg_price <= 0:
+                wf_unbased += 1
+            # 🔴 금액 계산은 **현행 그대로** 둔다(평단 폴백 포함) — 금액을 비우면 모니터링
+            # KPI 합산이 통째로 접히고, 전량 청산한 날의 0 은 진짜 0 이다.
+            # 달라지는 것은 "그 금액으로 비율을 발행할 자격이 있는가" 뿐이다.
+            current_price = observed_price if (observed_price and observed_price > 0) else pos.avg_price
             mult, side_sign = multipliers.get(symbol, (Decimal(1), Decimal(1)))
             eval_amount = current_price * pos.quantity * mult
             buy_amount = pos.avg_price * pos.quantity * mult
@@ -900,16 +1031,43 @@ class WorkflowPositionTracker:
                 pnl_rate=pnl_rate,
             ))
 
-        wf_rate = (wf_pnl / wf_buy * 100) if wf_buy else Decimal(0)
+        # 🔴 계산할 수 없으면 0 이 아니라 **아무것도 발행하지 않는다**(None).
+        #
+        # 종전 `else Decimal(0)` 는 "아무것도 안 샀다" 를 **"0% 로 측정됐다"** 로 바꿔 발행했다.
+        # 그러면 워크플로우를 시작만 해도 스냅샷이 생겨 공유 카드가 「참고 데이터」 배지 달린
+        # 정직한 0.0% 에서 **배지 없는 "실측 0.0%"** 로 바뀐다(승률 0%·손익비 0.00 까지).
+        # 선물은 이미 이 원칙으로 고쳐져 있다(`futures_pnl.unavailable_workflow_pnl`) —
+        # 주식만 안 따라갔다.
+        #
+        # 한 종목이라도 현재가를 못 봤거나(`wf_unpriced`) 평단이 없으면(`wf_unbased`)
+        # 합계 비율이 **부풀려진다**(분모만 줄거나 평가액이 매수액으로 눌린다). 그건 0 이
+        # 아닌 채로 틀리므로 값 자체를 내지 않는다.
+        wf_rate_reason: Optional[str] = None
+        if not workflow_positions:
+            wf_rate_reason = "no_workflow_positions"
+        elif wf_unbased:
+            wf_rate_reason = "basis_unreported"
+        elif wf_unpriced:
+            wf_rate_reason = "price_unreported"
+        elif not wf_buy:
+            wf_rate_reason = "no_workflow_positions"
+        wf_rate = None if wf_rate_reason else (wf_pnl / wf_buy * 100)
 
         # 그 외 포지션 계산
         other_eval = Decimal(0)
         other_buy = Decimal(0)
         other_pnl = Decimal(0)
         other_details: List[PositionDetail] = []
+        other_unpriced = 0
+        other_unbased = 0
 
         for symbol, pos in other_positions.items():
-            current_price = prices.get(symbol, pos.avg_price)
+            observed_price = prices.get(symbol)
+            if observed_price is None or observed_price <= 0:
+                other_unpriced += 1
+            if pos.avg_price <= 0:
+                other_unbased += 1
+            current_price = observed_price if (observed_price and observed_price > 0) else pos.avg_price
             mult, side_sign = multipliers.get(symbol, (Decimal(1), Decimal(1)))
             eval_amount = current_price * pos.quantity * mult
             buy_amount = pos.avg_price * pos.quantity * mult
@@ -930,13 +1088,26 @@ class WorkflowPositionTracker:
                 pnl_rate=pnl_rate,
             ))
 
-        other_rate = (other_pnl / other_buy * 100) if other_buy else Decimal(0)
+        # wf_rate 와 같은 규율 — 근거가 없으면 비율을 발행하지 않는다.
+        other_rate = (
+            None
+            if (not other_positions or other_unbased or other_unpriced or not other_buy)
+            else (other_pnl / other_buy * 100)
+        )
 
         # 전체 계산 — pnl 은 부호 보정된 per-position 합, eval/buy 는 명목가 합.
         total_eval = wf_eval + other_eval
         total_buy = wf_buy + other_buy
         total_pnl = wf_pnl + other_pnl
-        total_rate = (total_pnl / total_buy * 100) if total_buy else Decimal(0)
+        # 전체 비율은 **양쪽 다 증거가 성립할 때만** 낸다. 한쪽이 모름이면 합계도 모름이다
+        # (모르는 쪽을 0 으로 치고 더하면 없는 정확도를 만들어낸다).
+        total_unpriced = wf_unpriced + other_unpriced
+        total_unbased = wf_unbased + other_unbased
+        total_rate = (
+            None
+            if (not total_buy or total_unbased or total_unpriced)
+            else (total_pnl / total_buy * 100)
+        )
         
         # 신뢰도 계산
         anomalies = self.detect_anomalies()
@@ -948,6 +1119,10 @@ class WorkflowPositionTracker:
             "product": self.product,
             
             "workflow_pnl_rate": wf_rate,
+            # 비율을 못 낸 **이유**. 값을 비우는 것만으로는 "안 샀다" 와 "증권사가 평단을
+            # 안 보냈다" 가 구분되지 않는다 — 서버는 이 사유를 raw_event 에 그대로 싣는다.
+            # 어휘는 dsl-api `app/utils/pnl_rate_evidence.RATE_UNAVAILABLE_REASONS` 와 공용.
+            "workflow_rate_unavailable_reason": wf_rate_reason,
             "workflow_eval_amount": wf_eval,
             "workflow_buy_amount": wf_buy,
             "workflow_pnl_amount": wf_pnl,
@@ -978,6 +1153,34 @@ class WorkflowPositionTracker:
         Historical FIFO rows have no currency or fee evidence. Keep their amounts
         per symbol/exchange and reject mixed ownership or an incomplete FIFO 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,
+        using its *stored* realized amount — the replay below only validates the
+        basis and never replaces a stored value, so the outcome is read from the
+        same number the ledger committed.
+
+        A workflow sell now consumes only workflow lots (_process_sell_fifo), so
+        the old ``mixed_fifo_ownership`` pre-check is gone: a workflow sell can
+        no longer have realized a non-workflow lot, so there is nothing to guard
+        against. Old ledger rows written under the previous (classification-blind)
+        sell replay with ``stored != expected`` and are rejected below as
+        ``incomplete_fifo_basis`` — the honest outcome for a basis we can no
+        longer reconstruct.
+
+        A workflow sell whose own lots run out leaves a residual. When that
+        residual was recorded with an account-average-price estimate covering
+        exactly it (``estimate_basis_price`` present and ``unmatched_qty`` equal
+        to the residual), the group is not rejected: its status becomes
+        ``estimated``, its basis ``fifo_with_account_avg_price_estimate``, and
+        the sell scores on ``stored + estimated_pnl`` (the FIFO-matched amount
+        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.
+        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.
         """
         with sqlite3.connect(self.db_path) as conn:
             conn.row_factory = sqlite3.Row
@@ -1014,21 +1217,28 @@ class WorkflowPositionTracker:
         for (symbol, exchange), fills in sorted(groups.items()):
             reason = None
             amount = None
+            outcome = None
+            # Whether this group's amount includes an account-avg-price estimate,
+            # and how much quantity was estimated (Σ unmatched over its sells).
+            group_estimated = False
+            group_est_qty = Decimal(0)
             if self.product == "overseas_futures":
                 reason = "futures_fifo_not_monetary"
             elif not symbol:
                 reason = "missing_symbol"
-            elif any(row["symbol"] == symbol and (
-                row["product"] != self.product or row["provider"] != self.provider
-                or row["classification"] != "workflow" or (row["exchange"] or "") != exchange
-            ) for row in rows):
-                # The historical sell writer matches symbol/mode across all lots.
-                # It cannot prove workflow ownership when those domains overlap.
-                reason = "mixed_fifo_ownership"
             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
+                # non-workflow lot. Old rows written under the previous replay
+                # fall out below as incomplete_fifo_basis (stored != expected).
                 try:
                     lots = []
                     total = Decimal(0)
+                    # NB: `closed` below is the matched lot quantity — do not
+                    # reuse that name for a counter.
+                    trades = wins = losses = evens = 0
+                    gross_profit = Decimal(0)
+                    gross_loss = Decimal(0)
                     for fill in fills:
                         quantity = Decimal(str(fill["quantity"]))
                         price = Decimal(str(fill["price"]))
@@ -1051,23 +1261,166 @@ class WorkflowPositionTracker:
                                 if remaining == 0:
                                     break
                             tolerance = max(Decimal("0.000001"), abs(expected) * Decimal("0.000000001"))
-                            if remaining > 0 or abs(stored - expected) > tolerance:
-                                raise ValueError("Incomplete or inconsistent FIFO basis")
-                            # Preserve the stored amount; replay arithmetic only
-                            # validates the basis and never replaces its value.
-                            total += stored
+                            # The FIFO-matched portion must reproduce the stored
+                            # amount, whether or not a tail remains.
+                            if abs(stored - expected) > tolerance:
+                                raise ValueError("Inconsistent FIFO basis")
+                            # trade_amount is what this one closed trade scores on;
+                            # it starts as the stored (matched) value and grows by
+                            # the recorded estimate when a tail remains.
+                            trade_amount = stored
+                            if remaining > 0:
+                                # A residual after the workflow lots run out is
+                                # accepted only as a recorded account-avg-price
+                                # estimate covering exactly this residual; anything
+                                # else is an incomplete basis.
+                                est_basis = fill["estimate_basis_price"]
+                                est_unmatched = fill["unmatched_qty"]
+                                est_pnl = fill["estimated_pnl"]
+                                if est_basis is None or est_unmatched is None or est_pnl is None:
+                                    raise ValueError("Incomplete FIFO basis without estimate")
+                                est_unmatched_d = Decimal(str(est_unmatched))
+                                est_pnl_d = Decimal(str(est_pnl))
+                                if est_unmatched_d != remaining or not est_pnl_d.is_finite():
+                                    raise ValueError("Estimate does not cover the residual")
+                                # Add (never replace) the stored estimate to the
+                                # matched amount; one sell fill is still one trade.
+                                trade_amount = stored + est_pnl_d
+                                group_estimated = True
+                                group_est_qty += remaining
+                            total += trade_amount
+                            trades += 1
+                            if trade_amount > 0:
+                                wins += 1
+                                gross_profit += trade_amount
+                            elif trade_amount < 0:
+                                losses += 1
+                                gross_loss += -trade_amount
+                            else:
+                                evens += 1
                         else:
                             raise ValueError("Unknown fill side")
                     amount = float(total)
                     if not Decimal(str(amount)).is_finite():
                         raise ValueError("Non-finite total")
+                    gross_profit_f = float(gross_profit)
+                    gross_loss_f = float(gross_loss)
+                    if not all(Decimal(str(v)).is_finite() for v in (gross_profit_f, gross_loss_f)):
+                        raise ValueError("Non-finite gross amount")
+                    outcome = {"closed_trades": trades, "winning_trades": wins,
+                               "losing_trades": losses, "breakeven_trades": evens,
+                               "gross_profit": gross_profit_f, "gross_loss": gross_loss_f}
                 except (ValueError, TypeError, ArithmeticError, OverflowError):
                     reason = "incomplete_fifo_basis"
-            realized.append({"symbol": symbol, "exchange": exchange, "currency": None,
-                             "amount": amount, "status": "available" if reason is None else "unavailable",
-                             "reason": reason})
+                    outcome = None
+                    group_estimated = False
+                    group_est_qty = Decimal(0)
+            if reason is not None:
+                status = "unavailable"
+                basis = None
+                estimated_quantity = None
+            elif group_estimated:
+                status = "estimated"
+                basis = "fifo_with_account_avg_price_estimate"
+                estimated_quantity = float(group_est_qty)
+            else:
+                status = "available"
+                basis = "fifo"
+                estimated_quantity = 0
+            entry = {"symbol": symbol, "exchange": exchange, "currency": None,
+                     "amount": amount, "status": status, "reason": reason,
+                     "basis": basis, "estimated_quantity": estimated_quantity}
+            # A rejected group publishes no outcome: its trades are unknown, and
+            # unknown trades must not be counted as zero of anything.
+            entry.update(outcome or {"closed_trades": None, "winning_trades": None,
+                                     "losing_trades": None, "breakeven_trades": None,
+                                     "gross_profit": None, "gross_loss": None})
+            realized.append(entry)
+        # Counts carry no currency, so they aggregate across symbols. A group the
+        # replay rejected is excluded and downgrades the status to "partial" —
+        # "some of this strategy's trades are not in these numbers" is a different
+        # claim from "these are all of them", and the caller must be able to tell.
+        scored = [g for g in realized if g["closed_trades"] is not None]
+        counted = [g for g in scored if g["closed_trades"] > 0]
+        if not scored:
+            trade_status, trade_reason = "unavailable", (
+                "futures_fifo_not_monetary" if self.product == "overseas_futures"
+                else "no_scorable_fifo_basis")
+            closed_total = winning_total = losing_total = breakeven_total = None
+        else:
+            trade_status = "available" if len(scored) == len(realized) else "partial"
+            trade_reason = None if trade_status == "available" else "some_groups_unscorable"
+            closed_total = sum(g["closed_trades"] for g in scored)
+            winning_total = sum(g["winning_trades"] for g in scored)
+            losing_total = sum(g["losing_trades"] for g in scored)
+            breakeven_total = sum(g["breakeven_trades"] for g in scored)
+
+        # The ratio is money, and money needs a unit. One group means one symbol,
+        # hence one currency — the only case where the unit is provable without
+        # currency evidence. Anything else stays per group.
+        ratio = None
+        ratio_status = "unavailable"
+        if len(counted) != 1:
+            ratio_reason = ("no_closed_trades" if not counted
+                            else "multi_symbol_currency_unknown")
+        else:
+            group = counted[0]
+            if group["gross_loss"] > 0:
+                candidate = group["gross_profit"] / group["gross_loss"]
+                if Decimal(str(candidate)).is_finite():
+                    ratio, ratio_status, ratio_reason = candidate, "available", None
+                else:
+                    ratio_reason = "non_finite_ratio"
+            else:
+                # No losing trade means no denominator. Publishing gross profit
+                # here (the server's day-based metric does) reads as a ratio of
+                # that size and overstates the strategy.
+                ratio_reason = "no_losing_trades"
+
+        # How many groups carry an account-avg-price estimate, and whether the
+        # aggregated figures rest on any estimate. A count is null when it is
+        # itself unavailable; otherwise it is "measured" unless a scored group
+        # was estimated. The ratio comes from a single group, so its basis is
+        # that one group's.
+        estimated_group_count = sum(1 for g in realized if g["status"] == "estimated")
+        if trade_status == "unavailable":
+            closed_trade_basis = None
+        else:
+            closed_trade_basis = ("includes_estimates"
+                                  if any(g["status"] == "estimated" for g in scored)
+                                  else "measured")
+        if ratio_status != "available":
+            profit_loss_ratio_basis = None
+        else:
+            profit_loss_ratio_basis = ("includes_estimates"
+                                       if counted[0]["status"] == "estimated"
+                                       else "measured")
+
+        # Fills on this same account placed outside this strategy, by classification:
+        # manual (a person via HTS/app/branch) → hts, unknown_api (another API
+        # client) → other_api, other (broker-side codes 96/LP/SK/SO or unlisted)
+        # → other. Futures fill frames carry no communication-media field, so
+        # the channels cannot be told apart for them — unavailable.
+        if self.product == "overseas_futures":
+            off_strategy_fills = {"hts": None, "other_api": None, "other": None, "other_codes": None,
+                                  "status": "unavailable",
+                                  "reason": "futures_fills_have_no_media_code"}
+        else:
+            in_scope = [r for r in rows if r["product"] == self.product
+                        and r["provider"] == self.provider]
+            off_strategy_fills = {
+                "hts": sum(1 for r in in_scope if r["classification"] == "manual"),
+                "other_api": sum(1 for r in in_scope if r["classification"] == "unknown_api"),
+                "other": sum(1 for r in in_scope if r["classification"] == "other"),
+                # Distinct unlisted codes behind "other" — the evidence trail for
+                # extending MEDIA_CODES_* (consumers may ignore this key).
+                "other_codes": sorted({str(r["commda_code"]) for r in in_scope
+                                       if r["classification"] == "other" and r["commda_code"]}),
+                "status": "available", "reason": None,
+            }
+
         return {
-            "version": 1,
+            "version": 2,
             "scope": {"kind": "local_workflow_ledger", "product": self.product,
                       "provider": self.provider, "trading_mode": self.trading_mode},
             "as_of": datetime.now(timezone.utc).isoformat(),
@@ -1076,6 +1429,19 @@ class WorkflowPositionTracker:
             "executed_order_count_status": "unavailable" if invalid_count else "available",
             "executed_order_count_reason": "invalid_execution_identity" if invalid_count else None,
             "realized_pnl": realized,
+            "closed_trade_count": closed_total,
+            "winning_trade_count": winning_total,
+            "losing_trade_count": losing_total,
+            "breakeven_trade_count": breakeven_total,
+            "closed_trade_status": trade_status,
+            "closed_trade_reason": trade_reason,
+            "closed_trade_basis": closed_trade_basis,
+            "estimated_group_count": estimated_group_count,
+            "profit_loss_ratio": ratio,
+            "profit_loss_ratio_status": ratio_status,
+            "profit_loss_ratio_reason": ratio_reason,
+            "profit_loss_ratio_basis": profit_loss_ratio_basis,
+            "off_strategy_fills": off_strategy_fills,
             "max_drawdown": None,
             "max_drawdown_status": "unavailable",
             "max_drawdown_reason": "equity_history_unavailable",

{programgarden-1.34.0 → programgarden-1.35.0}/programgarden/executor.py

@@ -4567,6 +4567,25 @@ class BrokerNodeExecutor(NodeExecutorBase):
                 
                 async def record_and_refresh():
                     """체결 기록 후 AccountTracker refresh"""
+                    tracker_key = f"{context.job_id}_{node_id}"
+                    tracker_info = self._active_trackers.get(tracker_key)
+
+                    # 매도 잔량 추정용 계좌 평균매입가 — record 전에(그래서 refresh
+                    # 전에) StockAccountTracker 캐시(_positions[symbol].buy_price)에서
+                    # 읽는다. 캐시는 아직 이번 매도가 반영되기 전이라 '매도 직전 평단'.
+                    # 캐시에 없으면 None → 추정 없음(오늘처럼 unavailable).
+                    account_avg_price = 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
+                        buy_price = getattr(pos, "buy_price", None) if pos is not None else None
+                        if buy_price is not None:
+                            try:
+                                account_avg_price = float(buy_price)
+                            except (TypeError, ValueError):
+                                account_avg_price = None
+
                     await context.record_workflow_fill(
                         order_no=order_no,
                         order_date=order_date,
@@ -4576,19 +4595,21 @@ class BrokerNodeExecutor(NodeExecutorBase):
                         quantity=exec_qty,
                         price=exec_price,
                         fill_time=fill_time,
-                        commda_code='40',  # OPEN API
+                        # 프레임의 통신매체코드를 그대로 넘긴다(하드코딩 '40' 폐기).
+                        # 우리 주문과 일치하면 매체코드 무관하게 workflow 로 분류되고,
+                        # 일치하지 않는 계좌 내 타 체결만 이 코드로 HTS/타 API 를 가른다.
+                        commda_code=getattr(body, 'sCommdaCode', ''),
                         execution_id=execution_id,
+                        account_avg_price=account_avg_price,
                     )
-                    
+
                     # AccountTracker refresh로 PnL 이벤트 강제 트리거
-                    tracker_key = f"{context.job_id}_{node_id}"
-                    tracker_info = self._active_trackers.get(tracker_key)
                     if tracker_info and "tracker" in tracker_info:
                         tracker = tracker_info["tracker"]
                         if hasattr(tracker, 'refresh_now'):
                             await tracker.refresh_now()
                             logger.debug(f"📊 AccountTracker refreshed after fill")
-                
+
                 asyncio.run_coroutine_threadsafe(record_and_refresh(), loop)
                 logger.info(f"📌 Workflow fill recorded: {symbol} {side} {exec_qty}@{exec_price}")
                     
@@ -4742,6 +4763,9 @@ class BrokerNodeExecutor(NodeExecutorBase):
                                 quantity=quantity,
                                 price=price,
                                 fill_time=fill_time,
+                                # 선물 체결 프레임(TC3)에는 통신매체코드 필드가 없다
+                                # (blocks.py 에 commda/media 없음). 이 경로는 우리
+                                # 주문의 체결이므로 OPEN API 기본값 '40' 을 유지한다.
                                 commda_code='40',
                             ),
                             loop
@@ -4815,6 +4839,8 @@ class BrokerNodeExecutor(NodeExecutorBase):
                     side = 'buy' if bns_tp == '2' else 'sell'
                     fill_time = getattr(body, 'exectime', datetime.now().strftime('%H%M%S000'))
 
+                    media_code = getattr(body, 'commdacode', '')
+
                     async def record_and_refresh():
                         """체결 기록 후 AccountTracker refresh"""
                         await context.record_workflow_fill(
@@ -4826,7 +4852,10 @@ class BrokerNodeExecutor(NodeExecutorBase):
                             quantity=exec_qty,
                             price=exec_price,
                             fill_time=fill_time,
-                            commda_code='40',
+                            # SC1 프레임의 통신매체코드(commdacode)를 그대로 넘긴다.
+                            # 우리 주문과 일치하면 workflow, 아니면 이 코드로
+                            # HTS(manual)/타 API(unknown_api)를 가른다.
+                            commda_code=media_code,
                         )
 
                         # AccountTracker refresh로 PnL 이벤트 강제 트리거

{programgarden-1.34.0 → programgarden-1.35.0}/pyproject.toml

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