Compare commits

..

63 Commits

Author SHA1 Message Date
baobao 27cd570f95 记录账户资金修复在155的部署与对账判收 2026-10-26 16:49:39 +08:00
baobao f90d5e78a0 修复可用资金重复计入回笼并统一账户总览口径 2026-10-26 16:24:14 +08:00
baobao 80433d3f95 记录质地选股在模拟仓的联合切换与实际消费判收 2026-10-26 15:05:20 +08:00
baobao e7242f6555 切换质地选股并让命令升仓沿用候选顺序 2026-10-26 14:41:25 +08:00
baobao 83273b6dae 记录选股排序与传导筛选切换未完成的原因 2026-10-26 14:22:00 +08:00
baobao 8c4e086776 记录钧达修复的模拟仓部署与账实判收 2026-10-26 14:05:00 +08:00
baobao 47bcea58bd 修复成交回放延迟导致的重复下发并明确摊薄成本 2026-10-26 13:52:30 +08:00
baobao 2e5bc56cf9 交接副本同步 2026-10-22 11:00:54 +08:00
baobao 0506120d87 高股息建仓:登记四服务部署与页面判收(台账 082) 2026-10-22 11:00:48 +08:00
baobao ccf194bda9 高股息页面:合并重复缺口,完整核验记录折叠展示
一、默认展开只呈现论点、反方和阻塞原因,原始材料缺口放入二级详情。

二、三道页面守卫通过,仅调整展示层次,不改变候选资格、建仓评估或采纳逻辑。
2026-10-22 10:56:02 +08:00
baobao 03e569e3c5 高股息建仓:独立候选复用后台准备与原子采纳(台账 082)
一、补齐研究至建仓的缺失入口。未知资料不放行,固定依据变化交后台处理。

二、本地桥9项新增与PMS24项专项通过,PMS48批隔离禁网回归通过。部署另行判收。

三、保留原每日榜单、自主档位、仓位和执行逻辑。新来源人工发起,不合并进原自主扫描,不制造交易验收。
2026-10-22 10:37:51 +08:00
baobao e36f05f503 交接副本同步 2026-10-22 09:59:36 +08:00
baobao 69c1a5434e 方案副本同步 2026-10-21 17:17:47 +08:00
baobao 2685b78461 方案副本同步 2026-10-21 16:17:53 +08:00
baobao 22532c3a09 方案副本同步 2026-10-21 15:12:45 +08:00
baobao 048c93e1b7 交接副本同步 2026-10-21 10:26:25 +08:00
baobao 888a20897d 提议采纳:原数量可执行时保持确认内容(台账 078)
一、现场原500股因组合现金变化而反复改写说明,确认标识随报价漂移。研究与参数未变且原数量仍过闸时保留准备结果,不扩大数量。

二、额度不足仍按原流程重算数量并复用研判。新增真实API反例至14项,47批隔离禁网回归重新通过。
2026-10-21 10:14:20 +08:00
baobao 2d3982f945 方案副本同步 2026-10-21 10:07:35 +08:00
baobao 984e3d7f00 提议采纳:逐票快速核验、原子保存与重复确认幂等(台账 078)
一、盛弘股份09:45采纳因整榜读取超过3秒失败,实测3MB响应5.481秒。
改用已发布计划的逐票接口,取数失败保留原准备内容,已知研究变化仍阻断。
恢复只核验原数量,确认不重问模型、不新记消费;页面不把连接失败当建议变化。

二、普通建仓的采纳状态、动作审计和指令同事务提交。
API至真实SQL的13项离线反例覆盖故障回滚、双击、响应丢失重试和失效边界。
重复确认返回原指令,提议身份进入指令幂等键,避免同日不同建议碰撞。

三、47批隔离禁网回归和三页面守卫通过。候选镜像与155部署另记。
交易时段、排序、仓位、择时与下发终检没有改变。卖出与策略发单不并入本次事务改造。
2026-10-21 10:07:35 +08:00
baobao 54e26b64f9 交接副本同步 2026-10-20 11:41:00 +08:00
baobao 1df17e6777 提议留痕:保留原消费来源,单列采纳时的最新检查(桥台账077)
一、无关版本变化允许快速采纳,但不能将新计划身份和旧消费凭据拼在一起。保留建议原计划与消费记录,当前检查版本只存入version_check。

二、专项覆盖旧消费来源不变且最新检查可追溯,46批隔离禁网回归通过。交易行为、仓位、阈值和调度保持。
2026-10-20 11:32:54 +08:00
baobao 0acf7b8fdb 提议采纳:后台完成准备,人工确认只做快速检查(桥台账077)
一、待确认建议先完成研究、数量、规则和消费留痕。研究变化交后台原扫描重评,组合变化复用研判,准备结果与审计原子发布。

二、采纳不调用模型或新增消费快照,固定用户看到的数量,保留资料新鲜度、资金、规则、到期和买卖冲突检查。更新与确认通过原JSON条件互斥。

三、54项专项与46批隔离禁网回归通过,浏览器替身交互零错误。交易时段、策略阈值和既有执行终检保持;188及历史账务不改。生产部署另行判收。
2026-10-20 11:31:02 +08:00
baobao 82f4f00848 交接副本同步 2026-10-19 14:33:24 +08:00
baobao 28053f3bfc 交易执行:人工清仓保留待可卖任务,归零仍停止旧买入(台账 076)
一、人工采纳清仓原来按当日可卖量裁剪。T+1为零时返回已采纳却丢弃执行安排,旧买入仍可能续单。现在只按确认数量与当前总持仓取较小值,执行器继续限制当日可卖量。持仓已归零仍停止旧买入,不额外生成卖单。

二、补齐两项真实入口回归,24专项与45批本地隔离禁网验证通过。普通减仓、成交核销与业务阈值保持。首次部署已由自然调度停止科士达剩余买入,补修尚待部署判收。
2026-10-19 14:24:59 +08:00
baobao fad1bb1fb5 交易执行:清仓停止旧买入,补齐跨轮互斥与真实进度(台账 076)
一、科士达旧建仓600股已成400股,风控清仓400股已成200股,旧买入仍活跃。完整清仓统一停止买入指令、提议及未解锁批次,停止依据追加账本,旧进度不能复活终态。普通减仓仅暂停买入,做T配对不误作清仓。

二、出口先撤后发,认领排除待撤,发送前复核来源与方向。页面按子委托事实显示等待,补回上游原始卖出理由。22项专项及45批隔离禁网回归通过。

三、不修改成交、成本、盈亏、交易时段、仓位和策略阈值。仅拟部署155模拟实例,188不动;部署与自然调度判收另记。
2026-10-19 14:16:20 +08:00
baobao e8c33b39c9 交接副本同步 2026-10-19 10:07:58 +08:00
baobao 38db2415b5 交接副本同步 2026-10-19 09:54:05 +08:00
baobao 0e545c3ab1 交接副本同步 2026-10-16 14:50:07 +08:00
baobao fa919c9f3d 提议采纳:记录失效撤下的部署与真实判收 2026-10-16 14:50:01 +08:00
baobao 60de23e79a 每日计划:明确否决的提议自动撤下,保留原因和并发保护(台账 073)
一、明确失效后结束旧建议。瑞芯微14:20自然重核返回REJECT,仍留待确认会误导用户;复用EXPIRED并记录撤下原因,暂时不可用继续守成。

二、撤下与拒绝留痕同事务,原状态和JSON防并发。沿用既有拒绝和重问,不调整准入、仓位或交易时段,不恢复旧批准。

三、30项专项和44批隔离禁网测试通过,含事务回滚、重复收尾及页面守卫;Node交互替身通过。候选镜像和155部署判收另记。
2026-10-16 14:36:31 +08:00
baobao 0e8a845c21 交接副本同步 2026-10-16 14:08:05 +08:00
baobao 333ddc9392 提议采纳:记录真实拒绝原因、部署核验与验证边界 2026-10-16 14:07:59 +08:00
baobao 4f6b1922f1 提议采纳:保留拦截原因与确认内容,完善等待及结果反馈(台账 072)
一、真实拒绝需要让用户看见原因
瑞芯微13:40研判拒绝只回通用错误,原提议仍展示旧结论。失败保留具体原因与检查记录,条件更新避免覆盖并发结果,原数量及批准依据保持。

二、更新内容必须重新确认
确认框展示新数量与理由并清空旧选择。等待期间阻止重复点击,超时或断网不自动重发。浏览器等待覆盖有效研判超时与取数;已有失败不能复用旧批准。

三、验证与边界
24个专项、44批本地隔离禁网回归及Node交互替身通过。未改准入、研判、仓位、执行规则与时段,部署仅限155模拟仓。候选镜像和线上验证另记,188不操作。
2026-10-16 13:56:08 +08:00
baobao 938fff2e0f 交接副本同步 2026-10-16 13:34:54 +08:00
baobao 1e300adf95 交接副本同步 2026-10-16 13:25:30 +08:00
baobao c11a2771bd 交接副本同步 2026-10-16 11:37:19 +08:00
baobao b35c198f34 运行核验:记录网格越界修复部署与七笔成交核销 2026-10-16 11:37:13 +08:00
baobao bafecb7fea 网格策略:卖出按档位余额与实际网格持仓封顶
一、自然成交反例
威胜信息原网格档位1000股,首卖700后恢复300股。第二次穿越仍按配置卖700股,实际侵入400股底仓。原代码只以配置档量和总可卖量封顶,遗漏档位余额和实际ADD持仓。

二、修复与验证
增加两项数量上限,保持原穿越条件、参数、价格、资金上限和最小申报要求。四组新增回归原实现均失败,修复后45个策略用例及44批配置隔离禁网回归全部通过。未成交和部分成交仍按原流程恢复余额。

三、实际成交边界
真实七笔成交合计1400股、32933.49元,批次和指令已逐笔核验。保留实际成交,不回填底仓或反向交易,已取消策略不恢复。仅部署155模拟仓,188不动。关联桥台账070,规格与部署判收另同步。
2026-10-16 11:27:19 +08:00
baobao 8491381d4a 交接副本同步 2026-10-16 10:50:24 +08:00
baobao 18b6a20ccb 运行核验:记录重核修复部署与十四笔自然成交判收 2026-10-16 10:50:19 +08:00
baobao 15072f72e4 提议重核:报价波动不重复触发确认,保留真实承诺变化核验
一、修复重复确认
正常用户在 10:02 和 10:04 两次确认科士达均被要求重核。实时估算在途金额进入仓位指纹,报价变化会误判为承诺变化。稳定依据改用来源、标识、股票、数量与成交进度。

二、验证与边界
批次 38 的 18 个用例和完整 44 批隔离禁网回归通过。涵盖纯报价不重跑研判、真实承诺变更、旧输入保守兼容、并发确认。新增字段不改变原占用金额计算、候选顺序与执行终检。

三、部署范围
只部署已授权的 155 模拟 PMS,188 不动。旧提议格式升级仍需一次重核,不迁移旧批准。桥决定台账 069 与四仓规格、交接另行同步。用户已有台账草稿与探针不纳入。
2026-10-16 10:41:27 +08:00
baobao 1d7c74f46c 交接副本同步 2026-10-16 10:22:01 +08:00
baobao 564f553457 交易页面:补齐右栏分区折叠样式 2026-10-16 10:18:15 +08:00
baobao 16d8fd76b2 交易页面:精简提议与候选信息,突出建议和风险
一、让交易员先看建议与风险。数量、金额和仓位差异置于卡面,重复操作说明合并,数量计算过程收进详情。候选显示等待条件,来源与参数折叠保留。

二、仅调整呈现。三项页面守卫通过,缺价、时区和仓位显示检查通过。采纳、驳回、策略动作及候选筛选函数与改前一致。交易规则和运行参数未改。

三、部署采用 155 静态绑定挂载。先备份并断网验证,再拉取;不重启交易进程。线上判收另行记录。
2026-10-16 10:13:37 +08:00
baobao f79ddffd1b 交接副本同步 2026-10-16 09:50:47 +08:00
baobao c2d0dc921f 交易页面:研究依据复用详情入口,收起技术追溯字段
一、修复侧栏信息堆叠
右侧提议新增字段展开后出现长版本号溢出,裁决按钮被挤到下方。删除该清单,沿用基本面入口,按判断与风险组织研究详情。

二、保留追溯并统一阅读方式
版本、指纹与消费顺序收进默认折叠的数据来源。候选、持仓和运维提议共用详情,不改变研究原文、交易数量、参数或采纳核验。

三、验证
本地三道页面守卫通过。JavaScript 语法、空记录、零值、研究变化、数字格式与原始数据保持验证通过。155 挂载已核对,纯静态页无需重建交易进程,实机验收另记。
2026-10-16 09:45:43 +08:00
baobao 5378f70e8c 交接副本同步 2026-10-16 09:31:49 +08:00
baobao 3057250330 每日选股计划:统一收到版本的读写指纹,修正页面追溯说明
一、真实页面误报未落快照
收到记录已使用决策版本与查询范围指纹,变化和只读预览仍使用旧名册指纹。三个出口统一使用收到身份,旧数据保持原口径。记录结构及历史内容不改。

二、研究展示一致
删去上游实时装配、无版本戳及始终按分数排序的过期说明。运维提议页复用已有研究详情,与交易员视图一致。没有调整排序、过滤、数量或采纳规则。

三、验证
新增同版与查询范围的往返回归。全部 44 批隔离禁网测试通过;补齐页面展示后,三项页面守卫再通过。候选镜像与线上验收另行记录。
2026-10-16 09:17:34 +08:00
baobao 3989b21c75 交接副本同步 2026-10-16 07:41:50 +08:00
baobao 0095fc0004 交接副本同步 2026-10-15 12:51:53 +08:00
baobao a56dac5ab1 指令进度:新成交使旧修复均价失效,保留固定金额证据(台账 020)
一、历史修复补齐了 24 条父指令均价,但既有增量入账接口只提供数量。
后续成交若只改执行量,均价会继续显示旧修复时点数值。

二、执行量增加时同步使均价失效,固定时点金额仍保存在修复进度和操作审计。
不改变成交数量、批次、资金、策略或旧指令的暂停状态。

三、内存数据库行为测试通过,batch40 共 22 例;完整 44 批本地隔离禁网通过。
2026-10-15 12:47:30 +08:00
baobao 2909738263 交接副本同步 2026-10-15 12:44:08 +08:00
baobao 0871885801 历史账本:按逐笔恢复数量成本盈亏与执行进度,备份审计及事务回退(台账 020)
一、双来源历史重复污染了三票的批次、成本与父指令进度。
完整备份的 134 笔成交重建为 700、1900、1400 股;只按数量对账无法恢复盈亏。

二、真实买入唯一对应原批次,卖出按既有批次优先级重算。
33 个虚假或 RECON 批次归零留痕,61 个真实批次恢复;实际超目标成交保留。
误判已完成指令的剩余执行暂停,不自动复活旧单;活跃网格恢复真实余量。

三、写回经过备份哈希、并发原行核对和单表 SQL 事务,逐行审计并支持条件回退。
21 个新用例与完整 44 批隔离禁网回归通过。未改线上参数、原始成交、游标或历史净值;
手续费与历史峰值缺证据的部分明确保留边界。生产判收另记。
2026-10-15 12:34:06 +08:00
baobao 43cdc25881 交接副本同步 2026-10-15 12:09:50 +08:00
baobao e9afc7a3a3 成交回放:按委托归属隔离逐笔与汇总来源,避免重复入账(台账 019)
一、修复汇总回放的缺口
155 模拟仓八个委托同时由 ws 逐笔与 trading_order 汇总入账,形成三项持仓差异。出口身份相同的汇总镜像只推进游标,账本由原逐笔通道负责。

二、失败守成与兼容
查询失败、代码方向冲突、券商号冲突及多记录命中保留待重试。部分成交、逐笔迟到和模式切换不再重复记账;外部人工成交保持原回放。不改历史账本、交易参数和策略。

三、验证与部署边界
新增十二例先复现再通过,配置隔离及禁止联网的四十三批回归全部通过。155 部署及自然成交判收单独记录,不以离线测试冒充历史差异已修复。
2026-10-15 11:58:16 +08:00
baobao 6fa028527b 交接副本同步 2026-10-15 11:35:16 +08:00
baobao 3339d04ce4 每日计划:登记桥部署后模拟仓消费核验 2026-10-15 11:35:16 +08:00
baobao 7949b453a7 交接副本同步 2026-10-15 10:49:22 +08:00
baobao 78fb64ac36 每日计划:记录模拟仓部署与消费留痕实测(台账 018) 2026-10-15 10:49:22 +08:00
baobao 6a5ae12c74 每日计划:旧时间缺失时区时显示未知来源 2026-10-15 10:31:48 +08:00
baobao eee509e91b 方案副本同步 2026-10-15 10:27:12 +08:00
baobao 65d2940957 每日计划:记录消费顺序并核验提议依据(台账 018)
一、让候选顺序传到建仓。记录计划版本、有效参数、过滤与信号优先原因,保留实际消费历史。

二、采纳前检查依据。材料或组合依据变化时重走现有研判与数量流程,旧确认返回更新内容;条件更新防止重复采纳。新增控制默认关闭,保留所有现有参数。

三、验证与上线。隔离离线全量测试及三道页面守卫通过,新批次 15 例;先模拟部署,生产观察另记。
2026-10-15 10:27:12 +08:00
baobao afec4f7ecd 记录155部署验收与时间口径 2026-10-12 12:19:19 +08:00
70 changed files with 8920 additions and 307 deletions

View File

@ -101,7 +101,7 @@ Redis 有几路:决策系统的盘中信号流与风控卖出流、实时行
不能按「哪个系统」一刀切,要按「哪种时间」分。容器时钟与容器日志正文是北京时间,不要加八小时。数据库里的时间戳列(如各种 `created_at`、`updated_at`)是 UTC,读的时候要加八小时。日期列(如 `trade_date`、`audit_date`)是北京日期,不换算。写记录时一律用北京时间,引用数据库时间列先加八小时并标注已换算。完整依据见 `DEVLOG.md` 开头。 不能按「哪个系统」一刀切,要按「哪种时间」分。容器时钟与容器日志正文是北京时间,不要加八小时。数据库里的时间戳列(如各种 `created_at`、`updated_at`)是 UTC,读的时候要加八小时。日期列(如 `trade_date`、`audit_date`)是北京日期,不换算。写记录时一律用北京时间,引用数据库时间列先加八小时并标注已换算。完整依据见 `DEVLOG.md` 开头。
**待核实的例外。** 上段是历史约定。PMS 自有表的部分列实际是 `DATETIME`,`pms_repo.py` 与 `qmt_repo.py` 用容器内 `datetime.now()` 写值。10-08 的两个探针因此提出先用心跳和快照校准时区。用户已确认探针尚未执行,这个差异尚无新的真机结论。读这些列前要核对写入路径和实际时区,并明确标注原值与换算依据,不把两种口径混在同一份读数里。 **待核实的例外。** 上段是历史约定。PMS 自有表的部分列实际是 `DATETIME`,`pms_repo.py` 与 `qmt_repo.py` 用容器内 `datetime.now()` 写值。10-08 的两个探针因此提出先用心跳和快照校准时区。用户已确认探针尚未执行,2026-10-12 部署核对已确认 155 宿主机为 UTC,容器为北京时间,`pms_ws_state.heartbeat_at` 的 DATETIME 原值与容器北京时间同步,该字段不加八小时。其他列仍要核对写入路径和实际时区,并明确标注原值与换算依据,不把两种口径混在同一份读数里。
## 前端的两个坑 ## 前端的两个坑
@ -136,7 +136,7 @@ Redis 有几路:决策系统的盘中信号流与风控卖出流、实时行
- `README.md`:总览,最全。上面各节多是从它摘的。 - `README.md`:总览,最全。上面各节多是从它摘的。
- `DEVLOG.md`:开发节点流水账,每条含「做了什么、动了哪些文件、部署方式、真机判收、还欠什么」五样。查某个改动的来龙去脉看这里。 - `DEVLOG.md`:开发节点流水账,每条含「做了什么、动了哪些文件、部署方式、真机判收、还欠什么」五样。查某个改动的来龙去脉看这里。
- `docs/开发接续_2026-10-12.md`:Claude 到 Codex 的仓库迁移记录、未合入分支和当前待办入口。 - `docs/开发接续_2026-10-12.md`:Claude 到 Codex 的仓库迁移记录、修复整合、155 部署判收和当前待办入口。
- `POSITION_MGMT_DESIGN.md`:总体设计定稿。 - `POSITION_MGMT_DESIGN.md`:总体设计定稿。
- `QMT_WS_PROTOCOL.md`:PMS 与 QMT 的 WebSocket 协议,下发通道的唯一实现依据。 - `QMT_WS_PROTOCOL.md`:PMS 与 QMT 的 WebSocket 协议,下发通道的唯一实现依据。
- `BIONIC_PMS_INTERFACE.md`:PMS 与决策系统的接口契约(研判闸与盘中择时两个接口)。 - `BIONIC_PMS_INTERFACE.md`:PMS 与决策系统的接口契约(研判闸与盘中择时两个接口)。

416
DEVLOG.md
View File

@ -1777,8 +1777,424 @@ docs/交接_2026-09-20.md(新)、docs/dev_preview/mock_preview.py 与 sample
--- ---
## 2026-10-12(续二)· 155 模拟仓部署完成,983 例回归通过
**做了什么**
用户明确批准 155 条件部署与推送目的地。修复提交 `55e2ed6` 已推送 `main` 和 `codex/test-isolation-integrate`。服务器先做运行参数、通道和在途委托只读核对,再用无网络、无生产配置的临时容器验证完整 41 批、983 例。前置条件通过后完成部署。
**动了哪些文件**
运行代码同 `55e2ed6`。本节点仅补 `DEVLOG.md`、`docs/开发接续_2026-10-12.md` 和 `AGENTS.md` 的部署记录。用户原有台账、讨论稿与两项探针保持不变,未纳入本次提交。
**部署方式**
155 的 `/home/factor/project/tradingSystem` 快进主分支,执行 `make build`、`make up`。没有建表,没有改运行参数。保留服务器本地脚本可执行位及所有未跟踪文件。回退引用 `codex/predeploy-20261012` 指向 `fbe0014`,旧镜像保留为 `pms:rollback-20261012-fbe0014`。155 挂载源码,若需回退必须同时还原源码和镜像,再重建服务。188 未操作。
**真机判收**
真机见过。四服务于北京时间 12:16:07 重建,均运行、重启计数零,镜像统一为 `63e786de910a`。无挂载容器读到的镜像指纹与提交快照、服务器工作树均为 `18d7286b926a`。网页健康 `ok`、数据库连通、QMT `ONLINE`、回报水位推进、无在途子委托和待入账回报。启动后日志无 ERROR、CRITICAL 或 Traceback,调度正常。部署后 `make test` 再次输出 `ALL SUITES PASS`,41 批、983 例通过。开发机日志为 `/tmp/pms-deploy-55e2ed6.log` 和 `/tmp/pms-postdeploy-tests.log`。
只读参数确认 `ws`、QMT 开启、自主与自决均为 `full`,全局暂停开关均关,排序开关仍关、档位仍为“强传导”。宿主机用 UTC,容器用北京时间;通道心跳 DATETIME 与容器北京时间同步,该字段不能机械加八小时。
**还欠着什么**
部署时没有 GATED 方案,命令结算与一字板修复的真实行情触发仍未判收。历史假读数未清理,两个探针未运行,因子库复权基准与盘中才封板边界仍按原安排接续。188 真实仓不在本次范围。
---
<!-- <!--
下一条节点从这里往下写,格式照抄上面: 下一条节点从这里往下写,格式照抄上面:
## YYYY-MM-DD · 一句话标题 ## YYYY-MM-DD · 一句话标题
**做了什么** / **动了哪些文件** / **部署方式** / **真机判收** / **还欠着什么** **做了什么** / **动了哪些文件** / **部署方式** / **真机判收** / **还欠着什么**
--> -->
## 2026-10-15 · 每日计划版本贯通、消费顺序和提议重新核验
**做了什么。** 按用户批准的跨仓方案落本地四批实现;旧阈值与运行开关未改。候选消费记录分三类,执行保留消费顺序与信号调整原因;提议核验与人工再次确认通过条件更新保护并发;报告链接和两端研究展示贯通。
**动了哪些文件。** plan_feed、action_engine、plan_revision、plan_recheck、proposal_service、command_service、planner、executor、pms_repo、company_report、logic_state_service、Web 入口及页面;新控制 PMS_PLAN_VERSION_RECHECK 默认 False;新增第 38 批 15 例并登记总入口。
**本地验证。** 配置隔离且禁止联网的全套入口 ALL SUITES PASS,包含新增第 38 批 15 例;三个页面守卫通过。浏览器只连接 127.0.0.1 假数据页面,看到研究信息与过期内容重新确认提示,没有连接交易通道。
**部署方式。** 先兼容读与留痕,再桥发布,最后模拟实例启用修订与核验。实际机器、表前缀和容器需部署前确认,容器操作需用户同意。
**真机判收。** 未判收;本轮未连接生产机器,未改运行参数,未生成任何真实指令。
**还欠着什么。** 获准后的部署、真实参数及实例身份核对、十二分钟传播时延和连续五个交易日模拟观察。详见四仓同步规格书及交接。
## 2026-10-15 · 每日计划兼容与消费留痕在 155 模拟仓生效
**做了什么。** 用户明确授权部署和重启后,功能提交 65d2940 与旧时间显示补正 6a5ae12 已在 155 生效。42 批新镜像断网回归 ALL SUITES PASS。既有参数保持,新建仓仍只提议,新版本核验保持关闭。
**部署方式。** 临时目录先构建候选镜像并禁网验证,再优雅停止四个 PMS 服务,git pull 快进并重建。没有执行建表。北京时间 10:42:37 完成;镜像与运行目录 Python 指纹均为 eb4b4cbbff7f。原 deploy.sh 可执行位、未跟踪文件及开发机台账 017 保留。
**真机判收。** 四服务运行,健康、数据库与日历正常,QMT ONLINE。10:42:50 received 记录 54、10:43:04 consumed 记录 55 已由正常调度落库;保存 13 只实际顺序、过滤条件、参数和指纹。旧桥没有 decision,记录保留空值。待入账与在途出口委托为零。
**已有异常与剩余。** 部署前已有 8—9 月历史出口缺父指令;部署后轻量对账报告 3 项差异,未改账。桥等待保持旧排序兼容配置的确认;完整晨版、自动修订、提议重核和五日观察尚未启用或完成。188 未部署。详细参数、镜像与日志在同日四仓交接末节。
## 2026-10-15 · 桥按原排序完成部署,模拟仓消费顺序保持
**做了什么。** 用户批准补齐桥旧排序配置。桥实际为 transmission、CARD_SORT_BY_QUALITY=0,11:28:51 完成最终重建;PMS 无需再次重建,原四服务持续运行。
**动了哪些文件。** PMS 本节点仅更新同日方案与交接副本、追加本日志。业务代码仍为已部署的 6a5ae12,未改 PMS 参数或用户原有台账 017。
**真机判收。** 11:30 PMS 用真实参数只读拉取桥计划成功;主榜 300、观察 100。正常调度于 11:23:02 落 received 56、consumed 57。与 consumed 55 比较,13 只完整顺序、参数和排序模式均相同;过滤记录变化作为新消费记录保存,旧数据不改。四容器运行且重启计数零,健康 200,数据库与日历正常。
**部署方式。** 本节点不重启 PMS。桥从 Git 快进,已提交源码构建候选镜像,33 组隔离断网契约通过后切换。用户批准的配置只用于保持桥原行为。
**还欠着什么。** 首个完整晨版在下个交易日核验后,建立 XXL 五分钟任务并开启模拟仓 PMS_PLAN_VERSION_RECHECK;当前仍为 False。五日观察与传播时延未判收,188 未部署。此前历史出口缺父指令和轻量对账三项差异仍待查,本轮未改账。
## 2026-10-15 · 三项对账差异定位与防双记修复
用户要求先排查 155 模拟 PMS 的三项对账差异,取消额外五日模拟观察,下一交易日晨版通过后启用修订和重核。
八个委托的出口号、券商号、ws 逐笔合计与 trading_order 完整对应,确认回放缺少归属过滤。
新增 qmt_repo.orders_for_fill 与 ledger_service 的身份分流,新增第 39 批 12 例并补内存替身与 SUITES。
先跑回归复现 11 失败、1 新接口未实现错误;修复后 12 例和完整 43 批隔离、禁止联网测试通过。
历史证据:155 的 ~/pms_logs/reconciliation-evidence-20261015-before-fix-v2.json,340982 字节,SHA256 8e0badf4d771fbf8a3227250c6cc2c2bf3c8234dda2fc33a31f0ab00920f5501。初次导出因方法名拼错失败,零字节初稿保留,v2 才是有效证据。
不修改历史批次、成本、已实现盈亏或指令状态。部署与自然回放判收待追加;历史修复的前提见 docs/PMS三项对账差异排查_2026-10-15.md。
### 10-15 12:05 防双记部署判收
功能提交 e9afc7a 已部署 155。候选镜像断网全量 43 批通过,八笔实际委托的只读归属查验全部通过。
12:02:54 四服务重建,镜像 c17af17aeb09d151bbe932395b879add1ed336b16739703f9acc594bee30b3f1,Python 指纹 cc988cd762bf。
12:04:59 健康正常、QMT ONLINE、待入账及在途出口委托均 0,业务参数保持。午休无自然新成交,逐笔实际回放效果待事件判收。
三项历史数量差异仍在,未强制对账或回写成本与指令。完整证据与回退信息见同日每日计划交接末节。
## 2026-10-15 · 三票历史逐笔修复工具与预演
用户已授权备份后恢复数量、成本、盈亏和执行进度。实现 app/core/ledger_repair.py、scripts/repair_ledger_history.py 和 db.session 的受控事务入口;原行比较、全部逐笔与运行参数守卫、行级审计、条件回退均在同一事务边界内。ledger_service 的成本重算改用剩余成本减已实现金额,保持相同摊薄口径并消除三位均价反乘误差。
本地配置隔离且禁网:test_batch40 的 21 例通过,全量 44 批通过。生产备份和完整预判见 docs/PMS三项对账差异排查_2026-10-15.md;真实读数仅作离线预演,尚未写账,部署和判收后续追加。原未提交台账 017、讨论稿和探针未纳入本提交。
## 2026-10-15 12:40 · 历史逐笔修复部署与真机判收
0871885 已推送并在 155 拉取,四个容器用同一已断网验证镜像重建。12:37:27 页面/通道启动,12:39:33 调度恢复。镜像 sha256:22422dc46784ff87c8ccfc6f9a2ae05ba8ee111eb18e3f1a369f9d913279ff0b,指纹 01251315d8d1;回退标签 pms:rollback-before-history-repair-20261015。
先备份后写入,批号 HIST_c036a684cab040387321396e。134 笔成交恢复 61 个真实批次并将 33 个重复或 RECON 批次归零留痕;24 条父指令进度、活跃网格余量同步恢复。122 行修改与 123 条审计在同一事务提交,独立读回原值比较通过;重复执行返回 already_applied 且审计数量不变。三票恢复为 700/1900/1400 股,成本 44.109/55.060/23.704,毛盈亏 -6762.70/-1684.25/16.86。对账 diffs=[]、severity=OK,健康及通道正常。完整证据与不可还原边界见三项差异排查文档及四仓交接。
真实超目标成交 1300 股保留事实,七条误判完成指令暂停剩余执行;未改原始成交、游标和历史报表。费用、历史峰值、旧轮次原批次及全组合历史绩效未伪造恢复。自然新成交与次日首晨版尚待真实事件判收。automation-2 已更新结果并保留 10-16 07:25,不增加五日观察。
## 2026-10-15 · 指令执行均价的有效期补齐
历史修复后发现原成交路径只累加 exec_qty,未维护 exec_avg_price。新增成交时清空已过期均价,固定修复时点的准确金额继续保存在 progress 与审计。没有成交金额输入时保持未知,避免静默沿用旧值。变更 pms_repo.add_instruction_exec;内存数据库验证执行量增加、均价失效、固定证据保持。batch40 共 22 例,全量 44 批本地隔离禁网通过;候选镜像和部署验收另记。
## 10-15 12:50 最终运行版本与均价有效期
最终功能提交为 `a56dac5`,包含 0871885 的历史修复及指令均价有效期补齐。原增量入账接口只收到数量,不能重算全量均价;后续新成交时同步清空旧 exec_avg_price,固定修复时点的准确金额继续保存在 progress.historical_repair 与操作审计中,避免显示过期均价。未再次改写历史账本,也未恢复暂停指令。
batch40 增至 22 例,内存数据库验证数量增加、均价失效、固定证据保持;本地与候选镜像 `--network none` 全部 44 批再次通过。12:50:11 四容器重建并恢复,镜像 `sha256:f3d4e698bc31be521f59b39588444495e143f9a52a3d5233b42a699f4030093d`,标签 `pms:mean-validity-a56dac5`,Python 指纹 `3de5fc3a261e`。前一版保留为 `pms:rollback-before-mean-validity-20261015`。
12:50:47 再次独立逐字段核验通过,三票数量、成本与盈亏保持上一节读数,审计仍为 122+1,对账 diffs=[]、severity=OK。健康 200、db_ok=True、calendar_degraded=False,QMT ONLINE、last_seq=acked_seq=1226717、last_error 为空。PMS_PLAN_VERSION_RECHECK 仍 False。全部备份及不可还原边界继续有效,明日 07:25 接续安排保持。
最终日志位于 155 `~/pms_logs/mean-validity-build-20261015.log`、`mean-validity-tests-20261015.log`、`mean-validity-deploy-20261015.log`、`mean-validity-ledger-verify-20261015.json`。四仓文档继续同步;只有文档更新无需再次重启容器。
## 2026-10-16 首晨版通过后启用提议重核
北京时间 07:35:36,仅 155 模拟仓经 ParamStore 将 PMS_PLAN_VERSION_RECHECK 从 False 改为 True。
ws、propose_only、排序、档位、规模和仓位参数逐项保持。参数前后证据为 155 ~/pms_logs/plan-recheck-enable-20261016.json。
PMS 功能仍 a56dac5,本轮未重建 PMS 容器。07:27 三票历史修复数量、成本及毛盈亏仍一致,对账差异为零,streak=0,QMT 在线。
桥首晨版 556 主榜与 598 观察,查询及冻结指纹一致。凌晨旧日期重跑覆盖问题已由桥 e44f770 修复,晚生成样本排除,原件缺失明确记录。
五分钟任务已于 07:35 正常调度且回调成功。未采纳提议或制造成交。真实消费、提议重核案例及自然新成交仍待判收。
PMS 页面需要重新登录;基座页面版本与研究字段已实机核对。automation-2 下一次为今日 08:55,核对正常消费及区制修订。
详见四仓同步《交接_每日选股计划完善_2026-10-15.md》最后一节。
## 2026-10-16 · 计划版本页面比对兼容修复
浏览器验收发现,新版收到记录已使用 decision 与查询范围指纹,变化与预览仍以旧名册指纹比较。
因此落库成功也被误报为未落快照。写入和两个比对出口统一使用收到计划的身份。
旧数据继续按旧名册口径,不改变消费记录、排序或提议行为。页面删去实时重装配及永远按分数排序的过期说明。
新增离线往返回归:相同版本与范围通过,新版本或范围变更不误认;落新记录后恢复一致。
部署与实机判收另记到四仓同步交接。用户原有未提交台账内容保留。
### 10-16 09:30 部署与页面判收
3057250 本地和候选镜像 44 批禁网回归、三个页面守卫通过。09:20:19 四容器统一重建。
镜像 061c7c1218c5e0e62838ace6804aad785517337a511aae12e2a9f792d38aaef5,Python 指纹 72cbce06747b。
15 项有效参数及三票历史修复数量、成本、毛盈亏前后相同,健康正常、QMT ONLINE、diffs=[]。
09:25:03 正常扫描 consumed 64 消费区制版 6abfc0e8,24 只顺序与指纹一致,过滤原因完整。
登录后页面误报消失,旧提议与持仓明示追溯缺失;没有采纳或人为制造交易。
真实盘中评析传播、提议重核与新成交防双记继续等自然事件。备份、镜像及回退见四仓交接最新节。
## 2026-10-16 · 研究展示按交易员使用顺序收口
用户指出右栏展开的版本与研究字段破坏页面风格,长版本号横向溢出并把裁决按钮挤出视线。
删除侧栏新增的字段清单,复用原“基本面”入口。研究详情按判断、风险、预期、后续验证及变化分段。
报告时间与实际材料期保持区分。缺失项不连续铺“未知”;无摘要用一句明确说明。
计划标识、指纹和消费顺序放在详情底部“数据来源”,默认折叠且长字符串可换行。
候选与持仓、运维提议的同类字段清单一起复用详情,避免表格行无限增高。
只改 app/web/static/index.html,未改评析原文、建议数量、采纳核验或交易接口。
本地三页面守卫通过,页面脚本语法、空记录、零值、变化与原始值保持检查通过。
155 已核查 /app 源码绑定挂载,本次纯静态页可经 git pull 生效,不重建交易进程。
上线前先备份旧页面并在禁网临时容器运行守卫;浏览器结果另追加。
09:49 判收补记:c2d0dc9 已在 155 拉取,三道服务器禁网页面守卫通过。
四容器启动时间与镜像均未变化,静态页经 /app 挂载生效。
真实浏览器侧栏 295 像素、来源区 694 像素均无横向溢出,默认折叠与基本面详情展开通过。
裁决按钮回到提议摘要之后,重载后无新脚本错误。未触发裁决操作。
备份指纹、生效方式、回退与截图见四仓同步交接最新一节。
## 2026-10-16 交易员界面整体精简(本地完成,部署待判收)
用户要求围绕建议、依据和风险整理整个交易员界面,重点为右侧提议和候选。仅修改静态页面。提议突出数量、预计金额和建议仓位;仓位不一致仍显著提示。重算过程移入数量说明,通用操作说明只保留一次,有效期转为北京时间短格式。清仓使用中性的预计金额,缺价显示缺失。候选保留原列表与排序,直接显示等待条件;占用提示去除内部代码数组,未知失败提示原样保留。交易方案显示当前可见数量,暂停买入的原因可展开。持仓、信号、顶栏和计划详情同步简化,技术来源折叠保留。
本地验证:三项页面守卫全部通过;脚本语法、金额缺失、北京时间跨日、仓位差异、原值不变的临时断言通过。采纳、驳回、策略动作、计划读取刷新函数及候选筛选表达式与改前逐字一致。未修改 Python、运行参数或交易规则。
部署预判:155 当前为 f79ddff,pms-web 通过仓库绑定挂载提供静态页。先备份页面,以匹配的运行镜像断网运行三项页面守卫,再仅 git pull。预期四容器镜像和启动时间不变。浏览器应显示精简提议、可读的候选等待状态,数量说明与基本面入口正常,关键风险仍可见,右栏无横向溢出。不得采纳提议或制造交易用于验收。188 不操作。
浏览器补验发现既有右栏折叠只改变箭头,缺少隐藏内容的样式。补齐 `.sect.closed > .sectb`,使提议、方案和候选可按原设计折叠。仅补展示样式。
### 10:20 部署与页面判收
16d8fd7、564f553 已在 155 git pull 生效。两个候选包均在匹配镜像禁网通过三项守卫。写前备份留在 ~/pms_logs/,最终静态页 SHA256 为 8cd75f4cafd3e23f90c036ac2accd5131568ad2c26bc7bc844f5d45cd8808b31。四容器镜像、启动时间与写前一致,未重启;188 不动。
浏览器实测 3 提议、13 候选、2 当前方案。瑞芯微数量差异及最低一手说明保留;候选等待条件、计划入口与折叠正常。右栏 clientWidth=scrollWidth=317,候选行均为 295,错误数为零。未测试交易提交。详情见四仓同步交接 10:20 节;自然事件技术验收仍待后续正常事件。
## 2026-10-16 · 提议重核稳定依据修复
自然用户两次确认科士达提议均被要求重新确认。代码误将实时报价计算的在途金额纳入仓位依据指纹。新增稳定承诺依据,覆盖来源、标识、股票、数量及执行进度;指纹按其比较。额度仍使用原实时金额,原规则闸与执行终检保持。旧输入缺稳定依据时保守比较,旧提议可重核一次。
先新增三个回归,原代码出现两失败一错误。修复只涉及 plan_revision.py 与 proposal_service.py;既有批次 38 增加回归并更新入口说明。预期仅报价变化不会再重跑研判或重复要求确认,实际数量、承诺、持仓和资金变化仍重核。关联桥台账 069。部署前须本地和候选镜像禁网通过,再仅在 155 重建四容器。具体部署与真机判收待追加。
### 10:50 部署判收补记
15072f7 的 18 个专项用例、44 批本地和候选镜像禁网回归全部通过。10:44:28 在 155 重建四容器,镜像 7003b81c79000cb61633d94a6529253a412de9c2cbc5522e296aea71a0e2f337,代码指纹 cf0a57a03a76。15 项参数与三票修复账本不变,七条暂停指令仍 CANCELLED,审计 122+1。健康正常、QMT ONLINE、resync=0、对账差异为空。188 未操作。
14 笔昨日修复后自然成交已逐笔判收:数量、父指令进度与批次毛盈亏未双记。既有逐笔舍入一分钱差异单列。修复后的自然确认、开盘后新评析传播时延仍待事件,不能以本地通过替代。详细证据、备份与绑定挂载下的回退步骤见四仓同步交接 10:50 节。
## 2026-10-16 · 网格卖出按实际余额封顶
11:15 自然事件核验发现威胜信息第二次网格卖单越界。原档位 1,000 股,首卖 700 后正确恢复 300;第二次仍按配置卖 700,连同 400 股底仓卖出。七笔成交据实入账,快照追平后对账为空。原策略 11:16:01 已被清场取消。实际成交保留,不回填或反向交易。
修复 strategy_runner._eval_grid,将数量同时限在配置档量、档位余额、实际 ADD 与可卖量内。保持穿越信号、价格、档距、资金上限和最小申报规则。四组新增反例在原实现均失败,批次 17 增至 45 例;完整禁网与候选镜像回归通过后仅部署 155。关联桥台账 070。部署与成本核验结果待追加。
### 11:35 部署判收补记
bafecb7 经 45 策略用例、44 批本地及候选镜像禁网回归通过,11:31:02 在 155 四容器统一生效。镜像 a33ecb004e285ed7991b1492477e222703d1ec89892e36ee7cb51ee2d555b3c8,Python 指纹 12f782622c4d。11:31:29 参数与成交后账本逐项保持,已取消网格和七条历史暂停指令未恢复,审计122+1。健康正常、QMT ONLINE、resync=0、对账无差异。188 未操作。
七笔 1400 股实际成交据实核销,共32933.49元;新增毛盈亏-268.87元,当前账期-252.01元,400股底仓实际误卖已单列。原始故障日志在重建前保存。未删除真实成交、回填持仓或反向交易。没有自然新确认或新评析,原心跳13:15接续。详细证据、回退与手工验证命令见四仓交接11:35节。
## 2026-10-16 13:25 · 自然评析传播与实际消费核验
本轮无业务代码、参数、重启或交易写操作。四份正常盘中评析在 114.36—252.22 秒内被正常自主扫描实际消费,consumed 73、75 各24只,顺序与指纹通过。六份午休评析直到13:00消费,耗时约55分钟,十二分钟目标未通过,不能用收到记录替代。15项参数、三票账务、七条历史暂停与122+1审计保持,对账无差异,QMT与健康正常。科士达仍WAIT_USER、600股,修复后的自然确认尚无事件。原心跳14:15继续。明细见四仓交接13:25节与155、178只读证据;未改交易时段守卫,未宣告全时段达标。
## 2026-10-16 13:35 · 用户确认时延口径与自然提议重核
用户明确十二分钟按连续交易时段核验,午休材料开盘后及时消费即可。八份盘中样本耗时114.360—393.202秒;六份午休材料于13:00:03消费,两项本轮样本通过。13:27:30用户自然确认科士达,新增rechecked79、动作账本6783;研究依据与扫描参数相同,仓位上下文变化,重跑后仍WAIT_USER、600股并要求再次确认,没有生成指令。无变化直接通过仍待自然操作。13:28对账无差异,参数账务与审计保持。本轮仅文档与验收口径更新,无代码、参数、重启或交易写操作。原心跳14:15接续,见四仓交接13:35节及桥台账071。
## 2026-10-16 13:55 · 采纳失败原因与等待反馈修复
用户报告提议采纳长时间转圈,失败提示一闪而过。13:39科士达真实采纳成功;13:40瑞芯微实际研判拒绝,原接口丢弃具体原因。研判审计与只读缓存均确认拒绝原因,不能将它改成通过。
修改 plan_recheck、pms_repo、web/main 与静态页面。失败原因保存到现有提议JSON,条件更新防并发覆盖,原数量、批准依据与状态保留。错误原因进入现有操作日志,不新增会影响自主决策的拒绝账本。已有失败须重新核验,不能因组合回到旧值复用旧批准。确认框持续显示原因与更新内容,防重复点击;请求等待随有效研判超时配置,未知结果不自动重发。交易规则与参数保持。
本地24个专项和44批隔离禁网测试全部通过,含三页面守卫。Node前端替身验证失败保留、更新确认、结果不明、重复点击及异常释放。此时尚未部署;候选镜像与线上判收另追加。回退须反向提交加旧镜像重建四容器。155当前绑定挂载/app,不能仅回退镜像。
### 14:05部署补记
4f6b192候选镜像44批禁网测试通过。13:59四容器统一重建为6ee444e1c734dc454a8564c9e6ae8f05c5e0c4b25ba9282049f61234a1db10af,Python指纹63b3e303084e。前后15项参数、账本、提议、指令及成交记录一致,对账severity=OK、QMT在线、健康正常。浏览器只读加载正常无错误。自动审批拒绝代点采纳,确认框交互以离线替身验证,真实失败提示仍待自然用户操作。科士达13:39自然确认成功已判收。详细原因、证据与回退见docs/提议采纳失败排查_2026-10-16.md。
## 2026-10-16 14:40 提议明确否决后退出待确认
用户看到瑞芯微14:20明确REJECT后仍可重复点采纳,要求失效提议撤下。采纳重核现在将研判拒绝、策略放弃和可核验的资格失效置为EXPIRED,原JSON标记withdrawn。数量及原依据保留。不可用或暂时性规则不足继续等待。拒绝原因优先取实际rejected,在途扫描背景不混入。
状态和拒绝留痕同一事务,原状态加原JSON防并发。研判拒绝沿用既有解锁重问,策略放弃沿用当日去重。已有保存的明确失败由正常扫描收尾,不新建任务、不调用模型。原文记录时刻保留,旧缺失基线不补造。页面撤下后只留原因与关闭,旧页面重复请求也返回已撤下。
四个新增反例在旧实现失败,修复后30专项及44批本地隔离禁网回归通过,Node交互替身通过。部署与真机状态待本节后续补记。只部署155模拟仓,188不动。未改交易时段、准入参数、数量算法或研判结论。
- 14:45部署补记:60de23e在14:39:51于155统一重建,镜像befb6246、指纹3777e125a88a。候选镜像44批禁网回归通过。14:40正常扫描撤下已保存明确拒绝,账本6858唯一、零目标指令,14:45复查无重复。浏览器待确认0条、无错误;未代点采纳。15参数及账务保持,对账正常。24条历史指令仅一条正常WAIT时刻前进一分钟,数量和修复审计不变。188未操作。完整备份与回退见提议采纳失败排查14:45节及四仓交接。
## 2026-10-19 买卖方向冲突修复(台账076)
**做了什么。** 科士达旧建仓与风控清仓同时保持活跃。统一在执行前停止清仓票的旧买入,普通减仓期间暂停买入。停止事实留在追加账本,旧进度回写不能复活指令。出口先撤后发且发送前核对。原始audit_reason补回,页面按实际委托状态显示。
**动了哪些文件。** execution_conflicts服务、executor、dispatcher、proposal_service、strategy_service、signal_rules、两仓储、ws runner、web与页面。增加batch41并登记测试与替身。
**部署方式。** 本地22项专项与45批禁网回归通过。155需候选镜像断网验证后统一重建web、worker、beat、ws。当前此节尚未部署;后续追加真实读数。
**真机判收。** 修复前14:10仅科士达存在买卖重叠。已保存指令、成交、账务与参数原值,详见规格。未改成交,不恢复七条历史暂停指令,不操作188。
**还欠什么。** 候选镜像测试、部署、生效与页面核验,按真实证据追加。
### 2026-10-19 14:22 首次部署与补查
fad1bb1于14:19:39在155四容器生效。镜像2e5213b9d37f9c7337f4857ab0401e7426ea196f80d1e6b78325aecc1a993d6b。
45批候选镜像禁网测试通过,22专项通过。14:20:05正常调度终止科士达剩余买入。
买入600/400保持,清仓400/200保持。两条新审计6912、6913均为system。
部署前后15项参数一致,全部持仓账务字段及批次账一致,零新增委托。
14:21再次调度正常,对账0差异,QMT在线。93行指令展示查询0.344秒。
本地Chrome使用接口替身渲染,显示等待可卖与等待下一批,无页面错误。
生产读取显示科士达清仓等待可卖、旧买入已撤销。未冒充登录后的生产浏览器验收。
补查人工清仓:T+1不可卖时原路径会采纳但不留指令。
改为保留不超过确认量与当前总持仓的清仓任务;持仓已归零仍停止旧买入。
新增两项专项,共24例。本项待候选镜像和第二次部署;没有代替用户采纳。
### 2026-10-19 14:30 最终补修生效
28053f3于14:27:22统一重建四容器。镜像06493afa19ec4cd61d07b7834472a11c550d0ec0a341e251dcdb64626a4139c0。
24专项、45批本地与镜像禁网回归通过。14:28全量原值比对通过,21持仓、283批次与93指令执行进度保持。
只有科士达旧买入按授权终止,停止审计6912、6913不重复,清仓等待可卖。
QMT在线,无补同步要求,健康正常,正常回放0差异。93行指令读数耗时0.344秒。
本地Chrome替身页面零错误,线上服务读回进展正确;生产登录浏览器未直接验收。
人工T+1、失败撤单与并发边界仅离线验证,不制造交易,188未操作。
四仓规格与交接逐字同步,完整备份和回退见14:30交接。
## 2026-10-20 提议先准备后采纳:本地实施
用户批准将完整重评移到后台。待确认建议先完成数量、规则和消费记录。
采纳只读当前完整计划并检查已展示数量,不调用研判、不新增消费快照。
原自主扫描维护旧建议,研究变化重评,组合与参数变化复用原研判。
明确否决撤下,来源或留痕失败保持准备中。并发更新采用条件写入。
准备结果与动作审计同一事务,人工确认不能越过旧内容标识。
改动涉及plan_revision、plan_feed、plan_recheck、proposal_service、仓储和网页。
新增batch42共24例,更新batch38共30例。46批本地隔离禁网回归通过。
三页面守卫通过。本地Chrome替身测试页面错误零,确认提交一次。
窄屏展开右栏后遮挡确认框的旧问题同步修复,样式保持。
当前155尚未部署本改动。11:30备份为prepared-before-20261020.json。
现场没有WAIT_USER提议,不将替身验证当作自然用户采纳判收。
正式规格见docs/开发规格_提议先准备后采纳_2026-10-20.md。
## 2026-10-20 11:40 提议准备流程部署判收
功能1df17e6已于11:35:28在155四容器统一生效,188未操作。
镜像8bd79ea50a534f6feed28c192b49b80a29fd35188d852a88504c8435a1dcc5e9。
Python指纹2aebacdf92f2。
54专项、46批本地与候选镜像禁网回归通过,三页面守卫通过。
只读生产IAB右侧界面验收通过,页面错误零。
当前无待确认提议,自然采纳未判收。
15项参数、21条持仓账务、283条批次账与备份相同。
94条指令进度、16条委托和52条提议与写前相同。
QMT在线、对账无差异。午休任务按原时段跳过,不制造交易。
原消费计划与凭据配对保留,最新只读检查单列。
恢复与异常细节见四仓交接11:40节。
回退标签pms:rollback-before-prepared-20261020。
回退须源码反向提交后拉取并重建。
## 2026-10-21 采纳重请求与落库中断修复(开发验证)
09:45盛弘股份采纳超时来自3秒整榜读取。桥现场5.481秒、3093481字节。
新增逐票发布结果接口,采纳不下载整榜。网络暂不可用保留原准备内容,不触发重新研判。
旧source准备状态恢复时核验原500股,不改确认标识。已知修订仍关闭采纳,资格失效仍撤下。
普通OPEN确认、审计和指令原子提交。重复请求读回原指令,不重复下发。
指令标识追加提议身份摘要,避免同日不同提议撞用固定序号。OPEN没有一次性计数器,其他动作路径保持。
页面只在确认内容确实变化时清空原理由,不把连接失败叫建议更新。
新增批次43,实际API、来源解析、筛选、快速检查和SQL事务共13例;桥逐票7例。
47批PMS禁网回归与三页面守卫通过。桥完整版本契约回归通过。部署及真机读数随后追加。
补充:现场原500股因组合现金变化被后台反复生成新说明,连带更换确认标识。
原数量仍过全部闸门时保留准备结果;额度不足才重算。新增第14例,原回归补齐快速检查依赖。
## 2026-10-21 10:25 采纳修复部署判收
888a208于10:17:23在155四服务统一生效。镜像fe0b9d8cc12ef0e67adf91e1e577b08665d79f00ae2c3ef777b36222e33e52eb,Python01bee5e8f40a。
14专项、47批本地与候选镜像禁网回归通过。三页面守卫及生产确认框只读验收通过。
16项参数与23条持仓、299条批次、97条指令进度在10:17至10:18比较不变。
桥逐票0.208—0.326秒;真实提议预检1.085—1.227秒。自然网格买入后仍保留原500股确认内容。
10:22:38对账无差异、QMT在线。实际用户确认未代验,没有制造交易。
详细备份、回退、历史边界见四仓交接10:25节。
## 2026-10-22 高股息独立候选与建仓准备(开发验证)
桥提供独立资格契约,PMS通过dividend_feed消费。人工请求先保存准备状态,正常交易时段完成计算与研判,原采纳事务负责最终确认。固定研究、消费凭据与来源跟随提议、审计和指令。原自动扫描候选及所有参数保持。
新增24项专项通过。全量48批配置隔离、禁止联网回归通过,含三页面守卫。桥新增9项通过。生产部署与自然采纳尚未判收。详见四仓《高股息候选接入PMS开发规格_2026-10-22.md》及同日交接。
## 2026-10-22 高股息人工链路部署判收
用户确认独立候选区,人工发起。功能03e569e于10:51:01统一重建155四服务,镜像0f298f6d5b997c603b7d57a50223267367e1f7b1112d630b8e6af187e7f711d2,Python指纹83c49a380165。页面ccf194b随后挂载生效,原始记录二级折叠。
48批候选镜像禁网回归、最终三页面守卫和真实登录浏览器核验通过。19参数、23持仓、322批次完全不变,108指令未增减,三条只更新正常等待或拒绝时刻。健康正常、QMT在线、对账diffs=[]。高股息读取0.433秒,不写消费记录;匿名接口401。当前175研究记录、零家可评估,原自主扫描不切换。无真实合格公司,人工准备、采纳与成交未作生产代验。备份、回退及未判收边界见四仓同日交接。
## 2026-10-26 · 钧达股份成本口径与父指令重复下发修复
在 155 模拟仓只读核对钧达股份 002865.SZ 的持仓、批次、父子指令、18 笔成交回报与容器日志。发现 10 月 23 日追踪止盈父指令目标卖出 600 股,却实际发出两笔各 600 股的子委托。首单于 09:34:58 终态成交,09:35 执行任务先于回放任务运行,把父指令尚未更新的累计成交误当剩余额度,导致重复下发。QMT 确实还持有 100 股。5.053 元能够由累计买入 42,663.04 元、累计卖出 42,157.74 元复算,是摊薄成本,不是买入均价。今天用户已下达清仓 100 股命令,13:40 仍等待价格条件。
修改 `executor.py` 增加跨日父指令总量检查,综合父指令入账量、出口累计成交和未终态未成交量限制每次下发,出口读取失败不发新单。页面明确“摊薄成本”与“综合盈亏”的含义。补齐 `test_wiring.py` 出口仓储内存桩,新增并登记第 45 批 16 例回归。修正第 44 批周一因样本生成与核验使用不同日历而失败的测试准备顺序。详细成本计算、交易时间线和当前选股、建仓、退出、策略参数记入 `docs/钧达股份成本与重复下发排查_2026-10-26.md`。
开发机在独立 Python 3.12 环境通过 `python scripts/run_tests.py`,配置隔离、禁止联网,49 批、1154 例输出 ALL SUITES PASS。相同新增测试在旧代码上有 13 例失败,修复后 16 例通过,包含真实追踪止盈执行路径。三道页面守卫与差异格式检查通过。
调查证据为真机见过。修复运行态与页面视觉验收为未判收。本机会话无可连接浏览器;服务器断网容器回归、重建镜像与四服务 force-recreate 待本次部署确认,没有重启容器、改运行参数、写数据库或操作 188。保留真实持仓与成交,待已有清仓命令成交后正常移出当前持仓,不删账掩盖实际持股。尚欠服务器回归、部署判收与真实执行场景观察,不能把本机通过称作上线恢复完成。
## 2026-10-26(续)· 钧达重复下发修复已部署 155
用户批准本次条件部署后,修复 `47bcea5` 已推送原 origin 的 main 与 Codex 修复分支。155 用提交快照构建候选镜像,在没有业务配置和源码挂载的断网临时容器中通过 49 批、1154 例回归,Python 3.11.9,代码指纹 `cd17b9c2bcea`。随后两次核对在途委托与待入账回报均为零,保留回退引用与旧镜像,快进源码并 force-recreate 四服务。北京时间 14:00:41 四服务启动,镜像为 `sha256:8c446286b38d52e16e6c20860bdd881dada8b3e1add16bb288b27112a572d767`。
运行态判收为真机见过。页面健康、数据库与交易日历正常,四服务重启次数为零,QMT 在线、心跳新鲜、水位推进、无重同步。调度执行与回放正常完成,无错误日志。核对的 23 项运行参数、四只持仓数量及成本部署前后完全一致,账本持仓数量与 QMT 相符。没有建表、调参、改账、补单或操作 188,保留服务器本地文件与可执行位。只读模拟历史回放延迟时,新检查的可下发量为零;页面实际响应已含新成本说明。代码事实与部署细节补入本次排查文档。
钧达 100 股仍是真实持仓。14:03 原人工清仓指令仍未成交,等待 34.58 元卖出区间条件,记录尚未移出当前持仓。真实新成交下的防重复效果与浏览器视觉验收为未判收,后者因本机会话没有可连接浏览器。回退源码为服务器 `codex/predeploy-47bcea5`,旧镜像为 `pms:rollback-20261026-2e5bc56`;回退需源码与镜像同时恢复。服务器临时证据目录 `/tmp/pms-release-47bcea5.t6MVSP/`,开发机证据目录 `/tmp/pms-junda-20261026/`。
## 2026-10-26(续)· 查明强传导筛选与新排序尚未完成切换
用户指出选股应取消必须强传导、按综合评价选择。开发机复核 9 月 17 日已定方案、PMS 提交 f5cc1b8、台账 016/017 及 10 月 15 日部署记录。新代码仍在;原方案是公司质地优先的逐层排序,原始 score 编码未变。9 月临时关闭的 PMS 上游排序没有完成后续开启;10 月 15 日桥按当次授权显式保留旧排序,后续部署继续保留该配置。
155 于北京时间 14:15 至 14:18 只读核对。桥 PLAN_RANK_AXIS=transmission、CARD_SORT_BY_QUALITY=False;PMS 上游排序 False、本地质地分组 True、白名单强传导。上游排序覆盖记录仍由 plan-rollback-choiceB-0922 写入,时间数据库原值 2026-09-22 10:10:06,按容器 datetime.now() 写入路径解读为北京时间。强传导限制来自 settings 默认值,没有数据库或环境变量覆盖。
当日计划返回 300 条主榜,全部为传导轴。PMS 真实消费记录 148 留下 13 只,已持仓过滤 3 只、仅展示 267 只、档位过滤 17 只。用相同计划在内存运行 select_candidates,当前结果与真实消费顺序一致;只开 PMS 上游排序仍为 13 只,放开弱传导为 28 只,取消档位筛选为 30 只。后两项是当前旧计划的条件对照,不是完整新排序或可执行买入清单。坤恒顺维、四方股份虽为质地好且判决候选,仍被旧档位门剔除。
改动文件只有 docs/开发接续_2026-10-12.md 和本记录,补入跨系统未完成事项、实际参数、过滤影响和后续验收条件。另记录命令升仓仍按原始分重排,与自主提议继承 selection_rank 不同。开发机 git diff --check 通过,未改业务代码,未运行业务回归。服务器操作仅为 SELECT、GET 已发布计划及读取指定有效配置,没有写库、改参、重启、发布计划、下单或操作 188。
现状与过滤影响判收为真机见过,新策略上线为未判收。后续需明确两档白名单或完全取消档位的范围,联合验证桥、夜间分析池与 PMS 的排序及准入,不能以单个开关或重新部署替代策略切换验收。
## 2026-10-26(续)· 质地排序统一切换的代码交付
用户授权全权完成选股切换。PMS 取消传导档位默认过滤,命令升仓继承候选 selection_rank,旧来源缺名次时保留原分数顺序,用户点名仍优先。补齐已在计划中的白名单票优先级,黑名单和已持仓排除保持。原始分、研判、择时、仓位与下单规则未重定义。
变更为 config/settings.py、app/core/planner.py、app/services/command_service.py,新增 scripts/test_batch46_units.py 并登记 scripts/run_tests.py。开发机独立 Python 3.12 经隔离入口完整 50 批、1165 例通过,含新增 11 例及三道页面护栏。桥同步新增冻结输入的排序修订入口,并让研究池消费已发布计划,详见桥台账 083。
155 已在临时目录的无配置、禁网容器通过桥 54 组契约测试及真实冻结输入的重排检查,原分数、判决、风险和研究均不变。此时未切服务器配置,未重建运行容器。代码测试通过,策略运行态判收仍为未判收;下一步完成候选镜像回归、备份、无在途与无待入账确认后联合部署,再查真实消费及研究池覆盖。
## 2026-10-26(续)· 155 质地选股切换完成并验证实际消费
用户授权全权完成切换。本次 PMS 代码 e7242f6、桥代码 dabb96b 均已提交并推送到各自既有 origin/main。仅在 155 模拟链路执行,没有操作 188 真实 PMS。详细现状与恢复依据已追加到 docs/开发接续_2026-10-12.md 第十节。
部署前使用提交归档构建候选镜像,在 155 断网容器通过 PMS 50 批、1165 例,桥 54 组契约及三个相关脚本。14:54:08 确认在途委托和待入账回报均为零、账实相符后,停止页面及两个调度进程;QMT 通道保留到最后重建。桥于 14:55:31、PMS 四服务于 14:57:10 从已测镜像 force-recreate。没有建表。桥只改两个排序开关,PMS 仅落表 PMS_PLAN_RANK_BY_UPSTREAM=True、PMS_PLAN_TIERS="",其余核对参数不变。
桥在原冻结输入上追加 quality 修订版,版本后缀 872ff104ce6ec025de1f4c3304c307ca56dd41791fdb08a6595c5a247d0c51e2。PMS 自然调度于 14:57:22 写入接收记录 152 和真实消费记录 153,后者为 upstream 排序、空档位白名单、16 只候选,包含强传导 7、弱传导 5、无传导 4。完整顺序与只读核对一致,档位过滤数为零。新研究池覆盖全部 16 只候选和 3 只持仓,池上限仍为 100;正常回收 12 只、补入 12 只,增量研究补扫已受理。
真机见过:76 份既有归档与晨版指针哈希不变;15:00 定时修订成功且仍为 quality;PMS 与桥健康正常,QMT 在线、水位一致、持仓无差异。切换窗口内高股息读取曾超时一次,15:01:39 同一读取路径复查成功。PMS 镜像与服务器已跟踪 Python 源码指纹同为 51941a03fd92。切换前钧达股份已由原清仓流程完成退出,本次没有删除成交或账本记录。
判收为真机见过。未为验收发起交易。新排序后的自然建仓与收益表现尚未发生,不能当作已验证盈利。私有备份、计划发布记录、消费与健康验收留在 155 的 /home/factor/pms_logs/quality-switch-20261026;配置备份不进 Git。本地原有宏观研究、台账和未跟踪文件保持原状。
## 2026-10-26(续)· 账户可用资金重复加回笼与总览估值混用
用户截图显示总资产 1,936,262、可用 3,450,895。155 只读核对资金快照 seq1426810:QMT 总资产 1,936,261.62、可用 1,806,071.62、冻结 0、持仓市值 130,190,三项本来闭合。PMS cash_view 又加 sell_return_today=1,644,823.13,恰好得到截图错误值。该加法源于 7 月 30 日,8 月 6 日留下的非零卖出核查未闭环;与今天选股切换无关。另有 QMT 市值与 PMS 收盘行情估值 124,916 的 5,274 差额,数量一致,具体是三只股票的估值价格不同。
修复 portfolio 统一资金入口,页面和买入资金校验直接采用 available_cash,不重复加回笼。新增账户市值、冻结资金透传,总览前三项按同份账户快照展示,策略仓位与持仓明细维持行情估值。更新 ws_codec、rule_gate 注释、QMT 协议与需求中的误导说明。新增 scripts/test_batch47_units.py 九例并登记,纠正 test_wiring 原错误断言。详细证据、影响和验证见 docs/账户资金口径核查_2026-10-26.md。
开发机配置隔离、禁网全量 51 批、1174 例通过,包含三道页面护栏;独立本地浏览器预览 1920、1280 宽度核对卡片、说明与换行,无脚本错误。服务器只读核查为真机见过。修复线上判收为未判收,此时尚未推送或部署,不改运行参数、账本、成交,不操作 188。下一步为用户确认本次 155 部署后执行候选镜像回归和运行验收。QMT 内部估值价格不同的生成原因、回笼统计期间未核实,不能把账户快照标为按最新收盘行情计价。
## 2026-10-26(续)· 155 账户资金修复部署完成
用户明确批准 f90d5e7 推送到既有 origin 并条件部署 155。提交归档在服务器重建候选镜像,未带业务配置、未挂载工作树的断网容器完整 51 批、1174 例通过。16:44:05 再次确认无在途委托、无待入账回报且账实数量一致后,正式源码快进到 f90d5e7,四个 PMS 服务于北京时间 16:44:06 从已测镜像 force-recreate。没有建表、改参数、改账本或成交,没有操作桥与 188。
真机见过:可用资金 1,806,071.62 元,账户市值 130,190 元,总资产 1,936,261.62 元,冻结为零,账户值闭合。原策略估值 124,916 元、仓位 6.25% 与盈亏不变。232 项有效参数全部相同,24 行持仓的核对字段、344 行批次、1270 条成交回报及资金流水摘要不变。四服务镜像一致、重启计数零,网页和数据库健康,QMT 在线且水位推进,无在途或待入账,启动日志无错误。新镜像、提交归档与服务器已跟踪源码指纹均为 f95d7c112d3f,实际 HTTP 页面摘要匹配提交。
本次部署文档更新 docs/账户资金口径核查_2026-10-26.md、docs/开发接续_2026-10-12.md 和本条流水账。私有验收证据在 155 的 /home/factor/pms_logs/funds-fix-20261026。回退分支 codex/pre-funds-20261026、镜像 pms:rollback-before-funds-20261026 已保留;155 回退时须同时处理挂载源码与镜像。开发机原有研究、台账及未跟踪文件未纳入本次提交,服务器已有本地文件保留。
运行态判收为真机见过。浏览器布局先在本地隔离预览核对,线上实际页面文件和服务读数已核对,本次没有真实登录浏览器验收。QMT 内部估值相差 5,274 元及回笼统计期间仍待下游核实,本次没有通过修改账户数值强行消除差额,也没有为验收发起交易。验证命令、所在机器和预期输出详见资金核查文档。

View File

@ -14,7 +14,7 @@
|---|---|---|---|---|---| |---|---|---|---|---|---|
| A1 | 持仓快照 `trading_position` | 股票代码(点式)、持仓数量、**可用数量(T+1 可卖)**、成本价(如有)、冻结数量(如有) | 盘中 ≤ 5 分钟 | 账本对账基准。当前 PMS 只确认过 `stock_code` 列可用,**请提供该表完整字段定义(DDL)**,尤其确认是否已有"可用数量"列——若无,PMS 自行按 T+1 规则推算 | **PMS 侧实机探明(2026-07-27,待下游确认语义)**:该表 14 列,含 `stock_code / stock_name / total_quantity / available_quantity / frozen_quantity / cost_price / market_price / market_value / profit_loss`。**可用数量列已存在**(`available_quantity`),本项数据需求实质已满足,PMS 已按此列对接。仍请确认:①`available_quantity` 是否即 T+1 可卖口径 ②更新时延 ③`stock_code` 格式(点式/前缀式) | | A1 | 持仓快照 `trading_position` | 股票代码(点式)、持仓数量、**可用数量(T+1 可卖)**、成本价(如有)、冻结数量(如有) | 盘中 ≤ 5 分钟 | 账本对账基准。当前 PMS 只确认过 `stock_code` 列可用,**请提供该表完整字段定义(DDL)**,尤其确认是否已有"可用数量"列——若无,PMS 自行按 T+1 规则推算 | **PMS 侧实机探明(2026-07-27,待下游确认语义)**:该表 14 列,含 `stock_code / stock_name / total_quantity / available_quantity / frozen_quantity / cost_price / market_price / market_value / profit_loss`。**可用数量列已存在**(`available_quantity`),本项数据需求实质已满足,PMS 已按此列对接。仍请确认:①`available_quantity` 是否即 T+1 可卖口径 ②更新时延 ③`stock_code` 格式(点式/前缀式) |
| A2 | 委托与成交 `trading_order` | 委托号、股票代码、方向、委托价、委托量、状态(**完整状态枚举文档**)、成交量、成交均价、委托/成交时间、来源标识 | 状态变更后 ≤ 1 分钟 | 成交回放入账(批次/成本)、指令执行确认。**请提供完整 DDL 与状态流转说明**(现掌握的 submitted/filled/completed/pending/failed 为推断口径,需正式确认) | **PMS 侧实机探明**:该表 20 列,已见 `order_id / strategy_id / stock_code / stock_name / order_side / order_quantity / order_price / target_price / order_status` 等。**仍缺两项,是本清单里最卡 PMS 的**:①状态枚举的正式定义 ②**成交来源标识**(哪条委托对应 PMS 的哪条指令)。在来源标识到位前,PMS 只能按「同股同向 + 下发早于成交 + FIFO」贪心认领,认领不上即判外部成交并告警——人工与 PMS 同时下单时会误判 |<br><br>**QMT 侧答复(2026-07-28)**:①**状态枚举**已给出 —— `submitted` 已提交 / `filled` **部分成交** / `completed` 已完成 / `pending` 挂单成功但 QMT 无响应 / `failed` 委托失败;撤单另有可靠终态。②**成交均价**将新增列。③**策略标识**字段表中已有,改造后可写入。<br><br>**PMS 侧结论**:本项**主链路已由 WebSocket 承接**,`trade` 逐笔成交消息带 `instruction_id`,来源标识问题自然消解。仍需注意两点,已并入新协议:⑴表中的 `strategy_id` 是指向 `t_trading_strategy` 的整数外键(因子策略表),只能回答「是不是 PMS 下的」,回答不了「是哪一条指令」,**不足以支撑回放认领**;⑵`filled` = 部分成交这个命名与字面含义相反,协议层改用 `PARTIAL` / `FILLED` 区分,映射见新协议 §7.2。**PMS 不再读 `order_status` 判断成交** | | A2 | 委托与成交 `trading_order` | 委托号、股票代码、方向、委托价、委托量、状态(**完整状态枚举文档**)、成交量、成交均价、委托/成交时间、来源标识 | 状态变更后 ≤ 1 分钟 | 成交回放入账(批次/成本)、指令执行确认。**请提供完整 DDL 与状态流转说明**(现掌握的 submitted/filled/completed/pending/failed 为推断口径,需正式确认) | **PMS 侧实机探明**:该表 20 列,已见 `order_id / strategy_id / stock_code / stock_name / order_side / order_quantity / order_price / target_price / order_status` 等。**仍缺两项,是本清单里最卡 PMS 的**:①状态枚举的正式定义 ②**成交来源标识**(哪条委托对应 PMS 的哪条指令)。在来源标识到位前,PMS 只能按「同股同向 + 下发早于成交 + FIFO」贪心认领,认领不上即判外部成交并告警——人工与 PMS 同时下单时会误判 |<br><br>**QMT 侧答复(2026-07-28)**:①**状态枚举**已给出 —— `submitted` 已提交 / `filled` **部分成交** / `completed` 已完成 / `pending` 挂单成功但 QMT 无响应 / `failed` 委托失败;撤单另有可靠终态。②**成交均价**将新增列。③**策略标识**字段表中已有,改造后可写入。<br><br>**PMS 侧结论**:本项**主链路已由 WebSocket 承接**,`trade` 逐笔成交消息带 `instruction_id`,来源标识问题自然消解。仍需注意两点,已并入新协议:⑴表中的 `strategy_id` 是指向 `t_trading_strategy` 的整数外键(因子策略表),只能回答「是不是 PMS 下的」,回答不了「是哪一条指令」,**不足以支撑回放认领**;⑵`filled` = 部分成交这个命名与字面含义相反,协议层改用 `PARTIAL` / `FILLED` 区分,映射见新协议 §7.2。**PMS 不再读 `order_status` 判断成交** |
| A3 | 账户资金快照(**新增需求**) | 总资产、可用资金、冻结资金、当日卖出可用资金(T+0 回笼) | 盘中 ≤ 5 分钟;日终必须 | 总规模校准与买入前资金校验。形式不限:新表 / 现有表 / HTTP 接口均可,请给出可行方案 | **已确认可提供**,走 WebSocket 实时回传。字段与消息格式见新协议 §5.7 `snapshot{kind:"funds"}`。**`sell_return_today`(当日卖出回笼)务必提供**,PMS 买入前的资金校验依赖它 | | A3 | 账户资金快照(**新增需求**) | 总资产、可用资金、冻结资金、当日卖出回笼统计 | 盘中 ≤ 5 分钟;日终必须 | 总规模校准与买入前资金校验。形式不限:新表 / 现有表 / HTTP 接口均可,请给出可行方案 | **已确认可提供**,走 WebSocket 实时回传。字段与消息格式见新协议 §5.7 `snapshot{kind:"funds"}`。2026-10-26 澄清:买入校验直接使用 available_cash,已含可用回笼;sell_return_today 仅作统计,禁止重复相加 |
| A4 | 成交回报明细(可选) | 若 A2 已含逐笔或聚合成交(成交量/均价),本项可免;否则请提供逐笔成交表 | 同 A2 | 部分成交场景的精确入账 | **已升格为必需项**:QMT 侧确认可回传「逐笔和最终结果」。**PMS 账本以逐笔 `trade` 消息为唯一入账依据**,`order_update` 仅作状态跟踪与终态校验。见新协议 §5.5 | | A4 | 成交回报明细(可选) | 若 A2 已含逐笔或聚合成交(成交量/均价),本项可免;否则请提供逐笔成交表 | 同 A2 | 部分成交场景的精确入账 | **已升格为必需项**:QMT 侧确认可回传「逐笔和最终结果」。**PMS 账本以逐笔 `trade` 消息为唯一入账依据**,`order_update` 仅作状态跟踪与终态校验。见新协议 §5.5 |
| A5 | 上游买入计划 `trading_buy_plan` | PMS 将作为该表的承接方(替代原决策系统 ENTRY_GATE 的角色)。请确认:①下游当前是否仍轮询 `is_active=6` 自动挂单?②切换后是否可以**停止**该轮询(统一走 B1 通道),或保留作为过渡(方案 X) | — | 旧通道处置(见 C2) | **未答复,仍待确认**(新协议 Q1)。另注:该表唯一约束为 `(stock_code, trading_time)` 且 `buy_amount` 是金额非股数,单股分批会撞约束——这也是通道改走 WebSocket 后不再受制于该表的原因之一 | | A5 | 上游买入计划 `trading_buy_plan` | PMS 将作为该表的承接方(替代原决策系统 ENTRY_GATE 的角色)。请确认:①下游当前是否仍轮询 `is_active=6` 自动挂单?②切换后是否可以**停止**该轮询(统一走 B1 通道),或保留作为过渡(方案 X) | — | 旧通道处置(见 C2) | **未答复,仍待确认**(新协议 Q1)。另注:该表唯一约束为 `(stock_code, trading_time)` 且 `buy_amount` 是金额非股数,单股分批会撞约束——这也是通道改走 WebSocket 后不再受制于该表的原因之一 |

View File

@ -333,11 +333,13 @@ QMT 把成交写入 `trading_order` / `trading_position` / `trading_log` 之后
```json ```json
{ "kind": "funds", "as_of": 1769500000000, "data": { { "kind": "funds", "as_of": 1769500000000, "data": {
"total_asset": 2013456.78, "available_cash": 312450.10, "total_asset": 2013456.78, "available_cash": 312450.10,
"frozen_cash": 12000.00, "sell_return_today": 48900.00, "market_value": 1701006.68 "frozen_cash": 12000.00, "sell_return_today": 48900.00, "market_value": 1689006.68
}} }}
``` ```
`sell_return_today`(当日卖出回笼,T+0 可用)是 PMS 买入前资金校验必需的,请务必提供。 `available_cash` 是账户可用余额,已经包含可用的卖出回笼,并已扣除冻结资金。PMS 买入前直接用该值校验,不再加 `sell_return_today`,也不再次扣减 `frozen_cash`。`sell_return_today` 保留为卖出回笼统计,不能作为额外余额。该口径于 2026-10-26 在 155 资金快照上核实,修正此前把“T+0 可用”误解为应重复相加的说明。
账户总资产、账户市值与现金采用同一份资金快照。PMS 持仓明细另按行情估值,两者可能不同;不得用行情市值反算并覆盖账户报告的现金余额。上例总资产等于可用资金加冻结资金加账户市值,回笼统计不再次参与加总。
### 5.8 `position_update` / `funds_update` —— 主动推送 ### 5.8 `position_update` / `funds_update` —— 主动推送

View File

@ -1,5 +1,7 @@
# 上游选股计划接口 · 接入记录与待确认口径 # 上游选股计划接口 · 接入记录与待确认口径
当前开发契约见本文末尾“2026-10-15 补充:完整决策版本契约”;下文早期接入实测保留历史语义。
> 2026-07-30 建。上游「选股系统」提供 HTTP 计划接口, PMS 的升仓/建仓候选池自此改吃它, > 2026-07-30 建。上游「选股系统」提供 HTTP 计划接口, PMS 的升仓/建仓候选池自此改吃它,
> 不再读 `trading_buy_plan`。本文是接口现状 + PMS 侧接法 + **需要上游回答的问题**。 > 不再读 `trading_buy_plan`。本文是接口现状 + PMS 侧接法 + **需要上游回答的问题**。
> 代码入口: `app/services/plan_feed.py`; 单测: `scripts/test_batch7_units.py` (23 例); > 代码入口: `app/services/plan_feed.py`; 单测: `scripts/test_batch7_units.py` (23 例);
@ -672,3 +674,17 @@ make changes # 页面同款结论
**候选按上游名次排 (自门控)。** 计划顶层 `rank_axis` 为 quality 时, `select_candidates` 按上游名次升序排、关掉 PMS 自己的基本面立场分桶 (参数 `PMS_PLAN_RANK_BY_UPSTREAM`, 默认开); 上游没带这个键时无作用, 逐字回到按立场分桶排。这样选股序、入池、PMS 候选三处同一个序。本次用哪种序记在候选返回与名册快照元数据的 `rank_mode` 里 (upstream / quality_bucket / score)。 **候选按上游名次排 (自门控)。** 计划顶层 `rank_axis` 为 quality 时, `select_candidates` 按上游名次升序排、关掉 PMS 自己的基本面立场分桶 (参数 `PMS_PLAN_RANK_BY_UPSTREAM`, 默认开); 上游没带这个键时无作用, 逐字回到按立场分桶排。这样选股序、入池、PMS 候选三处同一个序。本次用哪种序记在候选返回与名册快照元数据的 `rank_mode` 里 (upstream / quality_bucket / score)。
**前缀效应 —— 强传导票变少不是故障。** 质地序把好公司排到前面, 质地差但强传导的票会往后掉, 可能落到我们要的三百只主榜前缀之外, 于是这批票在候选里变少甚至消失。这与"质地差降关注"同向, 是预期结果, 不要当成上游漏发或接口出错。要看全量强传导票, 去上游的逐票对账接口 `/plan/verdict` (它的"主榜第 N 名"仍按原始分序, 应答带 `rank_axis: transmission` 说明), 或把 `PMS_PLAN_RANK_BY_UPSTREAM` 关掉临时回到按分桶排。 **前缀效应 —— 强传导票变少不是故障。** 质地序把好公司排到前面, 质地差但强传导的票会往后掉, 可能落到我们要的三百只主榜前缀之外, 于是这批票在候选里变少甚至消失。这与"质地差降关注"同向, 是预期结果, 不要当成上游漏发或接口出错。要看全量强传导票, 去上游的逐票对账接口 `/plan/verdict` (它的"主榜第 N 名"仍按原始分序, 应答带 `rank_axis: transmission` 说明), 或把 `PMS_PLAN_RANK_BY_UPSTREAM` 关掉临时回到按分桶排。
# 2026-10-15 补充:完整决策版本契约
本节为当前开发实现;下文历史实测里“实时重装配、没有版本戳”的描述不再用于新版。
部署状态见 `docs/交接_每日选股计划完善_2026-10-15.md`,本地实现不等于已经上线。
- 顶层新增 schema_version=2、decision、traceability;plan_version 仍为代码版本。
- decision 包括 id、parent_id、cutoff_at、input_hash、params_hash、reason;时间带时区。
- 计划行新增全量 research_rank、research、review_ref。展示裁剪不改变全量名次。
- GET /plan、/plan/verdict、/logic_state 可指定 decision_id;指定日期或版本只读发布内容。缺档不现算。
- 最新查询带 refresh_status;pending_codes 为已知待修订或来源核验失败的股票,暂停新增自主提议。
- 评析报告 report_version_url 引用不可变对象;旧数据缺引用明确标示,不能用最新报告替代历史。
- PMS meta.kind 区分 received、consumed、rechecked;消费记录包括真实顺序、有效参数和过滤原因。
- 采纳核验由 PMS_PLAN_VERSION_RECHECK 控制,默认关闭;内容更新时接口返回 ok=false、原因及更新后的 proposal,页面必须重新确认其 proposal_revision。
- 旧消费者可忽略新增字段,新消费者接受旧字段为空;无版本旧数据不能通过已启用的自主采纳核验。

View File

@ -858,6 +858,9 @@ def eval_open(c: dict, params: dict, caps: dict, room_amt: float):
"tier": c.get("tier"), "upside": c.get("upside"), "heat": c.get("heat"), "tier": c.get("tier"), "upside": c.get("upside"), "heat": c.get("heat"),
"plan_rank": c.get("rank"), "plan_bucket": c.get("bucket"), "plan_rank": c.get("rank"), "plan_bucket": c.get("bucket"),
"plan_src": c.get("src"), "sector": c.get("sector"), "plan_src": c.get("src"), "sector": c.get("sector"),
**{k: c.get(k) for k in ('decision', 'consumption_id', 'consumption_error',
'plan_basis', 'selection_rank', 'research_rank', 'research', 'review_ref')},
**{k: c[k] for k in ('candidate_source','dividend_ref','dividend_policy_version','dividend_research') if k in c},
# 决策系统今天盘中判过这只票转多没有。这是**定性材料**不是仓位数字, 所以送研判时 # 决策系统今天盘中判过这只票转多没有。这是**定性材料**不是仓位数字, 所以送研判时
# 也带过去 (见 judge.OPEN_JUDGE_KEYS) —— 等于当面告诉它「你自己今天判过这只票转多」, # 也带过去 (见 judge.OPEN_JUDGE_KEYS) —— 等于当面告诉它「你自己今天判过这只票转多」,
# 它可以拿自己的结论去对照; 没有信号时这两项是 None, 不误导。 # 它可以拿自己的结论去对照; 没有信号时这两项是 None, 不误导。
@ -901,6 +904,9 @@ def eval_open(c: dict, params: dict, caps: dict, room_amt: float):
+ ("; **决策系统今天盘中判过该股转多**" if c.get("sig_buy") else "") + ("; **决策系统今天盘中判过该股转多**" if c.get("sig_buy") else "")
+ f", 现价 {price}, 目标仓位 {target_pct:.0%} 约 {full_amt:,.0f} 元, " + f", 现价 {price}, 目标仓位 {target_pct:.0%} 约 {full_amt:,.0f} 元, "
f"先建底仓 {qty} 股 (约 {qty * price:,.0f} 元)") f"先建底仓 {qty} 股 (约 {qty * price:,.0f} 元)")
if c.get('candidate_source') == 'dividend':
reason = (f"高股息建仓:研究核验通过,现价 {price},目标仓位 {target_pct:.0%},"
f"先建底仓 {qty} 股(约 {qty * price:,.0f} 元)")
cand = _cand(c, A_OPEN, BUY, qty, reason, hard) cand = _cand(c, A_OPEN, BUY, qty, reason, hard)
# 这两项是 OPEN 独有的, 供 proposal_service 用: # 这两项是 OPEN 独有的, 供 proposal_service 用:
# price —— 新票在账本里没有行, _pos_of 拿不到现价, 取它会是 0 而被规则闸判 PRICE_MISSING # price —— 新票在账本里没有行, _pos_of 拿不到现价, 取它会是 0 而被规则闸判 PRICE_MISSING
@ -972,13 +978,18 @@ def scan_open(*, candidates: list, params: dict, caps: dict, room_amt: float,
# 候选池的产物), 候选层那一整套过滤一道都不绕。 # 候选池的产物), 候选层那一整套过滤一道都不绕。
# PMS_OPEN_SIGNAL_PRIORITY 关掉即退回纯分数排序, 页面可改, 不用改码。 # PMS_OPEN_SIGNAL_PRIORITY 关掉即退回纯分数排序, 页面可改, 不用改码。
sig_first = bool(params.get("open_signal_priority", True)) sig_first = bool(params.get("open_signal_priority", True))
for c in sorted(candidates or [], for execution_rank, c in enumerate(sorted(candidates or [],
key=lambda x: (0 if (sig_first and x.get("sig_buy")) else 1, key=lambda x: (0 if (sig_first and x.get("sig_buy")) else 1,
-_f(x.get("score")), _f(x.get("rank"), 10 ** 9), (0, x['selection_rank']) if x.get('selection_rank') is not None
str(x.get("ts_code") or ""))): else (1, -_f(x.get('score'))),
_f(x.get("rank"), 10 ** 9),
str(x.get("ts_code") or ""))), 1):
code = c.get("ts_code") code = c.get("ts_code")
if not code: if not code:
continue continue
if code in ((c.get('refresh_status') or {}).get('pending_codes') or []) or c.get('consumption_error'):
skipped.append({'ts_code': code, 'action': A_OPEN, 'why': '计划修订或消费留痕尚未完成,暂停新的自主建仓'})
continue
if route and c.get("verdict") == VERDICT_DISPLAY: if route and c.get("verdict") == VERDICT_DISPLAY:
# 仅展示的行不占名额、不占金额, 也不进后面任何一道闸; 放在名额判断之前, # 仅展示的行不占名额、不占金额, 也不进后面任何一道闸; 放在名额判断之前,
# 是为了让它的跳过原因永远是「仅展示」而不是碰巧的「名额用完」。 # 是为了让它的跳过原因永远是「仅展示」而不是碰巧的「名额用完」。
@ -1043,6 +1054,9 @@ def scan_open(*, candidates: list, params: dict, caps: dict, room_amt: float,
continue continue
try: try:
cand.setdefault("hard_numbers", {})["advice"] = adv cand.setdefault("hard_numbers", {})["advice"] = adv
cand['hard_numbers']['execution_rank'] = execution_rank
cand['hard_numbers']['priority_reason'] = ('盘中转多信号优先' if sig_first and c.get('sig_buy')
else '继承候选消费顺序')
cand["hard_numbers"]["advice_text"] = adv.get("text") if isinstance(adv, dict) else None cand["hard_numbers"]["advice_text"] = adv.get("text") if isinstance(adv, dict) else None
cand["hard_numbers"]["plan_by_advice"] = bool(params.get("plan_by_advice")) cand["hard_numbers"]["plan_by_advice"] = bool(params.get("plan_by_advice"))
if isinstance(adv, dict) and adv.get("tier") == "试探仓": if isinstance(adv, dict) and adv.get("tier") == "试探仓":

236
app/core/ledger_repair.py Normal file
View File

@ -0,0 +1,236 @@
# -*- coding: utf-8 -*-
"""逐笔历史修复的离线编译器。只有完整证据才生成写回计划,不猜基线。"""
from collections import defaultdict
from copy import deepcopy
from datetime import datetime, timezone, timedelta
from decimal import Decimal, ROUND_HALF_UP
import hashlib
import json
from app.core.cushion import sell_allocation, cushion_state
D = lambda x: Decimal(str(x or 0))
TERMINAL = {'FILLED', 'CANCELLED', 'EXPIRED', 'REJECTED', 'ABORTED', 'SEND_FAILED'}
def canonical(value):
return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(',', ':'), default=str)
def digest(value):
return hashlib.sha256(canonical(value).encode()).hexdigest()
def rounded(value, places=3):
return str(D(value).quantize(Decimal(10) ** -places, rounding=ROUND_HALF_UP))
def net_lot_cost(lots):
"""核销均价只有三位小数;盈亏金额保留了逐笔核销金额,不能反乘均价丢精度。"""
return sum((D(l['qty']) * D(l['open_price']) -
(D(l['realized_pnl']) if l.get('realized_pnl') is not None else
D(l.get('closed_qty')) * (D(l.get('close_avg_price')) - D(l['open_price']))))
for l in lots)
def need(condition, message):
if not condition:
raise ValueError(message)
def compile_repair(backup, codes, *, scale=2000000, solid=0.03):
"""返回原行、目标列、逐笔分配和不能还原事项。输入、配置相同则结果完全一致。"""
need(backup.get('instance') == '155-sim', '仅接受已确认的 155 模拟仓备份')
need(codes and len(set(codes)) == len(codes), '股票范围为空或重复')
tables = backup['tables']
run_id = 'HIST_' + digest({'backup': backup, 'codes': sorted(codes),
'scale': scale, 'solid': solid})[:24]
out = {'run_id': run_id, 'backup_digest': digest(backup), 'codes': sorted(codes),
'changes': [], 'summaries': [], 'allocations': [], 'daily': {}, 'unknowns': [
'手续费原文为空时无法恢复实际净盈亏,以下盈亏均为不含费用的批次盈亏。',
'缺少完整盘中行情及当时账本,安全垫历史峰值保留原值,不声明已还原。',
'历史日报与全组合净值保留原始记录,受污染期间不得作为已修复的真实绩效。']}
snapshots = {x['ts_code']: x for x in backup['position_snapshot']['payload']['items']}
all_trades = []
for r in tables['pms_qmt_inbox']:
p = json.loads(r['payload_json'])
if p.get('ts_code') in codes:
all_trades.append(dict(r, payload=p))
by_no = set()
for r in all_trades:
p = r['payload']
need(p.get('trade_no') and p['trade_no'] not in by_no, '重复或缺失成交号')
by_no.add(p['trade_no'])
def change(table, row, fields):
out['changes'].append({'table': table, 'key': {'id': row['id']},
'before': row, 'fields': fields})
for code in sorted(codes):
positions = [x for x in tables['pms_position'] if x['ts_code'] == code]
need(len(positions) == 1 and code in snapshots, f'{code} 持仓事实缺失')
pos, fact = positions[0], snapshots[code]
lots = [x for x in tables['pms_lot'] if x['ts_code'] == code]
need(lots, f'{code} 无可追溯批次基线')
start = min(str(l['open_date']) for l in lots)
orders = {x['instruction_id']: x for x in tables['pms_qmt_order'] if x['ts_code'] == code}
instructions = {x['instruction_id']: x for x in tables['pms_instruction'] if x['ts_code'] == code}
trades = sorted([x for x in all_trades if x['payload']['ts_code'] == code],
key=lambda x: (int(x['payload']['trade_time']), int(x['seq'])))
before_qty = 0
current = []
for r in trades:
p = r['payload']
day = datetime.fromtimestamp(int(p['trade_time']) / 1000, timezone(timedelta(hours=8))).date().isoformat()
if day < start:
before_qty += int(p['qty']) * (1 if p['side'] == 'buy' else -1)
else:
current.append(r)
need(before_qty == 0, f'{code} 起点前未平仓,不能假设零基线')
need(current, f'{code} 缺少逐笔历史')
parents = defaultdict(list)
for iid, o in orders.items():
if str(o['created_at'])[:10] < start:
continue
need(o['status'] in TERMINAL, f'{iid} 仍有在途委托')
ts = [x for x in current if x['payload']['instruction_id'] == iid]
need(sum(int(x['payload']['qty']) for x in ts) == int(o['cum_qty']), f'{iid} 漏笔或累计量冲突')
for r in current:
p = r['payload']; o = orders.get(p['instruction_id'])
need(o and o['parent_id'] in instructions, f"{p['trade_no']} 缺出口或父指令")
need(o['side'] == p['side'] and o['broker_order_id'] == p['broker_order_id'], '成交身份冲突')
need(int(r['processed']) == 1 and int(p['qty']) > 0 and D(p['price']) > 0, '未完成原始入账或坏成交')
need(D(p.get('amount')) == int(p['qty']) * D(p['price']), '逐笔金额不一致')
parents[o['parent_id']].append(r)
fills = [x for x in backup['table_fills'] if x['ts_code'] == code and x['done_time'][:10] >= start]
for f in fills:
owners = [o for o in orders.values() if o['instruction_id'] == f['order_id'] or
(f.get('raw', {}).get('qmt_order_id') and o['broker_order_id'] == f['raw']['qmt_order_id'])]
need(len(owners) == 1 and owners[0]['side'] == f['side'], '存在无法解释的外部成交')
used, state, matched = set(), {}, {}
for r in current:
p = r['payload']; o = orders[p['instruction_id']]
if p['side'] != 'buy':
continue
matches = [l for l in lots if l['instruction_id'] == o['parent_id'] and
int(l['qty']) + int(l['closed_qty']) == int(p['qty']) and
D(l['open_price']) == D(p['price']) and str(l['created_at']) == str(r['processed_at'])]
need(len(matches) == 1 and matches[0]['id'] not in used, f"{p['trade_no']} 原批次无法唯一对应")
l = matches[0]; used.add(l['id']); matched[r['seq']] = l['id']
state[l['id']] = dict(l, qty=0, closed_qty=0, close_avg_price=None,
realized_pnl=Decimal(0), sell_amount=Decimal(0))
groups = defaultdict(list); void = []
for l in lots:
if l['id'] in used:
continue
void.append(l['id'])
if l['lot_type'] != 'RECON':
groups[(str(l['created_at']), str(l['open_price']))].append(l)
matched_fills = set()
for (created, price), group in groups.items():
qty = sum(int(l['qty']) + int(l['closed_qty']) for l in group)
fs = [f for f in fills if f['side'] == 'buy' and f['qty'] == qty and D(f['price']) == D(price)
and f['done_time'][:10] == created[:10] and all(
not l['instruction_id'] or l['instruction_id'] == orders[f['order_id']]['parent_id']
for l in group)]
need(len(fs) == 1 and fs[0]['order_id'] not in matched_fills, '非真实买入批次缺重复汇总单证据')
matched_fills.add(fs[0]['order_id'])
daily = {}; buy_cash = D(0); sell_cash = D(0)
for r in current:
p = r['payload']; qty = int(p['qty']); px = D(p['price'])
if p['side'] == 'buy':
state[matched[r['seq']]]['qty'] = qty
buy_cash += qty * px
else:
active = sorted((l for l in state.values() if l['qty'] > 0), key=lambda l: (str(l['open_date']), l['id']))
allocations = sell_allocation([dict(lot_id=l['id'], lot_type=l['lot_type'], qty=l['qty'],
open_date=int(str(l['open_date']).replace('-', ''))) for l in active], qty)
for a in allocations:
l = state[a['lot_id']]; q = a['qty']
l['qty'] -= q; l['closed_qty'] += q; l['sell_amount'] += q * px
l['realized_pnl'] += q * (px - D(l['open_price']))
out['allocations'].append(dict(ts_code=code, seq=r['seq'], trade_no=p['trade_no'],
lot_id=l['id'], qty=q, price=str(px), realized_pnl=str(q * (px - D(l['open_price'])))))
sell_cash += qty * px
day = str(r['received_at'])[:10]
q = sum(l['qty'] for l in state.values())
daily[day] = {'qty': q, 'buy_amount': str(buy_cash), 'sell_amount': str(sell_cash),
'realized_pnl': str(sum(l['realized_pnl'] for l in state.values())),
'avg_cost': rounded((buy_cash-sell_cash)/q) if q else None}
total = sum(l['qty'] for l in state.values())
need(total == int(fact['total_qty']), f'{code} 重建数量与 QMT 不符')
need(net_lot_cost(list(state.values())) == buy_cash - sell_cash, '成本与逐笔资金不守恒')
pnl = sum(l['realized_pnl'] for l in state.values())
for old in lots:
l = state.get(old['id'])
fields = {'qty': 0, 'closed_qty': 0, 'close_avg_price': None, 'realized_pnl': '0.00',
'status': 'CLOSED', 'note': f'{run_id} 原重复/RECON批次作废;原值见备份'}
if l:
fields.update(qty=l['qty'], closed_qty=l['closed_qty'],
close_avg_price=rounded(l['sell_amount']/l['closed_qty']) if l['closed_qty'] else None,
realized_pnl=rounded(l['realized_pnl'], 2), status='OPEN' if l['qty'] else 'CLOSED',
note=f'{run_id} 按逐笔重建;原值见备份')
change('pms_lot', old, fields)
by_type = defaultdict(int)
for l in state.values():
by_type[l['lot_type']] += l['qty']
avg = max(D(0), (buy_cash - sell_cash)/total) if total else None
px = D(fact['market_price']); cp = px/avg-1 if avg else None
# 保留原有 T+1 限制:当日买入不能因模拟 QMT 可用数过宽而全部放开。
today = backup['at'][:10]
day_open = daily[max((d for d in daily if d < today), default=min(daily))]['qty'] if min(daily) < today else 0
today_sell = sum(int(x['payload']['qty']) for x in current if x['received_at'][:10] == today and x['payload']['side']=='sell')
avail = min(int(fact['avail_qty']), max(0, day_open-today_sell), total)
fields = dict(total_qty=total, avail_qty=avail, base_qty=by_type['BASE']+by_type['RECON'],
add_qty=by_type['ADD'], dca_qty=by_type['DCA'], fill_qty=by_type['FILL'], t0_qty=by_type['T0'],
avg_cost=rounded(avg) if avg else None,
realized_t_profit=rounded(sum(l['realized_pnl'] for l in state.values() if l['lot_type']=='T0'),2),
cushion_pct=rounded(cp,4) if cp is not None else None,
cushion_state=cushion_state(float(cp) if cp is not None else None,solid),
pct_of_scale=rounded(total*px/D(scale),4) if scale else None,
status=('HOLDING' if pos['status']=='CLOSED' and total else pos['status']))
change('pms_position', pos, fields)
progress_rows = []
for pid, ts in parents.items():
ins = instructions[pid]; qty = sum(x['payload']['qty'] for x in ts)
amount = sum(D(x['payload']['amount']) for x in ts)
progress = json.loads(ins['progress_json'] or '{}')
evidence = {'run_id': run_id, 'old_exec_qty': ins['exec_qty'], 'old_status': ins['status'],
'exec_qty': qty, 'exec_amount': str(amount), 'remaining_qty': max(0, ins['qty']-qty),
'overfill_qty': max(0,qty-ins['qty']), 'seqs': [x['seq'] for x in ts]}
status = ins['status']
if status == 'CONFIRMED' and qty < ins['qty']:
status = 'CANCELLED'
evidence['hold_reason'] = '历史修复暂停剩余执行;子单均已终态,不自动续单'
progress['historical_repair'] = evidence
for child in progress.get('children', []):
child_ts = [x for x in ts if x['payload']['instruction_id'] == child.get('ref')]
child['actual_exec_qty'] = sum(x['payload']['qty'] for x in child_ts)
child['actual_exec_amount'] = str(sum(D(x['payload']['amount']) for x in child_ts))
change('pms_instruction', ins, dict(exec_qty=qty, exec_avg_price=rounded(amount/qty),
status=status, progress_json=canonical(progress)))
progress_rows.append(dict(instruction_id=pid, **evidence, new_status=status))
need(not [x for x in tables['pms_plan'] if x['ts_code']==code], '命令方案须另作完整重建,当前工具不猜命令进度')
# 活跃网格账的剩余档位来自同一批真实批次,已撤销策略不恢复。
for strategy in tables['pms_strategy']:
if strategy['ts_code'] != code or strategy['status'] != 'ACTIVE':
continue
need(strategy['type']=='GRID', '活跃非网格策略需要专门核验')
st = json.loads(strategy['state_json'] or '{}')
need(not st.get('pending'), '网格策略仍有待结算指令')
levels = defaultdict(lambda: [0,D(0)])
for l in state.values():
ins = instructions[l['instruction_id']]
if ins.get('origin_id') != strategy['strategy_id'] or not l['qty']:
continue
prog = json.loads(ins['progress_json'] or '{}'); leg = prog.get('leg','')
need(leg.startswith('grid_buy:'), '策略批次缺网格档位来源')
level = leg.split(':')[1]; levels[level][0] += l['qty']; levels[level][1] += l['qty']*D(l['open_price'])
st['filled_levels'] = {k:dict(qty=v[0],price=float(v[1]/v[0])) for k,v in levels.items()}
st['invested'] = float(sum(v[1] for v in levels.values()))
st['historical_repair'] = {'run_id':run_id,'source':'真实剩余批次'}
change('pms_strategy',strategy,dict(state_json=canonical(st)))
out['daily'][code] = daily
out['summaries'].append(dict(ts_code=code,start=start,trades=len(current),real_lots=len(used),
void_lots=void,old_qty=pos['total_qty'],qty=total,avg_cost=fields['avg_cost'],avail_qty=avail,
old_avg_cost=pos['avg_cost'],realized_pnl=rounded(pnl,2),buy_amount=str(buy_cash),sell_amount=str(sell_cash),
instructions=progress_rows))
return json.loads(canonical(out))

64
app/core/plan_revision.py Normal file
View File

@ -0,0 +1,64 @@
"""计划消费与提议版本核验的纯函数;不改变准入、仓位或自然语言判断。"""
import hashlib
import json
def fingerprint(value):
return hashlib.sha256(json.dumps(value, ensure_ascii=False, sort_keys=True,
separators=(',', ':'), default=str).encode()).hexdigest()
def basis(row):
# 排名与审计时间不是资格/风险/数量依据。完整评析引用变化需要重新研判。
result = {k: row.get(k) for k in ('score', 'tier', 'upside', 'heat', 'theme',
'verdict', 'risk', 'missing', 'reasons', 'logic_state', 'company_gate',
'company_review', 'company_review_text', 'events', 'pricing_state', 'news')}
if row.get('candidate_source') == 'dividend':
result.update({k: row.get(k) for k in ('candidate_source', 'dividend_ref', 'dividend_policy_version')})
# 资料年龄不是研究变化;固定报告引用和研究内容才是。
result['company_review'] = {k:v for k,v in (row.get('company_review') or {}).items() if k != 'age_days'}
result['review_ref'] = row.get('review_ref')
return result
def portfolio_context(view, commitments, stock=None):
"""持仓/资金/在途承诺变化使旧数量依据失效;价格漂移仍由执行终检管理。"""
totals = view.get('totals') or {}
inflight = {'names': sorted(commitments.get('names') or [])}
# 实时报价只改变预估占用,不能使同一份确认每次失效。
# 旧调用方缺少稳定依据时保留原比较;旧提议指纹变化仍须重核一次。
if isinstance(commitments.get('basis'), list):
inflight['basis'] = sorted(commitments['basis'])
else:
inflight['amount'] = commitments.get('amount')
return fingerprint({'held': sorted((r['ts_code'], r.get('total_qty'), r.get('sector'))
for r in view.get('held') or []),
'cash_source': totals.get('cash_source'), 'cash_avail': totals.get('cash_avail'),
'sector_ready': view.get('sector_ready'), 'stock': stock or {},
'inflight': inflight})
def compare(old, current, code):
"""返回 unavailable/material/unchanged。资格失效由调用方通过缺候选表达。"""
if not current or not (current.get('decision') or {}).get('id'):
return 'unavailable'
state = current.get('refresh_status') or {}
if code in (state.get('pending_codes') or []) or current.get('consumption_error'):
return 'unavailable'
if old is None or fingerprint(old) != fingerprint(basis(current)):
return 'material'
return 'unchanged'
def needs_new_judgement(hard, previous):
"""仅研究依据变化重问模型;组合及参数变化复算规则和数量。"""
return (not previous or previous.get('plan_basis') is None
or fingerprint(hard.get('plan_basis')) != fingerprint(previous.get('plan_basis')))
def confirmation_revision(qty, hard, verdict):
"""确认针对可见的建议内容;后台检查时间、名次及无关版本不让确认失效。"""
return fingerprint({'qty': qty, 'basis': hard.get('plan_basis'),
'advice': hard.get('advice'), 'reason': hard.get('reason'),
'verdict': verdict.get('verdict'), 'judge_reason': verdict.get('reason'),
'confidence': verdict.get('confidence')})

View File

@ -83,6 +83,19 @@ def _sortable(p, key, reverse=False):
return (-v if reverse else v, p.get("ts_code") or "") return (-v if reverse else v, p.get("ts_code") or "")
def candidate_order(c):
"""用户点名优先;计划票沿用实际筛选次序,旧来源仍按分数排。"""
code = c.get("ts_code") or ""
if c.get("src") == "whitelist" or c.get("user_selected"):
return (0, 0, 0, code)
rank = c.get("selection_rank")
if rank is None:
rank = (c.get("plan_provenance") or {}).get("selection_rank")
if rank is not None:
return (1, 0, float(rank), code)
return (1, 1, -float(c.get("score") or 0), code)
def _usable(positions, exclude_codes): def _usable(positions, exclude_codes):
"""可纳入减持方案的持仓: 有数量、**有真实现价**、不在排除名单 (已有在途方案的票)。 """可纳入减持方案的持仓: 有数量、**有真实现价**、不在排除名单 (已有在途方案的票)。
@ -303,7 +316,7 @@ def plan_increase_exposure(*, add_amount: float, positions: list, candidates=Non
ctx = _ctx_after(ctx, amt, is_new_name=False, sector=p.get("sector")) ctx = _ctx_after(ctx, amt, is_new_name=False, sector=p.get("sector"))
# ---- ② 候选池新票建仓 ---- # ---- ② 候选池新票建仓 ----
for c in sorted(candidates or [], key=lambda x: _sortable(x, "score", reverse=True)): for execution_rank, c in enumerate(sorted(candidates or [], key=candidate_order), 1):
if acc >= target: if acc >= target:
break break
price = float(c.get("price") or 0) price = float(c.get("price") or 0)
@ -328,8 +341,13 @@ def plan_increase_exposure(*, add_amount: float, positions: list, candidates=Non
if bad: if bad:
rejects.append({"ts_code": c.get("ts_code"), "reasons": bad}) rejects.append({"ts_code": c.get("ts_code"), "reasons": bad})
continue continue
items.extend(_open_batch_items(c.get("ts_code"), sp, price, batches = _open_batch_items(c.get("ts_code"), sp, price, reason_prefix="升仓建新仓")
reason_prefix="升仓建新仓")) for item in batches:
reason = ('用户白名单优先' if c.get('src') == 'whitelist' or c.get('user_selected')
else '沿用候选筛选次序' if candidate_order(c)[1] == 0 else '旧来源按分数排序')
item['plan_provenance'] = dict(c.get('plan_provenance') or {}, execution_rank=execution_rank,
priority_reason=reason)
items.extend(batches)
intended += want_amt intended += want_amt
acc += actual acc += actual
ctx = _ctx_after(ctx, actual, is_new_name=True, sector=c.get("sector")) ctx = _ctx_after(ctx, actual, is_new_name=True, sector=c.get("sector"))

View File

@ -236,7 +236,7 @@ def _check_cash(failed, warns, qty, price, caps, hard):
与组合上限是**两个不同的约束**, 所以单列一条而不是塞进 check_all_caps: 与组合上限是**两个不同的约束**, 所以单列一条而不是塞进 check_all_caps:
上限管「该不该买这么多」—— 仓位纪律, 基准是 PMS_TOTAL_SCALE 这个用户命令参数 上限管「该不该买这么多」—— 仓位纪律, 基准是 PMS_TOTAL_SCALE 这个用户命令参数
资金管「买不买得起」 —— 账户事实, 基准是 ws 资金快照的 available_cash + 当日回笼 资金管「买不买得起」 —— 账户事实, 基准是 ws 资金快照的 available_cash,已含可用回笼
2026-07-30 之前只有前者: scale=200 万而模拟账户实际只有 98 万, 于是排出的方案规则闸一路 2026-07-30 之前只有前者: scale=200 万而模拟账户实际只有 98 万, 于是排出的方案规则闸一路
放行, 要等 QMT 回 `INSUFFICIENT_CASH` 才被拒; 而 reject 不自动重发, 择时下一跳又算又发 放行, 要等 QMT 回 `INSUFFICIENT_CASH` 才被拒; 而 reject 不自动重发, 择时下一跳又算又发
又拒 —— 页面看着一切正常, 实际一单也下不去。 又拒 —— 页面看着一切正常, 实际一单也下不去。

View File

@ -113,7 +113,7 @@ def parse_intraday(fields: dict, *, msg_id: str = None) -> dict:
"confidence": _norm_conf(f.get("confidence")), "confidence": _norm_conf(f.get("confidence")),
"minute_qrs": _num(scores.get("minute_qrs")), "minute_qrs": _num(scores.get("minute_qrs")),
"suggested_price": _num(f.get("suggested_price")) or None, "suggested_price": _num(f.get("suggested_price")) or None,
"reason": f.get("reason") or f.get("llm_reason") or "", "reason": f.get("reason") or f.get("llm_reason") or f.get("audit_reason") or scores.get("reason") or "",
"dominant_signal": f.get("dominant_signal") or "", "dominant_signal": f.get("dominant_signal") or "",
# 发送方标识 (2026-09-03 起保留): 缺就是 unknown, 不猜是谁发的 # 发送方标识 (2026-09-03 起保留): 缺就是 unknown, 不猜是谁发的
"producer_id": str(f.get("producer_id") or "").strip() or PRODUCER_UNKNOWN} "producer_id": str(f.get("producer_id") or "").strip() or PRODUCER_UNKNOWN}

View File

@ -509,9 +509,8 @@ def parse_positions_snapshot(payload: dict) -> dict:
def parse_funds_snapshot(payload: dict) -> dict: def parse_funds_snapshot(payload: dict) -> dict:
"""`snapshot{kind:"funds"}` → 归一后的资金字段 (§5.7)。 """`snapshot{kind:"funds"}` → 归一后的资金字段 (§5.7)。
暂无消费方: `calibrate_fees` 的公式要「总资产变动 − 成交净额」, 需要**两天**的快照差 portfolio.cash_view 使用 available_cash 作为账户可用资金;该余额已包含可用的卖出
再扣掉入出金, 不是接上字段就能算对。先解析落库、等口径定了再接, 别硬凑一个看起来 回笼,sell_return_today 仅是统计字段,不可重复相加。市值与总资产原样保留账户口径。
有结果的数 —— 费用本来就不进成本, 晚校准无风险 (协议 §5.5)。
""" """
d = (payload or {}).get("data") d = (payload or {}).get("data")
d = d if isinstance(d, dict) else (payload or {}) d = d if isinstance(d, dict) else (payload or {})

View File

@ -236,3 +236,167 @@ def execute_many(sql: str, seq_params: list, source: str = "proxy") -> int:
except Exception as e: except Exception as e:
_mark(source, False) _mark(source, False)
raise DBUnavailable(f"批量写入异常({source}): {type(e).__name__}: {e}") from e raise DBUnavailable(f"批量写入异常({source}): {type(e).__name__}: {e}") from e
def apply_audited_repair(plan: dict, guards: list, *, rollback=False) -> dict:
"""维护专用:核验原行、逐条单表写入和审计在同一事务。绝不调下单或回放服务。"""
import json
from datetime import datetime
from app.core.ledger_repair import canonical
allowed = {
'pms_lot': {'qty','closed_qty','close_avg_price','realized_pnl','status','note'},
'pms_position': {'total_qty','avail_qty','base_qty','fill_qty','add_qty','dca_qty','t0_qty',
'avg_cost','realized_t_profit','cushion_pct','cushion_state','pct_of_scale','status'},
'pms_instruction': {'exec_qty','exec_avg_price','status','progress_json'},
'pms_strategy': {'state_json'},
}
if TABLE_PREFIX:
raise ValueError('历史修复仅允许模拟仓')
run_id = plan['run_id'] + ('_ROLLBACK' if rollback else '')
_check_cooldown('proxy')
with get_engine('proxy').begin() as c:
def query(sql, params=None):
sql = map_tables(sql)
assert_single_table(sql)
return c.execute(text(sql), params or {})
done = query("SELECT id FROM pms_op_log WHERE op='history_repair_summary' AND ref=:r FOR UPDATE",
{'r':run_id}).mappings().fetchall()
if done:
return {'ok':True, 'already_applied':True, 'run_id':run_id}
for g in guards:
rows = [dict(r) for r in query(g['sql'],g.get('params')).mappings().fetchall()]
if canonical(rows) != canonical(g['expected']):
raise ValueError('修复前置数据已变化,拒绝写入: '+g['name'])
for item in plan['changes']:
table, fields = item['table'], item['fields']
if table not in allowed or set(fields) - allowed[table] - {'updated_at'}:
raise ValueError('修复列越界')
current = [dict(r) for r in query(f'SELECT * FROM {table} WHERE id=:id FOR UPDATE',item['key']).mappings().fetchall()]
if len(current) != 1 or canonical(current[0]) != canonical(item['before']):
raise ValueError('目标行已变: '+table+':'+str(item['key']))
now = datetime.now().replace(microsecond=0)
for item in plan['changes']:
fields = dict(item['fields'])
fields.setdefault('updated_at',now)
query(f"UPDATE {item['table']} SET "+', '.join(f'{k}=:{k}' for k in fields)+' WHERE id=:row_id',
dict(fields,row_id=item['key']['id']))
after = dict(item['before'],**fields)
query('INSERT INTO pms_op_log (at,op,by_user,ts_code,result,reason,params_json,ref) '
'VALUES (:at,:op,:by,:code,:result,:reason,:params,:ref)',
dict(at=now,op='history_repair_row',by='codex',code=after.get('ts_code'),result='OK',
reason='逐笔账本修复'+('回退' if rollback else ''),
params=canonical(dict(item,after=after)),ref=run_id))
query('INSERT INTO pms_op_log (at,op,by_user,result,reason,params_json,ref) '
'VALUES (:at,:op,:by,:result,:reason,:params,:ref)',
dict(at=now,op='history_repair_summary',by='codex',result='OK',reason='历史修复事务完成',
params=canonical({k:v for k,v in plan.items() if k not in ('changes','allocations','daily')}),ref=run_id))
return {'ok':True,'run_id':run_id,'changed_rows':len(plan['changes'])}
def withdraw_rejected_proposal(old, hard):
"""提议生命周期专用事务。每条语句单表,原状态与 JSON 一起防并发。"""
import json
from datetime import datetime, timezone, timedelta
check = hard['last_accept_check']
stage = check['stage']
if stage not in ('judge', 'system', 'qualification') or check['status'] != 'withdrawn':
raise ValueError('只允许已确认的否决收尾')
encode = lambda v: json.dumps(v, ensure_ascii=False, default=str)
rejected = (check.get('details') or {}).get('rejected') or []
# 历史失败没有保存当时行情时,留空。不得把原提议旧价当作新否决的基线。
evidence = next((r.get('hard_numbers') for r in rejected if r.get('by') == stage and r.get('hard_numbers')), {})
ledger_hard = dict(evidence, proposal_withdrawal={'proposal_id': old['proposal_id'],
'check_at': check['at'], 'reason': check['message']})
now = datetime.now()
at = datetime.fromisoformat(check['at'])
if at.tzinfo is not None:
at = at.astimezone(timezone(timedelta(hours=8))).replace(tzinfo=None)
_check_cooldown('proxy')
with get_engine('proxy').begin() as c:
def query(sql, params):
sql = map_tables(sql)
assert_single_table(sql)
return c.execute(text(sql), params)
n = query("UPDATE pms_proposal SET status='EXPIRED', decided_at=:at, hard_numbers_json=:hn "
"WHERE proposal_id=:pid AND status='WAIT_USER' AND hard_numbers_json=:old",
{'at':now, 'hn':encode(hard), 'pid':old['proposal_id'], 'old':old['hard_numbers_json']}).rowcount
if not n:
return 0
query('INSERT INTO pms_action_ledger (ts_code,decided_at,action,arbiter,verdict,price_at,'
'hard_numbers_json,failed_checks_json,reason,ref_id,outcome_scored) '
'VALUES (:code,:at,:action,:arbiter,:verdict,:price,:hard,:failed,:reason,:ref,0)',
{'code':old['ts_code'], 'at':at, 'action':old['action'],
'arbiter':stage if stage in ('judge','system') else 'rule',
'verdict':'REJECT' if stage in ('judge','system') else 'NOTE',
'price':evidence.get('price') or 0, 'hard':encode(ledger_hard),
'failed':encode(check.get('reasons') or []),
'reason':('提议已撤下:'+check['message'])[:500], 'ref':old['proposal_id']})
return 1
def publish_prepared_proposal(old, candidate, verdict):
"""准备结果与变更审计同成同败。旧确认与后台发布只有一个能赢。"""
import json
from datetime import datetime
encode = lambda v: json.dumps(v, ensure_ascii=False, default=str)
hard = candidate['hard_numbers']
if (hard.get('preparation') or {}).get('status') != 'ready' or not hard.get('consumption_id'):
raise ValueError('准备结果缺少完整依据或消费凭据')
old_hard = old.get('hard_numbers') or {}
audit = dict(hard, previous_proposal={'qty': old['qty'], 'decision': old_hard.get('decision'),
'consumption_id': old_hard.get('consumption_id'), 'proposal_revision': old_hard.get('proposal_revision'),
'judge_verdict': old.get('judge_verdict'), 'judge_reason': old.get('judge_reason')})
_check_cooldown('proxy')
with get_engine('proxy').begin() as c:
def query(sql, params):
sql = map_tables(sql)
assert_single_table(sql)
return c.execute(text(sql), params)
n = query("UPDATE pms_proposal SET qty=:qty,hard_numbers_json=:hn,judge_verdict=:jv,judge_reason=:jr "
"WHERE proposal_id=:pid AND status='WAIT_USER' AND hard_numbers_json=:old",
{'qty':candidate['qty'],'hn':encode(hard),'jv':verdict.get('verdict'),
'jr':(verdict.get('reason') or '')[:500],'pid':old['proposal_id'],'old':old['hard_numbers_json']}).rowcount
if not n:
return 0
query('INSERT INTO pms_action_ledger (ts_code,decided_at,action,arbiter,verdict,price_at,'
'hard_numbers_json,failed_checks_json,reason,ref_id,outcome_scored) '
'VALUES (:code,:at,:action,:arbiter,:verdict,:price,:hard,:failed,:reason,:ref,0)',
{'code':old['ts_code'],'at':datetime.now(),'action':old['action'],'arbiter':'rule',
'verdict':'NOTE','price':float(hard.get('price') or 0),'hard':encode(audit),'failed':'[]',
'reason':'后台完成建议更新,等待人工确认','ref':old['proposal_id']})
return 1
def accept_open_proposal(old, hard, instruction, reason):
"""普通建仓的确认、动作审计、待执行指令同成同败;每条SQL仍严格单表。"""
import json
from datetime import datetime
if old['action'] != 'OPEN' or hard.get('kind') == 'strategy' or int(old['qty']) <= 0:
raise ValueError('只接受有效的普通建仓建议')
encode = lambda v: json.dumps(v, ensure_ascii=False, default=str)
now = datetime.now()
_check_cooldown('proxy')
with get_engine('proxy').begin() as c:
def query(sql, params):
sql = map_tables(sql)
assert_single_table(sql)
return c.execute(text(sql), params)
n = query("UPDATE pms_proposal SET status='ACCEPTED',decided_at=:at,hard_numbers_json=:hn "
"WHERE proposal_id=:pid AND status='WAIT_USER' AND hard_numbers_json=:old "
"AND expire_at>=:at AND qty=:qty",
{'at':now,'hn':encode(hard),'pid':old['proposal_id'],
'old':old['hard_numbers_json'],'qty':int(old['qty'])}).rowcount
if not n:
return False
query('INSERT INTO pms_action_ledger (ts_code,decided_at,action,arbiter,verdict,price_at,'
'hard_numbers_json,failed_checks_json,reason,ref_id,outcome_scored) '
"VALUES (:code,:at,'OPEN','user','PASS',:px,:hn,'[]',:reason,:pid,0)",
{'code':old['ts_code'],'at':now,'px':float(hard.get('price') or 0),
'hn':encode(hard),'reason':reason[:500],'pid':old['proposal_id']})
query('INSERT INTO pms_instruction (instruction_id,origin_type,origin_id,ts_code,action,side,'
'qty,limit_price,window_tdays,status,exec_qty,progress_json,created_at,updated_at) '
"VALUES (:iid,'proposal',:pid,:code,'OPEN','buy',:qty,:price,:window,'PROPOSED',0,:pg,:at,:at)",
{'iid':instruction['id'],'pid':old['proposal_id'],'code':old['ts_code'],
'qty':int(old['qty']),'price':hard.get('price'),'window':instruction['window'],
'pg':encode(instruction['progress']),'at':now})
return True

View File

@ -439,6 +439,13 @@ def list_instructions(*, statuses=None, side=None, ts_code=None, limit: int = 30
return rows return rows
def instruction_buy_stop(instruction_id: str):
# 停止依据留在只追加的动作账本,避免并发的进度更新覆盖 JSON 标记。
return fetch_one("SELECT id, reason, ref_id FROM pms_action_ledger "
"WHERE ref_id = :iid AND action = 'BUY_STOP' AND verdict = 'PASS' "
"ORDER BY id DESC LIMIT 1", {'iid': instruction_id})
def get_instruction(instruction_id: str): def get_instruction(instruction_id: str):
r = fetch_one("SELECT * FROM pms_instruction WHERE instruction_id = :iid", r = fetch_one("SELECT * FROM pms_instruction WHERE instruction_id = :iid",
{"iid": instruction_id}) {"iid": instruction_id})
@ -465,11 +472,16 @@ def update_instruction(instruction_id: str, *, status=None, exec_qty=None, exec_
if progress is not None: if progress is not None:
sets.append("progress_json = :pg") sets.append("progress_json = :pg")
p["pg"] = _dumps(progress) p["pg"] = _dumps(progress)
return execute(f"UPDATE pms_instruction SET {', '.join(sets)} WHERE instruction_id = :iid", p) guard = " AND status IN ('PROPOSED','RULE_PASSED','JUDGE_PASSED','DISPATCHED')" if status == 'DISPATCHED' else ''
# 下发后的旧进度回写不能把已撤销指令复活。真实迟到成交仍由成交入口记账。
return execute(f"UPDATE pms_instruction SET {', '.join(sets)} WHERE instruction_id = :iid" + guard, p)
def add_instruction_exec(instruction_id: str, qty: int) -> int: def add_instruction_exec(instruction_id: str, qty: int) -> int:
return execute("UPDATE pms_instruction SET exec_qty = exec_qty + :q, updated_at = :ts " # 本入口没有成交金额,不能维护均价。新增成交后使旧均价失效,避免历史修复的
# 固定时点均价冒充当前全量均价;原修复金额仍在 progress 与操作审计中可查。
return execute("UPDATE pms_instruction SET exec_avg_price = NULL, "
"exec_qty = exec_qty + :q, updated_at = :ts "
"WHERE instruction_id = :iid", "WHERE instruction_id = :iid",
{"q": int(qty), "iid": instruction_id, "ts": _NOW()}) {"q": int(qty), "iid": instruction_id, "ts": _NOW()})
@ -513,10 +525,34 @@ def get_proposal(proposal_id: str):
return r return r
def decide_proposal(proposal_id: str, status: str) -> int: def revise_pending_proposal(old, candidate, verdict):
return execute('UPDATE pms_proposal SET qty=:qty, hard_numbers_json=:hn, '
'judge_verdict=:jv, judge_reason=:jr WHERE proposal_id=:pid '
"AND status='WAIT_USER' AND hard_numbers_json=:old",
{'qty': candidate['qty'], 'hn': _dumps(candidate['hard_numbers']),
'jv': verdict.get('verdict'), 'jr': (verdict.get('reason') or '')[:500],
'pid': old['proposal_id'], 'old': old['hard_numbers_json']})
def record_proposal_check(old, hard_numbers):
"""仅追加最近一次采纳检查结果,原数量、研判与待确认状态保持。"""
return execute('UPDATE pms_proposal SET hard_numbers_json=:hn WHERE proposal_id=:pid '
"AND status='WAIT_USER' AND hard_numbers_json=:old",
{'hn': _dumps(hard_numbers), 'pid': old['proposal_id'],
'old': old['hard_numbers_json']})
def withdraw_proposal(old, hard_numbers):
"""关闭明确失效的旧建议;数据库层负责状态与拒绝留痕同成同败。"""
from app.db.session import withdraw_rejected_proposal
return withdraw_rejected_proposal(old, hard_numbers)
def decide_proposal(proposal_id: str, status: str, expected_hard=None) -> int:
return execute("UPDATE pms_proposal SET status = :st, decided_at = :ts " return execute("UPDATE pms_proposal SET status = :st, decided_at = :ts "
"WHERE proposal_id = :pid AND status = 'WAIT_USER'", "WHERE proposal_id = :pid AND status = 'WAIT_USER'" +
{"st": status, "pid": proposal_id, "ts": _NOW()}) (' AND hard_numbers_json = :expected' if expected_hard is not None else ''),
{"st": status, "pid": proposal_id, "ts": _NOW(), 'expected': expected_hard})
def expire_proposals(now=None) -> int: def expire_proposals(now=None) -> int:
@ -811,8 +847,13 @@ def upsert_industry(rows: list) -> int:
# ================================================================ pms_plan_snapshot # ================================================================ pms_plan_snapshot
def latest_plan_digest(): def latest_plan_digest(kind=None):
"""最新一份快照的 (plan_date, digest); 没有则 None。判"这份榜变没变"只该拿它比。""" """最新一份快照的 (plan_date, digest); 没有则 None。判"这份榜变没变"只该拿它比。"""
if kind:
r = fetch_one("SELECT plan_date, digest FROM pms_plan_snapshot "
"WHERE JSON_UNQUOTE(JSON_EXTRACT(meta_json, '$.kind')) = :kind "
"ORDER BY id DESC LIMIT 1", {'kind': kind})
else:
r = fetch_one("SELECT plan_date, digest FROM pms_plan_snapshot ORDER BY id DESC LIMIT 1") r = fetch_one("SELECT plan_date, digest FROM pms_plan_snapshot ORDER BY id DESC LIMIT 1")
return (r["plan_date"], r["digest"]) if r else None return (r["plan_date"], r["digest"]) if r else None
@ -837,7 +878,8 @@ def insert_plan_snapshot(*, plan_date, digest, roster, meta=None, n_main=0, n_ob
不产生任何假信号), 换掉的是一整类方向错误, 这笔交换是划算的。 不产生任何假信号), 换掉的是一整类方向错误, 这笔交换是划算的。
""" """
now = fetched_at or _NOW() now = fetched_at or _NOW()
cur = latest_plan_digest() kind = (meta or {}).get('kind')
cur = latest_plan_digest(kind) if kind else latest_plan_digest()
if cur and cur[0] == str(plan_date) and cur[1] == str(digest): if cur and cur[0] == str(plan_date) and cur[1] == str(digest):
return 0 return 0
execute( execute(
@ -857,7 +899,8 @@ def latest_plan_snapshots(limit: int = 2) -> list:
rows = fetch_all( rows = fetch_all(
"SELECT id, plan_date, digest, fetched_ymd, fetched_at, n_main, n_observe, " "SELECT id, plan_date, digest, fetched_ymd, fetched_at, n_main, n_observe, "
" capped_main, capped_obs, roster_json, meta_json " " capped_main, capped_obs, roster_json, meta_json "
"FROM pms_plan_snapshot ORDER BY id DESC LIMIT :n", {"n": max(1, int(limit))}) "FROM pms_plan_snapshot WHERE COALESCE(JSON_UNQUOTE(JSON_EXTRACT(meta_json, '$.kind')), '') "
"NOT IN ('consumed', 'rechecked') ORDER BY id DESC LIMIT :n", {"n": max(1, int(limit))})
return [_snapshot_row(r) for r in rows] return [_snapshot_row(r) for r in rows]
@ -881,20 +924,12 @@ def list_plan_snapshots(*, plan_date=None, limit: int = 50) -> list:
def prune_plan_snapshots(keep: int = 200) -> int: def prune_plan_snapshots(keep: int = 200) -> int:
"""只留最近 keep 份。 """停止按行数删除。保留全部记录,满足至少 120 交易日与未结束引用保留。
单表守卫不许子查询跨表, 所以先查出保留水位的 id 再按 id 删 —— 两条单表语句, 未来若加清理器,必须同时核验交易日水位、未结束提议及持仓引用;不能恢复行数上限。
比一条 `DELETE ... WHERE id NOT IN (SELECT ...)` 干净, 也不会被守卫拦下。 keep 仅为旧调用兼容,当前不删除任何历史。
下限是 **2 份不是 1 份**: 比对天生要两份, 留一份等于把榜单变化永久锁死在"首次"上,
而且页面上看起来一切正常。参数填了 0 或 1 也按 2 算。
""" """
keep = max(2, int(keep or 0))
r = fetch_one("SELECT id FROM pms_plan_snapshot ORDER BY id DESC LIMIT 1 OFFSET :k",
{"k": keep})
if not r:
return 0 return 0
return execute("DELETE FROM pms_plan_snapshot WHERE id <= :id", {"id": int(r["id"])})
def _snapshot_row(r: dict) -> dict: def _snapshot_row(r: dict) -> dict:
@ -1056,3 +1091,20 @@ def list_op_log(*, limit: int = 200) -> list:
for r in rows: for r in rows:
r["params"] = _loads(r.get("params_json"), {}) r["params"] = _loads(r.get("params_json"), {})
return rows return rows
def publish_prepared_proposal(old, candidate, verdict):
from app.db.session import publish_prepared_proposal as publish
return publish(old, candidate, verdict)
def accept_open_proposal(old, hard, instruction, reason):
from app.db.session import accept_open_proposal as accept
return accept(old, hard, instruction, reason)
def accepted_open_instruction(proposal_id):
rows = fetch_all("SELECT instruction_id FROM pms_instruction "
"WHERE origin_type='proposal' AND origin_id=:pid AND action='OPEN' ORDER BY id",
{'pid': proposal_id})
return rows[0]['instruction_id'] if len(rows) == 1 else None

View File

@ -355,6 +355,23 @@ def get_order(instruction_id: str):
{"iid": instruction_id}) {"iid": instruction_id})
def orders_for_fill(*, order_id, broker_order_id=None) -> list:
"""汇总成交的精确归属;包含终态和联调委托,不能按当前模式或状态裁剪。"""
clauses, params = [], {}
if order_id not in (None, ""):
clauses.append("instruction_id = :iid")
params["iid"] = str(order_id)
if broker_order_id not in (None, ""):
clauses.append("broker_order_id = :bid")
params["bid"] = str(broker_order_id)
if not clauses:
raise ValueError("成交缺少可核验的委托身份")
# 最多两行即可识别冲突;一条 SQL 只读本实例出口表。
return fetch_all("SELECT instruction_id, parent_id, ts_code, side, broker_order_id "
"FROM pms_qmt_order WHERE (" + " OR ".join(clauses) +
") ORDER BY instruction_id LIMIT 2", params)
def list_orders(*, statuses=None, parent_id=None, ts_code=None, limit: int = 200) -> list: def list_orders(*, statuses=None, parent_id=None, ts_code=None, limit: int = 200) -> list:
where, p = [], {"n": int(limit)} where, p = [], {"n": int(limit)}
if statuses: if statuses:
@ -372,6 +389,10 @@ def list_orders(*, statuses=None, parent_id=None, ts_code=None, limit: int = 200
return fetch_all(sql, p) return fetch_all(sql, p)
def orders_for_parent(parent_id: str) -> list:
return fetch_all('SELECT * FROM pms_qmt_order WHERE parent_id = :pid ORDER BY id', {'pid': parent_id})
def next_queued(limit: int = 20, side=None) -> list: def next_queued(limit: int = 20, side=None) -> list:
"""取待发委托。按 id 升序 = 先进先发, 保证同一只票的分笔不乱序 (§1「不开第二条连接」 """取待发委托。按 id 升序 = 先进先发, 保证同一只票的分笔不乱序 (§1「不开第二条连接」
是为了避免乱序, 出口这一端也得守住)。""" 是为了避免乱序, 出口这一端也得守住)。"""
@ -391,7 +412,7 @@ def claim_order(instruction_id: str) -> bool:
而不是靠"我们约定只起一个"。 而不是靠"我们约定只起一个"。
""" """
n = execute("UPDATE pms_qmt_order SET status = 'SENDING', updated_at = :ts " n = execute("UPDATE pms_qmt_order SET status = 'SENDING', updated_at = :ts "
"WHERE instruction_id = :iid AND status = 'QUEUED'", "WHERE instruction_id = :iid AND status = 'QUEUED' AND cancel_state = 'NONE'",
{"iid": instruction_id, "ts": _NOW()}) {"iid": instruction_id, "ts": _NOW()})
return bool(n) return bool(n)

View File

@ -349,6 +349,9 @@ def plan_command(cmd: dict) -> dict:
notes.insert(0, f"⚠ 停买入侧有 {len(stop_r['errors'])} 处未成: " notes.insert(0, f"⚠ 停买入侧有 {len(stop_r['errors'])} 处未成: "
+ "; ".join(str(x) for x in stop_r["errors"][:5])) + "; ".join(str(x) for x in stop_r["errors"][:5]))
progress = {"target_amount": result.get("target_amount", 0.0), progress = {"target_amount": result.get("target_amount", 0.0),
'plan_provenance': [{'ts_code': it['ts_code'], 'plan_id': cs.make_plan_id(command_id, i),
**it['plan_provenance']}
for i, it in enumerate(items, 1) if it.get('plan_provenance')],
"planned_amount": result.get("planned_amount", 0.0), "planned_amount": result.get("planned_amount", 0.0),
"done_amount": 0.0, "gap": result.get("gap", 0.0), "done_amount": 0.0, "gap": result.get("gap", 0.0),
"plan_count": len(rows), "deadline": str(deadline), "plan_count": len(rows), "deadline": str(deadline),
@ -756,9 +759,8 @@ def _candidates(view: dict) -> list:
旧表的 target_price 若有则直接用。 旧表的 target_price 若有则直接用。
2. **上游拿不到不回退旧表** —— 候选池宁可为空。那张表在目标架构下没有明确写入方, 2. **上游拿不到不回退旧表** —— 候选池宁可为空。那张表在目标架构下没有明确写入方,
拿它当事实源比没有候选更危险 (沿用「拿不到 ≠ 通过」的纪律)。 拿它当事实源比没有候选更危险 (沿用「拿不到 ≠ 通过」的纪律)。
3. **白名单必须压过计划票** —— planner 只认 score 一把尺子, 而计划的 score 是 200+ 3. 白名单必须压过计划票。规划器显式识别用户点名,计划票继承 selection_rank。
量级 (旧表的 prob_thresh 是 0~1)。白名单是用户点名的票, 故给 max(池内分)+1, 原始分仍保留供展示及旧来源兼容,不能用它重新覆盖质地排序。
写死 1.0 会让点名票沉到池底。
""" """
from app.services import market, plan_feed from app.services import market, plan_feed
held = {x["ts_code"] for x in view["held"]} held = {x["ts_code"] for x in view["held"]}
@ -768,7 +770,7 @@ def _candidates(view: dict) -> list:
or plan_feed.SRC_PLAN_API).strip() or plan_feed.SRC_PLAN_API).strip()
out, seen, noprice, fallback = [], set(), [], [] out, seen, noprice, fallback = [], set(), [], []
def _push(c, score, tag, *, price=None, theme=None): def _push(c, score, tag, *, price=None, theme=None, plan_provenance=None):
if not c or c in held or c in black or c in seen: if not c or c in held or c in black or c in seen:
return return
px, psrc = float(price or 0), "given" px, psrc = float(price or 0), "given"
@ -785,13 +787,17 @@ def _candidates(view: dict) -> list:
# 不参与约束 —— theme 是"传导主题"(事件驱动、天天变、覆盖率约三成), 拿它当行业标签 # 不参与约束 —— theme 是"传导主题"(事件驱动、天天变、覆盖率约三成), 拿它当行业标签
# 会让集中度约束跟着漂, 已于 2026-07-31 明确不再灌行业表 (见 UPSTREAM_PLAN_API.md §6)。 # 会让集中度约束跟着漂, 已于 2026-07-31 明确不再灌行业表 (见 UPSTREAM_PLAN_API.md §6)。
out.append({"ts_code": c, "price": px, "price_source": psrc, "score": float(score or 0), out.append({"ts_code": c, "price": px, "price_source": psrc, "score": float(score or 0),
"sector": industry.get(c), "theme": theme, "src": tag}) "sector": industry.get(c), "theme": theme, "src": tag,
'selection_rank': (plan_provenance or {}).get('selection_rank'),
'plan_provenance': plan_provenance})
if src in (plan_feed.SRC_PLAN_API, plan_feed.SRC_BOTH): if src in (plan_feed.SRC_PLAN_API, plan_feed.SRC_BOTH):
try: try:
sel = plan_feed.candidates(held=held, black=black) sel = plan_feed.candidates(held=held, black=black)
for r in sel["items"]: for r in sel["items"]:
_push(r["ts_code"], r["score"], "plan_api", theme=r.get("theme")) _push(r["ts_code"], r["score"], "plan_api", theme=r.get("theme"),
plan_provenance={k: r.get(k) for k in ('decision', 'consumption_id',
'selection_rank', 'research_rank', 'review_ref', 'research')})
logger.info("[候选池] 上游计划 %s: 排序池 %s → 合格 %s → 取 %d 只 (丢弃 %s)", logger.info("[候选池] 上游计划 %s: 排序池 %s → 合格 %s → 取 %d 只 (丢弃 %s)",
sel.get("date"), sel.get("considered"), sel.get("eligible"), sel.get("date"), sel.get("considered"), sel.get("eligible"),
len(sel["items"]), sel.get("dropped")) len(sel["items"]), sel.get("dropped"))
@ -812,6 +818,10 @@ def _candidates(view: dict) -> list:
for c, d in sp.items(): for c, d in sp.items():
if d.get("white"): if d.get("white"):
_push(c, white_score, "whitelist") _push(c, white_score, "whitelist")
# 已在计划中的点名票也必须提升优先级;保留其研究及消费来源。
for row in out:
if row['ts_code'] == c:
row.update(user_selected=True, score=white_score)
if fallback: if fallback:
logger.info("[候选池] %d 只候选无实时价, 已用昨收定量 (盘前正常): %s", logger.info("[候选池] %d 只候选无实时价, 已用昨收定量 (盘前正常): %s",

View File

@ -34,7 +34,7 @@ _cache: dict = {} # url -> {"at": 时刻, "text": 正文}
def _url_of(cr) -> str | None: def _url_of(cr) -> str | None:
if not isinstance(cr, dict): if not isinstance(cr, dict):
return None return None
u = cr.get("report_url") u = cr.get('report_version_url') or cr.get("report_url")
u = str(u).strip() if u else "" u = str(u).strip() if u else ""
return u if u.startswith(("http://", "https://")) else None return u if u.startswith(("http://", "https://")) else None
@ -106,9 +106,26 @@ def _fail_why(e: Exception, timeout: int) -> str:
return f"{type(e).__name__}: {e}" return f"{type(e).__name__}: {e}"
def get(code: str, *, now=None, timeout: int = TIMEOUT_SEC, getter=None, state_map=None, plan=None) -> dict: def get(code: str, *, now=None, timeout: int = TIMEOUT_SEC, getter=None, state_map=None, plan=None, ref=None) -> dict:
"""页面用的一站式取法。返回固定键: ok / ts_code / url / source / markdown / cached / fetched_at / error。""" """页面用的一站式取法。返回固定键: ok / ts_code / url / source / markdown / cached / fetched_at / error。"""
url, src = report_url_for(code, state_map=state_map, plan=plan) url, src = report_url_for(code, state_map=state_map, plan=plan)
if ref:
import re
from urllib.parse import urlsplit, urlunsplit, urlencode
if not re.fullmatch('[0-9a-f]{64}', ref):
return {'ok': False, 'error': '报告版本标识无效'}
if not url:
from app.repo import pms_repo
for row in pms_repo.list_ledger(ts_code=code, limit=200):
cr = (row.get('hard_numbers') or {}).get('company_review') or {}
if cr.get('review_ref') == ref:
url = _url_of(cr)
if url:
src = 'ledger'
break
if url:
parts = urlsplit(url)
url = urlunsplit((parts.scheme, parts.netloc, parts.path, urlencode({'ref': ref}), ''))
out = {"ok": False, "ts_code": code, "url": url, "source": src, "markdown": "", "cached": False, out = {"ok": False, "ts_code": code, "url": url, "source": src, "markdown": "", "cached": False,
"fetched_at": None, "error": None} "fetched_at": None, "error": None}
if not url: if not url:

View File

@ -140,6 +140,17 @@ def dispatch(*, instruction_id: str, ts_code: str, side: str, qty: int, limit_pr
"""递一手给下游。返回 {ok, ref, mode, note, error}; ok=False 时 executor 不改指令状态。""" """递一手给下游。返回 {ok, ref, mode, note, error}; ok=False 时 executor 不改指令状态。"""
m = mode() m = mode()
try: try:
if str(side).lower() == 'buy':
from app.services.execution_conflicts import buy_blocker
from app.repo import pms_repo
pid = _parent_of(instruction_id, parent_id)
parent = pms_repo.get_instruction(pid)
stopped = pms_repo.instruction_buy_stop(pid)
blocked = ('清仓已终止原买入安排' if stopped or ((parent or {}).get('progress') or {}).get('stopped_by_exit') else buy_blocker(ts_code))
if parent and parent.get('status') not in ('PROPOSED', 'RULE_PASSED', 'JUDGE_PASSED', 'DISPATCHED'):
blocked = '来源买入指令已结束,不再发单'
if blocked:
return {'ok': False, 'ref': None, 'mode': m, 'note': '', 'error': blocked}
if m == MODE_WS: if m == MODE_WS:
return _ws(instruction_id=instruction_id, ts_code=ts_code, side=side, qty=qty, return _ws(instruction_id=instruction_id, ts_code=ts_code, side=side, qty=qty,
limit_price=limit_price, valid_until=valid_until, limit_price=limit_price, valid_until=valid_until,

View File

@ -0,0 +1,147 @@
"""高股息独立候选来源。人工发起,复用后台准备与原子采纳,不参与原主榜扫描。"""
from copy import deepcopy
from datetime import datetime, timezone, timedelta
import logging
import re
import requests
from app.core.plan_revision import fingerprint, basis
from app.core import tradedays as td
from app.services.plan_feed import PlanFeedError
SOURCE = 'dividend'
BJ = timezone(timedelta(hours=8))
logger = logging.getLogger('pms.dividend')
def read(*, code=None):
from app.services import param_store
if code and not re.fullmatch(r'\d{6}\.(SH|SZ|BJ)', code):
raise ValueError('股票代码格式无效')
base = (param_store.get('PMS_PLAN_API_BASE', '') or '').rstrip('/')
if not base:
raise PlanFeedError('高股息研究地址尚未配置')
try:
res = requests.get(base+'/research/dividend/candidates', params={'code':code} if code else {}, timeout=(1,3))
res.raise_for_status()
data = res.json()
now = datetime.now(BJ)
if td.calendar_degraded():
raise ValueError('交易日历暂不可核对')
expected = str(td.prev_trade_day(now.date()))
if data['schema_version'] != 1 or data['source'] != SOURCE or data['data_date'] != expected:
raise ValueError('高股息资料尚未更新到上一交易日')
decision = data['decision']
if (decision.get('source') != SOURCE or decision.get('policy_version') != data.get('policy_version')
or not re.fullmatch(r'dividend_[0-9a-f]{64}', decision['id'])):
raise ValueError('高股息研究来源不完整')
for value in (decision['cutoff_at'], data['checked_at']):
at = datetime.fromisoformat(value.replace('Z','+00:00'))
if at.tzinfo is None or at > now:
raise ValueError('研究检查时间无法核对')
codes = set()
for row in data['rows']:
c = row['candidate']
if (not re.fullmatch(r'\d{6}\.(SH|SZ|BJ)', row['ts_code']) or row['ts_code'] in codes
or (code and row['ts_code'] != code) or c['ts_code'] != row['ts_code']
or c.get('candidate_source') != SOURCE or c.get('decision') != decision
or not isinstance(row.get('eligible'), bool)):
raise ValueError('高股息候选内容无法核对')
codes.add(row['ts_code'])
if row['eligible'] and (c.get('verdict') != '候选' or row.get('reasons')
or not re.fullmatch('[0-9a-f]{64}', str((c.get('dividend_research') or {}).get('ref', '')))):
raise ValueError('高股息候选缺少准入依据')
return data
except PlanFeedError:
raise
except (requests.RequestException, KeyError, TypeError, ValueError) as e:
logger.warning('高股息来源暂不可用: %s', type(e).__name__)
message = str(e) if isinstance(e, ValueError) and not isinstance(e, requests.RequestException) else '高股息研究暂不可用,恢复后可继续'
raise PlanFeedError(message) from e
def candidates(*, held=(), black=(), recheck_code=None, record=True, route_by_verdict=True):
data = read(code=recheck_code)
items, excluded = [], []
for row in data['rows']:
reason = ('已持仓' if row['ts_code'] in held else '在黑名单中' if row['ts_code'] in black
else ';'.join(row['reasons']) if not row['eligible'] else '')
if reason:
excluded.append({'ts_code':row['ts_code'], 'why':reason})
else:
c = deepcopy(row['candidate'])
c['dividend_ref'] = row['research_ref']
c['dividend_policy_version'] = data['policy_version']
items.append(c)
consumption = {'kind':'rechecked' if recheck_code else 'consumed', 'source':SOURCE,
'decision':data['decision'], 'params':{'policy_version':data['policy_version']},
'context':{'held':sorted(held),'black':sorted(black),'recheck_code':recheck_code},
'rank_mode':'code', 'filtered':excluded, 'order':[r['ts_code'] for r in items]}
cid = fingerprint(consumption)
for row in items:
row.update(consumption_id=cid, plan_basis=basis(row))
out = {'items':items, 'decision':data['decision'], 'date':data['data_date'],
'display_only':[], 'filtered':excluded, 'rank_mode':'code', 'consumption':dict(consumption,id=cid)}
if record:
from app.repo import pms_repo
try:
pms_repo.insert_plan_snapshot(plan_date=data['data_date'],digest=cid[:40],roster=items,
meta=out['consumption'],n_main=len(items))
except Exception as e:
logger.exception('高股息消费凭据保存失败')
out['consumption']['error'] = type(e).__name__
for row in items:
row['consumption_error'] = type(e).__name__
return out
def request_preparation(code, research_ref, *, actor):
"""只排入准备,不计算数量或调用模型。确定性编号与唯一键拦重复请求。"""
from app.services import portfolio, command_service, proposal_service as ps, param_store
from app.services.execution_conflicts import buy_blocker
from app.repo import pms_repo
now = datetime.now()
if not td.is_trade_day(now.date()) or now.hour >= 15 or td.calendar_degraded():
raise ValueError('请在交易日收盘前发起,建议当日有效')
if (param_store.get_bool('PMS_GLOBAL_EXEC_HALT',False)
or param_store.get('PMS_AUTONOMY','propose_only') == 'off'
or param_store.get('PMS_OPEN_AUTONOMY','full') == 'off'):
raise ValueError('建仓评估已暂停')
data = read(code=code)
row = next((r for r in data['rows'] if r['ts_code'] == code), None)
if not row or not row['eligible']:
raise ValueError('暂不具备建仓评估条件:'+(';'.join(row['reasons']) if row else '未进入有效研究名单'))
if not research_ref or row['research_ref'] != research_ref:
raise ValueError('研究内容已更新,请刷新后查看')
pid = f"PRP_{td.ymd(now)}_{code.replace('.','')}_OPEN"
old = pms_repo.get_proposal(pid)
if old:
return _existing(old)
stock = command_service.effective_stock_params()
view = portfolio.positions_view()
if any(r['ts_code'] == code for r in view['held']) or (stock.get(code) or {}).get('black'):
raise ValueError('该票已持仓或在黑名单中,不能新建仓')
blocked = buy_blocker(code)
if blocked:
raise ValueError(blocked)
if code in ps._inflight_open_commitments(view, strict=True)['names']:
raise ValueError('该票已有建仓提议或在途买单,请查看现有进度')
hard = {'candidate_source':SOURCE,'dividend_ref':research_ref,'dividend_policy_version':data['policy_version'],
'decision':data['decision'],'requested_by':actor,'requested_at':now.astimezone().isoformat(),
'name':row.get('name'), 'preparation':{'status':'pending','stage':'requested',
'reason':'等待交易时段完成建仓评估'}}
try:
pms_repo.insert_proposal(proposal_id=pid,ts_code=code,action='OPEN',qty=0,hard_numbers=hard,
expire_at=ps.proposal_expire_at(ttl_hours=24),judge_verdict=None,judge_reason='高股息建仓评估待完成')
except Exception:
old = pms_repo.get_proposal(pid)
if old:
return _existing(old)
raise
return {'ok':True,'proposal_id':pid,'preparing':True,'message':'已排入建仓评估,准备完成后可确认'}
def _existing(old):
if old['status'] in ('WAIT_USER','ACCEPTED'):
return {'ok':True,'proposal_id':old['proposal_id'],'already_requested':True,
'message':'已有该票建议,请查看待确认提议或指令进度'}
raise ValueError('该票今日建议已经结束,请先核对原处理结果')

View File

@ -0,0 +1,108 @@
"""统一执行方向检查。只消解既有指令冲突,不重做研究或择时。"""
from app.repo import pms_repo, qmt_repo
LIVE = ('PROPOSED', 'RULE_PASSED', 'JUDGE_PASSED', 'DISPATCHED')
BUY_ACTIONS = ('OPEN', 'FILL', 'ADD', 'DCA')
def buy_blocker(ts_code):
# 查询失败必须抛给调用者,不能当作无冲突。按票查,不受全局列表裁剪影响。
rows = pms_repo.list_instructions(statuses=list(LIVE), side='sell', ts_code=ts_code, limit=500)
for row in rows:
if row.get('action') in ('EXIT', 'TRIM') and int(row.get('qty') or 0) > int(row.get('exec_qty') or 0):
verb = '清仓' if row['action'] == 'EXIT' else '减仓'
return f'该股正在{verb},暂停买入'
return None
def queued_buy_blocker(row):
"""发出前再次检查。异常由通道保留队列等待,不按无冲突继续。"""
if row.get('side') != 'buy':
return None
parent = pms_repo.get_instruction(row.get('parent_id'))
if not parent:
raise RuntimeError('买入来源指令无法核实,暂不发送')
if pms_repo.instruction_buy_stop(row.get('parent_id')) or (parent.get('progress') or {}).get('stopped_by_exit'):
return '清仓已终止原买入安排'
if parent.get('status') not in LIVE:
return '来源买入指令已结束,未发出的委托作废'
return buy_blocker(row['ts_code'])
def enforce_exit(ins):
"""完整清仓停止旧买入。每跳重试,撤单失败不会阻断风控卖出。"""
out = {'ok': True, 'instructions': [], 'plans': [], 'errors': []}
if ins.get('action') != 'EXIT' or ins.get('side') != 'sell':
return out
from app.services import strategy_service
why = '清仓指令已生效,停止该股原有买入安排'
# 先持久化停止依据。即使下游撤单暂时失败、清仓随后成交,也不能恢复原买入。
buys = pms_repo.list_instructions(statuses=list(LIVE), side='buy', ts_code=ins['ts_code'], limit=500)
for buy in buys:
if not pms_repo.instruction_buy_stop(buy['instruction_id']):
if not pms_repo.insert_ledger(ts_code=ins['ts_code'], action='BUY_STOP', arbiter='system',
verdict='PASS', price_at=0, ref_id=buy['instruction_id'], reason=why,
hard_numbers={'exit_instruction_id': ins['instruction_id'],
'qty': buy.get('qty'), 'exec_qty': buy.get('exec_qty')}):
raise RuntimeError('清仓停止依据未写入动作账本')
progress = dict(buy.get('progress') or {})
if not progress.get('stopped_by_exit'):
progress['stopped_by_exit'] = ins['instruction_id']
progress['last_decision'] = {'action': 'WAIT', 'reason': why}
if not pms_repo.update_instruction(buy['instruction_id'], progress=progress):
raise RuntimeError('清仓停止买入依据未写入')
result = strategy_service.cancel_by_code(ins['ts_code'], reason=why)
out.update(result)
# 未解锁与尚未转指令的命令批也要收尾,否则下一跳又生出买单。
try:
plans = pms_repo.list_plans(ts_code=ins['ts_code'], statuses=['PENDING', 'GATED', 'EXECUTING'])
for plan in plans:
if plan.get('action') not in BUY_ACTIONS:
continue
pms_repo.insert_ledger(ts_code=ins['ts_code'], action='CLEANUP', arbiter='system',
verdict='PASS', price_at=0, ref_id=plan['plan_id'],
reason=why, hard_numbers={'exit_instruction_id': ins['instruction_id']})
if not pms_repo.update_plan(plan['plan_id'], status='CANCELLED'):
raise RuntimeError('停止买入批次未写入')
out['plans'].append(plan['plan_id'])
except Exception as exc:
out['ok'] = False
out['errors'].append(str(exc))
return out
def instruction_progress(rows):
"""只读展示。父指令发过单,不代表当前还有未成交委托。"""
from app.services import dispatcher
ws = dispatcher.mode() == 'ws'
for row in rows:
if row.get('status') not in LIVE and row.get('status') != 'CANCELLED':
continue
if not ws:
row['execution_label'] = '影子执行待核对'
continue
try:
orders = qmt_repo.orders_for_parent(row['instruction_id'])
active = [o for o in orders if o.get('status') in qmt_repo.LIVE]
if any(o.get('cancel_state') in ('REQUESTED', 'SENT') for o in active):
label = '撤单处理中'
elif any(o.get('status') not in ('QUEUED', 'SENDING') for o in active):
label = '委托待成交'
elif active:
label = '委托待发送'
else:
reason = ((row.get('progress') or {}).get('last_decision') or {}).get('reason') or ''
if row.get('status') == 'CANCELLED':
label = '已撤销'
elif '可卖量不足' in reason:
label = '等待可卖'
elif '当日配额' in reason:
label = '等待下一批'
elif '暂停买入' in reason:
label = '买入已暂停'
else:
label = '等待执行'
row['execution_label'] = label
except Exception:
row['execution_label'] = '委托状态待核实'
return rows

View File

@ -103,6 +103,10 @@ def materialize_plans(limit: int = 100) -> dict:
or param_store.get_int("PMS_EXEC_WINDOW_TDAYS", 3)) or param_store.get_int("PMS_EXEC_WINDOW_TDAYS", 3))
prog0 = {"deadline": str(p.get("deadline") or ""), "command_id": cid, prog0 = {"deadline": str(p.get("deadline") or ""), "command_id": cid,
"is_command": True, "children": []} "is_command": True, "children": []}
provenance = next((x for x in (cmd.get('progress') or {}).get('plan_provenance', [])
if x.get('plan_id') == p['plan_id']), None)
if provenance:
prog0['plan'] = provenance
if cmd.get("cmd_type") == "LIQUIDATE_ALL": if cmd.get("cmd_type") == "LIQUIDATE_ALL":
# 一键清仓是 danger 级紧急命令, 方案注记写着"紧急, 不做择时优化" —— # 一键清仓是 danger 级紧急命令, 方案注记写着"紧急, 不做择时优化" ——
# 这个语义从前没传到执行层, 紧急清仓照样等开盘半小时、等均价。 # 这个语义从前没传到执行层, 紧急清仓照样等开盘半小时、等均价。
@ -184,6 +188,43 @@ def run_tick(*, now=None, dry_run: bool = False) -> dict:
is_last = tdays_left <= 1 is_last = tdays_left <= 1
try: try:
from app.services import execution_conflicts
if ins.get('action') == 'EXIT' and side == 'sell' and not dry_run:
cleanup = execution_conflicts.enforce_exit(ins)
out['errors'].extend(cleanup.get('errors') or [])
if side == 'buy':
# 上面的清仓可能已撤销本轮列表中的旧买入,不能拿旧列表继续发。
fresh = pms_repo.get_instruction(ins['instruction_id'])
if not fresh or fresh.get('status') not in LIVE:
continue
ins = fresh
prog = dict(fresh.get('progress') or {})
children = list(prog.get('children') or [])
remaining = int(ins['qty']) - int(ins.get('exec_qty') or 0)
if pms_repo.instruction_buy_stop(ins['instruction_id']) or prog.get('stopped_by_exit'):
if not dry_run:
cancelled = cancel_instruction(ins['instruction_id'], reason='清仓已终止原买入安排', arbiter='system')
if not cancelled.get('ok'):
out['errors'].append(cancelled.get('message') or '清仓停止买入尚未完成')
continue
blocked = execution_conflicts.buy_blocker(code)
if blocked:
prog['last_decision'] = {'at': now.strftime('%H:%M'), 'action': 'WAIT', 'reason': blocked}
if not dry_run:
pms_repo.update_instruction(ins['instruction_id'], progress=prog)
out['waited'].append({'instruction_id': ins['instruction_id'], 'code': code, 'reason': blocked})
continue
# 回放与下发是两个任务。出口已成交时,exec_qty 可能还没更新,
# 不能把「已终态、不在途」误当成「父指令还有额度」。
available = _parent_available(ins, children)
if available <= 0:
reason = '父指令额度已由成交或在途委托占用,等待回报入账或撤单确认'
prog['last_decision'] = {'at': now.strftime('%H:%M'), 'action': 'WAIT', 'reason': reason}
if not dry_run:
pms_repo.update_instruction(ins['instruction_id'], progress=prog)
out['waited'].append({'instruction_id': ins['instruction_id'], 'code': code,
'action': 'WAIT', 'reason': reason})
continue
day = market.day_snapshot(code) day = market.day_snapshot(code)
pos = _pos_of(view, code) pos = _pos_of(view, code)
quota = et.daily_quota(remaining, tdays_left, lot=lot_of(code), quota = et.daily_quota(remaining, tdays_left, lot=lot_of(code),
@ -197,7 +238,8 @@ def run_tick(*, now=None, dry_run: bool = False) -> dict:
# 「当日配额已出完」, 当天不再补单, 连 14:45 强制兜底也被挡在这道判断前面, # 「当日配额已出完」, 当天不再补单, 连 14:45 强制兜底也被挡在这道判断前面,
# 要等次日配额清零才继续。这正是 2026-08-19 紧急清仓剩三支拖到次日早盘的根因。 # 要等次日配额清零才继续。这正是 2026-08-19 紧急清仓剩三支拖到次日早盘的根因。
# 只按在途量扣: 可再投放 = 剩余 − 在途, 永不重复扣, 紧急清仓当天会持续补单, # 只按在途量扣: 可再投放 = 剩余 − 在途, 永不重复扣, 紧急清仓当天会持续补单,
# 直到卖完或撞上 T+1 可卖为零 (可卖量那道闸在下面单独兜, 不会超卖/重复下单)。 # 父指令总量另由 _parent_available 限制。可卖量只能保护账户持仓,
# 不能保护某次只卖一半的指令,更不能假定回放已及时更新 exec_qty。
is_urgent = bool(prog.get("urgent")) is_urgent = bool(prog.get("urgent"))
fired_today = (_inflight_today(children, ymd_today) if (is_urgent or is_last) fired_today = (_inflight_today(children, ymd_today) if (is_urgent or is_last)
else _consumed_today(children, ymd_today)) else _consumed_today(children, ymd_today))
@ -234,7 +276,7 @@ def run_tick(*, now=None, dry_run: bool = False) -> dict:
pms_repo.insert_ledger( pms_repo.insert_ledger(
ts_code=code, action=ins.get("action"), arbiter="rule", ts_code=code, action=ins.get("action"), arbiter="rule",
verdict="WARN", price_at=day_ctx.get("price") or 0, verdict="WARN", price_at=day_ctx.get("price") or 0,
hard_numbers={"ref_lock": prog.get("ref_lock"), hard_numbers={**(prog.get('plan') or {}), "ref_lock": prog.get("ref_lock"),
"advice": (prog.get("exec_advice") or {})}, "advice": (prog.get("exec_advice") or {})},
ref_id=ins["instruction_id"], reason=d["ref_drift"]) ref_id=ins["instruction_id"], reason=d["ref_drift"])
except Exception as e: except Exception as e:
@ -246,7 +288,7 @@ def run_tick(*, now=None, dry_run: bool = False) -> dict:
"action": d["action"], "reason": d["reason"]}) "action": d["action"], "reason": d["reason"]})
continue continue
slice_list = et.slice_qty(min(d["qty_hint"], remaining), slices) slice_list = et.slice_qty(min(d["qty_hint"], remaining, available), slices)
qty = slice_list[0] if slice_list else 0 qty = slice_list[0] if slice_list else 0
if side == "sell": if side == "sell":
qty = min(qty, int(pos.get("avail_qty") or 0)) qty = min(qty, int(pos.get("avail_qty") or 0))
@ -304,7 +346,7 @@ def run_tick(*, now=None, dry_run: bool = False) -> dict:
pms_repo.insert_ledger( pms_repo.insert_ledger(
ts_code=code, action=ins.get("action"), arbiter="rule", ts_code=code, action=ins.get("action"), arbiter="rule",
verdict="REJECT", price_at=day_ctx.get("price") or 0, verdict="REJECT", price_at=day_ctx.get("price") or 0,
hard_numbers=gate["hard_numbers"], hard_numbers={**gate["hard_numbers"], **(prog.get('plan') or {})},
failed_checks=gate["failed"], ref_id=ins["instruction_id"], failed_checks=gate["failed"], ref_id=ins["instruction_id"],
reason="规则闸终检未通过 (宁可不动; 同因当日只记一条)") reason="规则闸终检未通过 (宁可不动; 同因当日只记一条)")
prog["gate_reject_logged"] = {"ymd": ymd_today, "key": rej_key} prog["gate_reject_logged"] = {"ymd": ymd_today, "key": rej_key}
@ -361,7 +403,7 @@ def run_tick(*, now=None, dry_run: bool = False) -> dict:
f"出口表与本端不一致") f"出口表与本端不一致")
pms_repo.insert_ledger(ts_code=code, action=ins.get("action"), arbiter="rule", pms_repo.insert_ledger(ts_code=code, action=ins.get("action"), arbiter="rule",
verdict="PASS", price_at=day_ctx.get("price") or 0, verdict="PASS", price_at=day_ctx.get("price") or 0,
hard_numbers={**gate["hard_numbers"], "limit": d["limit_price"], hard_numbers={**gate["hard_numbers"], **(prog.get('plan') or {}), "limit": d["limit_price"],
"mode": res["mode"]}, "mode": res["mode"]},
ref_id=ins["instruction_id"], reason=d["reason"]) ref_id=ins["instruction_id"], reason=d["reason"])
out["fired"].append({"instruction_id": ins["instruction_id"], "code": code, out["fired"].append({"instruction_id": ins["instruction_id"], "code": code,
@ -423,7 +465,7 @@ def sweep_windows(*, now=None) -> dict:
return out return out
def cancel_instruction(instruction_id: str, reason: str = "页面人工撤销") -> dict: def cancel_instruction(instruction_id: str, reason: str = "页面人工撤销", *, arbiter="user") -> dict:
ins = pms_repo.get_instruction(instruction_id) ins = pms_repo.get_instruction(instruction_id)
if not ins: if not ins:
return {"ok": False, "error": "指令不存在"} return {"ok": False, "error": "指令不存在"}
@ -449,8 +491,9 @@ def cancel_instruction(instruction_id: str, reason: str = "页面人工撤销")
except Exception as e: except Exception as e:
logger.warning("撤销指令进度回写失败 %s: %s", instruction_id, e) logger.warning("撤销指令进度回写失败 %s: %s", instruction_id, e)
pms_repo.update_instruction(instruction_id, status=ST_CANCELLED) pms_repo.update_instruction(instruction_id, status=ST_CANCELLED)
pms_repo.insert_ledger(ts_code=ins["ts_code"], action=ins.get("action"), arbiter="user", pms_repo.insert_ledger(ts_code=ins["ts_code"], action=ins.get("action"), arbiter=arbiter,
verdict="REJECT", price_at=0, ref_id=instruction_id, reason=reason) verdict="REJECT", price_at=0, ref_id=instruction_id, reason=reason,
hard_numbers=(ins.get('progress') or {}).get('plan') or {})
return {"ok": True, "downstream": r, "message": f"指令 {instruction_id} 已撤销"} return {"ok": True, "downstream": r, "message": f"指令 {instruction_id} 已撤销"}
@ -466,6 +509,49 @@ def _child_id(instruction_id: str, n: int) -> str:
return f"{instruction_id}_D{n:02d}" return f"{instruction_id}_D{n:02d}"
def _parent_available(ins: dict, children: list) -> int:
"""父指令总量减去已成交量与仍可成交量,不把通道回报当作账本入账。
已成交取父指令与全部出口子单累计成交的较大值,兼容任一方暂时领先。
在途子单再预留尚未成交的数量;终态只释放未成交部分。必须跨日查询,
也必须包含已入出口但没写回 progress 的子单。查询失败由调用方报错,禁止下发。
"""
target = int(ins['qty'])
booked = int(ins.get('exec_qty') or 0)
if dispatcher.mode() != dispatcher.MODE_WS:
return max(0, target - booked)
filled, pending = 0, 0
seen = set()
for order in qmt_repo.orders_for_parent(ins['instruction_id']):
ref = order['instruction_id']
if ref in seen:
raise ValueError('同一父指令的出口子单重复,暂停下发')
seen.add(ref)
qty = int(order['qty'])
done = int(order.get('cum_qty') or 0)
if qty <= 0 or done < 0 or done > qty:
raise ValueError('出口委托数量异常,暂停下发')
status = str(order.get('status') or '').upper()
# FILLED 却缺累计成交数属于不完整回报,不能据此释放整笔额度。
if status == qmt_repo.OS_FILLED:
done = qty
filled += done
if status not in qmt_repo.FINAL:
pending += qty - done
for child in children:
ref = child.get('ref')
if ref in seen:
continue
# 查不到出口的既有下发,或切换模式前的人工委托,保守预留全部数量。
qty = int(child['qty'])
if qty <= 0:
raise ValueError('既有子单数量异常,暂停下发')
pending += qty
if ref:
seen.add(ref)
return max(0, target - max(booked, filled) - pending)
def _consumed_today(children: list, ymd_today: int) -> int: def _consumed_today(children: list, ymd_today: int) -> int:
"""今日已投放量 —— **到期/被撤/被拒且一股没成的分片不算数**。 """今日已投放量 —— **到期/被撤/被拒且一股没成的分片不算数**。

View File

@ -6,7 +6,7 @@
摊薄成本口径 (与 core/cushion.PositionCost 等价, 但数据来自批次表): 摊薄成本口径 (与 core/cushion.PositionCost 等价, 但数据来自批次表):
cum_buy = Σ (剩余数量 + 已核销数量) × 开仓价 cum_buy = Σ (剩余数量 + 已核销数量) × 开仓价
cum_sell = Σ 已核销数量 × 核销均价 cum_sell = Σ 已核销数量 × 开仓价 + 已实现盈亏(金额,避免核销均价舍入误差)
avg_cost = max(0, (cum_buy − cum_sell) / 当前持股数) avg_cost = max(0, (cum_buy − cum_sell) / 当前持股数)
做T利润通过 T0 批次的买卖流水自然摊入上式, 故 **不再另行扣减** realized_t_profit 做T利润通过 T0 批次的买卖流水自然摊入上式, 故 **不再另行扣减** realized_t_profit
(该列仅作展示统计, 重复扣减会把成本做低两次)。 (该列仅作展示统计, 重复扣减会把成本做低两次)。
@ -22,6 +22,7 @@ from app.core import command_spec as cs
from app.core import cushion as cu from app.core import cushion as cu
from app.core import rebuild_check as rbc from app.core import rebuild_check as rbc
from app.core import recon as rc from app.core import recon as rc
from app.core.ledger_repair import net_lot_cost
from app.core import tradedays as td from app.core import tradedays as td
from app.core import ws_codec as wsc from app.core import ws_codec as wsc
from app.repo import downstream_repo, pms_repo, qmt_repo from app.repo import downstream_repo, pms_repo, qmt_repo
@ -339,6 +340,23 @@ def calibrate_fees(*, ymd=None, actual_fee=None) -> dict:
return out return out
def _ws_owner_for_fill(fill: dict):
"""汇总表不能再次入账本 PMS 的 ws 委托。归属不可核验时抛错,禁止猜成外部单。"""
broker_id = (fill.get("raw") or {}).get("qmt_order_id")
owners = qmt_repo.orders_for_fill(order_id=fill.get("order_id"), broker_order_id=broker_id)
if not owners:
return None
if len(owners) != 1:
raise ValueError("委托身份命中多个出口记录")
owner = owners[0]
for field in ("ts_code", "side"):
if str(owner.get(field) or "") != str(fill.get(field) or ""):
raise ValueError(f"汇总成交与出口委托 {field} 不一致")
if broker_id and owner.get("broker_order_id") and str(broker_id) != str(owner["broker_order_id"]):
raise ValueError("汇总成交与出口委托券商编号不一致")
return owner
def replay_fills(*, limit: int = 500) -> dict: def replay_fills(*, limit: int = 500) -> dict:
"""成交回放一跳 = ws 逐笔入账 + trading_order 增量回放 (幂等)。 """成交回放一跳 = ws 逐笔入账 + trading_order 增量回放 (幂等)。
@ -375,6 +393,31 @@ def replay_fills(*, limit: int = 500) -> dict:
out["ok"] = not out["errors"] # 早退也要按 errors 定 ok (ws 那半的错不能吞) out["ok"] = not out["errors"] # 早退也要按 errors 定 ok (ws 那半的错不能吞)
return out return out
# 2026-10-15:155 模拟仓三项差异均来自同一 ws 委托被汇总表再次回放。
# 以出口身份分流,不等逐笔齐全才排除;否则汇总先到或逐笔迟到仍会双记。
external, ws_owned = [], []
t_max = str(state["t"])
for fill in fresh:
key = _fill_key(fill)
try:
owner = _ws_owner_for_fill(fill)
except Exception as e:
out["errors"].append(f"order_id={key} 成交归属核验失败,保留待重试: {type(e).__name__}: {e}")
continue
if owner is None:
external.append(fill)
continue
ft = str(fill.get("done_time") or "")[:19] or t_max
seen[key] = ft
t_max = max(t_max, ft)
ws_owned.append({"order_id": key, "instruction_id": owner["instruction_id"],
"ts_code": fill.get("ts_code"), "qty": fill.get("qty"),
"reason": "本实例 ws 委托,汇总镜像不重复入账"})
out["ws_owned"] = ws_owned
if ws_owned:
logger.info("[回放] %s 笔本实例 ws 委托的汇总镜像跳过,逐笔通道负责入账", len(ws_owned))
fresh = external
try: try:
instrs = _open_instructions() instrs = _open_instructions()
except Exception as e: except Exception as e:
@ -391,7 +434,6 @@ def replay_fills(*, limit: int = 500) -> dict:
by_key.setdefault(str(act.get("order_id")), []).append(act) by_key.setdefault(str(act.get("order_id")), []).append(act)
time_by_key = {_fill_key(f): str(f.get("done_time") or "")[:19] for f in fresh} time_by_key = {_fill_key(f): str(f.get("done_time") or "")[:19] for f in fresh}
booked_codes = set() booked_codes = set()
t_max = str(state["t"])
for key, acts in by_key.items(): for key, acts in by_key.items():
ok_acts = 0 ok_acts = 0
err = None err = None
@ -586,15 +628,13 @@ def recompute_position(ts_code: str) -> dict:
"""由批次表重算持仓数量/摊薄成本/安全垫/垫子峰值。""" """由批次表重算持仓数量/摊薄成本/安全垫/垫子峰值。"""
lots = pms_repo.list_lots(ts_code, status=None, limit=2000) lots = pms_repo.list_lots(ts_code, status=None, limit=2000)
qty = sum(int(l["qty"] or 0) for l in lots) qty = sum(int(l["qty"] or 0) for l in lots)
cum_buy = sum((int(l["qty"] or 0) + int(l["closed_qty"] or 0)) * float(l["open_price"] or 0) net_cost = float(net_lot_cost(lots))
for l in lots)
cum_sell = sum(int(l["closed_qty"] or 0) * float(l["close_avg_price"] or 0) for l in lots)
by_type = {} by_type = {}
for l in lots: for l in lots:
if int(l["qty"] or 0) > 0: if int(l["qty"] or 0) > 0:
by_type[l["lot_type"]] = by_type.get(l["lot_type"], 0) + int(l["qty"]) by_type[l["lot_type"]] = by_type.get(l["lot_type"], 0) + int(l["qty"])
avg_cost = max(0.0, (cum_buy - cum_sell) / qty) if qty > 0 else None avg_cost = max(0.0, net_cost / qty) if qty > 0 else None
px = market.get_price(ts_code) or avg_cost or 0 px = market.get_price(ts_code) or avg_cost or 0
cp = (px / avg_cost - 1.0) if (avg_cost and avg_cost > 0 and px) else None cp = (px / avg_cost - 1.0) if (avg_cost and avg_cost > 0 and px) else None
solid = param_store.get_float("PMS_CUSHION_SOLID", 0.03) solid = param_store.get_float("PMS_CUSHION_SOLID", 0.03)

View File

@ -186,7 +186,9 @@ def company_view(st):
"line": f"质地{cr.get('overall')}(回报{g.get('回报与护城河') or '缺'}、盈余{g.get('盈余质量与财务安全') or '缺'}、成长{g.get('成长与含金量') or '缺'})" "line": f"质地{cr.get('overall')}(回报{g.get('回报与护城河') or '缺'}、盈余{g.get('盈余质量与财务安全') or '缺'}、成长{g.get('成长与含金量') or '缺'})"
f",估值{cr.get('valuation') or '无'}" + (f",置信{cr['confidence']}" if cr.get("confidence") else ""), f",估值{cr.get('valuation') or '无'}" + (f",置信{cr['confidence']}" if cr.get("confidence") else ""),
"invalidation": cr.get("invalidation"), "doubt_hard": bool(cr.get("doubt_hard")), "invalidation": cr.get("invalidation"), "doubt_hard": bool(cr.get("doubt_hard")),
"report_url": cr.get("report_url"), "text": (st or {}).get("company_review_text")} "report_url": cr.get("report_version_url") or cr.get("report_url"),
"text": (st or {}).get("company_review_text"), 'company_review': cr,
**{k: st.get(k) for k in ('decision', 'research', 'review_ref', 'observation_at', 'observation_scope')}}
def ref_target_view(st): def ref_target_view(st):
@ -237,6 +239,8 @@ def entry_view(ts_code: str) -> dict:
hn = hit.get("hard_numbers") or {} hn = hit.get("hard_numbers") or {}
st = hn.get("logic_state") if isinstance(hn.get("logic_state"), dict) else {} st = hn.get("logic_state") if isinstance(hn.get("logic_state"), dict) else {}
return {"basis": hn.get("basis"), "logic": list(hn.get("logic") or [])[:3], return {"basis": hn.get("basis"), "logic": list(hn.get("logic") or [])[:3],
**{k: hn.get(k) for k in ('decision', 'research', 'review_ref', 'company_review',
'consumption_id', 'execution_rank', 'priority_reason')},
"verdict": hn.get("verdict"), "logic_state_at_entry": st.get("state"), "verdict": hn.get("verdict"), "logic_state_at_entry": st.get("state"),
"decided_at": str(hit.get("decided_at") or "")[:16], "decided_at": str(hit.get("decided_at") or "")[:16],
"arbiter": hit.get("arbiter"), "reason": str(hit.get("reason") or "")[:200], "arbiter": hit.get("arbiter"), "reason": str(hit.get("reason") or "")[:200],

View File

@ -40,6 +40,7 @@ SECRET_KEYS = ("PMS_QMT_SIGN_SEED_HEX", "PMS_QMT_PEER_PUBKEY_B64", "PMS_SESSION_
# 运行态开关: key -> (默认值, 类型, 说明) # 运行态开关: key -> (默认值, 类型, 说明)
RUNTIME_EXTRA = { RUNTIME_EXTRA = {
'PMS_PLAN_VERSION_RECHECK': (False, bool, '自主建仓采纳前核验计划版本;新版发布与留痕验收后开启,当前不可核验时暂停采纳'),
"PMS_GLOBAL_BUY_HALT": (False, bool, "全局暂停买入 (HALT_BUY 命令置位)"), "PMS_GLOBAL_BUY_HALT": (False, bool, "全局暂停买入 (HALT_BUY 命令置位)"),
"PMS_GLOBAL_EXEC_HALT": (False, bool, "全局暂停执行"), "PMS_GLOBAL_EXEC_HALT": (False, bool, "全局暂停执行"),
"PMS_BRAKE_UNTIL": (0, int, "组合刹车解除日 YYYYMMDD, 0=未刹车"), "PMS_BRAKE_UNTIL": (0, int, "组合刹车解除日 YYYYMMDD, 0=未刹车"),

View File

@ -204,7 +204,10 @@ def _company_review_or_none(v):
"invalidation": _text_or_none(v.get("invalidation")), "antithesis": _text_or_none(v.get("antithesis")), "invalidation": _text_or_none(v.get("invalidation")), "antithesis": _text_or_none(v.get("antithesis")),
"catalyst": _text_or_none(v.get("catalyst")), "brain_status": _text_or_none(v.get("brain_status")), "catalyst": _text_or_none(v.get("catalyst")), "brain_status": _text_or_none(v.get("brain_status")),
"ran_at": _text_or_none(v.get("ran_at")), "age_days": _int_or_none(v.get("age_days")), "ran_at": _text_or_none(v.get("ran_at")), "age_days": _int_or_none(v.get("age_days")),
"report_url": _text_or_none(v.get("report_url"))} "report_url": _text_or_none(v.get("report_url")),
**{k: v.get(k) for k in ('review_ref', 'report_version_url', 'report_ran_at',
'period_fi', 'period_rf', 'qual', 'n_materials', 'unknown_n',
'numbers_unmatched', 'expectation', 'cycle', 'thesis_lens_refs')}}
def _industry_catalyst_or_none(v, limit=3): def _industry_catalyst_or_none(v, limit=3):
@ -337,11 +340,14 @@ def _rows(raw, bucket: str) -> list:
"pointed": (bool(it.get("pointed")) if it.get("pointed") is not None else None), "pointed": (bool(it.get("pointed")) if it.get("pointed") is not None else None),
"rank_axis": _text_or_none(it.get("rank_axis")), "rank_axis": _text_or_none(it.get("rank_axis")),
"rank_old": _int_or_none(it.get("rank_old")), "rank_old": _int_or_none(it.get("rank_old")),
"research_rank": _int_or_none(it.get('research_rank')),
"research": it.get('research') if isinstance(it.get('research'), dict) else None,
"review_ref": _text_or_none(it.get('review_ref')),
}) })
return out return out
def parse_plan(payload, *, requested=None) -> dict: def parse_plan(payload, *, requested=None, allow_empty=False) -> dict:
"""应答 → 内部结构。缺 date 或两档全空都算变形 (抛 PlanFeedError)。 """应答 → 内部结构。缺 date 或两档全空都算变形 (抛 PlanFeedError)。
requested: 本次实际发出的 {top, obs_top} (缺省按上游签名的默认值 20/10 算)。 requested: 本次实际发出的 {top, obs_top} (缺省按上游签名的默认值 20/10 算)。
@ -354,8 +360,10 @@ def parse_plan(payload, *, requested=None) -> dict:
raise PlanFeedError("应答缺 date —— 判不了新鲜度, 按取不到处理") raise PlanFeedError("应答缺 date —— 判不了新鲜度, 按取不到处理")
main = _rows(payload.get("main"), BUCKET_MAIN) main = _rows(payload.get("main"), BUCKET_MAIN)
observe = _rows(payload.get("observe"), BUCKET_OBSERVE) observe = _rows(payload.get("observe"), BUCKET_OBSERVE)
if not main and not observe: if not main and not observe and not allow_empty:
raise PlanFeedError(f"计划 {date} 主榜与观察档都是空的") raise PlanFeedError(f"计划 {date} 主榜与观察档都是空的")
state = dict(payload.get('refresh_status') or {})
state['pending_codes'] = [normalize_code(c) for c in state.get('pending_codes') or []]
counts = payload.get("counts") if isinstance(payload.get("counts"), dict) else {} counts = payload.get("counts") if isinstance(payload.get("counts"), dict) else {}
req = dict(requested or {}) req = dict(requested or {})
req_top = _int_or_none(req.get("top")) req_top = _int_or_none(req.get("top"))
@ -368,6 +376,8 @@ def parse_plan(payload, *, requested=None) -> dict:
themes[r["ts_code"]] = r["theme"] themes[r["ts_code"]] = r["theme"]
return { return {
"date": date, "date": date,
**{k: payload.get(k) for k in ('schema_version', 'decision', 'traceability')},
'refresh_status': state,
# 计划版本与生成时刻 (2026-09-02 起上游下发)。同一个 date 的计划会被重算多版, # 计划版本与生成时刻 (2026-09-02 起上游下发)。同一个 date 的计划会被重算多版,
# 这两项是上游自己的版本戳; 旧版应答没有, 缺就是 None (名册快照那套指纹照旧管用)。 # 这两项是上游自己的版本戳; 旧版应答没有, 缺就是 None (名册快照那套指纹照旧管用)。
"plan_version": _text_or_none(payload.get("plan_version")), "plan_version": _text_or_none(payload.get("plan_version")),
@ -505,6 +515,10 @@ def select_candidates(plan: dict, *, held=(), black=(), top_n: int = 30, tiers=N
dropped = {"held": 0, "black": 0, "tier": 0, "score": 0, "sources": 0, "upside": 0, dropped = {"held": 0, "black": 0, "tier": 0, "score": 0, "sources": 0, "upside": 0,
"st": 0, "theme": 0, "dup": 0, "capped": 0, "display": 0} "st": 0, "theme": 0, "dup": 0, "capped": 0, "display": 0}
passed, seen, per_theme, st_unknown, display_only = [], set(), {}, [], [] passed, seen, per_theme, st_unknown, display_only = [], set(), {}, [], []
filtered = []
def drop(reason, code):
dropped[reason] += 1
filtered.append({'ts_code': code, 'reason': reason})
# 排序: 默认按分数降序、同分按 rank 升序 (与 2026-09-11 之前逐字相同)。开了按质地排序后, 先按 # 排序: 默认按分数降序、同分按 rank 升序 (与 2026-09-11 之前逐字相同)。开了按质地排序后, 先按
# 基本面立场分桶 (质地看多的桶排在前) 再按分数, 在主题限额与截断之前生效; 技术面不参与排序。 # 基本面立场分桶 (质地看多的桶排在前) 再按分数, 在主题限额与截断之前生效; 技术面不参与排序。
# 2026-09-17 工作包乙: 上游是质地轴且开了按上游名次排时, 直接按上游名次升序 (同名次原始分降序), # 2026-09-17 工作包乙: 上游是质地轴且开了按上游名次排时, 直接按上游名次升序 (同名次原始分降序),
@ -513,28 +527,28 @@ def select_candidates(plan: dict, *, held=(), black=(), top_n: int = 30, tiers=N
mode = _rank_mode(plan, rank_by_upstream, rank_by_quality) mode = _rank_mode(plan, rank_by_upstream, rank_by_quality)
if mode == "upstream": if mode == "upstream":
def _sort_key(x): def _sort_key(x):
return (x.get("rank") or 10 ** 9, -(x.get("score") or 0.0)) return (x.get('research_rank') or x.get("rank") or 10 ** 9, -(x.get("score") or 0.0), x['ts_code'])
elif rank_by_quality: elif rank_by_quality:
def _sort_key(x): def _sort_key(x):
return (0 if _fund_stance_of(x) == "看多" else 1, return (0 if _fund_stance_of(x) == "看多" else 1,
-(x.get("score") or 0.0), x.get("rank") or 10 ** 9) -(x.get("score") or 0.0), x.get("rank") or 10 ** 9, x['ts_code'])
else: else:
def _sort_key(x): def _sort_key(x):
return (-(x.get("score") or 0.0), x.get("rank") or 10 ** 9) return (-(x.get("score") or 0.0), x.get("rank") or 10 ** 9, x['ts_code'])
for r in sorted(pool, key=_sort_key): for r in sorted(pool, key=_sort_key):
c = r["ts_code"] c = r["ts_code"]
if c in seen: if c in seen:
dropped["dup"] += 1 drop('dup', c)
continue continue
seen.add(c) seen.add(c)
if c in held: if c in held:
dropped["held"] += 1 drop('held', c)
continue continue
if c in black: if c in black:
dropped["black"] += 1 drop('black', c)
continue continue
if route_by_verdict and r.get("verdict") == VERDICT_DISPLAY: if route_by_verdict and r.get("verdict") == VERDICT_DISPLAY:
dropped["display"] += 1 # 上游判为仅展示: 不进池, 单独列出让人看得见 drop('display', c)
# 带上判决依据: 仅展示至少有三种来路 (差一个当日涨幅、吸筹没到确认线、 # 带上判决依据: 仅展示至少有三种来路 (差一个当日涨幅、吸筹没到确认线、
# 被昨夜坏信号一票否决), 三者处置完全不同。只记代码的话, 下游只能对所有 # 被昨夜坏信号一票否决), 三者处置完全不同。只记代码的话, 下游只能对所有
# 仅展示的票写同一句话, 人看不出哪只该继续盯。 # 仅展示的票写同一句话, 人看不出哪只该继续盯。
@ -545,30 +559,31 @@ def select_candidates(plan: dict, *, held=(), black=(), top_n: int = 30, tiers=N
if not nm: if not nm:
st_unknown.append(c) # 没名字判不了, 留着但要让人知道 st_unknown.append(c) # 没名字判不了, 留着但要让人知道
elif is_st(nm): elif is_st(nm):
dropped["st"] += 1 drop('st', c)
continue continue
if tiers and r.get("tier") is not None and r["tier"] not in tiers: if tiers and r.get("tier") is not None and r["tier"] not in tiers:
dropped["tier"] += 1 drop('tier', c)
continue continue
if min_score is not None and (r.get("score") or 0.0) < min_score: if min_score is not None and (r.get("score") or 0.0) < min_score:
dropped["score"] += 1 drop('score', c)
continue continue
if min_sources and (r.get("n_sources") or 0) < min_sources: if min_sources and (r.get("n_sources") or 0) < min_sources:
dropped["sources"] += 1 drop('sources', c)
continue continue
if min_upside is not None and (r.get("upside") or 0.0) < min_upside: if min_upside is not None and (r.get("upside") or 0.0) < min_upside:
dropped["upside"] += 1 drop('upside', c)
continue continue
if theme_cap > 0: if theme_cap > 0 and r.get('theme'):
t = r.get("theme") or "(无主题)" t = r['theme']
if per_theme.get(t, 0) >= theme_cap: if per_theme.get(t, 0) >= theme_cap:
dropped["theme"] += 1 drop('theme', c)
continue continue
per_theme[t] = per_theme.get(t, 0) + 1 per_theme[t] = per_theme.get(t, 0) + 1
passed.append(r) passed.append(r)
n = max(0, int(top_n or 0)) or len(passed) n = max(0, int(top_n or 0)) or len(passed)
dropped["capped"] = max(0, len(passed) - n) dropped["capped"] = max(0, len(passed) - n)
filtered.extend({'ts_code': r['ts_code'], 'reason': 'capped'} for r in passed[n:])
items = [{"ts_code": r["ts_code"], "name": r["name"], "score": r.get("score") or 0.0, items = [{"ts_code": r["ts_code"], "name": r["name"], "score": r.get("score") or 0.0,
"sector": r.get("theme"), "theme": r.get("theme"), "tier": r.get("tier"), "sector": r.get("theme"), "theme": r.get("theme"), "tier": r.get("tier"),
"heat": r.get("heat"), "upside": r.get("upside"), "rank": r.get("rank"), "heat": r.get("heat"), "upside": r.get("upside"), "rank": r.get("rank"),
@ -593,9 +608,14 @@ def select_candidates(plan: dict, *, held=(), black=(), top_n: int = 30, tiers=N
"company_gate": r.get("company_gate"), "company_gate": r.get("company_gate"),
# 排序轴四键 (2026-09-17 工作包乙): 原样透传给动作引擎与提议卡, 缺就是 None。 # 排序轴四键 (2026-09-17 工作包乙): 原样透传给动作引擎与提议卡, 缺就是 None。
"quality_band": r.get("quality_band"), "pointed": r.get("pointed"), "quality_band": r.get("quality_band"), "pointed": r.get("pointed"),
"rank_axis": r.get("rank_axis"), "rank_old": r.get("rank_old")} "rank_axis": r.get("rank_axis"), "rank_old": r.get("rank_old"),
**{k: r.get(k) for k in ('research_rank', 'research', 'review_ref')}}
for r in passed[:n]] for r in passed[:n]]
for i, item in enumerate(items, 1):
item.update(selection_rank=i, decision=plan.get('decision'),
refresh_status=plan.get('refresh_status'))
return {"date": plan.get("date"), "considered": len(pool), "eligible": len(passed), return {"date": plan.get("date"), "considered": len(pool), "eligible": len(passed),
'filtered': filtered, 'decision': plan.get('decision'),
"items": items, "dropped": dropped, "st_unknown": st_unknown, "items": items, "dropped": dropped, "st_unknown": st_unknown,
"display_only": display_only, "rank_mode": mode, "display_only": display_only, "rank_mode": mode,
"tier_complete": _tier_complete(pool, tiers)} "tier_complete": _tier_complete(pool, tiers)}
@ -806,6 +826,11 @@ def parse_logic_states(payload) -> dict:
# 公司深度两键随状态回 (2026-09-09 接入方案): 持仓页"证据还在不在"旁显示质地与失效条件。 # 公司深度两键随状态回 (2026-09-09 接入方案): 持仓页"证据还在不在"旁显示质地与失效条件。
st["company_review"] = _company_review_or_none(it.get("company_review")) st["company_review"] = _company_review_or_none(it.get("company_review"))
st["company_review_text"] = _text_or_none(it.get("company_review_text")) st["company_review_text"] = _text_or_none(it.get("company_review_text"))
st['decision'] = it.get('decision_version') or (payload or {}).get('decision_version')
st['observation_at'] = it.get('observation_at')
st['observation_scope'] = it.get('observation_scope')
st['research'] = it.get('research')
st['review_ref'] = it.get('review_ref')
out[code] = st out[code] = st
return out return out
@ -844,7 +869,7 @@ def get_plan(*, force: bool = False, date=None) -> dict:
now = time.time() now = time.time()
with _lock: with _lock:
fresh_hit = (not force and _cache["key"] == key and _cache["plan"] is not None fresh_hit = (not force and _cache["key"] == key and _cache["plan"] is not None
and now - _cache["at"] < max(1, p["cache_sec"])) and now - _cache["at"] < min(300, max(1, p["cache_sec"])))
if fresh_hit: if fresh_hit:
return _cache["plan"] return _cache["plan"]
if (not force and _cache["key"] == key and _cache["error"] if (not force and _cache["key"] == key and _cache["error"]
@ -876,6 +901,36 @@ def get_plan(*, force: bool = False, date=None) -> dict:
return plan return plan
def read_current_plan(*, code=None):
"""采纳只读最新完整发布版,限时取数,不写接收快照或行业映射。"""
p = _params()
if code is None:
plan = fetch(base=p['base'], path=p['path'], timeout=min(3, max(1, p['timeout'])),
extra_params=build_query(p))
else:
# 不能回退整榜下载:那会把采纳重新变成慢请求。旧桥须先升级兼容接口。
import requests
try:
r = requests.get(p['base'].rstrip('/') + '/' + p['path'].strip('/') + '/check',
params={'code': code}, timeout=(1, min(3, max(1, p['timeout']))))
r.raise_for_status()
payload = r.json()
if (not isinstance(payload, dict) or normalize_code(payload.get('check_code')) != code
or not isinstance(payload.get('found'), bool)
or not (payload.get('decision') or {}).get('id')
or not all(isinstance(payload.get(b), list) for b in ('main', 'observe'))):
raise ValueError('逐票核验应答不完整')
rows = payload['main'] + payload['observe']
if (len(rows) != int(payload['found']) or
any(normalize_code(row.get('code')) != code for row in rows)):
raise ValueError('逐票核验身份不一致')
plan = parse_plan(payload, allow_empty=True)
except Exception as e:
raise PlanFeedError('暂时无法核对最新资料,本次未采纳,请稍后重试') from e
assert_fresh(plan, max_stale_tdays=p['stale_tdays'])
return plan
def invalidate(): def invalidate():
with _lock: with _lock:
_cache.update({"at": 0.0, "key": None, "plan": None, "error": None}) _cache.update({"at": 0.0, "key": None, "plan": None, "error": None})
@ -904,6 +959,15 @@ def _sync_themes_quiet(plan: dict) -> dict:
# ================================================================ 名册快照与榜单变化 # ================================================================ 名册快照与榜单变化
def _received_digest(plan: dict, roster=None) -> str:
"""写入与页面比对共用收到计划的身份,旧数据继续使用名册指纹。"""
if plan.get('decision'):
from app.core.plan_revision import fingerprint
return fingerprint({'received': plan['decision'], 'requested': plan.get('requested')})[:40]
from app.core import plan_diff as pdf
return pdf.digest_of(pdf.roster_of(plan) if roster is None else roster)
def snapshot(plan: dict, *, keep: int = 200, rank_mode=None) -> dict: def snapshot(plan: dict, *, keep: int = 200, rank_mode=None) -> dict:
"""把这一份计划的名册落进 pms_plan_snapshot。 """把这一份计划的名册落进 pms_plan_snapshot。
@ -913,11 +977,13 @@ def snapshot(plan: dict, *, keep: int = 200, rank_mode=None) -> dict:
from app.core import plan_diff as pdf from app.core import plan_diff as pdf
from app.repo import pms_repo from app.repo import pms_repo
roster = pdf.roster_of(plan) roster = pdf.roster_of(plan)
digest = pdf.digest_of(roster) digest = _received_digest(plan, roster)
meta = {k: plan.get(k) for k in ("counts", "returned", "requested", "funnel", meta = {k: plan.get(k) for k in ("counts", "returned", "requested", "funnel",
"theme_cap", "heat_date", "market_snapshot_days", "theme_cap", "heat_date", "market_snapshot_days",
"age_tdays", "url", "age_tdays", "url",
"plan_source", "snapshot_generated_at", "gate_on")} "plan_source", "snapshot_generated_at", "gate_on",
"decision", "traceability")}
meta['kind'] = 'received'
# 排序模式 (2026-09-17 工作包乙): 让选股系统周报按它还原当天交付名单的序。旧调用没传即不写。 # 排序模式 (2026-09-17 工作包乙): 让选股系统周报按它还原当天交付名单的序。旧调用没传即不写。
if rank_mode is not None: if rank_mode is not None:
meta["rank_mode"] = rank_mode meta["rank_mode"] = rank_mode
@ -929,7 +995,8 @@ def snapshot(plan: dict, *, keep: int = 200, rank_mode=None) -> dict:
capped_main=bool(truncated.get("main")), capped_obs=bool(truncated.get("observe"))) capped_main=bool(truncated.get("main")), capped_obs=bool(truncated.get("observe")))
out = {"digest": digest, "rows": len(roster), "stored": bool(n)} out = {"digest": digest, "rows": len(roster), "stored": bool(n)}
if n: if n:
out["pruned"] = pms_repo.prune_plan_snapshots(keep=keep) # 停用按行数清理:盘中修订会把 200 行很快用尽。归档前保留全部历史及引用。
out["pruned"] = 0
logger.info("[上游计划] 名册快照已落: %s digest=%s (%d 只)", logger.info("[上游计划] 名册快照已落: %s digest=%s (%d 只)",
plan.get("date"), digest[:10], len(roster)) plan.get("date"), digest[:10], len(roster))
return out return out
@ -1017,7 +1084,7 @@ def preview_changes(plan: dict, *, held=None, rank_jump=None, tail_guard=None) -
curr_roster = pdf.roster_of(plan) curr_roster = pdf.roster_of(plan)
out["stored"] = ({k: prev.get(k) for k in ("id", "plan_date", "digest", "fetched_at")} out["stored"] = ({k: prev.get(k) for k in ("id", "plan_date", "digest", "fetched_at")}
if prev else None) if prev else None)
out["same_as_stored"] = bool(prev and prev["digest"] == pdf.digest_of(curr_roster)) out["same_as_stored"] = bool(prev and prev["digest"] == _received_digest(plan, curr_roster))
try: try:
tr = plan.get("truncated") or {} tr = plan.get("truncated") or {}
out["diff"] = _diff_against(prev, curr_roster, curr_date=plan.get("date"), out["diff"] = _diff_against(prev, curr_roster, curr_date=plan.get("date"),
@ -1053,7 +1120,7 @@ def changes(*, held=None, rank_jump=None, tail_guard=None) -> dict:
curr_digest = None curr_digest = None
try: # 先确保手上这份已落库 (缓存命中时是个空操作) try: # 先确保手上这份已落库 (缓存命中时是个空操作)
plan = get_plan() plan = get_plan()
curr_digest = pdf.digest_of(pdf.roster_of(plan)) curr_digest = _received_digest(plan)
except PlanFeedError as e: except PlanFeedError as e:
out["hint"] = f"上游计划取不到, 只能拿库里的历史快照比: {e}" out["hint"] = f"上游计划取不到, 只能拿库里的历史快照比: {e}"
except Exception as e: except Exception as e:
@ -1109,7 +1176,8 @@ def snapshot_log(*, plan_date=None, limit: int = 50) -> dict:
# ================================================================ 对外: 候选与状态 # ================================================================ 对外: 候选与状态
def candidates(*, held=(), black=(), route_by_verdict: bool = False) -> dict: def candidates(*, held=(), black=(), route_by_verdict: bool = False, force=False,
record=True, recheck_code=None, plan_override=None) -> dict:
"""参数驱动的候选清单 (不含价格 —— 价格由调用方用 market.get_price 现取)。 """参数驱动的候选清单 (不含价格 —— 价格由调用方用 market.get_price 现取)。
route_by_verdict 默认 False: 命令驱动建仓 (command_service._candidates) 不传, 于是用户 route_by_verdict 默认 False: 命令驱动建仓 (command_service._candidates) 不传, 于是用户
@ -1119,21 +1187,53 @@ def candidates(*, held=(), black=(), route_by_verdict: bool = False) -> dict:
显式传 True。要让命令驱动也按判决过滤, 改这里的调用方, 不改默认值。 显式传 True。要让命令驱动也按判决过滤, 改这里的调用方, 不改默认值。
""" """
p = _params() p = _params()
plan = get_plan() plan = plan_override if plan_override is not None else (get_plan(force=force) if force else get_plan())
route = bool(route_by_verdict) route = bool(route_by_verdict)
out = select_candidates(plan, held=held, black=black, top_n=p["top_n"], tiers=p["tiers"], out = select_candidates(plan, held=held, black=black, top_n=0 if recheck_code else p["top_n"], tiers=p["tiers"],
include_observe=p["include_observe"], include_observe=p["include_observe"],
min_score=(p["min_score"] or None), min_score=(p["min_score"] or None),
min_sources=p["min_sources"], min_sources=p["min_sources"],
min_upside=(p["min_upside"] or None), min_upside=(p["min_upside"] or None),
theme_cap=p["theme_cap_local"], exclude_st=p["exclude_st"], theme_cap=0 if recheck_code else p["theme_cap_local"], exclude_st=p["exclude_st"],
route_by_verdict=route, route_by_verdict=route,
rank_by_quality=p["rank_by_quality"], rank_by_quality=p["rank_by_quality"],
rank_by_upstream=p["rank_by_upstream"], rank_by_upstream=p["rank_by_upstream"],
observe_if_fund_bull=p["observe_if_fund_bull"]) observe_if_fund_bull=p["observe_if_fund_bull"])
out['refresh_status'] = plan.get('refresh_status')
out["age_tdays"] = plan.get("age_tdays") out["age_tdays"] = plan.get("age_tdays")
out["theme_cap"] = plan.get("theme_cap") out["theme_cap"] = plan.get("theme_cap")
out["route_by_verdict"] = route out["route_by_verdict"] = route
from app.core.plan_revision import fingerprint, basis
# 实际参数与组合上下文参与消费指纹;来源地址等接入信息不进入业务参数。
effective = {k: p[k] for k in ('top_n', 'tiers', 'include_observe', 'min_score',
'min_sources', 'min_upside', 'theme_cap_local', 'exclude_st', 'rank_by_quality',
'rank_by_upstream', 'observe_if_fund_bull')}
context = {'held': sorted(held), 'black': sorted(black), 'route_by_verdict': route,
'recheck_code': recheck_code}
if recheck_code:
out['items'] = [r for r in out['items'] if r['ts_code'] == recheck_code]
consumption = {'kind': 'rechecked' if recheck_code else 'consumed', 'decision': plan.get('decision'),
'params': effective, 'context': context, 'rank_mode': out['rank_mode'],
'filtered': out['filtered'], 'order': [r['ts_code'] for r in out['items']]}
cid = fingerprint(consumption)
for row in out['items']:
row['consumption_id'] = cid
row['plan_basis'] = basis(row)
out['consumption'] = dict(consumption, id=cid)
if record:
from app.repo import pms_repo
try:
pms_repo.insert_plan_snapshot(plan_date=plan['date'], digest=cid[:40],
roster=out['items'], meta=dict(consumption, id=cid),
n_main=sum(r.get('bucket') == BUCKET_MAIN for r in out['items']),
n_observe=sum(r.get('bucket') != BUCKET_MAIN for r in out['items']),
capped_main=False, capped_obs=False)
except Exception as e:
# 记录失败可展示,不能把无凭据候选变成自主指令。
logger.exception('候选消费记录保存失败 code=%s decision=%s', recheck_code, (plan.get('decision') or {}).get('id'))
out['consumption']['error'] = type(e).__name__
for row in out['items']:
row['consumption_error'] = type(e).__name__
return out return out

View File

@ -0,0 +1,341 @@
"""后台准备建议;人工采纳只做限时、无模型的执行检查。"""
from datetime import datetime, timedelta
import logging
import re
from app.core.plan_revision import compare, fingerprint, portfolio_context, confirmation_revision
from app.services.plan_feed import PlanFeedError
logger = logging.getLogger('pms.proposal.prepare')
def current_basis(hard, code, proposal_id=None, *, record=True):
from app.services import plan_feed, portfolio, command_service, proposal_service as ps
view = portfolio.positions_view()
stock = command_service.effective_stock_params()
params = ps._scan_params(view)
feed = plan_feed
if hard.get('candidate_source') == 'dividend':
from app.services import dividend_feed as feed
options = {'record': record}
else:
options = {'force': True} if record else {'record': False, 'plan_override': plan_feed.read_current_plan(code=code)}
selected = feed.candidates(held=[x['ts_code'] for x in view['held']],
black=[c for c, v in stock.items() if v.get('black')],
route_by_verdict=bool(params.get('open_route_by_verdict')), recheck_code=code, **options)
current = next((r for r in selected['items'] if r['ts_code'] == code), None)
if not (selected.get('decision') or {}).get('id'):
return {'ok': False, 'error': '当前研究资料暂不可用,恢复后自动更新建议', 'stage': 'source'}
state = selected.get('refresh_status') or {}
if code in (state.get('pending_codes') or []):
return {'ok': False, 'error': '这只股票的研究正在更新,完成后重新开放采纳', 'stage': 'research_pending'}
if (selected.get('consumption') or {}).get('error'):
return {'ok': False, 'error': '建议保存未完成,系统将自动重试', 'stage': 'record'}
if current is None:
return {'ok': False, 'error': '该票已不满足当前候选资格', 'material': True, 'withdraw': True}
result = compare(hard.get('plan_basis'), current, code)
if result == 'unavailable':
return {'ok': False, 'error': '当前研究资料无法核对,恢复后自动更新建议', 'stage': 'source'}
ph = fingerprint({k: v for k, v in params.items() if not k.startswith('_')})
commitments = ps._inflight_open_commitments(view, exclude_proposal=proposal_id,
**({'strict':True} if hard.get('candidate_source') == 'dividend' else {}))
if hard.get('candidate_source') == 'dividend' and code in commitments['names']:
return {'ok':False, 'withdraw':True, 'material':True, 'error':'该票已有其他建仓承诺,当前建议已撤下'}
context = portfolio_context(view, commitments, stock.get(code))
changed = {'research_changed': result == 'material',
'params_changed': hard.get('scan_params_hash') != ph,
'portfolio_changed': hard.get('portfolio_context_hash') != context}
material = any(changed.values())
return {'ok': not material, 'material': material, **changed,
'error': '建议依据已变化,后台正在更新' if material else None,
'view': view, 'stock': stock, 'params': params, 'commitments': commitments,
'provenance': {'decision': current['decision'], 'consumption_id': current['consumption_id'],
'version_check': {'status': 'passed', 'at': datetime.now().astimezone().isoformat(),
'reason': '依据已核对,名次变化不撤销'}}}
def _judgement(p):
h = p.get('hard_numbers') or {}
return h.get('prepared_judgement') or {
'verdict': p.get('judge_verdict') or h.get('judge_verdict') or 'UNAVAILABLE',
'reason': p.get('judge_reason') or '', 'confidence': h.get('judge_conf'),
'degraded': (p.get('judge_verdict') or h.get('judge_verdict')) != 'PASS',
'pv_heads': h.get('judge_pv_heads')}
def ready_hard(hard, verdict, now=None):
h = dict(hard)
h.pop('last_accept_check', None)
h['prepared_judgement'] = {k: verdict.get(k) for k in
('verdict', 'reason', 'confidence', 'degraded', 'pv_heads')}
h['preparation'] = {'status': 'ready', 'at': (now or datetime.now()).astimezone().isoformat()}
return h
def prepare_new(hard, code, verdict):
"""模型返回期间依据可能变化;只在准备完成后开放确认。"""
try:
check = current_basis(hard, code)
if check.get('ok') and hard.get('consumption_id') and not hard.get('consumption_error'):
return ready_hard(dict(hard, **check['provenance']), verdict)
reason = check.get('error') or '建议依据待复核,后台正在更新'
except Exception:
logger.exception('新提议准备失败 code=%s', code)
reason = '建议资料暂不可用,恢复后自动更新'
return dict(hard, prepared_judgement={k: verdict.get(k) for k in
('verdict', 'reason', 'confidence', 'degraded', 'pv_heads')},
preparation={'status': 'pending', 'reason': reason})
def _mark_pending(p, reason, stage='pending'):
"""先关闭旧内容的确认入口;原JSON条件更新与人工确认互斥。"""
from app.repo import pms_repo
h = dict(p.get('hard_numbers') or {})
state = {'status': 'pending', 'reason': reason, 'stage': stage}
if h.get('preparation') == state:
return p
h['preparation'] = state
if not pms_repo.record_proposal_check(p, h):
return None
return dict(p, hard_numbers=h, hard_numbers_json=pms_repo._dumps(h))
def _pending_response(p, reason, stage='pending'):
saved = _mark_pending(p, reason, stage)
return {'ok': False, 'pending': True, 'error': reason,
'proposal': saved or p, 'proposal_id': p.get('proposal_id')}
def fast_checks(p, check):
"""核对已展示数量是否仍可执行,不重算建议,不调用模型。"""
from app.services import proposal_service as ps, param_store, portfolio, market
from app.core import tradedays as td
from app.services.execution_conflicts import buy_blocker
h = p.get('hard_numbers') or {}
view, params, stock = check['view'], dict(check['params']), check['stock']
code = p['ts_code']
conflict = buy_blocker(code)
if conflict:
return conflict
if param_store.get('PMS_AUTONOMY', 'propose_only') == 'off' or param_store.get('PMS_OPEN_AUTONOMY', 'full') == 'off':
return '自主建仓已暂停'
t, vp = view['totals'], view['params']
inflight = check['commitments']
if int(vp['max_names']) - int(t['names_count']) - len(inflight['names']) <= 0:
return '可用持仓名额不足,后台将重新安排建议'
price = float(market.get_price(code) or 0)
amount = int(p['qty']) * price
room = float(vp['portfolio_cap']) * float(vp['scale']) - float(t['portfolio_mv']) - inflight['amount']
if amount > room:
return '可用仓位额度不足,后台将更新建议数量'
if t.get('cash_source') == portfolio.CASH_WS and t.get('cash_avail') is not None:
if amount > float(t['cash_avail']):
return '可用资金不足,后台将更新建议数量'
elif param_store.get_bool('PMS_OPEN_REQUIRE_WS_CASH', True):
return '账户可用资金暂不可读,恢复后重新开放采纳'
params['_mkt'] = {code: {'day': market.day_snapshot(code) or {}, 'ma5': market.get_ma5(code)}}
c = {'ts_code': code, 'action': 'OPEN', 'side': 'buy', 'qty': p['qty'],
'price': price, 'sector': h.get('sector')}
gate = ps.check_candidate_rules(c, view, params, stock,
td.ymd() < param_store.get_int('PMS_BRAKE_UNTIL', 0))
if not gate['passed']:
return ';'.join(re.sub(r'^[A-Z][A-Z0-9_]*:\s*', '', x) for x in gate['failed'])
return None
def before_accept(p, expected_revision):
"""只确认已准备的建议。来源变化交后台,HTTP请求绝不运行完整研判。"""
hard = p.get('hard_numbers') or {}
if p.get('action') != 'OPEN' or hard.get('kind') == 'strategy':
return {'ok': True, 'proposal': p}
from app.services import proposal_service as ps
if ps.is_expired(p):
return {'ok': False, 'error': '建议已过期,不能采纳'}
if (hard.get('preparation') or {}).get('status') != 'ready' or not hard.get('consumption_id'):
return {'ok': False, 'pending': True, 'error': (hard.get('preparation') or {}).get('reason')
or '建议正在准备,完成后可采纳', 'proposal': p}
if not hard.get('proposal_revision') or expected_revision != hard['proposal_revision']:
return {'ok': False, 'error': '建议内容已更新,请查看后再次确认', 'proposal': p}
try:
check = current_basis(hard, p['ts_code'], proposal_id=p.get('proposal_id'), record=False)
if check.get('withdraw'):
return _failed_recheck(p, {'rejected': [{'by': 'qualification', 'why': check['error']}]})
if not check.get('view'):
return _pending_response(p, check.get('error') or '建议资料暂不可用', check.get('stage', 'source'))
if check.get('research_changed') or check.get('params_changed') or hard.get('last_accept_check'):
return _pending_response(p, '建议依据已变化,后台更新完成后可确认', 'changed')
reason = fast_checks(p, check)
if reason:
return _pending_response(p, reason, 'execution')
# 保留生成时的已落库消费凭据。采纳核对结果随动作账本写入,不写另一份消费快照。
checked = check['provenance']
version_check = dict(checked.get('version_check') or {}, checked_decision=checked.get('decision'))
return {'ok': True, 'proposal': dict(p, hard_numbers=dict(hard, version_check=version_check))}
except PlanFeedError as e:
# 传输故障没有改变研究或确认内容。保留已准备状态,不制造后台重算。
logger.warning('采纳来源核验失败 proposal=%s: %s', p.get('proposal_id'), e, exc_info=True)
return {'ok': False, 'retryable': True, 'error': str(e), 'proposal': p}
except Exception:
logger.exception('采纳快速检查失败 proposal=%s', p.get('proposal_id'))
reason = '当前资料暂不可用,建议保留,后台将自动检查'
try:
return _pending_response(p, reason, 'source')
except Exception:
logger.exception('保存建议准备状态失败 proposal=%s', p.get('proposal_id'))
return {'ok': False, 'pending': True, 'error': reason, 'proposal': p}
def refresh_pending(*, now=None, deadline=None):
"""复用正常自主扫描的交易时段和模型预算;不新增任务。"""
from app.services import proposal_service as ps
from app.repo import pms_repo
results = []
from app.services import param_store
legacy_on = param_store.get_bool('PMS_PLAN_VERSION_RECHECK', False)
rows = pms_repo.list_proposals(statuses=('WAIT_USER',), limit=200)
for p in rows:
if not legacy_on and (p.get('hard_numbers') or {}).get('candidate_source') != 'dividend':
continue
if p.get('action') != 'OPEN' or (p.get('hard_numbers') or {}).get('kind') == 'strategy' or ps.is_expired(p, now):
continue
try:
result = refresh_one(p, now=now, deadline=deadline)
except PlanFeedError as e:
logger.warning('后台核对暂不可用 proposal=%s: %s', p['proposal_id'], e)
result = {'ok': False, 'error': str(e), 'retryable': True}
except Exception:
logger.exception('后台更新建议失败 proposal=%s', p['proposal_id'])
result = _pending_response(p, '建议更新暂未完成,系统将自动重试', 'source')
results.append({'proposal_id': p['proposal_id'], 'ok': result.get('ok', False),
'withdrawn': result.get('withdrawn', False), 'error': result.get('error')})
return results
def refresh_one(p, *, now=None, deadline=None):
from app.services import proposal_service as ps, param_store
from app.repo import pms_repo
from app.core import tradedays as td
now = now or datetime.now()
hard = p.get('hard_numbers') or {}
lease = (hard.get('preparation') or {}).get('lease_until')
if lease and datetime.fromisoformat(lease) > now.astimezone():
return {'ok': False, 'error': '后台正在更新建议'}
check = current_basis(hard, p['ts_code'], proposal_id=p['proposal_id'], record=False)
if check.get('withdraw'):
return _failed_recheck(p, {'rejected': [{'by': 'qualification', 'why': check['error']}]})
if not check.get('view'):
return _pending_response(p, check.get('error') or '建议资料暂不可用', check.get('stage', 'source'))
if ((hard.get('preparation') or {}).get('status') == 'ready' and not hard.get('last_accept_check')
and not check.get('research_changed') and not check.get('params_changed')):
# 其他持仓/现金读数变化不等于本建议失效。原数量仍满足当前闸门就保留,
# 否则报价写进新扫描的说明会让相同500股每分钟变成另一份待确认内容。
if check.get('ok') or not fast_checks(p, check):
return {'ok': True}
# 旧的短暂取数失败不应触发扫描、重新选数和新消费;当前原数量仍过闸即可恢复。
if ((hard.get('preparation') or {}).get('stage') in ('source', 'research_pending')
and hard.get('consumption_id') and hard.get('proposal_revision')
and hard.get('prepared_judgement') and hard.get('plan_basis') is not None
and not hard.get('last_accept_check') and not check.get('research_changed')
and not check.get('params_changed') and not fast_checks(p, check)):
restored = ready_hard(hard, _judgement(p), now)
candidate = {'qty': p['qty'], 'hard_numbers': restored}
if pms_repo.publish_prepared_proposal(p, candidate, _judgement(p)):
return {'ok': True, 'proposal': dict(p, hard_numbers=restored)}
return {'ok': False, 'error': '建议已被其他操作更新'}
research_changed = check.get('research_changed', check.get('material', False))
previous_failure = hard.get('last_accept_check') or {}
needs_model = research_changed or previous_failure.get('stage') in ('judge', 'system')
claimed_hard = dict(hard, preparation={'status': 'pending', 'reason': '建议正在更新,完成后可确认',
'stage': 'updating', 'lease_until': (now.astimezone() + timedelta(seconds=240)).isoformat()})
claimed = (dict(p, hard_numbers=claimed_hard, hard_numbers_json=pms_repo._dumps(claimed_hard))
if pms_repo.record_proposal_check(p, claimed_hard) else None)
if not claimed:
return {'ok': False, 'error': '建议已被其他操作更新'}
p = claimed
if needs_model and not ps._judge_budget_left(deadline):
return _pending_response(p, '等待下一轮完成研究更新', 'budget')
out = {'skipped': [], 'rejected': [], 'queued': [], 'executed': []}
params = dict(check['params'])
mkt = {}
params['_mkt'] = mkt
fresh = ps._scan_open(check['view'], params, check['stock'], {}, mkt, out, now=now,
review_code=p['ts_code'], exclude_proposal=p['proposal_id'],
**({'candidate_source':'dividend'} if hard.get('candidate_source') == 'dividend' else {}))
if not fresh:
return _failed_recheck(p, out)
c = fresh[0]
c['_plan_recheck'] = needs_model
verdict = None if needs_model else _judgement(p)
result = ps._route_one(c, check['view'], params, check['stock'],
td.ymd() < param_store.get_int('PMS_BRAKE_UNTIL', 0), now, True, out,
review_only=True, deadline=deadline, prepared_verdict=verdict)
if not result:
return _failed_recheck(p, out)
hn = c['hard_numbers']
hn.update({k:hard[k] for k in ('requested_by','requested_at') if k in hard})
latest = current_basis(hn, p['ts_code'], proposal_id=p['proposal_id'])
if not latest.get('ok'):
return _pending_response(p, latest.get('error') or '建议依据再次变化,下一轮继续更新', latest.get('stage', 'changed'))
hn = ready_hard(dict(hn, **latest['provenance']), result['verdict'], now)
hn['proposal_revision'] = confirmation_revision(c['qty'], hn, result['verdict'])
# 仅资金上下文变化而建议内容不变,维持已有确认标识。
if not needs_model and confirmation_revision(p['qty'], hard, _judgement(p)) == hn['proposal_revision']:
hn['proposal_revision'] = hard.get('proposal_revision') or hn['proposal_revision']
c['hard_numbers'] = hn
if not pms_repo.publish_prepared_proposal(p, c, result['verdict']):
return {'ok': False, 'error': '建议已被其他操作更新'}
return {'ok': True, 'proposal': dict(p, qty=c['qty'], hard_numbers=hn,
judge_verdict=result['verdict'].get('verdict'), judge_reason=result['verdict'].get('reason'))}
def _failed_recheck(p, out):
"""明确否决关闭旧提议;暂时性失败保留。原批准依据始终不升级。"""
from app.repo import pms_repo
def relevant(rows):
return [r for r in rows if not r.get('informational') and
(not r.get('ts_code') or r['ts_code'] == p['ts_code'])]
rejected = relevant(out.get('rejected', []))
rows = rejected or relevant(out.get('skipped', []))
reasons = []
for row in rows:
values = row.get('failed') or [row.get('why')]
if isinstance(values, str):
values = [values]
for value in values:
text = re.sub(r'^[A-Z][A-Z0-9_]*:\s*', '', str(value or '')).strip()
if text and text not in reasons:
reasons.append(text)
stage = rows[0].get('by', 'scan') if rows else 'scan'
title = {'rule': '交易条件不满足', 'judge': '最新研判不建议建仓',
'system': '当前策略不建议建仓', 'qualification': '候选条件已变化'}.get(stage, '暂不满足建仓条件')
message = title + (':' + ';'.join(reasons) if reasons else ',请稍后查看更新的建议')
withdrawn = bool(rejected and stage in ('judge', 'system', 'qualification'))
# 已有检查收尾保留原发生时刻;不假造一次新的研判。
old_check = (p.get('hard_numbers') or {}).get('last_accept_check') or {}
at = old_check.get('at') if out is old_check.get('details') else None
check = {'status': 'withdrawn' if withdrawn else 'blocked',
'at': at or datetime.now().astimezone().isoformat(),
'stage': stage, 'message': message, 'reasons': reasons, 'details': out}
hard = dict(p.get('hard_numbers') or {}, last_accept_check=check,
preparation={'status': 'pending', 'reason': message, 'stage': stage})
save = pms_repo.withdraw_proposal if withdrawn else pms_repo.record_proposal_check
if not save(p, hard):
return {'ok': False, 'error': '提议已被更新,请刷新后查看当前结果',
'proposal_id': p['proposal_id']}
return {'ok': False, 'withdrawn': withdrawn,
'error': ('提议已撤下。' if withdrawn else '') + message,
'details': out, 'proposal_id': p['proposal_id'],
'proposal': dict(p, hard_numbers=hard, status='EXPIRED' if withdrawn else p.get('status', 'WAIT_USER'))}
def withdraw_recorded_rejections():
"""旧失败记录由既有扫描收尾。只读结构化否决,不发研判、不按文字猜测。"""
from app.repo import pms_repo
count = 0
for p in pms_repo.list_proposals(statuses=('WAIT_USER',), limit=200):
hard = p.get('hard_numbers') or {}
check = hard.get('last_accept_check') or {}
if (p.get('action') == 'OPEN' and hard.get('kind') != 'strategy' and
check.get('status') == 'blocked' and check.get('stage') in ('judge', 'system') and
(check.get('details') or {}).get('rejected')):
count += bool(_failed_recheck(p, check['details']).get('withdrawn'))
return count

View File

@ -39,11 +39,14 @@ def cash_view() -> dict:
回 `INSUFFICIENT_CASH` 才被拒 —— 而 PMS 收到 reject 不自动重发, 择时下一跳又算又发又拒, 回 `INSUFFICIENT_CASH` 才被拒 —— 而 PMS 收到 reject 不自动重发, 择时下一跳又算又发又拒,
页面看着一切正常, 实际一单也下不去。 页面看着一切正常, 实际一单也下不去。
**`sell_return_today` 必须加进来**: 当日卖出回笼资金 T+0 可用 (协议 §5.7, A3 点名要的 available_cash 已包含可用的卖出回笼。sell_return_today 是回笼统计,不能重复相加。
字段)。不加会把「刚卖掉一只、拿回笼的钱买另一只」这条最常见的换仓路径判成资金不足。 2026-10-26 真机核对:可用 1,806,071.62 加账户市值 130,190,正好等于总资产
1,936,261.62;再加回笼统计会虚增可用资金 1,644,823.13 元。
账户市值和冻结资金随同一快照返回,页面不能把它们与独立行情估值混成一组账户余额。
""" """
max_age = param_store.get_int("PMS_RECON_WS_SNAPSHOT_MAX_AGE_SEC", 900) max_age = param_store.get_int("PMS_RECON_WS_SNAPSHOT_MAX_AGE_SEC", 900)
out = {"source": CASH_EST, "cash_avail": None, "total_asset": None, out = {"source": CASH_EST, "cash_avail": None, "total_asset": None,
"account_market_value": None, "frozen_cash": None,
"age_sec": None, "why": ""} "age_sec": None, "why": ""}
try: try:
snap = qmt_repo.latest_snapshot("funds") snap = qmt_repo.latest_snapshot("funds")
@ -67,7 +70,8 @@ def cash_view() -> dict:
out["why"] = "拿到了资金数据,但里面找不到可用余额这一项" out["why"] = "拿到了资金数据,但里面找不到可用余额这一项"
return out return out
out.update({"source": CASH_WS, "age_sec": age, "total_asset": f.get("total_asset"), out.update({"source": CASH_WS, "age_sec": age, "total_asset": f.get("total_asset"),
"cash_avail": round(float(avail) + float(f.get("sell_return_today") or 0), 2)}) "cash_avail": round(float(avail), 2),
"account_market_value": f.get("market_value"), "frozen_cash": f.get("frozen_cash")})
return out return out
@ -171,6 +175,7 @@ def positions_view(*, with_price: bool = True) -> dict:
"cash_avail": cash["cash_avail"], "cash_source": cash["source"], "cash_avail": cash["cash_avail"], "cash_source": cash["source"],
"cash_age_sec": cash["age_sec"], "cash_why": cash["why"], "cash_age_sec": cash["age_sec"], "cash_why": cash["why"],
"total_asset": cash["total_asset"], "total_asset": cash["total_asset"],
"account_market_value": cash["account_market_value"], "frozen_cash": cash["frozen_cash"],
"float_pnl": round(port_mv - cost_sum, 2) if cost_sum else 0.0, "float_pnl": round(port_mv - cost_sum, 2) if cost_sum else 0.0,
"float_pnl_pct": round(port_mv / cost_sum - 1, 4) if cost_sum > 0 else None, "float_pnl_pct": round(port_mv / cost_sum - 1, 4) if cost_sum > 0 else None,
"sector_names": sector_names, "sector_mv": sector_mv, "sector_names": sector_names, "sector_mv": sector_mv,
@ -229,6 +234,7 @@ def overview() -> dict:
# 会让人以为钱多得是 (07-30: cash_est 199 万 vs 真实可用 97 万) # 会让人以为钱多得是 (07-30: cash_est 199 万 vs 真实可用 97 万)
"cash_avail": t["cash_avail"], "cash_source": t["cash_source"], "cash_avail": t["cash_avail"], "cash_source": t["cash_source"],
"total_asset": t["total_asset"], "cash_why": t["cash_why"], "total_asset": t["total_asset"], "cash_why": t["cash_why"],
"account_market_value": t["account_market_value"], "frozen_cash": t["frozen_cash"],
"float_pnl": t["float_pnl"], "float_pnl": t["float_pnl"],
"float_pnl_pct": t["float_pnl_pct"], "solid_names": t["solid_names"], "float_pnl_pct": t["float_pnl_pct"], "solid_names": t["solid_names"],
"neg_names": t["neg_names"], "autonomy": p["autonomy"], "neg_names": t["neg_names"], "autonomy": p["autonomy"],

View File

@ -88,6 +88,8 @@ def scan_and_route(*, now=None, dry_run: bool = False) -> dict:
# 就清掉, 不能等 15:10 结算; 也免得下面的跳过集合把一条早该作废的提议当在途。只读试算不动表。 # 就清掉, 不能等 15:10 结算; 也免得下面的跳过集合把一条早该作废的提议当在途。只读试算不动表。
try: try:
out["expired_proposals"] = pms_repo.expire_proposals(now) out["expired_proposals"] = pms_repo.expire_proposals(now)
from app.services.plan_recheck import withdraw_recorded_rejections
out["withdrawn_proposals"] = withdraw_recorded_rejections()
except Exception as e: # noqa: BLE001 —— 清扫失败不挡扫描 except Exception as e: # noqa: BLE001 —— 清扫失败不挡扫描
out["errors"].append(f"过期提议清扫失败: {e}") out["errors"].append(f"过期提议清扫失败: {e}")
@ -212,7 +214,8 @@ def scan_and_route(*, now=None, dry_run: bool = False) -> dict:
out["skipped"].append({"action": ae.A_OPEN, "why": "新建仓档位 off, 不扫描候选池"}) out["skipped"].append({"action": ae.A_OPEN, "why": "新建仓档位 off, 不扫描候选池"})
else: else:
try: try:
open_cands = _scan_open(view, params, stock_params, skip, mkt, out, now=now) open_cands = _scan_open(view, params, stock_params, skip, mkt, out, now=now,
record_consumption=not dry_run)
except Exception as e: except Exception as e:
logger.exception("新建仓扫描失败") logger.exception("新建仓扫描失败")
out["errors"].append(f"新建仓扫描失败: {type(e).__name__}: {e}") out["errors"].append(f"新建仓扫描失败: {type(e).__name__}: {e}")
@ -231,7 +234,11 @@ def scan_and_route(*, now=None, dry_run: bool = False) -> dict:
deadline = time.monotonic() + max( deadline = time.monotonic() + max(
0, param_store.get_int("PMS_JUDGE_TICK_BUDGET_SEC", 150)) 0, param_store.get_int("PMS_JUDGE_TICK_BUDGET_SEC", 150))
for c in list(scanned["candidates"]) + open_cands: for group_index, group in enumerate((list(scanned['candidates']), open_cands)):
if group_index == 1 and not dry_run:
from app.services.plan_recheck import refresh_pending
out['prepared_proposals'] = refresh_pending(now=now, deadline=deadline)
for c in group:
try: try:
_rk = _unlocked.get((c.get("ts_code"), c.get("action"))) _rk = _unlocked.get((c.get("ts_code"), c.get("action")))
if _rk: if _rk:
@ -307,12 +314,14 @@ def _save_tech_exit_done(codes) -> None:
# ================================================================ 新建仓的取数与筛选 # ================================================================ 新建仓的取数与筛选
def _scan_open(view, params, stock_params, skip, mkt, out, now=None) -> list: def _scan_open(view, params, stock_params, skip, mkt, out, now=None,
review_code=None, exclude_proposal=None, record_consumption=True, candidate_source='plan') -> list:
"""候选池 → 新建仓候选。产出的候选数天生不超过剩余名额 (名额与金额在纯逻辑里边走边扣)。 """候选池 → 新建仓候选。产出的候选数天生不超过剩余名额 (名额与金额在纯逻辑里边走边扣)。
与命令驱动那条路 (command_service._candidates) 有意不同的两点: 与命令驱动那条路 (command_service._candidates) 有意不同的两点:
1. **只认上游计划接口这一个来源。** buy_plan 那张旧表在目标架构下没有明确的写入方, 1. **只认上游计划接口这一个来源。** buy_plan 那张旧表在目标架构下没有明确的写入方,
白名单是给人下命令用的 —— 无人值守地建仓, 事实源必须单一。 白名单是给人下命令用的 —— 无人值守地建仓, 事实源必须单一。
人工发起的高股息准备显式传来源,只从原来源重核,不加入此自主扫描。
2. **价格只认实时价。** 那边用 market.plan_price, 拿不到实时价会回落昨收; 它自己的 2. **价格只认实时价。** 那边用 market.plan_price, 拿不到实时价会回落昨收; 它自己的
注释就写着「拿昨收当现价去做不追高这类判断会出错, 只给规划期定量用」。 注释就写着「拿昨收当现价去做不追高这类判断会出错, 只给规划期定量用」。
这条路是要真下单的, 所以走 market.get_prices, 取不到就整只跳过并留痕。 这条路是要真下单的, 所以走 market.get_prices, 取不到就整只跳过并留痕。
@ -328,7 +337,7 @@ def _scan_open(view, params, stock_params, skip, mkt, out, now=None) -> list:
src = (param_store.get("PMS_CANDIDATE_SOURCE", plan_feed.SRC_PLAN_API) src = (param_store.get("PMS_CANDIDATE_SOURCE", plan_feed.SRC_PLAN_API)
or plan_feed.SRC_PLAN_API).strip() or plan_feed.SRC_PLAN_API).strip()
if src == plan_feed.SRC_BUY_PLAN: if src == plan_feed.SRC_BUY_PLAN and candidate_source == 'plan':
out["skipped"].append({"action": ae.A_OPEN, out["skipped"].append({"action": ae.A_OPEN,
"why": f"候选池来源是 {src}, 自主新建仓只认上游计划接口"}) "why": f"候选池来源是 {src}, 自主新建仓只认上游计划接口"})
return [] return []
@ -338,8 +347,13 @@ def _scan_open(view, params, stock_params, skip, mkt, out, now=None) -> list:
try: try:
# 按判决分流开着时, 上游判为「仅展示」的票在候选阶段就剔掉 (理由见 # 按判决分流开着时, 上游判为「仅展示」的票在候选阶段就剔掉 (理由见
# plan_feed.select_candidates 的说明: 不剔的话它们会白占 top_n 的名额)。 # plan_feed.select_candidates 的说明: 不剔的话它们会白占 top_n 的名额)。
sel = plan_feed.candidates(held=held, black=black, feed = plan_feed
route_by_verdict=bool(params.get("open_route_by_verdict"))) if candidate_source == 'dividend':
from app.services import dividend_feed as feed
sel = feed.candidates(held=held, black=black,
route_by_verdict=bool(params.get("open_route_by_verdict")),
**({'recheck_code': review_code} if review_code else {}),
**({'record': False} if not record_consumption else {}))
except plan_feed.PlanFeedError as e: except plan_feed.PlanFeedError as e:
# 拿不到 ≠ 今天没票可买。显式留痕, 本轮不产新建仓候选, 已有持仓的四类照常。 # 拿不到 ≠ 今天没票可买。显式留痕, 本轮不产新建仓候选, 已有持仓的四类照常。
logger.error("[新建仓] 候选池取数失败, 本轮不建仓: %s", e) logger.error("[新建仓] 候选池取数失败, 本轮不建仓: %s", e)
@ -353,6 +367,8 @@ def _scan_open(view, params, stock_params, skip, mkt, out, now=None) -> list:
out["skipped"].append({"ts_code": row.get("ts_code"), "action": ae.A_OPEN, out["skipped"].append({"ts_code": row.get("ts_code"), "action": ae.A_OPEN,
"why": ae.display_only_why(row)}) "why": ae.display_only_why(row)})
items = list(sel.get("items") or []) items = list(sel.get("items") or [])
if review_code:
items = [x for x in items if x['ts_code'] == review_code]
if not items: if not items:
out["skipped"].append({"action": ae.A_OPEN, "why": _no_candidate_why(sel)}) out["skipped"].append({"action": ae.A_OPEN, "why": _no_candidate_why(sel)})
return [] return []
@ -381,13 +397,18 @@ def _scan_open(view, params, stock_params, skip, mkt, out, now=None) -> list:
# 名额与金额都要扣掉**在途的建仓承诺** (2026-08-28 审查修): names_count 只数已成交 # 名额与金额都要扣掉**在途的建仓承诺** (2026-08-28 审查修): names_count 只数已成交
# 持仓, 在途 OPEN 指令与等拍板的 OPEN 提议两头都不占 —— 候选没进买入区间时指令滞留 # 持仓, 在途 OPEN 指令与等拍板的 OPEN 提议两头都不占 —— 候选没进买入区间时指令滞留
# 在途, 下一跳名额照旧又放两只, 几分钟就把持仓数上限击穿。同票去重挡不住换一只票。 # 在途, 下一跳名额照旧又放两只, 几分钟就把持仓数上限击穿。同票去重挡不住换一只票。
inflight = _inflight_open_commitments(view) if candidate_source == 'dividend':
inflight = _inflight_open_commitments(view, exclude_proposal=exclude_proposal, strict=True)
cands = [c for c in cands if c['ts_code'] not in inflight['names']]
else:
inflight = (_inflight_open_commitments(view, exclude_proposal=exclude_proposal)
if exclude_proposal else _inflight_open_commitments(view))
slots = int(p["max_names"] or 0) - int(t["names_count"] or 0) - len(inflight["names"]) slots = int(p["max_names"] or 0) - int(t["names_count"] or 0) - len(inflight["names"])
room = float(p["portfolio_cap"] or 0) * float(p["scale"] or 0) \ room = float(p["portfolio_cap"] or 0) * float(p["scale"] or 0) \
- float(t["portfolio_mv"] or 0) - inflight["amount"] - float(t["portfolio_mv"] or 0) - inflight["amount"]
if inflight["names"]: if inflight["names"]:
out["skipped"].append({"action": ae.A_OPEN, out["skipped"].append({"action": ae.A_OPEN,
"why": f"在途建仓已占 {len(inflight['names'])} 个名额、" "informational": True, "why": f"在途建仓已占 {len(inflight['names'])} 个名额、"
f"约 {inflight['amount']:,.0f} 元 " f"约 {inflight['amount']:,.0f} 元 "
f"({sorted(inflight['names'])[:6]}), 本轮按余量扫描"}) f"({sorted(inflight['names'])[:6]}), 本轮按余量扫描"})
# 真实可用资金封顶。**这一条比规则闸严一档, 是刻意的**: 规则闸那条「拿不到 ws 资金快照 # 真实可用资金封顶。**这一条比规则闸严一档, 是刻意的**: 规则闸那条「拿不到 ws 资金快照
@ -416,7 +437,11 @@ def _scan_open(view, params, stock_params, skip, mkt, out, now=None) -> list:
# 当日行情快照只对**真的产出了候选**的票取 —— 候选数已被名额与金额扣到很小, # 当日行情快照只对**真的产出了候选**的票取 —— 候选数已被名额与金额扣到很小,
# 不必为整池几十只票各拉一遍分钟线。规则闸的「不追高」靠的就是这一份。 # 不必为整池几十只票各拉一遍分钟线。规则闸的「不追高」靠的就是这一份。
for c in res["candidates"]: for c in res["candidates"]:
from app.core.plan_revision import fingerprint, portfolio_context
c.setdefault('hard_numbers', {})['scan_params_hash'] = fingerprint(
{k: v for k, v in _scan_params(view).items() if not k.startswith('_')})
code = c["ts_code"] code = c["ts_code"]
c['hard_numbers']['portfolio_context_hash'] = portfolio_context(view, inflight, stock_params.get(code))
d = {"ma5": market.get_ma5(code)} d = {"ma5": market.get_ma5(code)}
try: try:
d["day"] = market.day_snapshot(code) or {} d["day"] = market.day_snapshot(code) or {}
@ -585,32 +610,43 @@ def _no_candidate_why(sel) -> str:
return head + ":" + ",".join(parts) + "。" return head + ":" + ",".join(parts) + "。"
def _inflight_open_commitments(view) -> dict: def _inflight_open_commitments(view, exclude_proposal=None, strict=False) -> dict:
"""在途的新建仓承诺: {names: {代码}, amount: 预估占用金额}。 """在途的新建仓承诺: names 为代码集合,amount 为预估占用,basis 为稳定核验依据。
口径: 在途 (LIVE) 的 OPEN 指令 + 等拍板 (WAIT_USER) 的 OPEN 提议, 只算**尚未持有** 口径: 在途 (LIVE) 的 OPEN 指令 + 等拍板 (WAIT_USER) 的 OPEN 提议, 只算**尚未持有**
的票 (已成交的部分 names_count 里已经有了)。金额按 数量×现价 估 (指令下发前没有限价), 的票 (已成交的部分 names_count 里已经有了)。金额按 数量×现价 估 (指令下发前没有限价),
现价取不到时按提议里存的价兜底。读库失败按空 —— 与其它在途读取同一口径, 宁可这轮 现价取不到时按提议里存的价兜底。读库失败按空 —— 与其它在途读取同一口径, 宁可这轮
多放也不能因读不到把新建仓全停 (规则闸和真实资金封顶仍在后面兜)。""" 多放也不能因读不到把新建仓全停 (规则闸和真实资金封顶仍在后面兜)。"""
names, amount = set(), 0.0 names, amount = set(), 0.0
basis = []
held = {x["ts_code"] for x in view.get("held") or []} held = {x["ts_code"] for x in view.get("held") or []}
rows = [] rows = []
try: try:
for i in pms_repo.list_instructions(statuses=list(executor.LIVE), limit=300): for i in pms_repo.list_instructions(statuses=list(executor.LIVE), limit=300):
if i.get("action") == ae.A_OPEN and i["ts_code"] not in held: if i.get("action") == ae.A_OPEN and i["ts_code"] not in held:
rows.append((i["ts_code"], int(i.get("qty") or 0), None)) rows.append((i["ts_code"], int(i.get("qty") or 0), None))
basis.append(('instruction', str(i.get('instruction_id') or ''),
i['ts_code'], int(i.get('qty') or 0), int(i.get('exec_qty') or 0)))
except Exception as e: except Exception as e:
if strict:
raise
logger.warning("读在途 OPEN 指令失败 (按无在途): %s", e) logger.warning("读在途 OPEN 指令失败 (按无在途): %s", e)
try: try:
for pr in pms_repo.list_proposals(statuses=("WAIT_USER",), limit=200): for pr in pms_repo.list_proposals(statuses=("WAIT_USER",), limit=200):
if exclude_proposal and pr.get('proposal_id') == exclude_proposal:
continue
if pr.get("action") == ae.A_OPEN and pr["ts_code"] not in held: if pr.get("action") == ae.A_OPEN and pr["ts_code"] not in held:
hn = pr.get("hard_numbers") or {} hn = pr.get("hard_numbers") or {}
rows.append((pr["ts_code"], int(pr.get("qty") or 0), rows.append((pr["ts_code"], int(pr.get("qty") or 0),
float(hn.get("price") or 0) or None)) float(hn.get("price") or 0) or None))
basis.append(('proposal', str(pr.get('proposal_id') or ''),
pr['ts_code'], int(pr.get('qty') or 0), 0))
except Exception as e: except Exception as e:
if strict:
raise
logger.warning("读在途 OPEN 提议失败 (按无在途): %s", e) logger.warning("读在途 OPEN 提议失败 (按无在途): %s", e)
if not rows: if not rows:
return {"names": names, "amount": 0.0} return {"names": names, "amount": 0.0, "basis": []}
try: try:
prices = market.get_prices(sorted({c for c, _, _ in rows})) prices = market.get_prices(sorted({c for c, _, _ in rows}))
except Exception: except Exception:
@ -621,7 +657,8 @@ def _inflight_open_commitments(view) -> dict:
names.add(code) names.add(code)
px = float(prices.get(code) or 0) or float(px_hint or 0) px = float(prices.get(code) or 0) or float(px_hint or 0)
amount += qty * px amount += qty * px
return {"names": names, "amount": round(amount, 2)} # 金额继续按原顺序逐票去重。核验依据保留全部承诺,避免等额替换或数量变化漏检。
return {"names": names, "amount": round(amount, 2), "basis": sorted(basis)}
def _plain_check(c) -> str: def _plain_check(c) -> str:
@ -719,7 +756,7 @@ def disposition_snapshot(now=None) -> dict:
for _k in _inflight_keys(): # 在途; 前端多半已按指令/提议标成「已下单/待你确认」 for _k in _inflight_keys(): # 在途; 前端多半已按指令/提议标成「已下单/待你确认」
skip[_k] = "系统正在处理这只票(见『待确认提议』或『当日指令』)" skip[_k] = "系统正在处理这只票(见『待确认提议』或『当日指令』)"
sink = {"skipped": []} # 丢弃用: _scan_open 只往里 append/extend, 不读它 sink = {"skipped": []} # 丢弃用: _scan_open 只往里 append/extend, 不读它
would = _scan_open(view, params, stock_params, skip, {}, sink, now=now) would = _scan_open(view, params, stock_params, skip, {}, sink, now=now, record_consumption=False)
except Exception as e: except Exception as e:
logger.exception("候选处置快照失败") logger.exception("候选处置快照失败")
return {"ok": False, "ready": False, "error": f"{type(e).__name__}: {e}", return {"ok": False, "ready": False, "error": f"{type(e).__name__}: {e}",
@ -753,17 +790,12 @@ def disposition_snapshot(now=None) -> dict:
return res return res
def _route_one(c, view, params, stock_params, brake_active, now, dry_run, out, def check_candidate_rules(c, view, params, stock_params, brake_active):
*, deadline=None): code, action, side = c['ts_code'], c['action'], c['side']
code, action, side = c["ts_code"], c["action"], c["side"] is_open = action == ae.A_OPEN
is_open = (action == ae.A_OPEN)
pos = _pos_of(view, code) pos = _pos_of(view, code)
# 新建仓的现价取候选自带的那份。**不能取 pos 的**: 从没持仓过的票在账本里没有行, price = float(c.get('price') or 0) if is_open else float(pos.get('price') or 0)
# `_pos_of` 回的是空壳、没有 price, 取它会是 0, 规则闸一上来就判 PRICE_MISSING。 return rule_gate.check(
price = float(c.get("price") or 0) if is_open else float(pos.get("price") or 0)
# ---- 一级: 规则闸 (自主动作受刹车约束, is_command=False) ----
gate = rule_gate.check(
side=side, action=action, qty=c["qty"], price=price, side=side, action=action, qty=c["qty"], price=price,
ctx={"ts_code": code, "position": pos, ctx={"ts_code": code, "position": pos,
# 当日行情走 _market_ctx 取到的真实快照。原来这里是 # 当日行情走 _market_ctx 取到的真实快照。原来这里是
@ -790,6 +822,19 @@ def _route_one(c, view, params, stock_params, brake_active, now, dry_run, out,
# 不拦截, 见 rule_gate 里那段说明。 # 不拦截, 见 rule_gate 里那段说明。
"stop_price": stock_params.get(code, {}).get("stop_price"), "stop_price": stock_params.get(code, {}).get("stop_price"),
"is_command": False}}) "is_command": False}})
def _route_one(c, view, params, stock_params, brake_active, now, dry_run, out,
*, deadline=None, review_only=False, prepared_verdict=None):
code, action, side = c["ts_code"], c["action"], c["side"]
is_open = (action == ae.A_OPEN)
pos = _pos_of(view, code)
# 新建仓的现价取候选自带的那份。**不能取 pos 的**: 从没持仓过的票在账本里没有行,
# `_pos_of` 回的是空壳、没有 price, 取它会是 0, 规则闸一上来就判 PRICE_MISSING。
price = float(c.get("price") or 0) if is_open else float(pos.get("price") or 0)
# ---- 一级: 规则闸 (自主动作受刹车约束, is_command=False) ----
gate = check_candidate_rules(c, view, params, stock_params, brake_active)
if not gate["passed"]: if not gate["passed"]:
out["rejected"].append({"ts_code": code, "action": action, "by": "rule", out["rejected"].append({"ts_code": code, "action": action, "by": "rule",
"failed": gate["failed"]}) "failed": gate["failed"]})
@ -808,6 +853,12 @@ def _route_one(c, view, params, stock_params, brake_active, now, dry_run, out,
and _sd_mode in ("decline", "full")): and _sd_mode in ("decline", "full")):
verdict = {"verdict": "SKIPPED", "reason": "逻辑存疑,不送研判(系统自决直接放弃)", verdict = {"verdict": "SKIPPED", "reason": "逻辑存疑,不送研判(系统自决直接放弃)",
"degraded": False, "raw": None, "confidence": None} "degraded": False, "raw": None, "confidence": None}
elif prepared_verdict is not None:
verdict = dict(prepared_verdict) # 后台仅额度变化时复用同研究依据的结果。
if verdict.get('verdict') == judge.REJECT:
out['rejected'].append({'ts_code': code, 'action': action, 'by': 'judge',
'failed': [verdict.get('reason') or '决策系统驳回']})
return
elif c.get("judge_required"): elif c.get("judge_required"):
if not _judge_budget_left(deadline): if not _judge_budget_left(deadline):
# 本轮研判时间用尽 —— 整条跳过, 下一跳重来。 # 本轮研判时间用尽 —— 整条跳过, 下一跳重来。
@ -829,9 +880,18 @@ def _route_one(c, view, params, stock_params, brake_active, now, dry_run, out,
_rtext = reask_service.reask_text(_rk) _rtext = reask_service.reask_text(_rk)
else: else:
c.pop("reask", None) # 名额没落上就不算重问, 这一跳按普通候选走 c.pop("reask", None) # 名额没落上就不算重问, 这一跳按普通候选走
if is_open and param_store.get_bool('PMS_PLAN_VERSION_RECHECK', False):
from app.core.plan_revision import needs_new_judgement
try:
previous = next((r.get('hard_numbers') for r in pms_repo.list_ledger(ts_code=code, limit=20)
if r.get('action') == ae.A_OPEN and r.get('arbiter') in ('judge', 'system')), None)
except Exception:
previous = None
# 即使上一跳因版本变化放弃自动采纳,下一跳也不能复用该票旧批准的缓存。
_force = _force or needs_new_judgement(c.get('hard_numbers') or {}, previous)
verdict = judge.request(c, context={"position": _judge_ctx(pos), verdict = judge.request(c, context={"position": _judge_ctx(pos),
"recent_ledger": _recent_ledger(code)}, "recent_ledger": _recent_ledger(code)},
force=_force, reask_text=_rtext) force=_force or bool(c.get('_plan_recheck')), reask_text=_rtext)
# 新建仓的低把握驳回改交人 (2026-09-07, 第二道保险)。择时决策系统的提示词已改成 # 新建仓的低把握驳回改交人 (2026-09-07, 第二道保险)。择时决策系统的提示词已改成
# 「证据不足以判断 → 不可用」, 但模型未必每次守得住; 它给的把握度是现成的读数, # 「证据不足以判断 → 不可用」, 但模型未必每次守得住; 它给的把握度是现成的读数,
# 低于阈值的驳回按「不可用」处理 —— 进人的待确认队列, 不记驳回、不杀提议。 # 低于阈值的驳回按「不可用」处理 —— 进人的待确认队列, 不记驳回、不杀提议。
@ -848,6 +908,13 @@ def _route_one(c, view, params, stock_params, brake_active, now, dry_run, out,
if verdict["verdict"] == judge.REJECT: if verdict["verdict"] == judge.REJECT:
out["rejected"].append({"ts_code": code, "action": action, "by": "judge", out["rejected"].append({"ts_code": code, "action": action, "by": "judge",
"failed": [verdict.get("reason") or "决策系统驳回"]}) "failed": [verdict.get("reason") or "决策系统驳回"]})
if review_only:
rh = dict(c.get("hard_numbers") or {}, judge_conf=verdict.get("confidence"))
try:
rh["reask_base"] = reask_service.base_snapshot(code, price, judge_conf=verdict.get("confidence"))
except Exception:
pass # 基线未知时守成,不用当前值补造历史。
out["rejected"][-1]["hard_numbers"] = rh
if not dry_run: if not dry_run:
# 驳回也把把握度记进硬数字 (2026-09-08): 低把握驳回转交人那道保险 (PMS_JUDGE_REJECT_CONF_MIN) # 驳回也把把握度记进硬数字 (2026-09-08): 低把握驳回转交人那道保险 (PMS_JUDGE_REJECT_CONF_MIN)
# 是否在起作用, 只能从驳回行的把握度分布看出来; 此前只有提议行记它, 驳回行没有, 复核无据。 # 是否在起作用, 只能从驳回行的把握度分布看出来; 此前只有提议行记它, 驳回行没有, 复核无据。
@ -967,6 +1034,14 @@ def _route_one(c, view, params, stock_params, brake_active, now, dry_run, out,
if auto_why: if auto_why:
auto_exec = True auto_exec = True
if review_only:
_apply_advice_tier(c, c.setdefault('hard_numbers', {}), verdict,
force_trial=(sd.get('tier') == 'trial'))
c['hard_numbers'].update(judge_verdict=verdict.get('verdict'),
judge_conf=verdict.get('confidence'),
price=price, reason=c['reason'])
return {'candidate': c, 'verdict': verdict}
if dry_run: if dry_run:
(out["executed"] if auto_exec else out["queued"]).append( (out["executed"] if auto_exec else out["queued"]).append(
{**_brief(c), "route": "auto" if auto_exec else "queue", {**_brief(c), "route": "auto" if auto_exec else "queue",
@ -975,6 +1050,13 @@ def _route_one(c, view, params, stock_params, brake_active, now, dry_run, out,
return return
if auto_exec: if auto_exec:
if is_open and param_store.get_bool('PMS_PLAN_VERSION_RECHECK', False):
check = verify_open_basis(c.get('hard_numbers') or {}, code)
if not check.get('ok'):
out['skipped'].append({'ts_code': code, 'action': action,
'why': check['error'] + ';下一跳按新输入重新评估'})
return
c['hard_numbers'].update(check['provenance'])
sd_accept = sd_decision == "accept" sd_accept = sd_decision == "accept"
strat_cancelled, buys_cancelled = [], [] strat_cancelled, buys_cancelled = [], []
if sd_accept and side == "sell": if sd_accept and side == "sell":
@ -1089,6 +1171,14 @@ def _judge_budget_left(deadline) -> bool:
# ================================================================ 落表 # ================================================================ 落表
def verify_open_basis(hard, code):
from app.services.plan_recheck import current_basis
try:
return current_basis(hard, code)
except Exception as e:
return {'ok': False, 'error': f'当前计划版本无法核验:{type(e).__name__}'}
def _make_instruction(c, price, now) -> str: def _make_instruction(c, price, now) -> str:
ymd = td.ymd(now) ymd = td.ymd(now)
# 序号用完整时分秒 (2026-08-28 修): 原来 %1000 只留「分钟个位+秒」, 同日同票同动作 # 序号用完整时分秒 (2026-08-28 修): 原来 %1000 只留「分钟个位+秒」, 同日同票同动作
@ -1107,7 +1197,9 @@ def _make_instruction(c, price, now) -> str:
window_tdays=window, status=executor.ST_PROPOSED, window_tdays=window, status=executor.ST_PROPOSED,
progress={"deadline": str(td.window_deadline(now.date(), window)), progress={"deadline": str(td.window_deadline(now.date(), window)),
"is_command": False, "children": [], "auto": True, "is_command": False, "children": [], "auto": True,
"reason": c["reason"]}) "reason": c["reason"],
'plan': {k: (c.get('hard_numbers') or {}).get(k) for k in
('decision', 'consumption_id', 'review_ref', 'execution_rank', 'priority_reason')}})
iid = try_iid iid = try_iid
break break
except Exception as e: except Exception as e:
@ -1376,6 +1468,11 @@ def _make_proposal(c, price, verdict) -> str:
# 采纳按钮那边直接抄提议里的股数原样落单 (只有卖出侧会按可卖量重算), 所以不在这里 # 采纳按钮那边直接抄提议里的股数原样落单 (只有卖出侧会按可卖量重算), 所以不在这里
# 改, 后面就没有第二次机会了。 # 改, 后面就没有第二次机会了。
_apply_advice_tier(c, hn, verdict) _apply_advice_tier(c, hn, verdict)
if c['action'] == ae.A_OPEN and param_store.get_bool('PMS_PLAN_VERSION_RECHECK', False):
from app.services.plan_recheck import prepare_new
hn = prepare_new(hn, c['ts_code'], verdict)
from app.core.plan_revision import confirmation_revision
hn['proposal_revision'] = confirmation_revision(c['qty'], hn, verdict)
try: try:
pms_repo.insert_proposal( pms_repo.insert_proposal(
proposal_id=pid, ts_code=c["ts_code"], action=c["action"], qty=c["qty"], proposal_id=pid, ts_code=c["ts_code"], action=c["action"], qty=c["qty"],
@ -1383,6 +1480,11 @@ def _make_proposal(c, price, verdict) -> str:
judge_verdict=verdict.get("verdict"), judge_verdict=verdict.get("verdict"),
judge_reason=(verdict.get("reason") or "")[:500]) judge_reason=(verdict.get("reason") or "")[:500])
except Exception: except Exception:
existing = pms_repo.get_proposal(pid)
if existing and existing.get('status') in ('WAIT_USER', 'ACCEPTED'):
return pid
if existing is None:
raise
# 确定性编号被当日已终态 (过期/驳回) 的旧提议占着 —— 补时间后缀重试一次, # 确定性编号被当日已终态 (过期/驳回) 的旧提议占着 —— 补时间后缀重试一次,
# 不让唯一键冲突把整轮扫描刷成 error (2026-08-28 审查修; 用户驳回的当日 # 不让唯一键冲突把整轮扫描刷成 error (2026-08-28 审查修; 用户驳回的当日
# 不重提另有 _declined_today_keys 挡在扫描入口, 这里兜的是过期重生成) # 不重提另有 _declined_today_keys 挡在扫描入口, 这里兜的是过期重生成)
@ -1573,6 +1675,8 @@ def _inflight_keys() -> dict:
if action in ae.SELL_SIDE_ACTIONS: if action in ae.SELL_SIDE_ACTIONS:
for other in ae.SELL_SIDE_ACTIONS: for other in ae.SELL_SIDE_ACTIONS:
keys.setdefault((code, other), why + " (同票另一种减持一并让路)") keys.setdefault((code, other), why + " (同票另一种减持一并让路)")
for buy in ('OPEN', 'FILL', 'ADD', 'DCA'):
keys.setdefault((code, buy), '该股有减持安排待处理,暂不新增买入提议')
try: try:
for p in pms_repo.list_proposals(statuses=("WAIT_USER",), limit=200): for p in pms_repo.list_proposals(statuses=("WAIT_USER",), limit=200):
_mark(p["ts_code"], p["action"], f"已有在途提议 {p.get('proposal_id')} 在等人确认") _mark(p["ts_code"], p["action"], f"已有在途提议 {p.get('proposal_id')} 在等人确认")

View File

@ -437,10 +437,13 @@ def _eval_grid(st, pos, day, now, ctx):
if cur > last: if cur > last:
k = last k = last
if k in filled and avail >= LOT and actual_add >= LOT: if k in filled and avail >= LOT and actual_add >= LOT:
q = min(per_lot, _round_lot(avail)) info = filled[k]
# 部分成交恢复的档位可能小于配置档量;不能借底仓补齐一档。
# 同时守住实际网格股和可卖量,最小申报口径继续沿用下面的检查。
q = min(per_lot, _round_lot(info.get("qty")),
_round_lot(actual_add), _round_lot(avail))
if q >= mlot: # 科创板部分卖低于 200 股不合法, 量不足先不推进 if q >= mlot: # 科创板部分卖低于 200 股不合法, 量不足先不推进
state["last_band"] = last + 1 state["last_band"] = last + 1
info = filled[k]
return {"side": "sell", "action": A_SELL, "qty": q, "leg": f"grid_sell:{k}", return {"side": "sell", "action": A_SELL, "qty": q, "leg": f"grid_sell:{k}",
"grid_sell_idx": k, "grid_sell_idx": k,
"reason": f"网格卖: 现价 {price} 涨破档{k}(买价 {info.get('price')}), 卖 {q} 股"} "reason": f"网格卖: 现价 {price} 涨破档{k}(买价 {info.get('price')}), 卖 {q} 股"}

View File

@ -180,7 +180,8 @@ def cancel_by_code(ts_code: str, reason: str = "") -> dict:
from app.services import command_service, executor from app.services import command_service, executor
try: try:
props = [p for p in pms_repo.list_proposals(statuses=("WAIT_USER",), limit=500) props = [p for p in pms_repo.list_proposals(statuses=("WAIT_USER",), limit=500)
if p.get("ts_code") == ts_code and p.get("action") in command_service.BUILD_ACTIONS] if p.get("ts_code") == ts_code and (p.get("action") in command_service.BUILD_ACTIONS
or (p.get('hard_numbers') or {}).get('side') == 'buy')]
except Exception as e: # noqa: BLE001 except Exception as e: # noqa: BLE001
props = [] props = []
out["ok"] = False out["ok"] = False
@ -189,13 +190,15 @@ def cancel_by_code(ts_code: str, reason: str = "") -> dict:
try: try:
if pms_repo.decide_proposal(p["proposal_id"], "DECLINED"): if pms_repo.decide_proposal(p["proposal_id"], "DECLINED"):
out["proposals"].append(p["proposal_id"]) out["proposals"].append(p["proposal_id"])
pms_repo.insert_ledger(ts_code=ts_code, action=p.get('action'), arbiter='system',
verdict='REJECT', price_at=0, ref_id=p['proposal_id'], reason=why)
except Exception as e: # noqa: BLE001 except Exception as e: # noqa: BLE001
out["ok"] = False out["ok"] = False
out["errors"].append(f"驳回买入提议 {p.get('proposal_id')} 失败: {type(e).__name__}: {e}") out["errors"].append(f"驳回买入提议 {p.get('proposal_id')} 失败: {type(e).__name__}: {e}")
# 三, 撤该票当前在途的买入指令 (已下发到券商的网格/补仓买单, 撤了方案它还挂着) # 三, 撤该票当前在途的买入指令 (已下发到券商的网格/补仓买单, 撤了方案它还挂着)
try: try:
live_buys = [i for i in pms_repo.list_instructions( live_buys = [i for i in pms_repo.list_instructions(
statuses=list(command_service.LIVE_INSTR), side="buy", limit=500) statuses=list(command_service.LIVE_INSTR), side="buy", ts_code=ts_code, limit=500)
if i.get("ts_code") == ts_code] if i.get("ts_code") == ts_code]
except Exception as e: # noqa: BLE001 except Exception as e: # noqa: BLE001
live_buys = [] live_buys = []
@ -204,7 +207,7 @@ def cancel_by_code(ts_code: str, reason: str = "") -> dict:
for i in live_buys: for i in live_buys:
iid = i.get("instruction_id") iid = i.get("instruction_id")
try: try:
r = executor.cancel_instruction(iid, reason=why) or {} r = executor.cancel_instruction(iid, reason=why, arbiter="system") or {}
if r.get("ok"): if r.get("ok"):
out["instructions"].append(iid) out["instructions"].append(iid)
else: else:

View File

@ -419,8 +419,11 @@ def api_lots(ts_code: str, status: str = Query("OPEN")):
def api_instructions(status: str = Query(None), limit: int = 200, def api_instructions(status: str = Query(None), limit: int = 200,
include_archived: bool = Query(False)): include_archived: bool = Query(False)):
statuses = [s for s in (status or "").split(",") if s] or None statuses = [s for s in (status or "").split(",") if s] or None
return ok(pms_repo.list_instructions, statuses=statuses, limit=limit, def _list():
include_archived=include_archived) from app.services.execution_conflicts import instruction_progress
return instruction_progress(pms_repo.list_instructions(statuses=statuses, limit=limit,
include_archived=include_archived))
return ok(_list)
@app.get("/api/ledger") @app.get("/api/ledger")
@ -473,15 +476,42 @@ def api_proposals(status: str = Query("WAIT_USER"), limit: int = 100,
tech_service.attach(rows) tech_service.attach(rows)
except Exception as e: # noqa: BLE001 except Exception as e: # noqa: BLE001
logger.warning("[提议] 技术面立场挂不上: %s", e) logger.warning("[提议] 技术面立场挂不上: %s", e)
legacy_on = param_store.get_bool('PMS_PLAN_VERSION_RECHECK', False)
for row in rows:
h = row.get('hard_numbers') or {}
if (legacy_on or h.get('candidate_source') == 'dividend'):
if row.get('action') == 'OPEN' and h.get('kind') != 'strategy':
preparation = h.get('preparation') or {}
row['accept_ready'] = preparation.get('status') == 'ready' and bool(h.get('consumption_id'))
row['prepare_reason'] = preparation.get('reason') or '建议正在准备,完成后可采纳'
return rows return rows
return ok(_list) return ok(_list)
@app.get("/api/dividend/candidates")
def api_dividend_candidates():
from app.services import dividend_feed
return ok(dividend_feed.read)
@app.post("/api/dividend/proposals")
def api_dividend_proposal(request: Request, payload: dict = Body(default={})):
from app.services import dividend_feed
actor = _actor(request, payload)
result = ok(dividend_feed.request_preparation, str(payload.get('ts_code') or ''),
payload.get('research_ref'), actor=actor)
_oplog('dividend_prepare', ok_flag=result.get('ok',False), reason=result.get('error') or result.get('message'),
ts_code=payload.get('ts_code'), ref=result.get('proposal_id'), by=actor)
return result
@app.get("/api/proposals/decide-reasons") @app.get("/api/proposals/decide-reasons")
def api_decide_reasons(): def api_decide_reasons():
"""裁决预设理由的两张码表 (采纳 / 驳回), 页面据此铺按钮。台账 015。""" """裁决预设理由的两张码表 (采纳 / 驳回), 页面据此铺按钮。台账 015。"""
return {"ok": True, "accept": decide_reasons.ACCEPT_REASONS, return {"ok": True, "accept": decide_reasons.ACCEPT_REASONS,
"decline": decide_reasons.DECLINE_REASONS} "decline": decide_reasons.DECLINE_REASONS,
# 采纳只做快速检查,不等待完整研判;超时仍按结果未知处理。
"request_timeout_ms": 30000}
@app.post("/api/proposals/{proposal_id}/decide") @app.post("/api/proposals/{proposal_id}/decide")
@ -507,7 +537,17 @@ def api_decide(request: Request, proposal_id: str, payload: dict = Body(default=
p = pms_repo.get_proposal(proposal_id) p = pms_repo.get_proposal(proposal_id)
if not p: if not p:
return {"ok": False, "error": "提议不存在"} return {"ok": False, "error": "提议不存在"}
if (decision == 'ACCEPTED' and p['status'] == 'ACCEPTED' and p['action'] == 'OPEN'
and (p.get('hard_numbers') or {}).get('kind') != 'strategy'):
existing = pms_repo.accepted_open_instruction(proposal_id)
if existing:
return {'ok': True, 'decision': decision, 'instruction_id': existing, 'already_accepted': True}
return {'ok': False, 'error': '该建议已有采纳记录,但指令记录不完整,请联系维护人员核对'}
if p["status"] != "WAIT_USER": if p["status"] != "WAIT_USER":
check = (p.get('hard_numbers') or {}).get('last_accept_check') or {}
if p['status'] == 'EXPIRED' and check.get('status') == 'withdrawn':
return {'ok': False, 'withdrawn': True, 'proposal_id': proposal_id, 'proposal': p,
'error': '提议已撤下。' + (check.get('message') or '当前已不建议执行')}
return {"ok": False, "error": f"提议已处于 {p['status']}"} return {"ok": False, "error": f"提议已处于 {p['status']}"}
# 过了失效时刻的不能再裁决 (2026-09-16): 状态还没被清扫成 EXPIRED 也一样, 顺手清一遍。 # 过了失效时刻的不能再裁决 (2026-09-16): 状态还没被清扫成 EXPIRED 也一样, 顺手清一遍。
from app.services import proposal_service as psvc from app.services import proposal_service as psvc
@ -517,7 +557,49 @@ def api_decide(request: Request, proposal_id: str, payload: dict = Body(default=
except Exception as e: # noqa: BLE001 except Exception as e: # noqa: BLE001
logger.warning("[提议] 过期清扫失败: %s", e) logger.warning("[提议] 过期清扫失败: %s", e)
return {"ok": False, "error": "提议已过失效时刻, 不能再裁决; 该票由系统重新评估"} return {"ok": False, "error": "提议已过失效时刻, 不能再裁决; 该票由系统重新评估"}
if not pms_repo.decide_proposal(proposal_id, decision): if decision == 'ACCEPTED':
from app.services.execution_conflicts import buy_blocker
hn0 = p.get('hard_numbers') or {}
side0 = hn0.get('side') if hn0.get('kind') == 'strategy' else ('sell' if p['action'] in ('TRIM', 'EXIT') else 'buy')
if side0 == 'buy':
blocked = buy_blocker(p['ts_code'])
if blocked:
return {'ok': False, 'error': blocked, 'proposal_id': proposal_id}
expected_hard = None
if (decision == 'ACCEPTED' and p['action'] == ae.A_OPEN
and (param_store.get_bool('PMS_PLAN_VERSION_RECHECK', False)
or (p.get('hard_numbers') or {}).get('candidate_source') == 'dividend')):
from app.services.plan_recheck import before_accept
checked = before_accept(p, payload.get('proposal_revision'))
if not checked.get('ok'):
return checked
expected_hard = p.get('hard_numbers_json')
p = checked['proposal']
if (decision == 'ACCEPTED' and p['action'] == 'OPEN'
and (p.get('hard_numbers') or {}).get('kind') != 'strategy'):
# 先完整准备写入内容,再一次提交。不能先改成已采纳,再独立写账与落指令。
import hashlib
hn = dict(p.get('hard_numbers') or {}, decide_reason_code=reason_code)
window = param_store.get_int('PMS_EXEC_WINDOW_TDAYS', 3)
iid = cs.make_instruction_id(td.ymd(), p['ts_code'], 'OPEN', 1)
iid += '_' + hashlib.sha256(proposal_id.encode()).hexdigest()[:12]
instruction = {'id': iid, 'window': window, 'progress': {
'from_proposal': proposal_id, 'is_command': False, 'children': [],
'plan': {k: hn.get(k) for k in ('decision', 'consumption_id', 'review_ref',
'execution_rank', 'priority_reason', 'version_check',
'candidate_source','dividend_ref','dividend_policy_version')},
'deadline': str(td.window_deadline(None, window))}}
if pms_repo.accept_open_proposal(p, hn, instruction, reason):
return {'ok': True, 'decision': decision, 'instruction_id': iid}
latest = pms_repo.get_proposal(proposal_id)
existing = (pms_repo.accepted_open_instruction(proposal_id)
if latest and latest['status'] == 'ACCEPTED' else None)
if existing:
return {'ok': True, 'decision': decision, 'instruction_id': existing, 'already_accepted': True}
return {'ok': False, 'error': '建议已更新或过期,请查看当前内容', 'proposal': latest}
changed = (pms_repo.decide_proposal(proposal_id, decision, expected_hard=expected_hard)
if expected_hard is not None else pms_repo.decide_proposal(proposal_id, decision))
if not changed:
return {"ok": False, "error": "提议状态已变更, 请刷新"} return {"ok": False, "error": "提议状态已变更, 请刷新"}
hn = p.get("hard_numbers") or {} hn = p.get("hard_numbers") or {}
# 用到的预设理由码进硬数字备查 (复盘要能按码聚合"人常用哪条理由驳回")。 # 用到的预设理由码进硬数字备查 (复盘要能按码聚合"人常用哪条理由驳回")。
@ -545,10 +627,23 @@ def api_decide(request: Request, proposal_id: str, payload: dict = Body(default=
# 等人点采纳时持仓可能已被别的路卖少, 照原数落单会被卖出前的检查整条驳回, # 等人点采纳时持仓可能已被别的路卖少, 照原数落单会被卖出前的检查整条驳回,
# 人点了「清掉」结果一股没卖, 且那条指令会永久在途、挡住后续所有清仓。 # 人点了「清掉」结果一股没卖, 且那条指令会永久在途、挡住后续所有清仓。
cur = pms_repo.get_position(p["ts_code"]) or {} cur = pms_repo.get_position(p["ts_code"]) or {}
if p['action'] == 'EXIT':
# 与命令清仓、信号清仓一致:T+1限制当次出手,不丢弃已确认的清仓安排。
# 不扩大人确认的股数;已卖少的持仓按当前总量缩减。
qty = min(qty, max(0, int(cur.get('total_qty') or 0)))
else:
qty = ae.clamp_sell_qty(qty, cur) qty = ae.clamp_sell_qty(qty, cur)
if qty <= 0: if qty <= 0:
if p['action'] == 'EXIT':
from app.services.execution_conflicts import enforce_exit
stopped = enforce_exit({'instruction_id': proposal_id, 'ts_code': p['ts_code'],
'action': 'EXIT', 'side': 'sell'})
if not stopped['ok']:
return {'ok': False, 'decision': decision,
'error': '已确认清仓,但旧买入收尾未完成:' + ';'.join(stopped['errors'])}
return {"ok": True, "decision": decision, "instruction_id": None, return {"ok": True, "decision": decision, "instruction_id": None,
"note": "这只票现在没有可卖的股数 (已被清掉或今天刚买入), 未落单"} "note": "当前无需要卖出的股数,清仓对应的旧买入已停止" if p['action'] == 'EXIT'
else "当前没有可卖的股数,本次未落单"}
pms_repo.insert_instruction( pms_repo.insert_instruction(
instruction_id=instruction_id, origin_type="proposal", origin_id=proposal_id, instruction_id=instruction_id, origin_type="proposal", origin_id=proposal_id,
ts_code=p["ts_code"], action=p["action"], side=side, qty=qty, ts_code=p["ts_code"], action=p["action"], side=side, qty=qty,
@ -556,6 +651,9 @@ def api_decide(request: Request, proposal_id: str, payload: dict = Body(default=
window_tdays=_win, window_tdays=_win,
status="PROPOSED", status="PROPOSED",
progress={"from_proposal": proposal_id, "is_command": False, "children": [], progress={"from_proposal": proposal_id, "is_command": False, "children": [],
'plan': {k: hn.get(k) for k in ('decision', 'consumption_id', 'review_ref',
'execution_rank', 'priority_reason', 'version_check',
'candidate_source','dividend_ref','dividend_policy_version')},
"deadline": str(td.window_deadline(None, _win))}) "deadline": str(td.window_deadline(None, _win))})
# 与自主执行同一口径: 采纳即算「做过一次」, 计数器要跟着走 # 与自主执行同一口径: 采纳即算「做过一次」, 计数器要跟着走
# (否则页面采纳的那条动作绕开了 §6 的一次性约束) # (否则页面采纳的那条动作绕开了 §6 的一次性约束)
@ -805,12 +903,12 @@ def _research_st(code):
@app.get("/api/research/{ts_code}/report") @app.get("/api/research/{ts_code}/report")
def api_research_report(ts_code: str): def api_research_report(ts_code: str, ref: str = None):
"""个股深度评析全文 (2026-09-18): 上游给的 markdown 由后端代取, 页面自己排版成同款样式。 """个股深度评析全文 (2026-09-18): 上游给的 markdown 由后端代取, 页面自己排版成同款样式。
点击时调, 不进轮询; 按链接缓存十分钟。链接只认上游给的, 不收页面传入的地址。""" 点击时调, 不进轮询; 按链接缓存十分钟。链接只认上游给的, 不收页面传入的地址。"""
from app.services import company_report from app.services import company_report
try: try:
return company_report.get(cs.normalize_code(ts_code)) return company_report.get(cs.normalize_code(ts_code), **({'ref': ref} if ref else {}))
except Exception as e: # noqa: BLE001 except Exception as e: # noqa: BLE001
return {"ok": False, "error": f"评析报告读取失败: {type(e).__name__}: {e}"} return {"ok": False, "error": f"评析报告读取失败: {type(e).__name__}: {e}"}
@ -907,7 +1005,8 @@ def api_upstream_plan(limit: int = Query(30), date: str = Query(None),
plan = plan_feed.get_plan(date=(date or None)) plan = plan_feed.get_plan(date=(date or None))
rows = plan.get("observe" if bucket == "observe" else "main") or [] rows = plan.get("observe" if bucket == "observe" else "main") or []
out["rows"] = rows[:max(1, int(limit or 30))] out["rows"] = rows[:max(1, int(limit or 30))]
out["candidates_raw"] = plan_feed.candidates() out['rows'] = [dict(r, decision=plan.get('decision')) for r in out['rows']]
out["candidates_raw"] = plan_feed.candidates(record=False)
except Exception as e: except Exception as e:
out["status"] = {**st, "ok": False, "hint": f"{type(e).__name__}: {e}"} out["status"] = {**st, "ok": False, "hint": f"{type(e).__name__}: {e}"}
return out return out

View File

@ -394,6 +394,7 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
/* ── 右栏 待办与操作 ── */ /* ── 右栏 待办与操作 ── */
.sect{border-bottom:1px solid var(--hair);padding:2px 0 9px;margin-bottom:9px;} .sect{border-bottom:1px solid var(--hair);padding:2px 0 9px;margin-bottom:9px;}
.sect:last-child{border-bottom:none;} .sect:last-child{border-bottom:none;}
.sect.closed>.sectb{display:none;}
.secth{display:flex;align-items:center;gap:7px;padding:5px 0;cursor:pointer;font-size:13px;font-weight:640;} .secth{display:flex;align-items:center;gap:7px;padding:5px 0;cursor:pointer;font-size:13px;font-weight:640;}
.secth .n{font-weight:500;color:var(--muted);font-size:11.5px;} .secth .n{font-weight:500;color:var(--muted);font-size:11.5px;}
.secth .car{margin-left:auto;color:var(--muted);font-size:10px;} .secth .car{margin-left:auto;color:var(--muted);font-size:10px;}
@ -492,6 +493,17 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
.chip.hd-user{background:var(--accent-weak);color:var(--accent);} .chip.hd-user .dot{background:var(--accent);} .chip.hd-user{background:var(--accent-weak);color:var(--accent);} .chip.hd-user .dot{background:var(--accent);}
/* ── 提议卡: 来源结论行 + 详情弹窗 (2026-09-12 重构) ── */ /* ── 提议卡: 来源结论行 + 详情弹窗 (2026-09-12 重构) ── */
.prop-src{margin:9px 0 4px;border-top:1px solid var(--hair);} .prop-src{margin:9px 0 4px;border-top:1px solid var(--hair);}
.prop-order{margin:7px 0 4px;display:flex;align-items:baseline;justify-content:space-between;gap:8px;flex-wrap:wrap;}
.prop-order b{font-size:15px;font-variant-numeric:tabular-nums;}
.prop-meta{display:flex;align-items:center;gap:6px 12px;flex-wrap:wrap;color:var(--muted);font-size:12px;}
.prop-actions{display:flex;align-items:center;gap:8px;margin-top:8px;}
.prop-actions .el-button+.el-button{margin-left:0;}
.prop-actions .research-link{margin-left:auto;font-size:12px;}
.rail-note{font-size:12px;color:var(--muted);margin:0 0 8px;}
.rail-detail{font-size:12px;color:var(--ink-2);margin-top:5px;overflow-wrap:anywhere;}
.rail-detail summary{cursor:pointer;color:var(--muted);}
.sigrow2.clk .cand-status{flex-basis:100%;font-size:11.5px;color:var(--muted);padding-left:35px;}
.sigrow2.clk .cand-status.would{color:var(--accent);}
.prop-src-row{display:flex;align-items:center;gap:8px;padding:8px 2px;border-bottom:1px solid rgba(0,0,0,.04);cursor:pointer;} .prop-src-row{display:flex;align-items:center;gap:8px;padding:8px 2px;border-bottom:1px solid rgba(0,0,0,.04);cursor:pointer;}
.prop-src-row:last-child{border-bottom:none;} .prop-src-row:last-child{border-bottom:none;}
.prop-src-row:hover{background:var(--surface-2);} .prop-src-row:hover{background:var(--surface-2);}
@ -517,6 +529,17 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
.prop-metric{display:flex;flex-direction:column;gap:7px;margin:8px 0;} .prop-metric{display:flex;flex-direction:column;gap:7px;margin:8px 0;}
.prop-metric .m{background:var(--surface-2);border-radius:9px;padding:9px 11px;display:flex;align-items:center;gap:10px;} .prop-metric .m{background:var(--surface-2);border-radius:9px;padding:9px 11px;display:flex;align-items:center;gap:10px;}
.prop-metric .m .nm{font-size:12.5px;flex:1;} .prop-metric .m .dt{font-size:11px;color:var(--muted);} .prop-metric .m .nm{font-size:12.5px;flex:1;} .prop-metric .m .dt{font-size:11px;color:var(--muted);}
.research-link{display:inline-block;border:0;padding:3px 0;background:none;color:var(--accent);font:inherit;font-size:12px;cursor:pointer;text-align:left;}
.research-link:hover{text-decoration:underline;}
.prop-sheet.research-sheet{left:50%;right:auto;bottom:24px;transform:translateX(-50%);width:min(720px,calc(100vw - 32px));max-height:calc(100vh - 48px);border-radius:16px;}
.research-summary{display:flex;gap:8px;margin-bottom:14px;}
.research-section .st{white-space:pre-wrap;overflow-wrap:anywhere;line-height:1.75;}
.research-section .st + .st{margin-top:8px;}
.research-materials{display:flex;flex-wrap:wrap;gap:6px 16px;margin:18px 0 10px;color:var(--muted);font-size:12px;line-height:1.65;}
.research-source{border-top:1px solid var(--hair);margin-top:16px;padding-top:12px;font-size:12px;color:var(--muted);}
.research-source summary{cursor:pointer;}
.research-source dl{display:grid;grid-template-columns:90px minmax(0,1fr);gap:8px 12px;margin:14px 0 0;}
.research-source dt,.research-source dd{margin:0;overflow-wrap:anywhere;line-height:1.65;}
.prop-badge{font-size:11px;font-family:ui-monospace,Menlo,monospace;background:var(--surface-2);padding:2px 7px;border-radius:5px;} .prop-badge{font-size:11px;font-family:ui-monospace,Menlo,monospace;background:var(--surface-2);padding:2px 7px;border-radius:5px;}
</style> </style>
</head> </head>
@ -540,7 +563,7 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
<!-- 顶栏 (2026-09-18 改成单行): 原来七枚胶囊各带长文字与说明气泡, 右侧再排六个按钮, 窗口不到 1950 就折成两行。 <!-- 顶栏 (2026-09-18 改成单行): 原来七枚胶囊各带长文字与说明气泡, 右侧再排六个按钮, 窗口不到 1950 就折成两行。
现在状态只留一个短词做成标签 (与综合分析列同款), 说明进悬停; 按钮收进右侧一个菜单。整行不折行, 放不下时按重要性从低到高收起。 --> 现在状态只留一个短词做成标签 (与综合分析列同款), 说明进悬停; 按钮收进右侧一个菜单。整行不折行, 放不下时按重要性从低到高收起。 -->
<div class="hd"> <div class="hd">
<h1>PMS 持仓管理<span class="ver">v{{ health.version || '-' }} · {{ health.now || '' }}</span></h1> <h1>PMS 持仓管理<span class="ver"><template v-if="mode==='ops'">v{{ health.version || '-' }} · </template>{{ health.now || '' }}</span></h1>
<div class="hd-tags"> <div class="hd-tags">
<span class="hst" :class="marketOpen?'ok':'idle'" :title="'交易时段:' + marketState + (health.now ? '。服务器时间 ' + health.now : '')">{{ marketState }}</span> <span class="hst" :class="marketOpen?'ok':'idle'" :title="'交易时段:' + marketState + (health.now ? '。服务器时间 ' + health.now : '')">{{ marketState }}</span>
<span class="hst hd-buy" :class="ov.buy_halt?'warn':'ok'" :title="ov.buy_halt ? '买入已暂停:系统不再发起新买入,已挂出未成交的买单已撤;卖出与止损照常。恢复买入在运维视图的「组合操作」。' : '买入正常:系统按规则自动买入。暂停买入在运维视图的「组合操作」。'">买入{{ ov.buy_halt ? '已暂停' : '正常' }}</span> <span class="hst hd-buy" :class="ov.buy_halt?'warn':'ok'" :title="ov.buy_halt ? '买入已暂停:系统不再发起新买入,已挂出未成交的买单已撤;卖出与止损照常。恢复买入在运维视图的「组合操作」。' : '买入正常:系统按规则自动买入。暂停买入在运维视图的「组合操作」。'">买入{{ ov.buy_halt ? '已暂停' : '正常' }}</span>
@ -553,7 +576,7 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
<el-tooltip placement="bottom-start" effect="light" :show-after="120"> <el-tooltip placement="bottom-start" effect="light" :show-after="120">
<template #content> <template #content>
<div style="max-width:360px;font-size:12px;line-height:1.75"> <div style="max-width:360px;font-size:12px;line-height:1.75">
<template v-if="macro.enabled===false"><b>大盘冷热这一层没开</b><div class="muted">在「参数设置」里把 PMS_MACRO_ENABLED 打开</div></template> <template v-if="macro.enabled===false"><b>大盘冷热这一层没开</b><div class="muted">可在运维视图启用大盘冷热分析</div></template>
<template v-else-if="!mzSig"><b>大盘冷热</b>:还没有数据(今天还没扫描过,交易日 09:35 自动跑)</template> <template v-else-if="!mzSig"><b>大盘冷热</b>:还没有数据(今天还没扫描过,交易日 09:35 自动跑)</template>
<template v-else> <template v-else>
<div><b>{{ mzSig.label }}</b> <div><b>{{ mzSig.label }}</b>
@ -770,7 +793,7 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
<span class="disp" :class="lvClass(g.level)" style="padding:0 6px">{{ lvLabel(g.level) }}</span> <span class="disp" :class="lvClass(g.level)" style="padding:0 6px">{{ lvLabel(g.level) }}</span>
</div> </div>
<div class="muted" style="margin-top:9px;font-size:11.5px"> <div class="muted" style="margin-top:9px;font-size:11.5px">
灰掉的是已经过时的:超过设定的时效还没有新的同类信号盖过它。不隐藏,只是提醒你别再当新消息看。</div> 淡色信号已过时,仅供回顾。</div>
</template> </template>
<div class="muted" v-if="sigOld.length" @click="showOldSig=!showOldSig" <div class="muted" v-if="sigOld.length" @click="showOldSig=!showOldSig"
style="margin:10px 0 5px;font-weight:600;font-size:11.5px;border-top:1px dashed var(--hair);padding-top:8px;cursor:pointer"> style="margin:10px 0 5px;font-weight:600;font-size:11.5px;border-top:1px dashed var(--hair);padding-top:8px;cursor:pointer">
@ -962,13 +985,13 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
<main class="tmain"> <main class="tmain">
<div class="metrics"> <div class="metrics">
<div class="m"><div class="k">账户总资产</div><div class="v">{{ money(ov.total_asset) }}</div></div> <div class="m"><div class="k">账户总资产<span class="help" data-tip="采用账户资金快照中的总资产,包含账户现金和持仓估值;与用户设定的策略总规模不同。">?</span></div><div class="v">{{ money(ov.total_asset) }}</div></div>
<div class="m"><div class="k">可用资金<span class="muted" v-if="ov.cash_source!=='ws'"> (估算)</span></div> <div class="m"><div class="k">可用资金<span class="muted" v-if="ov.cash_source!=='ws'"> (估算)</span><span class="help" :data-tip="ov.cash_source==='ws' ? '采用账户报告的可用余额,已含可用的卖出回笼,不重复相加。账户冻结资金 ' + money(ov.frozen_cash) + ' 元。' : '账户资金暂不可用,此处仅按策略总规模减行情估值展示估算余额,不能视为账户可用资金。'">?</span></div>
<div class="v" :class="ov.cash_source==='ws'?'':'muted'">{{ money(ov.cash_source==='ws' ? ov.cash_avail : ov.cash_est) }}</div></div> <div class="v" :class="ov.cash_source==='ws'?'':'muted'">{{ money(ov.cash_source==='ws' ? ov.cash_avail : ov.cash_est) }}</div></div>
<div class="m"><div class="k">持仓市值</div><div class="v">{{ money(ov.portfolio_mv) }}</div></div> <div class="m"><div class="k">账户持仓市值<span class="help" :data-tip="'与总资产、可用资金采用同一份账户快照。持仓明细按行情估值,当前为 ' + money(ov.portfolio_mv) + ' 元;两者可能因估值价格不同而有差异。'">?</span></div><div class="v">{{ money(ov.account_market_value) }}</div></div>
<div class="m"><div class="k">仓位<span class="muted" style="margin-left:4px">上限 {{ pct(ov.portfolio_cap) }}</span></div> <div class="m"><div class="k" style="flex-wrap:wrap">策略仓位<span class="help" style="flex-shrink:0" :data-tip="'按持仓行情估值 ' + money(ov.portfolio_mv) + ' 元除以用户设定总规模 ' + money(ov.scale) + ' 元计算,仓位纪律沿用此口径。'">?</span><span class="muted" style="margin-left:4px">上限 {{ pct(ov.portfolio_cap) }}</span></div>
<div class="v">{{ pct(ov.portfolio_pct) }}</div></div> <div class="v">{{ pct(ov.portfolio_pct) }}</div></div>
<div class="m"><div class="k">浮动盈亏</div> <div class="m"><div class="k">持仓综合盈亏<span class="help" data-tip="按摊薄成本计算,包含当前持仓对应股票此前卖出已实现的盈亏,不等于剩余股份的浮动盈亏。">?</span></div>
<div class="v" :class="(ov.float_pnl||0)>=0?'up':'down'">{{ money(ov.float_pnl) }}<span style="font-size:12px"> {{ ov.float_pnl_pct==null?'':pct(ov.float_pnl_pct) }}</span></div></div> <div class="v" :class="(ov.float_pnl||0)>=0?'up':'down'">{{ money(ov.float_pnl) }}<span style="font-size:12px"> {{ ov.float_pnl_pct==null?'':pct(ov.float_pnl_pct) }}</span></div></div>
<div class="m"><div class="k">持仓只数<span class="muted" style="margin-left:4px">上限 {{ ov.max_names }}</span></div> <div class="m"><div class="k">持仓只数<span class="muted" style="margin-left:4px">上限 {{ ov.max_names }}</span></div>
<div class="v">{{ ov.names_count }}</div></div> <div class="v">{{ ov.names_count }}</div></div>
@ -986,11 +1009,8 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
<!-- 持仓: 操作折叠成一枚「⋯」, 表格在中栏放得下; 比中栏还宽时横向滚动 --> <!-- 持仓: 操作折叠成一枚「⋯」, 表格在中栏放得下; 比中栏还宽时横向滚动 -->
<div class="panel tblk postbl" id="t-pos"> <div class="panel tblk postbl" id="t-pos">
<h3>持仓 <span class="muted" style="font-weight:400">· {{ heldPositions.length }} 只</span></h3> <h3>持仓 <span class="muted" style="font-weight:400">· {{ heldPositions.length }} 只</span></h3>
<div class="sub2">安全垫<span class="help" data-tip="现在的浮盈够不够厚,够不够扛一次回撤。厚垫=赚得多,可以考虑加仓;薄垫=刚开始赚;浮亏无垫=还在亏,不加仓。">?</span> <div class="sub2">占比按总操作规模计算。
看的是浮盈厚不厚:厚垫可以考虑加仓,薄垫先放着,浮亏无垫不加仓。 <span class="help" data-tip="摊薄成本=(剩余批次买入金额-此前卖出已实现盈亏)÷剩余股数,不是券商买入均价。综合盈亏与安全垫均按摊薄成本计算;减仓后股数较少时,收益率可能明显放大。人工设定价仅随人工命令变更,系统参考位另见管理视图。">?</span></div>
成本是各批买入价的加权平均,占比是占总操作规模的百分比。
「人工设定价」这一列是人工通过命令设定的止损价与目标价,一直在,人工改动才变;
系统每天早上自己算的参考位是另一回事,在管理视图的持仓总览里看。</div>
<el-table :data="heldPositions" size="small" border max-height="480" @expand-change="onPosExpand"> <el-table :data="heldPositions" size="small" border max-height="480" @expand-change="onPosExpand">
<el-table-column type="expand" width="40"> <el-table-column type="expand" width="40">
<template #default="s"> <template #default="s">
@ -1021,7 +1041,7 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
<el-table-column label="股票" width="120"> <el-table-column label="股票" width="120">
<template #default="s"><b>{{ nm(s.row.ts_code) }}</b><br><span class="muted mono">{{ s.row.ts_code }}</span></template> <template #default="s"><b>{{ nm(s.row.ts_code) }}</b><br><span class="muted mono">{{ s.row.ts_code }}</span></template>
</el-table-column> </el-table-column>
<el-table-column label="现价 / 成本" width="96"> <el-table-column label="现价 / 摊薄成本" width="96">
<template #default="s">{{ s.row.price }}<span v-if="!s.row.price_ok" class="muted"> 估</span><br><span class="muted">{{ s.row.avg_cost||'—' }}</span></template> <template #default="s">{{ s.row.price }}<span v-if="!s.row.price_ok" class="muted"> 估</span><br><span class="muted">{{ s.row.avg_cost||'—' }}</span></template>
</el-table-column> </el-table-column>
<!-- 我设的止损价与目标价: 读命令表带出来的 user_stop_price / user_target_price, <!-- 我设的止损价与目标价: 读命令表带出来的 user_stop_price / user_target_price,
@ -1036,7 +1056,7 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
v-else class="muted">未设</span> v-else class="muted">未设</span>
</template> </template>
</el-table-column> </el-table-column>
<el-table-column label="浮动盈亏" width="76"> <el-table-column label="综合盈亏" width="76">
<template #default="s"> <template #default="s">
<span v-if="s.row.price_ok && s.row.avg_cost" :class="(s.row.price/s.row.avg_cost-1)>=0?'clr-up':'clr-down'">{{ pct(s.row.price/s.row.avg_cost-1) }}</span> <span v-if="s.row.price_ok && s.row.avg_cost" :class="(s.row.price/s.row.avg_cost-1)>=0?'clr-up':'clr-down'">{{ pct(s.row.price/s.row.avg_cost-1) }}</span>
<span v-else class="muted">—</span> <span v-else class="muted">—</span>
@ -1073,7 +1093,7 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
</template> </template>
<span v-else class="muted" style="cursor:pointer;text-decoration:underline dotted" <span v-else class="muted" style="cursor:pointer;text-decoration:underline dotted"
@click.stop="openCodeSignals(s.row.ts_code)" @click.stop="openCodeSignals(s.row.ts_code)"
title="速览只留了每类最新的若干条,这里的「没有」可能是假的。点一下按代码回扫今天全部。">今天没有</span> title="速览未收录信号,点击查看今日完整记录。">暂无速览</span>
</template> </template>
</el-table-column> </el-table-column>
<!-- 状态 · 下一步 (2026-09-15 重排): 第一行是芯片 (持仓状态 / 挂着的交易方案 / 只卖不买), 第二行一句短语, <!-- 状态 · 下一步 (2026-09-15 重排): 第一行是芯片 (持仓状态 / 挂着的交易方案 / 只卖不买), 第二行一句短语,
@ -1124,7 +1144,7 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
<el-table-column label="做什么" width="150"><template #default="s">{{ tx('action', s.row.action) }} · {{ tx('side', s.row.side) }}</template></el-table-column> <el-table-column label="做什么" width="150"><template #default="s">{{ tx('action', s.row.action) }} · {{ tx('side', s.row.side) }}</template></el-table-column>
<el-table-column label="下单量 / 已成交" width="130" align="right"><template #default="s"><span class="mono">{{ s.row.qty }} / {{ s.row.exec_qty||0 }}</span></template></el-table-column> <el-table-column label="下单量 / 已成交" width="130" align="right"><template #default="s"><span class="mono">{{ s.row.qty }} / {{ s.row.exec_qty||0 }}</span></template></el-table-column>
<el-table-column label="限价" width="82" align="right"><template #default="s"><span class="mono">{{ s.row.limit_price||'—' }}</span></template></el-table-column> <el-table-column label="限价" width="82" align="right"><template #default="s"><span class="mono">{{ s.row.limit_price||'—' }}</span></template></el-table-column>
<el-table-column label="进展" min-width="130"><template #default="s"><span class="chip idle"><span class="dot"></span>{{ tx('insStatus', s.row.status) }}</span></template></el-table-column> <el-table-column label="进展" min-width="130"><template #default="s"><span class="chip idle"><span class="dot"></span>{{ s.row.execution_label || tx('insStatus', s.row.status) }}</span></template></el-table-column>
<el-table-column label="操作" width="76"><template #default="s"><button class="tbtn sm" @click="cancelIns(s.row.instruction_id)">撤单</button></template></el-table-column> <el-table-column label="操作" width="76"><template #default="s"><button class="tbtn sm" @click="cancelIns(s.row.instruction_id)">撤单</button></template></el-table-column>
</el-table> </el-table>
</el-tab-pane> </el-tab-pane>
@ -1134,7 +1154,7 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
<el-table-column label="股票" min-width="150"><template #default="s"><b>{{ nm(s.row.ts_code) }}</b> <span class="muted mono">{{ s.row.ts_code }}</span></template></el-table-column> <el-table-column label="股票" min-width="150"><template #default="s"><b>{{ nm(s.row.ts_code) }}</b> <span class="muted mono">{{ s.row.ts_code }}</span></template></el-table-column>
<el-table-column label="做什么" width="150"><template #default="s">{{ tx('action', s.row.action) }} · {{ tx('side', s.row.side) }}</template></el-table-column> <el-table-column label="做什么" width="150"><template #default="s">{{ tx('action', s.row.action) }} · {{ tx('side', s.row.side) }}</template></el-table-column>
<el-table-column label="下单量 / 已成交" width="130" align="right"><template #default="s"><span class="mono">{{ s.row.qty }} / {{ s.row.exec_qty||0 }}</span></template></el-table-column> <el-table-column label="下单量 / 已成交" width="130" align="right"><template #default="s"><span class="mono">{{ s.row.qty }} / {{ s.row.exec_qty||0 }}</span></template></el-table-column>
<el-table-column label="进展" min-width="130"><template #default="s"><span class="chip ok"><span class="dot"></span>{{ tx('insStatus', s.row.status) }}</span></template></el-table-column> <el-table-column label="进展" min-width="130"><template #default="s"><span class="chip ok"><span class="dot"></span>{{ s.row.execution_label || tx('insStatus', s.row.status) }}</span></template></el-table-column>
</el-table> </el-table>
</el-tab-pane> </el-tab-pane>
<el-tab-pane name="end"> <el-tab-pane name="end">
@ -1142,7 +1162,7 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
<el-table :data="insEnd" size="small" max-height="280" empty-text="今天没有结束掉的单"> <el-table :data="insEnd" size="small" max-height="280" empty-text="今天没有结束掉的单">
<el-table-column label="股票" min-width="150"><template #default="s"><b>{{ nm(s.row.ts_code) }}</b> <span class="muted mono">{{ s.row.ts_code }}</span></template></el-table-column> <el-table-column label="股票" min-width="150"><template #default="s"><b>{{ nm(s.row.ts_code) }}</b> <span class="muted mono">{{ s.row.ts_code }}</span></template></el-table-column>
<el-table-column label="做什么" width="150"><template #default="s">{{ tx('action', s.row.action) }} · {{ tx('side', s.row.side) }}</template></el-table-column> <el-table-column label="做什么" width="150"><template #default="s">{{ tx('action', s.row.action) }} · {{ tx('side', s.row.side) }}</template></el-table-column>
<el-table-column label="怎么结束的" min-width="150"><template #default="s"><span class="chip warn"><span class="dot"></span>{{ tx('insStatus', s.row.status) }}</span></template></el-table-column> <el-table-column label="怎么结束的" min-width="150"><template #default="s"><span class="chip warn"><span class="dot"></span>{{ s.row.execution_label || tx('insStatus', s.row.status) }}</span></template></el-table-column>
</el-table> </el-table>
</el-tab-pane> </el-tab-pane>
<el-tab-pane name="deny"> <el-tab-pane name="deny">
@ -1173,7 +1193,7 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
<span class="muted" style="font-weight:400">· {{ opLog.length }} 条</span> <span class="muted" style="font-weight:400">· {{ opLog.length }} 条</span>
<span class="muted" style="font-size:12px;font-weight:normal">{{ showOpLog?'▲ 收起':'▼ 展开' }}</span></h3> <span class="muted" style="font-size:12px;font-weight:normal">{{ showOpLog?'▲ 收起':'▼ 展开' }}</span></h3>
<template v-if="showOpLog"> <template v-if="showOpLog">
<div class="muted" style="margin-bottom:6px">你每做一次操作留一行;被规则挡下的也记下原因。</div> <div class="muted" style="margin-bottom:6px">记录操作结果及未执行原因。</div>
<div class="muted" v-if="!opLog.length">还没有操作记录。</div> <div class="muted" v-if="!opLog.length">还没有操作记录。</div>
<div v-for="(o,i) in opLog" :key="i" class="feed-row"> <div v-for="(o,i) in opLog" :key="i" class="feed-row">
<span class="muted mono">{{ (o.at||'').slice(11,16) }}</span> <span class="muted mono">{{ (o.at||'').slice(11,16) }}</span>
@ -1208,33 +1228,29 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
<div class="secth" @click="toggleSect('prop')">待确认提议 <div class="secth" @click="toggleSect('prop')">待确认提议
<span class="n">· {{ proposals.length }} 条</span><span class="car">{{ sectClosed.prop?'▸':'▾' }}</span></div> <span class="n">· {{ proposals.length }} 条</span><span class="car">{{ sectClosed.prop?'▸':'▾' }}</span></div>
<div class="sectb"> <div class="sectb">
<div class="muted" v-if="!proposals.length">当前没有需人工确认的事。</div> <div class="muted" v-if="!proposals.length">暂无待确认提议。</div>
<div v-for="p in preparingProposals" :key="p.proposal_id" class="st muted" style="margin-bottom:8px">
{{ nm(p.ts_code) }} · {{ p.prepare_reason }}
<button class="research-link" @click="decide(p,'DECLINED')">放弃</button>
</div>
<div v-if="proposals.length" class="rail-note">采纳后生成待执行指令;驳回后今日不再提议。</div>
<div v-for="p in proposals" :key="p.proposal_id" class="mini"> <div v-for="p in proposals" :key="p.proposal_id" class="mini">
<div class="top"><b class="lk" title="查看个股详情" @click="openCodeSignals(p.ts_code)">{{ nm(p.ts_code) }}</b> <div class="top"><b class="lk" title="查看个股详情" @click="openCodeSignals(p.ts_code)">{{ nm(p.ts_code) }}</b>
<span class="muted mono lk" style="font-size:11px" title="查看个股详情" @click="openCodeSignals(p.ts_code)">{{ p.ts_code }}</span> <span class="muted mono lk" style="font-size:11px" title="查看个股详情" @click="openCodeSignals(p.ts_code)">{{ p.ts_code }}</span>
<el-tag size="small" effect="dark" type="primary">{{ tx('action', p.action) }}</el-tag> <el-tag size="small" effect="dark" type="primary">{{ tx('action', p.action) }}</el-tag>
<span class="spacer"></span><span class="muted" style="font-size:11px">{{ p.expire_at }} 前有效</span></div> <span class="spacer"></span></div>
<!-- 2026-09-10 重排。原先这里一口气铺十六行、实测一张卡二十七八个可视行, <!-- 只调整呈现:数量、金额和仓位差异在卡面,重算过程保留在数量说明。 -->
其中大半是「暂无」「近三天没点名」这类占位句 —— 要人在一屏读不完的 <div class="prop-order"><b>{{ p.qty }} 股</b><span>预计金额 <b>{{ propAmount(p) }}</b></span></div>
文字里自己找哪一条是要紧的。现在按「决定要不要点采纳所必需」分两层: <div class="prop-meta"><span>参考价 {{ (p.hard_numbers||{}).price==null ? '—' : (p.hard_numbers||{}).price }}</span>
必需的留在卡面, 证据类的收进展开。判定用的键一个都没动, 只动 DOM。 --> <span v-if="propSizePct(p)">占总规模 {{ propSizePct(p) }}</span></div>
<div class="st" v-if="propAdviceTier(p)"><span class="muted">建议 </span>{{ propAdviceTier(p) }}</div>
<!-- 第一行就是这一笔到底买多少。原先它排在第十四行, 而它才是采纳按钮真正 <div class="st" v-if="propSizeMismatch(p)" style="color:var(--warn)">{{ propSizeMismatch(p) }}</div>
会执行的东西。 -->
<div class="st"><b>{{ p.qty }} 股</b> · 参考价 {{ (p.hard_numbers||{}).price==null ? '—' : (p.hard_numbers||{}).price }}
· 约需 <b>{{ money(((p.hard_numbers||{}).price||0)*(p.qty||0)) }}</b>
<span class="muted" v-if="propSizePct(p)">(占总规模 {{ propSizePct(p) }})</span></div>
<!-- 建议档位与实际下单量对不对得上。对不上就直接说, 别让人自己去算。 -->
<div class="st" v-if="propAdviceTier(p)"><span class="muted">建议档位:</span>{{ propAdviceTier(p) }}</div>
<div class="st" v-if="propSizeMismatch(p)" style="color:#d8574a">{{ propSizeMismatch(p) }}</div>
<div class="st muted" v-if="propResized(p)">{{ propResized(p) }}</div>
<!-- 四行来源结论, 点开看完整依据 (2026-09-12 重构): 原先每类一整句平铺在卡面, <!-- 四行来源结论, 点开看完整依据 (2026-09-12 重构): 原先每类一整句平铺在卡面,
公司深度那句最长 —— 现在卡面只留结论标签, 整句进弹窗。判定用的键一个没动。 --> 公司深度那句最长 —— 现在卡面只留结论标签, 整句进弹窗。判定用的键一个没动。 -->
<div class="prop-src"> <div class="prop-src">
<div class="prop-src-row" v-if="propPlanTag(p)" @click="openPropDetail(p,'plan')"> <div class="prop-src-row" v-if="propPlanTag(p)" @click="openPropDetail(p,'plan')">
<span class="lbl">选股系统</span> <span class="lbl">{{ (p.hard_numbers||{}).candidate_source==='dividend' ? '高股息研究' : '选股系统' }}</span>
<span class="ptag" :class="propPlanTag(p).cls">{{ propPlanTag(p).text }}</span> <span class="ptag" :class="propPlanTag(p).cls">{{ propPlanTag(p).text }}</span>
<span class="sub">{{ propPlanSub(p) }}</span><i class="car">›</i> <span class="sub">{{ propPlanSub(p) }}</span><i class="car">›</i>
</div> </div>
@ -1261,11 +1277,15 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
<span class="sub">{{ propTimingSub(p) }}</span><i class="car">›</i> <span class="sub">{{ propTimingSub(p) }}</span><i class="car">›</i>
</div> </div>
</div> </div>
<div style="margin-top:6px"> <div v-if="(p.hard_numbers||{}).last_accept_check" class="st" style="color:var(--warn)">
最近核验未通过。<button class="research-link" @click="decide(p,'ACCEPTED')">查看原因</button>
</div>
<div class="prop-actions">
<el-button type="success" size="small" @click="decide(p,'ACCEPTED')">采纳</el-button> <el-button type="success" size="small" @click="decide(p,'ACCEPTED')">采纳</el-button>
<el-button type="danger" size="small" @click="decide(p,'DECLINED')">驳回</el-button> <el-button type="danger" size="small" @click="decide(p,'DECLINED')">驳回</el-button>
<button class="research-link" v-if="propResized(p) || propSizeMismatch(p)" @click="openPropDetail(p,'size')">数量说明</button>
</div> </div>
<div class="muted" style="font-size:11px;margin-top:4px">采纳=生成一笔待执行的指令,系统会在允许下单的时间段里挑时机下出去;驳回=今天不再提这只。</div> <div class="muted" style="font-size:11px;margin-top:5px" :title="p.expire_at">{{ propExpiry(p.expire_at) }}</div>
</div> </div>
</div> </div>
</div> </div>
@ -1273,17 +1293,17 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
<!-- 交易方案 --> <!-- 交易方案 -->
<div class="sect" :class="{closed:sectClosed.strat}" id="t-strat"> <div class="sect" :class="{closed:sectClosed.strat}" id="t-strat">
<div class="secth" @click="toggleSect('strat')">交易方案 <div class="secth" @click="toggleSect('strat')">交易方案
<span class="n">· {{ strategies.length }} 个</span><span class="car">{{ sectClosed.strat?'▸':'▾' }}</span></div> <span class="n">· {{ strategiesShown.length }} 个</span><span class="car">{{ sectClosed.strat?'▸':'▾' }}</span></div>
<div class="sectb"> <div class="sectb">
<div class="muted" style="margin-bottom:6px"> <div class="muted" style="margin-bottom:6px">
{{ stratEnabled ? '策略功能已开启' : '策略功能没开(参数 PMS_STRATEGY_ENABLED)' }}<template v-if="autoInfo"> · {{ stratEnabled ? '执行已开启' : '执行已关闭' }}<template v-if="autoInfo"> ·
{{ autoInfo.enabled ? '自动挂方案已开启' : '自动挂方案没开' }}</template> {{ autoInfo.enabled ? '自动安排' : '手动安排' }}</template>
<template v-if="autoInfo && autoInfo.ran_today && autoInfo.last_scan"> · 今天 <template v-if="autoInfo && autoInfo.ran_today && autoInfo.last_scan"> · 今天
{{ (autoInfo.last_scan.at||'').slice(11,16) }} 跑过一轮</template> {{ (autoInfo.last_scan.at||'').slice(11,16) }} 已评估</template>
<template v-else-if="autoInfo"> · 今天还没跑(交易日 09:40 自动跑)</template> <template v-else-if="autoInfo"> · 今日尚未评估</template>
</div> </div>
<el-alert v-if="!stratEnabled" type="info" effect="dark" :closable="false" show-icon style="margin-bottom:8px" <el-alert v-if="!stratEnabled" type="info" effect="dark" :closable="false" show-icon style="margin-bottom:8px"
title="策略挂上了也不会下单:要在运维视图的「参数设置」里把 PMS_STRATEGY_ENABLED 打开。至于是真下单还是只记录,由 PMS_DISPATCH_MODE 决定。"></el-alert> title="交易方案执行已关闭。启用方式与下单模式见运维视图。"></el-alert>
<div class="row" style="margin-bottom:8px"> <div class="row" style="margin-bottom:8px">
<el-checkbox v-model="showAllStrategies" @change="loadStrategies" size="small" style="font-weight:normal">显示已撤下和已完成</el-checkbox> <el-checkbox v-model="showAllStrategies" @change="loadStrategies" size="small" style="font-weight:normal">显示已撤下和已完成</el-checkbox>
@ -1337,9 +1357,10 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
<span class="spacer"></span> <span class="spacer"></span>
<el-tag size="small" :type="s.status==='ACTIVE'?'primary':'info'">{{ tx('stratStatus', s.status) }}</el-tag></div> <el-tag size="small" :type="s.status==='ACTIVE'?'primary':'info'">{{ tx('stratStatus', s.status) }}</el-tag></div>
<div class="st">{{ stratStateText(s) }}</div> <div class="st">{{ stratStateText(s) }}</div>
<div class="st" style="color:var(--warn)" v-if="s.buy_paused"> <template v-if="s.buy_paused">
这只票现在只卖不买。决策系统提示{{ s.buy_paused.reason || '资金异动' }},已经停掉买入; <div class="st" style="color:var(--warn)">买入已暂停,卖出照常。</div>
卖出、以及把当天做T买的那部分卖回去,都不受影响。</div> <details class="rail-detail"><summary>暂停原因</summary>{{ s.buy_paused.reason || '未记录具体原因' }}</details>
</template>
<div style="margin-top:6px"> <div style="margin-top:6px">
<el-button v-if="s.status==='ACTIVE'" size="small" @click="setStrategyStatus(s.strategy_id,'PAUSED')">暂停</el-button> <el-button v-if="s.status==='ACTIVE'" size="small" @click="setStrategyStatus(s.strategy_id,'PAUSED')">暂停</el-button>
<el-button v-else-if="s.status==='PAUSED'" size="small" type="success" @click="setStrategyStatus(s.strategy_id,'ACTIVE')">恢复</el-button> <el-button v-else-if="s.status==='PAUSED'" size="small" type="success" @click="setStrategyStatus(s.strategy_id,'ACTIVE')">恢复</el-button>
@ -1354,17 +1375,15 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
</div> </div>
<!-- 建仓候选 --> <!-- 建仓候选 -->
<div class="sect" :class="{closed:sectClosed.pool}"> <div class="sect" :class="{closed:sectClosed.pool}" id="t-pool">
<div class="secth" @click="toggleSect('pool')">建仓候选 <div class="secth" @click="toggleSect('pool')">建仓候选
<span class="n">· {{ watchCandidates.length }} 只</span><span class="car">{{ sectClosed.pool?'▸':'▾' }}</span></div> <span class="n">· {{ watchCandidates.length }} 只</span><span class="car">{{ sectClosed.pool?'▸':'▾' }}</span></div>
<div class="sectb"> <div class="sectb">
<div class="muted" style="margin-bottom:5px">今天选股计划里、系统仍在评估、可能建仓的票。计划数据至 {{ planStatus.date || '—' }}<template <div class="rail-note">行情截至 {{ planStatus.date || '—' }}<template v-if="planFetchedText"> · {{ planFetchedText.replace('拉取','更新') }}</template></div>
v-if="planFetchedText">,{{ planFetchedText }}</template>。 <div class="pool-note" v-if="scanNotes.length"><div v-for="n in scanNotes" :key="n">{{ n }}</div></div>
已下单、待确认、未建仓的,分别在「当日指令」和「待确认提议」。</div> <div class="pool-note" v-if="openScan.ok===false">候选评估暂不可用,以下仅供观察。</div>
<div class="pool-note" v-if="(openScan.notes||[]).length"> <div class="muted" v-if="planStatus.ok===false">选股计划暂不可用。</div>
<span v-for="(n,i) in openScan.notes" :key="i">{{ n }}<span v-if="i < openScan.notes.length-1">;</span></span></div> <div class="muted" v-else-if="!watchCandidates.length">暂无待评估候选。</div>
<div class="muted" v-if="planStatus.ok===false">上游的选股计划现在读不到。</div>
<div class="muted" v-else-if="!watchCandidates.length">当前没有待建仓的候选,都已处理。</div>
<div v-else v-for="r in watchCandidates" :key="r.ts_code" class="sigrow2 clk" <div v-else v-for="r in watchCandidates" :key="r.ts_code" class="sigrow2 clk"
:title="'查看个股详情' + (dispOf(r.ts_code).label ? ' · ' + dispOf(r.ts_code).label : '') + (dispOf(r.ts_code).why ? ':' + dispOf(r.ts_code).why : '')" :title="'查看个股详情' + (dispOf(r.ts_code).label ? ' · ' + dispOf(r.ts_code).label : '') + (dispOf(r.ts_code).why ? ':' + dispOf(r.ts_code).why : '')"
@click="openCodeSignals(r.ts_code)"> @click="openCodeSignals(r.ts_code)">
@ -1379,14 +1398,33 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
<span class="dim" :class="dimCls(conOf(r.ts_code).tech)" :title="'技术面 ' + (conOf(r.ts_code).tech||'无读数') + (conOf(r.ts_code).phase ? ' · ' + conOf(r.ts_code).phase : '')">技术面</span> <span class="dim" :class="dimCls(conOf(r.ts_code).tech)" :title="'技术面 ' + (conOf(r.ts_code).tech||'无读数') + (conOf(r.ts_code).phase ? ' · ' + conOf(r.ts_code).phase : '')">技术面</span>
<span class="dim" :class="dimCls(conOf(r.ts_code).timing)" :title="'择时 ' + (conOf(r.ts_code).timing||'无读数')">择时</span> <span class="dim" :class="dimCls(conOf(r.ts_code).timing)" :title="'择时 ' + (conOf(r.ts_code).timing||'无读数')">择时</span>
</template> </template>
<!-- 等待态 (候选观察/技术面待开口/盘中确认中/择时待转多) 不占行内位置: 这一栏本来就是
还在评估的票, 原因进悬停; 只有拟建仓、系统已放弃这类有动作意义的才显示芯片。 -->
<span class="disp" v-if="dispOf(r.ts_code).cls !== 'wait'" :class="dispOf(r.ts_code).cls" style="padding:0 6px">{{ dispOf(r.ts_code).label }}</span>
</span> </span>
<span class="cand-status" :class="dispOf(r.ts_code).cls">{{ dispOf(r.ts_code).label }}</span>
</div> </div>
<div class="muted" style="margin-top:6px;font-size:11.5px"> <button class="research-link" style="margin-top:8px" @click="openPlan">查看完整选股计划</button>
受益层级<span class="help" data-tip="这只票离主题多近:直接受益还是间接受益。上游的选股计划给的。">?</span> </div>
和完整明细,在右上角菜单的「选股计划」里。</div> </div>
<div class="sect" :class="{closed:sectClosed.dividend}">
<div class="secth" @click="toggleSect('dividend')">高股息研究
<span class="n">· {{ dividend.eligible_count || 0 }} 只可评估</span><span class="car">{{ sectClosed.dividend?'▸':'▾' }}</span></div>
<div class="sectb">
<div class="rail-note" v-if="dividend.data_date">股息数据截至 {{ dividend.data_date }} · 人工发起建仓评估</div>
<div class="muted" v-if="dividend.error">{{ dividend.error }}</div>
<div class="muted" v-else-if="!dividend.eligible_count">暂无公司通过全部核验。</div>
<div class="mini" v-for="r in dividendShown" :key="r.ts_code">
<div class="top"><b>{{ r.name || r.ts_code }}</b><span class="spacer"></span><span class="muted">滚动股息 {{ Number(r.yield_ttm_pct).toFixed(2) }}%</span></div>
<div class="muted">{{ r.eligible ? '可评估建仓' : r.conclusion }}</div>
<details style="margin-top:5px"><summary class="research-link">依据与待核验事项</summary>
<p v-if="r.thesis">{{ r.thesis }}</p><p v-if="r.antithesis">风险:{{ r.antithesis }}</p>
<div v-for="reason in (r.reasons||[]).filter(x=>x!=='分红持续性'+r.conclusion && x!=='个股资料仍有待核验事项')" :key="reason" class="muted">{{ reason }}</div>
<details v-if="(r.needs||[]).length" class="research-source"><summary>查看完整核验记录</summary>
<div v-for="item in r.needs" :key="item" class="muted">{{ item }}</div>
</details>
</details>
<el-button v-if="r.eligible" size="small" style="margin-top:6px" :loading="dividendBusy===r.ts_code"
:disabled="!!dividendBusy" @click="prepareDividend(r)">准备建仓建议</el-button>
</div>
<button class="research-link" v-if="(dividend.rows||[]).length>3" @click="dividendMore=!dividendMore">{{ dividendMore?'收起':'查看全部研究公司' }}</button>
</div> </div>
</div> </div>
@ -1399,18 +1437,30 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
<!-- 挂交易方案 对话框 (非盲填: 现价 / 持仓 / 可卖 / 浮盈都摆出来) --> <!-- 挂交易方案 对话框 (非盲填: 现价 / 持仓 / 可卖 / 浮盈都摆出来) -->
<!-- 裁决弹窗 (2026-09-14 台账 015): 采纳/驳回从预设理由里选, 选其他再补一句。 --> <!-- 裁决弹窗 (2026-09-14 台账 015): 采纳/驳回从预设理由里选, 选其他再补一句。 -->
<el-dialog v-model="decideDlg.visible" width="460px" <el-dialog v-model="decideDlg.visible" width="460px" :z-index="3200"
:title="(decideDlg.decision==='ACCEPTED'?'采纳':'驳回') + ' · ' + (decideDlg.row ? nm(decideDlg.row.ts_code) : '') + (decideDlg.row ? ' ' + tx('action', decideDlg.row.action) : '')"> :close-on-click-modal="!decideDlg.busy" :close-on-press-escape="!decideDlg.busy" :show-close="!decideDlg.busy"
:title="(decideDlg.withdrawn?'提议已撤下':(decideDlg.decision==='ACCEPTED'?'采纳':'驳回')) + ' · ' + (decideDlg.row ? nm(decideDlg.row.ts_code) : '') + (decideDlg.row ? ' ' + tx('action', decideDlg.row.action) : '')">
<div v-if="decideDlg.row && !decideDlg.withdrawn" class="prop-order" style="margin-bottom:10px">
<b>{{ decideDlg.row.qty }} 股</b><span>预计金额 <b>{{ propAmount(decideDlg.row) }}</b></span>
</div>
<el-alert v-if="decideDlg.message" :title="decideDlg.message" type="warning" :closable="false"
show-icon style="margin-bottom:10px;white-space:pre-line"></el-alert>
<div v-if="decideDlg.updated" class="why" style="margin-bottom:10px">{{ decideDlg.row.judge_reason || propWhy(decideDlg.row) }}</div>
<div v-if="decideDlg.busy" class="muted" role="status" style="margin-bottom:10px">
正在确认交易条件,请勿重复提交。
</div>
<template v-if="!decideDlg.withdrawn">
<div class="muted" style="margin-bottom:8px;font-size:12px">选一个理由记进评审账本。选「其他」时补充必填。</div> <div class="muted" style="margin-bottom:8px;font-size:12px">选一个理由记进评审账本。选「其他」时补充必填。</div>
<el-radio-group v-model="decideDlg.code" style="display:flex;flex-direction:column;gap:6px;align-items:flex-start"> <el-radio-group v-model="decideDlg.code" style="display:flex;flex-direction:column;gap:6px;align-items:flex-start">
<el-radio v-for="(label,code) in decideCodes" :key="code" :label="code">{{ label }}</el-radio> <el-radio v-for="(label,code) in decideCodes" :key="code" :label="code">{{ label }}</el-radio>
</el-radio-group> </el-radio-group>
<el-input v-model="decideDlg.note" type="textarea" :rows="2" style="margin-top:10px" <el-input v-model="decideDlg.note" type="textarea" :rows="2" style="margin-top:10px"
:placeholder="decideDlg.code && decideDlg.code.endsWith('_OTHER') ? '补充说明(必填)' : '补充说明(选填)'"></el-input> :placeholder="decideDlg.code && decideDlg.code.endsWith('_OTHER') ? '补充说明(必填)' : '补充说明(选填)'"></el-input>
</template>
<template #footer> <template #footer>
<el-button @click="decideDlg.visible=false">取消</el-button> <el-button :disabled="decideDlg.busy" @click="decideDlg.visible=false">关闭</el-button>
<el-button :type="decideDlg.decision==='ACCEPTED'?'success':'danger'" :loading="decideDlg.busy" @click="submitDecide"> <el-button v-if="!decideDlg.withdrawn" :type="decideDlg.decision==='ACCEPTED'?'success':'danger'" :loading="decideDlg.busy" :disabled="decideDlg.uncertain || decideDlg.pending" @click="submitDecide">
{{ decideDlg.decision==='ACCEPTED'?'确认采纳':'确认驳回' }}</el-button> {{ decideDlg.busy ? '正在处理' : (decideDlg.updated ? '确认更新后的建议' : (decideDlg.decision==='ACCEPTED' ? '确认采纳' : '确认驳回')) }}</el-button>
</template> </template>
</el-dialog> </el-dialog>
@ -1521,7 +1571,7 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
<div class="v" :class="ov.cash_source==='ws'?'':'muted'">{{ money(ov.cash_source==='ws' ? ov.cash_avail : ov.cash_est) }}</div></div> <div class="v" :class="ov.cash_source==='ws'?'':'muted'">{{ money(ov.cash_source==='ws' ? ov.cash_avail : ov.cash_est) }}</div></div>
<div class="m"><div class="k">持仓数</div> <div class="m"><div class="k">持仓数</div>
<div class="v">{{ ov.names_count }}<span class="muted"> / {{ ov.max_names }}</span></div></div> <div class="v">{{ ov.names_count }}<span class="muted"> / {{ ov.max_names }}</span></div></div>
<div class="m"><div class="k">浮动盈亏</div> <div class="m"><div class="k">持仓综合盈亏<span class="help" data-tip="按摊薄成本计算,包含当前持仓对应股票此前卖出已实现的盈亏,不等于剩余股份的浮动盈亏。">?</span></div>
<div class="v" :class="(ov.float_pnl||0)>=0?'up':'down'">{{ money(ov.float_pnl) }}</div></div> <div class="v" :class="(ov.float_pnl||0)>=0?'up':'down'">{{ money(ov.float_pnl) }}</div></div>
<div class="m"><div class="k">厚垫 / 负垫</div> <div class="m"><div class="k">厚垫 / 负垫</div>
<div class="v">{{ ov.solid_names }} / {{ ov.neg_names }}</div></div> <div class="v">{{ ov.solid_names }} / {{ ov.neg_names }}</div></div>
@ -1838,6 +1888,7 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
查回的逻辑状态、第一条出处与证据截止日。状态值是上游给的中文原文, 不是枚举码。 --> 查回的逻辑状态、第一条出处与证据截止日。状态值是上游给的中文原文, 不是枚举码。 -->
<el-table-column label="当初为什么买" min-width="220"> <el-table-column label="当初为什么买" min-width="220">
<template #default="s"> <template #default="s">
<button class="research-link" @click="openResearch(s.row.entry, s.row.ts_code)">查看入场依据</button>
<template v-if="s.row.entry && s.row.entry.basis"> <template v-if="s.row.entry && s.row.entry.basis">
<div :title="(s.row.entry.logic||[]).join('\n')">{{ s.row.entry.basis }}</div> <div :title="(s.row.entry.logic||[]).join('\n')">{{ s.row.entry.basis }}</div>
<div class="muted" v-if="(s.row.entry.logic||[]).length">{{ s.row.entry.logic[0] }}</div> <div class="muted" v-if="(s.row.entry.logic||[]).length">{{ s.row.entry.logic[0] }}</div>
@ -1850,6 +1901,7 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
</el-table-column> </el-table-column>
<el-table-column label="证据还在不在" min-width="200"> <el-table-column label="证据还在不在" min-width="200">
<template #default="s"> <template #default="s">
<button class="research-link" v-if="s.row.company" @click="openResearch(s.row.company, s.row.ts_code)">查看研究详情</button>
<template v-if="s.row.logic_now && s.row.logic_now.state"> <template v-if="s.row.logic_now && s.row.logic_now.state">
<el-tag size="small" effect="dark" :type="logicTag(s.row.logic_now.state)">{{ s.row.logic_now.state }}</el-tag> <el-tag size="small" effect="dark" :type="logicTag(s.row.logic_now.state)">{{ s.row.logic_now.state }}</el-tag>
<div class="muted" :title="s.row.logic_now.text">{{ s.row.logic_now.text }}</div> <div class="muted" :title="s.row.logic_now.text">{{ s.row.logic_now.text }}</div>
@ -1859,7 +1911,7 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
<!-- 公司质地 · 失效条件 (2026-09-09 接入方案): 数据基座代码合成的质地档与评议给的失效条件, 只显示。 --> <!-- 公司质地 · 失效条件 (2026-09-09 接入方案): 数据基座代码合成的质地档与评议给的失效条件, 只显示。 -->
<div class="muted" v-if="s.row.company && s.row.company.line" :title="s.row.company.text || ''" style="font-size:11px"> <div class="muted" v-if="s.row.company && s.row.company.line" :title="s.row.company.text || ''" style="font-size:11px">
{{ s.row.company.line }}<template v-if="s.row.company.invalidation">;失效条件:{{ s.row.company.invalidation }}</template><span {{ s.row.company.line }}<template v-if="s.row.company.invalidation">;失效条件:{{ s.row.company.invalidation }}</template><span
v-if="s.row.company.report_url" class="lnk" style="margin-left:6px" @click.stop="openCompanyReport(s.row.ts_code)">评析报告</span></div> v-if="s.row.company.report_url" class="lnk" style="margin-left:6px" @click.stop="openCompanyReport(s.row.ts_code, s.row.company.review_ref)">评析报告</span></div>
<!-- 兜底只在既无逻辑状态又无公司评析时出 (2026-09-11 修): 原来这条是公司质地那行的 v-else, <!-- 兜底只在既无逻辑状态又无公司评析时出 (2026-09-11 修): 原来这条是公司质地那行的 v-else,
一旦没有公司评析就把 logic_now.text 再印一遍 —— 而它上面已印过一次, 于是证据印两遍。 --> 一旦没有公司评析就把 logic_now.text 再印一遍 —— 而它上面已印过一次, 于是证据印两遍。 -->
<span v-if="!(s.row.logic_now && s.row.logic_now.state) && !(s.row.company && s.row.company.line)" <span v-if="!(s.row.logic_now && s.row.logic_now.state) && !(s.row.company && s.row.company.line)"
@ -1988,7 +2040,9 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
</el-table-column> </el-table-column>
<el-table-column prop="qty" label="数量" width="90"></el-table-column> <el-table-column prop="qty" label="数量" width="90"></el-table-column>
<el-table-column label="当时的依据" min-width="320"> <el-table-column label="当时的依据" min-width="320">
<template #default="s"><span class="muted" :title="JSON.stringify(s.row.hard_numbers)">{{ hardCn(s.row.hard_numbers) }}</span></template> <template #default="s"><span class="muted" :title="JSON.stringify(s.row.hard_numbers)">{{ hardCn(s.row.hard_numbers) }}</span>
<button class="research-link" @click="openResearch(s.row.hard_numbers, s.row.ts_code)">查看研究依据</button>
</template>
</el-table-column> </el-table-column>
<el-table-column label="研判" width="100"> <el-table-column label="研判" width="100">
<template #default="s">{{ tx('verdict', s.row.judge_verdict) }}</template> <template #default="s">{{ tx('verdict', s.row.judge_verdict) }}</template>
@ -2108,7 +2162,7 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
<teleport to="body"> <teleport to="body">
<div v-if="propDetailOpen"> <div v-if="propDetailOpen">
<div class="cs-scrim" @click="closePropDetail"></div> <div class="cs-scrim" @click="closePropDetail"></div>
<aside class="prop-sheet"> <aside class="prop-sheet" :class="{'research-sheet':propDetailKind==='company'}" role="dialog" aria-label="提议依据">
<div class="cs-h"> <div class="cs-h">
<span class="ttl">{{ nm((propDetailP||{}).ts_code) }}</span> <span class="ttl">{{ nm((propDetailP||{}).ts_code) }}</span>
<span class="muted mono" style="font-size:11px">{{ (propDetailP||{}).ts_code }}</span> <span class="muted mono" style="font-size:11px">{{ (propDetailP||{}).ts_code }}</span>
@ -2123,7 +2177,23 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
<div class="h">为什么选它</div> <div class="h">为什么选它</div>
<div class="st" v-for="(x,ri) in propReasons(propDetailP)" :key="ri">· {{ x }}</div> <div class="st" v-for="(x,ri) in propReasons(propDetailP)" :key="ri">· {{ x }}</div>
</div> </div>
<div class="cs-sect"><div class="h">榜单</div><div class="st muted">{{ propWhy(propDetailP) }}</div></div> <template v-if="(propDetailP.hard_numbers||{}).candidate_source==='dividend'">
<div class="cs-sect" v-for="item in Object.values((propDetailP.hard_numbers.dividend_research||{}).assessments||{})" :key="item.reason">
<div class="st">{{ item.reason }}</div>
<details class="research-source"><summary>查看依据原文</summary><p v-for="e in item.evidence||[]" :key="e.ref">{{ e.quote }}</p></details>
</div>
<div class="cs-sect"><div class="h">反方与风险</div><p v-for="item in (propDetailP.hard_numbers.dividend_research||{}).risks||[]" :key="item.reason">{{ item.reason }}</p></div>
</template>
<div class="cs-sect" v-else><div class="h">榜单</div><div class="st muted">{{ propWhy(propDetailP) }}</div></div>
</template>
<template v-else-if="propDetailKind==='size'">
<div class="st"><b>{{ propDetailP.qty }} 股 · {{ propAmount(propDetailP) }}</b></div>
<div class="st" v-if="propAdviceTier(propDetailP)">建议 {{ propAdviceTier(propDetailP) }}</div>
<div class="st" v-if="propSizeMismatch(propDetailP)" style="color:var(--warn)">{{ propSizeMismatch(propDetailP) }}</div>
<div class="cs-sect" v-if="propResized(propDetailP)"><div class="h">数量调整</div><div class="st">{{ propResized(propDetailP) }}</div></div>
<div class="st" v-if="(propDetailP.hard_numbers||{}).advice_resize_note">{{ propDetailP.hard_numbers.advice_resize_note }}</div>
<div class="st muted">采纳后按上述股数生成指令,实际成交金额以成交回报为准。</div>
</template> </template>
<template v-else-if="propDetailKind==='judge'"> <template v-else-if="propDetailKind==='judge'">
@ -2136,18 +2206,28 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
</template> </template>
<template v-else-if="propDetailKind==='company'"> <template v-else-if="propDetailKind==='company'">
<div style="display:flex;gap:6px;flex-wrap:wrap;margin-bottom:10px" v-if="cr(propDetailP)"> <div class="research-summary" v-if="researchData(propDetailP.hard_numbers).overall || researchData(propDetailP.hard_numbers).valuation">
<span class="ptag" :class="propCompanyTag(propDetailP).cls">质地{{ cr(propDetailP).overall }}</span> <span class="ptag neutral" v-if="researchData(propDetailP.hard_numbers).overall">质地{{ researchData(propDetailP.hard_numbers).overall }}</span>
<span class="ptag neutral" v-if="cr(propDetailP).valuation">估值{{ cr(propDetailP).valuation }}</span> <span class="ptag neutral" v-if="researchData(propDetailP.hard_numbers).valuation">估值{{ researchData(propDetailP.hard_numbers).valuation }}</span>
<span class="prop-badge" v-if="cr(propDetailP).grade_counts">十视角 好 {{ cr(propDetailP).grade_counts['好'] }} / 中 {{ cr(propDetailP).grade_counts['中'] }} / 差 {{ cr(propDetailP).grade_counts['差'] }}</span>
<span class="prop-badge" v-if="cr(propDetailP).confidence">置信 {{ cr(propDetailP).confidence }}</span>
</div> </div>
<div class="cs-sect" v-if="cr(propDetailP) && cr(propDetailP).thesis"><div class="h" style="color:var(--down)">买方论点</div><div class="st">{{ cr(propDetailP).thesis }}</div></div> <div class="st muted" v-if="!researchSections(propDetailP.hard_numbers).length">这条记录未保存研究摘要。</div>
<div class="cs-sect" v-if="cr(propDetailP) && cr(propDetailP).invalidation"><div class="h" style="color:var(--warn)">失效条件</div><div class="st">{{ cr(propDetailP).invalidation }}</div></div> <section class="cs-sect research-section" v-for="section in researchSections(propDetailP.hard_numbers)" :key="section.title">
<div class="cs-sect" v-if="cr(propDetailP) && cr(propDetailP).antithesis"><div class="h" style="color:var(--up)">反方</div><div class="st">{{ cr(propDetailP).antithesis }}</div></div> <div class="h">{{ section.title }}</div>
<div class="cs-sect" v-if="cr(propDetailP) && cr(propDetailP).catalyst"><div class="h">催化</div><div class="st muted">{{ cr(propDetailP).catalyst }}</div></div> <div class="st" v-for="line in section.lines" :key="line">{{ line }}</div>
<div class="st" v-if="cr(propDetailP) && cr(propDetailP).report_url" style="margin-top:8px"><span class="lnk" @click="openCompanyReport(propDetailP.ts_code)">查看完整评析报告</span></div> </section>
<div class="st muted" v-if="!cr(propDetailP)">这只票没有公司深度评析。</div> <div class="research-materials" v-if="researchMaterials(propDetailP.hard_numbers).length">
<span v-for="item in researchMaterials(propDetailP.hard_numbers)" :key="item">{{ item }}</span>
</div>
<div class="st" v-if="researchData(propDetailP.hard_numbers).report_version_url">
<button class="research-link" @click="openCompanyReport(propDetailP.ts_code, researchData(propDetailP.hard_numbers).review_ref)">阅读完整评析</button>
</div>
<div class="st muted" v-else-if="researchSections(propDetailP.hard_numbers).length">仅保留评析摘要,完整原文暂不可查。</div>
<details class="research-source" :key="(propDetailP.ts_code||'') + propDetailKind">
<summary>数据来源</summary>
<dl><template v-for="item in researchSource(propDetailP.hard_numbers)" :key="item.label">
<dt>{{ item.label }}</dt><dd>{{ item.value }}</dd>
</template></dl>
</details>
</template> </template>
<template v-else-if="propDetailKind==='tech'"> <template v-else-if="propDetailKind==='tech'">
@ -2404,21 +2484,22 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
</el-drawer> </el-drawer>
<!-- 上游选股计划抽屉 --> <!-- 上游选股计划抽屉 -->
<el-drawer v-model="planDrawer" title="上游选股计划 (候选池的事实源)" size="56%"> <el-drawer v-model="planDrawer" title="选股计划" size="56%">
<div class="row" style="margin-bottom:8px"> <div class="row" style="margin-bottom:8px">
<el-button v-if="isAdmin" type="primary" :loading="planLoading" @click="refreshPlan"> <el-button v-if="isAdmin" type="primary" :loading="planLoading" @click="refreshPlan">
强刷 + 灌行业映射</el-button> 更新计划与行业映射</el-button>
<el-button :loading="planLoading" @click="loadPlan">只重读</el-button> <el-button :loading="planLoading" @click="loadPlan">刷新显示</el-button>
<span class="muted" style="margin-left:8px"> <span class="muted" style="margin-left:8px">
计划不带价格与金额 —— 买多少/什么价一律 PMS 自己算; 行情取不到价的票会被剔除。 候选需结合持仓、行情与风险检查后确定买入数量。
</span> </span>
</div> </div>
<div class="muted" v-if="planLoading" style="margin-bottom:8px"> <div class="muted" v-if="planLoading" style="margin-bottom:8px">
正在读上游选股计划…… 上游装配这份计划要读论断与催化事件,慢的时候要几十秒。 正在读取选股计划…</div>
这段时间抽屉是空的,属正常;真读不到会在这里显示原因。</div>
<el-alert v-if="planStatus.ok===false" type="error" effect="dark" show-icon :closable="false" <el-alert v-if="planStatus.ok===false" type="error" effect="dark" show-icon :closable="false"
:title="planStatus.hint || '不可用'" style="margin-bottom:8px"></el-alert> :title="planStatus.hint || '不可用'" style="margin-bottom:8px"></el-alert>
<div class="muted" v-else style="margin-bottom:8px"> <div class="muted" v-else style="margin-bottom:8px">行情截至 {{ planStatus.date || '—' }}<template v-if="planFetchedText"> · {{ planFetchedText.replace('拉取','更新') }}</template></div>
<details class="rail-detail" style="margin-bottom:10px"><summary>数据来源与筛选记录</summary>
<div class="muted" style="margin-bottom:8px">
数据日 <b>{{ planStatus.date }}</b>(上游每个交易日早上用上一交易日收盘后的证据出计划,日龄 {{ planStatus.age_tdays }} 交易日<template 数据日 <b>{{ planStatus.date }}</b>(上游每个交易日早上用上一交易日收盘后的证据出计划,日龄 {{ planStatus.age_tdays }} 交易日<template
v-if="planStatus.age_tdays===1">,属正常</template>)<template v-if="planFetchedText"> · {{ planFetchedText }}</template> · v-if="planStatus.age_tdays===1">,属正常</template>)<template v-if="planFetchedText"> · {{ planFetchedText }}</template> ·
热度日 {{ planStatus.heat_date || '-' }} · 快照 {{ (planStatus.market_snapshot_days||[]).join(',') }} · 热度日 {{ planStatus.heat_date || '-' }} · 快照 {{ (planStatus.market_snapshot_days||[]).join(',') }} ·
@ -2428,10 +2509,11 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
→(券商预期 + 目标价≥现价 + 主题限额 + top)→ 实收 →(券商预期 + 目标价≥现价 + 主题限额 + top)→ 实收
主榜 {{ (planStatus.funnel||{}).returned_main }} / 观察 {{ (planStatus.funnel||{}).returned_observe }} 主榜 {{ (planStatus.funnel||{}).returned_main }} / 观察 {{ (planStatus.funnel||{}).returned_observe }}
</div> </div>
</details>
<el-alert v-if="planCand && planCand.tier_complete===false" type="warning" effect="dark" <el-alert v-if="planCand && planCand.tier_complete===false" type="warning" effect="dark"
show-icon :closable="false" style="margin-bottom:8px" show-icon :closable="false" style="margin-bottom:8px"
:title="'返回的全是白名单档位 (top=' + ((planStatus.requested||{}).top) :title="'候选档位覆盖不完整(读取数量 ' + ((planStatus.requested||{}).top)
+ ' 吃满了) —— 白名单档位可能没取全, 调大 PMS_PLAN_TOP'"> + ' 已达返回上限),候选可能不完整,请检查计划读取范围。'">
</el-alert> </el-alert>
<div class="muted" v-if="planCand" style="margin-bottom:8px"> <div class="muted" v-if="planCand" style="margin-bottom:8px">
按当前参数筛选: 排序池 {{ planCand.considered }} → 合格 {{ planCand.eligible }} → 按当前参数筛选: 排序池 {{ planCand.considered }} → 合格 {{ planCand.eligible }} →
@ -2440,7 +2522,6 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
落选 {{ dropCn(planCand.dropped) }} 落选 {{ dropCn(planCand.dropped) }}
<span v-if="(planCand.st_unknown||[]).length" style="color:#E6A23C">· <span v-if="(planCand.st_unknown||[]).length" style="color:#E6A23C">·
{{ planCand.st_unknown.length }} 只无名称, ST 判不了已放行</span> {{ planCand.st_unknown.length }} 只无名称, ST 判不了已放行</span>
<br><span class="mono">{{ (planCand.items||[]).map(x=>x.ts_code).join(' ') }}</span>
</div> </div>
<!-- 榜单变化 (PMS 自算; 上游 changes 恒为 null) --> <!-- 榜单变化 (PMS 自算; 上游 changes 恒为 null) -->
<el-divider content-position="left">榜单变化</el-divider> <el-divider content-position="left">榜单变化</el-divider>
@ -2450,16 +2531,15 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
</div> </div>
<el-alert v-if="chgSt.in_sync === false" type="error" effect="dark" show-icon <el-alert v-if="chgSt.in_sync === false" type="error" effect="dark" show-icon
:closable="false" style="margin-bottom:8px" :closable="false" style="margin-bottom:8px"
title="手上这份计划没落进快照 —— 下面比的是两个旧版本, 与当前候选池不是同一份"> title="当前计划的比较记录尚未就绪,下方变化暂不能代表当前候选。">
</el-alert> </el-alert>
<el-alert v-else-if="chg && chg.kind === 'same_date_revision'" type="warning" effect="dark" <el-alert v-else-if="chg && chg.kind === 'same_date_revision'" type="warning" effect="dark"
show-icon :closable="false" style="margin-bottom:8px" show-icon :closable="false" style="margin-bottom:8px"
:title="'同一计划日 ' + chg.curr_date + ' 的新版本 —— 上游重算过, ' :title="'今日选股依据已更新,请查看下方名单与研究变化。'">
+ '此前拿到的候选池与现在不是同一份 (上游 /plan 是实时算的, 没有版本戳)'">
</el-alert> </el-alert>
<el-alert v-if="chg && chg.prev_broken" type="error" effect="dark" show-icon <el-alert v-if="chg && chg.prev_broken" type="error" effect="dark" show-icon
:closable="false" style="margin-bottom:8px" :closable="false" style="margin-bottom:8px"
title="上一版名册读不出来 (快照损坏) —— 这次比不了, 下面的空白不代表没有变化"> title="上一份名单读取失败,暂时无法比较变化。">
</el-alert> </el-alert>
<el-alert v-if="chgHeld.n_watch" type="error" effect="dark" show-icon :closable="false" <el-alert v-if="chgHeld.n_watch" type="error" effect="dark" show-icon :closable="false"
style="margin-bottom:8px" style="margin-bottom:8px"
@ -2467,7 +2547,7 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
</el-alert> </el-alert>
<el-alert v-if="chg && chg.date_regressed" type="warning" effect="dark" show-icon <el-alert v-if="chg && chg.date_regressed" type="warning" effect="dark" show-icon
:closable="false" style="margin-bottom:8px" :closable="false" style="margin-bottom:8px"
title="计划日往回走了 (拉过一份旧计划?) —— 新进/掉榜的方向是反的"> title="当前计划日期早于此前记录,新进与退出方向需反向理解。">
</el-alert> </el-alert>
<div class="muted" v-if="chg" style="margin-bottom:8px"> <div class="muted" v-if="chg" style="margin-bottom:8px">
{{ chg.kind === 'first' ? '首次落快照' : (chg.prev_date + ' → ' + chg.curr_date) }} · {{ chg.kind === 'first' ? '首次落快照' : (chg.prev_date + ' → ' + chg.curr_date) }} ·
@ -2517,17 +2597,17 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
</el-tab-pane> </el-tab-pane>
<el-tab-pane name="in" :label="'新进榜 (' + chg.counts.entered + ')'"> <el-tab-pane name="in" :label="'新进榜 (' + chg.counts.entered + ')'">
<el-table :data="chg.entered" size="small" border max-height="220" empty-text="无"> <el-table :data="chg.entered" size="small" border max-height="220" empty-text="无">
<el-table-column prop="rank" label="rank" width="62"></el-table-column> <el-table-column prop="rank" label="名次" width="62"></el-table-column>
<el-table-column prop="ts_code" label="代码" width="104"></el-table-column> <el-table-column prop="ts_code" label="代码" width="104"></el-table-column>
<el-table-column prop="name" label="名称" width="92"></el-table-column> <el-table-column prop="name" label="名称" width="92"></el-table-column>
<el-table-column prop="tier" label="传导档" width="82"></el-table-column> <el-table-column prop="tier" label="传导档" width="82"></el-table-column>
<el-table-column prop="theme" label="主题" width="120"></el-table-column> <el-table-column prop="theme" label="主题" width="120"></el-table-column>
<el-table-column prop="score" label="score" width="82"></el-table-column> <el-table-column prop="score" label="评分" width="82"></el-table-column>
</el-table> </el-table>
</el-tab-pane> </el-tab-pane>
<el-tab-pane name="up" :label="'升档 (' + chg.counts.tier_up + ')'"> <el-tab-pane name="up" :label="'升档 (' + chg.counts.tier_up + ')'">
<el-table :data="chg.tier_up" size="small" border max-height="220" empty-text="无"> <el-table :data="chg.tier_up" size="small" border max-height="220" empty-text="无">
<el-table-column prop="rank" label="rank" width="62"></el-table-column> <el-table-column prop="rank" label="名次" width="62"></el-table-column>
<el-table-column prop="ts_code" label="代码" width="104"></el-table-column> <el-table-column prop="ts_code" label="代码" width="104"></el-table-column>
<el-table-column prop="name" label="名称" width="92"></el-table-column> <el-table-column prop="name" label="名称" width="92"></el-table-column>
<el-table-column label="档位" min-width="150"> <el-table-column label="档位" min-width="150">
@ -2565,21 +2645,23 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
<el-table-column prop="digest" label="指纹" min-width="140"></el-table-column> <el-table-column prop="digest" label="指纹" min-width="140"></el-table-column>
</el-table> </el-table>
<div class="muted" style="margin-top:6px"> <div class="muted" style="margin-top:6px">
<b>同一「计划日」出现多行 = 上游那天重算过多版</b>(UPSTREAM_PLAN_API.md §7.3: 同一计划日可包含收到计划、实际消费及提议核验记录。计划版本、消费参数或组合上下文变化时追加记录;
`/plan` 是实时算的, 应答里没有 generated_at, 下游本来没办法判断手上这份是哪一版)。 旧记录缺少版本时标明追溯不完整,不能据此重构历史决策。
指纹不含 score —— 分数抖动但次序没变不算新版本, 否则表白涨而信息量为零。
</div> </div>
</el-tab-pane> </el-tab-pane>
</el-tabs> </el-tabs>
<el-divider content-position="left">主榜明细</el-divider> <el-divider content-position="left">主榜明细</el-divider>
<el-table :data="planRows" size="small" border height="420"> <el-table :data="planRows" size="small" border height="420">
<el-table-column prop="rank" label="rank" width="62"></el-table-column> <el-table-column label="研究依据" width="110"><template #default="s">
<button class="research-link" @click="openResearch(s.row, s.row.ts_code)">查看详情</button>
</template></el-table-column>
<el-table-column prop="rank" label="名次" width="62"></el-table-column>
<el-table-column prop="ts_code" label="代码" width="104"></el-table-column> <el-table-column prop="ts_code" label="代码" width="104"></el-table-column>
<el-table-column prop="name" label="名称" width="92"></el-table-column> <el-table-column prop="name" label="名称" width="92"></el-table-column>
<el-table-column prop="score" label="score" width="82"></el-table-column> <el-table-column prop="score" label="评分" width="82"></el-table-column>
<el-table-column prop="tier" label="传导档" width="82"></el-table-column> <el-table-column prop="tier" label="传导档" width="82"></el-table-column>
<el-table-column prop="theme" label="主题" width="120"></el-table-column> <el-table-column prop="theme" label="主题" width="120"></el-table-column>
<el-table-column prop="heat" label="heat" width="78"></el-table-column> <el-table-column prop="heat" label="热度" width="78"></el-table-column>
<el-table-column label="预期空间" width="96"> <el-table-column label="预期空间" width="96">
<template #default="s"> <template #default="s">
<span class="muted">{{ s.row.upside==null ? '-' : <span class="muted">{{ s.row.upside==null ? '-' :
@ -2588,9 +2670,11 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
</el-table-column> </el-table-column>
<el-table-column prop="n_sources" label="源数" width="66"></el-table-column> <el-table-column prop="n_sources" label="源数" width="66"></el-table-column>
</el-table> </el-table>
<div class="muted" style="margin-top:6px">预期空间为券商目标价相对现价的幅度,不参与排序。</div>
<details class="rail-detail"><summary>筛选口径与参数说明</summary>
<div class="muted" style="margin-top:6px"> <div class="muted" style="margin-top:6px">
「预期空间」= 券商目标价相对现价的空间 (上游 upside 字段, 2.12 → +212%)。噪音大, 「预期空间」= 券商目标价相对现价的空间 (上游 upside 字段, 2.12 → +212%)。噪音大,
所以<b>永不参与排序</b> —— 排序始终按 score; 只在 PMS_PLAN_MIN_UPSIDE 上做下限过滤。 所以<b>永不参与排序</b> —— 排序按当前有效模式与稳定次级键; 只在 PMS_PLAN_MIN_UPSIDE 上做下限过滤。
筛选参数在「参数设置」里: PMS_PLAN_TOP_N / PMS_PLAN_TIERS / PMS_PLAN_INCLUDE_OBSERVE / 筛选参数在「参数设置」里: PMS_PLAN_TOP_N / PMS_PLAN_TIERS / PMS_PLAN_INCLUDE_OBSERVE /
PMS_PLAN_MIN_SCORE / PMS_PLAN_MIN_SOURCES / PMS_PLAN_MIN_UPSIDE / PMS_PLAN_STALE_TDAYS。 PMS_PLAN_MIN_SCORE / PMS_PLAN_MIN_SOURCES / PMS_PLAN_MIN_UPSIDE / PMS_PLAN_STALE_TDAYS。
<br>发给上游的三个: PMS_PLAN_TOP / PMS_PLAN_OBS_TOP / PMS_PLAN_THEME_CAP (0=不传, 用上游默认 <br>发给上游的三个: PMS_PLAN_TOP / PMS_PLAN_OBS_TOP / PMS_PLAN_THEME_CAP (0=不传, 用上游默认
@ -2600,6 +2684,7 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
「主题」是<b>传导主题</b>(事件驱动、天天变、覆盖约三成), <b>不是行业</b> —— 行业硬拦截 「主题」是<b>传导主题</b>(事件驱动、天天变、覆盖约三成), <b>不是行业</b> —— 行业硬拦截
请把 PMS_SECTOR_SOURCE 设成 gp_stock_category, 别用 PMS_PLAN_THEME_SYNC。 请把 PMS_SECTOR_SOURCE 设成 gp_stock_category, 别用 PMS_PLAN_THEME_SYNC。
</div> </div>
</details>
<pre class="json" v-if="planResult">{{ planResult }}</pre> <pre class="json" v-if="planResult">{{ planResult }}</pre>
</el-drawer> </el-drawer>
@ -2643,7 +2728,7 @@ createApp({
const health = ref({}), ov = ref({}), params = ref([]), paramsRaw = ref({}); const health = ref({}), ov = ref({}), params = ref([]), paramsRaw = ref({});
const catalog = ref([]), commands = ref([]), plans = ref([]), plansOf = ref(''); const catalog = ref([]), commands = ref([]), plans = ref([]), plansOf = ref('');
const positions = ref([]), lots = ref([]), lotsOf = ref(''); const positions = ref([]), lots = ref([]), lotsOf = ref('');
const instructions = ref([]), ledger = ref([]), proposals = ref([]); const instructions = ref([]), ledger = ref([]), proposals = ref([]), preparingProposals = ref([]);
const strategies = ref([]), stratEnabled = ref(false), opLog = ref([]); const strategies = ref([]), stratEnabled = ref(false), opLog = ref([]);
const autoScanRes = ref(null), autoScanBusy = ref(false); // 自动挂载试算 (2026-08-25) const autoScanRes = ref(null), autoScanBusy = ref(false); // 自动挂载试算 (2026-08-25)
const autoInfo = ref(null); // 自动挂载仪表: 总开关 + 今天正式一跳跑没跑 (2026-08-26) const autoInfo = ref(null); // 自动挂载仪表: 总开关 + 今天正式一跳跑没跑 (2026-08-26)
@ -2665,6 +2750,29 @@ createApp({
const _lvLoad = () => { try { const v = JSON.parse(sessionStorage.getItem(LV_STORE_KEY)); if (v && typeof v === 'object') return { ..._lvDefault, ...v }; } catch (e) {} return { ..._lvDefault }; }; const _lvLoad = () => { try { const v = JSON.parse(sessionStorage.getItem(LV_STORE_KEY)); if (v && typeof v === 'object') return { ..._lvDefault, ...v }; } catch (e) {} return { ..._lvDefault }; };
const levelShow = reactive(_lvLoad()); const levelShow = reactive(_lvLoad());
const openScan = ref({ by_code: {}, notes: [] }); const openScan = ref({ by_code: {}, notes: [] });
const dividend = ref({ rows: [] }), dividendBusy = ref(''), dividendMore = ref(false);
const dividendShown = computed(() => {
const rows = [...(dividend.value.rows || [])].sort((a,b) => Number(b.eligible)-Number(a.eligible)
|| Number(b.quality==='好')-Number(a.quality==='好') || a.ts_code.localeCompare(b.ts_code));
return dividendMore.value ? rows : rows.slice(0,3);
});
let dividendLoadedAt = 0;
async function loadDividend(force=false) {
if (!force && Date.now()-dividendLoadedAt < 60000) return;
dividendLoadedAt = Date.now();
try {
const r = await axios.get('/api/dividend/candidates');
dividend.value = r.data.ok ? r.data.data : {rows:[],error:'研究暂不可用,稍后自动重试'};
} catch(e) { dividend.value = {rows:[],error:'研究暂不可用,稍后自动重试'}; }
}
async function prepareDividend(row) {
if (dividendBusy.value) return;
dividendBusy.value = row.ts_code;
try {
const result = await call('post','/api/dividend/proposals',{ts_code:row.ts_code,research_ref:row.research_ref});
if (result.ok) { ElementPlus.ElMessage.success(result.message); await loadProposals(); }
} finally { dividendBusy.value = ''; }
}
const insTab = ref('live'); const insTab = ref('live');
const stratDlg = reactive({ visible:false, busy:false, reasons:[], ts_code:'', price:0, const stratDlg = reactive({ visible:false, busy:false, reasons:[], ts_code:'', price:0,
total_qty:0, avail_qty:0, cushion_pct:null, type:'T0', autonomy:'auto', total_qty:0, avail_qty:0, cushion_pct:null, type:'T0', autonomy:'auto',
@ -2814,7 +2922,7 @@ createApp({
const T = { const T = {
// 账本的动作有十六个:八个真动作(planner.py:31 那批常量)加八个伪动作 // 账本的动作有十六个:八个真动作(planner.py:31 那批常量)加八个伪动作
// (账本里直写的字面量,例如对账修正、信号留痕)。少一个就会在页面上露原码。 // (账本里直写的字面量,例如对账修正、信号留痕)。少一个就会在页面上露原码。
action: { OPEN:'建新仓', OPEN_REASK:'重问研判', FILL:'回落补足', ADD:'盈利加仓', DCA:'浮亏补仓', TRIM:'保盈减仓', action: { BUY_STOP:'停止买入', OPEN:'建新仓', OPEN_REASK:'重问研判', FILL:'回落补足', ADD:'盈利加仓', DCA:'浮亏补仓', TRIM:'保盈减仓',
EXIT:'清仓', T0:'做T', T0_ROUND:'做T', SWITCH:'换仓', HALT:'停手', EXIT:'清仓', T0:'做T', T0_ROUND:'做T', SWITCH:'换仓', HALT:'停手',
RECON:'对账修正', CLEANUP:'收尾清理', MACRO:'大盘冷热', RECON:'对账修正', CLEANUP:'收尾清理', MACRO:'大盘冷热',
SIGNAL:'信号留痕', SIGNAL_BUY:'买入信号', SIGNAL:'信号留痕', SIGNAL_BUY:'买入信号',
@ -2828,7 +2936,7 @@ createApp({
lot: { BASE:'首批', FILL:'回落补足', ADD:'盈利加仓', DCA:'浮亏补仓', T0:'做T仓', RECON:'对账修正' }, lot: { BASE:'首批', FILL:'回落补足', ADD:'盈利加仓', DCA:'浮亏补仓', T0:'做T仓', RECON:'对账修正' },
frozen: { NONE:'', COMMAND_HALT:'命令要求只卖不买', BRAKE:'组合刹车,只卖不买', MANUAL:'人工冻结,只卖不买' }, frozen: { NONE:'', COMMAND_HALT:'命令要求只卖不买', BRAKE:'组合刹车,只卖不买', MANUAL:'人工冻结,只卖不买' },
posStatus: { PLANNED:'计划建仓', OPENING:'建仓中', HOLDING:'持有中', EXITING:'清仓中', CLOSED:'已清仓' }, posStatus: { PLANNED:'计划建仓', OPENING:'建仓中', HOLDING:'持有中', EXITING:'清仓中', CLOSED:'已清仓' },
insStatus: { PROPOSED:'待校验', RULE_PASSED:'合规检查已过', JUDGE_PASSED:'决策系统复核已过', DISPATCHED:'已挂单待成交', insStatus: { PROPOSED:'待校验', RULE_PASSED:'合规检查已过', JUDGE_PASSED:'决策系统复核已过', DISPATCHED:'执行中',
CONFIRMED:'已成交', REJECTED:'已拦截', EXPIRED:'到期作废', CANCELLED:'已撤销' }, CONFIRMED:'已成交', REJECTED:'已拦截', EXPIRED:'到期作废', CANCELLED:'已撤销' },
arbiter: { rule:'合规检查', judge:'决策系统', user:'人工', system:'系统自动' }, arbiter: { rule:'合规检查', judge:'决策系统', user:'人工', system:'系统自动' },
// 这一组是**评审账本**的结论,只有四个值。研判闸的结论是另一组 judgeVerdict, // 这一组是**评审账本**的结论,只有四个值。研判闸的结论是另一组 judgeVerdict,
@ -3097,19 +3205,29 @@ createApp({
if (d.disp === 'would') return { cls: 'would', label: '拟建仓', why: d.why }; if (d.disp === 'would') return { cls: 'would', label: '拟建仓', why: d.why };
// 三源合议判观察 (2026-09-11): 等技术面开口, 是「在盯」不是「被否决」—— // 三源合议判观察 (2026-09-11): 等技术面开口, 是「在盯」不是「被否决」——
// 归到 watch 那一档而不是今天没建仓那一档, 因为它还会回来。 // 归到 watch 那一档而不是今天没建仓那一档, 因为它还会回来。
if (d.disp === 'wait_tech') return { cls: 'wait', label: '等技术面开口', why: d.why }; if (d.disp === 'wait_tech') return { cls: 'wait', label: '等待技术面转强', why: d.why };
// 盘中确认包 (2026-09-14): 开口未确认/时段外, 等盘中放量确认, 同样是「在盯」不是「被否决」。 // 盘中确认包 (2026-09-14): 开口未确认/时段外, 等盘中放量确认, 同样是「在盯」不是「被否决」。
if (d.disp === 'wait_confirm') return { cls: 'wait', label: '等盘中确认', why: d.why }; if (d.disp === 'wait_confirm') return { cls: 'wait', label: '等盘中确认', why: d.why };
// 系统自决 (2026-09-14): 方向看多但择时看空, 进观察等择时转多, 也是「在盯」不是「被否决」。 // 系统自决 (2026-09-14): 方向看多但择时看空, 进观察等择时转多, 也是「在盯」不是「被否决」。
if (d.disp === 'wait_timing') return { cls: 'wait', label: '择时待转多', why: d.why }; if (d.disp === 'wait_timing') return { cls: 'wait', label: '等待择时转多', why: d.why };
// 系统自决今日已放弃 (2026-09-14): 明日重评, 与「未建仓」分开显示。 // 系统自决今日已放弃 (2026-09-14): 明日重评, 与「未建仓」分开显示。
if (d.disp === 'sys_decline') return { cls: 'deny', label: '系统已放弃', why: d.why }; if (d.disp === 'sys_decline') return { cls: 'deny', label: '系统已放弃', why: d.why };
return { cls: 'deny', label: '未建仓', why: d.why }; return { cls: 'deny', label: '未建仓', why: d.why };
} }
return { cls: 'wait', label: '候选观察', why: '' }; return { cls: 'wait', label: '待评估', why: '' };
} }
// 候选行的三源合议摘要 (2026-09-14 页面收尾包): 后端候选处置快照 by_code 里挂的 consensus 小块 // 候选行的三源合议摘要 (2026-09-14 页面收尾包): 后端候选处置快照 by_code 里挂的 consensus 小块
// (fund/overall/tech/phase/direction/route)。没有就返回 null, 芯片整段不显示。 // (fund/overall/tech/phase/direction/route)。没有就返回 null, 芯片整段不显示。
function scanNoteText(note) {
const text = String(note || '');
const m = text.match(/^在途建仓已占 (\d+) 个名额、约 ([\d,]+) 元 \(\[.*\]\), 本轮按余量扫描$/);
if (m) return '待确认与未成交建仓占用 ' + m[1] + ' 个名额,约 ' + m[2] + ' 元。';
const labels = {'自主档位 off —— 本轮不扫描候选池 (off 是总闸)':'自主操作已暂停,候选暂不评估。',
'新建仓档位 off —— 不扫描候选池':'新建仓已暂停,候选暂不评估。',
'全局暂停执行 —— 本轮不扫描候选池':'执行已暂停,候选暂不评估。'};
return labels[text] || text;
}
const scanNotes = computed(() => [...new Set((openScan.value.notes || []).map(scanNoteText).filter(Boolean))]);
const conOf = (code) => ((openScan.value.by_code || {})[code] || {}).consensus || null; const conOf = (code) => ((openScan.value.by_code || {})[code] || {}).consensus || null;
const denyToday = computed(() => (planRows.value || []).map(r => { const denyToday = computed(() => (planRows.value || []).map(r => {
const d = dispOf(r.ts_code); const d = dispOf(r.ts_code);
@ -3174,10 +3292,25 @@ createApp({
const amt = Number(h.target_amount), pct = Number(h.target_pct); const amt = Number(h.target_amount), pct = Number(h.target_pct);
return (isFinite(amt) && isFinite(pct) && pct > 0) ? amt / pct : null; return (isFinite(amt) && isFinite(pct) && pct > 0) ? amt / pct : null;
} }
function propAmount(p) {
const raw = (p.hard_numbers || {}).price, price = Number(raw), qty = Number(p.qty);
return raw != null && raw !== '' && Number.isFinite(price) && price > 0
&& Number.isFinite(qty) && qty > 0 ? money(price * qty) + ' 元' : '—';
}
// PMS 的无偏移业务时刻约定为北京时间;带偏移的时间显式转换。
function propExpiry(value) {
if (!value) return '有效期未记录';
const raw = String(value), date = new Date(/(?:Z|[+-]\d{2}:?\d{2})$/i.test(raw) ? raw : raw.replace(' ','T') + '+08:00');
if (Number.isNaN(date.getTime())) return '有效期未记录';
const parts = Object.fromEntries(new Intl.DateTimeFormat('en-CA', {timeZone:'Asia/Shanghai',
year:'numeric',month:'2-digit',day:'2-digit',hour:'2-digit',minute:'2-digit',hourCycle:'h23'}).formatToParts(date).map(x=>[x.type,x.value]));
const day = parts.year + '-' + parts.month + '-' + parts.day;
return (day === todayDateStr.value ? '今日' : day) + ' ' + parts.hour + ':' + parts.minute + ' 前有效';
}
function propSizePct(p) { function propSizePct(p) {
const h = p.hard_numbers || {}; const h = p.hard_numbers || {};
const scale = propScale(p), price = Number(h.price), qty = Number(p.qty); const scale = propScale(p), price = Number(h.price), qty = Number(p.qty);
if (!scale || !isFinite(price) || !isFinite(qty) || qty <= 0) return ''; if (!scale || !isFinite(price) || price <= 0 || !isFinite(qty) || qty <= 0) return '';
return (price * qty / scale * 100).toFixed(2) + '%'; return (price * qty / scale * 100).toFixed(2) + '%';
} }
// 建议档位的短版。原先卡上摆的是 advice_text 那一整句 (实测 90 多个字, 把档位、 // 建议档位的短版。原先卡上摆的是 advice_text 那一整句 (实测 90 多个字, 把档位、
@ -3207,15 +3340,14 @@ createApp({
// 后端算不出新数量时会留一句原因(例如「一手就超过机械档,这只票对当前规模太贵」)。 // 后端算不出新数量时会留一句原因(例如「一手就超过机械档,这只票对当前规模太贵」)。
// 有这句就直接说它 —— 比让人自己去对两个百分比清楚。 // 有这句就直接说它 —— 比让人自己去对两个百分比清楚。
if (h.advice_resize_note) { if (h.advice_resize_note) {
return '注意:数量没能按建议档位重算(' + h.advice_resize_note + ')。采纳后下的就是上面那个数。'; return '数量未按建议仓位调整,采纳将按 ' + p.qty + ' 股执行。请查看数量说明。';
} }
const a = h.advice; const a = h.advice;
if (!a || typeof a !== 'object') return ''; if (!a || typeof a !== 'object') return '';
const advPct = Number(a.target_pct), usedPct = Number(h.target_pct); const advPct = Number(a.target_pct), usedPct = Number(h.target_pct);
if (!isFinite(advPct) || !isFinite(usedPct) || usedPct <= 0) return ''; if (!isFinite(advPct) || !isFinite(usedPct) || usedPct <= 0) return '';
if (Math.abs(advPct - usedPct) < 1e-9) return ''; if (Math.abs(advPct - usedPct) < 1e-9) return '';
return '注意:上面那个股数是按 ' + (usedPct * 100).toFixed(1) + '% 那一档算的,' return '数量按 ' + (usedPct * 100).toFixed(1) + '% 测算,建议为 ' + (advPct * 100).toFixed(1) + '%。';
+ '不是按建议档位的 ' + (advPct * 100).toFixed(1) + '%。采纳后下的就是上面那个数。';
} }
// 数量按建议档位重算过就说一声。这是正面反馈:让人知道卡上写的档位与真下的股数 // 数量按建议档位重算过就说一声。这是正面反馈:让人知道卡上写的档位与真下的股数
// 是对上的,不用自己再算一遍。抬到一手那种情形另有一句 note,一并带出来。 // 是对上的,不用自己再算一遍。抬到一手那种情形另有一句 note,一并带出来。
@ -3237,6 +3369,71 @@ createApp({
// 标签返回 {text, cls}; cls 走 .ptag 取色 —— 技术面看多看空按页面口径红涨绿跌 (up/down), // 标签返回 {text, cls}; cls 走 .ptag 取色 —— 技术面看多看空按页面口径红涨绿跌 (up/down),
// 其余评价类用中性色 (accent 蓝 / warn 黄 / neutral 灰), 不掺进涨跌红绿。 // 其余评价类用中性色 (accent 蓝 / warn 黄 / neutral 灰), 不掺进涨跌红绿。
const cr = (p) => (p && p.hard_numbers && p.hard_numbers.company_review) || null; const cr = (p) => (p && p.hard_numbers && p.hard_numbers.company_review) || null;
// 研究内容用于判断,技术来源仅供追溯。保持冻结值,不回源或重算建议。
function researchData(value) {
const h = value || {};
return { ...(h.company_review || h), ...(h.research || {}) };
}
function researchText(value) {
if (value == null || value === '') return '';
if (typeof value === 'number') return Number.isFinite(value) ? String(Number(value.toFixed(2))) : '';
if (Array.isArray(value)) return value.map(researchText).filter(Boolean).join(';');
if (typeof value === 'object') {
if (value.text) return researchText(value.text);
const labels = {grade:'评价', stance:'立场', gap_pts:'预期增速差(百分点)',
implied_pe_vs_cons:'隐含市盈率与一致预期比'};
return Object.entries(labels).filter(([k]) => value[k] != null)
.map(([k,label]) => label + ':' + researchText(value[k])).join(';');
}
return String(value).trim();
}
function researchWhen(value) {
if (!value) return '';
if (!/(?:Z|[+-]\d{2}:?\d{2})$/i.test(String(value))) return value + '(时区未记录)';
const d = new Date(value);
return Number.isNaN(d.getTime()) ? '' : d.toLocaleString('zh-CN', {timeZone:'Asia/Shanghai'}) + '(北京时间)';
}
function researchSections(value) {
const r = researchData(value), sections = [];
const add = (title, values) => {
const lines = values.map(researchText).filter(Boolean);
if (lines.length) sections.push({title, lines});
};
add('核心判断', [r.thesis]);
add('主要风险', [r.antithesis]);
add('预期与经营周期', [r.expectation, r.cycle]);
add('后续关注', [r.catalyst]);
add('判断失效的条件', [r.invalidation]);
const labels = {overall:'质地',valuation:'估值',doubt_hard:'财务风险',expectation:'预期',
cycle:'周期',period_fi:'财务材料期',period_rf:'研报材料期',n_materials:'材料数量',
unknown_n:'待核实问题',numbers_unmatched:'数字核验缺项',thesis:'核心判断',antithesis:'主要风险'};
add('研究变化', (Array.isArray(r.changes) ? r.changes : []).map(x =>
(labels[x.field] || '研究材料') + ':' + (researchText(x.before) || '未提供') + ' → ' + (researchText(x.after) || '未提供')));
return sections;
}
function researchMaterials(value) {
const r = researchData(value), items = [];
if (r.report_ran_at) items.push('评析时间 ' + researchWhen(r.report_ran_at));
[['period_fi','财务材料'],['period_rf','研报材料'],['n_materials','材料数量'],
['unknown_n','待核实问题'],['numbers_unmatched','数字核验缺项']].forEach(([key,label]) => {
if (r[key] != null && r[key] !== '') items.push(label + ' ' + researchText(r[key]));
});
return items;
}
function researchSource(value) {
const h = value || {}, d = h.decision || {}, r = researchData(value), out = [];
const add = (label, v) => { if (v != null && v !== '') out.push({label,value:String(v)}); };
add('记录完整度', d.id ? '已保存当时依据' : '旧记录未保存完整来源');
add('计划标识', d.id); add('更新原因', d.reason);
add('信息截止', researchWhen(d.cutoff_at)); add('持仓研究查询时间', researchWhen(h.observation_at));
add('评析引用', typeof r.review_ref === 'string' ? r.review_ref : (r.review_ref || {}).fingerprint);
add('执行顺序', h.execution_rank); add('顺序依据', h.priority_reason);
add('输入指纹', d.input_hash); add('配置指纹', d.params_hash); add('消费记录', h.consumption_id);
return out;
}
function openResearch(value, code) {
openPropDetail({ts_code:code, hard_numbers:value || {}}, 'company');
}
const propPlanTag = (p) => { const propPlanTag = (p) => {
const v = String((p.hard_numbers || {}).verdict || '').trim(); const v = String((p.hard_numbers || {}).verdict || '').trim();
if (!v) return null; if (!v) return null;
@ -3332,7 +3529,7 @@ createApp({
const propDetailOpen = ref(false), propDetailKind = ref(''), propDetailP = ref(null); const propDetailOpen = ref(false), propDetailKind = ref(''), propDetailP = ref(null);
const propTechFull = ref(null), propTechErr = ref(''); const propTechFull = ref(null), propTechErr = ref('');
const PROP_SRC_LABEL = { plan: '选股系统', judge: '决策系统', company: '基本面', const PROP_SRC_LABEL = { plan: '选股系统', judge: '决策系统', company: '基本面',
tech: '技术面', consensus: '择时' }; tech: '技术面', consensus: '择时', size: '数量说明' };
function openPropDetail(p, kind) { function openPropDetail(p, kind) {
propDetailP.value = p; propDetailKind.value = kind; propDetailOpen.value = true; propDetailP.value = p; propDetailKind.value = kind; propDetailOpen.value = true;
propTechFull.value = null; propTechErr.value = ''; propTechFull.value = null; propTechErr.value = '';
@ -3579,9 +3776,9 @@ createApp({
// ===================== /交易员视图 ===================== // ===================== /交易员视图 =====================
async function call(method, url, body) { async function call(method, url, body, options) {
try { try {
const r = await api[method](url, body); const r = await api[method](url, body, options);
if (r.data && r.data.ok === false) { err.value = r.data.error || '请求失败'; } if (r.data && r.data.ok === false) { err.value = r.data.error || '请求失败'; }
return r.data; return r.data;
} catch (e) { } catch (e) {
@ -3591,7 +3788,7 @@ createApp({
const m = (e.response && e.response.data && e.response.data.error) || '无权限: 需要系统管理员'; const m = (e.response && e.response.data && e.response.data.error) || '无权限: 需要系统管理员';
ElementPlus.ElMessage.error(m); return { ok: false, error: m }; ElementPlus.ElMessage.error(m); return { ok: false, error: m };
} }
err.value = url + ' → ' + e.message; return { ok: false, error: e.message }; err.value = url + ' → ' + e.message; return { ok: false, error: e.message, uncertain: !e.response || st >= 500 };
} }
} }
@ -3677,7 +3874,10 @@ createApp({
const d = await call('get', '/api/ledger?limit=60'); ledger.value = d.data || []; const d = await call('get', '/api/ledger?limit=60'); ledger.value = d.data || [];
} }
async function loadProposals() { async function loadProposals() {
const d = await call('get', '/api/proposals'); proposals.value = d.data || []; const d = await call('get', '/api/proposals');
const rows = d.data || [];
proposals.value = rows.filter(p => p.accept_ready !== false);
preparingProposals.value = rows.filter(p => p.accept_ready === false);
} }
async function loadOpenScan() { async function loadOpenScan() {
const d = await call('get', '/api/open-scan'); const d = await call('get', '/api/open-scan');
@ -4153,7 +4353,7 @@ createApp({
// ws-channel 是管理员专属接口: 交易员不调它, 免得每次刷新都弹一条「无权限」 // ws-channel 是管理员专属接口: 交易员不调它, 免得每次刷新都弹一条「无权限」
// (通道告警对交易员改由 dispatch-mode 里的 channel 兜底, 见 wsc 的注释) // (通道告警对交易员改由 dispatch-mode 里的 channel 兜底, 见 wsc 的注释)
(isAdmin.value ? loadWs() : Promise.resolve()), (isAdmin.value ? loadWs() : Promise.resolve()),
loadStrategies(), loadOpLog(), loadOpenScan(), loadUpstream(), loadStrategies(), loadOpLog(), loadOpenScan(), loadDividend(), loadUpstream(),
loadMacro(), loadTech()]); loadMacro(), loadTech()]);
await loadNames(); await loadNames();
lastRefresh.value = new Date().toTimeString().slice(0, 8); lastRefresh.value = new Date().toTimeString().slice(0, 8);
@ -4240,37 +4440,64 @@ createApp({
DECLINE_WAIT_PULLBACK:'等待回调再议', DECLINE_MARKET_RISK:'大盘风险偏高', DECLINE_OTHER:'其他' }, DECLINE_WAIT_PULLBACK:'等待回调再议', DECLINE_MARKET_RISK:'大盘风险偏高', DECLINE_OTHER:'其他' },
}; };
const decideReasons = reactive({ accept:{}, decline:{} }); const decideReasons = reactive({ accept:{}, decline:{} });
let decideTimeoutMs = 30000;
async function loadDecideReasons() { async function loadDecideReasons() {
const d = await call('get', '/api/proposals/decide-reasons'); const d = await call('get', '/api/proposals/decide-reasons');
const src = (d && d.ok !== false) ? d : DECIDE_REASONS_FALLBACK; const src = (d && d.ok !== false) ? d : DECIDE_REASONS_FALLBACK;
decideReasons.accept = src.accept || DECIDE_REASONS_FALLBACK.accept; decideReasons.accept = src.accept || DECIDE_REASONS_FALLBACK.accept;
decideReasons.decline = src.decline || DECIDE_REASONS_FALLBACK.decline; decideReasons.decline = src.decline || DECIDE_REASONS_FALLBACK.decline;
if (Number(src.request_timeout_ms) > 0) decideTimeoutMs = Number(src.request_timeout_ms);
} }
const decideDlg = reactive({ visible:false, busy:false, row:null, decision:'', code:'', note:'' }); const decideDlg = reactive({ visible:false, busy:false, row:null, decision:'', code:'', note:'', message:'', updated:false, uncertain:false, withdrawn:false, pending:false });
// 采纳/驳回都从预设理由里选一条 (选「其他」再补一句), 不再手写整段 (三源合议自决后剩的都是真交人的)。 // 采纳/驳回都从预设理由里选一条 (选「其他」再补一句), 不再手写整段 (三源合议自决后剩的都是真交人的)。
function decide(row, decision) { function decide(row, decision) {
if (decideDlg.busy) return;
if (!Object.keys(decideReasons.accept).length) loadDecideReasons(); if (!Object.keys(decideReasons.accept).length) loadDecideReasons();
Object.assign(decideDlg, { visible:true, busy:false, row, decision, code:'', note:'' }); Object.assign(decideDlg, { visible:true, busy:false, row, decision, code:'', note:'',
message:((row.hard_numbers||{}).last_accept_check||{}).message || '', updated:false, uncertain:false, withdrawn:false, pending:false });
} }
const decideCodes = computed(() => const decideCodes = computed(() =>
decideDlg.decision === 'ACCEPTED' ? decideReasons.accept : decideReasons.decline); decideDlg.decision === 'ACCEPTED' ? decideReasons.accept : decideReasons.decline);
async function submitDecide() { async function submitDecide() {
const dd = decideDlg; const dd = decideDlg;
if (dd.busy || dd.uncertain || dd.withdrawn || dd.pending) return;
if (!dd.code && !dd.note.trim()) { ElementPlus.ElMessage.warning('选一个理由,或补一句说明'); return; } if (!dd.code && !dd.note.trim()) { ElementPlus.ElMessage.warning('选一个理由,或补一句说明'); return; }
if (dd.code && dd.code.endsWith('_OTHER') && !dd.note.trim()) { if (dd.code && dd.code.endsWith('_OTHER') && !dd.note.trim()) {
ElementPlus.ElMessage.warning('选「其他」时必须填补充说明'); return; } ElementPlus.ElMessage.warning('选「其他」时必须填补充说明'); return; }
dd.busy = true; dd.busy = true;
dd.message = '';
try {
const d = await call('post', '/api/proposals/' + dd.row.proposal_id + '/decide', const d = await call('post', '/api/proposals/' + dd.row.proposal_id + '/decide',
{ decision: dd.decision, reason_code: dd.code || null, reason_note: dd.note.trim() || null }); { decision: dd.decision, reason_code: dd.code || null, reason_note: dd.note.trim() || null,
dd.busy = false; proposal_revision: (dd.row.hard_numbers || {}).proposal_revision || null },
{ timeout: decideTimeoutMs });
if (d.ok) { if (d.ok) {
ElementPlus.ElMessage.success(dd.decision === 'ACCEPTED' ElementPlus.ElMessage.success(dd.decision === 'ACCEPTED' ? '已采纳,请查看当日指令' : '已驳回');
? ('已采纳, 指令 ' + d.instruction_id) : '已驳回');
if (d.warning) ElementPlus.ElMessage.warning(d.warning); if (d.warning) ElementPlus.ElMessage.warning(d.warning);
dd.visible = false; dd.visible = false;
await Promise.all([loadProposals(), loadInstructions(), loadLedger()]); await Promise.all([loadProposals(), loadInstructions(), loadLedger()]);
} else { ElementPlus.ElMessage.error(d.error); } } else {
dd.uncertain = !!d.uncertain;
dd.withdrawn = !!d.withdrawn;
dd.pending = !!d.pending;
dd.message = dd.uncertain
? '尚未收到处理结果。请关闭后刷新,先核对待确认提议和当日指令,勿立即重复提交。'
: (d.error || '本次未能采纳,请稍后再试');
if (d.proposal) {
const priorRevision = (dd.row.hard_numbers || {}).proposal_revision;
dd.row = { ...dd.row, ...d.proposal };
dd.updated = !d.retryable && !dd.withdrawn && !dd.pending &&
priorRevision !== (d.proposal.hard_numbers || {}).proposal_revision;
if (dd.updated) { dd.code = ''; dd.note = ''; }
await loadProposals();
} }
}
} catch (e) {
dd.uncertain = true;
dd.message = '尚未收到处理结果。请关闭后刷新,先核对待确认提议和当日指令,勿立即重复提交。';
} finally { dd.busy = false; }
}
async function loadStrategies() { async function loadStrategies() {
const q = '/api/strategies' + (showAllStrategies.value ? '?include_archived=1' : ''); const q = '/api/strategies' + (showAllStrategies.value ? '?include_archived=1' : '');
const d = await call('get', q); const d = await call('get', q);
@ -4420,7 +4647,7 @@ createApp({
const src = p.plan_source === 'snapshot' ? '快照' : (p.plan_source === 'live' ? '现算' : (p.plan_source || '')); const src = p.plan_source === 'snapshot' ? '快照' : (p.plan_source === 'live' ? '现算' : (p.plan_source || ''));
const gate = p.gate_on === true ? '赛道闸开' : (p.gate_on === false ? '赛道闸关' : ''); const gate = p.gate_on === true ? '赛道闸开' : (p.gate_on === false ? '赛道闸关' : '');
const head = ['选股计划数据至 ' + (p.date || '-') + '(数据日)', planFetchedText.value, src, gate].filter(Boolean).join(' · '); const head = ['选股计划数据至 ' + (p.date || '-') + '(数据日)', planFetchedText.value, src, gate].filter(Boolean).join(' · ');
return head + '。日期是数据日:上游每个交易日早上 07:10 用上一交易日收盘后的证据出计划,持仓系统 08:40 拉取,所以正常显示的是上一交易日。计划来源:快照=盘前落盘那份,毫秒返回、可复现;现算=盘中实时装配,较慢,多半是快照过旧回落。赛道闸=上游是否只在十条赛道内选票。'; return head + '。日期是数据日:上游每个交易日早上 07:10 用上一交易日收盘后的证据出计划,持仓系统 08:40 拉取,所以正常显示的是上一交易日。计划来源:快照=已发布的完整版本,包含晨版及盘中修订;旧接口的现算来源不具备同等追溯能力。赛道闸=上游是否只在十条赛道内选票。';
}); });
const hdMenuLabel = computed(() => { const hdMenuLabel = computed(() => {
const who = authed.value ? (me.value.username || me.value.phone || '') : ''; const who = authed.value ? (me.value.username || me.value.phone || '') : '';
@ -4450,12 +4677,13 @@ createApp({
if (!_mdReady) return '<pre style="white-space:pre-wrap">' + _escHtml(md) + '</pre>'; if (!_mdReady) return '<pre style="white-space:pre-wrap">' + _escHtml(md) + '</pre>';
return window.marked.parse(md); return window.marked.parse(md);
} }
async function openCompanyReport(code) { async function openCompanyReport(code, reviewRef = null) {
if (!code) return; if (!code) return;
Object.assign(rp, { open: true, code, url: '', html: '', meta: '', loading: true, error: '' }); Object.assign(rp, { open: true, code, url: '', html: '', meta: '', loading: true, error: '' });
// 不走 call(): 取不到报告只在抽屉里说, 不再往顶部横幅重复报一次 // 不走 call(): 取不到报告只在抽屉里说, 不再往顶部横幅重复报一次
let d; let d;
try { d = (await api.get('/api/research/' + encodeURIComponent(code) + '/report')).data; } try { d = (await api.get('/api/research/' + encodeURIComponent(code) + '/report' +
(reviewRef ? '?ref=' + encodeURIComponent(reviewRef) : ''))).data; }
catch (e) { d = { ok: false, error: '评析报告读取失败: ' + ((e && e.message) || '请求失败') }; } catch (e) { d = { ok: false, error: '评析报告读取失败: ' + ((e && e.message) || '请求失败') }; }
if (!rp.open || rp.code !== code) return; if (!rp.open || rp.code !== code) return;
rp.loading = false; rp.loading = false;
@ -4497,7 +4725,7 @@ createApp({
async function refreshLive() { async function refreshLive() {
// allSettled: 单个 loader 失败/超时(axios 60s 兜底)不拖累其余与时间戳更新。 // allSettled: 单个 loader 失败/超时(axios 60s 兜底)不拖累其余与时间戳更新。
await Promise.allSettled([loadOverview(), loadPositions(), loadInstructions(), loadLedger(), await Promise.allSettled([loadOverview(), loadPositions(), loadInstructions(), loadLedger(),
loadProposals(), loadStrategies(), loadOpLog(), loadOpenScan(), loadUpstream(), loadMacro()]); loadProposals(), loadStrategies(), loadOpLog(), loadOpenScan(), loadDividend(), loadUpstream(), loadMacro()]);
try { await loadNames(); } catch (e) {} try { await loadNames(); } catch (e) {}
// 用客户端钟, 保证"自动·HH:MM:SS"稳定跳动, 不依赖 /health 的 now。 // 用客户端钟, 保证"自动·HH:MM:SS"稳定跳动, 不依赖 /health 的 now。
lastRefresh.value = new Date().toTimeString().slice(0, 8); lastRefresh.value = new Date().toTimeString().slice(0, 8);
@ -4655,7 +4883,7 @@ createApp({
const _rf = _railLoad(); const _rf = _railLoad();
const lFold = ref(!!_rf.l), rFold = ref(!!_rf.r); const lFold = ref(!!_rf.l), rFold = ref(!!_rf.r);
const railOpen = ref(null); // null / 'l' / 'r' const railOpen = ref(null); // null / 'l' / 'r'
const sectClosed = reactive({ prop:false, strat:false, pool:false }); const sectClosed = reactive({ prop:false, strat:false, pool:false, dividend:false });
// 提议卡上「展开证据」的状态, 按提议号记。用整体替换而不是原地增删, // 提议卡上「展开证据」的状态, 按提议号记。用整体替换而不是原地增删,
// 因为 Vue 对 Set 的方法调用不作响应, 替换引用才会重画。 // 因为 Vue 对 Set 的方法调用不作响应, 替换引用才会重画。
const propMoreOpen = ref(new Set()); const propMoreOpen = ref(new Set());
@ -4737,13 +4965,13 @@ createApp({
}); });
return { tab, loading, err, health, ov, params, catalog, commands, plans, plansOf, return { tab, loading, err, health, ov, params, catalog, commands, plans, plansOf,
positions, lots, lotsOf, instructions, ledger, ledgerToday, proposals, report, reportDrawer, positions, lots, lotsOf, instructions, ledger, ledgerToday, proposals, preparingProposals, report, reportDrawer,
opsDrawer, opsResult, opsLoading, issuing, form, curSpec, dirtyCount, dm, opsDrawer, opsResult, opsLoading, issuing, form, curSpec, dirtyCount, dm,
money, pct, groupLabel, fieldLabel, stTag, cuTag, logicTag, canCancel, progPct, insPct, money, pct, groupLabel, fieldLabel, stTag, cuTag, logicTag, canCancel, progPct, insPct,
scaleGap, scaleGap,
wsRaw, wsAuto, wsHidePong, wsc, wst, wsMode, wsOrders, wsInbox, wsWarnings, loadWs, wsRaw, wsAuto, wsHidePong, wsc, wst, wsMode, wsOrders, wsInbox, wsWarnings, loadWs,
loadAll, loadParams, saveParams, loadPlans, loadLots, onCmdChange, issue, loadAll, loadParams, saveParams, loadPlans, loadLots, onCmdChange, issue,
cancelCmd, replan, decide, decideDlg, decideCodes, submitDecide, ops, loadSchema, openReport, cancelIns, cancelCmd, replan, decide, decideDlg, decideCodes, submitDecide, ops, loadSchema, openReport, cancelIns, researchData, researchSections, researchMaterials, researchSource, openResearch,
planDrawer, planLoading, planStatus, planFetchedText, planRows, planCand, planResult, planDrawer, planLoading, planStatus, planFetchedText, planRows, planCand, planResult,
loadPlan, openPlan, refreshPlan, loadPlan, openPlan, refreshPlan,
techStatus, techChipText, techChipCls, techStatus, techChipText, techChipCls,
@ -4758,7 +4986,7 @@ createApp({
propVerdictLine, propLogic, propLogicMore, propText, propHeads, propVerdictLine, propLogic, propLogicMore, propText, propHeads,
hardCn, opCn, paramsCn, dropCn, plainCheck, hardCn, opCn, paramsCn, dropCn, plainCheck,
// 2026-09-10 提议卡重排新增 // 2026-09-10 提议卡重排新增
propScale, propSizePct, propAdviceTier, propSizeMismatch, propResized, propJudgeShort, propScale, propAmount, propExpiry, propSizePct, propAdviceTier, propSizeMismatch, propResized, propJudgeShort,
propMoreOpen, togglePropMore, propMoreOpen, togglePropMore,
// 2026-09-12 提议卡重构: 来源结论标签 + 详情弹窗 // 2026-09-12 提议卡重构: 来源结论标签 + 详情弹窗
cr, propPlanTag, propPlanSub, propJudgeTag, propCompanyTag, propTechTag, propTechSub, cr, propPlanTag, propPlanSub, propJudgeTag, propCompanyTag, propTechTag, propTechSub,
@ -4773,10 +5001,11 @@ createApp({
autoScanRes, autoScanBusy, autoScanPreview, stageTagType, autoInfo, autoScanRes, autoScanBusy, autoScanPreview, stageTagType, autoInfo,
openStrategy, validateStrategy, attachStrategy, setStrategyStatus, stratStateText, resumeBuy, openStrategy, validateStrategy, attachStrategy, setStrategyStatus, stratStateText, resumeBuy,
showLedger, onPosExpand, showLedger, onPosExpand,
dividend, dividendShown, dividendBusy, dividendMore, prepareDividend, loadDividend,
openScan, insTab, todayYmd, insLive, insDone, insEnd, dispOf, conOf, loadOpenScan, denyToday, openScan, insTab, todayYmd, insLive, insDone, insEnd, dispOf, conOf, loadOpenScan, denyToday,
commandsShown, strategiesShown, instrLive, showAllCommands, showAllStrategies, showAllInstr, commandsShown, strategiesShown, instrLive, showAllCommands, showAllStrategies, showAllInstr,
cmdArchivable, stratArchivable, archiveRow, cmdArchivable, stratArchivable, archiveRow,
showOpLog, showSettings, watchCandidates, marketOpen, marketState, lastRefresh, autoRefresh, showOpLog, showSettings, watchCandidates, scanNotes, marketOpen, marketState, lastRefresh, autoRefresh,
upstream, showUpstream, usrc, loadUpstream, srcFail, upstream, showUpstream, usrc, loadUpstream, srcFail,
csOpen, csCode, csLoading, csErr, csData, csFromSnap, csTimeline, csSrcFails, csOpen, csCode, csLoading, csErr, csData, csFromSnap, csTimeline, csSrcFails,
csTruncated, csSrcLabel, csLedger, csLedgerErr, csHeld, csInPlan, csTruncated, csSrcLabel, csLedger, csLedgerErr, csHeld, csInPlan,

View File

@ -843,8 +843,8 @@ class WsRunner:
""" """
while not self._stop.is_set(): while not self._stop.is_set():
try: try:
await self._drain_outbox(seed)
await self._drain_cancels(seed) await self._drain_cancels(seed)
await self._drain_outbox(seed)
except asyncio.CancelledError: except asyncio.CancelledError:
raise raise
except Exception as e: except Exception as e:
@ -871,6 +871,22 @@ class WsRunner:
if not await _db(qmt_repo.claim_order, iid): if not await _db(qmt_repo.claim_order, iid):
continue # 被别的进程抢走了 (滚动重启的瞬间) continue # 被别的进程抢走了 (滚动重启的瞬间)
try: try:
# 排队后可能发生清仓或撤单。认领后再核对,未知状态保留重试。
fresh = await _db(qmt_repo.get_order, iid)
if not fresh or fresh.get('cancel_state') in ('REQUESTED', 'SENT'):
await _db(qmt_repo.abort_order, iid, '发出前撤销')
continue
from app.services.execution_conflicts import queued_buy_blocker
try:
blocked = await _db(queued_buy_blocker, fresh)
except Exception as exc:
await _db(qmt_repo.requeue_order, iid, f'买入依据暂不可核实: {exc}',
self._p('max_attempts', 3), False)
logger.warning('[outbox] %s 买入依据暂不可核实,保留队列', iid)
continue
if blocked:
await _db(qmt_repo.abort_order, iid, blocked)
continue
payload = wsc.place_order_payload( payload = wsc.place_order_payload(
instruction_id=iid, ts_code=r["ts_code"], side=r["side"], instruction_id=iid, ts_code=r["ts_code"], side=r["side"],
qty=int(r["qty"]), limit_price=r["limit_price"], qty=int(r["qty"]), limit_price=r["limit_price"],

View File

@ -161,16 +161,16 @@ class Settings(BaseSettings):
PMS_PLAN_OBS_TOP: int = 100 # 上游 obs_top: 观察档要多少条 PMS_PLAN_OBS_TOP: int = 100 # 上游 obs_top: 观察档要多少条
PMS_PLAN_THEME_CAP: int = 999 # 上游 theme_cap: 让它别裁 (PMS 自己裁) PMS_PLAN_THEME_CAP: int = 999 # 上游 theme_cap: 让它别裁 (PMS 自己裁)
PMS_PLAN_THEME_CAP_LOCAL: int = 5 # PMS 侧同主题限额, 在 TOP_N 截断**之前**生效, 0=不限 PMS_PLAN_THEME_CAP_LOCAL: int = 5 # PMS 侧同主题限额, 在 TOP_N 截断**之前**生效, 0=不限
PMS_PLAN_TOP_N: int = 30 # 主榜按 score 降序取前 N 进池 (900+ 只是排序池不是清单) PMS_PLAN_TOP_N: int = 30 # 按有效排序取前 N 进池,运行参数可覆盖
PMS_PLAN_TIERS: str = "强传导" # 传导档白名单; 留空=不按档过滤 PMS_PLAN_TIERS: str = "" # 传导档白名单;留空不按强弱档位过滤
# **已定纪律 (2026-07-31, 用户): 候选宁缺毋滥, 不因当天强传导少就放宽到弱传导。** # 2026-10-26 用户授权完成质地排序切换:传导强弱不再是候选资格门槛。
# 上游文档说强传导规模随市场结构波动、无板块传导的日子可能一个都没有 —— 那种日子 # 质地次序由上游提供,判决、风险、黑名单和组合约束继续各自生效。
# 候选池就该是空的。只有"热度启动信息经确认"时才考虑放宽, 且要显式改这个参数。 # 此参数保留给显式限定场景,不能把旧的“只收强传导”默认为新策略。
PMS_PLAN_INCLUDE_OBSERVE: bool = False # 观察档是否进候选池 (上游把它定位为备选, 无 upside) PMS_PLAN_INCLUDE_OBSERVE: bool = False # 观察档是否进候选池 (上游把它定位为备选, 无 upside)
PMS_PLAN_MIN_SCORE: float = 0.0 # score 下限, 0=不设 PMS_PLAN_MIN_SCORE: float = 0.0 # score 下限, 0=不设
PMS_PLAN_MIN_SOURCES: int = 0 # evidence.n_sources 下限, 0=不设 PMS_PLAN_MIN_SOURCES: int = 0 # evidence.n_sources 下限, 0=不设
PMS_PLAN_MIN_UPSIDE: float = 0.0 # 预期空间下限 (0.5=+50%), 0=不设。券商目标价 PMS_PLAN_MIN_UPSIDE: float = 0.0 # 预期空间下限 (0.5=+50%), 0=不设。券商目标价
# 口径, 噪音大 (榜首能到 +212%), 只做下限过滤, **不参与排序** —— 排序始终是 score # 口径, 噪音大 (榜首能到 +212%), 只做下限过滤,不参与排序。
PMS_PLAN_STALE_TDAYS: int = 1 # 计划日龄超此交易日数即判过期并拒用 (防上游停更) PMS_PLAN_STALE_TDAYS: int = 1 # 计划日龄超此交易日数即判过期并拒用 (防上游停更)
PMS_PLAN_EXCLUDE_ST: bool = True # 剔除 ST/*ST/退市 (上游明确不剔除, 这道闸归 PMS) PMS_PLAN_EXCLUDE_ST: bool = True # 剔除 ST/*ST/退市 (上游明确不剔除, 这道闸归 PMS)
PMS_PLAN_THEME_SYNC: bool = False # 把 theme 灌进 pms_industry_map。**默认关**: PMS_PLAN_THEME_SYNC: bool = False # 把 theme 灌进 pms_industry_map。**默认关**:
@ -181,6 +181,7 @@ class Settings(BaseSettings):
# --- 榜单变化提示 (PMS 自算; 上游 changes 字段恒为 null, 见 UPSTREAM_PLAN_API.md §9) --- # --- 榜单变化提示 (PMS 自算; 上游 changes 字段恒为 null, 见 UPSTREAM_PLAN_API.md §9) ---
PMS_PLAN_SNAPSHOT: bool = True # 每次拉计划落一份名册快照 (变化提示的底本)。 PMS_PLAN_SNAPSHOT: bool = True # 每次拉计划落一份名册快照 (变化提示的底本)。
PMS_PLAN_VERSION_RECHECK: bool = False # 分批上线:新版计划稳定后显式开启采纳前重核。
# 关掉只是没有变化提示, 不影响候选池; 但同时也失去"手上这份是哪一版"的自证能力 # 关掉只是没有变化提示, 不影响候选池; 但同时也失去"手上这份是哪一版"的自证能力
PMS_PLAN_SNAPSHOT_KEEP: int = 200 # 快照保留份数 (一份 300 只约 20KB) PMS_PLAN_SNAPSHOT_KEEP: int = 200 # 快照保留份数 (一份 300 只约 20KB)
PMS_PLAN_DIFF_RANK_JUMP: int = 50 # 名次跳变多少名才报 PMS_PLAN_DIFF_RANK_JUMP: int = 50 # 名次跳变多少名才报

View File

@ -0,0 +1,181 @@
# PMS 三项对账差异排查与修复规格
2026-10-15,北京时间。对象是 155 模拟 PMS,ws 下发、propose_only 新建仓。188 真实仓不在本次范围。
## 事实与预判
只读 reconcile(apply_fix=False) 发现 002050.SZ 账本 800 / QMT 700,002979.SZ 账本 0 / QMT 1900,688100.SH 账本 2400 / QMT 1400。
八个委托的 trading_order.order_id 与 pms_qmt_order.instruction_id 相同,qmt_order_id 与 broker_order_id 也全部一致。
WebSocket 逐笔回报均 processed=1,汇总委托全部已进入 PMS_REPLAY_CURSOR.seen。
| 股票 | 当日重复回放的汇总数量 | 结果 |
| --- | --- | --- |
| 002050.SZ | 买入 100 | 净多 100;批次 1361 以委托限价 31.560 重复入账,逐笔实际为 73 股 30.690 和 27 股 30.650 |
| 002979.SZ | 卖出 1300、500、100、100,合计 2000 | 重复核销后数量扣到零,与 QMT 1900 不符;数量下限截断使差额不是 2000 |
| 688100.SH | 买入 700、卖出 400、买入 700 | 重复净买入 1000;部分重复买入又被错误认作外部 BASE |
根因在 ledger_service.replay_fills:注释承诺 trading_order 只兜外部/人工成交,实际没有排除本 PMS 的 WebSocket 委托。
这不是新计划版本造成的;三项当日账本更新时间均早于 10:42 PMS 部署。成交价格也因汇总表回退委托价格而被污染。
## 修复原理及边界
在 trading_order 回放认领前,以委托编号及券商编号精确查询本实例 pms_qmt_order,不按股票、时间和数量猜测重复。
属于本实例出口表的委托只由 WebSocket 逐笔入账,汇总镜像只推进既有 seen 游标并留跳过原因。
即使逐笔迟到、部分到达、联调单或当前模式已经切回 shadow,也不得从汇总表补记同一委托。
身份查不到的外部/人工成交保留原回放。身份读取失败、两个标识对应不同委托、代码/方向/券商身份冲突时,不入账、不记 seen,留错供下一跳重试。
单表 SQL,不新增表、调度或交易参数。历史账本与历史指令进度不由此补丁自动回写。
## 验收
先用合成数据复现双来源买入、卖出、部分成交与乱序。新增第 39 批测试;执行配置隔离与禁止联网的全量测试。
部署前再核验实例、在途委托与容器指纹;匹配候选镜像断网全量通过后,按本聊天授权重建 PMS 四进程。
真机检查健康、通道、回放无重复动作与只读身份分类。已有错账单独标记,不能把修复代码通过说成历史账已恢复。
## 历史修复约束
日终 RECON 只调数量,并会把差额按行情价格当成新增或核销,不能修复被污染的原始成本、已实现盈亏和指令 exec_qty。
因此不为消除告警直接 force 对账。先保存当前批次、原逐笔成交、汇总回放游标及指令快照,评估能否完整重建。
历史已有 RECON 与过往双记相互叠加;冻结证据不足时不能伪造无误差历史。任何后续修复须另存可逆备份与调整依据。
## 12:05 实测结果
修复提交 e9afc7a 已于 12:02:54 部署 155 四个 PMS 服务。新增 12 例、开发机全量 43 批、候选镜像断网全量 43 批均通过。
真实八笔委托的只读归属核验全部正确。健康、数据库、QMT 通道正常,待入账和在途出口委托为零。
当前为午休,修复后自然新成交回放尚待事件验证;三项历史差异仍保留,不报告为清零。
原始证据文件 ~/pms_logs/reconciliation-evidence-20261015-before-fix-v2.json 的 SHA256 为 8e0badf4d771fbf8a3227250c6cc2c2bf3c8234dda2fc33a31f0ab00920f5501。
原始交易持仓表额外出现 562590.SH 与 688825.SH 属另一项事实源覆盖差异,继续按既有 ws_first 取实际持仓,不混同三项账本差异。
## 历史修复开发规格与预判(2026-10-15 12:30,北京时间)
用户已明确授权先备份,再逐笔恢复数量、成本、盈亏和指令执行进度。修复限定 155 模拟仓 002050.SZ、002979.SZ、688100.SH。188 不在范围内。首份完整备份为主机 pms_logs/historical-repair-backup-20261015-1225.json,SHA256 为 81cfc59600d7ca07de7fc4b83b7c5b153719d0ea248be21fd9d910bcfc32e636。包含全部持仓、批次、指令、方案、命令、出口单、手续费、策略、提议、日报、净值,三票动作账本,完整留存逐笔成交及下游成交表。写前还要重新备份并校验并发变化。
实现采用纯函数重建与单表 SQL 事务写回。逐笔成交必须能唯一对应出口子单,代码、方向、委托号、累计数量一致;同成交号冲突、漏笔、卖超、外部成交无法解释、来源读取失败均阻断。每笔真实买入以父指令、数量、价格、原入账时间唯一对应原批次。重复买入批次须能聚合对应同一条下游汇总单,RECON 调整须单列;不能直接按数量差删除。真实卖出按既有批次优先级逐笔重算核销量与盈亏。原批次 ID 保留,虚假批次归零并注明备份与修复批号,不删除原证据。
成本使用成交金额或等价的“剩余批次成本减已实现盈亏”,避免三位小数核销均价再乘数量带来的舍入误差。费用不摊进成本;缺失费用保持未知。父指令按真实逐笔量与金额重建 exec_qty/exec_avg_price,同时在 progress 中保存原值、子单证据和剩余量。原误判完成但未足量的指令改为 CANCELLED 并记录“历史修复暂停剩余执行”,前提是所有子单均已终态,绝不恢复自动续单;原在执行的指令保持生命周期。真实超目标成交如 002979 的 1,300 股网格指令成交 2,600 股要如实保留并标异常。方案、命令当前为空,无需伪造。
完整性边界按当前留存批次的起始日验证,之前成交净数量必须为零。002050 从 09-22、002979 从 09-21、688100 从 10-14 重建。688100 的 08-27 至 09-01 已闭合旧轮次缺父指令及原批次,单列成交金额,不混入当前账期。历史安全垫峰值、手续费、过往日报与全组合净值如缺原始材料不宣称恢复;保存原值和修复附注。
写回只在受影响子单无在途、无未处理逐笔时进行。短暂停止 pms-beat 与 pms-worker,保留通道接收能力;所有快照比较和更新位于同一数据库事务,每条 SQL 仍经过表名前缀与单表守卫。事务写入审计记录;备份指纹不符、数据已变或中途失败均不提交。重复执行同一批号返回已完成。回退必须先比较修复后字段,若已有新成交则拒绝覆盖。写完只读核对,再恢复调度。
预判:重建后数量分别为 700、1,900、1,400;全部相关子单逐笔量等于累计量;虚假买入批次和 RECON 调整不再贡献成本或盈亏;指令真实进度不会因修复自动生成新单;原始成交、回放游标、策略阈值和明日启用门槛不变。测试覆盖金额、部分成交、漏笔、匹配歧义、并发、幂等、失败回滚及旧指令不复活。生产读回后逐条判收。
## 10-15 12:40 历史账本修复完成与判收
本节取代前文“三项历史差异尚未修复”的当前状态。用户明确批准先备份、逐笔核对并恢复数量、成本、盈亏及指令执行进度。已在 155 模拟仓完成,188 未操作。
### 备份、部署和写回
功能提交 `0871885`,Python 指纹 `01251315d8d1`。本地配置隔离禁网和 155 候选镜像 `--network none` 均通过全部 44 批测试,新批次 40 有 21 例。未将用户原有未提交台账 017、讨论稿或探针纳入提交。
先于任何写账保存完整备份,再在午间暂停 beat/worker,拉取已提交版本并重建四容器。web/ws 于 12:37:27 启动,worker/beat 于 12:39:33 恢复。四容器同镜像 `sha256:22422dc46784ff87c8ccfc6f9a2ae05ba8ee111eb18e3f1a369f9d913279ff0b`,标签 `pms:history-repair-0871885`;上一镜像留为 `pms:rollback-before-history-repair-20261015`。
155 宿主 `~/pms_logs/` 的证据如下,JSON 文件权限为 600。
| 文件 | 内容或 SHA256 |
| --- | --- |
| historical-repair-backup-20261015-1225.json | 初始完整备份,81cfc59600d7ca07de7fc4b83b7c5b153719d0ea248be21fd9d910bcfc32e636 |
| history-repair-before-write-20261015.json | 12:37:55 写前完整备份,d1b3eeaede0ea418ec071fa593ee6a98177a55433ee0201b502ff80ff6226f02 |
| history-repair-preview-20261015.json | 逐笔映射、每笔卖出分配、逐日数量金额、全部目标列和原值 |
| history-repair-after-write-20261015.json | 写后完整备份,8463f0da2e1d152e7606c38607918b05555481f4ecbd15b482a326951ebd3606 |
| history-repair-apply-20261015.log / history-repair-verify-20261015.json | 实际提交及独立读回判收,全部检查通过 |
| history-repair-build-20261015.log / history-repair-tests-20261015.log / history-repair-deploy-20261015.log | 候选构建、断网测试及容器重建 |
修复批号 `HIST_c036a684cab040387321396e`。同一事务校验原行、完整逐笔和有效参数,修改 122 行,保存 122 条逐行原值审计和 1 条完成记录。再次执行同一备份返回 already_applied,审计数仍 122+1。原始成交、回放游标、方案、命令、手续费流水、旧日报净值及其他股票原行均未被改写。
### 实际恢复结果
| 股票 | 恢复数量 | T+1 可卖量 | 摊薄成本(元) | 账期已实现盈亏(元) | 可追溯起点 |
| --- | ---: | ---: | ---: | ---: | --- |
| 002050.SZ | 700 | 600 | 44.109 | -6762.70 | 2026-09-22 |
| 002979.SZ | 1900 | 1900 | 55.060 | -1684.25 | 2026-09-21 |
| 688100.SH | 1400 | 0 | 23.704 | 16.86 | 2026-10-14 |
成本沿用 PMS 的含已实现盈亏摊薄口径,盈亏为原批次核销规则下的毛额,不含费用。134 笔成交对应 61 个真实买入批次;33 个重复汇总或 RECON 批次归零留痕,原 ID 保留。逐笔成交与 39 个留存子单的累计数量一致,累计均价差异最大 0.004964 元,处于 QMT 两位小数舍入范围内;其中 2 个子单属于 688100 的已闭合旧轮次,未混入当前账期。
24 条父指令恢复实际成交量、成交均价,并在 progress 中增加逐笔证据、原进度、剩余量及超额量。七条原误判 CONFIRMED 的指令改为 CANCELLED,含义为“历史修复暂停剩余执行”;其子单都已终态,无需撤单,也没有向 QMT 发送撤单或新单。仍在执行的 002050 DCA 指令实际进度为 100/300,保持原生命周期。
002979 的 `STR20261012093212_002979SZ_g` 目标 1300 股,两个真实子单累计买入 2600 股,保留超额 1300 的事实。这是实际执行异常,无法通过删账撤销,后续须单独排查历史出手并发/重试链路;本次没有反向交易。688100 活跃网格第 3 档恢复为真实剩余 1000 股,批次成本 23506.51 元、均价 23.50651;原仅记 700 股/16471 元。已取消的旧策略未恢复。
12:40 真机健康 200、db_ok=True、calendar_degraded=False,QMT ONLINE、last_seq=acked_seq=1226583、last_error 为空,待入账 0。独立对账返回 diffs=[]、errors=[]、severity=OK。历史 streak=14 是尚未到日终重置的旧计数,不是仍有三项差异。既有 ws_first 源覆盖警告仍为 562590.SH、688825.SH 两票,单列保留,不混同已修复差异。
### 明确不能还原或未判收的部分
1. 134 笔逐笔费用为空,无法还原真实扣费与净盈亏;费用流水原为空,未补零冒充真实费用。
2. 缺完整盘中行情和当时账本,历史安全垫峰值无法准确恢复,保留原值并标明限制。
3. 688100 的 08-27 买 800、09-01 卖 800 的旧轮次可核对成交毛差 330.47 元,但原父指令和批次已不在当前账本;无法恢复原始批次分配与完整决策链,不把该旧轮次利润写进本轮。
4. 历史日报和全组合净值受旧错账影响,缺少重建全组合所需的全部原始状态,本次保持原档案。修复预演提供逐票逐日数量、成交净额和批次盈亏,不能将其冒充当时实际报表或已修复全历史绩效。
5. 防双记代码的自然新成交判收仍需真实事件;不得制造成交来验收。真实超目标成交和两个事实源覆盖分歧仍单列待查。
### 后续和回退
`automation-2` 已更新修复结论,保持 ACTIVE 和北京时间 10-16 07:25。首个完整晨版通过后启用已创建且停止的 XXL 137,再开启 155 的 PMS_PLAN_VERSION_RECHECK。当前该参数仍 False,ws、propose_only、旧传导排序及档位和仓位参数保持;不增加额外五日模拟观察。版本一致、顺序、自然传播十二分钟、失败守成和无重复指令仍须实际事件判收。
手工入口 `scripts/repair_ledger_history.py` 开头列有 backup/preview/apply/rollback 跑法。回退须读取审计并比较修复后原行,后续有新交易或状态变化会拒绝覆盖;不得通过切旧镜像恢复旧账,更不得直接用旧备份覆盖新的成交。回退保留新旧审计与计划版本。
### 父指令进度逐条核验
| 父指令 | 原记成交量 | 真实成交量 | 真实均价 | 写后状态 | 剩余量 / 超额量 |
| --- | ---: | ---: | ---: | --- | --- |
| INS_20260918_002050SZ_OPEN_001 | 622 | 500 | 36.160 | CONFIRMED | 0 / 0 |
| STR20260923100400_002050SZ_g | 3277 | 1900 | 35.936 | CONFIRMED | 0 / 0 |
| STR20260923130400_002050SZ_g | 616 | 500 | 36.031 | CONFIRMED | 0 / 0 |
| STR20260928093600_002050SZ_g | 3544 | 1900 | 35.995 | CONFIRMED | 0 / 0 |
| STR20260928094700_002050SZ_g | 2000 | 1900 | 35.985 | CONFIRMED | 0 / 0 |
| STR20260928094900_002050SZ_g | 3609 | 1900 | 35.844 | CONFIRMED | 0 / 0 |
| STR20260930095702_002050SZ_g | 2183 | 1900 | 36.028 | CONFIRMED | 0 / 0 |
| INS_20260930_002050SZ_OPEN_100000 | 1600 | 800 | 35.032 | CANCELLED | 800 / 0 |
| INS_20261009_002050SZ_EXIT_103100 | 2711 | 1400 | 32.213 | CANCELLED | 1300 / 0 |
| INS_20261012_002050SZ_EXIT_93100 | 1346 | 700 | 33.044 | CANCELLED | 600 / 0 |
| INS_20261015_002050SZ_DCA_001 | 200 | 100 | 30.679 | DISPATCHED | 200 / 0 |
| INS_20260921_002979SZ_OPEN_001 | 307 | 200 | 54.470 | CANCELLED | 100 / 0 |
| STR20260923094502_002979SZ_g | 1401 | 1300 | 54.192 | CONFIRMED | 0 / 0 |
| STR20260923095800_002979SZ_g | 291 | 200 | 54.249 | CONFIRMED | 0 / 0 |
| STR20260924093702_002979SZ_g | 2438 | 1300 | 54.210 | CONFIRMED | 0 / 0 |
| STR20260924094001_002979SZ_g | 1458 | 1300 | 54.351 | CONFIRMED | 0 / 0 |
| STR20260924094200_002979SZ_g | 1683 | 1300 | 54.260 | CONFIRMED | 0 / 0 |
| INS_20261012_002979SZ_EXIT_001 | 2600 | 1300 | 54.178 | CANCELLED | 1300 / 0 |
| STR20261012093212_002979SZ_g | 2600 | 2600 | 53.677 | CONFIRMED | 0 / 1300 |
| INS_20261015_002979SZ_EXIT_95100 | 3900 | 2000 | 52.681 | CANCELLED | 1900 / 0 |
| INS_20261014_688100SH_OPEN_001 | 800 | 400 | 24.240 | CANCELLED | 400 / 0 |
| STR20261015094200_688100SH_g | 1023 | 700 | 23.571 | CONFIRMED | 0 / 0 |
| STR20261015094500_688100SH_g | 524 | 400 | 23.620 | CONFIRMED | 0 / 0 |
| STR20261015100700_688100SH_g | 1236 | 700 | 23.482 | CONFIRMED | 0 / 0 |
## 10-15 12:50 最终运行版本与均价有效期
最终功能提交为 `a56dac5`,包含 0871885 的历史修复及指令均价有效期补齐。原增量入账接口只收到数量,不能重算全量均价;后续新成交时同步清空旧 exec_avg_price,固定修复时点的准确金额继续保存在 progress.historical_repair 与操作审计中,避免显示过期均价。未再次改写历史账本,也未恢复暂停指令。
batch40 增至 22 例,内存数据库验证数量增加、均价失效、固定证据保持;本地与候选镜像 `--network none` 全部 44 批再次通过。12:50:11 四容器重建并恢复,镜像 `sha256:f3d4e698bc31be521f59b39588444495e143f9a52a3d5233b42a699f4030093d`,标签 `pms:mean-validity-a56dac5`,Python 指纹 `3de5fc3a261e`。前一版保留为 `pms:rollback-before-mean-validity-20261015`。
12:50:47 再次独立逐字段核验通过,三票数量、成本与盈亏保持上一节读数,审计仍为 122+1,对账 diffs=[]、severity=OK。健康 200、db_ok=True、calendar_degraded=False,QMT ONLINE、last_seq=acked_seq=1226717、last_error 为空。PMS_PLAN_VERSION_RECHECK 仍 False。全部备份及不可还原边界继续有效,明日 07:25 接续安排保持。
最终日志位于 155 `~/pms_logs/mean-validity-build-20261015.log`、`mean-validity-tests-20261015.log`、`mean-validity-deploy-20261015.log`、`mean-validity-ledger-verify-20261015.json`。四仓文档继续同步;只有文档更新无需再次重启容器。
## 2026-10-16 自然成交防双记补验
只读核对 10-15 12:50:47 修复后发生的 14 笔深科技卖出。成交发生在 13:31:36—13:41:45,合计 1,000 股、28,270.78 元,14 个成交号唯一且 processed=1。五条子单 D01、D02、D03、D04、D06 的实际成交数量分别为 400、300、100、100、100。汇总表中同五个委托的完成镜像已存在。
父指令 INS_20261015_000021SZ_EXIT_133100 的 exec_qty=1,000,状态 CONFIRMED。原持仓 1,000 股归零。批次 1302、1303 分别核销 400、600 股,其余历史批次逐字段保持。没有出现汇总镜像导致的第二次持仓扣减或执行进度累加。exec_avg_price 为 NULL,符合新增成交后不沿用旧均价的修复约定。
独立按原批次成本 36.182 元逐笔重算,分笔入账舍入到分后,两批已实现毛盈亏为 -3,237.32 和 -4,673.91 元,与账本一致。合计 -7,911.23 元。一次性按总金额减总成本为 -7,911.22 元,一分钱差异来自既有逐笔舍入。该票原批次是历史 RECON 成本,本次只判收修复后成交未双记,不宣称其全部早期历史成本已经重建。费用、旧批次与历史净值边界保持。
证据:155 ~/pms_logs/natural-fills-20261016-1035.json,读取的基线为 history-repair-after-write-20261015.json。核验脚本 verify_natural_fills_20261016.py 仅做 SELECT;没有调用回放、修复写入、采纳或交易。后续 10-16 仍无新成交,本项自然事件证据不再列为完全缺失。
## 2026-10-16 11:25 威胜信息自然卖出与网格数量边界
11:07:45—11:14:37 新增七笔威胜信息卖出,合计 1,400 股、32,933.49 元。成交号唯一且均已处理。两条父指令 STR20261016110502_688100SH_g、STR20261016111300_688100SH_g 各为目标 700、实际 700,均 CONFIRMED,执行均价为空。两条汇总镜像已被回放识别并跳过;11:08:01、11:14:00 原 worker 日志保留了逐笔入账与汇总 actions=0 的证据。
按修复后的原批次及既有核销顺序独立逐笔重算,所有批次的剩余数量、已核销量及已实现毛盈亏逐项一致。原 1,000 股 ADD 与 400 股 BASE 均已卖出,当前持仓 0、成本价空、已实现毛盈亏从 16.86 元变为 -252.01 元。七笔新增毛盈亏合计 -268.87 元。其中底仓 400 股已实现毛亏为 -282.93 元;这是按历史批次成本计算的金额,不能据此推断不卖出时的后续收益。费用仍未提供。
需与双记区分的实际策略缺陷:历史修复后的网格第 3 档为 1,000 股,配置 per_lot=700。11:05 首笔卖 700 后,11:09:02 运行器正确恢复档位剩余 300。11:13 卖出取量却只受配置档量和总可卖量限制,仍发 700,额外侵入底仓 400。11:16:01 原清场流程已取消该策略。修复 _eval_grid 的数量边界,保持触发条件与配置。真实成交不删除、不回填持仓,不作反向交易。
11:19 首次只读对账遇到旧持仓快照差异;11:19:31 完整快照更新后,11:20:04 diffs=[]、severity=OK。核验使用 apply_fix=False,未做数量调整。七条历史暂停指令继续保持,122+1 条原修复审计不重写。
证据位于 155 ~/pms_logs/。grid-incident-worker-20261016.log 的 SHA256 为 9fd10e419b46de2854a6e8e6793ec91de7218e531892d12ce0a97b1b9bfabd4c。grid-natural-20261016-1125.json 的 SHA256 为 24c22500168b1e9a9951cd3332a91e4385ca4027d6534cff3a7dcf4dfbd77f68。natural-fills-688100-20261016-1125.json 的 SHA256 为 929b2c4ace7ee12afb3bc411c2dc7e5521d62c5903294a9d7dc762a609d48200。独立逐笔结果在 688100-natural-fill-independent-20261016.json。修复及部署判收见同日四仓交接末节与桥台账 070。

View File

@ -0,0 +1,211 @@
# 分红持续性研究数据产品交接
2026-10-21,北京时间。用户批准专项研究,并要求基座沉淀可复用数据。
## 本地实现
基座新增独立研究包、归档表、只读批量及固定版本接口。
沿用brain模型路由,六项研究分别保留支持、压力与未知。
证据编号、原文摘录、数字和公司类型由程序检查。
模型不改变基座质地,不形成股票评分、候选资格或买卖动作。
金融企业类型以原始现金流表为准,必须保留资本约束证据。
来源故障和模型失败保留上一份完整研究,另记检查和调用状态。
输入不变复用;月度复查只检查已登记对象,自动开关默认关闭。
新任务、手工脚本、日检、表定义与运行参数均已登记。
桥每日检查新增只读研究摘要。缺失、失败和到期分别展示。
技术来源仍在详情,研究有支持也不改变investment_approved=false。
PMS与择时系统仅同步文档,没有代码或参数变更。
## 真实材料核对
仅在178的backend容器执行只读查询,无模型调用、写库或容器操作。
首个探针2026-10-21 16:54北京时间,随后冻结两家公司的真实材料。
丽珠集团与海尔智家各有21行财务指标、22行重构报表。
两家指标及原始现金流仅到2026一季度,重构报表已到半年报。
丽珠读取6份年度或半年度报告,海尔读取7份,解析缓存均存在。
当前匹配结果未见单独的分红实施公告,不能称公告覆盖完整。
海尔的分红表存在同阶段同日期冲突,未擅自选取或相加。
模型输入选择年度财务及最近两期,并提取有偏移的文档节选。
完整原料仍冻结。丽珠78条证据、67499字符,海尔82条、72155字符。
两家达到单次语义研究的输入条件,但材料缺口未消除。
本轮没有实际调用模型,没有生成这两家公司的专项研究结论。
## 验证与部署边界
本地标准库离线回归与桥契约测试结果见末节。
假模型输出仅用于用例,不进入研究页面或任何生产表。
曾发现测试文件根目录定位错误,修正后通过。
桥缺省文案变化导致旧用例失败,已恢复“待核验”兼容语义。
真实取材曾超过单次容量,已改为保留全量原料、精选有来源的输入。
未来与未知日期材料不进入模型提示词,此项有专门回归。
本轮没有推送、远端拉取、初始化新表、重启或重建。
新增接口与任务尚未在线生效,自动复查没有启用。
不得把本地实现或真实只读取材称作生产研究已完成。
部署前先核实际分支、队列及模型配置,不推断当前模型名仍与旧报告相同。
178工作进程代码生效需四类worker一起重建;新增定时需beat加载新表。
基座接口侧源码挂载会立即重载,远端拉取前核好整段提交。
桥需重建或重启加载新接口消费模块,遵守容器操作授权边界。
维护避开06:10及07:10。188不操作。
## 接续顺序
1. 准备部署并初始化研究表。先核只读接口,不启用自动批量。
2. 从少量已取材公司完成真实模型研究,核对每条引用和反方。
3. 补齐半年报和分红公告。不能用模型补写缺失事实。
4. 通过真实保存、重复提交与旧版查询验收后,再启用月度复查。
5. 继续分批补个股评析覆盖。此次没有自动完成155家的缺失研究。
暂停仅关闭专项复查,历史结果保留。PMS交易规则无需回退。
## 17:15本地验收记录
基座全量离线229项通过。桥研究与计划契约联合70项通过。
两组都禁止socket联网,实际网络尝试均为零。
桥仓要求的六组既有脚本另行通过,含XXL入口13例。
XXL首次因临时运行环境缺fastapi未启动,改用已有隔离环境后通过。
新增文件语法、空白与git diff --check通过。
没有在生产容器运行旧测试副本。
查询另覆盖A、B、再次复用A的序列。
用SQLite执行同一窗口查询,仅转换占位符与ANY语法。
确认当前返回复用的A,早期截止仍返回B,固定A正文未改。
该用例不代替生产PostgreSQL建表、索引与并发事务判收。
证据保存在开发机以下目录,SHA256SUMS包含八个文件摘要。
`/Users/baobao/.codex/visualizations/2026/10/14/01a1396c-4e8e-7a21-ac34-8b7f6150dfe3/dividend-foundation-20261021/`
包含只读取材脚本、源探针、完整冻结材料、材料形状与三份测试日志。
真实源材料没有写进Git仓库。假模型回答也没有作为研究产物发布。
本轮页面仅由离线HTML用例检查文案与旧字段兼容。
新研究页面的浏览器验收、真实模型语义与实际数据库接口均待部署后完成。
本地功能提交:基座a5d4c02,桥238b5f7。
方案与交接另作副本同步提交。没有推送或部署。
PMS既有台账、探针和择时仓库已有未提交文件均未纳入本次提交。
## 2026-10-22 部署与真实模型问题处置
用户已授权部署,也已授权本序列后续公司的云端模型研究。
范围为财报、公告节选及现有评析摘要,发往api.deepseek.com。
当前路由brain,实际模型deepseek-v4-pro,窗口1000000。
沿用现有路由,不调用188本地模型,不改PMS交易或参数。
178从a7c9af8快进部署。先初始化dividend_research_runs。
四类worker与beat重建,新任务注册及只读接口通过。
部署脚本首次因容器进程继承标准输入,未继续到启动步骤。
立即发现后另行重建,四类worker与beat均恢复。
脚本已为容器exec补上标准输入隔离。
既有未提交删除文件和未跟踪文件均保留,没有stash或reset。
09:06首轮丽珠真实任务在16000输出token处截断,正文为空。
记录失败且不发布,也没有自动重试。
7504416将单次额度改为30720,总额61440,保留每日五次上限。
09:18第一份完整丽珠研究发布,引用校验拒绝多项模型改写。
它的结论为证据不足,不能作为持续分红已成立的依据。
24f8804补齐未校验草稿留档,批量下游摘要不输出草稿。
09:26海尔完成,真实草稿定位到表格JSON的二次转义。
另发现2027-2028年份区间被误识别为负2028。
aada969修复输入字段呈现与区间识别,并明确每项所需材料种类。
所有真实模型尝试都保留;旧版不会因修复被覆盖。
每次重建前均核对四类worker无active及reserved任务。
最后代码本地234项禁网用例通过,网络尝试为零。
模型素材仍有一季度指标、现金流、独立分红公告与冲突记录缺口。
引用规则未放宽,无法核验的句子继续降为未知。
模型技术完成不等于公司持续性结论成立。
178备份:~/akg_logs/dividend-deploy-20261022/。
包含源码、.env、配置哈希与服务状态;原配置哈希保持。
开发机证据:/private/tmp/dividend-deploy-20261022/,交付前复制到永久证据目录。
基座未在容器内运行旧副本单测。桥使用独立候选镜像禁网验证。
最终两家研究、幂等、月度开关和页面判收见后续追加节。
## 2026-10-22 10:00 最终部署判收
本节为本轮最终事实。此前未部署、未启用描述属于历史阶段。
用户授权本序列后续公司调用api.deepseek.com的现有模型。
已核实际brain路由为deepseek-v4-pro,未调用188本地模型。
基座功能提交ca69b4a,155桥最终功能7111bde。
两端源码已推送并拉取;文档同步提交另记,不代表再次改动功能。
基座最后一批修复识别同报告期现金流来源差异。
例如丽珠2025年重构CFO为619617715.25元,原始合并报表为3145038968.09元。
源口径差异的根因尚未查明,不能任选较有利金额支持分红支付能力。
丽珠15处、海尔18处报告期差异均留在固定材料中,支付能力标未知。
模型生成的未核验草稿与未通过原因保留,不作为已核实结论向下游输出。
全天本轮模型尝试五次,含首轮截断一次,没有截断自动重试。
四份完整模型结果均已留档,两份最新结果为固定材料无模型重校验。
六份版本的固定查询正文与存储相同,历史截止未读入未来版本。
旧版本原字节摘要保持,重复重校验没有新增版本。
09:42正常review队列再次处理两家公司,均返回unchanged。
模型尝试保持5;本轮不继续为测试消耗模型额度。
| 公司 | 最新固定引用 | 专项结论 |
| --- | --- | --- |
| 丽珠集团000513.SZ | 9e978e203b4f08e93de64a1ec983d1101880835ab4ba8d969af2670c849c3fd2 | 证据不足 |
| 海尔智家600690.SH | 5121d5019cca980f8af07fe3ce46db94fb9e35b1b8005f754afa8387e5d9b487 | 证据不足 |
09:43:21月度开关AKG_DIVIDEND_RESEARCH_MONTHLY_ENABLED置1。
四类worker与beat一起重建,均读回1,每日模型上限5。
除了该授权开关,.env其余有效内容相同;models.yaml哈希保持。
09:50实际月度任务经review队列运行,finished且results为空。
本月两家公司已检查,无到期对象,模型尝试5前后一致。
后台任务读取新环境;未重建的接口进程不用于证明后台开关。
20:35首次自然定时尚未发生,不能将空批次手工入队冒充自然触发。
基座最终238项本地禁网unittest通过,联网尝试为零。
日检最终19项绿、0警告、0错误、22提示,退出码0。
新表、手工入口、日检、任务注册、台账及本交接已覆盖五处登记。
没有在生产容器里运行旧测试副本。
155最终镜像sha256:2aa75150aaae580392d5b510f8ea5436bd18d138dcf224dda31f0c5e020a440c。
09:53:09生效,只精简研究卡片文案,完整来源和未知事项仍保留详情。
70项研究与计划联合回归及六组原脚本在候选镜像禁网通过。
开发机本轮全组尝试因无pandas未启动两模块,不能计为通过。
真实候选镜像验证替代该环境缺失,网络尝试为零。
浏览器两家公司卡片、搜索与状态筛选通过,错误日志为空。
主卡片不堆研究指纹或表名,展开仍可核对完整资料。
原145份计划文件哈希与传导排序、池深等参数保持。
137在空闲时短停,重建后恢复,09:55自然执行成功14秒。
XXL141已启用,平台09:16手工运行成功4秒,次日08:05自然触发待核。
研究、选股计划与交易仍分开,未部署或改动PMS和188。
开发机永久证据目录:
`/Users/baobao/.codex/visualizations/2026/10/14/01a1396c-4e8e-7a21-ac34-8b7f6150dfe3/dividend-deployment-20261022/`
包含测试、脱敏调度状态、研究及归档核验、部署日志、截图与SHA256SUMS。
178备份在~/akg_logs/dividend-deploy-20261022/。
155备份在~/akg_bridge_logs/dividend-deploy-20261022/。
环境文件只保留在原机受限目录,不进入Git或开发机证据包。
```bash
# 178基座机 · ~/project/astock-kg;只读,预期companies=2、versions=6
docker compose exec -T -e PYTHONPATH=/app backend python /app/scripts/dividend_research_run.py --health
```
```bash
# 178基座机 · ~/project/astock-kg;只读固定版本,预期conclusion为证据不足
docker compose exec -T -e PYTHONPATH=/app backend python /app/scripts/dividend_research_run.py --code 000513.SZ --read --ref 9e978e203b4f08e93de64a1ec983d1101880835ab4ba8d969af2670c849c3fd2
```
```bash
# 155桥机 · ~/project/akg-factor-bridge;只读,预期ok=true、数据日为上一交易日
docker exec akg_factor_bridge python dividend_watch.py health
```
数据变化后数量与最新引用可以变化,不能将本轮固定读数当永久门槛。
新增公司仍由明确手工入口投review队列,后续进入月度复查。
159家公司缺个股评析、最新半年报缺口及来源冲突未被本轮补齐。
当前工具完成技术上线,不宣称找到了已证明持续分红的公司。
撤销时先停XXL141,并把月度开关恢复0。
开关生效需四类worker与beat同步重建,保留研究表、版本和审计。
代码回退在开发机反向提交,再由服务器git pull,禁止stash或reset。
桥源码挂载,回退须同步源码与进程,不能只换镜像。
原回退镜像akg-factor-bridge:rollback-before-dividend-20261022保留。
原137、PMS及历史计划不作为研究功能回退对象。

File diff suppressed because it is too large Load Diff

View File

@ -0,0 +1,130 @@
# 高股息候选接入PMS交接
## 2026-10-22 10:40 开发阶段
用户要求补齐高股息研究至PMS的链路。
默认采用独立候选区,由用户发起建仓评估。
系统不会将高股息研究池并入原自主扫描。
既有授权包含155模拟部署与容器重建,188不动。
178研究数据产品已经部署,本轮无基座运行代码修改。
规格见《高股息候选接入PMS开发规格_2026-10-22.md》。
桥的新来源资格检查已实现,PMS后台准备与快速采纳已经接通。
新请求先准备、当日有效,准备完成后才开放确认。
提议、消费快照、动作账本和指令进度保留来源与固定引用。
界面沿用原卡片,研究原文与反方放在详情。
本地桥9项新增、PMS24项专项与全量48批禁网回归通过。
生产尚未部署。当前真实两家公司仍有证据缺口,预计可评估数为零。
不能制造合格研究、提议、采纳或交易补验收。
10:35只读基线:155实例表前缀为空,ws下发,全局full,OPEN propose_only。
版本核验True,上游排序False、质地排序True、档位强传导。
规模200万元、总仓上限0.7、单股上限0.08、最大40只、目标0.06保持。
QMT ONLINE,resync_flag=0,健康正常,对账diffs=[]、severity=OK。
562590与688825两处事实源覆盖差异继续单列,保留ws_first。
远端PMS有既存scripts/deploy.sh修改与若干排查脚本,不能清理。
本地PMS决定台账及量化平台讨论稿、探针不是本任务改动。
本地bionic的DS_Store和第三方指南也不纳入提交。
## 2026-10-22 11:00 完成部署与技术验收
用户已明确确认独立候选区,由本人手动发起建仓评估。
用户登录后,真实交易员页面已核验。当前可评估为零。
175条研究可展开查看。丽珠9.09%、海尔5.86%,均标证据不足。
默认显示三家,支持查看全部。卡片不显示技术版本或指纹。
展开先看论点、反方与阻塞原因,原始材料缺口另行折叠。
完整页面和详情截图已归档,控制台错误为零。
### 部署事实
- 桥功能提交e860d4b84c18fb6c57b27092b3c46c3414550711。
10:48:46重建生效,镜像sha256:114913548acce5485c9fbec15d5fb949c674bd658d1f37b935013f5c0652d5d3。
- PMS功能提交03e569e3c55c04991fe617b07d97b3c3534e2c9a。
10:51:01四服务统一重建,镜像sha256:0f298f6d5b997c603b7d57a50223267367e1f7b1112d630b8e6af187e7f711d2。
Python指纹83c49a380165,与禁网候选镜像一致。
- 页面提交ccf194b,挂载即生效,未再次重启。
HTML SHA256为6c966a6df3e55edd31311388847b83d91b155052ff1d288241d4cdef95fbf0b8。
镜像仍含前一次页面,重建须带当前源码;运行页面已核对宿主与容器哈希相同。
- 178本轮没有运行代码变化,仅同步文档。188未连接或修改。
137维护期间短暂停止,桥健康后恢复。
10:50正常执行成功15秒,之后继续五分钟检查。
141与基座20:35月度研究调度未调整。
### 运行判收
10:50:54写前读数与10:51:18写后读数比较:
19项参数完全相同,23条持仓和322条批次逐字段相同。
108条指令未增减,数量、状态与实际成交进度相同。
指令638、632、606只更新正常等待或拒绝的分钟时间。
原原因与已执行数量保持,不宣称盘中所有运行字段永久不变。
健康status=ok、db_ok=true、日历正常。
QMT ONLINE,last_seq=1350932,resync_flag=0,last_error为空。
对账只读apply_fix=False,diffs=[]、errors=[]、severity=OK、streak=0。
562590与688825原有事实源覆盖差异不在本轮修改,保留ws_first。
历史已暂停指令、真实成交和历史还原边界继续有效。
桥旧145份计划文件逐一哈希一致,排序及数量参数一致。
高股息来源数据日10-21,decision为:
`dividend_27f27e1c0d42c5f119f121e93b777a2d773c302e6d2f87394de24de2be7c93c0`。
研究快照f83b26c66d22b5f1b1a355111ecb04f7b7c99532be6cc712f5e2f78d0123aae8。
共有175条可查看记录,包含身份待明的隔离记录,均不自动取得准入资格。
当前可评估0条,两家优先研究仍证据不足,与验收预判一致。
PMS只读取该来源耗时0.433秒,前后消费记录数量相同。
未登录GET候选与POST空发起均返回401,未产生有效请求。
本地PMS48批通过,候选镜像48批同样通过。
新增24项覆盖准备、来源变化、重复请求、原数量流程及原子采纳。
桥候选镜像79项联合用例与六组既有脚本通过,联网尝试0。
最终三页面守卫通过,真实登录页面已判收展示与不可操作边界。
没有为验收调用模型、生成合格研究、采纳提议或制造交易。
没有真实合格公司,因此高股息自然准备、人工确认与成交仍未判收。
这不阻塞已验证功能上线,也不声称存在真实投资效果证据。
### 备份与回退
155桥备份位于`~/akg_bridge_logs/dividend-entry-20261022/`。
155PMS备份与镜像测试日志位于`~/pms_logs/dividend-entry-20261022/`。
写前源码归档、配置原件及SHA、容器信息、PMS完整账务读数均保存。
环境文件权限600,备份目录700,未下载或提交任何密钥。
既有远端scripts/deploy.sh保持原哈希,未用它执行部署。
桥回退标签为`akg-factor-bridge:rollback-before-pms-dividend-20261022`。
PMS回退标签为`pms:rollback-before-dividend-entry-20261022`。
回退必须开发机反向提交、远端git pull,再重建对应服务。
155挂载源码,不能只切镜像。保留研究、提议、消费与真实成交。
回退前暂停新的高股息发起,并核对已有提议引用。
本轮未触发回退。
本地证据目录:
`/Users/baobao/.codex/visualizations/2026/10/14/01a1396c-4e8e-7a21-ac34-8b7f6150dfe3/pms-dividend-entry-20261022/`。
SHA256.json登记证据哈希。核心为before/after读数、镜像测试日志、页面截图。
### 用户可运行的核验
```bash
# 155模拟机 · ~/project/tradingSystem
curl -fsS http://127.0.0.1:38100/health
docker compose --profile sched --profile ws ps
docker exec pms-web python /app/scripts/code_fingerprint.py
```
预期健康ok、db_ok为true,四服务running,指纹83c49a380165。
后续有新代码时以新的部署记录为准。
```bash
# 155模拟机 · ~/project/tradingSystem
docker run --rm --network none pms:dividend-03e569e python scripts/run_tests.py
```
这是固定候选镜像的隔离测试,不挂载生产.env,不连接数据库或模型。
预期48批通过,最后为ALL SUITES PASS。
页面核验:登录155交易员页面,展开右侧高股息研究。
现阶段应显示零家可评估、具体待查原因,不出现准备建仓按钮。
未来通过证据核验的公司才出现按钮。点击后先后台准备,完成后人工采纳。
此人工链路不会被原自动扫描替代。

View File

@ -0,0 +1,153 @@
# 高股息阶段检测交接
2026-10-21,北京时间。
本次接用户“每日查股息,其他资料按月或季度查”的确认。
完整规格见《高股息阶段检测开发规格_2026-10-21.md》。
## 已完成
桥已实现独立扫描、月度资料复用和新入池补查。
季度评析到期列入研究需求,日常接收已有的新评析。
先排除ST及退市名称,未知名称或上市状态隔离。
股息使用月表dv_ttm,dv_ratio不作为缺失值替代。
固定输入、内容指纹、单写入锁与原子入口均已实现。
来源失败保留上一份结果,日检明确本次检查失败。
支持原文副本、各视角评价、反方和材料期查看。
所有持续性结论仍待公告和支付能力专项核验。
独立XXL入口不占每日计划修订锁。
现有XXL默认链、计划、PMS与择时参数均未改。
不调用模型,不提交研究股票池,不生成交易动作。
不需要新常驻容器,先复用桥的独立子进程。
## 实测与保存位置
155容器只读试跑冻结时刻为16:00:40,行情日10-20。
5568行中,171只滚动股息不低于5%。
排除ST八菱1只,6只名称缺失,研究池164只。
2只质地好、3只中、4只差,155只缺评析。
9份当前报告原文已保存。旧报告均明确为当前读取副本。
财务3447行、现金流3444行、分红3876行通过公开日期过滤。
这些只是当前数据源记录,不证明公告与财务材料完整。
结果位于开发机目录:
`/Users/baobao/.codex/visualizations/2026/10/14/01a1396c-4e8e-7a21-ac34-8b7f6150dfe3/dividend-watch-20261021/`。
latest.json指向本轮最后结果。versions保留各次本地研发归档。
bundle.json含完整输入与结果,report.html是可读报告。
这些是研发试跑记录,不是已在生产调度发布的每日样本。
原211只Excel实验文件另保留,没有改写历史核查。
新增36项研究与调度测试通过。
合并现有版本和查询测试,共63项禁网回归通过。
原XXL入口13项测试通过。
初次扩展回归遇到本地Python3.9和不完整日历依赖。
已改用捆绑Python3.12与现有完整日历包,未调整业务代码迁就测试。
测试日志在开发机 `/private/tmp/dividend-20261021/`。
同月第二次真实只读检查耗时2.438秒。
164家财务资料摘要和9份报告副本均未改变,月内复用通过。
最终页面搜索丽珠集团仅显示该公司,状态筛选正确,浏览器错误为空。
## 部署状态
本轮只读核实155桥提交5586016。
容器运行镜像为sha256:55f57b42951d2dd8a6ff871b05cf62db6216fa965c4912fb0b365219db9551b9。
容器启动时刻为UTC 2026-10-21 02:13:24.98567122。
服务器已有.env备份及data未跟踪文件,没有清理。
本次未推送、未远端拉取、未重启容器。
独立任务入口尚未在运行中的API加载。
XXL日程尚未创建或启用,不能声称已经每日自动运行。
178和188没有部署操作,PMS没有代码或参数变更。
## 后续顺序
1. 先补资料和个股评析覆盖。优先核验2只已有好结论的公司。
明确普通分红、特别分红、半年报缺口及支付能力。
金融企业另核资本约束,不套工业企业现金流阈值。
2. 对155只未覆盖者分批研究,保存观点分歧与未知事项。
不将自动请求清单误报为已经完成的模型评析。
3. 部署前运行候选镜像禁网测试,保存现有计划归档和参数摘要。
核实桥运行中没有未完成修订,再使API加载新入口。
4. 使用既有XXL平台单建研究日检,交易日北京时间08:05。
先核平台调度守卫。不得用Codex心跳或宿主cron替代。
首次正常调度核对回调、日检、月度复用与原计划无变化。
停止时只停独立研究任务,保留研究归档。
桥有源码挂载,回退须同步源码与进程,不能只换镜像标签。
## 2026-10-21 基座专项研究接续
用户批准将专项研究作为基座可复用数据产物。
本地已新增存储、模型语义研究与只读接口,桥接收已有结果。
最新事实见《交接_分红持续性研究数据产品_2026-10-21.md》。
原阶段的164只覆盖、未部署和未自动研究边界仍有效。
## 2026-10-22 09:25 部署与日检
用户授权完成开发后部署,并授权本研究序列后续公司调用现有模型。
155桥从5586016快进到efbd52a,功能为238b5f7。
候选镜像sha256:9d53c9f2b750fe46f702a7d6695c67af73bc984ae2eab2cea51cbddf82e56b16。
本地与独立候选镜像70项联合回归、六组既有脚本通过,联网尝试为零。
远端源码、.env及原计划已备份。
部署前后145份计划文件哈希相同,旧传导排序及池深参数未变。
为重建短暂停止137,09:00执行已成功结案。恢复后09:15正常成功13秒。
计划修订继续使用原137,没有新建替代任务。
独立研究任务为XXL141“高股息每日研究检测”。
沿用既有HTTP GLUE、鉴权及业务回调。
交易日08:05,时间段08:05—08:06,间隔86400秒。
预览为10-23、10-26、10-27等交易日08:05。
09:16手工执行,平台回调成功4秒,日志101798。
随后启用,下次为10-23 08:05。正常次日定时尚未发生。
首扫描行情日为10-21,高股息176只。
排除1只风险名称,隔离6只名称未知,进入研究169只。
已有评析10只:好2、中4、差4;缺评析159只。
首次与平台再次执行复用同一归档344e5e44209bffb98343810cf4bd69be415b0d5a1f4dc5e007ac302e3267dfcc。
169家月度财务资料及10份报告副本复用,没有新增模型调用。
基座真实专项结论仍在验收,后续追加节覆盖当前暂不可用状态。
研究页:http://192.168.16.155:8300/research/dividend。
研究健康:http://192.168.16.155:8300/research/dividend/health。
搜索与状态筛选正常。PMS、188与交易规则没有操作。
155备份:~/akg_bridge_logs/dividend-deploy-20261022/。
包含源码、参数、plan-before.tgz及哈希。
回退镜像akg-factor-bridge:rollback-before-dividend-20261022。
回退需要同步源码与镜像,再重建,不能只换镜像。
新任务可单独停止,研究与原计划归档保留。
## 2026-10-22 10:00 最终研究页与归档判收
桥最终功能7111bde,09:53:09重建后生效。
镜像sha256:2aa75150aaae580392d5b510f8ea5436bd18d138dcf224dda31f0c5e020a440c。
完整研究与计划契约70项、六组既有脚本在候选镜像禁网通过。
本轮开发机全组因缺pandas失败两模块,仅候选镜像全组记为通过。
基座最终ca69b4a,238项本地禁网测试通过,日检无警告或错误。
当前研究归档f83b26c66d22b5f1b1a355111ecb04f7b7c99532be6cc712f5e2f78d0123aae8。
三份研究归档依次为初版、接入专项结果、展示精简版。
最初归档字节哈希保持,169家财务资料与10份原报告副本摘要相同。
展示版发布后重复扫描changed=false,无重复发布或模型调用。
行情日10-21,176只高股息,排除1只风险名称,6只身份未明隔离。
进入研究169只,好2、中4、差4,159只仍缺个股评析。
丽珠与海尔均已接入基座固定研究,结论为证据不足。
现金流两路来源分别存在15、18处报告期差异,海尔另有分红记录冲突。
主卡片将这些问题放在待查项,完整版本和来源默认折叠。
浏览器搜索、状态筛选、两卡片及零错误日志通过。
截图保存在永久证据目录的dividend-research-final.png。
部署前后145份旧计划文件哈希一致,参数与08:45有效版本保持。
137空闲时短停,09:53恢复,09:55自然执行成功14秒。
独立研究141继续启用;10-23 08:05自然调度尚未发生。
基座月度开关已打开,09:50正常队列空批次完成,模型尝试5前后一致。
20:35检查到期公司,不自动入列全研究池,不新增宿主cron或心跳。
用户授权后续本序列公司调用现有云端模型,不再逐家重复询问。
完整版本、固定查询、研究事实边界、复现命令与撤销方式见
《交接_分红持续性研究数据产品_2026-10-21.md》10-22最终节。
四份规格与交接逐字同步四仓,业务台账追加在桥081之后。
永久证据:
`/Users/baobao/.codex/visualizations/2026/10/14/01a1396c-4e8e-7a21-ac34-8b7f6150dfe3/dividend-deployment-20261022/`
缺失个股评析、财务材料与源冲突仍待研究,不称为已证明可持续买入。

View File

@ -0,0 +1,218 @@
# 分红持续性研究数据产品开发规格
2026-10-21,北京时间。用户批准专项研究,并要求沉淀为基座数据。
## 目标与职责
基座为任意指定公司产出可复用的分红持续性研究。
不以股息率、ST 或交易候选资格限制基座的研究范围。
高股息初筛仍由桥执行。研究结果不修改个股质地,不进入融合断言。
PMS 与其他流程经桥消费,当前批次不接交易。
## 数据契约
每份记录保留股票代码、契约版本、研究版本、固定引用、输入指纹。
保留研究截止时刻、底层材料期、公开日期、模型名、用量和核验结果。
输入包括五年财务指标、重构现金流、分红记录、已解析年报及分红公告。
已有多视角评析作为观点来源。它不能替代公告与财务事实。
公开日未知或晚于截止日的材料隔离。原料保留,不补造历史版本。
只有日级公开日期时,明确不能证明当日盘前可得。
六项研究问题分别回答普通与特别分红、盈利持续性、支付能力、
债务或资本约束、分红政策、压力情形。每项输出支持、压力或未知。
每条判断带证据引用与原文摘录。支持与反方并存,不按模型票数表决。
模型不能新增无来源金额、概率、股息预测或买卖建议。
未核验的数字、无效引用或缺失关键材料使结论退回证据不足。
金融企业必须讨论资本约束,不能直接用工业企业自由现金流判定。
研究结论仅有“有支持”“存在压力”“证据不足”,均不是投资批准。
## 执行方式
沿用现有 brain 路由,经配置取实际模型,不写死厂商名称。
确定性取材、模型语义研究、确定性检查与发布分开。
没有足够财务与公告材料时不调用模型,保存缺口。
输入、提示词、模型配置不变时复用研究,不重复付费。
专项咨询锁防止并发重复调用。失败记录独立保存,旧完整结果可查。
新增独立研究表保存冻结输入和结构化结果,仅核对时间可更新。
查询不调用模型、不建表、不重装配。固定引用与按截止时刻查询均支持。
首版提供指定公司手工入队与批次入口,显式使用 review 队列。
接口不降级为同步模型调用。批量上限和每日调用上限均受控。
月度复查仅覆盖已登记研究的公司。每天20:35检查是否到期,
只有跨月者读材料;错开06:10、07:10及21:30行业催化。
自动复查默认关闭,部署验收后再启用。重大事件可显式提前复核。
月度材料未变时不重做研究。桥每日只接收已发布结果。
## 首批验收预判
现有材料可能不足。不得为了产出肯定结论降低证据要求。
离线用例覆盖日期边界、累计流量、重复记录、缺公告、模型编造数字、
无效引用、金融企业、模型截断、空回答重试、幂等与并发互斥。
覆盖失败保留旧版、固定引用、查询零模型、月度复用与桥缺键兼容。
用本地冻结真实材料检查输入形状,不把合成模型结果当真实研究。
基座使用离线 unittest。按 akg-verify 核对契约与五处登记。
## 撤销与交付边界
关闭专项复查开关即可停止新调用。保留已发布结果及失败审计。
本轮先完成本地代码与离线验证。部署、实际模型调用和生产判收分开记录。
四仓同步规格与交接,决定台账记入桥。服务重建遵守既有授权边界。
## 开发者参考
新增 analysis/dividend_research 包与 dividend_research_store。
表定义同步 db/postgres/init.sql,显式 init 入口建表。
源读取使用基座既有代理连接,逐表查询,不在开发机连库。
解析只读缓存,不临时解析 PDF,不绕过模型端点池。
输出引用同时包含表名或文档身份、内容指纹与材料日期。
桥以可选接口消费研究,错误与缺失分开显示,不改变研究池准入。
## 第一版实现与运行入口
新表为 dividend_research_runs。完整原料与研究结果保存为 JSON。
job_runs 单列每次检查和模型尝试。只有 checked_at 允许原位更新。
财务输入选年度和最近两期;未送入模型的季度原料仍完整保留。
文档按分红与资本约束关键词取六处节选,每处保留原文偏移。
有遗漏的相关段落明确列缺口,不声称已经通读全文。
未来与日期不明原料只留审计,不进入模型上下文。
同一分红的预案与实施分开,同阶段同日期冲突继续列待核验。
公司类型取 gp_cashflow.comp_type,不让模型将金融企业改判为工业企业。
类型与现金流字段口径依据:[供应商现金流文档](https://tushare.pro/document/2?doc_id=44)。
模型使用现有 brain 升级路由,不新增模型档位。
单次最多30720输出token,空回答至多重试一次,总额61440。
截断不重试。模型名、非敏感配置及每次使用量落账。
每日最多五次单公司模型尝试,可通过环境变量明确调整。
专项全局咨询锁串行处理。单家公司任务遇忙按分钟重试,最多三十次。
首版仍需显式指定公司提交,不会自动为全研究池付费研究。
| 入口 | 行为 |
| --- | --- |
| GET /research/dividends?codes=代码列表 | 最多200家公司,只读摘要,支持带时区asof。 |
| GET /research/dividends/{ts_code} | 读最新研究,或用ref读取固定版本。 |
| GET /research/dividends/health | 只读存储、检查与模型尝试状态。 |
| POST /admin/dividend_research?ts_code=代码 | 显式投review队列,接口不跑模型。 |
| akg.dividend_research_batch | 20:35检查月度到期,默认关闭。 |
月度开关 AKG_DIVIDEND_RESEARCH_MONTHLY_ENABLED 默认0。
调用上限 AKG_DIVIDEND_RESEARCH_DAILY_MAX 默认5。
桥的dividend_research_feed只调用GET,不自动提交模型任务。
基座未部署或暂不可用时显示专项研究不可用,不改变高股息初筛。
已有研究到月度复核期时显示待复核,不伪装为刚更新。
材料恢复为历史输入时,允许复用该固定研究。
最新与历史查询按当时已完成的核对选择,不只按首次建档时间。
后来的复查时间不能倒灌旧截止时刻。
## 2026-10-22 部署前补查
批次有失败时必须向调度报告未完成,不能只在逐票记录写失败。
到期对象按最近尝试时间轮转,失败的旧对象不能每天占满五个位置。
其余公司仍继续检查,失败对象留待下一轮,不删除既有结果。
先以离线数据库查询与混合成功失败用例核验,再部署。
上线依次核对新表、只读接口、少量真实模型、重复提交和固定查询。
通过后启用月度复查与桥08:05交易日检查。
所有模型调用仍在既有云端brain路由内,保留每日五次上限。
```bash
# 开发机 · astock-kg;预期测试全部OK,不连接数据库或模型
PYTHONDONTWRITEBYTECODE=1 PYTHONPATH=backend python3 -m unittest discover -s backend/tests -t backend
```
```bash
# 开发机 · akg-factor-bridge;预期研究及接口用例全部OK
PYTHONDONTWRITEBYTECODE=1 python3 -m unittest test_dividend_watch test_dividend_jobs test_dividend_research_feed
```
```bash
# 178基座机 · ~/project/astock-kg;代码部署后初始化,随后仅读健康
docker compose exec -T -e PYTHONPATH=/app backend python /app/scripts/dividend_research_run.py --init
docker compose exec -T -e PYTHONPATH=/app backend python /app/scripts/dividend_research_run.py --health
```
```bash
# 178基座机 · ~/project/astock-kg;上线后显式提交研究,会使用模型并写研究结果
docker compose exec -T -e PYTHONPATH=/app backend python /app/scripts/dividend_research_run.py --code 000513.SZ --enqueue
```
只有第一家真实研究完成,才能判收模型语义、用量和生产落库。
本地合成模型与读取真实原料都不能替代这个判收。
## 2026-10-22 首轮模型额度修正
09:06真实任务在16000输出token处截断,正文为空。
推理占用输出额度,不能按报告字数估计预算。
系统记失败且不发布,不自动重试,原归档保持。
参照既有个股深度评议,将单次额度改为30720,总额61440。
提示词同时约束说明、引用和反方长度,版本升为2026.10-2。
截断不重试、非截断空答最多一次重试、每日五次尝试均保持。
修正后仍需真实模型、引用校验和幂等判收。
用户已授权后续进入本序列的公司使用现有云端模型。
该授权覆盖财报、公告节选和已有评析摘要的专项研究与月度复查。
## 2026-10-22 引用失败的审计补齐
首份完整返回的研究有多处引用不匹配,程序降为未知。
原实现未保留校验前回答,无法追查被拒绝的原句。
现将model_draft作为未校验草稿留在固定版本,批量摘要不输出。
只有校验后的六项判断、风险和未知清单进入下游。
提示词明确引用必须是连续子串,不改空白标点、不加省略号。
非金融企业不强套金融监管资本要求。引用标准没有放宽。
新增无效引用留档回归,基座232项禁网测试通过。
## 2026-10-22 真实引用格式判收修正
海尔模型草稿证明,表格JSON的转义符被再次带入引用。
财务证据改为逐字段文本,数值、负号、小数精度与单位不变。
原始字段类型与全量表行仍保存在冻结输入。
公司类型从已校验原始现金流记录确定,不解析展示文本。
模型须明确满足各项所需的材料种类,反方统一放在顶层。
年份区间2027-2028不再被当作负2028;财务负数仍保留符号。
引用必须连续匹配原文的规则保持,未对模型错误做宽松替换。
新增真实反例回归后,234项离线禁网用例通过。
提示版本为2026.10-4。旧版不会被覆盖,新增研究继续占每日额度。
## 2026-10-22 现金流来源冲突与无模型重校验
真实材料中,同年重构CFO与标准合并现金流报表的经营现金净额不一致。
两路都标同一报告期,不能由模型任选一路宣称支付能力得到支持。
按报告期核对两路记录,仅允许一分钱表示精度差;不修改任一路金额。
冲突列表与材料缺口一并冻结,支付能力强制标未知。
这不是投资阈值,也不改财务重构或质地算法。
新增固定研究的无模型重校验,复用原输入与完整模型草稿。
材料编号、正文或提示版本不同则拒绝,不拿新材料冒充模型已阅读。
新校验结果另存版本,保留父引用及原模型生成时刻,模型新增用量为零。
校验指纹纳入版本,随后同材料正常复查直接复用。
旧记录及原模型尝试不删改。不存在原稿的旧版不可还原。
回归覆盖冲突、精度、未来材料、旧版不变、幂等及禁止混入新证据。
```bash
# 178基座机 · ~/project/astock-kg;固定材料重新校验并追加版本,不调用模型
docker compose exec -T -e PYTHONPATH=/app backend python /app/scripts/dividend_research_run.py --code 000513.SZ --revalidate-ref <固定引用>
```
## 2026-10-22 部署后验收结论
用户授权本研究序列后续公司调用现有云端模型,不再逐家公司询问。
授权范围为财报、公告节选与已有评析摘要,目标为api.deepseek.com。
当前实际模型deepseek-v4-pro。若以后改变发送范围或目的地,另核授权。
授权不等于自动把169家全部入队。基座仍只复查已登记公司。
基座功能ca69b4a已部署,238项本地禁网回归通过,联网尝试为零。
六份真实研究版本与五次模型尝试均已留档。
其中一次截断失败不发布,四份为模型输出,两份为无模型重新校验。
固定查询、历史截止、旧版哈希、重复重校验与正常队列复用均通过。
引用能匹配原文,不代表结论已经由人工完成投资判断。
09:43月度开关设为1,四类worker与beat同步重建。
09:50经正常review队列运行空到期批次,返回finished,结果为空。
模型尝试数保持5,验证开关由实际工作进程加载。
20:35首次自然定时尚未发生;两家公司当月已查,到期前不重复调用。
日调用上限仍为5,模型路由配置文件哈希不变。
丽珠与海尔均为证据不足。两路现金流分别有15、18处报告期金额差异。
另有最新财务材料、完整公告节选和海尔分红记录冲突待核验。
没有修改源金额、重构算法、质地结论或交易规则。
季度完整复核仍以材料实际覆盖为准,不把到期请求称为已完成。
最终固定引用、可复现入口、证据位置及回退见同名交接最新节。

View File

@ -249,3 +249,42 @@
**上线。** 09-19 交付、我复审后 09-23 收盘后重启 PMS 进程(重建镜像加 force-recreate,经用户同意)。不与 09-21 选股系统拉代码同一天,避免两处同时变化说不清。 **上线。** 09-19 交付、我复审后 09-23 收盘后重启 PMS 进程(重建镜像加 force-recreate,经用户同意)。不与 09-21 选股系统拉代码同一天,避免两处同时变化说不清。
**复核日期。** 上线次日 09-24 核候选序等于上游名次序;四周(10-16 前后)随选股系统排序轴一起复核。 **复核日期。** 上线次日 09-24 核候选序等于上游名次序;四周(10-16 前后)随选股系统排序轴一起复核。
## 018 · 2026-10-15 · 每日计划消费留痕与提议采纳前核验
**日期。** 2026-10-15,北京时间;用户已批准三仓联动,本轮仅本地实现,未调整线上参数。
**改动。** 记录 received、consumed、rechecked,保留有效参数、顺序、过滤原因和版本指纹;自主扫描继承消费顺序,盘中信号优先留原因。采纳前仅名次变化保留提议,资格、风险或仓位依据变化重走现有判断与数量流程,人工基于更新内容重新确认;未知版本不生成新的自主买入指令。条件更新防并发重复采纳。命令仍优先并补来源到最终指令与账本。停止按行数清理快照,当前保留全部历史。
**依据。** 用户批准的《每日选股计划完善整体方案》;单名额优先级、排名变化、资格失效、数量缩减、旧确认、版本不可用及并发采纳已有离线回归。桥台账 064 记录上游发布约定。
**预期。** 候选到建仓次序可解释,历史消费不受今天参数影响。新发布控制 PMS_PLAN_VERSION_RECHECK 默认关闭,兼容读取和桥版本验收后才在模拟实例启用;不改变现有排序开关、档位和仓位阈值。既有指令及持仓沿原执行风控处理。
**复核日期。** 获准部署后连续五个交易日记录顺序、版本、传播时延、重核结果和重复指令;具体首日待部署确定。本地测试不能替代真机判收。
**部署补记(2026-10-15)。** 用户授权后 10:42 在 155 模拟仓部署 6a5ae12,42 批镜像断网回归通过;收到和消费记录分别落库,既有参数保持。新版本核验仍关闭,桥完整版本和五日观察待后续启用。188 未部署。
## 019 · 2026-10-15 · 成交回放按委托归属隔离双来源
**改动。** trading_order 回放前用本实例出口表的委托号或券商号核对归属。已归属 WebSocket 的汇总镜像只记跳过及 seen,逐笔迟到仍等待原通道;读源失败或身份冲突不猜作外部成交。外部人工成交保留原回放。
**依据。** 155 模拟仓三项差异由八个委托的两套来源重复入账产生,两个身份字段逐笔一致。002050 重复买 100,688100 重复净买 1000,002979 重复卖 2000 后数量下限截断成零。发生于本次计划功能部署之前。
**预期。** 新成交不再双记数量、成本与指令进度,不改变交易参数、候选及执行规则。历史成本和盈亏不由数量对账冒充修复;原始证据已保存在 155 宿主日志目录。
**复核日期。** 2026-10-15 部署后核验身份分类与自然回放;2026-10-16 晨版核验同步检查。12 个新增用例及全量 43 批离线回归通过;部署结果追加到 DEVLOG。
## 020 · 2026-10-15 · 三票历史逐笔账本恢复
**改动。** 用户明确批准先备份后修复 155 模拟仓的三项错账。新增只读备份、离线预演、事务写入、原值审计和条件回退入口。逐笔成交唯一对应原批次,重复汇总批次与 RECON 调整归零留痕;真实卖出按原核销规则重建盈亏。成本从金额计算,避免反乘舍入均价;父指令恢复真实进度,原误判完成的剩余执行暂停。活跃网格恢复实际剩余档位与成本。
**依据。** 完整留存 134 笔成交、61 个真实买入批次;33 个重复或 RECON 批次有明确来源。离线重建数量 700、1900、1400 与 QMT 相同。002979 的一条网格指令真实成交 2600、目标 1300,保留超额事实,不冒充重复删除。
**预期。** 数量、金额、批次盈亏和指令执行量可逐笔核验。任何漏笔、歧义、并发变化、中断不产生半套账;已有终态指令不因修账续单。手续费、历史峰值和原历史绩效不假装已还原。方案、排序、仓位及明日启用门槛不变。
**复核日期。** 2026-10-15 写回前后按备份核验;2026-10-16 晨版核验继续检查自然回放。21 个新回归和全部 44 批隔离离线测试通过。部署与生产判收另记 DEVLOG。
**台账 020 均价有效期补充(2026-10-15)。** 原 add_instruction_exec 只收到增量数量,不知道成交金额。历史修复填入的均价在未来新成交后会过期,故增量数量写入时一并将 exec_avg_price 置空。准确的修复时点金额继续保留在 progress.historical_repair 与行级审计;不把旧均价冒充新的全量成交均价。增加内存数据库行为测试,batch40 共 22 例,全量 44 批离线通过。

View File

@ -1,6 +1,6 @@
# PMS 开发接续与 Codex 迁移记录 # PMS 开发接续与 Codex 迁移记录
日期为 2026-10-12,北京时间。开发入口已迁到根目录 `AGENTS.md`。本次整理完成了仓库规则与工作上下文的接续,下文保留接手时快照,最新进展见第七节。 日期为 2026-10-12,北京时间。开发入口已迁到根目录 `AGENTS.md`。本次整理完成了仓库规则与工作上下文的接续,下文第一至六节保留接手时快照,修复整合见第七节,部署结果见第八节。2026-10-26 质地选股的最终切换与判收见第十节,账户资金修复部署见第十一节。
用户在本次会话确认两件事。第一,原定 10-09 的服务器只读核对与离线探针均未执行。第二,先以当前仓库为准,不另找旧 Claude 会话资料。 用户在本次会话确认两件事。第一,原定 10-09 的服务器只读核对与离线探针均未执行。第二,先以当前仓库为准,不另找旧 Claude 会话资料。
@ -120,4 +120,148 @@ git diff --check
155 已做主机与容器元数据只读核对。仓库在 `/home/factor/project/tradingSystem`,主分支仍为 `fbe0014`,四个 PMS 服务运行,网页健康检查通过。四个容器均有源码挂载,启动时间为 2026-09-18 11:51:59 北京时间,由 Docker 的 UTC 值换算。服务器有本地文件和 `scripts/deploy.sh` 的修改,部署时保留。188 未操作。 155 已做主机与容器元数据只读核对。仓库在 `/home/factor/project/tradingSystem`,主分支仍为 `fbe0014`,四个 PMS 服务运行,网页健康检查通过。四个容器均有源码挂载,启动时间为 2026-09-18 11:51:59 北京时间,由 Docker 的 UTC 值换算。服务器有本地文件和 `scripts/deploy.sh` 的修改,部署时保留。188 未操作。
部署候选不含原有台账、讨论稿及两个探针。上线前需确认实例的运行参数与在途队列,在 155 断网临时容器通过后再重建镜像、重建四个 PMS 容器。本次没有 DDL 和依赖变更,无需重新建表。部署和真实交易行为尚未判收。 部署候选不含原有台账、讨论稿及两个探针。上线前需确认实例的运行参数与在途队列,在 155 断网临时容器通过后再重建镜像、重建四个 PMS 容器。本次没有 DDL 和依赖变更,无需重新建表。部署结果见下一节。两项修复在真实行情中的触发行为仍未判收。
## 八、155 模拟仓已完成部署
2026-10-12 北京时间 12:16:07,155 的四个 PMS 服务完成重建。用户已明确批准 155 条件部署,并确认允许推送到当前 `origin`。主分支和整合分支均已推送修复提交 `55e2ed6aa32012d4c09649836120c0622c19624f`。原始 Claude 分支和工作树仍保留。部署后的本节与流水账作为另一次纯文档提交保存。
部署前先在服务器临时目录展开该提交,通过 `docker run --rm --network none` 运行完整测试,没有生产 `.env`。实际使用 Python 3.11.9,41 批、983 例通过。随后在正式项目目录快进代码,执行 `make build` 和 `make up`。没有执行建表,没有修改运行参数,没有操作 188。155 的 `scripts/deploy.sh` 只有服务器本地可执行位修改,已原样保留。服务器原有未跟踪文件也保留。
运行态判收为真机见过。四个容器均为运行状态,重启计数为零,启动时间均为上述北京时间。四者镜像相同,为 `sha256:63e786de910adc5dd5ded41368922114cc40dc759dc6b472a5fcda60b032ee45`。另外用无挂载临时容器读取镜像内代码指纹,结果为 `18d7286b926a`,与提交快照、服务器工作树一致,因此没有仅凭源码挂载后的指纹一致判断上线成功。
12:16 至 12:18 的检查见网页健康状态为 `ok`,数据库连通,交易日历正常。QMT 通道为 `ONLINE`,回报水位继续推进,无重同步标记,无在途子委托,无待入账回报。四服务启动后日志没有 ERROR、CRITICAL 或 Traceback。调度正常完成任务,午休交易任务按 `not_in_session` 跳过。部署后的 `make test` 再次输出 `ALL SUITES PASS`,41 批、983 例通过。
本次只读确认的运行参数如下。这是 2026-10-12 午休的快照,后续仍以页面和参数表为准。
| 参数 | 读数 |
|---|---|
| `PMS_TABLE_PREFIX` | 空,模拟仓自有表 |
| `PMS_DISPATCH_MODE` | `ws` |
| `PMS_QMT_WS_ENABLED` | `True` |
| `PMS_AUTONOMY` | `full` |
| `PMS_SELF_DECIDE` | `full` |
| `PMS_GLOBAL_BUY_HALT` / `PMS_GLOBAL_EXEC_HALT` | 均为 `False` |
| `PMS_PLAN_RANK_BY_UPSTREAM` | `False` |
| `PMS_PLAN_TIERS` | `强传导` |
部署时没有 GATED 方案。尚未终态的两条父指令中,一条没有下发子委托,另一条已有子委托为 FILLED。它们没有被部署脚本撤销或改写。新结算与一字板修复在真实行情中的触发效果仍未判收,不能用测试通过代替实盘事件判收。
155 的回退引用为 `codex/predeploy-20261012`,指向 `fbe0014`。旧镜像保留为 `pms:rollback-20261012-fbe0014`。若需要回退,要同时切回该源码和旧镜像,再重建四服务;155 挂载源码,只换镜像不能回退。回退不是本次已执行的动作,不对账本做逆向写入。
开发机证据日志为 `/tmp/pms-integrated-fifth.log`、`/tmp/pms-deploy-55e2ed6.log`、`/tmp/pms-postdeploy-tests.log`。服务器部署前断网回归日志为 `/tmp/pms-codex-55e2ed6.wfe1Da/test.log`。这些临时日志不是长期归档,关键结果已记录在本文和 `DEVLOG.md`。
另核实宿主机系统时间为 UTC,容器时间为北京时间。部署脚本的窗口判断已显式用北京时间。PMS 通道心跳的 DATETIME 原值与容器北京时间同步,不能再给该字段一律加八小时;其他数据库时间列仍需按各自写入路径校准。
剩余事项不变:四行历史假读数未清理,两项探针未执行,盘中才封板与因子库前复权基准仍未补充验证,188 真实仓继续等待原准备条件。
## 九、2026-10-26 选股排序与强传导限制的接续核查
本节只更新选股排序事项。用户指出已经决定取消必须强传导、改按综合评价选股。14:15 至 14:18 北京时间,在 155 对 PMS、桥的有效配置、已发布计划和真实消费记录进行只读核对。代码没有在迁移中丢失;9 月的新排序未完成上线切换,后续部署继续保留了旧策略配置。
### 已定方案与实际运行的差别
9 月 17 日《选股计划调整方案》明确以公司质地为主轴,同档内再看是否被产业链指向、组内分等因素。它使用逐层排序,没有新增加权综合分。原始 score 保留“200 加传导档位乘 20 加组内分”的编码,因此直接按 score 排仍会偏向传导档位。方案仍保留候选卡的被指向门槛等条件,不能解释为所有研究与风险条件一并取消。
PMS 对接代码在提交 f5cc1b8 中已实现,目前仍在 app/services/plan_feed.py。它只有在 PMS_PLAN_RANK_BY_UPSTREAM 为 True,且上游计划顶层 rank_axis 为 quality 时,才沿用上游研究名次。PMS_PLAN_TIERS 是独立的资格筛选,打开排序开关不会自动取消它。
| 层次 | 155 实际值 | 实际影响 |
| --- | --- | --- |
| 桥排序主轴 | PLAN_RANK_AXIS=transmission | 继续旧传导轴,质地调整分参与旧排序 |
| 桥候选卡排序 | CARD_SORT_BY_QUALITY=False | 没启用候选卡的质地优先次序 |
| PMS 接受上游次序 | PMS_PLAN_RANK_BY_UPSTREAM=False | 不采用新上游排序 |
| PMS 本地排序 | PMS_PLAN_RANK_BY_QUALITY=True | 基本面看多优先分组,组内仍按原始分 |
| PMS 档位筛选 | PMS_PLAN_TIERS=强传导 | 弱传导及无传导仍可能被直接剔除 |
参数表只存在上述上游排序开关的覆盖记录,值为 False,updated_by 为 plan-rollback-choiceB-0922,updated_at 数据库原值为 2026-09-22 10:10:06。该列写入路径是容器 datetime.now(),按北京时间解读,不再加八小时。强传导限制没有数据库覆盖,也没有同名环境变量,实际来自 settings.py 的旧默认值;本地质地分组开关来自 ParamStore 默认值。
桥的 POOL_SOURCE=rank、REVIEW_TARGETS_AXIS=both 已启用,但当前输入榜仍是传导序。这说明新规则是部分接入状态,不能把开关名字中的 rank 当作已经完成质地切轴。
### 衔接中断的位置
1. 台账 017 记载 9 月 22 日临时关闭 PMS 上游排序,计划待上游切轴后重开,并把白名单改成“强传导,弱传导”。今天参数覆盖记录仍停在那次关闭,没有完成该后续步骤的证据。
2. 10 月 12 日迁移已经发现这一待办,但当次实际执行的是测试隔离与两个修复整合,没有把排序上线验收完成。
3. 10 月 15 日部署前,桥服务器仍在 3d3f317,未包含新排序。该次用户确认“补齐旧排序配置,保持当前行为”后,部署显式设置 transmission 与 CARD_SORT_BY_QUALITY=0,以避免代码默认值改变当时交易行为。该次授权及执行事实见 docs/交接_每日选股计划完善_2026-10-15.md,不能改写成已经批准取消 9 月方向。
4. 后续计划版本、提议核验及本次钧达修复部署继续保持运行参数。缺少的是跨系统策略切换的落实和最终验收,重新部署同一份代码不会消除这些旧配置。
### 今天确实影响了哪些候选
只读获取的计划数据日为 2026-10-23,决策版本为 2026-10-23_fda53be0e01b7c624756dd94e1fcd7d8e6f4c773eb1c26a99527c68b3aed4c95。计划顶层没有 quality 标志,返回的 300 条主榜行全部带 rank_axis=transmission。档位为强传导 29 条、弱传导 31 条、无传导 240 条。
PMS 真实消费记录 148,fetched_at 数据库原值为 2026-10-26 10:06:01,保存了 quality_bucket 排序、强传导白名单、四只持仓和空黑名单。实际留下 13 只,过滤已持仓 3 只、仅展示 267 只、档位不符 17 只。14:17 用相同计划及持仓上下文调用纯 select_candidates,结果与该消费记录的完整顺序一致。
| 仅在内存试算的条件 | 留下数量 | 说明 |
| --- | --- | --- |
| 当前参数 | 13 | 与真实消费记录一致 |
| 只打开 PMS 上游排序 | 13 | 上游不是 quality,排序与名单均不变 |
| 白名单改为强传导和弱传导 | 28 | 多出 15 只,其他筛选保持 |
| 不按传导档位过滤 | 30 | 多出 17 只,其他筛选保持 |
其中坤恒顺维、四方股份的上游质地带均为 3,判决均为候选,仍被 PMS 因弱传导剔除。这是旧限制实际生效的例子,不是买入建议。上述数量只说明对当前旧轴计划取消筛选的影响,不代表完整切换新排序后的名单,更不等于最终可下单数量。
### 修正边界与验收要求
后续应把桥的质地排序、候选卡排序、夜间分析池和 PMS 的档位与次序一起核对。先明确是执行台账 017 的两档白名单,还是完全取消档位筛选;两者在今天的计划里相差两只。不能以“把原始分倒序”代替已定的质地优先规则,也不能仅打开 PMS 单个开关就宣称完成。
还需检查命令驱动的升仓分配:app/core/planner.py 当前仍把候选按原始 score 重排,10 月 15 日规格明确保留该行为。自主提议已经继承 selection_rank,但命令链路不能据此认定也同序。正式切换前应在固定输入上比较完整名单与顺序,确认研究覆盖,并用真实消费记录验证效果。
本轮判收:现状与过滤影响为真机见过;新策略切换为未判收。本轮没有改交易代码、运行参数、计划版本或账本,没有重建容器、调用扫描写入口、采纳提议或下单。开发机仅补接续与开发记录,差异格式检查通过,未以只读试算冒充业务回归或策略上线。
## 十、2026-10-26 质地选股已完成联合切换
用户在第九节核查后授权全权完成切换。本节是最新状态,取代第九节“新策略未判收”的待办结论。旧日期记录继续保留,不能当作现行配置。
### 已生效的规则
公司质地优先,同档再看被产业链指向、组内分、原始分和股票代码。沿用 9 月已经确定的逐层排序,没有另造加权综合分。PMS 不再按强传导、弱传导、无传导决定准入,而是继承上游研究次序,再执行原有资格、风险和组合约束。候选卡的被指向门槛、仅展示排除、研判及择时继续有效,不能把取消传导档位筛选解释为取消全部门槛。
| 环节 | 现在的有效值或行为 |
| --- | --- |
| 桥排序轴 | PLAN_RANK_AXIS=quality |
| 桥候选卡排序 | CARD_SORT_BY_QUALITY=True |
| PMS 档位白名单 | PMS_PLAN_TIERS="",数据库显式保存,不按传导档位过滤 |
| PMS 上游排序 | PMS_PLAN_RANK_BY_UPSTREAM=True |
| PMS 本地质地开关 | PMS_PLAN_RANK_BY_QUALITY=True,仅作为旧来源的回退 |
| 命令升仓 | 保留候选 selection_rank,用户点名优先,缺名次的旧来源按原分数回退 |
| 研究池 | 从已发布计划按 rank 取被指向的前 50 只,保留持仓,总上限 100 |
研究池 POOL_TIERS 仍保留历史配置,但 POOL_SOURCE=rank 不读取它做过滤。其日志会打印该历史配置,不代表仍要求强传导。现已用实际池成员证明弱传导、无传导候选均获覆盖。
### 发布、部署及实际消费
PMS 代码提交 e7242f6,桥提交 dabb96b。两仓均已推送到既有代码服务器的 main。服务器只部署 155;未操作 188。候选镜像基于原镜像重建并覆盖提交归档,依赖未变。PMS 四服务使用 pms:quality-e7242f6 对应镜像,桥使用 akg-factor-bridge:quality-dabb96b 对应镜像。
14:54:08 北京时间,确认在途委托和未入账回报均为零、账本与 QMT 持仓一致,随后停页面及 worker、beat;通道最后重建。桥于 14:55:31,PMS 四服务于 14:57:10 force-recreate。没有运行建表,没有更改交易档位、规模、仓位上限、宏观闸或真实仓参数。
新计划数据日仍为 2026-10-23,对应周一决策使用的最新数据;不是把发布时间伪装成数据日。追加的决策版本为 2026-10-23_872ff104ce6ec025de1f4c3304c307ca56dd41791fdb08a6595c5a247d0c51e2,父版为 fda53be0e01b7c624756dd94e1fcd7d8e6f4c773eb1c26a99527c68b3aed4c95。冻结输入哈希仍为 5102f257551829ffef66f7b52e13a4c9b6a65db6ff7cb16c2dfc1d044142bd38。重放断言确认股票集合、原始分、判决、风险与研究内容均未改变,只改排序参数和次序。
PMS 自然调度在 14:57:22 保存接收记录 152 和消费记录 153。时间列按容器 datetime.now() 写入路径解读为北京时间。真实消费为 upstream、tiers=[],16 只候选,研究名次依次为 2、3、4、30、34、35、37、39、40、41、48、49、50、52、54、113。强传导 7 只、弱传导 5 只、无传导 4 只。档位过滤为零,已持仓排除 3 只,仅展示排除 281 只。坤恒顺维、四方股份已分别以研究名次 3、4 进入候选;这是实际调度记录,不是人为运行写入的验收样本,也不等于已经买入。
接口范围仍为 top=300、obs_top=100。PMS_PLAN_THEME_CAP=0 会省略请求参数,实际由桥 API 默认 theme_cap=5 处理;本次未改这个既有范围。预演和最终比较都按真实接口取数,不能用完整榜直接截前 300 代替接口结果。上午旧消费 13 只,此后钧达退出持仓,切换前最近旧消费为 14 只;不能把两个不同持仓时点的数量变化都归因于排序。
研究池实际补入 12 只,按原规则回收 1 只并在池满时移出 11 只。全部 3 只持仓与 16 只 PMS 候选均在池内。候选的 strategy_context 决策版本及研究名次与 PMS 一致。增量研究补扫已受理,任务为 5ce6930c-dd01-45ef-a68b-f830419d4858;受理不等于所有新增研究已完成。未为验证制造建仓或成交。
### 验证、备份与后续边界
开发机隔离入口全量 50 批、1165 例通过。155 候选镜像断网容器重复 PMS 全量通过;桥 54 组契约及 test_pool_logic.py、test_build_readiness.py、test_xxl_trigger.py 通过。PMS 镜像与服务器已跟踪 Python 代码指纹同为 51941a03fd92。服务器存在用户原有未跟踪脚本,不能把它们计入发布归档比较。
真机见过:四服务使用新镜像且无重启计数;页面及数据库健康;QMT 在线、水位一致、无在途、无待入账、账实无差异;76 份旧不可变版本及晨版指针哈希不变;15:00 定时修订检查无错误、无待修订股票,仍使用 quality。14:57:19 高股息独立读取曾超时一次,15:01:39 同一路径已成功复查,交易 worker、beat、ws 无错误记录。
下列只读命令在 155 运行,预期分别返回健康、健康且计划状态正常、四个服务 running。不能在开发机执行它们后声称真机验收。
```bash
curl -fsS http://127.0.0.1:38100/health
curl -fsS http://127.0.0.1:8300/health
docker inspect pms-web pms-worker pms-beat pms-ws --format '{{.Name}} {{.State.Status}} {{.Image}} {{.RestartCount}}'
```
私有备份目录为 /home/factor/pms_logs/quality-switch-20261026,包含切换前环境文件、完整计划目录、研究池原文档、归档哈希、镜像记录、发布与实际消费验收。目录权限 700,配置及取数文件 600,不提交 Git。旧镜像保留为 pms:rollback-before-quality-20261026、akg-factor-bridge:rollback-before-quality-20261026;两仓保留 codex/pre-quality-20261026 分支。回退排序必须重新追加 transmission 修订并同步参数,不可拿备份覆盖已经产生的新计划历史;研究池亦须重新考虑当时持仓,不能盲目恢复旧成员。
本次切换判收为真机见过。后续自然建仓、平仓和策略收益没有在本次验收中人为触发,不将其写作已验证。原有白名单优先、黑名单排除、命令限制、执行与风险控制继续生效。
## 十一、2026-10-26 账户资金口径修复完成
用户截图中的可用资金超过总资产,根因是 PMS 将 QMT 已含卖出回笼的 available_cash 又加了一次 sell_return_today。另有账户市值与 PMS 行情估值混用。修复 f90d5e7 已推送并于北京时间 16:44:06 在 155 模拟仓重建四个服务,断网镜像回归完整 51 批、1174 例通过。
运行态判收为真机见过。新总览可用资金 1,806,071.62 元,账户市值 130,190 元,总资产 1,936,261.62 元,冻结为零。策略估值 124,916 元、策略仓位 6.25% 保持。232 项有效参数以及持仓、批次、成交核对摘要不变;网页健康,QMT 在线,无在途、无待入账,未操作 188。取数时间、原始证据、镜像指纹、恢复引用及验证命令见 [账户资金口径核查](账户资金口径核查_2026-10-26.md)。QMT 与行情价格不同的上游原因尚未核实,不能将账户估值标为最新收盘行情。

View File

@ -0,0 +1,88 @@
# 买卖方向冲突修复开发规格
2026-10-19,北京时间。用户已授权修复并检查其他流程。
## 目标与已核实反例
科士达旧建仓目标600股,累计买入400股。今天09:51风控清仓400股,卖出200股。
旧建仓仍活跃,剩余200股可能隔日再买。实际子委托均已成交,页面却写已挂单。
原始卖出理由在audit_reason及component_scores.reason,PMS解析遗漏。
证据保存在155 ~/pms_logs/kstar-conflict-20261019-1402.json及kstar-signal-20261019.json。
## 实现与边界
1. 停止依据追加到动作账本,不依赖可被并发覆盖的进度JSON。下发回写不得复活终态指令。
全部完整清仓指令在执行前统一停买入侧。复用既有策略、提议、指令撤销路径。
覆盖信号自动清仓、命令清仓、人工采纳、技术面离场及跟踪止盈。
每跳重试未完成收尾,也覆盖上线前遗留的清仓指令。不修改已成交数量、成本或盈亏。
2. 同票有活跃EXIT或TRIM时,买入发出前再检查。查询失败停止买入。
普通减仓只暂缓买入,不永久撤销建仓或策略。做T自身T0_ROUND不当清仓。
完整清仓期间,做T买回也不能抵消清仓;没有清仓时原有配对流程不变。
3. 待确认卖出仅阻止新的自主增持提议,不自动撤销已有买单。
用户采纳买入前核对已生效的卖出指令,冲突时保留提议和说明,不写已采纳。
4. 出口队列先处理撤单,认领时排除待撤单。发送前重查买入冲突及父指令状态。
尚未发出且已失效的买单本地作废,已经发出的买单走撤单回执。
撤单受理不冒充成交撤回,迟到成交继续按已有逐笔路径记账。
5. 页面读取实际子委托状态。没有活跃子单时显示等待下一批、等待可卖或执行等待。
技术单号只在详情出现。卖出理由采用原文,不新调用模型。
## 预判与验证
先建立科士达跨日反例,再验证各入口共用的执行终检。
覆盖部分成交、T+1、普通减仓、T0配对、撤单失败重试、排队后清仓、查询失败、重复执行。
页面验证已发出且终态的子单不能显示为挂单,取数失败明确为状态待核实。
全部测试使用配置隔离与禁网入口。运行三页面守卫。
155部署前保存参数、账务、指令与镜像证据。只修模拟实例,188不动。
上线后先查自然调度清理旧建仓,保留真实400股买入与200股卖出。
不采纳提议、不制造成交,不改交易时段或业务阈值。
## 回退
保留成交与撤销审计。155挂载/app,须反向提交、git pull后重建四容器。
回退不恢复已经撤销的买入指令。撤销前保存旧镜像与证据。
## 本地验证记录
22项专项回归通过,覆盖五类清仓入口共用执行器、撤单失败与旧进度覆盖、T0不误挡、人工确认被拦时保持待确认。
45批配置隔离、禁止联网的回归通过,包含三页面守卫。生产状态另记部署判收。
原临时虚拟环境被系统清理,本轮另建 /private/tmp/pms-conflict-20261019-venv。
## 人工清仓补查
人工采纳EXIT原来按当日可卖量裁剪,T+1可卖量为零时会返回已采纳却不留清仓指令。
改为按已确认数量与当前总持仓取较小值,执行器继续按当日可卖量分批,不扩大用户授权数量。
持仓已经归零时不再生成卖单,但仍停止未完成的旧买入。普通减仓保持按可卖量处理。
增加两项回归,专项共24例。此项为代码发现的边界,尚无自然人工确认事件判收。
## 最终交付与验证入口
功能28053f3已于2026-10-19 14:27:22在155四容器生效。
镜像06493afa19ec4cd61d07b7834472a11c550d0ec0a341e251dcdb64626a4139c0。
本地和候选镜像45批全部通过,专项24例。
科士达旧建仓已终止,真实600/400及清仓400/200保留。
参数与全部持仓、批次账一致,零新增委托,对账正常。
两条system审计6912、6913未重复。完整证据见同仓每日计划交接14:30节。
```bash
# 开发机 · tradingSystem 仓库根目录
/private/tmp/pms-conflict-20261019-venv/bin/python scripts/unit_test_guard.py scripts/test_batch41_units.py
/private/tmp/pms-conflict-20261019-venv/bin/python scripts/run_tests.py
```
预期24项专项OK,完整入口ALL SUITES PASS。测试中故意注入失败的日志属于回归场景。
```bash
# 155模拟机 · ~/project/tradingSystem,只读
cd ~/project/tradingSystem
docker compose exec -T -e PYTHONPATH=/app pms-web python - <<'CHECK'
from app.repo import pms_repo
from app.services.execution_conflicts import instruction_progress
for r in instruction_progress(pms_repo.list_instructions(ts_code='002518.SZ', limit=10)):
print(r['instruction_id'], r['status'], r['qty'], r['exec_qty'], r.get('execution_label'))
CHECK
```
14:28判收时旧建仓CANCELLED、600/400、已撤销;清仓DISPATCHED、400/200、等待可卖。
后续真实成交会推进清仓进度,不能恢复判收时点的历史数量。
人工T+1与故障竞态尚无本轮自然生产事件,禁止为验收造单。
本地Chrome替身渲染和生产接口读数已核验;未直接操作用户登录的生产浏览器。

View File

@ -0,0 +1,93 @@
# 提议先准备后采纳开发规格
2026-10-20,北京时间。用户已批准本方案及155模拟仓部署,188不操作。
## 目标与问题
待确认提议必须已经完成研究、数量、规则和消费记录。采纳请求只做快速检查,不调用模型。
今天600183的提议在10:19被请求内重评,10:20又因统一技术错误提示被拦,第三次才成功。
原实现将研究变化、组合变化、记录失败混在一起。后台只跳过待确认项,不主动维护它们。
## 处理边界
复用已有交易时段的自主扫描,不新增任务,不改交易时段和策略阈值。
新建仓提议增加准备状态,仍保存在原JSON。旧提议由后台准备后才开放采纳。
数量、研判与必要留痕准备好后进入可确认状态,当日失效时刻沿用现有计算。
读取页面不运行研判。准备中的条目单列简短状态,不给采纳按钮,不堆技术字段。
研究变化由后台重跑原合议、研判、数量与规则闸。明确资格失效或研判否决撤下。
组合或参数变化重算数量与规则,复用相同研究依据的已有研判,不无故重问模型。
资金不足或来源暂不可用保留为准备中,后台恢复后重试;失败原因分开记录。
排序或无关计划更新不改变确认内容。可见数量、依据或风险变化才更换确认标识。
后台更新先使旧内容不可确认,再计算并用原状态与原JSON条件更新,防止并发覆盖。
采纳时检查确认内容、当日有效期、当前研究是否仍适用,以及资金、仓位、暂停与买卖冲突。
最新计划只读取完整发布结果,不新装配,不新增消费快照。必要交易动作审计仍必须落账。
生成时的计划与消费编号成对保留。最新核验的计划另记入检查记录,不拼接成虚假消费。
依据发生变化时快速返回等待后台更新,不在HTTP请求里重评,也不暗中改数量。
已准备的数量仍在当前额度内时,不因其他持仓或资金读数变化强制重新确认。
正常下发继续执行既有择时及交易前终检。
## 预判与测试
新增离线反例:新提议直接确认零模型调用;纯资金变化复用研判;研究变化后台更新;
旧确认标识拒绝;准备中没有采纳按钮;明确失效撤下;消费记录失败不发布可确认提议;
后台预算耗尽不调用模型;并发确认只生成一次;当前计划取数失败不下单;
正常到期及卖出、策略确认保持。必须运行完整隔离禁网回归与三页面守卫。
浏览器使用替身核验交互,再只读核对生产页面或接口;不得代用户采纳或制造交易。
## 部署与回退
部署前备份155参数、持仓、批次、提议、指令和出口委托,记录旧提交与镜像。
候选镜像断网测试通过后统一重建四容器,避开盘前维护窗口。
部署后核对正常调度、准备状态、模型调用边界、参数与账务。自然事件不足明确未判收。
回退须反向提交并拉取后重建,保留准备记录、真实成交与审计,不恢复已撤销指令。
同步四仓规格与交接,桥决定台账登记本轮选择。
## 本轮验收结果
功能1df17e6包含0acf7b8,2026-10-20北京时间11:35:28在155四服务生效。
54项专项与46批本地、候选镜像禁网回归通过,三页面守卫通过。
浏览器替身验证准备状态、确认提交和弹窗层级,错误零。
生产登录页面只读验证右侧提议与候选显示,错误零。
11:35:55对比备份,15项参数、21条持仓账务和283条批次账相同。
94条指令进度相同。QMT ONLINE,对账diffs=[]、severity=OK。
11:36、11:37按午休跳过盘中扫描。
当前无WAIT_USER提议,自然用户采纳和后台变化后再次确认仍未判收。
不触发交易补验收,不增加额外观察期。
完整镜像、备份、回退及命令见本轮交接11:40节。
## 2026-10-21 整条采纳路径补充规格
盛弘股份09:45采纳失败的堆栈指向整份计划读取超时。3秒上限低于实测5.481秒。
计划响应3093481字节,读取8.7MB发布文件本身0.427秒。昨天只验证了无模型调用,漏掉重请求。
新增逐票只读检查接口,只读取已发布完整计划。回传该票原始行、版本和修订状态。
不查数据库、不调用模型、不重新装配、不按展示名次截断资格。最新文件和健康状态发生切换时重读。
常规计划接口在工作线程序列化,避免大响应编码占用接口事件循环。
采纳与后台检查改用逐票接口。取数超时仅拒绝本次动作,保留已准备内容,返回可重试原因。
已知研究修订、资格失效及真实规则变化继续阻断。后台恢复只核验原数量可执行,不因连接恢复重算。
普通建仓采纳的状态、审计和指令在同一事务保存。任意一步失败全部回滚,重复请求返回原指令。
不将重复请求当第二次采纳,不改变股数、择时或下发流程。旧数据无指令时明确报不完整,不补造交易。
预判:使用真实响应形状覆盖请求超时、空候选、同票移出展示范围、修订中、来源变形、旧确认、
后台恢复、失败回滚、并发双击和响应丢失重试。检查API入口到实际SQL,不只替换内部核验函数。
部署前备份并核对155身份与参数。先桥后PMS,候选镜像禁网测试通过再重建。
部署后逐票与全量同版比较,读取真实提议做无写入预检,并浏览器核验。不代替用户确认。
回退保留审计与成交,反向提交、拉取和重建。实际用户采纳仍依自然事件判收。
## 2026-10-21 采纳链路补充及部署判收
普通建仓采纳改读完整发布计划的逐票接口,避免3MB整榜超出3秒限制。
短暂来源失败拒绝当次动作但保留准备内容,恢复不重扫。固定数量仍可执行时,不因组合现金漂移重写确认内容。
已知研究修订、资格失效、风险与参数变化继续由原规则阻断或重新准备。
采纳状态、动作审计和建仓指令同事务保存。失败回滚,重复请求返回原指令。
该补充优先于旧版“来源失败一律转准备中”及“组合变化一律重算”的实现描述。
桥2192a2c于10:13:24生效,PMS888a208于10:17:23四服务统一生效。
45组桥契约、47批PMS禁网回归及三页面守卫通过,候选镜像同样通过。
逐票0.208—0.326秒,真实建议只读预检1.085—1.227秒,未代用户采纳。
正常自然网格成交改变组合后,盛弘股份500股原确认标识保持,当前闸门通过。
页面按钮和确认框已登录核验,浏览器无错误。备份、前后账务及回退见交接10:25节。

View File

@ -0,0 +1,65 @@
# 提议采纳失败排查与修复
记录时间:2026-10-16 14:05,北京时间。仅操作155模拟仓,188未操作。
## 事实与原因
科士达13:27因依据变化完成重新评估。用户13:39:02再次确认时依据相同,version_check=passed,生成唯一指令 INS_20261016_002518SZ_OPEN_001,600股。操作日志276和动作账本6796对应成功。13:59仍PROPOSED、执行0股。本次自然操作补齐“依据未变直接通过”的验收,未由开发助手采纳。
瑞芯微13:40:00被重新研判拒绝。共享研判审计的created_at原值为05:40:00 UTC,与PMS北京时间响应吻合。结论PMS_REJECT;只读缓存确认把握度72。原理由为“实时主力净占比-4.04%且历史多次净流出,250日高位赔率-0.40,5日看空,开新仓证据反对。”这是当时研判系统的判断,不是本次开发重新作出的投资建议。
旧代码在重核拒绝时只返回“新版重新评估未通过”,真实原因仅放在details,页面不展示。旧提议也没有保存本次失败,继续显示上午“需人工确认”的意见。由13:39:10重新取计划到13:40响应约50秒。本次请求是明确的业务拒绝,未见请求超时。另发现潜在等待缺陷:浏览器60秒超时早于后端研判90秒上限。
## 修复内容与边界
功能提交4f6b192。失败原因按原返回内容提取,区分规则、研判、策略和候选不足。最近失败保存在现有提议JSON,以原内容和WAIT_USER状态做条件更新。原数量、原批准依据和提议状态保持。失败不生成指令,不写影响自动判断的拒绝账本。具体错误由原操作日志记录。已失败提议须重新核验,不能因组合恰好回到旧值而复用旧批准。
确认框保留错误信息,卡片提供再次查看入口。新版建议在同一框显示数量及理由,清空旧选择后重新确认。等待期间防止重复点击,并说明正在核验。浏览器等待为有效研判超时加60秒,最低120秒;当前为150秒。未收到结果时不自动重发,也不声称后端已经失败。没有改动准入、仓位、交易时段、研判结论或执行规则。
13:40旧失败没有自动补写回原提议。其原因已从审计找回并记在本报告。新失败记录从上线后生效,不以新检查冒充旧检查。
## 测试、部署与实测
本地24个专项、44批隔离禁网回归通过,含三页面守卫。前端Node替身覆盖错误保留、更新后确认、未知结果、重复点击和异常释放。155候选镜像在--network none下运行全部44批测试通过。
13:59:00四容器统一重建为sha256:6ee444e1c734dc454a8564c9e6ae8f05c5e0c4b25ba9282049f61234a1db10af,标签pms:proposal-feedback-4f6b192。镜像与运行容器Python指纹均为63b3e303084e。四个变更源码的SHA与本地一致。页面SHA为4ba2ed96f0b207ac2a7b6b2bfb952d956420f85d05e61b28ef85ec257e1c8543。开发机Python总指纹包含两个既有未跟踪探针,不能与纯归档镜像直接混比。
13:59:33前后15项参数、三票数量成本毛盈亏、24条历史指令进度、当日指令、提议及成交记录一致。修复审计仍122+1。对账diffs=[]、errors=[]、severity=OK、streak=0。QMT ONLINE、resync_flag=0、last_error空,last_seq=1245545。健康正常、db_ok=true、交易日历未降级。原两处事实源覆盖差异仍单列,不改ws_first。
浏览器独立标签核验页面正常、既有风格保持、错误日志为空。用户原标签及未提交确认框保留。自动审批拒绝打开“采纳”确认框,理由是会话不允许代点采纳。因此未在真实页面提交或代测采纳;确认框交互由离线替身验证。上线后自然失败提示的完整浏览器效果仍待正常用户事件,不能用只读页面检查替代。原心跳14:30接续,不为验收制造交易。
## 可复核命令
```bash
# 开发机 · tradingSystem 根目录;预期24 tests、OK
/private/tmp/pms-codex-20261012-venv/bin/python scripts/unit_test_guard.py scripts/test_batch38_units.py
node scripts/test_proposal_dialog.cjs
```
```bash
# 155模拟PMS机 · ~/project/tradingSystem;只读,核对自然用户事件
cd ~/project/tradingSystem
docker exec -e PYTHONPATH=/app -i pms-web python < ~/pms_logs/verify_proposal_rejection_20261016.py
```
## 证据与回退
证据在155 ~/pms_logs/。proposal-feedback-build-20261016.log、proposal-feedback-tests-20261016.log记录候选镜像验证;proposal-feedback-deploy-20261016.log记录重建。proposal-feedback-before-deploy-20261016.json和after-deploy文件为运行参数账本;events-before和events-after为提议、指令、成交与历史修复审计;before-20261016.sha256保存写前摘要;comparison文件保存逐项对照。proposal-web-20261016-1345.log和proposal-rejection-audit-20261016.json为本次问题证据。日志展示先脱敏,不打印鉴权参数。
回退镜像pms:rollback-before-proposal-feedback-20261016,指向a33ecb004e285ed7991b1492477e222703d1ec89892e36ee7cb51ee2d555b3c8。155挂载/app,回退须开发机反向提交后服务器git pull,再以匹配镜像重建四容器;不能只换镜像。保留新增检查记录、真实成交和七条历史取消状态,不以回退为由恢复续单。
## 14:45 追加:明确否决后撤下旧提议
用户14:20自然确认已看到具体否决,但旧提议仍待确认。本次按用户意见修正生命周期,取代上文所有失败都保留状态的范围。功能60de23e:明确研判拒绝、策略放弃或可核验资格失效转EXPIRED并标记withdrawn;暂时性不足和来源不可用继续等待。状态与拒绝账本同事务,原JSON防并发。旧已保存拒绝由既有扫描收尾,不新增模型调用。实际拒绝原因不再拼接在途名额背景。
30专项、44批本地及候选镜像禁网回归、Node交互替身与三页面守卫通过。14:39:51四容器统一镜像befb6246f3d8a4e5d5c4b6c8e2f3823a5875ef7d9acfe32e578ff0fe4fb80a46,指纹3777e125a88a。14:40:01正常扫描撤下瑞芯微,原100股及旧批准依据不变,保留原14:20检查时间,唯一拒绝账本6858,没有对应指令。14:45重复读回仍唯一。没有记录的历史重问基线为空,不用上午191元旧价冒充14:20行情。
14:40部署前后15参数、三票数量成本毛盈亏、其他提议、当日指令数量进度、成交行及122+1修复审计保持。24条历史指令仅既有WAIT时刻推进一分钟,执行数量、金额、子单不变。七条历史取消保持。QMT ONLINE、resync_flag=0、last_error空,对账diffs=[]、errors=[]、severity=OK。只读浏览器确认待确认0条,候选正常且无错误。用户原标签旧框保留,刷新可见新版;未代点采纳。确认框撤下分支由离线交互覆盖,实际撤下与列表已在线核验。
证据在155 ~/pms_logs/proposal-withdraw-*。回退标签pms:rollback-before-proposal-withdraw-20261016指向6ee444e;绑定挂载需源码反向提交、pull及配套重建。保留撤下和交易历史,不恢复旧提议或暂停指令。完整本轮判收与历史边界见四仓交接14:45节。
```bash
# 155模拟PMS机 · ~/project/tradingSystem;只读,瑞芯微EXPIRED且withdrawn,拒绝仅一条,无对应买入指令
cd ~/project/tradingSystem
docker exec -e PYTHONPATH=/app -i pms-web python < ~/pms_logs/withdraw-records-20261016.py
```

View File

@ -0,0 +1,581 @@
# 每日选股计划完善方案与开发规格
2026-10-15,北京时间。用户已批准三仓联动实施。本文是本轮开发、验收和接续入口。
## 目标与边界
统一研究依据、候选排序、建仓优先级和复盘记录。保留候选准入、线上参数和交易职责。
盘中新评析自动发布完整修订版。自主提议采纳前重核,排名变化本身不撤销提议。
基座提供研究,桥形成计划,PMS 管组合与执行。修订不调用模型。
## 实现契约
- 计划保留原字段;schema_version=2,decision 包含 id、parent_id、cutoff_at、input_hash、params_hash、reason。plan_version 仍为代码版本。
- 每行新增 research_rank(全量顺序)、research、review_ref;展示裁剪不能改写 research_rank。
- 采集输入与确定性装配分离。输入、有效配置、全量输出一起归档。相同内容幂等;文件锁串行发布,原子切换最新指针;晨版固定为首版。
- GET /plan 支持 decision_id,只读发布物。历史缺档明确报错,不以当前来源重构。旧快照可读但注明追溯不完整。
- 07:20—15:10 北京时间交易日每五分钟 plan-refresh,只更新评析与区制。晨版缺失不代造。08:45 区制更新同样发布版本。
- 修订失败保留旧完整版本;已识别的变更股票列入 pending_codes,PMS 暂停其新增自主提议。GET 不做重装配。
- 基座报告按内容指纹保存,最新索引保持原结构。report_version_url 固定内容;旧报告不伪造归档引用。
- PMS 保存 received(收到)、consumed(实际筛选消费)、rechecked(采纳核验)三类记录。后两类记录有效参数、实际顺序、逐票过滤原因与上下文指纹。动作账本保留决策及消费引用。
- 自主扫描继承 selection_rank;现有信号优先仍生效且记原因。命令驱动保留原分配规则并记录来源。
- 自主提议转指令前核对版本;资格、风险、仓位依据变化重新走现有评估,旧批准不复用。仅顺序变化可继续。未知当前版本守成。人工页面版本不匹配返回冲突与新提议。
- 研究增加预期差、周期、材料期、材料数、未知问题、数字核验、论点变化和验证事项。自然语言不自动转交易触发器。
- 复盘读取晨版与真实消费记录。缺档与重构不混入真实效果统计。旧收益口径和期限保持。
## 验收预判
1. A 优先于 B 且仅一名额时产出 A;信号插队有明确原因。
2. 好转差时全出口同步,旧版字节不变;相同输入不重复发布。
3. 同强度证据与无主题裁剪确定;全量名次不随展示参数改变。
4. 历史不含未来评析,当前参数不改变历史消费名单。
5. 提议排名变化、资格失效、仓位缩减、版本缺失和并发采纳逐项测试。
6. 发布中断、重复触发、并发区制更新、失败恢复和重启恢复不破坏旧版。
7. 缺新增字段兼容;修订零模型调用;普通查询不重装配。
8. 两端页面守卫与浏览器验证通过。
## 交付与运行边界
四批为确定排序、不可变版本、消费与重核、研究与页面。先兼容读取,再发布,最后开启修订。
本地验证不能代替部署验收。十二分钟目标按连续交易时段核验。午休等待单列,确保下午开盘后及时实际消费。10-15 用户确认当前即为模拟仓,取消额外五个交易日观察;首个完整晨版通过后启用修订及重核。
容器与生产操作另按授权边界执行。避开 06:10 及 07:10 窗口。
版本至少保存一百二十个交易日。被未结束提议或持仓引用的记录继续保留。
本轮初始记录为未部署;当前已部署,五日等待条件已由用户取消。验收实测在文末与交接追加。
## 开发人员实现说明
### 第一批:确定性与顺序
桥的 `plan._evidence` 在同强度证据后按目标名、来源数、市场统计与日期稳定排序;卡片最终以代码收尾。
`pick_rows` 与 PMS `select_candidates` 均只对明确主题应用主题限额,无主题不构造共同的行业桶。
有效排序开关仍从原配置读取;PMS 筛选结束写 `selection_rank`,动作引擎按此序逐只扣名额和资金。
既有盘中信号优先在它之前,写 `execution_rank/priority_reason`。命令规划保留原命令、白名单和分配次序,
把来源及最终顺序写入命令 progress,再按 plan_id 传到指令 progress 与执行账本。
### 第二批:固定输入、发布和恢复
`plan_inputs.Bundle` 在来源函数边界录制实际结果和错误,并使用 ContextVar 隔离装配。
输入支持 DataFrame、Series、日期、Decimal、集合及缺失值;归档 JSON 可重放。
重放禁止缺项回源,即使上层捕获异常,退出重放作用域时仍会报错。有效业务配置同步冻结。
晨版评析按带时区 cutoff_at 过滤;它与行情 date 独立,因此可以使用今日盘前已知材料。
`plan_versions` 用进程间文件锁覆盖采集至发布。文件路径为:
- `versions/<行情日>/<decision_id>.json`:完整计划、实际输入和有效配置,只追加。
- `plan_<行情日>.json`:原有兼容入口,完整写入临时文件、fsync 后原子替换。
- `versions/<行情日>/morning.json`:首个成功发布版本;中断缺失时沿已发布父链恢复。
- `versions/<行情日>/health.json`:检查时刻、待核验股票和错误原因。
版本身份包含输入、参数、代码版本、行情日和父版本。同有效输入不重复发布;A→B→A 保留三个实际版本。
最新入口带已发布祖先标识,查询固定版本不需要逐次读取整条历史。未切换成功的孤立文件不能对外查询。
Markdown 兼容文件从已发布 JSON 派生并标明决策版本;写入失败不回滚已发布 JSON,下一次发布可恢复。
普通查询只做固定版本读取和展示裁剪。`PLAN_FROM_SNAPSHOT` 的旧“回落现算”语义废止;
`PLAN_REVIEW_SOURCE=live` 也不再允许用当前研究伪造历史。保留两个配置名称用于旧配置兼容。
`plan-refresh` 是 XXL 白名单里的独立步骤,不加入晨间默认三步。调度平台每五分钟触发,
函数再核验北京时间、交易日和当日晨版。时段为 07:20 至 15:10(含端点);日历依赖 chinesecalendar>=1.11,
本地已验证其 2026 年工作日与国庆休市读数。08:45 `regime-append` 走同一锁和发布入口。
只替换新评析及区制,其余来源使用晨版冻结值;修订不写日频逻辑状态表、不重投评析目标、不调用模型。
读取评析前标记观察范围待核验,来源失败保留该标记;成功后仅对实际变化的票保留,发布完成后清除。
桥缓存键包含决策版本和修订状态。PMS 最新计划缓存不超过五分钟;基座最新计划代理缓存一分钟,
指定版本代理可长缓存。目标预算为检查等待五分钟、消费等待最多五分钟,余下两分钟供装配及传播,
十二分钟按连续交易时段测量。午休分别记录总等待时间与下午开盘后的实际消费时延,不修改原执行时段。
### 第三批:消费记录与采纳核验
复用 `pms_plan_snapshot.meta_json/roster_json`,消费指纹含决策版本、有效筛选参数、持仓与黑名单上下文、
实际顺序和逐票过滤原因;正常展示预览不记作实际消费。消费留痕失败仍可展示,但不能新增自主提议。
取消按行数删除的所有调用,旧清理函数也改为不删除;当前保留全部记录,满足至少 120 交易日及在用引用保留。
后续若增加容量治理,必须证明交易日水位与引用保护,不能恢复旧 200 行截断。
`PMS_PLAN_VERSION_RECHECK` 为新增发布控制,默认 False。启用后自动采纳和人工采纳 OPEN 均强制刷新计划核验。
仅排名变化保留提议;复核不再应用 top_n 和主题展示限额,但原档位、风险、黑名单等资格检查仍保留。
研究、风险或仓位参数变化时,以当前组合重新走 `_scan_open`、合议、强制重新研判、建议数量及规则闸,
排除原提议自己的在途占用;人工提议更新内容并产生 proposal_revision,原批准不能沿用。
持仓数量、可用资金、行业归属和其他在途承诺变化也会使旧数量依据失效。重新评估时按已有 force_refresh
接口要求决策系统重新回答,遵守其原有强制次数预算;不能复用股票/动作缓存中的旧批准。
数据库用 WAIT_USER 状态与原 hard_numbers_json 的条件更新拒绝并发重复采纳和旧内容确认。
版本不可用、资格失效或重评未通过时保留待确认提议并给出原因,不产生新的自主买入指令。
已落指令仍沿原执行终检和风控,不因研究名次变化自动撤单或卖出。
复盘主表固定首个成功晨版;日频“交付名单”使用当日最后一条真实消费的已记录顺序与参数。
新增 `版本消费对账_<日期>_<口径>.csv` 单列所有晨版、修订、消费及核验记录,关联父版本、原因、
消费参数、过滤项和追溯资格。盘中多版本不当作多个独立交易日加权。缺档和旧名册排除真实效果统计,
记录覆盖率;既有五、十、二十日观察及执行账本口径保留。
### 第四批:研究信息与报告引用
基座沿用 company_review_runs.summary,新增 review_ref、report_version_path;不改表、不改质地合成。
报告 Markdown 与侧车 JSON 的内容指纹决定对象路径,先保存两种对象,再更新最新索引。
`GET /company/{code}/review?ref=<指纹>` 只读固定对象;无 ref 的最新报告入口保留。
桥透传已有预期差、周期、材料期、数量、未知问题、核验信息与报告生成时刻,计划行保存冻结研究摘要和差异。
来源未给出的日期与阈值保持未知;摘要不冒充历史完整报告。
基座今日页先取计划,再按该 decision_id 取判决。PMS 候选、提议和持仓页面展示版本、原因、
论点、反方论点、材料与报告时间、待核验事项;独立持仓研究另带 observation_at/scope,不能冒充计划版本。
完整指纹保留在详情。报告查询只接受合法指纹,并从已知基座地址取得指定版本。
## 五处登记与运行入口
本轮没有新表。新增任务的存储、调度、手工入口、日检和台账分别为 `plan_versions.py`、
`xxl.py` 的 plan-refresh、`run.py plan-refresh`(及 POST /plan/refresh)、`plan_health.py`(及 GET /health),
桥决定台账 064、PMS 决定台账 018 与同名交接文档。
```bash
# 桥机 · 已确认的桥容器内 /app;部署批准之后才执行,date 不传自动取最新已发布日
python run.py plan-refresh
python plan_health.py
```
平台入口仍是 `/api/v1/xxl/daily-build?steps=plan-refresh`,使用既有 X-Job-Key 鉴权;
实际平台任务为 XXL 137“每日选股计划五分钟修订”,已创建但停止,首个完整晨版通过后启用。日检只读文件,0 正常、1 旧版/待修订/修订检查超十二分钟、2 缺档或结构损坏。
时段外不把停止检查误报成故障;窗口内没有今日晨版也会提示。
## 本地验收与分批上线
四批本地实现及离线、假数据页面验收已完成。10-15 用户批准部署后,基座、155 桥和 155 模拟 PMS 均已部署,
桥最终镜像 33 组断网契约测试通过,11:28:51 完成重建。具体提交、参数和实测见 `交接_每日选股计划完善_2026-10-15.md` 末节。
上线顺序:先基座版本报告与 PMS 兼容读取、留痕;再桥新版发布并核验首个晨版;最后配置五分钟修订任务,
核验传播正常后只在已确认的模拟实例开启 PMS_PLAN_VERSION_RECHECK。不能替用户切换原排序开关、
档位白名单、策略阈值或自动扩大仓位。桥 requirements 更新需要纳入镜像;基座后台代码必须四 worker 一起换,
前端必须重建;这些容器操作仍需用户同意。实际机器、容器名及实例前缀部署前按各仓现行运维文档只读确认。
10-15 已获得本次容器操作批准;不把这次批准延伸为以后维护的常设授权。用户另批准补齐旧排序配置,
桥实际为 PLAN_RANK_AXIS=transmission、CARD_SORT_BY_QUALITY=0,保持原行为。今天旧计划字节不变。
下一交易日 10-16 07:25 由 Codex 心跳 automation-2 核验首个完整晨版;通过后启用已经创建且停止的 XXL 137,并打开模拟仓提议重核。额外五日模拟观察已取消。
按首版与后续实际修订事件记录(不再要求连续五个交易日):晨版与修订版本、输入及配置指纹、评析到达/发布/消费三个时刻、
消费顺序、信号优先原因、待核验股票、重新确认案例、失败恢复及重复指令计数。
目标为同版内容一致、旧版不变、连续交易时段传播不超过十二分钟、午休材料开盘后及时消费、无并发重复指令。按文末实测逐项判收。
回退优先暂停平台 plan-refresh 并关闭新核验控制,保留版本、报告对象与账本;继续提供最后一份完整计划。
禁止把回退解释为删除历史或恢复查询时局部覆盖评析。
## 10-15 补充决定
用户取消额外五日模拟观察,未取消具体技术验收。任务 137 以 A股交易日时间段模式配置 07:20—15:10、300 秒,
当前停止;07:10 与 08:45 原任务保持。首个完整晨版通过后直接按已授权范围启用修订及提议重核,失败则保留当前有效版本并修复。
Codex 心跳 automation-2 负责 10-16 07:25 的接续检查和必要后续验证,不能当作五分钟业务调度。
PMS 三项旧对账差异的防双记修复 e9afc7a 已部署;旧批次成本、盈亏及执行进度仍需有证据的独立修复,不把日终数量归零差额当历史修复完成。
详细实例、测试、证据快照及待判收项见同日交接最后一节。
## 10-15 历史修复补充规格与判收
历史修复遵循“完整备份—逐笔编译—前置原行比较—事务写回—独立读回”,不能只调整持股差额。真实买入须以数量、价格、父指令和入账时间唯一对应批次;重复汇总批次须有下游汇总证据;逐笔数量须等于子单累计数量。卖出沿既有批次核销次序重建成本与盈亏,费用缺失不伪造。所有 SQL 维持单表守卫。原误判完成但未足量的父指令暂停剩余执行,不自动复活旧单;真实超额成交保留事实。
155 已部署 0871885 并恢复三票数量、成本、盈亏和 24 条父指令进度。134 笔成交、122 行原值审计,重复执行幂等,独立读回无差异。本地与候选镜像全部 44 批通过。费用、历史峰值、已删除旧轮次批次与历史全组合绩效的限制见同日交接最后一节。原始成交、回放游标和历史报表不改写。明日 07:25 首晨版核验和通过后启用 XXL 137 / 提议重核的安排不变。
最后补充:已恢复的指令均价有固定观察时点。未来新成交使旧均价失效,原修复金额保留于版本化审计,避免只更新执行量却沿用旧均价。该补齐为 a56dac5,22 个专项回归及完整 44 批本地和候选镜像测试通过,12:50 最终部署与再次读回通过。
## 10-16 晨版验收发现的重复构建边界
目标:已发布日期不能被另一条全量构建链重新采集研究后替换。盘中变化只走完整修订入口。
今晨验收发现,01:50 的既有流水线也触发默认 build、plan、push-pool。
它在当日盘前数据尚未准备时,以 10-14 数据日发布了新的首版,并覆盖旧格式日期文件。
07:10 正常链已另行产出 10-15 数据日的完整晨版。旧格式原文件尚未找到可核验备份,不能声称已恢复。
修复:generate 遇到已有日期直接复用已发布内容,不再采集、写日频逻辑或投评析目标。
底层 publish 拒绝替换没有 decision 的旧格式文件,保留原字节。
复盘以行情日的下一交易日校验晨版截止日期。跨过该日才生成的首版单列,不纳入真实决策统计。
不更改流水线、选股参数或晨版文件,不制造新的历史版本。
预判:旧格式重复构建字节不变;完整版本重复构建不回源;底层直接替换旧格式被拒绝。
复盘应排除 10-14 数据日但 10-16 才发布的首版,保留今晨正常 10-15 数据日版本。
先跑合成输入回归,再在候选镜像断网验证。上线只更换桥容器,核对完整晨版文件哈希保持。
回退保留版本与账本,恢复前一镜像并停止新增修订任务,不覆盖任何计划文件。
10-16 补充判收:e44f770 已部署。本地和候选镜像各 36 组禁网回归通过,07:33:40 桥重建完成。
今晨版本原字节保持,晚生成历史样本已排除;丢失的旧格式原件未恢复。
07:35 XXL 137 首次自动检查成功,未重复发布。07:35:36 提议重核开启,其余参数保持。
真实消费、自然研究传播和重核案例待后续正常调度验证。下一次接续为 10-16 08:55。
详细运行读数与边界以同日交接的 10-16 追加节为准。
## 10-16 08:45 区制与修订调度冲突修复
实测:XXL 122 的 08:45 区制追加与 137 的五分钟修订同时触发。
137 先取得桥全局任务锁,122 返回 409,平台未配置重试,区制未追加。
已发布晨版与修订版保持完整。此次修复只解决这两类完整修订的串行受理。
实现:在桥任务入口为 plan-refresh 和 regime-append 增加有界等待队列。
仅当正在执行与新请求均只含这两类步骤时排队,最多两条等待任务。
其他构建与写池任务继续沿用忙时拒绝。等待任务保持独立标识与结案回调。
完成或失败均释放下一条,单写入锁与输入幂等继续负责计划发布。
等待状态显示 queued,真正执行时才写 started_at,收到时间另记 accepted_at。
队列驻留现有进程内存,服务重启不冒充任务成功;须核对未结案任务后补执行。
不改 08:45 时刻、五分钟周期、候选参数、模型调用或交易行为。
预判与验证:两个方向同时到达均按接收顺序执行,无并行装配。
前一个失败仍放行后一个,各自回调一次;队列满明确拒绝,普通构建仍为 409。
先补合成回归,再跑完整离线及候选镜像禁网测试。部署前保存现有版本文件哈希。
上线后补执行原 122 区制任务,核对新完整版本、原晨版及所有旧归档不变。
回退使用前一桥镜像,保留版本与台账,并暂停冲突任务,不能覆盖归档。
## 10-16 PMS 收到版本身份比对修复
浏览器验收已进入登录后的真实页面。新版快照落库成功却提示未落库。
原因是写入使用版本与查询范围指纹,变化与预览仍使用旧名册指纹。
三个出口共用收到身份函数,保留旧数据回退;实际消费与收到继续分开。
预判:相同版本及查询范围显示一致,任一变化显示不一致,落新记录后恢复一致。
页面删去请求时实时装配、没有版本和始终按分数排序的过期说明。
只影响版本观察与说明,不调整候选、提议、数量或任何参数。
先跑隔离禁网回归与页面三守卫,候选镜像断网复核后仅在 155 部署。
回退保留快照账本并恢复前一 PMS 镜像,不修改历史记录。
10-16 09:30 补充判收:桥 72efc8c 与 PMS 3057250 均已在 155 生效。
桥 7 套本地及候选镜像回归、PMS 44 批本地及镜像禁网回归、三页面守卫均通过。
09:13 补执行原区制任务成功,晨版及旧归档保持;09:25 正常扫描消费区制完整版本。
24 只候选的顺序、有效参数、过滤原因与消费指纹通过核验。
24 份自然新评析在 17 秒至 5 分 9 秒内发布,但盘中评析至实际消费十二分钟仍待自然事件。
登录后候选、提议与持仓页面已核对。旧数据明示缺失,收到记录不冒充实际消费。
真实重核和新成交防双记继续接续,不制造事件,不增加额外五日观察。
详细版本、镜像、备份、运行边界和手工验证命令见同名交接最新追加节。
## 10-16 交易员研究展示修订
用户指出新增版本字段破坏交易员页面风格。本条修正此前“信息可读”的验收结论。
操作卡只保留动作、金额、主要结论及必要风险提示。研究复用原基本面入口,不增加字段清单。
详情按核心判断、风险、预期、待验证事项和研究变化组织;技术来源默认折叠。
报告时间和材料期分开,数值展示适度舍入。缺失项不连续占位,无摘要明确说明。
候选、持仓及运维提议复用同一详情,避免表格撑高;不改冻结依据、数量和交易行为。
预判为侧栏无长标识溢出,裁决按钮紧接摘要,旧记录不伪造研究,来源展开仍可核验。
本地与 155 禁网临时容器三道页面守卫通过。09:47 浏览器核验侧栏和来源区均无横向溢出。
纯静态页面 c2d0dc9 已经 155 源码挂载生效,交易进程未重启。回退需反向提交静态页并拉取。
## 10-16 交易员界面整体检查与补充验收
用户要求将同一原则扩展到整个交易员界面。提议以建议动作、股数、金额和仓位差异为主,重算过程可展开。候选直接显示等待条件,保留原筛选和排序;资金占用说明去除内部代码数组。交易方案、持仓和信号说明同步简化,技术参数及来源置于详情。补齐既有分区折叠样式,方便集中查看候选。
本轮仅修改展示,不更改交易流程与参数。16d8fd7 和 564f553 已在 155 静态挂载生效。两次本地与服务器禁网页面守卫通过。浏览器核验 3 条提议、13 只候选、2 个当前方案,数量差异仍显著,详情入口与折叠正常,无横向溢出或页面错误。四个交易进程未重启,188 未操作。回退使用静态反向提交。备份、哈希与手工验证方法见交接同日 10:20 追加节。自然事件技术验收继续独立记录,本轮不宣称该项完成。
## 10-16 10:40 提议重复确认修复规格与预判
正常操作日志显示科士达提议在 10:02 和 10:04 连续要求再次确认。计划、扫描参数与数量相同,但仓位依据指纹不同。代码将按实时价格计算的在途占用金额纳入指纹,报价变化会被当作承诺变化。先补回归,再修正这一核验依据。
在途读取新增稳定依据,包含来源类型、指令或提议标识、股票、数量与指令成交进度。指纹采用稳定依据,排序后计算;现价仍用于原占用金额计算与执行终检。新增、撤销、替换、数量、成交进度、现金与持仓变化继续触发重核。旧输入缺少稳定依据时保留原保守比较。旧提议因指纹格式升级可重核一次,不直接迁移旧批准。
验收预判:仅报价变化不重跑研判、不反复要求确认;真实数量或承诺变化必须重新评估。保留原金额去重、候选排序、准入及仓位上限。运行本地与候选镜像禁网回归后,仅重建 155 的四个 PMS 容器。核对运行参数、历史修复账本及七条暂停指令不变。自然用户确认留待实际事件,不代替用户操作。回退恢复上一镜像并使用匹配代码的反向提交,保留计划、提议与账本。
### 10-16 10:50 提议重核修复部署与自然成交判收
PMS 15072f7 已于 10:44:28 在 155 四容器统一生效。18 个专项用例及全部 44 批本地、候选镜像禁网回归通过,包含三项页面守卫。新镜像为 7003b81c79000cb61633d94a6529253a412de9c2cbc5522e296aea71a0e2f337,代码指纹 cf0a57a03a76。现有页面保持,188 未操作。
前后 15 项运行参数和三票数量、成本、毛盈亏逐项相同。七条暂停指令保持 CANCELLED,审计 122 行加 1 条汇总不变。QMT ONLINE、resync_flag=0、对账 diffs=[]。旧提议没有被自动采纳;修复后自然确认效果继续等待实际用户事件。
14 笔修复后的自然卖出已逐笔核验,合计 1,000 股、28,270.78 元。对应汇总镜像已存在,数量、父指令进度及批次毛盈亏没有双记。原成本与逐笔舍入边界另见 PMS 三项差异报告。自然成交防双记已有真实证据,不再列为缺失。
10:45 五分钟检查正常,仍为 11 个完整版本、24 份盘前评析修订,晨版与归档保持。研究十二分钟时延仍缺开盘后的自然新评析。后续安排同一心跳于北京时间 11:15 接续核验;任务 137 和提议重核开关保持启用,不增加模拟观察天数。
## 10-16 11:25 自然成交发现网格卖出越界的修复规格
威胜信息 11:05 与 11:13 各生成 700 股网格卖出。原档位 1,000 股,首笔成交后已恢复剩余 300 股;第二笔仍按 per_lot=700 取量,导致额外卖出 400 股底仓。七笔真实成交合计 1,400 股。代码仅以配置档量和总可卖量封顶,遗漏了档位余额与实际 ADD 持仓上限。
修复将网格卖出数量同时限制在配置档量、当前档位余额、实际 ADD 持仓和可卖量内,再沿用既有整手和最小申报要求。档位穿越、买入条件、档距、价格、资金上限和策略档量不改。未成交与部分成交的档位恢复继续使用原逻辑。历史实际成交保留,不伪造恢复底仓,不反向买入。该策略已由原清场流程于 11:16:01 取消,不自行恢复。
先补四组离线反例:剩余 300 不得按配置卖 700、首笔 700 后仅余 300 的连续状态、可卖和实际网格股限制、未成交及部分成交恢复。预判为正常完整档量行为保持,旧小余额不侵入底仓。完整本地和候选镜像禁网回归通过后仅在 155 部署,保存参数与账本基线,四容器统一重建。回退需匹配源代码与镜像,保留真实成交和台账。
### 10-16 11:35 网格数量修复部署判收
PMS bafecb7 已于 11:31:02 在 155 四容器统一生效,包含此前 15072f7 重核修复。四个新增反例在原实现全部失败。修复后 45 个策略用例、全部 44 批本地及候选镜像禁网回归通过,含三项页面守卫。当前镜像 a33ecb004e285ed7991b1492477e222703d1ec89892e36ee7cb51ee2d555b3c8,Python 指纹 12f782622c4d。
11:31:29 真机读回:15 项参数与部署前一致,三票数量、成本及毛盈亏与成交后的基线一致。威胜信息持仓为 0,当前账期已实现毛盈亏 -252.01 元。七条历史暂停指令、122+1 审计及已取消网格状态保持;没有恢复或制造交易。健康、QMT 与对账正常。原事件造成的 400 股底仓卖出事实保留,数量修复不能撤销已成交结果。
桥 11:30:11 检查正常,晨版和旧归档保持;consumed 68 记录持仓变化后的真实消费,顺序和指纹正确。没有新自然评析或用户确认。原心跳已改为北京时间 13:15 接续。技术验收尚有未决项,不关闭五分钟修订或提议核验,不新增五日观察。
### 10-16 13:25 自然传播样本与未达标边界
四份连续交易时段自然评析已通过全链路核验。13:09 的两份经 13:10:16 完整发布,13:11:09 实际消费;13:12 的两份经 13:15:16 发布,13:17:02 消费。耗时 1 分 54 秒至 4 分 12 秒。24 只候选的消费顺序、指纹和有效参数正确,固定报告内容指纹、晨版与此前完整归档均保持。
六份午休评析在 12:05 和 12:10 发布,直到 13:00:03 才被正常扫描消费。实际耗时约 55 分钟,未达到十二分钟目标,必须单列。当前执行任务有交易时段守卫;不删除守卫、不制造午休交易或伪记消费。此处没有自动将原目标改成仅交易时段适用。非交易时段的时延边界仍未收敛,不能宣告全时段达标。
修复后没有新的自然用户确认,提议重核的实际确认效果仍未判收。13:15 参数、数量、成本、毛盈亏和历史修复审计保持,对账无差异,健康与 QMT 正常。本轮没有业务代码、参数、重启或交易写操作。四份通过的样本不替代剩余验收。原心跳 14:15 接续,不新增五日观察。详细时刻、后续版本采样边界与证据见同名交接 13:25 节。
### 10-16 13:30 用户确认时延验收口径
用户确认:十二分钟目标按连续交易时段核验。午休期间的自然材料单列总等待时长,另核对下午开盘后是否及时被实际消费。保持原交易时段,不为验收生成评析、采纳提议或制造交易。本条取代 13:25 节的“非交易时段时延边界仍未收敛”结论,历史实测读数保留。
据已有实际证据,六份午休材料于 13:00:03 被 consumed 71 消费,即下午开盘后三秒。午休恢复消费要求通过;约 55 分钟总等待时间仍单列。四份连续交易时段材料在 1 分 54 秒至 4 分 12 秒内实际消费,十二分钟样本通过。不更改调度、缓存、准入、仓位或执行时段守卫,也不以页面收到记录代替实际消费。
剩余重点为提议稳定依据修复后的自然确认。只有实际用户操作到达时才核验,不代替用户确认。后续自然修订继续核对版本、顺序与失败守成,不增加额外五日观察。
13:35 补充实测:连续交易时段样本扩展到八份,生成至实际消费为 114.360—393.202 秒,均通过。13:27:30 出现首次修复后的自然确认,持仓上下文变化且旧指纹升级,系统重跑并更新为待再次确认的 600 股提议,没有生成指令。更新内容必须再次确认的分支已见实际证据;无变化直接通过的线上路径仍待自然操作。具体账本与时刻见同名交接 13:35 节。
## 10-16 13:55 提议采纳失败反馈修复规格
用户报告采纳后长时间等待,最后仅短暂提示“新版重新评估未通过”。13:39:02 科士达已由用户正常采纳,生成一条 600 股指令。13:40:00 瑞芯微重核返回拒绝,旧代码丢弃具体原因,待确认卡仍展示上午结论。只读研判缓存显示 REJECT、把握度72,原因为资金净流出及短期走势偏弱。不能将这次拒绝改成通过。页面统一60秒超时也短于既有研判90秒上限,容易先报超时而服务端仍在处理。
修复只补采纳结果的表达、留痕与确认保护。沿用原扫描、合议、数量、研判和规则闸。失败提取原拦截原因,区分交易条件、研判、策略与候选不足。最近一次失败写入提议现有JSON,并采用待确认状态与原内容的条件更新。保留原数量、原批准依据和状态;后续即使仓位回到旧值,也须重新核验这条已有失败结论的提议。失败不写影响自动交易判断的拒绝账本,具体原因由原操作日志保存。
确认框持续显示失败原因,不再只弹短提示。卡片仅增加一行“最近核验未通过”和查看入口,技术来源仍折叠。内容更新后在原确认框展示新数量及研判理由,清空旧选择,要求重新确认。请求等待覆盖有效研判超时与额外取数时间。等待时说明用途并阻止重复点击。断网、超时或服务异常视为结果未明,不自动重发采纳,也不声称已经失败或没有指令。
预判:研判拒绝、规则失败、扫描无候选都能显示原始业务原因;失败留痕不得覆盖并发更新;旧批准不能绕过已记录的失败。新数量必须二次确认,依据未变仍可直接采纳。等待结束或异常必须释放按钮状态,重复点击只能发送一次。运行离线专项、完整禁网测试、前端交互替身和三项页面守卫。候选镜像禁网通过后仅重建155四容器,再核对参数、账本和页面。禁止用真实采纳作为验收手段。
回退采用匹配源码的反向提交与旧镜像重建,保留提议JSON和操作日志。没有新增调度、模型调用路径、交易时段、参数或策略阈值。188不操作。
### 10-16 14:05 采纳反馈修复部署判收
4f6b192通过24个专项、44批本地与候选镜像禁网回归,以及Node交互替身和三页面守卫。13:59:00在155四容器统一生效。参数、账本、指令和提议前后保持,QMT在线、健康正常、对账无差异。镜像、指纹、备份和回退见同名交接14:05节。
科士达13:39用户自然确认成功,依据相同直接通过,唯一600股指令留有计划与检查引用。这一自然分支已验收。瑞芯微13:40真实研判拒绝的原因由既有审计确认,未改判或制造交易。旧失败没有补造为新检查。
浏览器只读核验页面正常、风格保持、无错误。自动审批拒绝代点“采纳”以打开确认框,已改用离线交互验证。新失败提示的真实页面闭环仍待自然事件,不假报完成。原心跳14:30接续,不扩展交易时段或增加模拟观察天数。
### 10-16 14:35 提议撤下的实施补充
用户指出:明确否决的提议继续占着待确认列表不合理。本条取代此前“所有失败均保持待确认”的处理。只调整提议生命周期,不修改研判、准入、仓位和交易时段。
明确的研判 REJECT、策略放弃,或可核验完整计划中的资格失效,关闭旧提议。复用 EXPIRED 终态,在原 JSON 标记 withdrawn 和具体原因,不冒充人工驳回。页面移出待确认,确认框只显示撤下原因及关闭。网络、来源、记录失败和暂时性条件不足继续保留,不能依据中文关键词猜测撤下。
关闭提议与拒绝留痕在同一事务,使用 WAIT_USER 加原 JSON 条件更新,防止覆盖并发采纳。研判与策略拒绝沿用现有拒绝、解锁重问规则,不能撤下后立即原样重提。原数量和原依据留存;只有未来正常扫描重新满足条件才产生新提议。
仅从 rejected 结构提取实际拒绝原因。在途名额等非阻断说明不进入失败提示。现存已保存的明确拒绝由原扫描入口确定性收尾,不调用模型,不增加调度。旧记录未保存的重问基线保持缺失,不拿当前行情补造历史。
预判:明确拒绝从待确认移除且零指令;不可用保留;已有成交和指令不动。覆盖并发采纳、重复收尾、事务失败回滚、背景说明过滤、规则临时不足和已有拒绝的正常扫描收尾。离线及候选镜像禁网回归后仅部署155,写前备份,读回核对状态和账务。回退代码时保留撤下历史,不自动恢复失效提议。
### 10-16 14:45 提议撤下与本轮判收
60de23e于14:39:51在155四容器生效,30专项和44批本地及镜像禁网回归通过。14:40:01正常扫描撤下瑞芯微旧提议,保留14:20原拒绝与100股原建议。唯一拒绝账本6858,无该票指令;14:45重复读回无重复收尾。不可用保留、并发保护和事务回滚由离线回归覆盖。前后参数、修复账务及实际指令进度一致,仅既有WAIT时间推进一分钟。
浏览器待确认0条,候选与风格正常、错误日志为空。没有代替用户采纳。原失败持续提示已由用户14:20自然操作验证;新撤下响应确认框仅做离线交互,正常扫描的真实撤下与页面结果已在线核验。具体备份、镜像、参数、局限和回退见交接14:45节。
14:42复查共有18完整版本、39次自然评析变化。新增14:09材料至14:13实际消费227.793秒,连续时段累计9份通过;午休六份恢复消费仍为开盘后三秒。晨版及归档、父子链、冻结来源、排名与消费指纹保持。10-14旧原件缺失仍单列为失败,当前文件哈希与13:25一致,不冒充恢复。本轮启用和自然事件技术验收闭环后暂停同一心跳,业务五分钟调度及提议重核继续;不增加五日观察。
## 2026-10-19:外部数据停更及失败状态修复
北京时间 09:40 只读核验发现,PMS 对两交易日前计划的拦截正确。
收盘行情已到 10-16,外部个股资金流和资金热度仍为 10-15。
资金流源表 `gp_moneyflow_ths` 最新日 5214 行。
热度源表 `stock_fund_heat_scores` 最新日 9118 行。
基座周六 06:20、06:35 正常同步,却只能取得旧资金流。
周六传导仍锚定 10-15,周一按既定安排复用周六产出。
桥周一 07:10 重建旧日因子并复用旧计划,平台仍收到成功回调。
盘中修订持续返回 `no_morning_today`,也被误计成功。
桥修复 `ef873bb` 已提交、推送并在 155 拉取。
自动日更写入前核对传导、收盘行情及热度的日期。
基准是北京时间当前日期之前的最近交易日。
来源失败不再猜今天,部分因子或冻结失败不继续计划及入池。
缺当日完整晨版的修订返回失败,窗口外仍正常跳过。
显式指定日期的历史维护入口保留。
不改交易时段、排序、档位、仓位及 PMS 的一交易日时效上限。
没有补造当日晨版,没有向旧版本混入新材料。
本地 12 个专项用例及版本契约、判决、候选卡测试通过。
本地调度及区制测试因缺依赖未完成,不算通过。
候选镜像 `--network none` 的八套测试全部通过。
其中专项 12 例、调度 13 例、版本契约 17 例。
155 桥于北京时间 09:50:54 重建。
镜像 `sha256:922fc400e06dbe128ad9dc2e822a0e0b949328677f70fa0c85dc2a1c297db58d`。
第一次部署命中空闲守卫,待既有修订完成才执行部署。
写前完整备份 `~/akg_bridge_logs/readiness-before-plan-20261019.tar`,约 598 MiB。
SHA256 为 `c1b90597f141d7acedc72d84f80e5269f17a40f7a8f9d7d9dd88cece52c3d309`。
全部计划 JSON、旧归档和晨版指针的部署前后哈希一致。
回退标签 `akg-factor-bridge-rollback:before-readiness-20261019`。
绑定挂载仍在,回退需开发机反向提交后远端拉取并重建,保留计划与账本。
线上只读输入检查正确返回 1,指出传导与热度缺少 10-16。
桥保持 transmission、CARD_SORT_BY_QUALITY=False。
155 PMS 实读 ws、OPEN propose_only、提议重核 True、过期上限 1。
上游排序 False、质地排序 True、强传导和 TOP_N=50 保持。
本轮未修改 PMS 代码、参数或容器,188 未操作。
外部两路采集仍待恢复,已询问用户其项目或调度入口。
当前不能宣称候选恢复。来源恢复后再补基座同步及扫描,核对后发布完整版本。
不得修改旧榜日期、放宽 PMS 时效,或用验收制造交易。
不新增五日模拟观察,不用心跳替代业务调度。
手工只读检查如下。当前预期退出 1,来源全部恢复后才应退出 0。
```bash
# 155 桥机 · ~/project/akg-factor-bridge
cd ~/project/akg-factor-bridge
docker compose exec -T akg-factor-bridge python -m build_readiness
```
部署、八套测试和只读核验日志分别为 `~/akg_bridge_logs/readiness-deploy-20261019.log`、
`readiness-tests-20261019.log`、`readiness-live-20261019.txt`。
规则登记桥决定台账 074。
## 2026-10-19 北京时间 10:07:补齐来源后的恢复判收
本节更新上一节“外部数据仍缺”的状态,保留此前排查事实。
用户已由外部系统手工补齐两路数据。
资金流最新日 10-16 共 5215 行。
热度最新日 10-16 共 5209 行,批次 116。
首次复核时热度尚未到达,第二次复核通过后才继续发布。
外部任务为何漏采及其自动补偿仍属外部系统待核查范围。
178 于北京时间 09:55 补同步资金流并扫描。
热度到齐后 09:59:48—09:59:56 再次完整同步及扫描。
个股快照 3824 行,热点 40 条,传导候选 25 条、未动成员 286 行。
扫描日和实际行情日均为 10-16。
一致预期实际观察日为 10-19,1819 行,不回写成盘前可知历史。
两个扫描均禁用可选模型旁批,没有新造个股评析。
源恢复日志在 178 `~/akg_logs/source-recovery-20261019.log`。
恢复前补齐首版历史边界,桥功能提交 `1139b9c` 已生效。
首版若已到北京时间 09:30,标为 recovery,原因“数据恢复后补发”。
首个完整版本指针仍固定,但该样本排除晨版效果统计。
实际 PMS 消费记录仍按真实发生时刻独立追溯。
本地版本契约 18 例通过,候选镜像九套禁网回归全部通过。
桥于 09:58:32 再次重建,镜像为
`sha256:358966226d3780f75c84c0a72fa594faf34dd64beca4d9b03292066bab32e8f4`。
回退镜像 `akg-factor-bridge-rollback:before-recovery-20261019`。
两次部署及恢复发布后,原有全部计划归档和入口哈希均不变。
规则登记桥台账 075。
使用既有鉴权入口补跑 build、plan、regime-append。
任务 `395d21ff-64cb-43d8-a610-5c6cbcdc7ec4` 于 10:00:28 受理。
没有执行 push-pool,也没有触发额外模型扫描或人工交易。
10:01:34 完成首版,10:01:53 完成区制追加。
首版截止为 10:00:41.991154,明确属于盘中恢复。
首版 ID 为 `2026-10-16_61a3f192cf15630f3d0ce80f3d1aedefa5707dfa87ba89635537cbfa6dca838c`。
含区制的版本 ID 为 `2026-10-16_0d5d43bcfc2b1780e18b7c9a067b9924f82d26279750fb5f693f4a01c332f739`。
区制版生成时间 10:01:48,实际完成发布及写派生文件为 10:01:53。
主榜 558 行,观察 663 行,32 路固定输入,无来源读取错误。
全量研究名次连续、股票唯一,输入和参数指纹匹配。
最新、按日期、固定版本三种查询一致。
区制为 OK,保留实际弱势读数,不调阈值。
155 PMS 于 10:02:47 写入 received 86。
10:03:00 正常 intraday_exec 任务启动,10:03:02 写入 consumed 87。
实际自主候选 10 只,名次 1—10,与消费名册和指纹一致。
首三只为 601126.SH、300274.SZ、002812.SZ,仅用于顺序核验。
从区制版生成至实际消费 74 秒。
10:03:57 独立只读取数核验,计划日 10-16,日龄 1,通过原时效保护。
10:05:13 原 XXL 137 自然检查 unchanged,成功回调。
仍为两个完整版本,无无变化重复发布。
没有把页面读取当作实际消费,也未为验收采纳提议或制造交易。
PMS 保持 ws、OPEN propose_only、提议重核 True、过期上限 1。
桥传导排序、PMS 上游排序 False 与质地排序 True 保持。
档位、仓位、交易时段和信号优先规则未改。
PMS 本轮没有重建,188 真实 PMS 未操作。
10:03 正常成交回放日志对账差异 0,severity=OK。
历史错账和无法还原项仍以 10-16 交接为准,本轮不扩张修复声明。
完整核验文件在 155 `~/akg_bridge_logs/recovery-contract-20261019.json`。
实际消费核验在 `~/pms_logs/recovery-consumption-20261019.json`。
恢复部署和九套测试日志为 `recovery-deploy-20261019.log`、`recovery-tests-20261019.log`。
只读命令 `python -m build_readiness` 现在预期退出 0,显示 2026-10-16 日期已对齐。
本轮故障恢复判收完成。既有五分钟业务任务继续运行。
不另加五日模拟观察,已暂停的 Codex 心跳保持暂停。
## 2026-10-19 14:30 买卖方向冲突修复与部署判收
用户要求立即修复科士达买入与清仓并存,并检查其他流程。
只操作155模拟PMS。178和桥本轮仅同步文档,188未操作。
修复前科士达旧建仓600股、累计成交400股,仍有200股未执行。
09:51择时系统95%置信度卖出触发清仓400股,09:52卖出200股。
剩余200股为当日买入,可卖为零。三个真实子委托均已成交。
页面把父指令DISPATCHED都写为已挂单,导致误解。
14:10检查全量活跃指令,只有科士达存在同票买卖重叠。
修复覆盖命令、信号、技术面离场、人工采纳和跟踪止盈的清仓入口。
完整清仓统一停止旧买入指令、买入提议和未解锁批次。
普通减仓期间暂停买入发出,不永久取消建仓或策略。
T0_ROUND自身配对不误判为清仓,外部完整清仓仍终止其原买入安排。
停止依据追加到动作账本,避免并发旧进度覆盖后恢复买入。
下发进度回写不得把终态指令重新改回DISPATCHED。
出口先处理撤单,认领排除待撤委托,发送前重查来源及方向。
旧卖出理由的audit_reason和component_scores.reason现可透传。
历史已落账的泛化理由不伪造回填。
人工清仓补查:T+1可卖量为零时仍保留清仓任务。
数量不超过用户确认量与当前持仓量,实际出手仍受可卖量约束。
当前已归零时不再生成卖单,但会停止旧买入。
普通减仓数量口径保持。
正式规格见同仓《开发规格_买卖方向冲突修复_2026-10-19.md》。
最终功能提交28053f3,包含fad1bb1。
24项专项与45批本地配置隔离禁网测试通过。
最终候选镜像45批在--network none下通过,包含三页面守卫。
原版本的五项行为反例在离线副本中全部失败,修复版本通过。
本地Chrome使用接口替身渲染,等待可卖、等待下一批显示正常,页面错误零。
生产读数对应清仓等待可卖、旧买入已撤销。
登录后的生产浏览器会话未在本轮直接操作,不将替身渲染充作该项验收。
首版于14:19:39统一重建四容器,正常14:20调度完成旧买入收尾。
最终补修于14:27:22再次统一重建web、worker、beat、ws。
最终镜像sha256:06493afa19ec4cd61d07b7834472a11c550d0ec0a341e251dcdb64626a4139c0。
回退镜像pms:rollback-before-conflict-20261019保留本轮前版本。
另有pms:rollback-before-manual-exit-20261019保留第一次修复版本。
155的/app仍绑定挂载,回退要先反向提交并git pull,再重建四容器。
回退不得恢复已经撤销的买入指令或删除真实成交与停止记录。
服务器本地scripts/deploy.sh哈希前后一致,未覆盖其他本地文件。
14:20:05,正常intraday_exec将INS_20261016_002518SZ_OPEN_001置CANCELLED。
目标600、实成400保持。停止依据6912,撤销记录6913,均记system。
INS_20261019_002518SZ_EXIT_95100仍400/200,显示等待可卖。
14:21及14:28正常调度保持,无重复停止记录、无新委托。
14:28:20全量比较:15项核验参数相同,21条持仓账务字段相同,283条批次账相同。
93条父指令执行数量相同,状态仅科士达旧买入由DISPATCHED变CANCELLED。
七条历史暂停指令未恢复。没有改写费用、历史峰值、旧批次或净值。
QMT ONLINE,resync_flag=0,last_error为空,水位1299667。
健康status=ok、db_ok=true、日历未降级;正常回放对账diffs=0、severity=OK。
93行指令列表与实际进展只读取数耗时0.344秒。
写前备份155 ~/pms_logs/conflict-predeploy-20261019.json,SHA256
fb5edeccc4712de12e8e702d196f7ebfdee573055ae494085a62c42fec7235f8。
最终只读快照conflict-final-20261019.json,SHA256
881a4f3a39f5f2b9f4ec5088722bc89a552ce65d9f4b820800e598bfcdc1d8dd。
原始证据kstar-conflict-20261019-1402.json、kstar-signal-20261019.json仍保留。
构建与测试日志conflict-final-build-20261019.log、conflict-final-tests-20261019.log。
桥台账076保存决定。用户原有未提交文档与探针保留。
人工T+1确认、撤单失败、迟到成交与并发竞态已离线覆盖。
本轮没有自然事件逐项生产复现,不宣称所有边界均真机判收。
未采纳提议或制造交易。交易时段、择时阈值、仓位档位、排序与自动修订安排保持。
不增加模拟观察期,也不重启已暂停的Codex心跳。
## 2026-10-20 已批准调整:提议先准备后采纳
用户批准完整研究、数量与规则计算移到既有后台扫描。
本节替代采纳请求内重跑研判的实现。采纳只核对已经展示的数量与必要条件。
研究变化交后台重评,组合与参数变化复用同依据的研判。
明确否决撤下,暂不可用显示准备状态。更新后的可见内容须再次确认。
准备结果与审计原子发布,并与人工确认互斥。
采纳保留原消费凭据,最新只读核验另记,不生成虚假消费。
交易时段、到期规则、策略阈值、排序、择时与下发终检不变。
功能1df17e6已于11:35在155四容器生效。
54专项、46批本地及候选镜像禁网测试通过。
三页面守卫、本地替身交互与登录后的生产右栏只读核验通过。
15项参数、21条持仓账务、283条批次账、94条指令进度均未变化。
QMT在线,对账正常。当前无待确认提议,自然采纳尚未判收。
完整规格见《开发规格_提议先准备后采纳_2026-10-20.md》。
实测见同名交接11:40节。
## 2026-10-21 采纳链路补充及部署判收
普通建仓采纳改读完整发布计划的逐票接口,避免3MB整榜超出3秒限制。
短暂来源失败拒绝当次动作但保留准备内容,恢复不重扫。固定数量仍可执行时,不因组合现金漂移重写确认内容。
已知研究修订、资格失效、风险与参数变化继续由原规则阻断或重新准备。
采纳状态、动作审计和建仓指令同事务保存。失败回滚,重复请求返回原指令。
该补充优先于旧版“来源失败一律转准备中”及“组合变化一律重算”的实现描述。
桥2192a2c于10:13:24生效,PMS888a208于10:17:23四服务统一生效。
45组桥契约、47批PMS禁网回归及三页面守卫通过,候选镜像同样通过。
逐票0.208—0.326秒,真实建议只读预检1.085—1.227秒,未代用户采纳。
正常自然网格成交改变组合后,盛弘股份500股原确认标识保持,当前闸门通过。
页面按钮和确认框已登录核验,浏览器无错误。备份、前后账务及回退见交接10:25节。

View File

@ -0,0 +1,78 @@
# 账户总资产与可用资金口径核查
2026-10-26,北京时间。用户提供 16:07 页面截图,账户总资产约 193.63 万元,可用资金约 345.09 万元。本次先在 155 模拟仓只读核查,再在开发机修复和验证。修复 f90d5e7 已于 16:44 部署到 155,运行判收见文末。没有操作 188,没有改动账户或账本记录。
## 真机证据与原因
16:08:45 读取资金快照 seq=1426810,接收时间原值为 2026-10-26 16:07:13。该列由容器 datetime.now() 写入,按北京时间解读。账户值如下。
| 项目 | 金额(元) | 来源 |
| --- | ---: | --- |
| 总资产 | 1,936,261.62 | QMT total_asset |
| 可用余额 | 1,806,071.62 | QMT available_cash |
| 冻结资金 | 0.00 | QMT frozen_cash |
| 账户持仓估值 | 130,190.00 | QMT market_value |
| 卖出回笼统计 | 1,644,823.13 | QMT sell_return_today |
| 页面错误可用值 | 3,450,894.75 | PMS 将可用余额与回笼统计相加 |
账户可用余额加账户持仓估值,恰好等于账户总资产。回笼资金已经体现在可用余额中,PMS 又加一次,造成 1,644,823.13 元重复计入。这是 portfolio.cash_view 的计算错误,不是现金账多写了一笔。该加法来自 2026-07-30 提交 0ab611b,2026-08-06 DEVLOG 已记“有卖出时再核实”的悬项,原单测也把重复加款钉成了正确结果。今天选股切换没有修改这段计算。
同一个 cash_avail 同时用于页面、建仓资金封顶及规则闸,所以不能只改页面减去差额。需要修正统一资金入口,确保买入校验直接使用账户可用余额。不得用“总资产减行情市值”反算现金,也不改运行总规模来掩盖问题。
第二处是估值来源混用。PMS 15:00 收盘分钟行情与 QMT 同时返回的持仓价格如下,数量三票全部一致。
| 股票 | 数量 | PMS 收盘行情 | QMT 持仓价格 | QMT 市值减 PMS 市值 |
| --- | ---: | ---: | ---: | ---: |
| 三花智控 002050.SZ | 1,800 | 34.41 | 32.53 | -3,384.00 |
| 科士达 002518.SZ | 400 | 27.49 | 26.14 | -540.00 |
| 厦钨新能 688778.SH | 1,400 | 37.13 | 43.70 | 9,198.00 |
| 合计 | | | | 5,274.00 |
页面持仓市值 124,916 元来自行情,账户估值 130,190 元来自 QMT。账户总资产继续采用 QMT 报告值,两者放在同一排却没有区分来源,因此去掉重复回笼后仍会差 5,274 元。新收到快照只证明通道新鲜,不能证明 QMT 内部的估值行情已更新;本次未进入 QMT 服务核查其价格生成路径,也不能据此把 QMT 总资产改为 PMS 的估算值。
策略仓位 6.25% 的分母是用户设定的 200 万元,计算为 124,916 / 2,000,000,不是按账户总资产计算。这是既有仓位纪律,不随本次账户显示修复改变。
## 已准备的修复
portfolio.cash_view 直接采用 available_cash,忽略回笼统计对余额的加成;账户市值和冻结资金随同一资金快照透传给总览。顶部前三项统一展示账户总资产、账户可用资金和账户持仓市值,增加来源说明。原仓位标签改为策略仓位,说明分母与估值来源。持仓明细、综合盈亏、组合风控继续使用原行情估值。
修正接口契约中造成误解的说明及不闭合的示例数值。ws_codec 和规则闸注释同步澄清。新增 batch47 九例,覆盖真实异常快照、买不起的单不能靠重复回笼过闸、回笼已在可用余额时可以再投、可用为零、冻结不重复扣、缺项、过期及两套估值互不污染。原 wiring 中的错误断言一并纠正。
开发机运行以下验证,预期为 ALL SUITES PASS,实际 51 批、1174 例通过,含三道页面护栏。浏览器使用独立无登录测试上下文访问本地固定数据预览,1920 与 1280 宽度核对卡片数值、说明和窄栏换行,无页面脚本错误。预览不连接业务服务。
```bash
/tmp/pms-junda-20261026/venv312/bin/python scripts/run_tests.py
```
真机见过的是原因、原始资金和两套估值。修复提交时的线上判收为未判收;当时没有推送或部署新补丁,没有改库、调参或重启服务。部署前需按 AGENTS.md 确认本次服务器操作范围,在 155 使用提交归档构建匹配镜像并断网回归,再于无在途、无待入账回报时 force-recreate 四个 PMS 服务。188 不在本次范围。QMT 内部估值价格与 sell_return_today 的统计期间仍需下游进一步核实,本次修复不依赖这些统计作为可用余额。
## 155 部署与运行判收
用户明确授权后,修复 f90d5e78a0841b3bcdaf9194f32fd5b109757c95 已推送到既有 origin/main 和 codex/account-funds-20261026。部署只涉及 155 模拟仓。没有改运行参数、建表或执行数据修补,没有操作桥或 188。
在 155 的私有临时目录展开 git archive 提交归档,使用现有运行镜像的依赖层重新构建候选镜像。构建替换全部 /app 源码,未混入开发机未提交研究或服务器本地文件。没有依赖变更。以下命令在 155 运行,没有注入业务环境或挂载工作树,预期输出 ALL SUITES PASS,实际完整 51 批、1174 例通过,包含九例资金回归及三道页面护栏。
```bash
# 155 模拟仓服务器。
docker run --rm --network none pms:funds-f90d5e7 python scripts/run_tests.py
```
16:44:05 暂停页面与两个调度进程后再次核对,出口无在途委托、收件箱无待入账回报、QMT 在线、三只持仓数量一致。正式工作树从 e7242f6 快进到 f90d5e7,将已测候选镜像作为运行镜像,使用 docker compose up -d --no-build --force-recreate 重建四个 PMS 服务。四者于北京时间 16:44:06 启动,运行镜像均为 sha256:1ba8087ea579e8fcfd48e842635cc5794b32ddc1b335d05bc17938573cc7f42d,重启计数为零。旧镜像基线、提交归档、运行镜像及已跟踪源码分别核对;新镜像与归档、服务器已跟踪 Python 源码指纹均为 f95d7c112d3f,不以挂载后的指纹一致代替镜像检查。
16:44:37 新代码读取资金快照 seq1427270,接收时间原值为 16:44:10,按容器北京时间解释。总览的现金为 1,806,071.62 元,账户市值为 130,190 元,总资产为 1,936,261.62 元,冻结资金为零,等式闭合。卖出回笼统计仍为 1,644,823.13 元,已不再重复加款。行情估值 124,916 元、策略仓位 6.25%、持仓盈亏 -10,746.80 元均保持原口径。
前后比对 232 项有效运行参数,全部不变。24 行持仓的数量、成本等核对字段,344 行批次账,1270 条成交回报以及资金流水摘要均不变。资金流水表原本为空,本次没有补造记录。QMT 上行水位继续推进,无重同步标记,无在途和待入账回报。四服务启动日志没有 ERROR、CRITICAL 或 Traceback。网页 /health 返回 ok,数据库及交易日历正常,容器健康为 healthy。实际 HTTP 返回的页面文件摘要与提交一致,说明部署后的页面内容已更新;浏览器布局验收使用前文记录的本地隔离预览,本次未使用真实登录会话做浏览器验收。
以下复核命令只在 155 运行,预期健康为 ok,四服务均为 running 且镜像一致、重启计数为零,只读核对脚本正常退出并打印无在途、无待入账和账实数量一致。
```bash
# 155 模拟仓服务器。
curl -fsS http://127.0.0.1:38100/health
docker inspect pms-web pms-worker pms-beat pms-ws --format '{{.Name}} {{.State.Status}} {{.Image}} {{.RestartCount}}'
docker exec -e PYTHONPATH=/app -i pms-web python - < /home/factor/pms_logs/funds-fix-20261026/deploy-check.py
```
运行态判收为真机见过。私有证据留在 /home/factor/pms_logs/funds-fix-20261026,包含断网回归、前后数据摘要、参数摘要、队列核对、实际页面文件及启动日志。服务器原有 deploy.sh 可执行位修改和未跟踪文件保留。回退引用为 codex/pre-funds-20261026,旧镜像为 pms:rollback-before-funds-20261026;如需回退,必须同时恢复相应源码与镜像再重建四服务,不能只换镜像,因为 155 有源码挂载。本次没有执行回退。
尚未判收的是 QMT 估值价格与 PMS 行情相差 5,274 元的上游生成原因,以及其回笼统计的时间范围。新总览统一了账户快照口径,没有把 QMT 估值标成最新行情。此修复没有人为发单,后续自然交易的实际资金拦截行为仍待发生时核对。

View File

@ -0,0 +1,147 @@
# 钧达股份成本与重复下发排查
记录日期为 2026 年 10 月 26 日,北京时间。对象为 155 模拟仓的钧达股份,代码为 002865.SZ。开发与运行基线为 `2e5bc56`。188 真实仓未操作。
## 结论与处理边界
截图中的 5.053 元不是买入均价,而是扣除卖出已实现收益后的摊薄成本。这个数可以由逐笔成交完整复算。页面却把它称为成本,并在说明中写成买入价的加权平均,还把对应收益率称为浮动盈亏,存在明确的口径误导。
更重要的问题发生在执行层。10 月 23 日,一条计划卖出 600 股的追踪止盈指令,实际下发了两笔各 600 股的子委托,两笔均真实成交。这使 1300 股降至 100 股。重复记账不是本次异常的原因。
13:32 的新鲜 QMT 持仓快照确认仍有 100 股,券商成本为 32.8176 元。因此不能删除 PMS 持仓、买入批次或成交回报来隐藏该行。这样的删除会让账本与实际持仓不符,也会破坏后续卖出认领。应保留真实交易历史,修复重复下发与显示口径;用户已经下达的清仓命令成交、回报入账、持仓归零后,该行才应自然退出当前持仓。
截至 13:40,只读核对未发现该清仓命令成交。本文没有授权或执行额外买卖,也没有通过参数或数据库改写加速已有命令。
## 真机证据
下列时间来自 PMS 容器日志正文和本服务用 `datetime.now()` 写入的 DATETIME 字段,均直接按北京时间记录,不额外加八小时。
| 时间 | 事件 |
|---|---|
| 10 月 16 日 09:35 | 宏观择时发出 `CMD_20261016_0001` 升仓命令。股汇对冲指数为 -22.4,进入偏冷区第一天,拟增加总规模的 4.45% |
| 10 月 19 日 | 钧达股份首笔买入子委托成交 700 股 |
| 10 月 20 日 | 第二笔买入子委托成交 600 股,累计买入 1300 股。余下未解锁的补足、加仓方案在命令完成时取消 |
| 10 月 22 日 09:40 | 自动挂载追踪止盈。热度 0.847 高于 0.80,同时命中明确吸筹,按规则优先选择止盈。参数为回撤 5%、卖出 50% |
| 10 月 23 日 09:34:01 | 高点 36.95 元回落至 35.00 元,回撤约 5.3%。生成父指令 `STR20261023093401_002865SZ_t`,目标卖出 600 股,首笔子委托入队 |
| 10 月 23 日 09:34:58 | 首笔子委托终态为 FILLED,累计成交 600 股 |
| 10 月 23 日 09:35:02 | 执行任务再次下发第二笔 600 股子委托。日志显示这一轮执行任务先于回放任务完成 |
| 10 月 23 日 09:36:33 | 第二笔子委托终态为 FILLED,累计成交 600 股 |
| 10 月 23 日 09:37 | 父指令累计成交更新为 1200 股,超过目标 600 股 |
| 10 月 26 日 10:39:19 | 用户从交易员视图下达 `CMD_20261026_0001`,清仓剩余 100 股,执行窗口为三个交易日,到 10 月 28 日 |
| 10 月 26 日 10:39:20 | 该清仓命令取消原追踪止盈策略 |
| 10 月 26 日 13:40 | 清仓指令仍在等待。最近择时理由为现价 33.81 元低于卖出区间下沿 34.58 元 |
本次检查到 18 笔不同成交编号的逐笔回报,其中 9 笔买入、9 笔卖出,均已入账。两笔卖出子委托分别有 4 笔和 5 笔成交回报。买入批次与核销结果相符,没有需要删掉的重复批次。
## 成本复算
| 项目 | 金额或数量 |
|---|---:|
| 累计买入 | 1300 股,42,663.04 元 |
| 累计卖出 | 1200 股,42,157.74 元 |
| 剩余数量 | 100 股 |
| 剩余批次原始买入金额 | 3,318.00 元,即每股 33.18 元 |
| 已卖股份的已实现收益 | 2,812.70 元 |
| 尚未收回的买入本金 | 505.30 元 |
| PMS 摊薄成本 | 505.30 ÷ 100 = 5.053 元 |
| QMT 快照中的券商成本 | 每股 32.8176 元 |
原始成交回报没有提供手续费,以上为按成交金额复算的口径,不应称为扣费后收益。
截图现价 33.79 元除以摊薄成本 5.053 元,再减一,确实得到约 568.71%。这个比例包含了此前卖出赚取的收益,而且分母已经被减仓显著缩小,不表示最后这 100 股自身上涨了 568.71%。若只比较剩余批次的 33.18 元买入价,其未实现涨幅约为 1.84%。券商平均成本与账本按批次核销后的剩余买价也不是同一口径。
修复页面时将成本列明确标为“摊薄成本”,把对应“浮动盈亏”改为“综合盈亏”,并说明已实现收益和剩余股数的影响。账本摊薄成本与安全垫公式保持原业务口径。
## 根因与修复
`executor.run_tick` 原先用父指令的 `qty - exec_qty` 算剩余数量。紧急指令或窗口末日指令只扣未终态子单占用的数量。这里隐含了一个不成立的假设:子单一旦终态成交,父指令的累计成交量已经完成更新。
实际存在两个独立任务。QMT 通道进程先更新出口子委托状态;账本回放任务之后才认领逐笔成交、更新父指令。10 月 23 日 09:35,执行任务先于回放任务运行,于是同时读到“首单已成交、不在途”和“父指令尚未成交”。此前已卖出的 600 股被错误地当成剩余额度。
账户可卖量保护无法阻止这一错误,因为当时账户还有足够股票可卖。追踪止盈自身的单次触发保护也无法阻止,因为重复发生在同一父指令的子委托层。
修复增加父指令总量检查。读取这个父指令在出口表的全部子委托,包括前一天的委托和已经入出口、尚未写回进度的委托。已成交数量取“父指令已入账数量”和“子委托累计成交数量”的较大值,再预留未终态子委托尚可成交的数量。余量不足时等待,部分撤单只释放未成交部分,读取失败时禁止新下发。此检查不改写成交、不替代账本回放、不自动补买已经多卖的股票。
## 当前选股与交易逻辑
本节参数为 155 在 10 月 26 日 13:40 的实读值。总操作规模为 200 万元,总仓位上限为 70%,单股上限为 8%,默认单股目标为 6%,最多 40 只,同一行业最多 4 只、40% 仓位。实际执行还受可用资金、在途承诺、申报数量和人工命令约束。
### 选股
主要候选来源是上游选股计划接口,取前 50 名,当前只允许“强传导”档。上游排序开关关闭,仍由本地的基本面质地分桶等逻辑组织候选,不能把上游最新研究排序当成当前下单顺序。盘中转多信号可以提高候选优先级,但收到买入信号本身不会直接下单。
基本面、技术面、择时三方面合议决定放行、观察或交人工。当前三源合议与技术面增持检查已打开。独立的盘中确认总开关关闭,因此不能宣称当前额外执行了该开关控制的量价确认。进入候选后仍需检查黑名单、已有持仓、在途买卖、组合上限和真实可用资金,并按规则请求决策系统研判。研判不可用时转人工,不由 PMS 自建研判结论。
高股息候选是另一条独立入口,由人工启动后台核验、确认后采纳,不等于已经启动独立的自动高股息建仓任务。
### 建仓与增持
存在命令驱动与自主评估两条入口。用户命令和宏观模块下达的升仓命令会被拆成方案;自主评估则对候选逐只检查。当前宏观模块为自动档,股汇对冲指数可触发总仓位调整。钧达此次买入属于前一条宏观命令路径。
建仓分配比例为底仓 50%、回踩补足 25%、盈利加仓 25%。后两批并非首批成交后立即连续买入。本轮命令完成时,未解锁方案会取消并保留记录,后续增持由动作引擎或新命令决定。
回踩补足要求处于建仓后的 10 个交易日内,摊薄口径亏损浅于 3%、仍未转盈、未跌破支撑,且尚未补足过。盈利加仓要求安全垫至少 3%,创五日新高或站上压力位,距上次加仓至少两个交易日,且不明显偏离五日均线。亏损补仓在 -8% 和 -15% 两档进入评估,最多为底仓的 50%,不是跌到阈值就无条件买入。
“仅提议”不是当前全系统的最终权限结论。虽然新建仓档位为 `propose_only`,但系统自决为 `full`,试探仓自动采纳打开,每天自动新建仓最多 3 只。符合合议、真实研判应答和风险约束的候选仍可以自动采纳;风险、缺少读数或无法研判会转人工。深亏补仓也可能在研判明确通过且把握度至少 60 时自动采纳。
执行层每分钟检查一次,择时优先委托决策系统,实现 A 不可用时回退本地保守规则。当前一笔子委托通常有效 10 分钟,命令窗口通常为三个交易日。命令在窗口末日有收尾安排,但仍受停牌、涨跌停、可卖数量等检查约束,不能承诺必成交。自主买入到期不会被强制追买。
### 减仓与清仓
人工清仓命令优先,先终止同股旧买入安排并取消策略,再生成卖出指令。达到用户目标价时,当前系统自决档可自动清仓。人工止损价当前只用于提醒和留痕,不能把它当成必然自动卖出的硬止损。
没有独立策略接管的股票,还会评估保垫减仓与技术面离场。安全垫峰值达到 6%、之后回吐一半时,保垫规则拟减持约三分之一。新近技术面转空时,确认转空清仓可卖部分,未确认则减持约三分之一,同一次翻向不重复处理。
决策系统卖出信号的置信度低于 60% 时通常只留痕,60% 至不足 85% 时进入减持提议,达到 85% 时可进入清仓流程。挂有独立策略的股票另有冲突处理,不能把这个阈值理解为所有股票无条件立即卖出。研究证据走弱的自动减持开关当前关闭。
### 网格、追踪止盈与做 T
| 策略 | 挂载与触发条件 | 交易行为 |
|---|---|---|
| 网格 | 每交易日 09:40 检查。明确吸筹且结论不陈旧,已有持仓且通过其他约束时可挂载 | 当前自动档距为中枢价的 2%。向下穿越中枢以下的新档位买入,向上穿越对应档位卖出已买网格股。跌破下界停买,买入暂停不阻止卖出,受预算、真实网格股和 T+1 可卖量约束 |
| 追踪止盈 | 热度至少 0.80 且有正安全垫时可挂载。与明确吸筹同时满足时优先止盈 | 默认安全垫达到 3% 后启动,从持续更新的最高价回撤 5% 时拟卖出一半。相同高点只触发一轮;需要再创新高后才允许下一轮回撤卖出 |
| 网格转追踪止盈 | 自动网格向上突破区间且热度达标,并通过接力检查 | 收起网格,改由追踪止盈管理 |
| 特殊试探仓止盈 | 弱基本面但技术面偏多的特定入场标记 | 更紧的回撤保护,参数应读对应策略记录,不套用普通追踪止盈的 5% |
| 趋势止损 | 追踪止盈已有有效 SAR 趋势线,09:45 后跌破其缓冲线 | 可以清仓,不必等待先盈利达到启动线。无趋势线时不凭空判断跌破 |
| 做 T | 需要明确挂载做 T 策略 | 支持先买后卖、先卖后买及尾盘收口。当前没有活动做 T 策略 |
### 实际策略记录
| 股票 | 实际记录 | 当前情况 |
|---|---|---|
| 三花智控 002050.SZ | 10 月 21 日 09:40 因明确吸筹挂载网格。区间 30.353 至 34.38 元,中枢 32.98 元,档距 2%,每档最多 600 股,投入上限 65,159 元 | 13:32 为唯一 ACTIVE 策略。两个保留档位分别有 600 股、300 股,并非每档都满额 |
| 钧达股份 002865.SZ | 10 月 22 日挂载追踪止盈,10 月 23 日触发回撤卖出。该次父指令应卖 600 股,却因本次缺陷实际卖 1200 股 | 10 月 26 日人工清仓命令已取消策略,剩余 100 股等待原清仓指令执行 |
| 厦钨新能 688778.SH | 9 月 18 日挂载网格;10 月 9 日 09:40,价格 47.44 元突破网格上沿 45.955 元且热度 0.91,转为追踪止盈 | 追踪止盈已于 10 月 12 日取消,当前不是活动网格或追踪止盈 |
| 科士达 002518.SZ | 当前有一条 600 股建仓指令,已成交 400 股,剩余 200 股因买入价格条件未到而等待 | 当前没有活动独立策略 |
挂有独立策略的股票通常由策略管理增减持,通用动作引擎让路,但用户目标价和明确清仓命令仍有优先权。无策略的股票并非无人管理,仍经过通用动作、信号与命令处理。
## 验证与部署状态
调查证据与修复后的运行态判收均为真机见过。修复已部署 155,详细结果见下节。新行情下防止重复下发的真实成交事件尚未判收。
新增第 45 批隔离单测,共 16 例,覆盖末日已成交未回放、部分成交后撤单、跨日委托、遗漏进度、查询失败、买入同类风险、终态缺累计数量、影子模式等情形。用相同测试回放旧提交,16 例中 13 例失败;修复后全部通过,包含真实追踪止盈择时与规则检查路径。
开发机使用独立 Python 3.12 环境,经 `scripts/run_tests.py` 配置隔离、禁止联网,全量 49 批、1154 例通过,输出 `ALL SUITES PASS`。其中三道页面守卫通过,`git diff --check` 通过。全量回归还暴露第 44 批测试先按真实日历生成样本、再把日历替换为每天交易的桩,周一因此失败;已统一样本生成与核验的日历,并统一使用北京时间。这是测试准备的修正,没有改变高股息生产准入规则。
本机会话未提供可连接的浏览器,页面完成三道静态检查及服务器实际响应内容核对,视觉验收未判收。开发机日志位于 `/tmp/pms-junda-20261026/tests-all.log`,原始只读取证与旧版本复现同存该临时目录,关键结论已写入本文。
本次没有数据库结构变更,没有需要批量删除的错误记录。已发生的多卖不能通过删成交或凭空加回 600 股修复。历史超额成交列表还有旧记录,不能仅凭 `exec_qty > qty` 就归为本次同一原因或批量重写。
## 155 部署判收
用户已明确批准将 `47bcea5` 推送至原代码仓库,并在断网回归通过、无在途委托和待入账回报时部署 155。代码已推送 `main` 和 `codex/junda-order-cap-20261026`,服务器从 `2e5bc56` 快进至 `47bcea58bd854ecb4d1b88d5f9af03056750c306`。
先将提交快照展开至服务器临时目录,按原 Dockerfile 构建候选镜像,再用没有业务环境变量、没有源码挂载、`--network none` 的临时容器执行全量回归。Python 3.11.9 下 49 批、1154 例通过。镜像内代码指纹为 `cd17b9c2bcea`,与部署后运行容器一致。
部署前在正常运行与暂停调度、执行任务之后分别检查队列,均无在途委托、无待入账回报。保留回退源码引用与旧镜像后,四个 PMS 服务均通过 `up -d --force-recreate` 重建,于北京时间 14:00:41 启动。没有运行建表,没有写运行参数或业务修复 SQL,没有操作 188。服务器原有本地文件及 `scripts/deploy.sh` 可执行位保持不变。
新镜像为 `sha256:8c446286b38d52e16e6c20860bdd881dada8b3e1add16bb288b27112a572d767`。14:01 核对四服务运行、重启次数均为零;`make health` 返回 `status=ok`、`db_ok=true`,交易日历正常。QMT 为 ONLINE,心跳新鲜,已收与已确认水位相同且继续推进,无重同步标记。调度执行与成交回放均已运行一轮且无错误,启动后的四服务日志未见 ERROR、CRITICAL 或 Traceback。
部署前后所核对的 23 项运行参数完全一致。四只实际持仓的数量、摊薄成本完全一致,并与 QMT 数量相符:三花智控 1800 股、科士达 400 股、钧达股份 100 股、厦钨新能 1400 股。没有为了隐藏钧达异常而改账或生成额外委托。
14:03 只读调用新版本数量检查,把历史父指令的入账量在内存中设为零模拟延迟,返回可下发量为零,没有写数据库。服务器实际页面响应已包含新的“摊薄成本”和“综合盈亏”说明。钧达已有清仓指令仍为 PROPOSED,成交量为零,最新择时理由为现价 33.66 元未到卖出区间下沿 34.58 元。因此持仓行尚未移除,等待用户原命令正常完成;不把部署成功写成清仓已经完成。
回退源码引用为服务器 `codex/predeploy-47bcea5`,指向 `2e5bc56`;旧镜像标签为 `pms:rollback-20261026-2e5bc56`。155 挂载源码,回退时必须同时恢复源码与镜像再重建服务,不能只换镜像。没有执行回退或逆向改账。
服务器构建、断网回归和切换前检查日志保存在 `/tmp/pms-release-47bcea5.t6MVSP/`。开发机的 `server-tests.log`、`cutover.log`、`preflight.json`、`postflight.json` 与 `health.txt` 保存在 `/tmp/pms-junda-20261026/`。这些是临时证据,关键判收结果以上文为准。

View File

@ -0,0 +1,131 @@
# 高股息候选接入PMS开发规格
2026-10-22,北京时间。用户要求补齐研究到建仓的缺失链路。
## 目标与范围
研究结果可进入PMS独立高股息候选区。
用户发起后,由后台准备建仓建议,完成后使用现有采纳入口。
首版按人工发起设计,自动扫描接入方式的问题仍等待用户回复。
不会因为名单中出现股票,就自动生成买入指令。
只部署155桥和模拟PMS,178如无契约需要则不改,188不操作。
基座保存事实与专项研究,桥决定高股息候选资格。
PMS继续负责组合、数量、合议、研判和执行。
沿用现有仓位、资金、行业、黑名单、买卖冲突与择时约束。
原每日计划候选、排序和自主档位不变。
## 候选资格
资格来自确定性检查,不把自然语言直接翻译成交易条件。
必须同时满足:名称及上市状态明确,非ST及退市名称,滚动股息不低于5%。
公司质地为好,评析覆盖应披露材料期且在本季度完成核验。
月度财务材料与分红专项研究已完成复查,数据日为上一完整交易日。
专项结论为有支持,六项问题均有支持、引用和原文,无未解决校验警告。
关键资料缺失、来源冲突、研究更新中或读取失败均不进入可发起名单。
页面仍展示研究中的公司和明确缺口,不能伪造合格样本。
有支持只允许进入建仓评估,不表示已获投资批准。
## 对外契约与留痕
桥新增独立JSON查询,只读取完整研究归档,不在查询时调用模型或采集材料。
返回数据日、检查时刻、固定研究版本、准入规则版本及逐票资格原因。
按代码稳定排序,不新增收益评分,不改变原计划版本或主榜名次。
旧研究归档缺必要字段时保持不可发起,不能默认通过。
PMS通过桥消费,复用计划快照JSON记录实际消费。
使用独立来源标识,不能混入每日计划名册变化与历史绩效。
提议、动作账本和指令进度保留来源及固定研究引用。
详情中可追溯技术字段,操作卡只显示建议、依据和风险。
## 人工发起与后台准备
发起接口只接收股票代码和页面所见研究版本,不接受客户端仓位或合格标记。
服务器重读当前资格,拒绝过期来源、黑名单、已持仓及冲突中的股票。
同日同票请求复用已有提议,不因双击生成多条建议。
先记录准备请求,复用原交易时段扫描完成组合检查、数量与研判。
接口请求内不调用研判模型,不创建买入指令。
准备中不能采纳。后台失败保留原因,明确资格失效时撤下。
准备完成后沿用现有确认内容标识、快速核验与原子采纳事务。
仅名次、无关公司更新或报价变化不重问模型。
当前公司的研究或资格变化交后台处理,不能带旧批准继续执行。
高股息来源即使旧版本核验开关关闭,也不得跳过其必要来源核验。
## 验收预判
1. 真实名单预计零家可发起。丽珠、海尔仍为证据不足,不放宽规则。
2. 合成完整材料的公司可进入候选;缺任一关键条件均给出具体原因。
3. 失效、未来日期、读取失败、跨月和跨季度不沿用旧资格。
4. 发起请求零模型、零指令,重复及并发请求不重复入队。
5. 后台复用既有数量、合议及研判,原资金、行业和买卖冲突照常拦截。
6. 采纳使用原快速检查与事务,研究变化不能沿用旧批准,旧来源不受影响。
7. 真实部署只做只读核验,不生成假提议、不调用模型制造合格研究、不制造交易。
8. PMS使用配置隔离且禁网的测试入口,桥使用替身依赖。
9. 运行三道页面守卫,浏览器核对候选、缺口与准备反馈。
## 偏差发现与撤销
部署前备份源码、运行参数和必要账务读数,核对实例身份。
旧计划归档与策略参数保持,部署后核对健康、通道和账务。
无真实合格公司时,完整自然采纳与成交单列未判收。
若出现问题,停止高股息发起入口并保留研究与消费历史。
回退采用开发机反向提交、服务器git pull,再重建155四服务。
不得仅换镜像,不删除提议或真实成交,不恢复历史暂停指令。
## 开发者参考
桥用纯函数装配独立候选契约,接口仅核日期与归档读取状态。
PMS新增来源适配器,输出已有建仓引擎所需形状。
研究依据比较仅对该来源扩展,避免改变已有提议的比较结果。
后台准备和人工确认统一分派到原来源适配器,避免重新读原主榜误撤下。
复用现有表与调度,不新增并行研判栈或第二套采纳事务。
## 2026-10-22 10:40 本地实现与验证
按独立人工发起完成实现。未收到自主扫描选项的调整。
桥增加 `/research/dividend/candidates`,逐票查询保持全量序号。
PMS增加 `/api/dividend/candidates` 与 `/api/dividend/proposals`。
前者只读,后者仅创建数量为零的准备请求。
原交易时段扫描完成计算,准备结果和审计同事务发布。
普通采纳事务继续复用,不新增表、调度或模型调用入口。
新来源关闭旧计划重核开关时仍须核验自身资料。
当前公司的固定研究变化才重算,不因名次或资料日龄变化重算。
在途事实读取失败不能当作没有在途,高股息请求停止准备。
同日同票重复请求复用已有提议,原自主来源不覆盖人工请求。
已结束建议不因再次点击而复活。
原自主扫描、命令候选与策略参数没有切到高股息来源。
本地桥新增9项离线用例通过。PMS新增24项专项通过。
PMS全量48批隔离禁网回归通过,包含原采纳事务和页面守卫。
后续小幅页面与取数整理已经重跑专项与页面守卫。
生产未部署,本节不构成生产判收。
## 2026-10-22 11:00 部署与判收
用户已明确选择独立候选区,由本人手动发起建仓。
本轮实现和部署保持这一选择,不并入原自主扫描。
桥e860d4b于10:48:46生效。PMS功能03e569e于10:51:01四服务统一生效。
页面ccf194b随后通过源码挂载生效,仅压缩重复缺口与折叠原始记录。
178本轮只同步文档,无运行代码变更。188未操作。
候选镜像桥79项联合用例和六组既有脚本通过,联网尝试零次。
PMS候选镜像48批配置隔离、禁网回归通过,新增24项专项。
最终页面三道守卫通过。真实登录页面核验175条研究记录。
可评估为零,没有准备按钮。详情层次正常,控制台无错误。
不能将目前的零候选说成已跑通真实高股息采纳或成交。
这些路径已有合成完整证据与事务用例,真实自然事件仍待判收。
部署前后19项参数、23条持仓、322条批次完全一致。
108条指令未增减,数量、状态和成交进度一致。
三条指令只由正常任务更新等待或拒绝时刻,业务原因未变。
QMT在线、健康正常,对账diffs为空、severity为OK。
两处原有事实源覆盖差异仍单列,ws_first不变。
新来源读取耗时0.433秒,读取前后消费记录数量不变。
未登录的读取与发起接口均返回401。
旧145份计划文件哈希及桥参数保持不变。
137恢复后10:50自然执行成功,耗时15秒。
本轮未调用模型生成资格,未创建验收提议、指令或交易。
具体镜像、备份、回退和手工验证见同日交接末节。

View File

@ -0,0 +1,341 @@
# 高股息实验首批核查
核查日期:2026-10-21,北京时间。价格固定为2026-10-20收盘。
完成211只口径比对、数据库事实提取和16只研究样本建档。
完成部分公告抽查。尚未完成211只公告级全面审核。
## 本轮结论
这个方向值得继续研究,但原表不能直接作为当前高股息投资名单。
研究重点应是未来普通分红的支付能力,以及价格是否留有余量。
稳定派息记录、经营现金充裕与持续买入资格,是三个不同判断。
原表211行均与供应商上一自然年度股息率字段一致。
其中11行同时与滚动值相同,不能单凭数值区分字段来源。
按供应商近十二个月字段,108只不低于5%,95只低于5%,8只缺值。
这108只仍需公告核查,并非已验证的可持续高股息名单。
字段定义见[每日指标说明](https://tushare.pro/document/2?doc_id=32)。
库内事件重算也不能直接作为正确答案。
格力、海尔及山东出版已有实施公告,库内相应事件仍停在通过阶段。
因此,无合格事件不等于未分红,缺值也不按零收益处理。
送转、股本基数及供应商报告期筛选会形成其他差异。
2025年除息事件重算有140只与原表差异不超过0.02个百分点。
另71只留待核查,差异本身不等于数据错误。
财务指标与现金流表均有203家最新合格报告期只到2026一季度。
6家到2026半年,2家没有合格记录。
这些是数据库覆盖,不是公司尚未披露半年报。
本轮从公告补读了格力、海尔、富安娜和兴业的半年数据。
不能把库内一季度同比当作当前最新经营状况。
## 首批16只研究样本
分组用于覆盖不同经营问题,不代表正式行业分类或投资排序。
选择是目的抽样,不能用16家的结果估计全市场策略胜率。
其余195家保留在全量事实表,尚未研究不等于投资不合格。
特别保留低于5%、字段缺值及风险案例,检验筛选是否会误判。
| 公司 | 研究分组 | 原表股息率 | 供应商滚动值 | 本轮安排 |
|---|---|---:|---:|---|
| 格力电器 | 经营现金回报 | 7.75% | 7.76% | 优先深挖 |
| 海尔智家 | 经营现金回报 | 6.15% | 5.74% | 优先深挖 |
| 富安娜 | 经营现金回报 | 10.32% | 6.37% | 优先深挖 |
| 山东出版 | 经营现金回报 | 5.51% | 4.32% | 边界对照 |
| 中国国贸 | 经营现金回报 | 5.27% | 5.13% | 补齐材料 |
| 陕天然气 | 经营现金回报 | 5.00% | 2.86% | 边界对照 |
| 兴业银行 | 金融资本约束 | 5.73% | 5.76% | 优先深挖 |
| 建设银行 | 金融资本约束 | 5.12% | 1.76% | 口径对照 |
| 江苏金租 | 金融资本约束 | 5.52% | 4.14% | 边界对照 |
| 中国神华 | 跨周期分红 | 5.69% | 3.73% | 周期对照 |
| 中远海控 | 跨周期分红 | 9.64% | 6.05% | 周期对照 |
| 思维列控 | 特别分红与风险 | 15.91% | 2.54% | 特别分红对照 |
| 东方雨虹 | 特别分红与风险 | 17.39% | 缺值 | 风险对照 |
| 蓝天燃气 | 特别分红与风险 | 12.88% | 缺值 | 风险对照 |
| 索菲亚 | 特别分红与风险 | 13.39% | 10.71% | 风险对照 |
| ST喜临门 | 特别分红与风险 | 8.43% | 2.94% | 风险对照 |
原表和滚动值均为历史税前口径,不是下一年的预测。
各公司正常情景、压力情景每股分红和可接受价格目前均留空。
缺维护性资本开支、可用现金与偿债资料时,不输出伪精确价格。
## 研究记录
五年描述使用2021至2025年度数据库记录。
现金转化为五年经营现金净流量合计除以合并净利润合计。
它没有扣资本开支,也不是归母可分配现金。
金融样本不使用这一比率。
五年ROE为年度数值中位数,不是本次对企业质量的评分。
### 格力电器(000651.SZ)
选择理由:检验成熟家电企业能否在需求下降时维持普通分红。
历史描述:五年ROE中位数24.46%,累计现金转化1.21倍。
资料深度:已抽查2026半年报及两份实施公告。
- 已知事实:2026年1月实施每股1元,8月实施每股2元。数据库漏收后一次实施。
- 反方与风险:2026半年报扣非净利润同比下降8.89%,经营现金净流量下降33.60%。不能按历史分红直接外推。
- 下一步材料:核对受限资金、财务公司资金、到期债务、渠道回款及维持性资本开支。
- 研究证伪条件:若正常经营现金扣除必要投资和偿债后不能支持普通派息,撤回持续投入假设。
公告来源:[格力中期派息](https://static.cninfo.com.cn/finalpage/2026-01-16/1224936369.PDF),[格力年度派息](https://file.finance.sina.com.cn/211.154.219.97:9494/MRGG/CNSESZ_STOCK/2026/2026-8/2026-08-21/12512438.PDF),[格力半年报](https://static.cninfo.com.cn/finalpage/2026-08-27/1225515004.PDF)。
### 海尔智家(600690.SH)
选择理由:检验全球家电业务的分红能否跨越需求波动。
历史描述:五年ROE中位数17.00%,累计现金转化1.43倍。
资料深度:已抽查2026半年报及年度实施公告。
- 已知事实:2025年度A股每股0.89151元,于2026年8月21日派发。数据库缺这笔实施记录。
- 反方与风险:2026半年报扣非净利润下降20.54%,经营现金净流量下降12.45%。海外业务与现金上划需分开核验。
- 下一步材料:核对分地区利润、关税及汇率影响、资本开支、海外资金可用性与分红政策。
- 研究证伪条件:若竞争优势或现金上划能力持续恶化,不能因价格下降继续追加。
公告来源:[海尔年度派息](https://static.cninfo.com.cn/finalpage/2026-08-15/1225474603.PDF),[海尔半年报](https://static.cninfo.com.cn/finalpage/2026-08-28/1225522691.PDF)。
### 富安娜(002327.SZ)
选择理由:检验品牌家纺的现金回报是否优于单纯高股息筛选。
历史描述:五年ROE中位数14.30%,累计现金转化1.25倍。
资料深度:已抽查2026半年报主要财务数据。
- 已知事实:2026半年报扣非净利润增长3.44%,经营现金净流量2.15亿元。
- 反方与风险:同期经营现金净流量下降25.80%。净利润增长没有同步转化为现金增长。
- 下一步材料:核对库存周转、渠道回款、理财资金可用性及同利润年度的实际支付率。
- 研究证伪条件:若库存与应收持续吸收现金,或普通派息长期依靠消耗现金储备,停止新增投入。
公告来源:[富安娜半年报](https://static.cninfo.com.cn/finalpage/2026-08-26/1225501968.PDF)。
### 山东出版(601019.SH)
选择理由:检验出版现金回报与教材业务稳定性,保留低于5%的对照。
历史描述:五年ROE中位数12.83%,累计现金转化1.20倍。
资料深度:已核对中期派息;经营材料待深读。
- 已知事实:2026年10月13日已派每股0.06元。数据库该笔仍停留在通过阶段。
- 反方与风险:供应商滚动股息率4.32%,已低于原表5.51%。尚未完成教材结构及现金用途核查。
- 下一步材料:补读半年报,核对教材教辅收入、应收款、母公司现金和投资预算。
- 研究证伪条件:若核心业务衰退或现金用于低回报项目,不能把稳定派息意愿当支付能力。
公告来源:[山东出版中期派息](https://money.finance.sina.com.cn/corp/view/vCB_AllBulletinDetail.php?id=12623323&stockid=601019)。
### 中国国贸(600007.SH)
选择理由:检验收租业务能否产生扣除翻新开支后的可分配现金。
历史描述:五年ROE中位数12.55%,累计现金转化1.52倍。
资料深度:仅完成数据库初筛;半年报待核验。
- 已知事实:数据库2021至2025年经营现金净流量合计高于合并净利润合计。
- 反方与风险:年度汇总不能反映最新出租率、租金、空置和翻新支出。数据库财务只到2026一季度。
- 下一步材料:读取半年报的出租率、单位租金、经营分部、资本开支与现金余额。
- 研究证伪条件:若净租金现金持续下降或必要翻新吞噬现金,重估可持续分红。
来源为本轮冻结数据库。尚未完成对应公告核验。
### 陕天然气(002267.SZ)
选择理由:检验管网业务现金回报,观察高股息门槛附近的误选。
历史描述:五年ROE中位数8.95%,累计现金转化1.84倍。
资料深度:仅完成数据库初筛;半年报待核验。
- 已知事实:数据库五年累计经营现金净流量高于合并净利润;供应商滚动股息率2.86%。
- 反方与风险:原表刚好5%,更新口径后明显低于门槛。管输定价和建设支出尚未核清。
- 下一步材料:核对最新半年报、管输价格、输气量、管网投资、到期债务和关联交易。
- 研究证伪条件:若监管价格或新增资本开支使可分配现金下降,不按过去派息追加。
来源为本轮冻结数据库。尚未完成对应公告核验。
### 兴业银行(601166.SH)
选择理由:检验银行分红与资本补充需求能否兼容。
历史描述:五年ROE中位数10.00%,累计现金转化不适用。
资料深度:已抽查2026半年报摘要。
- 已知事实:2026半年报不良率1.08%,与年末持平;集团核心一级资本充足率9.43%。
- 反方与风险:净息差1.60%,同比下降15个基点;归母净利润下降4.66%;拨备覆盖率225.67%,较年末下降。
- 下一步材料:核对普通股分红能力、风险加权资产增长、信用成本及资本管理目标。
- 研究证伪条件:若资本缓冲或资产质量不足以支持普通股分红,撤回分红持续性判断。
公告来源:[兴业半年报摘要](https://download.cib.com.cn/netbank/download/cn/announcements/20260827_2.pdf)。
### 建设银行(601939.SH)
选择理由:用大型银行检验A股每股派息与供应商股息率差异。
历史描述:五年ROE中位数11.08%,累计现金转化不适用。
资料深度:仅完成数据库初筛;分红口径待核验。
- 已知事实:五年财务和分红记录齐备,可用于对照金融类分析方法。
- 反方与风险:供应商滚动值1.76%与库内除息事件重算不一致。尚不能据此认定实际收益只有1.76%。
- 下一步材料:逐笔核对A股派息、报告期筛选、股本变化,再核对半年报净息差、拨备和资本。
- 研究证伪条件:先解决口径差异;经营结论以资本和资产质量为条件,不能套工业现金比率。
来源为本轮冻结数据库。尚未完成对应公告核验。
### 江苏金租(600901.SH)
选择理由:检验融资租赁资产收益与资金成本之间的稳定性。
历史描述:五年ROE中位数15.04%,累计现金转化不适用。
资料深度:仅完成数据库初筛;半年报待核验。
- 已知事实:五年财务和分红记录齐备,保留为银行以外的金融样本。
- 反方与风险:供应商滚动股息率4.14%,低于原表5.52%。不使用工业企业现金转化率判断。
- 下一步材料:核对租赁资产质量、逾期迁徙、减值、融资成本、资本与中期派息。
- 研究证伪条件:若资产收益下降而融资和信用成本上升,重估分红承受力。
来源为本轮冻结数据库。尚未完成对应公告核验。
### 中国神华(601088.SH)
选择理由:检验煤电一体化能否平滑煤价周期的分红波动。
历史描述:五年ROE中位数14.04%,累计现金转化1.35倍。
资料深度:仅完成数据库初筛;跨周期现金待重构。
- 已知事实:数据库五年累计经营现金净流量高于合并净利润合计。
- 反方与风险:供应商滚动股息率3.73%。高景气年份派息不能代表中周期分红。
- 下一步材料:核对最新半年报、煤价和成本、资本开支、收购及融资安排、普通分红政策。
- 研究证伪条件:若中周期现金扣除投资和偿债后不足以派息,不以景气高点作为估值分母。
来源为本轮冻结数据库。尚未完成对应公告核验。
### 中远海控(601919.SH)
选择理由:检验航运高股息是否主要来自运价周期。
历史描述:五年ROE中位数22.80%,累计现金转化1.43倍。
资料深度:仅完成数据库初筛;跨周期现金待重构。
- 已知事实:数据库滚动股息率6.05%,五年累计现金转化高于1。
- 反方与风险:数据库2026一季度扣非净利润同比下降49.66%。五年均值包含强景气年份。
- 下一步材料:核对最新半年报、长协及现货运价、船队交付、租赁付款与造船预算。
- 研究证伪条件:若中周期现金不能覆盖船队更新和普通派息,停止按高股息持续投入。
来源为本轮冻结数据库。尚未完成对应公告核验。
### 思维列控(603508.SH)
选择理由:检验把一次性分红当持续收益会造成多大误判。
历史描述:五年ROE中位数9.57%,累计现金转化0.73倍。
资料深度:特别分红已识别;可持续普通派息待估计。
- 已知事实:2025年中期每股2.1元为特别分红。2025年度每股0.5245元于2026年5月实施。
- 反方与风险:原表15.91%不能视为未来常态收益。供应商滚动值已降至2.54%。
- 下一步材料:拆开普通与特别分红,核对普通利润、订单、客户回款和未来分红政策。
- 研究证伪条件:特别分红不进入可持续派息分母。普通派息不能支持门槛时保留为对照。
公告来源:[思维特别分红](https://static.cninfo.com.cn/finalpage/2025-08-12/1224443652.PDF),[思维年度派息](https://dataclouds.cninfo.com.cn/shgonggao/hsomarket/2026/20260514/837f46bfbffd4a2596789ec5fb416d72.PDF)。
### 东方雨虹(002271.SZ)
选择理由:检验历史高派息与当前盈利承受力脱节的情况。
历史描述:五年ROE中位数7.99%,累计现金转化1.59倍。
资料深度:已核对2025分配预案;当前经营待核验。
- 已知事实:2025年中期已派约22.10亿元;全年归母净利润约1.13亿元。
- 反方与风险:2025年度方案未追加现金分红。原表17.39%不能外推,滚动字段缺值不等于零。
- 下一步材料:核对2026半年报、应收账款回收、减值、扩张支出及母公司与集团利润差异。
- 研究证伪条件:盈利与现金支撑未恢复前,不进入持续配置组。保留作高历史派息的反例。
公告来源:[东方雨虹分配预案](https://static.cninfo.com.cn/finalpage/2026-04-17/1225114226.PDF)。
### 蓝天燃气(605368.SH)
选择理由:检验高支付率公用事业是否仍有分红安全余量。
历史描述:五年ROE中位数16.17%,累计现金转化1.32倍。
资料深度:已核对2025分配说明;当前经营待核验。
- 已知事实:2025中期派息已占全年归母净利润101.36%;年度方案未追加分红。
- 反方与风险:原表12.88%不能直接延续。供应商滚动字段缺值,未证明下一次分红为零。
- 下一步材料:核对最新半年报、购销价差、接驳收入、建设支出、债务和分红承诺。
- 研究证伪条件:若普通派息持续超过经营可分配现金,不能因历史高分红继续追加。
公告来源:[蓝天燃气分配说明](https://static.cninfo.com.cn/finalpage/2026-04-22/1225135793.PDF)。
### 索菲亚(002572.SZ)
选择理由:检验滚动股息仍高时,基本面筛选能否识别利润恶化。
历史描述:五年ROE中位数18.63%,累计现金转化1.31倍。
资料深度:仅完成数据库初筛;利润恶化原因待核验。
- 已知事实:数据库滚动股息率仍为10.71%,五年年度扣非每股收益均为正。
- 反方与风险:数据库2026一季度扣非净利润同比下降95.45%。五年正盈利不能证明当前优质。
- 下一步材料:补齐半年报与经营数据,核对订单、渠道回款、减值及实际派息。
- 研究证伪条件:若利润恢复主要依靠非经常项目或回款继续恶化,不进入持续配置组。
来源为本轮冻结数据库。尚未完成对应公告核验。
### ST喜临门(603008.SH)
选择理由:检验风险警示公司是否被历史股息率误纳入。
历史描述:五年ROE中位数8.63%,累计现金转化2.34倍。
资料深度:仅完成数据库初筛;风险警示原因待核验。
- 已知事实:原表名称带ST,保留为负面对照,不作为获批投资样本。
- 反方与风险:数据库2026一季度扣非净利润同比下降164.15%。未查明ST原因,不自行推断。
- 下一步材料:查风险警示原文、审计意见、资金占用、关联交易及最新半年报。
- 研究证伪条件:风险警示原因和财务可信度未澄清前,不进入持续配置组。
来源为本轮冻结数据库。尚未完成对应公告核验。
## 后续实施顺序
先补齐16家的实施公告、2026半年报及资金使用证据。
优先深挖格力、海尔、富安娜和兴业,因其有可核查的现金回报基础。
同时保留当前经营下行的反方证据,不预设这四家最终通过。
再估计正常和压力情景的普通分红,特别分红单列。
最后冻结研究组合、对照组和新增投入规则,才开始收益记录。
三季报披露在10月20日之后的材料另开观察截面,不倒填本版。
## 验证与边界
- 原文件211行代码唯一,日期一致。原文件未改动。
- 178容器内只读五张代理表。各表单独查询,无联表、写库或模型调用。
- 取得行情211行、分红7629行、财务6725行、现金流4574行、主数据209行。
- 17家公司涉及近期送转,逐票列出。股本基数变化仍需公告复核。
- 2条实施记录的日期链需核验,未直接认定实际分红无效。
- 行业字段209行均为空,未用空值合成行业集中度。
- 209家公司覆盖五年财务;185家每个年度有合格分红记录。
后者不证明每年普通分红均已核全,也不证明以后仍持续。
- 原始文件和取数结果分别保存指纹。当前取数不能冒充历史实时快照。
- 本轮未建立真实交易组合,未修改每日计划、评分、PMS或择时规则。
源文件SHA256:2b4ec78b042f091001fe00554577d8dfda821e26a9381777cfb903ea09c93d71。
取数结果SHA256:9bdff9d9e9e9653733f64be53a0ba66d51d4539b78761b3205dc7023017c4e8a。
读取窗口:2026-10-21 14:50:11至14:50:12,北京时间。
数据库读取机器为178,服务实例身份已核对。155与188本轮未操作。
## 文件验证与接续入口
已逐项读回211行导出结果,880个公式无错误。
已检查零值、缺值和5%边界,并恢复原始输入。
三张工作表的代表区域已经渲染检查。
研究文件保存在本次聊天的独立资料目录,包含原始摘录和复核脚本。
本轮只保存本地文档和研究产物,不部署业务服务。
可在开发机执行以下只读核验。不会重新连库。
预期输出stocks为211,samples为16,formula_count为880。
formula_errors为空,all_211_rows_checked为true。
```bash
# 开发机 · 任意目录
/Users/baobao/.cache/codex-runtimes/codex-primary-runtime/dependencies/python/bin/python3 /Users/baobao/.codex/visualizations/2026/10/14/01a1396c-4e8e-7a21-ac34-8b7f6150dfe3/dividend-experiment-20261021/support/verify.py
```
接续时先保留本轮截面,再为新增公告另建观察版本。
不得用后来的三季报或分红倒填本轮可知信息。
下一批是逐票补证和正常、压力情景估算。
收益比较和条件持续投入规则尚未启动。

View File

@ -0,0 +1,124 @@
# 高股息持续配置实验规格
建立日期:2026-10-21,北京时间。
用户已同意从分红口径核查和首批深度研究开始。
本轮为独立研究,不改变四层系统的运行规则。
## 目标与假设
检验基本面研究能否提高高股息组合的分红持续性和长期总回报。
另行检验按估值与依据变化控制持续投入,是否优于固定投入。
两项假设分开评价,不把现金流入较多等同于总回报较高。
第一批只完成输入核查、研究分组和样本准备。
首批公司是研究样本,不是已经通过投资审核的组合。
没有足够证据时,预期分红和买入价格保持待核验。
## 固定输入与时间边界
原件:用户桌面的《股息率汇总.xlsx》,Sheet1的A1:H212。
行情日期:2026-10-20。211条,股票代码唯一。
原件SHA256:2b4ec78b042f091001fe00554577d8dfda821e26a9381777cfb903ea09c93d71。
完整原始行、取数时刻、数据库公开日期及证据来源独立保存。
不修改用户原文件,不将研究名单写入每日计划或交易股票池。
本轮使用10月20日收盘价格,财务与公告采用不晚于该日的可知材料。
数据库在10月21日读取,属于当前截面研究。
源表历史修订版本未证明,不冒充10月20日实时数据库快照。
公开日缺失、矛盾或晚于截止日的记录单列,不自动当作可知。
## 核查定义
1. 原表股息率与每日指标中的dv_ratio、dv_ttm逐票比对。
2. 用已实施、日期合格的税前每股分红重算两个观察窗。
一个为2025自然年度除息事件,另一个为截止日之前十二个月除息事件。
3. 后一个独立观察窗与供应商dv_ttm可能不同。
供应商还限制分红所属报告期,不能将差异直接认定为供应商错误。
4. 同一事件的预案、通过、实施不得相加。重复和冲突独立报告。
5. 送转股、股本基数变更影响每股可比性。
未完成复权核对时,不给每股长期增长和精确支付率结论。
6. 普通分红与特别分红必须由公告证实。
高支付率只能提示核查,不能自动判为特别分红或造假。
7. 税前分红与投资者实际税后收入分开。未知账户税制不假定免税。
8. 最新年度支付率按同一利润年度计算。股息率乘滚动市盈率仅作诊断。
## 研究内容与样本选择
先对211家提供统一事实表。
再选择12至20家,覆盖现金回报、金融、周期、特别分红与负面案例。
优先考虑资料覆盖、不同业务类型和对假设的辨别力。
不按股息率最高或近期涨幅最好选择,不产生竞争评分。
样本选择理由和未入选原因保留。
每家公司记录盈利持续性、现金转化、分红能力、分红意愿和价格。
记录支持证据、反方证据、未知事项、证伪条件及下一份所需材料。
金融企业单看资本约束和资产质量,不套工业企业自由现金流标准。
周期企业使用跨周期利润,不以高景气年份直接外推。
维护性资本开支、母子公司资金上划和到期债务未核清时,
不得用供应商自由现金流字段代替可分配现金。
## 后续实验规则
基础组为核验后高股息名单。研究组在同一范围内加入基本面筛选。
使用相同成本、时点、调仓频率与集中度约束,并另做行业匹配比较。
比较红利指数全收益、宽基全收益和现金收益。
持续投入另设固定投入与条件投入两组。
资金到达日期、总预算相同,未投入资金计入现金收益。
初拟单股8%、单行业25%上限,仅为研究组合假设。
正式组合启动前冻结具体样本、税费、交易价格与执行规则。
不改变现有PMS参数,不创建自动交易任务。
预期分红采用正常与压力两种情景,并保存逐项假设。
原股息率5%仅为初始研究入口,不是已证明的最优阈值。
价格上涨、盈利恶化、分红政策改变均重新评价新增投入。
减分红须区分经营恶化与合理资本投入,不机械统一卖出。
## 评价与停止
评价普通分红削减率、预测误差、税费后总回报、最大回撤、恢复时间。
效果观察按一年、三年、五年持有口径,五至二十日只作流程诊断。
保留失败、退市、长期停牌和被排除的样本。
不把今天的名单向过去回填,不用事后重述数据宣称当时可选。
历史公开日与版本无法证明的样本,不进入真实历史策略效果统计。
如果研究组只在某个行业或少数样本上占优,结论限于该范围。
若不能降低分红削减,或扣除成本后不优于可替代基准,
不扩大实验,不将复杂研究流程直接上线。
停止实验只停止独立研究记录,既有交易系统无需回退。
## 本轮预判与验收
预判原表可能使用上一自然年度股息率,需与211行事实比较。
预判极高股息中会混有特别分红和盈利下降,不预设数量。
必须给出原表、供应商和独立事件重算三者的覆盖与差异。
缺失、重复、冲突和股本可比性问题不能静默归零。
抽查极值、边界、金融、送转与负面样本。
研究输出表须验证公式、数量与来源,并进行可视化检查。
## 开发者参考
只读取数运行在178基座现有容器,使用153代理的单表查询。
原料含gp_day_basic、gp_dividend、gp_fina_indicator、gp_cashflow和gp_code_all。
不联表,不调用模型,不写业务库。分析结果放独立文件。
基座只提供事实;后续研究筛选归选股层,组合与执行归PMS。
新实验暂不新增表、后台任务、API或页面。
方案与交接按仓库约定逐字同步四仓。
## 第一批实测记录
2026-10-21已完成211行口径比对和16家研究建档。
结果见《高股息实验首批核查_2026-10-21.md》。
原表全部匹配上一年度字段。滚动值分组为108家、95家及8家缺值。
发现分红实施记录和半年报覆盖缺口,不能直接形成投资名单。
当前已抽查部分公告,未完成全部公司的公告级审核。
正常和压力分红、买入价格以及可执行组合仍待研究。
本轮没有新增业务表、任务、参数或交易指令,不涉及部署。
## 同日第二阶段决定
用户要求改成持续阶段检测。股息每日查,其他材料按月或季度查。
新入口改用gp_stock_factor_pro对应月份表,全市场扫描。
ST直接排除,不再保留为新的研究候选。旧核查记录保持。
实现与最新状态见《高股息阶段检测开发规格_2026-10-21.md》
及《交接_高股息阶段检测_2026-10-21.md》。
第二阶段已有本地代码和真实只读试跑,尚未部署或开启自动日程。

View File

@ -0,0 +1,168 @@
# 高股息阶段检测开发规格
2026-10-21,北京时间。承接高股息实验。
用户明确要求排除 ST,股息每日查,其他材料按月或季度查。
本方案替代旧实验中将 ST 留作研究样本的安排。
原始核查结果保留,不改写已保存的历史。
## 目标与边界
建立独立研究清单,回答股息是否够高、公司是否值得研究、分红能否持续。
筛选放在 akg-factor-bridge。基座继续提供事实和多视角评析。
复用桥容器的独立命令,不新增常驻容器。
本流程不修改每日计划、因子、股票池、PMS 或交易参数。
## 检测节奏
| 内容 | 节奏 | 工作 |
| --- | --- | --- |
| 股息与风险名称 | 每交易日北京时间 08:05 | 检查上一交易日全市场数据、ST、上市状态及股息变化。避开盘前链和计划生成。 |
| 财务与分红事实 | 每月首次成功运行;新进入者立即补查 | 读取五年年度财务、现金流和分红公告。失败不推进复查日期。 |
| 完整个股研究 | 每季度列出复核需求;重大反方变化提前列出 | 复用现有多视角结论,保存支持、反方与未知事项。缺材料时列补查清单。 |
每天接收已有的新评析,不每天重新调用模型。
月度取数完成不等于完成季度深度研究。
第一版输出研究需求,不自动批量生成数百份模型评析。
持续性专项结论须有普通分红、盈利、现金或资本约束证据。
没有这些证据时,只能列为待核验,不能宣称大概率持续。
## 取数与判断
1. 表名由预期行情日期生成,当前为 gp_stock_factor_pro_202610。
月初使用上一交易日所属月份,禁止永久写死 202610。
日期不对、表缺失、重复代码或整路来源失败,停止本次发布。
2. 使用 dv_ttm,单位为百分数,入口暂用不低于 5%。
dv_ratio 只作上一自然年度对照,不填补缺失的 dv_ttm。
TTM 是历史观察值,不是未来承诺。
字段定义见 https://tushare.pro/document/2?doc_id=32。
3. 名称从 gp_code_all 单表读取,在内存合并。
ST、*ST、SST、S*ST 及退市名称先排除。
名称或上市状态不明的股票隔离,不能因缺名单而放行。
4. 所有观点保留实际财务材料期、评析时间、来源和未知事项。
不以视角赞成数量代替研究,不更改基座质地算法。
5. 先分成质地较好待核验、观点有分歧、已有明确风险、待补评析。
这四类不是投资评级。分红持续性在专项证据齐备前保持待核验。
6. 金融企业不套用工业企业现金流阈值。
特别分红、资本开支、债务及母子公司资金上划单独核验。
旧半年报缺口不能用报告生成时间掩盖。
## 输出、故障与撤销
独立目录保存输入、完整结果、可读报告和研究需求清单。
每次成功发布只追加,固定内容指纹,最后原子切换 latest。
相同有效输入与配置不重复归档。源失败保留旧结果,同时明确检查失败。
旧结果不能以最新日期展示。缺值不归零。
原始报告按读取时点冻结。旧无固定引用报告只称当前读取副本。
不得将副本冒充原历史时点的完整材料。
只新增独立 XXL 入口,不加入默认 build、plan、push-pool 链。
研究任务使用独立运行锁,不占五分钟计划修订的锁。
统一调度启用前须验证本地、真实只读取数和接口加载。
手工入口与日检入口随实现登记。停止独立任务即可撤销。
历史研究记录保留,交易系统无需回退。
## 实施前预判与验收
预判高股息池的完整评析覆盖不足,不能把未覆盖当基本面良好。
预判北交所新代码与名称主表可能不同步,先隔离再补源。
测试覆盖 ST 与缺名称、5% 边界、月切换、日期落后、重复记录、
旧财务期、反方观点、月度复用、新进入者、源失败、发布中断和幂等。
只读实跑核对各组数量相加、研究来源及历史文件不变。
显示主要保留股息、经营依据、风险和待核验材料。
技术标识置于详情,不堆在研究卡上。
## 开发者参考
纯逻辑和文件发布使用标准库。数据库读取复用桥 db 连接。
153 代理逐表查询,禁止联表。所有查询有确定顺序。
冻结截止时间含时区。当前截面不冒充可回测的历史版本。
月度财务来源为 gp_fina_indicator、gp_cashflow、gp_dividend。
公开日期晚于研究截止时间的材料不进入判断。
新增内容缺键按未知处理。先保存来源再形成报告。
无新业务数据库表,无模型调用,无交易写入。
## 第一版实现与入口
桥新增 dividend_watch.py、dividend_sources.py、dividend_jobs.py。
研究报告路径为 GET /research/dividend。
日检路径为 GET /research/dividend/health。
独立任务入口为 /api/v1/xxl/dividend-watch。
使用既有任务鉴权和完成回调,任务执行成功才回调成功。
第一版没有在 XXL 创建或开启日程。
任务进程中断后,重新检查归档与日检,不把任务消失视为成功。
```bash
# 开发机 · akg-factor-bridge;预期全部 OK,不连接外部服务
PYTHONDONTWRITEBYTECODE=1 python3 -m unittest test_dividend_watch test_dividend_jobs
```
```bash
# 155 桥机 · ~/project/akg-factor-bridge;代码部署后使用
docker exec akg_factor_bridge python dividend_watch.py scan
docker exec akg_factor_bridge python dividend_watch.py health
```
第二条预期 ok=true,且行情日期是上一完整交易日。
资料缺失会进入核查事项,不代表研究已通过。
健康表示本次观察已完整保存,不表示投资资格通过。
月度资料完成取数,与季度研究完成审核是两个状态。
尚无自动补齐个股评析、专项分红审核或自动交易功能。
## 2026-10-21 真实只读试跑
北京时间16:00:40冻结输入。来源行情日2026-10-20。
月表5568行,滚动股息不低于5%的有171只。
其中ST八菱排除,6只北交所新代码的名称未匹配。
余164只进入独立研究池。已有评析9只,未覆盖155只。
已有结论中,好2只,中3只,差4只。
两只好公司为丽珠集团与海尔智家,仅列优先核验。
两者财务指标期与重构报表期不同,不能直接确认分红持续性。
九份当前报告原文已冻结,均为旧格式读取副本。
它们不冒充原生成时点的固定历史版本。
本月资料读取164家公司。日期过滤后保留财务指标3447行,
现金流3444行,分红3876行。记录数不能证明完整性。
所有公司的持续性结论仍为待核验,未批准任何投资。
本地新增36项研究与调度回归。
连同现有计划版本和查询共63项禁网回归通过。
原XXL入口13项回归通过。页面分组、搜索与筛选另做浏览器验证。
当前是本地实现与真实只读取数完成,未重启或部署服务。
同月第二次实测耗时2.438秒。164家财务缓存摘要相同,9份原报告复用。
本轮没有到月度复查日的对象,没有重复读取三路财务分红资料。
公开日期只有日级精度,不能证明某份材料在当天盘前已可知。
因此本轮结果只用于当前截面研究,不进入历史策略效果统计。
## 2026-10-21 分红研究归属更新
用户批准将分红持续性专项研究沉淀为基座数据产品。
实现与验收见《分红持续性研究数据产品开发规格_2026-10-21.md》。
桥继续筛选和展示,新增只读研究消费,不调用模型、不改交易资格。
本地代码已实现,但尚未部署或产生真实专项模型研究。
## 2026-10-22 日检上线
155桥已部署,独立任务为XXL141“高股息每日研究检测”。
交易日08:05运行,08:05—08:06窗口内间隔86400秒。
保留A股交易日历、HTTP鉴权和业务回调,不用宿主cron。
09:16通过平台执行一次,成功4秒;启用后下次为10-23 08:05。
正常次日自动触发尚未发生,不能用手工一次替代其生产判收。
当前行情日10-21,169家公司进入研究,其中159家缺个股评析。
页面只读归档,不在用户查询时重新计算或调用模型。
最新部署读数、备份、停止与回退见同名交接的10-22节。
## 2026-10-22 研究贯通与页面判收
基座已完成两家公司真实专项研究,并启用已登记公司的月度到期复查。
桥只读取已发布结果,未把169家公司自动投模型。
原财务资料和评析报告副本按月复用,每日仍刷新股息与研究状态。
两份专项结论均为证据不足,主卡片列现金流差异、分红冲突和材料缺口。
未知事项不自动转成交易阈值,完整来源与技术引用仅在详情显示。
页面表达精简不改变研究池、排序或资格。
本轮桥最终功能7111bde,09:53:09重建生效。
70项联合禁网回归、六组既有脚本及浏览器核验通过。
原145份计划归档和全部核对参数保持,现有计划修订137已恢复。
独立研究141启用,下一次自然触发10-23 08:05尚待发生。
研究月度任务20:35自然运行也尚待发生,不伪报调度长周期判收。
季度完整研究仍受原文与材料覆盖限制,缺口继续列出。

View File

@ -0,0 +1,95 @@
# -*- coding: utf-8 -*-
"""155 容器:python scripts/repair_ledger_history.py backup --codes ... > 主机备份.json
预演:python scripts/repair_ledger_history.py preview --codes ... < 备份.json
写入:停止 worker/beat 后,apply --backup-sha256 <文件哈希> --codes ... < 同一备份
回退:rollback --run-id HIST_xxx,仅原值未再变化时可回退。审计和原证据均保留。
脚本无模型调用、无交易下发,所有 SQL 经单表守卫;不得在开发机连接数据库。
"""
import argparse
import hashlib
import json
import sys
from datetime import datetime
from pathlib import Path
sys.path.insert(0,str(Path(__file__).resolve().parents[1]))
from app.core.ledger_repair import compile_repair, canonical
def backup(codes):
from app.db.session import fetch_all, TABLE_PREFIX
from app.repo import qmt_repo as q, pms_repo as p, downstream_repo as ds
from app.services import param_store as ps
if TABLE_PREFIX:
raise ValueError('仅允许模拟仓命名空间')
out = dict(schema=1,at=datetime.now().isoformat()+'+08:00',instance='155-sim',tables={})
for table in ['pms_position','pms_lot','pms_instruction','pms_plan','pms_command','pms_qmt_order',
'pms_cash_flow','pms_strategy','pms_proposal','pms_daily_report','pms_nav_daily']:
out['tables'][table] = fetch_all('SELECT * FROM '+table+' ORDER BY '+('ymd' if table=='pms_nav_daily' else 'id'))
params={f'c{i}':c for i,c in enumerate(codes)}; where='ts_code IN ('+','.join(':'+k for k in params)+')'
for table in ['pms_action_ledger','pms_op_log']:
out['tables'][table]=fetch_all('SELECT * FROM '+table+' WHERE '+where+' ORDER BY id',params)
rows=[];seq=0
while True:
page=fetch_all("SELECT * FROM pms_qmt_inbox WHERE msg_type='trade' AND seq>:s ORDER BY seq LIMIT 1000",{'s':seq})
if not page:break
rows.extend(page);seq=page[-1]['seq']
out['tables']['pms_qmt_inbox']=rows
out['position_snapshot']=q.latest_snapshot('positions')
out['funds_snapshot']=q.latest_snapshot('funds')
out['table_fills']=ds.fetch_filled_orders(since_time='2000-01-01 00:00:00',limit=100000)
if len(out['table_fills'])>=100000:raise ValueError('成交表截断,拒绝备份')
out['replay_cursor']=p.get_param('PMS_REPLAY_CURSOR')
out['runtime_rows']=fetch_all("SELECT * FROM pms_runtime_param WHERE param_key IN ('PMS_TOTAL_SCALE','PMS_CUSHION_SOLID','PMS_DISPATCH_MODE','PMS_PLAN_VERSION_RECHECK','PMS_REPLAY_CURSOR') ORDER BY param_key")
out['effective']={k:ps.get(k) for k in ['PMS_TOTAL_SCALE','PMS_CUSHION_SOLID','PMS_DISPATCH_MODE','PMS_PLAN_VERSION_RECHECK']}
return out
def guards_for(b,codes):
guards=[]
params={f'c{i}':c for i,c in enumerate(codes)};where='ts_code IN ('+','.join(':'+k for k in params)+')'
for table in ['pms_position','pms_lot','pms_instruction','pms_qmt_order','pms_strategy','pms_plan']:
guards.append(dict(name=table,sql='SELECT * FROM '+table+' WHERE '+where+' ORDER BY id FOR UPDATE',
params=params,expected=[x for x in b['tables'][table] if x['ts_code'] in codes]))
guards.append(dict(name='全部逐笔证据',sql="SELECT * FROM pms_qmt_inbox WHERE msg_type='trade' ORDER BY seq FOR UPDATE",
expected=b['tables']['pms_qmt_inbox']))
guards.append(dict(name='运行参数及回放游标',sql="SELECT * FROM pms_runtime_param WHERE param_key IN ('PMS_TOTAL_SCALE','PMS_CUSHION_SOLID','PMS_DISPATCH_MODE','PMS_PLAN_VERSION_RECHECK','PMS_REPLAY_CURSOR') ORDER BY param_key FOR UPDATE", expected=b['runtime_rows']))
return guards
def main():
ap=argparse.ArgumentParser(description=__doc__)
ap.add_argument('mode',choices=['backup','preview','apply','rollback'])
ap.add_argument('--codes',nargs='+');ap.add_argument('--backup-sha256');ap.add_argument('--run-id')
args=ap.parse_args()
if args.mode=='backup':
if not args.codes:raise ValueError('缺股票范围')
print(canonical(backup(args.codes)));return
if args.mode=='rollback':
from app.db.session import fetch_all, apply_audited_repair, TABLE_PREFIX
if TABLE_PREFIX or not args.run_id:raise ValueError('回退实例或批号错误')
rows=fetch_all("SELECT * FROM pms_op_log WHERE ref=:r AND op='history_repair_row' ORDER BY id",{'r':args.run_id})
if not rows:raise ValueError('无修复审计')
changes=[]
for row in rows:
item=json.loads(row['params_json'])
changes.append(dict(table=item['table'],key=item['key'],before=item['after'],
fields={k:item['before'][k] for k in set(item['fields'])|{'updated_at'}}))
print(canonical(apply_audited_repair(dict(run_id=args.run_id,changes=changes),[],rollback=True)));return
raw=sys.stdin.buffer.read();b=json.loads(raw)
if not args.codes:raise ValueError('缺股票范围')
effective=b.get('effective',{})
plan=compile_repair(b,args.codes,scale=float(effective.get('PMS_TOTAL_SCALE',2000000)),
solid=float(effective.get('PMS_CUSHION_SOLID',0.03)))
if args.mode=='preview':print(canonical(plan));return
if not args.backup_sha256 or hashlib.sha256(raw).hexdigest()!=args.backup_sha256:
raise ValueError('完整备份文件哈希不符')
from app.db.session import apply_audited_repair, TABLE_PREFIX
if TABLE_PREFIX:raise ValueError('拒绝真实仓')
age=(datetime.now()-datetime.fromisoformat(b['at']).replace(tzinfo=None)).total_seconds()
if not 0<=age<900:raise ValueError('备份超过15分钟,须重新备份和预演')
if not b['position_snapshot'] or b['position_snapshot']['age_sec']>900:
raise ValueError('QMT持仓快照过旧')
print(canonical(apply_audited_repair(plan,guards_for(b,args.codes))))
if __name__=='__main__':main()

View File

@ -4,7 +4,17 @@
====================================== ======================================
运行: docker compose run --rm pms-web python scripts/run_tests.py 运行: docker compose run --rm pms-web python scripts/run_tests.py
包含 (例数按 2026-10-12 隔离回归实跑校正): 包含 (例数按 2026-10-26 隔离回归实跑校正):
test_batch47_units.py 账户资金去重、买入额度与账户展示和策略估值分离 (9 例)
test_batch46_units.py 质地排序切换、档位准入、命令分配与白名单优先 (11 例)
test_batch45_units.py 父指令总量:回放延迟、部分成交、跨日预留、故障守成与影子模式 (16 例)
test_batch43_units.py 逐票来源核验、实际API至SQL事务、故障回滚与幂等 (14 例)
test_batch42_units.py 提议先准备后采纳、模型复用、并发更新与发布审计 (24 例)
test_batch41_units.py 跨流程买卖互斥、清仓收尾、出口撤单与真实进展及人工清仓T+1 (24 例)
test_batch40_units.py 逐笔历史修复、进度暂停、并发与事务回滚与均价失效 (22 例)
test_batch39_units.py 成交双来源归属、迟到、部分成交与失败守成 (12 例)
test_batch38_units.py 每日计划顺序、版本核验、重新确认、并发采纳、历史保留及采纳失败说明、明确否决撤下 (30 例)
含在途报价变化不重复确认、真实承诺变化仍重核。
test_core_units.py 仓位规划器 / 安全垫与成本账 (14 例) test_core_units.py 仓位规划器 / 安全垫与成本账 (14 例)
test_batch2_units.py 命令状态机 / 方案生成器 / 回放对账纯逻辑 (35 例) test_batch2_units.py 命令状态机 / 方案生成器 / 回放对账纯逻辑 (35 例)
test_batch3_units.py 规则闸 / 择时执行器实现B 纯逻辑 / 用户止损价只披露不拦截 (26 例) test_batch3_units.py 规则闸 / 择时执行器实现B 纯逻辑 / 用户止损价只披露不拦截 (26 例)
@ -39,7 +49,7 @@
五阶段判定与逐票阶段返回/note 约定与冷却推导/ 五阶段判定与逐票阶段返回/note 约定与冷却推导/
接力判定/clear_buypause/编排冒烟(dry_run 滴水不写/ 接力判定/clear_buypause/编排冒烟(dry_run 滴水不写/
名额/暂停买入/接力全链)/真跑写一跳摘要而预演不写/ 名额/暂停买入/接力全链)/真跑写一跳摘要而预演不写/
判分脚本聚合与对照分组 (41 例) 判分脚本聚合与对照分组、网格余额封顶与恢复 (45 例)
test_batch18_units.py 登录与权限: 角色判定/会话票签验/bshop 返回解析/ test_batch18_units.py 登录与权限: 角色判定/会话票签验/bshop 返回解析/
接口鉴权(维护类归管理员) (16 例) 接口鉴权(维护类归管理员) (16 例)
test_batch19_units.py 2026-08-28 审查修复回归: 科创板最小申报统一口径/ test_batch19_units.py 2026-08-28 审查修复回归: 科创板最小申报统一口径/
@ -111,6 +121,7 @@
开关、四类交人、逻辑存疑放弃、深亏补仓三分支、目标价直接采纳、每日上限、record/decline 开关、四类交人、逻辑存疑放弃、深亏补仓三分支、目标价直接采纳、每日上限、record/decline
降级)/mark_decide 优先级/eval_dca 深档打 decide_kind/三参数登记与范围/两个 repo 查询 降级)/mark_decide 优先级/eval_dca 深档打 decide_kind/三参数登记与范围/两个 repo 查询
+ 评审补: 真通过只认带应答体的 PASS、弱表态按强弱打标记 (24 例) + 评审补: 真通过只认带应答体的 PASS、弱表态按强弱打标记 (24 例)
test_batch44_units.py 高股息独立来源、后台准备、快速采纳及失败守成 (24例)
test_batch35_units.py 单测隔离:观察读数内存仓储、整轮扫描与覆盖重建、 test_batch35_units.py 单测隔离:观察读数内存仓储、整轮扫描与覆盖重建、
异常吞掉仍判联网失败、配置隔离与独立入口护栏 (8 例) 异常吞掉仍判联网失败、配置隔离与独立入口护栏 (8 例)
test_batch36_units.py 命令按方案额结算:原分支回归、未解锁批次收尾与故障重试 (13 例) test_batch36_units.py 命令按方案额结算:原分支回归、未解锁批次收尾与故障重试 (13 例)
@ -125,7 +136,7 @@
test_wiring.py 装配自检: 服务层→核心→落表 全链路 (内存桩) + test_wiring.py 装配自检: 服务层→核心→落表 全链路 (内存桩) +
目标价到价自决关时入队、自决开时自动清仓按可卖量夹紧、挂着方案且有在途买单时先撤再清 + 目标价到价自决关时入队、自决开时自动清仓按可卖量夹紧、挂着方案且有在途买单时先撤再清 +
用户设的止损价与目标价单独成列显示 (72 例) 用户设的止损价与目标价单独成列显示 (72 例)
共 983 例 共 1154 例,49 批
2026-10-12 校正历史漏计,原有测试实际 941 例;本次新增三批共 42 例。 2026-10-12 校正历史漏计,原有测试实际 941 例;本次新增三批共 42 例。
任一子集失败即整体失败 (退出码 1)。 任一子集失败即整体失败 (退出码 1)。
@ -187,6 +198,10 @@ SUITES = ["test_core_units.py", "test_batch2_units.py", "test_batch3_units.py",
"test_batch35_units.py", "test_batch35_units.py",
"test_batch36_units.py", "test_batch36_units.py",
"test_batch37_units.py", "test_batch37_units.py",
"test_batch38_units.py", "test_batch39_units.py", "test_batch40_units.py", "test_batch41_units.py", "test_batch42_units.py", "test_batch43_units.py", "test_batch44_units.py",
"test_batch45_units.py",
"test_batch46_units.py",
"test_batch47_units.py",
"test_page_copy_guard.py", "test_page_copy_guard.py",
"test_page_enum_guard.py", "test_page_enum_guard.py",
"test_page_wiring_guard.py", "test_page_wiring_guard.py",

View File

@ -836,6 +836,80 @@ def _():
assert rep._fmt_pct(None) == "—" and rep._fmt_pct(0.1) == "+10.00%" assert rep._fmt_pct(None) == "—" and rep._fmt_pct(0.1) == "+10.00%"
def _grid_sell_fixture(qty=300, avail=700, add=300, per_lot=700, code="688100.SH"):
from app.services import strategy_runner as srun
prm = {"lower": 9.0, "upper": 11.0, "center": 10.0, "step_pct": 0.02,
"per_lot": per_lot, "max_capital": 50000}
band = srun._band(srun._grid_levels(prm), 10.5) - 1
st = {"strategy_id": "grid-test", "type": "GRID", "ts_code": code, "params": prm}
state = {"last_band": band, "filled_levels": {str(band): {"price": 9.8, "qty": qty}},
"invested": 9.8 * qty}
pos = {"avail_qty": avail, "add_qty": add}
ctx = {"state": state, "notes": [], "buy_paused": False}
return srun, st, state, pos, ctx, band
@case("[网格余额] 剩余300股、配置700股时只卖300股,完整档保持")
def _():
for qty, avail, add, expected in [(300, 700, 300, 300), (700, 1100, 700, 700)]:
sr, st, state, pos, ctx, band = _grid_sell_fixture(qty, avail, add)
d = sr._eval_grid(st, pos, {"price": 10.5}, None, ctx)
assert d and d["qty"] == expected, d
assert state["last_band"] == band + 1
@case("[网格余额] 原1000股首卖700后恢复300,再触发不卖底仓")
def _():
from unittest.mock import patch
sr, st, state, pos, ctx, band = _grid_sell_fixture(1000, 1400, 1000)
first = sr._eval_grid(st, pos, {"price": 10.5}, None, ctx)
assert first["qty"] == 700
sr._apply_grid_state(state, first)
state["pending"] = {"iid": "i1", "leg": first["leg"], "grid_sell_idx": band,
"grid_restore": first["_grid_restore"]}
with patch.object(sr, "_pending_terminal", return_value=(True, {"exec_qty": 700})):
assert sr._reconcile(st, state, pos)
assert state["filled_levels"][str(band)]["qty"] == 300
assert abs(state["invested"] - 2940) < 1e-6
state["last_band"] = band # 正常再次穿越同档。
second = sr._eval_grid(st, {"avail_qty": 700, "add_qty": 300}, {"price": 10.5}, None, ctx)
assert second and second["qty"] == 300, second
assert first["qty"] + second["qty"] == 1000
assert 1400 - first["qty"] - second["qty"] == 400 # 底仓完整保留。
@case("[网格余额] 可卖不足、档位零股与科创板小余额不突破持仓")
def _():
for qty, avail, add, code, expected in [
(300, 200, 300, "688100.SH", 200),
(350, 1000, 500, "688100.SH", 300),
(100, 700, 100, "688100.SH", None),
(100, 700, 100, "600000.SH", 100),
(0, 700, 500, "688100.SH", None),
(300, 700, 0, "688100.SH", None)]:
sr, st, state, pos, ctx, band = _grid_sell_fixture(qty, avail, add, code=code)
d = sr._eval_grid(st, pos, {"price": 10.5}, None, ctx)
assert (d["qty"] if d else None) == expected, (qty, avail, add, d)
if qty in (100, 0) and code == "688100.SH":
assert state["last_band"] == band
@case("[网格余额] 未成交和部分成交继续按实际剩余恢复档位")
def _():
from unittest.mock import patch
for executed, remaining in [(0, 300), (200, 100), (300, 0)]:
sr, st, state, pos, ctx, band = _grid_sell_fixture()
d = sr._eval_grid(st, pos, {"price": 10.5}, None, ctx)
assert d["qty"] == 300, d
sr._apply_grid_state(state, d)
state["pending"] = {"iid": "i1", "leg": d["leg"], "grid_sell_idx": band,
"grid_restore": d["_grid_restore"]}
with patch.object(sr, "_pending_terminal", return_value=(True, {"exec_qty": executed})):
assert sr._reconcile(st, state, pos)
assert state["filled_levels"].get(str(band), {}).get("qty", 0) == remaining
assert abs(state["invested"] - remaining * 9.8) < 1e-6
def main(): def main():
from test_wiring import install_fakes from test_wiring import install_fakes
install_fakes() # 其余外部依赖也必须有默认内存桩。 install_fakes() # 其余外部依赖也必须有默认内存桩。

View File

@ -284,6 +284,7 @@ def _route(c, *, values, judge_resp, open_autonomy="propose_only"):
got = {"ledger": [], "instructions": [], "proposals": []} got = {"ledger": [], "instructions": [], "proposals": []}
with _Patch() as p: with _Patch() as p:
p(rule_gate, "check", lambda **kw: {"passed": True, "failed": [], "warnings": []}) p(rule_gate, "check", lambda **kw: {"passed": True, "failed": [], "warnings": []})
p(psvc, 'verify_open_basis', lambda *a: {'ok': True, 'provenance': {}})
p(judge, "request", lambda cand_, context=None, **kw: dict(judge_resp)) p(judge, "request", lambda cand_, context=None, **kw: dict(judge_resp))
p(portfolio, "caps_ctx", lambda *a, **kw: {}) p(portfolio, "caps_ctx", lambda *a, **kw: {})
p(pms_repo, "insert_ledger", lambda **kw: got["ledger"].append(kw) or 1) p(pms_repo, "insert_ledger", lambda **kw: got["ledger"].append(kw) or 1)

View File

@ -0,0 +1,406 @@
"""本地:python scripts/unit_test_guard.py scripts/test_batch38_units.py。禁止联网。"""
import unit_test_guard # noqa: F401
import copy
import os
import sys
import unittest
from unittest.mock import patch
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from app.services import plan_feed as pf
from app.core import plan_revision as pr
from app.core import action_engine as ae
from test_batch20_units import params, caps
def selected():
plan = pf.parse_plan({'date': '2026-10-14', 'rank_axis': 'quality', 'decision': {'id': 'v1'},
'main': [{'code': 'SH600001', 'name': '甲', 'rank': 1, 'score': 210, 'verdict': '候选'},
{'code': 'SH600002', 'name': '乙', 'rank': 2, 'score': 250, 'verdict': '候选'}]})
return pf.select_candidates(plan, rank_by_upstream=True, theme_cap=1)['items']
class DailyPlanTest(unittest.TestCase):
def test_judge_cache_requires_same_material_basis(self):
old = {'plan_basis': {'risk': []}, 'scan_params_hash': 'p', 'portfolio_context_hash': 'c'}
ranked = dict(old, decision={'id': 'new'}, research_rank=99)
self.assertFalse(pr.needs_new_judgement(ranked, old))
self.assertTrue(pr.needs_new_judgement(dict(old, plan_basis={'risk': ['变化']}), old))
self.assertTrue(pr.needs_new_judgement(old, None))
def test_portfolio_quantity_basis_detects_new_commitments(self):
view = {'held': [{'ts_code': '600001.SH', 'total_qty': 100, 'sector': '电子', 'price': 10}],
'totals': {'cash_source': 'ws', 'cash_avail': 10000}, 'sector_ready': True}
commitments = {'names': [], 'amount': 0}
original = pr.portfolio_context(view, commitments)
view['held'][0]['price'] = 11
self.assertEqual(original, pr.portfolio_context(view, commitments))
commitments.update(names=['600002.SH'], amount=1000)
self.assertNotEqual(original, pr.portfolio_context(view, commitments))
def test_commitment_quotes_do_not_change_quantity_basis(self):
view = {'held': [], 'totals': {'cash_source': 'ws', 'cash_avail': 10000}}
old = {'names': {'600002.SH'}, 'amount': 1000,
'basis': [('instruction', 'i1', '600002.SH', 100, 0)]}
changed = dict(old, amount=1100)
self.assertEqual(pr.portfolio_context(view, old), pr.portfolio_context(view, changed))
for basis in [[('instruction', 'i2', '600002.SH', 100, 0)],
[('instruction', 'i1', '600002.SH', 200, 0)],
[('instruction', 'i1', '600002.SH', 100, 50)], []]:
self.assertNotEqual(pr.portfolio_context(view, old),
pr.portfolio_context(view, dict(old, basis=basis)))
double = dict(old, basis=old['basis'] + [('proposal', 'p1', '600003.SH', 100, 0)])
self.assertEqual(pr.portfolio_context(view, double),
pr.portfolio_context(view, dict(double, basis=list(reversed(double['basis'])))))
self.assertNotEqual(pr.portfolio_context(view, old), pr.portfolio_context(view, old, {'black': True}))
changed_view = copy.deepcopy(view)
changed_view['totals']['cash_avail'] = 9000
self.assertNotEqual(pr.portfolio_context(view, old), pr.portfolio_context(changed_view, old))
legacy = {k: v for k, v in old.items() if k != 'basis'}
self.assertNotEqual(pr.portfolio_context(view, legacy),
pr.portfolio_context(view, dict(legacy, amount=1100)))
def test_inflight_basis_is_stable_and_preserves_amount_rules(self):
from app.services import proposal_service as ps
from app.repo import pms_repo
ins = [{'instruction_id': 'i1', 'action': 'OPEN', 'ts_code': '600002.SH', 'qty': 100, 'exec_qty': 0},
{'instruction_id': 'held', 'action': 'OPEN', 'ts_code': '600003.SH', 'qty': 100}]
proposals = [{'proposal_id': 'own', 'action': 'OPEN', 'ts_code': '600001.SH', 'qty': 100},
{'proposal_id': 'p2', 'action': 'OPEN', 'ts_code': '600002.SH', 'qty': 200,
'hard_numbers': {'price': 9}}]
view = {'held': [{'ts_code': '600003.SH'}]}
with patch.object(pms_repo, 'list_instructions', return_value=ins), \
patch.object(pms_repo, 'list_proposals', return_value=proposals), \
patch.object(ps.market, 'get_prices', side_effect=[{'600002.SH': 10}, {'600002.SH': 11}, {}]):
old = ps._inflight_open_commitments(view, exclude_proposal='own')
new = ps._inflight_open_commitments(view, exclude_proposal='own')
missing_price = ps._inflight_open_commitments(view, exclude_proposal='own')
self.assertEqual(old['names'], {'600002.SH'})
self.assertEqual(old['amount'], 1000)
self.assertEqual(new['amount'], 1100)
self.assertEqual(missing_price['amount'], 0) # 原首条指令优先去重口径保持。
self.assertEqual(old['basis'], new['basis'])
self.assertEqual(old['basis'], [('instruction', 'i1', '600002.SH', 100, 0),
('proposal', 'p2', '600002.SH', 200, 0)])
with patch.object(pms_repo, 'list_instructions', return_value=[]), \
patch.object(pms_repo, 'list_proposals', return_value=[]), \
patch.object(ps.market, 'get_prices', side_effect=AssertionError('无在途不读行情')):
self.assertEqual(ps._inflight_open_commitments(view)['basis'], [])
def test_quote_only_recheck_keeps_confirmation_without_model(self):
from app.services import plan_recheck as rc, proposal_service as ps, portfolio, command_service
row = dict(selected()[0], consumption_id='test-consumption')
view = {'held': [], 'totals': {'cash_source': 'ws', 'cash_avail': 10000}}
old = {'names': {'600002.SH'}, 'amount': 1000,
'basis': [('instruction', 'i1', '600002.SH', 100, 0)]}
hard = {'plan_basis': pr.basis(row), 'scan_params_hash': pr.fingerprint({}),
'portfolio_context_hash': pr.portfolio_context(view, old), 'proposal_revision': 'same', 'consumption_id': 'saved', 'preparation': {'status': 'ready'}}
p = {'proposal_id': 'p1', 'action': 'OPEN', 'ts_code': row['ts_code'], 'hard_numbers': hard}
with patch.object(rc, 'fast_checks', return_value=None), patch.object(pf, 'read_current_plan', return_value={}), \
patch.object(portfolio, 'positions_view', return_value=view), \
patch.object(command_service, 'effective_stock_params', return_value={}), \
patch.object(ps, '_scan_params', return_value={}), \
patch.object(pf, 'candidates', return_value={'items': [row], 'decision': row['decision']}), \
patch.object(ps, '_inflight_open_commitments', return_value=dict(old, amount=1100)), \
patch.object(ps, '_scan_open', side_effect=AssertionError('报价变化不得重算')) as scan, \
patch.object(ps, '_route_one', side_effect=AssertionError('报价变化不得调用研判')) as route:
out = rc.before_accept(p, 'same')
self.assertTrue(out['ok'], out)
self.assertEqual(out['proposal']['hard_numbers']['version_check']['status'], 'passed')
scan.assert_not_called()
route.assert_not_called()
def test_recheck_ignores_rank_cutoffs_but_keeps_qualification(self):
raw = {'date': '2026-10-14', 'rank_axis': 'quality', 'decision': {'id': 'v2'},
'main': [{'code': 'SH600001', 'rank': 1, 'score': 230, 'tier': '强传导', 'evidence': {'theme': '电子'}},
{'code': 'SH600002', 'rank': 2, 'score': 210, 'tier': '强传导', 'evidence': {'theme': '电子'}}]}
p = dict(top_n=1, tiers=['强传导'], include_observe=False, min_score=0,
min_sources=0, min_upside=0, theme_cap_local=1, exclude_st=False,
rank_by_quality=True, rank_by_upstream=True, observe_if_fund_bull=False)
with patch.object(pf, '_params', return_value=p), patch.object(pf, 'get_plan', return_value=pf.parse_plan(raw)):
self.assertEqual([x['ts_code'] for x in pf.candidates(record=False)['items']], ['600001.SH'])
fresh = pf.candidates(record=False, recheck_code='600002.SH')
self.assertEqual([x['ts_code'] for x in fresh['items']], ['600002.SH'])
self.assertEqual(fresh['consumption']['kind'], 'rechecked')
self.assertEqual(pf.candidates(record=False, recheck_code='600002.SH', black=['600002.SH'])['items'], [])
def test_snapshot_retention_never_deletes_by_row_count(self):
from app.repo import pms_repo
with patch.object(pms_repo, 'execute', side_effect=AssertionError('不得按行数删除历史')):
self.assertEqual(pms_repo.prune_plan_snapshots(2), 0)
def test_material_change_replaces_qty_and_never_accepts_old_confirmation(self):
from app.services import plan_recheck as rc, proposal_service as ps, param_store
from app.repo import pms_repo
p = {'proposal_id': 'p1', 'action': 'OPEN', 'ts_code': '600001.SH', 'qty': 300,
'hard_numbers_json': '{}', 'hard_numbers': {'proposal_revision': 'old'}}
c = {'qty': 100, 'ts_code': p['ts_code'], 'hard_numbers': {'price': 10, 'plan_basis': {}}}
check = {'material': True, 'view': {'held': []}, 'params': {}, 'stock': {}}
with patch.object(rc, 'current_basis', side_effect=[check, {'ok':True,'provenance':{}}]), \
patch.object(pms_repo, 'record_proposal_check', return_value=1), \
patch.object(ps, '_scan_open', return_value=[c]) as scan, \
patch.object(ps, '_route_one', return_value={'verdict': {'verdict': 'PASS'}}) as route, \
patch.object(param_store, 'get_int', return_value=0), \
patch.object(pms_repo, 'publish_prepared_proposal', return_value=1) as revise, \
patch.object(pms_repo, 'insert_ledger', return_value=1):
out = rc.refresh_one(p)
self.assertTrue(out['ok'])
self.assertEqual(out['proposal']['qty'], 100)
self.assertNotEqual(out['proposal']['hard_numbers']['proposal_revision'], 'old')
self.assertEqual(scan.call_args.kwargs['exclude_proposal'], 'p1')
self.assertTrue(route.call_args.kwargs['review_only'])
self.assertTrue(c['_plan_recheck'])
def test_rejected_recheck_preserves_reason_without_accepting_or_upgrading_basis(self):
from app.services import plan_recheck as rc, proposal_service as ps, param_store
from app.repo import pms_repo
p = {'proposal_id': 'p1', 'action': 'OPEN', 'ts_code': '600001.SH', 'qty': 300,
'hard_numbers_json': '{}', 'hard_numbers': {'proposal_revision': 'old', 'plan_basis': {'old': True}}}
c = {'qty': 100, 'ts_code': p['ts_code'], 'hard_numbers': {'price': 10, 'plan_basis': {'new': True}}}
def reject(*args, **kw):
args[7]['rejected'].append({'ts_code': p['ts_code'], 'by': 'judge', 'failed': ['资金净流出,短期看空']})
with patch.object(pms_repo, 'record_proposal_check', return_value=1), \
patch.object(rc, 'current_basis', return_value={'material': True, 'view': {'held': []}, 'params': {}, 'stock': {}}), \
patch.object(ps, '_scan_open', return_value=[c]), patch.object(ps, '_route_one', side_effect=reject), \
patch.object(param_store, 'get_int', return_value=0), \
patch.object(pms_repo, 'withdraw_proposal', return_value=1) as record, \
patch.object(pms_repo, 'publish_prepared_proposal', side_effect=AssertionError('不得升级原批准依据')), \
patch.object(pms_repo, 'insert_instruction', side_effect=AssertionError('不得生成指令')):
out = rc.refresh_one(p)
self.assertFalse(out['ok'])
self.assertIn('最新研判不建议建仓:资金净流出,短期看空', out['error'])
hard = record.call_args.args[1]
self.assertEqual(hard['plan_basis'], {'old': True})
self.assertEqual(hard['proposal_revision'], 'old')
self.assertEqual(out['proposal']['qty'], 300)
self.assertEqual(hard['last_accept_check']['stage'], 'judge')
def test_blocked_recheck_distinguishes_rule_strategy_and_scan(self):
from app.services import plan_recheck as rc
from app.repo import pms_repo
p = {'proposal_id': 'p1', 'ts_code': '600001.SH', 'hard_numbers': {}}
examples = [({'rejected': [{'by': 'rule', 'failed': ['CASH: 可用资金不足']}]}, '交易条件不满足:可用资金不足'),
({'rejected': [{'by': 'system', 'why': '逻辑存疑'}]}, '当前策略不建议建仓:逻辑存疑'),
({'skipped': [{'why': '没有可用名额'}]}, '暂不满足建仓条件:没有可用名额')]
with patch.object(pms_repo, 'record_proposal_check', return_value=1), patch.object(pms_repo, 'withdraw_proposal', return_value=1):
for details, reason in examples:
out = rc._failed_recheck(p, details)
self.assertEqual(out['error'].removeprefix('提议已撤下。'), reason)
self.assertFalse(out['ok'])
def test_failed_recheck_does_not_overwrite_concurrent_proposal(self):
from app.services import plan_recheck as rc
from app.repo import pms_repo
with patch.object(pms_repo, 'record_proposal_check', return_value=0):
out = rc._failed_recheck({'proposal_id': 'p1', 'ts_code': '600001.SH'}, {})
self.assertFalse(out['ok'])
self.assertNotIn('proposal', out)
self.assertIn('已被更新', out['error'])
def test_record_check_is_conditional_and_keeps_quantity_status_and_verdict(self):
import sqlite3
from app.repo import pms_repo
db = sqlite3.connect(':memory:')
self.addCleanup(db.close)
db.execute('CREATE TABLE pms_proposal(proposal_id TEXT, status TEXT, qty INTEGER, judge_verdict TEXT, hard_numbers_json TEXT)')
db.execute("INSERT INTO pms_proposal VALUES ('p1','WAIT_USER',300,'UNAVAILABLE','old')")
with patch.object(pms_repo, 'execute', side_effect=lambda q, p: db.execute(q,p).rowcount):
old = {'proposal_id':'p1','hard_numbers_json':'old'}
self.assertEqual(pms_repo.record_proposal_check(old, {'check':'blocked'}), 1)
self.assertEqual(pms_repo.record_proposal_check(old, {'check':'stale'}), 0)
self.assertEqual(db.execute('SELECT qty,status,judge_verdict FROM pms_proposal').fetchone(), (300,'WAIT_USER','UNAVAILABLE'))
def test_previous_rejection_cannot_reuse_old_approval_when_context_returns(self):
from app.services import plan_recheck as rc, proposal_service as ps
p = {'proposal_id': 'p1', 'action': 'OPEN', 'ts_code': '600001.SH',
'hard_numbers': {'proposal_revision': 'old', 'last_accept_check': {'status': 'blocked'}}}
with patch.object(rc, '_mark_pending', side_effect=lambda p,*a: p), \
patch.object(__import__('app.repo.pms_repo', fromlist=['record_proposal_check']), 'record_proposal_check', return_value=1), \
patch.object(rc, 'current_basis', return_value={'ok': True, 'material': False,
'view': {'held': []}, 'params': {}, 'stock': {}}), \
patch.object(ps, '_scan_open', return_value=[]) as scan, \
patch.object(rc, '_failed_recheck', return_value={'ok': False}) as blocked:
self.assertFalse(rc.refresh_one(p)['ok'])
scan.assert_called_once()
blocked.assert_called_once()
def test_definitive_rejection_withdraws_and_ignores_scan_context(self):
from app.services import plan_recheck as rc
from app.repo import pms_repo
p = {'proposal_id':'p1','ts_code':'600001.SH','action':'OPEN','qty':100,'hard_numbers':{}}
out = {'rejected':[{'ts_code':p['ts_code'],'by':'judge','failed':['资金流出。']}],
'skipped':[{'why':"在途建仓已占3个名额 ['SH600002']"}]}
with patch.object(pms_repo, 'withdraw_proposal', return_value=1, create=True) as withdraw, \
patch.object(pms_repo, 'record_proposal_check', side_effect=AssertionError('明确拒绝必须撤下')):
result = rc._failed_recheck(p,out)
self.assertTrue(result['withdrawn'])
self.assertEqual(result['proposal']['status'],'EXPIRED')
self.assertNotIn('在途',result['error'])
self.assertEqual(withdraw.call_args.args[1]['last_accept_check']['status'],'withdrawn')
def test_withdrawal_transaction_is_atomic_and_idempotent(self):
from sqlalchemy import create_engine, text
from app.db import session
from app.repo import pms_repo
engine=create_engine('sqlite:///:memory:')
self.addCleanup(engine.dispose)
with engine.begin() as db:
db.execute(text('CREATE TABLE pms_proposal(proposal_id TEXT, status TEXT, decided_at TEXT, qty INTEGER, hard_numbers_json TEXT)'))
db.execute(text("INSERT INTO pms_proposal VALUES ('p1','WAIT_USER',NULL,100,'old')"))
old={'proposal_id':'p1','ts_code':'600001.SH','action':'OPEN','hard_numbers_json':'old'}
hard={'last_accept_check':{'stage':'judge','at':'2026-10-16T14:20:00+08:00','message':'资金流出','status':'withdrawn'}}
with patch.object(session,'get_engine',return_value=engine), patch.object(session,'_check_cooldown'):
with self.assertRaises(Exception):
pms_repo.withdraw_proposal(old,hard) # 账本不存在,状态必须一起回滚。
with engine.begin() as db:
self.assertEqual(db.execute(text('SELECT status FROM pms_proposal')).scalar(),'WAIT_USER')
db.execute(text('CREATE TABLE pms_action_ledger(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)'))
self.assertEqual(pms_repo.withdraw_proposal(old,hard),1)
self.assertEqual(pms_repo.withdraw_proposal(old,hard),0)
self.assertEqual(pms_repo.decide_proposal('p1','ACCEPTED',expected_hard='old'),0)
with engine.begin() as db:
self.assertEqual(tuple(db.execute(text('SELECT status,qty FROM pms_proposal')).one()),('EXPIRED',100))
self.assertEqual(db.execute(text('SELECT COUNT(*) FROM pms_action_ledger')).scalar(),1)
def test_recorded_rejections_cleanup_is_scoped_and_model_free(self):
from app.services import plan_recheck as rc
from app.repo import pms_repo
def prop(i,action='OPEN',stage='judge'):
return {'proposal_id':i,'ts_code':'600001.SH','action':action,'status':'WAIT_USER',
'hard_numbers':{'last_accept_check':{'status':'blocked','stage':stage,
'details':{'rejected':[{'by':stage,'failed':['原拒绝']} ]}}}}
rows=[prop('yes'),prop('sell','EXIT'),prop('rule',stage='rule'),prop('data',stage='scan')]
with patch.object(pms_repo,'list_proposals',return_value=rows), \
patch.object(rc,'_failed_recheck',return_value={'withdrawn':True}) as fail:
self.assertEqual(rc.withdraw_recorded_rejections(),1)
self.assertEqual(fail.call_args.args[0]['proposal_id'],'yes')
def test_unavailable_and_scan_notes_do_not_withdraw(self):
from app.services import plan_recheck as rc
from app.repo import pms_repo
p={'proposal_id':'p1','ts_code':'600001.SH','hard_numbers':{}}
with patch.object(pms_repo,'record_proposal_check',return_value=1), \
patch.object(pms_repo,'withdraw_proposal',side_effect=AssertionError('暂时失败保留'),create=True):
for detail in ({'skipped':[{'why':'候选池取不到'}]},
{'rejected':[{'by':'rule','failed':['PRICE: 读不到行情']}]},
{'skipped':[{'informational':True,'why':'在途占用'}]}):
out=rc._failed_recheck(p,detail)
self.assertFalse(out.get('withdrawn'))
self.assertNotIn('在途占用',out['error'])
def test_browser_wait_is_independent_of_judge_timeout(self):
from app.web import main
with patch.object(main.param_store, 'get_int', return_value=240):
out = main.api_decide_reasons()
self.assertEqual(out['request_timeout_ms'], 30000)
self.assertTrue(out['accept'])
def test_missing_candidate_during_pending_revision_is_not_withdrawn(self):
from app.services import plan_recheck as rc, proposal_service as ps, portfolio, command_service
from app.repo import pms_repo
with patch.object(portfolio,'positions_view',return_value={'held':[]}), \
patch.object(command_service,'effective_stock_params',return_value={}), \
patch.object(ps,'_scan_params',return_value={}), \
patch.object(pf,'candidates',return_value={'items':[],'decision':{'id':'v2'},
'refresh_status':{'pending_codes':['600001.SH']}}):
out=rc.current_basis({},'600001.SH')
self.assertFalse(out['ok'])
self.assertFalse(out.get('withdraw'))
def test_verified_qualification_loss_withdraws_without_judgement(self):
from app.services import plan_recheck as rc, proposal_service as ps
from app.repo import pms_repo
p={'proposal_id':'p1','ts_code':'600001.SH','action':'OPEN','hard_numbers':{}}
with patch.object(rc,'current_basis',return_value={'ok':False,'material':True,
'withdraw':True,'error':'已不满足候选资格'}), \
patch.object(pms_repo,'withdraw_proposal',return_value=1), \
patch.object(ps,'_route_one',side_effect=AssertionError('无需新研判')):
out=rc.refresh_one(p)
self.assertTrue(out['withdrawn'])
def test_version_unavailable_and_qualification_loss_preserve_proposal(self):
from app.services import plan_recheck as rc
p = {'action': 'OPEN', 'ts_code': '600001.SH', 'hard_numbers': {}}
for check in ({'ok': False, 'error': '版本不可用'},
{'ok': False, 'material': True, 'error': '资格失效'}):
with patch.object(rc, 'current_basis', return_value=check):
self.assertFalse(rc.before_accept(p, None)['ok'])
def test_compare_and_set_rejects_stale_and_duplicate_acceptance(self):
import sqlite3
import threading
from concurrent.futures import ThreadPoolExecutor
from app.repo import pms_repo
db = sqlite3.connect(':memory:', check_same_thread=False)
self.addCleanup(db.close)
db.execute('CREATE TABLE pms_proposal(proposal_id TEXT, status TEXT, decided_at TEXT, hard_numbers_json TEXT)')
db.execute("INSERT INTO pms_proposal VALUES ('p1', 'WAIT_USER', NULL, 'new')")
lock = threading.Lock()
def execute(sql, params):
with lock:
n = db.execute(sql, params).rowcount
db.commit()
return n
with patch.object(pms_repo, 'execute', execute):
self.assertEqual(pms_repo.decide_proposal('p1', 'ACCEPTED', expected_hard='old'), 0)
with ThreadPoolExecutor(2) as pool:
results = list(pool.map(lambda _: pms_repo.decide_proposal('p1', 'ACCEPTED', expected_hard='new'), range(2)))
self.assertEqual(sum(results), 1)
def test_rank_survives_to_single_slot(self):
rows = [dict(r, price=10) for r in selected()]
out = ae.scan_open(candidates=rows, params=params(open_signal_priority=False),
caps=caps(), room_amt=1_000_000, slots=1)
self.assertEqual(out['candidates'][0]['ts_code'], '600001.SH')
self.assertEqual(out['candidates'][0]['hard_numbers']['execution_rank'], 1)
def test_signal_priority_has_reason(self):
rows = [dict(r, price=10) for r in selected()]
rows[1]['sig_buy'] = {'reason': '盘中转多'}
out = ae.scan_open(candidates=rows, params=params(open_signal_priority=True),
caps=caps(), room_amt=1_000_000, slots=1)
self.assertEqual(out['candidates'][0]['ts_code'], '600002.SH')
self.assertEqual(out['candidates'][0]['hard_numbers']['priority_reason'], '盘中转多信号优先')
def test_unknown_themes_do_not_form_sector(self):
self.assertEqual(len(selected()), 2)
def test_rank_only_change_keeps_proposal(self):
row = selected()[0]
old = pr.basis(row)
row.update(selection_rank=20, research_rank=100, decision={'id': 'v2'})
self.assertEqual(pr.compare(old, row, row['ts_code']), 'unchanged')
row['risk'] = ['材料存在矛盾']
self.assertEqual(pr.compare(old, row, row['ts_code']), 'material')
def test_pending_or_unverifiable_does_not_pass(self):
row = selected()[0]
old = pr.basis(row)
row['refresh_status'] = {'pending_codes': [row['ts_code']]}
self.assertEqual(pr.compare(old, row, row['ts_code']), 'unavailable')
row.pop('refresh_status')
row['decision'] = None
self.assertEqual(pr.compare(old, row, row['ts_code']), 'unavailable')
def test_stale_human_confirmation_rejected(self):
from app.services import plan_recheck as rc
p = {'action': 'OPEN', 'ts_code': '600001.SH', 'hard_numbers': {'proposal_revision': 'new', 'consumption_id': 'saved', 'preparation': {'status':'ready'}}}
with patch.object(rc, 'fast_checks', return_value=None), \
patch.object(rc, 'current_basis', return_value={'ok': True, 'provenance': {}, 'view': {'held':[]}}):
self.assertFalse(rc.before_accept(p, 'old')['ok'])
self.assertTrue(rc.before_accept(p, 'new')['ok'])
def test_received_and_consumed_fingerprint_include_context(self):
old = {'decision': {'id': 'v1'}, 'params': {'top_n': 2}, 'order': ['A', 'B']}
new = copy.deepcopy(old)
new['params']['top_n'] = 1
self.assertNotEqual(pr.fingerprint(old), pr.fingerprint(new))
self.assertEqual(old['params']['top_n'], 2)
def test_pending_prefix_codes_normalize(self):
p = pf.parse_plan({'date': '2026-10-14', 'main': [{'code': 'SH600001', 'score': 1}],
'refresh_status': {'pending_codes': ['SH600001']}})
self.assertEqual(p['refresh_status']['pending_codes'], ['600001.SH'])
if __name__ == '__main__':
unittest.main()

View File

@ -0,0 +1,123 @@
"""本地:python scripts/unit_test_guard.py scripts/test_batch39_units.py。禁止联网。"""
import unit_test_guard # noqa: F401
import json
import unittest
from unittest.mock import patch
from test_wiring import install_fakes
from app.services import ledger_service as ls
from app.repo import downstream_repo as ds, qmt_repo as q
CODE = '600000.SH'
IID = 'INS_R_D01'
class ReplayOwnershipTest(unittest.TestCase):
def setUp(self):
self.fake = install_fakes(prices={CODE: 10.0})
self.fake.insert_instruction(instruction_id='INS_R', origin_type='plan', origin_id='P1',
ts_code=CODE, action='OPEN', side='buy', qty=100, status='DISPATCHED')
self.fake.instructions['INS_R']['created_at'] = '2026-10-15 09:00:00'
self.fake.qmt.enqueue_order(instruction_id=IID, parent_id='INS_R', ts_code=CODE,
side='buy', qty=100, limit_price=10, valid_until=0)
self.fake.qmt.orders[IID]['broker_order_id'] = 'BROKER-1'
self.fills = [dict(order_id=IID, ts_code=CODE, side='buy', qty=100, price=11,
done_time='2026-10-15 10:00:00', raw={'qmt_order_id': 'BROKER-1'})]
self.patcher = patch.object(ds, 'fetch_filled_orders', side_effect=lambda **kw: self.fills)
self.patcher.start()
self.addCleanup(self.patcher.stop)
def trade(self, seq=1, qty=100, side='buy'):
self.fake.qmt.put_trade(seq=seq, instruction_id=IID, ts_code=CODE,
side=side, qty=qty, price=10, fee=0)
def qty(self):
return self.fake.positions.get(CODE, {}).get('total_qty', 0)
def test_buy_in_both_sources_is_booked_once(self):
self.trade()
result = ls.replay_fills()
self.assertTrue(result['ok'], result)
self.assertEqual(self.qty(), 100)
self.assertEqual(self.fake.instructions['INS_R']['exec_qty'], 100)
self.assertEqual(ls.replay_fills()['actions'], 0)
self.assertEqual(self.qty(), 100)
def test_sell_in_both_sources_is_booked_once(self):
ls._apply_action(dict(kind='BUY', ts_code=CODE, qty=300, price=9))
self.fake.qmt.orders[IID]['side'] = 'sell'
self.fake.instructions['INS_R'].update(side='sell', action='EXIT')
self.fills[0]['side'] = 'sell'
self.trade(side='sell')
self.assertTrue(ls.replay_fills()['ok'])
self.assertEqual(self.qty(), 200)
def test_table_before_ws_waits_for_exact_trades(self):
self.assertTrue(ls.replay_fills()['ok'])
self.assertEqual(self.qty(), 0)
self.trade()
self.assertTrue(ls.replay_fills()['ok'])
self.assertEqual(self.qty(), 100)
def test_partial_ws_then_delayed_remainder(self):
self.trade(qty=73)
ls.replay_fills()
self.assertEqual(self.qty(), 73)
self.trade(seq=2, qty=27)
ls.replay_fills()
self.assertEqual(self.qty(), 100)
def test_external_fill_still_books(self):
self.trade()
self.fills.append(dict(self.fills[0], order_id='MANUAL-1', qty=200, raw={}))
result = ls.replay_fills()
self.assertTrue(result['ok'], result)
self.assertEqual(self.qty(), 300)
def test_broker_identity_works_when_table_id_differs(self):
self.fills[0]['order_id'] = 'DOWNSTREAM-1'
self.trade()
self.assertTrue(ls.replay_fills()['ok'])
self.assertEqual(self.qty(), 100)
def test_lookup_failure_leaves_fill_retryable(self):
with patch.object(q, 'orders_for_fill', side_effect=RuntimeError('unavailable')):
result = ls.replay_fills()
self.assertFalse(result['ok'])
self.assertEqual(self.qty(), 0)
self.assertNotIn(IID, json.loads(self.fake.params[ls.CURSOR_KEY])['seen'])
self.trade()
self.assertTrue(ls.replay_fills()['ok'])
self.assertEqual(self.qty(), 100)
def test_conflicting_code_does_not_fall_back_to_external(self):
self.fills[0]['ts_code'] = '600001.SH'
result = ls.replay_fills()
self.assertFalse(result['ok'])
self.assertFalse(self.fake.lots)
self.assertNotIn(IID, json.loads(self.fake.params[ls.CURSOR_KEY])['seen'])
def test_conflicting_broker_identity_is_held(self):
self.fills[0]['raw']['qmt_order_id'] = 'DIFFERENT'
self.assertFalse(ls.replay_fills()['ok'])
self.assertEqual(self.qty(), 0)
def test_smoke_table_mirror_cannot_reenter_book(self):
self.fake.qmt.orders[IID]['parent_id'] = 'SMOKE_1'
self.trade()
self.assertTrue(ls.replay_fills()['ok'])
self.assertEqual(self.qty(), 0)
def test_ownership_survives_dispatch_mode_change(self):
self.fake.params['PMS_DISPATCH_MODE'] = 'shadow'
self.trade()
self.assertTrue(ls.replay_fills()['ok'])
self.assertEqual(self.qty(), 100)
def test_two_owners_fail_closed(self):
self.fake.qmt.orders['OTHER'] = dict(self.fake.qmt.orders[IID], instruction_id='OTHER')
self.assertFalse(ls.replay_fills()['ok'])
self.assertEqual(self.qty(), 0)
if __name__ == '__main__':
unittest.main()

View File

@ -0,0 +1,174 @@
# -*- coding: utf-8 -*-
"""本地:python scripts/unit_test_guard.py scripts/test_batch40_units.py。历史修复离线回归。"""
import unit_test_guard # noqa
import sys
from pathlib import Path
sys.path.insert(0,str(Path(__file__).resolve().parents[1]))
import json
import unittest
from copy import deepcopy
from contextlib import contextmanager
from unittest.mock import patch
from app.core.ledger_repair import compile_repair, net_lot_cost, D
from app.db import session
CODE='600001.SH'
def fixture():
ins=dict(id=1,instruction_id='P',ts_code=CODE,qty=200,exec_qty=200,status='CONFIRMED',
progress_json='{"children":[{"ref":"P_D01"}]}',origin_id=None,updated_at='2026-10-15 10:00:00')
order=dict(instruction_id='P_D01',parent_id='P',ts_code=CODE,side='buy',broker_order_id='B',
status='FILLED',cum_qty=100,created_at='2026-10-15 10:00:00')
lot=dict(id=1,ts_code=CODE,instruction_id='P',qty=100,closed_qty=0,open_price='10.000',
open_date='2026-10-15',created_at='2026-10-15 10:01:00',lot_type='BASE',realized_pnl='0.00')
pos=dict(id=1,ts_code=CODE,total_qty=200,avg_cost='10.000',status='HOLDING')
payload=dict(ts_code=CODE,instruction_id='P_D01',trade_no='T',broker_order_id='B',side='buy',
qty=100,price=10,amount=1000,trade_time=1792029600000)
trade=dict(seq=1,payload_json=json.dumps(payload),processed=1,received_at='2026-10-15 10:00:00',
processed_at='2026-10-15 10:01:00')
tables=dict(pms_position=[pos],pms_instruction=[ins],pms_qmt_order=[order],pms_lot=[lot,dict(lot,id=2,
instruction_id=None,created_at='2026-10-15 10:02:00')],pms_qmt_inbox=[trade],pms_plan=[],pms_strategy=[])
return dict(instance='155-sim',at='2026-10-15T12:00:00+08:00',tables=tables,
position_snapshot={'payload':{'items':[dict(ts_code=CODE,total_qty=100,avail_qty=100,market_price=11)]}},
table_fills=[dict(order_id='P_D01',ts_code=CODE,side='buy',qty=100,price=10,done_time='2026-10-15 10:00:00')])
class CoreTests(unittest.TestCase):
def plan(self,b=None):return compile_repair(b or fixture(),[CODE])
def test_quantity_cost_progress_and_terminal_hold(self):
p=self.plan();s=p['summaries'][0]
self.assertEqual((s['qty'],s['avg_cost'],s['avail_qty']),(100,'10.000',0))
self.assertEqual(s['void_lots'],[2]);self.assertEqual(s['instructions'][0]['new_status'],'CANCELLED')
self.assertEqual(s['instructions'][0]['exec_qty'],100)
def test_determinism(self):self.assertEqual(self.plan(),self.plan())
def test_missing_trade_blocks(self):
b=fixture();b['tables']['pms_qmt_inbox']=[]
with self.assertRaises(ValueError):self.plan(b)
def test_duplicate_trade_blocks(self):
b=fixture();b['tables']['pms_qmt_inbox']*=2
with self.assertRaises(ValueError):self.plan(b)
def test_wrong_broker_blocks(self):
b=fixture();b['tables']['pms_qmt_order'][0]['broker_order_id']='X'
with self.assertRaises(ValueError):self.plan(b)
def test_missing_summary_evidence_blocks(self):
b=fixture();b['table_fills']=[]
with self.assertRaises(ValueError):self.plan(b)
def test_ambiguous_lot_blocks(self):
b=fixture();b['tables']['pms_lot'][1].update(instruction_id='P',created_at='2026-10-15 10:01:00')
with self.assertRaises(ValueError):self.plan(b)
def test_position_disagreement_blocks(self):
b=fixture();b['position_snapshot']['payload']['items'][0]['total_qty']=200
with self.assertRaises(ValueError):self.plan(b)
def test_pending_order_blocks(self):
b=fixture();b['tables']['pms_qmt_order'][0]['status']='PARTIAL'
with self.assertRaises(ValueError):self.plan(b)
def test_active_grid_cost_and_qty_follow_actual_lots(self):
b=fixture();t=b['tables'];t['pms_instruction'][0].update(origin_id='GRID',progress_json='{"leg":"grid_buy:3"}')
t['pms_lot'][0]['lot_type']='ADD'
t['pms_strategy']=[dict(id=1,ts_code=CODE,strategy_id='GRID',type='GRID',status='ACTIVE',
state_json='{"pending":null,"filled_levels":{"3":{"qty":200,"price":10}},"invested":2000}')]
p=self.plan(b);row=next(c for c in p['changes'] if c['table']=='pms_strategy')
st=json.loads(row['fields']['state_json'])
self.assertEqual(st['filled_levels']['3']['qty'],100);self.assertEqual(st['invested'],1000)
def test_missing_baseline_is_not_assumed_zero(self):
b=fixture();p=json.loads(b['tables']['pms_qmt_inbox'][0]['payload_json'])
p.update(trade_no='OLD',trade_time=p['trade_time']-86400000)
b['tables']['pms_qmt_inbox'].append(dict(b['tables']['pms_qmt_inbox'][0],seq=0,payload_json=json.dumps(p)))
with self.assertRaises(ValueError):self.plan(b)
def test_existing_live_parent_stays_live(self):
b=fixture();b['tables']['pms_instruction'][0]['status']='DISPATCHED'
self.assertEqual(self.plan(b)['summaries'][0]['instructions'][0]['new_status'],'DISPATCHED')
def test_real_overfill_is_not_erased(self):
b=fixture();b['tables']['pms_instruction'][0]['qty']=50
s=self.plan(b)['summaries'][0]['instructions'][0]
self.assertEqual((s['exec_qty'],s['overfill_qty']),(100,50))
def test_new_fill_invalidates_fixed_historical_average(self):
import sqlite3
from app.repo import pms_repo
with sqlite3.connect(':memory:') as db:
db.execute('CREATE TABLE pms_instruction (instruction_id TEXT, exec_qty INTEGER, exec_avg_price REAL, updated_at TEXT, progress_json TEXT)')
db.execute("INSERT INTO pms_instruction VALUES ('P',100,10,'old','fixed evidence')")
with patch.object(pms_repo,'execute',side_effect=lambda sql,params:db.execute(sql,params).rowcount):
pms_repo.add_instruction_exec('P',100)
row=db.execute('SELECT exec_qty,exec_avg_price,progress_json FROM pms_instruction').fetchone()
self.assertEqual(row,(200,None,'fixed evidence'))
def test_money_precision_does_not_multiply_rounded_average(self):
lots=[dict(qty=1,closed_qty=3,open_price='10.000',close_avg_price='10.003',realized_pnl='0.01')]
self.assertEqual(net_lot_cost(lots),D('9.99'))
def test_sell_rebuilds_pnl_and_remaining_cost(self):
b=fixture();t=b['tables'];o=dict(t['pms_qmt_order'][0],instruction_id='S_D01',parent_id='S',side='sell',cum_qty=40)
t['pms_qmt_order'].append(o);t['pms_instruction'].append(dict(t['pms_instruction'][0],id=2,instruction_id='S',qty=40))
p=json.loads(t['pms_qmt_inbox'][0]['payload_json']);p.update(instruction_id='S_D01',trade_no='T2',side='sell',qty=40,price=11,amount=440,trade_time=p['trade_time']+60000)
t['pms_qmt_inbox'].append(dict(t['pms_qmt_inbox'][0],seq=2,payload_json=json.dumps(p)))
b['position_snapshot']['payload']['items'][0]['total_qty']=60
s=self.plan(b)['summaries'][0]
self.assertEqual((s['qty'],s['realized_pnl'],s['avg_cost']),(60,'40.00','9.333'))
class Result:
def __init__(self,rows):self.rows=rows
def mappings(self):return self
def fetchall(self):return self.rows
class Engine:
def __init__(self):self.rows={1:{'id':1,'qty':100,'ts_code':CODE},2:{'id':2,'qty':200,'ts_code':CODE}};self.audit=[];self.fail=False
@contextmanager
def begin(self):
old=deepcopy((self.rows,self.audit))
try:yield self
except Exception:
self.rows,self.audit=old
raise
def execute(self,sql,params):
s=str(sql);session.assert_single_table(s)
if s.startswith('SELECT id FROM pms_op_log'):
return Result([{'id':1}] if any(x['op']=='history_repair_summary' and x['ref']==params['r'] for x in self.audit) else [])
if s.startswith('SELECT * FROM pms_lot'):return Result([deepcopy(self.rows[params['id']])])
if s.startswith('UPDATE'):
if self.fail and params['row_id']==2:raise RuntimeError('interrupted')
self.rows[params['row_id']].update({k:v for k,v in params.items() if k!='row_id'})
return Result([])
if s.startswith('INSERT INTO pms_op_log'):self.audit.append(deepcopy(params));return Result([])
raise AssertionError(s)
class TransactionTests(unittest.TestCase):
def setUp(self):
self.engine=Engine();self.plan=dict(run_id='TEST',changes=[dict(table='pms_lot',key={'id':i},before=deepcopy(r),fields={'qty':0}) for i,r in self.engine.rows.items()])
self.p=patch.object(session,'get_engine',return_value=self.engine);self.p.start();self.addCleanup(self.p.stop)
def test_success_and_idempotency(self):
self.assertEqual(session.apply_audited_repair(self.plan,[])['changed_rows'],2)
self.assertTrue(session.apply_audited_repair(self.plan,[])['already_applied'])
self.assertEqual(len(self.engine.audit),3)
def test_failure_rolls_back_all_rows_and_audit(self):
self.engine.fail=True
with self.assertRaises(RuntimeError):session.apply_audited_repair(self.plan,[])
self.assertEqual(self.engine.rows[1]['qty'],100);self.assertEqual(self.engine.audit,[])
def test_changed_before_image_rejects(self):
self.engine.rows[2]['qty']=201
with self.assertRaises(ValueError):session.apply_audited_repair(self.plan,[])
self.assertEqual(self.engine.rows[1]['qty'],100)
def test_forbidden_table_rejected(self):
self.plan['changes'][0]['table']='real_pms_lot'
with self.assertRaises(ValueError):session.apply_audited_repair(self.plan,[])
def test_audited_inverse_restores_original_values(self):
for row in self.engine.rows.values():row['updated_at']='2026-10-15 09:00:00'
for item in self.plan['changes']:item['before']=deepcopy(self.engine.rows[item['key']['id']])
original=deepcopy(self.engine.rows)
session.apply_audited_repair(self.plan,[])
changes=[]
for row in self.engine.audit:
if row['op']!='history_repair_row':continue
item=json.loads(row['params'])
changes.append(dict(table=item['table'],key=item['key'],before=item['after'],
fields={k:item['before'][k] for k in set(item['fields'])|{'updated_at'}}))
session.apply_audited_repair(dict(run_id='TEST',changes=changes),[],rollback=True)
self.assertEqual(self.engine.rows,original)
def test_single_table_guard_still_applies(self):
with self.assertRaises(session.MultiTableSQL):
session.apply_audited_repair(self.plan,[dict(name='bad',sql='SELECT * FROM pms_lot JOIN pms_position ON 1=1',expected=[])])
if __name__=='__main__':unittest.main()

View File

@ -0,0 +1,283 @@
"""本地:python scripts/unit_test_guard.py scripts/test_batch41_units.py。配置隔离、禁止联网。"""
import unit_test_guard
import os
import sys
import unittest
from datetime import datetime, timedelta
from unittest.mock import patch
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from test_wiring import install_fakes
from app.repo import pms_repo, qmt_repo
from app.services import executor, dispatcher, proposal_service, signal_service
from app.core import signal_rules
CODE = '002518.SZ'
def ins(fake, iid, action, side, qty=600, done=0):
fake.insert_instruction(instruction_id=iid, origin_type='proposal', origin_id=None,
ts_code=CODE, action=action, side=side, qty=qty, status='DISPATCHED',
progress={'children': [], 'deadline': '2026-10-21', 'is_command': False})
fake.instructions[iid]['exec_qty'] = done
return fake.instructions[iid]
class ConflictsTest(unittest.TestCase):
def setUp(self):
self.fake=install_fakes(params={'PMS_DISPATCH_MODE':'ws'})
self.fake.qmt.set_channel()
def test_old_partial_buy_stopped_before_exit(self):
from app.services import execution_conflicts as c
buy=ins(self.fake,'old','OPEN','buy',600,400)
sell=ins(self.fake,'exit','EXIT','sell',400,200)
result=c.enforce_exit(sell)
self.assertTrue(result['ok'])
self.assertEqual(buy['status'],'CANCELLED')
self.assertEqual((buy['qty'],buy['exec_qty']),(600,400))
self.assertEqual(sell['exec_qty'],200)
n=len(self.fake.ledger)
c.enforce_exit(sell)
self.assertEqual(len(self.fake.ledger),n)
def test_trim_pauses_without_cancelling_buy(self):
from app.services import execution_conflicts as c
buy=ins(self.fake,'old','OPEN','buy')
sell=ins(self.fake,'trim','TRIM','sell')
self.assertTrue(c.buy_blocker(CODE))
c.enforce_exit(sell)
self.assertEqual(buy['status'],'DISPATCHED')
sell['status']='CONFIRMED'
self.assertFalse(c.buy_blocker(CODE))
def test_t0_pair_is_not_exit(self):
from app.services import execution_conflicts as c
ins(self.fake,'t0','T0_ROUND','sell')
self.assertFalse(c.buy_blocker(CODE))
def test_dispatch_rejects_buy_with_active_sell(self):
ins(self.fake,'exit','EXIT','sell',400)
result=dispatcher.dispatch(instruction_id='buy_D01',parent_id='buy',ts_code=CODE,
side='buy',qty=200,limit_price=28,valid_until=datetime.now()+timedelta(minutes=10))
self.assertFalse(result['ok'])
self.assertEqual(self.fake.qmt.orders,{})
def test_lookup_failure_cannot_dispatch_buy(self):
with patch.object(pms_repo,'list_instructions',side_effect=RuntimeError('source down')):
r=dispatcher.dispatch(instruction_id='buy_D01',ts_code=CODE,side='buy',qty=200,limit_price=28)
self.assertFalse(r['ok'])
self.assertEqual(self.fake.qmt.orders,{})
def test_pending_sell_blocks_new_buy_proposals(self):
self.fake.insert_proposal(proposal_id='sell',ts_code=CODE,action='EXIT',qty=200,
hard_numbers={},expire_at=datetime.now()+timedelta(hours=1))
keys=proposal_service._inflight_keys()
for action in ('OPEN','ADD','FILL','DCA'):
self.assertIn((CODE,action),keys)
def test_signal_reason_preserved(self):
parsed=signal_rules.parse_intraday({'ts_code':CODE,'action':'SELL','confidence':'0.95',
'audit_reason':'支撑失守,资金流出','component_scores':'{"reason":"另一份理由"}'})
self.assertEqual(parsed['reason'],'支撑失守,资金流出')
parsed=signal_rules.parse_intraday({'component_scores':'{"reason":"资金流出"}'})
self.assertEqual(parsed['reason'],'资金流出')
def test_cancel_failure_keeps_stop_after_exit_completes(self):
from app.services import execution_conflicts as c
buy=ins(self.fake,'old','OPEN','buy',600,400)
sell=ins(self.fake,'exit','EXIT','sell',400,200)
with patch.object(dispatcher,'cancel',return_value={'ok':False,'error':'offline'}):
result=c.enforce_exit(sell)
self.assertFalse(result['ok'])
self.assertEqual(buy['status'],'DISPATCHED')
self.assertEqual(buy['progress']['stopped_by_exit'],'exit')
sell['status']='CONFIRMED'
r=dispatcher.dispatch(instruction_id='old_D03',parent_id='old',ts_code=CODE,
side='buy',qty=200,limit_price=28)
self.assertFalse(r['ok'])
self.assertEqual(self.fake.qmt.orders,{})
def test_cleanup_cancels_gated_plans_and_strategy_buy_proposal(self):
from app.services import execution_conflicts as c
self.fake.plans=[{'plan_id':'p1','ts_code':CODE,'action':'ADD','status':'GATED','filled_qty':0}]
self.fake.insert_proposal(proposal_id='t0buy',ts_code=CODE,action='T0_ROUND',qty=200,
hard_numbers={'kind':'strategy','side':'buy'},expire_at=datetime.now()+timedelta(hours=1))
result=c.enforce_exit(ins(self.fake,'exit','EXIT','sell',400))
self.assertTrue(result['ok'],result)
self.assertEqual(self.fake.plans[0]['status'],'CANCELLED')
self.assertEqual(self.fake.proposals['t0buy']['status'],'DECLINED')
self.assertTrue(any(x['arbiter']=='system' and x['ref_id']=='t0buy' for x in self.fake.ledger))
def test_all_exit_origins_share_executor_cleanup(self):
from app.services import execution_conflicts as c, portfolio, exec_advisor
for origin in ('system','proposal','plan','strategy'):
with self.subTest(origin=origin):
self.fake.instructions.clear()
buy=ins(self.fake,'old','OPEN','buy',600,400)
sell=ins(self.fake,'exit','EXIT','sell',400,200)
sell['origin_type']=origin
with patch.object(portfolio,'positions_view',return_value={'positions':[],'params':{}}), \
patch.object(executor.td,'trade_days_left',return_value=2), \
patch.object(exec_advisor,'decide',return_value={'action':'WAIT','reason':'等待可卖'}):
result=executor.run_tick()
self.assertEqual(buy['status'],'CANCELLED',result)
self.assertFalse(result['fired'])
self.assertEqual(sell['exec_qty'],200)
def test_dry_run_does_not_cancel(self):
from app.services import portfolio, exec_advisor
buy=ins(self.fake,'old','OPEN','buy',600,400)
ins(self.fake,'exit','EXIT','sell',400,200)
with patch.object(portfolio,'positions_view',return_value={'positions':[],'params':{}}), \
patch.object(executor.td,'trade_days_left',return_value=2), \
patch.object(exec_advisor,'decide',return_value={'action':'WAIT','reason':'等待可卖'}):
executor.run_tick(dry_run=True)
self.assertEqual(buy['status'],'DISPATCHED')
self.assertFalse(buy['progress'].get('stopped_by_exit'))
self.assertFalse(self.fake.ledger)
def test_queued_buy_rechecks_parent_and_exit(self):
from app.services import execution_conflicts as c
buy=ins(self.fake,'old','OPEN','buy')
row={'parent_id':'old','ts_code':CODE,'side':'buy'}
self.assertIsNone(c.queued_buy_blocker(row))
ins(self.fake,'exit','EXIT','sell')
self.assertTrue(c.queued_buy_blocker(row))
self.fake.instructions['exit']['status']='CONFIRMED'
buy['status']='CANCELLED'
self.assertTrue(c.queued_buy_blocker(row))
self.assertIsNone(c.queued_buy_blocker(dict(row,side='sell')))
def test_missing_parent_keeps_queue_unverified(self):
from app.services import execution_conflicts as c
with self.assertRaises(RuntimeError):
c.queued_buy_blocker({'parent_id':'missing','ts_code':CODE,'side':'buy'})
def test_finished_children_show_wait_instead_of_pending_order(self):
from app.services import execution_conflicts as c
row=ins(self.fake,'old','OPEN','buy',600,400)
row['progress']['last_decision']={'reason':'当日配额已出完'}
with patch.object(qmt_repo,'orders_for_parent',return_value=[{'status':'FILLED'}]):
self.assertEqual(c.instruction_progress([row])[0]['execution_label'],'等待下一批')
row['progress']['last_decision']={'reason':'可卖量不足, 顺延'}
with patch.object(qmt_repo,'orders_for_parent',return_value=[]):
self.assertEqual(c.instruction_progress([row])[0]['execution_label'],'等待可卖')
def test_pending_cancel_never_shown_as_finished(self):
from app.services import execution_conflicts as c
row=ins(self.fake,'old','OPEN','buy');row['status']='CANCELLED'
with patch.object(qmt_repo,'orders_for_parent',return_value=[{'status':'PARTIAL','cancel_state':'REQUESTED'}]):
self.assertEqual(c.instruction_progress([row])[0]['execution_label'],'撤单处理中')
with patch.object(qmt_repo,'orders_for_parent',side_effect=RuntimeError('unavailable')):
self.assertEqual(c.instruction_progress([row])[0]['execution_label'],'委托状态待核实')
def test_other_stock_not_blocked(self):
from app.services import execution_conflicts as c
ins(self.fake,'exit','EXIT','sell')
self.assertIsNone(c.buy_blocker('600000.SH'))
def test_claim_rejects_cancel_requested_atomically(self):
with patch.object(qmt_repo,'execute',return_value=0) as write:
self.assertFalse(qmt_repo.claim_order('child'))
self.assertIn("cancel_state = 'NONE'",write.call_args.args[0])
def test_outbox_drops_new_conflict_without_sending(self):
import asyncio
from unittest.mock import AsyncMock
from app.ws.runner import WsRunner
buy=ins(self.fake,'old','OPEN','buy')
ins(self.fake,'exit','EXIT','sell')
row={'instruction_id':'old_D03','parent_id':'old','ts_code':CODE,'side':'buy',
'qty':200,'limit_price':28,'valid_until':int((datetime.now()+timedelta(minutes=10)).timestamp()*1000),
'cancel_state':'NONE','status':'SENDING'}
loop=asyncio.new_event_loop()
asyncio.set_event_loop(loop)
self.addCleanup(loop.close)
runner=WsRunner()
with patch.object(qmt_repo,'next_queued',return_value=[row]), \
patch.object(qmt_repo,'claim_order',return_value=True), \
patch.object(qmt_repo,'get_order',return_value=row), \
patch.object(qmt_repo,'abort_order') as abort, \
patch.object(qmt_repo,'mark_sent'), \
patch.object(runner,'_send',new_callable=AsyncMock) as send:
asyncio.run(runner._drain_outbox('unused'))
abort.assert_called_once()
send.assert_not_called()
def test_outbox_source_failure_preserves_queue(self):
import asyncio
from unittest.mock import AsyncMock
from app.ws.runner import WsRunner
row={'instruction_id':'old_D03','parent_id':'old','ts_code':CODE,'side':'buy',
'valid_until':int((datetime.now()+timedelta(minutes=10)).timestamp()*1000), 'cancel_state':'NONE'}
loop=asyncio.new_event_loop()
asyncio.set_event_loop(loop)
self.addCleanup(loop.close)
runner=WsRunner()
with patch.object(qmt_repo,'next_queued',return_value=[row]), \
patch.object(qmt_repo,'claim_order',return_value=True), \
patch.object(qmt_repo,'get_order',return_value=row), \
patch.object(qmt_repo,'requeue_order') as retry, \
patch.object(qmt_repo,'mark_sent'), \
patch.object(runner,'_send',new_callable=AsyncMock) as send:
asyncio.run(runner._drain_outbox('unused'))
retry.assert_called_once()
self.assertIs(retry.call_args.args[-1],False)
send.assert_not_called()
def test_stale_progress_cannot_restore_stopped_buy(self):
from app.services import execution_conflicts as c
buy=ins(self.fake,'old','OPEN','buy',600,400)
sell=ins(self.fake,'exit','EXIT','sell',400,200)
with patch.object(dispatcher,'cancel',return_value={'ok':False,'error':'offline'}):
c.enforce_exit(sell)
buy['progress']={'children':[]} # 模拟并发旧进度覆盖,停止事实仍在追加账本中。
sell['status']='CONFIRMED'
result=dispatcher.dispatch(instruction_id='old_D03',parent_id='old',ts_code=CODE,side='buy',qty=200,limit_price=28)
self.assertFalse(result['ok'])
def test_terminal_parent_cannot_be_revived_by_old_dispatch_write(self):
buy=ins(self.fake,'old','OPEN','buy');buy['status']='CANCELLED'
self.assertEqual(pms_repo.update_instruction('old',status='DISPATCHED'),0)
self.assertEqual(buy['status'],'CANCELLED')
def test_human_accept_is_blocked_before_changing_proposal(self):
from app.web import main
ins(self.fake,'exit','EXIT','sell')
self.fake.insert_proposal(proposal_id='p',ts_code=CODE,action='OPEN',qty=200,
hard_numbers={},expire_at=datetime.now()+timedelta(hours=1))
with patch.object(main,'ok_logged',side_effect=lambda name,fn,**kw:fn()), \
patch.object(main,'_actor',return_value='test'):
result=main.api_decide(None,'p',{'decision':'ACCEPTED','reason':'用户确认'})
self.assertFalse(result['ok'])
self.assertEqual(self.fake.proposals['p']['status'],'WAIT_USER')
self.assertEqual(len(self.fake.instructions),1)
def test_human_exit_retains_t1_locked_quantity(self):
from app.web import main
self.fake.positions[CODE]={'ts_code':CODE,'total_qty':400,'avail_qty':0}
self.fake.insert_proposal(proposal_id='exit_prop',ts_code=CODE,action='EXIT',qty=200,
hard_numbers={},expire_at=datetime.now()+timedelta(hours=1))
with patch.object(main,'ok_logged',side_effect=lambda name,fn,**kw:fn()), \
patch.object(main,'_actor',return_value='test'), \
patch.object(main.td,'window_deadline',return_value='2026-10-21'):
result=main.api_decide(None,'exit_prop',{'decision':'ACCEPTED','reason':'确认清仓'})
self.assertTrue(result['ok'],result)
row=self.fake.instructions[result['instruction_id']]
self.assertEqual(row['qty'],200) # 不扩成当前400股
self.assertEqual(row['action'],'EXIT')
self.assertEqual(row['exec_qty'],0)
def test_human_exit_after_position_closed_still_stops_old_buy(self):
from app.web import main
buy=ins(self.fake,'old','OPEN','buy',600,400)
self.fake.positions[CODE]={'ts_code':CODE,'total_qty':0,'avail_qty':0}
self.fake.insert_proposal(proposal_id='exit_prop',ts_code=CODE,action='EXIT',qty=200,
hard_numbers={},expire_at=datetime.now()+timedelta(hours=1))
with patch.object(main,'ok_logged',side_effect=lambda name,fn,**kw:fn()), \
patch.object(main,'_actor',return_value='test'):
result=main.api_decide(None,'exit_prop',{'decision':'ACCEPTED','reason':'确认清仓'})
self.assertTrue(result['ok'],result)
self.assertIsNone(result['instruction_id'])
self.assertEqual(buy['status'],'CANCELLED')
self.assertEqual(buy['exec_qty'],400)
if __name__=='__main__':unittest.main()

View File

@ -0,0 +1,256 @@
"""开发机:python scripts/unit_test_guard.py scripts/test_batch42_units.py。配置隔离且禁网。"""
import unit_test_guard
import os
import sys
import copy
import unittest
from datetime import datetime, timedelta
from unittest.mock import patch
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from app.services import plan_recheck as rc, plan_feed as pf, proposal_service as ps
from app.repo import pms_repo
from app.core import plan_revision as pr
CODE='600183.SH'
def proposal(**kw):
h={'preparation':{'status':'ready'},'proposal_revision':'shown','consumption_id':'saved',
'decision':{'id':'prepared'},'plan_basis':{'risk':[]},'price':10,'sector':'电子','prepared_judgement':{'verdict':'PASS','reason':'原研究','degraded':False}}
p={'proposal_id':'p1','ts_code':CODE,'action':'OPEN','qty':100,'hard_numbers':h,
'hard_numbers_json':pms_repo._dumps(h),'expire_at':datetime.now()+timedelta(hours=1)}
p.update(kw)
return p
def current(**kw):
r={'ok':True,'view':{'held':[]},'params':{},'stock':{},'commitments':{},
'provenance':{'decision':{'id':'new'},'consumption_id':'unwritten','version_check':{'status':'passed'}},
'research_changed':False,'params_changed':False,'portfolio_changed':False}
r.update(kw)
return r
class PreparedProposalTest(unittest.TestCase):
def test_accept_ready_is_model_free_and_does_not_write_consumption(self):
with patch.object(rc,'current_basis',return_value=current()) as basis, \
patch.object(rc,'fast_checks',return_value=None), \
patch.object(ps,'_scan_open',side_effect=AssertionError('采纳不能扫描重算')), \
patch.object(ps,'_route_one',side_effect=AssertionError('采纳不能研判')), \
patch.object(pms_repo,'insert_plan_snapshot',side_effect=AssertionError('采纳不能写消费快照')):
out=rc.before_accept(proposal(),'shown')
self.assertTrue(out['ok'])
self.assertFalse(basis.call_args.kwargs['record'])
self.assertEqual(out['proposal']['hard_numbers']['consumption_id'],'saved')
self.assertEqual(out['proposal']['hard_numbers']['decision']['id'],'prepared')
self.assertEqual(out['proposal']['hard_numbers']['version_check']['checked_decision']['id'],'new')
def test_cash_or_other_position_change_can_accept_existing_quantity(self):
with patch.object(rc,'current_basis',return_value=current(ok=False,material=True,portfolio_changed=True)), \
patch.object(rc,'fast_checks',return_value=None), \
patch.object(ps,'_route_one',side_effect=AssertionError('资金变化不问模型')):
out=rc.before_accept(proposal(),'shown')
self.assertTrue(out['ok'])
self.assertEqual(out['proposal']['qty'],100)
def test_research_change_marks_pending_without_model(self):
with patch.object(rc,'current_basis',return_value=current(ok=False,research_changed=True)), \
patch.object(pms_repo,'record_proposal_check',return_value=1), \
patch.object(ps,'_route_one',side_effect=AssertionError('只能后台研判')):
out=rc.before_accept(proposal(),'shown')
self.assertTrue(out['pending'])
self.assertEqual(out['proposal']['hard_numbers']['preparation']['status'],'pending')
def test_pending_or_legacy_proposal_cannot_accept(self):
for h in ({},{'preparation':{'status':'pending','reason':'研究更新中'}}):
with patch.object(rc,'current_basis',side_effect=AssertionError('尚未准备不远程取数')):
out=rc.before_accept(proposal(hard_numbers=h),'shown')
self.assertTrue(out['pending'])
def test_expired_proposal_does_not_read_or_accept(self):
with patch.object(rc,'current_basis',side_effect=AssertionError('已过期')):
out=rc.before_accept(proposal(expire_at=datetime.now()-timedelta(seconds=1)),'shown')
self.assertFalse(out['ok'])
def test_stale_content_is_returned_without_recalculation(self):
with patch.object(rc,'current_basis',side_effect=AssertionError('旧页面不远程取数')):
out=rc.before_accept(proposal(),'old')
self.assertFalse(out['ok'])
self.assertEqual(out['proposal']['qty'],100)
def test_source_failure_is_closed_without_discarding_proposal(self):
with patch.object(rc,'current_basis',side_effect=RuntimeError('offline')), \
patch.object(pms_repo,'record_proposal_check',return_value=1):
out=rc.before_accept(proposal(),'shown')
self.assertFalse(out['ok'])
self.assertTrue(out['pending'])
self.assertEqual(out['proposal']['qty'],100)
self.assertEqual(out['proposal']['hard_numbers']['preparation']['status'],'pending')
def test_pause_or_money_block_is_saved_with_specific_reason(self):
with patch.object(rc,'current_basis',return_value=current()), \
patch.object(rc,'fast_checks',return_value='可用资金不足'), \
patch.object(pms_repo,'record_proposal_check',return_value=1):
out=rc.before_accept(proposal(),'shown')
self.assertEqual(out['error'],'可用资金不足')
self.assertTrue(out['pending'])
def test_prepared_research_not_reasked_for_portfolio_or_param_change(self):
old={'plan_basis':{'risk':[]},'portfolio_context_hash':'a','scan_params_hash':'a'}
self.assertFalse(pr.needs_new_judgement(dict(old,portfolio_context_hash='b',scan_params_hash='b'),old))
self.assertTrue(pr.needs_new_judgement(dict(old,plan_basis={'risk':['变化']}),old))
def test_read_current_plan_has_short_timeout_and_no_snapshot(self):
params={'base':'http://fixture','path':'/plan','timeout':30,'stale_tdays':1}
with patch.object(pf,'_params',return_value=params), patch.object(pf,'build_query',return_value={}), \
patch.object(pf,'fetch',return_value={'date':'2026-10-19'}) as fetch, \
patch.object(pf,'assert_fresh') as fresh, \
patch.object(pf,'_snapshot_quiet',side_effect=AssertionError('只读取')):
pf.read_current_plan()
self.assertEqual(fetch.call_args.kwargs['timeout'],3)
fresh.assert_called_once()
def test_new_proposal_not_ready_when_record_failed(self):
with patch.object(rc,'current_basis',return_value={'ok':False,'error':'建议保存未完成','stage':'record'}):
h=rc.prepare_new({'consumption_id':'c'},CODE,{'verdict':'PASS'})
self.assertEqual(h['preparation']['status'],'pending')
self.assertIn('保存',h['preparation']['reason'])
def test_new_proposal_ready_only_with_recorded_consumption(self):
with patch.object(rc,'current_basis',return_value=current()):
self.assertEqual(rc.prepare_new({},CODE,{'verdict':'PASS'})['preparation']['status'],'pending')
self.assertEqual(rc.prepare_new({'consumption_id':'c'},CODE,{'verdict':'PASS'})['preparation']['status'],'ready')
def _background(self, changed, *, route=None):
p=proposal()
c={'ts_code':CODE,'action':'OPEN','qty':100,'hard_numbers':{'consumption_id':'c','price':10,'plan_basis':{'risk':[]}}}
with patch.object(rc,'current_basis',side_effect=[current(ok=False,material=True,**changed),current()]), \
patch.object(pms_repo,'record_proposal_check',return_value=1), \
patch.object(ps,'_scan_open',return_value=[c]), \
patch.object(ps,'_route_one',return_value={'verdict':{'verdict':'PASS','reason':'原研究'}}) as routed, \
patch.object(pms_repo,'publish_prepared_proposal',return_value=1), \
patch.object(rc,'fast_checks',return_value='原数量不再满足资金条件'), patch.object(ps.param_store,'get_int',return_value=0):
out=rc.refresh_one(p)
return out,routed
def test_background_portfolio_change_reuses_judgement(self):
out,route=self._background({'portfolio_changed':True})
self.assertTrue(out['ok'])
self.assertEqual(route.call_args.kwargs['prepared_verdict']['reason'],'原研究')
self.assertFalse(route.call_args.args[0]['_plan_recheck'])
self.assertEqual(out['proposal']['hard_numbers']['proposal_revision'],'shown')
def test_background_research_change_uses_original_judge_pipeline(self):
out,route=self._background({'research_changed':True})
self.assertTrue(out['ok'])
self.assertIsNone(route.call_args.kwargs['prepared_verdict'])
self.assertTrue(route.call_args.args[0]['_plan_recheck'])
self.assertNotEqual(out['proposal']['hard_numbers']['proposal_revision'],'shown')
def test_active_update_lease_prevents_duplicate_judgement(self):
p=proposal();p['hard_numbers']['preparation']['lease_until']=(datetime.now().astimezone()+timedelta(seconds=100)).isoformat()
with patch.object(rc,'current_basis',side_effect=AssertionError('租约内不能重评')):
self.assertFalse(rc.refresh_one(p)['ok'])
def test_budget_exhausted_returns_to_pending_without_model(self):
with patch.object(rc,'current_basis',return_value=current(ok=False,research_changed=True)), \
patch.object(pms_repo,'record_proposal_check',return_value=1), \
patch.object(ps,'_judge_budget_left',return_value=False), \
patch.object(ps,'_scan_open',side_effect=AssertionError('预算不足不扫描')):
out=rc.refresh_one(proposal(),deadline=0)
self.assertTrue(out['pending'])
self.assertNotIn('lease_until',out['proposal']['hard_numbers']['preparation'])
def test_background_cas_loser_never_calls_model(self):
with patch.object(rc,'current_basis',return_value=current(ok=False,research_changed=True)), \
patch.object(pms_repo,'record_proposal_check',return_value=0), \
patch.object(ps,'_scan_open',side_effect=AssertionError('失去所有权')):
self.assertFalse(rc.refresh_one(proposal())['ok'])
def test_sell_and_strategy_proposals_keep_existing_path(self):
with patch.object(rc,'current_basis',side_effect=AssertionError('无选股重评')):
self.assertTrue(rc.before_accept(proposal(action='EXIT'),None)['ok'])
self.assertTrue(rc.before_accept(proposal(hard_numbers={'kind':'strategy'}),None)['ok'])
def test_publication_and_audit_rollback_and_concurrent_accept(self):
from sqlalchemy import create_engine,text
from app.db import session
engine=create_engine('sqlite:///:memory:');self.addCleanup(engine.dispose)
p=proposal();h=rc.ready_hard({'consumption_id':'c','price':10},{'verdict':'PASS'})
c={'qty':200,'hard_numbers':h};v={'verdict':'PASS'}
with engine.begin() as db:
db.execute(text('CREATE TABLE pms_proposal(proposal_id TEXT,status TEXT,qty INTEGER,hard_numbers_json TEXT,judge_verdict TEXT,judge_reason TEXT,decided_at TEXT)'))
db.execute(text("INSERT INTO pms_proposal VALUES ('p1','WAIT_USER',100,:old,NULL,NULL,NULL)"),{'old':p['hard_numbers_json']})
with patch.object(session,'get_engine',return_value=engine),patch.object(session,'_check_cooldown'):
with self.assertRaises(Exception):pms_repo.publish_prepared_proposal(p,c,v)
with engine.begin() as db:
self.assertEqual(db.execute(text('SELECT qty FROM pms_proposal')).scalar(),100)
db.execute(text('CREATE TABLE pms_action_ledger(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)'))
self.assertEqual(pms_repo.publish_prepared_proposal(p,c,v),1)
self.assertEqual(pms_repo.publish_prepared_proposal(p,c,v),0)
self.assertEqual(pms_repo.decide_proposal('p1','ACCEPTED',expected_hard=p['hard_numbers_json']),0)
with engine.begin() as db:
self.assertEqual(db.execute(text('SELECT COUNT(*) FROM pms_action_ledger')).scalar(),1)
def test_quantity_changed_requires_new_confirmation_identity(self):
h={'plan_basis':{'risk':[]}};v={'verdict':'PASS'}
self.assertNotEqual(pr.confirmation_revision(100,h,v),pr.confirmation_revision(200,h,v))
self.assertEqual(pr.confirmation_revision(100,h,v),pr.confirmation_revision(100,dict(h,decision={'id':'v2'},research_rank=99),v))
def test_real_fast_checks_capacity_and_funds_without_changing_quantity(self):
from app.services import market,portfolio,param_store,execution_conflicts
p=proposal()
view={'held':[],'params':{'max_names':5,'portfolio_cap':0.7,'scale':10000},
'totals':{'names_count':1,'portfolio_mv':1000,'cash_source':portfolio.CASH_WS,'cash_avail':2000}}
check=current(view=view,commitments={'names':set(),'amount':0})
with patch.object(execution_conflicts,'buy_blocker',return_value=None), \
patch.object(param_store,'get',return_value='propose_only'), \
patch.object(param_store,'get_int',return_value=0), \
patch.object(param_store,'get_bool',return_value=True), \
patch.object(market,'get_price',return_value=10), \
patch.object(market,'day_snapshot',return_value={}), \
patch.object(market,'get_ma5',return_value=10), \
patch.object(ps,'check_candidate_rules',return_value={'passed':True}) as gate:
self.assertIsNone(rc.fast_checks(p,check))
view['totals']['cash_avail']=900
self.assertIn('资金不足',rc.fast_checks(p,check))
view['totals']['cash_avail']=2000
check['commitments']['names']={'a','b','c','d'}
self.assertIn('名额不足',rc.fast_checks(p,check))
self.assertEqual(p['qty'],100)
gate.assert_called_once()
def test_route_reuses_prepared_verdict_without_judge(self):
from app.services import judge,param_store
c={'ts_code':CODE,'action':'OPEN','side':'buy','qty':100,'price':10,'reason':'原依据','hard_numbers':{}}
with patch.object(ps,'check_candidate_rules',return_value={'passed':True}), \
patch.object(ps,'_pos_of',return_value={}), \
patch.object(ps,'_self_decide',return_value={}), \
patch.object(ps,'_apply_advice_tier'), \
patch.object(judge,'request',side_effect=AssertionError('不许重复调用模型')), \
patch.object(param_store,'get_bool',return_value=False):
out=ps._route_one(c,{}, {},{},False,datetime.now(),True,{'autonomy':'propose_only'},
review_only=True,prepared_verdict={'verdict':'PASS','reason':'原结论'})
self.assertEqual(out['verdict']['reason'],'原结论')
def test_background_failure_stays_pending_and_does_not_publish(self):
with patch.object(rc,'current_basis',return_value=current(ok=False,portfolio_changed=True)), \
patch.object(rc,'fast_checks',return_value='资金不足'), \
patch.object(pms_repo,'record_proposal_check',return_value=1), \
patch.object(ps,'_scan_open',return_value=[]), \
patch.object(pms_repo,'publish_prepared_proposal',side_effect=AssertionError('无结果不能发布')):
out=rc.refresh_one(proposal())
self.assertFalse(out['ok'])
self.assertEqual(out['proposal']['hard_numbers']['preparation']['status'],'pending')
def test_prepare_final_source_failure_cannot_publish(self):
c={'ts_code':CODE,'qty':100,'hard_numbers':{'consumption_id':'c'}}
with patch.object(rc,'current_basis',side_effect=[current(ok=False,research_changed=True),{'ok':False,'error':'研究更新中'}]), \
patch.object(pms_repo,'record_proposal_check',return_value=1), \
patch.object(ps,'_scan_open',return_value=[c]), \
patch.object(ps,'_route_one',return_value={'verdict':{'verdict':'PASS'}}), \
patch.object(ps.param_store,'get_int',return_value=0), \
patch.object(pms_repo,'publish_prepared_proposal',side_effect=AssertionError('旧研究不能发布')):
out=rc.refresh_one(proposal())
self.assertTrue(out['pending'])
if __name__=='__main__':unittest.main()

View File

@ -0,0 +1,152 @@
"""开发机:python scripts/unit_test_guard.py scripts/test_batch43_units.py。隔离禁网,真实SQL事务。"""
import unit_test_guard
import os,sys,copy,tempfile,json
from datetime import datetime,timedelta
from types import SimpleNamespace
from concurrent.futures import ThreadPoolExecutor
from unittest.mock import patch
import unittest
sys.path.insert(0,os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from sqlalchemy import create_engine,text,event
from app.db import session
from app.repo import pms_repo
from app.services import plan_feed as pf,plan_recheck as rc,proposal_service as ps,portfolio,command_service,param_store,market,execution_conflicts
from app.core import plan_revision as pr,tradedays as td
from app.web import main
import requests
CODE='300693.SZ'
class AcceptancePathTest(unittest.TestCase):
def setUp(self):
self.tmp=tempfile.TemporaryDirectory();self.addCleanup(self.tmp.cleanup)
self.engine=create_engine('sqlite:///'+self.tmp.name+'/state.sqlite',connect_args={'check_same_thread':False})
self.addCleanup(self.engine.dispose)
def use(target,**kw):
p=patch(target,**kw);v=p.start();self.addCleanup(p.stop);return v
use('app.db.session.get_engine',return_value=self.engine);use('app.db.session._check_cooldown')
use('app.services.param_store.get',side_effect=lambda k,d=None:d)
use('app.services.param_store.get_int',side_effect=lambda k,d=0:d)
use('app.services.param_store.get_float',side_effect=lambda k,d=0:d)
use('app.services.param_store.get_list',side_effect=lambda k,d=None:d or [])
use('app.services.param_store.get_bool',side_effect=lambda k,d=False:True if k=='PMS_PLAN_VERSION_RECHECK' else d)
use('app.web.main._oplog');use('app.web.main._actor',return_value='test')
self.params=pf._params();self.params.update(base='http://bridge',tiers=['强传导'])
use('app.services.plan_feed._params',return_value=self.params)
self.view={'held':[],'params':{'max_names':40,'scale':2000000,'portfolio_cap':0.7},
'totals':{'names_count':0,'portfolio_mv':0,'cash_source':portfolio.CASH_WS,'cash_avail':100000}}
self.commitments={'names':set(),'amount':0,'basis':[]}
self.scan={'open_route_by_verdict':True}
use('app.services.portfolio.positions_view',return_value=self.view)
use('app.services.command_service.effective_stock_params',return_value={})
use('app.services.proposal_service._scan_params',return_value=self.scan)
use('app.services.proposal_service._inflight_open_commitments',return_value=self.commitments)
use('app.services.execution_conflicts.buy_blocker',return_value=None)
use('app.services.market.get_price',return_value=34.18)
use('app.services.market.day_snapshot',return_value={});use('app.services.market.get_ma5',return_value=34)
use('app.services.proposal_service.check_candidate_rules',return_value={'passed':True})
use('app.core.tradedays.window_deadline',return_value='2026-10-23')
use('app.services.proposal_service._scan_open',side_effect=AssertionError('不能重扫'))
use('app.services.proposal_service._route_one',side_effect=AssertionError('不能重问模型'))
use('app.repo.pms_repo.insert_plan_snapshot',side_effect=AssertionError('采纳不能写新消费'))
self.raw={'date':datetime.now().date().isoformat(),'schema_version':2,'decision':{'id':'live'},
'check_code':'SZ300693','found':True,'refresh_status':{'pending_codes':[]},
'main':[{'code':'SZ300693','name':'盛弘股份','score':230,'tier':'强传导','rank':555,
'verdict':'候选','risk':[],'company_review_text':'研究依据'}],'observe':[]}
def response(url,**kw):
self.assertEqual(url,'http://bridge/plan/check');self.assertEqual(kw['params'],{'code':CODE})
return SimpleNamespace(raise_for_status=lambda:None,json=lambda:copy.deepcopy(self.raw))
self.http=use('requests.get',side_effect=response)
selected=pf.candidates(record=False,recheck_code=CODE,plan_override=pf.parse_plan(self.raw),route_by_verdict=True)
h={'price':34.18,'sector':'电气设备','preparation':{'status':'ready'},'proposal_revision':'shown',
'consumption_id':'already-saved','decision':{'id':'prepared'},'plan_basis':pr.basis(selected['items'][0]),
'scan_params_hash':pr.fingerprint(self.scan),'portfolio_context_hash':pr.portfolio_context(self.view,self.commitments),
'prepared_judgement':{'verdict':'UNAVAILABLE','reason':'原人工确认依据','degraded':True}}
self.hard=h;self.pid='PRP_20261021_300693SZ_OPEN'
ddl=[
'CREATE TABLE pms_proposal(id INTEGER PRIMARY KEY,proposal_id TEXT UNIQUE,ts_code TEXT,action TEXT,qty INTEGER,hard_numbers_json TEXT,status TEXT,expire_at TEXT,decided_at TEXT,judge_verdict TEXT,judge_reason TEXT,archived_at TEXT)',
'CREATE TABLE pms_action_ledger(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)',
'CREATE TABLE pms_instruction(id INTEGER PRIMARY KEY,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,progress_json TEXT,created_at TEXT,updated_at TEXT)']
with self.engine.begin() as c:
for sql in ddl:c.execute(text(sql))
c.execute(text("INSERT INTO pms_proposal(proposal_id,ts_code,action,qty,hard_numbers_json,status,expire_at) VALUES (:pid,:code,'OPEN',500,:hn,'WAIT_USER',:expiry)"),
{'pid':self.pid,'code':CODE,'hn':pms_repo._dumps(h),'expiry':datetime.now()+timedelta(hours=1)})
def decide(self,revision='shown'):
return main.api_decide(None,self.pid,{'decision':'ACCEPTED','reason':'用户确认','proposal_revision':revision})
def counts(self):
with self.engine.connect() as c:return tuple(c.execute(text('SELECT COUNT(*) FROM '+t)).scalar() for t in ('pms_instruction','pms_action_ledger'))
def test_full_api_to_sql_accepts_prepared_quantity_and_pairs_original_source(self):
r=self.decide();self.assertTrue(r['ok'],r);self.assertEqual(self.counts(),(1,1))
with self.engine.connect() as c:
row=dict(c.execute(text('SELECT * FROM pms_instruction')).mappings().one())
self.assertEqual(row['qty'],500);p=json.loads(row['progress_json'])['plan']
self.assertEqual(p['consumption_id'],'already-saved');self.assertEqual(p['decision']['id'],'prepared')
self.assertEqual(p['version_check']['checked_decision']['id'],'live')
def test_transport_timeout_keeps_ready_and_retry_uses_same_confirmation(self):
self.http.side_effect=requests.exceptions.ReadTimeout('3 seconds')
r=self.decide();self.assertFalse(r['ok']);self.assertTrue(r['retryable']);self.assertEqual(self.counts(),(0,0))
self.assertEqual(pms_repo.get_proposal(self.pid)['hard_numbers']['preparation']['status'],'ready')
self.http.side_effect=lambda *a,**k:SimpleNamespace(raise_for_status=lambda:None,json=lambda:self.raw)
self.assertTrue(self.decide()['ok']);self.assertEqual(self.counts(),(1,1))
def test_response_lost_retry_returns_exact_existing_instruction(self):
a=self.decide();self.http.side_effect=AssertionError('重试已采纳不再查来源')
b=self.decide();self.assertTrue(b['already_accepted']);self.assertEqual(a['instruction_id'],b['instruction_id'])
self.assertEqual(self.counts(),(1,1))
def test_two_concurrent_confirmations_create_one_instruction_and_audit(self):
with ThreadPoolExecutor(2) as pool:r=list(pool.map(lambda _:self.decide(),range(2)))
self.assertTrue(all(x['ok'] for x in r),r);self.assertEqual(len({x['instruction_id'] for x in r}),1)
self.assertEqual(self.counts(),(1,1))
def test_instruction_or_audit_failure_rolls_back_confirmation(self):
for table in ('pms_instruction','pms_action_ledger'):
def fail(conn,cursor,statement,params,context,many):
if statement.startswith('INSERT INTO '+table):raise RuntimeError('故障注入')
event.listen(self.engine,'before_cursor_execute',fail)
try:r=self.decide()
finally:event.remove(self.engine,'before_cursor_execute',fail)
self.assertFalse(r['ok']);self.assertEqual(self.counts(),(0,0))
self.assertEqual(pms_repo.get_proposal(self.pid)['status'],'WAIT_USER')
self.assertTrue(self.decide()['ok'])
def test_stale_confirmation_cannot_accept(self):
self.assertFalse(self.decide('old')['ok']);self.assertEqual(self.counts(),(0,0))
def test_unknown_shape_or_wrong_stock_does_not_withdraw_or_accept(self):
for bad in ({},dict(self.raw,check_code='SH600000'),dict(self.raw,found=False),dict(self.raw,main=None)):
self.http.side_effect=lambda *a,**k:SimpleNamespace(raise_for_status=lambda:None,json=lambda:bad)
self.assertFalse(self.decide()['ok']);self.assertEqual(self.counts(),(0,0))
self.assertEqual(pms_repo.get_proposal(self.pid)['status'],'WAIT_USER')
def test_known_research_pending_is_not_transport_retry(self):
self.raw['refresh_status']['pending_codes']=['SZ300693']
r=self.decide();self.assertTrue(r['pending']);self.assertEqual(self.counts(),(0,0))
self.assertEqual(pms_repo.get_proposal(self.pid)['hard_numbers']['preparation']['status'],'pending')
def test_missing_qualification_withdraws(self):
self.raw.update(found=False,main=[])
r=self.decide();self.assertTrue(r['withdrawn'],r);self.assertEqual(self.counts(),(0,1))
self.assertEqual(pms_repo.get_proposal(self.pid)['status'],'EXPIRED')
def test_material_change_waits_for_background_not_accept(self):
self.raw['main'][0]['risk']=['重大风险变化']
self.assertTrue(self.decide()['pending']);self.assertEqual(self.counts(),(0,0))
def test_existing_quantity_still_requires_funds(self):
self.view['totals']['cash_avail']=100
r=self.decide();self.assertFalse(r['ok']);self.assertIn('资金不足',r['error']);self.assertEqual(self.counts(),(0,0))
def test_ready_portfolio_price_changes_keep_confirmation_when_quantity_fits(self):
self.view['totals']['cash_avail']=90000
before=pms_repo.get_proposal(self.pid)
self.assertTrue(rc.refresh_one(before)['ok'])
self.assertEqual(pms_repo.get_proposal(self.pid)['hard_numbers_json'],before['hard_numbers_json'])
self.assertEqual(self.counts(),(0,0))
self.assertTrue(self.decide()['ok'])
def test_source_recovery_restores_original_content_without_scan(self):
p=pms_repo.get_proposal(self.pid);h=dict(p['hard_numbers'],preparation={'status':'pending','stage':'source'})
pms_repo.record_proposal_check(p,h)
self.assertTrue(rc.refresh_one(pms_repo.get_proposal(self.pid))['ok'])
after=pms_repo.get_proposal(self.pid)
self.assertEqual(after['qty'],500);self.assertEqual(after['hard_numbers']['proposal_revision'],'shown')
self.assertTrue(self.decide()['ok']);self.assertEqual(self.counts(),(1,2))
def test_expiry_during_checks_prevents_commit(self):
original=rc.fast_checks
def expire(p,c):
session.execute("UPDATE pms_proposal SET expire_at=:at WHERE proposal_id=:pid",{'at':datetime.now()-timedelta(seconds=1),'pid':self.pid})
return original(p,c)
with patch.object(rc,'fast_checks',side_effect=expire):r=self.decide()
self.assertFalse(r['ok']);self.assertEqual(self.counts(),(0,0))
if __name__=='__main__':unittest.main()

View File

@ -0,0 +1,217 @@
"""开发机:python scripts/unit_test_guard.py scripts/test_batch44_units.py。高股息来源,隔离禁网。"""
import unit_test_guard
import os,sys,copy,json
from datetime import datetime,timedelta
from types import SimpleNamespace
from unittest.mock import patch
from concurrent.futures import ThreadPoolExecutor
import unittest
sys.path.insert(0,os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from sqlalchemy import text
import test_batch43_units as base43
from app.services import dividend_feed as df,plan_recheck as rc,proposal_service as ps,portfolio,command_service,param_store
from app.core import plan_revision as pr,action_engine as ae,tradedays as td
from app.repo import pms_repo
from app.web import main,auth
CODE='300693.SZ'
REF='a'*64
def source():
now=datetime.now(df.BJ)
decision={'id':'dividend_'+'b'*64,'source':'dividend','policy_version':'2026.10-1','cutoff_at':now.isoformat()}
c={'ts_code':CODE,'name':'合成公司','candidate_source':'dividend','src':'dividend','bucket':'dividend','verdict':'候选',
'decision':decision,'company_review':{'overall':'好','age_days':1},'company_review_text':'合成研究依据',
'review_ref':{'ref':'original-report'},'dividend_research':{'ref':REF,'conclusion':'有支持'},'rank':1,'selection_rank':1,
'risk':['需求可能下降'],'reasons':['高股息研究核验通过']}
return {'schema_version':1,'source':'dividend','data_date':str(td.prev_trade_day(now.date())),
'policy_version':'2026.10-1','checked_at':now.isoformat(),'decision':decision,'eligible_count':1,
'rows':[{'ts_code':CODE,'name':'合成公司','eligible':True,'reasons':[],'research_ref':REF,'candidate':c}]}
class DividendPathTest(unittest.TestCase):
decide=base43.AcceptancePathTest.decide
counts=base43.AcceptancePathTest.counts
def setUp(self):
base43.AcceptancePathTest.setUp(self)
self.patch('app.services.param_store.get',side_effect=lambda k,d=None:'http://bridge' if k=='PMS_PLAN_API_BASE' else d)
self.http.side_effect=lambda url,**kw:self.response(url,kw)
self.patch('app.core.tradedays.calendar_degraded',return_value=False)
self.patch('app.core.tradedays.is_trade_day',return_value=True)
# 样本与被测入口使用同一个日历,避免周一先按周五生成、再按周日核验。
self.data=source()
# Existing switch remains off: new source cannot bypass preparation/acceptance checks.
self.patch('app.services.param_store.get_bool',side_effect=lambda k,d=False:False if k=='PMS_PLAN_VERSION_RECHECK' else d)
c=df.candidates(record=False,recheck_code=CODE)['items'][0]
self.hard.update(candidate_source='dividend',dividend_ref=REF,dividend_policy_version='2026.10-1',plan_basis=c['plan_basis'])
self.save(self.hard)
def patch(self,target,**kw):
p=patch(target,**kw);r=p.start();self.addCleanup(p.stop);return r
def response(self,url,kw):
self.assertEqual(url,'http://bridge/research/dividend/candidates')
self.assertEqual(kw['timeout'],(1,3))
return SimpleNamespace(raise_for_status=lambda:None,json=lambda:copy.deepcopy(self.data))
def save(self,hard):
with self.engine.begin() as c:c.execute(text('UPDATE pms_proposal SET hard_numbers_json=:h WHERE proposal_id=:p'),{'h':pms_repo._dumps(hard),'p':self.pid})
def test_ready_accepts_without_research_and_retains_source(self):
self.assertTrue(self.decide()['ok']);self.assertEqual(self.counts(),(1,1))
with self.engine.connect() as c: row=c.execute(text('SELECT progress_json FROM pms_instruction')).scalar()
self.assertEqual(json.loads(row)['plan']['candidate_source'],'dividend')
self.assertEqual(json.loads(row)['plan']['dividend_ref'],REF)
def test_only_rank_and_age_change_do_not_reask(self):
self.data['rows'][0]['candidate'].update(rank=900,selection_rank=900)
self.data['rows'][0]['candidate']['company_review']['age_days']=9
self.assertTrue(self.decide()['ok'])
def test_company_research_change_closes_confirmation(self):
self.data['rows'][0]['research_ref']='c'*64
self.data['rows'][0]['candidate']['dividend_research']['ref']='c'*64
r=self.decide();self.assertTrue(r['pending']);self.assertEqual(self.counts(),(0,0))
def test_loss_of_eligibility_withdraws(self):
self.data['rows'][0].update(eligible=False,reasons=['资料不完整'])
self.data['rows'][0]['candidate']['verdict']='仅展示'
r=self.decide();self.assertTrue(r['withdrawn']);self.assertEqual(self.counts()[0],0)
self.assertEqual(pms_repo.get_proposal(self.pid)['status'],'EXPIRED')
def test_other_source_open_commitment_withdraws(self):
self.commitments['names'].add(CODE)
self.assertTrue(self.decide()['withdrawn']);self.assertEqual(self.counts()[0],0)
def test_unavailable_keeps_existing_prepared_suggestion(self):
import requests
self.http.side_effect=requests.Timeout('network')
self.assertTrue(self.decide()['retryable']);self.assertEqual(self.counts(),(0,0))
self.assertEqual(pms_repo.get_proposal(self.pid)['hard_numbers']['preparation']['status'],'ready')
def test_pending_not_accepted_when_legacy_switch_off(self):
self.hard['preparation']={'status':'pending','reason':'等待准备'};self.save(self.hard)
self.assertTrue(self.decide()['pending']);self.assertEqual(self.counts(),(0,0))
self.patch('app.services.tech_service.attach')
r=main.api_proposals(status='WAIT_USER',limit=100,include_archived=False)
self.assertFalse(r['data'][0]['accept_ready'])
def test_concurrent_accepts_use_one_transaction(self):
with ThreadPoolExecutor(2) as pool: rows=list(pool.map(lambda _:self.decide(),range(2)))
self.assertTrue(all(r['ok'] for r in rows),rows);self.assertEqual(self.counts(),(1,1))
def test_bad_contract_future_date_calendar_or_reference_refuses(self):
for change in (lambda d:d.update(data_date='2000-01-01'),lambda d:d['decision'].update(cutoff_at='2099-01-01T00:00:00+08:00'),lambda d:d['rows'][0]['candidate'].update(decision={}),lambda d:d['rows'][0]['candidate']['dividend_research'].update(ref='bad')):
self.data=source();change(self.data)
with self.assertRaises(df.PlanFeedError):df.read(code=CODE)
self.data=source()
with patch.object(td,'calendar_degraded',return_value=True):
with self.assertRaises(df.PlanFeedError):df.read(code=CODE)
def test_readonly_is_not_consumption_and_failed_record_blocks(self):
d=df.candidates(record=False,recheck_code=CODE);self.assertNotIn('error',d['consumption'])
with patch.object(pms_repo,'insert_plan_snapshot',side_effect=RuntimeError('save failed')):
d=df.candidates(record=True,recheck_code=CODE)
self.assertEqual(d['items'][0]['consumption_error'],'RuntimeError')
def test_snapshot_uses_source_and_compatible_consumption_kind(self):
with patch.object(pms_repo,'insert_plan_snapshot',return_value=1) as write:
d=df.candidates(record=True,recheck_code=CODE)
kw=write.call_args.kwargs;self.assertEqual(kw['meta']['source'],'dividend');self.assertEqual(kw['meta']['kind'],'rechecked')
self.assertEqual(kw['meta']['order'],[CODE]);self.assertEqual(kw['roster'][0]['plan_basis'],d['items'][0]['plan_basis'])
def test_first_background_prepare_dispatches_original_source(self):
h=copy.deepcopy(self.hard);h.update(preparation={'status':'pending','stage':'requested'},plan_basis=None)
self.save(h)
current=df.candidates(record=False,recheck_code=CODE)['items'][0]
fresh={'ts_code':CODE,'action':'OPEN','side':'buy','qty':500,'reason':'高股息建仓','price':34.18,
'hard_numbers':dict(self.hard,plan_basis=current['plan_basis'],consumption_id=current['consumption_id'])}
with patch.object(ps,'_scan_open',return_value=[fresh]) as scan, patch.object(ps,'_route_one',return_value={'verdict':{'verdict':'PASS','reason':'合成核验','confidence':0.8}}) as route, patch.object(pms_repo,'insert_plan_snapshot',return_value=1):
r=rc.refresh_one(pms_repo.get_proposal(self.pid))
self.assertTrue(r['ok'],r);self.assertEqual(scan.call_args.kwargs['candidate_source'],'dividend')
self.assertTrue(route.call_args.kwargs['review_only']);self.assertEqual(self.counts()[0],0)
self.assertEqual(pms_repo.get_proposal(self.pid)['hard_numbers']['preparation']['status'],'ready')
def test_legacy_off_still_prepares_only_dividend(self):
p=pms_repo.get_proposal(self.pid);other=copy.deepcopy(p);other['hard_numbers'].pop('candidate_source');other['proposal_id']='old'
with patch.object(pms_repo,'list_proposals',return_value=[p,other]),patch.object(rc,'refresh_one',return_value={'ok':True}) as call:
result=rc.refresh_pending()
self.assertEqual(len(result),1);self.assertEqual(call.call_args.args[0]['proposal_id'],self.pid)
class RequestTest(unittest.TestCase):
def setUp(self):
self.data=source();self.rows={}
self.mock('app.services.dividend_feed.read',side_effect=lambda **kw:copy.deepcopy(self.data))
self.mock('app.core.tradedays.is_trade_day',return_value=True)
self.mock('app.core.tradedays.calendar_degraded',return_value=False)
fixed=datetime.now().replace(hour=10,minute=0)
d=self.mock('app.services.dividend_feed.datetime');d.now.return_value=fixed
self.mock('app.services.param_store.get',side_effect=lambda k,d=None:d)
self.mock('app.services.param_store.get_bool',side_effect=lambda k,d=False:d)
self.mock('app.repo.pms_repo.get_proposal',side_effect=lambda pid:self.rows.get(pid))
self.insert=self.mock('app.repo.pms_repo.insert_proposal',side_effect=self.add)
self.mock('app.services.command_service.effective_stock_params',return_value={})
self.mock('app.services.portfolio.positions_view',return_value={'held':[]})
self.mock('app.services.execution_conflicts.buy_blocker',return_value=None)
self.mock('app.services.proposal_service._inflight_open_commitments',return_value={'names':set(),'amount':0,'basis':[]})
self.mock('app.services.proposal_service.proposal_expire_at',return_value=fixed.replace(hour=15))
self.mock('app.repo.pms_repo.insert_instruction',side_effect=AssertionError('请求不得生成指令'))
self.mock('app.services.proposal_service._route_one',side_effect=AssertionError('请求不得调用研判'))
def mock(self,key,**kw):
p=patch(key,**kw);v=p.start();self.addCleanup(p.stop);return v
def add(self,**kw):
if kw['proposal_id'] in self.rows:raise RuntimeError('duplicate')
self.rows[kw['proposal_id']]=dict(kw,status='WAIT_USER');return 1
def request(self):return df.request_preparation(CODE,REF,actor='test')
def test_request_has_zero_quantity_and_no_approval(self):
r=self.request();p=self.rows[r['proposal_id']]
self.assertEqual(p['qty'],0);self.assertEqual(p['hard_numbers']['preparation']['stage'],'requested')
self.assertEqual(p['hard_numbers']['requested_by'],'test')
def test_repeated_request_returns_existing_without_overwrite(self):
a=self.request();b=self.request();self.assertEqual(a['proposal_id'],b['proposal_id']);self.assertEqual(self.insert.call_count,1)
def test_terminal_proposal_not_revived(self):
p=self.request();self.rows[p['proposal_id']]['status']='DECLINED'
with self.assertRaises(ValueError):self.request()
def test_missing_support_or_changed_reference_does_not_queue(self):
self.data['rows'][0]['eligible']=False
with self.assertRaises(ValueError):self.request()
self.data['rows'][0]['eligible']=True
with self.assertRaises(ValueError):df.request_preparation(CODE,'old',actor='test')
self.assertEqual(self.insert.call_count,0)
def test_held_black_selling_inflight_or_failure_block(self):
cases=[('app.services.portfolio.positions_view',{'held':[{'ts_code':CODE}]}),
('app.services.command_service.effective_stock_params',{CODE:{'black':True}}),
('app.services.execution_conflicts.buy_blocker','正在清仓'),
('app.services.proposal_service._inflight_open_commitments',{'names':{CODE}})]
for target,value in cases:
with patch(target,return_value=value):
with self.assertRaises(ValueError):self.request()
with patch.object(ps,'_inflight_open_commitments',side_effect=RuntimeError('db failure')):
with self.assertRaises(RuntimeError):self.request()
self.assertEqual(self.insert.call_count,0)
def test_duplicate_insert_race_reuses_winner(self):
def raced(**kw):self.add(**kw);raise RuntimeError('duplicate')
self.insert.side_effect=raced
r=self.request();self.assertTrue(r['already_requested']);self.assertEqual(len(self.rows),1)
def test_api_authorization_requires_login_not_admin(self):
self.assertFalse(auth.is_public_path('/api/dividend/proposals'))
self.assertEqual(auth.authz_decision('POST','/api/dividend/proposals'),'any')
def test_original_basis_unchanged(self):
r={'score':1,'decision':{'id':'x'}}
self.assertNotIn('candidate_source',pr.basis(r));self.assertNotIn('dividend_ref',pr.basis(r))
class AssemblyTest(unittest.TestCase):
def test_real_scan_uses_existing_sizer_and_preserves_dividend_basis(self):
from contextlib import ExitStack
from test_batch20_units import params,caps
data=source()
view={'held':[],'params':{'max_names':20,'scale':2000000,'portfolio_cap':0.7},
'totals':{'names_count':0,'portfolio_mv':0,'cash_source':portfolio.CASH_WS,'cash_avail':500000}}
p=params(consensus_route=False,plan_by_advice=False)
settings=[(df,'read',data),(ps,'_macro_gate',{}),(param_store,'get','plan_api'),
(portfolio,'caps_ctx',caps()),(ps,'_inflight_open_commitments',{'names':set(),'amount':0,'basis':[]}),
(ps,'_buy_signals_today',{}),(ps,'_scan_params',p),(ps.market,'get_prices',{CODE:10}),
(ps.market,'get_ma5',10),(ps.market,'day_snapshot',{}),(ps.industry,'get_many',{CODE:'电子'}),
(pms_repo,'insert_plan_snapshot',1)]
with ExitStack() as stack:
for module,name,value in settings:stack.enter_context(patch.object(module,name,return_value=value))
out={'skipped':[]};rows=ps._scan_open(view,p,{}, {},{},out,review_code=CODE,exclude_proposal='own',candidate_source='dividend')
self.assertEqual(len(rows),1,out);c=rows[0]
expected,_=ae.eval_open(dict(data['rows'][0]['candidate'],price=10,sector='电子'),p,caps(),500000)
self.assertEqual(c['qty'],expected['qty']);self.assertEqual(c['hard_numbers']['dividend_ref'],REF)
self.assertEqual(c['hard_numbers']['plan_basis']['candidate_source'],'dividend');self.assertIn('高股息建仓',c['reason'])
def test_strict_inflight_read_cannot_hide_db_failure(self):
with patch.object(pms_repo,'list_instructions',side_effect=RuntimeError('db')):
with self.assertRaises(RuntimeError):ps._inflight_open_commitments({'held':[]},strict=True)
def test_normal_source_duplicate_does_not_overwrite_new_request(self):
c={'ts_code':CODE,'action':'OPEN','qty':500,'reason':'normal','hard_numbers':{}}
with patch.object(param_store,'get_int',return_value=24),patch.object(param_store,'get_bool',return_value=False),patch.object(ps,'_apply_advice_tier'),patch.object(pms_repo,'insert_proposal',side_effect=RuntimeError('duplicate')) as put,patch.object(pms_repo,'get_proposal',return_value={'status':'WAIT_USER'}):
pid=ps._make_proposal(c,10,{'verdict':'PASS'})
self.assertEqual(put.call_count,1);self.assertTrue(pid.endswith('_OPEN'))
if __name__=='__main__':unittest.main()

View File

@ -0,0 +1,142 @@
"""父指令数量上限。入口隔离配置并禁止联网,不以回放及时完成为前提。"""
import unit_test_guard
import os
import sys
import unittest
from datetime import datetime
from unittest.mock import patch
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from test_wiring import install_fakes
from app.repo import qmt_repo
from app.services import executor, exec_advisor
CODE = '002865.SZ'
NOW = datetime(2026, 10, 23, 9, 35)
class ParentQuantityTest(unittest.TestCase):
def setUp(self):
self.fake = install_fakes(prices={CODE: 35}, positions=[{
'ts_code': CODE, 'total_qty': 1300, 'avail_qty': 1300,
'base_qty': 1300, 'avg_cost': 32.82,
}], params={'PMS_DISPATCH_MODE': 'ws'})
self.fake.qmt.set_channel()
self.fake.insert_instruction(instruction_id='P', origin_type='strategy',
origin_id='STR', ts_code=CODE, action='TRIM', side='sell', qty=600,
status='DISPATCHED', progress={'deadline': '2026-10-23',
'is_command': False, 'children': []})
self.parent = self.fake.instructions['P']
# 使用仓储的真实入口形状。返回副本,避免内存共享掩盖两个任务的快照延迟。
self.orders = self.fake.qmt.orders
p = patch.object(qmt_repo, 'orders_for_parent',
side_effect=lambda pid: [dict(o) for o in self.orders.values()
if o['parent_id'] == pid])
p.start()
self.addCleanup(p.stop)
def child(self, status, done, *, qty=600, day=20261023, remember=True):
iid = 'P_D01'
self.fake.qmt.enqueue_order(instruction_id=iid, parent_id='P', ts_code=CODE,
side=self.parent['side'], qty=qty, limit_price=35, valid_until=1)
self.orders[iid].update(status=status, cum_qty=done)
if remember:
self.parent['progress']['children'].append(
{'ref': iid, 'ymd': day, 'qty': qty, 'mode': 'ws'})
def tick(self):
with patch.object(executor.td, 'ymd', return_value=20261023), \
patch.object(executor.td, 'trade_days_left', return_value=1), \
patch.object(exec_advisor, 'decide', return_value={
'action': 'FIRE', 'qty_hint': 600, 'limit_price': 35,
'reason': '测试触发'}), \
patch.object(executor.rule_gate, 'check', return_value={
'passed': True, 'failed': [], 'hard_numbers': {}}):
return executor.run_tick(now=NOW)
def test_filled_child_before_replay_does_not_sell_again(self):
self.child('FILLED', 600)
result = self.tick()
self.assertEqual(result['fired'], [])
self.assertEqual(len(self.orders), 1)
self.assertEqual(self.parent['exec_qty'], 0, '数量检查不能代替成交入账')
def test_actual_trailing_path_does_not_repeat_after_terminal_fill(self):
self.parent['progress'].update(origin='strategy', stype='TRAIL')
self.child('FILLED', 600)
with patch.object(executor.td, 'ymd', return_value=20261023), \
patch.object(executor.td, 'trade_days_left', return_value=1):
result = executor.run_tick(now=NOW)
self.assertEqual(result['errors'], [])
self.assertEqual(result['fired'], [])
self.assertEqual(len(self.orders), 1)
def test_partial_then_cancelled_only_releases_unfilled_tail(self):
self.child('CANCELLED', 400)
result = self.tick()
self.assertEqual([r['qty'] for r in result['fired']], [200])
def test_partial_live_keeps_whole_parent_reserved(self):
self.child('PARTIAL', 200)
self.parent['exec_qty'] = 200
self.assertEqual(self.tick()['fired'], [])
def test_previous_day_live_child_still_reserves_quantity(self):
self.child('ACCEPTED', 0, day=20261022)
self.assertEqual(self.tick()['fired'], [])
def test_previous_day_filled_child_waits_for_replay(self):
self.child('FILLED', 600, day=20261022)
self.assertEqual(self.tick()['fired'], [])
def test_zero_fill_expired_releases_quantity(self):
self.child('EXPIRED', 0)
self.assertEqual([r['qty'] for r in self.tick()['fired']], [600])
def test_replay_ahead_of_order_update_remains_conservative(self):
self.child('PARTIAL', 100, qty=400)
self.parent['exec_qty'] = 300
self.assertEqual(self.tick()['fired'], [])
def test_orphaned_progress_cannot_hide_filled_outlet(self):
self.child('FILLED', 600, remember=False)
self.assertEqual(self.tick()['fired'], [])
def test_outlet_read_failure_cannot_dispatch(self):
with patch.object(qmt_repo, 'orders_for_parent', side_effect=RuntimeError('不可读')):
result = self.tick()
self.assertEqual(result['fired'], [])
self.assertTrue(result['errors'])
def test_buy_obeys_same_parent_cap(self):
self.parent.update(side='buy', action='OPEN')
self.child('FILLED', 600)
self.assertEqual(self.tick()['fired'], [])
def test_filled_without_cumulative_quantity_cannot_release(self):
self.child('FILLED', 0)
self.assertEqual(self.tick()['fired'], [])
def test_missing_child_is_reserved_instead_of_ignored(self):
self.parent['progress']['children'] = [
{'ref': 'P_D01', 'qty': 600, 'ymd': 20261022, 'mode': 'ws'}]
self.assertEqual(self.tick()['fired'], [])
def test_overfill_never_creates_compensating_trade(self):
self.child('FILLED', 1200, qty=1200)
self.assertEqual(self.tick()['fired'], [])
self.assertEqual(len(self.orders), 1)
def test_terminal_partial_does_not_double_subtract_booked_fill(self):
self.child('CANCELLED', 400)
self.parent['exec_qty'] = 400
self.assertEqual([r['qty'] for r in self.tick()['fired']], [200])
def test_shadow_does_not_require_qmt_outlet(self):
self.fake.params['PMS_DISPATCH_MODE'] = 'shadow'
with patch.object(qmt_repo, 'orders_for_parent', side_effect=AssertionError('不应查出口')):
self.assertEqual([r['qty'] for r in self.tick()['fired']], [600])
if __name__ == '__main__':
unittest.main()

View File

@ -0,0 +1,108 @@
"""质地排序切换:资格、命令优先级与实际分配;配置隔离,禁止联网。"""
import unit_test_guard # noqa: F401
import os
import sys
import unittest
from unittest.mock import patch
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from app.core import planner
from app.services import plan_feed as pf, command_service as cs, param_store as ps
from config.settings import settings
from test_wiring import install_fakes
from test_batch20_units import caps, params
def sample():
return pf.parse_plan({'date': '2026-10-23', 'rank_axis': 'quality', 'main': [
{'code': 'SH600001', 'name': '质地好弱传导', 'tier': '弱传导', 'score': 220,
'rank': 1, 'research_rank': 2, 'verdict': '候选'},
{'code': 'SH600002', 'name': '质地中强传导', 'tier': '强传导', 'score': 245,
'rank': 2, 'research_rank': 9, 'verdict': '候选'},
{'code': 'SH600003', 'name': '已启动无传导', 'tier': '无传导', 'score': 201,
'rank': 3, 'research_rank': 15, 'verdict': '候选'}]})
class QualityCutoverTest(unittest.TestCase):
def setUp(self):
install_fakes(prices={f'60000{i}.SH': 10 for i in range(1, 5)},
params={'PMS_CANDIDATE_SOURCE': 'plan_api'})
def selected(self, **kw):
return pf.select_candidates(sample(), rank_by_upstream=True, **kw)
def plan(self, rows):
return planner.plan_increase_exposure(add_amount=10000, positions=[], candidates=rows,
ctx=caps(), params=params(batch_split=(1., 0., 0.)))
def commands(self, white=None, black=None, held=()):
sp = {c: {'white': True} for c in white or []}
sp.update({c: {'black': True} for c in black or []})
with patch.object(cs, 'effective_stock_params', return_value=sp), \
patch.object(pf, 'candidates', return_value=self.selected()):
return cs._candidates({'held': [{'ts_code': c} for c in held]})
def test_default_has_no_transmission_tier_gate(self):
self.assertEqual(settings.PMS_PLAN_TIERS, '')
self.assertEqual(ps.get_list('PMS_PLAN_TIERS'), [])
def test_quality_rank_precedes_stronger_transmission_score(self):
out = self.selected(top_n=1)
self.assertEqual(out['rank_mode'], 'upstream')
self.assertEqual([r['ts_code'] for r in out['items']], ['600001.SH'])
def test_weak_and_no_transmission_remain_eligible(self):
self.assertEqual(len(self.selected()['items']), 3)
self.assertEqual(self.selected()['dropped']['tier'], 0)
def test_explicit_tier_override_is_still_honored(self):
self.assertEqual([r['ts_code'] for r in self.selected(tiers=['强传导'])['items']], ['600002.SH'])
def test_held_black_st_and_display_filters_survive(self):
p = sample()
p['main'] += [dict(p['main'][0], ts_code='600004.SH', name='ST测试'),
dict(p['main'][0], ts_code='600005.SH', verdict='仅展示')]
out = pf.select_candidates(p, rank_by_upstream=True, held=['600001.SH'],
black=['600002.SH'], route_by_verdict=True)
self.assertEqual([r['ts_code'] for r in out['items']], ['600003.SH'])
self.assertEqual([out['dropped'][k] for k in ('held', 'black', 'st', 'display')], [1]*4)
def test_command_pipeline_keeps_selection_and_research_reference(self):
rows = self.commands()
self.assertEqual(rows[0]['selection_rank'], 1)
self.assertEqual(rows[0]['plan_provenance']['research_rank'], 2)
out = self.plan(rows)
self.assertEqual({r['ts_code'] for r in out['items']}, {'600001.SH'})
self.assertEqual(out['items'][0]['plan_provenance']['priority_reason'], '沿用候选筛选次序')
def test_whitelist_outside_plan_precedes_quality_rank(self):
out = self.plan(self.commands(white=['600004.SH']))
self.assertEqual({r['ts_code'] for r in out['items']}, {'600004.SH'})
def test_whitelist_already_in_plan_precedes_quality_rank(self):
rows = self.commands(white=['600002.SH'])
self.assertEqual(len(rows), 3)
out = self.plan(rows)
self.assertEqual({r['ts_code'] for r in out['items']}, {'600002.SH'})
self.assertEqual(out['items'][0]['plan_provenance']['research_rank'], 9)
self.assertEqual(out['items'][0]['plan_provenance']['priority_reason'], '用户白名单优先')
def test_whitelist_cannot_override_blacklist_or_existing_holding(self):
rows = self.commands(white=['600002.SH', '600004.SH'], black=['600002.SH'], held=['600004.SH'])
self.assertNotIn('600002.SH', [r['ts_code'] for r in rows])
self.assertNotIn('600004.SH', [r['ts_code'] for r in rows])
def test_legacy_source_without_rank_keeps_score_order(self):
rows = [{'ts_code': '600001.SH', 'score': 1, 'price': 10},
{'ts_code': '600002.SH', 'score': 2, 'price': 10}]
self.assertEqual({r['ts_code'] for r in self.plan(rows)['items']}, {'600002.SH'})
def test_only_legacy_metadata_rank_also_keeps_quality_order(self):
rows = self.commands()
for row in rows:
row.pop('selection_rank')
self.assertEqual({r['ts_code'] for r in self.plan(rows)['items']}, {'600001.SH'})
if __name__ == '__main__':
unittest.main()

View File

@ -0,0 +1,105 @@
"""账户资金口径:防止回笼重复计入,账户展示与策略估值分开。"""
import unit_test_guard # noqa: F401
import os
import sys
import unittest
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from app.core import rule_gate
from app.services import portfolio
from test_wiring import install_fakes
from test_batch3_units import ctx
FUNDS = dict(total_asset=1936261.62, available_cash=1806071.62,
frozen_cash=0.0, sell_return_today=1644823.13, market_value=130190.0)
class AccountFundsTest(unittest.TestCase):
def setUp(self):
self.fake = install_fakes(params={'PMS_TOTAL_SCALE': '2000000'})
def funds(self, **values):
data = dict(FUNDS, **values)
self.fake.qmt.put_snapshot(kind='funds', data=data)
return data
def gate(self, qty):
view = portfolio.positions_view()
caps = portfolio.caps_ctx(view, ts_code='600000.SH')
return rule_gate.check(side='buy', action='OPEN', qty=qty, price=10,
ctx=ctx(caps=caps))
def test_real_snapshot_sale_stat_does_not_create_extra_cash(self):
self.funds()
cash = portfolio.cash_view()
self.assertEqual(cash['cash_avail'], 1806071.62)
self.assertAlmostEqual(cash['cash_avail'] + cash['account_market_value'], cash['total_asset'])
def test_gate_rejects_order_only_affordable_with_double_count(self):
self.funds(available_cash=5000, sell_return_today=10000, total_asset=5000, market_value=0)
result = self.gate(1000)
self.assertFalse(result['passed'])
self.assertTrue(any(x.startswith('INSUFFICIENT_CASH:') for x in result['failed']))
self.assertEqual(result['hard_numbers']['cash_avail'], 5000)
def test_returned_sale_cash_remains_usable_in_reported_balance(self):
self.funds(available_cash=12000, sell_return_today=8000, total_asset=12000, market_value=0)
result = self.gate(1000)
self.assertTrue(result['passed'], result)
def test_zero_available_is_not_replaced_by_sale_stat(self):
self.funds(available_cash=0, sell_return_today=10000, total_asset=10000, frozen_cash=10000, market_value=0)
result = self.gate(100)
self.assertFalse(result['passed'])
self.assertEqual(result['hard_numbers']['cash_avail'], 0)
def test_frozen_cash_is_not_subtracted_twice(self):
self.funds(available_cash=8000, frozen_cash=2000, total_asset=10000, market_value=0)
result = self.gate(800)
self.assertTrue(result['passed'], result)
self.assertEqual(portfolio.overview()['frozen_cash'], 2000)
def test_missing_available_does_not_infer_cash_from_other_fields(self):
self.funds(available_cash=None)
cash = portfolio.cash_view()
self.assertEqual(cash['source'], 'estimate')
self.assertIsNone(cash['cash_avail'])
self.assertIsNone(cash['account_market_value'])
def test_stale_snapshot_does_not_masquerade_as_current_account(self):
self.fake.qmt.put_snapshot(kind='funds', data=FUNDS, age_sec=901)
result = portfolio.overview()
self.assertEqual(result['cash_source'], 'estimate')
for key in ('cash_avail', 'total_asset', 'account_market_value', 'frozen_cash'):
self.assertIsNone(result[key])
def test_account_display_does_not_change_strategy_valuation(self):
self.fake = install_fakes(prices={'002050.SZ': 34.41, '002518.SZ': 27.49, '688778.SH': 37.13},
positions=[{'ts_code': '002050.SZ', 'total_qty': 1800, 'avg_cost': 36.697},
{'ts_code': '002518.SZ', 'total_qty': 400, 'avg_cost': 27.549},
{'ts_code': '688778.SH', 'total_qty': 1400, 'avg_cost': 41.849}],
params={'PMS_TOTAL_SCALE': '2000000'})
self.funds()
result = portfolio.overview()
self.assertEqual(result['account_market_value'], 130190)
self.assertEqual(result['portfolio_mv'], 124916)
self.assertEqual(result['portfolio_pct'], 0.0625)
self.assertEqual(result['float_pnl'], -10746.8)
caps = portfolio.caps_ctx(portfolio.positions_view())
self.assertEqual(caps['portfolio_mv'], 124916)
self.assertEqual(caps['cash_avail'], 1806071.62)
def test_missing_account_value_is_not_replaced_by_market_estimate(self):
self.fake = install_fakes(prices={'600000.SH': 10}, positions=[
{'ts_code': '600000.SH', 'total_qty': 100, 'avg_cost': 8}])
self.funds(market_value=None, frozen_cash=None)
result = portfolio.overview()
self.assertIsNone(result['account_market_value'])
self.assertIsNone(result['frozen_cash'])
self.assertEqual(result['portfolio_mv'], 1000)
self.assertEqual(result['cash_avail'], 1806071.62)
if __name__ == '__main__':
unittest.main()

View File

@ -500,10 +500,10 @@ def _():
got = [(x["theme"], x["ts_code"]) for x in capped["items"]] got = [(x["theme"], x["ts_code"]) for x in capped["items"]]
assert [t for t, _ in got] == ["储能", "储能", "传感器", "传感器", "整车"], got assert [t for t, _ in got] == ["储能", "储能", "传感器", "传感器", "整车"], got
assert capped["dropped"]["theme"] == 5 # 储能多 4 只 + 传感器多 1 只 assert capped["dropped"]["theme"] == 5 # 储能多 4 只 + 传感器多 1 只
# 主题为空的行归到「(无主题)」一档, 不跟着别的主题挤 # 没有主题不是同一行业,不能共享限额。
p2 = pf.parse_plan({"date": "2026-07-29", "main": [ p2 = pf.parse_plan({"date": "2026-07-29", "main": [
{"rank": 1, "code": "SH600001", "score": 9}, {"rank": 2, "code": "SH600002", "score": 8}]}) {"rank": 1, "code": "SH600001", "score": 9}, {"rank": 2, "code": "SH600002", "score": 8}]})
assert len(pf.select_candidates(p2, top_n=5, theme_cap=1)["items"]) == 1 assert len(pf.select_candidates(p2, top_n=5, theme_cap=1)["items"]) == 2
@case("取数·build_query: 显式 top/obs_top/theme_cap 覆盖 QUERY_EXTRA 同名键; 0=不传") @case("取数·build_query: 显式 top/obs_top/theme_cap 覆盖 QUERY_EXTRA 同名键; 0=不传")

View File

@ -632,6 +632,33 @@ def t_j4():
restore() restore()
@case("[J4b] 新版收到身份写读一致,查询范围变化不能误认同版")
def t_j4b():
from app.services import plan_feed as pf
from unittest.mock import patch
store, restore = _with_fake_repo({"PMS_PLAN_SNAPSHOT": True})
try:
p = plan(main=[_r("600418.SH", 1, 242.24)], date="2026-07-30")
p.update(decision={'id': 'decision-a', 'input_hash': 'a'}, requested={'top': 300})
pf.snapshot(p)
before = len(store['rows'])
assert pf.preview_changes(p)['same_as_stored'] is True
with patch.object(pf, 'get_plan', return_value=p):
assert pf.changes()['in_sync'] is True
assert len(store['rows']) == before
q = dict(p, requested={'top': 100})
assert pf.preview_changes(q)['same_as_stored'] is False
q = dict(p, decision={'id': 'decision-b', 'input_hash': 'b'})
with patch.object(pf, 'get_plan', return_value=q):
assert pf.changes()['in_sync'] is False
assert pf.snapshot(q)['stored'] is True
with patch.object(pf, 'get_plan', return_value=q):
assert pf.changes()['in_sync'] is True
assert pf.preview_changes(q)['same_as_stored'] is True
finally:
restore()
@case("[J5] 只读预览能比出手上这份与库里那份的差异") @case("[J5] 只读预览能比出手上这份与库里那份的差异")
def t_j5(): def t_j5():
from app.services import plan_feed as pf from app.services import plan_feed as pf

View File

@ -0,0 +1,34 @@
// 本地:node scripts/test_proposal_dialog.cjs。内存替身,不发网络请求。
const fs=require('fs'),vm=require('vm'),assert=require('assert');
const html=fs.readFileSync(require('path').join(__dirname,'../app/web/static/index.html'),'utf8');
const block=html.slice(html.indexOf(' const decideDlg = reactive('),html.indexOf(' async function loadStrategies()'));
function make(response){
let n=0,resolve;
const ctx={reactive:x=>x,computed:f=>f,decideReasons:{accept:{a:'why'},decline:{}},loadDecideReasons:()=>{},
ElementPlus:{ElMessage:{warning:()=>{},success:()=>{},error:()=>{throw Error('failure must stay visible')}}},
loadProposals:async()=>{},loadInstructions:async()=>{},loadLedger:async()=>{},decideTimeoutMs:150000,
call:async(m,u,p,c)=>{n++;assert.equal(c.timeout,150000);return typeof response==='function'?response(p):response}};
vm.createContext(ctx);vm.runInContext(block+';this.t={decideDlg,decide,submitDecide}',ctx);
return {...ctx.t,count:()=>n};
}
(async()=>{
const row={proposal_id:'p1',qty:300,hard_numbers:{proposal_revision:'old'}};
let t=make({ok:false,error:'最新研判不建议建仓:资金净流出',proposal:{...row,hard_numbers:{...row.hard_numbers,last_accept_check:{message:'资金净流出'}}}});
t.decide(row,'ACCEPTED');t.decideDlg.code='ACCEPT_CONSENSUS';await t.submitDecide();
assert(t.decideDlg.visible);assert(!t.decideDlg.busy);assert(t.decideDlg.message.includes('资金净流出'));assert(!t.decideDlg.updated);
t=make({ok:false,error:'请确认更新后的建议',proposal:{...row,qty:100,judge_reason:'新理由',hard_numbers:{proposal_revision:'new'}}});
t.decide(row,'ACCEPTED');t.decideDlg.code='ACCEPT_CONSENSUS';await t.submitDecide();
assert(t.decideDlg.visible);assert(t.decideDlg.updated);assert.equal(t.decideDlg.row.qty,100);assert.equal(t.decideDlg.code,'');
t=make({ok:false,error:'timeout',uncertain:true});t.decide(row,'ACCEPTED');t.decideDlg.code='ACCEPT_CONSENSUS';await t.submitDecide();await t.submitDecide();
assert.equal(t.count(),1);assert(t.decideDlg.message.includes('尚未收到'));assert(!t.decideDlg.busy);
let done;t=make(()=>new Promise(r=>{done=r}));t.decide(row,'ACCEPTED');t.decideDlg.code='ACCEPT_CONSENSUS';const pending=t.submitDecide();await t.submitDecide();
t.decide({...row,proposal_id:'p2'},'DECLINED');assert.equal(t.decideDlg.row.proposal_id,'p1');assert.equal(t.count(),1);done({ok:true,instruction_id:'i1'});await pending;assert(!t.decideDlg.visible);
t=make(()=>{throw new Error('unexpected')});t.decide(row,'ACCEPTED');t.decideDlg.code='ACCEPT_CONSENSUS';await t.submitDecide();assert(!t.decideDlg.busy);assert(t.decideDlg.uncertain);
t=make({ok:false,withdrawn:true,error:'提议已撤下。资金流出',proposal:{...row,status:'EXPIRED'}});
t.decide(row,'ACCEPTED');t.decideDlg.code='ACCEPT_CONSENSUS';await t.submitDecide();await t.submitDecide();
assert(t.decideDlg.withdrawn);assert(t.decideDlg.visible);assert(!t.decideDlg.updated);assert.equal(t.count(),1);
assert(html.includes('<el-button v-if="!decideDlg.withdrawn"'));assert(html.includes('<template v-if="!decideDlg.withdrawn">'));
t.decide(row,'ACCEPTED');assert(!t.decideDlg.withdrawn);
const script=html.match(/<script>\s*([\s\S]*?)<\/script>/)[1];new vm.Script(script);
console.log('PASS: rejection, reconfirmation, uncertain result, concurrent click, finally and script syntax');
})().catch(e=>{console.error(e);process.exit(1)});

View File

@ -257,6 +257,10 @@ class FakeRepo:
and (not ts_code or i["ts_code"] == ts_code)] and (not ts_code or i["ts_code"] == ts_code)]
return out[:limit] return out[:limit]
def instruction_buy_stop(self, instruction_id):
return next((r for r in reversed(self.ledger) if r.get('ref_id') == instruction_id
and r.get('action') == 'BUY_STOP' and r.get('verdict') == 'PASS'), None)
def get_instruction(self, iid): def get_instruction(self, iid):
return self.instructions.get(iid) return self.instructions.get(iid)
@ -269,6 +273,8 @@ class FakeRepo:
i = self.instructions.get(iid) i = self.instructions.get(iid)
if not i: if not i:
return 0 return 0
if status == 'DISPATCHED' and i.get('status') not in ('PROPOSED', 'RULE_PASSED', 'JUDGE_PASSED', 'DISPATCHED'):
return 0
for k, v in (("status", status), ("exec_qty", exec_qty), for k, v in (("status", status), ("exec_qty", exec_qty),
("exec_avg_price", exec_avg_price), ("dispatch_ref", dispatch_ref), ("exec_avg_price", exec_avg_price), ("dispatch_ref", dispatch_ref),
("progress", progress)): ("progress", progress)):
@ -546,6 +552,14 @@ class FakeQmtRepo:
def get_order(self, instruction_id): def get_order(self, instruction_id):
return self.orders.get(instruction_id) return self.orders.get(instruction_id)
def orders_for_parent(self, parent_id):
return [dict(o) for o in self.orders.values() if o['parent_id'] == parent_id]
def orders_for_fill(self, *, order_id, broker_order_id=None):
return [r for r in self.orders.values()
if r["instruction_id"] == str(order_id)
or (broker_order_id and r.get("broker_order_id") == str(broker_order_id))][:2]
# ---- pms_qmt_inbox ---- # ---- pms_qmt_inbox ----
def put_trade(self, *, seq, instruction_id, ts_code, side, qty, price, fee=0.0, def put_trade(self, *, seq, instruction_id, ts_code, side, qty, price, fee=0.0,
trade_no=None, processed=0): trade_no=None, processed=0):
@ -646,7 +660,7 @@ def install_fakes(prices=None, positions=None, params=None, high5=None, prev_clo
for name in ("upsert_many", "delete_day_kind", "list_range", "count_by_kind"): for name in ("upsert_many", "delete_day_kind", "list_range", "count_by_kind"):
setattr(consensus_stat_repo, name, getattr(fake.consensus_stats, name)) setattr(consensus_stat_repo, name, getattr(fake.consensus_stats, name))
for _n in ("get_state", "inbox_pending_count", "queue_depth", "enqueue_order", for _n in ("get_state", "inbox_pending_count", "queue_depth", "enqueue_order",
"request_cancel", "get_order", "inbox_pending", "inbox_mark", "request_cancel", "get_order", "orders_for_parent", "orders_for_fill", "inbox_pending", "inbox_mark",
"inbox_orphan_count", "latest_snapshot"): "inbox_orphan_count", "latest_snapshot"):
setattr(qmt_repo, _n, getattr(fake.qmt, _n)) setattr(qmt_repo, _n, getattr(fake.qmt, _n))
fake.params.update(params or {}) fake.params.update(params or {})
@ -739,6 +753,7 @@ def _():
"/api/commands/{command_id}/cancel", "/api/plans", "/api/positions", "/api/commands/{command_id}/cancel", "/api/plans", "/api/positions",
"/api/positions/{ts_code}/lots", "/api/instructions", "/api/ledger", "/api/report", "/api/positions/{ts_code}/lots", "/api/instructions", "/api/ledger", "/api/report",
"/api/proposals", "/api/proposals/{proposal_id}/decide", "/api/proposals", "/api/proposals/{proposal_id}/decide",
"/api/dividend/candidates", "/api/dividend/proposals",
"/api/proposals/decide-reasons", # 2026-09-14 系统自决包: 裁决预设理由码表 "/api/proposals/decide-reasons", # 2026-09-14 系统自决包: 裁决预设理由码表
"/api/ops/replay", "/api/ops/replay",
"/api/ops/reconcile", "/api/ops/daily-settle", "/api/ops/report", "/api/ops/reconcile", "/api/ops/daily-settle", "/api/ops/report",
@ -1434,7 +1449,7 @@ def _():
assert fake.instructions["INS_A2"]["status"] == "EXPIRED" assert fake.instructions["INS_A2"]["status"] == "EXPIRED"
@case("组合快照·真钱取 ws 资金快照(含当日回笼); 取不到则标明是估的") @case("组合快照·真钱取 ws 可用余额,不重复加回笼;取不到则标明是估的")
def _(): def _():
from app.services import portfolio from app.services import portfolio
fake = install_fakes(prices={"600000.SH": 10.0}, params={"PMS_TOTAL_SCALE": "2000000"}) fake = install_fakes(prices={"600000.SH": 10.0}, params={"PMS_TOTAL_SCALE": "2000000"})
@ -1448,10 +1463,10 @@ def _():
v = portfolio.positions_view() v = portfolio.positions_view()
t = v["totals"] t = v["totals"]
assert t["cash_source"] == "ws", t assert t["cash_source"] == "ws", t
# 当日卖出回笼 T+0 可用, 必须算进去 —— 不算就把"卖一只买另一只"判成资金不足 # available_cash 已含可用回笼,统计字段不再相加。
assert t["cash_avail"] == round(971251.56 + 48900.0, 2), t assert t["cash_avail"] == 971251.56, t
assert t["total_asset"] == 981448.56, t assert t["total_asset"] == 981448.56, t
# 这一行是整件事的由来: 按 scale 估出来 200 万, 账户真钱只有 102 万, 差着一倍 # 按 scale 估出来 200 万,账户真钱只有约 97 万,两者不能混用。
assert t["cash_est"] > t["cash_avail"], (t["cash_est"], t["cash_avail"]) assert t["cash_est"] > t["cash_avail"], (t["cash_est"], t["cash_avail"])
# caps_ctx 要把真钱与来源一起带给规则闸, 否则闸门只能降级 # caps_ctx 要把真钱与来源一起带给规则闸, 否则闸门只能降级
caps = portfolio.caps_ctx(v, ts_code="600000.SH") caps = portfolio.caps_ctx(v, ts_code="600000.SH")