cfquant 0.2.58__tar.gz → 0.2.59__tar.gz

{cfquant-0.2.58 → cfquant-0.2.59}/MANIFEST.in

@@ -5,6 +5,7 @@ include cfquant_pipe_hub.py
 
 recursive-include cfquant *.py
 include cfquant/qmt_component_agent.js
+include cfquant/qmt_strategy_agent.js
 recursive-include cfquant/tests *.py *.md
 recursive-include LTtx *.py
 include LTtx/tx/Config.txt

{cfquant-0.2.58 → cfquant-0.2.59}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cfquant
-Version: 0.2.58
+Version: 0.2.59
 Summary: QMT local bridge and xtquant-compatible Python client.
 License: MIT
 Requires-Python: >=3.8

{cfquant-0.2.58 → cfquant-0.2.59}/cfquant/qmt_component_login.py

@@ -125,7 +125,7 @@ def select_binding(config_path, name):
 
 
 class QtLoginBackend:
-    def __init__(self, directory, timeout=40, expected_pid=None):
+    def __init__(self, directory, timeout=40, expected_pid=None, *, agent_extension=""):
         try:
             from .qmt_dependencies import import_login_module
         except ImportError:
@@ -178,7 +178,8 @@ class QtLoginBackend:
             readiness.unload()
             if not ready:
                 raise QmtNotReady("QMT login modules are still loading")
-            script = self.session.create_script(Path(__file__).with_name("qmt_component_agent.js").read_text(encoding="utf-8"))
+            source = Path(__file__).with_name("qmt_component_agent.js").read_text(encoding="utf-8")
+            script = self.session.create_script(source + "\n" + agent_extension)
             script.on("message", lambda message, data: self.messages.append("agent_error") if message.get("type") == "error" else None)
             script.load()
             self.script, self.api = script, script.exports_sync

cfquant-0.2.59/cfquant/qmt_strategy_agent.js

@@ -0,0 +1,131 @@
+// Appended to qmt_component_agent.js. All access runs on QMT's GUI thread.
+// The Python backend checks the tested Formula.dll hash before loading this.
+const strategyFormula = Process.getModuleByName('Formula.dll');
+const strategyXml = Process.getModuleByName('Qt5Xml.dll');
+const strategyManager = fn(strategyFormula, '?instance@?$CSingletonT@VCStrategyTradeManager@TC@@@utils@@SAPEAVCStrategyTradeManager@TC@@XZ', 'pointer', []);
+const strategySave = fn(strategyFormula, '?saveSettings@CStrategyTradeManager@TC@@QEAAXAEAVQDomElement@@AEAVQDomDocument@@@Z', 'void', ['pointer', 'pointer', 'pointer']);
+// isStrategyRun takes a request identifier; isFomrulaRun takes a formula name.
+const strategyRunning = fn(strategyFormula, '?isFomrulaRun@CStrategyTradeManager@TC@@QEAA_NAEBVQString@@@Z', 'bool', ['pointer', 'pointer']);
+const strategyWhitelistReady = fn(strategyFormula, '?isConnWhiteListReady@CStrategyTradeManager@TC@@QEBA_NXZ', 'bool', ['pointer']);
+const strategyRun = fn(strategyFormula, '?runStrategy@CStrategyTradeManager@TC@@QEAAXHAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@Z', 'void', ['pointer', 'int', 'pointer']);
+const strategyDocCtor = fn(strategyXml, '??0QDomDocument@@QEAA@XZ', 'pointer', ['pointer']);
+const strategyDocDtor = fn(strategyXml, '??1QDomDocument@@QEAA@XZ', 'void', ['pointer']);
+const strategyElemDtor = fn(strategyXml, '??1QDomElement@@QEAA@XZ', 'void', ['pointer']);
+const strategyCreateElem = fn(strategyXml, '?createElement@QDomDocument@@QEAA?AVQDomElement@@AEBVQString@@@Z', 'pointer', ['pointer', 'pointer', 'pointer']);
+const strategyFirst = fn(strategyXml, '?firstChildElement@QDomNode@@QEBA?AVQDomElement@@AEBVQString@@@Z', 'pointer', ['pointer', 'pointer', 'pointer']);
+const strategyNext = fn(strategyXml, '?nextSiblingElement@QDomNode@@QEBA?AVQDomElement@@AEBVQString@@@Z', 'pointer', ['pointer', 'pointer', 'pointer']);
+const strategyNull = fn(strategyXml, '?isNull@QDomNode@@QEBA_NXZ', 'bool', ['pointer']);
+const strategyAttr = fn(strategyXml, '?attribute@QDomElement@@QEBA?AVQString@@AEBV2@0@Z', 'pointer', ['pointer', 'pointer', 'pointer', 'pointer']);
+
+function strategyString(text, action) {
+  const value = Memory.alloc(8);
+  stringCtor(value, Memory.allocUtf16String(text), text.length);
+  try { return action(value); } finally { stringDtor(value); }
+}
+
+function strategyAttribute(element, name) {
+  return strategyString(name, key => strategyString('', empty => {
+    const value = Memory.alloc(8);
+    strategyAttr(element, value, key, empty);
+    try { return stringData(value).readUtf16String(stringSize(value)); }
+    finally { stringDtor(value); }
+  }));
+}
+
+function strategySnapshot(root) {
+  if (!hasType(root, 'TC::CMainWindow')) throw new Error('QMT is not logged in');
+  const manager = strategyManager();
+  if (manager.isNull()) throw new Error('Strategy manager unavailable');
+  const doc = Memory.alloc(64), parent = Memory.alloc(64), models = [];
+  strategyDocCtor(doc);
+  try {
+    strategyString('Models', tag => strategyCreateElem(doc, parent, tag));
+    try {
+      // Serializes only into our temporary DOM; no configuration is written.
+      strategySave(manager, parent, doc);
+      strategyString('item', tag => {
+        let element = Memory.alloc(64);
+        strategyFirst(parent, element, tag);
+        try {
+          while (!strategyNull(element)) {
+            if (models.length >= 1000) throw new Error('Too many QMT models');
+            const row = {};
+            for (const key of ['id', 'name', 'account', 'm_strAccountKey', 'runMode',
+                               'startupAutorun', 'eStrategyType', 'stock', 'peroid']) {
+              row[key] = strategyAttribute(element, key);
+            }
+            row.running = Boolean(strategyString(row.name, name => strategyRunning(manager, name)));
+            models.push(row);
+            const next = Memory.alloc(64);
+            strategyNext(element, next, tag);
+            strategyElemDtor(element);
+            element = next;
+          }
+        } finally { strategyElemDtor(element); }
+      });
+    } finally { strategyElemDtor(parent); }
+  } finally { strategyDocDtor(doc); }
+  return {models, whitelist_ready: Boolean(strategyWhitelistReady(manager))};
+}
+
+rpc.exports.strategystatus = hwnd => onGui(hwnd, () => strategySnapshot(getRoot(hwnd)));
+// These two additional DLL builds are verified by the Python backend before
+// accessing the message dialog's content widget (Dialog.dll: setContent).
+function illegalIpNotice(hwnd) {
+  const root = getRoot(hwnd);
+  if (!hasType(root, 'XP::CGlobalMessageDialog') || !isVisible(root)) return null;
+  const content = root.add(0xe8).readPointer();
+  if (content.isNull() || !childObjects(root).some(child => child.equals(content))) {
+    throw new Error('Unexpected QMT message content widget');
+  }
+  const value = Memory.alloc(8);
+  fn(Process.getModuleByName('BaseWidget.dll'), '?getText@CSimpleTextWidget@XP@@QEBA?AVQString@@XZ',
+     'pointer', ['pointer', 'pointer'])(content, value);
+  let text;
+  try { text = stringData(value).readUtf16String(stringSize(value)); }
+  finally { stringDtor(value); }
+  if (!/^\[防外接\]\s*Python进程访问了网络地址\s*\[[^\]]+\]\s*[，,]\s*策略运行中止[！!]\s*$/.test(text)) return null;
+  return {hwnd, text};
+}
+rpc.exports.illegalipnotice = hwnd => onGui(hwnd, () => illegalIpNotice(hwnd));
+rpc.exports.dismissillegalip = (mainHwnd, hwnd, text, expected) => onGui(mainHwnd, () => {
+  const models = strategySnapshot(getRoot(mainHwnd)).models;
+  for (const target of expected) {
+    const matches = models.filter(model => model.name === target.name);
+    if (matches.length !== 1 || Object.keys(target).some(key => matches[0][key] !== target[key])) {
+      throw new Error('Strategy binding changed before warning dismissal');
+    }
+  }
+  if (!expected.length) throw new Error('No bound strategy');
+  const current = illegalIpNotice(hwnd);
+  if (!current) return {outcome: 'already_hidden_or_changed', closed: false};
+  if (current.text !== text) return {outcome: 'message_changed', closed: false};
+  fn(Process.getModuleByName('Dialog.dll'), '?closeMessage@CGlobalMessageDialog@XP@@SAXXZ', 'void', [])();
+  const closed = !isVisible(getRoot(hwnd));
+  return {outcome: closed ? 'closed' : 'close_failed', closed};
+});
+rpc.exports.strategystart = (hwnd, expected) => onGui(hwnd, () => {
+  // Re-read on the same GUI turn as the mutation. Cached IDs are insufficient.
+  const snapshot = strategySnapshot(getRoot(hwnd));
+  const matches = snapshot.models.filter(row => row.name === expected.name);
+  if (matches.length !== 1) throw new Error('No unique bound strategy');
+  const model = matches[0];
+  for (const key of ['id', 'name', 'account', 'm_strAccountKey', 'runMode',
+                     'startupAutorun', 'eStrategyType', 'stock', 'peroid']) {
+    if (typeof expected[key] !== 'string' || !expected[key] || model[key] !== expected[key]) {
+      throw new Error('Strategy binding changed: ' + key);
+    }
+  }
+  if (!/^CFQ_[A-Za-z0-9_]+$/.test(model.name) || model.startupAutorun !== '1' ||
+      model.eStrategyType !== '4' || !/^[1-9][0-9]*$/.test(model.id) || Number(model.id) > 2147483647) {
+    throw new Error('Not an eligible managed strategy');
+  }
+  if (model.running) return {outcome: 'already_running', requested: false};
+  if (!snapshot.whitelist_ready) return {outcome: 'waiting_whitelist', requested: false};
+  // Empty MSVC x64 release std::string (SSO). Allowed only on the tested build.
+  const reason = Memory.alloc(32);
+  reason.writeByteArray(new Uint8Array(32));
+  reason.add(24).writeU64(15);
+  strategyRun(strategyManager(), Number(model.id), reason);
+  return {outcome: 'start_requested', requested: true};
+});

cfquant-0.2.59/cfquant/qmt_strategy_recovery.py

@@ -0,0 +1,480 @@
+"""Recover the current binding's stopped QMT models through native Qt methods.
+
+No mouse/keyboard events, order calls, whitelist changes, or terminal restarts.
+The command line defaults to inspection; --ensure/--watch enable recovery.
+"""
+import argparse
+import copy
+import datetime
+import hashlib
+import json
+import os
+from pathlib import Path
+import sys
+import threading
+import time
+import uuid
+
+from .qmt_component_login import QtLoginBackend, QmtNotReady
+from .qmt_strategy_deploy import (
+    _role_stock, _strategy_slot_name, account_qmt_roots,
+    _write_json, _digest, PipeStrategyController, normalize_strategy_mode, normalize_strategy_settings, qmt_root,
+)
+
+
+# Verified on Guojin simulation 2.1.33.0 / Qt 5.6.2 x64. Native ABI support is
+# deliberately explicit; another build needs its own inspection and live test.
+SUPPORTED_FORMULA_SHA256 = {
+    "673e512bab175e068cbee5fa349e33025bf564e5f57192ff3509f87dad8b8214",
+}
+NOTICE_DLL_SHA256 = {
+    "Dialog.dll": "b71c3dc77cfa830e1037ac2b7f1cc10a43aabec113a9a4c77d0fa97b34cedd67",
+    "BaseWidget.dll": "31fd0313f8b2b1f55f0d367121782ec3dc941a884d59a40cfc77ae155e2e861b",
+}
+
+
+def visible_notice_windows(pid, main_hwnd):
+    if os.name != "nt" or not pid or not main_hwnd:
+        return []
+    import win32gui
+    import win32process
+    result = []
+    def visit(hwnd, _):
+        if (hwnd != main_hwnd and win32gui.IsWindowVisible(hwnd)
+                and win32process.GetWindowThreadProcessId(hwnd)[1] == pid
+                and win32gui.GetClassName(hwnd).startswith("Qt")):
+            result.append(hwnd)
+    win32gui.EnumWindows(visit, None)
+    return result
+
+
+class RecoveryJournal:
+    """Append UTF-8 JSON lines; flush to disk before acknowledging a warning."""
+    def __init__(self, directory):
+        self.directory = Path(directory)
+        self.lock = threading.Lock()
+
+    def __call__(self, event):
+        stamp = datetime.datetime.now().astimezone()
+        event = dict(event, timestamp=stamp.isoformat(timespec="milliseconds"))
+        with self.lock:
+            self.directory.mkdir(parents=True, exist_ok=True)
+            path = self.directory / (stamp.strftime("%Y-%m-%d") + ".jsonl")
+            with path.open("a", encoding="utf-8") as stream:
+                stream.write(json.dumps(event, ensure_ascii=False) + "\n")
+                stream.flush()
+                os.fsync(stream.fileno())
+
+
+def confirm_recovery_bridge(job, pid):
+    controller = PipeStrategyController()
+    desired = dict(enabled=True, mode=job["mode"], generation=job["generation"],
+                   runtime_key=_digest([os.path.normcase(job["root"]), job["account_id"]])[:24])
+    try:
+        for role in job["roles"]:
+            reply = controller(role["identity"], desired)
+            if (reply.get("state") != "running" or reply.get("pid") != pid
+                    or reply.get("generation") != job["generation"]
+                    or reply.get("role") != role["role"]
+                    or reply.get("runtime_key") != desired["runtime_key"]):
+                return False
+        return True
+    finally:
+        controller.close()
+
+
+class UnsupportedQmt(RuntimeError):
+    pass
+
+
+class QtStrategyBackend(QtLoginBackend):
+    def __init__(self, root):
+        directory = qmt_root(root) / "bin.x64"
+        digest = hashlib.sha256((directory / "Formula.dll").read_bytes()).hexdigest()
+        if digest not in SUPPORTED_FORMULA_SHA256:
+            raise UnsupportedQmt("QMT 策略组件版本尚未验证，未执行自动启动")
+        self.notice_supported = all(hashlib.sha256((directory / name).read_bytes()).hexdigest() == digest
+                                    for name, digest in NOTICE_DLL_SHA256.items())
+        extension = Path(__file__).with_name("qmt_strategy_agent.js").read_text(encoding="utf-8")
+        super().__init__(directory, agent_extension=extension)
+        try:
+            if not self.already_logged_in():
+                raise QmtNotReady("QMT 尚未登录，等待主界面")
+            if "strategystatus" not in self.script.list_exports_sync():
+                raise UnsupportedQmt("QMT 策略组件接口不可用")
+        except Exception:
+            self.close()
+            raise
+
+    def snapshot(self):
+        return self.api.strategystatus(str(self.main_hwnd))["result"]
+
+    def start_strategy(self, expected):
+        return self.api.strategystart(str(self.main_hwnd), expected)["result"]
+
+    def notices(self):
+        if not self.notice_supported:
+            return []
+        result = []
+        for hwnd in visible_notice_windows(self.pid, self.main_hwnd):
+            notice = self.api.illegalipnotice(str(hwnd))["result"]
+            if notice:
+                result.append(notice)
+        return result
+
+    def dismiss_notice(self, notice, expected):
+        return self.api.dismissillegalip(str(self.main_hwnd), notice["hwnd"], notice["text"], expected)["result"]
+
+
+def expected_models(job, accounts):
+    """Build an exact allowlist from the CURRENT binding and deployed job."""
+    row = accounts.get(job.get("account_key")) or {}
+    settings = normalize_strategy_settings(row.get("qmt_strategy"))
+    if (not row or not row.get("enabled", True) or not job.get("enabled")
+            or not settings["enabled"] or not settings["autorun"]
+            or str(row.get("account_id")) != job.get("account_id")
+            or normalize_strategy_mode(row.get("mode")) != job.get("mode")
+            or os.path.normcase(str(qmt_root(job["root"]))) not in account_qmt_roots(row)
+            or settings != job.get("settings")
+            or job.get("control_generation") or job.get("accepted_generations")):
+        return []
+    expected = []
+    for role in job.get("roles", []):
+        name = _strategy_slot_name(job["account_id"], job["mode"], role["role"])
+        if (role.get("name") != name or not role.get("model_prepared")
+                or role.get("reimport_required") or not role.get("model_id")
+                or not role.get("resolved_account_key")):
+            return []
+        expected.append({
+            "id": str(role["model_id"]), "name": name, "account": job["account_id"],
+            "m_strAccountKey": role["resolved_account_key"],
+            "runMode": "1" if settings["live"] else "0", "startupAutorun": "1",
+            "eStrategyType": "4", "stock": _role_stock(settings, role["role"]),
+            "peroid": str(settings["period"]),
+        })
+    return expected
+
+
+def match_models(snapshot, expected):
+    matched = []
+    for target in expected:
+        candidates = [item for item in snapshot["models"] if item.get("name") == target["name"]]
+        if len(candidates) != 1 or any(candidates[0].get(k) != v for k, v in target.items()):
+            raise ValueError("QMT 内存策略与当前绑定不一致: " + target["name"])
+        matched.append(candidates[0])
+    return matched
+
+
+class QmtStrategyRecovery:
+    def __init__(self, accounts_provider, *, backend_factory=QtStrategyBackend,
+                 job_is_current=lambda job: True, clock=time.time, interval=20.0,
+                 notice_probe=visible_notice_windows, event_sink=None, bridge_verifier=confirm_recovery_bridge):
+        self.accounts_provider = accounts_provider
+        self.backend_factory = backend_factory
+        self.job_is_current = job_is_current
+        self.clock = clock
+        self.interval = interval
+        self.notice_probe = notice_probe
+        self.event_sink = event_sink or RecoveryJournal(Path("runtime/logs/qmt_strategy_recovery"))
+        self.bridge_verifier = bridge_verifier
+
+    def _event(self, job, status, event, **details):
+        self.event_sink(dict(event=event, account_id=job["account_id"], account_key=job["account_key"],
+                             mode=job["mode"], pid=status.get("pid"), generation=job["generation"],
+                             event_id=(status.get("incident") or {}).get("id"), **details))
+
+    def _notices(self, job, status, backend, expected):
+        for notice in backend.notices():
+            if expected_models(job, self.accounts_provider()) != expected or not self.job_is_current(job):
+                raise ValueError("Binding changed before warning dismissal")
+            incident = status.get("incident") or {}
+            if (incident.get("text") != notice["text"] or incident.get("hwnd") != notice["hwnd"]
+                    or incident.get("dismissed") or incident.get("handled")):
+                incident = dict(id=uuid.uuid4().hex, text=notice["text"], hwnd=notice["hwnd"], detected_at=self.clock())
+                # Detection must be durably recorded before dismissing the popup.
+                status["incident"] = incident
+            if not incident.get("recorded"):
+                self._event(job, status, "illegal_ip_detected", message=notice["text"])
+                incident["recorded"] = True
+            outcome = backend.dismiss_notice(notice, expected)
+            self._event(job, status, "illegal_ip_popup_result", **outcome)
+            incident["dismissed"] = outcome.get("closed") is True
+            incident["dismissal"] = outcome["outcome"]
+            status["next_check_at"] = self.clock() + 1
+
+    def _confirm_incident(self, job, status, backend, expected):
+        incident = status.get("incident") or {}
+        if not incident or incident.get("handled"):
+            return
+        status["next_check_at"] = self.clock() + (1 if self.clock() - incident["detected_at"] < 60 else self.interval)
+        if expected_models(job, self.accounts_provider()) != expected or not self.job_is_current(job):
+            return
+        models = match_models(backend.snapshot(), expected)
+        if not all(model["running"] for model in models):
+            return
+        try:
+            confirmed = self.bridge_verifier(job, backend.pid)
+        except Exception as error:
+            status["bridge_error"] = str(error)
+            return
+        status["bridge_confirmed"] = confirmed
+        if confirmed:
+            status.pop("bridge_error", None)
+        if confirmed and incident.get("dismissed"):
+            self._event(job, status, "illegal_ip_handled", message="非法 IP 弹窗已关闭，绑定策略及通信恢复成功",
+                        strategies=[model["name"] for model in models], popup_closed=True, bridge_confirmed=True)
+            incident["handled"] = True
+            status.update(state="running", strategies=[{"name": m["name"], "running": True} for m in models])
+            status["next_check_at"] = self.clock() + self.interval
+
+    def __call__(self, job, *, inspect_only=False):
+        now = self.clock()
+        expected = expected_models(job, self.accounts_provider())
+        if not expected or not self.job_is_current(job):
+            job["recovery"] = {"state": "ineligible", "last_checked_at": now}
+            return job["recovery"]
+        previous = job.get("recovery") or {}
+        if (not inspect_only and now < previous.get("next_check_at", 0)
+                and not self.notice_probe(previous.get("pid"), previous.get("main_hwnd"))):
+            return previous
+        status = dict(previous, last_checked_at=now, next_check_at=now + self.interval)
+        status.pop("error", None)
+        backend = None
+        try:
+            backend = self.backend_factory(job["root"])
+            if (status.get("pid"), status.get("generation")) != (backend.pid, job["generation"]):
+                status = {"last_checked_at": now, "next_check_at": now + self.interval,
+                          "pid": backend.pid, "generation": job["generation"], "attempts": {}}
+            models = match_models(backend.snapshot(), expected)
+            status["main_hwnd"] = getattr(backend, "main_hwnd", None)
+            if not inspect_only:
+                self._notices(job, status, backend, expected)
+            status["strategies"] = [{"name": item["name"], "running": item["running"]} for item in models]
+            status["bridge_confirmed"] = all(item["running"] for item in models) and all(
+                (role.get("control_sync") or {}).get("pid") == backend.pid
+                and (role.get("control_sync") or {}).get("state") == "running"
+                and 0 <= now - (role.get("control_sync") or {}).get("last_success_at", 0) < 10
+                for role in job["roles"])
+            stopped = [target for target, model in zip(expected, models) if not model["running"]]
+            if not stopped:
+                status["state"] = "running"
+                if status["bridge_confirmed"]:
+                    status.setdefault("stable_since", now)
+                    if now - status["stable_since"] >= 300:
+                        status["attempts"] = {}
+                else:
+                    status.pop("stable_since", None)
+            else:
+                status.pop("stable_since", None)
+                status["state"] = "stopped"
+                if not inspect_only:
+                    attempts = dict(status.get("attempts") or {})
+                    status["attempts"] = attempts
+                    if any(attempts.get(target["name"], 0) >= 5 for target in stopped):
+                        status["state"] = "retry_exhausted"
+                    elif now < status.get("retry_after", 0):
+                        status["state"] = "backoff"
+                    else:
+                        for target in stopped:
+                            # Re-check the binding after attach/observation and before each start.
+                            if (expected_models(job, self.accounts_provider()) != expected
+                                    or not self.job_is_current(job)):
+                                status["state"] = "binding_changed"
+                                break
+                            count = attempts.get(target["name"], 0) + 1
+                            attempts[target["name"]] = count
+                            status["retry_after"] = now + min(300, 60 * 2 ** (count - 1))
+                            # Reserve the attempt before a call that may time out ambiguously.
+                            job["recovery"] = status
+                            outcome = backend.start_strategy(target)
+                            status["state"] = outcome["outcome"]
+                            if outcome.get("requested"):
+                                status["last_started_at"] = now
+                                self._event(job, status, "strategy_start_requested", strategy=target["name"])
+                            else:
+                                attempts[target["name"]] -= 1
+                                status["retry_after"] = now
+            if not inspect_only:
+                self._confirm_incident(job, status, backend, expected)
+                if status.get("state") in ("retry_exhausted", "backoff") and status.get("incident"):
+                    if status.get("last_logged_state") != status["state"]:
+                        self._event(job, status, "illegal_ip_recovery_pending", state=status["state"])
+                        status["last_logged_state"] = status["state"]
+        except Exception as error:
+            status.update(state="unsupported" if isinstance(error, UnsupportedQmt) else "unavailable",
+                          error=str(error), next_check_at=now + max(self.interval, 60))
+            if status.get("incident") and status.get("last_logged_error") != str(error):
+                try:
+                    self._event(job, status, "illegal_ip_processing_failed", error=str(error))
+                    status["last_logged_error"] = str(error)
+                except OSError:
+                    pass  # Preserve the original journal failure in status; never claim success.
+        finally:
+            if backend is not None:
+                backend.close()
+        job["recovery"] = status
+        return status
+
+
+class QmtStrategyRecoveryScheduler:
+    """Separate worker: native GUI waits must not delay the Pipe control loop."""
+    def __init__(self, manager, accounts_provider, report_path, interval=20.0):
+        self.manager = manager
+        self.accounts_provider = accounts_provider
+        self.report_path = Path(report_path)
+        self.interval = interval
+        self.stop_event = threading.Event()
+        self.thread = None
+        self.lock = threading.RLock()
+        self.states = {}
+        try:
+            self.states = json.loads(self.report_path.read_text(encoding="utf-8")).get("targets", {})
+        except (OSError, ValueError):
+            pass
+        self.recovery = QmtStrategyRecovery(accounts_provider, job_is_current=self._current, interval=interval,
+            event_sink=RecoveryJournal(self.report_path.parent.parent / "logs/qmt_strategy_recovery"))
+
+    def _current(self, job):
+        if self.stop_event.is_set():
+            return False
+        with self.manager.lock:
+            accounts = self.accounts_provider()
+            return any(item.get("account_key") == job["account_key"]
+                       and item.get("root") == job["root"]
+                       and item.get("generation") == job["generation"]
+                       and expected_models(item, accounts) == expected_models(job, accounts)
+                       for item in self.manager.jobs.values())
+
+    def run_once(self):
+        with self.manager.lock:
+            jobs = copy.deepcopy(self.manager.jobs)
+        with self.lock:
+            states = copy.deepcopy(self.states)
+        result = {}
+        for key, job in jobs.items():
+            if self.stop_event.is_set():
+                break
+            job["recovery"] = states.get(key, {})
+            try:
+                result[key] = self.recovery(job)
+            except Exception as error:
+                result[key] = dict(job["recovery"], state="unavailable", error=str(error))
+        with self.lock:
+            self.states = result
+        _write_json(self.report_path, {"checked_at": time.time(), "targets": result})
+
+    def decorate(self, account_key, status):
+        status = copy.deepcopy(status)
+        with self.manager.lock:
+            keys = {job["root"]: (key, job.get("generation")) for key, job in self.manager.jobs.items()
+                    if job.get("account_key") == account_key}
+        with self.lock:
+            for target in status.get("targets", []):
+                key, generation = keys.get(target.get("root"), (None, None))
+                recovery = copy.deepcopy(self.states.get(key, {}))
+                if (recovery.get("generation") not in (None, generation)
+                        or time.time() - recovery.get("last_checked_at", 0) > 120):
+                    recovery = {}
+                target["recovery"] = recovery
+                state = recovery.get("state")
+                if state in ("start_requested", "backoff", "retry_exhausted"):
+                    target["state"] = "waiting_start"
+                    target["message"] = {
+                        "start_requested": "已检测到托管策略停止，已直接提交启动，等待通道恢复",
+                        "backoff": "托管策略尚未恢复，等待冷却后重试",
+                        "retry_exhausted": "托管策略连续启动失败，已暂停重试，请检查 QMT 提示",
+                    }[state]
+                elif state == "unsupported" and target.get("state") != "running":
+                    target["message"] = recovery.get("error", "当前 QMT 版本尚未验证策略自动恢复")
+        return status
+
+    def start(self):
+        if self.thread and self.thread.is_alive():
+            return
+        self.stop_event.clear()
+        def run():
+            while not self.stop_event.is_set():
+                try:
+                    self.run_once()
+                except Exception:
+                    pass  # Transient config/status IO failures retry on the next interval.
+                self.stop_event.wait(1.0)
+        self.thread = threading.Thread(target=run, name="qmt-strategy-recovery", daemon=True)
+        self.thread.start()
+
+    def close(self):
+        self.stop_event.set()
+        if self.thread:
+            self.thread.join(timeout=2)
+
+
+def main():
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(encoding="utf-8")
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--account-id", required=True)
+    parser.add_argument("--config", type=Path, default=Path("runtime/config/cfquant_web_config.json"))
+    parser.add_argument("--jobs", type=Path, default=Path("runtime/config/qmt_strategy_jobs.json"))
+    action = parser.add_mutually_exclusive_group()
+    action.add_argument("--ensure", action="store_true")
+    action.add_argument("--watch", action="store_true")
+    parser.add_argument("--report", type=Path)
+    parser.add_argument("--parent-pid", type=int, help="Stop the temporary watcher when this Web process exits")
+    args = parser.parse_args()
+
+    def accounts():
+        return json.loads(args.config.read_text(encoding="utf-8"))["account_configs"]
+
+    def jobs():
+        return json.loads(args.jobs.read_text(encoding="utf-8"))["jobs"]
+
+    def current(job):
+        return any(item.get("account_key") == job["account_key"]
+                   and item.get("root") == job["root"]
+                   and item.get("generation") == job["generation"]
+                   and item.get("enabled")
+                   and expected_models(item, accounts()) == expected_models(job, accounts())
+                   for item in jobs().values())
+
+    parent = None
+    if args.parent_pid:
+        import psutil
+        parent = psutil.Process(args.parent_pid)
+    recovery = QmtStrategyRecovery(accounts, job_is_current=lambda job: (
+        (parent is None or parent.is_running()) and current(job)),
+        event_sink=RecoveryJournal(args.config.parent.parent / "logs/qmt_strategy_recovery"))
+    states = {}
+    if args.report and args.report.exists():
+        states = json.loads(args.report.read_text(encoding="utf-8")).get("targets", {})
+    while True:
+        if parent is not None and not parent.is_running():
+            return 0
+        output = {"account_id": args.account_id, "checked_at": time.time(), "targets": {}}
+        try:
+            for key, original in jobs().items():
+                if original.get("account_id") != args.account_id:
+                    continue
+                job = copy.deepcopy(original)
+                if key in states:
+                    job["recovery"] = states[key]
+                result = recovery(job, inspect_only=not (args.ensure or args.watch))
+                output["targets"][key] = result
+        except Exception as error:
+            if not args.watch:
+                raise
+            output.update(targets=states, error=str(error))
+        states = output["targets"]
+        text = json.dumps(output, ensure_ascii=False, indent=2)
+        if args.report:
+            args.report.parent.mkdir(parents=True, exist_ok=True)
+            temporary = args.report.with_suffix(".pending")
+            temporary.write_text(text, encoding="utf-8")
+            temporary.replace(args.report)
+        if not args.watch:
+            print(text)
+            return 0 if states and all(s["state"] in ("running", "start_requested") for s in states.values()) else 1
+        time.sleep(1)
+
+
+if __name__ == "__main__":
+    sys.exit(main())