cfquant 0.2.55__tar.gz → 0.2.57__tar.gz

{cfquant-0.2.55 → cfquant-0.2.57}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cfquant
-Version: 0.2.55
+Version: 0.2.57
 Summary: QMT local bridge and xtquant-compatible Python client.
 License: MIT
 Requires-Python: >=3.8
@@ -9,6 +9,7 @@ License-File: LICENSE
 Requires-Dist: pandas>=1.0
 Requires-Dist: packaging>=20
 Requires-Dist: psutil>=5.8
+Requires-Dist: tomli>=1.1.0; python_version < "3.11"
 Requires-Dist: pycryptodome>=3.20
 Requires-Dist: pytz
 Requires-Dist: tabulate
@@ -343,6 +344,8 @@ trader.disconnect()
 
 `XtQuantTrader`、`StockAccount`、常用行情查询和交易方法保持接近 `xtquant` 的调用方式，原有回调类通常可以继续使用。仍有部分 QMT 专有接口、字段和返回结构存在兼容边界，使用前请查看 [xtquant 原版接口适配清单](docs/xtquant原版接口适配清单.md) 和 [QMT 函数封装能力清单](docs/QMT函数封装能力清单.md)。
 
+账号订阅成功后，SDK 会在后台约每两秒重新确认订阅。用户程序保持运行时，QMT、cfquant Web 或通信服务重启后，待桥接策略恢复授权、通道可用，SDK 会自动恢复该账号的新回调；默认 Web 路由和直接 Pipe/LTtx 连接均适用。主动 `unsubscribe(account)` 后不会再恢复该账号，`stop()` / `disconnect()` 会停止后台恢复。此机制只恢复账号订阅，不补发停机期间的回调，也不重试委托或撤单。升级 SDK 后需先重启一次用户程序加载新代码，此后无需随 QMT 重启用户程序。
+
 推荐迁移顺序：**行情查询 → 资金/持仓 → 回调 → 模拟委托 → 模拟撤单 → 正式策略**。每一步都先在 Web 控制台接口测试和日志中确认，再进入下一步。
 
 ## Web 控制台

{cfquant-0.2.55 → cfquant-0.2.57}/README.md

@@ -317,9 +317,11 @@ trader.disconnect()
 
 ### 回调和接口差异
 
-`XtQuantTrader`、`StockAccount`、常用行情查询和交易方法保持接近 `xtquant` 的调用方式，原有回调类通常可以继续使用。仍有部分 QMT 专有接口、字段和返回结构存在兼容边界，使用前请查看 [xtquant 原版接口适配清单](docs/xtquant原版接口适配清单.md) 和 [QMT 函数封装能力清单](docs/QMT函数封装能力清单.md)。
-
-推荐迁移顺序：**行情查询 → 资金/持仓 → 回调 → 模拟委托 → 模拟撤单 → 正式策略**。每一步都先在 Web 控制台接口测试和日志中确认，再进入下一步。
+`XtQuantTrader`、`StockAccount`、常用行情查询和交易方法保持接近 `xtquant` 的调用方式，原有回调类通常可以继续使用。仍有部分 QMT 专有接口、字段和返回结构存在兼容边界，使用前请查看 [xtquant 原版接口适配清单](docs/xtquant原版接口适配清单.md) 和 [QMT 函数封装能力清单](docs/QMT函数封装能力清单.md)。
+
+账号订阅成功后，SDK 会在后台约每两秒重新确认订阅。用户程序保持运行时，QMT、cfquant Web 或通信服务重启后，待桥接策略恢复授权、通道可用，SDK 会自动恢复该账号的新回调；默认 Web 路由和直接 Pipe/LTtx 连接均适用。主动 `unsubscribe(account)` 后不会再恢复该账号，`stop()` / `disconnect()` 会停止后台恢复。此机制只恢复账号订阅，不补发停机期间的回调，也不重试委托或撤单。升级 SDK 后需先重启一次用户程序加载新代码，此后无需随 QMT 重启用户程序。
+
+推荐迁移顺序：**行情查询 → 资金/持仓 → 回调 → 模拟委托 → 模拟撤单 → 正式策略**。每一步都先在 Web 控制台接口测试和日志中确认，再进入下一步。
 
 ## Web 控制台
 

{cfquant-0.2.55 → cfquant-0.2.57}/cfquant/_editable_install.py

@@ -16,6 +16,7 @@ else:
 
 
 PACKAGE_NAME = "cfquant"
+TOMLI_REQUIREMENT = "tomli>=1.1.0"
 
 
 def _hidden_subprocess_kwargs():
@@ -118,6 +119,21 @@ def requirements_install_args(project_root, python_exe=None):
     return command
 
 
+def tomli_install_args(project_root=None, python_exe=None):
+    """Build the bootstrap command needed before parsing TOML on old Python."""
+    command = [
+        python_exe or sys.executable,
+        "-m",
+        "pip",
+        "install",
+        "--disable-pip-version-check",
+        "--no-input",
+    ]
+    command.extend(pip_index_args())
+    command.append(TOMLI_REQUIREMENT)
+    return command
+
+
 def _output_tail(value, limit=6000):
     text = str(value or "")
     if len(text) <= int(limit):
@@ -478,7 +494,12 @@ def project_package_version(project_root):
     try:
         import tomllib
     except ImportError:
-        from pip._vendor import tomli as tomllib
+        try:
+            import tomli as tomllib
+        except ImportError:
+            # Keep compatibility with pip versions that vendor tomli while
+            # preferring the project's explicit conditional dependency.
+            from pip._vendor import tomli as tomllib
     with (Path(project_root) / "pyproject.toml").open("rb") as stream:
         return str(tomllib.load(stream)["project"]["version"])
 
@@ -503,7 +524,24 @@ def ensure_cfquant_installed(project_root, python_exe=None):
         return 2
 
     python_exe = python_exe or sys.executable
-    expected = project_package_version(project_root)
+    try:
+        expected = project_package_version(project_root)
+    except ImportError:
+        # project_package_version runs before the project itself is installed.
+        # Bootstrap tomli here so a clean Python 3.8-3.10 environment can still
+        # complete its first startup without requiring a manual pip command.
+        print("TOML parser unavailable; installing %s before startup check." % TOMLI_REQUIREMENT)
+        bootstrap = run(tomli_install_args(project_root, python_exe), project_root)
+        if bootstrap.returncode != 0:
+            print("[ERROR] Could not install %s; cannot read pyproject.toml." % TOMLI_REQUIREMENT,
+                  file=sys.stderr)
+            return bootstrap.returncode
+        try:
+            expected = project_package_version(project_root)
+        except ImportError:
+            print("[ERROR] %s is still unavailable after bootstrap installation." % TOMLI_REQUIREMENT,
+                  file=sys.stderr)
+            return 1
     installed = installed_package_version(python_exe)
     print("cfquant installed=%s project=%s" % (installed or "missing", expected))
     if installed == expected:

{cfquant-0.2.55 → cfquant-0.2.57}/cfquant/batch_orders.py

@@ -197,6 +197,8 @@ def batch_cancel_result_rows(cancels, seqs=None):
 def batch_result(account, batch_id, asynchronous, results, operation="order"):
     counts = {name: sum(row["status"] == name for row in results)
               for name in ("submitted", "failed", "unknown", "skipped")}
+    counts["rejected"] = sum(row.get("dispatched") is False for row in results)
+    counts["retryable"] = sum(row.get("safe_to_retry") is True for row in results)
     return dict(counts, batch_id=batch_id, account=account, asynchronous=asynchronous,
                 operation=operation, execution="qmt", total=len(results), attempted=len(results) - counts["skipped"],
                 ok=counts["submitted"] == len(results), results=results)
@@ -207,6 +209,19 @@ def batch_unknown(rows, error):
         row.update(status="unknown", ok=None, error=str(error) or type(error).__name__)
 
 
+def batch_rejected(rows, error):
+    """Mark a rejection known to happen before QMT dispatch."""
+    details = getattr(error, "error_details", None)
+    details = details if isinstance(details, dict) else {}
+    message = str(error) or type(error).__name__
+    for row in rows:
+        row.update(status="failed", ok=False, error=message, dispatched=False,
+                   safe_to_retry=details.get("safe_to_retry") is True,
+                   retry_when=details.get("retry_when", ""),
+                   error_code=details.get("code", ""),
+                   error_stage=details.get("stage", "before_dispatch"))
+
+
 def validate_batch_response(result, params, asynchronous):
     expected = params["orders"]
     if (not isinstance(result, dict) or result.get("execution") != "qmt"

{cfquant-0.2.55 → cfquant-0.2.57}/cfquant/cftrader.py

@@ -1,7 +1,7 @@
 """Order-only extensions sharing an existing XtQuantTrader session and callbacks."""
 
 from .batch_orders import (
-    batch_cancel_result_rows, batch_result, batch_result_rows, batch_unknown,
+    batch_cancel_result_rows, batch_rejected, batch_result, batch_result_rows, batch_unknown,
     prepare_batch_cancels, prepare_batch_orders, validate_batch_cancel_response, validate_batch_response,
 )
 from .protocol import new_id
@@ -86,9 +86,18 @@ class CfQuantTrader:
             result = validate_batch_response(response, params, asynchronous)
         except Exception as error:
             results = batch_result_rows(rows, seqs)
-            batch_unknown(results, "Batch response unavailable; QMT may still execute the batch: %s" % error)
+            if getattr(error, "dispatched", None) is False:
+                batch_rejected(results, error)
+            else:
+                batch_unknown(results, "Batch response unavailable; QMT may still execute the batch: %s" % error)
             result = batch_result(account, batch_id, asynchronous, results)
             result["request_error"] = str(error) or type(error).__name__
+            details = getattr(error, "error_details", None)
+            if isinstance(details, dict):
+                result.update(error_code=details.get("code", ""), error_stage=details.get("stage", ""),
+                              dispatched=details.get("dispatched"), safe_to_retry=details.get("safe_to_retry") is True,
+                              retry_when=details.get("retry_when", ""),
+                              runtime_instance_id=details.get("runtime_instance_id", ""))
         if asynchronous:
             for row in result["results"]:
                 if row["status"] in ("failed", "skipped"):
@@ -113,7 +122,16 @@ class CfQuantTrader:
             return validate_batch_cancel_response(response, params, asynchronous)
         except Exception as error:
             results = batch_cancel_result_rows(rows, seqs)
-            batch_unknown(results, "Batch cancel response unavailable; QMT may still execute the batch: %s" % error)
+            if getattr(error, "dispatched", None) is False:
+                batch_rejected(results, error)
+            else:
+                batch_unknown(results, "Batch cancel response unavailable; QMT may still execute the batch: %s" % error)
             result = batch_result(account, batch_id, asynchronous, results, operation="cancel")
             result["request_error"] = str(error) or type(error).__name__
+            details = getattr(error, "error_details", None)
+            if isinstance(details, dict):
+                result.update(error_code=details.get("code", ""), error_stage=details.get("stage", ""),
+                              dispatched=details.get("dispatched"), safe_to_retry=details.get("safe_to_retry") is True,
+                              retry_when=details.get("retry_when", ""),
+                              runtime_instance_id=details.get("runtime_instance_id", ""))
             return result

{cfquant-0.2.55 → cfquant-0.2.57}/cfquant/client.py

@@ -12,8 +12,17 @@ from .protocol import decode_value, dumps_message, loads_message, new_id, pack_r
 from .rpc_timing import RpcTiming
 
 
-class CfquantError(RuntimeError):
-    pass
+class CfquantError(RuntimeError):
+    """RPC failure retaining the server's structured rejection details."""
+
+    def __init__(self, message="", details=None):
+        super(CfquantError, self).__init__(message)
+        self.error_details = dict(details) if isinstance(details, dict) else {}
+        self.code = self.error_details.get("code", "")
+        self.stage = self.error_details.get("stage", "")
+        self.dispatched = self.error_details.get("dispatched")
+        self.safe_to_retry = self.error_details.get("safe_to_retry", False) is True
+        self.retry_when = self.error_details.get("retry_when", "")
 
 
 class CfquantTimeout(TimeoutError):
@@ -209,6 +218,7 @@ class LTtxRpcClient(object):
                 with self._pending_lock:
                     self._pending[request_id] = q
                 self._push("request", raw, request_channel or self.request_channel)
+                timing.sent()
             try:
                 msg = _wait_response(q, effective_timeout)
             except queue.Empty:
@@ -216,7 +226,7 @@ class LTtxRpcClient(object):
             timing.received(msg)
             if not msg.get("ok"):
                 err = msg.get("error") or {}
-                raise CfquantError(err.get("message") or str(err))
+                raise CfquantError(err.get("message") or str(err), details=err)
             return timing.decode(msg.get("result"), decode_value)
         except (KeyboardInterrupt, SystemExit):
             self.close()

{cfquant-0.2.55 → cfquant-0.2.57}/cfquant/management.py

@@ -100,6 +100,7 @@ class RuntimeManager:
         self._process = None
         self.accounts = AccountManager(self)
         self.updates = UpdateManager(self)
+        self.remote = RemoteManager(self)
         # Local service requests should never be sent to an HTTP proxy.
         self._opener = urllib.request.build_opener(urllib.request.ProxyHandler({}))
 
@@ -337,6 +338,21 @@ class RuntimeManager:
         configure(host=info["lttx_host"], port=info["lttx_port"], transport="web_lttx")
 
 
+class RemoteManager:
+    """Opt-in connection using a project API key created on the official site."""
+
+    def __init__(self, runtime):
+        self.runtime = runtime
+
+    def status(self):
+        return self.runtime._request("GET", "/api/remote-management")
+
+    def configure(self, *, enabled=True, api_key=None, permissions=None):
+        body = {"enabled": bool(enabled)}
+        body.update({k: v for k, v in {"api_key": api_key, "permissions": permissions}.items() if v is not None})
+        return self.runtime._request("POST", "/api/remote-management", body)
+
+
 class AccountManager:
     def __init__(self, runtime):
         self.runtime = runtime

{cfquant-0.2.55 → cfquant-0.2.57}/cfquant/normal_bridge.py

@@ -837,6 +837,7 @@ class NormalQmtBridge(TxTradeBridge):
             if not active:
                 return
             msg = active[0][0]
+            dispatch_started = time.perf_counter()
             result = self._dispatch(msg.get("action"), msg.get("params") or {}, msg)
             with self.coalesce_lock:
                 entry = self.coalesced_requests.pop(coalesce_key, None)
@@ -847,6 +848,15 @@ class NormalQmtBridge(TxTradeBridge):
             encoded_result = encode_response_result(result)
             while response_waiters:
                 waiter_msg, _ = response_waiters[0]
+                if msg.get("_response_meta") and str(msg.get("action", "")).startswith("xttrader.query_stock_"):
+                    # Coalesced readers share execution, but each keeps its own ID
+                    # and queue delay (including readers arriving during execution).
+                    timing = dict(msg["_response_meta"]["timing"]["qmt"])
+                    received = waiter_msg.get("_received_monotonic")
+                    if received is not None:
+                        timing["queue_ms"] = round(max(0.0, dispatch_started - received) * 1000, 3)
+                    timing["coalesced_request_id"] = msg.get("id")
+                    waiter_msg["_response_meta"] = {"timing": {"qmt": timing}}
                 self._send_response(waiter_msg, result, encoded_result=encoded_result)
                 response_waiters.pop(0)
             self._log(
@@ -864,6 +874,13 @@ class NormalQmtBridge(TxTradeBridge):
                 % (source, msg.get("action"), msg.get("id"), len(waiters), e)
             )
             for waiter_msg, _ in waiters:
+                if msg.get("_response_meta") and str(msg.get("action", "")).startswith("xttrader.query_stock_"):
+                    timing = dict(msg["_response_meta"]["timing"]["qmt"])
+                    received = waiter_msg.get("_received_monotonic")
+                    if received is not None:
+                        timing["queue_ms"] = round(max(0.0, dispatch_started - received) * 1000, 3)
+                    timing["coalesced_request_id"] = msg.get("id")
+                    waiter_msg["_response_meta"] = {"timing": {"qmt": timing}}
                 self._send_error(waiter_msg, e)
 
     def _on_whole_quote(self, data):
@@ -908,6 +925,13 @@ class NormalQmtBridge(TxTradeBridge):
         client_id = msg.get("client_id") or msg.get("reply_channel")
         if not client_id:
             return
+        if (not msg.get("_response_meta") and str(msg.get("action", "")).startswith("xttrader.query_stock_")
+                and str(error) == "read-only request expired before QMT execution"):
+            received = msg.get("_received_monotonic")
+            msg["_response_meta"] = {"timing": {"qmt": {
+                "available": True, "executed": False, "native_ms": 0.0, "execute_ms": 0.0,
+                "queue_ms": round((time.perf_counter() - received) * 1000, 3) if received is not None else None,
+            }}}
         self._log(
             "normal bridge send_error action=%s id=%s client_id=%s error=%s"
             % (msg.get("action"), msg.get("id"), client_id, error)

{cfquant-0.2.55 → cfquant-0.2.57}/cfquant/pipe_client.py

@@ -48,18 +48,24 @@ class PipeRpcClient(object):
             if self._started:
                 self._started = False
                 self._close_conns_locked()
-            self._rx_conn = connect_pipe(self.pipe_name, timeout_ms=self.connect_timeout_ms)
-            self._rx_conn.write_frame(dumps_pipe_message({
-                "type": "hello",
-                "role": "api_rx",
-                "client_id": self.client_id,
-            }))
-            self._tx_conn = connect_pipe(self.pipe_name, timeout_ms=self.connect_timeout_ms)
-            self._tx_conn.write_frame(dumps_pipe_message({
-                "type": "hello",
-                "role": "api_tx",
-                "client_id": self.client_id,
-            }))
+            try:
+                self._rx_conn = connect_pipe(self.pipe_name, timeout_ms=self.connect_timeout_ms)
+                self._rx_conn.write_frame(dumps_pipe_message({
+                    "type": "hello",
+                    "role": "api_rx",
+                    "client_id": self.client_id,
+                }))
+                self._tx_conn = connect_pipe(self.pipe_name, timeout_ms=self.connect_timeout_ms)
+                self._tx_conn.write_frame(dumps_pipe_message({
+                    "type": "hello",
+                    "role": "api_tx",
+                    "client_id": self.client_id,
+                }))
+            except BaseException:
+                # A retry must not orphan the receive pipe when opening or
+                # registering the send pipe failed halfway through startup.
+                self.close()
+                raise
             self._started = True
             self._closed = False
             generation = self._event_dispatcher.start()
@@ -95,6 +101,7 @@ class PipeRpcClient(object):
                     self._pending[request_id] = q
                 try:
                     self._send_request(raw, request_channel or self.request_channel)
+                    timing.sent()
                 except Exception:
                     self.close()
                     raise
@@ -111,7 +118,7 @@ class PipeRpcClient(object):
                 err = msg.get("error") or {}
                 from .client import CfquantError
 
-                raise CfquantError(err.get("message") or str(err))
+                raise CfquantError(err.get("message") or str(err), details=err)
             return timing.decode(msg.get("result"), decode_value)
         except (KeyboardInterrupt, SystemExit):
             self.close()

{cfquant-0.2.55 → cfquant-0.2.57}/cfquant/protocol.py

@@ -215,10 +215,11 @@ def encode_error(error):
         return None
     if isinstance(error, dict):
         return error
-    return {
-        "type": type(error).__name__,
-        "message": str(error),
-    }
+    details = getattr(error, "error_details", None)
+    result = dict(details) if isinstance(details, dict) else {}
+    result.setdefault("type", type(error).__name__)
+    result["message"] = str(error)
+    return result
 
 
 def encode_value(value):

{cfquant-0.2.55 → cfquant-0.2.57}/cfquant/qmt_component_agent.js

@@ -115,10 +115,19 @@ function noticeKind(rows) {
 }
 
 function submit(root) {
+  const rows = walk(root);
+  const edits = rows.filter(row => row.echo_mode === 2 && row.visible && row.enabled);
+  // Check on the GUI thread as well: an update can disable the button after
+  // Python has inspected it. A declined submission is safe to retry later.
+  if (edits.length !== 1 || !hasText(ptr(edits[0].address)) ||
+      !rows.some(row => row.visible && row.enabled && /^登\s*录(?:[（(]\d+[)）])?$/.test(row.label || ''))) {
+    return {submitted: false};
+  }
   passwordEditor(root);
   const login = fn(Process.getModuleByName('LoginDialog.dll'),
     '?slot_loginClicked@CLoginDialog@TC@@QEAAXXZ', 'void', ['pointer']);
   login(root);
+  return {submitted: true};
 }
 
 function loginIdentity(root) {
@@ -190,7 +199,7 @@ rpc.exports = {
       const edits = rows.filter(row => row.echo_mode === 2 && row.visible);
       if (edits.length > 1) throw new Error('Multiple password editors are visible');
       return {is_login: true, has_password: edits.length === 1 && hasText(ptr(edits[0].address)),
-        busy: edits.length === 0, login_identity: loginIdentity(root), notice: noticeKind(rows),
+        busy: edits.length === 0 || !edits[0].enabled, login_identity: loginIdentity(root), notice: noticeKind(rows),
         login_enabled: rows.some(row => row.visible && row.enabled && /^登\s*录(?:[（(]\d+[)）])?$/.test(row.label || ''))};
     });
   },
@@ -210,7 +219,7 @@ rpc.exports = {
       return {acknowledged: true};
     });
   },
-  submit(hwnd) { return onGui(hwnd, () => { submit(getRoot(hwnd)); return {submitted: true}; }); },
+  submit(hwnd) { return onGui(hwnd, () => submit(getRoot(hwnd))); },
   close(hwnd) { return onGui(hwnd, () => ({closed: closeWidget(getRoot(hwnd))})); },
   clicklabel(hwnd, text) {
     return onGui(hwnd, () => {

{cfquant-0.2.55 → cfquant-0.2.57}/cfquant/qmt_component_login.py

@@ -16,6 +16,10 @@ class QmtNotReady(RuntimeError):
     pass
 
 
+class QmtProcessExited(RuntimeError):
+    pass
+
+
 def verify_environment(directory):
     """Validate dependencies and native ABI before stopping a running terminal."""
     try:
@@ -37,8 +41,13 @@ def verify_environment(directory):
             raise RuntimeError("QMT 组件自动登录需要 64 位客户端")
 
 
-def auto_login(backend, password_provider):
-    """Replace existing password contents and submit the supplied credential once."""
+def auto_login(backend, password_provider, *, retry_not_ready=False, login_account=None,
+               should_cancel=lambda: False, on_wait=lambda phase: None):
+    """Wait through startup/update when managed, and submit the credential once.
+
+    Readiness retries never force a disabled button. After submission, a timeout
+    only renews observation: it is not evidence that another submission is safe.
+    """
     attempts = []
     password_requested = False
 
@@ -46,28 +55,59 @@ def auto_login(backend, password_provider):
         return {"outcome": outcome, "login_succeeded": outcome in ("logged_in", "already_logged_in"),
                 "attempts": attempts, "password_requested": password_requested}
 
-    if backend.already_logged_in():
-        return result("already_logged_in")
-    state = backend.state()
-    if state.get("busy"):
-        return result("login_not_ready")
-    if state.get("notice") in ("challenge", "network_error"):
-        return result(state["notice"])
-    if state.get("notice") == "credential_error":
-        backend.acknowledge_failure()
-    password_requested = True
-    password = password_provider()
-    if not password:
-        return result("password_required")
-    try:
-        backend.fill(password)
-    finally:
-        password = None
-    if not backend.state()["login_enabled"]:
-        return result("login_not_ready")
-    backend.submit()
-    attempts.append("provided")
-    return result(backend.wait_outcome())
+    while True:
+        if should_cancel():
+            return result("cancelled")
+        if backend.already_logged_in():
+            if login_account is not None:
+                backend.select_account(login_account)
+            return result("already_logged_in")
+        state = backend.state()
+        if state.get("notice") in ("challenge", "network_error"):
+            return result(state["notice"])
+        if not state.get("busy"):
+            if not password_requested or not state.get("has_password"):
+                if not password_requested:
+                    if state.get("notice") == "credential_error":
+                        backend.acknowledge_failure()
+                    if login_account is not None:
+                        backend.select_account(login_account, replace=True)
+                if should_cancel():
+                    return result("cancelled")
+                password_requested = True
+                password = password_provider()
+                if not password:
+                    return result("password_required")
+                try:
+                    backend.fill(password)
+                finally:
+                    password = None
+                state = backend.state()
+            if state.get("login_enabled") and not state.get("busy"):
+                if should_cancel():
+                    return result("cancelled")
+                try:
+                    backend.submit()
+                except QmtNotReady:
+                    # The button can become disabled between status and submit.
+                    pass
+                else:
+                    attempts.append("provided")
+                    break
+        if not retry_not_ready:
+            return result("login_not_ready")
+        on_wait("waiting_ready")
+        time.sleep(0.5)
+
+    on_wait("logging_in")
+    while True:
+        if should_cancel():
+            return result("cancelled")
+        outcome = backend.wait_outcome()
+        if outcome != "timeout" or not retry_not_ready:
+            return result(outcome)
+        on_wait("logging_in")
+        time.sleep(0.5)
 
 
 def select_binding(config_path, name):
@@ -104,6 +144,7 @@ class QtLoginBackend:
         self.session = None
         self.mutex = None
         self.messages = []
+        self.should_cancel = lambda: False
         self.foreground_before = win32gui.GetForegroundWindow()
         expected = (directory / "XtItClient.exe").resolve()
         matches = []
@@ -114,6 +155,8 @@ class QtLoginBackend:
             except (psutil.NoSuchProcess, psutil.AccessDenied):
                 continue
         if not matches:
+            if expected_pid is not None and not psutil.pid_exists(expected_pid):
+                raise QmtProcessExited("QMT process exited")
             raise QmtNotReady("QMT process is not ready")
         if len(matches) != 1:
             raise RuntimeError("Expected exactly one running QMT for this binding directory")
@@ -167,11 +210,18 @@ class QtLoginBackend:
         return result
 
     def already_logged_in(self):
+        if self.session.is_detached:
+            raise QmtProcessExited("QMT automation session detached")
+        if not self.existing_main or self.hwnd is not None:
+            for hwnd in self.windows():
+                if self.api.status(str(hwnd))["result"].get("is_main"):
+                    self.existing_main, self.main_hwnd, self.hwnd = True, hwnd, None
+                    break
         return self.existing_main and self.hwnd is None
 
     def state(self):
         state = self.api.status(str(self.hwnd))["result"]
-        if not state.get("is_login") or not self.identity or state.get("login_identity") != self.identity:
+        if not state.get("is_login") or state.get("login_identity") != self.identity:
             raise RuntimeError("Login window or selected account changed; stopping")
         state.pop("login_identity", None)
         for hwnd in self.windows():
@@ -197,8 +247,9 @@ class QtLoginBackend:
     def submit(self):
         state = self.state()
         if not state["has_password"] or not state["login_enabled"]:
-            raise RuntimeError("Login is not ready")
-        self.api.submit(str(self.hwnd))
+            raise QmtNotReady("Login is not ready")
+        if not self.api.submit(str(self.hwnd))["result"]["submitted"]:
+            raise QmtNotReady("Login is not ready")
 
     def fill(self, password):
         self.state()
@@ -207,6 +258,10 @@ class QtLoginBackend:
     def wait_outcome(self):
         deadline = time.monotonic() + self.timeout
         while time.monotonic() < deadline:
+            if self.should_cancel():
+                return "cancelled"
+            if self.session.is_detached:
+                raise QmtProcessExited("QMT automation session detached")
             windows = self.windows()
             for hwnd in windows:
                 caption = self.gui.GetWindowText(hwnd)
@@ -291,28 +346,41 @@ def main():
 
 
 def login_running_qmt(directory, login_account="", password_provider=lambda: "", expected_pid=None,
-                      startup_timeout=60, timeout=40):
-    """Wait for a freshly launched QMT, then execute one bounded login flow."""
-    deadline = time.monotonic() + startup_timeout
+                      startup_timeout=60, timeout=40, *, should_cancel=lambda: False,
+                      on_wait=lambda phase: None, before_poll=lambda: None):
+    """Wait for QMT startup/updates and observe login until success or rejection.
+
+    The web worker uses startup_timeout=None to wait while its process is alive.
+    Cancellation stops waiting when that worker is disabled or superseded.
+    """
+    cancelled = should_cancel
+    def should_cancel():
+        if cancelled():
+            return True
+        before_poll()
+        return cancelled()
+
+    deadline = None if startup_timeout is None else time.monotonic() + startup_timeout
+    backend = None
     while True:
+        if should_cancel():
+            return {"outcome": "cancelled", "login_succeeded": False, "attempts": []}
         try:
             backend = QtLoginBackend(Path(directory), timeout, expected_pid=expected_pid)
             break
+        except QmtProcessExited:
+            return {"outcome": "process_exited", "login_succeeded": False, "attempts": []}
         except QmtNotReady:
-            if time.monotonic() >= deadline:
+            if deadline is not None and time.monotonic() >= deadline:
                 return {"outcome": "startup_timeout", "login_succeeded": False, "attempts": []}
+            on_wait("waiting_ready")
             time.sleep(0.5)
     try:
-        if not backend.already_logged_in() and backend.state().get("busy"):
-            outcome = backend.wait_outcome()
-            if outcome == "logged_in":
-                # Reopen only the automation session to verify the resulting user.
-                backend.close()
-                backend = QtLoginBackend(Path(directory), timeout, expected_pid=expected_pid)
-            elif outcome != "credential_error":
-                return {"outcome": outcome, "login_succeeded": False, "attempts": []}
-        backend.select_account(login_account, replace=True)
-        return auto_login(backend, password_provider)
+        backend.should_cancel = should_cancel
+        return auto_login(backend, password_provider, retry_not_ready=True, login_account=login_account,
+                          should_cancel=should_cancel, on_wait=on_wait)
+    except QmtProcessExited:
+        return {"outcome": "process_exited", "login_succeeded": False, "attempts": []}
     finally:
         backend.close()