落实两次清仓确认与评级下降退出

This commit is contained in:
baobao 2026-11-05 12:23:33 +08:00
parent 682c5262c7
commit 64449c6832
17 changed files with 1015 additions and 5 deletions

View File

@ -2826,3 +2826,9 @@ PMS最终代码56db0fd已推送,155 web/WS/beat为execution-2b1c447,worker
开发机隔离全量和页面三道护栏通过,1440/390/320像素浏览器复现52条真实信号,并用明确标注的离线样例验证关注同类展示及无信号不占行。10:44快照中六只关注没有既有实际信号,未将样例或研究回执冒充自然信号。155候选断网全量ALL SUITES PASS后,10:55:36仅web发布pms:original-signal-e4a7424;其他17个容器完整基线不变,线上页面摘要与验收版一致。
10:56:31确认1640502、近200条连续、待入账及孤儿0、现金数量一致。用户参数、私有配置、挂载、worker和唯一WS保持,188未动。产品提交e4a7424及发布证据分别留档;文档提交不再重建。部署、回退和隔离验证边界见[接续](docs/信号流格式与选股恢复_2026-11-05.md)及[发布证据](docs/evidence/pms_original_signal_release_20261105.json)。
## 2026-11-05 12:22 原策略退出纪律实现
用户确认手工试探仓不约束后续系统仓位,仓位和网格计算保持。新增第一次有效清仓级信号停买、第二次独立信号全仓退出;买方整体评级好降中、中降差、好降差直接退出。持仓轮次与消息防重独立落表,撤旧卖单后按实际数量清仓,T+1与迟到成交沿原回报收尾,人工清仓和全局暂停优先。
发现盘前评级映射遗漏当日四只新仓,增加独立批量只读补齐,执行不等待外部请求。35项隔离专项通过;12:19实际五只持仓补读均与入场评级相同。雷赛智能只承接09:38真实第一次停买,不伪造第二次。全量、候选及定向发布结果后续追加,规则和边界见[退出纪律接续](docs/两次清仓信号与评级下降退出_2026-11-05.md)。

108
app/core/risk_exit.py Normal file
View File

@ -0,0 +1,108 @@
"""两次清仓信号与买方评级下降。只识别事实,不生成新的研判。"""
import hashlib
import json
import math
from datetime import datetime, timedelta, timezone
TZ = timezone(timedelta(hours=8))
GRADES = {'差': 0, '中': 1, '好': 2}
def stamp(value):
try:
if isinstance(value, datetime):
d = value
elif isinstance(value, (int, float)) or str(value).isdigit():
n = float(value)
d = datetime.fromtimestamp(n / 1000 if n > 100000000000 else n, TZ)
else:
d = datetime.fromisoformat(str(value).replace('Z', '+00:00'))
return d.replace(tzinfo=TZ) if d.tzinfo is None else d.astimezone(TZ)
except (ValueError, TypeError, OverflowError, OSError):
return None
def digest(value):
return hashlib.sha256(json.dumps(value, ensure_ascii=False, sort_keys=True,
separators=(',', ':'), allow_nan=False).encode()).hexdigest()
def signal_event(sig, *, now, since, threshold=.85, max_age=300):
"""真正的清仓级信号才计次。过期、未来、回退结论及无出处不计数。"""
code = str(sig.get('ts_code') or '')
from app.core.command_spec import is_stock_code
if not is_stock_code(code) or not code.endswith(('.SH', '.SZ')):
return None, '证券不在沪深范围'
try:
conf = float(sig.get('confidence'))
except (TypeError, ValueError):
return None, '没有有效置信度'
if (sig.get('action') != 'SELL' or not math.isfinite(conf) or conf < threshold or conf > 1
or sig.get('is_fallback') not in (None, False, 0, 'false', '0', '')):
return None, '不是有效清仓级结论'
source = sig.get('source')
if source not in ('intraday', 'risk_sell'):
return None, '信号来源不可核实'
reason = ' '.join(str(sig.get('reason') or '').split())[:500]
at = stamp(sig.get('event_time'))
now, start = stamp(now), stamp(since)
if not at or not now or not start or not reason or not sig.get('msg_id'):
return None, '缺少原始信号时间、内容或标识'
if at < start or at > now or (now-at).total_seconds() > max_age:
return None, '信号不在当前有效窗口'
expiry = stamp(sig.get('expires_at'))
if sig.get('expires_at') is not None and (not expiry or now >= expiry):
return None, '信号已过期或期限无效'
producer = str(sig.get('producer_id') or '')
if source == 'intraday' and not producer.startswith('bionic_brain_intraday'):
return None, '不是决策系统盘中研判'
source_id = str(sig.get('signal_id') or '')
# 风控流未提供研判编号,保留原始时间与内容指纹;不把消费时刻当研判时刻。
key = digest([code, source, source_id or at.isoformat(), reason])
return {'key': key, 'source': source, 'source_id': source_id,
'msg_id': str(sig['msg_id']), 'at': at.isoformat(), 'confidence': conf,
'reason': reason[:500], 'content': digest([code, reason])}, ''
def duplicate(events, event, *, mirror_seconds=120):
for old in events:
if old.get('key') == event['key']:
return True
if old.get('source') == event['source'] and old.get('msg_id') == event['msg_id']:
return True
if old.get('source') == event['source'] and event.get('source_id') and old.get('source_id') == event['source_id']:
return True
# 上游两条流没有共同研判编号,文案也可能不同。近时跨流不能证明独立,只记一次。
if old.get('source') != event['source']:
a, b = stamp(old.get('at')), stamp(event.get('at'))
if a and b and abs((a-b).total_seconds()) <= mirror_seconds:
return True
return False
def review_snapshot(review, *, now, stale_days=120):
"""只接受可追溯的正式买方评析整体评级;缺失、过期不等于降级。"""
r = review if isinstance(review, dict) else {}
grade, ref = r.get('overall'), str(r.get('review_ref') or '')
at, current = stamp(r.get('report_ran_at')), stamp(now)
if grade not in GRADES or len(ref) != 64 or any(c not in '0123456789abcdef' for c in ref):
return None
if not at or not current or at > current or (current-at).days > stale_days:
return None
if r.get('qual') != 'ok' or r.get('brain_status') != 'ok':
return None
return {'grade': grade, 'ref': ref, 'at': at.isoformat()}
def review_change(before, after):
if not after:
return 'missing'
if not before:
return 'baseline'
if before['ref'] == after['ref']:
if before != after:
raise ValueError('同一买方评析版本内容不一致,等待核实')
return 'same'
if stamp(after['at']) <= stamp(before['at']):
return 'old'
return 'downgrade' if GRADES[after['grade']] < GRADES[before['grade']] else 'updated'

View File

@ -107,7 +107,15 @@ def parse_intraday(fields: dict, *, msg_id: str = None) -> dict:
scores = json.loads(raw_scores) if isinstance(raw_scores, str) else dict(raw_scores)
except (json.JSONDecodeError, TypeError, ValueError):
scores = {}
validity = f.get('signal_validity') or {}
if isinstance(validity, str):
try:
validity = json.loads(validity)
except (ValueError, TypeError):
validity = {'expires_at': 'invalid'}
return {"source": SRC_INTRADAY, "msg_id": msg_id,
'signal_id': f.get('signal_id'), 'event_time': f.get('trigger_time'),
'expires_at': validity.get('expires_at') if isinstance(validity, dict) else 'invalid',
"ts_code": (f.get("ts_code") or "").strip(),
"action": (f.get("action") or "").strip().upper(),
"confidence": _norm_conf(f.get("confidence")),
@ -132,6 +140,8 @@ def parse_risk_sell(fields: dict, *, msg_id: str = None) -> dict:
"confidence": 0.0, "parse_error": "内层 data JSON 解析失败",
"reason": "", "dominant_signal": ""}
return {"source": SRC_RISK_SELL, "msg_id": msg_id,
'signal_id': inner.get('signal_id'), 'event_time': inner.get('timestamp'),
'is_fallback': inner.get('is_fallback'),
"ts_code": (inner.get("ts_code") or "").strip(),
"action": (inner.get("action") or "").strip().upper(),
"confidence": _norm_conf_pct(inner.get("confidence")),

View File

@ -260,6 +260,8 @@ def intraday_exec():
if param_store.get_bool('PMS_EXEC_REPRICE_ENABLED', False):
from app.services import execution_basis
r['execution_basis'] = execution_basis.monitor()
from app.services import risk_exit
r['risk_exit'] = risk_exit.scan() # 先收尾退出纪律,网格与买入执行不得越过停买状态。
r["strategies"] = strategy_runner.tick() # 个股交易方案: 触发即发短窗口指令, 由下面 run_tick 执行
# 过期收口改为每分钟一次 (原来只在 15:10 日结跑) —— 让过了窗口/deadline 的单当即作废,
# 不再多活一整天堵在「今日在办」、也不会隔天还替它试单 (2026-08-12 用户定的"实时"口径)。
@ -295,10 +297,14 @@ def proposal_scan():
@guard(trade_day=True, session=True)
@_exclusive("INFRA_LOCK_EXEC_BASIS_REFRESH", ttl_sec=115)
def execution_basis_refresh():
from app.services import risk_exit
reviews = risk_exit.refresh_reviews()
if not param_store.get_bool('PMS_EXEC_REPRICE_ENABLED', False):
return {'skipped': '独立执行依据刷新未开启'}
return {'skipped': '独立执行依据刷新未开启', 'risk_reviews': reviews}
from app.services import execution_basis
return execution_basis.refresh()
result = execution_basis.refresh()
result['risk_reviews'] = reviews
return result
@celery_app.task(name="pms.signal_digest")

View File

@ -167,7 +167,20 @@ def issue(cmd_type: str, params: dict, *, note=None, issued_by="user",
logger.exception("命令落表失败")
return {"ok": False, "errors": [f"DB_ERROR: 命令落表失败 {type(e).__name__}: {e}"]}
if spec["cls"] == cs.CLS_PARAM:
# 只有明确解冻才能恢复;新买入方案失败或旧命令重规划都不能顺带清掉风控停买。
from app.services import risk_exit
if cmd_type == 'UNFREEZE_STOCK' and risk_exit.enabled():
from app.db import session as db
try:
with db.transaction():
risk_exit.resume_buy(ts_code)
res = _apply_param(command_id, cmd_type, spec, norm)
if not res.get('ok'):
raise RuntimeError('解冻命令未生效,保留原停买状态')
except (ValueError, RuntimeError) as exc:
pms_repo.update_command(command_id, status=cs.ST_CANCELLED, note=str(exc))
return {'ok': False, 'command_id': command_id, 'errors': [str(exc)]}
elif spec["cls"] == cs.CLS_PARAM:
res = _apply_param(command_id, cmd_type, spec, norm)
else:
res = plan_command(pms_repo.get_command(command_id))

View File

@ -6,6 +6,10 @@ BUY_ACTIONS = ('OPEN', 'FILL', 'ADD', 'DCA')
def buy_blocker(ts_code):
from app.services import risk_exit
stopped = risk_exit.buy_blocker(ts_code)
if stopped:
return stopped
# 查询失败必须抛给调用者,不能当作无冲突。按票查,不受全局列表裁剪影响。
rows = pms_repo.list_instructions(statuses=list(LIVE), side='sell', ts_code=ts_code, limit=500)
for row in rows:

View File

@ -46,6 +46,12 @@ def _valid_limit_flag(value):
# 运行态开关: key -> (默认值, 类型, 说明)
RUNTIME_EXTRA = {
'PMS_RISK_EXIT_ENABLED': (False, bool, '原策略退出纪律:第一次清仓级信号停买,第二次独立信号清仓;买方整体评级下降直接清仓'),
'PMS_RISK_EXIT_START_AT': ('', str, '退出纪律启用时刻,北京时间;只接收此后有效新信号,既有真实停买最多承接第一次'),
'PMS_RISK_SIGNAL_MAX_AGE_SEC': (300, int, '清仓信号最大时龄,秒;消息期限更短时服从消息期限'),
'PMS_RISK_SIGNAL_MIRROR_SEC': (120, int, '两条信号流的近时副本合并窗口,秒;缺少共同研判编号时不重复计次'),
'PMS_RISK_REVIEW_REFRESH_SEC': (300, int, '原策略持仓买方评析补读间隔,秒;新报告按原版本和评级比较'),
'PMS_RISK_REVIEW_TIMEOUT_SEC': (3, int, '原策略持仓买方评析批量只读请求超时,秒;失败保留原评级'),
'PMS_MONITOR_WATCH_SCOPE': ('', str, '人工关注研究覆盖来源;仅155模拟实例设置pms-sim-155,留空停用'),
'PMS_MONITOR_WATCH_TTL_SEC': (600, int, '人工关注研究名单有效期,秒;与交易候选和交易开关分离'),
'PMS_LIMIT_CACHE_ENABLED': (False, bool, '执行报价读取已核实的当日限制价缓存;缺失时逐票等待'),
@ -206,6 +212,7 @@ RUNTIME_EXTRA = {
# 冷启、连库超时), 全局暂停买入、休假模式、组合刹车就一起静默解除, 且没有任何调用方
# 看得出这是降级。安全开关的默认方向必须是"拦", 不是"放"。
FAIL_CLOSED = {
'PMS_RISK_EXIT_ENABLED': False,
'PMS_MONITOR_WATCH_SCOPE': '',
"PMS_LIMIT_CACHE_ENABLED": True, # 无法确认开关时仍走严格本地缓存,不退到旧读取。
"PMS_LIMIT_COLLECT_ENABLED": False,
@ -559,6 +566,10 @@ def set_param(key: str, value, updated_by: str = "user") -> dict:
_RANGES = {
'PMS_MONITOR_WATCH_TTL_SEC': (120, 600),
'PMS_RISK_SIGNAL_MAX_AGE_SEC': (30, 900),
'PMS_RISK_SIGNAL_MIRROR_SEC': (0, 600),
'PMS_RISK_REVIEW_REFRESH_SEC': (60, 3600),
'PMS_RISK_REVIEW_TIMEOUT_SEC': (1, 10),
'PMS_LIMIT_FETCH_TIMEOUT_SEC': (1, 10),
'PMS_LIMIT_ROUND_BUDGET_SEC': (5, 60),
'PMS_LIMIT_ROUND_MAX_CODES': (1, 60),

374
app/services/risk_exit.py Normal file
View File

@ -0,0 +1,374 @@
"""原策略持仓的退出纪律。事件先入账,暂停买入与清仓按实际回报持续收尾。"""
from datetime import datetime
from config.settings import settings
from app.core import risk_exit as rules, strategy_book as books
from app.repo import pms_repo, rotation_repo
from app.services import param_store
KIND = 'risk_exit'
PAUSED = {'STOP_BUY', 'EXIT_PENDING', 'EXITING', 'CLOSED', 'MANUAL'}
LIVE = ('PROPOSED', 'RULE_PASSED', 'JUDGE_PASSED', 'DISPATCHED', 'WAIT_REVIEW')
def enabled():
return (settings.INFRA_STRATEGY_BOOK_SCHEMA and books.CURRENT.get() == books.ORIGINAL
and param_store.get_bool('PMS_RISK_EXIT_ENABLED', False))
def _key(code):
return 'risk-exit:original:' + code
def _code_ok(code):
from app.core.command_spec import is_stock_code
return is_stock_code(code) and str(code).endswith(('.SH', '.SZ'))
def buy_blocker(code):
if not enabled() or not _code_ok(code):
return None
state, _ = rotation_repo.get(_key(code))
if state and state.get('phase') in PAUSED:
return state.get('reason') or '该股退出纪律已生效,停止新增买入'
return None
def _holding(code):
pos = pms_repo.get_position(code) or {}
rows = pms_repo.list_lots(code, status='OPEN', limit=2001)
if len(rows) >= 2001:
raise ValueError('持仓批次超过完整核验上限')
lots = {str(r['id']) for r in rows if int(r.get('qty') or 0) > 0}
if sum(int(r.get('qty') or 0) for r in rows) != int(pos.get('total_qty') or 0):
raise ValueError('持仓与批次数量不一致,等待对账后执行退出纪律')
pos['_risk_lots'] = rows
return pos, lots
def _ledger(code, action, reason, hard, ref):
if pms_repo.insert_ledger(ts_code=code, action=action, arbiter='system', verdict='PASS',
price_at=0, hard_numbers=hard, reason=reason[:500], ref_id=ref) != 1:
raise RuntimeError('退出纪律依据未入账')
def _sync(state, code, pos, lots, now):
"""以真实未平批次衔接持仓轮次,清空后再开仓不继承上轮信号。"""
if not lots:
return
late = any(r.get('instruction_id') in (state.get('stopped_parents') or []) for r in pos.get('_risk_lots', []))
same = bool((state.get('opened_date') == str(pos.get('opened_date'))
and set(state.get('lot_ids') or []) & lots) or late)
if not same:
# 没有批次交集时不猜是同一轮,旧证据绝不用于新批次清仓。
state.clear()
state.update(code=code, book_id=books.ORIGINAL, opened_date=str(pos.get('opened_date')),
round_id=rules.digest([code, str(pos.get('opened_date')), sorted(lots)])[:20],
phase='WATCH', events=[], lot_ids=sorted(lots), count=0, exit_seq=0,
initialized_at=rules.stamp(now).isoformat())
from app.services import logic_state_service
entry = logic_state_service.entry_view(code) or {}
baseline = rules.review_snapshot(entry.get('company_review'), now=now,
stale_days=param_store.get_int('PMS_FUND_STALE_DAYS', 120))
if baseline:
state['review'] = baseline
_seed_legacy_first(state, code, pos, now)
else:
state['lot_ids'] = sorted(set(state['lot_ids']) | lots)
if state.get('phase') == 'CLOSED' and late:
state['phase'] = 'EXIT_PENDING'
state['stopped_parents'] = sorted(set(state.get('stopped_parents') or []) |
{r['instruction_id'] for r in pos.get('_risk_lots', []) if r.get('instruction_id')})
def _seed_legacy_first(state, code, pos, now):
"""只承接已有的真实停买及待确认清仓,不回扫历史凑第二次信号。"""
from app.services import strategy_service
pause = strategy_service.buypause_map().get(code) or {}
sources = pause.get('sources') or {pause.get('source'): pause}
candidates = pms_repo.list_proposals(statuses=('WAIT_USER',), limit=501)
if len(candidates) >= 501:
raise ValueError('待确认提议过多,不能截断迁移退出依据')
for p in candidates:
if p.get('ts_code') != code or p.get('action') != 'EXIT' or p.get('judge_verdict') != 'STRATEGY_RISK':
continue
hard = p.get('hard_numbers') or {}
source = hard.get('signal_source')
at, paused = rules.stamp(p.get('created_at')), sources.get(source) or {}
pat = rules.stamp(paused.get('at'))
if (not at or not pat or at.date() != rules.stamp(now).date()
or abs((at-pat).total_seconds()) > 120 or not hard.get('on_strategy')
or float(hard.get('confidence') or 0) < param_store.get_float('PMS_SIGNAL_AUTO_EXIT_CONF', .85)):
continue
reason = str(paused.get('reason') or '')
if not reason or reason not in str(hard.get('reason') or ''):
continue
original = reason.split(' —— ', 1)[-1]
event = {'key': rules.digest(['legacy', p['proposal_id']]), 'source': source,
'source_id': p['proposal_id'], 'msg_id': 'legacy:'+p['proposal_id'],
'at': pat.isoformat(), 'reason': original, 'content': rules.digest([code, original]),
'confidence': float(hard['confidence']), 'legacy_proposal': p['proposal_id']}
state.update(events=[event], count=1, phase='STOP_BUY',
reason='第一次清仓信号已确认,停止新增买入,等待第二次独立信号')
_ledger(code, 'SIGNAL', state['reason'], {'legacy_proposal': p['proposal_id'],
'event': event, 'round_id': state['round_id']}, p['proposal_id'])
return
def on_signal(sig, *, now=None, dry_run=False):
if not enabled():
return None
now = now or datetime.now()
event, why = rules.signal_event(sig, now=now,
since=param_store.get('PMS_RISK_EXIT_START_AT', ''),
threshold=param_store.get_float('PMS_SIGNAL_AUTO_EXIT_CONF', .85),
max_age=param_store.get_int('PMS_RISK_SIGNAL_MAX_AGE_SEC', 300))
if not event:
return {'accepted': False, 'reason': why}
code = sig['ts_code']
if dry_run:
state, _ = rotation_repo.get(_key(code))
return {'accepted': True, 'dry_run': True, 'count': (state or {}).get('count', 0),
'reason': '只读预览,不登记次数、不改变委托'}
with rotation_repo.account_guard(), rotation_repo.locked(_key(code), KIND, {}) as state:
pos, lots = _holding(code)
if not lots:
return {'accepted': False, 'reason': '当前没有原策略持仓'}
_sync(state, code, pos, lots, now)
reset = rules.stamp(state.get('reset_at'))
if reset and rules.stamp(event['at']) <= reset:
return {'accepted': False, 'reason': '信号早于人工恢复买入'}
# 持仓买入前的消息不能用来清这轮新仓。
opened = rules.stamp(pos.get('opened_date'))
if opened and rules.stamp(event['at']) < opened:
return {'accepted': False, 'reason': '信号早于当前持仓轮次'}
duplicate = rules.duplicate(state['events'], event,
mirror_seconds=param_store.get_int('PMS_RISK_SIGNAL_MIRROR_SEC', 120))
if not duplicate and state['phase'] not in ('EXIT_PENDING', 'EXITING', 'CLOSED', 'MANUAL'):
state['events'].append(event)
state['count'] = int(state.get('count') or 0) + 1
state['phase'] = 'STOP_BUY' if state['count'] == 1 else 'EXIT_PENDING'
state['reason'] = ('第一次清仓信号已确认,停止新增买入,等待第二次独立信号'
if state['count'] == 1 else '第二次独立清仓信号已确认,开始清仓')
_ledger(code, 'SIGNAL', state['reason'],
{'event': event, 'count': state['count'], 'round_id': state['round_id']}, event['key'][:64])
count, phase = state['count'], state['phase']
drive(code, now=now)
return {'accepted': True, 'duplicate': duplicate, 'count': count, 'phase': phase}
def observe_review(code, review, *, now=None):
if not enabled() or not _code_ok(code):
return None
now = now or datetime.now()
snapshot = rules.review_snapshot(review, now=now,
stale_days=param_store.get_int('PMS_FUND_STALE_DAYS', 120))
with rotation_repo.account_guard(), rotation_repo.locked(_key(code), KIND, {}) as state:
pos, lots = _holding(code)
if not lots:
return None
_sync(state, code, pos, lots, now)
change = rules.review_change(state.get('review'), snapshot)
if change in ('baseline', 'updated', 'downgrade'):
before = state.get('review')
state['review'] = snapshot
if change == 'downgrade' and state['phase'] not in ('EXIT_PENDING', 'EXITING', 'MANUAL'):
state.update(phase='EXIT_PENDING', reason=f"买方评析整体评级由{before['grade']}降为{snapshot['grade']},开始清仓")
state['review_exit'] = {'before': before, 'after': snapshot}
_ledger(code, 'SIGNAL', state['reason'],
{'review_exit': state['review_exit'], 'round_id': state['round_id']}, snapshot['ref'])
return change
def _stop_buys(code, state):
"""先持久化逐指令停止依据,再请求撤单;未确认撤销的量继续保留。"""
from app.services import executor, strategy_service
reason = state['reason']
strategy_service.pause_buy(code, reason=reason, source='risk_exit')
pause = strategy_service.buypause_map().get(code) or {}
if 'risk_exit' not in (pause.get('sources') or {}):
raise RuntimeError('退出纪律暂停买入未保存')
rows = pms_repo.list_instructions(statuses=list(LIVE), side='buy', ts_code=code, limit=501)
if len(rows) >= 501:
raise ValueError('在途买入过多,不能截断处理')
for ins in rows:
iid = ins['instruction_id']
state['stopped_parents'] = sorted(set(state.get('stopped_parents') or []) | {iid})
if not pms_repo.instruction_buy_stop(iid):
_ledger(code, 'BUY_STOP', reason, {'risk_exit': True}, iid)
result = executor.cancel_instruction(iid, reason=reason, arbiter='system') or {}
if not result.get('ok'):
raise RuntimeError('退出纪律撤单失败,保留停买并等待重试')
def drive(code, *, now=None):
"""同账户串行收尾。T+1、迟到成交、部分成交继续沿已有执行与回报链处理。"""
if not enabled() or not _code_ok(code) or param_store.get_bool('PMS_GLOBAL_EXEC_HALT', False):
return
now = now or datetime.now()
from app.services import execution_conflicts, execution_orders, strategy_service
with rotation_repo.account_guard(), rotation_repo.locked(_key(code), KIND, {}) as state:
if not state or state.get('phase') not in PAUSED:
return
_stop_buys(code, state)
if state['phase'] in ('STOP_BUY', 'CLOSED', 'MANUAL'):
return
# 旧网格卖单也需明确撤销,不能只撤策略后让旧父单永久等待来源状态。
from app.services import executor
all_live = pms_repo.list_instructions(statuses=list(LIVE), ts_code=code, limit=501)
if len(all_live) >= 501:
raise ValueError('在途指令过多,不能截断处理')
for old in all_live:
if old.get('origin_type') == 'strategy' and old.get('side') == 'sell':
result = executor.cancel_instruction(old['instruction_id'], reason=state['reason'], arbiter='system') or {}
if not result.get('ok'):
raise RuntimeError('旧策略卖出撤单失败,等待重试')
# 撤掉网格等自动策略,避免旧卖单与整票清仓并发占用可卖量。
result = strategy_service.cancel_by_code(code, reason=state['reason']) or {}
if not result.get('ok'):
raise RuntimeError('清仓前策略撤销未完成,等待重试')
if pms_repo.list_strategies(ts_code=code, statuses=['ACTIVE', 'PAUSED'], limit=1):
raise RuntimeError('清仓前仍有未撤下的交易方案,等待重试')
# 同一账户锁和文档事务覆盖清仓指令、计数、报告版本与审计。
current = state
pos, lots = _holding(code)
from app.repo import qmt_repo
children = qmt_repo.list_orders(ts_code=code, statuses=list(qmt_repo.LIVE), limit=1001)
if len(children) >= 1001:
raise ValueError('在途委托超过核验上限')
owned = []
for child in children:
with books.scope('all'):
parent = pms_repo.get_instruction(child['parent_id'])
if not parent or parent.get('book_id') not in (books.ORIGINAL, books.MICRO):
raise ValueError('在途委托策略归属无法核实')
if parent['book_id'] == books.ORIGINAL:
owned.append(child)
if any(c.get('side') == 'sell' for c in owned):
return
if qmt_repo.inbox_pending_count() or qmt_repo.inbox_orphan_count():
return
rows = pms_repo.list_instructions(statuses=list(LIVE), side='sell', ts_code=code, limit=501)
if len(rows) >= 501:
raise ValueError('在途卖出过多,不能截断处理')
if rows:
return # 已有真实卖出先收尾,不叠加超卖,也不覆盖用户指令。
if current.get('exit_iid'):
prev = pms_repo.get_instruction(current['exit_iid'])
if not prev or prev.get('status') in ('CANCELLED', 'REJECTED'):
current.update(phase='MANUAL', reason='清仓安排已撤销、拒绝或无法核实,等待人工处理')
return
# 等所有回报入账后才确认清仓完成;迟到买入仍归本轮退出收尾。
qty = int(pos.get('total_qty') or 0)
if qty <= 0:
live_buy = pms_repo.list_instructions(statuses=list(LIVE), side='buy', ts_code=code, limit=1)
if not live_buy and not owned:
current.update(phase='CLOSED', closed_at=rules.stamp(now).isoformat())
return
blocker = execution_orders.correction_blocker(ts_code=code, side='sell')
if blocker:
raise RuntimeError(blocker)
seq = int(current.get('exit_seq') or 0) + 1
iid = f"RX_{current['round_id']}_{seq}"
progress = {'is_command': False, 'urgent': True, 'from_signal': True,
'risk_exit': {'round_id': current['round_id'], 'events': current['events'],
'review_exit': current.get('review_exit')},
'reason': current['reason'], 'children': [], 'deadline': str(now.date())}
if pms_repo.insert_instruction(instruction_id=iid, origin_type='system', origin_id='risk_exit',
ts_code=code, action='EXIT', side='sell', qty=qty, limit_price=None,
window_tdays=1, status='PROPOSED', progress=progress) != 1:
raise RuntimeError('清仓指令未成功落表')
_ledger(code, 'EXIT', current['reason'], progress['risk_exit'], iid)
current.update(phase='EXITING', exit_iid=iid, exit_seq=seq)
# 旧风控/目标价提议被新清仓覆盖,避免再被采纳为重复委托。
proposals = pms_repo.list_proposals(statuses=('WAIT_USER',), limit=501)
if len(proposals) >= 501:
raise ValueError('提议过多,不能完整清理退出冲突')
for p in proposals:
if p.get('ts_code') == code and p.get('action') in ('EXIT', 'TRIM', 'OPEN', 'FILL', 'ADD', 'DCA'):
if not pms_repo.decide_proposal(p['proposal_id'], 'EXPIRED'):
raise RuntimeError('清仓冲突提议未成功收尾')
result = execution_conflicts.enforce_exit(pms_repo.get_instruction(iid))
if not result.get('ok'):
raise RuntimeError('清仓已落表,买入侧仍待收尾')
def resume_buy(code):
"""仅响应用户明确恢复;清仓已启动时不能用恢复买入撤销卖出安排。"""
if not enabled():
return
with rotation_repo.account_guard(), rotation_repo.locked(_key(code), KIND, {}) as state:
if state.get('phase') in ('EXIT_PENDING', 'EXITING'):
raise ValueError('该股已进入清仓流程,请先处理清仓安排')
if state.get('phase') == 'MANUAL':
from app.repo import qmt_repo
if (pms_repo.list_instructions(statuses=list(LIVE), side='sell', ts_code=code, limit=1)
or qmt_repo.list_orders(ts_code=code, statuses=list(qmt_repo.LIVE), limit=1)
or qmt_repo.inbox_pending_count() or qmt_repo.inbox_orphan_count()):
raise ValueError('该股委托或回报仍待收尾,暂不能恢复买入')
if state:
state.update(phase='WATCH', count=0, reset_at=rules.stamp(datetime.now()).isoformat(), reason='用户明确恢复买入')
state.pop('exit_iid', None)
from app.services import strategy_service
result = strategy_service.clear_buypause(code) or {}
if not result.get('ok'):
raise RuntimeError('用户恢复买入未保存,保留原暂停')
_ledger(code, 'SIGNAL', state['reason'], {'round_id': state['round_id'],
'reset_at': state['reset_at']}, state['round_id'])
def scan(*, now=None):
out = {'enabled': enabled(), 'reviews': {}, 'errors': []}
if not out['enabled']:
return out
now = now or datetime.now()
from app.services import logic_state_service
states = logic_state_service.state_map()
positions = pms_repo.list_positions(only_open=True)
codes = {p['ts_code'] for p in positions if _code_ok(p['ts_code'])}
pending = rotation_repo.recent(KIND, limit=1000)
if len(pending) >= 1000:
raise RuntimeError('退出纪律记录超过核验上限')
codes.update(r['value']['code'] for r in pending if r['value'].get('phase') in PAUSED)
for code in sorted(codes):
try:
out['reviews'][code] = observe_review(code, (states.get(code) or {}).get('company_review'), now=now)
drive(code, now=now)
except Exception as exc:
out['errors'].append(f'{code}: {type(exc).__name__}: {exc}')
out['ok'] = not out['errors']
return out
def refresh_reviews(*, now=None):
"""在独立刷新任务中批量只读持仓评析;执行任务不等待外部请求或模型。"""
out = {'enabled': enabled(), 'ok': True, 'reviews': {}, 'errors': []}
if not out['enabled']:
return out
now = now or datetime.now()
current = rules.stamp(now)
from app.services import plan_feed
positions = pms_repo.list_positions(only_open=True)
codes = sorted({p['ts_code'] for p in positions if _code_ok(p['ts_code'])})
if not codes:
return out
if len(codes) > 200:
raise ValueError('持仓评级批量查询超过完整核验上限')
with rotation_repo.locked('risk-review-refresh:original', 'risk_review_refresh', {}) as state:
previous = rules.stamp(state.get('attempt_at'))
if previous and (current-previous).total_seconds() < param_store.get_int('PMS_RISK_REVIEW_REFRESH_SEC', 300):
return {**out, 'skipped': '尚未到持仓评析刷新时间'}
state['attempt_at'] = current.isoformat()
try:
states = plan_feed.fetch_logic_states(codes,
timeout=param_store.get_int('PMS_RISK_REVIEW_TIMEOUT_SEC', 3))
except Exception as exc:
out.update(ok=False, errors=[f'持仓评析补读失败,保留原评级:{type(exc).__name__}'])
return out
for code in codes:
try:
out['reviews'][code] = observe_review(code, (states.get(code) or {}).get('company_review'), now=now)
except Exception as exc:
out['errors'].append(f'{code}: {type(exc).__name__}: {exc}')
out['ok'] = not out['errors']
return out

View File

@ -148,6 +148,15 @@ def _handle(sig, view, prm, seen, ymd, dry_run, out, strat_codes=frozenset()):
d = sr.digest(sig, pos, prm)
act = d["action"]
# 已授权退出纪律独立于旧的“每股每天一次”去重;重放按原研判标识防重。
# 必须早于在途提议检查,否则第一次生成的提议会吞掉第二次真实信号。
if act == sr.ACT_EXIT:
from app.services import risk_exit
handled = risk_exit.on_signal(sig, dry_run=dry_run)
if handled is not None:
out.setdefault('risk_exit', []).append({'ts_code': code, **handled})
return
if act == sr.ACT_IGNORE:
out["ignored"] += 1
# **持仓票的卖出被忽略也要留痕** (2026-08-18)。digest 对"低于门槛"返回 IGNORE,

View File

@ -285,6 +285,11 @@ def resume_buy(strategy_id: str, by: str = "user") -> dict:
if not st:
return {"ok": False, "error": "策略不存在"}
code = st.get("ts_code")
from app.services import risk_exit
try:
risk_exit.resume_buy(code)
except (ValueError, RuntimeError) as exc:
return {'ok': False, 'error': str(exc)}
m = buypause_map()
if code in m:
m.pop(code, None)

View File

@ -0,0 +1,41 @@
# 两次清仓信号与评级下降退出
## 用户决定与范围
2026年11月5日,用户说明试探仓由人工操作,不应以试探仓比例约束后续系统规划。本次不修改仓位预算、网格档距和每格数量。用户确定:系统第一次清仓信号停止买入,第二次独立清仓信号开始清仓;买方评析整体评级只要下降就直接清仓,包括“好”降为“中”。人工清仓命令仍立即生效。
本次只涉及155模拟PMS的original账本。微盘轮换规则、188真实PMS、选股排序、三源合议与已确认的单行信号页面保持原规则。需要更新web、worker及唯一WS,因为新的停买检查覆盖规划、执行、下发和已排队委托的最终发送。
## 生效规则
1. 清仓级信号沿用现行置信度门槛,当前为85%。只接受有效的决策系统盘中SELL或风控SELL,核对原始时间、期限、出处、非降级结果及当前沪深持仓。新开关开启前的积压消息不计次。
2. 第一次登记持仓轮次、原始消息标识和内容依据,立即阻断新增买入,撤销该股在途买入。取消未确认和迟到成交保留原回报处理。此时不撤下正常卖出侧,不自动清仓。
3. 第二次独立信号撤下该股网格等交易方案,待旧卖出委托、待入账与孤儿回报收尾后,按original实际持仓量建立一条紧急EXIT。不是仅平掉试探仓或某个网格层。T+1部分顺延,后续迟到买入继续收尾;已有人工卖出先处理,不叠加卖出数量。
4. 消息重放和同一研判编号只算一次。上游两条流缺少共同研判编号,近120秒跨流消息保守地按一份处理,即使文字不同;不能证明独立时不凑足第二次。此边界可能合并近时的两个真实跨流结论,属于有意保守处理。
5. 正式买方评析以整体评级“好、中、差”比较。报告有可追溯版本、生成时间和有效状态;较新版本下降一档或两档直接进入清仓,不等待两个信号。旧版本、同版冲突、缺失、超时、过期和未知档均不当作降级。已启动的退出不会因评级随后回升自动撤销。
6. 首次取入场记录的正式评级作基线;无入场评级则以首次有效报告建基线,不臆测历史。按未平批次识别持仓轮次,已清空再开仓不继承旧计数;被停止父指令的迟到买入仍归旧退出收尾。
7. 用户全局暂停优先。第一次停买可以通过既有“恢复买入”或明确解冻命令解除;普通建仓失败、重试和旧命令重规划不能清除状态。已启动清仓须先处理冲突,用户取消的清仓不会被后台不断重新建立。取消收尾后可明确恢复。微盘账本不可被此路径认领或清仓。
## 实现及定时补读
`app/core/risk_exit.py`负责纯事实校验,`app/services/risk_exit.py`用既有轮换文档表保存每股计数、持仓轮次、评级版本和退出进度。事件先记账,账户锁与数据库事务保证同一轮不重复生成EXIT,无新表和账本重建。
信号入口在旧每日去重和待确认提议拦截之前消费新规则,否则旧的“一天一次”会吞掉第二个有效信号。盘中执行每轮在网格之前检查退出状态;执行任务不联网等评级。
持仓评级另在既有独立依据刷新任务中每300秒批量只读补齐,单次超时3秒,不发起模型任务。解决盘前映射遗漏当天新持仓以及无法及时发现新报告的问题。失败保留已确认评级与退出状态,下次重试。无新增调度项,不重建beat。
参数经ParamStore读取:`PMS_RISK_EXIT_ENABLED`默认关闭,`PMS_RISK_EXIT_START_AT`使用实际切换时刻,信号时龄300秒,跨流合并120秒,评级刷新300秒、请求超时3秒。部署完成后只在155开启。
## 发布前实况与验证
12:17只读核验:155主机factorevaluation,原PMS目录,表前缀为空,dispatch为ws,用户两项暂停false,改价、异步与微盘v3开启。最近200条连续确认1641795,资金与持仓快照5.9秒,待入账与孤儿0,数量和现金一致。当前web为e4a7424,worker和唯一WS为f756344。
12:19只读补读返回五只原策略持仓的正式报告,均与入场评级相同,未发现评级下降。盘前映射仅含雷赛智能,四只当日新仓原来尚未覆盖。雷赛智能1600股,存在09:38真实清仓提议和同源停买,评级“好”。切换只承接这一条真实第一次信号,不回扫历史补第二次,不补造模型、委托或回报。
开发机35项专项覆盖信号防重、三种评级下降、持仓轮次、缺失和超时、事务回滚、原策略与微盘隔离、取消待确认、既有卖出、迟到成交、T+1数量保留、用户恢复与解冻失败回滚、独立调度。全量与候选回归、部署和自然判收将在下节按实际结果追加。
## 回退与待验
回退只限三个目标服务,保留所有退出文档、指令、账本和回报。已经登记的停买不能仅关闭开关后丢失:回退前须先停止新增买入,检查已有EXIT和QMT委托,再按已落表指令继续收尾,不能删除计数或重放真实成交。
隔离检查不等于自然判收。当前没有本规则启用后的第二次独立清仓信号或评级下降,不能报告真实自动清仓已经验证。发布后记录实际开关、迁移初始化、自然调度和委托回报各自的状态,不为验证制造交易。

View File

@ -16,6 +16,7 @@
| 盘中改价、异步研判与微盘递补发布 | [执行链路发布接续](执行报价与异步研判发布接续_2026-11-03.md),区分部署、开关与自然判收;[实施规格](执行报价与异步研判实施规格_2026-11-03.md);[当日限制价采集边界](当日限制价采集边界_2026-11-03.md) |
| 策略资金缺行情提示、成本三位精度与含费口径 | [估值与成本精度修复](策略估值与成本精度修复_2026-11-04.md),含实际QMT回执、展示降级和导出舍入边界 |
| QMT工作台成交修正与配套委托回报 | [成交修正接入与发布](QMT成交修正接入与发布_2026-11-05.md),含原成交保留、修正幂等、数量变化阻断续单和证据不足挂起边界 |
| 原策略两次清仓信号与买方评级下降退出 | [退出纪律接续](两次清仓信号与评级下降退出_2026-11-05.md),含第一次停买、第二次清仓、任一级评级下降、持仓轮次、重复消息和T+1收尾 |
| 人工关注显示已剔除、每日选股重复与研究覆盖 | [人工关注分析链修复规格](人工关注分析链修复规格_2026-11-04.md),说明独立研究、回执与交易边界;[只读巡检及当日更正](人工关注与选股覆盖巡检_2026-11-04.md)保留历史时点证据;首次部署见[发布接续](人工关注与吸筹参考发布接续_2026-11-04.md),11月4日进度见[后续跟进](人工关注后续跟进与信号融合_2026-11-04.md),最新格式要求及计划过期恢复见[11月5日接续](信号流格式与选股恢复_2026-11-05.md) |
| 架构与接口 | [README模块地图](../README.md)、[总体设计](../POSITION_MGMT_DESIGN.md);改接口再读[QMT协议](../QMT_WS_PROTOCOL.md)、[bionic接口](../BIONIC_PMS_INTERFACE.md)或[计划接口](../UPSTREAM_PLAN_API.md) |
| 后端、前端、测试、研究 | [后端规则](../app/AGENTS.md)、[页面规则](../app/web/AGENTS.md)、[脚本规则](../scripts/AGENTS.md)、[研究规则](../research/AGENTS.md),仅选择所涉及目录 |

View File

@ -198,7 +198,8 @@ import sys
HERE = os.path.dirname(os.path.abspath(__file__))
ROOT = os.path.dirname(HERE)
SUITES = ["test_rotation_accounting_units.py", "test_cost_precision.py", "test_execution_basis_decimal.py",
# 退出纪律专项:两次独立清仓信号、评级下降、事务、双策略隔离及撤单收尾。
SUITES = ["test_risk_exit.py", "test_rotation_accounting_units.py", "test_cost_precision.py", "test_execution_basis_decimal.py",
"test_trade_correction_units.py", "test_trade_correction_transport.py",
"test_trade_correction_service.py", "test_trade_lineage_units.py",
"test_trade_correction_strategy.py",

View File

@ -50,6 +50,8 @@ ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# 这些函数**写失败时不抛异常**, 只把失败写在返回值里。调用点必须接住。
# key = 函数名, value = 允许的调用者模块名 (None = 不限, 用于 _db(f, ...) 这种间接调用)
SOFT_FAIL = {
"scan": {"risk_exit"},
"refresh_reviews": {"risk_exit"},
"consume": {"trade_correction"},
"sync": {"monitor_watch"},
"mark_send_attempt": {"qmt_repo"},

View File

@ -209,7 +209,9 @@ class SchedulerEntryTests(unittest.TestCase):
self.review.assert_called_once_with();self.model.assert_called_once_with()
def test_basis_refresh_entry_uses_new_flag(self):
self.assertEqual(self.sch.execution_basis_refresh.run(),{'enabled':True})
result = self.sch.execution_basis_refresh.run()
self.assertTrue(result['enabled'])
self.assertEqual(result['risk_reviews'], {'enabled': False, 'ok': True, 'reviews': {}, 'errors': []})
self.refresh.assert_called_once_with()
def test_cancel_confirm_entry_continues_under_global_halt(self):

412
scripts/test_risk_exit.py Normal file
View File

@ -0,0 +1,412 @@
"""退出纪律:虚构事件、真实SQLite事务与双策略隔离,禁止联网。"""
import unit_test_guard # noqa: F401
import copy
import datetime as dt
import json
import sys
import tempfile
import unittest
from pathlib import Path
from unittest.mock import patch
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
from sqlalchemy import create_engine, event, text
from app.core import risk_exit as core, signal_rules, strategy_book as books
from app.db import session as db
from app.repo import pms_repo, qmt_repo, rotation_repo as store
from app.services import risk_exit as service, param_store, strategy_service, logic_state_service
from app.services import executor, execution_orders, execution_conflicts, signal_service
from config.settings import settings
CODE = '600001.SH'
NOW = dt.datetime(2026, 11, 5, 10, tzinfo=core.TZ)
START = NOW-dt.timedelta(hours=1)
def signal(n=1, *, at=None, source='intraday', reason='独立研判确认退出'):
return {'ts_code': CODE, 'action': 'SELL', 'confidence': .95, 'reason': reason,
'source': source, 'producer_id': 'bionic_brain_intraday_v2.0',
'msg_id': str(n), 'signal_id': 'S'+str(n),
'event_time': (at or NOW).isoformat(), 'is_fallback': False}
def review(grade='好', ref='a', days=2):
return {'overall': grade, 'review_ref': ref*64,
'report_ran_at': (NOW-dt.timedelta(days=days)).isoformat(),
'qual': 'ok', 'brain_status': 'ok'}
class CoreTests(unittest.TestCase):
def parse(self, value):
return core.signal_event(value, now=NOW, since=START)
def test_valid_and_invalid_event_boundaries(self):
self.assertIsNotNone(self.parse(signal())[0])
changes = [dict(ts_code='920001.BJ'), dict(confidence=.6), dict(confidence=float('nan')),
dict(action='BUY'), dict(source='unknown'), dict(producer_id='smoketest'),
dict(event_time=None), dict(msg_id=None), dict(reason=''), dict(is_fallback=True),
dict(is_fallback='true'), dict(event_time=(NOW+dt.timedelta(seconds=1)).isoformat()),
dict(event_time=(NOW-dt.timedelta(minutes=6)).isoformat()),
dict(expires_at=(NOW-dt.timedelta(seconds=1)).isoformat()), dict(expires_at='bad')]
for changeset in changes:
with self.subTest(changeset=changeset):
self.assertIsNone(self.parse({**signal(), **changeset})[0])
def test_cutover_does_not_replay_old_signals(self):
self.assertIsNone(core.signal_event(signal(),now=NOW,since=NOW+dt.timedelta(seconds=1))[0])
self.assertIsNone(core.signal_event(signal(),now=NOW,since='')[0])
def test_replay_and_cross_stream_copy_do_not_count_twice(self):
a=self.parse(signal())[0]
self.assertTrue(core.duplicate([a],a))
copy_event=self.parse({**signal(2,source='risk_sell'), 'event_time':(NOW-dt.timedelta(seconds=1)).isoformat()})[0]
self.assertTrue(core.duplicate([a],copy_event))
copy_event=self.parse(signal(3,source='risk_sell',reason='同一研判的另一份文字'))[0]
self.assertTrue(core.duplicate([a],copy_event))
modified=self.parse({**signal(3), 'signal_id':'S1','reason':'重新包装的同一信号'})[0]
self.assertTrue(core.duplicate([a],modified))
self.assertFalse(core.duplicate([a],self.parse(signal(4))[0]))
def test_parser_preserves_upstream_identity_and_expiry(self):
t=int(NOW.timestamp()*1000)
a=signal_rules.parse_intraday({'ts_code':CODE,'action':'SELL','confidence':'.95',
'signal_id':'id','trigger_time':str(t),'producer_id':'bionic_brain_intraday_v2.0',
'signal_validity':json.dumps({'expires_at':t+300000}),'audit_reason':'退出'},msg_id='1')
self.assertEqual(a['event_time'],str(t));self.assertEqual(a['expires_at'],t+300000)
self.assertIsNotNone(self.parse(a)[0])
b=signal_rules.parse_risk_sell({'data':json.dumps({'ts_code':CODE,'action':'SELL',
'confidence':95,'timestamp':t,'is_fallback':False,'llm_reason':'退出'})},msg_id='2')
self.assertIsNotNone(self.parse(b)[0])
def test_every_overall_downgrade_counts(self):
for before,after in [('好','中'),('中','差'),('好','差')]:
with self.subTest(before=before,after=after):
a=core.review_snapshot(review(before),now=NOW)
b=core.review_snapshot(review(after,'b',1),now=NOW)
self.assertEqual(core.review_change(a,b),'downgrade')
def test_missing_stale_incomplete_and_future_review_are_not_downgrades(self):
for value in [None,{},review('未知'),{**review(),'qual':'off'},
{**review(),'brain_status':'timeout'},review(days=121),review(days=-1),
{**review(),'review_ref':''}]:
self.assertIsNone(core.review_snapshot(value,now=NOW))
def test_review_order_and_immutable_identity(self):
a=core.review_snapshot(review(),now=NOW)
self.assertEqual(core.review_change(a,a),'same')
self.assertEqual(core.review_change(None,a),'baseline')
self.assertEqual(core.review_change(a,None),'missing')
self.assertEqual(core.review_change(a,core.review_snapshot(review('差','b',3),now=NOW)),'old')
with self.assertRaises(ValueError):core.review_change(a,{**a,'grade':'中'})
class ServiceTests(unittest.TestCase):
def setUp(self):
self.tmp=tempfile.TemporaryDirectory();self.addCleanup(self.tmp.cleanup)
self.engine=create_engine('sqlite:///'+self.tmp.name+'/risk.sqlite');self.addCleanup(self.engine.dispose)
@event.listens_for(self.engine,'before_cursor_execute',retval=True)
def dialect(conn,cursor,sql,params,context,many):
db.assert_single_table(sql)
sql=sql.replace(' FOR UPDATE','')
if 'ON DUPLICATE KEY UPDATE' in sql:
self.assertIn('pms_rotation_document',sql)
sql=sql.split('ON DUPLICATE KEY UPDATE')[0]+'ON CONFLICT DO NOTHING'
return sql,params
self.params={'PMS_RISK_EXIT_ENABLED':True,'PMS_RISK_EXIT_START_AT':START.isoformat()}
self.use(db,'get_engine',lambda *args:self.engine)
self.use(db,'_check_cooldown',lambda *args:None)
self.use(settings,'INFRA_STRATEGY_BOOK_SCHEMA',True)
for name in ('get','get_bool','get_int','get_float'):
self.use(param_store,name,lambda key,default=None:self.params.get(key,default))
self.use(logic_state_service,'entry_view',lambda code:{'company_review':review()})
self.reviews={CODE:{'company_review':review()}}
self.use(logic_state_service,'state_map',lambda:self.reviews)
self.use(execution_orders,'correction_blocker',lambda *a,**k:'')
self.pending,self.orphans=0,0
self.use(qmt_repo,'inbox_pending_count',lambda:self.pending)
self.use(qmt_repo,'inbox_orphan_count',lambda:self.orphans)
self.use(strategy_service,'buypause_map',lambda:(store.get('test-pause')[0] or {}))
def pause(code,reason='',source='signal'):
with store.locked('test-pause','test',{}) as m:
e=m.setdefault(code,{'sources':{}})
e['sources'][source]={'reason':reason,'at':NOW.isoformat()}
return []
def clear(code,only_source=None):
with store.locked('test-pause','test',{}) as m:m.pop(code,None)
return {'ok':True,'cleared':True}
self.use(strategy_service,'pause_buy',pause)
self.use(strategy_service,'clear_buypause',clear)
self.cancel_pending=False
def cancel(iid,reason='',arbiter='user',**kwargs):
self.assertEqual(arbiter,'system')
if not self.cancel_pending:pms_repo.update_instruction(iid,status='CANCELLED')
return {'ok':True,'pending':self.cancel_pending}
self.use(executor,'cancel_instruction',cancel)
schema={
'pms_position':'id INTEGER PRIMARY KEY,book_id TEXT,ts_code TEXT,total_qty INTEGER,avail_qty INTEGER,opened_date TEXT,status TEXT',
'pms_lot':'id INTEGER PRIMARY KEY,book_id TEXT,ts_code TEXT,instruction_id TEXT,qty INTEGER,status TEXT,open_date TEXT',
'pms_instruction':'id INTEGER PRIMARY KEY,book_id TEXT,instruction_id TEXT UNIQUE,origin_type TEXT,origin_id TEXT,ts_code TEXT,action TEXT,side TEXT,qty INTEGER,limit_price REAL,window_tdays INTEGER,status TEXT,exec_qty INTEGER DEFAULT 0,exec_avg_price REAL,progress_json TEXT,created_at TEXT,updated_at TEXT,archived_at TEXT',
'pms_action_ledger':'id INTEGER PRIMARY KEY,book_id TEXT,ts_code TEXT,decided_at TEXT,action TEXT,arbiter TEXT,verdict TEXT,price_at REAL,hard_numbers_json TEXT,failed_checks_json TEXT,reason TEXT,ref_id TEXT,outcome_scored INTEGER',
'pms_proposal':'id INTEGER PRIMARY KEY,book_id TEXT,proposal_id TEXT,ts_code TEXT,action TEXT,qty INTEGER,hard_numbers_json TEXT,judge_verdict TEXT,judge_reason TEXT,status TEXT,expire_at TEXT,created_at TEXT,decided_at TEXT,archived_at TEXT',
'pms_strategy':'id INTEGER PRIMARY KEY,book_id TEXT,strategy_id TEXT,ts_code TEXT,type TEXT,status TEXT,params_json TEXT,state_json TEXT,autonomy TEXT,note TEXT,created_at TEXT,updated_at TEXT,archived_at TEXT',
'pms_rotation_document':'doc_id TEXT PRIMARY KEY,kind TEXT,payload_json TEXT,revision INTEGER,updated_at TEXT',
'pms_plan':'id INTEGER PRIMARY KEY,book_id TEXT,plan_id TEXT,ts_code TEXT,action TEXT,status TEXT,priority INTEGER,created_at TEXT,updated_at TEXT',
'pms_qmt_order':'id INTEGER PRIMARY KEY,instruction_id TEXT,parent_id TEXT,ts_code TEXT,side TEXT,status TEXT',
}
with self.engine.begin() as conn:
for table,cols in schema.items():conn.execute(text('CREATE TABLE '+table+' ('+cols+')'))
self.insert('pms_position',dict(book_id='original',ts_code=CODE,total_qty=1600,avail_qty=1600,opened_date='2026-11-03',status='HOLDING'))
self.insert('pms_lot',dict(id=1,book_id='original',ts_code=CODE,instruction_id='BASE',qty=1600,status='OPEN',open_date='2026-11-03'))
def use(self,obj,name,value):
p=patch.object(obj,name,value);p.start();self.addCleanup(p.stop)
def insert(self,table,value):
with self.engine.begin() as conn:
conn.execute(text('INSERT INTO '+table+' ('+','.join(value)+') VALUES ('+','.join(':'+k for k in value)+')'),value)
def change(self,sql):
with self.engine.begin() as conn:conn.execute(text(sql))
def state(self):return store.get(service._key(CODE))[0] or {}
def instructions(self):return pms_repo.list_instructions(ts_code=CODE,include_archived=True)
def fire(self,n=1,**kwargs):return service.on_signal(signal(n,**kwargs),now=NOW)
def test_first_stops_buys_second_creates_one_full_exit(self):
self.assertEqual(self.fire()['count'],1)
self.assertTrue(execution_conflicts.buy_blocker(CODE));self.assertEqual(self.instructions(),[])
self.assertEqual(self.fire(2)['count'],2)
orders=self.instructions();self.assertEqual(len(orders),1)
self.assertEqual((orders[0]['action'],orders[0]['qty']),('EXIT',1600))
self.assertTrue(orders[0]['progress']['urgent'])
def test_duplicate_after_restart_does_not_count(self):
self.fire();self.fire()
self.assertEqual(self.state()['count'],1);self.assertEqual(self.instructions(),[])
self.fire(2);self.fire(2);service.scan(now=NOW)
self.assertEqual(len(self.instructions()),1)
def test_same_report_and_upgrade_no_exit_downgrade_exits(self):
self.assertEqual(service.observe_review(CODE,review(),now=NOW),'same')
service.drive(CODE,now=NOW);self.assertEqual(self.instructions(),[])
self.assertEqual(service.observe_review(CODE,review('中','b',1),now=NOW),'downgrade')
service.drive(CODE,now=NOW)
self.assertEqual(self.instructions()[0]['qty'],1600)
self.assertEqual(self.state()['review_exit']['before']['grade'],'好')
def test_missing_entry_review_starts_baseline_without_fabricated_decline(self):
self.use(logic_state_service,'entry_view',lambda code:{})
self.assertEqual(service.observe_review(CODE,review('中'),now=NOW),'baseline')
service.drive(CODE,now=NOW);self.assertEqual(self.instructions(),[])
def test_incomplete_review_keeps_last_valid_baseline(self):
service.observe_review(CODE,review(),now=NOW)
service.observe_review(CODE,{**review('差','b',1),'brain_status':'timeout'},now=NOW)
self.assertEqual(self.state()['review']['grade'],'好');self.assertEqual(self.instructions(),[])
def test_stale_or_changed_same_version_does_not_exit(self):
service.observe_review(CODE,review(),now=NOW)
self.assertEqual(service.observe_review(CODE,review('差','b',3),now=NOW),'old')
with self.assertRaises(ValueError):service.observe_review(CODE,review('差'),now=NOW)
self.assertEqual(self.state()['review']['grade'],'好');self.assertEqual(self.instructions(),[])
def test_global_pause_records_intent_without_actions(self):
self.params['PMS_GLOBAL_EXEC_HALT']=True
self.fire();self.fire(2)
self.assertEqual(self.state()['phase'],'EXIT_PENDING');self.assertEqual(self.instructions(),[])
self.params['PMS_GLOBAL_EXEC_HALT']=False
service.scan(now=NOW);self.assertEqual(len(self.instructions()),1)
def test_dry_run_writes_nothing(self):
result=service.on_signal(signal(),now=NOW,dry_run=True)
self.assertTrue(result['dry_run']);self.assertEqual(self.state(),{});self.assertEqual(self.instructions(),[])
def test_feature_off_keeps_legacy_path(self):
self.params['PMS_RISK_EXIT_ENABLED']=False
self.assertIsNone(self.fire());self.assertIsNone(service.buy_blocker(CODE))
def test_micro_book_untouched(self):
self.insert('pms_position',dict(book_id='micro30',ts_code=CODE,total_qty=900,avail_qty=900,opened_date='2026-11-03'))
self.insert('pms_lot',dict(id=2,book_id='micro30',ts_code=CODE,instruction_id='MICRO',qty=900,status='OPEN'))
with books.scope('micro30'):
self.assertIsNone(self.fire());self.assertIsNone(service.buy_blocker(CODE))
self.fire();self.fire(2)
self.assertEqual(self.instructions()[0]['qty'],1600)
with books.scope('micro30'):
self.assertEqual(self.instructions(),[]);self.assertEqual(pms_repo.get_position(CODE)['total_qty'],900)
def test_t1_retains_full_exit_quantity_until_available(self):
self.change('UPDATE pms_position SET avail_qty=0')
self.fire();self.fire(2)
self.assertEqual(self.instructions()[0]['qty'],1600)
service.scan(now=NOW);self.assertEqual(len(self.instructions()),1)
def test_exit_insert_failure_does_not_consume_second_signal_twice(self):
self.fire()
with patch.object(pms_repo,'insert_instruction',return_value=0):
with self.assertRaises(RuntimeError):self.fire(2)
self.assertEqual(self.state()['count'],2);self.assertEqual(self.state()['phase'],'EXIT_PENDING')
self.assertEqual(self.instructions(),[])
self.fire(2);self.assertEqual(len(self.instructions()),1);self.assertEqual(self.state()['count'],2)
def test_audit_failure_rolls_back_signal_count(self):
with patch.object(pms_repo,'insert_ledger',return_value=0):
with self.assertRaises(RuntimeError):self.fire()
self.assertEqual(self.state(),{})
self.fire();self.assertEqual(self.state()['count'],1)
def test_first_cancels_buy_but_preserves_sell(self):
pms_repo.insert_instruction(instruction_id='BUY',origin_type='proposal',origin_id=None,ts_code=CODE,action='ADD',side='buy',qty=100,status='PROPOSED')
pms_repo.insert_instruction(instruction_id='SELL',origin_type='plan',origin_id=None,ts_code=CODE,action='TRIM',side='sell',qty=100,status='PROPOSED')
self.fire()
self.assertEqual(pms_repo.get_instruction('BUY')['status'],'CANCELLED')
self.assertEqual(pms_repo.get_instruction('SELL')['status'],'PROPOSED')
self.assertIsNotNone(pms_repo.instruction_buy_stop('BUY'))
def test_existing_sell_finishes_before_full_exit(self):
pms_repo.insert_instruction(instruction_id='SELL',origin_type='plan',origin_id=None,ts_code=CODE,action='TRIM',side='sell',qty=100,status='PROPOSED')
self.fire();self.fire(2);self.assertEqual(len(self.instructions()),1)
pms_repo.update_instruction('SELL',status='CONFIRMED')
self.change('UPDATE pms_position SET total_qty=1500,avail_qty=1500')
self.change('UPDATE pms_lot SET qty=1500')
service.drive(CODE,now=NOW)
self.assertEqual(self.instructions()[0]['qty'],1500)
def test_pending_order_even_with_terminal_parent_prevents_double_sell(self):
pms_repo.insert_instruction(instruction_id='OLD',origin_type='strategy',origin_id=None,ts_code=CODE,action='TRIM',side='sell',qty=100,status='CANCELLED')
self.insert('pms_qmt_order',dict(instruction_id='CHILD',parent_id='OLD',ts_code=CODE,side='sell',status='ACCEPTED'))
self.fire();self.fire(2)
self.assertEqual(len(self.instructions()),1)
def test_pending_ledger_and_correction_hold_wait(self):
self.fire();self.pending=1;self.fire(2)
self.assertEqual(self.instructions(),[])
self.pending=0
with patch.object(execution_orders,'correction_blocker',return_value='修正待核实'):
with self.assertRaises(RuntimeError):service.drive(CODE,now=NOW)
self.assertEqual(self.instructions(),[])
service.drive(CODE,now=NOW);self.assertEqual(len(self.instructions()),1)
def test_cancelled_exit_is_not_reopened(self):
self.fire();self.fire(2)
pms_repo.update_instruction(self.instructions()[0]['instruction_id'],status='CANCELLED')
service.drive(CODE,now=NOW)
self.assertEqual(self.state()['phase'],'MANUAL');self.assertEqual(len(self.instructions()),1)
service.resume_buy(CODE)
self.assertEqual(self.state()['phase'],'WATCH')
self.assertIsNone(service.buy_blocker(CODE))
def test_late_buy_after_flat_is_still_closed_out(self):
self.fire();self.fire(2)
iid=self.instructions()[0]['instruction_id'];pms_repo.update_instruction(iid,status='CONFIRMED',exec_qty=1600)
self.change('UPDATE pms_position SET total_qty=0,avail_qty=0');self.change("UPDATE pms_lot SET qty=0,status='CLOSED'")
service.scan(now=NOW);self.assertEqual(self.state()['phase'],'CLOSED')
self.insert('pms_lot',dict(id=2,book_id='original',ts_code=CODE,instruction_id='BASE',qty=100,status='OPEN'))
self.change('UPDATE pms_position SET total_qty=100,avail_qty=0')
service.scan(now=NOW)
self.assertEqual(len(self.instructions()),2);self.assertEqual(self.instructions()[0]['qty'],100)
def test_new_holding_round_does_not_inherit_old_signal(self):
self.fire();old=self.state()['round_id']
self.change("UPDATE pms_lot SET qty=0,status='CLOSED'")
self.insert('pms_lot',dict(id=2,book_id='original',ts_code=CODE,instruction_id='NEW',qty=1600,status='OPEN'))
service.observe_review(CODE,review(),now=NOW)
self.assertNotEqual(self.state()['round_id'],old);self.assertEqual(self.state()['count'],0)
self.assertEqual(self.instructions(),[])
def test_human_resume_resets_count_but_cannot_undo_started_exit(self):
self.fire();service.resume_buy(CODE)
self.assertIsNone(service.buy_blocker(CODE));self.assertEqual(self.state()['count'],0)
self.fire();self.assertEqual(self.state()['count'],0) # 已处理的旧信号不得重算。
self.change("DELETE FROM pms_rotation_document WHERE doc_id LIKE 'risk-exit:%'")
self.fire();self.fire(2)
with self.assertRaises(ValueError):service.resume_buy(CODE)
def test_legacy_pause_only_seeds_one_real_signal(self):
reason='风控 SELL 置信度 95% ≥ 85%, 清仓 1600 股 —— 旧真实研判'
strategy_service.pause_buy(CODE,reason=reason,source='intraday')
pms_repo.insert_proposal(proposal_id='LEGACY',ts_code=CODE,action='EXIT',qty=1600,
hard_numbers={'on_strategy':True,'confidence':.95,'signal_source':'intraday','reason':'策略暂停。 —— '+reason},
expire_at=NOW+dt.timedelta(days=1),judge_verdict='STRATEGY_RISK')
self.change("UPDATE pms_proposal SET created_at='2026-11-05 10:00:00'")
service.observe_review(CODE,review(),now=NOW)
self.assertEqual(self.state()['count'],1);self.assertEqual(self.instructions(),[])
self.fire(2)
self.assertEqual(len(self.instructions()),1)
self.assertEqual(pms_repo.get_proposal('LEGACY')['status'],'EXPIRED')
def test_signal_handler_bypasses_legacy_daily_dedup_and_pending_proposal(self):
view={'positions':[{'ts_code':CODE,'total_qty':1600,'avail_qty':1600}]}
prm={'sell_conf_min':.6,'auto_exit_conf':.85,'trim_ratio':.3333}
seen={signal_rules.dedup_key(signal(),20261105):None}
class Clock(dt.datetime):
@classmethod
def now(cls,tz=None):return NOW
with patch.object(service,'datetime',Clock):
out={'ignored':0}
signal_service._handle(signal(),view,prm,seen,20261105,False,out,{CODE})
signal_service._handle(signal(2),view,prm,seen,20261105,False,out,{CODE})
self.assertEqual(len(self.instructions()),1)
def test_independent_review_refresh_and_timeout_keep_baseline(self):
from app.services import plan_feed
with patch.object(plan_feed,'fetch_logic_states',return_value={CODE:{'company_review':review('中','b',1)}}) as fetch:
out=service.refresh_reviews(now=NOW)
self.assertTrue(out['ok']);self.assertEqual(out['reviews'][CODE],'downgrade')
fetch.assert_called_once_with([CODE],timeout=3)
self.assertEqual(self.instructions(),[]) # 刷新只记意图,委托留给执行任务。
service.refresh_reviews(now=NOW+dt.timedelta(seconds=60))
self.assertEqual(fetch.call_count,1)
with patch.object(plan_feed,'fetch_logic_states',side_effect=TimeoutError):
out=service.refresh_reviews(now=NOW+dt.timedelta(minutes=6))
self.assertFalse(out['ok']);self.assertEqual(self.state()['review']['grade'],'中')
self.assertEqual(self.state()['phase'],'EXIT_PENDING')
service.scan(now=NOW)
self.assertEqual(len(self.instructions()),1)
def test_refresh_missing_rows_and_disabled_do_not_manufacture_downgrade(self):
from app.services import plan_feed
with patch.object(plan_feed,'fetch_logic_states',return_value={}) as fetch:
out=service.refresh_reviews(now=NOW)
self.assertEqual(out['reviews'][CODE],'missing')
self.assertEqual(self.state()['review']['grade'],'好')
self.params['PMS_RISK_EXIT_ENABLED']=False
service.refresh_reviews(now=NOW+dt.timedelta(minutes=6))
self.assertEqual(fetch.call_count,1)
self.assertEqual(self.instructions(),[])
def test_failed_unfreeze_command_cannot_clear_risk_pause(self):
from app.services import command_service
self.fire()
with patch.object(command_service,'active_commands',return_value=[]), \
patch.object(pms_repo,'next_command_seq',return_value=1), \
patch.object(pms_repo,'insert_command',return_value=1), \
patch.object(pms_repo,'update_command',return_value=1), \
patch.object(command_service,'_apply_param',return_value={'ok':False}):
result=command_service.issue('UNFREEZE_STOCK',{'ts_code':CODE})
self.assertFalse(result['ok'])
self.assertEqual(self.state()['phase'],'STOP_BUY')
self.assertIn('risk_exit',strategy_service.buypause_map()[CODE]['sources'])
def test_new_buy_command_does_not_silently_reset_stop(self):
from app.services import command_service
self.fire()
with patch.object(command_service,'active_commands',return_value=[]), \
patch.object(pms_repo,'next_command_seq',return_value=1), \
patch.object(pms_repo,'insert_command',return_value=1), \
patch.object(pms_repo,'get_command',return_value={}), \
patch.object(command_service,'plan_command',return_value={'ok':False}):
command_service.issue('OPEN_TARGET',{'ts_code':CODE,'target_ratio':.05})
self.assertEqual(self.state()['phase'],'STOP_BUY')
def test_refresh_runs_independently_of_reprice_switch(self):
from app import scheduler
self.params['PMS_EXEC_REPRICE_ENABLED']=False
fn=scheduler.execution_basis_refresh.run
while hasattr(fn,'__wrapped__'):fn=fn.__wrapped__
with patch.object(service,'refresh_reviews',return_value={'ok':True,'reviews':{CODE:'same'}}) as fresh:
result=fn()
fresh.assert_called_once()
self.assertEqual(result['risk_reviews']['reviews'],{CODE:'same'})
if __name__=='__main__':unittest.main()

View File

@ -728,6 +728,11 @@ def install_fakes(prices=None, positions=None, params=None, high5=None, prev_clo
execution_repo.pending_corrections = pending_corrections
from app.repo import trade_correction_repo
trade_correction_repo.pending = lambda limit=100: []
# 持仓评析补读走既有只读接口;装配测试使用内存结果,禁止访问上游。
from app.services import plan_feed
fake.logic_states = {}
plan_feed.fetch_logic_states = lambda codes, **kw: {c: dict(fake.logic_states[c])
for c in codes if c in fake.logic_states}
fake.params.update(params or {})
for p in (positions or []):
base = {"ts_code": p["ts_code"], "status": "HOLDING", "frozen_reason": "NONE",