Compare commits

...
Author SHA1 Message Date
阿白叔 488bf027cc feat: update DeepSeek Harness and support runtime upgrades
Core regression / Python core, intervention UI and release configuration (push) Successful in 16m20s
Core regression / JavaScript syntax (push) Successful in 11s
Core regression / Python core, intervention UI and release configuration (pull_request) Failing after 11m11s
Core regression / JavaScript syntax (pull_request) Successful in 7s
2026-11-20 15:43:58 +08:00
abaishu0730 bd80f86357 Merge pull request 'feat: 新增独立工程校验工作台与可追溯换料闭环' (#30) from codex/independent-verification into main
Core regression / Python core, intervention UI and release configuration (push) Successful in 4m43s
Core regression / JavaScript syntax (push) Successful in 6s
2026-11-20 11:23:52 +08:00
阿白叔 0540a1e3bb Merge remote-tracking branch 'origin/main' into codex/independent-verification
Core regression / Python core, intervention UI and release configuration (push) Successful in 4m52s
Core regression / JavaScript syntax (push) Successful in 11s
Core regression / Python core, intervention UI and release configuration (pull_request) Successful in 4m35s
Core regression / JavaScript syntax (pull_request) Successful in 6s
2026-11-20 11:13:09 +08:00
阿白叔 846c4b92e9 test: read long verification report paths portably 2026-11-20 11:13:08 +08:00
abaishu0730 03ae2cdaa8 Merge pull request 'fix: 闭环提交批量替换结果,复用桌面并处理保存占锁' (#31) from codex/issue29-blocking-cleanup into main
Core regression / Python core, intervention UI and release configuration (push) Successful in 4m1s
Core regression / JavaScript syntax (push) Successful in 8s
2026-11-20 08:50:56 +08:00
阿白叔 4a438e027b fix: preserve batch receipts and resource recovery after review
Core regression / Python core, intervention UI and release configuration (push) Successful in 18m39s
Core regression / JavaScript syntax (push) Successful in 7s
Core regression / Python core, intervention UI and release configuration (pull_request) Successful in 11m51s
Core regression / JavaScript syntax (pull_request) Successful in 7s
2026-11-19 15:24:40 +08:00
阿白叔 b2a84404d8 fix: address independent verification review findings
Core regression / Python core, intervention UI and release configuration (push) Successful in 12m44s
Core regression / JavaScript syntax (push) Successful in 10s
Core regression / Python core, intervention UI and release configuration (pull_request) Failing after 24m33s
Core regression / JavaScript syntax (pull_request) Successful in 10s
2026-11-19 14:44:52 +08:00
阿白叔 7597e98eef docs: close remaining verification acceptance gates with full regression evidence
Core regression / Python core, intervention UI and release configuration (push) Successful in 4m54s
Core regression / JavaScript syntax (push) Successful in 13s
Core regression / Python core, intervention UI and release configuration (pull_request) Failing after 4m54s
Core regression / JavaScript syntax (pull_request) Successful in 6s
2026-11-18 18:34:14 +08:00
阿白叔 e63a82b695 fix: reconcile saved database locks without replaying replacements
Core regression / Python core, intervention UI and release configuration (push) Successful in 4m44s
Core regression / JavaScript syntax (push) Successful in 6s
Core regression / Python core, intervention UI and release configuration (pull_request) Successful in 3m57s
Core regression / JavaScript syntax (pull_request) Successful in 6s
2026-11-18 18:24:50 +08:00
阿白叔 b038951cc4 test: close packaged stop recovery and real saved handoff workflows 2026-11-18 18:00:22 +08:00
阿白叔 cdbc92fab8 fix: reuse managed desktop across batches with isolated leases 2026-11-18 10:38:11 +08:00
阿白叔 d9bfc57900 docs: record native verification closed-loop evidence and remaining gates 2026-11-18 10:25:22 +08:00
阿白叔 e65bed0408 test: enforce reproducible verification closed-loop standards 2026-11-18 10:23:14 +08:00
阿白叔 a74b810786 docs: record batch verification import acceptance 2026-11-18 09:39:16 +08:00
阿白叔 de16bbdfa1 fix: respect rejected batch import receipts 2026-11-18 09:36:48 +08:00
阿白叔 eda9403d94 feat: preview and batch import independent verification pairs 2026-11-18 09:32:26 +08:00
阿白叔 9ccf99bd8f docs: record verification delivery and remaining release limits 2026-11-17 19:37:16 +08:00
阿白叔 d08a940afe fix: verify saved replacements through native netlist exports 2026-11-17 19:35:38 +08:00
阿白叔 f91b4deb5e fix: preserve verification pagination and evidence during refresh 2026-11-17 19:33:21 +08:00
阿白叔 fe8765beec fix: show persisted verification resource failure reasons 2026-11-17 18:51:18 +08:00
阿白叔 a606ed9179 fix: preserve live verification owners across windows and durable stops 2026-11-17 18:44:02 +08:00
阿白叔 6175bdb254 fix: keep verification run controls and close cancellation consistent 2026-11-17 17:33:18 +08:00
阿白叔 211d139653 test: accept independent verification tasks and evidence workflows 2026-11-17 17:12:08 +08:00
阿白叔 d9cf6a07e9 fix: close batch execution and recovery lifecycle 2026-11-17 16:56:29 +08:00
阿白叔 ec677a2864 feat: export verification evidence and preserve result history 2026-11-17 16:03:02 +08:00
阿白叔 b9712ed651 feat: control and recover independent verification attempts 2026-11-17 15:59:28 +08:00
阿白叔 e6e9b6906d feat: add the independent verification workspace and evidence inspector 2026-11-17 15:52:25 +08:00
阿白叔 f25dd228fd feat: build traceable pin and network comparison evidence 2026-11-17 15:45:16 +08:00
阿白叔 deaf8c3ab4 feat: expose proven pin metadata and unsupported mapping coverage 2026-11-17 15:43:47 +08:00
阿白叔 de486a9c6b feat: classify verification checks with explicit evidence and coverage 2026-11-17 15:42:19 +08:00
阿白叔 4da211d5d2 feat: execute independent verification on immutable inputs 2026-11-17 15:40:23 +08:00
阿白叔 b3c8c9c126 feat: query current verification results and task summaries 2026-11-17 15:37:52 +08:00
阿白叔 76074f8d11 feat: receive verification inputs and import project pairs 2026-11-17 15:36:17 +08:00
阿白叔 f5d39f6261 feat: persist verification tasks inputs and attempts 2026-11-17 15:22:10 +08:00
阿白叔 0406028a02 feat: define independent verification contracts and verdicts 2026-11-17 15:19:38 +08:00
阿白叔 dbb264f679 docs: record approved independent verification implementation plan 2026-11-17 15:14:50 +08:00
阿白叔 b19afc6a53 test: complete blocker spy for asynchronous model readiness callbacks
Core regression / Python core, intervention UI and release configuration (push) Successful in 3m53s
Core regression / JavaScript syntax (push) Successful in 12s
2026-11-16 11:17:43 +08:00
abaishu0730 6a8bf08809 fix: wait for official workspace synchronization (#28)
Core regression / Python core, intervention UI and release configuration (push) Failing after 3m41s
Core regression / JavaScript syntax (push) Successful in 8s
包含审查修复及 V1.3.1 实机测试版准备;Mentor 退出超时与 CAD20 仍待实机复核。
2026-11-16 11:10:17 +08:00
195 changed files with 20276 additions and 3944 deletions

No files matched your search

+2 -1
View File
@@ -49,8 +49,9 @@ jobs:
npm install --prefix /opt/ci-node --no-audit --no-fund node@24.11.1
node --version
npm ci --prefix integration/dsh --no-audit --no-fund
- name: Read-only model availability (real Harness, no remote model calls)
- name: Runtime and model availability (real Harness, no remote model calls)
run: |
node tools/verify_dsh_runtime.mjs
node tools/verify_dsh_model_availability.mjs
node --test tests/integration/test_dsh_standard_compat.mjs
node tools/verify_dsh_incident_restart.mjs
@@ -0,0 +1,9 @@
# 引脚字段读取范围
FREEFORM / FLAT BLOCKS 原生文本中的 `Pin 名称\tnum 编号\ttype 类型码` 可以与已解析图的实例、位号、物理脚号核对。适配器保留文件 SHA256 和行号,重复或无法绑定的字段不进入已证明清单。类型码按原文展示,不臆造类型语义。
自建格式夹具验证了逻辑名和电气类型码。另对已有工程的两份已保存副本执行了真实原生只读导出:前后各 57 个器件,83 个物理引脚取得了名称和类型码的原文证明。验收记录在本机 `D:/dx-vfy-native-final/acceptance.json`;原始客户工程和网表不提交 Git。
引脚级 Value 尚未在该格式中证明,保持 unknown;器件 Value 不能代替它。确切库版本内部的引脚到焊盘映射尚未支持,保持未覆盖。若检查计划要求这些未证明字段,结论必须为 INCOMPLETE(已有明确硬异常时仍为 DIFFERENT)。
探针:`python tools/probe_verification_pin_metadata.py <受管导出/netlist.json>`,只读已有输出,不调用 CAD、不修改工程。
@@ -0,0 +1,32 @@
# 批量替换阻塞与状态闭环实施计划
按用户在本聊天确认的设计执行。保留此前 issue29 修复,不修改其他聊天的 independent-verification 文档。
## 用户已确定的规则
- 位号可明确定位时忽略 UID 缺失、异常、重复或变化;贯通清单、计划、执行、回读、恢复和网表。
- 同工程统一保存/关闭重开/回读一次,暂停时提前提交;提交前不得记作 saved_ok。
- Mentor 和全部自有写进程确认退出后,隔离残留桌面并放行新批次,不假报桌面已释放。
- 结果不确定的工程保留待核验并隔离,同写入源一并隔离;释放全部自有写进程后继续独立工程。人工暂停停止整批。
- 操作回执、任务、队列状态幂等收敛。已保存结果、网表验收、资源告警分别展示。
- 补齐关键调用进入/返回和等待原因及诊断包,不让清理错误覆盖原错误。
## 实施任务
1. 位号身份:原生清单与目标键使用位号身份,保留原始 UID 证据;旧计划/成功操作编号不变,执行与网表允许位号关联,合法多单元及真实歧义分别处理。
2. 工程提交/暂停:增加待保存及工程提交记录,工程结束或暂停统一保存回读,所有待提交项原子转完成;SafeStop 不包装成 Baseline,确认未写入暂停返回 pending/paused;未知保存仍 blocked。
3. 资源隔离:新增隔离终态和明确阻断字段,持久化进程退出证明;残留桌面不重复 Quit/CloseDesktop,新会话可进入;未知写进程不得隔离放行。
4. 工程与任务隔离:新增 BLOCKED,工程异常释放后继续独立工程,区分本地回收控制和用户暂停;共享工程/iCDB写入源隔离,旧回执不重放。
5. 诊断与状态:明确停止原因/等待原因,记录关键操作进入返回;诊断包含执行日志、worker进度、原生报告和提交证据,保留脱敏/体积限制;UI正确显示 blocked/failed/paused/completed。
6. 集成验收:按设计20种场景测试,回归现有队列/恢复/资源/UI/网表;本机CAD仅副本,不把fake和CLI协议验证称为真实CAD验收;记录每工程save次数及阶段计时。打包候选版但不自动发布旧Release。
## 接口约定
- 现有 @REFDES| 标识复用,不改写旧成功操作编号。
- saved_ok 仅表示保存回读已通过。新增暂存状态必须由工程提交记录覆盖后才能转 verified。
- 隔离桌面保持 desktop_released=false;写进程退出证据与桌面存在性分开。
- BLOCKED是业务待核验,不等于全局资源未释放。
## 工作区与验证
当前分支 codex/issue29-blocking-cleanup,base b19afc6。已有未提交变更已完成此前回归,用户授权本轮继续实施。每个非平凡行为先RED后GREEN。阶段回归按实际修改选择,最终检查 tracked diff、打包产物和验收覆盖。
@@ -0,0 +1,324 @@
# 独立校验新增功能 Implementation Plan
> **For agentic workers:** REQUIRED SUB-SKILL: Use `superpowers:executing-plans` to implement task-by-task. N01–N12 implementation and local development-package acceptance are complete. Continuous full-suite stability remains a release gate; see the acceptance record. Do not start implementation from the UI image alone or dispatch agents without user authorization.
**Goal:** 新增可独立创建、接收成功结果、执行并让人复核的工程校验任务,交付 A 工作台及完整判断/失败处理。
**Architecture:** 在现有原生捕获、导出、图比较、回执证明之上增加校验领域包;任务、工程项、不可变输入版本、执行尝试与本次运行范围各有身份。界面只查持久事实和证据;统一输入接口不包含来源分类,批量与未来增量共用接口。
**Tech Stack:** Python 3.12、SQLite、PySide6、pytest/pytest-qt、已有 Native CLI/OwnedCliScope/ServiceWorker/LatestQuery;标准库 JSON/HTML,无新运行时依赖。
**Spec:** [业务、流程、状态、数据与失败处理](../specs/2026-11-17-independent-verification-business-design.md)。对应用户最终选择的 A 图片入口,不采用此前带来源或流水线横条的旧草案。
用户已确认业务方向,开发阶段、工作区隔离、跨任务接口和交付门槛统一从[开发与交付入口](2026-11-17-verification-development.md)读取。本文件是该入口下的逐任务清单,N01~N12 已实施并完成本地开发包验收;既有连续全量回归的时序波动保留为发布门槛,详见验收记录。
## Global Constraints
- 只开发当前没有的功能;不接手 issue29 收尾、既有任务列表或其他并行修复。
- 原始捕获、原生导出、覆盖核验与绑定实际回执的预期解析直接复用;不重写旧替换状态机。
- 独立任务始终可创建;资源忙只影响执行领取,不影响新建和输入登记。
- 无 source/type/mode 来路字段或来源筛选;没有预期清单不等于所有变化均被允许。
- 当前只在已落盘结果后批量交接;增量接口和乱序规则先做好,不修改替换侧实时刷新。
- 所有工作只读固定输入;禁止重新换料、自动换脚、修改库或把当前工程补造为旧 before。
- 位号/物理脚号/连接严格;引脚文字变化与器件 Value、网络名分开;未知字段不能冒充一致。
- “执行成功”与“工程结论”分开;必查未知不能通过,已知异常不被警告或未知覆盖。
- 同一输入版本只允许一个活动尝试;新版本不替换在跑输入,迟到结果不能覆盖当前结论。
- GUI 不进行 CAD/CLI/磁盘全图扫描;延用既有风格、980×700 最小窗口与1280×880默认窗口。
- 新增原生进程只使用现有 OwnedCliScope;退出无法确认时暂停该执行器,不触发旧 CAD 退出/恢复动作。
- 清理不能删除活动/当前引用的快照、证明和报告;Git不接收客户工程、原始网表或厂商二进制。
- 每个任务独立测试/审阅/提交;只暂存其明确文件,保护工作区并行修改。实现前按最新主线重新定位接口。
## 0. 文件划分与依赖
领域包新建于 `src/dx_productivity/trial_task_center/verification/`,以下缩写 `V/` 指该目录;`UI/` 指既有 `src/dx_productivity/trial_task_center/ui/`。测试使用完整仓库相对路径。
| 文件 | 职责 | 首次任务 |
| --- | --- | --- |
| `V/__init__.py`、`V/contracts.py` | 输入/检查/状态合同,结果汇总 | N01 |
| `V/store.py` | 校验任务、工程、版本、尝试、运行、命令去重事务 | N02 |
| `V/service.py` | 本域公开接口,接收/查询/执行薄编排 | N03 |
| `V/intake.py` | 稳定导入、版本接收、成功交接适配 | N03 |
| `V/queries.py` | 当前版本投影、分页与统计 | N04 |
| `V/runner.py` | 独立只读执行器、资源准入与发布 | N05 |
| `V/control.py`、`V/ownership.py` | 冻结运行范围、持久停止、跨窗口进程归属和恢复证明 | N10 |
| `V/rules.py` | J01~J13 分维度判断与事实差异 | N06 |
| `V/pin_metadata.py` | 已验证原生字段适配、能力与未覆盖清单 | N07 |
| `V/evidence.py` | issue 定位、端点差异与确定性图数据 | N08 |
| `UI/verification_workspace.py` | 页面、任务选择、工程表、底栏 | N09 |
| `UI/verification_controller.py` | 异步查询、选择代次和用户命令 | N09 |
| `UI/verification_inspector.py` | 逐脚对照、事实表、范围与证据入口 | N09 |
| `V/report.py` | 同一证据包的HTML/JSON和整任务导出 | N11 |
| `tools/verify_independent_verification.py` | 受控/真实只读验收CLI,明确区分两种证据 | N12 |
新增 schema 由现有 `store_schema.py` 的版本升级入口调用 `V/store.py`,原服务 `service.py` 只暴露本域服务引用,不继续堆叠校验业务。
依赖:N01→N02→N03→N04;N02/N03→N05;N01→N06;N05/N06→N07→N08;N04/N05/N08→N09;N05/N09→N10→N11→N12。
N05 可以先用已有比较器返回原始事实和明确覆盖,N06 增加分级,N07 丰富引脚元数据;能力未验证的阶段必须产生 unknown,不为界面测试假造通过。
## N01:固定输入、执行状态与结论合同
**Files:** Create `V/__init__.py`、`V/contracts.py`;Test `tests/v1_1/test_independent_verification_contracts.py`。
**Interfaces:** `validate_input(value: dict) -> dict`;`rollup_results(checks: tuple[dict, ...], *, required_checks: tuple[str, ...], optional_checks: tuple[str, ...] = ()) -> dict`。返回 verdict、coverage、warnings/errors/unknown计数及 scope。missing required check 等同 unknown;空检查不能一致,空required_checks拒绝为非法检查计划。`CheckResult` 用字典并严格校验 check_id/state/issues/evidence_refs,不新增泛型框架。
检查ID固定:inputs(J01)、coverage(J02)、components(J03)、physical_pins(J04)、connections(J05/J06)、net_names(J07)、declared_attributes(J08)、attribute_changes(J09)、pin_text(J10)、pin_semantics(J11)、footprint_mapping(J12)、export_identity(J13)。同一check有多个issue,不重复check_id;无expectation时declared_attributes不能伪装已检查,attribute_changes仍输出变化事实。
- [x] 写空结果、缺必查、错误与未知并存、警告、可选未知、无预期清单的失败测试:
```python
def test_empty_checks_do_not_prove_consistency():
from dx_productivity.trial_task_center.verification.contracts import rollup_results
result = rollup_results((), required_checks=('connections',))
assert result['verdict'] == 'INCOMPLETE'
assert result['coverage'] == 'partial'
```
- [x] Run `.venv/Scripts/python.exe -m pytest tests/v1_1/test_independent_verification_contracts.py -q`,确认新合同尚不存在而失败。
- [x] 实现严格字段、枚举、摘要、整数版本与受管引用结构校验;拒绝外部任意输出路径,UI不传来源字段。输入字段按规范4.1,check_plan明确 required/optional/excluded。
- [x] 实现纯汇总优先级,核心逻辑固定为:
```python
if any(row['state'] == 'error' for row in checks):
verdict = 'DIFFERENT'
elif any(states.get(key, 'unknown') not in {'equal', 'expected_change', 'warning'}
for key in required_checks):
verdict = 'INCOMPLETE'
elif any(row['state'] == 'warning' for row in checks):
verdict = 'WARNING'
else:
verdict = 'CONSISTENT'
```
`states` 在同函数中由唯一 check_id 建立;重复check_id拒绝,不用后值覆盖前值。必查项被标not_requested同样不能通过;空required_checks在该分支前抛出TaskCenterError。覆盖清单独立计算。
- [x] 重跑本组,补 actual属性值不能反推expected、not_requested不计已检查、没有规则时scope文字不能“换料符合”的断言。
- [x] 对照规范J01~J13与状态表自审字段;保留原始文字及证据引用,不在合同层猜测引脚功能。
- [x] Commit `feat: define independent verification contracts and verdicts`。
## N02:任务、版本、尝试与去重事务
**Files:** Create `V/store.py`;Modify `src/dx_productivity/trial_task_center/store_schema.py`;Test `tests/v1_1/test_independent_verification_store.py`。
**Interfaces:** `VerificationRepository(task_store)`:`create_task(name: str, *, request_id: str) -> dict`、`publish(task_id: str, inputs: tuple[dict, ...], *, submission_id: str) -> dict`、`create_attempt(item_id: str, version: int, *, request_id: str) -> dict`、`claim(attempt_id: str, *, owner_id: str) -> dict`、`finish(attempt_id: str, *, generation: int, result: dict) -> bool`。这些只操作已验证的领域记录;原生I/O由服务完成。
- [x] 写旧DB升级、创建去重、同版不同正文、乱序、唯一活动尝试、迟到finish与并发claim测试。测试内创建真实临时TaskStore:
```python
def test_new_task_does_not_require_replacement_task(tmp_path):
from dx_productivity.trial_task_center.store import TaskStore
from dx_productivity.trial_task_center.verification.store import VerificationRepository
with_store = TaskStore(tmp_path / 'tasks.db')
try:
repo = VerificationRepository(with_store)
first = repo.create_task('电源板核对', request_id='create-1')
again = repo.create_task('电源板核对', request_id='create-1')
assert first['task_id'] == again['task_id']
finally:
with_store.close()
```
- [x] Run `.venv/Scripts/python.exe -m pytest tests/v1_1/test_independent_verification_store.py -q`,确认失败。
- [x] 建 verification_tasks/items/input_revisions/attempts/runs/requests 表,状态只属于本域;给版本和请求去重键唯一索引。至少固定:
```sql
CREATE UNIQUE INDEX verification_input_identity
ON verification_input_revisions(item_id, input_version);
CREATE UNIQUE INDEX verification_active_attempt
ON verification_attempts(item_id, input_version)
WHERE state IN ('queued','running','publishing','stopping');
```
- [x] 实现事务内版本指针移动、逐条接收和CAS generation;批量外层错误全拒绝,逐项错误返回原因,已接收其他项不回滚。保存request摘要,拒绝同request_id异文。
- [x] 用真实临时SQLite跑本组及既有schema/store回归;核对旧execution_operations与重试额度字节/行值未被新操作改写。
- [x] 故障注入提交前/提交后;返回值在事务内准备,不能因COMMIT后的额外尾读失败误报未接收;记录同一 before 新after与新before分项的区别。
- [x] Commit `feat: persist verification tasks inputs and attempts`。
## N03:统一接收、独立导入与成功结果交接
**Files:** Create `V/service.py`、`V/intake.py`;Modify `src/dx_productivity/trial_task_center/service.py` 仅暴露 `verification` 服务;接入 `dsh/execution_runs.py` 的已持久结果通知,不修改其执行/恢复合同;Test `tests/v1_1/test_independent_verification_intake.py`。
**Interfaces:** `VerificationService(task_store, data_root: Path)`;`create_task(name, *, request_id)`;`publish_inputs(task_id, inputs, *, submission_id)`;`import_pair(task_id, before: Path, after: Path, *, request_id: str, stop_event) -> dict`;`receive_successful_results(result_ref: dict, *, submission_id: str) -> dict`;`reconcile_deliveries(*, limit: int = 100) -> dict`。两种操作最终发布同一种inputs,无来路枚举。默认自动接收容器名为“校验任务”,以持久交接关联键去重,用户可改名。
- [x] 写两份工程同文件/数据库别名、捕获时变化、成功交接缺before、未成功结果拒绝、重复交接、一次批量和分次输入等价的测试。自建文件只用于事务/捕获测试,不假称可打开CAD工程。
- [x] Run `.venv/Scripts/python.exe -m pytest tests/v1_1/test_independent_verification_intake.py -q`,确认失败。
- [x] 复用capture_project,受管目录外输入先检查稳定性;两个文件最终数据库同源也要拒绝。已冻结交接只核验引用,不打开原CAD或重新捕获旧before。
- [x] 对已落盘成功范围建规范inputs;expectation_ref来自冻结清单/有效回执,不用after反推。补有界交接对账:首次接收和重启/进入校验页重扫未确认通知都用同submission键,落库回执作为完成依据。
- [x] 重跑本组;让导入/发布期间的替换和恢复入口抛AssertionError,证明只创建校验记录。成功工程缺证据仍可见,错误输入不能将旧baseline换成当前工程。
- [x] 对照接口确认当前能批量传、未来能乱序增量传;输入接收不创建queued尝试,不强制切走用户正在看的任务。
- [x] Commit `feat: receive verification inputs and import project pairs`。
## N04:当前版本查询、任务统计与历史投影
**Files:** Create `V/queries.py`;Modify `V/service.py`;Test `tests/v1_1/test_independent_verification_queries.py`。
**Interfaces:** `list_tasks(*, query='', cursor=None, limit=50, read_control=None)`;`read_task(task_id, *, state='', query='', cursor=None, limit=100, read_control=None)`;`read_item(item_id, *, version: int | None = None, read_control=None)`;`read_issues(attempt_id, *, kind='', cursor=None, limit=100, read_control=None)`。返回task view_revision、当前input_version、attempt身份、结论、范围、动作门禁、分页cursor。`summarize_items(rows)`只统计当前版本。
- [x] 写24项计数、旧版不重复计数、重校验转排队后旧绿灯退出当前、同名不同身份、筛选与整任务操作范围分离的测试。
- [x] Run `.venv/Scripts/python.exe -m pytest tests/v1_1/test_independent_verification_queries.py -q`,确认失败。
- [x] 实现“输入→当前尝试→结论→可执行动作”的单一投影;执行succeeded且verdictDIFFERENT必须显示异常,而非通过。空任务可新建/加工程,活动任务不禁用创建其他任务。
- [x] 参数化查询实现50任务/100工程/100问题上限,搜索名称、路径及已有issue位号/料号;转义LIKE的百分号/下划线。分页cursor绑定过滤、排序和view_revision,身份不从行号推断。
- [x] 跑本组与既有任务只读查询测试,核对“24=16一致+2警告+1异常+1无法校验+4待校验,已处理20”;暂停/中断单列不当一致。
- [x] 用并发读/新版本发布验证快照计数一致;旧attempt结果只进入历史,不刷新当前绿色。
- [x] Commit `feat: query current verification results and task summaries`。
## N05:独立只读执行器与原生后端适配
**Files:** Create `V/runner.py`;Modify `netlist_verification.py` 仅暴露固定输入导出缓存适配,原调用保持;Modify `V/service.py`、`V/store.py`;Test `tests/v1_1/test_independent_verification_runner.py`;Regression `test_netlist_execution.py`、`test_pr27_netlist_pause.py`。
**Interfaces:** `run_attempt(service, attempt_id: str, *, stop_event) -> dict`;`export_inputs(before_ref: dict, after_ref: dict, *, output: Path, stop_event) -> tuple[dict, dict]`;`can_start_native_export(service) -> dict` 返回allowed/reason,不占用新建入口。N06前本适配可返回已有比较事实并显式缺少扩展检查,不能编造完整结论。
- [x] 写任意独立任务可运行、原输入不变、缺工具不启动CAD、旧缓存损坏重导出、并发领取唯一、资源忙排队的测试。runner用受控OwnedCliScope/现有graph夹具,实际持久库和文件发布链不替换为固定成功值。
- [x] Run `.venv/Scripts/python.exe -m pytest tests/v1_1/test_independent_verification_runner.py -q`,确认失败。
- [x] 依照E03~E07核验固定引用;捕获/导出只走既有native_netlist。首版独立runner一次领取一个工程对,前后导出顺序运行,避免复制旧批次pool再叠加并发。若原生资源准入不可证明可并行,则留队列等待;不以该等待禁用新建。
- [x] 组织比较调用与暂存产物;先按E10确认自有CLI退出,再按E11发布结果及CAS finish。原异步导出/旧finish行为不被替换为新全局队列,接收既有完整证据时可以只复核/复用而不额外开进程。
- [x] 跑新组及两个旧网表组;断言替换派发数、CAD启动数、execution_operations写次数均为0,旧入口的暂停与缓存合同不退化。
- [x] 注入导出失败和发布中断;确认旧结果不覆盖、迟到attempt不更新当前。记录新执行器与旧资源修复的责任边界,不用本任务修退出helper。
- [x] Commit `feat: execute independent verification on immutable inputs`。
## N06:结构、属性、警告与未知的逐项判断
**Files:** Create `V/rules.py`;Modify `V/runner.py`;Test `tests/v1_1/test_independent_verification_rules.py`。
**Interfaces:** `evaluate(before: dict, after: dict, *, expectations: dict | None, check_plan: dict, pin_metadata: dict | None = None) -> dict` 返回checks、issues和N01汇总;`match_components(before_graph, after_graph) -> dict`返回可证明对应及歧义,不改原图。没有expectations与有意声明空变化清单须区分。
- [x] 用真实最小graph夹具写J01~J13反例:断线、短接、交换物理脚、位号增删、用户网名、无清单属性、正常目标变化、非目标变化、命名警告、必查unknown。固定脚号互换测试独立于名称相似度。
- [x] Run `.venv/Scripts/python.exe -m pytest tests/v1_1/test_independent_verification_rules.py -q`,确认失败。
- [x] 复用已有完整图/物理端点语义,建立只读对应视图;延用最新实例范围+生效位号唯一绑定,UID仅保留原始证据,其缺失/重复/变化不得否定已证明的位号对应。真实位号/实例歧义仍unknown。连接按完整端点集合比较,单端网络与未连接不混用。
- [x] 按check输出事实,不直接复用旧verified作为新最终结论;对允许改名的原比较结果补warning。关键边界为:
```python
if numbers_equal is False or connections_equal is False:
pin_text_state = 'error'
elif numbers_equal is not True or connections_equal is not True or pin_text_changed is None:
pin_text_state = 'unknown'
elif pin_text_changed:
pin_text_state = 'warning'
else:
pin_text_state = 'equal'
```
该片段只在物理脚已建立对应后运行;结构或连接已证明改变仍按硬异常处理,未证明的比较结果不会被Python的假值语义误判为“已证实改变”。unknown字段不由空字符串补齐,GND/VCC语义不由模型判断。
- [x] 跑本组及现有physical pin/逻辑改名测试;证明默认旧比较器结果不被全局放宽,网名变化不会套入引脚名称规则。
- [x] 检查错误优先、未知必查、警告、范围一致四类;有已知反脚加缺失属性时仍DIFFERENT,同时保留unknown列表。
- [x] Commit `feat: classify verification checks with explicit evidence and coverage`。
## N07:引脚级字段与封装映射能力探测
**Files:** Create `V/pin_metadata.py`、`tools/probe_verification_pin_metadata.py`、`docs/research/2026-11-17-pin-metadata-capability.md`;Test `tests/v1_1/test_verification_pin_metadata.py`;Modify `V/runner.py`。
**Interfaces:** `inspect_pin_metadata(export: dict, *, evidence_root: Path) -> dict` 返回每物理脚的logical_name/pin_value/electrical_type字段、存在性、原始定位、confidence为proven/unknown;`inspect_footprint_mapping(binding: dict) -> dict` 首版只接纳真实可证适配,未支持返回unknown及原因,不用空字典代表映射相同。
- [x] 写引脚Value与器件Value不同、原字段缺失、引脚类型变化、逻辑名对齐物理号、库映射未知的测试。缺证据边界:
```python
def test_missing_mapping_is_unknown(tmp_path):
from dx_productivity.trial_task_center.verification.pin_metadata import inspect_footprint_mapping
result = inspect_footprint_mapping({'symbol': 'example', 'cell': 'example', 'evidence': None})
assert result['state'] == 'unknown'
assert result['mapping'] is None
```
- [x] Run `.venv/Scripts/python.exe -m pytest tests/v1_1/test_verification_pin_metadata.py -q`,确认失败。
- [x] 探针只在用户工程已保存副本/受管导出上读取现有原生输出,记录确切字段、版本、存在性和物理脚绑定。先确认能否读出,不能凭类型名发明COM方法或回退CAD采集;探针不直接进入生产导入链。
- [x] 只有已证明的字段进入最小解析适配;无引脚Value就保留unknown,不用逻辑名或器件Value代替。库内映射默认未覆盖,只有取得真实版本/符号/Cell/脚号证据才实现对应分支。
- [x] 运行本组及N06,使用自建可提交fixture覆盖loop/outloop、同号不同文字、同名不同脚和已证实映射交换;客户报告只本地保存,仓库仅自建摘录。
- [x] 写能力报告:已验证字段/格式、未覆盖项、真实读取或纯夹具证据;无法验证的能力不阻止A基础页交付,但必查请求该能力时必须INCOMPLETE。
- [x] Commit `feat: expose proven pin metadata and unsupported mapping coverage`。
## N08:可人工复核的证据模型与连接图
**Files:** Create `V/evidence.py`;Modify `V/runner.py`;Test `tests/v1_1/test_verification_evidence.py`。
**Interfaces:** `build_evidence(before_graph: dict, after_graph: dict, issues: tuple[dict, ...], *, binding: dict) -> dict` 返回issue稳定ID、前后物理脚位置、连接对端、差异表和raw定位。`connection_view(evidence: dict, issue_id: str) -> dict` 只生成确定性绘图数据,不调用图片/语言模型。
- [x] 写R12 1/2互换、短接多对端、纯改名不画红断线、未知映射、图页未知与证据摘要损坏测试。前后pin1的绘制顺序必须相同,不能自动互换位置使图看起来一致。
- [x] Run `.venv/Scripts/python.exe -m pytest tests/v1_1/test_verification_evidence.py -q`,确认失败。
- [x] 从N06事实产生唯一issue_id;图和表共享同一数据结构,不分别拼判断。端点按固定脚号排列,变化线给出added/removed及原网络名,保留多gate与实例身份。
- [x] 将issue绑定不可变raw文件、摘要与可定位段落/对象键;图页无法确定则明确未定位。图标注“由网表生成”,不画伪原理图截图,不用生成模型解释电气正确性。
- [x] 跑本组与N06;反例断言每条红色连线都有对应连接error/差异,纯文字warning没有虚构接线变化。
- [x] 检查独立输入无expectation时证据仍可读;原生身份列差异与有效料号显示分开,不改写raw以统一数值。
- [x] Commit `feat: build traceable pin and network comparison evidence`。
## N09:A工作台、独立新建与证据检查器
**Files:** Create `UI/verification_workspace.py`、`UI/verification_controller.py`、`UI/verification_inspector.py`;Modify `UI/main_window.py`、`UI/icons.py`,样式仅加本页控件选择器;Test `tests/ui/test_verification_workspace.py`、`test_verification_inspector.py`。
**Interfaces:** `VerificationWorkspace(service, parent=None)`;`open_task(task_id, item_id=None)`、`set_active(active)`、`shutdown()`、`busy`、`busy_changed`;`VerificationInspector.set_evidence(evidence)`。controller通过N04查询,未来增量输入仅更新结果查询,不重新设计来路入口。
- [x] 写四导航映射、始终可新建、已有任务时独立导入、无来源横条、选择保持、不同任务延迟回调、DIFFERENT不显示通过的Qt测试。沿用既有`ui` fixture,但不更改其修复逻辑。
- [x] Run `.venv/Scripts/python.exe -m pytest tests/ui/test_verification_workspace.py tests/ui/test_verification_inspector.py -q`,确认失败。
- [x] 按最终图建立任务列表/状态筛选/工程表/右证据/固定底栏;main_window按页面对象明确映射四导航,DSH懒加载不被触发。新建对话框只含名称与可选前后工程,不要求来源选择。
- [x] QPainter或Qt原生控件渲染N08确定性图,表格同源;保持8–12px圆角、白色数据面、已有亚克力外框和减少透明度设置。980宽改可展开详情,不遮住开始/停止按钮。
- [x] 跑本组、现有history/DSH导航与样式测试;无后台run时点击导航或选工程只查询,不隐式导出。
- [x] 人工看1280×880、980×700及125/150%缩放;右侧R12对照保持1/2位置,警告/未知文字可读。静态图片仅视觉参考,不算功能验收。
- [x] Commit `feat: add the independent verification workspace and evidence inspector`。
## N10:开始、停止、重校验、崩溃恢复与版本竞争
**Files:** Modify `V/service.py`、`V/store.py`、`V/runner.py`、`UI/verification_controller.py`、`UI/main_window.py` 仅校验生命周期;Test `tests/v1_1/test_verification_control.py`、`tests/ui/test_verification_control.py`。
**Interfaces:** `start(task_id, *, selection: tuple[tuple[str,int], ...] | None, request_id)`,None表示服务端冻结当前全部ready;`stop(run_id, *, request_id)`;`rerun(item_id, version, *, request_id)`;`recover() -> dict`;`begin_shutdown()`。停止/恢复均不调用替换停止/准备重试/核验恢复函数。
- [x] 写重复点击、冻结范围不吞新项、当前v2不被v1完成覆盖、取消与提交竞争、进程退出未知、重启不自动执行的测试。queued取消保留历史;整run停止前从未派发项投影回待校验,用户单项取消显示已停止。
- [x] Run `.venv/Scripts/python.exe -m pytest tests/v1_1/test_verification_control.py tests/ui/test_verification_control.py -q`,确认失败。
- [x] 实现命令幂等与持久stop_requested;领取前/后、原生导出阶段和发布CAS前检查。终态提交先发生时保留真实结果;取消先发生时旧callback不能提交当前结果。
- [x] 实现重启核实OwnedCli身份/退出、F15产物补提交和interrupted;归属核对使用原owner/token/进程创建身份,不仅凭PID,以免PID复用误杀外部进程。未知资源留stopping,禁止盲目新导出。新attempt递增generation,旧terminal不改回running。
- [x] 跑本组及旧网表暂停组;在全部校验控制测试中将既有替换动作设为抛AssertionError,证明不会触发。GUI关闭不join/wait原生进程,通知安全结束后再关闭。
- [x] 受控慢导出期间切页、建新任务和停止,验证事件循环可响应;新工程后到保持待校验,不无限扩展当前run范围。
- [x] Commit `feat: control and recover independent verification attempts`。
## N11:完整报告、历史与证据保留
**Files:** Create `V/report.py`;Modify `V/service.py`、`UI/verification_controller.py`、`retention.py` 仅保护校验引用,复用HistoryRepository;Test `tests/v1_1/test_verification_reports.py`、`tests/ui/test_verification_report_actions.py`;Create `docs/user/independent-verification.md`。
**Interfaces:** `render_item_report(result_ref: dict, destination: Path) -> Path`;`export_task(task_id, destination: Path, *, request_id)`;`open_evidence(attempt_id, artifact_id)`只接受受管artifact标识。导出冻结view_revision,可在运行中生成并明确未完成项。
- [x] 写同版本报告/图表一致、HTML转义、原证据损坏、导出重名、运行中快照、清历史不删证据、缓存不可伪装新结果的测试。
- [x] Run `.venv/Scripts/python.exe -m pytest tests/v1_1/test_verification_reports.py tests/ui/test_verification_report_actions.py -q`,确认失败。
- [x] 从N08证据包渲染HTML/JSON,字段转义,原始文件只引用或用户明确选择后打包;默认不复制整个工程。报告固定输入/策略/工具/attempt摘要与检查范围。
- [x] 暂存→完整性核验→原子发布,重名目录明确错误不混写;HistoryRepository用稳定source_key防重复记录校验事件,此source_key为事件去重而非UI来源类型。
- [x] 跑本组与retention/history回归,核对当前/活动引用不可被普通日志清空删除,失去证据时显示不可用而非缓存绿灯。
- [x] 写用户说明:新建/自动接收无需来源、开始范围、警告/异常/未知、版本更新、停止重启、对照图与证据查看;不宣称ERC/PCB已检查。
- [x] Commit `feat: export verification evidence and preserve result history`。
## N12:集成、真实只读输入、包内入口与发布门禁
**Files:** Create `tools/verify_independent_verification.py`、`tests/v1_1/test_independent_verification_acceptance.py`、`tests/ui/test_verification_acceptance.py`、`docs/testing/2026-11-17-independent-verification-acceptance.md`;Modify `packaging/DxPartReplace.spec`及打包测试只在确有静态遗漏时,保护现有本地变更。
**Interfaces:** CLI `--fixture-root ... --output ...` 与 `--native-before ... --native-after ... --output ...` 明确分开;后者只读两份合法已保存工程,不执行换料。原有真实新换料闭环由已有执行器/验收工具交接,本任务只验证新校验任务能接收和复核,不重做其他任务的修复。
- [x] 用真实临时SQLite、受控CLI和完整文件发布链建立端到端用例:两份工程创建、批量成功交接、增量乱序、24工程计数、命名警告、反脚、缺基线、停止、重启、v1/v2竞争、报告。每用例记录实际派发与原工程摘要,不用单纯固定绿灯填页面。
- [x] Run `.venv/Scripts/python.exe -m pytest tests/v1_1/test_independent_verification_acceptance.py tests/ui/test_verification_acceptance.py -q`,确认缺口;前置已全部实现时允许首跑通过,不为制造red破坏实现。
- [x] 实现验收CLI串联公开接口并非零退出失败,记录模型图片仅参考、新功能真实证据另存。真实只读副本上复核引脚字段与层级范围;未知范围保持未知,不修改源工程制造反例。
- [x] 运行全部新增组、现有网表/BOM/导航/关闭/DSH及打包回归;再按仓库默认配置运行默认suite一次。记录当前分支并行修复是否已合入,不能冒用旧108项或旧EXE结果。
- [x] 在实际包中验证四导航、缺CAD工具仍可新建/导入记录/看已有报告、正确unavailable、正常关闭;不携带厂商exe和客户fixture。若可用真实本次成功回执,验证自动交接与手工独立输入共存且零重复换料。
- [x] 输出验收矩阵每项结果、通过数量、精确构建/输入/策略摘要、失败现场和未测范围;未取得真实引脚Value/映射证明时保留未覆盖声明。
- [x] Commit `test: accept independent verification tasks and evidence workflows`,功能完成后再走集成/发布决策;本计划不授权发布。
## 1. 场景到任务的验收映射
| 场景 | 必须满足 | 任务 |
| --- | --- | --- |
| 前面已有替换任务,仍新建独立校验 | 新建不依赖或覆盖换料任务,不要求来源 | N02/N03/N09 |
| 成功结果批量与分次传入 | 当前数据相同,重复与旧版不派发 | N02/N03 |
| 校验运行时收到新版本 | 旧输入固定,旧结果历史,新版待校验 | N02/N04/N10 |
| R12 1/2连接互换 | DIFFERENT,固定脚号图与逐脚表同源 | N06/N08/N09 |
| loop→outloop且结构不变 | WARNING,不能直接无提示通过 | N06/N07 |
| 缺引脚字段或库内映射 | unknown/未覆盖,必查未知不通过 | N01/N07 |
| 只有网名变 | 拓扑与名称分别显示,不套引脚改名放行 | N06 |
| 无清单两份工程 | 可比较,不能说换料规则符合 | N01/N03/N06 |
| CLI/解析/证据失败 | 明确原因,安全收尾后继续,未知资源暂停 | N05/N10/N11 |
| 关闭/崩溃/迟到回调 | 不重做换料、不污染新尝试,重启不自运行 | N10 |
| 图、表、报告、raw | 同一输入/issue/attempt,能追溯 | N08/N11 |
| 24项及1000工程规模 | 当前版本计数正确,100行有界读取,事件循环可响应 | N04/N09/N12 |
## 2. 分段交付与未实现边界
1. N01~N04:可以创建、接收和查询独立任务,先不宣称校验完成。
2. N05~N08:可独立执行、输出分级结论与人工证据;无法读取的字段保留unknown。
3. N09~N11:最终A页面、控制、报告与历史完整可用。
4. N12:真实输入、包内入口与回归结果已留证,交付本地开发包;默认回归仍有既有时序波动,不据此发布。
共12个新增功能任务、84个复选步骤已逐项实施和执行验证;测试波动及未覆盖能力见验收记录,勾选不表示已满足发布门槛。本文不是把旧计划未完成项全部重做:原生后端、非阻塞换料和当前修复仍沿用已有成果。未来替换实时推送、自动启动开关、未知电气语义字典、库映射扩展和自动修复均不作为首版暗含承诺。
@@ -0,0 +1,22 @@
# 保存后原生数据核验实施计划
用户已确认:原生数据定位 → DxDesigner 仅负责目标器件替换、属性写入和保存 → 从已保存数据库导出数据核验。此轮修正上一轮没有移除的 CAD 全页核验,不增加第二套全页保护。
## 约束与接口
- 正常执行不调用 QPCurrentSemanticState、QPVerifyUntouched、QPNativeCapture/QPNativeRead,不为核验关闭重开 CAD。工程末保存关闭一次;下一工程复用 CAD 会话。
- 写入所需的目标器件定位、原实例属性快照、属性恢复与引脚编号提升仍属于写入操作,限于目标器件;不读取非目标属性/样式/连接。禁止把全页检查改名后继续运行。
- 新目标快照使用 `X\tsaved_netlist_v1` 标记;保留原 M/C/A 格式及旧操作编号。C.connections 使用 `NETLIST` 表示连接由保存后原生导出核验,不查询 CAD 连接。旧快照/旧恢复证据按原协议处理,不删除历史保护。
- 新 CAD 工程收尾清单第一行第三列为 `project_saved`;只证明写入/保存/关闭已返回,不能当成 `project_verified`。各项保持 pending_save,原生导出核验通过后才提交 saved_ok/verified。
- 原生 helper 新快照成功阶段为 `native_replace_applied`,保留事务/库件/尝试身份;旧快照仍保留 native_replace_verified。新正常路径不做全页前后 COM 验证。
- Python 在确认工程关闭后,复用 native_netlist.capture_project/export_netlist 与原生证据校验,按工程/页/位号对齐全部暂存目标;核验料号、Value/NC、Cell 和可导出的库件属性。证据不完整、目标缺失、属性错误均不得提前完成,不回退 CAD。
- 独立前后网表比较继续单独展示;尽量复用同一份保存后导出,不再次驱动 CAD。原生格式不覆盖文字位置/字体/颜色,明确覆盖范围,不伪造图形证明。
- 新回执/重启/暂停/恢复不再要求 full_sheet_v1 或 CAD value-readback TSV;使用有保存源与原尝试绑定的原生导出证据。旧回执验证保留兼容。
- 不改原工程、中心库、Excel;真实验证仅新副本。保留用户和其他聊天文档。当前功能分支继续,本轮基点 d9cf6a0。
## 实施与验证
1. VBS/native_helper:先写真实函数测试,令任何正常路径全页扫描调用都失败;实现仅目标写入、工程保存关闭及 project_saved 协议。测试两项目标、合法多单元、暂停前缀、旧恢复兼容。
2. Python 原生核验/回执:先写缺失/错误目标、原生导出失败、无 CAD 的正例;接入工程提交回调和持久证据。不得以省略 baseline 的方式给旧回执放行。
3. 集成:同步运行时关闭检查点、journal、恢复与独立网表导出复用。先 RED 后 GREEN;真实副本两项替换比较扫描次数与计时,确认全页 CAD 采集为零、无保存后重开。
4. 针对改动回归、独立审查、记录真实限制并提交本地变更。此次先改执行链;上一轮候选程序保留,不将旧包冒充本轮源码。
@@ -0,0 +1,158 @@
# 工程校验功能开发与交付计划
> **For agentic workers:** REQUIRED SUB-SKILL: Use `superpowers:executing-plans` with the linked N01~N12 detailed plan. This is the delivery entry point, not authorization to begin application changes. N01–N12 implementation and local development-package acceptance are complete; continuous full-suite stability remains a release gate.
**Goal:** 开发独立校验任务、可信判断和可人工复核的 A 工作台,复用现有能力,只增加缺失功能。
**Architecture:** 按“任务数据 → 独立校验 → 人工证据 → 页面与操作 → 验收”顺序交付。任务、工程输入版本、执行尝试分开持久化;统一接收接口适配当前批量交接和未来增量推送;判断、图、表和报告共享一份事实。
**Tech Stack:** Python 3.12、SQLite、PySide6、现有原生网表CLI与进程归属机制、pytest/pytest-qt;不新增运行时依赖。
**Spec:** [已确认业务设计及六张流程/状态图](../specs/2026-11-17-independent-verification-business-design.md)。逐文件接口、测试命令和提交步骤见 [N01~N12 开发清单](2026-11-17-independent-verification-new-features.md)。
## Global Constraints
- 只做新增功能,不接手其他任务的退出、资源回收、工程统一提交或任务徽标修复。
- 任何时候可新建校验,不展示或要求选择来源,不加换料流水线横条。
- 当前接收已提交成功结果;增量、去重和版本接口做好,但本轮不开发替换实时刷新。
- 使用固定前后副本;不自动换脚、不重新换料、不写原工程或库。
- 位号/物理脚号/连接严格;引脚文字变化单独警告;缺证据明确未知。
- 工具判断、人工接线图、事实表、报告绑定同一工程版本和同一次尝试。
- 每任务先验证失败用例、最小实现、相关回归、自审和单独提交。功能完成前不发布。
## 1. 开工前处理
现在共享工作区的公共执行模块正在由其他任务修改,包括回执、工程统一保存、身份关联、资源隔离和 UI 状态。不得复制或清理这些未提交修改,也不得在其上混入本功能实现。
实施时使用独立开发分支 `codex/independent-verification` 和独立工作目录,按 `superpowers:using-git-worktrees` 流程准备。先核对已有分支是否存在并保留工作;不重置用户分支。基础纯逻辑和新增文件可基于已提交主线开发;接线前将其他任务的已合入修复同步进来,再复核接口。
| 接口边界 | 我们需要什么 | 处理原则 |
| --- | --- | --- |
| 工程身份 | 实例范围、生效位号、物理脚号及可靠对应证据 | 延用最新位号唯一关联规则;UID 为证据,不因UID缺失/变化一律拒绝 |
| 成功交接 | 真正已保存、关闭/重开回读的工程提交证明 | 待保存或只完成内存替换的项不得交接为成功 |
| 输入副本 | 本次 before、after、范围与摘要 | 缺失就登记无法校验,不能补造历史before |
| 预期变化 | 相对同一before的累计已成功修改及固定规则 | 不只传最后一条改动,不从after实际值反推预期 |
| 自有资源 | 当前本域CLI的归属和退出证明 | 复用既有接口,不修CAD退出;隔离桌面不被错误等同未退出CLI |
| UI公共文件 | 四导航插入点、关闭协作、主服务引用 | 窄范围接线,不覆盖其他任务实时刷新或状态投影改动 |
接线不满足时仍可完成本域数据/规则测试;不得用虚构成功回执凑出可演示闭环。若同名类/方法已经被新版本增加,应先复用,不按旧文件清单重复建设。
## 2. 四个开发阶段
| 阶段 | 任务 | 完成后能做什么 | 阶段验收条件 |
| --- | --- | --- | --- |
| 第一阶段:校验任务与数据 | N01~N04 | 创建空任务、导入两份工程、接收成功项、保存版本和查询状态 | 重复/乱序不重复建项;新版本不覆盖旧输入;无来源限制;缺证据可见 |
| 第二阶段:独立校验与人工证据 | N05~N08 | 独立导出、逐项判断、警告分级,生成前后接线图所需数据 | 反脚检出;改名有警告;未知不通过;图和表能定位到原始证据 |
| 第三阶段:A 页面与完整操作 | N09~N11 | 第四页、任务选择、开始/停止/重校验、前后对照、报告和历史 | 有其他任务仍可新建;控制操作不换料;关闭重启安全;报告可独立复核 |
| 第四阶段:集成与交付验收 | N12 | 在实际应用包中完成两种输入路径和混合批次 | 相关/默认回归、真实只读输入、产物身份、正常关闭全部留证 |
前三个阶段是内部可测交付,不等同发布版本。每阶段更新同一进度记录,注明实际完成的任务、提交、测试和能力缺口,不依据图片或测试数量推断已经支持的业务范围。
## 3. 十二个任务的工作量边界
| ID | 要实现的最小完整内容 | 依赖 | 做完怎么判断 |
| --- | --- | --- | --- |
| N01 | 输入、逐项检查、执行状态、结论和覆盖合同 | 无 | 空检查/缺必查不一致,错误优先,警告与未知分别保留 |
| N02 | SQLite校验任务、工程、不可变版本、尝试、运行与去重 | N01 | 同版同文幂等,同版异文拒绝,只有一个活动尝试,旧DB正常打开 |
| N03 | 独立导入、统一发布、成功交接和有界补交 | N02 | 一次批量和分次发布结果相同;只交接提交成功范围;创建不派发 |
| N04 | 当前版本投影、计数、分页、筛选、历史 | N03 | 24项计数正确,旧结果不重复,筛选不改变批量命令范围 |
| N05 | 复用原生导出的独立只读runner | N02、N03 | 不调用替换/CAD写入,工作副本隔离,资源忙只排队 |
| N06 | 器件/物理脚/连接/属性/名称的判断分级 | N01、N05 | 断线短接反脚、错属性均定位;允许改名给警告;缺证据未知 |
| N07 | 引脚Value、逻辑名、电气类型能力验证与适配 | N05、N06 | 证明字段来源与脚号对应;拿不到就unknown,不替代字段 |
| N08 | 同源issue、接线图数据、对照表和raw定位 | N06、N07 | 1/2脚前后位置固定,红线有对应事实,文字警告不画成接错线 |
| N09 | A页面、独立新建、四导航、工程表与检查器 | N04、N05、N08 | 与整体UI一致,已有任务时仍可新建,无来源/流水线横条 |
| N10 | 开始/停止/继续/重校验、关闭重启与版本竞争 | N05、N09 | 停止未派发项保留待校验,迟到结果不串版本,零重复换料 |
| N11 | 单项/整任务HTML/JSON、证据打开、历史和引用保留 | N08、N10 | 图表报告对应同一证据包,运行中报告标未完成,清历史不删证明 |
| N12 | 服务/Qt/真实只读输入/实际包验收 | N01~N11 | 全链路证据可复查,失败现场保留,支持范围写明 |
顺序执行即可,不需要同时派多个代理。每项具体文件、接口签名、用例和7步清单在[N01~N12详细清单](2026-11-17-independent-verification-new-features.md)中;共84步,不在此重复创建另一套进度复选框。
## 4. 最早验证的两个能力点
N01~N04开发期间可以提前做N07的只读探针,尽早知道业务边界;只读探索结果不等于N07任务已完成。
| 能力点 | 成功时 | 无法取得时 |
| --- | --- | --- |
| 引脚级Value/名称/类型 | 保存准确字段、存在性、原始定位,与物理脚绑定后比较 | 明确标该字段未覆盖;用户必查时INCOMPLETE;不得用器件Value代替 |
| 库内引脚到焊盘映射 | 只有确切库版本和绑定证明才启用检查 | 首版显示未覆盖,不承诺能发现网表未体现的库内反脚 |
已确认的工程接线反脚检查不能因为扩展映射拿不到就不做;也不能因为基础网表一致而宣称库内部映射通过。GND/VCC文字变化的语义字典和自动严重性仍沿用业务稿的保留决定,不在开发时临时让模型判断。
## 5. 开发时固定的接口载荷
这里固定形状,摘要、ID和受管路径由服务生成,示例是结构说明,不是可跳过验证的真实输入。
```python
input_record = {
'item_key': 'stable-project-comparison-key',
'project_key': 'stable-project-identity',
'input_version': 1,
'before_ref': {'manifest_id': 'before-id', 'sha256': 'a' * 64},
'after_ref': {'manifest_id': 'after-id', 'sha256': 'b' * 64},
'expectation_ref': None,
'check_plan': {
'policy_version': 'verification-v1',
'required_checks': ['inputs', 'coverage', 'components', 'physical_pins', 'connections', 'net_names'],
'optional_checks': ['pin_text'],
'excluded_checks': ['footprint_mapping'],
},
}
```
校验task_id与submission_id为外层命令参数;没有 source 字段。expectation_ref=None仅说明未核对换料规则;若后来提供规则,要发布新版本,不能修改原检查上下文。check_plan的id与N01实际定义保持一致,类型/枚举/摘要长度在边界拒绝非法值。
结果包至少分开保存:输入版本、attempt/generation、执行state、verdict、coverage、checks、issues、artifacts、resource_state。界面不得把attempt succeeded当成verdict CONSISTENT。
## 6. 每个提交的验证流程
1. 写本任务明确反例,运行该测试确认失败原因属于本功能缺失。
2. 实现最小完整逻辑;同步所有调用方、必要fixture、序列化和导出。
3. 运行该任务测试和与公共边界相关的既有回归,失败则定位根因,不通过跳过/放宽断言凑绿。
4. 对照业务稿检查状态、图表数据、证据绑定和失败路径;确认未调用换料/恢复入口。
5. 只提交本任务文件,记录提交SHA、实际命令、通过数量和未测范围,再进入下一项。
本仓库默认测试路径在 `pyproject.toml` 中为 `tests/v1_1` 与 `tests/ui`;只运行裸pytest不能声称DSH/打包组已测。N12需显式执行相关扩展组后,再跑默认suite。
```text
.venv/Scripts/python.exe -m pytest tests/v1_1/test_native_cli_netlist.py tests/v1_1/test_netlist_execution.py tests/v1_1/test_pr27_netlist_pause.py -q
.venv/Scripts/python.exe -m pytest tests/ui tests/dsh tests/packaging -q
.venv/Scripts/python.exe -m pytest -q
```
第一条是旧原生网表边界回归;第二条涵盖UI、DSH、打包;第三条按项目默认配置验证。具体新增测试文件由N01~N12逐项命令执行,不能只跑以上旧测试声称新功能完成。进程级测试使用新的短路径basetemp,环境变量仅对测试进程设置,不改系统用户环境。
## 7. 最终交付门槛
| 验收面 | 必须提供的证据 |
| --- | --- |
| 功能路径 | 已有换料成功数据交接与用户独立两份工程均可创建、运行、查看、重校验,且可共存 |
| 业务正确性 | 反脚/断线/短接/错属性/命名警告/缺证据均给出对应事实与范围 |
| 人工说服力 | 同一R12反脚在图、逐脚表、HTML报告、raw证据四处一致,能看出为什么异常 |
| 版本与幂等 | 重复接收零重复项;v1结果不覆盖v2;同版异文拒绝;旧attempt不能覆盖新结果 |
| 非阻塞与失败 | 单项问题保留后继续其他可运行项;资源/存储不确定时暂停正确范围,不假报通过 |
| 使用体验 | 980×700、1280×880和125%/150%可读;慢查询可导航和停止;新建按钮始终可用 |
| 生命周期 | 正常关闭、崩溃恢复、停止继续、证据丢失、历史清理均不损坏输入或重复换料 |
| 包与范围 | 实际包启动/入口/关闭、工具缺失原因、精确产物与输入摘要;未覆盖能力明确列出 |
开发不设虚假的固定天数。每阶段通过验收出口后再推进;引脚字段/封装映射的探索结果影响能承诺的检查范围,不影响先交付可信基础校验和证据页面。
## 8. 交接状态
### N12 后续闭环标准(2026-11-18)
所有后续任务按[闭环标准 v1](../../testing/verification-closed-loop-standard.md)留证;不再用“导入成功”“文件已生成”或历史分组通过数量单独宣布闭环完成。批量添加见[验收记录](../../testing/2026-11-18-verification-batch-import.md)。
- [x] C01~C05:开始前冻结名单/输入/策略,核对实际运行成员、预期结论、同源图表与报告、原文和退出证明;源文件不变、新增换料操作为0。
- [x] C06:实际包正常关闭后重启,证据可回读,尝试数不增加。
- [x] C07:实际包单项重校验,新attempt及generation递增,旧结果/报告不被覆盖。
- [x] C08受控回归:反脚、命名警告、必查未知、停止/资源未知、版本竞争和单项失败后继续的服务/Qt反例。
- [x] C08实际包补充:原生导出失败项先运行,后续正常项仍完成;混合批次的报告、重启和重校验均通过,见[本轮闭环验收](../../testing/2026-11-18-verification-closed-loop.md)。
- [x] C08实际包停止与资源未知:已有各自独立现场,见[剩余闭环执行记录](2026-11-18-verification-remaining-closure.md);三工程停止/继续和自有实例异常退出后资源未知保护分别通过。
- [x] 真实已保存换料回执触发的自动交接实际包闭环:新临时副本真实换料1项,自动交接后校验、报告、重启和重校验通过,校验期间换料增量0;见同一执行记录。
- [x] 连续默认全量:两轮2276 passed,固定提交上的最终运行0失败/0错误,631个产品/测试/工具文件运行前后不变;扩展120 passed、1 skipped(缺7-Zip)。未改旧时序断言,完整结果见[最终闭环验收](../../testing/2026-11-18-verification-final-closure.md)。
单次只读验收入口为 `tools/verify_independent_verification.py --expect-verdict ...`,明确只覆盖 C01~C05;实际包入口为 `tools/accept_verification_closed_loop.py`,覆盖独立输入 C01~C07,并可用 `--fault-batch` 增加原生失败隔离反例。未测项在JSON里保留not_run。测试失败或标准不符均非零退出;已有换料历史采用执行前基线,不能要求历史总数为0。
用户授权的 N01~N12 已顺序实现、分步提交并完成本地开发包验收。11月18日后续批量导入及四项剩余闭环均已完成:独立输入和真实换料保存交接两条实际包路径通过,停止与资源未知保护通过,固定版本的默认全量2276项通过。历史波动记录保留,不宣称修复其全部根因。未合并、推送或发布,本分支没有复制另一修复任务的未提交修改。
实施进度及验证结果见 docs/testing/2026-11-17-independent-verification-acceptance.md。后续开发以本入口和[N01~N12清单](2026-11-17-independent-verification-new-features.md)共同为准,11月6日的V/U旧计划保留为历史参考,不能再并行照旧重建后端或来源界面。
@@ -0,0 +1,28 @@
# 固定私有桌面跨批复用 Implementation Plan
**Goal:** 外部 Agent 保留 HDESK 引用时,正常批次和重启继续复用同一个受管理桌面,停止按批次增加桌面对象。
**Architecture:** 用现有 supervisor 领取当前用户/登录会话/窗口站唯一的命名槽位。桌面名称稳定,租用编号、Job 和执行代次每批独立;先确认写进程退出,再归还槽位,保留对象未消失的事实。原批次资源与业务回执仍沿用现有规则。
**Tech Stack:** Python 3.12、pywin32、现有原子 JSON 记录和 Windows Job;无新依赖、常驻服务或桌面池扩容。
**Spec:** `docs/testing/2026-11-18-desktop-reuse-research.md`,用户已明确批准实施,沿用当前功能分支,不涉及校验工作台。
## 约束
- 原工程、中心库和 Excel 不作为故障注入对象;真实验证使用新副本。
- 命名槽位跨 data-root/应用重启一致,跨用户/登录会话隔离。
- 空窗口列表不能证明写进程退出;实际 Job 与精确进程身份是交接依据。
- 崩溃中断的启动窗口不能假报零写入或自动重放;新槽位不能绕过旧写入者。
- 对象复用与桌面消失分别记录;旧租用不能关闭新代次的 CAD。
- 正常批次仍退出 Mentor,不关闭外部 Agent 或远程强关其句柄。
- 缓存命中和纯 CLI 不获取桌面。
## 步骤
1. [x] 新增 `desktop_slot.py` 与 `test_desktop_slot.py`。先以跨 root 顺序租用、竞争、放弃的互斥量、存活旧 writer、挂起 launch、损坏记录与重复归还建立 RED;实现稳定名称、命名互斥、持久来源、启动前 Job 记录、不可变归还证明和释放。
2. [x] 修改 `isolated_desktop.py`:显式 managed 模式;新批 Job 命名与启动阶段绑定;关闭本批进程/句柄后归还;外部残留不重复等待/关闭。同步 `batch_runtime.py`、独立 `isolated_cad.py`、`cell_catalog.py` 的实际入口,测试证明记录使用真实稳定名称、库读取严格验证进程释放且保留桌面残留。
3. [x] `batch_resources.py` 兼容旧 UUID 记录,管理新租用的历史观察;补旧/新租用隔离、进程仍活跃和归还证明损坏的测试,维持回执及源文件保护。
4. [x] 使用生产入口实测外部持有、20 次跨进程轮换、并发争用、owner 崩溃/子 Job 未退;副本工程跑两批 Mentor,核验原生数据和桌面数量。完成受影响回归、差异审查与本地提交,记录不覆盖的故障机条件。
验证临时目录使用 `D:/CodexValidation/managed-desktop-20261118/`。每个新分支先观察预期失败,完成后检查 XML/退出码;不将 Win32 探针作为业务样本。
@@ -0,0 +1,16 @@
# 剩余四项闭环执行计划
用户确认顺序实施并允许在工具新建的临时副本中执行真实换料。使用 `codex/independent-verification` 工作区,不修改另一修复工作区,不合并/推送/发布。
- [x] 实际包停止、重启不重跑、继续未派发项、明确重校验已停止项。三工程现场:`D:/dx-vfy-stop-three-20261118/acceptance.json`,两项未派发均保持待校验,继续和重校验的报告绑定通过。
- [x] 本工具自有实例异常退出,按PID和创建时间证明后才中断;重启保留资源未知,不派发后续原生导出,仍能新建校验。现场:`D:/dx-vfy-owner-exit-20261118/acceptance.json`。不为闭环伪造退出证明,不终止其他进程。
- [x] 真实换料交接:临时副本 RV05 从4100-CA0000-T7替换至4100-CA0000-T0,RV11保持;真实保存回执自动登记,校验/报告/重启/重校验不新增换料。新现场 `D:/dx-vfy-real-handoff-20261118-v2/acceptance.json` 和其 `verification-loop/acceptance.json` 均通过;替换操作1条且verified,校验阶段增量0,声明属性检查为expected_change,原始样例及库LMC摘要未变。
- [x] 最终回归:两轮完整默认suite均为2276 passed;最终固定提交XML `D:/dx-vfy-fixed-default-20261118.xml`,运行前后631个产品/测试/工具文件摘要不变。执行恢复与打包扩展120 passed、1 skipped(缺官方7-Zip),最终包运行时和资源释放复核通过。没有用分组复核替代连续通过,也未放宽旧断言。
验收工具新增 `--control-scenario stop|owner-exit`、`--handoff-data`,真实换料入口为 `tools/accept_verification_saved_handoff.py`。后者只接受全新外部输出目录,先原生导出证明固定RV05/RV11前提,使用已有BOM/执行器和实际EXE运行;不通过直接修改SQLite制造回执。
交接场景的before来自不可变历史捕获,不能要求它的源文件在真实替换后仍保留旧字节;`freeze_inputs(..., historical_before=True)`要求冻结预期清单,核验历史副本完整性,以已保存after的源摘要建立校验只读基线。默认独立导入仍要求两个源与导入时摘要相同。
每项完成需:输入名单/摘要和预期在执行前固定;运行及报告身份一致;原始样例/共享库不变;测试副本仅发生一次授权替换;校验阶段新增换料为0;停止/异常状态不能被显示为一致。按[闭环标准](../../testing/verification-closed-loop-standard.md)逐项留passed/failed/not_run。
最终四项记录见[剩余闭环验收](../../testing/2026-11-18-verification-final-closure.md)。保留分支与独立工作目录;未合并、推送或发布。Value/库内部映射仍属于明确未覆盖的能力边界。
@@ -0,0 +1,402 @@
# 独立工程校验:判断、执行、状态与失败处理
日期:2026-11-17。状态:业务细化稿,尚未实现新增功能。本文落实本次对话已确定的校验任务与 A 界面;未回答的引脚语义问题明确列为待人工确认,不擅自变成自动放行规则。
## 1. 用户使用方式与本轮范围
用户可以随时创建校验任务,选择修改前、修改后的工程。前面的替换成功结果也可以自动交接到校验任务;校验页不展示或要求选择来源,不把当前换料任务作为新建校验的前置条件。
当前先在已有替换执行结果落盘后一次性交接。接收接口支持批量、增量、去重和版本更新,为后续实时交接留接口;本轮不改替换任务的实时刷新机制。
用户在工程表里先看结论,再点开同一物理脚号的前后连接图、差异表和原始证据,能够独立复核。校验不修改工程,不自动换脚、不重新换料;发现的问题集中记录。
本轮新增:校验任务与输入接收、独立只读运行与恢复、判断分级、引脚元数据能力探测、可复核证据、A 工作台和报告。其他任务正在处理的退出/收尾修复、任务列表修复、既有替换状态机和性能优化不纳入本轮。
## 2. 现有能力怎样复用
检查基线:`main/v1.3.1@b19afc6`。工作区有并行进行的 issue29 修改;实施前再次核对实际主线,不能覆盖其改动。
| 已有模块 | 直接复用 | 新增边界 |
| --- | --- | --- |
| `native_netlist.py` | 固定副本、HIER/effective ASCII/Keyin 导出、层级/实例/gate 与物理连接交叉核验 | 新增领域层调用已有公开捕获/导出接口;不重写原生导出器 |
| `netlist_verification.py` | 完整导出缓存、原生库回执绑定、原计划/实际成功证据 | 提取或暴露接收固定输入的薄适配;原有队列入口保持兼容 |
| `native_cli.OwnedCliScope` | 隐藏进程、归属和退出证明 | 独立校验只拥有自己的 CLI,不接管替换 CAD |
| `batch_resources.write_record` | 原子文件发布 | 新报告先完整发布再提交数据库引用 |
| `TaskStore`、schema、事务锁 | 持久化与升级 | 只新增校验表,不写 execution_operations 终态或重试预算 |
| `LatestQuery`、`ServiceWorker` | 异步读取、旧回调隔离 | UI 不同步跑导出或遍历全工程 |
| `HistoryRepository`、现有样式 | 事件与窗口视觉 | 四导航、任务列表、工程表和证据检查器 |
现有比较器已能拒绝物理脚号/连接变化,并在已证明的目标符号替换中允许逻辑脚名变化;该变化目前没有警告。ASCII 引脚记录中的类型、引脚级 Value、库内焊盘映射不能因现有物理图通过而视为已覆盖。新增功能补充这些事实和范围,不全局放宽旧比较器。
## 3. 四种业务对象与身份
| 对象 | 是什么 | 身份与生命周期 |
| --- | --- | --- |
| 校验任务 task | 左侧一个名称,例如“电源板核对”;可以含多个工程 | 独立 task_id,随时新建;既有任务或排队不禁用新建 |
| 工程项 item | 中间表里的一行比较对象 | item_id;绑定 project_key、基线 before_id 和检查配置,不按名称猜测合并 |
| 输入版本 revision | 一对固定 before/after、预期变化及检查配置 | item_id + input_version;发布后不可修改 |
| 执行尝试 attempt | 对某个版本真正运行一次校验 | attempt_id + generation;重新校验增加尝试,不更改旧报告 |
另有批量命令 run:只冻结本次选择的 item/revision 集合、派发顺序和停止意图,不建立第二套工程结论。任务的状态与统计由当前工程版本推导,不另造会与工程行矛盾的通过标记。
同名工程不自动合并。同一个工程更换了 before 基线,建立新的工程项;不能把另一轮 before 覆盖到原项上。相同基线下的新 after 与累计预期变化才是新 input_version。
## 4. 统一输入与未来增量交接
### 4.1 统一接收合同
UI、文件导入和成功交接最终调用同一个 `publish_inputs(task_id, inputs, submission_id)`。没有 source/type/mode 等按来路分流的字段。
| 字段 | 必需 | 含义与校验 |
| --- | --- | --- |
| task_id | 是 | 已存在的校验任务;创建独立任务不要求换料任务存在 |
| submission_id | 是 | 请求去重键;相同键与不同正文冲突时拒绝 |
| item_key / project_key | 是 | 发布者持久身份;独立导入由服务生成,不使用显示名作为身份 |
| input_version | 是 | 同工程项内递增整数;较旧版本不得夺回当前版本 |
| before_ref / after_ref | 是 | 受管快照引用及 manifest 摘要;缺失证据可登记不可用工程项,不能伪造输入 |
| expectation_ref | 可空 | 已确认的预期属性变化与适用器件、证据引用;空表示未提供换料规则,不等于确认所有属性都应不变 |
| check_plan | 是 | 本次要求核对的维度、必查/可选范围和固定策略版本 |
| payload_digest | 服务生成 | 规范化内容摘要,绑定输入、预期和检查计划 |
内部证据仍保留真实执行回执、文件摘要和版本以供追溯,但它们不是 UI 的任务来源字段。不得以“没有换料任务”拒绝独立输入。
### 4.2 接收规则
1. task 不存在、外层结构不合法:整个请求拒绝,不修改任何任务。
2. 外层有效后逐条处理;一条坏输入不会撤销其他条已接收的输入。返回 accepted、duplicates、stale_ignored、rejected 以及逐条原因。
3. 相同 item_key/version/digest:幂等返回原记录,不加行、不重复排队。
4. 相同 item_key/version、不同 digest:记输入冲突,不覆盖。
5. 较旧版本:只返回旧记录或忽略,不成为当前版本。版本跳号允许,不能依据到达顺序推断修改顺序。
6. 新版本:原子发布新 revision,然后移动 current_revision 指针;旧输入、运行和结果保留。
7. 新工程/新版本默认待校验,接收本身不自动执行。正在运行的批量命令不自动吞入后来到达的项,避免未来持续流入导致命令永不结束。
8. 当前一次性交接与未来逐条交接具有相同语义;未来是否自动开始是独立运行设置,首版默认手动。
### 4.3 成功交接与独立输入
- 成功交接从已落盘、已保存回读且归属准确的回执读取成功范围,引用已冻结前后副本;失败、不确定或未执行项不冒充成功工程。工程内部分成功时只能交接有完整检查范围和可靠 after 的成功集合,明确预期范围;不能宣称整个替换计划完成。
- 若替换成功但附加校验副本缺失,仍登记该项并显示“缺少校验证据”,不撤销替换成功,也不从当前盘上补造旧 before。
- 当前已有网表报告可以作为证据导入,但只有输入、工具、解析器、检查策略和输出摘要均匹配时才复用;不能用旧 verified 字段直接点亮新任务。
- 独立新建填写任务名和前后工程;服务后台验证不同工程文件/数据库别名、源稳定性及可读性,冻结受管副本后发布同一种输入。没有预期清单时只比较结构和列出属性变化,不声称换料规则已符合。
- 交接失败不影响已保存换料结果。接收去重和已有回执扫描允许重新交接;UI 不在结束回调里等待全部捕获或导出。首版进入校验页或重启时扫描有界、尚未交接的已完成结果,且不为缺失 before 创建替代基线。
## 5. 判断规则:先证明能检查,再判断结果
每个检查返回 `check_id`、`state`、`required`、`issues`、`evidence_refs`、`coverage_reason`。state 为 equal / expected_change / warning / error / unknown / not_requested。所有异常都有明确事实;警告不能抵消异常,未知不能冒充相同。
### 5.1 输入与范围
| 编号 | 判断内容 | 具体逻辑 | 结果 |
| --- | --- | --- | --- |
| J01 | 前后输入可信 | manifest 存在、摘要匹配、数据库和配置属于声明对象,源在捕获时稳定 | 缺失/损坏则 unknown,停止依赖该输入的检查 |
| J02 | 能完整读出 | HIER 实例集合、effective 器件/脚/网络互反覆盖与 Keyin 物理端点覆盖一致 | 部分/截断/不支持配置则 unknown,不能比较两个不完整图判通过 |
| J03 | 器件身份 | 延用最新实例范围+生效位号唯一对应;UID保留为证据,缺失、重复、变化不得否定已证明的位号对应 | 缺件、多件或位号改变为 error;真实位号/实例对应歧义为 unknown,不做相似匹配 |
多 gate 使用工程实例范围+生效位号+物理脚作为对应依据,不能将同一位号的不同 gate 误报为重复器件;同一物理脚重叠仍为异常或无法完整核对。跨工程不合并身份。
### 5.2 脚号、连接和网名
| 编号 | 判断内容 | 具体逻辑 | 结果 |
| --- | --- | --- | --- |
| J04 | 物理脚号和集合 | 对应器件的物理脚号集合和占用次数必须相同,包括已知未连接脚 | 增减、重复或编号改变为 error;不能交换脚号消除差异 |
| J05 | 固定脚号的连接 | 每个端点 `(实例范围, 位号, 物理脚号)` 对应网络的完整端点集合前后相同 | 分组变化为 error;给出新增/丢失对端及网络分裂/合并 |
| J06 | 单连接端与未连接 | 有明确完整名册时区分“单端网络”“明确未连接”“导出未覆盖” | 已连接变未连接为 error,未覆盖为 unknown |
| J07 | 网名 | 连接分组相同后再比较名称 | 已识别自动生成名称变化保留说明;用户/未知网名变化保持 error,不能套用引脚文字警告 |
R12.1 原连 NET_LOOP/U1.3、R12.2 原连 GND/C5.2,修改后两者互换:J05 必须报错。器件数、脚数、网络总数相同不能抵消此错误。
比较本质是端点分组,不能因为另一个脚仍写 GND 就推断整个器件接线正确;两个网络同名也不能替代端点集合证明。
### 5.3 预期属性与引脚文字
| 编号 | 判断内容 | 具体逻辑 | 结果 |
| --- | --- | --- | --- |
| J08 | 有清单的器件属性 | 只允许固定 expectation_ref 声明的目标 UID/位号及字段按精确目标变化;其余字段保持原值 | 已声明且符合为 expected_change;漏换/错值/非目标变化为 error |
| J09 | 没有预期清单 | 仍列出全部属性变化,区分器件 Value、引脚 Value 和网络名 | 属性变更为 warning,标“未核对换料规则”;不得显示规则符合。无变化也只证明一致,不证明某个换料目标已完成 |
| J10 | 引脚 Value/名称 | 先按固定物理脚号对应;保留原始文字,单独记录变化;不能把器件 Value 充当引脚 Value | 文字相同为 equal。用户确认的 loop→outloop 且结构/连接保持时为 warning;其他名称变化为 warning 并提示功能需确认,不自动宣称功能等价 |
| J11 | 功能位置疑点 | 若 GND/VCC 等文字变化或原两脚文字对调,保留原始值和结构证据 | 输出高关注 warning“疑似功能变化,需人工确认”;是否升级 error 尚未由用户确认。若 J04/J05 或可靠库映射已证明互换,直接 error,不依赖名称猜测 |
| J12 | 库内映射 | 已有可靠方法能读取并绑定确切库版本、symbol/Cell 和引脚→焊盘映射时再核对 | 明确反脚为 error;未实现/拿不到为 unknown 或 not_requested,显式显示未覆盖 |
| J13 | 原生身份表 | Keyin Part 表与 effective Part Number 各自保留 | 旧身份列与有效料号不一致单列 warning/限制说明,不改写原始输出,不据此推导 PCB 已验证 |
J10 的“其他名称变化为 warning”只表示需要复核,不能解释为所有改名均安全。不能采用字符串相似度、模型猜测或全局 loop 替换来自动放行。引脚电气类型变更在可读取时与原值一起提示;其自动严重性字典首版不臆造。
预期值来自用户确认的清单、固定策略与可靠事务/库证据;不得从待校验 after 的实际字段倒推“预期就是这个值”。旧策略的特殊保留/NC 语义由已有函数解释并保留证据,本轮不另写一套换料策略。
### 5.4 首版检查范围
核心必查:可信输入、完整图、器件/位号、物理脚号、端点连接与名称;有 expectation_ref 时该范围内的预期属性也为必查。没有清单时属性检查为“只展示变化”,不能冒充目标检查。
引脚 Value/电气类型先做原生字段能力探测。探测未完成或字段缺失,报告明确 unknown;用户请求该项时不得算完整通过。库内部焊盘映射首版默认不请求,UI 固定披露“未覆盖:封装库内部映射”;有可靠适配器后才能启用为必查项。
检查计划记录 required_checks、optional_checks、excluded_checks 和策略摘要。未请求项不能被写成已检查;用户不能通过“一键忽略异常”改写原报告。只对当前输入和明确范围下结论。
## 6. 结论与执行状态必须分开
### 6.1 业务结论
```text
存在任何已证明 error → DIFFERENT(发现异常)
否则有必查 unknown → INCOMPLETE(无法完整校验)
否则有 warning → WARNING(检查完成,有警告)
否则全部必查 equal / expected_change → CONSISTENT(本次检查范围一致)
```
可选 unknown 使 coverage=partial 并显示未覆盖项;允许核心范围一致,但显示“核心检查一致,扩展项未覆盖”,不能笼统写全工程全部通过。必查 unknown 优先于警告,已经证明的异常优先于 unknown,两类事实都保留。
J08 未请求时,结论文字始终附“未核对换料规则”。人工作出“已查看/备注”的行为不改变机器结论;真正消除异常需要修改工程后发布新输入版本。
### 6.2 三组独立字段
| 字段 | 值 | 含义 |
| --- | --- | --- |
| input_state | receiving / ready / unavailable | 前后副本是否已可信发布 |
| attempt_state | queued / running / publishing / stopping / succeeded / failed / cancelled / interrupted | 校验程序是否完成执行;succeeded 可以对应 DIFFERENT |
| verdict | CONSISTENT / WARNING / DIFFERENT / INCOMPLETE / 空 | 工程内容结论;尚未得到结果时为空 |
另存 resource_state=not_started/owned/released/unknown 与 currentness=current/historical。资源未知只影响归属的校验执行器准入,不改写已有换料回执,也不发出全局 CAD 退出命令。
## 7. 每个工程怎样执行
| 步骤 | 动作 | 发布物 / 下一步条件 |
| --- | --- | --- |
| E01 | 接收工程或导入两份文件 | 建 item 与不可变输入版本,登记缺证据原因 |
| E02 | 固定当前点击范围 | 全部待校验或明确所选 item/revision;提交后不跟随新版本漂移 |
| E03 | 入队与领取 | 事务内去重与 CAS;同一版本只允许一个活动尝试 |
| E04 | 复核固定输入 | 校验 manifest/摘要、工具与配置支持;原文件变化不偷偷换输入 |
| E05 | 准备工作副本 | 从受管冻结输入复制;原生工具不写原工程或冻结原件 |
| E06 | 导出前/后图和属性 | 复用已有 HIER/effective/Keyin;保存命令、版本、输出摘要和清理结果 |
| E07 | 核对覆盖 | 先执行 J01/J02;某维度缺数据就记录 unknown,不以空集合相同通过 |
| E08 | 执行判断 | J03~J13 只读取本版本输入和预期;检查之间按依赖分组继续,不因一个可定位差异跳过其他可检查维度 |
| E09 | 组织人工证据 | 生成逐脚差异、网络端点增删、前后示意和原始证据定位 |
| E10 | 确认资源退出 | 自有 CLI 收尾得到证明后才能提交执行完成并继续派发;不以“报告已写完”代替资源确认 |
| E11 | 发布结果 | 暂存→摘要与资源证明核对→原子发布产物→数据库 CAS 完成;迟到尝试不可覆盖新尝试 |
| E12 | 更新当前任务 | 更新工程行/计数;下一个工程继续,最后导出本命令汇总 |
首版一个独立校验工程对处于运行中,新runner前后顺序导出,同时最多一个本域CLI;复用已有单次导出能力,不另建一个双线程批次池叠加并发。资源实际许可/系统准入继续生效,不能证明可并行时保留排队,不通过新建任务动作抢占替换资源。只增加任务和排队不占原工程写入租约;原有批次内部导出并发不由本功能改写。
发生差异不会立即弹模态框要求处理,不自动重新运行相同输入。只读工具异常首版由用户点击重校验;不借用、消耗或重置换料的一次自动重试额度。
## 8. 总流程图
```mermaid
flowchart TD
A[新建校验或接收已成功结果] --> B[统一接收接口与去重]
B --> C{固定前后输入可用}
C -->|否| D[登记无法校验及原因]
C -->|是| E[待校验]
E --> F[用户开始当前待校验或所选]
F --> G[冻结本次范围并入队]
G --> H[领取一个工程版本]
H --> I[复核输入并在工作副本导出]
I --> J{覆盖和格式可判断}
J -->|完整或部分可判断| K[逐项判断并保存未知范围]
J -->|无有效输入| L[记录执行失败或无法判断]
K --> M[生成前后对照与事实证据]
M --> O{自有资源已确认释放}
L --> O
D --> V[更新任务列表与原因]
O -->|是| N[原子发布结果并更新状态]
N --> P{本次范围还有待执行项}
P -->|有| H
P -->|无| V
O -->|否| Q[暂停该校验执行器并保留队列]
Q --> R[等待安全收尾或人工处理]
R -->|确认释放后用户继续| N
```
## 9. 状态图
### 9.1 单次执行尝试
```mermaid
stateDiagram-v2
[*] --> Queued: 用户明确提交
Queued --> Running: CAS领取且资源准入通过
Queued --> Cancelled: 派发前取消
Running --> Publishing: 证据与资源退出证明齐备
Publishing --> Succeeded: 产物与数据库引用提交成功
Running --> Failed: 工具或解析失败且资源已释放
Publishing --> Failed: 结果发布失败且可确认落盘状态
Running --> Stopping: 记录停止意图
Publishing --> Stopping: 完成提交前请求停止
Stopping --> Cancelled: 自有资源退出确认
Queued --> Interrupted: 重启后冻结原队列
Running --> Interrupted: 崩溃后核实旧进程退出
Publishing --> Interrupted: 提交结果未能证明完整
Stopping --> Interrupted: 重启后核实收尾状态
Succeeded --> [*]
Failed --> [*]
Cancelled --> [*]
Interrupted --> [*]
```
Stopping 的 resource_state=unknown 时保持等待,不直接迁移 Cancelled。Succeeded 只表示比较处理完成,仍须读取 verdict;停止与发布竞争以数据库提交先后为准,完整终态已提交就保留真实结果,不改成“取消”。恢复/重校验建立新 attempt,旧终态不原地改回 running。
整run停止时,尚未实际派发的queued尝试记录cancelled及`run_stopped_before_dispatch`原因,释放队列预留;工程行恢复“待校验”,继续时创建新queued尝试。用户明确取消单个工程或已经启动的工程显示“已停止”;不能因两种行为都留下cancelled尝试就混淆行状态。
### 9.2 任务状态由工程当前版本推导
```mermaid
stateDiagram-v2
[*] --> Empty: 创建任务
Empty --> Ready: 收到可运行输入
Empty --> Attention: 只有不可用输入
Ready --> Active: 用户开始校验
Active --> Stopping: 用户停止当前运行范围
Stopping --> Paused: 归属资源已释放
Paused --> Active: 用户继续尚未开始项
Active --> Attention: 本次完成且有异常或缺证据
Active --> Finished: 当前范围完成
Attention --> Ready: 补充合法新输入或手动重校验
Finished --> Ready: 收到新工程或新版本
Paused --> Ready: 收到新输入且无活动派发
```
队列尚未执行的行存在时,任务不得标“所有工程已完成”。任务可继续接收新输入;Finished 不是禁止接收的永久关闭状态。Attention 与 Finished 的详情仍显示准确计数,警告不导致自动重试。
## 10. 数据流向与版本更新
### 10.1 数据流图
```mermaid
flowchart LR
A[已落盘的成功结果] --> C[统一输入接收服务]
B[用户选择两份工程] --> D[稳定性检查与冻结副本]
D --> C
C --> S[(SQLite任务/工程/版本/尝试)]
C --> M[(受管快照及manifest)]
S --> Q[独立校验调度器]
Q --> M
M --> W[一次性工作副本]
W --> N[已有原生导出与覆盖核验]
N --> G[标准图与逐项判断]
E[(固定预期变化与策略版本)] --> G
G --> R[(不可变结果包和原始证据)]
R --> S
S --> U[A工作台查询投影]
R --> U
U --> H[人查看前后图/差异表/原始证据]
R --> X[导出HTML与JSON]
```
没有从校验服务回到替换执行器的写入箭头。GUI 不直接读原工程数据库,示意图与差异表来自同一个标准图和 issue 记录,不使用生图模型或语言模型生成工程判定。
### 10.2 新版本到来时
```mermaid
sequenceDiagram
participant P as 输入发布者
participant S as 校验服务
participant DB as 持久库
participant W as 校验执行器
participant UI as A工作台
P->>S: 发布工程A v1和去重键
S->>DB: 原子发布v1并设为当前
S-->>P: 返回接收回执
UI->>S: 开始工程A v1
S->>DB: 建立queued尝试
W->>DB: CAS领取v1
P->>S: 发布工程A v2
S->>DB: 新增v2并更新当前指针
S-->>UI: v2待校验,v1正在处理历史版本
W->>DB: 提交v1结果,绑定v1尝试
DB-->>UI: v1结果归档,v2仍待校验
P->>S: 重复v2或迟到v1
S-->>P: 去重或忽略旧版,不新增派发
```
同一 before 下,v2 的预期集合必须覆盖该 before 到 v2 after 的全部累计成功变化,不能只携带最后一条改动;否则其他合法变化会被误判。新一轮 before 不同则新建工程项。当前只做接收和版本管理,不在本轮实现替换侧实时推送。
## 11. 结果包:让人能够复核
每个 issue 必须有:稳定 issue_id、check_id、严重性、工程/版本、位号/实例、物理脚号、前值、后值、预期或保持规则、关联证据及定位、检查范围。没有足够定位时说明“图页未定位”,不编造图页或 CAD 截图。
| 产物 | 内容与约束 |
| --- | --- |
| `result.json` | 身份、attempt/generation、输入/工具/策略摘要、逐项结论、覆盖、问题与资源证明 |
| 标准图 | 物理脚、网络端点、有效属性、实例/多 gate、字段来源;原值不被正常化覆盖 |
| 原始导出 | HIER/effective/Keyin 和完整工具输出,保持原样 |
| 连接对照 | 前后相同脚号相同位置;只高亮变化连接,列新增/丢失对端 |
| 事实表 | 引脚/字段、替换前、替换后、判断、证据入口;与示意图共享同一 issue 数据 |
| 覆盖清单 | 已检查、未知、未请求;封装内部映射不能被工程网表结果隐含覆盖 |
| HTML/JSON报告 | 相同结果包渲染;明确任务、版本、生成时间和未完成项 |
例如 R12 反脚:左右两张图均保持 1 脚在上、2 脚在下;前后网络/对端不同处标红。明确标“连接关系示意(由网表生成)”,不伪装原理图截图。命名警告用 amber,不能用红色导线假装发生实际断接。
UI 的原始证据入口只能打开受管、摘要匹配的文本/报告,不接受工程字符串或模型输出指定任意可执行路径。所有 HTML 字段转义,客户数据和原始网表不写入 Git。
## 12. 失败处理矩阵
| 编号 | 失败或变化 | 当前工程怎样处理 | 其他工程 / 后续 |
| --- | --- | --- | --- |
| F01 | 缺 before/after | input unavailable,指出缺哪个副本 | 继续其他可运行项;补合法记录,不补造 before |
| F02 | 独立导入源正在写入或复制中变化 | 不发布可信 revision,保留导入原因 | 可重新选择/捕获;其他任务可新建 |
| F03 | 相同版本不同内容 | 输入冲突,拒绝覆盖 | 返回逐条原因,其他已接收项保留 |
| F04 | 旧版本迟到/重复通知 | 幂等或 stale_ignored | 不再导出、不改当前结果 |
| F05 | 缺工具/不支持配置 | 明确能力原因,必查为 unknown | 其他支持项继续;不回退 CAD 读取 |
| F06 | CLI 超时/异常退出 | 保存诊断,自有进程安全收尾 | 确认 released 后继续下一项;用户可单项重校验 |
| F07 | CLI 无输出/空图/截断/覆盖不足 | 无法完整检查;保留可定位事实 | 不显示通过,其他工程继续 |
| F08 | 发现反脚/漏换/非目标改动 | succeeded + DIFFERENT,保存事实与证据 | 继续后续项,不自动修改或重试 |
| F09 | 只有符合条件的文字变化 | succeeded + WARNING | 继续,留待集中查看 |
| F10 | 引脚属性/库映射读取不支持 | 对应 check unknown/not_requested | 必查未知则 INCOMPLETE;未请求项始终披露 |
| F11 | 用户停止 | 先存停止意图,停止当前自有只读导出 | 未派发项回到待校验;当前 cancelled 后用户可重校验 |
| F12 | 自有资源退出不确定 | 保持 stopping + resource unknown | 暂停该校验执行器,不盲目开启下一导出,不杀用户 CAD |
| F13 | 应用关闭或崩溃 | 正常关闭先收尾;异常重启核实旧进程和产物 | interrupted 后等用户继续,不自动重复换料或开始校验 |
| F14 | 结果文件或数据库提交失败 | 不显示完成;旧结果保持 | 优先停止受影响发布/执行范围;存储故障不能保证后续落盘,不承诺其他项仍可持久化 |
| F15 | 保存文件后DB提交前崩溃 | 扫描已发布结果包并核对输入/attempt/token | 仅有完整不可变包、released证明且无更新尝试才可补提交;否则 interrupted |
| F16 | 迟到 worker 回调 | CAS拒绝当前终态覆盖,保留诊断 | 新尝试/新版本不受污染 |
| F17 | 当前工程文件后来变化 | 已固定版本仍能比较,其结果标“对应已保存副本” | 不偷偷替换 after;要核对新状态须新输入版本 |
| F18 | 报告丢失/摘要不符 | UI显示证据不可用,保留原记录 | 可对原固定输入重校验;不能用残留绿灯代替证据 |
一般异常不弹阻塞对话框。需要用户选择路径、确认停止或操作外部文件时才交互。资源/存储归属异常属于无法安全继续的边界,不用“非阻塞”掩盖它。
```mermaid
flowchart TD
A[步骤异常或用户停止] --> B{已有完整提交的终态}
B -->|有| C[保留真实结论与证据]
B -->|无| D[记录失败或停止意图]
D --> E[收尾本次自有只读进程]
E --> F{资源退出是否有证明}
F -->|有且存储可用| G[当前项终态,其他待执行项继续]
F -->|无| H[保持停止中,暂停该执行器]
H --> I[继续收尾或人工处理资源]
I -->|确认退出后用户继续| G
D -->|持久化不可用| J[显示存储故障,暂停结果发布]
```
## 13. A 工作台与数量口径
- 四导航保持一致;上方只有“工程校验”和始终可用的“新建校验”。无来源、流水线或返回替换任务横条。
- 左侧先选择校验任务,再筛选当前任务工程;中间表与右侧证据随同一个 item/revision 切换。
- 新建任务只需名称;选择两份工程可在新建对话框完成,也可先建空任务后加工程。校验侧不要求用户先创建替换任务。
- “开始待校验”仅对当前任务所有 ready、未提交的当前版本生效,不受表格筛选暗中缩小范围;“校验所选”只对显式勾选版本生效。勾选随切任务/分页/筛选清空并提示,避免隐藏提交。
- “重新校验此工程”默认当前选中版本;历史版本只能从历史详情显式重校验并始终标历史,不能把其结果挂到当前版本。
- 表格每页100项,差异每页100项;250ms搜索防抖,后台查询代次隔离旧回调;不在GUI扫描全部网表。
- 统计只取每个 item 的 current_revision。已处理 = 一致 + 有警告 + 有异常 + 无法完整校验;排队/执行中/待校验/已停止/中断分别列出。失败且无有效业务结果计入无法校验,并保留“执行失败”原因,不计一致。
- 旧版结果和旧尝试不重复计入当前计数。重校验排队后该行显示排队中,旧结果可展开查看但不继续充当当前已处理结论。
- 没有完整证据的“处理结束”不显示绿色通过;只有 scoped 一致可使用绿色,并带检查范围。
## 14. 持久化、接口与发布顺序
新增校验 task/item/input_revision/attempt/run 与命令去重记录,复用当前 SQLite 事务和日志模式。文件内容保存在受管目录,数据库存身份、状态、摘要与引用;不在新表复制原 execution_operations 状态。运行去重/停止命令可使用校验域自己的 request 表;不复用专用于 AI 创建任务的请求语义。
```text
verification/<task_id>/<item_id>/inputs/<version>/manifest.json
verification/<task_id>/<item_id>/attempts/<attempt_id>/raw/...
verification/<task_id>/<item_id>/attempts/<attempt_id>/result.json
verification/<task_id>/<item_id>/attempts/<attempt_id>/report.html
```
输入版本、尝试、产物路径均由服务生成并验证归属,不允许外部命令在受管目录之外指定输出位置。清历史不删除校验结果;活动/当前引用的快照、原生证明和结果包不得按普通日志保留期清掉。首版不新增“一键删除证据”入口。
发布顺序固定:完整暂存文件 → 原子发布 manifest/结果包 → DB事务验证身份与generation并引用 → 通知UI。目录与DB不能跨资源真原子,使用上述顺序和 F15 恢复规则;拒绝“先更新成功状态,再尝试写报告”。
## 15. 能力门禁和未确认事项
1. 引脚级 Value 的实际字段、端点逻辑名与物理脚号对应、可读电气类型需用真实导出确认;缺失不以器件属性替代。
2. 库内脚→焊盘读取尚未证明,首版可先交付工程物理连接校验与明确未覆盖项,不宣称封装制造验证。
3. GND→VCC 或纯功能文字对调的自动严重性尚未由用户确认,首版保留高关注警告,不让模型推断电气等价或改工程。
4. 用户网名变化暂不放宽为普通命名警告;后续若要放宽,独立规则与反例确认。
5. 多层级/多 gate 当前已有读取能力;直接换料的子实例范围不是本轮新增任务。独立比较若不能唯一建立前后对应,返回 unknown,不强行比对。
6. 旧 before 缺失不会因为新增页面而变得可恢复;真实新副本验收与图像原型分开。
实施从[开发与交付入口](../plans/2026-11-17-verification-development.md)进入,逐项步骤见[独立校验新增功能计划](../plans/2026-11-17-independent-verification-new-features.md)。本文及计划不授权开始 CAD 写入、改动其他任务的修复或发布程序。
@@ -0,0 +1,109 @@
# 批量执行闭环验收
本轮对应 `docs/superpowers/plans/2026-11-17-batch-execution-closure.md`。位号优先定位;工程内先暂存,工程统一保存回读后提交;不确定工程隔离,确认全部自有写进程退出后继续独立工程。工程执行、网表验收、资源告警分开记录。
```mermaid
flowchart TD
A[导入 BOM 并保存待执行计划] --> B[原生读取当前工程所需位号与网表]
B --> C{工程/页/位号能否明确定位}
C -- 否 --> D[记录明确的匹配错误]
C -- 是 --> E[逐项原生替换和内存核验]
E --> F[写 pending_save / 暂存回执]
F --> G{工程还有项且未暂停}
G -- 是 --> E
G -- 否 --> H[统一保存页 / 关闭工程 / 重开回读 / 最终关闭]
H --> I{全部前缀核验通过}
I -- 是 --> J[原子提交已保存回执和任务进度]
J --> K{人工暂停}
K -- 是 --> L[结束整批 / 保留未执行项]
K -- 否 --> M[继续下一独立工程]
E -- 未知写入或异常 --> N[保留 uncertain / 工程待核验]
I -- 否 --> N
N --> O[回收该工程自有写进程]
O --> P{写进程退出和自有句柄关闭已证实}
P -- 否 --> Q[停止整批 / 等待资源核验]
P -- 是 --> R[隔离工程及共享写入源]
R --> S{旧桌面是否仍存在}
S -- 是 --> T[保留隔离告警 / desktop_released=false]
S -- 否 --> M
T --> M
J --> U[独立原生网表验收 / 单独显示结果]
R --> V[共享源后续任务未派发即阻塞]
V --> W[原依赖恢复后显式核验重新准入]
```
## 20 类验收场景
下面是自动化验收矩阵,不代表 20 次真实 Mentor 替换。Python 测试替代 COM 边界;VBS 测试执行生产脚本函数并使用假 COM 对象。真实 Windows 桌面测试另列。
| # | 场景 | 需要确认的结果 | 自动化覆盖 |
|---|---|---|---|
| 1 | 器件 UID 缺失或格式异常 | 位号明确时可定位,原始 UID 留证 | `test_refdes_identity_closure` inventory cases |
| 2 | 不同位号共享 UID | 不误绑定,不阻断无关器件 | 同模块 duplicate UID / unselected collision cases |
| 3 | 替换或重开后 UID 变化 | 快照、回读、网表仍关联原位号,旧操作编号不变 | 同模块 snapshot/readback/netlist cases |
| 4 | 原 UID 被另一位号复用 | 不把错误位号当成替换成功 | 同模块 reused UID mismatch cases |
| 5 | 不同页或层级同位号 | 依据工程、页和层级定位,真实歧义拒绝 | 同模块 sheet/hierarchy cases |
| 6 | 同一物理器件多个合法单元 | 全单元快照及回读,物理引脚连接仍严格比较 | 同模块 multiunit cases |
| 7 | 工程中多项暂存 | 游标推进,但 saved/completed 不提前增加 | `test_project_commit_progress` |
| 8 | 工程末统一保存 | 每个已修改页保存一次,工程关闭重开回读一次 | `test_project_commit_vbs` save/reopen case |
| 9 | 暂存前缀后人工暂停 | 提交已修改前缀,未执行项不产生写入/不确定状态 | `test_project_commit_end_to_end` pause cases |
| 10 | 写入前暂停 | 保留 SafeStop 来源,当前项保持 pending | `test_project_commit_vbs` / `test_resource_isolation_prewrite_pause` |
| 11 | 回读失败或提交清单不完整 | 不提前提交任何暂存项 | `test_project_commit_journal` / `test_project_commit_proof` |
| 12 | 保存成功后程序崩溃 | 从不可变提交证据幂等恢复,不重放替换 | `test_project_commit_journal` / `test_project_commit_public_recovery` |
| 13 | 工程保存回读持续有进度且超过原等待时间 | 不因固定 60 秒误判收尾失败 | `test_project_commit_session` progressing commit case |
| 14 | 自有进程退出但旧桌面仍被外部句柄持有 | 保留 desktop_released=false,隔离告警,新批次可进入 | `test_resource_isolation`;真实 Windows 探针 |
| 15 | 仍有写进程或进程身份未知 | 不允许隔离放行 | `test_resource_isolation` active/unknown cases |
| 16 | 隔离后重启,随后外部句柄消失 | 重验退出证明;被动确认释放,不重复 Quit | 同模块 restart/passive disappearance cases |
| 17 | 工程结果未知,资源已收尾 | 保留 blocked 和 uncertain,继续独立工程,恢复队列不重放 | `test_project_isolation_queue` / `test_workspace_execution` |
| 18 | 本地回收与人工停止 | 本地回收不污染下一工程;人工暂停/强制结束仍生效 | `test_project_isolation_queue` / workspace control cases |
| 19 | 后续工程共享 iCDB 写入源 | 未派发即阻塞,原依赖核验完成后才重新准入 | `test_lifecycle_integration_fix` dependency cases |
| 20 | 任务完成、失败、恢复及资源告警 | 实时分类;已保存结果与网表/资源结果分别展示;诊断含最后成功项和未返回调用 | `test_live_task_completion` / `test_failed_native_recovery_guard` / `test_diagnostics_closure` |
## 证据位置
- 本轮回归日志:`build/batch-execution-closure/`。
- Windows 桌面实际持有、重启复核及新桌面准入:`build/batch-execution-closure/resource-isolation/run-4ace6aa7a36b4204a7bed568b5ce7505/evidence.json`。
- 工单原始日志保留在 `outputs/issues-20261117/issue29/`,不修改用户上传证据。
## 自动化验证结果
主程序/UI 全量运行 2335 项,最初 2320 项通过、15 项失败。14 项仍断言“未知结果必须整批暂停”,已按已批准的工程隔离策略更新,同时保留同工程后项不派发、不重放和独立工程可继续的断言;另一项修复测试对尚未创建完成的原生弹窗按钮的读取竞态。随后对全部失败项和本轮新增/修改的调用链定点复验。
最终 JUnit 合并记录为 **2438 个唯一用例通过,0 个未解决失败**,证据见 `build/batch-execution-closure/verified-test-summary.json`。这是全量运行加定点复验的合并结果,不是另一次全部用例在最后源码上的全量运行。定点记录为 root delta 143 项、lifecycle delta 97 项、project recovery 29 项、identity delta 47 项、deleted guard 1 项,均通过;这些记录存在重叠,不应直接相加。
独立审查已复核位号/多单元、工程暂存及暂停、资源隔离、共享源恢复及公开工程提交恢复。工程已保存但数据库回执未完成时,公开恢复入口验证原生关闭检查点、保存源、回读文件及原尝试身份后恢复回执,不启动 CAD 或重复替换;源变化、其他未知写入、证据损坏及不匹配的中断记录继续保持待核验。
## 实机边界
工程级批量保存、UID 异常和多单元替换需要使用副本进行真实 Mentor 验收。自动化协议验证、真实桌面句柄探针和真实 CAD 写入必须分别报告;不得用前两者声称已完成原 100 工程队列。原工程、中心库、Excel 和历史 uncertain 记录不作为试验修改对象。
首轮真实 Mentor 探针 `build/batch-execution-closure/mentor-live/` 在 RL02 原生替换和内存回读后失败:新暂存入口未暂时清除内存 `restored_ok`,导致生产命令读取器认定没有待处理命令。该问题已有真实读取器回归;复测使用 `mentor-live-fixed/` 全新副本。失败副本及 uncertain 保留,不重放。首轮 Mentor 正常退出、桌面释放,无强制终止;原备份 34 个文件前后哈希一致。
第二轮 `mentor-live-fixed/` 发现未选中非 PCB 图形的空位号被写成相同别名,导致后续全页原生回读重复 UID;已对空位号跳过引用别名并保留其独立原始 UID。第三轮 `mentor-live-final/` 通过该位置并写出 `pending_save`,随后全页语义采集缺少逐器件进度,触发无进度停止;补充实际完成计数后使用 `mentor-live-progress/` 新副本复测。前三轮异常资源均确认释放,备份源文件前后哈希一致;不计为工程保存成功验收。
第四轮真实 Mentor 验收通过,证据为 `build/batch-execution-closure/mentor-live-progress/closure-live-summary.json`。RL02、RL05 两项替换先暂存,最后统一提交;日志确认一个 worker、一次保存、两次打开工程(首次打开及保存后重开)。两项 SQL 操作均为 `verified/generation=1`,工程提交 `verified`,任务 `completed`。独立原生清单读取复核 13 个位号:两项目标料号正确,其余 11 项保留原料号。Mentor 和桌面确认释放,无强制终止;备份源 34 个文件哈希未变化。
### 本机计时及限制
| 实际边界 | 秒 |
|---|---:|
| 第一项开始至暂存回执 | 472.664 |
| 第二项派发至暂存回执,含前一项检查点核验 | 539.298 |
| 工程收尾,含完整状态检查、统一保存、关闭重开和回读 | 431.863 |
| 其中两次原生替换提交调用 | 0.631 / 0.424 |
| Mentor 退出 | 5.093 |
| 桌面释放 | 0.009 |
| 整个队列 | 1450.341 |
| 队列结束后的独立原生清单复核 | 1.505 |
“其中”调用嵌套于上层步骤,不能再次相加。本轮同时存在构建和回归负载,不能作为独占性能基准,也没有同条件旧版对照。全页状态反复采集仍是明显耗时项;本次证明阻塞闭环、保存次数与结果提交正确,**没有证明速度提升**。真实 CAD 仅验证一个副本工程、两次替换;多单元、UID 异常和 20 类异常场景主要依靠自动化协议/COM 边界测试,不能当成 20 个真实工程已通过。
候选包仅供本地测试,不自动覆盖旧 Release。
## 本地候选程序
入口:`D:\CodexValidation\batch-closure-20261117\candidate\dist\DxPartReplace\DxPartReplace.exe`。这是包含完整 Harness/Node/Qt 运行时的目录包,运行时文件须与程序一起保留。应用版本资源仍为 1.3.1,本轮候选代码通过冻结模块核对区分,不代表远端已经发布了新版本。
冻结包内 162 个应用模块与最终源码编译结果一致,两份 VBS 与源码逐字节一致。EXE SHA256:`4b19948b6a008912851f3ab674afa361bf4a28de4b74f20d3d04b80719200cc1`。打包程序本身已通过启动、冻结监督进程、进程身份读取、资源释放及正常退出验证。报告位于候选目录上级的 `source-verification.json` 与 `packaged-runtime-verification.json`。
实施决定:沿用已有功能分支保留先前授权修复;互不重叠的模块并行处理后统一审查;本地直接交付完整目录包。前两项若判断错误需集成返工,目录包如需转移到其他机器可另行归档。本轮未合并、推送或发布远端版本。
@@ -0,0 +1,94 @@
# 独立工程校验验收记录
2026-11-18 已追加批量添加工程对,见[本轮验收](2026-11-18-verification-batch-import.md)。同一路径的本地开发包已更新;下文为11月17日历史结果,原EXE和证明保留在 `D:/dx-vfy-history-20261117/`。
开发分支:`codex/independent-verification`。独立工作目录:`.worktrees/independent-verification`。基础主线:`origin/main@b19afc6`;重新 fetch 后未出现更新提交。原工作区另一项修复仍有未提交修改,本分支没有复制它们。
## 已实现范围
| 阶段 | 结果 |
| --- | --- |
| N01~N04 | 独立任务、不可变输入版本、幂等交接、独立导入、当前版本投影、筛选/分页/计数 |
| N05~N08 | 原生只读导出、固定物理脚号判断、名称/属性警告、未知覆盖、同源接线图和逐脚事实 |
| N09~N11 | 第四导航、随时新建、开始/停止/重校验、历史版本与尝试、异步关闭、HTML/JSON报告、证据摘要与保留 |
| N12 | 混合批次、验收 CLI、真实原生导出已验证;最终默认回归、扩展回归和安装包结果见下方完成记录 |
## 验收路径
受控格式路径:`python tools/verify_independent_verification.py --fixture-root <目录> --output <新目录>`。夹具目录中 `before/after` 各含合法捕获配置 `.prj` 与数据库、`effective.txt` 和 `design.kyn`。该路径明确标记 `controlled-format-fixture`,不能冒充真实 CAD 导出。
真实只读路径:`python tools/verify_independent_verification.py --native-before <前工程.prj> --native-after <后工程.prj> --output <新目录>`。非零退出区分异常、缺覆盖和执行失败;警告结果保留给人工确认。
实际执行输出:`D:/dx-vfy-native-final/acceptance.json`。前后各 57 个器件、83 个有原文定位的引脚,结论 WARNING(器件属性变化且没有固定换料清单;原生身份表另有提示)。两个工程文件及两个数据库的 SHA256 前后不变,`replacement_operations=0`。JSON、HTML、网表原文及输入摘要保留于该本地目录,Git不收录工程和厂商二进制。
## 验证过的关键反例
- R12.1/2 互换:DIFFERENT;前后图位置不随名称交换,表和报告来自相同证据。
- loop→outloop、拓扑不变:WARNING;不伪造红色接错线。
- 断线、短接、位号变化、物理脚号/占用次数变化、用户网名变化:硬异常。
- 有固定清单时精确核对目标属性;无清单时列出变化并注明“未核对换料规则”。
- 缺必查字段/库映射:INCOMPLETE;硬异常与未知同时存在时仍为 DIFFERENT。
- 重复/乱序交接不重复创建;旧版本结果只留历史;重校验不会沿用旧绿灯。
- 持久停止先于提交时取消获胜;终态先提交时保留真实结果;未派发项回到待校验。
- 原始证据损坏取消绿色结论并拒绝有效报告;清历史不删除证据;存储失败暂停执行器。
- 慢证据核验不占住数据库事务,新建任务可继续;同一尝试仅一个领取者。
- 关闭可重复调用;重启不自动重跑;退出缺证明保留现场,不按 PID 误杀其他进程。
## 视觉检查
实际 Qt 截图而非生图:本机 `F:/dx-vfy-preview-20261117/`。1280×880、980×700,以及 1.25/1.5 缩放均已生成检查。接线图使用自建 R12 反脚夹具演示,不能冒充真实工程错误。完整事实另有逐脚表和原文定位。
## 验证环境与限制
共享 `.venv` 的基础 Python 路径异常,导致 `-E/-I` 的旧进程边界测试失败;Windows 默认 GBK 还影响旧测试中未声明编码的读取。没有修改产品旧执行器或用户环境变量。独立验证环境为 `D:/dx-vfy-python-20261117`,基于本机已安装 Python 3.12.10,复用已安装依赖;测试使用进程级 `-X utf8`。
首次默认回归:2221 passed、6 failed、6 errors;其中关闭重复调用的本功能回归已修复,环境相关项在独立环境的相关 66 项测试中通过。首次扩展回归 818 passed、4 failed、4 skipped;本功能首选问题定位已修正,GBK 相关的 28 项复核通过。不能把首轮失败记录解释为最终全绿结果。
F 盘空间不足使第一次构建未完成;仅清理了本工作目录本次生成的失败构建目录,构建和后续测试转到 D 盘。没有清理原工作区、客户工程或其他任务输出。引脚级 Value、确切库内部引脚到焊盘映射、ERC/PCB 正确性仍未覆盖。
## 最终完成记录
N01~N12 的新增功能已完成并提交到独立分支,本次交付本地开发包,不合并、不推送、不发布。原工作区另一任务的未提交修复未改动。
### 测试结果
| 范围 | 实际结果与证据 |
| --- | --- |
| 全部新增服务/Qt/验收组(16 个测试文件) | **81 passed**,`D:/dx-vfy-new-final81.xml`;包含慢读取不饿死、100行分页保持、刷新保留问题选择 |
| DSH 与打包扩展组 | **476 passed, 1 skipped**;跳过项是未配置官方 7-Zip 的自解压验证 |
| 默认范围分段及相关复核 | 当前收集 **2250** 项,均能在通过的分组记录中找到,`missing=[]`;`D:/dx-vfy-regression-coverage.json` |
| 一次连续默认全量稳定全绿 | **未取得**;不能用分组覆盖替代。此前运行及复核记录保留如下 |
新增组命令:使用 `D:/dx-vfy-python-20261117/Scripts/python.exe -X utf8 -m pytest`,逐项传入 `tests/v1_1/test_independent_verification_{contracts,store,intake,queries,runner,rules,acceptance}.py`、`tests/v1_1/test_verification_{pin_metadata,evidence,control,reports}.py`、`tests/ui/test_verification_{workspace,inspector,control,report_actions,acceptance}.py`(花括号表示文件集合,实际使用完整文件名),参数 `-q --basetemp D:/dx-vfy-tests-final81 --junitxml D:/dx-vfy-new-final81.xml`。扩展组命令为同一解释器执行 `-m pytest tests/dsh tests/packaging -q`。
默认范围证据:`D:/dx-vfy-default-complete.xml`(1496 passed、1 failed)、`D:/dx-vfy-default-tail.xml`(746 passed、1 failed、1 teardown error)。失败分别涉及既有 safe-user-stop 的真实 supervisor 启动见证超时,以及 history 搜索精确 250ms 的定时边界;相应文件未改,独立复核 `D:/dx-vfy-legacy-stop.xml` 为 **34 passed**。既有 VBS 超时组单独复核 **5 passed**。这些波动仍是发布前需要处理的事项,不在本次新增功能中改写旧逻辑或放宽断言。
覆盖审计只收集当前默认用例、与各 XML 的实际 passed 节点集合比较,不运行或跳过测试;证据集合为上述两份默认记录、新增81项及34项复核,`continuous_full_run_green=false`。审计脚本 `D:/vfy_audit_coverage.py`。
### 实际包验收
开发包:`D:/dx-vfy-release-20261117/DxPartReplace/DxPartReplace.exe`(须保留同目录完整 `_internal`)。源码提交 `f91b4de`;EXE SHA256:`9aeea5d8fb1263b1da32d5d0363a2f9cd6310d884c41a45c44debb4bf3fb8fb3`。随后只更新验收文档,不改变包内源码。
完整运行时由仓库标准 spec 构建。最终 Python 修改通过官方 PyInstaller PYZ/EXE API 重新编译并原子替换 EXE,复用该次已完成且未改变的原生/Node运行时,未修改厂商内容。可复核脚本为 `D:/verification-code-refresh.spec`;`D:/vfy_verify_archive.py` 实际逐个比较归一化路径后的 Python 代码对象,**22 个变更源码模块与最终包完全一致**,无 mismatch,证明保存在 `D:/dx-vfy-package-proof.json`。
| 实际操作 | 结果与现场 |
| --- | --- |
| 四导航、连续新建两个独立任务 | 通过,`D:/dx-vfy-package-ui-v2/acceptance.json` |
| 使用真实系统文件选择器添加前后工程并开始 | 原生导出完成、WARNING、输入四文件摘要不变、换料操作数0、正常退出,`D:/dx-vfy-package-pair-v5/acceptance.json` |
| 包内重校验 | generation 2、WARNING;PID+进程创建时间归属证明成立、换料操作数0、正常退出,`D:/dx-vfy-package-final-rerun/acceptance.json` |
| 最终包重启并查看已有结果 | 右侧真实接线图与“input · 需关注”加载完成;attempt数仍为2、不自动执行、换料操作数0、退出码0,`D:/dx-vfy-package-final-view/acceptance.json` |
| 最终包运行时/正常关闭 | frozen supervisor、win32timezone、创建时间读取及资源释放均通过;`tools/verify_packaged_runtime.py` 对新数据根 `D:/dx-vfy-package-smoke-delivery` 的实际结果 |
最终包截图:`D:/dx-vfy-package-final-view/native-result-final.png`。该图使用真实导出的工程结果,不能把较早在读取完成前抓到的待校验画面当成最终证据。反脚效果仍使用明确标注的自建 R12 夹具;没有改写客户工程制造错误。
### 操作与恢复细节
工程表每页100项,“下一页”有界读取;周期刷新保留当前页,筛选回第一页,开始全部不受分页影响。周期刷新等待当前查询完成,保留多选、问题选择和事实滚动位置,用户显式切换仍使用代际取消。切任务清空旧检查器,关闭先失效旧查询。
`verification/ownership.py` 用 PID 和创建时间证明校验窗口归属,保护另一窗口仍活跃的执行;调度仅处理本实例运行,停止请求持久化。进程已经退出但缺少原生CLI退出证明时仍保持资源未知;不猜测退出、不按PID杀进程、不自动重跑。资源失败原因随尝试保存。
成功交接与增量接口已通过受控真实SQLite/服务集成测试;本次包内真实验证走独立两份工程路径,没有为制造新回执再执行客户换料。未来替换实时推送不在本轮范围。
### 保留边界
引脚级 Value、确切封装库内部脚位到焊盘映射未得到来源证明,明确未覆盖;ERC/PCB及自动修复不属于本功能。默认连续全量时序稳定性尚未满足发布门槛。以上限制不以网表一致或执行完成掩盖。
@@ -0,0 +1,68 @@
# 保存后原生数据核验
本轮修正正常执行链仍然依赖全页 CAD/COM 核验的问题。DxDesigner 负责目标器件替换、属性恢复、保存和关闭;保存后的目标数据与连接核验由 Mentor 原生命令行导出承担。
```mermaid
flowchart TD
A[原生数据发现目标:工程、页、位号] --> B[打开工程与目标页]
B --> C[仅记录目标器件原属性]
C --> D[替换目标器件,记录库件 Value 写入期望]
D --> E[恢复属性与 NC,暂存 pending_save]
E --> F{还有同工程目标?}
F -- 有 --> C
F -- 无或暂停 --> G[保存并关闭一次,发布 project_saved]
G --> H[捕获保存数据库,原生命令行导出]
H --> I{按工程、页、位号核验目标数据}
I -- 通过 --> J[原子提交本工程回执,追加完成状态]
I -- 不通过或导出失败 --> K[保留已保存待核验状态,不重放替换]
K --> H
J --> L[独立前后网表比对复用同一份保存后导出]
```
## 开发项
- [x] 正常路径不调用全页语义状态、非目标属性、连接索引与原生 CAD 宿主快照。
- [x] 新快照 `saved_netlist_v1` 仅含目标 C/A;旧快照继续使用原兼容路径。
- [x] helper 使用 `native_replace_applied`,不将写入完成冒充核验通过。
- [x] 写入前固定选定库件、Value/NC 与 Cell 期望,保留原 preserve 语义。
- [x] 工程末保存关闭一次;不为核验重开 CAD。
- [x] 原生导出按工程、页、位号匹配目标,UID 作为尝试关联证据。
- [x] `project_saved` 仅授权后续原生验证,SQL 完成提交必须具备已验证导出。
- [x] 暂停、重启与恢复沿用原尝试,已保存操作不重放。
- [x] 回执只记录本项观察与共享导出引用,完整工程证明只存一份。
- [x] 独立网表比对复用保存后导出。
- [x] 完成状态以追加方式发布,保持活动批次的增量读取位置。
- [x] 单步执行和非复用模式也按本次调用保存、原生核验、提交完成。
- [x] 多批保存恢复只对最新保存状态比较当前源;历史已完成批次核对其固化证据。
- [x] 修正真实工程端口名 `LED2/RXDLY` 被误识别为层级路径的问题。
- [x] 审查发现的可变缓存图与 mixed no-match 提交问题均有失败复现和修复测试。
## 验收记录
真实验证只使用备份的新副本,原备份 34 个文件哈希保持不变。样本选择单页 RL02/RL05,料号从 `4100-CA3300-T7` 替换为 `4100-CA3300-2200`。
第一次副本完成替换、一次保存与关闭,但原生解析因带 `/` 的端口名误判而拒绝提交。修复解析后,新 Python 进程在 6.03 秒内完成导出与原子提交,两项仍为 generation 1,没有调用 CAD 或重放替换。以原备份独立导出作前基准,与已验证保存后导出比较,结果 verified、差异为空;后导出直接复用。
第二次副本暴露完成状态发布重建文件、破坏增量读取位置的问题。追加式发布修复后,第三次全新副本完整执行通过:任务表状态 completed,两项操作 verified 且 generation 仍为 1,CAD 进程正常退出。
| 指标 | 上一轮 | 本轮第三份副本 |
| --- | ---: | ---: |
| 两项任务总耗时 | 1450.341 秒 | 226.461 秒 |
| 工程打开 | — | 1 次 |
| 工程保存 | 1 次 | 1 次 |
| 全页原生 CAD 快照 | 4 次 | 0 次 |
| 保存后为核验重开 CAD | 存在 | 0 次 |
本轮无 `post-state-*.tsv`,两个目标快照均无 U/G 记录。独立原生器件清单读取耗时 1.312 秒,13 个器件料号全部符合预期;对第三份副本的完整原生前后网表比较同样 verified、差异为空,直接复用保存后导出。原备份 34 文件哈希不变。耗时降低约 84.4%,剩余耗时主要在 CAD 启动、目标定位、替换交互和属性写入。
本次只完成两项目标的实机功能与性能探针,不能代替此前要求的 20 个业务样本验收。
第四份新副本验证非复用分支:253.389 秒,两次打开/保存,两个工程提交均 verified,任务 completed,全页 CAD 原生采集仍为 0。两个公开执行事件的 Value 回执均为 verified。随后在该副本模拟“SQL 已提交但状态发布未完成”的保护记录,复现历史源指纹错误阻塞;修复后,新 Python 进程在 0.452 秒内完成恢复,尝试编号、generation、操作状态和历史条目数量均未改变,审计记录 `native_replacement_called=false`。CAD 进程已正常退出。
全量回归先得到 2412 通过、1 失败;失败来自抽取 VBS 函数的测试夹具漏声明全局新模式变量。修正夹具后该文件 37 项通过;最后一轮涉及执行、恢复、状态、网表与身份关联的回归 430 项通过。后续多批恢复专项 51 项通过,包含三个恢复时机与五个失败证据场景。将全量与增量报告按测试名称合并、以后续复验覆盖原失败结果,**2426 个不同用例均已验证通过**;这不是一次完整重跑的数量,也不将重复执行算作额外业务样本。
证据位于 `D:/CodexValidation/saved-netlist-20261117/`,自动化报告位于 `build/saved-netlist-validation/`。
## 覆盖限制
原生 ASCII 导出不证明 Value 属性的空值/缺失差异,也不覆盖 CAD 显示位置、字体和颜色;回执保留此限制,不伪造这些图形核验结果。本轮不更新旧候选安装包。
@@ -0,0 +1,56 @@
# 私有桌面累积:GitHub 参考与本地可行性验证
日期:2026-11-18。范围:工单 #20/#29 的 Win32 Desktop 生命周期;不涉及独立校验工作台。本轮为源码调研和一次性 Win32 探针,未修改产品执行逻辑,也未启动 Mentor。
## 结论
推荐采用“当前用户、当前 Windows 登录会话内的固定命名桌面,串行租用;每批独立进程 Job 与执行代次”。桌面身份与任务/批次身份解耦。默认只需一个槽位,因为现有 CAD 本身串行执行。
现有 `BatchCadRuntime._ensure_desktop()` 每次需要新运行代次就生成 `dx-<uuid>`。外部 Agent 留住旧桌面后,隔离记录允许后续任务继续,但新一代仍创建不同桌面;这处理了队列阻断,没有限制桌面对象数量。
固定对象可以在前一批自有写进程退出后重新打开,即使外部只读句柄仍存在。关闭自己的句柄、关闭 Mentor 和确认桌面对象消失是三件不同的事。复用不应把 `desktop_disappeared=false` 伪报为 true。
## GitHub 参考
| 项目 | 核对源码 | 借鉴内容及边界 |
| --- | --- | --- |
| Sandboxie Plus | [GuiServer.cpp](https://github.com/sandboxie-plus/Sandboxie/blob/f23a6cfd50f506413634e8f2906bfc2888d2b1c3/Sandboxie/core/svc/GuiServer.cpp#L1237) | `GetWindowStationAndDesktopName` 使用静态窗口站/桌面句柄和缓存名称,复用长期管理对象。这里只借鉴资源生命周期,不表示 Sandboxie 已证明解决本机 OCular 问题;它的 dummy desktop、驱动和权限模型不照搬。 |
| System Informer | [native.c](https://github.com/winsiderss/systeminformer/blob/952a0e7a4efb45b5e1acc4c733916684a7803406/phlib/native.c#L2158)、[hndlinfo.c](https://github.com/winsiderss/systeminformer/blob/952a0e7a4efb45b5e1acc4c733916684a7803406/phlib/hndlinfo.c#L2256) | 系统句柄枚举、进程句柄快照、对象类型/名称查询,适合作为按需持有者诊断参考。权限不足必须保留未知,不以推断代替持有者身份,不把远端关闭句柄作为日常回收策略。 |
| DesktopHeapDiag | [README](https://github.com/leonardomsft/DesktopHeapDiag/blob/7af5ffc3bbc499d3e0850c61326880bc95cb93a5/README.MD)、[main.cpp](https://github.com/leonardomsft/DesktopHeapDiag/blob/7af5ffc3bbc499d3e0850c61326880bc95cb93a5/main.cpp) | 说明桌面堆与 USER 对象的区别。该工具通过大量注册窗口类、逼近分配上限估算使用率,不适合嵌入产品每批自动运行;本轮只读源码,没有运行它。 |
另核对 UltraVNC 的桌面线程退出处理和 CreateDesktop 示例。普通 Windows Virtual Desktop 切换器使用另一套窗口分组接口,不能替代 Win32 HDESK 管理。未引入任何上述项目的二进制、驱动或依赖。
微软 [CreateDesktopW](https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-createdesktopw) 明确规定:同名桌面已存在时返回已有对象句柄。[CloseDesktop](https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-closedesktop) 关闭调用方句柄;调用进程线程正在使用该句柄时会失败。重复 CloseDesktop 不能替外部进程释放其引用。
## 最小落地方案
1. 同一用户、同一 Windows 登录会话、同一窗口站使用一个稳定桌面名。不能由工作区路径或批次 UUID 决定,避免更换 data-root、重启程序或多份安装包又制造新桌面。
2. 用同范围的命名互斥量串行领取桌面;桌面名称、访问权限与持久租用记录共同确认归属,不能收养任意历史 `dx-*` 对象。
3. 每批仍建立新 Job、执行代次、尝试身份与新 Mentor 进程。前批自有写进程及其子树确认退出后,才能把桌面交给下批。已保存回执、源隔离和不重放规则沿用既有逻辑。
4. 批次结束先收尾 Mentor/worker 和 Job,再关闭本批桌面句柄。对象消失则记录 released;外部句柄留住但已满足交接条件时记录可复用的空闲桌面及残留事实。不能继续依赖“名称存在=前批写入仍活跃”。
5. 异常/重启后重新核对原进程身份与租用记录,再打开相同槽位。槽位仍有实际写入者或无法安全交接时,仅等待该槽位处理,不以新 UUID 桌面绕开。
6. 历史资源记录引用租用代次,而不把名称相同误认成同一批 CAD。旧记录不能反复向新 Mentor 发 Quit,也不能因新批正在使用同名桌面而重判旧批清理失败。
首版无需常驻服务、桌面池扩容或新第三方管理器。使用现有 supervisor 持有本批租用即可。正常结束仍按用户要求退出 CAD;跨批复用的是桌面对象。
## 本地可行性探针
脚本:`build/desktop-research-20261118/probe_named_desktop_reuse.py`。结果:`build/desktop-research-20261118/named-desktop-reuse-result.json`。
- 一个明确由探针创建的独立进程持续 OpenDesktop,模拟外部 Agent 持有引用。
- 创建进程关闭自己的句柄后,桌面继续存在,确实进入外部持有场景。
- 20 个独立工作进程依次打开/创建同一个名称,每次实际启动另一个进程,在目标桌面创建并销毁 Win32 STATIC 窗口。
- 其中 4 个工作进程在自己的 GUI 子进程正常退出后直接 `os._exit(0)`,验证其桌面句柄交给系统收尾的情况;没有测试 GUI 子进程仍活着时的崩溃接管。
- 20 轮名称集合始终只比初始状态多同一个对象,新增桌面对象数为 1。
- 外部持有者关闭句柄后,该对象消失。调用线程的桌面未变化,没有切换输入桌面。
- 46.356 秒,探针 passed;所有探针子进程已结束,无 Mentor 进程启动。
该探针证明同名对象在外部引用保留下可跨进程复用,不证明真实 OCular 的持有方式完全相同,也不证明 Mentor 跨批 ROT、COM、许可、弹窗和退出兼容性。它更不代表 20 个业务样本通过。
## 产品改动范围与正式验收
预计涉及 `isolated_desktop.py` 的明确打开/创建与释放事实、`batch_runtime.py` 的槽位租用和代次、`batch_resources.py` 的历史租用解释,以及 supervisor 跨进程互斥范围。保留现有进程所有权、已保存回执和原生网表核验。
正式验收应包括外部引用持续存在下的多批真实 Mentor、正常退出/重启、owner 崩溃但 Job 子进程尚在、两份应用同时请求、证据中断、旧租用记录与新代次隔离,并检查桌面对象数不随批次数增长。至少两份工程轮换且分别核验最终原生数据。
已经存在的任意 UUID 桌面不会因采用稳定槽位自动消失。存量对象仍需外部持有方正常关句柄,或由系统在相关登录会话结束时回收;产品先控制新增对象数量。应在用户故障机上核对持有者和长期运行数据,才能宣布 #20 根治。
@@ -0,0 +1,83 @@
# 固定私有桌面复用:实现与验收
日期:2026-11-18。分支:`codex/issue29-blocking-cleanup`,基础提交:`d08a940`。范围为 #20/#29 的桌面累积和租用交接;不包含独立校验工作台。
## 实现结果
同一 Windows 用户 SID、登录 SID、窗口站产生稳定的 `dx-<32hex>` 桌面名,不再按批次 UUID 创建新桌面。批次、执行代次、租用编号、Mentor 进程及每个子进程的命名 Job 仍独立。批次结束仍退出 Mentor。
默认队列运行时、独立 CAD 和需要 GUI 的 LibraryManager 入口均启用 managed 模式。原始 `PrivateDesktop` 默认接口保留,缓存命中及纯 CLI 路径不额外领取桌面。无新依赖、服务或桌面池。
租用状态存于 `%LOCALAPPDATA%/DxPartReplace/desktop-slots/<scope>/`,使用命名互斥量跨进程串行交接。目录创建后取规范路径,以适应本机 Codex MSIX 路径虚拟化。一个短生命周期线程持有和释放 Win32 mutex,允许主线程领取、监控线程收尾,避免 Windows 互斥量的线程所有权错误。
启动前先持久化命名 Job;实际 Windows 启动通过 `PROC_THREAD_ATTRIBUTE_JOB_LIST` 在 CreateProcess 内原子分配 Job,避免 owner 在“创建子进程”和“加入 Job”之间崩溃留下无归属子进程。启动记录未发布时,仅原子分配且实际 Job 已空的情况允许接管。自定义未知启动边界继续保留未确认状态。
```mermaid
flowchart TD
A[请求执行批次] --> B[领取稳定名称的互斥租用]
B --> C{前批 owner / Job 已退出?}
C -- 否或未确认 --> D[保留等待状态,不创建其他桌面]
C -- 是 --> E[创建或打开同名桌面]
E --> F[独立命名 Job 启动本批 Mentor / worker]
F --> G[执行、保存及原生数据核验]
G --> H[正常退出或失败收尾本批进程]
H --> I{本批写入者与句柄均已收尾?}
I -- 否 --> J[保留租用,继续收尾]
I -- 是 --> K[关闭本批桌面句柄,写不可变归还证明]
K --> L{桌面对象已消失?}
L -- 否 --> M[记录 reusable / isolated,允许下批复用]
L -- 是 --> N[记录 released]
```
外部句柄留住桌面时,记录 `desktop_released=false` 与 `desktop_release_state=reusable`,不把归还租用伪报成对象已消失。旧批次只校验自己的不可变归还证明;被动观察桌面消失也取得同一互斥量,不打开或关闭新批次的 Mentor。
## 验收证据
证据根目录:`D:/CodexValidation/managed-desktop-20261118/`。构建临时 XML 位于本仓库 `build/managed-desktop/`,不作为产品文件提交。
| 验证 | 结果 | 证据 |
| --- | --- | --- |
| 最终相关回归 | 133 passed,43.55 秒 | `build/managed-desktop/final-regression.xml` |
| 更早运行的桌面、runtime、catalog 回归 | 143 passed | `build/managed-desktop/regression-1.xml` |
| 更早运行的资源生命周期、恢复、保存证明回归 | 135 passed | `build/managed-desktop/fake-delta.xml` |
| 最终原生循环 | 20 轮通过,34.781 秒 | `native-probe-04/report.json` |
| 两批真实 Mentor | 均通过保存与原生数据回读 | `mentor-live-final/two-batches-result.json` |
| 原始备份保护 | 34 个文件 SHA-256 均未变化 | 对照 `mentor-live/original-hashes.json` |
上述 pytest 集合存在交集,不能累加为独立样本数。先前一次回归与真实 CAD 同时争用默认槽位导致 3 项失败,最终已在 CAD 退出后串行重跑相关模块,包含这 3 项,133 项全过。
### 原生循环的判定范围
生产 `BatchCadRuntime` 入口运行 20 个独立进程轮次,外部 helper 全程 OpenDesktop 保持句柄,各轮实际创建和销毁 Win32 窗口。验证稳定桌面名、20 个不同租用编号、竞争实例拒绝领取、owner 崩溃后存活 Job 阻止接管、Job 退出后允许复用。分别覆盖进程身份发布后崩溃,以及原子 Job 已分配但身份尚未发布时崩溃。helper 释放后检查对象消失。
桌面数量断言针对本探针自己的资源记录:整个运行仅一个受管理名称。全系统枚举同时记录,但其他应用可能并发创建对象,不能把全系统变化归因于本产品。早期 probe-01 因该全系统断言失败的报告保留;probe-03 在改成按归属统计后通过,最终版本另跑 probe-04。原生 20 轮不是 20 个 BOM 业务样本。
最终 probe-04 全部判定通过:20 个独立租用共用一个名称;并发实例和崩溃后存活 Job 均阻止接管;两种崩溃边界在 Job 退出后恢复;外部 holder 退出后桌面消失。最终检查两批真实任务的全部已记录写进程身份均已退出,受管理桌面已不存在。
### 两批真实 Mentor
使用两个独立的新工程副本,同一个外部 helper 跨两批一直持有桌面引用。每批仅替换 `RL02`:`4100-CA3300-T7` → `4100-CA3300-2200`,并从保存后的原生数据回读确认 RL02 和其他未选位号。
| 项目 | 第一批 | 第二批 |
| --- | --- | --- |
| 队列执行耗时 | 201.373 秒 | 156.222 秒 |
| saved / failed | 1 / 0 | 1 / 0 |
| 任务状态 | completed | completed |
| CAD 代次 | 1 | 1 |
| 正常退出 / 强杀 | 正常 / 无 | 正常 / 无 |
| CAD 退出收尾耗时 | 3.484 秒 | 3.156 秒 |
| 租用编号 | `2a9dfc16c34e4510bc0df4710869ea02` | `62c4f185a1ac45ccad8a387369d7b5d3` |
两批桌面均为 `dx-5f48d43089f541634f609af9e3fbdfac`。批次刚结束、helper 仍持有时,Mentor 已释放,桌面未消失,租用已归还。helper 关闭后,两批历史资源记录经被动核对均为 released,待释放集合为空。整体驱动耗时 368.837 秒。
任务 ID:第一批 `e7fbebd9-c2fa-4554-be05-26f004fd0d02`,第二批 `bfdcaaf8-59ec-467f-81b5-bf061858e799`。各批 `report.json`、`tasks.db` 和 `data/batch-resources/*/session.json` 均保留于 `mentor-live-final/`。
## 审查和保留问题
独立源码审查发现并修复两处问题,均观察 RED/GREEN:归还证明临时读取失败后,历史记录不能恢复非阻塞状态;创建 Job 失败时,没有启动进程却留下未确认 launching 记录。随后审查原子 Job 分配及跨线程 mutex 交接,未发现新的具体问题。
较早真实运行保留在 `mentor-live/`:首批选择 RL02、RL05,两处替换以及 Save/CloseProject 返回后,`bind_project_commit_source` 读取 `database/icdb.dat` 遇到 PermissionError。正常 Quit 后仍需强制结束两个本批后代。业务结果保留失败/未确认,未重放。自有写进程退出后租用成功归还。本次没有修改 `execution_proof.py`,也没有放宽保存证明;数据库锁的根因仍未解决。最终两批单目标成功不能证明该失败已修复。
已有随机 UUID 桌面不会自动消失;存量仍依赖外部持有方正常关句柄或 Windows 登录会话结束。测试 helper 模拟的是外部 OpenDesktop 引用,真实 OCular 环境的长期行为仍需用户故障机验收。稳定名称只限制本产品新增受管理对象,不保证消除其他软件内部资源泄漏。
本次未构建安装包或发布新版本,没有操作原工程、中心库、系统配置或外部 Agent。
@@ -0,0 +1,86 @@
# 保存后数据库占用:修复与验收
日期:2026-11-18。分支:`codex/issue29-blocking-cleanup`,基础提交:`cdbc92f`。范围为保存后的源文件绑定、占锁交接、诊断与收尾错误;不涉及独立校验工作台。
## 问题与处理
先前 `mentor-live/first-project` 的 RL02、RL05 两处替换及 Save/CloseProject 已返回,随后 `bind_project_commit_source()` 读取 `database/icdb.dat` 时发生 PermissionError。该异常被归为通用错误,外层资源释放错误又掩盖了原始位置。历史日志缺少底层 Windows 代码和持锁者证据,仍不能认定当时的具体持锁进程。
现在先验证 CAD 身份及工程确实关闭,固定保存 marker、原始尝试和目标证据到 `project-save-pending.json`,再进行源文件绑定。只有绑定成功才发布完整 `project-checkpoint.json` 并登记工程检查点。等待期间显示“工程已保存,等待数据库释放后核验”;不是已经核验成功。
```mermaid
flowchart TD
A[替换、保存及关闭工程] --> B[验证空工程与本批身份]
B --> C[保留保存 marker 和原始尝试证据]
C --> D[读取保存源文件]
D --> E{读取结果}
E -- 正常 --> F[绑定稳定源文件及命令摘要]
E -- Windows 32 / 33 --> G[记录错误及持锁观察,最多等待 3 秒]
E -- 权限、缺失等 --> P[已保存但待核验,保留首发原因]
G --> D
G -- 仍占用 --> H[再检查暂停意图,正常退出本批 Mentor 一次]
H -- 正常退出 --> I[再次读取,最多等待 3 秒]
H -- 强杀或收尾未确认 --> P
I -- 仍占用或暂停 --> P
I -- 可稳定读取 --> F
F --> J[从保存副本导出原生数据并核验目标]
J --> K[提交真实回执,任务完成]
```
Windows 读文件使用 CreateFile 保留原生错误码,使用与后续 CRT 校验一致的 READ/WRITE 共享模式。仅 32(共享冲突)、33(锁冲突)进入等待;5(权限不足)、2(文件缺失)等直接形成明确的 `saved_source_pending` 错误。源文件读前后的工程摘要必须一致,改变或不可确认时保留待核验。
退出回调只存在于受管理 runtime 的已关闭工程、已验证保存 marker 分支。正常可读时继续复用 CAD;异常才走现有身份绑定的正常 Quit。该路径不派发替换,也不重新打开原工程。退出失败或需要强杀时,不绑定成功证明;资源释放和业务待核验分别保留。暂停会阻止进入退出回调,并在诊断、读取恢复后重新检查。已请求普通暂停但未遇锁的安全保存收尾仍沿用原流程。
首次锁冲突使用 Windows Restart Manager 只读查询候选进程,记录 PID、创建时间和名称。结果是该接口返回的观察,不是穷举全部内核句柄;空结果或查询失败均不授权结束任何外部进程。查询后重读,防止用已经过时的锁状态触发 CAD 回收。
`saved-source-status.json` 保留同一 session token、同一工程的首发错误、持锁观察及回收事实,后续 SQL 回执再次绑定时不会覆盖它;新 token 重置诊断。该文件不是成功证明,实际源文件始终重新验证。`operation-events.jsonl` 保留绑定及 Mentor 退出调用的先后顺序。多层资源异常仍显示最初的保存读取错误;诊断写入失败通过附注保留,不能替换首发错误。
## 验收结果
证据根目录:`D:/CodexValidation/saved-source-20261118/`。测试 XML 在仓库 `build/managed-desktop/`,集合有交集,不累加为独立用例或业务样本数。
| 验证 | 结果 | 证据 |
| --- | --- | --- |
| 保存、runtime、回执、恢复与反馈相关回归 | 124 passed,108.18 秒 | `saved-source-regression-final.xml` |
| 源文件交接及资源状态增量回归 | 64 passed,26.56 秒 | `saved-source-delta-final.xml` |
| 最终专项,Windows 默认 GBK 环境 | 21 passed,5.52 秒 | `saved-source-handoff-final.xml` |
| 最终原生文件锁探针 | 20 个样本通过,28.320 秒 | `native-final-02/report.json` |
| 原失败双目标工程,正常运行 | 2 saved / 0 failed,原生回读通过 | `mentor-dual/report.json` |
| 双目标工程,保存后注入真实锁 | 2 saved / 0 failed,正常退出后核验通过 | `mentor-dual-fault/report.json`、`fault-result.json` |
新逻辑均先观察失败再修复;覆盖权限/缺失不重试、短暂锁、持续外部锁、源文件变化、暂停在诊断中到达和在退出提示后到达、强杀/退出未确认不发布证明、日志写失败、嵌套异常、诊断再绑定历史、下一工程新代次和可选进度损坏。独立只读审查提出的具体问题已修复,最终复查无剩余可操作发现。
### 20 个原生文件锁样本
脚本:`tools/probe_saved_source_handoff.py`。使用合成工程与文件,不启动 CAD。五种场景各 4 次:短暂独占锁、退出持有者后读取、持续外部锁、等待中暂停、文件缺失。真实 CreateFile 独占锁返回 32;Restart Manager 查到已知 fixture 进程。仅前两类最终绑定成功,其余保留 pending,退出回调次数受限,均不执行替换。真正 ACL 拒绝不通过修改用户 ACL 制造,错误 5 由专项测试模拟。
探针中的退出回调只释放其自建 fixture 进程,不能当成真实 Mentor 回收测试。首轮 `native-01` 曾发现诊断耗时导致使用旧冲突触发退出,报告保留;补重读及回归后通过,最终又以默认编码环境运行。20 个文件锁样本不是 20 个 BOM 业务样本。
### 两次真实 Mentor 双目标验收
两个独立的新副本均替换 RL02、RL05:`4100-CA3300-T7` → `4100-CA3300-2200`。从保存后的原生数据独立读取两个目标及其余未选位号;每次仅一个 VBS worker、一次 OpenProject、一次保存,没有重放。
| 指标 | 正常双目标 | 注入锁双目标 |
| --- | --- | --- |
| 队列耗时 | 257.842 秒 | 271.420 秒 |
| saved / failed | 2 / 0 | 2 / 0 |
| 任务 / 操作状态 | completed / verified | completed / verified |
| CAD 代次 | 1 | 1 |
| 正常退出 / 强杀 | 正常 / 无 | 正常 / 无 |
| CAD 退出耗时 | 16.625 秒 | 5.688 秒 |
正常运行没有复现历史锁。故障运行由 `build/managed-desktop/live_saved_source_fault.py` 在已保存关闭后,用一个自建独立进程持有副本数据库的只读独占句柄;产品调用正常退出 Mentor,驱动确认退出回调返回后才释放 fixture,然后由产品继续核验。`fault-result.json` 证明注入成功、退出回调确实调用且运行退出码为 0。外部 fixture 并非被产品杀死,不能据此声称 Mentor 的 Quit 可以关闭任意外部文件句柄。
故障时间线(本地时间):18:16:39.722 开始绑定,18:16:43.192 开始正常退出 Mentor,18:16:48.910 退出返回,18:16:49.806 绑定完成。两次总耗时差异包含 CAD 运行波动,不能直接视为等待逻辑的固定开销。
任务 ID:正常 `d9a1c9af-7a39-4659-a445-a682c8c41a91`;故障 `be954b05-2b8c-4990-a74f-e18655ca93af`。两次任务数据库均 completed、两个操作均 verified;全部已记录写进程身份退出,受管理桌面消失。原始备份 34 文件 SHA-256 全部未变化。
真实故障验收后发现并修正同 token 诊断被第二次绑定覆盖的问题;暂停、嵌套报错、编码及诊断保留的最终增量由专项和资源回归验证。真实工程写入场景未为这些诊断增量重复执行。
## 边界
历史失败的具体持锁者仍不可从旧日志还原,本次修复并验证的是这类冲突的交接处理。持续的外部锁、真正权限不足、文件变化及强杀后不确定写入继续保留待核验,不能算执行成功,也不会自动重替换。
如果在完成源文件绑定之前退出程序,只保留保存 marker 和原始尝试,现有恢复逻辑不会把未绑定的 `project-save-pending.json` 当成成功证明。该状态仍需核对原结果,不提供自动重放或自动成功恢复。
未构建安装包、推送或发布版本;未修改原工程、中心库、系统配置和外部 Agent。
@@ -0,0 +1,41 @@
# 批量添加工程对验收
分支 `codex/independent-verification`,功能提交 `eda9403`,拒收回执修正 `de16bbd`。2026-11-18 重新 fetch 后,主线仍为 `b19afc6`。本轮只补批量导入,不修改另一任务的既有执行器修复。
## 已实现
- 第四页新增“批量添加”,打开非模态窗口,仍能新建其他校验任务。
- 读取两个独立根目录,沿用已有只读目录扫描规则,按相对路径精确配对;不按同名文件猜测对应关系。缺失、不唯一的项列出且不能勾选。
- 勾选后逐对建立冻结副本,列表与报告保留相对路径名称;同名工程可区分。导入不会启动网表校验或换料。
- 单项失败后继续,取消保留已导入项;同一批请求可续传且不重复建项。请求取消后仍绑定原始输入,不允许用相同请求标识替换内容。
- 磁盘/存储故障中断整批;任务库拒收单项时明确显示失败,不把函数返回等同于导入成功。超过256字符的批量名称提示缩短层级或逐对添加。
- 扫描、复制在后台执行;关闭窗口取消操作,晚到结果不回写已关闭界面,应用关闭协作沿用现有控制器。
## 自动化验证
| 范围 | 实际结果 |
| --- | --- |
| 原独立校验组与本轮两份新测试文件,共18文件 | **92 passed**,`D:/dx-vfy-batch-final.xml` |
| 既有关闭生命周期 `tests/ui/test_deferred_close_lifetime.py` | **2 passed**,`D:/dx-vfy-batch-close.xml` |
| 最终包运行时、supervisor、创建时间、关闭与资源释放 | 通过;`tools/verify_packaged_runtime.py`,数据根 `D:/dx-vfy-batch-smoke-20261118` |
本轮新增11项测试覆盖相对路径/缺失、根目录重叠、失败后继续、重复请求、取消续传、存储耗尽、输入绑定、拒收回执,以及Qt勾选导入、并行新建和关闭读取。先确认缺失接口、请求复用及误报成功的反例失败,再实现并复跑。
解释器为 `D:/dx-vfy-python-20261117/Scripts/python.exe -X utf8`。新文件为 `tests/v1_1/test_verification_batch_import.py` 与 `tests/ui/test_verification_batch_import.py`,与[前轮验收](2026-11-17-independent-verification-acceptance.md)的16文件校验组一起执行,使用独立D盘临时目录,没有放宽旧断言。
本轮未重新执行全部默认测试。当前默认收集2261项,在已留存的分组通过记录中均有覆盖,`missing=[]`,`D:/dx-vfy-batch-regression-coverage.json`。这属于历史分组覆盖审计,不代表新取得一次连续全量全绿;前轮记录的既有时序波动仍保留。
## 实际开发包
更新包:`D:/dx-vfy-release-20261117/DxPartReplace/DxPartReplace.exe`,保留同目录 `_internal`。EXE SHA256:`56ba31c71f61aafed0bdeab88026112adc7362c4a037d94a783cfddb5959a24f`。仍使用前轮完整标准构建的原生运行时,通过官方PyInstaller API重新编译Python代码;`D:/verification-code-refresh.spec` 显式包含新增两个模块。
实际解包与源码代码对象比较:**24个变更模块匹配,无 mismatch**;`D:/dx-vfy-package-proof.json`,复核脚本 `D:/vfy_verify_archive.py`。前轮EXE及证明另存 `D:/dx-vfy-history-20261117/`,避免覆盖历史证据。
通过外部Windows UI操作实际EXE,新建任务、点击“批量添加”、填写前后目录、读取配对、导入所选、返回任务、正常关闭。输入是既有已保存工程的复制件,包含两个同名工程对及一项缺失:
- `A/input.prj`、`B/input.prj` 正确导入,`orphan/input.prj` 因缺少修改后工程未导入。
- 校验尝试数0、换料操作数0,所有输入文件摘要不变,退出码0。
- 实际操作证明 `D:/dx-vfy-batch-package-20261118/acceptance.json`;预览截图 `batch-preview.png`、完成截图 `batch-imported.png`、任务截图 `batch-workspace.png` 在同目录。
- 测试脚本 `D:/vfy_packaged_batch.py` 只通过Windows可访问性接口操作应用窗口,再查询持久结果;没有直接注入任务状态。主窗口PrintWindow截图的灰底来自默认透明材质捕获,不据此改动既有全局UI。
批量导入仅覆盖目录结构对应的输入登记;本轮未重新执行真实原生网表导出。引脚级Value、确切库内脚到焊盘映射仍按前轮明确未覆盖。未合并、推送或发布。
@@ -0,0 +1,53 @@
# 工程校验闭环验收(2026-11-18)
后续剩余四项已完成,最新状态见[最终闭环验收](2026-11-18-verification-final-closure.md)。本文保留当时的原始范围与未测记录,不作为最新缺口清单。
按[闭环标准 v1](verification-closed-loop-standard.md)补齐 N12。代码与工具提交 `e65bed0`,分支 `codex/independent-verification`。本次没有修改另一修复任务的旧执行器,没有合并、推送或发布。
## 实现与标准
新增 `tools/verification_closed_loop.py`:开始前冻结范围、源文件摘要和换料操作基线,逐项检查实际运行成员、终态、预期结论、输入/尝试/策略绑定、原文摘要、资源退出证明与报告。空任务、漏项、停止/中断、错误预期、旧报告或源文件变化不能通过。
HTML报告增加 item、attempt、generation、输入版本/摘要和证据摘要的可核对绑定。已有换料历史允许保留;只读标准检查运行前后计数不变,而非历史总数必须为0。整任务报告中只验证选定项时必须明确指定范围,其余项不冒充已验证。
单次服务验收入口 `tools/verify_independent_verification.py` 增加 `--expect-verdict`,默认 CONSISTENT;预期警告应事先传 WARNING。输出 `frozen-scope.json` 和 `closed-loop.json`,检查不通过非零退出。它明确只覆盖 C01~C05,C06~C08 保留 not_run。
实际包入口 `tools/accept_verification_closed_loop.py` 通过Windows可访问性操作EXE,公开服务和SQLite用于读取及核对,不直接注入执行状态。必须事先给出预期名单和结论;`--fault-batch` 在私有复制件中加入明确无效的数据库反例,原输入目录不改写。
## 实际通过范围
| 场景 | 结果 | 证据 |
| --- | --- | --- |
| 两份真实保存副本批量导入、原生执行、查看、报告、重启、重校验 | C01~C07通过,两个 WARNING 符合事先指定的预期;重校验后尝试为1、1、2,旧结果和报告不变 | `D:/dx-vfy-loop-package-20261118-v2/acceptance.json`,16条检查通过 |
| 首项原生失败,后续两个真实保存副本继续 | 00-invalid 为 failed/INCOMPLETE,随后 A、B 均完成 WARNING;混合报告、重启和A单项重校验通过 | `D:/dx-vfy-loop-faults-20261118-v2/acceptance.json`,17条检查通过 |
| 只读与正常关闭 | 两个现场的所有记录输入摘要不变,换料操作数0;所有测试实例正常关闭,未按PID杀进程 | 各现场 JSON、应用正常退出日志和资源退出证明 |
| 校验功能组 | 104 passed,19个测试文件 | `D:/dx-vfy-loop-final.xml` |
| 闭环选定范围补充复核 | 19 passed,覆盖本轮验收器、CLI和报告 | `D:/dx-vfy-loop-scope.xml` |
第二现场的失败项是自建无效数据库,证据类型 `native-real-copies-and-invalid-database-fixture`。它证明真实原生导出失败后的隔离行为,不能冒充真实客户工程反脚。物理脚互换、断线、短接、loop→outloop、必查未知等判断仍由明确标注的受控服务/Qt反例验证。
各现场保存 `01-pairs.png`、`02-result.png`、`03-restart.png`、`frozen-scope.json`、`first-run.json`、`restart-readback.json`、`rerun.json` 和两个不可覆盖的报告目录。重校验报告绑定新attempt,原报告摘要未变。
## 可复现命令
使用本机独立验证环境,下面的输入目录是前轮保存副本,不是源工程;输出必须为新目录。
```powershell
& 'D:/dx-vfy-python-20261117/Scripts/python.exe' -X utf8 tools/accept_verification_closed_loop.py --exe D:/dx-vfy-release-20261117/DxPartReplace/DxPartReplace.exe --before-root D:/dx-vfy-batch-package-20261118/before --after-root D:/dx-vfy-batch-package-20261118/after --expected-items A/input.prj B/input.prj --expect-verdict WARNING --output D:/NEW-normal-loop
```
加入 `--fault-batch` 并换用新输出目录,可重复故障隔离场景。工具只在自己的输出目录复制输入并生成 `00-invalid`,该名称为反例保留名。
测试使用同一解释器 `-X utf8 -m pytest`,原18文件校验组增加 `tests/v1_1/test_verification_closed_loop.py`,参数 `-q --basetemp D:/dx-vfy-loop-delta-final --junitxml D:/dx-vfy-loop-final.xml`。补充复核为 `tests/v1_1/test_verification_closed_loop.py tests/v1_1/test_independent_verification_acceptance.py tests/v1_1/test_verification_reports.py`,输出 `D:/dx-vfy-loop-scope.xml`。
## 包身份与失败现场
本地开发包仍位于 `D:/dx-vfy-release-20261117/DxPartReplace/DxPartReplace.exe`,须保留同目录 `_internal`。本轮EXE SHA256为 `c52c43d8b4a864b85f0a39b92a5b3aab2bc36095240d42968d2d34971c270a91`。复用此前标准构建的未变原生运行时,通过官方PyInstaller API重新编译Python;`D:/vfy_verify_archive.py` 对本分支24个变更模块逐个比较代码对象,全部一致,记录 `D:/dx-vfy-package-proof.json`。上一批量版EXE和证明保留在 `D:/dx-vfy-history-20261118-batch/`。
失败记录保留:首个正常现场因自动化误用文件选择器而无法操作目录选择器;首个故障现场在重启等待中触发驱动内部15秒超时。已依据真实控件ID修正目录选择器,并让外层90秒等待正确处理内部超时;没有改产品文件对话框或伪造结果。旧现场分别为 `D:/dx-vfy-loop-package-20261118/`、`D:/dx-vfy-loop-faults-20261118/`,测试实例均正常关闭。通过结果来自修正后的全新目录,不是改写旧失败记录。
## 未测与发布门槛
仍未取得实际包中停止/资源未知的独立故障现场;其服务/Qt受控回归已通过。真实成功换料回执触发自动交接的包内闭环尚未测,不能用独立输入替代;本轮没有为此重新执行客户换料。连续默认全量没有重跑,前轮既有时序波动仍未解决。因此本次只证明上表范围,未达到发布门槛。
引脚级Value、确切封装库内部脚位到焊盘映射仍未覆盖,不能从网表校验推断这些能力通过。后续按计划中未勾选项推进。
@@ -0,0 +1,59 @@
# 剩余四项闭环验收
执行分支 `codex/independent-verification`,验收工具与回归提交 `b038951`。按[确认的剩余计划](../superpowers/plans/2026-11-18-verification-remaining-closure.md)顺序执行,未修改其他修复工作区,未合并、推送或发布。
**剩余四项均已取得对应闭环证据。** 停止/恢复、资源未知保护、真实已保存回执自动交接,以及固定提交上的连续默认全量均通过;此前历史记录中的未测状态以本文更新为准。
## 业务闭环现场
| 项目 | 已验证的实际行为 | 现场 |
| --- | --- | --- |
| 三工程停止与继续 | 第一项运行时点击停止;两项未派发保持待校验;重启不自动运行;开始全部只继续这两项,已停止项明确重校验;最终三项均WARNING,旧停止记录保留 | `D:/dx-vfy-stop-three-20261118/acceptance.json` |
| 自有实例异常退出 | 核对PID、创建时间与owner后仅中断本工具启动的实例;没有原生退出证明时重启保留stopping/unknown,不显示有效结论、不给后续项创建导出目录 | `D:/dx-vfy-owner-exit-register-20261118/acceptance.json` |
| 资源未知下可用性 | 可新建另一任务并导入两项;共4输入、仍只有原来的2次尝试;暂停原因在“检查与范围”中实际可见,应用正常关闭 | 同目录 `reason-visible.json`、`resource-unknown-reason.png` |
| 真实保存回执自动交接 | 临时副本RV05从4100-CA0000-T7到4100-CA0000-T0,RV11保持;恰好一条verified换料记录,自动交接只有一个工程项 | `D:/dx-vfy-real-handoff-20261118-v2/acceptance.json` |
| 交接后校验、报告、重启与重校验 | 两次尝试generation 1/2,均WARNING;声明属性为expected_change,物理脚/连接/位号/覆盖/网名等必查equal;14条闭环检查通过,换料记录完整内容未变,重复交接未重复建项 | 同目录 `verification-loop/acceptance.json` |
所有只读校验现场的输入摘要再次核对未变。真实换料只发生于新测试副本,原始样例及共享库LMC摘要仍与执行前一致。资源未知现场按设计保留,不补造退出证明;测试应用实例均已退出。
预期在开始前保存:停止/异常场景的 `frozen-scope.json`,真实换料的 `predeclared.json`。后者先真实原生导出证明RV05/RV11前提,再准备BOM并通过实际EXE点击确认执行;无直接SQLite写入来伪造换料结果。
停止现场有 `continued.json`、`stopped-item-rerun.json` 和各自报告。真实交接有确认截图、自动交接截图、原生before/after、不可变快照、实际运行回执、报告以及重启截图。未知资源场景有本工具记录的owner身份和界面截图,未终止其他进程。
## 实现与验证边界
新增控制场景验收检查器和真实交接验收工具;`accept_verification_closed_loop.py` 增加 `--control-scenario stop|owner-exit`、`--handoff-data`。产品没有新增故障开关,也没有更改旧换料执行器。
真实交接的before是历史不可变快照,替换保存后,其原路径自然已有新内容。验收器仅在明确的 `historical_before=True` 且存在预期清单时使用历史快照证明before,以after源摘要作为后续校验只读基线,不重新捕获旧before。普通独立导入仍检查源文件未偏离导入版本。
只读检查增加执行日志摘要,除了记录数不变,还要求原有command、receipt和generation不变;相应反例已先失败再修正。真实实际包外层另外比较校验前后全部换料记录,证明不会原地重放已有操作。
针对验收器/控制/CLI/报告的相关回归:**22 passed**,`D:/dx-vfy-final-closure-related.xml`。
第一次连续默认全量:**2276 passed,0 failures,0 errors**,`D:/dx-vfy-continuous-default-20261118.xml`,耗时1214.45秒。此轮启动后补充过验收器的日志摘要反例,因此仍追加在固定提交 `b038951` 上的最终全量运行,不把首轮当作最终固定测试版本的全部证据。
执行恢复/回执及打包扩展:**120 passed,1 skipped**,`D:/dx-vfy-final-closure-extended.xml`。范围为 `tests/dsh/test_execution_recovery.py`、`test_run_journal.py`、`test_large_execution_scope.py` 和 `tests/packaging`;跳过的是未配置官方7-Zip的自解压验证。
固定提交上的最终默认全量:**2276 passed,0 failures,0 errors,0 skipped**,输出 `D:/dx-vfy-fixed-default-20261118.xml`,耗时1271.60秒。启动前记录631个已跟踪产品/测试/工具文件的SHA256:`D:/dx-vfy-fixed-default-20261118-manifest.json`;结束后实际复核全部不变。它与第一轮分开留证,不能用历史分组覆盖代替。
两轮均只有pywinauto的STA COM线程模式提示,没有失败或错误。本轮未改写旧测试的时序断言;当前完整回归通过不等于声称根治所有环境中的历史时序波动。
第一次真实交接现场 `D:/dx-vfy-real-handoff-20261118` 因自动化尚未选择任务导致执行按钮不可用,记录失败并正常关闭,换料操作数0。修正测试驱动为先选择任务,再使用全新v2副本完成实际执行;没有对已替换副本重复派发。
## 包身份
仍使用 `D:/dx-vfy-release-20261117/DxPartReplace/DxPartReplace.exe` 和完整 `_internal`。EXE SHA256:`c52c43d8b4a864b85f0a39b92a5b3aab2bc36095240d42968d2d34971c270a91`。本轮只改验收工具、测试和文档,产品代码没有改变,无需重新构建。
`D:/vfy_verify_archive.py` 已对本分支24个变更产品模块逐个比较最终包代码对象,全部匹配。身份记录 `D:/dx-vfy-package-proof.json`。校验源码与包的一致性不能替代厂商工具或库内部能力验证。
最终运行时复核通过:`tools/verify_packaged_runtime.py` 对全新数据根 `D:/dx-vfy-final-closure-runtime-20261118` 验证frozen supervisor、win32timezone、进程创建时间、正常退出和资源释放,均为true。开发包保持原SHA256。
## 复现入口
使用 `D:/dx-vfy-python-20261117/Scripts/python.exe -X utf8`,工作目录为本分支。所有输出目录必须新建且不能位于源工程/库内。
- 停止/异常退出:`tools/accept_verification_closed_loop.py --exe <EXE> --before-root <前目录> --after-root <后目录> --expected-items A/input.prj B/input.prj C/input.prj --expect-verdict WARNING --control-scenario stop --output <新目录>`;未知资源用 `owner-exit`,至少保留两项供未派发检查。
- 真实交接:`tools/accept_verification_saved_handoff.py --source <原始已保存工程.prj> --library <已安装库.lmc> --exe <EXE> --output <新目录>`;固定RV05/RV11和料号前提不满足时失败,不临时换测试目标。
- 连续默认全量:`-m pytest -q --basetemp D:/dx-vfy-fixed-default-20261118-long-temporary-root --junitxml D:/dx-vfy-fixed-default-20261118.xml`;重复执行须换用全新临时根和XML文件,保留本次原始记录。
引脚级Value和确切封装库内部映射仍未覆盖,不属于四项验收缺口,也未宣称完成ERC/PCB验证。官方7-Zip缺失导致的自解压安装包检查仍为skip;本轮交付已验证的本地开发包,没有制作、合并或发布新安装包。
@@ -0,0 +1,71 @@
{
"verification_method": "Full main/UI run plus focused reruns for amended behavior; not a second whole-suite run.",
"unique_verified_cases": 2438,
"unresolved_failures": 0,
"junit_sha256": {
"final-regression.xml": "3e06b8c07bb057a039d67ce62eb2dcc133a52c0a24af1158c0f32cb8658dc277",
"root-delta.xml": "9124ddb63d063f4c07319e83541d4b8da2dfe0376d03ba4307568e8631d98f00",
"lifecycle-delta.xml": "1a753e128f82aad2c93ac6a56ff02201141bb7a2df178066d4376d8252a4cdb5",
"project-recovery-delta.xml": "a6834285d840263bcddd908d86594c9f742f696490a52bb2b2b382e4c7ffecaf",
"identity-final-delta.xml": "7990ce9459db3dec29c3ddbec3b6080569f5c527f3240bc8d896bb659e34329c",
"lifecycle-deleted-delta.xml": "fbdc727e207b747f5d4f95db437e04f573572fe74828d9d85dc9f3c6ad1fc445"
},
"real_mentor": {
"verified": true,
"real_mentor": true,
"targets": [
"RL02",
"RL05"
],
"native_inventory_readback_targets": 13,
"source_unchanged": true,
"source_files": 34,
"save_calls": 1,
"project_open_calls": 2,
"worker_starts": 1,
"saved_items": 2,
"operations": [
[
"verified",
1
],
[
"verified",
1
]
],
"project_commits": [
[
"verified"
]
],
"queue_seconds": 1450.341202999989,
"independent_readback_seconds": 1.5047315999981947,
"resource_state": "released",
"forced_termination": false,
"limitation": "Two replacement items on one copied project; concurrent tests/build affected timing; no speedup claim."
},
"review_reports": [
"identity-review.md",
"progress-review.md",
"lifecycle-review.md",
"final-review.md"
],
"candidate_published": false,
"packaged_source_verification": {
"passed": true,
"compiled_application_modules": 162,
"mismatches": [],
"executable_sha256": "4b19948b6a008912851f3ab674afa361bf4a28de4b74f20d3d04b80719200cc1",
"full_harness_present": true
},
"packaged_runtime_verification": {
"passed": true,
"frozen_supervisor": true,
"win32timezone_archived": true,
"process_creation_time_read": true,
"resources_released": true,
"executable": "D:\\CodexValidation\\batch-closure-20261117\\candidate\\dist\\DxPartReplace\\DxPartReplace.exe",
"data_root": "D:\\CodexValidation\\batch-closure-20261117\\candidate\\runtime-smoke"
}
}
@@ -0,0 +1,35 @@
# 工程校验闭环标准 v1
本标准用于 N12 及后续功能。写完代码、测试通过、工程检查一致、业务闭环通过、允许发布,是不同结论。每次验收必须声明正在证明哪一个结论。
## 单次功能闭环的通过条件
| 编号 | 必须证明 | 不满足时 |
| --- | --- | --- |
| C01 输入冻结 | 开始前写下预期工程名单、数量、前后摘要、输入版本和检查策略;配对预览与实际导入相符 | 失败;不能从运行后的结果反推预期 |
| C02 完整执行 | 用户显式开始;运行成员与冻结范围完全相同,每项都有属于本次运行的终态尝试 | 有排队、运行、停止、中断、漏项或重复项,均不能算完整闭环 |
| C03 判断正确 | 每项结论符合事先指定的预期;执行成功与 CONSISTENT/WARNING/DIFFERENT 分开;必查未知不得通过 | 误报、漏报、未知充当一致都失败 |
| C04 事实同源 | 页面、逐脚表、JSON和HTML报告绑定同一 item、输入版本、attempt、generation、输入摘要和证据摘要;原文摘要可复核 | 任何串版本、旧结果、缺证据或报告不符都失败 |
| C05 只读安全 | 校验前后全部已冻结源文件摘要不变,新增换料操作数为0,执行资源退出有证明;已有换料历史以开始前基线计数核对 | 不变性或退出证明缺失,失败并保留现场 |
| C06 重启回读 | 正常退出后重启,结果及证据仍可查看,尝试数不增加、不自动重跑 | 失败 |
| C07 重校验 | 同一输入重新执行时 attempt 更新、generation 递增;旧结果保留,新旧报告均可追溯 | 失败 |
| C08 异常隔离 | 反脚/断线等业务异常不挡后续工程;停止后未派发项仍待校验;资源/存储未知暂停正确范围;仍可新建独立任务 | 相应异常用例失败;不能以“正常样本跑过”替代 |
只有本次要求的检查全部通过,才写“该功能闭环通过”。验证程序对失败必须非零退出;结构性检查失败不能被 WARNING、正常进程退出或成功生成文件覆盖。某项故障测试验证了预期失败,不等于故障工程已经检查通过。
## 固定业务反例
物理脚1/2互换、断线、短接、位号或物理脚号变化必须为 DIFFERENT;loop→outloop 且连接不变必须为 WARNING;必查字段缺失必须为 INCOMPLETE。图中固定物理脚号位置,异常端点可与逐脚表和原文对应。自建格式夹具用于反例和可复现测试,必须明确标注,不能当成真实CAD导出证据。
## 两条业务路径分别验收
1. 独立输入:实际开发包中批量添加 → 开始全部 → 原生导出 → 查看图表 → 导出报告 → 正常关闭 → 重启查看 → 重校验 → 再导出。
2. 成功结果交接:真正已落盘的成功换料回执 → 自动登记校验 → 同一套执行、复核与报告。重复接收不重复建项,未保存项不得作为成功项。
两条路径不能互相代替。受控服务测试可证明交接合同、幂等和非阻塞;没有取得实际成功回执触发的包内证据时,该路径记“实际闭环未测”。本任务不为补验收重新执行客户换料,也不修改其他任务的旧执行器。
## 留证与发布
验收记录至少包含:代码提交、EXE SHA256、证据类型、预期清单、输入和报告摘要、任务/运行/尝试身份、每项标准的 passed/failed/not_run、失败原因、截图和实际命令。前一次运行、仅有截图、历史分组测试覆盖均不能替代本次闭环。
发布还要求相关回归通过、连续默认全量无未解决失败、实际包身份与源码相符、声明的两条实际路径通过。现有时序波动仍是发布保留项,不在本功能中改断言掩盖。引脚级Value和确切库内脚到焊盘映射仍未覆盖;不能写成“封装全部正确”。
+9 -1
View File
@@ -4,7 +4,7 @@
主工具顶部固定显示左右两个入口:左侧 **任务中心**,右侧 **DSH助手**,单击直接切换,无需展开菜单。助手也可按 `Ctrl+Shift+D` 打开;切回任务中心再进入助手时保留同一个网页、会话和未发送草稿。右侧“任务监管”读取主工具当前选中的任务。
这里直接运行 [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) 的官方前端与运行时,固定 npm 版本 `0.2.1-rc.5`,通过 Qt WebEngine 嵌入主窗口。官方三栏框架、原生 SVG、鲸鱼悬停动画、输入编辑器、模型选择、侧栏与停靠交互均由上游代码提供。项目增加任务监管插件和“DSH助手”名称,不再使用 Qt 控件重画聊天页面。上游许可见 `licenses/DeepSeek-Harness-MIT.txt`。
这里直接运行 [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) 的官方前端与运行时,通过 Qt WebEngine 嵌入主窗口。当前 npm 版本以 `integration/dsh/package.json` 为准。官方三栏框架、原生 SVG、鲸鱼悬停动画、输入编辑器、模型选择、侧栏与停靠交互均由上游代码提供。项目增加任务监管插件和“DSH助手”名称,不再使用 Qt 控件重画聊天页面。上游许可见 `licenses/DeepSeek-Harness-MIT.txt`。
不显示上游账户登录、注册、充值和首次产品引导,也不注册其账户模型提供方。左下角 **工具设置** 单击打开原生设置页,包含“DSH工具”“通用设置”和“模型”;首页提示和任务监管面板围绕器件替换任务。输入框下方选择已配置的模型。
@@ -178,6 +178,14 @@ node tools/verify_dsh_runtime.mjs
python tools/accept_dsh_desktop.py
```
源码工作区可从 npm 更新 DSH。先退出任务中心,运行更新命令,再重新打开任务中心。
```powershell
powershell -ExecutionPolicy Bypass -File tools/Install-DshRuntime.ps1 -Version latest
```
将 `latest` 换成 `0.2.2-rc.5` 这样的完整版本号即可安装指定版本。脚本先在临时目录启动候选运行时并验证任务插件,通过后更新依赖声明、锁文件和实际依赖。更新成功时会打印 `build/dsh-update-…` 路径,其中 `previous` 保存旧运行时,`verification/report.json` 记录验收结果。便携版随应用打包 DSH,通过重新构建的应用发行包更新。
CLI 验证启动真实官方内核,检查工具与 preset 名单,实际读取快照、执行禁止工具探针,并测试本机请求认证、跨任务与过期动作边界。桌面验收启动真实主工具,用 Qt 鼠标事件单击左右导航,用 Chromium Input 事件操作官方页面,核对全新数据下无账户或引导弹窗、工具设置、任务刷新、会话、侧栏、SVG 动画、模型选择、草稿保留、取消确认和正常退出。验收只使用独立测试数据,不启动 CAD 或修改用户工程;未配置模型的验收不计为真实模型回复验证。
已配置本机模型时,可执行真实 API 桌面验收:
+25
View File
@@ -0,0 +1,25 @@
# 工程校验
在第四个“工程校验”页面随时新建任务。选择修改前、修改后两份已保存的 `.prj` 工程添加比较项,不能选择同一文件或共用数据库的两个工程。已有替换任务不影响新建;替换已保存的成功项会自动交接,缺少前后副本的项显示无法校验,不能用当前工程补造历史版本。
大量工程可点击“批量添加”,选择修改前、修改后两个根目录,再点“读取配对”。两个目录不能相同或互相包含。工具沿用工程目录扫描规则:发现含原理图工程的目录后,不再扫描其子目录;数据目录不参与扫描。
配对只认相对路径,例如前目录的 `Board-A/board.prj` 对应后目录的 `Board-A/board.prj`;不同子目录中同名工程不会混配。预览列出缺失或无法唯一配对的项,它们不能勾选。不符合这个目录结构的工程,仍可用“添加工程对”逐对指定。
批量导入后,任务内保留这个相对路径作为工程名称,列表、历史和报告中都能区分不同目录里的同名工程。
批量名称沿用任务库的 256 字符上限;相对路径超过上限时该项显示导入失败,可缩短目录层级或使用“添加工程对”单独添加。不会把任务库拒收误报成导入成功。
勾选后点“导入所选”,只建立前后只读副本,随后回到任务点击“开始全部”或“校验所选”。单项导入失败后继续其他项,失败原因保留在状态提示中;取消或关闭导入窗口时保留已导入项,未处理项可继续选择导入。磁盘空间或存储故障会中断整批并保留已导入项。此窗口不阻止新建其他校验任务。
“开始全部”处理当前任务中当时待校验/中断的工程;筛选不会缩小这个范围。“校验所选”和“重校验”明确处理所选工程当前版本。运行期间后到的新项或新版本留待下次开始。校验只读副本,不会重新换料或自动换脚。
工程表每页最多显示 100 项,点击“下一页”继续查看;自动刷新保留当前页,修改搜索或筛选后回到第一页。分页和筛选都不影响“开始全部”的范围。
一致表示已覆盖的必查项未发现差异;需关注表示有文字或属性变化需要人工判断;异常表示已证明位号、物理脚号、连接或声明目标等不符合;无法校验表示证据不足。没有固定换料清单时始终显示“未核对换料规则”。执行结束不等于工程一致。
选择工程,在右侧选择位号查看固定脚号的前后接线图和逐脚事实。红线对应连接变化;纯名称变化以关注提示。图由网表生成,不是原理图截图。原始证据入口会核对摘要;历史版本仅供查看,不改变当前结论。导出报告包含同一份图表、检查范围、输入和尝试摘要,不复制整个工程。
停止采用安全收尾。未派发项保留待校验,已开始项保留停止记录。重启不会自动重跑;缺少进程退出证明的项保留现场并暂停新的原生导出,不按 PID 猜测或终止其他进程。
首版未证明引脚级 Value 读取和确切库内部引脚→焊盘映射,页面明确未覆盖。电气类型按原生码展示,不臆造语义。本网表比较不宣称完成 ERC、PCB 或封装库内部正确性验证。普通操作历史清空和运行日志保留不会删除校验快照与证据。
+4138 -3271
View File
File diff suppressed because it is too large. Load diff
+11 -3
View File
@@ -2,7 +2,15 @@
"name": "dxdesigner-dsh-runtime",
"private": true,
"type": "module",
"scripts": {"doctor": "node start.mjs --doctor", "start": "node start.mjs"},
"engines": {"node": ">=24.9.0"},
"dependencies": {"@deepseek-ai/dsh": "0.2.1-rc.5", "fflate": "0.8.3"}
"scripts": {
"doctor": "node start.mjs --doctor",
"start": "node start.mjs"
},
"engines": {
"node": ">=24.9.0"
},
"dependencies": {
"@deepseek-ai/dsh": "0.2.2-rc.5",
"fflate": "0.8.3"
}
}
+1 -1
View File
@@ -12,7 +12,7 @@ export const FILE_TOOLS=['read','read_image','write','edit','glob','grep','worki
const root = path.dirname(fileURLToPath(import.meta.url));
const require = createRequire(import.meta.url);
export const VERSION = '0.2.1-rc.5';
export const VERSION = require('./package.json').dependencies['@deepseek-ai/dsh'];
export const DISABLED = [
'desktop-product-telemetry','product-analytics','session-telemetry-otel',
];
@@ -249,6 +249,7 @@ Function QPNativeCollectMode(ByRef SelectedUids, ByVal Token, ByVal Project, ByV
QPNativeRequireContext Project, Sheet, Guid
QPInvalidatePinIndex
Set Components = QP_App.ActiveView.Query(VDM_COMP, VD_ALL)
QPBindSheetReferences Components
Set Seen = CreateObject("Scripting.Dictionary")
Set Found = CreateObject("Scripting.Dictionary")
Text = "NR1" & vbTab & Token & vbTab & QPEncode(Project) & vbTab & QPEncode(Sheet) & vbCrLf
@@ -306,6 +307,13 @@ Function QPBuildNativeReadScript(ByVal Source, ByRef SelectedUids, ByVal Token,
For Each Uid In SelectedUids.Keys
Body = Body & "QP_NR_Selected.Add " & QPNativeExpression(Uid) & ",True" & vbCrLf
Next
If IsObject(QP_ReferenceAliases) Then
Body=Body & "Set QP_ReferenceAliases=CreateObject(""Scripting.Dictionary"")" & vbCrLf
For Each Uid In QP_ReferenceAliases.Keys
Body=Body & "QP_ReferenceAliases.Add " & QPNativeExpression(Uid) & "," & _
QPNativeExpression(QP_ReferenceAliases(Uid)) & vbCrLf
Next
End If
Body = Body & "On Error Resume Next" & vbCrLf & _
"Set QP_App=GetObject(,""Viewdraw.Application"")" & vbCrLf & _
"If Err.Number=0 Then QP_NR_Text=QPNativeCollectMode(QP_NR_Selected," & _
@@ -315,7 +323,7 @@ Function QPBuildNativeReadScript(ByVal Source, ByRef SelectedUids, ByVal Token,
"If QP_NR_Code<>0 Then QP_NR_Text=""ERROR"" & vbTab & " & QPNativeExpression(Token) & _
" & vbTab & CStr(QP_NR_Code) & vbTab & QPEncode(QP_NR_Source) & vbTab & QPEncode(QP_NR_Description) & vbCrLf" & vbCrLf & _
"QPWriteUtf8 " & QPNativeExpression(ResultPath) & ",QP_NR_Text" & vbCrLf & "On Error GoTo 0" & vbCrLf
Names = Split("QPNativeCollectMode QPNativeRequireContext QPNativeReadInvalid QPSnapshotComponent QPUntouchedComponent QPUntouchedFullState QPUntouchedIdentity QPComponentPins QPComponentIdentityKey QPInvalidatePinIndex QPConnectionSignatureFromPins QPAddSortedSignature QPSnapshotAttribute QPReadOptionalAttributeValue QPOptionalAttributeField QPSortSnapshotLines QPLog QPAppendAscii QPEncode QPDecode QPProjectPath QPSheetIdentity QPCanonicalPath QPEnsureProjectAccess QPReadUtf8 QPWriteUtf8", " ")
Names = Split("QPNativeCollectMode QPNativeRequireContext QPNativeReadInvalid QPSnapshotComponent QPUntouchedComponent QPUntouchedFullState QPUntouchedIdentity QPComponentPins QPComponentIdentityKey QPComponentUnitKey QPBindSheetReferences QPInvalidatePinIndex QPConnectionSignatureFromPins QPAddSortedSignature QPSnapshotAttribute QPReadOptionalAttributeValue QPOptionalAttributeField QPSortSnapshotLines QPLog QPAppendAscii QPEncode QPDecode QPProjectPath QPSheetIdentity QPCanonicalPath QPEnsureProjectAccess QPReadUtf8 QPWriteUtf8", " ")
Pattern.Global = False
For Each Name In Names
Pattern.Pattern = "^(Function|Sub) " & Name & "\([^\n]*\n[\s\S]*?^End \1[ \t]*"
File diff suppressed because it is too large. Load diff
+1 -1
View File
@@ -1,5 +1,5 @@
DeepSeek Harness native frontend and runtime
Pinned release: @deepseek-ai/dsh 0.2.1-rc.5
Package: @deepseek-ai/dsh
Source: https://github.com/deepseek-ai/deepseek-harness
MIT License
+16 -1
View File
@@ -152,6 +152,20 @@ def _finish_execution_run(service, root, task_ids, stop, run_id, result, *, base
receipt['reporting_errors'].append({'code': getattr(error, 'code', 'schedule_receipt_unavailable')})
_persist_execution_receipt(service, journal, run_id, receipt, baseline)
raise
# Optional downstream delivery follows the durable replacement receipt.
# Delivery failure must never turn a saved replacement into a repeat request.
try:
verification = getattr(service, 'verification', None)
if verification is not None:
from ..trial_task_center.verification.contracts import digest
delivery = verification.receive_successful_results(
receipt, submission_id=f'run:{run_id}:{digest(receipt)}')
if delivery['rejected']:
receipt['reporting_errors'].append({'code': 'verification_delivery_pending',
'rejected': delivery['rejected']})
except Exception as error:
receipt['reporting_errors'].append({'code': 'verification_delivery_pending',
'error': type(error).__name__})
return receipt
@@ -286,7 +300,8 @@ def _execute_incident_retry(service, root, task_id, run_id, *, expected_item, st
raise TaskCenterError('run_scope', '原队列检查点身份或范围已变化;保留本次结果。')
checkpoint['entries'][task_id].update(state=state, message=message)
if path.parent.name == 'workspace-queues':
checkpoint['entries'][task_id].update(released=not bool(service.pending_batch_resources()), problems_done=True)
from ..trial_task_center.batch_resources import resource_blockers
checkpoint['entries'][task_id].update(released=not bool(resource_blockers(service.pending_batch_resources())), problems_done=True)
if reports:
checkpoint['entries'][task_id]['netlist_verification'] = reports[task_id]
elif reports:
+2 -1
View File
@@ -316,7 +316,8 @@ class IncidentRunner:
remaining = tuple(self.service.pending_batch_resources())
cleanup['remaining_resources'] = _bounded_details(remaining)
cleanup['remaining_resources_observed'] = True
released = not remaining
from ..trial_task_center.batch_resources import resource_blockers
released = not resource_blockers(remaining)
except Exception as error:
cleanup['verification_error'] = scrub({'type': type(error).__name__, 'detail': str(error)[:1000]})
cleanup['remaining_resources'], released = None, None
@@ -12,9 +12,6 @@ from uuid import uuid4
from .snapshot import TaskSnapshot
from ..trial_task_center.path_access import retry_sharing_violation
HARNESS_VERSION = '0.2.1-rc.5'
def integration_root() -> Path:
if getattr(sys, 'frozen', False):
return Path(sys._MEIPASS) / 'dsh-runtime'
+2 -1
View File
@@ -402,7 +402,8 @@ class RunJournal:
blockers.append("preflight_blocked")
except Exception:
blockers.append("preflight_unavailable")
if service.pending_batch_resources():
from ..trial_task_center.batch_resources import resource_blockers
if resource_blockers(service.pending_batch_resources()):
blockers.append("resources_pending")
blockers = list(dict.fromkeys(blockers))
value = {**row, "queue_available": queue is not None, "tasks": tasks, "counters": counters,
+2 -1
View File
@@ -246,7 +246,8 @@ class ScheduleStore:
with self.execution_lease(schedule_id):
assert_task_queue_idle(self.data_root)
with _queue_lease(self.data_root):
if service.pending_batch_resources():
from ..trial_task_center.batch_resources import resource_blockers
if resource_blockers(service.pending_batch_resources()):
raise TaskCenterError('schedule_busy', '后台资源尚未释放,请先在任务中心核验和清理。')
with self._connect() as db:
db.execute('BEGIN IMMEDIATE')
+2 -1
View File
@@ -50,7 +50,8 @@ def preflight(service, task_ids, *, allow_completed=False):
from .impact import _scope
task_ids = _scope(task_ids)
tasks, paths, hashes = [], set(), {}
pending = bool(service.pending_batch_resources())
from ..trial_task_center.batch_resources import resource_blockers
pending = bool(resource_blockers(service.pending_batch_resources()))
for task_id in task_ids:
context = _context(service, task_id)
state = execution_state(context)
+18 -10
View File
@@ -1,6 +1,6 @@
"""Serial, confirmed queue execution with safe between-item pausing."""
from dataclasses import dataclass
from dataclasses import dataclass, replace
import json
from pathlib import Path
import shutil
@@ -121,6 +121,9 @@ def execute_batch(
**({'runtime': runtime} if runtime is not None else {})) as project_session:
while not progress.queue_complete:
if stop_event.is_set():
if project_session.enabled and project_session.worker is not None:
progress = preparer.complete_project_session(task_id, project_session, session, projects)
progress = service._synchronize_quick_run_progress(task_id, progress=progress)
backups.commit_prefetched(progress)
return BatchRunResult(
progress, True, last_result, tuple(item_messages), tuple(backups.unbacked_project_paths)
@@ -133,6 +136,9 @@ def execute_batch(
backups.prepare(current, progress)
service._batch_feedback = (task_id, progress, f'正在处理 {current.name}')
if stop_event.is_set():
if project_session.enabled and project_session.worker is not None:
progress = preparer.complete_project_session(task_id, project_session, session, projects)
progress = service._synchronize_quick_run_progress(task_id, progress=progress)
backups.commit_prefetched(progress)
return BatchRunResult(
progress, True, last_result, tuple(item_messages), tuple(backups.unbacked_project_paths)
@@ -194,10 +200,16 @@ def execute_batch(
item_messages.append(last_result.message)
if last_result.progress is None:
raise TaskCenterError('quick_run_queue_progress', '批量执行器未返回增量进度,队列已停止。')
failed_component = (task.primary_project_id and last_result.state in {BATCH_FAILED_STATE, 'batch_skipped'}
and session.journal_rows.get(metric['job_id'], {}).get('execution_unit') == 'component')
candidate = last_result.progress
if failed_component and project_session.worker is not None:
# Verify the retained prefix before admitting another component.
candidate = preparer.complete_project_session(task_id, project_session, session, projects)
last_result = replace(last_result, progress=candidate)
project_completed = candidate.completed_project_paths != progress.completed_project_paths
synchronize = (
progress.completed_items == 0
(progress.completed_items == 0 and last_result.state != 'pending_save')
or project_completed
or candidate.queue_complete
or last_result.state in {BATCH_FAILED_STATE, BATCH_SAVED_UNVERIFIED_STATE}
@@ -208,7 +220,8 @@ def execute_batch(
persistence['completed_units'] = 1
else:
updated = candidate
if updated.completed_items <= progress.completed_items or updated.total_items != progress.total_items:
if ((updated.completed_items <= progress.completed_items and last_result.state != 'pending_save')
or updated.total_items != progress.total_items):
_write_uncertain_flag(preparer.data_root / 'quick-run/uncertain.flag', 'batch_progress_mismatch')
raise TaskCenterError('quick_run_queue_progress', '执行器返回后队列进度异常,已停止,避免重复执行。')
# Keep every verified step: one project can contain many sheets and rules.
@@ -233,12 +246,7 @@ def execute_batch(
progress = updated
if task.primary_project_id and last_result.state in {BATCH_FAILED_STATE, 'batch_skipped'}:
row = session.journal_rows.get(metric['job_id'], {})
if row.get('execution_unit') == 'component':
# A failed component is terminal; rebuild its session before
# admitting another UID against the last verified baseline.
if project_session.worker is not None:
project_session.worker.close()
project_session.worker = None
if failed_component:
from .quick_run import _run_process
if journal is None:
raise TaskCenterError('quick_run_uncertain', '缺少失败回执及工程健康证明,暂缓剩余位号。')
@@ -266,7 +274,7 @@ def execute_batch(
feedback = '未命中已跳过,继续下一项' if last_result.state == 'no_match' else (
'失败已记录,继续下一项'
if last_result.state == BATCH_FAILED_STATE
else '已保存并校验,继续下一项'
else '替换已暂存,等待工程统一保存回读' if last_result.state == 'pending_save' else '已保存并校验,继续下一项'
)
service._batch_feedback = (task_id, progress, feedback)
return BatchRunResult(
@@ -31,7 +31,7 @@ def write_release_event(root, path, record, phase, *, context=None, reason='batc
'generation': record.get('generation'), 'desktop': record.get('desktop'),
'cad_pid': record.get('cad_pid'), 'cad_guid': record.get('cad_guid'),
'reason': reason, 'result': 'releasing' if phase == 'started' else (
'released' if phase == 'succeeded' else 'blocked'),
'released' if phase == 'succeeded' else 'isolated' if phase == 'isolated' else 'blocked'),
'elapsed_seconds': elapsed, 'record_path': str(path),
'desktop_handle_closed': cleanup.get('desktop_handle_closed'),
'desktop_disappeared': disappeared, 'cad_exit_code': cad.get('cad_exit_code'),
@@ -39,7 +39,8 @@ def write_release_event(root, path, record, phase, *, context=None, reason='batc
'cad_shutdown': cad, 'shutdown_warning': record.get('shutdown_warning'),
'retries': record.get('retries', {}), 'cleanup': cleanup, 'error': str(error)}
title = {'started': '开始释放后台资源', 'succeeded': '后台资源释放成功',
'failed': '后台资源释放失败,资源释放待处理'}[phase]
'failed': '后台资源释放失败,资源释放待处理',
'isolated': '后台写入进程已退出,残留桌面已隔离(未确认释放)'}[phase]
purpose = {'batch_end': '批次结束', 'rebuild': '安全重建', 'manual_retry': '重新清理',
'restart_recheck': '重启后重新检查'}.get(reason, reason)
cad_text = f"CAD PID={details['cad_pid']}" if details['cad_pid'] else (
@@ -56,7 +57,7 @@ def write_release_event(root, path, record, phase, *, context=None, reason='batc
if error:
message += ' · 原因:' + str(error)
message = message.replace('\r', '\\r').replace('\n', '\\n')
level = 'ERROR' if phase == 'failed' else 'INFO'
level = 'ERROR' if phase == 'failed' else 'WARNING' if phase == 'isolated' else 'INFO'
timestamp = datetime.now(timezone.utc).isoformat(timespec='milliseconds')
errors = []
try:
@@ -19,6 +19,13 @@ LIVE_RESOURCES = {}
class BatchResourceCleanupError(TaskCenterError):
def __init__(self, message, *, completed_result=None, primary_error=None, cleanup_error=None):
original, seen = primary_error, set()
while original is not None and id(original) not in seen:
if getattr(original, 'code', None) in {'saved_source_pending', 'saved_source_changed'}:
message = str(original) + ';资源收尾异常:' + message
break
seen.add(id(original))
original = getattr(original, 'primary_error', None)
super().__init__('batch_resources_pending', message)
self.completed_result = completed_result
self.primary_error = primary_error
@@ -51,7 +58,7 @@ def _valid_record(record, path):
and type(record.get('generation')) is int and record['generation'] >= 1
and isinstance(record.get('desktop'), str)
and re.fullmatch('dx-[0-9a-f]{32}', record['desktop']) is not None
and record.get('state') in {'starting', 'ready', 'recycling', 'closing', 'blocked', 'released'}
and record.get('state') in {'starting', 'ready', 'recycling', 'closing', 'blocked', 'released', 'isolated'}
and isinstance(processes, list) and all(isinstance(item, dict)
and type(item.get('pid')) is int and item['pid'] > 0
and 'creation_time' in item and (item['creation_time'] is None
@@ -66,14 +73,17 @@ def _valid_record(record, path):
def pending_resources(root):
pending = []
for path in sorted(internal_path(canonical_path(root) / 'batch-resources').glob('*/session.json')):
directory = internal_path(canonical_path(root) / 'batch-resources')
paths = (*directory.glob('*/session.json'), *directory.glob('*/isolated-generation-*.json'))
for path in sorted(paths):
path = canonical_path(path)
try:
record = json.loads(internal_path(path).read_text(encoding='utf-8'))
if not _valid_record(record, path):
raise ValueError('invalid resource ownership record')
if record.get('state') != 'released' or not _released_evidence(record):
pending.append(dict(record, record_path=str(path)))
pending.append(dict(record, record_path=str(path),
blocking=not (record.get('state') == 'isolated' and _isolation_evidence(record))))
except (OSError, ValueError, TypeError) as error:
pending.append({'state': 'blocked', 'record_path': str(path), 'error': str(error)})
import sys
@@ -109,9 +119,76 @@ def pending_resources(root):
return tuple(pending)
def resource_blockers(records):
"""Only a validated isolated desktop warning may leave the resource gate open."""
return tuple(item for item in records
if not (item.get('state') == 'isolated' and item.get('blocking') is False))
def blocking_resources(root):
return resource_blockers(pending_resources(root))
def writer_identities(record):
identities = []
for item in [*record.get('writer_identities', ()), *record.get('processes', ()),
*([record['cad_process']] if record.get('cad_process') else [])]:
if item not in identities:
identities.append(item)
if record.get('cad_pid') is not None and not any(
item.get('pid') == record['cad_pid'] for item in identities):
raise ValueError('CAD process identity is missing')
if any(type(item.get('pid')) is not int or item['pid'] <= 0
or not isinstance(item.get('creation_time'), str) or not item['creation_time']
for item in identities):
raise ValueError('Exact writer process identity is missing')
return identities
def isolation_proof(record):
"""Certify handle closure and exact writer exit, never a desktop disappearance."""
cleanup = record.get('cleanup') or {}
if cleanup.get('desktop_lease_pending') is True:
raise ValueError('Managed desktop lease is still held')
if cleanup.get('desktop_lease'):
from .desktop_slot import returned_lease_intact
if not returned_lease_intact(cleanup['desktop_lease'], record['desktop']):
raise ValueError('Managed desktop return proof changed')
if (cleanup.get('desktop_handle_closed') is not True
or cleanup.get('owned_cleanup_complete') is not True):
raise ValueError('Owned resource cleanup is not proven')
identities = writer_identities(record)
if not all(_process_gone(item) for item in identities):
raise ValueError('Owned writer process is still active')
return {'session_id': record['session_id'], 'generation': record['generation'],
'desktop': record['desktop'], 'desktop_handle_closed': True, 'desktop_released': False,
'processes_exited': True, 'processes': identities, 'observed_at': time.time()}
def _isolation_evidence(record):
try:
proof = record.get('isolation_proof', {})
current = isolation_proof(record)
return (isinstance(proof, dict) and all(proof.get(key) == current[key] for key in
('session_id', 'generation', 'desktop', 'desktop_handle_closed', 'desktop_released',
'processes_exited', 'processes')))
except Exception:
return False
def _released_evidence(record):
"""A state label alone must never reopen the physical resource gate."""
proof = record.get('release_proof', {})
cleanup = record.get('cleanup') or {}
if (proof.get('generation') == record['generation'] and proof.get('desktop_not_acquired') is True
and cleanup.get('desktop_not_acquired') is True and cleanup.get('desktop_handle_closed') is True
and cleanup.get('owned_cleanup_complete') is True and not cleanup.get('errors')
and record.get('cad_pid') is None and not writer_identities(record)):
return True
if cleanup.get('desktop_lease'):
from .desktop_slot import returned_lease_intact
if not returned_lease_intact(cleanup['desktop_lease'], record['desktop']):
return False
if (isinstance(proof, dict) and proof.get('generation') == record['generation']
and proof.get('desktop_released') is True and proof.get('processes_exited') is True):
return True
@@ -126,7 +203,7 @@ def _released_evidence(record):
def guard_pending_resources(root):
if pending_resources(root):
if blocking_resources(root):
raise BatchResourceCleanupError('上一批资源尚未确认释放;请先重试释放资源,再开始新批次。')
@@ -216,7 +293,7 @@ def cleanup_pending_resources(root, *, logging_context=None, retry_failed=False)
if not record.get('session_id'):
continue # Corrupt evidence cannot authorize resource actions.
log('started')
identities = list(record.get('processes', ()))
identities = writer_identities(record)
cad_identity = record.get('cad_process')
if record.get('cad_pid') is not None:
if (not isinstance(cad_identity, dict) or cad_identity.get('pid') != record['cad_pid']
@@ -229,12 +306,36 @@ def cleanup_pending_resources(root, *, logging_context=None, retry_failed=False)
log('failed', '记录中的进程仍未确认退出')
continue
desktop = record.get('desktop')
if desktop:
_Win32Api().confirm_desktop_released(desktop)
if (record.get('cleanup') or {}).get('desktop_lease'):
# A return belongs to this past lease, even while the same name
# is now serving another batch. Never open or stop its new owner.
proof = isolation_proof(record)
from .desktop_slot import managed_desktop_disappeared
if not managed_desktop_disappeared(record['cleanup']['desktop_lease']):
record.pop('record_path', None)
record.update(state='isolated', blocking=False, isolation_proof=proof)
write_record(path, record)
log('isolated')
continue
elif desktop:
try:
_Win32Api().confirm_desktop_released(desktop)
except Exception as error:
# A residual desktop name is only a warning after owned
# handle closure and independently revalidated writer exit.
proof = isolation_proof(record)
record.pop('record_path', None)
record.update(state='isolated', blocking=False, isolation_proof=proof,
isolation_warning=str(error))
write_record(path, record)
log('isolated', str(error))
continue
# After restart only confirm disappearance. Never attach to COM,
# close a project, or terminate a PID whose handles we no longer own.
record.pop('record_path', None)
record = dict(record, state='released', reconciled=True, released_at=time.time(),
record = dict(record, state='released', blocking=False, reconciled=True, released_at=time.time(),
release_results={'mentor_released': True, 'desktop_released': True},
release_state={'mentor': 'released', 'desktop': 'released'}, wait_reason='',
release_proof={'generation': record['generation'], 'desktop_released': True,
'processes_exited': True, 'processes': identities, 'method': 'restart_observation'})
write_record(path, record)
@@ -11,7 +11,8 @@ from threading import Lock
from uuid import UUID, uuid4
from .batch_resources import (BatchResourceCleanupError, LIVE_RESOURCES, cleanup_pending_resources,
guard_pending_resources, pending_resources, process_identity, project_checkpoint_released, write_record)
guard_pending_resources, pending_resources, process_identity, project_checkpoint_released, write_record,
isolation_proof)
from .errors import TaskCenterError
from .path_access import canonical_path, internal_path, legacy_path
from .isolated_desktop import PrivateDesktop, ProcessNotStartedError
@@ -192,7 +193,9 @@ class BatchCadRuntime:
def _save(self, **values):
record = dict(self.record, **values)
write_record(self.path, record)
# Prelaunch retries can change runtime state before it owns resources.
if record['generation']:
write_record(self.path, record)
self.record = record
def _timing(self, phase, started, **details):
@@ -202,21 +205,39 @@ class BatchCadRuntime:
def _ensure_desktop(self, abort_event=None):
if self.record['state'] == 'blocked':
raise BatchResourceCleanupError('当前批次资源已阻断,不能启动新的工作进程。')
if self.record['state'] == 'isolated':
if self.desktop is not None:
raise BatchResourceCleanupError('隔离桌面已停止使用,请为后续工程创建新的运行会话。')
write_record(self.path.parent / f'isolated-generation-{self.generation}.json', self.record)
if self.desktop is None:
check_cancelled(self.stop_event if abort_event is None else abort_event)
self.generation += 1
generation = self.generation + 1
name = 'dx-' + uuid4().hex
self._save(state='starting', generation=self.generation, desktop=name,
processes=[], cad_pid=None, cad_guid=None, checkpoints={}, native_operations={},
desktop = (self.desktop_factory(name, enabled=True, managed=True)
if self.desktop_factory is PrivateDesktop else self.desktop_factory(name, enabled=True))
# The factory does not acquire a desktop. Commit the starting
# record before assigning cleanup ownership or entering it.
self._save(state='starting', generation=generation, desktop=desktop.name,
processes=[], writer_identities=[], cad_pid=None, cad_guid=None, checkpoints={}, native_operations={},
blocking=True, isolation_proof=None,
stopping_reason='', wait_reason='', primary_error=None,
cad_process=None, cad_token=None, cad_shutdown=None, cad_start_requested=False, cleanup=None,
release_state={'mentor': 'not_started', 'desktop': 'pending'})
self.generation = generation
self.desktop = desktop
LIVE_RESOURCES[str(self.path)] = self
self.desktop = self.desktop_factory(name, enabled=True)
started = time.monotonic()
try:
self.desktop.__enter__()
except Exception:
self._save(state='blocked', error='private desktop startup failed')
if getattr(self.desktop, '_slot', None) is not None and not self.desktop._slot_acquired:
self.desktop.close()
self._save(state='released', blocking=False, cleanup=self.desktop.cleanup_record,
release_proof=dict(generation=self.generation, desktop_not_acquired=True))
self.desktop = None
LIVE_RESOURCES.pop(str(self.path), None)
else:
self._save(state='blocked', error='private desktop startup failed')
raise
self._timing('desktop_start', started)
self._save(state='ready')
@@ -226,6 +247,8 @@ class BatchCadRuntime:
identity = process_identity(process)
if identity not in self.record['processes']:
self.record['processes'].append(identity)
if identity not in self.record.setdefault('writer_identities', []):
self.record['writer_identities'].append(identity)
self._save()
def _release_process(self, process, *, desktop=None, generation=None):
@@ -245,6 +268,9 @@ class BatchCadRuntime:
cad_process = getattr(self.cad, 'cad', None)
if cad_process is not None and cad_process not in processes:
processes.append(cad_process)
for process in getattr(self.cad, '_retained_processes', ()):
if process not in processes:
processes.append(process)
if not processes:
cleanup = getattr(self.desktop, 'cleanup_record', None) or {}
# Closing our handle follows owned-process cleanup. An external
@@ -401,14 +427,107 @@ class BatchCadRuntime:
def _checkpoint(self, root, project, attempt_id):
self.cad.checkpoint(root / ('cad-closed-' + attempt_id + '.json'))
key = str(root).casefold()
self.record['checkpoints'][key] = attempt_id
self._save(state='ready')
write_record(root / 'project-checkpoint.json', {'version': 1, 'resource_record': str(self.path),
checkpoint = {'version': 1, 'resource_record': str(self.path),
'session_id': self.session_id, 'generation': self.generation, 'attempt_id': attempt_id,
'evidence_root': str(root), 'project_path': str(project), 'project_closed': True,
'worker_closed': True, 'cad_pid': self.record['cad_pid'], 'cad_guid': self.record['cad_guid']})
'worker_closed': True, 'cad_pid': self.record['cad_pid'], 'cad_guid': self.record['cad_guid']}
request_path = internal_path(root / 'project-session.request')
if request_path.is_file():
request = request_path.read_text(encoding='utf-8-sig').strip().split('\t')
if (len(request) == 3 and len(request[0]) == 32
and all(character in '0123456789abcdef' for character in request[0])
and canonical_path(request[1]) == project):
marker = internal_path(root / ('project-commit-' + request[0] + '.tsv'))
if marker.is_file():
from .execution_proof import capture_project_commit, bind_project_commit_source
from .quick_run import _decode_vbs_field
rows = [line.split('\t') for line in marker.read_text(encoding='utf-8-sig').splitlines() if line]
if (not rows or len(rows[0]) != 3 or rows[0][0] != request[0]
or rows[0][2] not in {'project_verified', 'project_saved'}
or canonical_path(_decode_vbs_field(rows[0][1])) != project
or any(len(row) != 2 for row in rows[1:])):
raise WorkerMonitorError('native project commit marker is not bound to the closed project')
jobs = [row[0] for row in rows[1:]]
expected_jobs = [record['job_id'] for _, record in self._current_attempts]
expected_jobs = expected_jobs[expected_jobs.index(self.record['active_job']):]
if not jobs or len(set(jobs)) != len(jobs) or jobs != expected_jobs[:len(jobs)]:
raise WorkerMonitorError('native project commit marker does not cover an authorized prefix')
saved_only = rows[0][2] == 'project_saved'
allowed_outcomes = {'pending_save', 'no_match'} if saved_only else {'saved_ok', 'no_match'}
if any(row[1] not in allowed_outcomes for row in rows[1:]):
raise WorkerMonitorError('native project commit marker has an invalid outcome')
proof = capture_project_commit(self.root, root, {'session_token': request[0],
'project_path': str(project).casefold(), 'jobs_json': json.dumps(jobs)})
proof['marker_sha256'] = hashlib.sha256(marker.read_bytes()).hexdigest()
proof['files'].append({'path': str(canonical_path(marker)), 'sha256': proof['marker_sha256']})
readback_names = []
for job, outcome in proof['outcomes'].items():
if saved_only:
from .batch_attempt import read_attempt
path, expected = next((path, expected) for path, expected in self._current_attempts
if expected['job_id'] == job)
actual = read_attempt(path)
if any(actual.get(name) != value for name, value in expected.items() if name != 'state'):
raise WorkerMonitorError('saved project attempt identity changed')
if outcome == 'no_match' and actual['state'] != 'prepared':
raise WorkerMonitorError('saved project no-match outcome has a possible native write')
snapshot = internal_path(root / ('snapshot-' + job + '.tsv'))
report_path = internal_path(str(snapshot) + '.native.json')
if snapshot.exists():
if b'X\tsaved_netlist_v1' not in snapshot.read_bytes().splitlines():
raise WorkerMonitorError('saved project snapshot does not authorize native export validation')
readback_names.append(snapshot.name)
if outcome in {'saved_ok', 'pending_save'} or report_path.exists():
report = json.loads(report_path.read_text(encoding='utf-8'))
native = report.get('batch_attempt', {})
if (report.get('ok') is not True
or outcome in {'saved_ok', 'pending_save'} and report.get('stage') != 'native_replace_applied'
or any(native.get(name) != expected[name] for name in
('session_id', 'generation', 'attempt_id', 'task_id', 'job_id'))
or canonical_path(native.get('project_path', '')) != project):
raise WorkerMonitorError('saved project native write attempt is not bound')
readback_names.append(report_path.name)
if outcome in {'saved_ok', 'pending_save'}:
if not snapshot.is_file() or actual['state'] != 'mutation_possible':
raise WorkerMonitorError('saved project applied write lacks its original mutation attempt')
readback_names.append('writer-expectations-' + job + '.tsv')
proof.setdefault('batch_attempts', []).append({'path': str(path), 'expected': expected})
proof['files'].append({'path': str(path), 'sha256': hashlib.sha256(internal_path(path).read_bytes()).hexdigest()})
else:
readback_names.append('post-state-' + job + '.tsv')
if not saved_only and outcome == 'saved_ok':
readback_names.extend(('snapshot-' + job + '.tsv', 'snapshot-' + job + '.tsv.native.json',
'value-readback-' + job + '.tsv'))
proof['readback_files'] = {name: hashlib.sha256(internal_path(root / name).read_bytes()).hexdigest()
for name in readback_names}
proof['native_attempt'] = {'session_id': self.session_id, 'generation': self.generation,
'attempt_id': attempt_id}
if saved_only:
proof.update(marker_state='project_saved', saved_only=True, validation_required='saved_netlist_v1',
native_outcomes=dict(rows[1:]), outcomes=dict(rows[1:]))
# Keep the saved marker and attempt evidence before any file-lock wait.
write_record(root / 'project-save-pending.json', dict(checkpoint, project_commit_pending=proof))
proof = bind_project_commit_source(proof, self.root, root, project,
stop_event=self.stop_event, release_mentor=self._release_saved_source_owner if saved_only else None)
checkpoint['project_commit_source'] = proof
write_record(root / 'project-checkpoint.json', checkpoint)
self.record['checkpoints'][key] = attempt_id
self._save()
self._active_attempts = []
def _release_saved_source_owner(self, error):
"""Only a closed project's read handoff may recycle an idle CAD here."""
try:
self.close(rebuilding=True, reason='saved_source_locked')
except Exception as cleanup:
self.record['primary_error'] = {'type': type(error).__name__, 'code': error.code, 'message': str(error)}
try:
self._save()
except Exception as diagnostic:
error.add_note('资源收尾记录写入失败:' + str(diagnostic))
raise BatchResourceCleanupError(str(cleanup), primary_error=error, cleanup_error=cleanup) from cleanup
self.desktop = self.cad = None
def _certify_unlaunched_worker(self, root, project, command, attempt_id, expected, before, inputs, *, failure=None,
worker_creation_rejected=False):
"""Certify no worker was created, using exact launch and release provenance."""
@@ -514,6 +633,11 @@ class BatchCadRuntime:
cooperative_abort=cooperative_abort, process_factory=start_worker,
**({'owner_loss_path': self.path.parent / 'owner-loss.json'} if self.read_only else {}),
**({'force_control': self.stop_event} if hasattr(self.stop_event, 'force_event') else {}))
if result.returncode == 75 and not self.read_only:
result.prewrite_pause = self._certify_prewrite_pause(
root, project, attempt_id, expected, before, inputs,
getattr(result, 'prewrite_pause', {}), abort_event)
return result
if result.returncode == 74 and not self.read_only:
from .batch_attempt import can_retry_attempt
pause = getattr(result, 'startup_pause', {})
@@ -643,6 +767,92 @@ class BatchCadRuntime:
self.close(rebuilding=True) # Prove disappearance before creating another.
self.desktop = self.cad = None
def _certify_prewrite_pause(self, root, project, attempt_id, expected, before, inputs, pause, abort_event):
from .batch_attempt import can_retry_attempt, read_attempt
from .discovery_cache import project_fingerprint
from .project_session_health import _source_parameters
from .quick_run import _decode_vbs_field
try:
request_path = internal_path(root / 'project-session.request')
request_bytes = request_path.read_bytes()
request = request_bytes.decode('utf-8-sig').strip().split('\t')
original = inputs['project-session.request'].decode('utf-8-sig').strip().split('\t')
if (len(request) != 3 or len(original) != 3 or request[:2] != original[:2]
or pause.get('session_token') != request[0] or len(request[0]) != 32
or pause.get('job_id') != request[2] or canonical_path(request[1]) != project
or canonical_path(pause.get('project_path', '')) != project
or pause.get('worker_tree_exited') is not True
or type(pause.get('sequence')) is not int or pause['sequence'] <= 0
or not ((abort_event is not None and abort_event.is_set())
or (self.stop_event is not None and self.stop_event.is_set()))
or getattr(getattr(self.stop_event, 'force_event', None), 'is_set', lambda: False)()
or internal_path(root / 'command.tsv').read_bytes() != inputs['command.tsv']):
raise ValueError('prewrite pause ownership is not bound')
selected = [(path, record) for path, record in expected if record['job_id'] == request[2]]
if len(selected) != 1 or not can_retry_attempt(*selected[0]):
raise ValueError('current paused job may have mutated')
jobs = [record['job_id'] for _, record in expected]
prefix_jobs = set(jobs[:jobs.index(request[2])])
mutated = set()
for path, record in expected:
actual = read_attempt(path)
if any(actual.get(key) != value for key, value in record.items() if key != 'state'):
raise ValueError('batch attempt identity changed')
if actual['state'] == 'mutation_possible':
mutated.add(record['job_id'])
marker_path = root / ('project-pause-' + request[0] + '.tsv')
marker = internal_path(marker_path).read_text(encoding='utf-8-sig').strip().split('\t')
if (len(marker) != 4 or marker[0] != request[0] or marker[2:] != [request[2], 'prewrite_closed']
or canonical_path(_decode_vbs_field(marker[1])) != project):
raise ValueError('prewrite project closure marker is missing or stale')
manifest_path = root / ('project-commit-' + request[0] + '.tsv')
committed = {}
prefix_marker_state = None
files = [marker_path, *(path for path, _ in expected)]
if internal_path(manifest_path).exists():
rows = [line.split('\t') for line in internal_path(manifest_path).read_text(encoding='utf-8-sig').splitlines()]
if (not rows or len(rows[0]) != 3 or rows[0][0] != request[0]
or canonical_path(_decode_vbs_field(rows[0][1])) != project
or rows[0][2] not in {'project_verified', 'project_saved'}):
raise ValueError('committed prefix manifest is not bound')
prefix_marker_state = rows[0][2]
allowed_outcomes = {'pending_save', 'no_match'} if prefix_marker_state == 'project_saved' else {'saved_ok', 'no_match'}
for row in rows[1:]:
if (len(row) != 2 or row[0] not in prefix_jobs or row[0] in committed
or row[1] not in allowed_outcomes):
raise ValueError('committed prefix manifest contains an unrelated result')
committed[row[0]] = row[1]
files.append(manifest_path)
after = project_fingerprint(project, self.root)
if (after is None or not mutated <= committed.keys()
or not committed and (before is None or before != after)):
raise ValueError('source changes lack a verified committed prefix')
self._checkpoint(root, project, attempt_id)
files.append(root / 'project-checkpoint.json')
current = internal_path(root / 'current-command.tsv')
status = internal_path(root / 'status.tsv')
proof = dict(pause, phase='before_native_dispatch', task_id=selected[0][1]['task_id'],
session_id=self.session_id, generation=self.generation, attempt_id=attempt_id,
resource_record=str(self.path), project_closed=True, native_dispatch_not_started=True,
source_sha256=hashlib.sha256(repr(after).encode()).hexdigest(), committed_prefix=committed,
prefix_marker_state=prefix_marker_state, prefix_validation_required=prefix_marker_state == 'project_saved',
pause_marker_path=str(marker_path),
pause_marker_sha256=hashlib.sha256(internal_path(marker_path).read_bytes()).hexdigest(),
commit_manifest_path=str(manifest_path) if committed else None,
commit_manifest_sha256=hashlib.sha256(internal_path(manifest_path).read_bytes()).hexdigest() if committed else None,
request_sha256=hashlib.sha256(request_bytes).hexdigest(),
status_sha256=hashlib.sha256(status.read_bytes()).hexdigest() if status.exists() else None,
current_command_sha256=hashlib.sha256(current.read_bytes()).hexdigest() if current.exists() else None,
batch_attempts=[{'path': str(path), 'expected': record} for path, record in selected])
proof.update(_source_parameters(project, self.root))
proof_path = root / ('prewrite-pause-' + attempt_id + '.json')
write_record(proof_path, proof)
proof['files'] = [{'path': str(path), 'sha256': hashlib.sha256(internal_path(path).read_bytes()).hexdigest()}
for path in [proof_path, *files]]
return proof
except (OSError, ValueError, TypeError, KeyError, AttributeError) as error:
raise WorkerMonitorError('prewrite pause lacks bound current-job and committed-prefix proof: ' + str(error)) from error
def _retain_uncertain(self, root, project, expected, error):
if self.read_only:
return
@@ -747,7 +957,7 @@ class BatchCadRuntime:
def _close_once(self, *, rebuilding=False, reason=None):
if self.desktop is None and not self.generation:
return # A cache-only batch never acquired resources.
if self.record['state'] == 'released':
if self.record['state'] in {'released', 'isolated'}:
return
reason = reason or ('rebuild' if rebuilding else 'batch_end')
if self._close_failure is not None:
@@ -775,7 +985,7 @@ class BatchCadRuntime:
completed_result=self.result, cleanup_error=self._close_failure)
cleanup = self.desktop.cleanup_record or {}
self.record['cleanup'] = cleanup
if cleanup.get('desktop_confirmation', {}).get('released') is True:
if (cleanup.get('desktop_confirmation') or {}).get('released') is True:
self.record['release_results'] = {'mentor_released': True, 'desktop_released': True}
self.record['release_state'] = {'mentor': 'released', 'desktop': 'released'}
self._release_log('started', reason=reason)
@@ -807,30 +1017,41 @@ class BatchCadRuntime:
raise
self._close_failure = None
self._close_failure_rebuild = False
self._release_log('succeeded', reason=reason, elapsed=time.monotonic() - started)
self._release_log('isolated' if self.record['state'] == 'isolated' else 'succeeded',
reason=reason, elapsed=time.monotonic() - started)
def _close_resources(self, *, rebuilding=False):
from .operation_diagnostics import record_operation
operation_root = self._active_evidence or self.path.parent
started = time.monotonic()
errors = []
shutdown_errors = []
retained_cad = False
phases = {'mentor': 'closing' if self.cad is not None else 'released', 'desktop': 'waiting_for_mentor'}
try:
self._save(state='closing', release_state=phases)
self._save(state='closing', release_state=phases,
wait_reason='mentor_exit' if self.cad is not None else 'desktop_release',
stopping_reason=getattr(self.stop_event, 'stopping_reason', ''),
primary_error=self.record.get('primary_error') or getattr(self.stop_event, 'primary_error', ''))
except Exception as error:
errors.append('resource journal: ' + str(error))
if self.cad is not None:
cad = self.cad
try:
failure = getattr(self, '_cad_close_error', None)
record_operation(operation_root, 'mentor_exit', 'enter')
cad.__exit__(type(failure) if failure is not None else None, failure, None)
record_operation(operation_root, 'mentor_exit', 'return')
self.cad = None
except Exception as error:
record_operation(operation_root, 'mentor_exit', 'error', error=str(error))
if rebuilding:
self.record['shutdown_warning'] = str(error)
# A rebuild must not proceed while the previous CAD owner has
# an unconfirmed shutdown. Keep the warning for diagnostics,
# but retain the failure in the resource gate as well.
errors.append(str(error))
shutdown_errors.append(str(error))
from .read_recovery import process_tree_exited
process = getattr(cad, 'cad', None)
processes = [*getattr(cad, '_retained_processes', ()),
@@ -853,9 +1074,13 @@ class BatchCadRuntime:
phases['mentor'] = 'failed' if retained_cad else 'released'
if self.desktop is not None and not retained_cad:
phases['desktop'] = 'closing'
self.record['wait_reason'] = 'desktop_release'
try:
record_operation(operation_root, 'desktop_release', 'enter')
self.desktop.close()
record_operation(operation_root, 'desktop_release', 'return')
except Exception as error:
record_operation(operation_root, 'desktop_release', 'error', error=str(error))
errors.append(str(error))
self._timing('batch_release', started)
self.record['cleanup'] = getattr(self.desktop, 'cleanup_record', None)
@@ -863,12 +1088,32 @@ class BatchCadRuntime:
self.record['release_results'] = {
'mentor_released': not retained_cad,
'desktop_released': cleanup.get('desktop_handle_closed') is True
and cleanup.get('desktop_confirmation', {}).get('released') is True}
and (cleanup.get('desktop_confirmation') or {}).get('released') is True}
phases['desktop'] = ('waiting_for_mentor' if retained_cad else
'released' if self.record['release_results']['desktop_released'] else 'failed')
self.record['release_state'] = phases
self.record['cleanup_mode'] = getattr(self.stop_event, 'cleanup_mode', None)
if not retained_cad and not self.record['release_results']['desktop_released']:
try:
proof = isolation_proof(self.record)
if not self._other_writers_exited():
raise ValueError('Retained writer ownership is still active')
except Exception:
pass
else:
phases['desktop'] = 'isolated'
self._save(state='isolated', blocking=False, isolation_proof=proof,
isolation_warning='; '.join(errors), release_state=phases, wait_reason='')
LIVE_RESOURCES.pop(str(self.path), None)
if shutdown_errors:
raise BatchResourceCleanupError('; '.join(shutdown_errors), completed_result=self.result)
return
if errors:
if (errors == shutdown_errors and not retained_cad and self.owned_processes_exited()
and self._other_writers_exited() and self.record['release_results']['desktop_released']):
self.record['shutdown_warning'] = '; '.join(shutdown_errors)
self._record_release()
raise BatchResourceCleanupError('; '.join(errors), completed_result=self.result)
self._save(state='blocked', error='; '.join(errors))
raise BatchResourceCleanupError('; '.join(errors), completed_result=self.result)
self._record_release()
@@ -879,5 +1124,57 @@ class BatchCadRuntime:
'cad_pid': self.record['cad_pid'], 'cad_guid': self.record['cad_guid'],
'cleanup': self.record['cleanup'], 'released_at': released_at}
releases = [*self.record.get('generation_releases', ()), release]
self._save(state='released', released_at=released_at, processes=[], generation_releases=releases)
self._save(state='released', blocking=False, released_at=released_at, processes=[], generation_releases=releases,
wait_reason='')
LIVE_RESOURCES.pop(str(self.path), None)
def _other_writers_exited(self):
from .isolated_cad import RETAINED_CAD_SESSIONS
from .read_recovery import process_tree_exited
from .worker_monitor import RETAINED_WORKERS, _worker_tree_exited
return (all(all(process_tree_exited(process) for process in session._owned_processes())
for session in tuple(RETAINED_CAD_SESSIONS.values())
if session.root.is_relative_to(self.root))
and all(_worker_tree_exited(entry['process'], entry['owned'])
for entry in tuple(RETAINED_WORKERS.values()) if entry['root'].is_relative_to(self.root)))
def release_failed_project(self, error, evidence_root):
"""Release proven stopped writers; the failed project's business evidence stays untouched."""
from .stop_control import protect_interruption
protect_interruption(evidence_root, 'project_failure: ' + str(error))
request = getattr(self.stop_event, 'request_failure_cleanup', None)
if request is not None:
request(evidence_root, error)
if self.cad is not None:
self.cad.stop_control = self.stop_event
self._cad_close_error = error
cleanup_warning = None
try:
self.close(reason='project_failure')
except BatchResourceCleanupError as cleanup:
from .batch_resources import blocking_resources
if (self.record['state'] not in {'released', 'isolated'} or blocking_resources(self.root)
or not self.owned_processes_exited() or not self._other_writers_exited()):
raise
cleanup_warning = str(cleanup)
error.shutdown_warning = cleanup_warning
self.record.setdefault('generation_shutdown_warnings', []).append({
'generation': self.generation, 'error': cleanup_warning, 'cad_shutdown': self.record.get('cad_shutdown')})
self._save(shutdown_warning=cleanup_warning)
if ((self.generation and not self.owned_processes_exited()) or not self._other_writers_exited()):
return False
from .batch_resources import blocking_resources
if blocking_resources(self.root):
return False
write_record(canonical_path(evidence_root) / 'project-resource-release.json', {
'version': 1, 'session_id': self.session_id, 'generation': self.generation,
'resource_record': str(self.path), 'writers_exited': True,
'resource_state': self.record['state'], 'desktop_released':
self.record.get('release_results', {}).get('desktop_released') is True,
'business_uncertainty_preserved': True})
self.desktop = self.cad = None
self._active_evidence = None
self._active_attempts = []
self._close_failure = None
self._cad_close_error = None
return True
@@ -305,9 +305,9 @@ def pending_supervisors(root):
def reconcile_supervisors(root):
"""Recheck orphan ownership only; this never launches or replays a job."""
from .batch_resources import _process_gone, pending_resources, write_record
from .batch_resources import _process_gone, blocking_resources, write_record
from .read_recovery import process_tree_exited
physical = pending_resources(root)
physical = blocking_resources(root)
for record in pending_supervisors(root):
owner = (_LIVE_SUPERVISORS.get(canonical_path(record['record_path']))
or _ACTIVE_SUPERVISORS.get(canonical_path(record['record_path'])))
@@ -348,21 +348,26 @@ def _environment():
def _finish_response(root, journal, response, context):
"""A supervisor exit may release its last USER reference. Never repeat work."""
from .batch_resources import cleanup_pending_resources, write_record
from .batch_resources import cleanup_pending_resources, resource_blockers, write_record
from .supervisor_result import validated_outcome, resource_pending_error, application_shutdown_error
result, error, primary = validated_outcome(journal['operation'], response)
pending = cleanup_pending_resources(root, logging_context=context)
related = tuple(item for item in pending if item.get('session_id') == journal['batch_id'] or not item.get('session_id'))
journal['state'] = 'blocked' if related else 'finished'
journal['outcome'] = ('completed_resources_pending' if related and response.get('business_succeeded')
blockers = resource_blockers(related)
warnings = tuple(item for item in related if item not in blockers)
journal['state'] = 'blocked' if blockers else 'finished'
journal['outcome'] = ('completed_resources_pending' if blockers and response.get('business_succeeded')
else response.get('status', 'interrupted'))
journal['resource_recheck'] = {'pending': bool(related), 'checked_at': time.time()}
journal['resource_recheck'] = {'pending': bool(blockers), 'warnings': list(warnings),
'desktop_released': not related, 'owned_writers_exited': not blockers, 'checked_at': time.time()}
write_record(Path(root) / 'batch-resources' / journal['batch_id'] / 'supervisor.json', journal)
if related:
if blockers:
raise resource_pending_error(journal['operation'], result, error, primary)
for failure in (error, primary):
if failure is not None:
failure.resources_released = True
failure.resources_released = not warnings
failure.owned_writers_exited = True
failure.resource_warnings = warnings
resource_path = internal_path(Path(root) / 'batch-resources' / journal['batch_id'] / 'session.json')
def preserve_shutdown_failure(detail):
try:
@@ -373,7 +378,9 @@ def _finish_response(root, journal, response, context):
journal['shutdown_record_error'] = str(record_error)
def shutdown_failure():
failure = application_shutdown_error(result, error, primary)
failure.resources_released = True
failure.resources_released = not warnings
failure.owned_writers_exited = True
failure.resource_warnings = warnings
return failure
try:
resource = json.loads(resource_path.read_text(encoding='utf-8'))
@@ -558,6 +565,7 @@ def run_supervised(service, operation, arguments, *, stop_event=None, on_progres
on_phase(*payload)
elif value['type'] == 'state':
state = decode(value['payload'])
service._supervisor_state = state
business_watch.observe('state', state, time.monotonic())
service._task_queue_feedback = getattr(service, '_workspace_queue_context', None) or state['queue']
service._batch_feedback = state['batch']
@@ -578,6 +586,7 @@ def run_supervised(service, operation, arguments, *, stop_event=None, on_progres
service._task_queue_feedback = None
service._batch_feedback = None
service._supervisor_waiting = False
service._supervisor_state = None
service._supervisor_business_stalled = False
service._supervisor_dialog_state = None
try:
@@ -616,10 +625,10 @@ def run_supervised(service, operation, arguments, *, stop_event=None, on_progres
exit_code=getattr(process, 'returncode', None),
stdout_chars=len(stdout_tail), stderr_chars=len(stderr_tail))
if force_accepted:
from .batch_resources import cleanup_pending_resources
from .batch_resources import cleanup_pending_resources, resource_blockers
try:
pending = cleanup_pending_resources(root, logging_context=service._logging)
if pending:
if resource_blockers(pending):
ownership_cleanup_error = TaskCenterError('batch_resources_pending', '强制结束后的资源仍待清理。')
except Exception as error:
ownership_cleanup_error = error
@@ -628,7 +637,8 @@ def run_supervised(service, operation, arguments, *, stop_event=None, on_progres
failure = TaskCenterError('mentor_release_required' if automatic else 'user_forced_stop',
'执行失败,已自动收尾本批后台进程;已有结果保留,当前结果待核验。' if automatic else
'已按确认强制结束;已保存的执行证据保留,当前结果待核验。请先核验恢复,不要重复替换。')
failure.resources_released = ownership_cleanup_error is None
failure.resources_released = ownership_cleanup_error is None and not pending
failure.owned_writers_exited = ownership_cleanup_error is None
failure.primary_error = transport_error
if ownership_cleanup_error is not None:
journal.update(force_state='confirmation_failed', force_cleanup_error=str(ownership_cleanup_error))
@@ -688,7 +698,7 @@ def run_supervised(service, operation, arguments, *, stop_event=None, on_progres
raise failure from protection_error
# Recheck physical resources even when final business results are
# missing; this never authorizes repeating the interrupted job.
from .batch_resources import cleanup_pending_resources
from .batch_resources import cleanup_pending_resources, resource_blockers
outstanding = cleanup_pending_resources(root, logging_context=service._logging)
failure = cause if isinstance(cause, TaskCenterError) else TaskCenterError(
'supervisor_interrupted', '批次监督进程未留下可信结果;保留保护记录,不自动重试。' +
@@ -697,6 +707,8 @@ def run_supervised(service, operation, arguments, *, stop_event=None, on_progres
from .read_recovery import process_tree_exited
failure.resources_released = (not outstanding and ownership_cleanup_error is None
and (process is None or process_tree_exited(process)))
failure.owned_writers_exited = (not resource_blockers(outstanding) and ownership_cleanup_error is None
and (process is None or process_tree_exited(process)))
raise failure from (transport_error or error)
if transport_error is not None:
if response['payload']['business_succeeded']:
@@ -705,9 +717,13 @@ def run_supervised(service, operation, arguments, *, stop_event=None, on_progres
else:
_mark_interrupted(root, journal, transport_error)
failure = resource_pending_error(operation, decoded_result, transport_error, decoded_primary)
from .batch_resources import pending_resources
from .batch_resources import pending_resources, resource_blockers
from .read_recovery import process_tree_exited
failure.resources_released = (ownership_cleanup_error is None and not pending_resources(root)
pending = pending_resources(root)
failure.resources_released = (ownership_cleanup_error is None and not pending
and process is not None and process_tree_exited(process))
failure.owned_writers_exited = (ownership_cleanup_error is None and not resource_blockers(pending)
and process is not None and process_tree_exited(process))
failure.resource_warnings = tuple(row for row in pending if row not in resource_blockers(pending))
raise failure
return _finish_response(root, journal, response['payload'], service._logging)
@@ -14,6 +14,14 @@ from uuid import UUID
from .path_access import internal_path, canonical_path
from .supervisor_protocol import VERSION, OPERATIONS, valid_journal, encode, decode, encode_error
def _persist_result(directory, envelope):
from .batch_resources import write_record
from .operation_diagnostics import operation_span
with operation_span(directory, 'result_persistence', item_id=envelope['attempt_id']):
write_record(directory / 'result.json', envelope)
def _output_stream():
if sys.stdout is not None:
return sys.stdout, False
@@ -85,7 +93,7 @@ def consume_manual_dialog_actions(directory, runtime, batch_id, attempt_id):
write_record(claimed.with_suffix('.result'), result)
def _wait_for_owned_writes(runtime, control):
def _wait_for_owned_writes(runtime, control) -> Exception | None:
"""Process exit would close kill-on-close Jobs, so it is also a write boundary."""
if runtime.read_only:
return
@@ -103,15 +111,21 @@ def _wait_for_owned_writes(runtime, control):
return False
return all(_worker_tree_exited(entry['process'], entry['owned'])
for entry in tuple(RETAINED_WORKERS.values()) if entry['root'].is_relative_to(runtime.root))
if not exited():
try:
wait_for_resolution(control, runtime.path.parent,
'supervisor exit still has owned write processes', resolved=exited, release_on_failure=True)
except MentorReleaseRequired:
cleanup_retained_workers(runtime.root, force=True)
cleanup_retained_workers(runtime.root)
if runtime.desktop is not None or runtime.cad is not None:
runtime.close(reason='resource_recheck')
try:
if not exited():
try:
wait_for_resolution(control, runtime.path.parent,
'supervisor exit still has owned write processes', resolved=exited, release_on_failure=True)
except MentorReleaseRequired:
cleanup_retained_workers(runtime.root, force=True)
cleanup_retained_workers(runtime.root)
if runtime.desktop is not None or runtime.cad is not None:
runtime.close(reason='resource_recheck')
except Exception as error:
# Desktop references may remain after writers exit; publish that failure.
if not exited():
raise
return error
def run(request_path):
@@ -154,7 +168,7 @@ def run(request_path):
'generation': max(1, runtime.generation), 'sequence': sequence,
'type': kind, 'payload': payload}
if persist:
write_record(directory / 'result.json', envelope)
_persist_result(directory, envelope)
try:
output.write(json.dumps(envelope, ensure_ascii=True, allow_nan=False) + '\n')
output.flush()
@@ -175,9 +189,13 @@ def run(request_path):
emit('heartbeat')
feedback = getattr(service, '_task_queue_feedback', None)
emit('state', encode({'phase': runtime.record['state'], 'queue': feedback,
'release_state': runtime.record.get('release_state'),
'batch': service.batch_feedback(),
'active_project': runtime.record.get('active_project'),
'business_progress': runtime.business_progress(),
'stopping_reason': runtime.record.get('stopping_reason') or getattr(runtime.stop_event, 'stopping_reason', ''),
'wait_reason': runtime.record.get('wait_reason') or getattr(runtime.stop_event, 'wait_reason', ''),
'primary_error': runtime.record.get('primary_error') or getattr(runtime.stop_event, 'primary_error', ''),
'dialog_supervision': runtime.dialog_state(),
'dialog_binding': {'batch_id': batch_id, 'attempt_id': attempt_id,
'generation': runtime.generation, 'session_token': getattr(runtime.cad, 'token', None)},
@@ -249,7 +267,15 @@ def run(request_path):
context.report_exception('batch_supervisor', error)
response.update(status='error', error=encode_error(error))
finally:
_wait_for_owned_writes(runtime, stop)
cleanup_error = _wait_for_owned_writes(runtime, stop)
if cleanup_error is not None:
context.report_exception('batch_supervisor_resource_recheck', cleanup_error)
response['status'] = 'error'
response.setdefault('error', encode_error(cleanup_error))
if runtime.record.get('state') == 'isolated':
response['resource_warning'] = {'state': 'isolated', 'blocking': False,
'desktop': runtime.record['desktop'], 'desktop_released': False,
'owned_writers_exited': True}
evidence.try_append('worker_closing', status=response.get('status'), business_succeeded=response.get('business_succeeded'))
finished.set()
thread.join(3)
@@ -40,8 +40,9 @@ def retained_bom_rows(pending, existing_rows):
candidates = tuple(index for identity in dict.fromkeys(((record.old.casefold(), ref.casefold()),
(record.new.casefold(), ref.casefold()))) for index in by_identity.get(identity, ())
if (not record.schematic or existing_rows[index].target.schematic_name.casefold() == record.schematic.casefold())
and (not record.sheet or existing_rows[index].target.sheet_number.casefold() == record.sheet.casefold())
and (not record.uid or existing_rows[index].target.uid == record.uid))
and (not record.sheet or existing_rows[index].target.sheet_number.casefold() == record.sheet.casefold()))
if len(candidates) > 1 and record.uid:
candidates = tuple(index for index in candidates if existing_rows[index].target.uid == record.uid)
if len(candidates) > 1:
raise TaskCenterError('bom_scope_ambiguous', f'位号 {ref} 无法唯一匹配已保存位号;请填写原理图、图页或 UID:'
f'{request.source_file} 第 {request.source_row} 行')
@@ -25,7 +25,7 @@ _HEADER_HELP = (
'位号,必填。一行可填 R1,R2,R3,支持逗号、分号、空格或顿号分隔。',
'原理图名称,可选。位号重复时用于精确匹配。',
'图页,可选。位号跨页重复时应填写图页或 UID。',
'器件 UID,可选;填写时必须与采集结果一致。',
'器件 UID,可选。工程、图页和位号已唯一匹配时忽略;仅用于区分仍有多个候选的位号。',
'是否替换:TRUE/FALSE 或 是/否;留空默认替换。未列出的位号保留。',
'自定义 Value,可选;留空沿用工具原有 Value 策略。',
'同步 NC:TRUE/FALSE 或 是/否;留空默认开启。',
@@ -209,8 +209,9 @@ class BomMatcher:
for key, target in self.by_identity.get(identity, ())
if (not record.project_path or self.identities.project(record.project_path) == key[0])
and (not record.schematic or target.schematic_name.casefold() == record.schematic.casefold())
and (not record.sheet or target.sheet_number.casefold() == record.sheet.casefold())
and (not record.uid or target.uid == record.uid)]
and (not record.sheet or target.sheet_number.casefold() == record.sheet.casefold())]
if len(candidates) > 1 and record.uid:
candidates = [(key, target) for key, target in candidates if target.uid == record.uid]
if len(candidates) != 1:
raise TaskCenterError('bom_import', f'位号 {refdes} 无法唯一匹配当前采集清单')
key, target = candidates[0]
@@ -156,7 +156,10 @@ def _catalog_from_evidence(evidence, library, part, partition, fingerprint, path
def _require_cleanup(cleanup):
def pending(message):
raise TaskCenterError('batch_resources_pending', message)
if not isinstance(cleanup, dict) or cleanup.get('errors') or not cleanup.get('desktop_handle_closed') or not cleanup.get('desktop_confirmation', {}).get('released'):
from .desktop_slot import returned_lease_intact
returned = isinstance(cleanup, dict) and returned_lease_intact(cleanup.get('desktop_lease', {}), cleanup.get('desktop'))
if (not isinstance(cleanup, dict) or cleanup.get('errors') or not cleanup.get('desktop_handle_closed')
or not ((cleanup.get('desktop_confirmation') or {}).get('released') or returned)):
pending('catalog private desktop cleanup was not proven')
if not cleanup.get('processes'):
pending('catalog owned process cleanup is missing')
@@ -419,7 +422,7 @@ def _run_owned_reader(clone, part, partition, root):
from .isolated_desktop import PrivateDesktop
from .legacy_paths import _AliasPool, _fits, _short_path
exe = _library_manager_executable()
desktop = PrivateDesktop('dx-cell-' + uuid.uuid4().hex, enabled=True)
desktop = PrivateDesktop('dx-cell-' + uuid.uuid4().hex, enabled=True, managed=True)
aliases = _AliasPool()
report_path = root / 'worker-result.json'
clone_fingerprint = _content_fingerprint(_library_manifest(clone))
@@ -0,0 +1,230 @@
"""One desktop per user/logon, with independent durable leases and named Jobs."""
import hashlib
import json
import os
from pathlib import Path
import re
from threading import Event, Thread
from uuid import uuid4
from .batch_resources import write_record
from .errors import TaskCenterError
from .path_access import canonical_path, internal_path
def _fail(message):
raise TaskCenterError('desktop_slot_busy', message)
def _context():
import win32api
import win32con
import win32security
import win32service
token = win32security.OpenProcessToken(win32api.GetCurrentProcess(), win32con.TOKEN_QUERY)
try:
sid = win32security.GetTokenInformation(token, win32security.TokenUser)[0]
groups = win32security.GetTokenInformation(token, win32security.TokenGroups)
logon = [value for value, flags in groups if flags & 0xC0000000 == 0xC0000000]
if len(logon) != 1:
_fail('无法确认当前 Windows 登录会话,未创建桌面。')
return dict(sid=win32security.ConvertSidToStringSid(sid),
logon=win32security.ConvertSidToStringSid(logon[0]),
station=win32service.GetUserObjectInformation(win32service.GetProcessWindowStation(), 2))
finally:
token.Close()
class _Windows:
def lock(self, name):
import win32event
mutex = win32event.CreateMutex(None, False, name)
# A mutex is recursive on one thread; separate desktop owners are not.
if name in _held:
mutex.Close()
_fail('当前进程已有桌面租用,等待本批收尾后再领取。')
ready, release = Event(), Event()
result = {}
def own_mutex():
try:
result['acquired'] = win32event.WaitForSingleObject(mutex, 0) in (0, 0x80)
except Exception as error:
result['error'] = error
finally:
ready.set()
if result.get('acquired'):
release.wait()
try: win32event.ReleaseMutex(mutex)
except Exception as error: result['error'] = error
# Runtime setup and worker-monitor cleanup occur on different threads;
# keep Windows mutex ownership on one short-lived dedicated thread.
thread = Thread(target=own_mutex, name='desktop-slot-mutex', daemon=True)
thread.start(); ready.wait()
if not result.get('acquired'):
thread.join(); mutex.Close()
if 'error' in result: raise result['error']
_fail('桌面正在由另一批任务使用,请等待其收尾。')
_held.add(name)
return mutex, name, release, thread, result
def unlock(self, value):
handle, name, release, thread, result = value
release.set(); thread.join()
try:
if 'error' in result:
raise result['error']
finally:
try:
handle.Close()
finally:
_held.discard(name)
def desktop_exists(self, name):
import win32service
return name.casefold() in {s.casefold() for s in win32service.GetProcessWindowStation().EnumDesktops()}
def process_gone(self, identity):
from .batch_resources import _process_gone
return _process_gone(identity)
def job_empty(self, name):
import win32job
try:
handle = win32job.OpenJobObject(4, False, name) # JOB_OBJECT_QUERY
except Exception as error:
if getattr(error, 'winerror', error.args[0] if error.args else None) == 2:
return True # No handle remains; KILL_ON_JOB_CLOSE has been applied.
raise
try:
return win32job.QueryInformationJobObject(handle, win32job.JobObjectBasicAccountingInformation)['ActiveProcesses'] == 0
finally:
handle.Close()
def current_process(self):
import win32api
import win32process
return dict(pid=os.getpid(), creation_time=str(win32process.GetProcessTimes(win32api.GetCurrentProcess())['CreationTime']))
_held = set()
def returned_lease_intact(receipt, name):
"""Read an immutable *past* return; never query or close a newer lease."""
try:
data = internal_path(receipt['path']).read_bytes()
record = json.loads(data)
return (receipt['returned'] is True and receipt['name'] == name
and hashlib.sha256(data).hexdigest() == receipt['sha256']
and record['lease_id'] == receipt['lease_id'] and record['scope'] == receipt['scope']
and record['name'] == name and record['state'] == 'idle' and record['writers_exited'] is True)
except (OSError, ValueError, KeyError, TypeError):
return False
def managed_desktop_disappeared(receipt):
"""Observe under the same mutex; an active newer lease is left untouched."""
backend = _Windows()
try:
mutex = backend.lock('Local\\DxPartReplace-Desktop-' + receipt['scope'])
except TaskCenterError:
return False
try:
return not backend.desktop_exists(receipt['name'])
finally:
backend.unlock(mutex)
class DesktopSlot:
def __init__(self, *, root=None, context=None, backend=None):
self.context = _context() if context is None else context
digest = hashlib.sha256(json.dumps(self.context, sort_keys=True).encode()).hexdigest()[:32]
self.name = 'dx-' + digest
self.scope = digest
self.backend = _Windows() if backend is None else backend
base = Path(root) if root is not None else Path(os.environ['LOCALAPPDATA']) / 'DxPartReplace/desktop-slots'
internal_path(base).mkdir(parents=True, exist_ok=True)
base = canonical_path(base)
self.path = base / digest / 'slot.json'
self.lease_id = uuid4().hex
self.return_path = self.path.parent / 'leases' / (self.lease_id + '.json')
self.handle = None
self.receipt = None
self.record = None
def _save(self, record):
write_record(self.path, record)
self.record = record
def _validate(self, record):
if (record.get('version') != 1 or record.get('context') != self.context
or record.get('name') != self.name or record.get('scope') != self.scope
or not re.fullmatch('[0-9a-f]{32}', record.get('lease_id', ''))
or record.get('state') not in {'leased', 'idle'} or not isinstance(record.get('launches'), list)):
_fail('桌面租用记录不完整,未打开桌面。')
identities = [record['owner'], *(r['process'] for r in record['launches'] if r.get('process'))]
if any(type(item.get('pid')) is not int or not isinstance(item.get('creation_time'), str)
or not item['creation_time'] for item in identities):
_fail('桌面原进程身份不完整,未打开桌面。')
for launch in record['launches']:
recoverable = launch.get('state') in {'started', 'closed'} or (
launch.get('state') == 'launching' and launch.get('atomic_job') is True)
if (not recoverable
or not re.fullmatch(r'Local\\DxPartReplace-Job-[0-9a-f]{32}', launch.get('job', ''))
or not self.backend.job_empty(launch['job'])
or launch.get('process') and not self.backend.process_gone(launch['process'])):
_fail('前批进程或启动尝试尚未确认退出,保留原桌面租用。')
def acquire(self):
if self.handle is not None or self.receipt is not None:
_fail('该租用已领取或归还,不能重复派发。')
self.handle = self.backend.lock('Local\\DxPartReplace-Desktop-' + self.scope)
try:
if internal_path(self.path).exists():
previous = json.loads(internal_path(self.path).read_text(encoding='utf-8'))
self._validate(previous)
if previous['state'] == 'leased' and not self.backend.process_gone(previous['owner']):
_fail('前批桌面持有者尚未退出,保留原租用。')
elif self.backend.desktop_exists(self.name):
_fail('同名桌面缺少归属记录,未收养现有桌面。')
self._save(dict(version=1, context=self.context, name=self.name, scope=self.scope,
lease_id=self.lease_id, owner=self.backend.current_process(), state='leased', launches=[]))
except Exception as error:
handle, self.handle = self.handle, None
self.backend.unlock(handle)
if isinstance(error, TaskCenterError): raise
raise TaskCenterError('desktop_slot_busy', '桌面租用记录无法核对,未创建新桌面。') from error
return self
def prepare_launch(self, *, atomic_job=False):
if self.handle is None or self.receipt is not None:
_fail('桌面租用已结束,禁止派发。')
job = 'Local\\DxPartReplace-Job-' + uuid4().hex
record = dict(self.record, launches=[*self.record['launches'],
dict(job=job, state='launching', process=None, atomic_job=atomic_job)])
self._save(record)
return job
def launched(self, job, process):
launches = [dict(item, state='started', process=process) if item['job'] == job else item
for item in self.record['launches']]
self._save(dict(self.record, launches=launches))
def launch_closed(self, job):
launches = [dict(item, state='closed') if item['job'] == job else item for item in self.record['launches']]
self._save(dict(self.record, launches=launches))
def release(self, *, desktop_disappeared):
if self.receipt is not None: return self.receipt
if self.handle is None: _fail('桌面租用未领取。')
self._validate(self.record)
record = dict(self.record, state='idle', writers_exited=True, desktop_disappeared=desktop_disappeared)
write_record(self.return_path, record)
self._save(record)
receipt = dict(returned=True, name=self.name, scope=self.scope, lease_id=self.lease_id,
desktop_disappeared=desktop_disappeared, path=str(self.return_path),
sha256=hashlib.sha256(internal_path(self.return_path).read_bytes()).hexdigest())
handle, self.handle = self.handle, None
self.receipt = receipt
self.backend.unlock(handle)
return receipt
@@ -9,16 +9,20 @@ import stat
import zipfile
from .path_access import canonical_path, internal_path
from .operation_diagnostics import summarize_operations
MAX_FILE_BYTES = 4 * 1024 * 1024
MAX_BUNDLE_BYTES = 32 * 1024 * 1024
MAX_FILES = 512
_BATCH_NAMES = {'session.json', 'supervisor.json', 'request.json', 'result.json',
'business-result.json', 'supervisor.log', 'resource-release.log', 'cancel.json',
'process.json', 'lifecycle.jsonl', 'owner-loss.json', 'claim.json', 'force-request.json'}
'process.json', 'lifecycle.jsonl', 'owner-loss.json', 'claim.json', 'force-request.json',
'operation-events.jsonl'}
_QUICK_NAMES = {'private-desktop.json', 'checkpoint.json', 'status.json',
'uncertain.flag', 'resolved-uncertain.flag', 'protection.json', 'cleanup.json',
'project-session.json', 'project-checkpoint.json', 'project-read-release.json', 'status.tsv'}
'project-session.json', 'project-checkpoint.json', 'project-read-release.json', 'status.tsv',
'worker-progress.json', 'quick-part-replace.log', 'native-inventory.json', 'operation-events.jsonl',
'recovery-commit.json', 'retry-preparation.json'}
_SECRET_KEY = re.compile(r'(?:password|passwd|(?:client[_-]?)?secret|credentials?|authorization|api[_-]?key|access[_-]?token|refresh[_-]?token|token)', re.I)
_USER_KEY = re.compile(r'(?:user(?:[_-]?name)?|login[_-]?name)', re.I)
_SECRET_TEXT = re.compile(r'''(?ix)(\b(?:password|passwd|(?:client[_-]?)?secret|credentials?|authorization|api[_-]?key|access[_-]?token|refresh[_-]?token|token)\b["']?\s*[=:]\s*)(?:"[^"\r\n]*"|'[^'\r\n]*'|[^\s,;}]+)''')
@@ -52,6 +56,15 @@ def _scrub_json(value):
def _allowed(parts):
if parts[0] == 'execution-proof' or (len(parts) > 3 and parts[0] == 'tasks' and parts[2] == 'execution-proof'):
return (parts[-1] == 'completion.json'
or bool(re.fullmatch(r'project-(?:commit|pause)-[a-f0-9]{32}\.tsv', parts[-1]))
or bool(re.fullmatch(r'(?:post-state|value-readback)-[A-Za-z0-9_.-]+\.(?:tsv|json)', parts[-1])))
if (len(parts) >= 5 and parts[:1] == ('tasks',) and parts[2] == 'netlist-checks'):
return parts[-1] in {'verification.json', 'netlist.json', 'capture.json', 'export-cache.json'}
if (any(re.fullmatch(r'native-inventory-[A-Za-z0-9-]+', part) for part in parts)
and len(parts) >= 3 and parts[-2] == 'output'):
return parts[-1] in {'scope.txt', 'effective.txt'} or bool(re.fullmatch(r'icdb2ascii-(?:scope|effective)\.(?:stdout|stderr)\.txt', parts[-1], re.I))
if re.fullmatch(r'cad-dialogs-[a-f0-9]{32}\.json', parts[-1]):
return ((len(parts) == 4 and parts[0] == 'batch-resources' and re.fullmatch(r'generation-\d+', parts[2])) or
any(value in parts for value in ('quick-run', 'quickrun', 'quick-run-history')))
@@ -71,7 +84,10 @@ def _allowed(parts):
if len(parts) >= 2 and parts[0] in {'queue', 'queues', 'task-queues', 'workspace-queues'}:
return parts[-1].endswith('.json')
if len(parts) >= 2 and any(value in parts for value in ('quick-run', 'quickrun', 'quick-run-history')):
return parts[-1] in _QUICK_NAMES or bool(re.fullmatch(r'retained-worker-[a-f0-9]{32}\.json', parts[-1]))
return (parts[-1] in _QUICK_NAMES
or bool(re.fullmatch(r'retained-worker-[a-f0-9]{32}\.json', parts[-1]))
or bool(re.fullmatch(r'project-(?:commit|pause)-[a-f0-9]{32}\.tsv', parts[-1]))
or bool(re.fullmatch(r'(?:post-state|value-readback)-[A-Za-z0-9_.-]+\.(?:tsv|json)', parts[-1])))
return False
@@ -84,11 +100,13 @@ def export_diagnostic_bundle(data_root, destination: Path) -> Path:
root, destination = canonical_path(data_root), canonical_path(destination)
if destination.suffix.lower() != '.zip':
raise ValueError('diagnostic destination must have a .zip suffix')
manifest = {'version': 1, 'included': [], 'omissions': [], 'unknowns': [
'External desktop handle holders are unknown; empty window/thread lists do not prove release.',
manifest = {'version': 2, 'included': [], 'omissions': [], 'truncated': [], 'unknowns': [
'Active logs and metadata are point-in-time reads; no source CAD, libraries, BOM, database or environment configuration is included.'],
'limits': {'max_file_bytes': MAX_FILE_BYTES, 'max_bundle_bytes': MAX_BUNDLE_BYTES, 'max_files': MAX_FILES}}
total = 0
candidates = []
operations = {}
items = {}
physical = internal_path(root)
# os.walk does not descend symlinks; explicitly prune Windows junctions too.
with zipfile.ZipFile(internal_path(destination), 'x', compression=zipfile.ZIP_DEFLATED) as archive:
@@ -101,7 +119,7 @@ def export_diagnostic_bundle(data_root, destination: Path) -> Path:
info = entry.lstat()
if stat.S_ISLNK(info.st_mode) or getattr(info, 'st_file_attributes', 0) & 0x400:
manifest['omissions'].append({'path': _scrub_text(relative), 'reason': 'link_or_reparse_point'})
elif base == physical and name not in {'logs', 'batch-resources', 'attempts', 'tasks', 'queue', 'queues', 'task-queues', 'workspace-queues', 'quick-run', 'quick-run-history'}:
elif base == physical and name not in {'logs', 'batch-resources', 'attempts', 'tasks', 'queue', 'queues', 'task-queues', 'workspace-queues', 'quick-run', 'quick-run-history', 'execution-proof'}:
manifest['omissions'].append({'path': _scrub_text(relative), 'reason': 'outside_allowlist'})
else:
safe_folders.append(name)
@@ -119,28 +137,94 @@ def export_diagnostic_bundle(data_root, destination: Path) -> Path:
reason = 'link_or_reparse_point'
elif not stat.S_ISREG(info.st_mode):
reason = 'not_regular_file'
elif info.st_size > MAX_FILE_BYTES or total + info.st_size > MAX_BUNDLE_BYTES or len(manifest['included']) >= MAX_FILES:
reason = 'size_or_count_limit'
else:
with path.open('rb') as source:
payload = source.read(MAX_FILE_BYTES + 1)
if len(payload) > MAX_FILE_BYTES or b'\x00' in payload:
reason = 'binary_or_size_limit'
else:
text = payload.decode('utf-8-sig')
if relative.suffix == '.json':
text = json.dumps(_scrub_json(json.loads(text)), ensure_ascii=False, indent=2)
elif '.jsonl' in relative.name:
text = '\n'.join(json.dumps(_scrub_json(json.loads(line)), ensure_ascii=False)
for line in text.splitlines() if line.strip()) + '\n'
else:
text = _scrub_text(text)
archive.writestr(label, text)
total += len(payload)
manifest['included'].append(label)
candidates.append((info.st_mtime_ns, path, relative, label, info.st_size))
except (OSError, UnicodeError, ValueError):
reason = 'unreadable_or_invalid_text'
if reason:
manifest['omissions'].append({'path': label, 'reason': reason})
# Current failures must survive a busy workspace's file/count budget.
for _, path, relative, label, size in sorted(candidates, key=lambda row: (-row[0], row[3])):
reason = None
budget = min(MAX_FILE_BYTES, MAX_BUNDLE_BYTES - total)
try:
tail = bool(re.search(r'\.(?:log|jsonl)(?:\.\d+)?$', relative.name))
truncated = size > budget
if len(manifest['included']) >= MAX_FILES or budget <= 0 or (truncated and (not tail or budget < 64)):
reason = 'size_or_count_limit'
else:
info = path.lstat()
if stat.S_ISLNK(info.st_mode) or getattr(info, 'st_file_attributes', 0) & 0x400 or info.st_nlink != 1:
manifest['omissions'].append({'path': label, 'reason': 'link_or_reparse_point'})
continue
with path.open('rb') as source:
if truncated:
source.seek(max(0, size - budget))
source.readline(budget + 1) # Discard clipped credentials and UTF-8 lines.
payload = source.read(budget + 1)
if len(payload) > budget or b'\x00' in payload:
reason = 'binary_or_size_limit'
elif not payload and size:
reason = 'no_complete_tail_line'
else:
try:
content = payload.decode('utf-8-sig')
except UnicodeDecodeError:
if relative.name not in {'scope.txt', 'effective.txt'}:
raise
content = payload.decode('mbcs' if os.name == 'nt' else 'cp1252')
if relative.suffix == '.json':
content = json.dumps(_scrub_json(json.loads(content)), ensure_ascii=False, indent=2)
elif '.jsonl' in relative.name:
records, invalid = [], 0
for line in content.splitlines():
if not line.strip():
continue
try:
records.append(_scrub_json(json.loads(line)))
except ValueError:
invalid += 1
content = '\n'.join(json.dumps(record, ensure_ascii=False) for record in records) + '\n'
if invalid:
manifest['omissions'].append({'path': label, 'reason': 'invalid_jsonl_lines', 'lines': invalid})
else:
content = _scrub_text(content)
encoded = content.encode('utf-8')
if tail and budget >= 64 and len(encoded) > budget:
# Redaction may grow a short secret. Trim complete oldest lines again.
offset, remaining = 0, len(encoded)
for line in encoded.splitlines(keepends=True):
if remaining <= budget:
break
offset += len(line)
remaining -= len(line)
encoded = encoded[offset:]
content = encoded.decode('utf-8')
truncated = True
if '.jsonl' in relative.name:
records = [json.loads(line) for line in content.splitlines() if line.strip()]
if len(encoded) > budget:
reason = 'size_or_count_limit'
else:
archive.writestr(label, encoded)
total += len(encoded)
manifest['included'].append(label)
if truncated:
manifest['truncated'].append({'path': label, 'mode': 'tail', 'source_bytes': size})
if relative.name == 'operation-events.jsonl':
operations[_scrub_text(relative.parent.as_posix())] = summarize_operations(records)
elif relative.name == 'status.tsv':
rows = [line.split('\t') for line in content.splitlines() if line.strip()]
rows = [row for row in rows if len(row) >= 4 and row[0] != 'job_id']
if rows:
saved = [row[0] for row in rows if row[1] in {'saved_ok', 'restored_ok'}]
items[_scrub_text(relative.parent.as_posix())] = {
'last_successful_item': saved[-1] if saved else None,
'latest_item': {'job_id': rows[-1][0], 'state': rows[-1][1]}}
except (OSError, UnicodeError, ValueError):
reason = 'unreadable_or_invalid_text'
if reason:
manifest['omissions'].append({'path': label, 'reason': reason})
archive.writestr('closure-summary.json', json.dumps({'operations': operations, 'items': items}, ensure_ascii=False, indent=2))
archive.writestr('manifest.json', json.dumps(manifest, ensure_ascii=False, indent=2))
return destination
@@ -14,25 +14,43 @@ class ExecutionFeedback:
stage: str = ''
stage_seconds: float = 0.0
waiting_for_safe_completion: bool = False
stopping_reason: str = ''
wait_reason: str = ''
primary_error: str = ''
def wait_reason_for_stage(stage):
return {'save_and_close': 'save', 'verify_saved_project': 'readback', 'saved_source_wait': 'readback',
'native_snapshot_read': 'readback', 'capture_semantic_state': 'readback',
'private_shutdown': 'desktop_release',
'awaiting_reconciliation': 'reconciliation', 'mentor_exit': 'mentor_exit',
'desktop_release': 'desktop_release'}.get(stage,
'native_call' if stage in {'native_replace', 'restore_attributes',
'restore_attribute_fields', 'verify_restoration', 'verify_attribute_fields'} else '')
def read_feedback(task_id, position, total, message, root: Path, started_after: float):
private_state = ''
private_seconds = 0.0
private = root / 'quick-run' / 'private-desktop.json'
try:
modified = private.stat().st_mtime
if modified >= started_after:
state = json.loads(private.read_text(encoding='utf-8')).get('state')
if state in {'starting', 'closing'}:
return ExecutionFeedback(task_id, position, total, message,
'private_startup' if state == 'starting' else 'private_shutdown', max(0, time.time() - modified))
private_state = 'private_startup' if state == 'starting' else 'private_shutdown'
private_seconds = max(0, time.time() - modified)
except (OSError, ValueError, TypeError, AttributeError):
pass
path = root / 'quick-run' / 'worker-progress.json'
stage, seconds, waiting = '', 0.0, False
record = {}
try:
modified = path.stat().st_mtime
if modified >= started_after:
record = json.loads(path.read_text(encoding='utf-8'))
if not isinstance(record, dict):
record = {}
waiting = record.get('waiting_for_safe_completion') is True
candidate = record.get('stage', '')
if candidate and candidate != 'finished':
@@ -40,4 +58,14 @@ def read_feedback(task_id, position, total, message, root: Path, started_after:
stage = candidate
except (OSError, ValueError, TypeError, AttributeError):
pass # Display feedback is optional; it never changes execution state.
return ExecutionFeedback(task_id, position, total, message, stage, seconds, waiting)
if private_state:
stage, seconds = private_state, private_seconds
stopping_reason = record.get('stopping_reason', '')
if not stopping_reason and record.get('stop_requested'):
stopping_reason = 'inactivity'
wait_reason = record.get('wait_reason') or wait_reason_for_stage(stage)
if private_state and wait_reason not in {'mentor_exit', 'desktop_release'}:
wait_reason = wait_reason_for_stage(stage)
return ExecutionFeedback(task_id, position, total, message, stage, seconds, waiting,
stopping_reason, wait_reason,
record.get('primary_error') or record.get('resolution_error') or '')
@@ -33,6 +33,11 @@ def create_execution_schema(connection):
connection.execute('''CREATE TABLE IF NOT EXISTS execution_target_claims (
task_id TEXT NOT NULL, round_id TEXT NOT NULL, target_key TEXT NOT NULL,
operation_key TEXT NOT NULL, PRIMARY KEY(task_id,round_id,target_key))''')
connection.execute('''CREATE TABLE IF NOT EXISTS execution_project_commits (
task_id TEXT NOT NULL, round_id TEXT NOT NULL, session_token TEXT NOT NULL,
project_path TEXT NOT NULL, evidence_root TEXT NOT NULL, state TEXT NOT NULL,
jobs_json TEXT NOT NULL, proof_json TEXT,
PRIMARY KEY(task_id,round_id,session_token))''')
def _json(value):
@@ -115,7 +120,7 @@ class ExecutionJournal:
current=self._round(task_id)
if current:
unsafe=self.store._connection.execute('''SELECT 1 FROM execution_operations
WHERE task_id=? AND round_id=? AND state IN ('prepared','uncertain') LIMIT 1''',
WHERE task_id=? AND round_id=? AND state IN ('prepared','uncertain','pending_save') LIMIT 1''',
(task_id,current['round_id'])).fetchone()
if unsafe:raise TaskCenterError('quick_run_uncertain','原执行项尚待核验,不能准备重试。')
self.store._connection.execute('DELETE FROM execution_retry_selections WHERE task_id=?',(task_id,))
@@ -154,7 +159,7 @@ class ExecutionJournal:
(task_id, current['round_id']))}
for key in json.loads(current['plan_json']):
record = records.get(key)
if record is None or record['state'] in {'prepared', 'uncertain'}:return False
if record is None or record['state'] in {'prepared', 'uncertain', 'pending_save'}:return False
if record['state'] == 'pending':
command = json.loads(record['command_json'])
return bool(self.can_continue_component(task_id, command))
@@ -392,13 +397,18 @@ class ExecutionJournal:
if record is None or not self.certified_startup_pause(task_id, record):
return
proof = json.loads(record['receipt_json'] or '{}').get('startup_pause', {})
status = internal_path(root / 'status.tsv').read_bytes()
status_size = proof.get('status_size')
if proof.get('phase') == 'before_native_dispatch' and type(status_size) is int and 0 < status_size <= len(status):
# A delayed marker retirement can follow appends to the certified stream.
status = status[:status_size]
if (proof.get('task_id') != task_id or proof.get('job_id') != row['job_id']
or proof.get('native_dispatch_not_started') is not True
or proof.get('project_closed') is not True or proof.get('worker_tree_exited') is not True
or not proof.get('files') or not proof_intact(proof)
or _source_digest(proof) != proof.get('source_sha256')
or hashlib.sha256(marker.read_bytes()).hexdigest() != proof.get('current_command_sha256')
or hashlib.sha256(internal_path(root / 'status.tsv').read_bytes()).hexdigest() != proof.get('status_sha256')
or hashlib.sha256(status).hexdigest() != proof.get('status_sha256')
# Scope cleanup removes this request after the durable pause;
# a surviving request must still match the certified one.
or internal_path(root / 'project-session.request').exists() and hashlib.sha256(
@@ -430,7 +440,7 @@ class ExecutionJournal:
with self.store._lock:
current=self._round(task_id)
return bool(current and self.store._connection.execute('''SELECT 1 FROM execution_operations
WHERE task_id=? AND round_id=? AND state='prepared' LIMIT 1''',
WHERE task_id=? AND round_id=? AND state IN ('prepared','pending_save') LIMIT 1''',
(task_id,current['round_id'])).fetchone())
def unresolved_jobs(self,task_id,rows):
@@ -438,7 +448,7 @@ class ExecutionJournal:
current=self._round(task_id)
if current is None:return ()
keys={record[0] for record in self.store._connection.execute('''SELECT operation_key
FROM execution_operations WHERE task_id=? AND round_id=? AND state IN ('prepared','uncertain')''',
FROM execution_operations WHERE task_id=? AND round_id=? AND state IN ('prepared','uncertain','pending_save')''',
(task_id,current['round_id']))}
return tuple(row['job_id'] for row in rows if _hash(command_identity(row)) in keys)
@@ -506,6 +516,8 @@ class ExecutionJournal:
elif record['state']=='failed':
restored[row['job_id']]=tuple(json.loads(record['receipt_json'])[name] for name in ('native_state','code','message'))
continue
elif record['state']=='pending_save':
raise TaskCenterError('quick_run_uncertain','工程替换尚待统一保存回读,禁止重放;请先核验工程提交记录。')
outcome=latest.get(row['job_id'])
if outcome and outcome[0] in _TERMINAL:
record=connection.execute('''SELECT * FROM execution_operations
@@ -546,6 +558,186 @@ class ExecutionJournal:
WHERE task_id=? AND round_id=? AND operation_key=?''',(identifier,generation,task_id,current['round_id'],key))
return JournalAttempt(task_id,current['round_id'],key,identifier,generation,row['job_id'])
def stage_project_result(self, attempt, row, *, session_token, root, proof):
"""Retain an applied operation without granting a saved receipt or retry."""
from .execution_proof import proof_intact
if not session_token or not proof_intact(proof):
raise TaskCenterError('quick_run_uncertain', '工程暂存证据不完整。')
with self.store.transaction():
connection = self.store._connection
record = connection.execute('''SELECT * FROM execution_operations
WHERE task_id=? AND round_id=? AND operation_key=?''',
(attempt.task_id, attempt.round_id, attempt.operation_key)).fetchone()
if (record is None or record['state'] != 'prepared' or record['attempt_id'] != attempt.attempt_id
or record['generation'] != attempt.generation or _hash(command_identity(row)) != attempt.operation_key):
raise TaskCenterError('quick_run_uncertain', '工程暂存结果不属于当前执行声明。')
project = command_identity(row)['project_path']
commit = connection.execute('''SELECT * FROM execution_project_commits
WHERE task_id=? AND round_id=? AND session_token=?''',
(attempt.task_id, attempt.round_id, session_token)).fetchone()
if commit and (commit['state'] != 'pending_save' or commit['project_path'] != project
or commit['evidence_root'] != str(canonical_path(root))):
raise TaskCenterError('quick_run_uncertain', '工程提交身份发生变化。')
jobs = json.loads(commit['jobs_json']) if commit else []
if row['job_id'] in jobs:
raise TaskCenterError('quick_run_uncertain', '工程暂存操作重复。')
jobs.append(row['job_id'])
connection.execute('''INSERT INTO execution_project_commits VALUES (?,?,?,?,?, 'pending_save',?,NULL)
ON CONFLICT(task_id,round_id,session_token) DO UPDATE SET jobs_json=excluded.jobs_json''',
(attempt.task_id, attempt.round_id, session_token, project, str(canonical_path(root)), _json(jobs)))
receipt = dict(native_state='pending_save', code='session_staged', message='替换已暂存,等待工程统一保存回读。',
job_id=row['job_id'], session_token=session_token, row=row, proof=proof,
operation_attempt=[attempt.operation_key, attempt.attempt_id, attempt.generation])
connection.execute('''UPDATE execution_operations SET state='pending_save',receipt_json=?
WHERE task_id=? AND round_id=? AND operation_key=?''',
(_json(receipt), attempt.task_id, attempt.round_id, attempt.operation_key))
def pending_project_commits(self, task_id):
with self.store._lock:
current = self._round(task_id)
if not current:return ()
return tuple(dict(row) for row in self.store._connection.execute('''SELECT * FROM execution_project_commits
WHERE task_id=? AND round_id=? AND state='pending_save' ''', (task_id, current['round_id'])))
def project_commit_records(self, task_id):
with self.store._lock:
current = self._round(task_id)
return tuple(dict(row) for row in self.store._connection.execute('''SELECT * FROM execution_project_commits
WHERE task_id=? AND round_id=?''', (task_id, current['round_id']))) if current else ()
def project_commit_attempts(self, task_id, session_token, *, require_recorded=False):
with self.store._lock:
current = self._round(task_id)
if not current:return {}
result = {}
for row in self.store._connection.execute('''SELECT * FROM execution_operations
WHERE task_id=? AND round_id=?''', (task_id, current['round_id'])):
receipt = json.loads(row['receipt_json'] or '{}')
token = receipt.get('session_token') or receipt.get('proof', {}).get('project_commit', {}).get('session_token')
if token == session_token:
actual = [row['operation_key'], row['attempt_id'], row['generation']]
original = receipt.get('operation_attempt') or receipt.get('proof', {}).get('project_commit', {}).get('operation_attempts', {}).get(receipt['job_id'])
if original != actual and (require_recorded or original is not None):
raise TaskCenterError('quick_run_uncertain', '原工程暂存尝试与当前执行记录不同。')
result[receipt['job_id']] = actual
return result
def project_commit_recovery_attempts(self, task_id):
"""Include actual attempts outside the frozen command rows as well."""
with self.store._lock:
current = self._round(task_id)
if not current:return ()
return tuple([row['operation_key'], row['attempt_id'], row['generation']]
for row in self.store._connection.execute('''SELECT operation_key,attempt_id,generation
FROM execution_operations WHERE task_id=? AND round_id=?
AND (attempt_id IS NOT NULL OR generation>0)''', (task_id, current['round_id'])))
def bind_project_commit_proof(self, task_id, session_token, proof):
with self.store.transaction():
current = self._round(task_id)
self.store._connection.execute('''UPDATE execution_project_commits SET proof_json=?
WHERE task_id=? AND round_id=? AND session_token=? AND state='pending_save' AND proof_json IS NULL''',
(_json(proof), task_id, current['round_id'], session_token))
def promote_project_commit_proof(self, task_id, session_token, expected_proof, verified_proof):
"""Attach native verification to the same saved attempt without replacing its source binding."""
from .execution_proof import proof_intact
with self.store.transaction():
current = self._round(task_id)
record = self.store._connection.execute('''SELECT * FROM execution_project_commits
WHERE task_id=? AND round_id=? AND session_token=?''',
(task_id, current['round_id'], session_token)).fetchone() if current else None
original = {key: value for key, value in expected_proof.items() if key not in {'files', 'outcomes', 'saved_netlist'}}
if (record is None or record['state'] != 'pending_save'
or expected_proof.get('session_token') != session_token
or expected_proof.get('validation_required') != 'saved_netlist_v1'
or verified_proof.get('saved_netlist', {}).get('status') != 'verified'
or any(verified_proof.get(key) != value for key, value in original.items())
or any(item not in verified_proof.get('files', []) for item in expected_proof.get('files', []))
or not proof_intact(verified_proof)
or json.loads(record['proof_json'] or 'null') not in (expected_proof, verified_proof)):
raise TaskCenterError('quick_run_uncertain', '原工程保存证明发生变化,不能覆盖核验结果。')
self.store._connection.execute('''UPDATE execution_project_commits SET proof_json=?
WHERE task_id=? AND round_id=? AND session_token=?''',
(_json(verified_proof), task_id, current['round_id'], session_token))
def staged_project_rows(self, task_id, session_token):
with self.store._lock:
current = self._round(task_id)
if not current:return ()
records = self.store._connection.execute('''SELECT receipt_json FROM execution_operations
WHERE task_id=? AND round_id=? AND state='pending_save' ''', (task_id, current['round_id']))
return tuple(receipt for record in records
if (receipt := json.loads(record[0])).get('session_token') == session_token)
def commit_project_results(self, task_id, session_token, proofs, commit_proof):
"""Commit a whole staged prefix and its history in one SQL transaction."""
from .execution_proof import proof_intact
statuses = []
with self.store.transaction():
connection = self.store._connection
current = self._round(task_id)
commit = connection.execute('''SELECT * FROM execution_project_commits
WHERE task_id=? AND round_id=? AND session_token=?''', (task_id, current['round_id'], session_token)).fetchone() if current else None
if commit is None:
raise TaskCenterError('quick_run_uncertain', '缺少原工程暂存提交记录。')
if commit['state'] == 'verified':return ()
jobs = json.loads(commit['jobs_json'])
if (commit_proof.get('session_token') != session_token
or str(canonical_path(commit_proof.get('project_path', ''))).casefold() != commit['project_path']
or commit_proof.get('jobs') != jobs or set(proofs) != set(jobs)
or not commit_proof.get('files') or not proof_intact(commit_proof)
or any(not proof.get('files') or not proof_intact(proof) for proof in proofs.values())):
raise TaskCenterError('quick_run_uncertain', '工程保存回读证明未覆盖全部暂存项。')
saved_protocol = commit_proof.get('marker_state') == 'project_saved' or commit_proof.get('validation_required') == 'saved_netlist_v1'
saved = commit_proof.get('saved_netlist', {})
if saved_protocol and (commit_proof.get('validation_required') != 'saved_netlist_v1'
or saved.get('status') != 'verified' or set(saved.get('jobs', {})) != set(jobs)
or set(commit_proof.get('native_outcomes', {})) != set(jobs)
or any(state not in {'pending_save', 'no_match'} for state in commit_proof['native_outcomes'].values())
or commit_proof.get('outcomes') != {job: 'saved_ok' if state == 'pending_save' else state
for job, state in commit_proof['native_outcomes'].items()}
or not saved.get('files') or not proof_intact(saved)):
raise TaskCenterError('quick_run_uncertain', '工程已保存,尚未完成原生数据核验。')
records = connection.execute('''SELECT * FROM execution_operations
WHERE task_id=? AND round_id=? AND state='pending_save' ''', (task_id, current['round_id'])).fetchall()
records = [record for record in records if json.loads(record['receipt_json']).get('session_token') == session_token]
if {json.loads(record['receipt_json'])['job_id'] for record in records} != set(jobs):
raise TaskCenterError('quick_run_uncertain', '工程暂存前缀与提交证明不一致。')
for record in records:
receipt = json.loads(record['receipt_json'])
job = receipt['job_id']
proof = dict(proofs[job])
if proof.get('native_attempt') != receipt.get('proof', {}).get('native_attempt'):
raise TaskCenterError('quick_run_uncertain', '保存回读与原暂存原生尝试不一致。')
if saved_protocol:
proof['project_commit'] = dict(session_token=session_token, project_path=commit_proof['project_path'],
validation_required='saved_netlist_v1',
operation_attempts={job: [record['operation_key'], record['attempt_id'], record['generation']]},
saved_netlist={key: saved[key] for key in ('status', 'export_path', 'export_sha256')})
command = json.loads(record['command_json'])
proof['baseline'] = dict(project_path=command['project_path'], schematic_name=command['schematic_name'],
sheet_number=command['sheet_number'], validation_mode='saved_netlist_v1',
state='N\tsaved_netlist_v1\t' + saved['export_sha256'])
shared = [{'path': saved['export_path'], 'sha256': saved['export_sha256']}]
if saved.get('verification_path'):
shared.append({'path': saved['verification_path'], 'sha256': saved['verification_sha256']})
proof['files'] = list(proof['files']) + [item for item in shared if item not in proof['files']]
else:
proof['project_commit'] = commit_proof
proof['files'] = list(proof['files']) + list(commit_proof['files'])
attempt = JournalAttempt(task_id, current['round_id'], record['operation_key'],
record['attempt_id'], record['generation'], job)
connection.execute('''UPDATE execution_operations SET state='prepared'
WHERE task_id=? AND round_id=? AND operation_key=?''', (task_id, current['round_id'], record['operation_key']))
native_state = commit_proof.get('outcomes', {}).get(job, 'saved_ok')
message = '工程统一保存,原生数据核验通过。' if saved_protocol else '工程统一保存、关闭重开及回读校验通过。'
self.finish(attempt, native_state, 'project_committed', message, proof=proof)
statuses.append((job, native_state, 'project_committed', message))
connection.execute('''UPDATE execution_project_commits SET state='verified',proof_json=?
WHERE task_id=? AND round_id=? AND session_token=?''', (_json(commit_proof), task_id, current['round_id'], session_token))
return tuple(statuses)
def finish(self,attempt,native_state,code,message,*,progress=None,proof=None):
if native_state not in _TERMINAL:raise TaskCenterError('quick_run_uncertain','不能提交未知的执行结果。')
state=({'saved_ok':'verified','no_match':'no_match','restored_ok':'restored',
@@ -682,7 +874,7 @@ class ExecutionJournal:
from .execution_proof import proof_intact
if not proof_intact(receipt.get('proof',{})):return True
if not outcome or tuple(outcome[:2])!=(receipt['native_state'],receipt['code']):return True
elif record['state']=='uncertain':return True
elif record['state'] in {'uncertain','pending_save'}:return True
elif record['state']=='prepared' and (not outcome or outcome[0] not in _TERMINAL):return True
return False
@@ -17,14 +17,35 @@ def proof_intact(proof):
except (OSError,ValueError,KeyError,TypeError):return False
def capture_result(data_root,root,row,outcome,*,strict=False,persist=True):
def capture_result(data_root,root,row,outcome,*,strict=False,persist=True,project_commit=None):
from .quick_run import _decode_vbs_field, _safe_run_token
from .native_helper import read_snapshot, require_resumable_transaction, snapshot_target_cell
from .native_helper import read_snapshot, require_resumable_transaction, snapshot_target_cell, saved_netlist_snapshot
state,code,_=outcome
proof={'files':[]}
paths=[]
try:
_safe_run_token(row['job_id'])
snapshot = internal_path(root/f'snapshot-{row["job_id"]}.tsv')
saved_protocol = ((snapshot.is_file() and saved_netlist_snapshot(snapshot))
or bool(project_commit and project_commit.get('validation_required') == 'saved_netlist_v1'))
if saved_protocol:
proof['validation_required'] = 'saved_netlist_v1'
if state in {'saved_ok', 'no_match'}:
saved = (project_commit or {}).get('saved_netlist', {})
if saved.get('status') != 'verified' or row['job_id'] not in saved.get('jobs', {}):
raise ValueError('saved native netlist proof is required')
proof['saved_netlist'] = {key:saved[key] for key in ('status','export_path','export_sha256')}
proof['value_readback'] = saved['jobs'][row['job_id']]
if state == 'no_match' and persist:
destination = internal_path(data_root/'execution-proof'/uuid4().hex)
destination.mkdir(parents=True,exist_ok=False)
target = destination/f'no-match-{row["job_id"]}.json'
reference = dict(command=dict(row),session_token=project_commit['session_token'],
**{key:saved[key] for key in ('export_path','export_sha256','verification_path','verification_sha256')})
data = json.dumps(reference,ensure_ascii=False,sort_keys=True).encode('utf-8')
with target.open('xb') as stream:
stream.write(data);stream.flush();os.fsync(stream.fileno())
proof['files'].append({'path':str(canonical_path(target)),'sha256':hashlib.sha256(data).hexdigest()})
if row.get('execution_unit') == 'inventory_empty':
from .component_scope import validate_empty_command
if state != 'batch_skipped' or not validate_empty_command(root, row):
@@ -33,13 +54,13 @@ def capture_result(data_root,root,row,outcome,*,strict=False,persist=True):
checked_manifest = manifest.read_bytes()
paths.append(manifest)
proof['inventory_empty'] = True
if strict and state in {'saved_ok','no_match'} and code not in {'batch_closed','session_verified'}:
if strict and state in {'saved_ok','no_match'} and code not in {'batch_closed','session_verified','project_committed'}:
raise ValueError('save/close was not verified')
checked={}
if row.get('execution_unit') == 'inventory_empty':
checked[manifest] = checked_manifest
baseline=internal_path(root/f'post-state-{row["job_id"]}.tsv')
if baseline.is_file():
if baseline.is_file() and not saved_protocol:
checked[baseline]=baseline.read_bytes()
with baseline.open(encoding='utf-8-sig',newline='') as stream:
rows=list(csv.DictReader(stream,delimiter='\t'))
@@ -53,9 +74,9 @@ def capture_result(data_root,root,row,outcome,*,strict=False,persist=True):
proof['baseline']={'project_path':str(canonical_path(row['project_path'])).casefold(),
'schematic_name':actual['schematic_name'],'sheet_number':actual['sheet_number'],'state':actual['semantic_state']}
paths.append(baseline)
elif strict and state in {'saved_ok','no_match','restored_ok','recovery_readback'}:
elif strict and not saved_protocol and state in {'saved_ok','no_match','restored_ok','recovery_readback'}:
raise ValueError('missing verified semantic state')
if state=='saved_ok' or (state=='restored_ok' and code in {'recovery_verified','recovery_saved_verified'}):
if state=='saved_ok' or (state=='pending_save' and code == 'session_staged') or (state=='restored_ok' and code in {'recovery_verified','recovery_saved_verified'}):
snapshot=internal_path(root/f'snapshot-{row["job_id"]}.tsv')
report_path=Path(str(snapshot)+'.native.json')
if strict or snapshot.is_file() or report_path.is_file():
@@ -74,7 +95,8 @@ def capture_result(data_root,root,row,outcome,*,strict=False,persist=True):
raise ValueError('snapshot command changed')
attempt=report.get('batch_attempt')
if strict:
if report.get('stage')!='native_replace_verified' or report.get('ok') is not True:
required_stage = 'native_replace_applied' if saved_protocol else 'native_replace_verified'
if report.get('stage')!=required_stage or report.get('ok') is not True:
raise ValueError('native result is not verified')
if (not isinstance(attempt,dict) or attempt.get('job_id')!=row['job_id'] or
attempt.get('task_id')!=row['task_id'] or
@@ -84,6 +106,10 @@ def capture_result(data_root,root,row,outcome,*,strict=False,persist=True):
raise ValueError('native attempt differs from this job')
proof['native_attempt']=attempt
paths.extend((snapshot,report_path))
if saved_protocol:
writer = internal_path(root/f'writer-expectations-{row["job_id"]}.tsv')
checked[writer] = writer.read_bytes()
paths.append(writer)
if any(path.read_bytes()!=data for path,data in checked.items()):
raise ValueError('execution evidence changed during receipt binding')
if persist and paths:
@@ -101,6 +127,57 @@ def capture_result(data_root,root,row,outcome,*,strict=False,persist=True):
raise TaskCenterError('quick_run_uncertain','原生回执、尝试身份或工程语义基线无法核验,已停止以避免重复替换。') from error
def capture_project_commit(data_root, root, commit):
"""Bind a durable project marker to the exact staged prefix before SQL commit."""
from .quick_run import _decode_vbs_field
try:
path = internal_path(Path(root) / f'project-commit-{commit["session_token"]}.tsv')
data = path.read_bytes()
lines = data.decode('utf-8-sig').splitlines()
token, project, state = lines[0].split('\t')
outcomes = [line.split('\t') for line in lines[1:] if line]
jobs = json.loads(commit['jobs_json'])
saved_only = state == 'project_saved'
allowed = {'pending_save', 'no_match'} if saved_only else {'saved_ok', 'no_match'}
if (token != commit['session_token'] or state not in {'project_verified', 'project_saved'}
or str(canonical_path(_decode_vbs_field(project))).casefold() != commit['project_path']
or [outcome[0] for outcome in outcomes] != jobs
or any(len(outcome) != 2 or outcome[1] not in allowed for outcome in outcomes)):
raise ValueError('project commit does not cover staged prefix')
destination = internal_path(data_root / 'execution-proof' / uuid4().hex)
destination.mkdir(parents=True, exist_ok=False)
target = destination / path.name
with target.open('xb') as stream:
stream.write(data); stream.flush(); os.fsync(stream.fileno())
if path.read_bytes() != data:
raise ValueError('project marker changed during binding')
proof = dict(session_token=token, project_path=commit['project_path'], jobs=jobs,
outcomes=dict(outcomes), files=[dict(path=str(canonical_path(target)), sha256=hashlib.sha256(data).hexdigest())])
if saved_only:
proof.update(marker_state=state, saved_only=True, validation_required='saved_netlist_v1', native_outcomes=dict(outcomes))
return proof
except (OSError, UnicodeError, ValueError, KeyError, TypeError, IndexError) as error:
raise TaskCenterError('quick_run_uncertain', '工程统一保存或回读尚未得到完整证明,保留全部暂存项待核验。') from error
def bind_project_commit_source(proof, data_root, root, project, *, stop_event=None, release_mentor=None):
"""Capture saved bytes only at the completed native-close callback."""
from .saved_source import bind_sources
return bind_sources(proof, data_root, root, project,
stop_event=stop_event, release_mentor=release_mentor)
def validate_project_commit_source(proof, root):
from .project_session_health import _source_digest
try:
return (proof.get('source_sha256') and _source_digest(proof) == proof['source_sha256']
and proof.get('command_sha256') == hashlib.sha256(internal_path(root / 'command.tsv').read_bytes()).hexdigest()
and bool(proof.get('saved_sources')) and all(
hashlib.sha256(internal_path(source).read_bytes()).hexdigest() == digest
for source, digest in proof['saved_sources'].items()) and proof_intact(proof))
except (OSError, KeyError, TypeError, ValueError):return False
def capture_recovery(data_root,audit,row,outcome,*,strict=False):
"""The recovery audit proves readback; it never asserts a second replacement."""
worker=audit/'worker'
@@ -0,0 +1,51 @@
"""Read-only Restart Manager observations; never shut down registered applications."""
import ctypes
from ctypes import wintypes as w
import os
from .path_access import strip_extended_prefix
def locking_processes(path):
result = dict(method='windows_restart_manager', processes=[], complete=False)
if os.name != 'nt':
return dict(result, error='unsupported platform')
class UniqueProcess(ctypes.Structure):
_fields_ = [('pid', w.DWORD), ('started', w.FILETIME)]
class ProcessInfo(ctypes.Structure):
_fields_ = [('process', UniqueProcess), ('name', w.WCHAR*256), ('service', w.WCHAR*64),
('type', ctypes.c_int), ('status', w.ULONG), ('session', w.DWORD), ('restartable', w.BOOL)]
session = w.DWORD()
api = ctypes.WinDLL('rstrtmgr')
api.RmStartSession.argtypes = [ctypes.POINTER(w.DWORD), w.DWORD, w.LPWSTR]
api.RmRegisterResources.argtypes = [w.DWORD, w.UINT, ctypes.POINTER(w.LPCWSTR), w.UINT,
ctypes.POINTER(UniqueProcess), w.UINT, ctypes.POINTER(w.LPCWSTR)]
api.RmGetList.argtypes = [w.DWORD, ctypes.POINTER(w.UINT), ctypes.POINTER(w.UINT),
ctypes.POINTER(ProcessInfo), ctypes.POINTER(w.DWORD)]
api.RmEndSession.argtypes = [w.DWORD]
started = False
try:
code = api.RmStartSession(ctypes.byref(session), 0, ctypes.create_unicode_buffer(33))
if code: raise OSError(code, 'RmStartSession')
started = True
files = (w.LPCWSTR*1)(strip_extended_prefix(path))
code = api.RmRegisterResources(session, 1, files, 0, None, 0, None)
if code: raise OSError(code, 'RmRegisterResources')
needed, count, reboot = w.UINT(), w.UINT(), w.DWORD()
code = api.RmGetList(session, ctypes.byref(needed), ctypes.byref(count), None, ctypes.byref(reboot))
for _ in range(3):
if code != 234: break # ERROR_MORE_DATA
count.value = needed.value
items = (ProcessInfo*count.value)()
code = api.RmGetList(session, ctypes.byref(needed), ctypes.byref(count), items, ctypes.byref(reboot))
if code == 0:
result['processes'] = [dict(pid=item.process.pid, name=item.name,
creation_filetime=(item.process.started.dwHighDateTime << 32) | item.process.started.dwLowDateTime)
for item in items[:count.value]]
if code: raise OSError(code, 'RmGetList')
result['complete'] = True # Complete RM result, not an exhaustive kernel-handle scan.
except Exception as error:
result['error'] = str(error)
finally:
if started: api.RmEndSession(session)
return result
@@ -99,7 +99,7 @@ class IsolatedCadSession:
self.root = canonical_path(root)
self.token = uuid4().hex
self.borrowed_desktop = desktop is not None
self.desktop = desktop if desktop is not None else PrivateDesktop('dx-' + self.token, enabled=True)
self.desktop = desktop if desktop is not None else PrivateDesktop('dx-' + self.token, enabled=True, managed=True)
self.cad = None
self.binding = None
self.started = time.monotonic()
@@ -87,6 +87,7 @@ def build_startup_info(desktop_name: str) -> StartupInfo:
class _Win32Api:
atomic_job_launch = True
def __init__(self) -> None:
try:
import win32api, win32con, win32event, win32job, win32process, win32service
@@ -101,6 +102,12 @@ class _Win32Api:
def create_desktop(self, name: str):
return self.service.CreateDesktop(name, 0, self.con.GENERIC_ALL, None)
def validate_desktop_owner(self, handle, sid):
import win32security
security = win32security.GetUserObjectSecurity(handle, win32security.OWNER_SECURITY_INFORMATION)
if win32security.ConvertSidToStringSid(security.GetSecurityDescriptorOwner()) != sid:
raise TaskCenterError('desktop_slot_busy', '同名桌面的所有者不匹配,未启动工作进程。')
def confirm_desktop_released(self, name: str):
started = time.monotonic()
# USER references can outlive the owned processes briefly. Allow a
@@ -166,7 +173,7 @@ class _Win32Api:
return windows
def create_process(self, command: Sequence[str], desktop: str, cwd: Path | None, env: Mapping[str, str] | None,
*, stdout=None, stderr=None):
*, stdout=None, stderr=None, job_name=None):
# Windows venv python.exe redirects to a second process. Launch the
# interpreter directly with its venv identity, so the handle we own is
# also the process that admits the request and creates desktop windows.
@@ -176,18 +183,23 @@ class _Win32Api:
command = (sys._base_executable, *command[1:])
env = dict(os.environ if env is None else env)
env['__PYVENV_LAUNCHER__'] = sys.executable
startup = self.process.STARTUPINFO()
startup.lpDesktop = desktop
flags = self.con.CREATE_NO_WINDOW | self.con.CREATE_SUSPENDED
job = self.job.CreateJobObject(None, "")
try:
startup = self.process.STARTUPINFO()
startup.lpDesktop = desktop
flags = self.con.CREATE_NO_WINDOW | self.con.CREATE_SUSPENDED
job = self.job.CreateJobObject(None, job_name or "")
except Exception as error:
error.desktop_launch_cleanup_proven = True # CreateProcess has not been called.
raise
process = None
try:
info = self.job.QueryInformationJobObject(job, self.job.JobObjectExtendedLimitInformation)
info["BasicLimitInformation"]["LimitFlags"] |= self.job.JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE
self.job.SetInformationJobObject(job, self.job.JobObjectExtendedLimitInformation, info)
streams = (None, None)
if stdout is not None or stderr is not None:
(handle, thread, pid, _), streams = _create_redirected_process(command, desktop, cwd, env, flags, stdout, stderr)
if stdout is not None or stderr is not None or job_name:
(handle, thread, pid, _), streams = _create_redirected_process(command, desktop, cwd, env, flags, stdout, stderr,
**({'job': job} if job_name else {}))
else:
handle, thread, pid, _ = self.process.CreateProcess(
str(command[0]), subprocess.list2cmdline([str(item) for item in command]),
@@ -197,7 +209,7 @@ class _Win32Api:
open_process=getattr(self, 'open_process', None), process_ids=self.process_ids)
process.stdout, process.stderr = streams
process.thread = thread
self.job.AssignProcessToJobObject(job, handle)
if not job_name: self.job.AssignProcessToJobObject(job, handle)
process.job_assigned = True
if not self.job.IsProcessInJob(handle, job):
raise TaskCenterError('private_desktop', 'Owned process Job membership was not confirmed')
@@ -218,6 +230,7 @@ class _Win32Api:
self._pending_cleanup = pending = []
pending.append(process if process is not None else job)
raise TaskCenterError('private_desktop', f'launch failed: {error}; cleanup failed: {cleanup_error}') from error
error.desktop_launch_cleanup_proven = True
raise
return process
@@ -260,7 +273,7 @@ def _stop_and_wait(process):
return errors
def _create_redirected_process(command, desktop, cwd, env, flags, stdout, stderr):
def _create_redirected_process(command, desktop, cwd, env, flags, stdout, stderr, *, job=None):
"""Use an explicit inheritance list; never inherit unrelated parent handles."""
import msvcrt
import pywintypes
@@ -323,13 +336,19 @@ def _create_redirected_process(command, desktop, cwd, env, flags, stdout, stderr
handles = list(dict.fromkeys((stdin_handle, stdout_handle, stderr_handle)))
inherited = (wintypes.HANDLE * len(handles))(*handles)
size = ctypes.c_size_t()
initialize(None, 1, 0, ctypes.byref(size))
count = 2 if job is not None else 1
initialize(None, count, 0, ctypes.byref(size))
attributes = ctypes.create_string_buffer(size.value)
if not initialize(attributes, 1, 0, ctypes.byref(size)):
if not initialize(attributes, count, 0, ctypes.byref(size)):
raise ctypes.WinError(ctypes.get_last_error())
try:
if not update(attributes, 0, 0x20002, inherited, ctypes.sizeof(inherited), None, None):
raise ctypes.WinError(ctypes.get_last_error())
if job is not None:
jobs = (wintypes.HANDLE * 1)(int(job))
# Assign before the initial thread exists, including owner-loss windows.
if not update(attributes, 0, 0x2000D, jobs, ctypes.sizeof(jobs), None, None):
raise ctypes.WinError(ctypes.get_last_error())
startup = ExtendedStartup()
startup.StartupInfo.cb = ctypes.sizeof(startup)
startup.StartupInfo.lpDesktop = desktop
@@ -570,8 +589,13 @@ class _Win32Process:
class PrivateDesktop:
"""Own a private Windows desktop and processes started on it."""
def __init__(self, name: str, *, enabled: bool = False, api=None) -> None:
self.name = name
def __init__(self, name: str, *, enabled: bool = False, api=None, managed=False, slot=None) -> None:
if managed and slot is None and os.name == 'nt':
from .desktop_slot import DesktopSlot
slot = DesktopSlot()
self._slot = slot
self._slot_acquired = False
self.name = slot.name if slot is not None else name
self.enabled = enabled
self._handle = None
self._processes: list[subprocess.Popen[str]] = []
@@ -583,7 +607,16 @@ class PrivateDesktop:
def __enter__(self) -> "PrivateDesktop":
if not self.enabled:
raise TaskCenterError("private_desktop_opt_in", "private desktop backend requires explicit opt-in")
self._create()
if self._slot is not None:
self._slot.acquire()
self._slot_acquired = True
try:
self._create()
if self._slot is not None and hasattr(self._api, 'validate_desktop_owner'):
self._api.validate_desktop_owner(self._handle, self._slot.context['sid'])
except Exception:
self.close()
raise
if self._handle is None:
raise TaskCenterError("private_desktop", "private desktop could not be created")
return self
@@ -638,8 +671,23 @@ class PrivateDesktop:
if self._api is None:
raise TaskCenterError("private_desktop", "private desktop process API is unavailable")
options = {} if stdout is None and stderr is None else {'stdout': stdout, 'stderr': stderr}
process = self._api.create_process(command, build_startup_info(self.name).lpDesktop, cwd, env, **options)
job = self._slot.prepare_launch(atomic_job=bool(getattr(self._api, 'atomic_job_launch', False))) if self._slot is not None else None
if job is not None: options['job_name'] = job
try:
process = self._api.create_process(command, build_startup_info(self.name).lpDesktop, cwd, env, **options)
except Exception as error:
if job is not None and getattr(error, 'desktop_launch_cleanup_proven', False):
self._slot.launch_closed(job)
raise
self._processes.append(process)
if job is not None:
from .batch_resources import process_identity
try:
self._slot.launched(job, process_identity(process))
except Exception:
process.close()
self._slot.launch_closed(job)
raise
self._process_history.append({'pid': getattr(process, 'pid', None),
'owner_pid': os.getpid(), 'owner_thread_id': get_native_id(),
'started_time_ns': time.time_ns(), 'process_handle': _native_handle(getattr(process, 'handle', None)),
@@ -666,6 +714,12 @@ class PrivateDesktop:
self._remember_process_cleanup(process, forgotten=True)
def close(self) -> None:
if self._slot is not None and not self._slot_acquired:
self.cleanup_record = dict(desktop=self.name, desktop_not_acquired=True,
desktop_handle_closed=True, owned_cleanup_complete=True, processes=[], errors=[])
return
if self._slot is not None and self._slot.receipt is not None:
return # A past lease must never observe or close a newer owner.
errors, remaining = [], []
self.cleanup_record = {'desktop': self.name, 'processes': []}
for process in reversed(self._processes):
@@ -689,6 +743,7 @@ class PrivateDesktop:
close_pending()
except Exception as error:
errors.append(error)
self.cleanup_record['owned_cleanup_complete'] = not errors and not self._processes
try:
self.release_desktop()
except Exception as error:
@@ -703,6 +758,10 @@ class PrivateDesktop:
errors = []
if self.cleanup_record is None:
self.cleanup_record = {'desktop': self.name, 'processes': []}
if self._slot is not None and self._slot.receipt is not None:
return
if self._slot is not None and self.cleanup_record.get('owned_cleanup_complete') is not True:
raise TaskCenterError('desktop_waiting_for_mentor', '自有进程和句柄尚未收尾,桌面租用保持。')
from .read_recovery import process_tree_exited
if any(not process_tree_exited(process) for process in self._processes):
self.cleanup_record.update(desktop_release_state='waiting_for_mentor',
@@ -720,20 +779,35 @@ class PrivateDesktop:
event['error'] = str(error)
self._desktop_handle_history.append(event)
confirm = getattr(self._api, 'confirm_desktop_released', None)
if confirm and self._handle is None:
confirmation = None
if self._slot is not None and self._handle is None and not errors:
try:
disappeared = not self._slot.backend.desktop_exists(self.name)
self._slot.release(desktop_disappeared=disappeared)
confirmation = dict(desktop=self.name, released=disappeared,
method='managed_lease_return', elapsed_seconds=0.0)
except Exception as error:
errors.append(error)
if self._slot.receipt is not None:
self.cleanup_record['desktop_lease'] = self._slot.receipt
elif confirm and self._handle is None:
try:
confirm(self.name)
except Exception as error:
errors.append(error)
confirmation = getattr(self._api, 'desktop_release_check', None)
self.cleanup_record.update(desktop_handle_closed=self._handle is None,
desktop_release_state='failed' if errors else 'released',
desktop_confirmation=getattr(self._api, 'desktop_release_check', None),
desktop_confirmation=confirmation,
desktop_lease_pending=self._slot is not None and self._slot.receipt is None,
desktop_handle_history=deepcopy(self._desktop_handle_history),
process_history=deepcopy(self._process_history),
diagnostic_scope={'external_handle_holders': 'unknown',
'thread_desktops': 'unknown unless observed through residual windows; no exhaustive holder scan',
'empty_windows_prove_no_holders': False},
errors=[str(error) for error in errors])
if confirmation and self._slot is not None and not confirmation['released']:
self.cleanup_record['desktop_release_state'] = 'reusable'
if errors:
self.cleanup_record['owned_resource_diagnostics'] = self._owned_resource_diagnostics()
_raise_cleanup_errors(errors)
@@ -15,6 +15,7 @@ class TaskStatus(str, Enum):
PAUSED = "paused"
COMPLETED = "completed"
FAILED = "failed"
BLOCKED = "blocked"
DELETED = "deleted"
@@ -1,6 +1,9 @@
"""Native current-sheet replacement adapter for the existing QuickPartReplace runner."""
import argparse
from collections import Counter
from contextlib import contextmanager
from contextvars import ContextVar
from functools import wraps
import faulthandler
import ctypes
import csv
@@ -15,6 +18,46 @@ import time
import traceback
_SNAPSHOT_REFERENCE_KEYS = ContextVar('snapshot_reference_keys', default={})
@contextmanager
def snapshot_identity_scope(snapshot):
"""Keep original receipt keys while resolving live COM objects by reference."""
rows = [line.split('\t') for line in Path(snapshot).read_text(encoding='utf-8-sig').splitlines()]
references, owners, spelling = {}, {}, {}
for row in rows:
if len(row) >= 3 and row[0] in {'C', 'U'}:
uid, ref = decode(row[1]), decode(row[2]).strip().casefold()
spelling[ref] = decode(row[2]).strip()
transform = tuple(decode(value) for value in row[3:7]) if row[0] == 'C' and len(row) == 8 else None
references.setdefault(ref, []).append((uid, transform))
owners.setdefault(uid, set()).add(ref)
for row in rows:
if len(row) == 3 and row[0] == 'G':
headers = [line.split('\t') for line in decode(row[2]).splitlines() if line.startswith('C\t')]
if len(headers) == 1 and len(headers[0]) == 8:
header = [decode(value) for value in headers[0]]
ref = header[2].strip().casefold()
references[ref] = [(uid, tuple(header[3:7]) if uid == header[1] else transform)
for uid, transform in references.get(ref, ())]
keys = {ref: [(uid if len(owners[uid]) == 1 else '@REFDES|' + spelling[ref], transform)
for uid, transform in values] for ref, values in references.items() if ref}
token = _SNAPSHOT_REFERENCE_KEYS.set(keys)
try:
yield
finally:
_SNAPSHOT_REFERENCE_KEYS.reset(token)
def _bound_snapshot_identity(action):
@wraps(action)
def bound(snapshot, *args, **kwargs):
with snapshot_identity_scope(snapshot):
return action(snapshot, *args, **kwargs)
return bound
def snapshot_attempt(snapshot):
"""Bind batch evidence to the actual snapshot and its confirmed queue row."""
from .batch_attempt import _bound_attempt
@@ -99,6 +142,22 @@ def read_snapshot(path):
return metadata[0], components
def saved_netlist_snapshot(snapshot):
rows = [line.split('\t') for line in Path(snapshot).read_text(encoding='utf-8-sig').splitlines() if line]
markers = [row for row in rows if row[0] == 'X']
if ['X', 'saved_netlist_v1'] not in markers:
return False
if (markers != [['X', 'saved_netlist_v1']] or any(row[0] not in {'M', 'C', 'A', 'X', 'L'} for row in rows)
or not any(row[0] == 'C' for row in rows)
or any(len(row) != 8 or row[7] != 'NETLIST' for row in rows if row[0] == 'C')):
raise ValueError('Invalid saved native data snapshot scope')
_, components = read_snapshot(snapshot)
selected = {row[1] for row in components}
if any(len(row) != 12 or decode(row[1]) not in selected for row in rows if row[0] == 'A'):
raise ValueError('Invalid saved native data snapshot attributes')
return True
def snapshot_value_mode(metadata):
return metadata[5] if len(metadata) >= 6 else "part_label"
@@ -392,16 +451,35 @@ def components_on_sheet(app, api):
def _component_uid(component):
value = getattr(component, 'UID', None)
refdes = str(getattr(component, 'Refdes', '') or '').strip()
identities = _SNAPSHOT_REFERENCE_KEYS.get().get(refdes.casefold(), ())
if len(identities) == 1:
return identities[0][0]
if identities:
matches = [uid for uid, transform in identities if transform and _same_unit(component, transform)]
if len(matches) != 1:
raise ValueError('Snapshot physical unit association is missing or ambiguous')
return matches[0]
try:
value = getattr(component, 'UID', None)
except Exception:
value = None
uid = '' if value is None else str(value).strip()
if uid:
return uid
refdes = str(getattr(component, 'Refdes', '') or '').strip()
if not refdes:
raise ValueError("Component UID and Refdes are empty; cannot safely identify the target")
return '@REFDES|' + refdes
def _same_unit(component, transform):
point = component.GetLocation()
return (abs(float(point.X) - float(transform[0])) <= 10
and abs(float(point.Y) - float(transform[1])) <= 10
and float(component.Orientation) == float(transform[2])
and float(component.Scale) == float(transform[3]))
def check_active_context(app, metadata):
from .cad_identity import verify_application, project_file_path
verify_application(app)
@@ -418,18 +496,24 @@ def check_context(app, api, metadata, records, require_selection=True):
by_uid = {_component_uid(component): component for component in components}
if len(by_uid) != len(components):
raise ValueError("Duplicate component UID on sheet")
for record in records:
component = by_uid.get(record[1])
if component is None or str(component.Refdes).strip().casefold() != record[2].strip().casefold():
raise ValueError('Snapshot reference differs from the selected live component')
if len(metadata) == 10:
selectors = _target_selectors(metadata[9])
if set(selectors) != wanted:
selected_refs = {ref.strip().casefold() for ref, _ in selectors.values()}
if selected_refs != {record[2].strip().casefold() for record in records}:
raise ValueError("Target selector differs from snapshot components")
for uid, (refdes, old_value) in selectors.items():
component = by_uid.get(uid)
if (component is None or str(component.Refdes) != refdes or
attribute_value(component, "Part Number", required=True).casefold() != metadata[2].casefold() or
attribute_value(component, "Value") != old_value):
candidates = [component for component in components if str(component.Refdes).strip().casefold() == refdes.strip().casefold()]
if (not candidates or any(_component_uid(component) not in wanted
or attribute_value(component, "Part Number", required=True).casefold() != metadata[2].casefold()
or attribute_value(component, "Value") != old_value for component in candidates)):
raise ValueError("Selected target changed since inventory")
else:
actual = {_component_uid(component) for component in components if attribute_value(component, "Part Number", required=True).casefold() == metadata[2].casefold()}
scope = [component for component in components if _component_uid(component) in wanted] if all(row[7] == "NETLIST" for row in records) else components
actual = {_component_uid(component) for component in scope if attribute_value(component, "Part Number", required=True).casefold() == metadata[2].casefold()}
if actual != wanted:
raise ValueError(f"Source batch changed since snapshot: expected={sorted(wanted)!r} actual={sorted(actual)!r}")
if require_selection:
@@ -545,6 +629,21 @@ def select_snapshot_batch(app, api, metadata, records):
return components
def applied_replacement_uids(components, records, target):
"""Associate just the written targets while the native operation completes."""
wanted = {row[1] for row in records}
targets = {_component_uid(component): component for component in components
if _component_uid(component) in wanted}
if len(targets) != len(records):
return None
for record in records:
component = targets[record[1]]
if (str(component.Refdes).strip().casefold() != record[2].strip().casefold()
or attribute_value(component, 'Part Number', required=True).casefold() != target.casefold()):
return None
return [record[1] for record in records]
def existing_replacement_uids(components, records, target, binding, require_part_label=True):
matches = replacement_matches(components, records, target, require_part_label,
library_row=binding['library_row'])
@@ -553,7 +652,7 @@ def existing_replacement_uids(components, records, target, binding, require_part
return matches
def promote_pin_numbers(app, api, replacement_uids, slot_count=1, on_progress=None):
def promote_pin_numbers(app, api, replacement_uids, slot_count=1, on_progress=None, *, verify_pins=True):
def progress(phase):
if on_progress:
on_progress(phase)
@@ -567,6 +666,8 @@ def promote_pin_numbers(app, api, replacement_uids, slot_count=1, on_progress=No
for slot in range(1, int(slot_count) + 1):
progress(f'promote_slot_{slot}')
app.ActiveView.Block.PromoteSymbolNumbers(1, slot)
if not verify_pins:
return []
progress('query_promoted_pins')
promoted = []
for item in app.ActiveView.Query(4096, 0):
@@ -591,20 +692,26 @@ def _promotion_phase(snapshot, report, phase):
def replacement_matches(components, records, target, require_part_label, *, library_row=None):
current_by_uid = {_component_uid(component): component for component in components}
if len(current_by_uid) != len(components):
raise ValueError('Duplicate component UID on sheet')
current_by_ref = {}
for component in components:
current_by_ref.setdefault(str(component.Refdes).strip().casefold(), []).append(component)
expected_name = expected_label = None
if library_row is not None:
if (len(library_row) < 6 or str(library_row[1]).casefold() != target.casefold()
or not str(library_row[4]).strip()):
raise ValueError('Recorded target library identity is incomplete or inconsistent')
expected_name, expected_label = str(library_row[4]), str(library_row[5])
matches = []
matches, used = [], set()
for record in records:
candidate = current_by_uid.get(record[1])
if candidate is None:
raise ValueError('Native replacement lost component UID identity')
candidates = current_by_ref.get(str(record[2]).strip().casefold(), [])
if len(candidates) > 1:
candidates = [candidate for candidate in candidates if len(record) >= 7 and _same_unit(candidate, record[3:7])]
if len(candidates) != 1:
raise ValueError('Native replacement reference is missing or ambiguous')
candidate = candidates[0]
if id(candidate) in used:
raise ValueError('Duplicate physical unit association')
used.add(id(candidate))
if attribute_value(candidate, "Part Number", required=True).casefold() != target.casefold():
return None
identity = str(candidate.Refdes).strip() or f"UID={candidate.UID}"
@@ -622,7 +729,7 @@ def replacement_matches(components, records, target, require_part_label, *, libr
if expected_name is not None and (part_name != expected_name
or (expected_label and part_label != expected_label)):
raise ValueError(f'Native replacement does not match the selected target library identity; uid={candidate.UID}')
matches.append(_component_uid(candidate))
matches.append(record[1])
if len(set(matches)) != len(records):
raise ValueError("Duplicate replacement association")
return matches
@@ -651,6 +758,7 @@ def verify_replacement_readback(snapshot, components, metadata, records, before_
return verified
@_bound_snapshot_identity
def run_native(snapshot, report):
import win32api
import win32con
@@ -659,6 +767,7 @@ def run_native(snapshot, report):
from pywinauto import Desktop
metadata, records = read_snapshot(snapshot)
native_mode = saved_netlist_snapshot(snapshot)
target_cell = snapshot_target_cell(snapshot, required=False)
require_part_label = snapshot_value_mode(metadata) == "part_label"
app, api = attach()
@@ -666,7 +775,7 @@ def run_native(snapshot, report):
cell_proof = target_cell_catalog(app, snapshot, metadata, target_cell) if target_cell is not None else None
components = components_on_sheet(app, api)
wanted = {row[1] for row in records}
if len(metadata) == 10:
if len(metadata) == 10 and not native_mode:
verify_unselected_snapshot(snapshot, components, wanted, api=api)
source_uids = {
_component_uid(component)
@@ -677,6 +786,11 @@ def run_native(snapshot, report):
binding = require_resumable_transaction(snapshot, report, metadata, records)
if binding.get("cell_catalog") != cell_proof:
raise ValueError("Current Cell catalog differs from recorded native transaction")
if native_mode:
if report.get("stage") == "native_replace_applied" and report.get("pin_promotion_phase") == "promotion_complete":
report["already_replaced"] = True
return
raise ValueError("Native replacement may already have been applied; verify saved native data before continuing")
report["replaced_uids"] = existing_replacement_uids(
components, records, metadata[3], binding, require_part_label=require_part_label
)
@@ -696,7 +810,7 @@ def run_native(snapshot, report):
return
components = select_snapshot_batch(app, api, metadata, records)
before_uids = {_component_uid(component) for component in components}
untouched = None if len(metadata) == 10 else {_component_uid(component): (
untouched = None if native_mode or len(metadata) == 10 else {_component_uid(component): (
str(component.Refdes),
*(attribute_value(component, name) for name in ("Part Number", "Value", "Part Name", "Part Label"))
) for component in components if _component_uid(component) not in wanted}
@@ -854,13 +968,17 @@ def run_native(snapshot, report):
report["stage"] = "native_replace_started"
save_report(snapshot, report)
mark_snapshot_mutation(snapshot)
click(dlg_item(dialog, 1695))
from .operation_diagnostics import operation_span
with operation_span(Path(snapshot).parent, 'native_replace', item_id=Path(snapshot).stem):
click(dlg_item(dialog, 1695))
replacement_poll_count = 0
def selected_replaced():
nonlocal replacement_poll_count
replacement_poll_count += 1
if native_mode:
return applied_replacement_uids(components_on_sheet(app, api), records, metadata[3])
selected = [api.IVdComp(component._oleobj_) for component in app.ActiveView.Query(128, 1)]
if len(selected) == len(records):
matches = replacement_matches(selected, records, metadata[3], require_part_label, library_row=columns)
@@ -880,7 +998,7 @@ def run_native(snapshot, report):
# Preserve the last observed identities without retrying a mutation.
report['replacement_timeout'] = {'polls': replacement_poll_count}
try:
current = components_on_sheet(app, api)
current = [] if native_mode else components_on_sheet(app, api)
refs = {record[2] for record in records}
report['replacement_timeout'].update(
component_count=len(current),
@@ -895,16 +1013,17 @@ def run_native(snapshot, report):
except Exception as error:
report['replacement_timeout']['target_control_error'] = str(error)
raise
current = components_on_sheet(app, api)
verify_replacement_readback(snapshot, current, metadata, records, before_uids,
untouched, require_part_label, columns, report['replaced_uids'], api=api)
if not native_mode:
current = components_on_sheet(app, api)
verify_replacement_readback(snapshot, current, metadata, records, before_uids,
untouched, require_part_label, columns, report['replaced_uids'], api=api)
report["stage"] = "native_replace_applied"
save_report(snapshot, report)
report["stage"] = "pin_promotion_started"
save_report(snapshot, report)
report["promoted_pins"] = promote_pin_numbers(app, api, report["replaced_uids"], slot_count,
lambda phase: _promotion_phase(snapshot, report, phase))
report["stage"] = "native_replace_verified"
lambda phase: _promotion_phase(snapshot, report, phase), verify_pins=not native_mode)
report["stage"] = "native_replace_applied" if native_mode else "native_replace_verified"
finally:
if dialog and win32gui.IsWindow(dialog):
close_button = dlg_item(dialog, 1696)
@@ -2,7 +2,7 @@
from __future__ import annotations
import os
from collections import Counter
from collections import Counter, defaultdict
from pathlib import Path
import re
@@ -38,38 +38,45 @@ def _require_report(text, mode):
def _effective_properties(text):
from .native_netlist import _is_pcb
_require_report(text, 'FLAT BLOCKS')
if len(re.findall(r'^Config .+', text, re.MULTILINE)) != 1:
raise NativeInventoryUnsupported('展开报告必须具有唯一配置')
result, attributes, paths = {}, {}, []
inconsistent_refs = set()
symbol = None
symbol = symbol_type = None
def finish():
if symbol is None:
return
uid, ref = symbol
if not _UID.fullmatch(uid):
if attributes.get('Part Number'):
raise NativeInventoryUnsupported('展开报告的物料缺少唯一 UID')
if symbol_type is not None and not _is_pcb({'symbol': symbol_type, 'attributes': attributes}):
return
if uid in result or paths != ['']:
raise NativeInventoryUnsupported('展开报告含重复或嵌套实例,需由 CAD 核验')
uid, ref, page = symbol
if not ref:
if attributes.get('Part Number') and symbol_type and _is_pcb({'symbol': symbol_type,'attributes':attributes}):
raise NativeInventoryUnsupported('展开报告的请求物料缺少位号')
return
unit = symbol_type.split(' type ', 1)[0] if symbol_type else ''
key = (ref.strip().casefold(), page.strip(), unit)
if key in result or paths != ['']:
raise NativeInventoryUnsupported('展开报告含重复位号或嵌套实例,无法明确定位')
if ref != attributes.get('Ref Designator', ''):
inconsistent_refs.add(uid)
result[uid] = dict(attributes)
inconsistent_refs.add(key)
result[key] = (uid, dict(attributes))
if len(result) > 100000:
raise NativeInventoryUnsupported('原生器件数量超过读取上限')
for line in text.splitlines():
if line.startswith(' Symbol '):
finish()
match = re.fullmatch(r' Symbol (.+?)\tref des ([^\t]*)\tpage [^\t]*', line)
match = re.fullmatch(r' Symbol (.*?)\tref des ([^\t]*)\tpage ([^\t]*)', line)
if match is None:
raise NativeInventoryUnsupported('展开报告含不明确的器件身份')
symbol, attributes, paths = match.groups(), {}, []
symbol, attributes, paths, symbol_type = match.groups(), {}, [], None
elif symbol is not None and line.startswith('\tPath '):
paths.append(line[6:])
elif symbol is not None and line.startswith('\tSymbol name '):
symbol_type = line[13:]
elif symbol is not None:
match = _PROPERTY.fullmatch(line)
if match:
@@ -82,39 +89,61 @@ def _effective_properties(text):
def _parse_scope(text, requested, effective, inconsistent_refs):
from .native_netlist import _is_pcb
blocks, sheets, targets = set(), set(), set()
seen_uids = set()
block, symbol, attributes = '', None, {}
physical_targets = {}
by_ref = defaultdict(list)
uid_counts = Counter(uid for uid, _ in effective.values())
unit_counts = Counter(key[:2] for key in effective)
for key in effective:
by_ref[key[0]].append(key)
block, symbol, attributes, symbol_type = '', None, {}, None
def finish():
if symbol is None:
return
uid, sheet = symbol
if not _UID.fullmatch(uid):
if attributes.get('Part Number'):
raise NativeInventoryUnsupported('全工程报告中的请求物料缺少唯一身份')
if symbol_type is not None and not _is_pcb({'symbol': symbol_type, 'attributes': attributes}):
return
if uid in seen_uids or uid not in effective:
raise NativeInventoryUnsupported('分层与展开报告的 UID 不完整或重复,需由 CAD 核验')
seen_uids.add(uid)
values = effective[uid]
uid, sheet = symbol
ref = attributes.get('Ref Designator','')
if not ref:
if attributes.get('Part Number','').casefold() in requested:
raise NativeInventoryUnsupported('全工程报告中的请求物料缺少位号')
return
unit = symbol_type.split(' type ', 1)[0] if symbol_type else ''
candidates = [key for key in by_ref[ref.strip().casefold()]
if (not key[1] or key[1] == sheet.strip())
and (not key[2] or not unit or key[2] == unit)]
if len(candidates) != 1 or candidates[0] in seen_uids:
raise NativeInventoryUnsupported('分层与展开报告的器件范围不完整或位号重复')
key = candidates[0]
seen_uids.add(key)
flat_uid, values = effective[key]
if attributes.get('Part Number') and 'Part Number' not in values:
raise NativeInventoryUnsupported('展开报告缺少物料生效属性')
if 'Value' in attributes and 'Value' not in values:
raise NativeInventoryUnsupported('展开报告缺少 Value 生效属性')
if values.get('Part Number', '').casefold() in requested:
# A library reference override on an unrelated part cannot affect
# the requested identities. Still validate every UID/config/path,
# the requested identities. Still validate every reference/config/path,
# and require CAD whenever the ambiguous component is requested.
if uid in inconsistent_refs:
if key in inconsistent_refs:
raise NativeInventoryUnsupported('展开报告的位号与属性不一致')
ref, part = values.get('Ref Designator', ''), values['Part Number']
if not ref or 'Ref Designator' not in attributes:
raise NativeInventoryUnsupported('全工程报告中的请求物料缺少位号')
target = (block, sheet, uid, ref, part, values.get('Value', ''),
multiunit = unit_counts[key[:2]] > 1
identity = uid if not multiunit and _UID.fullmatch(uid) and uid == flat_uid and uid_counts[uid] == 1 else '@REFDES|' + ref
target = (block, sheet, identity, ref, part, values.get('Value', ''),
values.get('Part Label'), values.get('Cell Name'))
if target in targets:
physical_key = block, sheet, ref
prior = physical_targets.get(physical_key)
if prior and prior[3:] != target[3:]:
raise NativeInventoryUnsupported('Conflicting effective attributes across physical symbol units')
if target in targets and not multiunit:
raise NativeInventoryUnsupported('全工程报告含重复器件身份')
targets.add(target)
physical_targets[physical_key] = target
if len(targets) > 100000:
raise NativeInventoryUnsupported('原生器件数量超过读取上限')
for line in text.splitlines():
@@ -124,14 +153,16 @@ def _parse_scope(text, requested, effective, inconsistent_refs):
if not name or name in blocks:
raise NativeInventoryUnsupported('全工程报告含不明确的原理图身份')
blocks.add(name)
block, symbol, attributes = name, None, {}
block, symbol, attributes, symbol_type = name, None, {}, None
elif line.startswith(' Symbol '):
finish()
match = re.fullmatch(r' Symbol (.+?)\tpage (.+)', line)
match = re.fullmatch(r' Symbol (.*?)\tpage (.+)', line)
if not block or match is None:
raise NativeInventoryUnsupported('全工程报告含不明确的图页身份')
symbol, attributes = match.groups(), {}
symbol, attributes, symbol_type = match.groups(), {}, None
sheets.add((block, symbol[1]))
elif symbol is not None and line.startswith('\tSymbol name '):
symbol_type = line[13:]
elif symbol is not None and line.startswith('\tProp '):
# Pin properties have two tabs and must never override a component.
match = _PROPERTY.fullmatch(line)
@@ -149,49 +180,46 @@ def _parse_scope(text, requested, effective, inconsistent_refs):
def _hierarchical_root_discovery(project, report_path, effective_path, requested, expected_root):
# ComponentTarget has no instance path: certify only globally unique root selections.
from .native_netlist import _parse_ascii, _check_hierarchy_graph, _is_pcb
text = read_native_text(report_path)
roots = re.findall(r'^Block ([^\t\r\n]+)\tRoot$', text, re.MULTILINE)
root = expected_root or (roots[0].rstrip() if len(roots) == 1 else None)
try:
components, _ = _parse_ascii(effective_path, require_connections=False)
_check_hierarchy_graph(report_path, {'components': components}, root)
_, _, expanded = _check_hierarchy_graph(report_path, {'components': components}, root, include_rows=True)
except ValueError as error:
raise NativeInventoryUnsupported(str(error)) from error
physical = {uid: row for uid, row in components.items() if _is_pcb(row)}
source_uids = Counter(row.get('source_uid', uid) for uid, row in components.items())
references = Counter(row['refdes'] for row in physical.values())
scopes, sheets, block = {}, set(), None
for line in text.splitlines():
if line.startswith('Block '):
block = line[6:].split('\t', 1)[0].rstrip()
elif line.startswith(' Symbol '):
match = re.fullmatch(r' Symbol (.+?)\tpage (.+)', line)
if match is None or block is None:
raise NativeInventoryUnsupported('分层报告图页身份不明确')
scopes[(block, match[1])] = match[2]
sheets.add((block, match[2]))
targets = []
for uid, row in physical.items():
sheets = {(row['source_schematic'], row['source_page']) for row in expanded}
counts = Counter(row.get('source_uid', uid) for uid, row in components.items())
targets = {}
for scope in expanded:
row = components[scope['graph_key']]
attributes = row['attributes']
if attributes.get('Part Number', '').casefold() not in requested:
if not _is_pcb(row) or attributes.get('Part Number', '').casefold() not in requested:
continue
if row.get('instance_path') or source_uids[uid] != 1 or references[row['refdes']] != 1:
raise NativeInventoryUnsupported('请求物料含子实例或非唯一 UID/位号,当前写入选择器不能安全定位')
if 'source_refdes' in row or row.get('ambiguous_attributes'):
raise NativeInventoryUnsupported('请求物料的位号或生效属性存在歧义')
sheet = scopes.get((root, uid))
if not sheet:
raise NativeInventoryUnsupported('请求物料缺少唯一根块图页')
targets.append(ComponentTarget(Path(project), root, sheet, uid, row['refdes'],
attributes['Part Number'], attributes.get('Value', ''), attributes.get('Part Label'),
attributes.get('Cell Name')))
if not scope.get('refdes'):
raise NativeInventoryUnsupported('Hierarchical physical component is missing its reference observation')
if 'Value' in scope['attributes'] and 'Value' not in attributes:
raise NativeInventoryUnsupported('Effective physical component is missing its Value observation')
if row.get('ambiguous_attributes'):
raise NativeInventoryUnsupported('Requested physical component has ambiguous effective attributes')
source_uid = row.get('source_uid', scope['source_uid'])
identity = source_uid if (_UID.fullmatch(source_uid) and counts[source_uid] == 1
and source_uid == scope['source_uid']) else '@REFDES|' + row['refdes']
target = ComponentTarget(Path(project), scope['source_schematic'], scope['source_page'],
identity, row['refdes'], attributes['Part Number'], attributes.get('Value', ''),
attributes.get('Part Label'), attributes.get('Cell Name'))
previous = targets.get(target.key)
if previous and (previous.old_part_number, previous.old_value, previous.actual_part_label,
previous.actual_cell) != (target.old_part_number, target.old_value,
target.actual_part_label, target.actual_cell):
raise NativeInventoryUnsupported('Conflicting effective attributes across physical symbol units')
targets[target.key] = target
matches = {sheet: set() for sheet in sheets}
for target in targets:
for target in targets.values():
matches[(target.schematic_name, target.sheet_number)].add(target.old_part_number.casefold())
return ProjectDiscovery(tuple(sorted(sheets)), {key: frozenset(value) for key, value in matches.items()},
tuple(sorted(targets, key=lambda target: target.key)), complete_sheet_manifest=False)
tuple(sorted(targets.values(), key=lambda target: target.key)), complete_sheet_manifest=False)
def read_ascii_discovery(project, report_path, old_part_numbers, *, expected_root=None,
@@ -107,10 +107,11 @@ def _parse_ascii(path, *, hierarchy_boundaries=(), require_connections=True):
symbol = pin = net = conn = None
for line in text.splitlines():
if line.startswith(' Symbol '):
match = re.fullmatch(r' Symbol (.+?)\tref des ([^\t]*)\tpage [^\t]*', line)
match = re.fullmatch(r' Symbol (.*?)\tref des ([^\t]*)\tpage ([^\t]*)', line)
if not match:
raise ValueError('Invalid effective symbol identity')
symbol = {'uid': match[1], 'refdes': match[2], 'attributes': {}, 'pins': {}, 'paths': []}
symbol = {'uid': match[1], 'refdes': match[2], 'source_page': match[3].strip(),
'attributes': {}, 'pins': {}, 'paths': []}
symbols.append(symbol)
pin = None
elif symbol is not None:
@@ -155,7 +156,7 @@ def _parse_ascii(path, *, hierarchy_boundaries=(), require_connections=True):
raise ValueError('Duplicate or empty net')
expected[net] = Counter()
elif line.startswith('\t\tConn '):
match = re.fullmatch(r'\t\tConn (.+?) pin (.+?) page .*', line)
match = re.fullmatch(r'\t\tConn (.*?) pin (.+?) page .*', line)
if net is None or not match:
raise ValueError('Invalid net endpoint')
conn = match.groups()
@@ -168,12 +169,15 @@ def _parse_ascii(path, *, hierarchy_boundaries=(), require_connections=True):
conn = None
if conn is not None:
raise ValueError('Endpoint missing path')
raw_counts = Counter((row['uid'], tuple(row['paths'])) for row in symbols)
endpoint_aliases = defaultdict(list)
for symbol in symbols:
uid = symbol.pop('uid')
paths = symbol.pop('paths')
if len(paths) != 1:
raise ValueError('Symbol instance path is missing or ambiguous')
source_uid = uid
symbol['source_uid'] = source_uid
uid = _instance_identity(uid, paths[0])
attrs = symbol['attributes']
if paths[0]:
@@ -181,8 +185,16 @@ def _parse_ascii(path, *, hierarchy_boundaries=(), require_connections=True):
symbol['refdes'] = attrs.get('Ref Designator', '')
elif attrs.get('Ref Designator') and attrs['Ref Designator'] != symbol['refdes']:
symbol['source_refdes'], symbol['refdes'] = symbol['refdes'], attrs['Ref Designator']
if _is_pcb(symbol) and (not re.fullmatch(r'\$\d+I\d+', source_uid) or not symbol['refdes'] or attrs.get('Ref Designator') != symbol['refdes']):
# Port names can contain '/', so retain the reported path even at the root.
symbol['instance_path'] = '' if paths[0] == 'root' else paths[0]
if _is_pcb(symbol) and (not symbol['refdes'] or attrs.get('Ref Designator') != symbol['refdes']):
raise ValueError(f'PCB component identity is ambiguous: {uid!r} / {symbol["refdes"]!r}')
raw_identity = uid
if _is_pcb(symbol) and (not re.fullmatch(r'\$\d+I\d+', source_uid)
or raw_counts[(source_uid, tuple(paths))] > 1):
slot = re.match(r'\S+\.(\d+) type ', symbol.get('symbol', ''))
uid = _instance_identity('@REFDES|' + symbol['refdes'] + ('|slot=' + slot[1] if slot else ''), paths[0])
endpoint_aliases[raw_identity].append(uid)
symbol['other_attributes'] = sorted(symbol.get('other_attributes', []))
if uid in components:
old = components[uid]
@@ -203,6 +215,16 @@ def _parse_ascii(path, *, hierarchy_boundaries=(), require_connections=True):
for net in row['nets']:
nets[net][(uid, pin)] += 1
for name, endpoints in expected.items():
normalized = Counter()
for (uid, pin), count in endpoints.items():
candidates = [key for key in endpoint_aliases.get(uid, [uid])
if key in components and pin in components[key]['pins']
and name in components[key]['pins'][pin]['nets']]
if len(set(candidates)) == 1:
uid = candidates[0]
normalized[(uid, pin)] += count
endpoints.clear()
endpoints.update(normalized)
for (uid, port), count in list(endpoints.items()):
if uid not in hierarchy_boundaries:
continue
@@ -316,18 +338,19 @@ def read_graph(ascii_path, keyin_path, *, hierarchy_path=None, root_block=None):
return graph
def _check_hierarchy_graph(path, graph, root_block):
"""Expand native child links independently; inventory UID selectors stay root-only."""
def _check_hierarchy_graph(path, graph, root_block, *, include_rows=False):
"""Bind expanded instances by reference/page/unit while retaining raw UID evidence."""
text = read_native_text(path)
_require_report(text, 'HIER BLOCKS')
blocks, roots, block = {}, [], None
blocks, roots, block, symbol = {}, [], None, None
for line in text.splitlines():
if line.startswith('Block '):
fields = line[6:].split('\t')
block = fields[0].rstrip()
if not block or block in blocks:
raise ValueError('Duplicate or missing native hierarchy block')
blocks[block] = {'children': {}, 'symbols': Counter()}
blocks[block] = {'children': {}, 'symbols': Counter(), 'rows': []}
symbol = None
if fields[1:] == ['Root']:
roots.append(block)
elif line.startswith('\tChild '):
@@ -336,13 +359,23 @@ def _check_hierarchy_graph(path, graph, root_block):
raise ValueError('Ambiguous native hierarchy child')
blocks[block]['children'][match[2]] = match[1]
elif line.startswith(' Symbol '):
match = re.fullmatch(r' Symbol (.+?)\tpage (.+)', line)
match = re.fullmatch(r' Symbol (.*?)\tpage (.+)', line)
if block is None or match is None:
raise ValueError('Ambiguous native hierarchy symbol')
blocks[block]['symbols'][match[1]] += 1
symbol = {'source_uid': match[1], 'source_page': match[2], 'attributes': {}}
blocks[block]['rows'].append(symbol)
elif symbol is not None and line.startswith('\tProp Ref Designator '):
symbol['refdes'] = line[len('\tProp Ref Designator '):]
elif symbol is not None and line.startswith('\tProp Part Number '):
symbol['attributes']['Part Number'] = line[len('\tProp Part Number '):]
elif symbol is not None and (line == '\tProp Value' or line.startswith('\tProp Value ')):
symbol['attributes']['Value'] = line[len('\tProp Value '):]
elif symbol is not None and line.startswith('\tSymbol name '):
symbol['symbol'] = line[len('\tSymbol name '):]
if roots != [root_block]:
raise ValueError('Native hierarchy root differs from captured project')
identities, boundaries = Counter(), set()
identities, boundaries, expanded, source_sheets = Counter(), set(), [], set()
pending = [(root_block, '', set())]
while pending:
@@ -352,6 +385,11 @@ def _check_hierarchy_graph(path, graph, root_block):
row = blocks[name]
identities.update({_instance_identity(uid, path): count for uid, count in row['symbols'].items()
if uid not in row['children']})
for item in row['rows']:
source_sheets.add((name, item['source_page']))
if item['source_uid'] in row['children'] and not _is_pcb(item):
continue
expanded.append(dict(item, instance_path=path, source_schematic=name))
for uid, child in row['children'].items():
if uid not in row['symbols']:
raise ValueError('Native hierarchy child symbol missing')
@@ -359,10 +397,41 @@ def _check_hierarchy_graph(path, graph, root_block):
boundaries.add(identity)
pending.append((child, identity, ancestors | {name}))
if graph is not None:
effective = Counter({uid: len(row.get('annotation_instances', [row])) for uid, row in graph['components'].items()})
if identities != effective:
remaining = [(uid, item) for uid, row in graph['components'].items()
for item in row.get('annotation_instances', [row])]
indices, consumed = defaultdict(list), set()
for index, (uid, row) in enumerate(remaining):
instance = row.get('instance_path', uid.rsplit('/', 1)[0] if '/' in uid else '')
ref = row.get('source_refdes', row.get('refdes', '')).strip().casefold()
indices[(instance, 'ref', ref)].append(index)
indices[(instance, 'uid', row.get('source_uid', uid.rsplit('/', 1)[-1]))].append(index)
for item in expanded:
ref = item.get('refdes', '').strip().casefold()
key = item['instance_path'], 'ref' if ref else 'uid', ref or item['source_uid']
candidates = [(index, remaining[index][0], remaining[index][1]) for index in indices[key]
if index not in consumed and (not remaining[index][1].get('source_page')
or remaining[index][1]['source_page'] == item['source_page'])]
if len(candidates) > 1 and item.get('symbol'):
unit = item['symbol'].split(' type ', 1)[0]
candidates = [candidate for candidate in candidates if candidate[2].get('symbol', '').split(' type ', 1)[0] == unit]
if len(candidates) > 1:
exact = [candidate for candidate in candidates if candidate[2].get('source_uid') == item['source_uid']]
if exact:
candidates = exact
# Identical nonphysical annotations are counted, not mistaken for devices.
if not candidates or (len(candidates) > 1 and ref):
raise ValueError('Hierarchical/effective instance coverage differs')
index, uid, row = candidates[0]
item['graph_key'] = uid
if row:
row['source_schematic'] = item['source_schematic']
row['source_page'] = row.get('source_page') or item['source_page']
consumed.add(index)
if len(consumed) != len(remaining):
raise ValueError('Hierarchical/effective instance coverage differs')
return identities, boundaries
# A page may contain only a child block absent from the flat component graph.
graph['source_sheets'] = [list(sheet) for sheet in sorted(source_sheets)]
return (identities, boundaries, expanded) if include_rows else (identities, boundaries)
def export_netlist(capture: dict, output: Path, *, stop_event=None) -> dict:
@@ -466,6 +535,80 @@ def _connections(graph):
return sorted(nets)
def reference_targets(graph, refdes, *, sheet='', schematic=''):
"""Return every native unit for a physical reference within the requested sheet."""
ref = refdes.strip().casefold()
candidates = [(uid, row) for uid, row in graph['components'].items()
if _is_pcb(row) and row.get('refdes', '').strip().casefold() == ref]
pages_known = any(row.get('source_page') for _, row in candidates)
blocks_known = any(row.get('source_schematic') for _, row in candidates)
return tuple(uid for uid, row in candidates
if (not sheet or not pages_known or row.get('source_page') == sheet)
and (not schematic or not blocks_known or row.get('source_schematic') == schematic))
def _reference_graph(graph):
"""Normalize physical endpoints without changing the captured source evidence."""
from copy import deepcopy
result = deepcopy(graph)
identities, components = {}, {}
groups = defaultdict(list)
for row in result['components'].values():
if _is_pcb(row):
groups[row.get('refdes', '').strip().casefold()].append(row)
for uid, row in result['components'].items():
if _is_pcb(row):
ref = row.get('refdes', '').strip().casefold()
if not ref:
raise ValueError('Physical component has no reference designator')
# Separate slots of the same physical device remain independently checked.
peers = groups[ref]
scopes = {(item.get('source_schematic', ''), item.get('source_page', '')) for item in peers}
scope = (row.get('source_schematic', ''), row.get('source_page', ''))
same_scope = sum((item.get('source_schematic', ''), item.get('source_page', '')) == scope for item in peers)
slot = re.match(r'\S+\.(\d+) type ', row.get('symbol', ''))
identity = '@REFDES|' + ref
if len(scopes) > 1:
identity += '|sheet=' + json.dumps(scope, ensure_ascii=False)
if same_scope > 1 and slot:
repeated_slot = sum(bool(re.match(r'\S+\.' + re.escape(slot[1]) + r' type ', item.get('symbol', '')))
for item in peers if (item.get('source_schematic', ''), item.get('source_page', '')) == scope) > 1
if repeated_slot:
numbers = [pin.get('number') for pin in row.get('pins', {}).values()]
if not numbers or any(not number for number in numbers):
raise ValueError('Repeated symbol slots lack a unique physical pin partition')
identity += '|pins=' + json.dumps(sorted(numbers), ensure_ascii=False)
else:
identity += '|slot=' + slot[1]
row.pop('source_uid', None)
row.pop('instance_path', None)
else:
identity = uid
if identity in components:
raise ValueError('Reference designator and symbol slot are ambiguous')
identities[uid] = identity
components[identity] = row
result['components'] = components
for net in result['nets']:
net['endpoints'] = [[identities.get(uid, uid), pin] for uid, pin in net['endpoints']]
return result, identities
def _reference_expectations(graph, aliases, values):
result = {}
for uid, value in (values or {}).items():
targets = (uid,) if uid in aliases else ()
if not targets and uid.startswith('@REFDES|'):
targets = reference_targets(graph, uid[len('@REFDES|'):])
scopes = {(graph['components'][key].get('source_schematic', ''),
graph['components'][key].get('source_page', '')) for key in targets}
if len(scopes) > 1:
raise ValueError('Expected reference requires a sheet-qualified native identity')
for target in targets or (uid,):
result[aliases.get(target, target)] = value
return result
def compare_netlists(before: dict, after: dict, *, expected_changes=None, expected_symbols=None) -> dict:
"""Compare complete nonempty exports, allowing only declared attribute/symbol changes.
@@ -476,7 +619,13 @@ def compare_netlists(before: dict, after: dict, *, expected_changes=None, expect
graph = result.get('graph', {})
if result.get('status') != 'success' or result.get('complete') is not True or not graph.get('components') or not graph.get('nets'):
return {'status': 'unavailable', 'verified': False, 'reason': 'Complete nonempty native graphs required'}
left, right = before['graph'], after['graph']
try:
left, aliases = _reference_graph(before['graph'])
right, _ = _reference_graph(after['graph'])
expected_changes = _reference_expectations(before['graph'], aliases, expected_changes)
expected_symbols = _reference_expectations(before['graph'], aliases, expected_symbols)
except (KeyError, TypeError, ValueError) as error:
return {'status': 'unavailable', 'verified': False, 'reason': str(error)}
differences = []
try:
connections_changed = _connections(left) != _connections(right)
@@ -1,5 +1,5 @@
"""Overlap native exports with replacement, keeping each saved input immutable."""
from concurrent.futures import ThreadPoolExecutor
from concurrent.futures import Future, ThreadPoolExecutor
from dataclasses import asdict
import json
import hashlib
@@ -54,7 +54,7 @@ def library_from_receipt(command, receipt):
if receipt.get('native_state') not in {'saved_ok', 'restored_ok'}:
return {}
from .execution_proof import proof_intact
from .native_helper import read_snapshot, require_resumable_transaction
from .native_helper import read_snapshot, require_resumable_transaction, saved_netlist_snapshot
from .path_access import canonical_path, internal_path
proof = receipt.get('proof', {})
native_files = [Path(item['path']) for item in proof.get('files', ())
@@ -70,13 +70,18 @@ def library_from_receipt(command, receipt):
if str(snapshot) not in paths:
raise ValueError('原生库件证据缺少配套快照')
report = json.loads(internal_path(path).read_text(encoding='utf-8'))
if report.get('ok') is not True or report.get('stage') != 'native_replace_verified':
saved_native = saved_netlist_snapshot(snapshot)
if saved_native and proof.get('saved_netlist', proof.get('project_commit', {}).get('saved_netlist', {})).get('status') != 'verified':
raise ValueError('已保存的原生数据尚未核验,不能使用写入回执声明成功')
stage = 'native_replace_applied' if saved_native else 'native_replace_verified'
if report.get('ok') is not True or report.get('stage') != stage:
raise ValueError('原生库件回执未通过实际替换核验')
metadata, records = read_snapshot(snapshot)
binding = require_resumable_transaction(snapshot, report, metadata, records)
if (canonical_path(metadata[1]) != canonical_path(command['project_path'])
or metadata[2:4] != [command['old_part'], command['new_part']]
or metadata[4] != f"{command['schematic_name']}:{command['sheet_number']}"):
or metadata[4] != f"{command['schematic_name']}:{command['sheet_number']}"
or (metadata[9] if len(metadata) == 10 else '') != command.get('target_selectors', '')):
raise ValueError('原生库件证据属于不同执行项')
row = binding['library_row']
if row[1].casefold() != command['new_part'].casefold() or not row[4]:
@@ -95,12 +100,16 @@ def library_from_receipt(command, receipt):
raise ValueError('Value 回读证据的器件范围不完整')
for uid in binding['source_uids']:
identity = {'attributes': {'Part Number': row[1], 'Part Name': row[4], 'Part Label': row[5]},
'target_symbol': binding['target_symbol'], 'slot_count': binding['slot_count']}
'target_symbol': binding['target_symbol'], 'slot_count': binding['slot_count'],
'refdes': next(record[2] for record in records if record[1] == uid),
'schematic_name': command.get('schematic_name',''), 'sheet_number': command.get('sheet_number','')}
if uid in values:
value = values[uid]
native_empty = (saved_native and value['actual_value'] == '' and value['actual_value_present'] is None
and value.get('value_presence_coverage') == 'native_ascii_empty_presence_unknown')
if (value['actual_part_number'].casefold() != row[1].casefold()
or not isinstance(value['actual_value'], str)
or type(value['actual_value_present']) is not bool):
or (type(value['actual_value_present']) is not bool and not native_empty)):
raise ValueError('Value 回读证据与目标库件不符')
identity.update(preserved_value=value['actual_value'],
preserved_value_present=value['actual_value_present'])
@@ -180,30 +189,86 @@ def _rule_rows(child, task_id, plan, before):
if not identities:
raise ValueError('规则替换缺少绑定实际 sheet/UID 的原生事务证据')
if selector is not None:
original = before['graph']['components'].get(selector[0], {})
if (set(identities) != {selector[0]} or original.get('refdes') != selector[1]
or original.get('attributes', {}).get('Value', '') != selector[2]):
keys = native_netlist.reference_targets(before['graph'], selector[1],
sheet=command.get('sheet_number',''),schematic=command.get('schematic_name',''))
if ((set(identities) != {selector[0]} and not all(
identity.get('refdes','').strip().casefold() == selector[1].strip().casefold()
for identity in identities.values())) or not keys or any(
before['graph']['components'][key].get('attributes', {}).get('Value', '') != selector[2]
for key in keys)):
raise ValueError('规则位号选择器与替换前器件及原生 UID 范围不一致')
scopes.append({key: command.get(key, '') for key in
('project_path', 'schematic_name', 'sheet_number', 'old_part', 'new_part')}
| {'source_uids': sorted(identities)})
for uid in identities:
component = before['graph']['components'].get(uid)
if component is None or component['attributes'].get('Part Number', '').casefold() != command['old_part'].casefold():
identity = identities[uid]
keys = _reference_keys(before['graph'], dict(identity, uid=uid,
sheet_number=command.get('sheet_number',''), schematic_name=command.get('schematic_name','')))
if not keys or any(before['graph']['components'][key]['attributes'].get('Part Number', '').casefold()
!= command['old_part'].casefold() for key in keys):
raise ValueError('原生 UID 无法唯一对应替换前的原料号;不能按同料号猜测图页')
row = {'enabled': True, 'target': {'uid': uid, 'old_value': component['attributes'].get('Value', '')},
for key in keys:
component = before['graph']['components'][key]
row = {'enabled': True, 'target': {'uid': key, 'refdes': component['refdes'],
'schematic_name':command.get('schematic_name',''),'sheet_number':command.get('sheet_number',''),
'old_value': component['attributes'].get('Value', '')},
'new_part_number': command['new_part'], 'value_mode': command['value_mode'],
'custom_value_enabled': command['value_mode'] == 'custom',
'custom_value': command.get('custom_value', ''), 'sync_nc': command.get('sync_nc', '1') == '1',
'target_cell': command.get('target_cell', '')}
if uid in rows and rows[uid] != row:
raise ValueError('同一 UID 对应多个不同规则结果,不能独立核验')
rows[uid] = row
if key in rows and rows[key] != row:
raise ValueError('同一位号对应多个不同规则结果,不能独立核验')
rows[key] = row
if not rows:
raise ValueError('已保存的规则替换缺少可核验的原生 UID 事务')
return list(rows.values()), scopes
def _reference_keys(graph, identity):
ref = identity.get('refdes', '').strip().casefold()
keys = native_netlist.reference_targets(graph, ref, sheet=identity.get('sheet_number',''),
schematic=identity.get('schematic_name','')) if ref else ()
uid = identity.get('uid')
if not keys and uid in graph['components']:
component = graph['components'][uid]
constraints = ((ref, component.get('refdes','').strip().casefold()),
(identity.get('sheet_number',''), component.get('source_page','')),
(identity.get('schematic_name',''), component.get('source_schematic','')))
if not any(expected and actual and expected != actual for expected, actual in constraints):
keys = (uid,)
return keys
def _reference_plan(plan, before, library):
from copy import deepcopy
result, rebound = deepcopy(plan), {}
graph = before['graph']
rows, plan_keys = [], {}
for row in result['rows']:
target = row['target']
keys = _reference_keys(graph, target)
if not keys and row['enabled']:
raise ValueError('独立网表无法定位计划中的位号')
plan_keys[target['uid']] = keys
for key in keys:
item = deepcopy(row)
item['target']['uid'] = key
rows.append(item)
for uid, identity in library.items():
keys = _reference_keys(graph, dict(identity, uid=uid))
if not keys and not identity.get('refdes'):
keys = plan_keys.get(uid, ())
if not keys:
raise ValueError('独立网表无法定位回执中的位号或图页')
exact = tuple(key for key in keys if key == uid or graph['components'][key].get('source_uid') == uid)
for key in exact or keys:
if key in rebound and rebound[key] != identity:
raise ValueError('独立网表无法区分同一位号的原生单元回执')
rebound[key] = identity
result['rows'] = rows
return result, rebound
class NetlistVerification:
def __init__(self, root, run_id, stop_event):
self.root, self.run_id, self.stop = Path(root), run_id, stop_event
@@ -305,6 +370,18 @@ class NetlistVerification:
return
try:
record['library'] = _library_expectations(record['child'], task_id)
preparer = getattr(record['child'], '_quick_run_preparer', None)
if preparer is not None:
from .saved_netlist_verification import load_saved_export
saved = load_saved_export(preparer.data_root / 'quick-run',
Path(record['before_capture']['project']))
if saved is not None:
exported = Future()
exported.set_result(saved['result'])
record.update(after_capture=saved['capture'],
after_export=Path(saved['export_path']).parent,
after=exported)
return
directory = record['directory']
attempt = uuid4().hex
capture = native_netlist.capture_project(Path(record['before_capture']['project']),
@@ -398,6 +475,7 @@ class NetlistVerification:
rows, scopes = _rule_rows(record['child'], task_id, plan, before)
plan = dict(plan, rows=rows)
result['rule_scopes'] = scopes
plan, library = _reference_plan(plan, before, library)
expected = self._expected(plan, after, library)
symbols = {uid: {key: item[key] for key in ('target_symbol', 'slot_count')}
for uid, item in library.items() if uid in expected}
@@ -0,0 +1,64 @@
"""Small append-only call timeline; diagnostics never replace an execution error."""
from datetime import datetime, timezone
from contextlib import contextmanager
import json
import os
from .path_access import internal_path
def record_operation(root, operation, event, *, item_id='', error=''):
if event not in {'enter', 'return', 'error'}:
raise ValueError('operation event must be enter, return or error')
try:
record = {'timestamp_utc': datetime.now(timezone.utc).isoformat(),
'operation': operation, 'event': event, 'item_id': item_id}
if error:
record['error'] = str(error)
line = json.dumps(record, ensure_ascii=False) + '\n'
path = internal_path(root) / 'operation-events.jsonl'
path.parent.mkdir(parents=True, exist_ok=True)
with path.open('a', encoding='utf-8') as stream:
stream.write(line)
stream.flush()
os.fsync(stream.fileno())
return True
except Exception:
return False
@contextmanager
def operation_span(root, operation, *, item_id=''):
"""Trace a real call without letting diagnostics change its outcome."""
def publish(event, error=''):
try:
record_operation(root, operation, event, item_id=item_id, error=error)
except Exception:
pass
publish('enter')
try:
yield
except BaseException as error:
publish('error', error)
raise
else:
publish('return')
def summarize_operations(records):
active, errors, last_item = {}, [], None
for record in records:
if not isinstance(record, dict) or not all(isinstance(record.get(name, ''), str)
for name in ('operation', 'item_id', 'event')):
continue
key = record.get('operation'), record.get('item_id', '')
if record.get('event') == 'enter':
active[key] = record
elif record.get('event') in {'return', 'error'}:
active.pop(key, None)
if record['event'] == 'error':
errors.append(record)
elif record.get('operation') == 'item' and record.get('item_id'):
last_item = record['item_id']
return {'last_successful_item': last_item, 'incomplete_operations': list(active.values()),
'errors': errors}
@@ -0,0 +1,159 @@
"""Keep uncertain engineering sources quarantined without stopping unrelated work."""
from pathlib import Path
import json
import re
from .path_access import canonical_path, internal_path
def write_sources(project):
project = canonical_path(project)
sources = {str(project).casefold()}
try:
from .native_inventory_protocol import read_native_text
text = read_native_text(internal_path(project))
match = re.search(r'^\s*KEY\s+iCDBDir\s+"([^"\r\n]+)"', text, re.MULTILINE | re.IGNORECASE)
if match:
directory = Path(match[1])
if not directory.is_absolute():
directory = project.parent / directory
sources.add(str(canonical_path(directory / 'icdb.dat')).casefold())
except (OSError, UnicodeError, ValueError):
pass
return sources
def record_task_outcome(child, task_id, state, message):
store = getattr(child, '_store', None)
if store is None:
return
from .models import TaskStatus
target = {'blocked': TaskStatus.BLOCKED, 'failed': TaskStatus.FAILED, 'paused': TaskStatus.PAUSED}.get(state)
if target is None:
return # Successful completion is committed with its actual execution receipts.
with store.transaction():
task = store.get_task(task_id)
if task.status not in {TaskStatus.COMPLETED, TaskStatus.DELETED}:
store.set_task_status(task_id, target, summary=message)
def isolate_project(runtime, child, task_id, error):
release = getattr(runtime, 'release_failed_project', None)
if release is None:
return False
preparer = getattr(child, '_quick_run_preparer', None)
root = preparer.data_root / 'quick-run' if preparer is not None else runtime.root / 'tasks' / task_id / 'quick-run'
released = release(error, root)
return released
def dependency_path(root, task_id):
return canonical_path(root) / 'dependency-blocks' / (task_id + '.json')
def dependency_block(root, task_id):
from .errors import TaskCenterError
try:
value = json.loads(internal_path(dependency_path(root, task_id)).read_text(encoding='utf-8'))
if (not isinstance(value, dict) or value.get('version') != 1 or value.get('task_id') != task_id or value.get('undispatched') is not True
or value.get('state') not in {'blocked', 'readmission_prepared', 'readmitted'}
or not isinstance(value.get('dependency_task_id'), str)
or Path(value['dependency_task_id']).name != value['dependency_task_id']
or not isinstance(value.get('sources'), list) or not value['sources']
or not all(isinstance(source, str) and Path(source).is_absolute() for source in value['sources'])
or not isinstance(value.get('plan_hash'), str) or not re.fullmatch('[0-9a-f]{64}', value['plan_hash'])
or not isinstance(value.get('queue_id'), str) or not re.fullmatch('[0-9a-f]{32}', value['queue_id'])
or not isinstance(value.get('project_path'), str) or not Path(value['project_path']).is_absolute()):
raise ValueError('invalid dependency block')
return value
except FileNotFoundError:
return None
except (OSError, ValueError, TypeError) as error:
raise TaskCenterError('quick_run_dependency', '共享数据源隔离记录无法核验,请保留证据。') from error
def block_dependency(root, child, task_id, dependency_task_id, sources, plan_hash, queue_id):
from .batch_resources import write_record
projects = child.projects(task_id)
write_record(dependency_path(root, task_id), {'version': 1, 'task_id': task_id,
'dependency_task_id': dependency_task_id, 'sources': sorted(sources), 'plan_hash': plan_hash,
'project_path': str(canonical_path(projects[0].path)).casefold(),
'queue_id': queue_id, 'state': 'blocked', 'undispatched': True})
record_task_outcome(child, task_id, 'blocked', f'共享数据源依赖 {dependency_task_id} 尚待核验;本任务未派发替换。')
def _validate_dependency(service, task_id, block):
from .batch_resources import resource_blockers
from .errors import TaskCenterError
from .models import TaskStatus
from .task_queue import _plan_hash
child = service.for_project_task(task_id)
dependency = service.for_project_task(block['dependency_task_id'])
projects = child.projects(task_id)
dependency_projects = dependency.projects(block['dependency_task_id'])
queue_path = next((path for directory in ('task-queues', 'workspace-queues')
if internal_path(path := canonical_path(service._logging.root) / directory / (block['queue_id'] + '.json')).is_file()), None)
try:
queue = json.loads(internal_path(queue_path).read_text(encoding='utf-8')) if queue_path else {}
queue_bound = (queue['plan_hashes'][task_id] == block['plan_hash']
and queue['dependency_tasks'][task_id] == block['dependency_task_id']
and queue['entries'][task_id]['state'] == 'blocked')
except (OSError, ValueError, TypeError, KeyError):
queue_bound = False
store = getattr(child, '_store', None)
with store._lock:
dispatched = store._connection.execute('''SELECT 1 FROM execution_operations o
JOIN execution_rounds r ON r.task_id=o.task_id AND r.round_id=o.round_id
WHERE o.task_id=? AND (o.attempt_id IS NOT NULL OR o.generation>0 OR o.state!='pending') LIMIT 1''',
(task_id,)).fetchone()
evidence = child._quick_run_preparer.data_root / 'quick-run'
absent_attempt = not dispatched and not any(internal_path(evidence).glob('snapshot-*'))
if (len(projects) != 1 or len(dependency_projects) != 1
or not queue_bound or not absent_attempt
or str(canonical_path(projects[0].path)).casefold() != block['project_path']
or _plan_hash(child, task_id) != block['plan_hash']
or not set(block['sources']) <= write_sources(projects[0].path) & write_sources(dependency_projects[0].path)
or child.has_interrupted_quick_run(task_id)
or dependency.has_interrupted_quick_run(block['dependency_task_id'])
or dependency.get_task(block['dependency_task_id']).status not in {TaskStatus.READY, TaskStatus.COMPLETED}
or resource_blockers(service.pending_batch_resources())):
raise TaskCenterError('quick_run_dependency', '原依赖工程尚未核验、写入资源未退出或冻结计划已变化,不能解除隔离。')
def recover_dependency(service, task_id, *, confirmed):
from .batch_resources import write_record
from .errors import TaskCenterError
from .models import TaskStatus
from .quick_run_protocol import QuickRunStepResult
root = service._logging.root
block = dependency_block(root, task_id)
if not confirmed:
raise TaskCenterError('quick_run_dependency', '请确认核验共享数据源依赖后解除未派发任务的隔离。')
_validate_dependency(service, task_id, block)
path = dependency_path(root, task_id)
write_record(path, dict(block, state='readmission_prepared'))
with service._store.transaction():
task = service._store.get_task(task_id)
if task.status is TaskStatus.BLOCKED:
service._store.set_task_status(task_id, TaskStatus.READY, summary='共享数据源依赖已核验;原计划未派发,可重新确认执行。')
elif task.status not in {TaskStatus.READY, TaskStatus.COMPLETED}:
raise TaskCenterError('quick_run_dependency', '当前任务状态已变化,请重新读取隔离记录。')
write_record(path, dict(block, state='readmitted'))
child = service.for_project_task(task_id)
progress = child.quick_run_progress(task_id)
handoff = child._quick_run_preparer.data_root / 'quick-run'
return QuickRunStepResult(handoff / 'QuickPartReplace.vbs', handoff / 'command.tsv', handoff / 'status.tsv', path,
'pending', '共享数据源依赖已核验;本任务从未派发替换,已恢复原待执行计划。',
progress.next_project_path, progress.next_old_part_number, progress.next_new_part_number,
progress.next_schematic_name, progress.next_sheet_number, progress)
def dependency_readmitted(service, task_id, plan_hash):
from .models import TaskStatus
block = dependency_block(service._logging.root, task_id)
if not block or block['state'] not in {'readmission_prepared', 'readmitted'} or block['plan_hash'] != plan_hash:
return False
if service.get_task(task_id).status not in {TaskStatus.READY, TaskStatus.COMPLETED}:
return False
_validate_dependency(service, task_id, block)
return True
@@ -2,12 +2,14 @@
from __future__ import annotations
from pathlib import Path
import json
import subprocess
import time
from threading import Event, Thread
from uuid import uuid4
from .worker_monitor import WorkerMonitorError, run_monitored_process
from .operation_diagnostics import operation_span
def _write_control(path: Path, value: str):
@@ -28,7 +30,7 @@ def _write_control(path: Path, value: str):
class ProjectSessionWorker:
"""Only a saved-and-reopened checkpoint releases the caller for its next step.
"""Retain applied steps; engineering close performs the save/readback commit.
The VBS worker owns CAD. This driver never attaches to COM or terminates CAD.
A separate monitor thread retains the existing idle watchdog and worker job.
@@ -61,6 +63,10 @@ class ProjectSessionWorker:
self._done.set()
def run_step(self, command: tuple[str, ...], timeout: float):
with operation_span(self.root, 'native_step', item_id=command[-1]):
return self._run_step(command, timeout)
def _run_step(self, command: tuple[str, ...], timeout: float):
if self._closed:
raise WorkerMonitorError('project session is already closed')
if Path(command[3]).resolve() != self.root.resolve():
@@ -82,6 +88,7 @@ class ProjectSessionWorker:
if not self._waiting:
raise WorkerMonitorError('project session has no verified checkpoint')
self._waiting = False
_write_control(self.root / 'project-session.request', f'{self.token}\t{self.project}\t{job}')
_write_control(self.root / 'project-session-next.tsv', f'{self.token}\t{job}')
while True:
if self._done.is_set():
@@ -92,8 +99,8 @@ class ProjectSessionWorker:
raise self._error
if self._result.returncode == 0:
raise WorkerMonitorError('project session exited before authorized closing')
if self._result.returncode == 74:
pause = getattr(self._result, 'startup_pause', {})
if self._result.returncode in {74, 75}:
pause = getattr(self._result, 'startup_pause' if self._result.returncode == 74 else 'prewrite_pause', {})
if (pause.get('session_token') != self.token or pause.get('job_id') != job
or Path(pause.get('project_path', '')).resolve() != self.project.resolve()
or pause.get('worker_tree_exited') is not True):
@@ -110,13 +117,20 @@ class ProjectSessionWorker:
except (FileNotFoundError, PermissionError):
fields = ()
if len(fields) == 4 and fields[:2] == [self.token, job]:
if fields[2] not in {'saved_ok', 'no_match'} or fields[3] != 'session_verified':
if (fields[2], fields[3]) not in {('saved_ok', 'session_verified'), ('no_match', 'session_verified'),
('pending_save', 'session_staged'), ('pending_save', 'session_staged_no_match')}:
raise WorkerMonitorError('project session returned an invalid checkpoint')
self._waiting = True
return subprocess.CompletedProcess(command, 0, '', '')
self._done.wait(0.025)
def close(self):
if not self._closed and self._thread is not None and not self._done.is_set():
with operation_span(self.root, 'close_project', item_id=self.token):
return self._close()
return self._close()
def _close(self):
if self._closed:
return
try:
@@ -128,25 +142,33 @@ class ProjectSessionWorker:
from .stop_control import StopControl
interactive = isinstance(getattr(self.runtime, 'stop_event', None), StopControl)
close_grace = 60 if self.private_desktop else min(30, max(10, self._timeout))
if interactive:
# A failed close has its own deadline, separate from pause.
force_event = getattr(getattr(self.runtime, 'stop_event', None), 'force_event', None)
last_notice = time.monotonic()
deadline = last_notice + close_grace
while not self._done.wait(.1):
if force_event is not None and force_event.is_set():
self._abort.set()
break
if time.monotonic() >= deadline:
force_event = getattr(getattr(self.runtime, 'stop_event', None), 'force_event', None)
last_notice = time.monotonic()
deadline = last_notice + close_grace
last_progress = (-1, -1)
while not self._done.wait(.1):
if force_event is not None and force_event.is_set():
self._abort.set()
break
try:
native = json.loads((self.root / 'worker-progress.json').read_text(encoding='utf-8'))
progress = (native['sequence'], native.get('native_progress_frames', 0))
if all(type(value) is int for value in progress) and progress > last_progress:
last_progress = progress
deadline = time.monotonic() + close_grace
except (OSError, ValueError, KeyError, TypeError):
pass
if time.monotonic() >= deadline:
if interactive:
self.runtime.stop_event.request_failure_cleanup(self.root,
'project session did not acknowledge closing within its grace period')
self._abort.set()
break
if time.monotonic() - last_notice >= 15:
import logging
logging.getLogger(__name__).warning(
'project_session_awaiting_close token=%s', self.token)
last_notice = time.monotonic()
self._abort.set()
break
if time.monotonic() - last_notice >= 15:
import logging
logging.getLogger(__name__).warning(
'project_session_awaiting_close token=%s', self.token)
last_notice = time.monotonic()
if not self._done.wait(close_grace):
self._abort.set()
if not self._done.wait(30):
@@ -174,6 +196,7 @@ class ProjectSessionScope:
self.worker = None
self.private_desktop = private_desktop
self.runtime = runtime
self.on_commit = None
def __enter__(self):
return self
@@ -189,13 +212,25 @@ class ProjectSessionScope:
def prepare(self, project):
if self.worker is not None and (self.worker.project.resolve() != Path(project).resolve()
or self.worker._done.is_set()):
self.worker.close()
self.worker = None
self.close()
def close(self):
if self.worker is None:return
worker = self.worker
worker.close()
if self.on_commit is not None:
self.on_commit(worker)
self.on_commit = None
self.worker = None
def __exit__(self, error_type, error, traceback):
if self.worker is not None:
try:
self.worker.close()
except Exception:
self.close()
except Exception as cleanup_error:
self.worker._abort.set()
if error is not None:
if hasattr(error, 'add_note'):
error.add_note('Project session cleanup: ' + str(cleanup_error))
return False
raise
@@ -373,24 +373,289 @@ class QuickRunPreparer:
if journal is None or not journal.needs_reconciliation(task_id):
return
root = self._data_root/'quick-run'
flag = root/'uncertain.flag'
if _io_path(flag).exists():
raise TaskCenterError('quick_run_uncertain', '工程已保留待核验保护,请先核验原执行证据。')
from .handoff_guard import assert_handoff_intact
assert_handoff_intact(root, task_id)
try:
self._commit_staged_project(task_id)
self._bind_journal_handoff(task_id, QuickRunResult(root/'QuickPartReplace.vbs',
root/'command.tsv', root/'status.tsv', root/'quick-part-replace.log', self.vbs_root_compatible))
except TaskCenterError:
_write_uncertain_flag(root/'uncertain.flag','uncommitted_receipt_requires_verification')
raise
except (OSError, ValueError, KeyError, TypeError) as error:
_write_uncertain_flag(flag, 'uncommitted_receipt_requires_verification')
if isinstance(error, TaskCenterError):
raise
raise TaskCenterError('quick_run_uncertain', '无法核验原工程提交回执;请保留执行证据。') from error
def result_proof(self, root, row, outcome, *, persist=True):
def result_proof(self, root, row, outcome, *, persist=True, project_commit=None):
from .execution_proof import capture_result
return capture_result(self._data_root,root,row,outcome,
strict=self._process_runner is _run_process,persist=persist)
strict=self._process_runner is _run_process,persist=persist,project_commit=project_commit)
def _commit_staged_project(self, task_id, *, session_token=None, bind_source=False):
journal = getattr(self, 'journal', None)
if journal is None:return
from .execution_proof import capture_project_commit, validate_project_commit_source
from .operation_diagnostics import record_operation
for commit in journal.pending_project_commits(task_id):
if session_token is not None and commit['session_token'] != session_token:continue
root = Path(commit['evidence_root'])
record_operation(root, 'readback_proof', 'enter', item_id=commit['session_token'])
try:
marker = capture_project_commit(self._data_root, root, commit)
saved_protocol = marker.get('validation_required') == 'saved_netlist_v1'
persisted = json.loads(commit['proof_json']) if commit.get('proof_json') else None
commit_proof = dict(persisted or marker)
if persisted:
if ((saved_protocol or commit_proof.get('saved_sources'))
and not validate_project_commit_source(commit_proof, root)
or marker['files'][0]['sha256'] != commit_proof['files'][0]['sha256']):
raise ValueError('saved project proof changed before receipt commit')
elif saved_protocol and not bind_source:
commit_proof, _ = self._closed_project_commit_proof(root, commit)
if (not validate_project_commit_source(commit_proof, root)
or marker['files'][0]['sha256'] != commit_proof['files'][0]['sha256']
or commit_proof.get('native_outcomes') != marker['native_outcomes']):
raise ValueError('saved project proof changed after native closure')
elif bind_source:
if _io_path(root/'uncertain.flag').exists():
raise TaskCenterError('quick_run_uncertain', '工程已保留待核验保护,不能重新绑定保存源。')
from .execution_proof import bind_project_commit_source
commit_proof = bind_project_commit_source(commit_proof, self._data_root, root, commit['project_path'])
attempts = journal.project_commit_attempts(task_id, commit['session_token'])
if commit_proof.get('operation_attempts', attempts) != attempts:
raise ValueError('original project attempts changed')
commit_proof['operation_attempts'] = attempts
staged = journal.staged_project_rows(task_id, commit['session_token'])
if saved_protocol:
from .saved_netlist_verification import verify_saved_project
for receipt in staged:
for item in receipt['proof'].get('files', ()):
name = Path(item['path']).name
if hashlib.sha256(_io_path(root/name).read_bytes()).hexdigest() != item['sha256']:
raise ValueError('staged native target evidence changed before saved export')
if bind_source and not persisted:
names = [name for job, state in commit_proof['native_outcomes'].items() if state == 'pending_save'
for name in (f'snapshot-{job}.tsv', f'snapshot-{job}.tsv.native.json', f'writer-expectations-{job}.tsv')]
commit_proof['readback_files'] = {name:hashlib.sha256(_io_path(root/name).read_bytes()).hexdigest() for name in names}
journal.bind_project_commit_proof(task_id, commit['session_token'], commit_proof)
before_validation = persisted or commit_proof
commit_proof = verify_saved_project(self._data_root, root, commit_proof, [receipt['row'] for receipt in staged])
journal.promote_project_commit_proof(task_id, commit['session_token'], before_validation, commit_proof)
proofs = {}
for receipt in staged:
row = receipt['row']
outcome = (commit_proof['outcomes'][row['job_id']], 'project_committed',
'工程统一保存,原生数据核验通过。' if saved_protocol else '工程保存回读校验通过。')
proof = self.result_proof(root, row, outcome, project_commit=commit_proof) if saved_protocol else self.result_proof(root,row,outcome)
if outcome[0] == 'saved_ok':
from .value_readback import capture_value_readback
proof['value_readback'] = capture_value_readback(root, row, outcome, project_commit=commit_proof)
proofs[row['job_id']] = proof
if bind_source and not commit.get('proof_json') and not saved_protocol:
commit_proof['readback_files'] = {Path(item['path']).name: item['sha256']
for proof in proofs.values() for item in proof.get('files', ())}
for job, outcome in commit_proof['outcomes'].items():
if outcome == 'saved_ok':
value_path = _io_path(root / f'value-readback-{job}.tsv')
if value_path.is_file():commit_proof['readback_files'][value_path.name] = hashlib.sha256(value_path.read_bytes()).hexdigest()
journal.bind_project_commit_proof(task_id, commit['session_token'], commit_proof)
statuses = journal.commit_project_results(task_id, commit['session_token'], proofs, commit_proof)
if saved_protocol and statuses:
_append_status_details(root/'status.tsv', statuses)
record_operation(root, 'readback_proof', 'return', item_id=commit['session_token'])
for job in commit_proof['jobs']:
record_operation(root, 'item', 'return', item_id=job)
except Exception as error:
record_operation(root, 'readback_proof', 'error', item_id=commit['session_token'], error=str(error))
raise
def _closed_project_commit_proof(self, root, commit):
from .batch_resources import _valid_record
checkpoint = json.loads(_io_path(root / 'project-checkpoint.json').read_text(encoding='utf-8'))
owner_path = Path(checkpoint['resource_record'])
owner = json.loads(_io_path(owner_path).read_text(encoding='utf-8'))
proof = checkpoint['project_commit_source']
native = {key: checkpoint[key] for key in ('session_id', 'generation', 'attempt_id')}
if (not _valid_record(owner, owner_path) or checkpoint.get('worker_closed') is not True
or checkpoint.get('project_closed') is not True
or Path(checkpoint['evidence_root']).resolve() != root.resolve()
or _path_key(checkpoint['project_path']) != _path_key(commit['project_path'])
or owner['session_id'] != native['session_id'] or owner['generation'] != native['generation']
or owner['checkpoints'].get(str(root.resolve()).casefold()) != native['attempt_id']
or proof.get('native_attempt') != native or proof.get('session_token') != commit['session_token']
or proof.get('jobs') != json.loads(commit['jobs_json'])):
raise ValueError('native close checkpoint is not bound to this project commit')
return proof, owner_path
def recover_project_commit(self, task_id, *, confirmed=False):
"""Reconcile an already closed/saved project without acquiring CAD."""
journal = getattr(self, 'journal', None)
if journal is None:return None
commits = journal.project_commit_records(task_id)
root = self._data_root / 'quick-run'
flag = _io_path(root / 'uncertain.flag')
audit = root / 'project-commit-recovery.json'
if not commits:return None
protection = flag.read_bytes() if flag.is_file() else None
allowed = {f'reason={reason}; manual reconciliation required\n'.encode() for reason in
('receipt_commit_failed', 'project_commit_unverified', 'uncommitted_receipt_requires_verification')}
interrupted = None
if protection is not None:
import re
match = re.fullmatch(rb'reason=supervisor_interrupted; batch=([0-9a-f]{32}); manual reconciliation required\r?\n', protection)
if match:interrupted = match[1].decode('ascii')
if protection is None:
try:
completed = json.loads(_io_path(audit).read_text(encoding='utf-8'))
if (completed.get('task_id') != task_id or completed.get('native_replacement_called') is not False
or completed.get('session_tokens') != [commit['session_token'] for commit in commits]):return None
except (OSError, ValueError, TypeError):return None
elif protection not in allowed and interrupted is None:return None
if not confirmed:
raise TaskCenterError('quick_run_recovery_confirmation', '工程提交回执核验需要明确确认。')
from .execution_proof import capture_project_commit, validate_project_commit_source, proof_intact
from .execution_journal import read_command_rows, command_identity, _hash
from .batch_resources import write_record
try:
rows = read_command_rows(root / 'command.tsv')
if not rows or any(row['task_id'] != task_id for row in rows):raise ValueError('foreign command plan')
current = journal._round(task_id)
if json.loads(current['plan_json']) != [_hash(command_identity(row)) for row in rows]:
raise ValueError('frozen command plan changed')
positions = {row['job_id']:index for index,row in enumerate(rows)}
markers = {commit['session_token']:capture_project_commit(self._data_root,root,commit) for commit in commits}
ends = {token:max(positions[job] for job in marker['jobs']) for token,marker in markers.items()}
latest = {}
for commit in commits:
token = commit['session_token']
if markers[token].get('validation_required') == 'saved_netlist_v1':
latest[commit['project_path']] = max(latest.get(commit['project_path'],-1),ends[token])
historical = set()
def historical_intact(proof):
saved = proof['saved_netlist']
verified = json.loads(_io_path(saved['verification_path']).read_text(encoding='utf-8'))
context = {key:proof[key] for key in ('session_token','project_path','saved_sources','command_sha256')}
context['marker_sha256'] = proof['files'][0]['sha256']
return (proof_intact(proof) and saved.get('status') == 'verified'
and proof['command_sha256'] == hashlib.sha256(_io_path(root/'command.tsv').read_bytes()).hexdigest()
and hashlib.sha256(_io_path(saved['verification_path']).read_bytes()).hexdigest() == saved['verification_sha256']
and hashlib.sha256(_io_path(saved['export_path']).read_bytes()).hexdigest() == saved['export_sha256']
and verified.get('status') == 'verified' and verified.get('context') == context
and verified.get('export_path') == saved['export_path'] and verified.get('export_sha256') == saved['export_sha256']
and verified.get('jobs') == saved.get('jobs') and set(saved['jobs']) == set(proof['jobs'])
and proof['outcomes'] == {job:'saved_ok' if state == 'pending_save' else state
for job,state in proof['native_outcomes'].items()})
covered = set()
covered_attempts = []
for commit in commits:
if Path(commit['evidence_root']).resolve() != root.resolve():raise ValueError('foreign commit root')
proof = json.loads(commit['proof_json'] or '{}')
prior = (commit['state'] == 'verified' and proof.get('validation_required') == 'saved_netlist_v1'
and ends[commit['session_token']] < latest.get(commit['project_path'],-1))
if prior:historical.add(commit['session_token'])
if proof:
attempts = journal.project_commit_attempts(task_id, commit['session_token'], require_recorded=True)
if (proof.get('operation_attempts', attempts) != attempts
or set(attempts) != set(proof['jobs'])):
raise ValueError('original project attempts changed')
proof.setdefault('operation_attempts', attempts)
if not proof or interrupted is not None and not prior:
proof, owner_path = self._closed_project_commit_proof(root, commit)
if interrupted is not None:
supervisor = json.loads(_io_path(owner_path.parent / 'supervisor.json').read_text(encoding='utf-8'))
if (proof['native_attempt']['session_id'] != interrupted or supervisor.get('batch_id') != interrupted
or supervisor.get('state') != 'blocked' or supervisor.get('business_uncertain') is not True
or task_id not in supervisor.get('protected_task_ids', ())):
raise ValueError('supervisor interruption is not bound to the closed native worker')
proof = dict(proof, operation_attempts=journal.project_commit_attempts(task_id, commit['session_token']))
if (not (historical_intact(proof) if prior else validate_project_commit_source(proof, root))
or proof.get('operation_attempts') != journal.project_commit_attempts(task_id, commit['session_token'])):
raise ValueError('saved source or original attempts changed')
marker = markers[commit['session_token']]
if (marker['jobs'] != proof.get('jobs') or marker['outcomes'] != proof.get('native_outcomes',proof.get('outcomes'))
or marker['files'][0]['sha256'] != proof['files'][0]['sha256']):
raise ValueError('native project marker changed')
covered.update(proof['jobs'])
covered_attempts.extend(proof['operation_attempts'].values())
for row in rows:
if row['job_id'] not in proof['jobs']:continue
saved_protocol = proof.get('validation_required') == 'saved_netlist_v1'
state = proof.get('native_outcomes',proof['outcomes'])[row['job_id']] if saved_protocol else proof['outcomes'][row['job_id']]
if saved_protocol and state == 'no_match':continue
outcome = (state, 'session_staged' if saved_protocol else 'project_committed', '工程保存回读校验通过。')
result = self.result_proof(root, row, outcome)
if proof.get('native_attempt') and outcome[0] in {'saved_ok','pending_save'} and any(
result.get('native_attempt', {}).get(key) != value for key, value in proof['native_attempt'].items()):
raise ValueError('native result differs from the exited project worker')
if any(proof.get('readback_files', {}).get(Path(item['path']).name) != item['sha256'] for item in result.get('files', ())):
raise ValueError('saved native readback evidence changed')
if outcome[0] == 'saved_ok' and not saved_protocol:
from .value_readback import capture_value_readback
if capture_value_readback(root, row, outcome, project_commit=proof).get('value_readback_status') != 'verified':
raise ValueError('saved target Value readback is incomplete')
if any(Path(name).name != name or hashlib.sha256(_io_path(root / name).read_bytes()).hexdigest() != digest
for name, digest in proof.get('readback_files', {}).items()):
raise ValueError('native/readback files changed since project closure')
if not commit.get('proof_json'):
journal.bind_project_commit_proof(task_id, commit['session_token'], proof)
commit['proof_json'] = json.dumps(proof)
if (not set(journal.unresolved_jobs(task_id, rows)) <= covered
or any(attempt not in covered_attempts for attempt in journal.project_commit_recovery_attempts(task_id))):
raise ValueError('another native attempt is unresolved')
# SQL/history may already have committed before a publication failure.
self._commit_staged_project(task_id)
for commit in commits:
proof = json.loads(commit['proof_json'])
if not (historical_intact(proof) if commit['session_token'] in historical else validate_project_commit_source(proof, root)):
raise ValueError('saved source or historical proof changed during recovery')
handoff = QuickRunResult(root/'QuickPartReplace.vbs', root/'command.tsv', root/'status.tsv', root/'quick-part-replace.log', self.vbs_root_compatible)
self._bind_journal_handoff(task_id, handoff)
if protection is not None:
if flag.read_bytes() != protection:raise ValueError('protection reason changed')
write_record(audit, {'task_id': task_id, 'session_tokens': [commit['session_token'] for commit in commits],
'native_replacement_called': False, 'original_protection_sha256': hashlib.sha256(protection).hexdigest()})
flag.replace(root / 'project-commit-resolved-uncertain.flag')
details = _read_status_details(root / 'status.tsv')
projects = tuple(project for project in journal.store.list_projects(task_id) if project.selected and project.available)
progress = _progress_from_queue(projects, _read_commands(root/'command.tsv'), details, _read_command_sheet_targets(root/'command.tsv'))
return QuickRunStepResult(handoff.script_path, handoff.command_path, handoff.status_path, audit,
'saved_ok', '完整工程保存回读证明已恢复原回执;未启动 CAD 或重复替换。', progress.next_project_path,
progress.next_old_part_number, progress.next_new_part_number, progress.next_schematic_name, progress.next_sheet_number, progress)
except (OSError, ValueError, KeyError, TypeError) as error:
raise TaskCenterError('quick_run_uncertain', '工程提交证明、保存源或原尝试无法核验,保护记录保持。') from error
def complete_project_session(self, task_id, scope, session, projects):
"""Close the retained owner before exposing saved progress to the queue."""
from .operation_diagnostics import record_operation
worker = scope.worker
if worker is not None:
record_operation(worker.root, 'save', 'enter', item_id=worker.token)
try:
scope.close()
record_operation(worker.root, 'save', 'return', item_id=worker.token)
except Exception as error:
record_operation(worker.root, 'save', 'error', item_id=worker.token, error=str(error))
_write_uncertain_flag(worker.root / 'uncertain.flag', 'project_commit_unverified')
raise
if session is not None:
appended, offset, identity, stamp = _read_appended_status_details(session)
session.statuses += appended
session.status_offset, session.status_identity, session.status_stamp = offset, identity, stamp
session.latest = {job: (state, code) for job, state, code, _ in session.statuses}
session.next_index = _next_unfinished_index(session.commands, session.latest)
session.progress = _progress_from_queue(tuple(project for project in projects if project.selected and project.available),
session.commands, session.statuses, session.sheets)
session.completed_project_keys = {_path_key(path) for path in session.progress.completed_project_paths}
return session.progress
def write_expected_baselines(self, task_id, root, project_path):
journal=getattr(self,'journal',None)
if journal is None:return
rows=journal.expected_baselines(task_id,project_path)
rows=tuple(row for row in journal.expected_baselines(task_id,project_path)
if row.get('validation_mode') != 'saved_netlist_v1')
text='project_path\tschematic_name\tsheet_number\tsemantic_state\r\n'
text+=''.join('\t'.join(_encode_vbs_field(row[key]) for key in
('project_path','schematic_name','sheet_number','state'))+'\r\n' for row in rows)
@@ -403,7 +668,8 @@ class QuickRunPreparer:
from .worker_monitor import WorkerMonitorError
try:
with ProjectSessionScope(self._process_runner,
enabled=enabled and self._process_runner is _run_process, private_desktop=True, runtime=runtime) as scope:
enabled=enabled and self._process_runner is _run_process and getattr(self, 'journal', None) is not None,
private_desktop=True, runtime=runtime) as scope:
yield scope
except (WorkerMonitorError, subprocess.TimeoutExpired) as error:
_write_uncertain_flag(self._data_root / 'quick-run/uncertain.flag', 'project_session_cleanup')
@@ -428,6 +694,31 @@ class QuickRunPreparer:
uncertain_path = self._data_root / "quick-run" / "uncertain.flag"
if _io_path(uncertain_path).exists():
raise TaskCenterError("quick_run_uncertain", "a previous quick-run worker timed out or returned an uncorrelated status; reconcile the project before retrying")
if (self._process_runner is _run_process and getattr(self,'journal',None) is not None
and (project_session is None or not project_session.enabled)):
if not batch_mode:
from .single_step import prepare_private_single_step
prepare_private_single_step(self,task_id,projects,rules,copy_part_number_to_value,
**({'runtime':runtime} if runtime is not None else {}))
session = batch_session or self.begin_batch_session(task_id,projects,rules,
copy_part_number_to_value=copy_part_number_to_value,runtime=runtime)
if session.next_index >= len(session.commands):
raise TaskCenterError('quick_run_complete','all replacement rules in this queue are complete')
job = session.commands[session.next_index][1]
# A standalone or explicitly nonretained call still needs one closed,
# saved native prefix. The scope is held for this invocation only.
with self.project_session_scope(enabled=True,runtime=runtime) as scope:
result = self.execute_step(task_id,projects,rules,copy_part_number_to_value=copy_part_number_to_value,
expected_item=expected_item,batch_mode=True,batch_session=session,project_session=scope,
runtime=runtime,stop_event=stop_event)
if result.state == 'pending_save':
self.complete_project_session(task_id,scope,session,projects)
if result.state not in DONE_STATES | {'pending_save'}:return result
terminal = next(entry for entry in reversed(session.statuses) if entry[0] == job)
progress = session.progress
return QuickRunStepResult(result.script_path,result.command_path,result.status_path,result.log_path,
terminal[1],terminal[3],progress.next_project_path,progress.next_old_part_number,
progress.next_new_part_number,progress.next_schematic_name,progress.next_sheet_number,progress)
if self._process_runner is _run_process and not batch_mode:
from .single_step import prepare_private_single_step
prepare_private_single_step(self, task_id, projects, rules, copy_part_number_to_value,
@@ -636,6 +927,56 @@ class QuickRunPreparer:
_write_uncertain_flag(uncertain_path, "malformed_status_after_worker")
_append_log(handoff.log_path, "quick_run_uncertain malformed_status_after_worker")
raise TaskCenterError("quick_run_uncertain", "quick-run worker left an unreadable status; reconcile the project before retrying") from error
if completed.returncode == 75:
if project_session is not None:
project_session.on_commit = None
if _io_path(uncertain_path).exists():
raise TaskCenterError('quick_run_uncertain', '工程已保留待核验保护,请先核验原执行证据。')
prefix_commit_pending = False
try:
proof = getattr(completed, 'prewrite_pause', {})
pause_token = proof.get('session_token', '')
marker = _io_path(handoff.command_path.parent / f'project-pause-{pause_token}.tsv')
fields = marker.read_text(encoding='utf-8-sig').strip().split('\t')
status_bytes = _io_path(handoff.status_path).read_bytes()
if (runtime is None or journal_attempt is None or project_session is None
or project_session.worker is None or pause_token != project_session.worker.token
or proof.get('phase') != 'before_native_dispatch'
or proof.get('session_id') != runtime.session_id or proof.get('generation') != runtime.generation
or proof.get('attempt_id') != runtime.record.get('active_attempt')
or proof.get('resource_record') != str(runtime.path)
or len(fields) != 4 or fields[0] != pause_token or fields[2:] != [row['job_id'], 'prewrite_closed']
or _path_key(_decode_vbs_field(fields[1])) != _path_key(row['project_path'])
or proof.get('request_sha256') != hashlib.sha256(
_io_path(handoff.command_path.with_name('project-session.request')).read_bytes()).hexdigest()
or proof.get('current_command_sha256') != hashlib.sha256(
_io_path(handoff.command_path.with_name('current-command.tsv')).read_bytes()).hexdigest()
or proof.get('status_sha256') != hashlib.sha256(status_bytes).hexdigest()
or any(entry[0] == row['job_id'] and entry[1] in TERMINAL_STATES for entry in after)
or not ((stop_event is not None and stop_event.is_set())
or (runtime.stop_event is not None and runtime.stop_event.is_set()))):
raise ValueError('prewrite pause is not bound to the retained owner')
journal.pause_before_dispatch(journal_attempt, row, dict(proof, status_size=len(status_bytes)))
journal.finalize_startup_pause(task_id, handoff.command_path.parent)
_append_status_details(handoff.status_path, (
(row['job_id'], 'pending', 'prewrite_paused', '工程安全关闭;当前项确认未替换,保留待执行。'),))
if proof.get('committed_prefix'):
# Confirmed recovery can publish the prefix if the process
# stops after committing SQL but before appending status.
_write_uncertain_flag(uncertain_path, 'project_commit_unverified')
prefix_commit_pending = True
self._commit_staged_project(task_id, session_token=pause_token)
if not any(commit['session_token'] == pause_token and commit['state'] == 'verified'
and set(json.loads(commit['jobs_json'])) == set(proof['committed_prefix'])
for commit in journal.project_commit_records(task_id)):
raise ValueError('certified prewrite prefix has no matching verified receipt')
_io_path(uncertain_path).unlink()
except Exception as error:
if not prefix_commit_pending:
_write_uncertain_flag(uncertain_path, 'unproven_prewrite_pause')
raise TaskCenterError('quick_run_uncertain', '暂停缺少完整的未写入与工程关闭证明;保留保护并核验。') from error
_append_log(handoff.log_path, 'quick_run_paused prewrite_closed')
raise TaskCenterError('operation_cancelled', '工程已安全关闭,已暂存前缀完成保存回读;当前项保留待执行。')
if completed.returncode == 74:
try:
proof = getattr(completed, 'startup_pause', {})
@@ -771,7 +1112,8 @@ class QuickRunPreparer:
_append_log(handoff.log_path, "quick_run_uncertain native_failure_after_snapshot")
raise TaskCenterError("quick_run_uncertain", detail)
raise TaskCenterError("quick_run_execution", detail)
if state not in TERMINAL_STATES:
if state not in TERMINAL_STATES and not (state == 'pending_save' and project_session is not None
and project_session.enabled and code in {'session_staged', 'session_staged_no_match'}):
raise TaskCenterError("quick_run_execution", f"unexpected quick-run state: {state}")
if batch_mode and state == "saved_ok":
try:
@@ -804,6 +1146,23 @@ class QuickRunPreparer:
progress = _progress_from_queue(tuple(project for project in projects if project.selected and project.available),
commands, after, _read_command_sheet_targets(handoff.command_path))
try:
if state == 'pending_save':
proof = self.result_proof(handoff.command_path.parent, row, (state, code, message))
journal.stage_project_result(journal_attempt, row, session_token=project_session.worker.token,
root=handoff.command_path.parent, proof=proof)
project_session.on_commit = lambda worker: self._commit_staged_project(task_id, session_token=worker.token, bind_source=True)
if (next_command is None or _path_key(next_command[2]) != _path_key(row['project_path'])
or (stop_event is not None and stop_event.is_set())):
progress = self.complete_project_session(task_id, project_session, batch_session, projects)
state = 'no_match' if code == 'session_staged_no_match' else 'saved_ok'
message = ('工程统一保存,原生数据核验通过。' if proof.get('validation_required') == 'saved_netlist_v1'
else '工程统一保存、关闭重开及回读校验通过。')
next_command = commands[batch_session.next_index] if batch_session is not None and batch_session.next_index < len(commands) else None
next_sheet = batch_session.sheets.get(next_command[1], (None, None)) if batch_session is not None and next_command is not None and batch_session.sheets is not None else (None, None)
return QuickRunStepResult(handoff.script_path, handoff.command_path, handoff.status_path, handoff.log_path,
state, message, Path(next_command[2]) if next_command is not None else None,
next_command[3] if next_command is not None else None, next_command[4] if next_command is not None else None,
next_sheet[0], next_sheet[1], progress)
verified_source_health = None
if (state in {'saved_ok', 'restored_ok', 'no_match'} and self._process_runner is _run_process
and journal.failure_health_references(task_id, row['project_path'])):
@@ -1196,9 +1555,21 @@ def _advance_batch_session(
current_index = session.next_index
current = session.commands[current_index]
job_id, state, code, _ = changed
if job_id != current[1] or state not in TERMINAL_STATES:
if job_id != current[1] or state not in TERMINAL_STATES | {'pending_save'}:
raise TaskCenterError("quick_run_queue_progress", "batch result does not complete the expected queue item")
session.latest[job_id] = (state, code)
if state == 'pending_save':
from dataclasses import replace
next_index = current_index + 1
while next_index < len(session.commands) and session.latest.get(session.commands[next_index][1], ('', ''))[0] in TERMINAL_STATES | {'pending_save'}:
next_index += 1
session.next_index = next_index
next_command = session.commands[next_index] if next_index < len(session.commands) else None
next_sheet = session.sheets.get(next_command[1], (None, None)) if session.sheets is not None and next_command is not None else (None, None)
session.progress = replace(session.progress, next_project_path=Path(next_command[2]) if next_command else None,
next_old_part_number=next_command[3] if next_command else None, next_new_part_number=next_command[4] if next_command else None,
next_schematic_name=next_sheet[0], next_sheet_number=next_sheet[1], queue_complete=False)
return
current_key = session.project_keys_by_index[current_index]
partial_failures = {
_path_key(path): (path, summary)
@@ -1512,6 +1883,22 @@ def _recover_pre_mutation_hard_failures(
)
def _append_status_details(path: Path, statuses: tuple[tuple[str, str, str, str], ...]) -> None:
"""Publish closed-project receipts without replacing an active batch stream."""
payload = ''.join('\t'.join(_encode_vbs_field(field) for field in entry)+'\r\n' for entry in statuses).encode('utf-8')
try:
with _io_path(path).open('r+b') as stream:
stream.seek(0,os.SEEK_END)
end = stream.tell()
if end:
stream.seek(-1,os.SEEK_END)
if stream.read(1) != b'\n':raise ValueError('cannot append to an incomplete status stream')
stream.seek(0,os.SEEK_END)
stream.write(payload);stream.flush();os.fsync(stream.fileno())
except (OSError,ValueError) as error:
raise TaskCenterError('quick_run_status','cannot publish saved project status') from error
def _write_status_details(path: Path, statuses: tuple[tuple[str, str, str, str], ...]) -> None:
temporary = path.with_name(f".{path.name}.{uuid4().hex}.tmp")
text = "job_id\tstate\tcode\tmessage\r\n"
@@ -2074,10 +2461,12 @@ def _correlated_status_change(
job_id = appended[0][0]
prior_state = next((state for status_job_id, state, _, _ in reversed(before) if status_job_id == job_id), None)
transitions = {
None: {"awaiting_native_replace", "hard_failure", "batch_failed", "batch_saved_unverified", "no_match"},
None: {"awaiting_native_replace", "hard_failure", "batch_failed", "batch_saved_unverified", "no_match", "pending_save"},
"pending": {"awaiting_native_replace", "hard_failure", "batch_failed", "batch_saved_unverified", "no_match", "pending_save"},
"awaiting_native_replace": {
"restored_ok",
"saved_ok",
"pending_save",
"hard_failure",
"batch_failed",
"batch_saved_unverified",
@@ -0,0 +1,328 @@
"""Validate a closed project's applied targets through one saved native export."""
import hashlib
import json
import re
from collections import Counter
from pathlib import Path
from . import native_netlist
from .batch_resources import write_record
from .execution_proof import proof_intact, validate_project_commit_source
from .path_access import canonical_path, internal_path
from .quick_run_protocol import _decode_vbs_field
def _hash(path):
return hashlib.sha256(internal_path(path).read_bytes()).hexdigest()
def _fields(line):
return [_decode_vbs_field(value) for value in line.split('\t')]
def _context(proof):
return {key: proof[key] for key in ('session_token', 'project_path', 'saved_sources', 'command_sha256')}
def _intact(record):
return (record.get('files') and proof_intact(record)
and _saved_sources_intact(record['context']['saved_sources'])
and _hash(record['export_path']) == record['export_sha256'])
def _saved_sources_intact(sources):
return bool(sources) and all(_hash(path) == digest for path, digest in sources.items())
def _read_export_pointer(root):
try:
record = json.loads(internal_path(root / 'saved-netlist-export.json').read_text(encoding='utf-8'))
except FileNotFoundError:
return None
if not isinstance(record, dict) or record.get('status') not in {'exported', 'verified'}:
raise ValueError('invalid saved native export lookup')
return record
def _authoritative_export(record):
"""The mutable lookup record cannot supply graph data or captured inputs."""
result = json.loads(internal_path(record['export_path']).read_text(encoding='utf-8'))
capture = result['capture']
source_hashes = {str(canonical_path(path)).casefold():digest for path,digest in capture['source_hashes'].items()}
if (result.get('status') != 'success' or result.get('complete') is not True
or canonical_path(capture['project']) != canonical_path(record['context']['project_path'])
or any(source_hashes.get(str(canonical_path(path)).casefold()) != digest
for path,digest in record['context']['saved_sources'].items())
or set(result['outputs'].values()) != set(record['output_hashes'])
or any(_hash(path) != record['output_hashes'][path] for path in result['outputs'].values())):
raise ValueError('immutable saved native export differs from its original source binding')
native_netlist._check_capture(capture)
return result
def load_saved_export(root, project):
"""Return a verified intact shared export for the current saved source, or None."""
root = Path(root)
try:
record = _read_export_pointer(root)
if record is None or record['status'] == 'exported':
return None
context = record['context']
if (canonical_path(context['project_path']) != canonical_path(project)
or context['command_sha256'] != _hash(root / 'command.tsv')):
return None
if _hash(record['verification_path']) != record['verification_sha256']:
raise ValueError('immutable saved target verification changed')
verified = json.loads(internal_path(record['verification_path']).read_text(encoding='utf-8'))
if any(verified[key] != record[key] for key in ('status', 'context', 'export_path', 'export_sha256')):
raise ValueError('saved target lookup differs from its immutable verification')
if not context['saved_sources']:
raise ValueError('saved source hashes are missing')
if not _saved_sources_intact(context['saved_sources']):
return None
marker = root / f'project-commit-{context["session_token"]}.tsv'
if _hash(marker) != context['marker_sha256'] or not _intact(record):
raise ValueError('saved marker or export artifacts changed')
record['jobs'] = verified['jobs']
record['result'] = _authoritative_export(record)
record['capture'] = record['result']['capture']
return record
except (OSError, ValueError, KeyError, TypeError, AttributeError) as error:
raise ValueError(f'saved native export integrity check failed: {error}') from error
def compact_saved_netlist(record, *, include_jobs=True):
result = {key: record[key] for key in ('status', 'export_path', 'export_sha256')}
result.update(verification_path=record['verification_path'], verification_sha256=record['verification_sha256'])
if include_jobs:
result.update(context=record['context'], jobs=record['jobs'], files=record['files'])
return result
def _expectations(root, row):
from .execution_proof import capture_result
from .native_helper import read_snapshot, require_resumable_transaction, saved_netlist_snapshot
snapshot = internal_path(root / f'snapshot-{row["job_id"]}.tsv')
if not saved_netlist_snapshot(snapshot):raise ValueError('saved netlist target snapshot protocol required')
# This validates the command, selected original target set and native attempt.
capture_result(root.parent, root, row, ('pending_save', 'session_staged', ''), strict=True, persist=False)
metadata, components = read_snapshot(snapshot)
report_path = Path(str(snapshot) + '.native.json')
report = json.loads(report_path.read_text(encoding='utf-8'))
binding = require_resumable_transaction(snapshot, report, metadata, components)
library = binding['library_row']
if library[1].casefold() != row['new_part'].casefold():raise ValueError('native library target changed')
writer = internal_path(root / f'writer-expectations-{row["job_id"]}.tsv')
records = [_fields(line) for line in writer.read_text(encoding='utf-8-sig').splitlines() if line]
header = ['W', '1', row['task_id'], row['job_id'], row['project_path'],
row.get('schematic_name',''), row.get('sheet_number',''), snapshot.read_bytes().decode('utf-8-sig')]
if not records or records[0] != header:raise ValueError('writer expectations are not bound to the original snapshot and command')
original = {item[1]: item[2] for item in components}
if row.get('target_scope') == 'targets':
selectors = [value.split('\x1f') for value in row.get('target_selectors','').split('\x1e')]
if (not selectors or any(len(value) != 3 or not value[1].strip() for value in selectors)
or {value[1].strip().casefold() for value in selectors} != {ref.strip().casefold() for ref in original.values()}):
raise ValueError('native snapshot reference set differs from the frozen target selectors')
old_values = {}
for line in snapshot.read_text(encoding='utf-8-sig').splitlines():
fields = _fields(line)
if fields[0] == 'A' and len(fields) == 12 and fields[2].casefold() == 'value':
if fields[1] in old_values:raise ValueError('original Value is ambiguous')
old_values[fields[1]] = fields[4] or fields[3]
has_nc = lambda text: '/' in text and any(part.strip().casefold() == 'nc' for part in text.split('/'))
expected = {}
for fields in records[1:]:
if len(fields) != 9 or fields[0] != 'C':raise ValueError('malformed writer target expectation')
_, uid, ref, value, present, name, label, part, cell = fields
if (uid not in original or uid in expected or ref != original[uid] or present not in {'0','1'}
or name != library[4] or label != library[5] or part.casefold() != row['new_part'].casefold()
or cell != row.get('target_cell','')):
raise ValueError('writer target expectation differs from native library/command')
mode = row['value_mode']
if mode != 'preserve':
policy_value = {'custom': row.get('custom_value',''), 'part_number': row['new_part'], 'part_label': library[5]}[mode]
if row.get('sync_nc','1') == '1' and has_nc(old_values.get(uid,'')) and not has_nc(policy_value):
policy_value = policy_value.rstrip(' ') + ('NC' if policy_value.rstrip(' ').endswith('/') else '/NC')
if present != '1' or value != policy_value:raise ValueError('writer Value contradicts the frozen write policy')
if row.get('sync_nc','1') == '1' and has_nc(old_values.get(uid,'')) and not has_nc(value):
raise ValueError('required original NC marker was not retained')
expected[uid] = dict(refdes=ref, value=value, present=present == '1', old_value=old_values.get(uid),
attributes={'Part Number': part, 'Part Name': name, 'Part Label': label}, target_cell=cell)
if set(expected) != set(original):raise ValueError('writer target set is incomplete')
return expected, binding, [snapshot, report_path, writer]
def _scope(component, row):
return all(not row.get(key) or component.get(field) == row[key]
for key, field in (('schematic_name','source_schematic'), ('sheet_number','source_page')))
def _verify_no_match(graph, row):
components = graph['components']
if row.get('target_scope') == 'targets':
selectors = [item.split('\x1f') for item in row.get('target_selectors', '').split('\x1e')]
if any(len(item) != 3 or not item[1].strip() for item in selectors):
raise ValueError('saved native no-match coverage lacks valid frozen target selectors')
for _, ref, _ in selectors:
keys = native_netlist.reference_targets(graph, ref, sheet=row.get('sheet_number', ''),
schematic=row.get('schematic_name', ''))
if not keys or any(not _scope(components[key], row) for key in keys):
raise ValueError(f'saved native no-match coverage lacks selected reference {ref}')
# A frozen selector can return no_match only through already_target in the writer.
if any(components[key]['attributes'].get('Part Number', '').casefold() != row['new_part'].casefold()
for key in keys):
raise ValueError(f'saved native no-match Part Number differs from the target for {ref}')
return
candidates = [item for component in components.values()
for item in component.get('annotation_instances', [component]) if _scope(item, row)]
if not candidates and [row['schematic_name'], row['sheet_number']] not in graph.get('source_sheets', ()):
raise ValueError('saved native no-match coverage lacks the frozen schematic or sheet')
if any(item['attributes'].get('Part Number', '').casefold() == row['old_part'].casefold() for item in candidates):
raise ValueError('native no-match claim still has original targets in the saved scope')
def _observations(graph, row, expected, binding):
observations = []
counts = Counter(item['refdes'].strip().casefold() for item in expected.values())
remaining = {}
for uid, item in expected.items():
ref = item['refdes'].strip().casefold()
if ref not in remaining:
keys = native_netlist.reference_targets(graph, item['refdes'],
sheet=row.get('sheet_number',''), schematic=row.get('schematic_name',''))
if len(keys) != counts[ref] or not keys:
raise ValueError('saved native target units are missing or ambiguous')
if any(not _scope(graph['components'][key],row) or graph['components'][key].get('ambiguous_attributes') for key in keys):
raise ValueError('saved native target sheet or attributes are ambiguous')
remaining[ref] = list(keys)
# Match the declared multiset within one physical reference. Native UIDs
# may change; no expected property is inferred from the exported graph.
matches = []
for key in remaining[ref]:
attrs = graph['components'][key]['attributes']
if (all(attrs.get(name) is not None and
(attrs[name].casefold() == value.casefold() if name == 'Part Number' else attrs[name] == value)
for name,value in item['attributes'].items())
and (not item['target_cell'] or attrs.get('Cell Name') == item['target_cell'])
and attrs.get('Value','') == item['value']):
matches.append(key)
if not matches:raise ValueError('saved native target library attributes, Cell or Value differ from the write policy')
key = matches[0]
remaining[ref].remove(key)
symbol = graph['components'][key].get('symbol','')
if symbol:
target = re.fullmatch(r'(?:[^:\s]+:)?([^:\s]+?)(?:\.(\d+))?', binding['target_symbol'])
actual = re.match(r'([^\s]+?)\.(\d+) type ', symbol)
if (not target or not actual or target[1] != actual[1]
or target[2] is not None and target[2] != actual[2]
or not 1 <= int(actual[2]) <= binding['slot_count']):
raise ValueError('saved native target symbol differs from the selected library')
actual = graph['components'][key]['attributes']
observations.append(dict(uid=uid, refdes=item['refdes'], old_part_number=row['old_part'],
actual_part_number=actual['Part Number'], old_value=item['old_value'], actual_value=actual.get('Value',''),
old_value_present=item['old_value'] is not None,
actual_value_present=True if actual.get('Value') else None,
value_presence_coverage='native_ascii_empty_presence_unknown', actual_cell=actual.get('Cell Name','')))
return dict(value_readback_status='verified', value_readback=observations, value_readback_job_id=row['job_id'],
project_path=row['project_path'], schematic_name=row.get('schematic_name',''), sheet_number=row.get('sheet_number',''),
coverage_limits=['Native ASCII empty Value does not prove attribute presence; CAD display/layout is not checked.'])
def verify_saved_project(data_root, root, proof, rows, *, stop_event=None):
"""Export once, validate all applied targets, and return the verified commit proof."""
from .netlist_verification import _export_saved_capture
root, data_root = Path(root), Path(data_root)
if proof.get('validation_required') != 'saved_netlist_v1' or not validate_project_commit_source(proof, root):
raise ValueError('saved source-bound project proof is required')
outcomes = proof.get('native_outcomes', proof['outcomes'])
readbacks = proof.get('readback_files')
required = {name for job, state in outcomes.items() if state == 'pending_save'
for name in (f'snapshot-{job}.tsv', f'snapshot-{job}.tsv.native.json', f'writer-expectations-{job}.tsv')}
def readbacks_intact():
return (isinstance(readbacks, dict) and required <= readbacks.keys()
and all(Path(name).name == name and _hash(root / name) == digest
for name, digest in readbacks.items()))
if not readbacks_intact():raise ValueError('native writer evidence changed before saved export')
rows = {row['job_id']: row for row in rows}
if not set(proof['jobs']) <= rows.keys():raise ValueError('saved prefix is outside the frozen command plan')
context = _context(proof)
context['marker_sha256'] = proof['files'][0]['sha256']
evidence, inputs = {}, []
for job in proof['jobs']:
if outcomes[job] == 'pending_save':
evidence[job] = _expectations(root, rows[job])
inputs.extend(evidence[job][2])
elif not rows[job].get('schematic_name') or not rows[job].get('sheet_number'):
raise ValueError('saved native no-match coverage requires a frozen schematic and sheet')
pointer = root / 'saved-netlist-export.json'
record = None
candidate = _read_export_pointer(root)
if candidate is not None and candidate['context'] == context:
if not _intact(candidate):
raise ValueError('saved native export changed before target validation')
record = candidate
if record is None:
directory = data_root / 'execution-proof' / ('saved-netlist-' + proof['session_token'])
capture_path = directory / 'capture/capture.json'
if capture_path.is_file():
capture = json.loads(capture_path.read_text(encoding='utf-8'))
native_netlist._check_capture(capture)
source_hashes = {str(canonical_path(path)).casefold():digest for path,digest in capture['source_hashes'].items()}
if (canonical_path(capture['project']) != canonical_path(proof['project_path'])
or any(source_hashes.get(str(canonical_path(path)).casefold()) != digest for path,digest in proof['saved_sources'].items())):
raise ValueError('saved native capture belongs to a different original source')
else:
capture = native_netlist.capture_project(Path(proof['project_path']), directory / 'capture')
if not validate_project_commit_source(proof, root):raise ValueError('saved source changed while capturing the native database')
result = _export_saved_capture(capture, directory / 'export', stop_event=stop_event)
if result.get('status') != 'success' or result.get('complete') is not True:
raise ValueError('complete native saved export unavailable: ' + str(result.get('reason','')))
manifest = directory / 'export/netlist.json'
paths = [Path(capture['manifest_path']), manifest, *map(Path,result['outputs'].values()),
*(Path(capture['root']) / name for name in capture['capture_hashes'])]
for path in inputs:
target = internal_path(directory / 'inputs' / path.name)
target.parent.mkdir(parents=True,exist_ok=True)
data = internal_path(path).read_bytes()
if hashlib.sha256(data).hexdigest() != readbacks[path.name]:
raise ValueError('native target evidence changed during capture')
target.write_bytes(data)
if internal_path(path).read_bytes() != data:raise ValueError('native target evidence changed during capture')
paths.append(target)
files = [{'path':str(canonical_path(path)), 'sha256':_hash(path)} for path in dict.fromkeys(paths)]
record = dict(status='exported', context=context, capture=capture, result=result,
export_path=str(canonical_path(manifest)), export_sha256=_hash(manifest),
output_hashes={str(canonical_path(path)):_hash(path) for path in result['outputs'].values()}, files=files)
write_record(pointer, record)
record['result'] = _authoritative_export(record)
record['capture'] = record['result']['capture']
graph, jobs = record['result']['graph'], {}
for job in proof['jobs']:
row = rows[job]
if job in evidence:
expected, binding, _ = evidence[job]
jobs[job] = _observations(graph, row, expected, binding)
else:
_verify_no_match(graph, row)
jobs[job] = dict(value_readback_status='verified',value_readback=[],value_readback_job_id=job,
project_path=row['project_path'],schematic_name=row.get('schematic_name',''),sheet_number=row.get('sheet_number',''))
if not validate_project_commit_source(proof,root) or not _intact(record) or not readbacks_intact():
raise ValueError('saved source/export or writer evidence changed during target validation')
record.update(status='verified',jobs=jobs)
verification = Path(record['export_path']).parent / 'verification.json'
verification_value = {key:record[key] for key in ('status','context','export_path','export_sha256','jobs')}
if verification.is_file():
if json.loads(verification.read_text(encoding='utf-8')) != verification_value:
raise ValueError('saved native target verification changed on resume')
else:write_record(verification,verification_value)
record.update(verification_path=str(canonical_path(verification)),verification_sha256=_hash(verification))
if not any(item['path'] == str(canonical_path(verification)) for item in record['files']):
record['files'].append({'path':str(canonical_path(verification)),'sha256':_hash(verification)})
write_record(pointer,record)
result = dict(proof, saved_netlist=compact_saved_netlist(record))
result['native_outcomes'] = outcomes
result['outcomes'] = {job:'saved_ok' if state == 'pending_save' else state for job,state in result['native_outcomes'].items()}
result['files'] = list({(item['path'],item['sha256']):item for item in [*proof['files'],*record['files']]}.values())
return result
@@ -0,0 +1,160 @@
"""Read saved sources after native close, retrying only actual Windows locks."""
import hashlib
import json
import os
from pathlib import Path
import time
from .errors import TaskCenterError
from .file_lock_diagnostics import locking_processes
from .path_access import internal_path
LOCK_WAIT_SECONDS = 3.0
class SavedSourceReadError(TaskCenterError):
def __init__(self, error, path, *, interrupted=False):
self.winerror = getattr(error, 'winerror', None)
self.path = str(path)
self.retryable = self.winerror in (32, 33)
self.interrupted = interrupted
reason = '核验已暂停' if interrupted else '数据库仍被占用' if self.retryable else '源文件读取失败'
super().__init__('saved_source_pending',
f'工程已返回保存,{reason},结果待核验;不会重复替换。文件:{path};Windows 错误码:{self.winerror};{error}')
def source_hash(path):
"""Retain CreateFile's error code; Python open can reduce sharing errors to EACCES."""
path = internal_path(path)
if os.name != 'nt':
with path.open('rb') as stream:
return hashlib.file_digest(stream, 'sha256').hexdigest()
import msvcrt
import pywintypes
import win32file
try:
# Match the CRT reads used by subsequent source validation.
handle = win32file.CreateFile(str(path), 0x80000000, 3, None, 3, 0, None)
except pywintypes.error as error:
failure = OSError(error.winerror, error.strerror, str(path))
failure.winerror = error.winerror
raise failure from error
try:
fd = msvcrt.open_osfhandle(int(handle), os.O_RDONLY | os.O_BINARY)
handle.Detach() # The file descriptor now owns this handle.
finally:
handle.Close()
with os.fdopen(fd, 'rb') as stream:
return hashlib.file_digest(stream, 'sha256').hexdigest()
def bind_sources(proof, data_root, root, project, *, stop_event=None, release_mentor=None):
from .batch_resources import write_record
from .operation_diagnostics import record_operation
from .project_session_health import _source_parameters, _source_digest
from .project_isolation import write_sources
from .worker_monitor import _publish_progress
root = Path(root)
parameters = _source_parameters(Path(project), data_root)
started = time.monotonic()
deadline = started + LOCK_WAIT_SECONDS
status = dict(session_token=proof.get('session_token'), project_path=str(project),
replacement_replayed=False, mentor_released_for_read=False)
try:
prior = json.loads(internal_path(root / 'saved-source-status.json').read_text(encoding='utf-8'))
if (proof.get('session_token') and prior.get('session_token') == proof['session_token']
and prior.get('project_path', '').casefold() == str(project).casefold()):
status.update({key: prior[key] for key in ('first_error', 'last_error', 'lock_observation') if key in prior})
status['mentor_released_for_read'] = prior.get('mentor_released_for_read') is True
except (OSError, ValueError, AttributeError, TypeError):
pass # Historical diagnostics never authorize a saved result.
last_lock = None
observed = False
released_this_call = False
def publish(state, error=None):
status.update(state=state, elapsed_seconds=time.monotonic()-started)
if error is not None:
status['last_error'] = dict(path=getattr(error, 'path', str(project)),
winerror=getattr(error, 'winerror', None), message=str(error))
status.setdefault('first_error', status['last_error'])
write_record(root / 'saved-source-status.json', status)
try:
progress = json.loads(internal_path(root / 'worker-progress.json').read_text(encoding='utf-8'))
except (OSError, ValueError):
progress = {}
if not isinstance(progress, dict) or type(progress.get('sequence', 0)) is not int:
progress = {}
progress.update(stage='saved_source_wait' if state in {'waiting', 'releasing_mentor'} else
'awaiting_reconciliation' if state == 'pending' else 'verify_saved_project',
wait_reason='readback', waiting_for_safe_completion=False,
sequence=progress.get('sequence', 0)+1, stage_seconds={})
if state == 'pending': progress['primary_error'] = str(error)
_publish_progress(internal_path(root / 'worker-progress.json'), progress)
def publish_read(state, error):
try:
publish(state, error)
except Exception as diagnostic:
error.add_note('保存源文件交接状态记录失败:' + str(diagnostic))
raise error from diagnostic
def check_paused():
if last_lock is not None and stop_event is not None and stop_event.is_set():
raise SavedSourceReadError(last_lock[0], last_lock[1], interrupted=True) from last_lock[0]
record_operation(root, 'saved_source_bind', 'enter', item_id=proof.get('session_token', ''))
try:
while True:
check_paused()
path = project
try:
before = _source_digest(parameters)
hashes = {}
for path in sorted(write_sources(project)):
hashes[path] = source_hash(path)
if not before or before != _source_digest(parameters):
raise TaskCenterError('saved_source_changed', '保存后的源文件仍在变化,结果待核验;不会重复替换。')
except OSError as failure:
error = SavedSourceReadError(failure, path)
stopped = stop_event is not None and stop_event.is_set()
if stopped:
raise SavedSourceReadError(failure, path, interrupted=True) from failure
if not error.retryable:
raise error from failure
last_lock = failure, path
if not observed:
publish_read('waiting', error)
status['lock_observation'] = locking_processes(path)
observed = True
continue # The lock may have disappeared during this diagnostic.
if time.monotonic() >= deadline:
if release_mentor is None or released_this_call:
raise error from failure
publish_read('releasing_mentor', error)
check_paused()
release_mentor(error)
released_this_call = True
status['mentor_released_for_read'] = True
deadline = time.monotonic() + LOCK_WAIT_SECONDS
else:
if status.get('state') != 'waiting': publish_read('waiting', error)
time.sleep(.05)
continue
command_hash = hashlib.sha256(internal_path(root / 'command.tsv').read_bytes()).hexdigest()
check_paused()
try:
publish('bound')
except OSError as diagnostic:
record_operation(root, 'saved_source_diagnostic', 'error', error=str(diagnostic))
record_operation(root, 'saved_source_bind', 'return', item_id=proof.get('session_token', ''))
return dict(proof, **parameters, source_sha256=before, saved_sources=hashes, command_sha256=command_hash)
except Exception as error:
record_operation(root, 'saved_source_bind', 'error', item_id=proof.get('session_token', ''), error=str(error))
try:
publish('pending', error)
except Exception as diagnostic:
error.add_note('保存源文件交接状态记录失败:' + str(diagnostic))
raise
@@ -102,6 +102,14 @@ def _default_path_opener(path: Path) -> None:
class TaskCenterService:
"""The only API used by UI workers and widgets."""
@property
def verification(self):
with self._store._lock:
if not hasattr(self, '_verification_service'):
from .verification.service import VerificationService
self._verification_service = VerificationService(self._store, self._logging.root)
return self._verification_service
def __init__(
self,
store: TaskStore,
@@ -1117,8 +1125,9 @@ class TaskCenterService:
summary='quick_run_result:failed | '+message)
if task.status in {TaskStatus.DRAFT,TaskStatus.READY,TaskStatus.PAUSED}:
self._store.set_task_status(task_id,TaskStatus.RUNNING,summary=summary)
self._store.set_task_status(task_id,TaskStatus.FAILED,summary=summary)
elif task.status is TaskStatus.RUNNING:
self._store.set_task_status(task_id,TaskStatus.RUNNING,summary=summary)
self._store.set_task_status(task_id,TaskStatus.FAILED,summary=summary)
HistoryRepository(self._store).append(task_id=task_id,task_name=task.name,
operation='工程执行收尾',state='failed',summary='本工程安全失败,剩余项暂缓;继续后续工程。',
details={'reason':message})
@@ -1147,7 +1156,15 @@ class TaskCenterService:
child._quick_run_preparer.data_root, started_after)
if getattr(self, '_supervisor_waiting', False):
from dataclasses import replace
value = replace(value, stage='awaiting_reconciliation', waiting_for_safe_completion=True)
from .execution_feedback import wait_reason_for_stage
state = getattr(self, '_supervisor_state', None) or {}
wait_reason = state.get('wait_reason') or value.wait_reason or wait_reason_for_stage(value.stage)
stopping_reason = state.get('stopping_reason') or value.stopping_reason
if not stopping_reason and getattr(self, '_supervisor_business_stalled', False):
stopping_reason = 'inactivity'
value = replace(value, waiting_for_safe_completion=True,
wait_reason=wait_reason, stopping_reason=stopping_reason,
primary_error=state.get('primary_error') or value.primary_error)
if read_control is not None:
read_control.checkpoint()
return value
@@ -1175,6 +1192,38 @@ class TaskCenterService:
return self._quick_run_preparer.has_interrupted(task_id)
def recover_quick_run(self, task_id: str, *, confirmed: bool = False, runtime=None, stop_event=None) -> QuickRunStepResult:
if self._store.get_task(task_id).status is TaskStatus.DELETED:
raise TaskCenterError("quick_run_recovery", "请先恢复已删除的任务记录,再核验其中断步骤。")
from .project_isolation import dependency_block, recover_dependency
dependency = dependency_block(self._logging.root, task_id)
dispatched = None
if dependency is not None and dependency['state'] in {'readmission_prepared', 'readmitted'}:
with self._store._lock:
dispatched = self._store._connection.execute('''SELECT 1 FROM execution_operations o
JOIN execution_rounds r ON r.task_id=o.task_id AND r.round_id=o.round_id
WHERE o.task_id=? AND (o.attempt_id IS NOT NULL OR o.generation>0) LIMIT 1''', (task_id,)).fetchone()
if dependency is not None and not dispatched:
if stop_event is not None and stop_event.is_set():
raise TaskCenterError('operation_cancelled', '共享数据源依赖核验已取消。')
from .task_queue import assert_task_queue_idle
assert_task_queue_idle(self._logging.root)
with _quick_run_lease(self._logging.root):
return self._operation('recover_quick_run', task_id,
lambda: recover_dependency(self, task_id, confirmed=confirmed))
commit_recovery = getattr(self._project_task_service(task_id)._quick_run_preparer, 'recover_project_commit', None)
if commit_recovery is not None:
from .batch_resources import guard_pending_resources
from .task_queue import assert_task_queue_idle
assert_task_queue_idle(self._logging.root)
with _quick_run_lease(self._logging.root):
guard_pending_resources(self._logging.root)
result = self._operation('recover_project_commit', task_id,
lambda: commit_recovery(task_id, confirmed=confirmed))
if result is not None:
if self._store.get_task(task_id).status in {TaskStatus.BLOCKED, TaskStatus.FAILED, TaskStatus.PAUSED}:
self._store.set_task_status(task_id, TaskStatus.READY, summary='原工程提交已通过持久化保存回读证据核验。')
self._synchronize_quick_run_progress(task_id)
return result
if runtime is None and self._supervised:
return self._supervise('recover_quick_run', {'task_id': task_id, 'confirmed': confirmed}, stop_event=stop_event)
if runtime is None:
@@ -1221,7 +1270,7 @@ class TaskCenterService:
self._quick_run_preparer._bind_journal_handoff(task_id,
QuickRunResult(result.script_path, result.command_path, result.status_path,
handoff_root/'quick-part-replace.log', True))
if task.status in {TaskStatus.PAUSED, TaskStatus.FAILED}:
if task.status in {TaskStatus.PAUSED, TaskStatus.FAILED, TaskStatus.BLOCKED}:
self._store.set_task_status(task_id, TaskStatus.READY, summary="interrupted quick-run reconciled")
from .recovery_commit import marker_path
marker_path(self._quick_run_preparer).unlink(missing_ok=True)
@@ -1409,8 +1458,8 @@ class TaskCenterService:
rules,
copy_part_number_to_value=task.copy_part_number_to_value,
)
if self._supervised:
return progress # Only the batch process persists live execution state.
if self._supervised or task.status is TaskStatus.BLOCKED:
return progress # BLOCKED classification changes only through explicit reconciliation.
by_path = {_path_key(project.path): project.project_id for project in projects}
project_by_id = {project.project_id: project for project in projects}
summary_by_id = {
@@ -1457,7 +1506,7 @@ class TaskCenterService:
) or (
progress.queue_complete
and (
(bool(failed_project_ids) and (task.status is not TaskStatus.RUNNING or task.summary != retry_summary))
(bool(failed_project_ids) and (task.status is not TaskStatus.FAILED or task.summary != retry_summary))
or (not failed_project_ids and task.status is not TaskStatus.COMPLETED)
)
)
@@ -80,7 +80,7 @@ def read_target_plan(store, task_id: str, path: Path) -> tuple[TargetPlanRow, ..
raise ValueError("invalid or formula plan row")
identity = tuple("" if value is None else str(value) for value in values[:8])
key = (str(Path(identity[0]).resolve(strict=False)).casefold(),
identity[2], identity[3], identity[4])
identity[2], identity[3], identity[5].strip().casefold())
original = expected.get(key)
if original is None or key in by_key:
raise ValueError("forged or duplicate target")
@@ -1,5 +1,6 @@
"""Separate ordinary stop intent from an explicitly confirmed forced interruption."""
from threading import Event
import time
import json
import os
@@ -23,6 +24,13 @@ class StopControl(Event):
self.resolution_error = ''
self.cleanup_mode = None
self.cleanup_reason = ''
self.stopping_reason = ''
self.wait_reason = ''
self.primary_error = ''
def set(self):
self.stopping_reason = self.stopping_reason or 'user_pause'
super().set()
def request_force(self):
self.set()
@@ -33,10 +41,64 @@ class StopControl(Event):
protect_interruption(root, MENTOR_RELEASE_REQUIRED + ': ' + str(error))
self.cleanup_mode = MENTOR_RELEASE_REQUIRED
self.cleanup_reason = self.cleanup_reason or str(error)
self.primary_error = self.primary_error or str(error)
self.stopping_reason = 'failure_cleanup'
self.set()
self.force_event.set()
class _ProjectForce:
def __init__(self, parent):
self.local = Event()
self.parent = getattr(parent, 'force_event', None)
def is_set(self):
return self.local.is_set() or self.parent is not None and self.parent.is_set()
def set(self):
self.local.set()
def clear(self):
self.local.clear()
if self.parent is not None:
self.parent.clear()
def wait(self, timeout=None):
deadline = None if timeout is None else time.monotonic() + timeout
while not self.is_set():
remaining = .1 if deadline is None else min(.1, deadline - time.monotonic())
if remaining <= 0:
return False
self.local.wait(remaining)
return True
class ProjectStopControl(StopControl):
"""An engineering failure stops its owner; user pause still stops the batch."""
def __init__(self, parent):
super().__init__()
self.parent = parent
self.force_event = _ProjectForce(parent)
def is_set(self):
return self.parent.is_set() or super().is_set()
def set(self):
if self.stopping_reason in {'failure_cleanup','inactivity'}:
Event.set(self)
else:
self.parent.set()
def request_failure_cleanup(self, root, error):
protect_interruption(root, MENTOR_RELEASE_REQUIRED + ': ' + str(error))
self.stopping_reason = 'failure_cleanup'
self.cleanup_mode = MENTOR_RELEASE_REQUIRED
self.cleanup_reason = self.cleanup_reason or str(error)
self.primary_error = self.primary_error or str(error)
Event.set(self)
self.force_event.set()
def protect_interruption(root, reason):
"""Create or re-sync a marker without overwriting prior protection evidence."""
root = internal_path(root)
@@ -69,9 +131,12 @@ def wait_for_resolution(control, root, error, *, resolved=None, release_on_failu
return
from .worker_monitor import WorkerMonitorError, _publish_progress
root = internal_path(root)
control.stopping_reason = 'failure_cleanup' if release_on_failure else (control.stopping_reason or 'inactivity')
control.wait_reason = 'reconciliation'
control.primary_error = control.primary_error or str(error)
control.set()
control.waiting_for_resolution = True
control.resolution_error = str(error)
control.resolution_error = control.resolution_error or str(error)
def protect():
protect_interruption(root, 'operation_interrupted: ' + str(error))
try:
@@ -91,7 +156,9 @@ def wait_for_resolution(control, root, error, *, resolved=None, release_on_failu
record = {}
record.update(stage='awaiting_reconciliation', waiting_for_safe_completion=True,
resolution_error=str(error), stop_requested=True, safe_stop=False,
cleanup_mode=control.cleanup_mode)
cleanup_mode=control.cleanup_mode, stopping_reason=control.stopping_reason,
wait_reason=control.wait_reason,
primary_error=record.get('primary_error') or control.primary_error)
_publish_progress(root / 'worker-progress.json', record)
while True:
if resolved is not None and resolved():
+13 -5
View File
@@ -40,7 +40,7 @@ _TASK_TRANSITIONS = {
TaskStatus.RUNNING: {TaskStatus.PAUSED, TaskStatus.COMPLETED, TaskStatus.FAILED},
TaskStatus.PAUSED: {TaskStatus.READY, TaskStatus.RUNNING, TaskStatus.FAILED, TaskStatus.DELETED},
TaskStatus.COMPLETED: {TaskStatus.DELETED},
TaskStatus.FAILED: {TaskStatus.PAUSED, TaskStatus.READY, TaskStatus.DELETED},
TaskStatus.FAILED: {TaskStatus.PAUSED, TaskStatus.READY, TaskStatus.RUNNING, TaskStatus.DELETED},
TaskStatus.DELETED: {
TaskStatus.DRAFT,
TaskStatus.READY,
@@ -49,6 +49,13 @@ _TASK_TRANSITIONS = {
TaskStatus.FAILED,
},
}
for _state in (TaskStatus.DRAFT, TaskStatus.READY, TaskStatus.RUNNING, TaskStatus.PAUSED, TaskStatus.FAILED):
_TASK_TRANSITIONS[_state].add(TaskStatus.BLOCKED)
_TASK_TRANSITIONS[TaskStatus.DRAFT].update({TaskStatus.PAUSED, TaskStatus.FAILED})
_TASK_TRANSITIONS[TaskStatus.READY].add(TaskStatus.PAUSED)
_TASK_TRANSITIONS[TaskStatus.FAILED].add(TaskStatus.FAILED)
_TASK_TRANSITIONS[TaskStatus.BLOCKED] = {TaskStatus.BLOCKED, TaskStatus.PAUSED, TaskStatus.READY, TaskStatus.DELETED}
_TASK_TRANSITIONS[TaskStatus.DELETED].add(TaskStatus.BLOCKED)
_PROJECT_TRANSITIONS = {
ProjectStatus.PENDING: {ProjectStatus.CAPTURING_BEFORE, ProjectStatus.FAILED, ProjectStatus.SKIPPED},
ProjectStatus.CAPTURING_BEFORE: {ProjectStatus.AWAITING_OPERATOR, ProjectStatus.FAILED},
@@ -467,7 +474,8 @@ class TaskStore:
"""Persist current-sheet quick-run progress independently of manual attempts."""
with self.transaction():
task = self.get_task(task_id)
allowed_task_states = {TaskStatus.DRAFT, TaskStatus.READY, TaskStatus.RUNNING, TaskStatus.PAUSED, TaskStatus.COMPLETED}
allowed_task_states = {TaskStatus.DRAFT, TaskStatus.READY, TaskStatus.RUNNING, TaskStatus.PAUSED,
TaskStatus.COMPLETED, TaskStatus.FAILED}
if task.status not in allowed_task_states:
raise TaskCenterError("quick_run_task_state", "task state does not allow quick-run progress")
for project_id in completed_project_ids:
@@ -512,7 +520,7 @@ class TaskStore:
"quick-run queue completed before project states were synchronized",
)
has_failures = any(project.status is ProjectStatus.FAILED for project in selected)
if task.status in {TaskStatus.DRAFT, TaskStatus.READY, TaskStatus.PAUSED}:
if task.status in {TaskStatus.DRAFT, TaskStatus.READY, TaskStatus.PAUSED, TaskStatus.FAILED}:
task = self.set_task_status(
task_id,
TaskStatus.RUNNING,
@@ -520,10 +528,10 @@ class TaskStore:
if has_failures else "current-sheet quick-run queue completed",
)
if has_failures:
if task.status is TaskStatus.RUNNING and task.summary != "current-sheet quick-run queue completed with retryable failures":
if task.status is TaskStatus.RUNNING:
task = self.set_task_status(
task_id,
TaskStatus.RUNNING,
TaskStatus.FAILED,
summary="current-sheet quick-run queue completed with retryable failures",
)
else:
@@ -65,6 +65,8 @@ class StoreSchema:
from .execution_journal import create_execution_schema
create_history_schema(self._store._connection)
create_execution_schema(self._store._connection)
from .verification.store import create_schema as create_verification_schema
create_verification_schema(self._store._connection)
def _create_schema_v1(self) -> None:
statements = (
@@ -20,7 +20,8 @@ class ProjectIdentityResolver:
return self._projects[spelling]
def target(self, target):
return (self.project(target.project_path), target.schematic_name, target.sheet_number, target.uid)
return (self.project(target.project_path), target.schematic_name, target.sheet_number,
target.refdes.strip().casefold())
@dataclass(frozen=True, slots=True)
@@ -36,6 +37,8 @@ class ComponentTarget:
actual_cell: str | None = None
def __post_init__(self) -> None:
if not self.uid and self.refdes:
object.__setattr__(self, 'uid', '@REFDES|' + self.refdes.strip())
if any(value is not None and not isinstance(value, str)
for value in (self.actual_part_label, self.actual_cell)):
raise TaskCenterError('target_inventory', 'effective Part Label and Cell must be text or unknown')
@@ -118,7 +121,7 @@ def compile_target_rules(rows: tuple[TargetPlanRow, ...], *, default_value_mode:
raise TaskCenterError("target_identity", "component identity is incomplete")
target_key = identities.target(target)
if target_key in seen:
raise TaskCenterError("target_overlap", "target UID appears more than once")
raise TaskCenterError("target_overlap", "target reference appears more than once")
seen.add(target_key)
if not row.enabled:
continue
@@ -23,7 +23,8 @@ def archive_completed_session(service):
def _archive(service):
store = service._store
pending = service.pending_batch_resources()
from .batch_resources import resource_blockers
pending = resource_blockers(service.pending_batch_resources())
owned = set()
unknown = False
for record in pending:
@@ -39,7 +40,7 @@ def _archive(service):
reason = None
if unknown or task.task_id in owned:
reason = '后台资源尚未确认释放;重新打开后使用“重新清理资源”。'
elif task.status is TaskStatus.RUNNING:
elif task.status in {TaskStatus.RUNNING, TaskStatus.BLOCKED}:
reason = '任务仍在执行状态;重新打开后暂停或核验恢复。'
elif any(project.status in {ProjectStatus.CAPTURING_BEFORE, ProjectStatus.AWAITING_OPERATOR,
ProjectStatus.CAPTURING_AFTER, ProjectStatus.VERIFYING}
@@ -12,6 +12,8 @@ from uuid import uuid4
from .errors import TaskCenterError
from .quick_run import _write_atomic_queue_text
from .project_isolation import (write_sources, record_task_outcome, isolate_project,
block_dependency, dependency_block, dependency_readmitted)
_QUEUE_LOCK = Lock()
@@ -212,12 +214,14 @@ def execute_task_queue(service, task_ids: tuple[str, ...], *, stop_event: Event,
with _queue_lease(root):
children = {task_id: service.for_project_task(task_id) for task_id in ids}
project_paths = []
sources = {}
for task_id, child in children.items():
task = child.get_task(task_id)
projects = child.projects(task_id)
if not getattr(task, 'primary_project_id', None) or len(projects) != 1:
raise TaskCenterError('project_binding', '顺序执行仅支持绑定单个工程的任务。')
project_paths.append(str(projects[0].path.resolve(strict=False)).casefold())
sources[task_id] = write_sources(projects[0].path)
if len(set(project_paths)) != len(ids):
raise TaskCenterError('task_queue_selection', '不能在同一队列重复处理同一个工程。')
runtime.bind_logs(service._logging, ids)
@@ -251,10 +255,38 @@ def execute_task_queue(service, task_ids: tuple[str, ...], *, stop_event: Event,
_save(path, state)
paused = False
current = None
from .stop_control import ProjectStopControl
parent_control = getattr(runtime, 'stop_event', None)
isolated_tasks = state.setdefault('isolated_tasks', {})
isolated_sources = state.setdefault('isolated_sources', {})
dependency_tasks = state.setdefault('dependency_tasks', {})
from .netlist_verification import NetlistVerification
checks = NetlistVerification(root, token, stop_event)
try:
for task_id in ids:
readmitted = False
if task_id in dependency_tasks:
try:
readmitted = dependency_readmitted(children[task_id], task_id, hashes[task_id])
except TaskCenterError:
pass
if readmitted:
isolated_tasks.pop(task_id, None)
dependency_tasks.pop(task_id)
state['entries'][task_id] = {'state': 'pending', 'message': '共享依赖已核验,恢复未派发原计划。'}
if task_id in isolated_tasks:
continue
conflict = next((isolated_sources[source] for source in sources[task_id]
if source in isolated_sources), None)
if conflict is not None and not readmitted and state['entries'][task_id]['state'] not in _TERMINAL:
message = f'与待核验工程 {conflict} 共享写入源,已隔离;未派发替换。'
state['entries'][task_id] = {'state': 'blocked', 'message': message}
isolated_tasks[task_id] = message
dependency_tasks[task_id] = conflict
block_dependency(root, children[task_id], task_id, conflict,
sources[task_id] & sources[conflict], hashes[task_id], token)
_save(path, state)
continue
if state['entries'][task_id]['state'] in _TERMINAL:
if state['entries'][task_id]['state'] == 'completed':
checks.before_task(children[task_id], task_id, existing_only=True)
@@ -264,6 +296,10 @@ def execute_task_queue(service, task_ids: tuple[str, ...], *, stop_event: Event,
break
current = task_id
child = children[task_id]
project_control = ProjectStopControl(stop_event)
runtime.stop_event = project_control
if getattr(runtime, 'cad', None) is not None:
runtime.cad.stop_control = project_control
service._task_queue_feedback = (token, task_id, ids.index(task_id) + 1, len(ids))
resolving_bom = False
execution_dispatched = False
@@ -277,7 +313,7 @@ def execute_task_queue(service, task_ids: tuple[str, ...], *, stop_event: Event,
if _plan_hash(child, task_id) != hashes[task_id]:
raise TaskCenterError('assistant_stale', '待执行 BOM 已变化,请重新确认。')
resolving_bom = True
resolved = child.resolve_pending_bom(task_id, stop_event=stop_event)
resolved = child.resolve_pending_bom(task_id, stop_event=project_control)
resolving_bom = False
if not any(row.enabled for row in resolved):
state['entries'][task_id] = {'state': 'skipped',
@@ -304,7 +340,7 @@ def execute_task_queue(service, task_ids: tuple[str, ...], *, stop_event: Event,
for parameter in parameters) else {})
checks.before_task(child, task_id)
execution_dispatched = True
result = execute(task_id, expected_item=expected, stop_event=stop_event,
result = execute(task_id, expected_item=expected, stop_event=project_control,
**runtime_options)
if child.has_interrupted_quick_run(task_id) or (
result.last_result is not None and result.last_result.state == 'batch_saved_unverified'
@@ -340,10 +376,31 @@ def execute_task_queue(service, task_ids: tuple[str, ...], *, stop_event: Event,
entry = {'state': 'failed' if safe else 'paused' if error.code == 'operation_cancelled' else 'blocked',
'message': f'{error.code}: {error.message}' if resolving_bom else error.message}
paused = not safe
if not safe and error.code != 'operation_cancelled' and not stop_event.is_set():
try:
isolated = isolate_project(runtime, child, task_id, error)
except Exception as cleanup_error:
entry['message'] += '; 资源收尾未确认:' + str(cleanup_error)
isolated = False
if isolated:
isolated_tasks[task_id] = entry['message']
isolated_sources.update((source,task_id) for source in sources[task_id])
paused = False
except Exception as error:
entry = {'state': 'blocked', 'message': str(error)}
paused = True
if not stop_event.is_set():
try:
isolated = isolate_project(runtime, child, task_id, error)
except Exception as cleanup_error:
entry['message'] += '; 资源收尾未确认:' + str(cleanup_error)
isolated = False
if isolated:
isolated_tasks[task_id] = entry['message']
isolated_sources.update((source,task_id) for source in sources[task_id])
paused = False
state['entries'][task_id] = entry
record_task_outcome(child, task_id, entry['state'], entry['message'])
_save(path, state)
if (entry['state'] in {'completed', 'failed'} and task_id in checks.tasks
and not child.has_interrupted_quick_run(task_id)):
@@ -369,7 +426,8 @@ def execute_task_queue(service, task_ids: tuple[str, ...], *, stop_event: Event,
checks.after_task(task_id, execution_state='failed' if result.progress.failed_items else 'completed',
refresh=True, execution_summary={key: getattr(result.progress, key, None)
for key in ('saved_items', 'failed_items', 'no_match_items')})
retried = run_problem_pass(service, ids, token, stop_event=stop_event, runtime=runtime,
admitted_problem_tasks = tuple(item for item in ids if item not in isolated_tasks)
retried = run_problem_pass(service, admitted_problem_tasks, token, stop_event=stop_event, runtime=runtime,
on_result=capture_retry)
for task_id, result in retried.results.items():
state['entries'][task_id] = {'state': 'paused' if result.paused else 'failed' if result.progress.failed_items else 'completed',
@@ -416,3 +474,6 @@ def execute_task_queue(service, task_ids: tuple[str, ...], *, stop_event: Event,
checks.__exit__(None, None, None)
finally:
service._task_queue_feedback = None
runtime.stop_event = parent_control
if getattr(runtime, 'cad', None) is not None:
runtime.cad.stop_control = parent_control
@@ -9,12 +9,14 @@ STAGES = {
'snapshot_attributes': '记录原始属性', 'capture': '采集替换前快照',
'capture_untouched': '记录未选中器件状态', 'verify_untouched': '核验未选中器件',
'native_snapshot_read': '采集并核验器件完整状态',
'capture_semantic_state': '采集完整图页状态',
'before_native': '准备原生替换', 'native_replace': '执行原生替换',
'restore_preflight': '检查属性恢复条件',
'before_restore_transaction': '准备恢复属性',
'restore_attribute_fields': '恢复属性字段', 'restore_attributes': '恢复属性',
'verify_restoration': '核验恢复结果', 'verify_attribute_fields': '核验属性字段',
'save_and_close': '保存并关闭工程', 'verify_saved_project': '回读已保存工程',
'save_and_close': '保存并关闭工程', 'verify_saved_project': '回读工程并核对',
'saved_source_wait': '工程已保存,等待数据库释放后核验',
'awaiting_reconciliation': '当前结果待核验,已保留工程现场',
}
@@ -22,7 +24,20 @@ STAGES = {
def format_feedback(value, task_name, elapsed, stopping):
stage = STAGES.get(value.stage, '')
details = f'{stage}({value.stage_seconds:.1f} 秒)' if stage else value.message
prefix = '等待当前步骤保存核验后暂停 · ' if stopping else ''
reason = getattr(value, 'stopping_reason', '')
wait = getattr(value, 'wait_reason', '')
prefix = ({'user_pause': '已请求暂停,等待当前步骤完成',
'failure_cleanup': '执行失败,正在回收资源',
'inactivity': '当前步骤长时间无进展'}
.get(reason, '已请求暂停,等待当前步骤完成' if stopping else ''))
waits = {'native_call': '等待原生调用返回', 'save': '等待工程保存完成',
'readback': '等待工程重读核对', 'mentor_exit': '等待 Mentor 写进程退出',
'desktop_release': '等待后台桌面释放', 'reconciliation': '等待结果核对'}
if wait and (stopping or value.waiting_for_safe_completion):
prefix = ','.join(filter(None, (prefix, waits.get(wait, ''))))
if value.waiting_for_safe_completion:
prefix = '当前保存或核验尚未确认,未自动结束应用;可继续等待、导出诊断,或确认强制结束后核验 · '
prefix += ';最终结果尚未确认,可继续等待、导出诊断,或确认强制结束后核对'
if getattr(value, 'primary_error', ''):
details += ';原始错误:' + value.primary_error
prefix = prefix + ' · ' if prefix else ''
return f'{prefix}任务 {value.position}/{value.total}:{task_name} · {details} · 总计 {elapsed} 秒'
@@ -3,12 +3,20 @@ from dataclasses import dataclass
from ..models import TaskStatus
def task_display_status(task):
"""Legacy retryable failures retain running admission, but are not active work."""
if (task.status is TaskStatus.RUNNING
and task.summary == 'current-sheet quick-run queue completed with retryable failures'):
return TaskStatus.FAILED
return task.status
def pending_batch_tasks(tasks, group_id):
"""Use the persisted batch order for both execution and its UI controls."""
if not group_id:
return ()
return tuple(sorted((task for task in tasks if task.group_id == group_id
and task.status not in {TaskStatus.DELETED, TaskStatus.COMPLETED}
and task.status not in {TaskStatus.DELETED, TaskStatus.COMPLETED, TaskStatus.BLOCKED}
and getattr(task, 'summary', '') != 'current-sheet quick-run queue completed with retryable failures'),
key=lambda task: task.group_position))
@@ -34,7 +42,8 @@ def execution_state(context, *, busy=False, dirty=False):
if not project or task.status is TaskStatus.DELETED:
return ExecutionState(message='任务已删除,可从已删除列表恢复。')
editable = task.status in {TaskStatus.DRAFT, TaskStatus.READY, TaskStatus.FAILED} and not context.has_evidence and not busy
retry = context.phase == 'retry' and not context.interrupted and not busy and not dirty
retry = (context.phase == 'retry' and task.status is not TaskStatus.BLOCKED
and not context.interrupted and not busy and not dirty)
requests = getattr(context, 'pending_bom', ())
deferred = bool(requests)
from ..bom_pending import retained_bom_rows
@@ -44,7 +53,7 @@ def execution_state(context, *, busy=False, dirty=False):
execute = (pending and task.status in {TaskStatus.DRAFT, TaskStatus.READY, TaskStatus.RUNNING, TaskStatus.PAUSED}
and project.available and not context.interrupted and not busy and not dirty)
text = '核验并执行' if deferred else '继续当前任务' if task.status is TaskStatus.PAUSED else '执行当前任务'
message = ('结果待核验,请先恢复中断步骤。' if context.interrupted else
message = ('结果待核验,请先恢复中断步骤。' if context.interrupted or task.status is TaskStatus.BLOCKED else
'位号计划有未保存编辑,请先保存。' if dirty else
'正在处理当前步骤,暂停会等待安全收尾。' if busy else
'任务已完成。可查看原计划和日志;点击“开始新一轮”归档本批已完成任务,再采集当前料号。' if task.status is TaskStatus.COMPLETED else
@@ -54,5 +63,6 @@ def execution_state(context, *, busy=False, dirty=False):
'BOM 表格已保存;确认后仅核验当前工程位号,再执行替换。' if deferred else
'先填写旧、新料号,再采集并勾选位号。' if not pending else
'配置就绪,可执行当前任务或按顺序执行本批任务。')
return ExecutionState(editable, execute, retry, context.interrupted and not busy and not dirty, text, message,
return ExecutionState(editable, execute, retry,
(context.interrupted or task.status is TaskStatus.BLOCKED) and not busy and not dirty, text, message,
task.status is TaskStatus.COMPLETED and not context.interrupted and not busy and not dirty)
@@ -30,6 +30,7 @@ def icon(name: str, primary: bool = False) -> QIcon:
BUTTON_ICONS = {
'task_center_navigation': 'grid', 'dsh_navigation': 'chat',
'history_navigation': 'clock',
'verification_navigation': 'check', 'verificationNew': 'plus',
'newTaskButton': 'plus', 'editTaskButton': 'sliders', 'deleteTaskButton': 'trash',
'selectAllTasks': 'check', 'clearTaskSelection': 'close',
'restoreTaskButton': 'refresh', 'taskRecycleBin': 'trash',
@@ -60,6 +60,8 @@ class TrialTaskCenterWindow(MaterialMainWindow):
self.dsh_action = QAction('DSH助手', self)
self.dsh_action.setShortcut('Ctrl+Shift+D')
self.dsh_action.triggered.connect(self._open_dsh)
self.verification_action = QAction('工程校验', self)
self.verification_action.triggered.connect(lambda: self.content_stack.setCurrentWidget(self.verification_panel))
self._navigation_actions = QActionGroup(self)
self._navigation_actions.setExclusive(True)
navigation = QWidget(objectName='toolNavigation')
@@ -70,7 +72,8 @@ class TrialTaskCenterWindow(MaterialMainWindow):
navigation_layout.addWidget(brand)
navigation_layout.addSpacing(24)
for name, action in (('task_center_navigation', self.task_center_action),
('history_navigation', self.history_action), ('dsh_navigation', self.dsh_action)):
('history_navigation', self.history_action), ('dsh_navigation', self.dsh_action),
('verification_navigation', self.verification_action)):
action.setCheckable(True)
self._navigation_actions.addAction(action)
self.addAction(action)
@@ -292,14 +295,20 @@ class TrialTaskCenterWindow(MaterialMainWindow):
self.history_panel = OperationHistoryPage(self.service, self)
self.history_panel.busy_changed.connect(self._history_activity_changed)
self.content_stack.addWidget(self.history_panel)
from .verification_workspace import VerificationWorkspace
self.verification_panel = VerificationWorkspace(self.service, self)
self.content_stack.addWidget(self.verification_panel)
self.content_stack.currentChanged.connect(self._workspace_changed)
self.setCentralWidget(self.content_stack)
self._reset_layout()
def _workspace_changed(self, index):
history = self.content_stack.widget(index) is self.history_panel
(self.task_center_action if index == 0 else self.history_action if history else self.dsh_action).setChecked(True)
verification = self.content_stack.widget(index) is self.verification_panel
action = self.task_center_action if index == 0 else self.history_action if history else self.verification_action if verification else self.dsh_action
action.setChecked(True)
self.history_panel.set_active(history)
self.verification_panel.set_active(verification)
def _history_activity_changed(self):
self._update_gates()
@@ -400,6 +409,12 @@ class TrialTaskCenterWindow(MaterialMainWindow):
self._dsh_view.stopped.connect(lambda: QTimer.singleShot(0, self, self.close))
self._dsh_view.shutdown()
return
if self.verification_panel.busy:
self._close_pending = True
self.verification_panel.begin_shutdown()
event.ignore()
QTimer.singleShot(100, self.close)
return
self._cancel_dsh_diagnosis()
for name, widget in self._layout_widgets().items():
self._layout_settings.setValue(f'single_project/{name}', widget.saveState())
@@ -408,6 +423,7 @@ class TrialTaskCenterWindow(MaterialMainWindow):
self._dsh_status.close()
self._dsh_stall_timer.stop()
self.history_panel.shutdown()
self.verification_panel.shutdown()
if self._dsh_operations:
self._dsh_operations.close()
self._context_query.close()
@@ -423,9 +439,10 @@ class TrialTaskCenterWindow(MaterialMainWindow):
def _refresh_task_list(self):
deleted = self.task_list.recycle_button.isChecked()
def received(tasks):
self._known_task_groups.update((task.task_id, task.group_id) for task in tasks)
self._tasks = tasks
self.task_list.populate(tasks, selected_task_id=self._task_id)
if tasks != self._tasks or not self.task_list.count.text():
self._known_task_groups.update((task.task_id, task.group_id) for task in tasks)
self._tasks = tasks
self.task_list.populate(tasks, selected_task_id=self._task_id)
self._update_gates()
self._task_query.request(lambda control: self.service.tasks(status=TaskStatus.DELETED, read_control=control)
if deleted else self.service.tasks(read_control=control), received, self._show_error, cancellable=True)
@@ -529,7 +546,7 @@ class TrialTaskCenterWindow(MaterialMainWindow):
self.run_panel.retry_button.setVisible(bool(context and context.phase == 'retry'))
self.run_panel.retry_button.setEnabled(state.retry and not resources_pending)
self.run_panel.problems_button.setEnabled(bool(context and not busy))
self.run_panel.recover_button.setVisible(bool(context and context.interrupted))
self.run_panel.recover_button.setVisible(bool(context and (context.interrupted or context.task.status is TaskStatus.BLOCKED)))
self.run_panel.recover_button.setEnabled(state.recover and not resources_pending)
self.run_panel.new_round_button.setVisible(bool(context and context.task.status is TaskStatus.COMPLETED))
self.run_panel.new_round_button.setEnabled(state.new_round and not group_unsaved)
@@ -597,7 +614,8 @@ class TrialTaskCenterWindow(MaterialMainWindow):
self.run_panel.execution_status.setText('正在检查后台资源' if not self._resource_status.known else
'资源状态读取失败' if self._resource_status.error is not None else
'资源待清理' if resources_pending else '任务读取失败' if read_failed else
'结果待核验' if context and context.interrupted else '空闲')
'结果待核验' if context and (context.interrupted or context.task.status is TaskStatus.BLOCKED) else
'旧桌面已隔离,可继续执行' if self._resource_status.records else '空闲')
def _group_has_unsaved_plans(self):
if not self._context:
@@ -1037,16 +1055,22 @@ class TrialTaskCenterWindow(MaterialMainWindow):
cleanup_finished = True
start_force_if_ready()
def forced(remaining):
from ..batch_resources import resource_blockers
self._resource_status.refresh()
self._set_operator_message('仍有资源未能确认释放,请保留诊断。' if remaining else
self._set_operator_message('仍有资源未能确认释放,请保留诊断。' if resource_blockers(remaining) else
'自有写入进程已退出,残留桌面已隔离(未确认释放);相关工程仍须核验。' if remaining else
'自有残留资源已释放;相关工程仍须核验后恢复。', 'warning')
self._update_gates()
def done(pending):
nonlocal force_confirmed
from ..batch_resources import resource_blockers
warnings = tuple(row for row in pending if row.get('blocking') is False)
pending = resource_blockers(pending)
hints = tuple(dict.fromkeys(row['resolution_hint'] for row in pending if row.get('resolution_hint')))
self._set_operator_message(
'\n'.join(hints) if hints else '后台资源仍待清理,请保留诊断记录后重试。' if pending else '后台资源已释放,可以继续。',
'warning' if pending else 'success')
'\n'.join(hints) if hints else '后台资源仍待清理,请保留诊断记录后重试。' if pending else
'旧桌面仍存在,已隔离;自有写进程已退出,可以继续执行。' if warnings else '后台资源已释放,可以继续。',
'warning' if pending or warnings else 'success')
if pending:
self._dsh_blockers.report('resource-release', '', 'batch_resources_pending',
'后台资源清理完成后仍有资源未确认释放。', {'resources': list(pending)[:20]}, cleanup_allowed=True)
@@ -1187,7 +1211,7 @@ class TrialTaskCenterWindow(MaterialMainWindow):
if not self.run_panel.recover_button.isEnabled():
return
if QMessageBox.question(self, '核验并恢复',
'先备份工程和证据,再打开工程核验;如需补齐属性,会保存并重开回读,不会重复调用原生替换。请确保待处理工程未在其他 CAD 会话中打开。',
'共享数据源依赖导致隔离、且从未派发的任务,将核验依赖与原计划后解除隔离,不打开 CAD。其他中断任务先备份工程和证据,再打开核验;如需补齐属性,会保存并重开回读,不会重复调用原生替换。请确保待处理工程未在其他 CAD 会话中打开。',
QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
QMessageBox.StandardButton.No) != QMessageBox.StandardButton.Yes:
return
@@ -1223,6 +1247,8 @@ class TrialTaskCenterWindow(MaterialMainWindow):
def _update_quick_run_elapsed(self):
self._update_gates()
if self._batch_stop is not None and not self._task_query.busy:
self._refresh_task_list()
if self._batch_stop is not None and not self._feedback_query.busy:
task_id, started = self._active_quick_run_task_id, self._run_started_at
run_id = self._dsh_run_id
@@ -1459,6 +1485,7 @@ class TrialTaskCenterWindow(MaterialMainWindow):
# If it fails, release the execution controls just as
# the service failure path does.
self._finish_run()
self._refresh_task_list()
self.operation_state = self.operation_state.finish(error)
self._show_error(error, owner_task_id=owner, operation_area=operation_area)
def failed(error):
@@ -1470,6 +1497,8 @@ class TrialTaskCenterWindow(MaterialMainWindow):
if self._close_saving or not (isinstance(error, TaskCenterError) and error.code == 'operation_cancelled'):
self._close_pending = False
self._finish_run()
if execution:
self._refresh_task_list()
if isinstance(error, TaskCenterError) and error.code == 'operation_cancelled':
self._set_operator_message(self.operation_state.message)
return
@@ -18,6 +18,7 @@ STATES={'verified':'已核验完成','no_match':'未命中','failed':'失败','f
'uncertain':'待核验','saved_unverified':'保存待核验','skipped':'已跳过','recorded':'已记录',
'running':'执行中','paused':'已暂停','pending':'待执行','restored':'已恢复'}
OPERATIONS={'quick_run_executed':'替换执行','quick_run_prepared':'准备执行',
'verification_completed':'工程校验',
'quick_run_recovered':'核验恢复','quick_run_queue_paused':'暂停执行',
'quick_run_retry_prepared':'准备失败项重试','create_project_tasks':'创建工程任务',
'create_task':'新建任务','update_task':'编辑任务','delete_task':'归档任务',
@@ -29,7 +29,8 @@ class ResourceStatus(QObject):
@property
def blocked(self):
return not self.known or self.error is not None or bool(self.records)
from ..batch_resources import resource_blockers
return not self.known or self.error is not None or bool(resource_blockers(self.records))
def refresh(self):
if self._closed:
@@ -12,6 +12,7 @@ from PySide6.QtWidgets import (QAbstractItemView,QComboBox,QHBoxLayout,QLabel,QL
QListWidgetItem,QPushButton,QVBoxLayout,QWidget,QToolButton,QMenu,
QStyledItemDelegate,QStyleOptionViewItem,QStyle,QApplication)
from .command_menu import CommandMenu
from .execution_state import task_display_status
class TaskItemDelegate(QStyledItemDelegate):
@@ -80,10 +81,13 @@ class TaskList(QWidget):
self.count = QLabel(objectName='taskCount')
self.filter = QComboBox(objectName="taskFilter")
for label, key, picture in (('全部任务', 'all', 'grid'), ('未完成', 'unfinished', 'clock'),
('已完成', 'completed', 'check-circle'), ('失败', 'failed', 'warning')):
('待开始', 'pending', 'clock'), ('执行中', 'running', 'clock'),
('已暂停', 'paused', 'clock'), ('已完成', 'completed', 'check-circle'),
('待核验', 'blocked', 'warning'),
('失败 / 待重试', 'failed', 'warning')):
self.filter.addItem(icon(picture), label, key)
self.filter.setAccessibleName('任务状态分类')
self.filter.setToolTip('未完成包括待配置、待执行、执行中、已暂停和失败的任务;分类只筛选显示。')
self.filter.setToolTip('待开始包括待配置和待执行;失败包括已收尾的待重试任务。未完成包括所有尚未完成的任务;分类只筛选显示。')
self.list = QListWidget(objectName="taskList")
self.list.setItemDelegate(TaskItemDelegate(self.list))
self.list.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection)
@@ -163,9 +167,17 @@ class TaskList(QWidget):
return str(item.data(Qt.ItemDataRole.UserRole)) if item is not None else None
def populate(self, tasks: Iterable[object], *, selected_task_id: str | None = None) -> None:
preserve_selection = selected_task_id in (None, self.current_task_id())
selected_ids = {item.data(Qt.ItemDataRole.UserRole) for item in self.list.selectedItems()}
self._selected_task_id = selected_task_id or self.current_task_id() or self._selected_task_id
self._tasks = tuple(tasks)
self._render()
if preserve_selection:
with QSignalBlocker(self.list):
for row in range(self.list.count()):
item = self.list.item(row)
item.setSelected(item.data(Qt.ItemDataRole.UserRole) in selected_ids)
self._update_selection_state()
def select_task(self, task_id: str) -> None:
if task_id != self._selected_task_id:
@@ -209,8 +221,9 @@ class TaskList(QWidget):
category = self.filter.currentData()
if not self.recycle_button.isChecked() and category != 'all':
tasks = [task for task in tasks if
(task.status.value not in {'completed', 'deleted'} if category == 'unfinished'
else task.status.value == category)]
(task_display_status(task).value not in {'completed', 'deleted'} if category == 'unfinished'
else task_display_status(task).value in {'draft', 'ready'} if category == 'pending'
else task_display_status(task).value == category)]
mode = self.sort.currentData()
if mode.startswith('name_'):
tasks.sort(key=lambda task: tuple(int(part) if part.isdigit() else part
@@ -230,9 +243,9 @@ class TaskList(QWidget):
for task in tasks:
group_id = getattr(task, "group_id", None)
prefix = f"{getattr(task, 'group_position', 0) + 1:02d}. " if group_id else ""
status = getattr(getattr(task, 'status', None), 'value', '')
status = task_display_status(task).value
labels = {'draft': '待配置', 'ready': '待执行', 'running': '执行中', 'paused': '已暂停',
'completed': '已完成', 'failed': '失败', 'deleted': '已删除'}
'completed': '已完成', 'failed': '失败', 'blocked': '待核验', 'deleted': '已删除'}
item = QListWidgetItem(prefix + str(getattr(task, "name")) + f"\n{labels.get(status, status)}")
item.setData(Qt.ItemDataRole.UserRole, str(getattr(task, "task_id")))
item.setIcon(self._project_icon)
@@ -0,0 +1,187 @@
"""Nonmodal preview and sequential import of saved project pairs."""
from threading import Event
from uuid import uuid4
from PySide6.QtCore import QObject, Signal, Qt
from PySide6.QtWidgets import (QDialog, QFileDialog, QHeaderView, QHBoxLayout, QLabel,
QLineEdit, QPushButton, QTableWidget, QTableWidgetItem, QVBoxLayout)
LABELS = {'ready': '可导入', 'missing_before': '缺少修改前工程', 'missing_after': '缺少修改后工程',
'ambiguous': '无法唯一配对', 'imported': '已导入', 'failed': '导入失败,可重试'}
class _Progress(QObject):
changed = Signal(object, int, int)
class VerificationBatchDialog(QDialog):
changed = Signal()
def __init__(self, service, controller, task_id, task_name, parent=None):
super().__init__(parent)
self.service, self.controller, self.task_id = service, controller, task_id
self._phase = None
self._closed = False
self._stop = Event()
self._rows = []
self._selection = []
self.setWindowTitle('批量添加工程对')
self.resize(860, 540)
layout = QVBoxLayout(self)
title = QLabel(f'添加到:{task_name}')
title.setWordWrap(True)
layout.addWidget(title)
explanation = QLabel('按两个目录中的相对路径精确配对;先预览再导入。只建立只读副本,不自动开始校验。')
explanation.setWordWrap(True)
layout.addWidget(explanation)
self.before = QLineEdit(objectName='verificationBeforeRoot')
self.after = QLineEdit(objectName='verificationAfterRoot')
self._browsers = []
for label, field in (('修改前目录', self.before), ('修改后目录', self.after)):
row = QHBoxLayout()
row.addWidget(QLabel(label)); row.addWidget(field, 1)
browse = QPushButton('选择目录')
browse.clicked.connect(lambda _, f=field: self._browse(f))
self._browsers.append(browse); row.addWidget(browse)
layout.addLayout(row)
field.textChanged.connect(self._invalidate)
actions = QHBoxLayout()
self.scan = QPushButton('读取配对', objectName='verificationScanPairs')
self.select_all = QPushButton('全选可导入项')
self.select_none = QPushButton('清空选择')
for button in (self.scan, self.select_all, self.select_none): actions.addWidget(button)
actions.addStretch(); layout.addLayout(actions)
self.table = QTableWidget(0, 4, objectName='verificationPairPreview')
self.table.setHorizontalHeaderLabels(['工程相对路径', '修改前工程', '修改后工程', '状态'])
self.table.setEditTriggers(QTableWidget.EditTrigger.NoEditTriggers)
self.table.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.Stretch)
layout.addWidget(self.table, 1)
self.summary = QLabel('选择前后目录后读取配对。'); self.summary.setWordWrap(True)
layout.addWidget(self.summary)
bottom = QHBoxLayout()
self.import_button = QPushButton('导入所选', objectName='verificationImportPairs')
self.cancel_button = QPushButton('取消当前操作')
close_button = QPushButton('关闭')
bottom.addWidget(self.import_button); bottom.addWidget(self.cancel_button); bottom.addStretch(); bottom.addWidget(close_button)
layout.addLayout(bottom)
self.scan.clicked.connect(self._scan)
self.select_all.clicked.connect(lambda: self._select(Qt.CheckState.Checked))
self.select_none.clicked.connect(lambda: self._select(Qt.CheckState.Unchecked))
self.table.itemChanged.connect(self._selection_changed)
self.import_button.clicked.connect(self._import)
self.cancel_button.clicked.connect(self.cancel_operation)
close_button.clicked.connect(self.reject)
self._gates()
@property
def busy(self): return self._phase is not None
def _browse(self, field):
selected = QFileDialog.getExistingDirectory(self, '选择工程根目录', field.text())
if selected: field.setText(selected)
def _invalidate(self):
if not self.busy:
self._rows = []; self.table.setRowCount(0)
self.summary.setText('目录已改变,请重新读取配对。'); self._gates()
def _selected(self):
return [n for n, row in enumerate(self._rows) if row['status'] in ('ready', 'failed')
and self.table.item(n, 0).checkState() == Qt.CheckState.Checked]
def _gates(self):
for widget in (self.before, self.after, *self._browsers, self.select_all, self.select_none, self.table):
widget.setEnabled(not self.busy)
self.scan.setEnabled(not self.busy and bool(self.before.text().strip()) and bool(self.after.text().strip()))
self.import_button.setEnabled(not self.busy and bool(self._selected()))
self.cancel_button.setEnabled(self.busy and not self._stop.is_set())
def _select(self, state):
for n, row in enumerate(self._rows):
if row['status'] in ('ready', 'failed'): self.table.item(n, 0).setCheckState(state)
def _selection_changed(self):
if not self.busy:
self.summary.setText(f'共 {len(self._rows)} 项,已选 {len(self._selected())} 对;缺失或不唯一的项目不会导入。')
self._gates()
def _scan(self):
before, after = self.before.text().strip(), self.after.text().strip()
self._phase = 'scan'; self._stop = Event(); self._rows = []; self.table.setRowCount(0)
self.summary.setText('正在读取前后目录…'); self._gates()
stop = self._stop
self.controller.command(lambda: self.service.preview_pairs(before, after, stop_event=stop), self._scanned, self._failed)
def _scanned(self, rows):
self._phase = None
if self._closed: return
self._rows = rows
self.table.blockSignals(True)
try:
self.table.setRowCount(len(rows))
for n, row in enumerate(rows):
for col, value in enumerate((row['relative_path'], row['before'] or '—', row['after'] or '—', LABELS[row['status']])):
item = QTableWidgetItem(value); item.setToolTip(value)
if col == 0:
item.setCheckState(Qt.CheckState.Checked if row['status']=='ready' else Qt.CheckState.Unchecked)
if row['status']!='ready': item.setFlags(item.flags() & ~Qt.ItemFlag.ItemIsUserCheckable)
self.table.setItem(n, col, item)
finally: self.table.blockSignals(False)
self._selection_changed()
def _import(self):
self._selection = self._selected()
pairs = tuple((self._rows[n]['before'], self._rows[n]['after']) for n in self._selection)
names = tuple(self._rows[n]['relative_path'] for n in self._selection)
self._phase = 'import'; self._stop = Event()
self.summary.setText(f'正在导入 0/{len(pairs)} 对…'); self._gates()
progress = _Progress(self); progress.changed.connect(self._progress)
stop, request = self._stop, uuid4().hex
self.controller.command(lambda: self.service.import_pairs(self.task_id, pairs, request_id=request,
stop_event=stop, on_progress=progress.changed.emit, display_names=names), self._imported, self._failed)
def _progress(self, row, processed, total):
if self._closed: return
n = self._selection[row['index']]
self._rows[n]['status'] = row['status']
status = self.table.item(n, 3)
status.setText(LABELS[row['status']]); status.setToolTip(row.get('reason', LABELS[row['status']]))
if row['status'] == 'imported':
self.table.item(n, 0).setCheckState(Qt.CheckState.Unchecked)
self.table.item(n, 0).setFlags(self.table.item(n, 0).flags() & ~Qt.ItemFlag.ItemIsUserCheckable)
self.summary.setText(f'已处理 {processed}/{total} 对;单项失败后继续,已导入项予以保留。')
def _imported(self, result):
self._phase = None
self.changed.emit()
if self._closed: return
imported = sum(r['status']=='imported' for r in result['rows'])
failed = sum(r['status']=='failed' for r in result['rows'])
state = '已取消,未处理项可继续导入' if result['cancelled'] else '本批导入完成'
self.summary.setText(f'{state}:已导入 {imported} 对,失败 {failed} 对;尚未开始校验。')
self._gates()
def _failed(self, error):
phase, self._phase = self._phase, None
self.changed.emit()
if self._closed: return
if getattr(error, 'code', None) in ('discovery_cancelled', 'operation_cancelled'):
self.summary.setText('已取消读取,请重新读取配对。')
else:
prefix = '导入中断,已导入项保留:' if phase=='import' else '读取失败:'
self.summary.setText(prefix+str(error))
self._gates()
def cancel_operation(self):
self._stop.set()
if self.busy and not self._closed:
self.summary.setText('正在取消,已导入项保留…'); self._gates()
def reject(self):
self._closed = True; self.cancel_operation()
super().reject()
def closeEvent(self, event):
self._closed = True; self.cancel_operation()
super().closeEvent(event)
@@ -0,0 +1,42 @@
"""Asynchronous verification reads; each selection owns its own query generation."""
from PySide6.QtCore import QObject,QThreadPool,Signal,Slot
from .queries import LatestQuery
from .workers import ServiceWorker
class VerificationController(QObject):
changed=Signal()
failed=Signal(object)
def __init__(self,service,parent=None):
super().__init__(parent);self.service=service;self.task_id=None;self.item_id=None
self.tasks_query=LatestQuery(self);self.task_query=LatestQuery(self);self.item_query=LatestQuery(self)
self.workers={};self.closed=False
for query in (self.tasks_query,self.task_query,self.item_query):query.settled.connect(self.changed)
@property
def busy(self):
return bool(self.workers) or any(q.busy for q in (self.tasks_query,self.task_query,self.item_query)) or getattr(self.service,'busy',False)
def command(self,action,received,failed=None):
if self.closed:return
worker=ServiceWorker(action);self.workers[worker.signals]=(worker,received,failed)
worker.signals.succeeded.connect(self._received);worker.signals.failed.connect(self._failed)
worker.signals.finished.connect(self._finished);QThreadPool.globalInstance().start(worker);self.changed.emit()
@Slot(object)
def _received(self,result):
entry=self.workers.get(self.sender())
if entry and not self.closed:entry[1](result)
@Slot(object)
def _failed(self,error):
entry=self.workers.get(self.sender())
if entry and not self.closed:
(entry[2] or self.failed.emit)(error)
@Slot()
def _finished(self):self.workers.pop(self.sender(),None);self.changed.emit()
def close(self):
self.closed=True
for q in (self.tasks_query,self.task_query,self.item_query):q.close()
@@ -0,0 +1,149 @@
"""Deterministic before/after netlist drawing and matching facts."""
import json
from PySide6.QtCore import QRectF,Qt,Signal
from PySide6.QtCore import QSignalBlocker
from PySide6.QtGui import QColor,QPainter,QPen
from PySide6.QtWidgets import (QWidget,QLabel,QVBoxLayout,QHBoxLayout,QComboBox,QTableWidget,
QTableWidgetItem,QHeaderView,QTabWidget,QScrollArea,QPlainTextEdit,QPushButton)
from ..verification.evidence import PIN_FACT_COLORS,pin_fact,verify_evidence
ATTEMPTS={'queued':'排队中','running':'执行中','publishing':'保存结果中','stopping':'安全收尾中',
'succeeded':'执行完成','failed':'执行失败','cancelled':'已停止','interrupted':'已中断'}
def _choices(combo,rows,selected):
current=[(combo.itemText(n),combo.itemData(n)) for n in range(combo.count())]
with QSignalBlocker(combo):
if current!=rows:
combo.clear()
for label,value in rows:combo.addItem(label,value)
combo.setCurrentIndex(combo.findData(selected))
def pin_text(pin):
if pin is None:return '不存在/未覆盖'
if not pin['nets']:return '明确未连接'
return '\n'.join(n['name']+' · '+', '.join(f'{e[1]}.{e[2]}' for e in n['endpoints'] if e!=[None]) for n in pin['nets'])
class ConnectionDiagram(QWidget):
def __init__(self,parent=None):
super().__init__(parent);self.pins=[];self.facts=[];self.setMinimumSize(320,220)
def set_pins(self,pins,facts):
self.pins=pins;self.facts=facts;self.setMinimumHeight(max(220,100+len(pins)*100));self.update()
def paintEvent(self,event):
painter=QPainter(self);painter.setRenderHint(QPainter.RenderHint.Antialiasing)
painter.fillRect(self.rect(),QColor('#ffffff'));w=self.width()/2
for column,phase,title in ((0,'before','修改前'),(1,'after','修改后')):
x=column*w+12
painter.setPen(QColor('#34445b'));painter.drawText(QRectF(x,8,w-24,26),Qt.AlignmentFlag.AlignLeft,title)
painter.setPen(QPen(QColor('#dfe6ef'),1));painter.drawRoundedRect(QRectF(x,40,w-24,self.height()-55),9,9)
for n,row in enumerate(self.pins):
y=64+n*100;pin=row[phase]
label,state=self.facts[n]
color=QColor(PIN_FACT_COLORS[state])
name=pin['logical_name'] if pin else ('不存在' if label.startswith('器件') else '未覆盖')
change=f' · {label}' if state!='equal' else ''
painter.setPen(color);painter.drawText(QRectF(x+12,y,w-46,24),Qt.AlignmentFlag.AlignLeft,
f"脚 {row['endpoint'][2]} {name}{change}")
painter.drawLine(int(x+18),int(y+37),int(x+40),int(y+37))
painter.setPen(QColor('#516078'))
font=painter.font();font.setPointSizeF(8.5);painter.setFont(font)
painter.drawText(QRectF(x+44,y+24,w-78,64),Qt.TextFlag.TextWordWrap,pin_text(pin))
painter.end()
class VerificationInspector(QWidget):
open_raw=Signal(str)
select_version=Signal(int)
select_attempt=Signal(str)
def __init__(self,parent=None):
super().__init__(parent);self.evidence=None
layout=QVBoxLayout(self);layout.setContentsMargins(12,8,12,8)
self.heading=QLabel('选择工程查看证据',objectName='projectTitle');layout.addWidget(self.heading)
self.coverage=QLabel('未覆盖:封装库内部映射');self.coverage.setWordWrap(True);layout.addWidget(self.coverage)
row=QHBoxLayout();self.components=QComboBox();self.components.setMinimumWidth(100)
self.versions=QComboBox();self.versions.setToolTip('查看历史输入版本,不改变当前输入')
row.addWidget(self.components,1);row.addWidget(self.versions);layout.addLayout(row)
self.attempts=QComboBox();layout.addWidget(self.attempts)
self.issues=QComboBox();layout.addWidget(self.issues)
self.tabs=QTabWidget();layout.addWidget(self.tabs,1)
self.diagram=ConnectionDiagram();scroll=QScrollArea();scroll.setWidgetResizable(True);scroll.setWidget(self.diagram)
self.tabs.addTab(scroll,'前后接线图')
self.pin_table=QTableWidget(0,6);self.pin_table.setHorizontalHeaderLabels(['脚号','前名称','后名称','前连接','后连接','变化'])
self.pin_table.setEditTriggers(QTableWidget.EditTrigger.NoEditTriggers)
self.pin_table.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.ResizeToContents)
self.tabs.addTab(self.pin_table,'逐脚事实')
self.facts=QPlainTextEdit();self.facts.setReadOnly(True);self.tabs.addTab(self.facts,'检查与范围')
self.raw=QComboBox();self.raw_button=QPushButton('打开原始证据')
rawrow=QHBoxLayout();rawrow.addWidget(self.raw,1);rawrow.addWidget(self.raw_button);layout.addLayout(rawrow)
self.raw_button.clicked.connect(lambda:self.open_raw.emit(self.raw.currentData()) if self.raw.currentData() else None)
self.components.currentIndexChanged.connect(self._component)
self.issues.currentIndexChanged.connect(self._issue)
self.versions.activated.connect(lambda _:self.select_version.emit(self.versions.currentData()))
self.attempts.activated.connect(lambda _:self.select_attempt.emit(self.attempts.currentData()) if self.attempts.currentData() else None)
def set_record(self,record):
versions=record.get('versions',sorted({record['current_version'],*(h['input_version'] for h in record['history'])},reverse=True))
_choices(self.versions,[(f'输入 v{v}',v) for v in versions],record['input_version'])
attempts=[(f"第 {e['generation']} 次校验 · {ATTEMPTS.get(e['state'],'未完成')}",e['attempt_id'])
for e in record['history'] if e['input_version']==record['input_version']]
_choices(self.attempts,attempts,record.get('attempt_id'))
result=((record.get('attempt') or {}).get('result') or {})
if record.get('evidence_error'):
self.set_evidence(None);self.heading.setText(record['display_name']+' · 证据不可用')
self.facts.setPlainText(record['evidence_error']);return
evidence=result.get('evidence')
if (evidence or {}).get('digest')!=(self.evidence or {}).get('digest'):self.set_evidence(evidence)
self.heading.setText(record['display_name']+' · '+{'CONSISTENT':'一致','WARNING':'需关注','DIFFERENT':'异常','INCOMPLETE':'无法完整校验'}.get(result.get('verdict'),'待校验'))
details=json.dumps({'范围':result.get('scope',record['scope']),'检查':result.get('checks',[]),
'问题':result.get('issues',[]),'执行原因':result.get('reason') or record.get('reason') or record.get('unavailable_reason'),
'输入摘要':record['payload']['payload_digest'],'尝试':record.get('attempt_id')},ensure_ascii=False,indent=2)
if self.facts.toPlainText()!=details:self.facts.setPlainText(details)
def clear(self):
self.heading.setText('选择工程查看证据');self.facts.clear();self.versions.clear();self.attempts.clear();self.set_evidence(None)
def set_evidence(self,evidence):
if evidence:verify_evidence(evidence)
previous=self.components.currentData()
self.evidence=evidence;self.components.blockSignals(True);self.components.clear();self.issues.blockSignals(True);self.issues.clear();self.raw.clear()
if evidence:
for key in sorted({tuple(p['endpoint'][:2]) for p in evidence['pins']}):self.components.addItem(f'{key[1]} · {key[0]}',key)
self.issues.addItem('全部问题',None)
def priority(issue):
related=sum(i.get('refdes')==issue.get('refdes') and i.get('instance_path')==issue.get('instance_path') for i in evidence['issues'])
return (0 if issue['state']=='error' else 1,-related,issue.get('refdes',''))
for issue in sorted(evidence['issues'],key=priority):self.issues.addItem(f"{issue.get('refdes','工程')} · {issue['reason']}",issue)
for raw in evidence['binding'].get('raw',[]):self.raw.addItem(raw['artifact_id'],raw['artifact_id'])
self.coverage.setText('由网表生成 · 图页未定位\n未覆盖:封装库内部映射、引脚级 Value')
self.components.blockSignals(False);self.issues.blockSignals(False);self._component()
old=next((n for n in range(self.components.count()) if self.components.itemData(n)==previous),-1)
if old>=0:self.components.setCurrentIndex(old)
elif self.issues.count()>1:self.issues.setCurrentIndex(1);self._issue()
def _issue(self):
issue=self.issues.currentData()
if issue:
key=(issue.get('instance_path'),issue.get('refdes'))
index=next((n for n in range(self.components.count()) if tuple(self.components.itemData(n))==key),-1)
if index>=0:self.components.setCurrentIndex(index)
def _component(self):
key=self.components.currentData()
evidence=self.evidence or {}
pins=[p for p in evidence.get('pins',[]) if tuple(p['endpoint'][:2])==key]
issues={issue['issue_id']:issue for issue in evidence.get('issues',())}
facts=[pin_fact(pin,issues) for pin in pins]
self.diagram.set_pins(pins,facts);self.pin_table.setRowCount(len(pins))
for n,row in enumerate(pins):
l,r=row['before'],row['after']
for col,value in enumerate((row['endpoint'][2],l['logical_name'] if l else '未知',r['logical_name'] if r else '未知',pin_text(l),pin_text(r))):
self.pin_table.setItem(n,col,QTableWidgetItem(value))
label,state=facts[n]
cell=QTableWidgetItem(label)
cell.setForeground(QColor(PIN_FACT_COLORS[state]))
self.pin_table.setItem(n,5,cell)
self.pin_table.resizeRowsToContents()
@@ -0,0 +1,280 @@
"""The fourth workspace: independently creatable tasks and continuous handoff."""
from threading import Event
from uuid import uuid4
from PySide6.QtCore import Qt,QTimer,Signal,QSignalBlocker,QItemSelectionModel
from PySide6.QtGui import QColor
from PySide6.QtWidgets import (QWidget,QVBoxLayout,QHBoxLayout,QLabel,QPushButton,QListWidget,QListWidgetItem,
QTableWidget,QTableWidgetItem,QSplitter,QLineEdit,QComboBox,QInputDialog,QFileDialog,QHeaderView)
from .verification_controller import VerificationController
from .verification_inspector import VerificationInspector
LABELS={'consistent':'一致','warning':'需关注','different':'异常','unavailable':'无法校验',
'waiting':'待校验','running':'校验中','stopped':'已停止','interrupted':'已中断'}
class VerificationWorkspace(QWidget):
busy_changed=Signal()
def __init__(self,service,parent=None):
super().__init__(parent);self.service=service.verification;self.controller=VerificationController(self.service,self)
self._active=False;self._closed=False;self._run_id=None;self._rows=[];self._cursor=None;self._intake_stop=Event()
layout=QVBoxLayout(self);layout.setContentsMargins(16,12,16,12)
head=QHBoxLayout();self.title=QLabel('工程校验',objectName='verificationTitle');head.addWidget(self.title);head.addStretch()
self.title.setStyleSheet('font-size:20px;font-weight:600;color:#34445b')
self._scroll_to_selection=False;self._view_version=None;self._view_attempt=None;self._selected_attempt=None
self._page_cursor=None
self._task_list_cursor=None
self._next_tasks_cursor=None
self._previous_tasks_cursors=[]
self.new_button=QPushButton('新建校验',objectName='verificationNew');self.import_button=QPushButton('添加工程对')
self.batch_button=QPushButton('批量添加',objectName='verificationBatchImport');self._batch_dialog=None
head.addWidget(self.import_button);head.addWidget(self.batch_button);head.addWidget(self.new_button);layout.addLayout(head)
description=QLabel('替换完成后接续核对,也可随时添加两份工程独立校验。');description.setWordWrap(True);layout.addWidget(description)
self.splitter=QSplitter();layout.addWidget(self.splitter,1)
left=QWidget();ll=QVBoxLayout(left);ll.setContentsMargins(0,0,8,0);ll.addWidget(QLabel('校验任务'))
self.tasks=QListWidget();ll.addWidget(self.tasks,1)
task_paging=QHBoxLayout()
self.previous_tasks_button=QPushButton('上一页')
self.next_tasks_button=QPushButton('下一页')
self.previous_tasks_button.setAccessibleName('校验任务上一页')
self.next_tasks_button.setAccessibleName('校验任务下一页')
task_paging.addWidget(self.previous_tasks_button)
task_paging.addWidget(self.next_tasks_button)
ll.addLayout(task_paging)
self.state_filter=QComboBox();self.state_filter.addItem('全部工程','')
for key,value in LABELS.items():self.state_filter.addItem(value,key)
ll.addWidget(self.state_filter);self.splitter.addWidget(left)
middle=QWidget();ml=QVBoxLayout(middle);ml.setContentsMargins(4,0,4,0)
self.search=QLineEdit();self.search.setPlaceholderText('搜索工程、位号、料号');self.search.setClearButtonEnabled(True);ml.addWidget(self.search)
controls=QHBoxLayout();self.start_button=QPushButton('开始全部');self.selected_button=QPushButton('校验所选');self.stop_button=QPushButton('停止')
for button in (self.start_button,self.selected_button,self.stop_button):controls.addWidget(button)
ml.addLayout(controls)
self.table=QTableWidget(0,4);self.table.setHorizontalHeaderLabels(['工程','版本','结果','范围'])
self.table.setSelectionBehavior(QTableWidget.SelectionBehavior.SelectRows);self.table.setEditTriggers(QTableWidget.EditTrigger.NoEditTriggers)
self.table.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.Stretch);ml.addWidget(self.table,1)
bottom=QHBoxLayout();self.more_button=QPushButton('下一页');self.rerun_button=QPushButton('重校验');self.export_button=QPushButton('导出报告')
for button in (self.more_button,self.rerun_button,self.export_button):bottom.addWidget(button)
ml.addLayout(bottom);self.splitter.addWidget(middle)
self.inspector=VerificationInspector();self.splitter.addWidget(self.inspector);self.splitter.setSizes([180,430,570])
self.footer=QLabel('新建一个校验任务开始。');self.footer.setWordWrap(True);layout.addWidget(self.footer)
self.notice=QLabel('');self.notice.setWordWrap(True);layout.addWidget(self.notice)
self.new_button.clicked.connect(self._new);self.import_button.clicked.connect(self._import)
self.batch_button.clicked.connect(self._batch_import)
self.tasks.currentItemChanged.connect(self._task_selected);self.table.itemSelectionChanged.connect(self._item_selected)
self.previous_tasks_button.clicked.connect(lambda:self._turn_tasks_page(False))
self.next_tasks_button.clicked.connect(lambda:self._turn_tasks_page(True))
self.state_filter.currentIndexChanged.connect(self._filters_changed);self.search.textChanged.connect(self._search_changed)
self.more_button.clicked.connect(lambda:self.refresh_task(append=True));self.start_button.clicked.connect(lambda:self._start(False))
self.selected_button.clicked.connect(lambda:self._start(True));self.stop_button.clicked.connect(self._stop)
self.rerun_button.clicked.connect(self._rerun);self.export_button.clicked.connect(self._export)
self.inspector.open_raw.connect(self._open_raw);self.inspector.select_version.connect(self._version)
self.inspector.select_attempt.connect(self._attempt)
self.controller.failed.connect(self._error);self.controller.changed.connect(self._gates)
self._timer=QTimer(self);self._timer.setInterval(1500);self._timer.timeout.connect(self._poll)
self._debounce=QTimer(self);self._debounce.setSingleShot(True);self._debounce.setInterval(250);self._debounce.timeout.connect(self._filters_changed)
self._gates()
@property
def busy(self):return self.controller.busy
def _error(self,error):self.notice.setText(str(error))
def _gates(self):
has=bool(self.controller.task_id);item=any(r['item_id']==self.controller.item_id for r in self._rows)
self.import_button.setEnabled(has);self.start_button.setEnabled(has);self.selected_button.setEnabled(has and bool(self.table.selectionModel().selectedRows()))
self.batch_button.setEnabled(has)
self.rerun_button.setEnabled(item);self.export_button.setEnabled(has)
self.stop_button.setEnabled(bool(self._run_id))
can_page=not self.controller.tasks_query.current_busy
self.previous_tasks_button.setEnabled(can_page and bool(self._previous_tasks_cursors))
self.next_tasks_button.setEnabled(can_page and self._next_tasks_cursor is not None)
self.busy_changed.emit()
def set_active(self,active):
self._active=active
if active:
self._timer.start();self.controller.command(self.service.initialize,lambda _:self.refresh())
else:self._timer.stop()
def refresh(self):
if self._closed:return
self._refresh_tasks()
if self.controller.task_id:self.refresh_task()
self._gates()
def _refresh_tasks(self):
cursor=self._task_list_cursor
self.controller.tasks_query.request(
lambda control:self.service.list_tasks(cursor=cursor,read_control=control),
self._tasks_received,self._tasks_failed,cancellable=True)
def _turn_tasks_page(self,forward):
if forward and self._next_tasks_cursor is not None:
self._previous_tasks_cursors.append(self._task_list_cursor)
self._task_list_cursor=self._next_tasks_cursor
elif not forward and self._previous_tasks_cursors:
self._task_list_cursor=self._previous_tasks_cursors.pop()
else:
return
self._refresh_tasks()
self._gates()
def _tasks_failed(self,error):
if self._task_list_cursor is not None and getattr(error,'code',None)=='verification_cursor':
self._task_list_cursor=None
self._previous_tasks_cursors.clear()
self._refresh_tasks()
else:
self._error(error)
def _poll(self):
# Let a slow current read finish; periodic ticks must not keep cancelling it.
queries=(self.controller.tasks_query,self.controller.task_query,self.controller.item_query)
if not self._debounce.isActive() and not any(q.current_busy for q in queries):self.refresh()
def _tasks_received(self,result):
self._next_tasks_cursor=result['cursor']
with QSignalBlocker(self.tasks):
self.tasks.clear()
for row in result['tasks']:
item=QListWidgetItem(row['name']+f" {row['summary']['processed']}/{row['summary']['total']}")
item.setData(Qt.ItemDataRole.UserRole,row['task_id']);self.tasks.addItem(item)
item.setToolTip(row['name'])
if row['task_id']==self.controller.task_id:self.tasks.setCurrentItem(item)
if not self.controller.task_id and self.tasks.count():self.open_task(self.tasks.item(0).data(Qt.ItemDataRole.UserRole))
def open_task(self,task_id,item_id=None):
self.controller.task_id=task_id;self.controller.item_id=item_id;self._cursor=None;self._run_id=None;self.notice.clear()
self._scroll_to_selection=True;self._view_version=None;self._view_attempt=None;self._selected_attempt=None
self._rows=[];self._page_cursor=None
with QSignalBlocker(self.table):self.table.setRowCount(0)
self.controller.item_query.invalidate();self.inspector.clear();self.refresh();self._gates()
def _task_selected(self,item,previous):
if item:self.open_task(item.data(Qt.ItemDataRole.UserRole))
def _search_changed(self):
self._page_cursor=None;self._cursor=None;self._debounce.start()
def _filters_changed(self,*_):
self._page_cursor=None;self._cursor=None;self.refresh_task()
def refresh_task(self,*_,append=False):
task=self.controller.task_id
if not task or self._closed:return
cursor=self._cursor if append else self._page_cursor
state,query=self.state_filter.currentData(),self.search.text()
self.controller.task_query.request(lambda control:self.service.read_task(task,state=state,
query=query,cursor=cursor,read_control=control),lambda result:self._task_received(result,cursor),
lambda error:self._task_failed(error,cursor),cancellable=True)
def _task_failed(self,error,cursor):
if getattr(error,'code',None)=='verification_cursor' and cursor is not None:
self._page_cursor=None;self._cursor=None;self.refresh_task()
else:self._error(error)
def _task_received(self,result,cursor):
self._run_id=(result.get('run') or {}).get('run_id')
selected_ids={self._rows[i.row()]['item_id'] for i in self.table.selectionModel().selectedRows() if i.row()<len(self._rows)}
previous=self._rows;self._rows=result['items'];self._page_cursor=cursor;self._cursor=result['cursor']
selected=self.controller.item_id
if selected and not selected_ids:selected_ids.add(selected)
if previous!=self._rows:
with QSignalBlocker(self.table):
self.table.setRowCount(len(self._rows));self.table.clearSelection();self.table.setCurrentCell(-1,-1)
for n,row in enumerate(self._rows):
for col,value in enumerate((row['display_name'],str(row['input_version']),LABELS[row['status']],row['scope'])):
cell=QTableWidgetItem(value);cell.setData(Qt.ItemDataRole.UserRole,row['item_id']);self.table.setItem(n,col,cell)
cell.setToolTip(value)
if col==2:cell.setForeground(QColor({'different':'#b83d4a','warning':'#9c6b1e','consistent':'#39817d'}.get(row['status'],'#61758e')))
if row['item_id'] in selected_ids:
self.table.selectionModel().select(self.table.model().index(n,0),QItemSelectionModel.SelectionFlag.Select|QItemSelectionModel.SelectionFlag.Rows)
if row['item_id']==selected:self.table.setCurrentCell(n,0,QItemSelectionModel.SelectionFlag.NoUpdate)
if self._scroll_to_selection and self.table.currentRow()>=0:
self.table.scrollToItem(self.table.item(self.table.currentRow(),0));self._scroll_to_selection=False
self.more_button.setEnabled(bool(self._cursor))
s=result['summary'];self.footer.setText(f"已处理 {s['processed']}/{s['total']} · 一致 {s['consistent']} · 关注 {s['warning']} · 异常 {s['different']} · 无法校验 {s['unavailable']} · 待校验 {s['waiting']}")
if selected:self._load_item(selected,self._view_version,self._view_attempt)
self._gates()
def _item_selected(self):
row=self.table.currentRow()
if 0<=row<len(self._rows):
self._view_version=None;self._view_attempt=None;self.controller.item_id=self._rows[row]['item_id'];self._load_item(self.controller.item_id);self._gates()
def _load_item(self,item,version=None,attempt=None):
self.controller.item_query.request(lambda control:self.service.read_item(item,version=version,attempt_id=attempt,read_control=control),self._record_received,self._error,cancellable=True)
def _record_received(self,record):
self._selected_attempt=record['attempt_id'];self.inspector.set_record(record)
def _attempt(self,attempt):
self._view_attempt=attempt
if self.controller.item_id:self._load_item(self.controller.item_id,attempt=attempt)
def _version(self,version):
self._view_version=version
self._view_attempt=None
if self.controller.item_id:self._load_item(self.controller.item_id,version)
def _new(self):
name,ok=QInputDialog.getText(self,'新建校验','任务名称',text='校验任务')
if ok and name.strip():
self.controller.command(lambda:self.service.create_task(name.strip(),request_id=uuid4().hex),self._open_new_task)
def _open_new_task(self,row):
self._task_list_cursor=None
self._previous_tasks_cursors.clear()
self.open_task(row['task_id'])
def _import(self):
task=self.controller.task_id
before,_=QFileDialog.getOpenFileName(self,'选择修改前工程','','DxDesigner (*.prj)')
if not before:return
after,_=QFileDialog.getOpenFileName(self,'选择修改后工程','','DxDesigner (*.prj)')
if after:
self.controller.command(lambda:self.service.import_pair(task,before,after,request_id=uuid4().hex,stop_event=self._intake_stop),lambda _:self.refresh())
def _start(self,selected):
task=self.controller.task_id
selection=tuple((self._rows[i.row()]['item_id'],self._rows[i.row()]['input_version']) for i in self.table.selectionModel().selectedRows()) if selected else None
if task:self.controller.command(lambda:self.service.start(task,selection=selection,request_id=uuid4().hex),self._started)
def _batch_import(self):
if self._batch_dialog is not None and (self._batch_dialog.isVisible() or self._batch_dialog.busy):
if self._batch_dialog.isVisible():self._batch_dialog.raise_();self._batch_dialog.activateWindow()
else:self.notice.setText('上一批正在取消,已导入项会保留,请稍候。')
return
from .verification_batch_import import VerificationBatchDialog
current=self.tasks.currentItem()
name=current.text() if current else '校验任务'
self._batch_dialog=VerificationBatchDialog(self.service,self.controller,self.controller.task_id,name,self)
self._batch_dialog.changed.connect(self.refresh);self._batch_dialog.show()
def _started(self,result):self._run_id=result['run_id'];self.refresh()
def _stop(self):
run_id=self._run_id
if run_id:self.controller.command(lambda:self.service.stop(run_id,request_id=uuid4().hex),lambda _:self.refresh())
def _rerun(self):
item=self.controller.item_id
row=next((r for r in self._rows if r['item_id']==item),None)
if row:self.controller.command(lambda:self.service.rerun(item,row['input_version'],request_id=uuid4().hex),self._started)
def _export(self):
task=self.controller.task_id;folder=QFileDialog.getExistingDirectory(self,'选择报告保存位置')
if folder:self.controller.command(lambda:self.service.export_task(task,folder,request_id=uuid4().hex),lambda result:self.notice.setText('报告已保存:'+str(result)))
def _open_raw(self,artifact):
attempt=self._selected_attempt
if attempt:self.controller.command(lambda:self.service.open_evidence(attempt,artifact),lambda _:None)
def begin_shutdown(self):
self._timer.stop();self._intake_stop.set()
if self._batch_dialog is not None:self._batch_dialog.cancel_operation()
for query in (self.controller.tasks_query,self.controller.task_query,self.controller.item_query):query.invalidate()
if hasattr(self.service,'begin_shutdown'):self.service.begin_shutdown()
def shutdown(self):
if self._closed:return
self._closed=True;self.begin_shutdown();self.controller.close()
@@ -37,14 +37,28 @@ def _fields(line):
return tuple(_decode_vbs_field(field) for field in line.split('\t'))
def _validated(root, row, outcome):
def _validated(root, row, outcome, *, project_commit=None):
raw, _, snapshot_path = _paths(root, row)
state, code, message = outcome
if state not in {'saved_ok', 'restored_ok'}:
raise ValueError('Value report requires a verified replacement terminal state')
status_bytes = _read(internal_path(root) / 'status.tsv')
terminal = _fields(status_bytes.decode('utf-8-sig').splitlines()[-1])
if terminal != (row['job_id'], state, code, message):
if project_commit is not None:
from .execution_proof import proof_intact
from .path_access import canonical_path
if (code != 'project_committed' or not proof_intact(project_commit)
or canonical_path(project_commit['project_path']) != canonical_path(row['project_path'])
or project_commit['outcomes'].get(row['job_id']) != state):
raise ValueError('Value report has no matching intact project commit')
marker = internal_path(project_commit['files'][0]['path'])
lines = [_fields(line) for line in _read(marker).decode('utf-8-sig').splitlines() if line]
if (lines[0] != (project_commit['session_token'],row['project_path'],'project_verified')
or [fields[0] for fields in lines[1:]] != project_commit['jobs']
or dict(lines[1:]) != project_commit['outcomes']):
raise ValueError('Value report project commit marker differs')
terminal = (row['job_id'],state,code,message)
elif terminal != (row['job_id'], state, code, message):
raise ValueError('Value report does not belong to the current terminal job')
raw_bytes, snapshot_bytes = _read(raw), _read(snapshot_path)
snapshot = snapshot_bytes.decode('utf-8-sig')
@@ -74,8 +88,10 @@ def _validated(root, row, outcome):
if row.get('target_scope') == 'targets':
selected = {parts[0]: parts[1] for selector in selectors.split('\x1e')
if len(parts := selector.split('\x1f')) == 3}
if components != selected:
raise ValueError('Value snapshot UID set differs from frozen command')
expected_refs = {ref.strip().casefold() for ref in selected.values()}
if (not selected or len(expected_refs) != len(selected)
or {ref.strip().casefold() for ref in components.values()} != expected_refs):
raise ValueError('Value snapshot physical reference set differs from frozen command')
values, observations, seen, ordinals = [], [], set(), set()
names = {}
for line in lines[1:]:
@@ -117,14 +133,28 @@ def _validated(root, row, outcome):
value_readback_job_id=row['job_id'], project_path=row['project_path'],
schematic_name=row.get('schematic_name', ''), sheet_number=row.get('sheet_number', ''),
attribute_observations=observations, attribute_ambiguities=ambiguities)
binding = dict(command=dict(row), terminal=list(terminal), status_sha256=_digest(status_bytes),
binding = dict(command=dict(row), terminal=list(terminal), status_sha256=None if project_commit else _digest(status_bytes),
snapshot_sha256=_digest(snapshot_bytes), report_sha256=_digest(raw_bytes))
if project_commit is not None:
binding['project_commit'] = project_commit
return details, binding
def capture_value_readback(root, row, outcome):
def capture_value_readback(root, row, outcome, *, project_commit=None):
try:
details, binding = _validated(root, row, outcome)
if project_commit and project_commit.get('validation_required') == 'saved_netlist_v1':
saved = project_commit['saved_netlist']
details = saved['jobs'][row['job_id']]
binding = dict(command=dict(row),terminal=[row['job_id'],*outcome],
verification_path=saved['verification_path'], verification_sha256=saved['verification_sha256'],
export_path=saved['export_path'], export_sha256=saved['export_sha256'])
if (saved.get('status') != 'verified' or details.get('value_readback_status') != 'verified'
or details.get('value_readback_job_id') != row['job_id'] or outcome[0] != 'saved_ok'):
raise ValueError('saved native target Value proof differs')
_, path, _ = _paths(root,row)
write_record(path,dict(schema=3,binding=binding,details=details))
return details
details, binding = _validated(root, row, outcome, project_commit=project_commit)
_, saved, _ = _paths(root, row)
write_record(saved, dict(schema=2, binding=binding, details=details))
return details
@@ -134,11 +164,28 @@ def capture_value_readback(root, row, outcome):
return {'value_readback_status': 'rejected', 'value_readback_reason': str(error)}
def _load_saved_netlist_value(binding,row,outcome):
if (binding['command'] != dict(row) or binding['terminal'] != [row['job_id'],*outcome]
or _digest(_read(internal_path(binding['verification_path']))) != binding['verification_sha256']
or _digest(_read(internal_path(binding['export_path']))) != binding['export_sha256']):
raise ValueError('saved native Value evidence binding changed')
verified = json.loads(_read(internal_path(binding['verification_path'])))
if (verified['status'] != 'verified' or verified['export_path'] != binding['export_path']
or verified['export_sha256'] != binding['export_sha256']):
raise ValueError('saved native target verification is incomplete')
return verified['jobs'][row['job_id']]
def load_value_readback(root, row, outcome):
try:
details, binding = _validated(root, row, outcome)
_, saved, _ = _paths(root, row)
persisted = json.loads(_read(saved))
if persisted.get('schema') == 3:
details = _load_saved_netlist_value(persisted['binding'],row,outcome)
if details != persisted['details']:raise ValueError('persisted native Value observation changed')
return details
details, binding = _validated(root, row, outcome,
project_commit=persisted.get('binding',{}).get('project_commit'))
if persisted != dict(schema=2, binding=binding, details=details):
raise ValueError('persisted Value evidence binding changed')
return details
@@ -0,0 +1 @@
"""Independent, read-only project verification and traceable evidence."""
@@ -0,0 +1,87 @@
"""Exact directory pairing and resumable, sequential snapshot intake."""
import errno
from pathlib import Path
from ..errors import TaskCenterError
from ..project_tasks import scan_project_directory
from .contracts import digest, fail
def preview_pairs(before_root, after_root, *, excluded_roots=(), stop_event=None):
given_roots = (before_root, after_root)
before_root, after_root = Path(before_root).resolve(), Path(after_root).resolve()
if before_root.is_relative_to(after_root) or after_root.is_relative_to(before_root):
fail('前后目录不能相同或互相包含。', 'verification_pair_roots')
sides = []
for given_root, root in zip(given_roots, (before_root, after_root)):
groups = {}
for path in scan_project_directory(given_root, excluded_roots=excluded_roots, stop_event=stop_event):
relative = path.relative_to(root).as_posix()
groups.setdefault(relative.casefold(), []).append((relative, str(path)))
sides.append(groups)
rows = []
left, right = sides
for key in sorted(left.keys() | right.keys()):
a, b = left.get(key, []), right.get(key, [])
status = ('ambiguous' if len(a)>1 or len(b)>1 else
'missing_before' if not a else 'missing_after' if not b else 'ready')
rows.append({'relative_path': (a or b)[0][0],
'before': a[0][1] if len(a)==1 else None,
'after': b[0][1] if len(b)==1 else None, 'status': status})
return rows
def import_pairs(service, task_id, pairs, *, request_id, stop_event, on_progress=None, display_names=None):
pairs = tuple((str(a), str(b)) for a, b in pairs)
names = tuple(display_names) if display_names is not None else (None,) * len(pairs)
if len(names) != len(pairs) or any(n is not None and (not isinstance(n, str) or not n.strip()) for n in names):
fail('工程名称必须与工程对一一对应。')
body = [task_id, pairs, names]
result = {'rows': [], 'processed': 0, 'total': len(pairs), 'cancelled': False}
# Successful item receipts survive cancellation; replay never captures them twice.
with service._intake_lock:
service.repo.task(task_id)
with service.repo.store.transaction():
old = service.repo._request('import-batch', request_id, body)
if old is not None:
return old
if service.repo._request('import-batch-input', request_id, body) is None:
service.repo._remember('import-batch-input', request_id, body, {'bound': True})
for index, (before, after) in enumerate(pairs):
if stop_event.is_set():
result['cancelled'] = True
break
row = {'index': index, 'before': before, 'after': after}
try:
receipt = service.import_pair(task_id, before, after,
request_id='batch-row:'+digest([request_id, index, before, after]), stop_event=stop_event,
display_name=names[index])
if receipt['accepted'] or receipt['duplicates']:
row.update(status='imported', receipt=receipt)
else:
reason = ';'.join(r['reason'] for r in receipt['rejected']) or '工程未被任务接收。'
if names[index] is not None and len(names[index])>256:
reason = '相对路径超过256字符,请缩短目录层级或使用“添加工程对”。'
row.update(status='failed', reason=reason, receipt=receipt)
except TaskCenterError as error:
if error.code == 'operation_cancelled':
result['cancelled'] = True
break
row.update(status='failed', reason=str(error))
except OSError as error:
# Storage failures affect the whole batch; source-file failures affect one pair.
destination = Path(error.filename).resolve() if error.filename else None
if error.errno in (errno.ENOSPC, errno.EDQUOT, errno.EIO) or (
destination is not None and destination.is_relative_to(service.data_root)):
raise
row.update(status='failed', reason=str(error))
except ValueError as error:
row.update(status='failed', reason=str(error))
result['rows'].append(row)
result['processed'] += 1
if on_progress:
on_progress(row, result['processed'], result['total'])
if not result['cancelled']:
with service.repo.store.transaction():
service.repo._remember('import-batch', request_id, body, result)
return result
@@ -0,0 +1,114 @@
"""Versioned input contracts and conclusions independent of execution status."""
import copy
import hashlib
import json
import re
from ..errors import TaskCenterError
CHECKS = frozenset(('inputs','coverage','components','physical_pins','connections','net_names',
'declared_attributes','attribute_changes','pin_text','pin_semantics','footprint_mapping','export_identity'))
STATES = frozenset(('equal','expected_change','warning','error','unknown','not_requested'))
ACTIVE = ('queued','running','publishing','stopping')
TERMINAL = ('succeeded','failed','cancelled','interrupted')
def fail(message, code='verification_input'):
raise TaskCenterError(code, message)
def digest(value):
return hashlib.sha256(json.dumps(value, sort_keys=True, ensure_ascii=False,
separators=(',', ':'), allow_nan=False).encode('utf-8')).hexdigest()
def identifier(value):
if not isinstance(value, str) or not value.strip() or len(value) > 256 or any(ord(c) < 32 for c in value):
fail('标识不能为空或包含控制字符。')
return value
def artifact_ref(value):
if value is None:
return None
if (not isinstance(value, dict) or set(value) != {'manifest_id','sha256'}
or re.fullmatch('[0-9a-f]{32}', str(value['manifest_id'])) is None
or re.fullmatch('[0-9a-f]{64}', str(value['sha256'])) is None):
fail('校验证据引用无效。')
return dict(value)
def default_plan():
return {'policy_version': 'verification-v1',
'required_checks': ['inputs','coverage','components','physical_pins','connections','net_names'],
'optional_checks': ['attribute_changes','pin_text','pin_semantics','export_identity'],
'excluded_checks': ['footprint_mapping']}
def validate_plan(plan):
if not isinstance(plan, dict) or set(plan) != {'policy_version','required_checks','optional_checks','excluded_checks'}:
fail('检查计划字段不完整。')
if plan['policy_version'] != 'verification-v1':
fail('不支持的校验策略版本。')
groups = [plan[key] for key in ('required_checks','optional_checks','excluded_checks')]
if any(not isinstance(group, (list,tuple)) for group in groups):
fail('检查范围必须为列表。')
flat = [key for group in groups for key in group]
if not groups[0] or any(not isinstance(key,str) or key not in CHECKS for key in flat) or len(set(flat)) != len(flat):
fail('检查范围为空、重复或包含未知项目。')
return copy.deepcopy(plan)
def validate_input(value):
allowed = {'item_key','project_key','input_version','before_ref','after_ref','expectation_ref',
'check_plan','display_name','unavailable_reason','handoff_saved_items'}
required = {'item_key','project_key','input_version','before_ref','after_ref','expectation_ref','check_plan'}
if not isinstance(value,dict) or set(value) - allowed or not required <= set(value):
fail('校验输入字段不完整或包含不支持字段。')
result = copy.deepcopy(value)
for key in ('item_key','project_key'):
identifier(result[key])
if type(result['input_version']) is not int or not 1 <= result['input_version'] <= 2**31-1:
fail('输入版本必须为正整数。')
if 'handoff_saved_items' in result:
count=result['handoff_saved_items']
if type(count) is not int or count<1:fail('交接回执的已保存数量无效。')
for key in ('before_ref','after_ref','expectation_ref'):
result[key] = artifact_ref(result[key])
result['check_plan'] = validate_plan(result['check_plan'])
result['display_name'] = identifier(result.get('display_name') or result['project_key'])
reason = result.get('unavailable_reason','')
if not isinstance(reason,str) or len(reason)>4000:
fail('不可用原因无效。')
if not result['before_ref'] or not result['after_ref']:
reason = reason or '缺少替换前或替换后的可信副本。'
result.update(input_state='unavailable' if reason else 'ready', unavailable_reason=reason)
result['payload_digest'] = digest(result)
return result
def rollup_results(checks, *, required_checks, optional_checks=()):
if not required_checks or any(key not in CHECKS for key in (*required_checks,*optional_checks)):
fail('必查项目不能为空。', 'verification_check_plan')
states = {}
partial = set()
for row in checks:
key, state = row.get('check_id'), row.get('state')
if key not in CHECKS or state not in STATES or key in states:
fail('检查结果包含重复或未知项目。', 'verification_result')
states[key] = state
if row.get('coverage')=='partial': partial.add(key)
requested = tuple(dict.fromkeys((*required_checks,*optional_checks)))
unknown = [key for key in requested if key in partial or states.get(key, 'unknown') in {'unknown','not_requested'}]
if any(state=='error' for state in states.values()):
verdict = 'DIFFERENT'
elif any(key in unknown for key in required_checks):
verdict = 'INCOMPLETE'
elif any(state=='warning' for state in states.values()):
verdict = 'WARNING'
else:
verdict = 'CONSISTENT'
return {'verdict': verdict, 'coverage': 'partial' if unknown else 'complete',
'unknown_checks': unknown, 'checked': [key for key in requested if key not in unknown],
'warnings': sum(state=='warning' for state in states.values()),
'errors': sum(state=='error' for state in states.values())}
@@ -0,0 +1,171 @@
"""Frozen run membership and cooperative cancellation for the verification domain."""
import json
from threading import Event,Thread,RLock
from uuid import uuid4
from .contracts import ACTIVE,digest,fail
from .store import encode,now
from .ownership import owner_path,write_owner,read_owner,RunStop
class VerificationControl:
def __init__(self,service):
self.service=service;self.repo=service.repo;self.lock=RLock();self.events={};self.thread=None;self.closing=False
self.last_error=None
self.owner_id=uuid4().hex;self._owned_runs=set()
@property
def busy(self):
with self.lock:return bool(self.thread and self.thread.is_alive())
def start(self,task_id,*,selection,request_id):
if self.closing:fail('校验执行器已暂停:'+self.last_error if self.last_error else '校验执行器正在安全关闭。')
body=[task_id,selection]
with self.repo.store.transaction():
old=self.repo._request('start',request_id,body)
if old is not None:return old
self.repo.task(task_id)
active=self.repo.connection.execute("SELECT * FROM verification_runs WHERE task_id=? AND state IN ('queued','running','stopping') ORDER BY created LIMIT 1",(task_id,)).fetchone()
if active:
result={'run_id':active['run_id'],'members':json.loads(active['members_json'])}
members={(row['item_id'],row['input_version']) for row in result['members']}
if selection is not None and not all(tuple(value) in members for value in selection):
fail('当前校验正在运行,未包含所选工程或版本。请等本次运行结束后再启动。','verification_run_active')
else:
rows=self.service.queries._rows(task_id)
wanted=set(tuple(v) for v in selection) if selection is not None else None
members=[];run_id=uuid4().hex
for row in rows:
identity=(row['item_id'],row['input_version'])
if wanted is not None and identity not in wanted:continue
if not row['can_start']:continue
# Start all only processes waiting/interrupted items; explicit selection permits recheck.
if wanted is None and row['status'] not in {'waiting','interrupted'}:continue
attempt=self.repo.create_attempt(*identity,request_id='run-attempt:'+run_id+':'+row['item_id'],run_id=run_id)
members.append({'item_id':identity[0],'input_version':identity[1],'attempt_id':attempt['attempt_id']})
if wanted and wanted-{(m['item_id'],m['input_version']) for m in members}:fail('所选版本已变化或正在执行,请刷新。')
self.repo.connection.execute('INSERT INTO verification_runs(run_id,task_id,members_json,state,created) VALUES (?,?,?,?,?)',
(run_id,task_id,encode(members),'queued' if members else 'completed',now()))
write_owner(self.service,'runs',run_id,self.owner_id)
result={'run_id':run_id,'members':members}
self.repo._remember('start',request_id,body,result)
owner=read_owner(self.service,'runs',result['run_id'])
if owner.get('owner_id')==self.owner_id and result['members']:
with self.lock:self._owned_runs.add(result['run_id'])
self.wake()
return result
def wake(self):
with self.lock:
if self._owned_runs and not self.closing and not self.busy:
self.thread=Thread(target=self._dispatch,name='verification-runner',daemon=True);self.thread.start()
def stop(self,run_id,*,request_id):
with self.repo.store.transaction():
old=self.repo._request('stop',request_id,run_id)
if old is not None:return old
run=self.repo._one('verification_runs','run_id',run_id)
self.repo.connection.execute("UPDATE verification_runs SET stop_requested=1,state=CASE WHEN state='queued' THEN 'stopped' WHEN state='running' THEN 'stopping' ELSE state END WHERE run_id=?",(run_id,))
for member in json.loads(run['members_json']):
self.repo.connection.execute("UPDATE verification_attempts SET state='cancelled',reason='run_stopped_before_dispatch',resource_state='released',updated=? WHERE attempt_id=? AND state='queued'",(now(),member['attempt_id']))
self.repo._touch(run['task_id']);result={'run_id':run_id,'stop_requested':True}
self.repo._remember('stop',request_id,run_id,result)
with self.lock:self.events.setdefault(run_id,Event()).set()
return result
def _next_run(self):
with self.lock:owned=tuple(self._owned_runs)
if not owned:return None
placeholders=','.join('?' for _ in owned)
return self.repo.connection.execute(f"SELECT * FROM verification_runs WHERE state='queued' AND run_id IN ({placeholders}) ORDER BY created LIMIT 1",owned).fetchone()
def _dispatch(self):
from .runner import run_attempt
try:
while not self.closing:
with self.repo.store.transaction():
run=self._next_run()
if run is None:return
run=dict(run)
if not run['stop_requested']:
self.repo.connection.execute("UPDATE verification_runs SET state='running' WHERE run_id=?",(run['run_id'],))
with self.lock:event=self.events.setdefault(run['run_id'],Event())
stop=RunStop(self.service,run['run_id'],event)
if run['stop_requested']:event.set()
blocked=False
for member in json.loads(run['members_json']):
result={}
if stop.is_set() or self.closing:break
while not stop.is_set() and not self.closing:
result=run_attempt(self.service,member['attempt_id'],stop_event=event)
if not result.get('waiting'):break
event.wait(.2)
if result.get('blocked'):blocked=True;break
with self.repo.store.transaction():
state='blocked' if blocked else 'stopped' if stop.is_set() or self.closing else 'completed'
self.repo.connection.execute('UPDATE verification_runs SET state=? WHERE run_id=?',(state,run['run_id']))
self.repo._touch(run['task_id'])
with self.lock:self._owned_runs.discard(run['run_id'])
except Exception as error:
self.closing=True;self.last_error=str(error)
from ..batch_resources import write_record
try:write_record(self.service.data_root/'verification/engine-paused.json',{
'reason':str(error),'error':type(error).__name__,'replayed':False})
except OSError:pass
finally:
with self.lock:
self.thread=None
# Close the enqueue/empty-dispatch race without polling from the UI.
if not self.closing:
with self.repo.store._lock:
pending=self._next_run()
if pending:self.wake()
def recover(self):
if self.busy:return {'interrupted':0,'blocked':0,'published':0}
result={'interrupted':0,'blocked':0,'published':0,'live_owners':0}
with self.repo.store.transaction():
active_runs=self.repo.connection.execute("SELECT run_id FROM verification_runs WHERE state IN ('queued','running','stopping')").fetchall()
protected=set()
for run in active_runs:
owner=read_owner(self.service,'runs',run[0])
if owner['state']=='live' and owner.get('owner_id')!=self.owner_id:protected.add(run[0])
rows=self.repo.connection.execute("SELECT * FROM verification_attempts WHERE state IN ('queued','running','publishing','stopping')").fetchall()
for raw in rows:
row=dict(raw);identity=row['attempt_id'];directory=self.service.data_root/'verification'/'attempts'/identity
if row['run_id'] in protected:continue
owner=read_owner(self.service,'attempts',identity,row['owner_id'])
if owner['state']=='live' and owner.get('owner_id')!=self.owner_id:
if row['run_id']:protected.add(row['run_id'])
continue
if row['state']=='queued':state,resource='interrupted','released'
else:
try:
ready=json.loads((directory/'result-ready.json').read_text(encoding='utf-8'))
value=self.service.artifacts.read(ready['result_ref'],'result')
if value['attempt_id']!=identity or value['generation']!=row['generation']:raise ValueError('身份不符')
from .report import validate_result
validate_result(value,self.service.data_root)
if row['state'] in {'running','publishing'} and self.repo.finish(identity,generation=row['generation'],result=dict(value,result_ref=ready['result_ref'])):
result['published']+=1;continue
except (OSError,ValueError,KeyError,ImportError):pass
try:
proof=json.loads((directory/'resource-released.json').read_text(encoding='utf-8'))
if proof['owner_id']!=row['owner_id'] or proof['resource_state']!='released':raise ValueError('退出未知')
state,resource='interrupted','released'
except (OSError,ValueError,KeyError):state,resource='stopping','unknown'
self.repo.connection.execute('UPDATE verification_attempts SET state=?,resource_state=?,reason=?,updated=? WHERE attempt_id=?',
(state,resource,'上次执行中断;未自动重跑' if resource=='released' else '上次原生进程退出缺少证明,保留现场',now(),identity))
self.repo._touch(self.repo.item(row['item_id'])['task_id'])
result['blocked' if resource=='unknown' else 'interrupted']+=1
for run in active_runs:
if run[0] not in protected:self.repo.connection.execute("UPDATE verification_runs SET state='interrupted' WHERE run_id=?",(run[0],))
result['live_owners']=len(protected)
return result
def begin_shutdown(self):
if self.closing:return
self.closing=True
with self.lock:runs=tuple(self._owned_runs)
for identity in runs:self.stop(identity,request_id='shutdown:'+identity)
with self.lock:
for event in self.events.values():event.set()
@@ -0,0 +1,67 @@
"""One immutable fact model for diagrams, tables and reports."""
import copy
import re
from .contracts import digest,fail
from .rules import physical_view
def pin_sort(value):
return tuple((0,int(part)) if part.isdigit() else (1,part) for part in re.split(r'(\d+)',str(value)))
def build_evidence(before_graph,after_graph,issues,*,binding):
views=[];limitations=[]
for graph in (before_graph,after_graph):
try:views.append(physical_view(graph))
except (ValueError,TypeError,KeyError) as error:views.append({});limitations.append(str(error))
left,right=views;pins=[]
for endpoint in sorted(left.keys()|right.keys(),key=lambda e:(e[:2],pin_sort(e[2]))):
l,r=left.get(endpoint),right.get(endpoint)
associated=[i['issue_id'] for i in issues if i.get('instance_path')==endpoint[0]
and i.get('refdes')==endpoint[1] and (i.get('pin_number') in (None,endpoint[2]))]
connection_changed=any(i['issue_id'] in associated and i['check_id'] in {'connections','physical_pins'} and i['state']=='error' for i in issues)
pins.append({'endpoint':list(endpoint),'before':l,'after':r,'issue_ids':associated,
'connection_changed':connection_changed,
'text_changed':bool(l and r and l['logical_name']!=r['logical_name'])})
result={'schema_version':1,'binding':copy.deepcopy(binding),'issues':copy.deepcopy(list(issues)),
'pins':pins,'page':None,'label':'由网表生成','limitations':limitations+['未覆盖:封装库内部映射']}
result['digest']=digest(result)
return result
def verify_evidence(evidence):
if evidence.get('digest')!=digest({k:v for k,v in evidence.items() if k!='digest'}):
fail('证据包摘要不符。','verification_evidence')
def pin_fact(pin, issues_by_id):
"""Interpret stored issues without changing the historical evidence digest."""
checks={issue['check_id'] for identity in pin['issue_ids']
if (issue:=issues_by_id.get(identity)) and issue['state']=='error'}
labels=[]
if 'components' in checks:
labels.append('器件新增' if pin['before'] is None else '器件删除')
if 'physical_pins' in checks:
labels.append('物理脚变化')
if 'connections' in checks:
labels.append('连接变化')
if 'net_names' in checks:
labels.append('网名变化')
if pin['text_changed']:
labels.append('引脚名称变化')
if labels:
return '、'.join(labels),'error' if checks else 'warning'
if pin['before'] is None or pin['after'] is None:
return '无法确认','unknown'
return '未发现变化','equal'
PIN_FACT_COLORS={'error':'#b83d4a','warning':'#9c6b1e','unknown':'#61758e','equal':'#39817d'}
def connection_view(evidence,issue_id):
verify_evidence(evidence)
issue=next((i for i in evidence['issues'] if i['issue_id']==issue_id),None)
if issue is None:fail('问题记录不存在。')
return {'issue':issue,'pins':[p for p in evidence['pins'] if p['endpoint'][:2]==[issue.get('instance_path'),issue.get('refdes')]],
'page':evidence['page'],'binding':evidence['binding'],'label':evidence['label']}
@@ -0,0 +1,98 @@
"""Managed immutable inputs; native tools never receive arbitrary live paths."""
import json
import logging
from pathlib import Path
import shutil
from uuid import uuid4
from .. import native_netlist
from ..batch_resources import write_record
from ..operation_control import check_cancelled
from ..native_inventory import _project_options
from ..path_access import internal_path
from .contracts import artifact_ref, fail
class ArtifactStore:
def __init__(self, data_root):
self.data_root = Path(data_root).resolve()
self.root = self.data_root/'verification'/'artifacts'
def directory(self, identity):
artifact_ref({'manifest_id':identity,'sha256':'0'*64})
path = self.root/identity
if path.resolve().parent != self.root.resolve(): fail('证据目录越界。')
return path
def put(self, kind, payload, *, identity=None):
identity = identity or uuid4().hex
directory = self.directory(identity); directory.mkdir(parents=True,exist_ok=True)
manifest = directory/'manifest.json'
if manifest.exists(): fail('不可覆盖已有校验证据。')
write_record(manifest, {'schema_version':1,'kind':kind,'payload':payload})
return {'manifest_id':identity,'sha256':native_netlist._hash(manifest)}
def read(self, ref, kind):
artifact_ref(ref)
if not ref: fail('缺少校验证据。')
directory = self.directory(ref['manifest_id'])
path = directory/'manifest.json'
try:
if native_netlist._hash(path) != ref['sha256']: fail('证据清单摘要不符。')
manifest = json.loads(path.read_text(encoding='utf-8'))
if manifest.get('schema_version') != 1 or manifest.get('kind') != kind: fail('证据类型不符。')
payload = manifest['payload']
if kind == 'snapshot':
capture_root = Path(payload['root']).resolve()
if capture_root != (directory/'capture').resolve(): fail('输入副本归属不符。')
for relative in payload['capture_hashes']:
if not (capture_root/relative).resolve().is_relative_to(capture_root): fail('输入文件越界。')
for key,relative in (('project_path','input.prj'),('database_path','database/icdb.dat')):
if Path(payload[key]).resolve() != (capture_root/relative).resolve(): fail('输入文件身份不符。')
native_netlist._check_capture(payload)
return payload
except (OSError,ValueError,KeyError,TypeError) as error:
fail(f'校验证据不可用:{error}', 'verification_evidence')
def discard(self, identity):
"""Remove a directory allocated by this operation before publication."""
directory=internal_path(self.directory(identity))
try:
shutil.rmtree(directory)
except FileNotFoundError:
pass
except OSError:
logging.getLogger(__name__).warning('Cannot remove unpublished verification artifact %s',identity,exc_info=True)
def capture(self, project, *, stop_event, identity=None):
check_cancelled(stop_event)
identity = identity or uuid4().hex
capture = native_netlist.capture_project(Path(project),self.directory(identity)/'capture')
check_cancelled(stop_event)
return self.put('snapshot',capture,identity=identity)
def adopt(self, capture, *, identity=None):
root = Path(capture['root']).resolve()
if not root.is_relative_to(self.data_root): fail('交接副本不属于当前任务库。')
native_netlist._check_capture(capture)
identity = identity or uuid4().hex
destination = self.directory(identity)/'capture'
destination.mkdir(parents=True)
for relative, sha in capture['capture_hashes'].items():
source = (root/relative).resolve(); target=(destination/relative).resolve()
if not source.is_relative_to(root) or not target.is_relative_to(destination.resolve()): fail('交接文件路径越界。')
target.parent.mkdir(parents=True,exist_ok=True); shutil.copyfile(source,target)
if native_netlist._hash(target) != sha: fail('交接副本在复制时变化。')
value = dict(capture,root=str(destination),project_path=str(destination/'input.prj'),
database_path=str(destination/'database/icdb.dat'),manifest_path=str(destination/'capture.json'))
native_netlist._check_capture(capture)
write_record(destination/'capture.json',value)
return self.put('snapshot',value,identity=identity)
def validate_pair(before, after):
before,after = Path(before).resolve(strict=True),Path(after).resolve(strict=True)
if before==after or before.samefile(after): fail('请选择不同的前后工程。','verification_same_source')
before_db,after_db = _project_options(before)[3],_project_options(after)[3]
if Path(before_db).samefile(after_db): fail('两个工程引用同一个数据库。','verification_same_source')
return before,after
@@ -0,0 +1,56 @@
"""Process creation identities for recovery; never terminate a recorded PID."""
import json
import os
from pathlib import Path
import re
import time
from types import SimpleNamespace
from ..batch_resources import process_identity,_process_gone,write_record
from .contracts import fail
def owner_path(service,kind,identity):
if kind not in {'runs','attempts'} or re.fullmatch('[0-9a-f]{32}',identity or '') is None:fail('执行归属标识无效。')
root=(service.data_root/'verification').resolve()
path=root/kind/identity/'owner.json'
if not path.resolve().is_relative_to(root):fail('执行归属目录越界。')
return path
def write_owner(service,kind,identity,owner_id):
process={'pid':os.getpid(),'creation_time':None}
if os.name=='nt':
import win32api
process=process_identity(SimpleNamespace(pid=os.getpid(),handle=win32api.GetCurrentProcess()))
write_record(owner_path(service,kind,identity),{'version':1,'identity':identity,'owner_id':owner_id,
'process':process,'scope':'OwnedCliScope','kill_on_owner_exit':True})
def read_owner(service,kind,identity,expected_owner=None):
try:
value=json.loads(owner_path(service,kind,identity).read_text(encoding='utf-8'))
if (value.get('version')!=1 or value.get('identity')!=identity or value.get('scope')!='OwnedCliScope'
or value.get('kill_on_owner_exit') is not True or not isinstance(value.get('owner_id'),str)
or (expected_owner and value['owner_id']!=expected_owner)):raise ValueError('归属证明不符')
identity_record=value['process']
if type(identity_record.get('pid')) is not int or identity_record['pid']<=0:raise ValueError('进程证明无效')
if os.name!='nt' or not identity_record.get('creation_time'):state='unknown'
else:state='gone' if _process_gone(identity_record) else 'live'
return dict(value,state=state)
except Exception:return {'state':'unknown'} # An inaccessible process is never proof of release.
class RunStop:
"""An Event-compatible token that observes another window's durable stop."""
def __init__(self,service,run_id,event):self.service=service;self.run_id=run_id;self.event=event
def is_set(self):
if self.event.is_set():return True
with self.service.repo.store._lock:
row=self.service.repo.connection.execute('SELECT stop_requested FROM verification_runs WHERE run_id=?',(self.run_id,)).fetchone()
return row is None or bool(row[0])
def wait(self,timeout=None):
deadline=None if timeout is None else time.monotonic()+timeout
while not self.is_set():
if deadline is not None and time.monotonic()>=deadline:return False
self.event.wait(.05 if deadline is None else min(.05,max(0,deadline-time.monotonic())))
return True
@@ -0,0 +1,59 @@
"""Conservative native text adapter. Missing fields remain unknown."""
from pathlib import Path
import re
from ..native_netlist import _hash, _instance_identity
from ..native_inventory import read_native_text
from .rules import component_key
def inspect_footprint_mapping(binding):
return {'state':'unknown','mapping':None,'reason':'未实现确切库版本的内部引脚到焊盘映射读取'}
def inspect_pin_metadata(export,*,evidence_root):
result={'pins':[],'uncovered':['引脚级 Value','库内引脚到焊盘映射']}
try:
path=Path(export.get('outputs',{})['effective']).resolve()
if not path.is_relative_to(Path(evidence_root).resolve()):raise ValueError('原始证据越界')
sha=_hash(path);lines=read_native_text(path).splitlines();records=[];record=None
for n,line in enumerate(lines,1):
if line.startswith(' Symbol '):
match=re.fullmatch(r' Symbol (.+?)\tref des ([^\t]*)\tpage ([^\t]*)',line)
record={'uid':match[1],'refdes':match[2],'page':match[3],'paths':[],'pins':[]} if match else None
if record:records.append(record)
elif record is not None:
if line.startswith('\tPath '):record['paths'].append(line[6:])
elif line.startswith('\tPin '):
fields=line[5:].split('\t');values=dict(v.split(' ',1) for v in fields[1:] if ' ' in v)
record['pins'].append((fields[0],values,n))
graph=export.get('graph',{}).get('components',{})
candidates=[]
for record in records:
for scope in record['paths']:
uid=_instance_identity(record['uid'],scope);component=graph.get(uid)
if component is None or component.get('refdes')!=record['refdes']:continue
for name,values,n in record['pins']:
pin=component.get('pins',{}).get(name)
if not pin or not values.get('num') or pin.get('number')!=values['num']:continue
key=component_key(uid,component)
if key is None:continue
candidates.append({'endpoint':[*key,values['num']],
'logical_name':{'value':name,'confidence':'proven'},
'pin_value':{'value':None,'confidence':'unknown'},
'electrical_type':{'value':values.get('type'),'confidence':'proven' if 'type' in values else 'unknown'},
'raw':{'path':str(path),'sha256':sha,'line':n,'page':record['page'] or None}})
from collections import Counter
counts=Counter(tuple(p['endpoint']) for p in candidates)
result['pins']=[p for p in candidates if counts[tuple(p['endpoint'])]==1]
if _hash(path)!=sha:raise ValueError('原始证据在读取时变化')
except (OSError,ValueError,KeyError,TypeError) as error:
result.update(pins=[],reason=str(error))
return result
def compare_metadata(before,after):
left={tuple(p['endpoint']):p for p in before['pins']};right={tuple(p['endpoint']):p for p in after['pins']}
return {'comparisons':{str(key):dict({phase:{name:row[name]['value'] for name in ('pin_value','electrical_type')}
for phase,row in (('before',left[key]),('after',right[key]))}
,endpoint=list(key))
for key in left.keys()&right.keys()}}
@@ -0,0 +1,138 @@
"""Snapshot projections: only the current input and latest attempt drive badges."""
import json
from .contracts import ACTIVE, digest, fail
def checkpoint(control):
if control is not None: control.checkpoint()
def project(row):
row=dict(row)
state=row.get('attempt_state')
verdict=row.get('verdict')
if row['input_state']!='ready': status='unavailable'
elif state in ACTIVE: status='running'
elif state=='cancelled' and row.get('reason')=='run_stopped_before_dispatch': status='waiting'
elif state=='cancelled': status='stopped'
elif state=='interrupted': status='interrupted'
elif state=='failed': status='unavailable'
elif state=='succeeded': status={'CONSISTENT':'consistent','WARNING':'warning','DIFFERENT':'different'}.get(verdict,'unavailable')
else: status='waiting'
row.update(status=status,can_start=row['input_state']=='ready' and state not in ACTIVE,
scope='包含固定换料规则' if row.get('expectation_ref') else '未核对换料规则')
return row
def summarize_items(rows):
summary=dict.fromkeys(('total','processed','consistent','warning','different','unavailable','waiting','running','stopped','interrupted'),0)
for row in rows:
summary['total']+=1; summary[row['status']]+=1
if row['status'] in {'consistent','warning','different','unavailable'}: summary['processed']+=1
return summary
def paginate(rows,cursor,limit,binding,maximum):
if type(limit) is not int or not 1<=limit<=maximum: fail('分页大小超出范围。')
offset=0
if cursor is not None:
if not isinstance(cursor,dict) or cursor.get('binding')!=binding or type(cursor.get('offset')) is not int or cursor['offset']<0:
fail('列表已更新,请刷新后重试。','verification_cursor')
offset=cursor['offset']
return rows[offset:offset+limit],({'offset':offset+limit,'binding':binding} if len(rows)>offset+limit else None)
class VerificationQueries:
def __init__(self,repo):self.repo=repo;self.validator=None
def _validate(self,row,attempt):
if self.validator and attempt and attempt['state']=='succeeded':
try:self.validator(attempt)
except (ValueError,OSError,KeyError,TypeError) as error:
row.update(status='unavailable',verdict='INCOMPLETE',evidence_error=str(error))
return row
def _rows(self,task_id,control=None):
checkpoint(control)
rows=self.repo.connection.execute('''SELECT i.*, r.input_version,
json_extract(r.payload_json,'$.input_state') input_state,
json_extract(r.payload_json,'$.unavailable_reason') unavailable_reason,
json_extract(r.payload_json,'$.expectation_ref') expectation_ref,
a.attempt_id,a.state attempt_state,a.generation,a.reason,
json_extract(a.result_json,'$.verdict') verdict
FROM verification_items i JOIN verification_input_revisions r
ON r.item_id=i.item_id AND r.input_version=i.current_version
LEFT JOIN verification_attempts a ON a.attempt_id=(SELECT attempt_id FROM verification_attempts
WHERE item_id=i.item_id AND input_version=i.current_version ORDER BY generation DESC LIMIT 1)
WHERE i.task_id=? ORDER BY i.rowid''',(task_id,)).fetchall()
result=[]
for row in rows:
checkpoint(control);row=project(row)
result.append(row)
return result
def validate_rows(self,rows,control=None):
for row in rows:
checkpoint(control)
if self.validator and row['attempt_state']=='succeeded':self._validate(row,self.repo.attempt(row['attempt_id']))
return rows
def list_tasks(self,*,query='',cursor=None,limit=50,read_control=None):
with self.repo.store.transaction():
tasks=[]
for row in self.repo.connection.execute('SELECT * FROM verification_tasks ORDER BY created DESC,task_id').fetchall():
checkpoint(read_control)
row=dict(row)
if query.casefold() in row['name'].casefold():
tasks.append(row)
binding=digest([query,[r['task_id'] for r in tasks]])
page,next_cursor=paginate(tasks,cursor,limit,binding,50)
for row in page:
row['_rows']=self._rows(row['task_id'],read_control)
for row in page:row['summary']=summarize_items(self.validate_rows(row.pop('_rows'),read_control))
return {'tasks':page,'cursor':next_cursor}
def read_task(self,task_id,*,state='',query='',cursor=None,limit=100,read_control=None):
with self.repo.store.transaction():
task=self.repo.task(task_id);rows=self._rows(task_id,read_control)
run=self.repo.connection.execute("SELECT run_id,state,stop_requested FROM verification_runs WHERE task_id=? AND state IN ('queued','running','stopping') ORDER BY created LIMIT 1",(task_id,)).fetchone()
self.validate_rows(rows,read_control)
filtered=[]
for row in rows:
checkpoint(read_control)
if state and row['status']!=state:continue
text=row['display_name']+' '+row['project_key']
if query and row.get('attempt_id'):text+=' '+(self.repo.attempt(row['attempt_id'])['result_json'] or '')
if query.casefold() in text.casefold():filtered.append(row)
binding=digest([task_id,task['view_revision'],state,query])
page,next_cursor=paginate(filtered,cursor,limit,binding,100)
return dict(task,items=page,cursor=next_cursor,summary=summarize_items(rows),run=dict(run) if run else None)
def read_item(self,item_id,*,version=None,attempt_id=None,read_control=None):
row=self.snapshot_item(item_id,version=version,attempt_id=attempt_id,read_control=read_control)
return self._validate(row,row['attempt'])
def snapshot_item(self,item_id,*,version=None,attempt_id=None,read_control=None):
with self.repo.store.transaction():
checkpoint(read_control)
item=self.repo.item(item_id)
attempt=self.repo.attempt(attempt_id) if attempt_id else None
if attempt:
if attempt['item_id']!=item_id or (version is not None and attempt['input_version']!=version):fail('历史尝试不属于该工程版本。')
version=attempt['input_version']
version=version or item['current_version']
revision=self.repo.revision(item_id,version);attempt=attempt or self.repo.latest_attempt(item_id,version)
row=dict(item,**{k:v for k,v in revision['payload'].items() if k not in item})
row.update(input_version=version,attempt_id=attempt['attempt_id'] if attempt else None,
attempt_state=attempt['state'] if attempt else None,reason=attempt['reason'] if attempt else '',
verdict=(attempt['result'] or {}).get('verdict') if attempt else None)
history=[dict(r) for r in self.repo.connection.execute('SELECT input_version,generation,attempt_id,state FROM verification_attempts WHERE item_id=? ORDER BY input_version DESC,generation DESC',(item_id,))]
versions=[r[0] for r in self.repo.connection.execute('SELECT input_version FROM verification_input_revisions WHERE item_id=? ORDER BY input_version DESC',(item_id,))]
return dict(project(row),payload=revision['payload'],attempt=attempt,history=history,versions=versions)
def read_issues(self,attempt_id,*,kind='',cursor=None,limit=100,read_control=None):
checkpoint(read_control)
attempt=self.repo.attempt(attempt_id)
rows=[r for r in (attempt['result'] or {}).get('issues',()) if not kind or r.get('check_id')==kind]
page,next_cursor=paginate(rows,cursor,limit,digest([attempt_id,attempt['updated'],kind]),100)
return {'issues':page,'cursor':next_cursor}
@@ -0,0 +1,136 @@
"""HTML and JSON views of the exact immutable evidence shown in the workspace."""
from html import escape
import json
from pathlib import Path
from uuid import uuid4
from ..native_netlist import _hash
from ..batch_resources import write_record
from ..path_access import internal_path
from .contracts import fail,digest
from .evidence import PIN_FACT_COLORS,pin_fact,verify_evidence
def validate_result(result,root=None):
evidence=result.get('evidence')
if evidence:
verify_evidence(evidence)
for raw in evidence['binding'].get('raw',()):
path=Path(raw['path']).resolve()
if root is not None and not path.is_relative_to(Path(root).resolve()):fail('证据文件不属于本任务库。')
try:
if _hash(path)!=raw['sha256']:fail('原始证据已损坏。','verification_evidence')
except OSError:fail('原始证据已丢失。','verification_evidence')
def text(value):
if isinstance(value,(dict,list,tuple)):value=json.dumps(value,ensure_ascii=False,sort_keys=True)
return escape(str(value if value is not None else '未知'))
STYLE='body{font:14px "Segoe UI","Microsoft YaHei",sans-serif;color:#34445b;background:#f5f7fa;margin:24px}main{background:white;padding:24px;border-radius:12px}table{border-collapse:collapse;width:100%;margin:16px 0}td,th{border:1px solid #dae2eb;padding:9px;text-align:left;vertical-align:top}pre{white-space:pre-wrap;overflow-wrap:anywhere}.error{color:#b83d4a}.warning{color:#9c6b1e}svg{max-width:100%;height:auto}'
def diagram(pins,issues):
height=max(100,70+len(pins)*90);out=[f'<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 900 {height}" role="img" aria-label="由网表生成的前后连接对照">']
for col,phase,title in ((0,'before','修改前'),(1,'after','修改后')):
x=col*450+16;out.append(f'<text x="{x}" y="24" fill="#34445b">{title}</text>')
for n,pin in enumerate(pins):
y=60+n*90;row=pin[phase];fact,state=pin_fact(pin,issues);color=PIN_FACT_COLORS[state]
out.append(f'<g><title>{text(fact)}</title>')
name=row['logical_name'] if row else ('不存在' if fact.startswith('器件') else '未知')
out.append(f'<text x="{x}" y="{y}" fill="{color}">脚 {text(pin["endpoint"][2])} · {text(name)}</text>')
out.append(f'<line x1="{x+4}" y1="{y+22}" x2="{x+30}" y2="{y+22}" stroke="{color}"/>')
nets=row['nets'] if row else []
label=';'.join(net['name']+' · '+', '.join(e[1]+'.'+e[2] for e in net['endpoints']) for net in nets) or ('明确未连接' if row else name)
out.append(f'<text x="{x+36}" y="{y+26}" fill="#516078" font-size="11">{text(label)}</text></g>')
return ''.join(out)+'</svg>'
def item_html(result):
validate_result(result)
evidence=result.get('evidence') or {};pins=evidence.get('pins',[])
issues={issue['issue_id']:issue for issue in evidence.get('issues',())}
verdict=result.get('verdict','未完成')
label={'CONSISTENT':'一致','WARNING':'需关注','DIFFERENT':'异常','INCOMPLETE':'无法完整校验'}.get(verdict,'未完成')
out=[f'<h1>{text(result.get("display_name","工程校验"))}</h1>',f'<h2>{label} · {text(verdict)}</h2>',
f'<p>{text(result.get("scope","未核对换料规则"))} · 由网表生成 · 未覆盖:封装库内部映射、引脚级 Value</p>']
keys=sorted({tuple(p['endpoint'][:2]) for p in pins})
for key in keys:
subset=[p for p in pins if tuple(p['endpoint'][:2])==key]
out.append(f'<h3>{text(key[1])} · {text(key[0])}</h3>');out.append(diagram(subset,issues))
out.append('<table><tr><th>物理脚</th><th>修改前</th><th>修改后</th><th>事实</th></tr>')
for pin in subset:
def description(row):
if row is None:return '不存在/未覆盖'
nets=';'.join(n['name']+' → '+', '.join(e[1]+'.'+e[2] for e in n['endpoints'] if e!=pin['endpoint']) for n in row['nets'])
return '名称:'+row['logical_name']+'\n'+(nets or '明确未连接')
label,_=pin_fact(pin,issues)
out.append(f'<tr><td>{text(pin["endpoint"][2])}</td><td><pre>{text(description(pin["before"]))}</pre></td><td><pre>{text(description(pin["after"]))}</pre></td><td>{text(label)}</td></tr>')
out.append('</table>')
out.append('<h2>判断依据</h2><ul>')
for issue in result.get('issues',[]):
out.append(f'<li class="{text(issue["state"])}">{text(issue.get("refdes","工程"))} {text(issue.get("pin_number",""))} · {text(issue["reason"])}</li>')
out.append('</ul>')
if result.get('reason'):out.append('<p>执行说明:'+text(result['reason'])+'</p>')
out.append('<details><summary>检查范围、版本与完整事实</summary><pre>'+text({key:result.get(key) for key in ('attempt_state','resource_state','checks','issues','uncovered','attempt_id','input_version','input_digest','policy')})+'</pre></details>')
out.append('<details><summary>原始证据定位与摘要</summary><pre>'+text(evidence.get('binding',{}))+'</pre></details>')
return ''.join(out)
def render_item_report(result_ref,destination):
destination=Path(destination)
target=internal_path(destination)
if target.exists():fail('报告文件已存在,请换一个名称。')
fields={'item-id':result_ref.get('item_id'),'attempt-id':result_ref.get('attempt_id'),
'input-version':result_ref.get('input_version'),'generation':result_ref.get('generation'),
'input-digest':result_ref.get('input_digest'),'evidence-digest':(result_ref.get('evidence') or {}).get('digest')}
binding=' '.join(f'data-{key}="{text(value)}"' for key,value in fields.items())
html='<!doctype html><html lang="zh-CN"><meta charset="utf-8"><title>工程校验报告</title><style>'+STYLE+'</style><main '+binding+'>'+item_html(result_ref)+'</main></html>'
target.parent.mkdir(parents=True,exist_ok=True)
temporary=target.with_name('.'+uuid4().hex+'.tmp')
try:
temporary.write_text(html,encoding='utf-8')
# On Windows rename does not overwrite an existing destination.
if target.exists():fail('报告文件已存在。')
temporary.rename(target)
finally:temporary.unlink(missing_ok=True)
return destination
def export_task(service,task_id,destination,*,request_id):
body=[task_id,str(Path(destination).resolve())]
with service._intake_lock:
with service.repo.store._lock:
old=service.repo._request('export',request_id,body)
if old is not None:
path=Path(old['path'])
if not internal_path(path).is_dir():fail('先前导出的报告已丢失,请重新导出。')
return path
with service.repo.store.transaction():
task=service.repo.task(task_id);rows=service.queries._rows(task_id)
records=[service.queries.snapshot_item(row['item_id']) for row in rows]
snapshot=dict(task,items=records)
for row in records:
service.queries._validate(row,row['attempt'])
if row.get('evidence_error'):fail('证据不可用,不能导出为有效报告:'+row['evidence_error'])
root=Path(destination).resolve();internal_path(root).mkdir(parents=True,exist_ok=True)
output=root/f'verification-{task_id[:12]}-v{task["view_revision"]}-{digest(request_id)[:8]}'
target=internal_path(output)
if target.exists():fail('报告目录已存在。')
staging=internal_path(root/('.verification-'+uuid4().hex));staging.mkdir()
write_record(staging/'task.json',snapshot)
content=[f'<h1>{text(task["name"])}</h1><p>视图版本 {task["view_revision"]} · 生成时冻结,待校验/运行中项尚未完成。</p><ul>']
for row in records:
filename=row['item_id']+f'-v{row["input_version"]}.html'
result=((row.get('attempt') or {}).get('result') or {})
if result:
render_item_report(dict(result,display_name=row['display_name']),staging/filename)
content.append(f'<li><a href="{filename}">{text(row["display_name"])}</a> · {text(row["status"])}</li>')
else:content.append(f'<li>{text(row["display_name"])} · {text(row["status"])} · 未完成/无法校验</li>')
content.append('</ul>')
(staging/'index.html').write_text('<!doctype html><html lang="zh-CN"><meta charset="utf-8"><style>'+STYLE+'</style><main>'+''.join(content)+'</main></html>',encoding='utf-8')
# Roundtrip before publication; the destination never contains a partial report.
json.loads((staging/'task.json').read_text(encoding='utf-8'))
staging.rename(target)
with service.repo.store.transaction():service.repo._remember('export',request_id,body,{'path':str(output)})
return output
@@ -0,0 +1,174 @@
"""Electrical comparison at fixed instance/refdes/physical-pin identities."""
from collections import Counter, defaultdict
from .contracts import CHECKS, digest, rollup_results, validate_plan
from ..native_netlist import _is_pcb, _proven_symbol
def component_key(uid,row):
scope=row.get('instance_path',uid.rpartition('/')[0]) or 'root'
ref=row.get('refdes') or row.get('attributes',{}).get('Ref Designator')
return (scope,ref) if ref else None
def component_index(graph):
index={};ambiguous=[]
for uid,row in graph.get('components',{}).items():
if not _is_pcb(row):continue
key=component_key(uid,row)
if key is None or key in index:ambiguous.append(key)
else:index[key]=(uid,row)
return index,ambiguous
def match_components(before_graph,after_graph):
left,la=component_index(before_graph);right,ra=component_index(after_graph)
return {'before':left,'after':right,'ambiguous':la+ra,
'matches':{key:(left[key][0],right[key][0]) for key in left.keys()&right.keys()}}
def physical_view(graph):
"""Keep unknowns explicit; networks include self to distinguish singles from open pins."""
indexed,ambiguous=component_index(graph)
if ambiguous:raise ValueError('位号或实例范围对应不唯一')
endpoints={};pins={}
for uid,row in graph.get('components',{}).items():
pcb=_is_pcb(row);key=component_key(uid,row)
for name,pin in row.get('pins',{}).items():
number=pin.get('number') if pcb else name
if pcb and (key is None or not number):raise ValueError('缺少物理脚号')
endpoint=(*key,str(number)) if key else ('native',uid,name)
if endpoint in pins:raise ValueError('物理脚号重复,无法唯一绑定')
endpoints[(uid,name)]=endpoint
pins[endpoint]={'logical_name':name,'number':str(number),'nets':[],
'uid':uid,'raw_key':['components',uid,'pins',name],
'declared_nets':pin.get('nets')}
seen=defaultdict(list)
for net in graph.get('nets',()):
members=[]
for uid,name in net['endpoints']:
if (uid,name) not in endpoints:raise ValueError('网表端点未覆盖')
members.append(endpoints[(uid,name)])
if len(set(members))!=len(members):raise ValueError('网络含重复物理端点')
for endpoint in members:
record={'name':net['name'],'endpoints':[list(e) for e in sorted(members)]}
pins[endpoint]['nets'].append(record);seen[endpoint].append(net['name'])
for endpoint,pin in pins.items():
if pin['declared_nets'] is None or Counter(pin['declared_nets'])!=Counter(seen[endpoint]):
raise ValueError('引脚与网络互反覆盖不完整')
pin['nets'].sort(key=lambda n:(n['name'],n['endpoints']))
return pins
def evaluate(before,after,*,expectations,check_plan,pin_metadata=None):
plan=validate_plan(check_plan)
requested=set(plan['required_checks'])|set(plan['optional_checks'])
states={key:'unknown' if key in requested else 'not_requested' for key in CHECKS}
issues=[]
rank={'not_requested':0,'equal':1,'expected_change':2,'unknown':3,'warning':4,'error':5}
def issue(check,state,reason,*,key=None,pin=None,left=None,right=None,field=None):
# Hard facts stay visible even if a user did not request optional enrichment.
if rank[state]>rank.get(states[check],0) or states[check]=='unknown':states[check]=state
row={'check_id':check,'state':state,'reason':reason,'before':left,'after':right}
if key:row.update(instance_path=key[0],refdes=key[1])
if pin is not None:row['pin_number']=pin
if field:row['field']=field
row['issue_id']=digest(row)[:24];issues.append(row)
states['inputs']='equal'
complete=all(
e.get('status')=='success' and e.get('complete') is True
and e.get('graph',{}).get('components') and e['graph'].get('nets')
for e in (before,after)
)
left=before.get('graph',{});right=after.get('graph',{})
states['coverage']='equal' if complete else 'unknown'
if not complete:
issue('coverage','unknown','缺少完整原生导出',left=before.get('reason'),right=after.get('reason'))
matched=match_components(left,right)
if complete and not matched['ambiguous']:
states['components']='equal'
for key in sorted(matched['before'].keys()^matched['after'].keys()):
issue('components','error','器件位号或实例范围增减',key=key,
left=key in matched['before'],right=key in matched['after'])
else:issue('components','unknown','器件身份或覆盖无法唯一证明')
if complete:
for key,(lid,rid) in matched['matches'].items():
lnums=[p.get('number') for p in left['components'][lid].get('pins',{}).values()]
rnums=[p.get('number') for p in right['components'][rid].get('pins',{}).values()]
if lnums and rnums and all(lnums+rnums) and Counter(lnums)!=Counter(rnums):
issue('physical_pins','error','物理脚号或占用次数变化',key=key,left=lnums,right=rnums)
views=[]
try:
if not complete:raise ValueError('导出不完整')
views=[physical_view(left),physical_view(right)]
except (ValueError,KeyError,TypeError) as error:
issue('coverage','unknown',str(error))
if views:
if states['physical_pins']!='error':states['physical_pins']='equal'
states['connections']=states['net_names']='equal'
states['pin_text']='equal' if 'pin_text' in requested else 'not_requested'
states['pin_semantics']='equal' if 'pin_semantics' in requested else 'not_requested'
lp,rp=views
for key in sorted(matched['matches']):
lset={e[2] for e in lp if e[:2]==key};rset={e[2] for e in rp if e[:2]==key}
if lset!=rset:issue('physical_pins','error','物理脚号集合变化',key=key,left=sorted(lset),right=sorted(rset))
for endpoint in sorted(lp.keys()&rp.keys()):
l,r=lp[endpoint],rp[endpoint];key=endpoint[:2];pin=endpoint[2]
lt=sorted(n['endpoints'] for n in l['nets']);rt=sorted(n['endpoints'] for n in r['nets'])
if lt!=rt:issue('connections','error','固定物理脚号的连接变化',key=key,pin=pin,left=l,right=r)
elif [n['name'] for n in l['nets']]!=[n['name'] for n in r['nets']]:
issue('net_names','error','网络名称变化,需确认',key=key,pin=pin,left=l,right=r)
if l['logical_name']!=r['logical_name'] and 'pin_text' in requested:
issue('pin_text','warning','引脚名称变化,需人工确认功能',key=key,pin=pin,left=l,right=r)
if {l['logical_name'].upper(),r['logical_name'].upper()} & {'GND','VCC','VDD','VSS'}:
issue('pin_semantics','warning','疑似电源或地功能变化,高关注',key=key,pin=pin,left=l,right=r)
declared=expectations is not None
states['declared_attributes']='equal' if declared else 'not_requested'
states['attribute_changes']='equal' if 'attribute_changes' in requested else 'not_requested'
changes=(expectations or {}).get('changes',{})
symbols=(expectations or {}).get('symbols',{})
used=set()
for key,(lid,rid) in matched['matches'].items():
l,r=left['components'][lid],right['components'][rid]
expected=dict(l.get('attributes',{}));delta=changes.get(lid,changes.get(key[1],{}));used.add(lid);used.add(key[1])
for name,value in delta.items():
if value is None:expected.pop(name,None)
else:expected[name]=value
actual=r.get('attributes',{})
if declared:
if actual!=expected:issue('declared_attributes','error','器件属性与固定预期不符',key=key,left=expected,right=actual,field='attributes')
elif delta:states['declared_attributes']='expected_change' if states['declared_attributes']!='error' else 'error'
elif actual!=expected:issue('attribute_changes','warning','器件属性变化;未核对换料规则',key=key,left=expected,right=actual,field='attributes')
proof=symbols.get(lid)
proven=proof is not None and _proven_symbol(l,r,proof)
if proof is not None and not proven:issue('declared_attributes','error','目标符号证明无法绑定',key=key,left=l.get('symbol'),right=r.get('symbol'))
for field in ('symbol','other_attributes','ambiguous_attributes'):
if field=='symbol' and proven:continue
if l.get(field)!=r.get(field):issue('declared_attributes' if declared else 'attribute_changes',
'error' if declared else 'warning','符号或其他属性变化',key=key,left=l.get(field),right=r.get(field),field=field)
for missing in set(changes)-used:issue('declared_attributes','error','预期清单目标未找到',left=missing)
# Proven metadata is enrichment; never substitute component Value for pin Value.
if pin_metadata:
for key in ('pin_value','electrical_type'):
for endpoint,fields in pin_metadata.get('comparisons',{}).items():
l,r=fields.get('before',{}).get(key),fields.get('after',{}).get(key)
if l is not None and r is not None and l!=r:
bound=fields.get('endpoint')
issue('pin_text' if key=='pin_value' else 'pin_semantics','warning','引脚字段变化,需人工确认',
key=tuple(bound[:2]) if bound else None,pin=bound[2] if bound else None,left=l,right=r,field=key)
if 'export_identity' in requested:
diffs=[g.get('identity_tables',{}).get('keyin',{}).get('part_number_differences',[]) for g in (left,right)]
states['export_identity']='warning' if any(diffs) else 'equal'
if any(diffs):issue('export_identity','warning','原生身份表与有效料号存在差异',left=diffs[0],right=diffs[1])
checks=[{'check_id':key,'state':states[key],'issues':[i['issue_id'] for i in issues if i['check_id']==key]} for key in sorted(CHECKS)]
# This dimension covers names AND pin-level Value. Native text has not proven Value.
for check in checks:
if check['check_id']=='pin_text' and 'pin_text' in requested:
check.update(coverage='partial',unknown_fields=['pin_value'])
if check['check_id']=='pin_semantics' and 'pin_semantics' in requested:
expected={e for e in views[0] if e[:2] in matched['matches']} if views else set()
proven={tuple(fields['endpoint']) for fields in (pin_metadata or {}).get('comparisons',{}).values()
if fields.get('endpoint') and all(fields.get(phase,{}).get('electrical_type') is not None for phase in ('before','after'))}
if not expected or not expected<=proven:check.update(coverage='partial',unknown_fields=['electrical_type'])
return dict(rollup_results(checks,required_checks=plan['required_checks'],optional_checks=plan['optional_checks']),
checks=checks,issues=issues,scope='已核对换料规则' if declared else '未核对换料规则',
uncovered=['封装库内部引脚到焊盘映射','引脚级 Value(原生输出未证明)'])
@@ -0,0 +1,98 @@
"""Independent native read-only execution. No replacement or CAD mutation entrypoints."""
from pathlib import Path
from threading import Lock
from uuid import uuid4
from .. import native_netlist, netlist_verification
from ..batch_resources import pending_resources
from ..operation_control import check_cancelled
from .contracts import rollup_results
_native_lock=Lock()
def can_start_native_export(service):
from ..native_cli import _UNCERTAIN_SCOPES
with service.repo.store._lock:
held=service.repo.connection.execute("SELECT 1 FROM verification_attempts WHERE state='stopping' OR resource_state='unknown' LIMIT 1").fetchone()
if held or _UNCERTAIN_SCOPES or pending_resources(service.data_root):return {'allowed':False,'reason':'资源退出尚未确认'}
return {'allowed':not _native_lock.locked(),'reason':'原生导出忙' if _native_lock.locked() else ''}
def export_inputs(service,before_ref,after_ref,*,output,stop_event):
before=service.artifacts.read(before_ref,'snapshot')
after=service.artifacts.read(after_ref,'snapshot')
left=netlist_verification._export_saved_capture(before,Path(output)/'before',stop_event=stop_event)
if left.get('cleanup_uncertain'):return left,{}
check_cancelled(stop_event)
right=netlist_verification._export_saved_capture(after,Path(output)/'after',stop_event=stop_event)
return left,right
def run_attempt(service,attempt_id,*,stop_event):
if not can_start_native_export(service)['allowed'] or not _native_lock.acquire(blocking=False):
return {'published':False,'waiting':True}
attempt=None
try:
check_cancelled(stop_event)
from .ownership import write_owner,RunStop
with service.repo.store.transaction():
attempt=service.repo.claim(attempt_id,owner_id=service.control.owner_id)
if attempt:write_owner(service,'attempts',attempt_id,attempt['owner_id'])
if attempt is None:return {'published':False}
if attempt['run_id']:stop_event=RunStop(service,attempt['run_id'],stop_event)
check_cancelled(stop_event)
payload=service.repo.revision(attempt['item_id'],attempt['input_version'])['payload']
output=service.data_root/'verification'/'attempts'/attempt_id
left,right=export_inputs(service,payload['before_ref'],payload['after_ref'],output=output,stop_event=stop_event)
if left.get('cleanup_uncertain') or right.get('cleanup_uncertain'):
with service.repo.store.transaction():
service.repo.connection.execute("UPDATE verification_attempts SET state='stopping',resource_state='unknown',reason=? WHERE attempt_id=?",('原生资源退出未知',attempt_id))
return {'published':False,'blocked':True}
from ..batch_resources import write_record
write_record(output/'resource-released.json',{'owner_id':attempt['owner_id'],'resource_state':'released'})
check_cancelled(stop_event)
expected=service.artifacts.read(payload['expectation_ref'],'expectations') if payload['expectation_ref'] else None
from .rules import evaluate
from .pin_metadata import inspect_pin_metadata,compare_metadata
metadata={phase:inspect_pin_metadata(export,evidence_root=output) for phase,export in (('before',left),('after',right))}
result=dict(evaluate(left,right,expectations=expected,check_plan=payload['check_plan'],
pin_metadata=compare_metadata(metadata['before'],metadata['after'])),
before=left,after=right,attempt_state='succeeded' if all(e.get('status')=='success' for e in (left,right)) else 'failed',resource_state='released')
result['pin_metadata']=metadata
result.update(item_id=attempt['item_id'],input_version=attempt['input_version'],attempt_id=attempt_id,
generation=attempt['generation'],input_digest=payload['payload_digest'],policy=payload['check_plan'])
from .evidence import build_evidence
raw=[]
for phase,export in (('before',left),('after',right)):
for kind,path in export.get('outputs',{}).items():
file=Path(path).resolve()
if not file.is_relative_to(output.resolve()):raise ValueError('导出证据越界')
raw.append({'artifact_id':phase+':'+kind,'path':str(file),'sha256':native_netlist._hash(file)})
result['evidence']=build_evidence(left.get('graph',{}),right.get('graph',{}),result['issues'],
binding={'attempt_id':attempt_id,'input_version':attempt['input_version'],
'input_digest':payload['payload_digest'],'raw':raw})
ref=service.artifacts.put('result',result)
result['result_ref']=ref
write_record(output/'result-ready.json',{'result_ref':ref})
check_cancelled(stop_event)
published=service.repo.finish(attempt_id,generation=attempt['generation'],result=result)
if not published and stop_event.is_set():
service.repo.finish(attempt_id,generation=attempt['generation'],result={
'attempt_state':'cancelled','resource_state':'released','verdict':'INCOMPLETE','reason':'用户停止先于结果提交',
'attempt_id':attempt_id,'input_version':attempt['input_version'],'checks':[],'issues':[]})
return dict(result,published=published)
except Exception as error:
if attempt:
from ..native_cli import _UNCERTAIN_SCOPES
if _UNCERTAIN_SCOPES:
with service.repo.store.transaction():
service.repo.connection.execute("UPDATE verification_attempts SET state='stopping',resource_state='unknown',reason=? WHERE attempt_id=?",(str(error),attempt_id))
return {'published':False,'blocked':True}
cancelled=getattr(error,'code','')=='operation_cancelled'
result={'attempt_state':'cancelled' if cancelled else 'failed','resource_state':'released',
'verdict':'INCOMPLETE','reason':str(error),'checks':[],'issues':[]}
service.repo.finish(attempt_id,generation=attempt['generation'],result=result)
return {'published':False,'reason':str(error)}
finally:
_native_lock.release()
@@ -0,0 +1,335 @@
"""One interface for standalone verification and successful-result handoff."""
from contextlib import ExitStack
from hashlib import sha256
import json
from pathlib import Path
from threading import RLock
from uuid import uuid4
from ..native_netlist import _check_capture
from ..path_access import canonical_path, internal_path
from ..errors import TaskCenterError
from ..operation_control import check_cancelled
from .contracts import default_plan, digest, fail, identifier, validate_input
from .intake import ArtifactStore, validate_pair
from .store import VerificationRepository
class VerificationService:
def __init__(self, task_store, data_root):
self.repo = VerificationRepository(task_store)
self.data_root = Path(data_root).resolve()
self.artifacts = ArtifactStore(self.data_root)
self._intake_lock = RLock()
from .queries import VerificationQueries
self.queries = VerificationQueries(self.repo)
self.queries.validator = self.validate_attempt
from .control import VerificationControl
self.control = VerificationControl(self)
self._recovered=False
def initialize(self):
with self._intake_lock:
if not self._recovered:
self.recover()
self._recovered=True
return self.reconcile_deliveries()
@property
def busy(self): return self.control.busy
def start(self, task_id, *, selection=None, request_id):
return self.control.start(task_id,selection=selection,request_id=request_id)
def stop(self, run_id, *, request_id): return self.control.stop(run_id,request_id=request_id)
def rerun(self, item_id, version, *, request_id):
return self.start(self.repo.item(item_id)['task_id'],selection=((item_id,version),),request_id=request_id)
def recover(self): return self.control.recover()
def begin_shutdown(self): return self.control.begin_shutdown()
def list_tasks(self, **kwargs): return self.queries.list_tasks(**kwargs)
def read_task(self, task_id, **kwargs): return self.queries.read_task(task_id, **kwargs)
def read_item(self, item_id, **kwargs): return self.queries.read_item(item_id, **kwargs)
def read_issues(self, attempt_id, **kwargs): return self.queries.read_issues(attempt_id, **kwargs)
def export_task(self, task_id, destination, *, request_id):
from .report import export_task
return export_task(self,task_id,destination,request_id=request_id)
def validate_attempt(self, attempt):
result=attempt.get('result') or {}
if not result.get('result_ref'): return
stored=self.artifacts.read(result['result_ref'],'result')
if stored!={k:v for k,v in result.items() if k!='result_ref'}:fail('结果记录与不可变证据不符。')
from .report import validate_result
validate_result(stored,self.data_root)
payload=self.repo.revision(attempt['item_id'],attempt['input_version'])['payload']
for key in ('before_ref','after_ref'):self.artifacts.read(payload[key],'snapshot')
if payload['expectation_ref']:self.artifacts.read(payload['expectation_ref'],'expectations')
def open_evidence(self, attempt_id, artifact_id):
attempt=self.repo.attempt(attempt_id);self.validate_attempt(attempt)
raw=next((r for r in (attempt['result'] or {}).get('evidence',{}).get('binding',{}).get('raw',[]) if r['artifact_id']==artifact_id),None)
if raw is None:fail('原始证据标识不存在。')
path=Path(raw['path']).resolve()
if not path.is_relative_to(self.data_root/'verification'):fail('原始证据越界。')
import os
os.startfile(path)
return path
def create_task(self, name, *, request_id):
return self.repo.create_task(name,request_id=request_id)
def preview_pairs(self, before_root, after_root, *, stop_event):
from .batch_import import preview_pairs
return preview_pairs(before_root,after_root,excluded_roots=(self.data_root,),stop_event=stop_event)
def import_pairs(self, task_id, pairs, *, request_id, stop_event, on_progress=None, display_names=None):
from .batch_import import import_pairs
return import_pairs(self,task_id,pairs,request_id=request_id,stop_event=stop_event,on_progress=on_progress,display_names=display_names)
def publish_inputs(self, task_id, inputs, *, submission_id):
body = {'task_id':task_id,'inputs':inputs}
with self.repo.store._lock:
old = self.repo._request('ingest',submission_id,body)
if old is not None: return old
normalized=self._validated_inputs(inputs)
with self.repo.store.transaction():
old=self.repo._request('ingest',submission_id,body)
if old is not None:return old
result=self.repo.publish(task_id,tuple(normalized),submission_id='ingest:'+submission_id)
return self.repo._remember('ingest',submission_id,body,result)
def _validated_inputs(self, inputs):
# Snapshot hashing can be slow; never run it inside a store transaction.
normalized=[]
for value in inputs:
if not isinstance(value,dict):
normalized.append(value)
continue
row=dict(value)
try:
for field,kind in (('before_ref','snapshot'),('after_ref','snapshot'),('expectation_ref','expectations')):
if row.get(field): self.artifacts.read(row[field],kind)
except (ValueError,OSError) as error:
row['unavailable_reason']=str(error)
normalized.append(row)
return normalized
def import_pair(self, task_id, before, after, *, request_id, stop_event, display_name=None):
body=[task_id,str(before),str(after)]
if display_name is not None:body.append(display_name)
with self._intake_lock:
with self.repo.store._lock:
old=self.repo._request('import',request_id,body)
if old is not None:return old
check_cancelled(stop_event)
self.repo.task(task_id)
try: before,after=validate_pair(before,after)
except OSError as error: fail(f'工程文件不可用:{error}')
project_key=digest([str(before),str(after)])
name=after.stem if display_name is None else display_name
try:
identifier(name or project_key)
except TaskCenterError as error:
result={'accepted':[],'duplicates':[],'stale_ignored':[],
'rejected':[{'index':0,'code':error.code,'reason':error.message}]}
with self.repo.store.transaction():
old=self.repo._request('import',request_id,body)
return old if old is not None else self.repo._remember('import',request_id,body,result)
with ExitStack() as unpublished:
refs={}
for phase,project in (('before',before),('after',after)):
identity=uuid4().hex
unpublished.callback(self.artifacts.discard,identity)
refs[phase]=self.artifacts.capture(project,stop_event=stop_event,identity=identity)
row={'item_key':uuid4().hex,'project_key':project_key,'display_name':name,
'input_version':1,'before_ref':refs['before'],'after_ref':refs['after'],
'expectation_ref':None,'check_plan':default_plan()}
normalized=self._validated_inputs((row,))
with self.repo.store.transaction():
old=self.repo._request('import',request_id,body)
if old is not None:return old
check_cancelled(stop_event)
result=self.repo.publish(task_id,tuple(normalized),submission_id='import:'+request_id)
self.repo._remember('import',request_id,body,result)
if result['accepted']:
unpublished.pop_all()
return result
def receive_successful_results(self, result_ref, *, submission_id):
with self._intake_lock:
with self.repo.store._lock:
completed=self.repo._request('handoff-complete',submission_id,result_ref)
if completed is not None:return completed
old=self.repo._request('handoff',submission_id,result_ref)
if old is not None and not old['rejected']:return old
reports=result_ref.get('netlist_verification') or {}
candidates=[]
for key,report in reports.items():
execution=report.get('execution') or {}
if execution.get('state')=='completed' and (execution.get('saved_items') or 0)>0:
candidates.append((key,report))
# A successful save without optional netlist evidence is still visible.
for task in result_ref.get('tasks',()):
if task.get('state')=='completed' and (task.get('saved_items') or 0)>0 and task['task_id'] not in reports:
candidates.append((task['task_id'],{'execution':{'state':'completed','saved_items':task['saved_items']},
'task_name':task.get('name',task['task_id'])}))
empty={key:[] for key in ('accepted','duplicates','stale_ignored','rejected')}
if not candidates:return empty
with self.repo.store.transaction():
if self.repo._request('handoff-receipt',submission_id,result_ref) is None:
self.repo._remember('handoff-receipt',submission_id,result_ref,True)
run_key=identifier(str(result_ref.get('queue_id') or result_ref.get('run_id') or submission_id))
task=self.create_task('校验任务',request_id='handoff-task:'+run_key)['task_id']
result=dict(empty,task_id=task)
for index,(key,report) in enumerate(candidates):
try:
delivery_key=digest([run_key,key,report])
status,reference=self._deliver_project(task,str(key),report,delivery_key)
except (ValueError,OSError,KeyError,TypeError) as error:
result['rejected'].append({'index':index,'code':getattr(error,'code','verification_evidence'),
'reason':str(error)})
else:
result[status].append(reference)
if result['rejected']:
return result
with self.repo.store.transaction():
completed=self.repo._request('handoff-complete',submission_id,result_ref)
return completed if completed is not None else self.repo._remember(
'handoff-complete',submission_id,result_ref,result)
def _deliver_project(self, task, key, report, delivery_key):
for _ in range(3):
with self.repo.store._lock:
known=self.repo._request('handoff-input',delivery_key,report)
if known is not None:
return 'duplicates',known
current=self.repo.current_input(task,key)
legacy=self.repo._request('handoff-row',delivery_key,report)
if current and legacy:
first=self.repo.revision(current['item_id'],1)
if first['payload_digest']==validate_input(legacy)['payload_digest']:
return 'duplicates',{'item_id':first['item_id'],'input_version':1}
with ExitStack() as unpublished:
row=self._prepare_handoff_input(key,report,current,unpublished)
with self.repo.store.transaction():
known=self.repo._request('handoff-input',delivery_key,report)
if known is not None:
return 'duplicates',known
if self.repo.current_input(task,key)!=current:
continue
if row is None:
reference={field:current[field] for field in ('item_id','input_version')}
return 'stale_ignored',reference
if current and row['input_version']==current['input_version']:
status='duplicates'
reference={field:current[field] for field in ('item_id','input_version')}
else:
if current and row['project_key']!=current['payload']['project_key']:
self.repo.connection.execute(
'UPDATE verification_items SET project_key=? WHERE item_id=? AND before_id IS NULL',
(row['project_key'],current['item_id']))
published=self.repo.publish(task,(row,),submission_id='handoff-input:'+delivery_key)
if published['rejected']:
rejection=published['rejected'][0]
fail(rejection['reason'],rejection['code'])
status='accepted'
reference=published['accepted'][0]
self.repo._remember('handoff-input',delivery_key,report,reference)
if status=='accepted':
unpublished.pop_all()
return status,reference
fail('交接项正在更新,请稍后重试。','verification_conflict')
def _prepare_handoff_input(self, key, report, current, unpublished):
previous=current['payload'] if current else {}
project=str(report.get('project_path') or previous.get('project_key') or key)
saved_items=report['execution']['saved_items']
project_changed=bool(current and previous['project_key']!=project)
expected=None
previous_expected=None
if previous.get('expectation_ref'):
previous_expected=self.artifacts.read(previous['expectation_ref'],'expectations')
previous_count=previous.get('handoff_saved_items') or (
(previous_expected or {}).get('execution',{}).get('saved_items') or 0)
if saved_items<previous_count:
return None
captures={}
reason=''
for phase in ('before','after'):
try:
captures[phase]=self._handoff_capture(report.get(phase) or {})
except (ValueError,OSError,KeyError,TypeError) as error:
reason=reason or str(error)
if current and previous['input_state']=='ready' and reason and saved_items<=previous_count:
return None
if project_changed and (previous.get('before_ref') or not captures.get('before')):
fail('交接工程身份变化,请新增比较项。','verification_conflict')
refs={}
for phase in ('before','after'):
field=phase+'_ref'
ref=previous.get(field)
capture=captures.get(phase)
if capture and ref:
original=self.artifacts.read(ref,'snapshot')
if (capture['project'],capture['capture_hashes'])!=(original['project'],original['capture_hashes']):
if phase=='before':
fail('交接原始基线变化,请新增比较项。','verification_conflict')
ref=None
if capture and not ref:
identity=uuid4().hex
unpublished.callback(self.artifacts.discard,identity)
ref=self.artifacts.adopt(capture,identity=identity)
refs[field]=ref if capture or phase=='before' else None
if not reason and 'expected_changes' in report:
value={'changes':report['expected_changes'],'symbols':report.get('expected_symbols',{}),
'execution':report['execution']}
expected=previous.get('expectation_ref') if value==previous_expected else None
if expected is None:
identity=uuid4().hex
unpublished.callback(self.artifacts.discard,identity)
expected=self.artifacts.put('expectations',value,identity=identity)
plan=default_plan()
if expected:plan['required_checks'].append('declared_attributes')
name=previous.get('display_name') or report.get('task_name') or Path(project).stem
row=dict(refs,item_key=key,project_key=project,display_name=name,
expectation_ref=expected,check_plan=plan,unavailable_reason=reason,
handoff_saved_items=saved_items)
version=previous.get('input_version',0)
if saved_items>previous_count or any(previous.get(field)!=value for field,value in row.items()
if field!='handoff_saved_items'):
version+=1
row['input_version']=version
return row
def _handoff_capture(self, evidence):
path=canonical_path(evidence.get('export_path',''))
if not path.is_relative_to(self.data_root) or not internal_path(path).is_file():
fail('缺少可信前后副本。')
content=internal_path(path).read_bytes()
if sha256(content).hexdigest()!=evidence.get('export_sha256'):
fail('交接导出摘要不符。')
capture=json.loads(content)['capture']
if not canonical_path(capture['root']).is_relative_to(self.data_root):
fail('交接副本不属于当前任务库。')
_check_capture(capture)
return capture
def reconcile_deliveries(self, *, limit=100):
result={'accepted':0,'errors':[]}
# Completed queue checkpoints are durable and exist independently of a UI callback.
directory=self.data_root/'task-queues'
for path in sorted(directory.glob('*.json'),key=lambda p:p.stat().st_mtime,reverse=True)[:limit]:
try:
value=json.loads(path.read_text(encoding='utf-8'))
value.setdefault('run_id',path.stem)
record=self.receive_successful_results(value,submission_id='checkpoint:'+digest(value))
result['accepted']+=len(record['accepted'])
for rejection in record['rejected']:
result['errors'].append({'record':path.name,'reason':rejection['reason']})
except (ValueError,OSError,KeyError,TypeError) as error:
result['errors'].append({'record':path.name,'reason':str(error)})
return result
@@ -0,0 +1,206 @@
"""Transactional verification records; replacement receipts are never modified."""
from datetime import datetime, timezone
import json
from uuid import uuid4
from .contracts import ACTIVE, TERMINAL, digest, fail, identifier, validate_input
from ..errors import TaskCenterError
def now():
return datetime.now(timezone.utc).isoformat()
def encode(value):
return json.dumps(value, ensure_ascii=False, sort_keys=True, allow_nan=False)
def create_schema(c):
statements = (
'''CREATE TABLE IF NOT EXISTS verification_tasks (
task_id TEXT PRIMARY KEY, name TEXT NOT NULL, created TEXT NOT NULL,
view_revision INTEGER NOT NULL DEFAULT 0)''',
'''CREATE TABLE IF NOT EXISTS verification_items (
item_id TEXT PRIMARY KEY, task_id TEXT NOT NULL REFERENCES verification_tasks(task_id),
item_key TEXT NOT NULL, project_key TEXT NOT NULL, before_id TEXT,
display_name TEXT NOT NULL, current_version INTEGER NOT NULL,
UNIQUE(task_id,item_key))''',
'''CREATE TABLE IF NOT EXISTS verification_input_revisions (
item_id TEXT NOT NULL REFERENCES verification_items(item_id), input_version INTEGER NOT NULL,
payload_json TEXT NOT NULL, payload_digest TEXT NOT NULL, created TEXT NOT NULL,
PRIMARY KEY(item_id,input_version))''',
'''CREATE TABLE IF NOT EXISTS verification_attempts (
attempt_id TEXT PRIMARY KEY, item_id TEXT NOT NULL, input_version INTEGER NOT NULL,
generation INTEGER NOT NULL, state TEXT NOT NULL, owner_id TEXT, run_id TEXT,
result_json TEXT, reason TEXT NOT NULL DEFAULT '', resource_state TEXT NOT NULL DEFAULT 'not_started',
created TEXT NOT NULL, updated TEXT NOT NULL,
FOREIGN KEY(item_id,input_version) REFERENCES verification_input_revisions(item_id,input_version))''',
'''CREATE UNIQUE INDEX IF NOT EXISTS verification_active_attempt ON verification_attempts(item_id,input_version)
WHERE state IN ('queued','running','publishing','stopping')''',
'''CREATE UNIQUE INDEX IF NOT EXISTS verification_attempt_generation
ON verification_attempts(item_id,input_version,generation DESC)''',
'''CREATE TABLE IF NOT EXISTS verification_runs (
run_id TEXT PRIMARY KEY, task_id TEXT NOT NULL REFERENCES verification_tasks(task_id),
members_json TEXT NOT NULL, stop_requested INTEGER NOT NULL DEFAULT 0,
state TEXT NOT NULL DEFAULT 'queued', created TEXT NOT NULL)''',
'''CREATE TABLE IF NOT EXISTS verification_requests (
kind TEXT NOT NULL, request_id TEXT NOT NULL, request_hash TEXT NOT NULL, result_json TEXT NOT NULL,
PRIMARY KEY(kind,request_id))''',
)
for statement in statements: c.execute(statement)
class VerificationRepository:
def __init__(self, task_store):
self.store = task_store
with task_store.transaction(): create_schema(task_store._connection)
@property
def connection(self): return self.store._connection
def _request(self, kind, request_id, body):
identifier(request_id)
row = self.connection.execute('SELECT * FROM verification_requests WHERE kind=? AND request_id=?',
(kind,request_id)).fetchone()
if row:
if row['request_hash'] != digest(body): fail('相同请求标识对应不同内容。','verification_conflict')
return json.loads(row['result_json'])
def _remember(self, kind, request_id, body, result):
self.connection.execute('INSERT INTO verification_requests VALUES (?,?,?,?)',
(kind,request_id,digest(body),encode(result)))
return result
def _touch(self, task_id):
self.connection.execute('UPDATE verification_tasks SET view_revision=view_revision+1 WHERE task_id=?',(task_id,))
def _one(self, table, key, value):
with self.store._lock:
row = self.connection.execute(f'SELECT * FROM {table} WHERE {key}=?',(value,)).fetchone()
if row is None: fail('找不到校验记录。','verification_not_found')
return dict(row)
def task(self, task_id): return self._one('verification_tasks','task_id',task_id)
def item(self, item_id): return self._one('verification_items','item_id',item_id)
def current_input(self,task_id,item_key):
with self.store._lock:
item=self.connection.execute(
'SELECT item_id,current_version FROM verification_items WHERE task_id=? AND item_key=?',
(task_id,item_key)).fetchone()
return self.revision(*item) if item else None
def revision(self, item_id, version):
with self.store._lock:
row = self.connection.execute('SELECT * FROM verification_input_revisions WHERE item_id=? AND input_version=?',
(item_id,version)).fetchone()
if row is None: fail('输入版本不存在。','verification_not_found')
return dict(row) | {'payload':json.loads(row['payload_json'])}
def attempt(self, attempt_id):
row = self._one('verification_attempts','attempt_id',attempt_id)
row['result'] = json.loads(row['result_json']) if row['result_json'] else None
return row
def latest_attempt(self, item_id, version):
with self.store._lock:
row = self.connection.execute('SELECT attempt_id FROM verification_attempts WHERE item_id=? AND input_version=? ORDER BY generation DESC LIMIT 1',
(item_id,version)).fetchone()
return self.attempt(row[0]) if row else None
def create_task(self, name, *, request_id):
name = identifier(name).strip()
with self.store.transaction():
old = self._request('create',request_id,name)
if old is not None: return old
task_id = uuid4().hex
self.connection.execute('INSERT INTO verification_tasks(task_id,name,created) VALUES (?,?,?)',(task_id,name,now()))
return self._remember('create',request_id,name,self.task(task_id))
def publish(self, task_id, inputs, *, submission_id):
body = {'task_id':task_id,'inputs':inputs}
with self.store.transaction():
self.task(task_id)
old = self._request('publish',submission_id,body)
if old is not None: return old
result = {key:[] for key in ('accepted','duplicates','stale_ignored','rejected')}
for index,value in enumerate(inputs):
try:
row = validate_input(value)
item = self.connection.execute('SELECT * FROM verification_items WHERE task_id=? AND item_key=?',
(task_id,row['item_key'])).fetchone()
before_id = row['before_ref']['manifest_id'] if row['before_ref'] else None
if item:
if item['project_key'] != row['project_key'] or (item['before_id'] and item['before_id'] != before_id):
fail('工程身份或原始基线变化,请新增比较项。','verification_conflict')
item_id = item['item_id']
existing = self.connection.execute('SELECT payload_digest FROM verification_input_revisions WHERE item_id=? AND input_version=?',
(item_id,row['input_version'])).fetchone()
ref = {'item_id':item_id,'input_version':row['input_version']}
if existing:
if existing[0] != row['payload_digest']: fail('同一版本内容冲突。','verification_conflict')
result['duplicates'].append(ref); continue
if row['input_version'] < item['current_version']:
result['stale_ignored'].append(ref); continue
else:
item_id = uuid4().hex
self.connection.execute('INSERT INTO verification_items VALUES (?,?,?,?,?,?,?)',
(item_id,task_id,row['item_key'],row['project_key'],before_id,row['display_name'],row['input_version']))
self.connection.execute('INSERT INTO verification_input_revisions VALUES (?,?,?,?,?)',
(item_id,row['input_version'],encode(row),row['payload_digest'],now()))
self.connection.execute('UPDATE verification_items SET current_version=?,before_id=COALESCE(before_id,?),display_name=? WHERE item_id=?',
(row['input_version'],before_id,row['display_name'],item_id))
result['accepted'].append({'item_id':item_id,'input_version':row['input_version']})
self._touch(task_id)
except TaskCenterError as error:
result['rejected'].append({'index':index,'code':error.code,'reason':error.message})
return self._remember('publish',submission_id,body,result)
def create_attempt(self, item_id, version, *, request_id, run_id=None):
body = [item_id,version]
with self.store.transaction():
old = self._request('attempt',request_id,body)
if old is not None: return old
item = self.item(item_id)
revision = self.revision(item_id,version)
if revision['payload']['input_state'] != 'ready': fail('前后输入不可用。')
current = self.latest_attempt(item_id,version)
if current and current['state'] in ACTIVE:
return self._remember('attempt',request_id,body,current)
generation = (current['generation'] + 1) if current else 1
attempt_id, stamp = uuid4().hex, now()
self.connection.execute('''INSERT INTO verification_attempts
(attempt_id,item_id,input_version,generation,state,run_id,created,updated)
VALUES (?,?,?,?,'queued',?,?,?)''',(attempt_id,item_id,version,generation,run_id,stamp,stamp))
self._touch(item['task_id'])
return self._remember('attempt',request_id,body,self.attempt(attempt_id))
def claim(self, attempt_id, *, owner_id):
with self.store.transaction():
changed = self.connection.execute("UPDATE verification_attempts SET state='running',owner_id=?,updated=? WHERE attempt_id=? AND state='queued'",
(identifier(owner_id),now(),attempt_id)).rowcount
return self.attempt(attempt_id) if changed else None
def finish(self, attempt_id, *, generation, result):
with self.store.transaction():
attempt = self.attempt(attempt_id)
if attempt['generation'] != generation or attempt['state'] not in {'running','publishing'}: return False
if result.get('resource_state') != 'released': fail('资源退出尚未确认。','verification_resources')
state = result.get('attempt_state','succeeded')
if state not in TERMINAL: fail('无效校验终态。')
if attempt['run_id'] and state not in {'cancelled','interrupted'}:
run=self.connection.execute('SELECT stop_requested FROM verification_runs WHERE run_id=?',(attempt['run_id'],)).fetchone()
if run and run[0]:return False
self.connection.execute('UPDATE verification_attempts SET state=?,result_json=?,resource_state=?,updated=? WHERE attempt_id=?',
(state,encode(result),'released',now(),attempt_id))
self._touch(self.item(attempt['item_id'])['task_id'])
from ..history_store import HistoryRepository
item=self.item(attempt['item_id']);task=self.task(item['task_id'])
HistoryRepository(self.store).append(task_id=task['task_id'],task_name=task['name'],
project_path=item['project_key'],operation='verification_completed',
state='verified' if result.get('verdict')=='CONSISTENT' else 'failed' if result.get('verdict')=='DIFFERENT' else 'uncertain',
summary='工程校验:'+str(result.get('verdict','INCOMPLETE')),
details={'attempt_id':attempt_id,'input_version':attempt['input_version'],'generation':generation,
'verdict':result.get('verdict'),'scope':result.get('scope')},
source_key='verification:'+attempt_id)
return True
@@ -362,6 +362,7 @@ def run_monitored_process(command: tuple[str, ...], idle_timeout: float, *, abor
stop_readers = threading.Event()
output = [bytearray(), bytearray()]
startup_pause = None
prewrite_pause = None
def read_stream(stream, channel):
try:
@@ -379,7 +380,7 @@ def run_monitored_process(command: tuple[str, ...], idle_timeout: float, *, abor
stream.close()
def receive(channel, line):
nonlocal startup_pause
nonlocal startup_pause, prewrite_pause
if channel == 0 and watch.accept(line, time.monotonic()):
_publish_progress(progress_path, watch.snapshot())
elif channel == 0 and line.startswith(b'DX_STARTUP_PAUSED\t'):
@@ -399,6 +400,29 @@ def run_monitored_process(command: tuple[str, ...], idle_timeout: float, *, abor
'project_path': request[1], 'sequence': watch.sequence}
except (OSError, UnicodeError, ValueError):
pass
elif channel == 0 and line.startswith(b'DX_PREWRITE_PAUSED\t'):
try:
from .quick_run import _decode_vbs_field
from .path_access import canonical_path
fields = line.decode('ascii').strip().split('\t')
request_data = (root / 'project-session.request').read_bytes()
request = request_data.decode('utf-8-sig').strip().split('\t')
original = session_request.decode('utf-8-sig').strip().split('\t') if session_request else []
if (len(fields) == 6 and fields[:3] == ['DX_PREWRITE_PAUSED', token, job_id]
and len(request) == 3 and len(original) == 3 and request[:2] == original[:2]
and fields[3:5] == [request[0], request[2]] and re.fullmatch('[0-9a-f]{32}', request[0])
and re.fullmatch(r'[A-Za-z0-9_.-]{1,128}', request[2])
and int(fields[5]) == watch.sequence and watch.sequence > 0
and abort_event is not None and abort_event.is_set() and watch.stop_requested):
marker = (root / ('project-pause-' + request[0] + '.tsv')).read_bytes()
values = marker.decode('utf-8-sig').strip().split('\t')
if (len(values) == 4 and values[0] == request[0] and values[2:] == [request[2], 'prewrite_closed']
and canonical_path(_decode_vbs_field(values[1])) == canonical_path(request[1])):
prewrite_pause = {'monitor_token': token, 'session_token': request[0], 'job_id': request[2],
'project_path': request[1], 'sequence': watch.sequence,
'request_bytes': request_data, 'marker_bytes': marker}
except (OSError, UnicodeError, ValueError):
pass
elif len(output[channel]) < 1024 * 1024:
output[channel].extend(line[:1024 * 1024 - len(output[channel])])
@@ -545,6 +569,15 @@ def run_monitored_process(command: tuple[str, ...], idle_timeout: float, *, abor
or not _worker_tree_exited(process, owned)):
raise WorkerMonitorError('startup pause lacks correlated no-project acknowledgement or worker exit')
result.startup_pause = dict(startup_pause, worker_tree_exited=True)
if process.returncode == 75:
if (prewrite_pause is None or prewrite_pause['sequence'] != watch.sequence
or result.stderr.strip() or not _worker_tree_exited(process, owned)
or (root / 'project-session.request').read_bytes() != prewrite_pause['request_bytes']
or (root / ('project-pause-' + prewrite_pause['session_token'] + '.tsv')).read_bytes()
!= prewrite_pause['marker_bytes']):
raise WorkerMonitorError('prewrite pause lacks correlated closed-project acknowledgement or worker exit')
result.prewrite_pause = {key: value for key, value in prewrite_pause.items()
if key not in {'request_bytes', 'marker_bytes'}} | {'worker_tree_exited': True}
return result
except Exception as error:
if process is not None:
@@ -9,21 +9,14 @@ from uuid import uuid4
from .batch_resources import write_record
from .errors import TaskCenterError
from .path_access import canonical_path, internal_path
from .stop_control import StopControl, protect_interruption
from .stop_control import ProjectStopControl, protect_interruption
from .project_isolation import write_sources, record_task_outcome, block_dependency, dependency_readmitted
_LOCK = Lock()
_TERMINAL = {'completed', 'failed', 'skipped', 'blocked'}
class _ProjectControl(StopControl):
def __init__(self, parent):
super().__init__()
self.parent = parent
if hasattr(parent, 'force_event'):
self.force_event = parent.force_event
def is_set(self):
return super().is_set() or self.parent.is_set()
_ProjectControl = ProjectStopControl
@contextmanager
@@ -68,7 +61,8 @@ def _released_after_recheck(root, task_id, row):
journal = json.loads(internal_path(root / 'batch-resources' / batch_id / 'supervisor.json').read_text(encoding='utf-8'))
return (valid_journal(journal, batch_id) and journal['task_ids'] == [task_id]
and journal['state'] == 'finished' and journal.get('process')
and _process_gone(journal['process']) and not pending_resources(root) and not pending_supervisors(root))
and _process_gone(journal['process']) and not any(row.get('blocking', True) for row in pending_resources(root))
and not any(row.get('blocking', True) for row in pending_supervisors(root)))
except (OSError, ValueError, KeyError, TypeError):
return False
@@ -88,6 +82,7 @@ def execute_workspace_projects(service, task_ids, *, stop_event, queue_id=None,
for rows in projects}) != len(ids):
raise TaskCenterError('project_binding', '每个任务必须对应不同的单个工程。')
hashes = {item: _plan_hash(children[item], item) for item in ids}
sources = {item: write_sources(rows[0].path) for item, rows in zip(ids, projects)}
if expected_plan_hashes is not None and hashes != expected_plan_hashes:
raise TaskCenterError('assistant_stale', '执行计划已变化,请重新预检。')
token = queue_id or checkpoint_id or uuid4().hex
@@ -115,6 +110,9 @@ def execute_workspace_projects(service, task_ids, *, stop_event, queue_id=None,
for item in ids}}
write_record(path, state)
isolated_sources = state.setdefault('isolated_sources', {})
dependency_tasks = state.setdefault('dependency_tasks', {})
def result(paused=False, current=None):
verification = {item: state['entries'][item]['netlist_verification'] for item in ids
if state['entries'][item].get('netlist_verification')}
@@ -140,17 +138,25 @@ def execute_workspace_projects(service, task_ids, *, stop_event, queue_id=None,
or outcome.entries[0].state not in {'pending', 'running', 'paused', *_TERMINAL}):
raise TaskCenterError('task_queue_state', '工程监督进程返回了不同的队列身份。')
row.update(state=outcome.entries[0].state, message=outcome.entries[0].message, released=True)
if row['state'] == 'blocked':
record_task_outcome(children[item], item, 'blocked', row['message'])
isolated_sources.update((source, item) for source in sources[item])
verification = (outcome.netlist_verification or {}).get(item)
if verification:
row['netlist_verification'] = verification
write_record(path, state)
return outcome.paused and row['state'] != 'blocked'
except TaskCenterError as error:
released = getattr(error, 'resources_released', False) is True
from .batch_resources import resource_blockers
released = ((getattr(error, 'resources_released', False) is True
or getattr(error, 'owned_writers_exited', False) is True)
and not resource_blockers(service.pending_batch_resources() if hasattr(service, 'pending_batch_resources') else ()))
row.update(state='blocked', message=error.message, released=released)
row['supervisor_batch_id'] = getattr(service, '_last_supervisor_batch_id', None)
evidence = getattr(getattr(children[item], '_quick_run_preparer', None), 'data_root', root / 'tasks' / item)
protect_interruption(Path(evidence) / 'quick-run', 'project_supervisor_failed: ' + error.message)
record_task_outcome(children[item], item, 'blocked', error.message)
isolated_sources.update((source, item) for source in sources[item])
if released:
from .batch_supervisor import reconcile_supervisors
try:
@@ -165,9 +171,31 @@ def execute_workspace_projects(service, task_ids, *, stop_event, queue_id=None,
raise
try:
if state['phase'] == 'finished' and any(dependency_readmitted(children[item], item, hashes[item])
for item in tuple(dependency_tasks)):
state['phase'] = 'primary'
if state['phase'] == 'primary':
for item in ids:
row = state['entries'][item]
readmitted = False
if item in dependency_tasks:
try:
readmitted = dependency_readmitted(children[item], item, hashes[item])
except TaskCenterError:
pass
if readmitted:
row.update(state='pending', message='共享依赖已核验,恢复未派发原计划。')
dependency_tasks.pop(item)
conflict = next((isolated_sources[source] for source in sources[item]
if source in isolated_sources and isolated_sources[source] != item), None)
if conflict is not None and not readmitted and row['state'] not in {'completed', 'failed', 'skipped'}:
message = f'与待核验工程 {conflict} 共享写入源,已隔离;未派发替换。'
block_dependency(root, children[item], item, conflict,
sources[item] & sources[conflict], hashes[item], token)
dependency_tasks[item] = conflict
row.update(state='blocked', message=message, released=True, problems_done=True)
write_record(path, state)
continue
if row['state'] in _TERMINAL:
if row['state'] == 'blocked' and not row['released']:
if not _released_after_recheck(root, item, row):
+20 -8
View File
@@ -192,10 +192,11 @@ def test_legacy_rule_retry_cannot_create_a_replacement_before_baseline(rule_run)
assert receipt['execution_status'] == 'completed' and receipt['acceptance']['status'] == 'unavailable'
def test_retry_receipt_refresh_preserves_other_task_without_dispatch(tmp_path, monkeypatch):
def test_retry_receipt_refresh_preserves_other_task_without_dispatch(tmp_path, monkeypatch, request):
from types import SimpleNamespace as NS
from dx_productivity.dsh.execution_runs import execute_incident_retry
from dx_productivity.dsh.execution_runs import _finish_execution_run, execute_incident_retry
from dx_productivity.trial_task_center import netlist_verification, task_queue
from dx_productivity.trial_task_center.verification.service import VerificationService
selected, other, run_id = 'a' * 32, 'b' * 32, 'c' * 32
hashes = {selected: 'd' * 64, other: 'e' * 64}
monkeypatch.setattr(task_queue, '_plan_hash', lambda child, key: hashes[key])
@@ -206,22 +207,32 @@ def test_retry_receipt_refresh_preserves_other_task_without_dispatch(tmp_path, m
def execute(key, **options):
dispatch.append(key)
return NS(paused=False)
service = NS(for_project_task=lambda key: service, task_context=context, execute_quick_run_queue=execute)
store = TaskStore(tmp_path / 'tasks.db')
request.addfinalizer(store.close)
verification_service = VerificationService(store, tmp_path)
service = NS(for_project_task=lambda key: service, task_context=context, execute_quick_run_queue=execute,
verification=verification_service)
class Checks:
def __init__(self, *args): self.tasks = {}
def __enter__(self): return self
def __exit__(self, *args): pass
def before_task(self, child, key, *, existing_only): assert existing_only
def after_task(self, key, **options): assert key == selected
def finish(self): return {selected: {'status': 'verified', 'verified': True, 'report_path': 'new.json'}}
def finish(self):
return {selected: {'status': 'verified', 'verified': True, 'report_path': 'new.json',
'execution': {'state': 'completed', 'saved_items': 1}}}
monkeypatch.setattr(netlist_verification, 'NetlistVerification', Checks)
journal = RunJournal(tmp_path)
journal.begin(run_id, [selected, other], hashes)
old_other = {'task_id': other, 'state': 'completed', 'message': 'original saved result'}
old_report = {'status': 'verified', 'verified': True, 'report_path': 'original.json'}
journal.finish(run_id, {'status': 'failed', 'entries': [
{'task_id': selected, 'state': 'failed', 'message': 'safe failure'}, old_other],
'netlist_verification': {other: old_report}})
old_report = {'status': 'verified', 'verified': True, 'report_path': 'original.json',
'execution': {'state': 'completed', 'saved_items': 1}}
initial = task_queue.TaskQueueResult(run_id, (
task_queue.TaskQueueEntry(selected, 'failed', 'safe failure'),
task_queue.TaskQueueEntry(**old_other)), False, netlist_verification={other: old_report})
_finish_execution_run(service, tmp_path, [selected, other], Event(), run_id, initial, baseline={})
verification_task = verification_service.list_tasks()['tasks'][0]['task_id']
assert verification_service.read_task(verification_task)['summary']['total'] == 1
checkpoint = tmp_path / 'task-queues' / (run_id + '.json')
checkpoint.parent.mkdir()
checkpoint.write_text(json.dumps({'version': 1, 'phase': 'finished', 'task_ids': [selected, other],
@@ -234,6 +245,7 @@ def test_retry_receipt_refresh_preserves_other_task_without_dispatch(tmp_path, m
assert next(row for row in receipt['entries'] if row['task_id'] == other) == old_other
assert receipt['netlist_verification'][other] == old_report
assert json.loads(checkpoint.read_text())['entries'][other] == {'state': 'completed', 'message': 'original saved result'}
assert {row['item_key'] for row in verification_service.read_task(verification_task)['items']} == {selected, other}
@pytest.mark.parametrize('scheduled', [False, True])
@@ -1,18 +1,14 @@
import importlib.util
import inspect
from pathlib import Path
import subprocess
import tempfile
from types import SimpleNamespace
import unittest
from unittest.mock import call, patch
ROOT = Path(__file__).resolve().parents[2]
RUNTIME = ROOT / "integration" / "dxdesigner795"
SPEC = importlib.util.spec_from_file_location(
"native", ROOT / "src" / "dx_productivity" / "trial_task_center" / "native_helper.py"
)
native = importlib.util.module_from_spec(SPEC)
SPEC.loader.exec_module(native)
from dx_productivity.trial_task_center import native_helper as native
FAKES = r"""
Class TestPoint
@@ -107,7 +103,7 @@ End Sub
class NativeTests(unittest.TestCase):
def test_native_command_does_not_use_physical_mouse_fallback(self):
source = inspect.getsource(native.run_native)
source = inspect.getsource(inspect.unwrap(native.run_native))
self.assertIn("replacement_command_from_resources(executable)", source)
self.assertNotIn("win32api.SetCursorPos", source)
@@ -115,20 +111,24 @@ class NativeTests(unittest.TestCase):
self.assertNotIn("win32gui.SetCursorPos(screen_point)", source)
def test_snapshot_batch_is_reselected_before_the_strict_selection_gate(self):
app = object()
api = object()
metadata = ["M"]
first = type("Component", (), {"UID": "wanted"})()
other = type("Component", (), {"UID": "other"})()
first = SimpleNamespace(UID='wanted', Refdes='R1', Selected=False)
other = SimpleNamespace(UID='other', Refdes='R2', Selected=True)
first._oleobj_, other._oleobj_ = first, other
app = SimpleNamespace(ActiveView=SimpleNamespace(Query=lambda kind, scope:
[component for component in (first, other) if component.Selected]))
api = SimpleNamespace(IVdComp=lambda value:value)
records = [["C", "wanted"]]
with patch.object(native, "check_context", side_effect=([first, other], [first, other])) as check:
with patch.object(native, "selection") as select:
with patch.object(native, "check_context", return_value=[first, other]) as check:
with patch.object(native, "selection", side_effect=lambda component, selected:setattr(component,'Selected',selected)) as select, \
patch.object(native, "check_active_context"):
result = native.select_snapshot_batch(app, api, metadata, records)
self.assertEqual(result, [first, other])
self.assertEqual(check.call_args_list[0], call(app, api, metadata, records, require_selection=False))
self.assertEqual(check.call_args_list[1], call(app, api, metadata, records))
self.assertEqual(select.call_args_list, [call(first, True), call(other, False)])
self.assertTrue(first.Selected)
self.assertFalse(other.Selected)
def test_snapshot_escape_format(self):
self.assertEqual(native.decode("a%0009b%000Ac%0025"), "a\tb\nc%")
Loaded 100 of 195 files, more files were not shown because too many files have changed in this diff. Show more