fix: reconcile KIS correction order chains

2026-09-12 22:12:19 +09:00
parent 6017bde744
commit 06c3f06b5d
6 changed files with 864 additions and 149 deletions
@@ -7,6 +7,7 @@ Unit tests run always; the sandbox integration test runs only when KIS
 from __future__ import annotations

 import os
+from datetime import UTC, datetime, timedelta

 import httpx
 import pytest
@@ -564,7 +565,9 @@ def test_submit_unknown_confirmed_absent_becomes_retryable_reject(monkeypatch):
    status = b.poll_fill(ack.broker_order_id, side="buy", symbol="005930")

    assert status.state == "rejected"
-    assert status.raw == {"reason": "submission_confirmed_absent"}
+    assert status.raw["reason"] == "submission_confirmed_absent"
+    assert status.raw["poll_performed"] is True
+    assert status.raw["poll_count"] == 1


 def test_fill_poll_transport_failure_uses_backoff(monkeypatch):
@@ -588,8 +591,12 @@ def test_fill_poll_transport_failure_uses_backoff(monkeypatch):
    )

    assert first.state == "unknown"
+    assert first.raw["reason"] == "fill_inquiry_transport"
+    assert "timed out" not in str(first.raw)
    assert immediate.state == "accepted"
-    assert immediate.raw == {"reason": "fill_poll_backoff"}
+    assert immediate.raw["reason"] == "fill_poll_backoff"
+    assert immediate.raw["poll_performed"] is False
+    assert immediate.raw["poll_count"] == 1
    assert len(calls) == 1

    clock[0] += 31
@@ -598,3 +605,68 @@ def test_fill_poll_transport_failure_uses_backoff(monkeypatch):
    )
    assert again.state == "unknown"
    assert len(calls) == 2
+
+
+def test_unresolved_fill_poll_uses_elapsed_bounded_backoff_and_converges(monkeypatch):
+    wall_now = datetime(2026, 9, 10, 12, 0, tzinfo=UTC)
+    b = KISBroker(
+        "12345678-01",
+        app_key="k",
+        app_secret="s",
+        base_url=_MOCK_URL,
+        clock=lambda: wall_now,
+    )
+    monkeypatch.setattr(b, "_headers", lambda _tr: {})
+    mono = [100.0]
+    monkeypatch.setattr("trex_core.adapters.broker.kis.monotonic", lambda: mono[0])
+    calls = []
+    terminal = [False]
+
+    class Response:
+        status_code = 200
+
+        def json(self):
+            calls.append(1)
+            parent = {
+                "odno": "1234", "orgn_odno": "", "ord_qty": "10",
+                "tot_ccld_qty": "0", "avg_prvs": "0", "cncl_yn": "",
+                "rjct_qty": "0", "rmn_qty": "0", "ord_dt": "20260910",
+                "ord_gno_brno": "91258", "pdno": "005930",
+            }
+            child = {
+                **parent, "odno": "1235", "orgn_odno": "1234",
+                "cnc_cfrm_qty": "10" if terminal[0] else "0",
+            }
+            return {"rt_cd": "0", "output1": [parent, child]}
+
+    monkeypatch.setattr("trex_core.adapters.broker.kis.httpx.get", lambda *a, **kw: Response())
+    submitted_at = wall_now - timedelta(hours=7)
+
+    first = b.poll_fill(
+        "91258:1234", side="buy", symbol="005930",
+        order_date="20260910", submitted_at=submitted_at,
+    )
+    assert first.state == "unknown"
+    assert first.raw["poll_performed"] is True
+    assert first.raw["poll_count"] == 1
+    assert first.raw["backoff_sec"] == 300.0
+    assert first.raw["stuck_duration_sec"] == 7 * 3600
+
+    terminal[0] = True
+    mono[0] += 299
+    skipped = b.poll_fill(
+        "91258:1234", side="buy", symbol="005930",
+        order_date="20260910", submitted_at=submitted_at,
+    )
+    assert skipped.state == "accepted"
+    assert skipped.raw["last_result_state"] == "unknown"
+    assert len(calls) == 1
+
+    mono[0] += 1
+    resolved = b.poll_fill(
+        "91258:1234", side="buy", symbol="005930",
+        order_date="20260910", submitted_at=submitted_at,
+    )
+    assert resolved.state == "cancelled"
+    assert resolved.raw["poll_count"] == 2
+    assert len(calls) == 2
@@ -222,6 +222,209 @@ def test_correction_child_row_not_misclassified_as_cancel(monkeypatch):
    assert not raw.get("order_open_confirmed", False)


+def test_correction_child_cancel_confirmed_quantity_maps_to_cancelled(monkeypatch):
+    """KIS cancel-confirm quantity is terminal evidence even when cncl_yn is blank."""
+    payload = _payload_with_child_cancel(ODNO, "0000123458", ord_qty="31", symbol="053050")
+    parent, child = payload["output1"]
+    child.update(cncl_yn="", cnc_cfrm_qty="31")
+    monkeypatch.setattr(kis_mod.httpx, "get", _fake_get(payload))
+
+    fs = _broker().poll_fill(
+        f"06010:{ODNO}", side="sell", symbol="053050", order_date="20260901"
+    )
+
+    assert fs.state == "cancelled"
+    assert fs.filled_qty == 0
+    assert fs.raw["reason"] == "replacement_chain_terminal_cancel"
+    assert "resolved_broker_order_id" not in fs.raw
+
+
+def test_live_replacement_remains_fail_closed(monkeypatch):
+    payload = _payload_with_child_cancel(ODNO, "0000123458")
+    _, child = payload["output1"]
+    child.update(cncl_yn="", cnc_cfrm_qty="0", rmn_qty="10", ord_qty="10")
+    monkeypatch.setattr(kis_mod.httpx, "get", _fake_get(payload))
+
+    fs = _broker().poll_fill(
+        f"06010:{ODNO}", side="sell", symbol="225190", order_date="20260901"
+    )
+
+    assert fs.state == "unknown"
+    assert fs.raw["reason"] == "replacement_live_unresolved"
+    assert not fs.raw.get("order_open_confirmed", False)
+
+
+def test_replacement_partial_fill_then_confirmed_cancel(monkeypatch):
+    payload = _payload_with_child_cancel(ODNO, "0000123458", ord_qty="10")
+    _, child = payload["output1"]
+    child.update(
+        cncl_yn="",
+        cnc_cfrm_qty="6",
+        tot_ccld_qty="4",
+        rmn_qty="0",
+        avg_prvs="70100",
+    )
+    monkeypatch.setattr(kis_mod.httpx, "get", _fake_get(payload))
+
+    fs = _broker().poll_fill(
+        f"06010:{ODNO}", side="sell", symbol="225190", order_date="20260901"
+    )
+
+    assert fs.state == "partially_filled"
+    assert fs.filled_qty == 4
+    assert fs.avg_price == 70100.0
+    assert fs.is_partial_cancel
+    assert fs.raw["reason"] == "replacement_chain_terminal_cancel"
+
+
+def test_repeated_cumulative_fill_across_generations_is_not_ambiguous(monkeypatch):
+    payload = _payload_with_child_cancel(ODNO, "0000123458", ord_qty="10")
+    parent, child = payload["output1"]
+    parent.update(tot_ccld_qty="4", rmn_qty="0", avg_prvs="70100")
+    child.update(
+        cncl_yn="",
+        cnc_cfrm_qty="6",
+        tot_ccld_qty="4",
+        rmn_qty="0",
+        avg_prvs="70100",
+    )
+    monkeypatch.setattr(kis_mod.httpx, "get", _fake_get(payload))
+
+    fs = _broker().poll_fill(
+        f"06010:{ODNO}", side="sell", symbol="225190", order_date="20260901"
+    )
+
+    assert fs.state == "partially_filled"
+    assert fs.filled_qty == 4
+    assert fs.avg_price == 70100.0
+    assert fs.is_partial_cancel
+
+
+def test_multi_generation_replacement_chain_terminal_cancel(monkeypatch):
+    payload = _payload_with_child_cancel(ODNO, "0000123458", ord_qty="10")
+    parent, replacement = payload["output1"]
+    replacement.update(cncl_yn="", cnc_cfrm_qty="0", rmn_qty="0")
+    terminal = {
+        **replacement,
+        "odno": "0000123459",
+        "orgn_odno": replacement["odno"],
+        "cnc_cfrm_qty": "10",
+    }
+    payload["output1"] = [terminal, parent, replacement]
+    monkeypatch.setattr(kis_mod.httpx, "get", _fake_get(payload))
+
+    fs = _broker().poll_fill(
+        f"06010:{ODNO}", side="sell", symbol="225190", order_date="20260901"
+    )
+
+    assert fs.state == "cancelled"
+    assert fs.raw["replacement_depth"] == 2
+
+
+def test_replacement_chain_branching_is_ambiguous(monkeypatch):
+    payload = _payload_with_child_cancel(ODNO, "0000123458", ord_qty="10")
+    parent, child = payload["output1"]
+    child.update(cncl_yn="", cnc_cfrm_qty="10")
+    sibling = {**child, "odno": "0000123459"}
+    payload["output1"] = [parent, child, sibling]
+    monkeypatch.setattr(kis_mod.httpx, "get", _fake_get(payload))
+
+    fs = _broker().poll_fill(
+        f"06010:{ODNO}", side="sell", symbol="225190", order_date="20260901"
+    )
+
+    assert fs.state == "unknown"
+    assert fs.raw["reason"] == "replacement_chain_ambiguous"
+
+
+def test_zero_remaining_without_cancel_confirmation_remains_unknown(monkeypatch):
+    payload = _payload_with_child_cancel(ODNO, "0000123458", ord_qty="10")
+    _, child = payload["output1"]
+    child.update(cncl_yn="", cnc_cfrm_qty="0", rmn_qty="0")
+    monkeypatch.setattr(kis_mod.httpx, "get", _fake_get(payload))
+
+    fs = _broker().poll_fill(
+        f"06010:{ODNO}", side="sell", symbol="225190", order_date="20260901"
+    )
+
+    assert fs.state == "unknown"
+    assert fs.raw["reason"] == "correction_child_present_unresolved"
+
+
+def test_stable_zero_fill_replacement_chain_converges_after_grace(monkeypatch):
+    payload = _payload_with_child_cancel(ODNO, "0000123458", ord_qty="31", symbol="053050")
+    parent, child = payload["output1"]
+    parent.update(rmn_qty="0")
+    child.update(cncl_yn="", cnc_cfrm_qty="0", rmn_qty="0")
+    monotonic_now = [100.0]
+    monkeypatch.setattr(kis_mod, "monotonic", lambda: monotonic_now[0])
+    monkeypatch.setattr(kis_mod.httpx, "get", _fake_get(payload))
+    broker = _broker()
+
+    first = broker.poll_fill(
+        f"06010:{ODNO}", side="sell", symbol="053050", order_date="20260901"
+    )
+    assert first.state == "unknown"
+    assert first.raw["reason"] == "correction_child_present_unresolved"
+
+    monotonic_now[0] += 90
+    confirmed = broker.poll_fill(
+        f"06010:{ODNO}", side="sell", symbol="053050", order_date="20260901"
+    )
+    assert confirmed.state == "cancelled"
+    assert confirmed.raw["reason"] == "replacement_chain_stable_zero_terminal"
+
+
+def test_zero_fill_terminal_grace_resets_when_chain_changes(monkeypatch):
+    payload = _payload_with_child_cancel(ODNO, "0000123458", ord_qty="31", symbol="053050")
+    parent, child = payload["output1"]
+    parent.update(rmn_qty="0")
+    child.update(cncl_yn="", cnc_cfrm_qty="0", rmn_qty="0")
+    monotonic_now = [100.0]
+    monkeypatch.setattr(kis_mod, "monotonic", lambda: monotonic_now[0])
+    monkeypatch.setattr(kis_mod.httpx, "get", _fake_get(payload))
+    broker = _broker()
+
+    first = broker.poll_fill(
+        f"06010:{ODNO}", side="sell", symbol="053050", order_date="20260901"
+    )
+    assert first.state == "unknown"
+
+    monotonic_now[0] += 90
+    child["rmn_qty"] = "31"
+    changed = broker.poll_fill(
+        f"06010:{ODNO}", side="sell", symbol="053050", order_date="20260901"
+    )
+    assert changed.raw["reason"] == "replacement_live_unresolved"
+
+    monotonic_now[0] += 90
+    child["rmn_qty"] = "0"
+    restarted_grace = broker.poll_fill(
+        f"06010:{ODNO}", side="sell", symbol="053050", order_date="20260901"
+    )
+    assert restarted_grace.state == "unknown"
+
+    monotonic_now[0] += 90
+    confirmed = broker.poll_fill(
+        f"06010:{ODNO}", side="sell", symbol="053050", order_date="20260901"
+    )
+    assert confirmed.state == "cancelled"
+
+
+def test_incomplete_cancel_confirmation_remains_unknown(monkeypatch):
+    payload = _payload_with_child_cancel(ODNO, "0000123458", ord_qty="10")
+    _, child = payload["output1"]
+    child.update(cncl_yn="", cnc_cfrm_qty="3", rmn_qty="0")
+    monkeypatch.setattr(kis_mod.httpx, "get", _fake_get(payload))
+
+    fs = _broker().poll_fill(
+        f"06010:{ODNO}", side="sell", symbol="225190", order_date="20260901"
+    )
+
+    assert fs.state == "unknown"
+    assert fs.raw["reason"] == "correction_child_present_unresolved"
+
+
 def test_partial_fill_with_child_cancel_row(monkeypatch):
    """Partial fill on parent + cancel child → partial_cancel."""
    parent = {
@@ -104,6 +104,58 @@ def test_full_external_cancel_returns_slot_to_holding():
    assert r.rolled_back == 1


+def test_unresolved_poll_observability_is_sanitized_and_deduplicated(caplog):
+    broker = ProgrammableBroker()
+    repo, _svc, intents, execution, _ledger, _writer = _wire(broker)
+    sid = _buy_to_holding(intents, execution)
+    assert sid is not None
+    intents.submit_sell(SellIntent(intent_id="s-poll-observe", slot_id=sid))
+    samples = iter([
+        ("correction_child_present_unresolved", 10),
+        ("correction_child_present_unresolved", 10),
+        ("correction_child_present_unresolved", 61),
+        ("correction_child_present_unresolved", 61),
+        ("parent_identity_mismatch", 61),
+    ])
+
+    def unresolved(side):
+        del side
+        reason, age = next(samples)
+        return FillStatus(
+            state="unknown",
+            raw={
+                "poll_performed": True,
+                "poll_count": broker.polls,
+                "stuck_duration_sec": age,
+                "last_result_reason": reason,
+                "backoff_sec": 15.0,
+                "raw_payload": {"authorization": "secret-token"},
+                "broker_order_id": "sensitive-order-id",
+            },
+        )
+
+    broker.responder = unresolved
+    with caplog.at_level(logging.INFO):
+        for _ in range(5):
+            execution.run_once()
+
+    observations = [
+        record for record in caplog.records
+        if getattr(record, "event", None) == "order_poll"
+    ]
+    warnings = [
+        record for record in caplog.records
+        if getattr(record, "event", None) == "order_poll_unresolved"
+    ]
+    assert len(observations) == 5
+    assert len(warnings) == 3  # first, long-duration threshold, reason change
+    assert observations[-1].poll_count == 6
+    assert observations[-1].stuck_duration_sec == 61
+    assert observations[-1].result_reason == "parent_identity_mismatch"
+    assert "secret-token" not in caplog.text
+    assert "sensitive-order-id" not in caplog.text
+
+
 def test_partial_fill_then_cancel_records_and_keeps_remainder():
    broker = ProgrammableBroker()
    repo, svc, intents, execution, ledger, writer = _wire(broker)
@@ -12,7 +12,7 @@ from zoneinfo import ZoneInfo
 from trex_core.adapters.broker.kis import KISBroker
 from trex_core.adapters.persistence.in_memory_intent_store import InMemoryIntentStore
 from trex_core.application.execution import ExecutionService
-from trex_core.application.intents import BuyIntent, IntentService
+from trex_core.application.intents import BuyIntent, IntentService, SellIntent
 from trex_core.domain.slot import SlotService, SlotState
 from trex_core.domain.slot.in_memory_repository import InMemorySlotRepository

@@ -30,12 +30,15 @@ class _ExchangeState:
        self.orders: list[dict[str, str]] = []
        self.fill_orders = False
        self.reject_orders = False
+        self.next_side = "02"
+        self.correction_cancel_sell = False
+        self.balance_qty: int | None = None

    def submit(self, body: dict[str, str]) -> tuple[bool, dict[str, object]]:
        self.submit_attempts += 1
        order = {
            "pdno": body["PDNO"],
-            "sll_buy_dvsn_cd": "02",
+            "sll_buy_dvsn_cd": self.next_side,
            "ord_qty": body["ORD_QTY"],
            "ord_unpr": body["ORD_UNPR"],
            "ord_dt": VIRTUAL_AT.strftime("%Y%m%d"),
@@ -65,6 +68,20 @@ class _ExchangeState:
                order["rjct_qty"] = order["ord_qty"]
                order["rmn_qty"] = "0"
            row = dict(order)
+            if self.correction_cancel_sell and order["sll_buy_dvsn_cd"] == "01":
+                row["rmn_qty"] = "0"
+                rows.append(row)
+                rows.append(
+                    {
+                        **row,
+                        "odno": f"{int(order['odno']) + 1:010d}",
+                        "orgn_odno": order["odno"],
+                        "cncl_yn": "",
+                        "cnc_cfrm_qty": "0",
+                        "rmn_qty": "0",
+                    }
+                )
+                continue
            if self.fill_orders and order["rjct_qty"] == "0":
                row["tot_ccld_qty"] = row["ord_qty"]
                row["avg_prvs"] = row["ord_unpr"]
@@ -72,11 +89,13 @@ class _ExchangeState:
        return {"rt_cd": "0", "output1": rows}

    def balance(self) -> dict[str, object]:
-        quantity = (
-            sum(int(order["ord_qty"]) for order in self.orders if order["rjct_qty"] == "0")
-            if self.fill_orders
-            else 0
-        )
+        quantity = self.balance_qty
+        if quantity is None:
+            quantity = (
+                sum(int(order["ord_qty"]) for order in self.orders if order["rjct_qty"] == "0")
+                if self.fill_orders
+                else 0
+            )
        rows = [{"pdno": SYMBOL, "hldg_qty": str(quantity)}] if quantity else []
        return {"rt_cd": "0", "output1": rows}

@@ -265,3 +284,54 @@ def test_exchange_reject_after_broker_ack_rolls_back_and_allows_one_retry():
    finally:
        server.shutdown()
        server.server_close()
+
+
+def test_stable_correction_chain_returns_pending_sell_to_holding(monkeypatch):
+    state = _ExchangeState(first_attempt_reaches_exchange=True)
+    server = _serve(state)
+    mono = [100.0]
+    monkeypatch.setattr("trex_core.adapters.broker.kis.monotonic", lambda: mono[0])
+    try:
+        repo, slots, intents, execution, slot_id = _wire(_broker(server))
+        assert slot_id is not None
+
+        execution.run_once()
+        state.fill_orders = True
+        execution = ExecutionService(
+            slots,
+            repo,
+            _broker(server),
+            instance_key=INSTANCE,
+            clock=lambda: VIRTUAL_AT,
+        )
+        execution.reconcile()
+        bought = repo.fetch_slot(slot_id)
+        assert bought is not None
+        assert bought.status is SlotState.HOLDING
+
+        state.fill_orders = False
+        state.balance_qty = 2
+        state.next_side = "01"
+        state.correction_cancel_sell = True
+        admitted = intents.submit_sell(
+            SellIntent(intent_id="virtual-sell-corrected", slot_id=slot_id)
+        )
+        assert admitted.status == "admitted"
+
+        execution.run_once()
+        unresolved = repo.fetch_slot(slot_id)
+        assert unresolved is not None
+        assert unresolved.status is SlotState.PENDING_SELL
+        assert state.submit_attempts == 2
+
+        mono[0] += 90
+        execution.run_once()
+        holding = repo.fetch_slot(slot_id)
+        assert holding is not None
+        assert holding.status is SlotState.HOLDING
+        assert holding.qty == 2
+        assert holding.broker_order_id is None
+        assert state.submit_attempts == 2
+    finally:
+        server.shutdown()
+        server.server_close()