programgarden 2.5.4__tar.gz → 2.5.6__tar.gz

{programgarden-2.5.4 → programgarden-2.5.6}/PKG-INFO

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

{programgarden-2.5.4 → programgarden-2.5.6}/programgarden/context.py

@@ -260,6 +260,7 @@ class ExecutionContext:
         # Stores trackers/connections that should stay alive between flow executions
         self._persistent_nodes: Dict[str, Any] = {}  # node_id -> tracker/connection
         self._persistent_tasks: Dict[str, asyncio.Task] = {}  # node_id -> background task
+        self._schedule_tick_source: Optional[str] = None  # Only this timer may trigger the current cycle.
         self._persistent_metadata: Dict[str, Dict[str, Any]] = {}  # node_id -> {key: value}
         
         # === New: Order Event Dispatcher ===

{programgarden-2.5.4 → programgarden-2.5.6}/programgarden/database/order_recovery.py

@@ -97,6 +97,9 @@ def initialize_recovery(conn):
     columns = {row[1] for row in conn.execute("PRAGMA table_info(workflow_position_lots)")}
     if "recovery_id" not in columns:
         conn.execute("ALTER TABLE workflow_position_lots ADD COLUMN recovery_id INTEGER")
+    recovery_columns = {row[1] for row in conn.execute("PRAGMA table_info(workflow_order_recoveries)")}
+    if "unpriced_quantity" not in recovery_columns:
+        conn.execute("ALTER TABLE workflow_order_recoveries ADD COLUMN unpriced_quantity TEXT NOT NULL DEFAULT '0'")
 
 
 def recovery_for_order(conn, tracker, day, number):
@@ -159,7 +162,8 @@ def recover_totals(tracker, totals):
     with sqlite3.connect(tracker.db_path) as conn:
         conn.execute("BEGIN IMMEDIATE")
         # Aggregate execution times are only a recovery ordering, never invented
-        # timestamps for individual executions. Missing basis fails closed.
+        # timestamps for individual executions. Missing basis invalidates PnL,
+        # not a broker-verified execution or the later fresh holdings check.
         for total, (number, symbol, total_qty, price) in sorted(
                 validated, key=lambda item: (item[0].order_date, item[0].fill_time, int(item[1][0]))):
             scope = tracker.product, tracker.provider, tracker.trading_mode
@@ -232,13 +236,18 @@ def recover_totals(tracker, totals):
                     SELECT 1 FROM trade_history WHERE product=? AND provider=? AND trading_mode=?
                     AND symbol=? AND classification='workflow' AND side='sell' AND fill_datetime>=? LIMIT 1
                 """, (*scope, symbol, fill_datetime)).fetchone()
+                later_recovery = conn.execute("""
+                    SELECT 1 FROM workflow_order_recoveries WHERE product=? AND provider=? AND trading_mode=?
+                    AND symbol=? AND side='sell' AND fill_datetime>=? LIMIT 1
+                """, (*scope, symbol, fill_datetime)).fetchone()
                 adjusted = conn.execute("SELECT 1 FROM sqlite_master WHERE name='position_adjustments'").fetchone()
                 if adjusted:
                     adjusted = conn.execute("""SELECT 1 FROM position_adjustments WHERE product=?
                         AND provider=? AND trading_mode=? AND symbol=? LIMIT 1""", (*scope, symbol)).fetchone()
-                if later_sell or adjusted:
+                if later_sell or later_recovery or adjusted:
                     raise ReconciliationUnavailable("historical_buy_requires_full_replay")
             pnl = Decimal(0)
+            unpriced = Decimal(0)
             lots = []
             if total.side == "sell" and missing:
                 lots = conn.execute("""
@@ -246,9 +255,12 @@ def recover_totals(tracker, totals):
                     AND provider=? AND trading_mode=? AND symbol=? AND classification='workflow'
                     AND remaining_qty>0 AND fill_datetime<=? ORDER BY fill_datetime,id
                 """, (*scope, symbol, fill_datetime)).fetchall()
-                if (any(quantity(row[1]) <= 0 for row in lots)
-                        or sum((quantity(row[2]) for row in lots), Decimal(0)) < missing):
-                    raise ReconciliationUnavailable("recovery_cost_basis_unavailable")
+                # Account-wide strategies can sell holdings acquired before this
+                # workflow. Never invent their purchase lots or a zero-cost basis.
+                # Validate stored numbers even when there are too few owned lots.
+                for _, basis, available in lots:
+                    quantity(basis)
+                    quantity(available)
             cursor = conn.execute("""
                 INSERT INTO workflow_order_recoveries
                 (product,provider,trading_mode,order_date,order_no,symbol,exchange,side,
@@ -273,16 +285,25 @@ def recover_totals(tracker, totals):
                 remainder = missing
                 for lot_id, basis, available in lots:
                     used = min(remainder, quantity(available))
-                    pnl += (recovered_price - quantity(basis)) * used
+                    if quantity(basis) > 0:
+                        pnl += (recovered_price - quantity(basis)) * used
+                    else:
+                        unpriced += used
                     conn.execute("UPDATE workflow_position_lots SET remaining_qty=? WHERE id=?",
                                  (float(quantity(available) - used), lot_id))
                     remainder -= used
                     if not remainder:
                         break
-                conn.execute("UPDATE workflow_order_recoveries SET estimated_pnl=? WHERE id=?", (str(pnl), recovery_id))
+                unpriced += remainder
+                # estimated_pnl stores only the matched portion for audit. Public
+                # readers must return null whenever any quantity lacks a basis.
+                conn.execute("UPDATE workflow_order_recoveries SET estimated_pnl=?, unpriced_quantity=? WHERE id=?",
+                             (str(pnl), str(unpriced), recovery_id))
             results.append({"id": recovery_id, "order_date": total.order_date, "order_no": number,
                             "symbol": symbol, "side": total.side, "quantity": str(missing),
-                            "estimated_pnl": str(pnl), "currency": total.currency,
+                            "estimated_pnl": None if unpriced else str(pnl), "currency": total.currency,
+                            "unpriced_quantity": str(unpriced),
+                            "cost_basis_status": "unavailable" if unpriced else "estimated",
                             "basis": "broker_order_total", "is_estimated": True, "is_trade": False})
     return results
 

{programgarden-2.5.4 → programgarden-2.5.6}/programgarden/database/workflow_position_tracker.py

@@ -1818,10 +1818,16 @@ class WorkflowPositionTracker:
         """Read the immutable recovery audit; this is not individual fill history."""
         with sqlite3.connect(self.db_path) as conn:
             conn.row_factory = sqlite3.Row
-            return [dict(row) for row in conn.execute(
+            rows = [dict(row) for row in conn.execute(
                 "SELECT * FROM workflow_order_recoveries WHERE product=? AND provider=? "
                 "AND trading_mode=? ORDER BY id",
                 (self.product, self.provider, self.trading_mode))]
+        for row in rows:
+            unknown = Decimal(row["unpriced_quantity"]) > 0
+            row["cost_basis_status"] = "unavailable" if unknown else "estimated"
+            if unknown:
+                row["estimated_pnl"] = None
+        return rows
 
     def get_position_adjustments(self, limit: int = 50) -> List[Dict[str, Any]]:
         """Return the current product/mode audit without creating synthetic trades."""
@@ -2249,6 +2255,10 @@ class WorkflowPositionTracker:
                 reason = "futures_fifo_not_monetary"
             elif not symbol:
                 reason = "missing_symbol"
+            elif any(fill.get("cost_basis_status") == "unavailable" for fill in fills):
+                # Verified order quantity can permit startup without establishing
+                # historical profit. Preserve the existing unavailable contract.
+                reason = "incomplete_fifo_basis"
             elif len(units - {None}) > 1 or unit_conflict:
                 # Contradictory units cannot establish a comparable FIFO basis.
                 reason = "incomplete_fifo_basis"

{programgarden-2.5.4 → programgarden-2.5.6}/programgarden/executor.py

@@ -2227,12 +2227,12 @@ class ScheduleNodeExecutor(NodeExecutorBase):
     ) -> Dict[str, Any]:
         from datetime import datetime
         from zoneinfo import ZoneInfo
-        from croniter import croniter
+        from croniter import croniter, CroniterBadDateError
         
         # 이미 스케줄러가 실행 중이면 재등록하지 않음 (schedule_tick 이벤트로 인한 재실행 시)
         if node_id in context._persistent_tasks:
             context.log("debug", f"Scheduler already running for {node_id}, skip", node_id)
-            return {"trigger": True}
+            return {"trigger": bool(context.is_dry_run or context._schedule_tick_source == node_id)}
         
         # ⑭ cron is required — NO silent "*/5 * * * *" fallback. A missing cron
         # used to make the schedule quietly run every 5 minutes ("looks fine,
@@ -2305,7 +2305,7 @@ class ScheduleNodeExecutor(NodeExecutorBase):
             try:
                 # second_at_beginning=True로 초 단위 cron도 지원
                 try:
-                    itr = croniter(cron_expr, datetime.now(tz), second_at_beginning=True)
+                    itr = croniter(cron_expr, datetime.now(tz), second_at_beginning=True, max_years_between_matches=130)
                 except TypeError:
                     itr = croniter(cron_expr, datetime.now(tz))
 
@@ -2340,7 +2340,12 @@ class ScheduleNodeExecutor(NodeExecutorBase):
                         )
                         break
                     # 다음 실행 시간 계산
-                    next_dt = itr.get_next(datetime)
+                    try:
+                        next_dt = itr.get_next(datetime)
+                    except CroniterBadDateError:
+                        # A calendar date/year can be exhausted. It is not an
+                        # execution failure and must never roll into another year.
+                        break
                     now = datetime.now(tz)
                     delay = (next_dt - now).total_seconds()
                     
@@ -2421,8 +2426,9 @@ class ScheduleNodeExecutor(NodeExecutorBase):
         task = asyncio.create_task(scheduler_task())
         context.register_persistent_task(node_id, task)
         
-        # 초기 트리거 반환 (첫 플로우 실행용)
-        return {"trigger": True}
+        # Register the timer without executing downstream trading work early.
+        # Explicit dry-run simulation still exercises one synthetic cycle.
+        return {"trigger": bool(context.is_dry_run)}
 
 
 class WatchlistNodeExecutor(NodeExecutorBase):
@@ -23557,6 +23563,14 @@ class WorkflowJob:
             event = await self.context.wait_for_event(timeout=1.0)
             
             if event is None:
+                has_realtime_source = any(
+                    self.workflow.nodes[n].node_type in REALTIME_NODE_TYPES
+                    for n in self._stay_connected_nodes
+                )
+                if (self._has_schedule_node and not has_realtime_source
+                        and all(task.done() for task in self.context._persistent_tasks.values())):
+                    # Finite calendar/count schedules finish after queued ticks drain.
+                    break
                 continue
             
             # Wait if paused
@@ -23595,6 +23609,7 @@ class WorkflowJob:
                 # RuntimeError 등)가 스케줄 잡 전체를 종료시키지 않도록 한다.
                 # 실패 사이클은 silent 하지 않게 'cycle_failed' 로 통지하고
                 # 다음 tick 에서 재시도한다 (24시간 무인 운영 보호).
+                self.context._schedule_tick_source = event.source_node_id
                 try:
                     await self._execute_main_flow()
                 except Exception as cycle_err:
@@ -23606,6 +23621,8 @@ class WorkflowJob:
                     await self.context.notify_job_state("cycle_failed", self.stats)
                 else:
                     await self.context.notify_job_state("cycle_completed", self.stats)
+                finally:
+                    self.context._schedule_tick_source = None
         
         logger.info("Event loop ended")
 

{programgarden-2.5.4 → programgarden-2.5.6}/pyproject.toml

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