programgarden 2.5.5__tar.gz → 2.6.0__tar.gz

{programgarden-2.5.5 → programgarden-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: programgarden
-Version: 2.5.5
+Version: 2.6.0
 Summary: ProgramGarden - 노드 기반 자동매매 DSL 실행 엔진
 License-Expression: AGPL-3.0-or-later
 Author: 프로그램동산
@@ -16,7 +16,7 @@ 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.5.3,<3.0.0)
+Requires-Dist: programgarden-core (>=2.6.0,<3.0.0)
 Requires-Dist: programgarden-finance (>=2.0.1,<3.0.0)
 Requires-Dist: psutil (>=6.0.0,<7.0.0)
 Requires-Dist: psycopg2-binary (>=2.9.11,<3.0.0)
@@ -29,6 +29,15 @@ Description-Content-Type: text/markdown
 
 # ProgramGarden
 
+An unreleased [futures detail and durable state candidate](../../docs/futures-contract-details-and-rollover-state.md)
+adds exact o3105 metadata, opt-in execution-scoped SQLite and XHKG calendar
+intersection. Missing evidence remains explicit; this does not authorize orders.
+
+An unreleased [offline temporal replay extension](../../docs/offline-temporal-replay.md)
+supports explicit bounded multi-day acceptance without changing the default
+32-event worker/save path. Public package release remains pending; the server
+team has validated a private DEV candidate with the same runtime changes.
+
 The REST overseas-stock account output preserves broker-reported `sellable_qty`
 separately from holdings; absent capacity remains null. See
 [the sell-capacity contract](../../docs/overseas-stock-sellable-quantity.md).

{programgarden-2.5.5 → programgarden-2.6.0}/README.md

@@ -1,5 +1,14 @@
 # ProgramGarden
 
+An unreleased [futures detail and durable state candidate](../../docs/futures-contract-details-and-rollover-state.md)
+adds exact o3105 metadata, opt-in execution-scoped SQLite and XHKG calendar
+intersection. Missing evidence remains explicit; this does not authorize orders.
+
+An unreleased [offline temporal replay extension](../../docs/offline-temporal-replay.md)
+supports explicit bounded multi-day acceptance without changing the default
+32-event worker/save path. Public package release remains pending; the server
+team has validated a private DEV candidate with the same runtime changes.
+
 The REST overseas-stock account output preserves broker-reported `sellable_qty`
 separately from holdings; absent capacity remains null. See
 [the sell-capacity contract](../../docs/overseas-stock-sellable-quantity.md).

{programgarden-2.5.5 → programgarden-2.6.0}/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.6.0/programgarden/database/sqlite_scope.py

@@ -0,0 +1,19 @@
+"""Opt-in strategy SQLite namespace below the host-provided durable directory."""
+import hashlib
+import re
+
+
+def scoped_sqlite_filename(config, context):
+    name = config.get('db_name', 'default.db')
+    scope = config.get('storage_scope', 'shared')
+    if scope == 'shared':
+        return name
+    if scope != 'execution':
+        raise ValueError('Unknown SQLite storage scope')
+    if not isinstance(name, str) or not re.fullmatch(r'[A-Za-z0-9_-][A-Za-z0-9_.-]{0,119}\.db', name):
+        raise ValueError('Execution-scoped SQLite requires a plain .db filename')
+    key = context.execution_key or context.workflow_id
+    if not isinstance(key, str) or not key.strip():
+        raise ValueError('Execution-scoped SQLite requires a stable execution or workflow identity')
+    basis = ('execution:' if context.execution_key else 'workflow:') + key
+    return 'strategy_' + hashlib.sha256(basis.encode()).hexdigest() + '_' + name

{programgarden-2.5.5 → programgarden-2.6.0}/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.5 → programgarden-2.6.0}/programgarden/executor.py

@@ -6312,6 +6312,49 @@ class AccountNodeExecutor(NodeExecutorBase):
         return result
 
 
+class FuturesContractInfoNodeExecutor(NodeExecutorBase):
+    """Read exact contract details independently of quote availability."""
+
+    async def execute(self, node_id, node_type, config, context, **kwargs):
+        from programgarden.futures_contract_info import (
+            FuturesContractEvidenceError, build_contract_info_request, read_contract_info,
+            synthetic_contract_info,
+        )
+        config = evaluate_all_bindings(config, context, node_id)
+        try:
+            request = build_contract_info_request(config)
+            if context.is_deep_validate:
+                from programgarden import deep_fixtures
+                return deep_fixtures.apply_override(
+                    synthetic_contract_info(config), context.get_deep_fixture(node_id, node_type),
+                )
+            connection = config.get("connection")
+            if not isinstance(connection, dict) or connection.get("product") != "overseas_futures" or not connection.get("credential_id"):
+                raise FuturesContractEvidenceError("A matching futures broker connection is required")
+            try:
+                credential = exact_futures_credential(connection, context)
+            except ValueError as exc:
+                raise FuturesContractEvidenceError(str(exc)) from exc
+            if not credential or not credential.get("appkey") or not credential.get("appsecret"):
+                raise FuturesContractEvidenceError("The selected futures credential is unavailable")
+            ls, success, _ = ensure_ls_login(
+                credential["appkey"], credential["appsecret"], connection.get("paper_trading", False),
+                context, node_id, product="overseas_futures", caller_name="FuturesContractInfoNode",
+            )
+            if not success:
+                raise FuturesContractEvidenceError("The selected futures broker login failed")
+            response = await asyncio.wait_for(
+                ls.overseas_futureoption().market().o3105(body=request).req_async(), timeout=20,
+            )
+            return read_contract_info(response, config)
+        except (FuturesContractEvidenceError, asyncio.TimeoutError) as exc:
+            reason = str(exc) or "Futures contract detail query timed out"
+        except Exception as exc:
+            reason = f"Futures contract detail query failed ({type(exc).__name__})"
+        context.log("warning", reason, node_id)
+        return {"value": None, "verified": False, "missing_fields": [], "error": reason}
+
+
 class FuturesOrderableQuantityNodeExecutor(NodeExecutorBase):
     """Read per-contract capacity; never place an order or replace failed evidence."""
 
@@ -8479,7 +8522,19 @@ class RealOrderEventNodeExecutor(NodeExecutorBase):
         """LS증권 실시간 주문 이벤트 구독"""
 
         # secrets에서 인증 정보 가져오기
-        credential = context.get_credential()
+        if product == "overseas_futures":
+            try:
+                credential = exact_futures_credential(config.get("connection") or {}, context)
+            except ValueError:
+                return {"error": "The selected futures credential is unavailable"}
+            connection = config.get("connection") or {}
+            owner = tuple(connection.get(key) for key in ("broker_node_id", "credential_id", "paper_trading"))
+            prior_owner = getattr(context, "_futures_order_event_owner", None)
+            if prior_owner is not None and prior_owner != owner:
+                return {"error": "A futures event stream cannot be shared across broker connections"}
+            context._futures_order_event_owner = owner
+        else:
+            credential = context.get_credential()
 
         if not credential:
             context.log("error", "Credential not found in secrets", node_id)
@@ -8487,7 +8542,8 @@ class RealOrderEventNodeExecutor(NodeExecutorBase):
 
         appkey = credential.get("appkey")
         appsecret = credential.get("appsecret")
-        paper_trading = credential.get("paper_trading", False)
+        paper_trading = (config.get("connection", {}).get("paper_trading", False)
+                         if product == "overseas_futures" else credential.get("paper_trading", False))
 
         if not appkey or not appsecret:
             context.log("error", "appkey/appsecret not found in credential", node_id)
@@ -19886,7 +19942,8 @@ class SQLiteNodeExecutor(NodeExecutorBase):
         import os
         from programgarden.database.query_builder import SQLQueryBuilder
         
-        db_name = config.get("db_name", "default.db")
+        from programgarden.database.sqlite_scope import scoped_sqlite_filename
+        db_name = scoped_sqlite_filename(config, context)
         operation = config.get("operation", "simple")
 
         # dry_run 모드에서는 SELECT만 허용. INSERT/UPDATE/DELETE/UPSERT는
@@ -20334,6 +20391,7 @@ class WorkflowExecutor:
             "OverseasStockSymbolQueryNode": SymbolQueryNodeExecutor(),
             "OverseasFuturesSymbolQueryNode": SymbolQueryNodeExecutor(),
             "FuturesContractNode": FuturesContractNodeExecutor(),
+            "OverseasFuturesContractInfoNode": FuturesContractInfoNodeExecutor(),
             "SymbolFilterNode": SymbolFilterNodeExecutor(),
             "ExclusionListNode": ExclusionListNodeExecutor(),
             "MarketUniverseNode": MarketUniverseNodeExecutor(),
@@ -22055,6 +22113,7 @@ class WorkflowJob:
         # 종목 마스터 조회 노드 — 배열을 **생성**하는 쪽이다. 상류에 배열이 붙었다고
         # 아이템 수만큼 마스터 조회를 반복하면 같은 전체 목록을 N 번 받아온다.
         "FuturesContractNode",
+        "OverseasFuturesContractInfoNode",  # One exact identity; explicit SplitNode for a batch.
         "OverseasFuturesSymbolQueryNode", "OverseasStockSymbolQueryNode", "KoreaStockSymbolQueryNode",
         "SymbolFilterNode",  # 집합 연산 노드 (배열 입력/출력)
         # LogicNode 도 집합 연산 노드다 — 상류 조건 결과 **배열 전체**를 AND/OR 해야 한다.

programgarden-2.6.0/programgarden/futures_contract_info.py

@@ -0,0 +1,91 @@
+"""Strict o3105 detail projection shared by live nodes and offline replay.
+
+Request fields follow finance/example/overseas_futureoption/run_o3105.py.
+No current quote is needed to read valid static contract metadata.
+"""
+from datetime import UTC, datetime
+import math
+
+from programgarden_finance.ls.overseas_futureoption.market.o3105.blocks import O3105InBlock
+
+
+TEXT_FIELDS = {
+    "symbol_name": "SymbolNm", "underlying_code": "BscGdsCd", "currency": "CrncyCd",
+    "trade_status_code": "DlPsblCd",
+}
+DATE_FIELDS = {
+    "maturity_date": "MtrtDt", "last_trading_date": "FnlDlDt", "first_notice_date": "FstTrsfrDt",
+    "master_received_date": "ApplDate", "korea_start_date": "DlDt",
+    "local_start_date": "OvsStrDay", "local_end_date": "OvsEndDay",
+}
+TIME_FIELDS = {"korea_start_time": "DlStrtTm", "korea_end_time": "DlEndTm",
+               "local_start_time": "OvsStrTm", "local_end_time": "OvsEndTm"}
+NUMBER_FIELDS = {"initial_margin": "OpngMgn", "maintenance_margin": "MntncMgn",
+                 "tick_size": "UntPrc", "tick_value": "MnChgAmt"}
+
+
+class FuturesContractEvidenceError(ValueError):
+    """Safe-to-display contract evidence error without broker payloads or secrets."""
+
+
+def build_contract_info_request(config):
+    identity = config.get("symbol")
+    if not isinstance(identity, dict) or not all(
+        isinstance(identity.get(key), str) and identity[key].strip() for key in ("symbol", "exchange")
+    ):
+        raise FuturesContractEvidenceError("An exact futures contract symbol and exchange are required")
+    return O3105InBlock(symbol=identity["symbol"].strip())
+
+
+def _text(block, field):
+    value = getattr(block, field) if field in block.model_fields_set else None
+    return value.strip() or None if isinstance(value, str) else None
+
+
+def _date_or_time(block, field, *, date):
+    value = _text(block, field)
+    if not value or len(value) != (8 if date else 6) or not value.isascii() or not value.isdigit():
+        return None
+    try:
+        parsed = datetime.strptime(value, "%Y%m%d" if date else "%H%M%S")
+    except ValueError:
+        return None
+    return parsed.date().isoformat() if date else parsed.time().isoformat()
+
+
+def read_contract_info(response, config, *, observed_at=None):
+    request = build_contract_info_request(config)
+    if response.status_code != 200 or response.error_msg or response.rsp_cd != "00000" or response.block is None:
+        raise FuturesContractEvidenceError("o3105 did not return a successful contract detail response")
+    block = response.block
+    if not {"Symbol", "ExchCd"} <= block.model_fields_set or block.Symbol.strip() != request.symbol:
+        raise FuturesContractEvidenceError("o3105 contract identity is absent or mismatched")
+    exchange = block.ExchCd.strip()
+    if exchange != config["symbol"]["exchange"].strip():
+        raise FuturesContractEvidenceError("o3105 exchange identity is absent or mismatched")
+    now = observed_at or datetime.now(UTC)
+    if now.tzinfo is None:
+        raise FuturesContractEvidenceError("Contract observation requires a timezone-aware timestamp")
+    value = {"symbol": block.Symbol.strip(), "exchange": exchange,
+             "source_tr": "o3105", "observed_at": now.astimezone(UTC).isoformat()}
+    value.update({name: _text(block, field) for name, field in TEXT_FIELDS.items()})
+    for fields, is_date in ((DATE_FIELDS, True), (TIME_FIELDS, False)):
+        value.update({name: _date_or_time(block, field, date=is_date) for name, field in fields.items()})
+    for name, field in NUMBER_FIELDS.items():
+        observed = getattr(block, field) if field in block.model_fields_set else None
+        valid = type(observed) in (int, float) and math.isfinite(observed) and observed >= 0
+        if name in ("tick_size", "tick_value"):
+            valid = valid and observed > 0
+        value[name] = float(observed) if valid else None
+    return {"value": value, "verified": True, "missing_fields": sorted(k for k, v in value.items() if v is None), "error": None}
+
+
+def synthetic_contract_info(config, *, observed_at=None):
+    """Legacy deep-check shape only; replay instead requires raw recorded evidence."""
+    from programgarden_finance.ls.overseas_futureoption.market.o3105.blocks import O3105OutBlock, O3105Response
+    request = build_contract_info_request(config)
+    response = O3105Response(status_code=200, rsp_cd="00000", rsp_msg="Synthetic deep-check identity", block=O3105OutBlock(
+        Symbol=request.symbol, ExchCd=config["symbol"]["exchange"].strip(),
+    ))
+    # Unknown dates/margins intentionally stay unknown; do not manufacture rollover permission.
+    return read_contract_info(response, config, observed_at=observed_at)

{programgarden-2.5.5 → programgarden-2.6.0}/programgarden/replay_events.py

@@ -12,9 +12,20 @@ from programgarden.context import WorkflowEvent
 from programgarden.replay_contracts import ContractViolation, check_contract
 
 
-def checked_events(fixture):
+DEFAULT_EVENT_LIMIT = 32
+MAX_OFFLINE_EVENT_LIMIT = 4096
+
+
+def checked_events(fixture, *, event_limit=DEFAULT_EVENT_LIMIT):
+    """Allow a trusted offline caller to raise the bound, never a fixture field.
+
+    Interactive worker callers retain 32 events. Longer acceptance runs keep all
+    cron instants and one disposable state store, bounded by replay's timeout.
+    """
+    if type(event_limit) is not int or not 0 <= event_limit <= MAX_OFFLINE_EVENT_LIMIT:
+        raise ContractViolation("events", "Event limit must be an integer from 0 to 4096")
     events = fixture.get("events", [])
-    check_contract(events, {"type": "array", "maxItems": 32, "items": {
+    check_contract(events, {"type": "array", "maxItems": event_limit, "items": {
         "type": "object", "required": ["as_of", "type", "source_node_id"],
         "additionalProperties": False, "properties": {
             "as_of": {"type": "string", "format": "date-time"},
@@ -79,8 +90,8 @@ def event_fixture(fixture, event):
     return frame
 
 
-async def replay_events(job, runner, fixture, outcome):
-    events = checked_events(fixture)
+async def replay_events(job, runner, fixture, outcome, *, event_limit=DEFAULT_EVENT_LIMIT):
+    events = checked_events(fixture, event_limit=event_limit)
     # Ancestor-only node checks may not yet contain a later event source. Final
     # verification checks all declared events against the complete graph.
     pending = iter((index, event) for index, event in enumerate(events)

{programgarden-2.5.5 → programgarden-2.6.0}/programgarden/replay_scenarios.py

@@ -23,7 +23,7 @@ def check_financial_expectations(simulation, schema):
         raise ContractViolation("live_order_count", "Replay must never submit live orders")
 
 
-def check_final_expectations(result, fixture, graph):
+def check_final_expectations(result, fixture, graph, *, event_limit=32):
     """Final acceptance asserts outputs and financial state, not just no error."""
     expected = fixture.get("expected")
     if not isinstance(expected,dict) or not expected:
@@ -39,7 +39,7 @@ def check_final_expectations(result, fixture, graph):
         if node_id not in result.initial_executed:
             raise ContractViolation(node_id, "Required path was not reached")
     from programgarden.replay_events import checked_events
-    events = checked_events(fixture)
+    events = checked_events(fixture, event_limit=event_limit)
     if len(events) != len(result.events):
         raise ContractViolation("events", "Every declared final replay event must be observed")
     has_orders = any(node["type"] in ORDER_NODES for node in graph["nodes"])

{programgarden-2.5.5 → programgarden-2.6.0}/programgarden/replay_sources.py

@@ -10,7 +10,7 @@ from programgarden.replay_external import external_record
 from programgarden.replay_triggers import fixture_instant
 
 SOURCE_NODES = frozenset({"MarketUniverseNode",
-    "FuturesContractNode", "ScreenerNode", "OverseasFuturesOrderableQuantityNode"})
+    "FuturesContractNode", "ScreenerNode", "OverseasFuturesOrderableQuantityNode", "OverseasFuturesContractInfoNode"})
 
 
 def source_contract_catalog():
@@ -21,6 +21,7 @@ def source_contract_catalog():
     The parser and independently written assertions remain authoritative.
     """
     from programgarden_finance.ls.overseas_futureoption.market.o3101.blocks import O3101OutBlock
+    from programgarden_finance.ls.overseas_futureoption.market.o3105.blocks import O3105Response
     from programgarden_finance.ls.overseas_futureoption.accno.CIDBQ01400.blocks import CIDBQ01400Response
     from programgarden_finance.ls.overseas_stock.market.g3101.blocks import G3101OutBlock
     from programgarden.executor import MarketUniverseNodeExecutor
@@ -39,6 +40,11 @@ def source_contract_catalog():
             "required_row_fields": ["Symbol", "BscGdsCd", "ExchCd", "LstngYr", "LstngM"],
             "notes": "Supply raw o3101 model fields, including explicit contract identity/month. "
                      "Native expiry/exchange/front-next selection runs at as_of; do not preselect results."},
+        "OverseasFuturesContractInfoNode": {"source_schema": O3105Response.model_json_schema(),
+            "notes": "Use the raw SDK o3105 response envelope, with status_code=200, rsp_cd=00000, "
+                     "no error_msg, and matching block.Symbol and block.ExchCd. Optional dates use "
+                     "YYYYMMDD, times HHMMSS. Omitted fields stay null; no quote is required. "
+                     "The recorded response is parsed by the native live detail parser."},
         "OverseasFuturesOrderableQuantityNode": {"source_schema": CIDBQ01400Response.model_json_schema(),
             "notes": "Use the SDK response envelope (block1, block2, status_code, rsp_cd, error_msg), "
                      "not LS wire block names. status_code=200, error_msg absent and rsp_cd=00000 or00136 "
@@ -104,6 +110,11 @@ async def execute_source(node, config, fixture, context):
         return FuturesContractNodeExecutor().select_recorded_master(rows,
             [p.strip().upper() for p in node.base_products], node.contract_selection, exchange,
             context, node.id, as_of=fixture_instant(context, node.id))
+    if node.type == "OverseasFuturesContractInfoNode":
+        from programgarden.futures_contract_info import read_contract_info
+        from programgarden_finance.ls.overseas_futureoption.market.o3105.blocks import O3105Response
+        response = O3105Response.model_validate(source, strict=True)
+        return read_contract_info(response, config, observed_at=fixture_instant(context, node.id))
     if node.type == "OverseasFuturesOrderableQuantityNode":
         from programgarden.futures_orderable import build_orderable_request, read_orderable_quantity
         from programgarden_finance.ls.overseas_futureoption.accno.CIDBQ01400.blocks import CIDBQ01400Response

{programgarden-2.5.5 → programgarden-2.6.0}/programgarden/replay_sqlite.py

@@ -20,7 +20,8 @@ async def execute_sqlite(node_id, config, context):
     if not isinstance(name, str) or not re.fullmatch(r"[A-Za-z0-9_-][A-Za-z0-9_.-]{0,119}\.db", name):
         raise ContractViolation(node_id, "Replay SQLite requires a plain .db filename")
     root = Path(context._storage_dir).resolve()
-    path = root / name
+    from programgarden.database.sqlite_scope import scoped_sqlite_filename
+    path = root / scoped_sqlite_filename(config, context)
     if path.is_symlink() or path.resolve().parent != root:
         raise ContractViolation(node_id, "SQLite path leaves the replay workspace")
     operation = config.get("operation", "simple")

{programgarden-2.5.5 → programgarden-2.6.0}/programgarden/validation_replay.py

@@ -349,7 +349,8 @@ class ReplayExecutor(WorkflowExecutor):
 
 
 async def replay(definition: dict[str, Any], fixture: dict[str, Any], *,
-                 timeout: float = 30, node_under_test: str | None = None) -> ReplayResult:
+                 timeout: float = 30, node_under_test: str | None = None,
+                 event_limit: int = 32) -> ReplayResult:
     """Run actual scheduler/mappings in disposable state; no silent soft PASS.
 
     A node check executes its actual upstream setup in the same disposable
@@ -358,6 +359,9 @@ async def replay(definition: dict[str, Any], fixture: dict[str, Any], *,
     node_under_test and always start with another fresh workspace.
     An empty branch is not an exception; required activation/output expectations
     belong to the suite and are checked explicitly by the coordinator.
+    Offline acceptance may explicitly raise event_limit (at most 4096). The
+    default worker/save path stays at 32. Every scheduled instant is still
+    required; state and the timeout span the whole timeline without resets.
     """
     outcome = ReplayResult(False, content_hash(definition), content_hash(fixture))
     outcome.node_under_test = node_under_test
@@ -391,6 +395,9 @@ async def replay(definition: dict[str, Any], fixture: dict[str, Any], *,
         context.set_workflow_job(job)
         context.start()
         async def run_all():
+            # Reject an oversized/malformed timeline before any initial action.
+            from programgarden.replay_events import checked_events
+            checked_events(fixture, event_limit=event_limit)
             if any(node.node_type in ORDER_NODES for node in resolved.nodes.values()):
                 # A no-signal branch still has account state to verify. Starting
                 # the book only on the first order loses unchanged cash/holdings
@@ -407,7 +414,7 @@ async def replay(definition: dict[str, Any], fixture: dict[str, Any], *,
                                         for node in resolved.nodes}
                 outcome.main_executed = list(outcome.executed)
                 from programgarden.replay_events import replay_events
-                await replay_events(job, runner, fixture, outcome)
+                await replay_events(job, runner, fixture, outcome, event_limit=event_limit)
 
         try:
             await asyncio.wait_for(run_all(), timeout=timeout)

{programgarden-2.5.5 → programgarden-2.6.0}/pyproject.toml

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