Compare commits

...
Author SHA1 Message Date
abaishu0730 46deb9cec8 Merge pull request 'feat: 升级 DeepSeek Harness 并支持运行时更新' (#32) from codex/dsh-runtime-update into main
Core regression / Python core, intervention UI and release configuration (push) Failing after 20m55s
Core regression / JavaScript syntax (push) Successful in 10s
2026-11-20 17:21:04 +08:00
阿白叔 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
阿白叔 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
阿白叔 b038951cc4 test: close packaged stop recovery and real saved handoff workflows 2026-11-18 18:00:22 +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
阿白叔 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
阿白叔 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
80 changed files with 10283 additions and 3322 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 npm install --prefix /opt/ci-node --no-audit --no-fund node@24.11.1
node --version node --version
npm ci --prefix integration/dsh --no-audit --no-fund 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: | run: |
node tools/verify_dsh_runtime.mjs
node tools/verify_dsh_model_availability.mjs node tools/verify_dsh_model_availability.mjs
node --test tests/integration/test_dsh_standard_compat.mjs node --test tests/integration/test_dsh_standard_compat.mjs
node tools/verify_dsh_incident_restart.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,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,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,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,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,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,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` 打开;切回任务中心再进入助手时保留同一个网页、会话和未发送草稿。右侧“任务监管”读取主工具当前选中的任务。 主工具顶部固定显示左右两个入口:左侧 **任务中心**,右侧 **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工具”“通用设置”和“模型”;首页提示和任务监管面板围绕器件替换任务。输入框下方选择已配置的模型。 不显示上游账户登录、注册、充值和首次产品引导,也不注册其账户模型提供方。左下角 **工具设置** 单击打开原生设置页,包含“DSH工具”“通用设置”和“模型”;首页提示和任务监管面板围绕器件替换任务。输入框下方选择已配置的模型。
@@ -178,6 +178,14 @@ node tools/verify_dsh_runtime.mjs
python tools/accept_dsh_desktop.py 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 或修改用户工程;未配置模型的验收不计为真实模型回复验证。 CLI 验证启动真实官方内核,检查工具与 preset 名单,实际读取快照、执行禁止工具探针,并测试本机请求认证、跨任务与过期动作边界。桌面验收启动真实主工具,用 Qt 鼠标事件单击左右导航,用 Chromium Input 事件操作官方页面,核对全新数据下无账户或引导弹窗、工具设置、任务刷新、会话、侧栏、SVG 动画、模型选择、草稿保留、取消确认和正常退出。验收只使用独立测试数据,不启动 CAD 或修改用户工程;未配置模型的验收不计为真实模型回复验证。
已配置本机模型时,可执行真实 API 桌面验收: 已配置本机模型时,可执行真实 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", "name": "dxdesigner-dsh-runtime",
"private": true, "private": true,
"type": "module", "type": "module",
"scripts": {"doctor": "node start.mjs --doctor", "start": "node start.mjs"}, "scripts": {
"engines": {"node": ">=24.9.0"}, "doctor": "node start.mjs --doctor",
"dependencies": {"@deepseek-ai/dsh": "0.2.1-rc.5", "fflate": "0.8.3"} "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 root = path.dirname(fileURLToPath(import.meta.url));
const require = createRequire(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 = [ export const DISABLED = [
'desktop-product-telemetry','product-analytics','session-telemetry-otel', 'desktop-product-telemetry','product-analytics','session-telemetry-otel',
]; ];
+1 -1
View File
@@ -1,5 +1,5 @@
DeepSeek Harness native frontend and runtime 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 Source: https://github.com/deepseek-ai/deepseek-harness
MIT License MIT License
+14
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')}) receipt['reporting_errors'].append({'code': getattr(error, 'code', 'schedule_receipt_unavailable')})
_persist_execution_receipt(service, journal, run_id, receipt, baseline) _persist_execution_receipt(service, journal, run_id, receipt, baseline)
raise 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 return receipt
@@ -12,9 +12,6 @@ from uuid import uuid4
from .snapshot import TaskSnapshot from .snapshot import TaskSnapshot
from ..trial_task_center.path_access import retry_sharing_violation from ..trial_task_center.path_access import retry_sharing_violation
HARNESS_VERSION = '0.2.1-rc.5'
def integration_root() -> Path: def integration_root() -> Path:
if getattr(sys, 'frozen', False): if getattr(sys, 'frozen', False):
return Path(sys._MEIPASS) / 'dsh-runtime' return Path(sys._MEIPASS) / 'dsh-runtime'
@@ -102,6 +102,14 @@ def _default_path_opener(path: Path) -> None:
class TaskCenterService: class TaskCenterService:
"""The only API used by UI workers and widgets.""" """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__( def __init__(
self, self,
store: TaskStore, store: TaskStore,
@@ -65,6 +65,8 @@ class StoreSchema:
from .execution_journal import create_execution_schema from .execution_journal import create_execution_schema
create_history_schema(self._store._connection) create_history_schema(self._store._connection)
create_execution_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: def _create_schema_v1(self) -> None:
statements = ( statements = (
@@ -30,6 +30,7 @@ def icon(name: str, primary: bool = False) -> QIcon:
BUTTON_ICONS = { BUTTON_ICONS = {
'task_center_navigation': 'grid', 'dsh_navigation': 'chat', 'task_center_navigation': 'grid', 'dsh_navigation': 'chat',
'history_navigation': 'clock', 'history_navigation': 'clock',
'verification_navigation': 'check', 'verificationNew': 'plus',
'newTaskButton': 'plus', 'editTaskButton': 'sliders', 'deleteTaskButton': 'trash', 'newTaskButton': 'plus', 'editTaskButton': 'sliders', 'deleteTaskButton': 'trash',
'selectAllTasks': 'check', 'clearTaskSelection': 'close', 'selectAllTasks': 'check', 'clearTaskSelection': 'close',
'restoreTaskButton': 'refresh', 'taskRecycleBin': 'trash', 'restoreTaskButton': 'refresh', 'taskRecycleBin': 'trash',
@@ -60,6 +60,8 @@ class TrialTaskCenterWindow(MaterialMainWindow):
self.dsh_action = QAction('DSH助手', self) self.dsh_action = QAction('DSH助手', self)
self.dsh_action.setShortcut('Ctrl+Shift+D') self.dsh_action.setShortcut('Ctrl+Shift+D')
self.dsh_action.triggered.connect(self._open_dsh) 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 = QActionGroup(self)
self._navigation_actions.setExclusive(True) self._navigation_actions.setExclusive(True)
navigation = QWidget(objectName='toolNavigation') navigation = QWidget(objectName='toolNavigation')
@@ -70,7 +72,8 @@ class TrialTaskCenterWindow(MaterialMainWindow):
navigation_layout.addWidget(brand) navigation_layout.addWidget(brand)
navigation_layout.addSpacing(24) navigation_layout.addSpacing(24)
for name, action in (('task_center_navigation', self.task_center_action), 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) action.setCheckable(True)
self._navigation_actions.addAction(action) self._navigation_actions.addAction(action)
self.addAction(action) self.addAction(action)
@@ -292,14 +295,20 @@ class TrialTaskCenterWindow(MaterialMainWindow):
self.history_panel = OperationHistoryPage(self.service, self) self.history_panel = OperationHistoryPage(self.service, self)
self.history_panel.busy_changed.connect(self._history_activity_changed) self.history_panel.busy_changed.connect(self._history_activity_changed)
self.content_stack.addWidget(self.history_panel) 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.content_stack.currentChanged.connect(self._workspace_changed)
self.setCentralWidget(self.content_stack) self.setCentralWidget(self.content_stack)
self._reset_layout() self._reset_layout()
def _workspace_changed(self, index): def _workspace_changed(self, index):
history = self.content_stack.widget(index) is self.history_panel 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.history_panel.set_active(history)
self.verification_panel.set_active(verification)
def _history_activity_changed(self): def _history_activity_changed(self):
self._update_gates() 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.stopped.connect(lambda: QTimer.singleShot(0, self, self.close))
self._dsh_view.shutdown() self._dsh_view.shutdown()
return 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() self._cancel_dsh_diagnosis()
for name, widget in self._layout_widgets().items(): for name, widget in self._layout_widgets().items():
self._layout_settings.setValue(f'single_project/{name}', widget.saveState()) self._layout_settings.setValue(f'single_project/{name}', widget.saveState())
@@ -408,6 +423,7 @@ class TrialTaskCenterWindow(MaterialMainWindow):
self._dsh_status.close() self._dsh_status.close()
self._dsh_stall_timer.stop() self._dsh_stall_timer.stop()
self.history_panel.shutdown() self.history_panel.shutdown()
self.verification_panel.shutdown()
if self._dsh_operations: if self._dsh_operations:
self._dsh_operations.close() self._dsh_operations.close()
self._context_query.close() self._context_query.close()
@@ -18,6 +18,7 @@ STATES={'verified':'已核验完成','no_match':'未命中','failed':'失败','f
'uncertain':'待核验','saved_unverified':'保存待核验','skipped':'已跳过','recorded':'已记录', 'uncertain':'待核验','saved_unverified':'保存待核验','skipped':'已跳过','recorded':'已记录',
'running':'执行中','paused':'已暂停','pending':'待执行','restored':'已恢复'} 'running':'执行中','paused':'已暂停','pending':'待执行','restored':'已恢复'}
OPERATIONS={'quick_run_executed':'替换执行','quick_run_prepared':'准备执行', OPERATIONS={'quick_run_executed':'替换执行','quick_run_prepared':'准备执行',
'verification_completed':'工程校验',
'quick_run_recovered':'核验恢复','quick_run_queue_paused':'暂停执行', 'quick_run_recovered':'核验恢复','quick_run_queue_paused':'暂停执行',
'quick_run_retry_prepared':'准备失败项重试','create_project_tasks':'创建工程任务', 'quick_run_retry_prepared':'准备失败项重试','create_project_tasks':'创建工程任务',
'create_task':'新建任务','update_task':'编辑任务','delete_task':'归档任务', 'create_task':'新建任务','update_task':'编辑任务','delete_task':'归档任务',
@@ -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()
@@ -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
+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' 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 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 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 selected, other, run_id = 'a' * 32, 'b' * 32, 'c' * 32
hashes = {selected: 'd' * 64, other: 'e' * 64} hashes = {selected: 'd' * 64, other: 'e' * 64}
monkeypatch.setattr(task_queue, '_plan_hash', lambda child, key: hashes[key]) 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): def execute(key, **options):
dispatch.append(key) dispatch.append(key)
return NS(paused=False) 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: class Checks:
def __init__(self, *args): self.tasks = {} def __init__(self, *args): self.tasks = {}
def __enter__(self): return self def __enter__(self): return self
def __exit__(self, *args): pass def __exit__(self, *args): pass
def before_task(self, child, key, *, existing_only): assert existing_only def before_task(self, child, key, *, existing_only): assert existing_only
def after_task(self, key, **options): assert key == selected 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) monkeypatch.setattr(netlist_verification, 'NetlistVerification', Checks)
journal = RunJournal(tmp_path) journal = RunJournal(tmp_path)
journal.begin(run_id, [selected, other], hashes) journal.begin(run_id, [selected, other], hashes)
old_other = {'task_id': other, 'state': 'completed', 'message': 'original saved result'} old_other = {'task_id': other, 'state': 'completed', 'message': 'original saved result'}
old_report = {'status': 'verified', 'verified': True, 'report_path': 'original.json'} old_report = {'status': 'verified', 'verified': True, 'report_path': 'original.json',
journal.finish(run_id, {'status': 'failed', 'entries': [ 'execution': {'state': 'completed', 'saved_items': 1}}
{'task_id': selected, 'state': 'failed', 'message': 'safe failure'}, old_other], initial = task_queue.TaskQueueResult(run_id, (
'netlist_verification': {other: old_report}}) 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 = tmp_path / 'task-queues' / (run_id + '.json')
checkpoint.parent.mkdir() checkpoint.parent.mkdir()
checkpoint.write_text(json.dumps({'version': 1, 'phase': 'finished', 'task_ids': [selected, other], 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 next(row for row in receipt['entries'] if row['task_id'] == other) == old_other
assert receipt['netlist_verification'][other] == old_report assert receipt['netlist_verification'][other] == old_report
assert json.loads(checkpoint.read_text())['entries'][other] == {'state': 'completed', 'message': 'original saved result'} 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]) @pytest.mark.parametrize('scheduled', [False, True])
+22
View File
@@ -0,0 +1,22 @@
from threading import Event
def test_mixed_result_inspector_shows_error_and_keeps_new_task_enabled(ui,qtbot):
from pathlib import Path
import sys
sys.path.insert(0,str(Path(__file__).parents[1]/'v1_1'))
from test_independent_verification_rules import export,evaluate
from dx_productivity.trial_task_center.verification.evidence import build_evidence
from test_independent_verification_contracts import payload
import copy
v=ui.service.verification;task=v.create_task('人工复核',request_id='accept')['task_id']
row=payload();item=v.repo.publish(task,(row,),submission_id='direct')['accepted'][0]['item_id']
a=export();b=copy.deepcopy(a);b['graph']['components']['a']['pins']['loop']['number']='2';b['graph']['components']['a']['pins']['GND']['number']='1'
result=evaluate(a,b);result.update(resource_state='released',evidence=build_evidence(a['graph'],b['graph'],result['issues'],binding={}))
attempt=v.repo.create_attempt(item,1,request_id='a');v.repo.claim(attempt['attempt_id'],owner_id='controlled')
v.repo.finish(attempt['attempt_id'],generation=1,result=result)
page=ui.window.verification_panel;page.open_task(task,item);ui.window.verification_action.trigger()
qtbot.waitUntil(lambda:'异常' in page.inspector.heading.text())
assert page.new_button.isEnabled() and page.inspector.pin_table.rowCount()==2
assert page.inspector.diagram.pins[0]['endpoint'][2]=='1'
assert '已处理 1/1' in page.footer.text()
+100
View File
@@ -0,0 +1,100 @@
from pathlib import Path
import sys
from threading import Event
from PySide6.QtCore import Qt
sys.path.insert(0, str(Path(__file__).parents[1]/'v1_1'))
from test_native_cli_netlist import project_fixture
def projects(tmp_path):
roots = tmp_path/'before', tmp_path/'after'
for root in roots:
for name in ('A', 'B'):
directory = root/name
directory.mkdir(parents=True)
project_fixture(directory)
directory = roots[0]/'only-before'
directory.mkdir()
project_fixture(directory)
return roots
def test_batch_preview_imports_only_checked_pairs_without_running_verification(ui, qtbot, tmp_path):
from dx_productivity.trial_task_center.ui.verification_batch_import import VerificationBatchDialog
page = ui.window.verification_panel
task = page.service.create_task('批量', request_id='batch')['task_id']
page.open_task(task)
page.batch_button.click()
dialog = page._batch_dialog
assert isinstance(dialog, VerificationBatchDialog) and dialog.isVisible() and not dialog.isModal()
before, after = projects(tmp_path)
dialog.before.setText(str(before)); dialog.after.setText(str(after))
dialog.scan.click()
qtbot.waitUntil(lambda: not dialog.busy)
assert dialog.table.rowCount() == 3
assert dialog.table.item(2, 0).checkState() == Qt.CheckState.Unchecked
assert not dialog.table.item(2, 0).flags() & Qt.ItemFlag.ItemIsUserCheckable
dialog.table.item(1, 0).setCheckState(Qt.CheckState.Unchecked)
dialog.import_button.click()
qtbot.waitUntil(lambda: not dialog.busy)
data = page.service.read_task(task)
assert data['summary']['total'] == 1
assert data['items'][0]['display_name'] == 'A/source/board.prj'
assert data['summary']['waiting'] == 1
assert page.new_button.isEnabled() and dialog.import_button.isEnabled() is False
assert page.service.repo.connection.execute('SELECT COUNT(*) FROM verification_attempts').fetchone()[0] == 0
dialog.reject()
def test_batch_cancel_keeps_first_pair_and_main_page_can_create_another_task(ui, qtbot, tmp_path, monkeypatch):
from dx_productivity.trial_task_center.ui.verification_batch_import import VerificationBatchDialog
page = ui.window.verification_panel
task = page.service.create_task('批量', request_id='batch')['task_id']
page.open_task(task)
dialog = VerificationBatchDialog(page.service, page.controller, task, '批量', page)
qtbot.addWidget(dialog)
before, after = projects(tmp_path)
dialog.before.setText(str(before)); dialog.after.setText(str(after)); dialog.scan.click()
qtbot.waitUntil(lambda: not dialog.busy)
entered, release = Event(), Event()
original = page.service.import_pair
def slow(*args, **kwargs):
result = original(*args, **kwargs)
entered.set(); release.wait(5)
return result
monkeypatch.setattr(page.service, 'import_pair', slow)
dialog.import_button.click()
qtbot.waitUntil(entered.is_set)
try:
assert page.new_button.isEnabled()
other = page.service.create_task('另一个任务', request_id='other')['task_id']
assert other != task
dialog.cancel_button.click()
finally:
release.set()
qtbot.waitUntil(lambda: not dialog.busy)
assert page.service.read_task(task)['summary']['total'] == 1
dialog.reject()
def test_closing_preview_cancels_scan_without_late_table_changes(ui, qtbot, tmp_path, monkeypatch):
from dx_productivity.trial_task_center.ui.verification_batch_import import VerificationBatchDialog
page = ui.window.verification_panel
task = page.service.create_task('关闭读取', request_id='batch')['task_id']
dialog = VerificationBatchDialog(page.service, page.controller, task, '关闭读取', page)
qtbot.addWidget(dialog)
before, after = projects(tmp_path)
entered, release = Event(), Event()
scan = page.service.preview_pairs
def slow(*args, **kwargs):
entered.set(); release.wait(5)
return scan(*args, **kwargs)
monkeypatch.setattr(page.service, 'preview_pairs', slow)
dialog.before.setText(str(before)); dialog.after.setText(str(after)); dialog.scan.click()
qtbot.waitUntil(entered.is_set)
dialog.reject(); release.set()
qtbot.waitUntil(lambda: not page.controller.workers)
assert not dialog.busy and dialog.table.rowCount() == 0
assert page.service.read_task(task)['summary']['total'] == 0
+38
View File
@@ -0,0 +1,38 @@
def test_close_and_controls_do_not_block_new_task_creation(ui,qtbot):
page=ui.window.verification_panel
task=ui.service.verification.create_task('任务',request_id='control')['task_id']
page.open_task(task)
qtbot.waitUntil(lambda:not page.controller.task_query.busy)
assert page.start_button.isEnabled() and page.new_button.isEnabled()
page.begin_shutdown()
assert page.new_button.isEnabled()
def test_shutdown_is_idempotent_after_store_is_released(ui,qtbot):
page=ui.window.verification_panel
page.shutdown()
original=page.service.begin_shutdown
def forbidden():raise AssertionError('closed page must not access released store')
page.service.begin_shutdown=forbidden
try:page.shutdown()
finally:page.service.begin_shutdown=original
def test_finished_run_does_not_leave_stop_enabled(ui,qtbot):
page=ui.window.verification_panel
task=page.service.create_task('空任务',request_id='finished')['task_id']
page.open_task(task)
page._started({'run_id':'already-finished'})
qtbot.waitUntil(lambda:not page.controller.task_query.busy)
assert not page.stop_button.isEnabled()
def test_cancelling_window_close_does_not_close_verification_admission(ui,monkeypatch):
from dx_productivity.trial_task_center.ui.verification_workspace import VerificationWorkspace
ui.settle();window=ui.window
with monkeypatch.context() as patch:
patch.setattr(VerificationWorkspace,'busy',property(lambda self:True))
patch.setattr(window.plan_panel,'has_unsaved_plans',lambda:True)
window._close_plan_confirmer=lambda:'cancel'
assert not window.close()
assert not window.verification_panel.service.control.closing
+34
View File
@@ -0,0 +1,34 @@
from dx_productivity.trial_task_center.verification.evidence import build_evidence
def test_inspector_uses_evidence_pin_table_and_explicit_coverage(qtbot):
from dx_productivity.trial_task_center.ui.verification_inspector import VerificationInspector
from pathlib import Path
import sys
sys.path.insert(0,str(Path(__file__).parents[1]/'v1_1'))
from test_independent_verification_rules import export,evaluate
a=export();result=evaluate(a,a)
evidence=build_evidence(a['graph'],a['graph'],result['issues'],binding={})
widget=VerificationInspector();qtbot.addWidget(widget)
widget.set_evidence(evidence)
assert widget.pin_table.rowCount()>=1
assert '未覆盖' in widget.coverage.text()
assert widget.diagram.pins==[p for p in evidence['pins'] if p['endpoint'][:2]==widget.diagram.pins[0]['endpoint'][:2]]
def test_same_result_refresh_keeps_the_chosen_issue(qtbot):
from dx_productivity.trial_task_center.ui.verification_inspector import VerificationInspector
from pathlib import Path
import sys,copy
sys.path.insert(0,str(Path(__file__).parents[1]/'v1_1'))
from test_independent_verification_rules import export,evaluate
a=export();b=copy.deepcopy(a)
b['graph']['components']['a']['pins']['outloop']=b['graph']['components']['a']['pins'].pop('loop')
b['graph']['nets'][0]['endpoints'][0][1]='outloop'
result=evaluate(a,b);result['evidence']=build_evidence(a['graph'],b['graph'],result['issues'],binding={})
record={'current_version':1,'input_version':1,'attempt_id':'attempt','display_name':'board','scope':'未核对换料规则',
'payload':{'payload_digest':'0'*64},'history':[{'input_version':1,'generation':1,'attempt_id':'attempt','state':'succeeded'}],
'attempt':{'result':result}}
widget=VerificationInspector();qtbot.addWidget(widget);widget.set_record(record)
widget.issues.setCurrentIndex(1);widget.set_record(record)
assert widget.issues.currentIndex()==1
@@ -0,0 +1,5 @@
def test_report_action_available_for_empty_task_without_cad(ui,qtbot):
task=ui.service.verification.create_task('报告',request_id='report')['task_id']
page=ui.window.verification_panel;page.open_task(task)
qtbot.waitUntil(lambda:not page.controller.task_query.busy)
assert page.export_button.isEnabled() and page.new_button.isEnabled()
+81
View File
@@ -0,0 +1,81 @@
from PySide6.QtCore import Qt
def test_fourth_navigation_is_independent_and_does_not_open_dsh(ui,qtbot):
window=ui.window
window.verification_action.trigger()
qtbot.waitUntil(lambda:window.content_stack.currentWidget() is window.verification_panel)
page=window.verification_panel
assert window.verification_action.isChecked() and not window.dsh_action.isChecked()
assert window._dsh_view is None and page.new_button.isEnabled()
task=ui.service.verification.create_task('独立校验',request_id='one')['task_id']
page.open_task(task)
qtbot.waitUntil(lambda:page.controller.task_id==task and not page.controller.task_query.busy)
assert page.new_button.isEnabled()
assert page.table.rowCount()==0
assert '来源' not in page.findChild(type(page.title),'verificationTitle').text()
def test_page_keeps_selected_task_when_refreshed(ui,qtbot):
page=ui.window.verification_panel
task=ui.service.verification.create_task('任务',request_id='one')['task_id']
page.open_task(task);page.set_active(True)
qtbot.waitUntil(lambda:page.tasks.count()==1)
page.refresh()
qtbot.waitUntil(lambda:not page.controller.tasks_query.busy)
assert page.controller.task_id==task
def test_periodic_refresh_does_not_starve_a_slow_read(ui,qtbot,monkeypatch):
from threading import Event
from pathlib import Path
import sys
sys.path.insert(0,str(Path(__file__).parents[1]/'v1_1'))
from test_independent_verification_contracts import payload
page=ui.window.verification_panel;v=page.service
task=v.create_task('慢查询',request_id='slow')['task_id'];row=payload();row['before_ref']=None
v.repo.publish(task,(row,),submission_id='row')
original=v.read_task
def slow(*args,**kwargs):Event().wait(.15);return original(*args,**kwargs)
monkeypatch.setattr(v,'read_task',slow)
page.open_task(task);page._timer.setInterval(20);page._timer.start()
try:qtbot.waitUntil(lambda:page.table.rowCount()==1,timeout=1500)
finally:page._timer.stop()
def test_engineering_pages_remain_bounded_and_keep_the_current_page(ui,qtbot):
from pathlib import Path
import sys
sys.path.insert(0,str(Path(__file__).parents[1]/'v1_1'))
from test_independent_verification_contracts import payload
page=ui.window.verification_panel;v=page.service
task=v.create_task('分页',request_id='pages')['task_id'];rows=[]
for n in range(201):
row=payload();row.update(item_key=str(n),display_name=f'Board{n:03}',before_ref=None);rows.append(row)
v.repo.publish(task,rows,submission_id='rows');page.open_task(task)
qtbot.waitUntil(lambda:page.table.rowCount()==100)
page.more_button.click()
qtbot.waitUntil(lambda:not page.controller.task_query.busy)
assert page.table.rowCount()==100 and page.table.item(0,0).text()=='Board100'
page.refresh_task();qtbot.waitUntil(lambda:not page.controller.task_query.busy)
assert page.table.item(0,0).text()=='Board100'
page.search.setText('Board000')
qtbot.waitUntil(lambda:page.table.rowCount()==1)
assert page.table.item(0,0).text()=='Board000'
def test_older_verification_task_can_be_opened_after_paging(ui,qtbot):
page=ui.window.verification_panel
tasks=[page.service.create_task(f'任务 {n}',request_id=f'page-{n}')['task_id'] for n in range(51)]
page.open_task(tasks[-1])
qtbot.waitUntil(lambda:page.tasks.count()==50 and not page.controller.tasks_query.busy)
page.next_tasks_button.click()
qtbot.waitUntil(lambda:page.tasks.count()==1)
assert page.tasks.item(0).data(Qt.ItemDataRole.UserRole)==tasks[0]
page.tasks.setCurrentRow(0)
qtbot.waitUntil(lambda:page.controller.task_id==tasks[0] and not page.controller.tasks_query.busy)
page.refresh()
qtbot.waitUntil(lambda:not page.controller.tasks_query.busy)
assert page.tasks.currentItem().data(Qt.ItemDataRole.UserRole)==tasks[0]
page.previous_tasks_button.click()
qtbot.waitUntil(lambda:page.tasks.count()==50)
@@ -0,0 +1,68 @@
import copy
import json
from pathlib import Path
from threading import Event
from test_independent_verification_intake import service
from test_independent_verification_runner import imported
from test_independent_verification_rules import export
from test_verification_control import wait_idle
def test_end_to_end_mixed_batch_is_nonblocking_and_exports_same_evidence(service,tmp_path,monkeypatch):
from dx_productivity.trial_task_center import netlist_verification
from dx_productivity.trial_task_center.history_store import HistoryRepository
from dx_productivity.trial_task_center.retention import maintain_quick_run_storage
task,item=imported(service,tmp_path)
original=service.repo.revision(item,1)['payload']
rows=[]
for key in ('rename','swap','missing'):
row={k:v for k,v in original.items() if k not in {'payload_digest','input_state'}};row['item_key']=key;row['display_name']=key
if key=='missing':row['before_ref']=None
rows.append(row)
service.publish_inputs(task,rows,submission_id='batch')
def native(capture,output,*,stop_event):
graph=export()
aid=output.parent.name;attempt=service.repo.attempt(aid);name=service.repo.item(attempt['item_id'])['display_name']
if output.name=='after':
if name=='swap':
graph['graph']['components']['a']['pins']['loop']['number']='2';graph['graph']['components']['a']['pins']['GND']['number']='1'
if name=='rename':
graph['graph']['components']['a']['pins']['outloop']=graph['graph']['components']['a']['pins'].pop('loop')
graph['graph']['nets'][0]['endpoints'][0][1]='outloop'
return graph
monkeypatch.setattr(netlist_verification,'_export_saved_capture',native)
run=service.start(task,request_id='all');wait_idle(service)
summary=service.read_task(task)['summary']
assert [summary[k] for k in ('consistent','warning','different','unavailable')]==[1,1,1,1]
report=service.export_task(task,tmp_path/'reports',request_id='report')
saved=json.loads((report/'task.json').read_text(encoding='utf-8'))
swapped=next(r for r in saved['items'] if r['display_name']=='swap')
assert swapped['attempt']['result']['verdict']=='DIFFERENT'
assert any(p['connection_changed'] for p in swapped['attempt']['result']['evidence']['pins'])
history=HistoryRepository(service.repo.store);assert history.page(query='工程校验').total==3
snapshot=history.clear_snapshot();history.clear(snapshot.cutoff_id)
maintain_quick_run_storage(service.data_root,max_age_days=0,min_entries=0)
assert service.read_item(item)['status']=='consistent'
assert service.repo.store._connection.execute('SELECT COUNT(*) FROM execution_operations').fetchone()[0]==0
def test_required_pin_text_does_not_claim_unread_pin_value_is_equal():
from dx_productivity.trial_task_center.verification.rules import evaluate
from dx_productivity.trial_task_center.verification.contracts import default_plan
plan=default_plan();plan['optional_checks'].remove('pin_text');plan['required_checks'].append('pin_text')
assert evaluate(export(),export(),expectations=None,check_plan=plan)['verdict']=='INCOMPLETE'
def test_acceptance_cli_labels_controlled_format_evidence(tmp_path):
import subprocess,sys
from test_native_cli_netlist import project_fixture,graph
fixture=tmp_path/'fixture'
for phase in ('before','after'):
folder=fixture/phase;folder.mkdir(parents=True)
project_fixture(folder);graph(folder)
script=Path(__file__).parents[2]/'tools/verify_independent_verification.py'
result=subprocess.run([sys.executable,str(script),'--fixture-root',str(fixture),'--output',str(tmp_path/'acceptance')],capture_output=True,text=True,timeout=20)
assert result.returncode==0,result.stderr
summary=json.loads((tmp_path/'acceptance/acceptance.json').read_text(encoding='utf-8'))
assert summary['evidence_kind']=='controlled-format-fixture' and summary['inputs_unchanged']
assert summary['replacement_operations']==0
@@ -0,0 +1,79 @@
import copy
import pytest
from dx_productivity.trial_task_center.errors import TaskCenterError
def payload():
return {'item_key': 'board', 'project_key': 'board', 'input_version': 1,
'before_ref': {'manifest_id': 'a' * 32, 'sha256': '1' * 64},
'after_ref': {'manifest_id': 'b' * 32, 'sha256': '2' * 64},
'expectation_ref': None,
'check_plan': {'policy_version': 'verification-v1', 'required_checks': ['connections'],
'optional_checks': ['pin_text'], 'excluded_checks': ['footprint_mapping']}}
@pytest.mark.parametrize('state,want', [('equal','CONSISTENT'), ('warning','WARNING'),
('error','DIFFERENT'), ('unknown','INCOMPLETE'),
('not_requested','INCOMPLETE')])
def test_required_checks_determine_verdict_without_hiding_missing_checks(state, want):
from dx_productivity.trial_task_center.verification.contracts import rollup_results
result = rollup_results(({'check_id': 'connections', 'state': state, 'issues': []},),
required_checks=('connections',))
assert result['verdict'] == want
def test_error_wins_but_unknown_coverage_remains_visible():
from dx_productivity.trial_task_center.verification.contracts import rollup_results
result = rollup_results(({'check_id':'connections','state':'error','issues':[]},),
required_checks=('connections','physical_pins'))
assert result['verdict'] == 'DIFFERENT'
assert result['coverage'] == 'partial'
assert result['unknown_checks'] == ['physical_pins']
def test_empty_or_duplicate_checks_cannot_be_consistency():
from dx_productivity.trial_task_center.verification.contracts import rollup_results
assert rollup_results((), required_checks=('connections',))['verdict'] == 'INCOMPLETE'
with pytest.raises(TaskCenterError):
rollup_results((), required_checks=())
row = {'check_id':'connections','state':'equal','issues':[]}
with pytest.raises(TaskCenterError):
rollup_results((row,row), required_checks=('connections',))
def test_optional_unknown_is_explicit_without_erasing_core_result():
from dx_productivity.trial_task_center.verification.contracts import rollup_results
result = rollup_results(({'check_id':'connections','state':'equal','issues':[]},),
required_checks=('connections',), optional_checks=('pin_text',))
assert result['verdict'] == 'CONSISTENT'
assert result['coverage'] == 'partial'
assert result['unknown_checks'] == ['pin_text']
def test_input_is_detached_and_cannot_contain_source_or_arbitrary_paths():
from dx_productivity.trial_task_center.verification.contracts import validate_input
value = payload()
result = validate_input(value)
value['check_plan']['required_checks'].clear()
assert result['check_plan']['required_checks'] == ['connections']
for name in ('source','output_path'):
bad = payload(); bad[name] = 'anything'
with pytest.raises(TaskCenterError): validate_input(bad)
@pytest.mark.parametrize('field,value', [('input_version', True), ('input_version',0),
('before_ref', {'manifest_id':'../outside','sha256':'1'*64}),
('after_ref', {'manifest_id':'b'*32,'sha256':'invalid'})])
def test_invalid_input_never_enters_storage(field,value):
from dx_productivity.trial_task_center.verification.contracts import validate_input
bad = payload(); bad[field] = value
with pytest.raises(TaskCenterError): validate_input(bad)
def test_missing_capture_stays_recordable_as_unavailable():
from dx_productivity.trial_task_center.verification.contracts import validate_input
value = payload(); value['before_ref'] = None
result = validate_input(value)
assert result['input_state'] == 'unavailable'
assert result['unavailable_reason']
@@ -0,0 +1,188 @@
from pathlib import Path
from threading import Event
import json
import pytest
from dx_productivity.trial_task_center.store import TaskStore
from dx_productivity.trial_task_center.errors import TaskCenterError
from test_native_cli_netlist import project_fixture
@pytest.fixture
def service(tmp_path):
from dx_productivity.trial_task_center.verification.service import VerificationService
store = TaskStore(tmp_path/'tasks.db')
verification=VerificationService(store,tmp_path/'data')
try: yield verification
finally:
verification.begin_shutdown()
thread=verification.control.thread
if thread is not None:thread.join(10)
assert not verification.busy,'Verification must finish before its store is closed'
store.close()
def test_pair_import_creates_same_input_contract_without_replacement(service,tmp_path):
a = tmp_path/'a'; b = tmp_path/'b'; a.mkdir(); b.mkdir()
before,after = project_fixture(a),project_fixture(b)
task = service.create_task('独立任务',request_id='create')['task_id']
result = service.import_pair(task,before,after,request_id='import',stop_event=Event())
item = result['accepted'][0]['item_id']
row = service.repo.revision(item,1)['payload']
assert row['input_state']=='ready' and row['expectation_ref'] is None
assert service.import_pair(task,before,after,request_id='import',stop_event=Event())==result
assert service.repo.latest_attempt(item,1) is None
before_capture = service.artifacts.read(row['before_ref'],'snapshot')
assert Path(before_capture['database_path']).read_bytes()==b'saved-database'
Path(before_capture['database_path']).write_bytes(b'tampered')
with pytest.raises(TaskCenterError): service.artifacts.read(row['before_ref'],'snapshot')
def test_same_source_and_cancel_do_not_publish_items(service,tmp_path):
project = project_fixture(tmp_path)
task = service.create_task('任务',request_id='c')['task_id']
with pytest.raises(TaskCenterError): service.import_pair(task,project,project,request_id='i',stop_event=Event())
stopped=Event(); stopped.set()
with pytest.raises(TaskCenterError): service.import_pair(task,project,project,request_id='j',stop_event=stopped)
assert service.repo.connection.execute('SELECT COUNT(*) FROM verification_items').fetchone()[0]==0
def test_missing_handoff_evidence_remains_visible_and_duplicate_delivery_does_not_repeat(service):
report={'task_id':'execution-task','project_path':'F:/board.prj',
'execution':{'state':'completed','saved_items':1},'status':'unavailable','reason':'capture failed'}
result=service.receive_successful_results({'run_id':'run','netlist_verification':{'execution-task':report}},submission_id='handoff')
item=result['accepted'][0]['item_id']
assert service.repo.revision(item,1)['payload']['input_state']=='unavailable'
assert service.receive_successful_results({'run_id':'run','netlist_verification':{'execution-task':report}},submission_id='handoff')==result
assert service.repo.connection.execute('SELECT COUNT(*) FROM verification_items').fetchone()[0]==1
def test_unsaved_handoff_is_not_accepted_as_success(service):
report={'task_id':'e','project_path':'F:/board.prj','execution':{'state':'failed','saved_items':0}}
result=service.receive_successful_results({'run_id':'r','netlist_verification':{'e':report}},submission_id='bad')
assert not result['accepted']
def test_artifact_reference_cannot_escape_managed_directory(service):
with pytest.raises(TaskCenterError):
service.artifacts.read({'manifest_id':'../../secret','sha256':'1'*64},'snapshot')
def test_malformed_row_does_not_block_good_rows(service):
task=service.create_task('任务',request_id='c')['task_id']
result=service.publish_inputs(task,(None,{}),submission_id='mixed')
assert len(result['rejected'])==2
def test_complete_delivery_can_be_reconciled_under_another_notification(service,tmp_path):
from dx_productivity.trial_task_center.native_netlist import capture_project, _hash
reports={}
for phase in ('before','after'):
folder=tmp_path/phase; folder.mkdir()
capture=capture_project(project_fixture(folder),service.data_root/phase/'capture')
path=service.data_root/phase/'export.json'
path.write_text(json.dumps({'capture':capture}),encoding='utf-8')
reports[phase]={'export_path':str(path),'export_sha256':_hash(path)}
reports.update(project_path='board.prj',execution={'state':'completed','saved_items':1},expected_changes={})
receipt={'run_id':'r','queue_id':'q','netlist_verification':{'e':reports}}
first=service.receive_successful_results(receipt,submission_id='receipt')
checkpoint=dict(receipt); checkpoint['run_id']='q'
second=service.receive_successful_results(checkpoint,submission_id='checkpoint')
assert len(first['accepted'])==1
assert len(second['duplicates'])==1 and not second['rejected']
assert second['task_id']==first['task_id']
def test_import_evidence_validation_does_not_hold_store_lock(service,tmp_path,monkeypatch):
from threading import Thread
a=tmp_path/'a';b=tmp_path/'b';a.mkdir();b.mkdir()
before,after=project_fixture(a),project_fixture(b)
task=service.create_task('导入',request_id='c')['task_id']
read=service.artifacts.read;entered=Event();release=Event();created=Event();errors=[]
def slow(*args):entered.set();release.wait(5);return read(*args)
monkeypatch.setattr(service.artifacts,'read',slow)
def import_pair():
try:service.import_pair(task,before,after,request_id='i',stop_event=Event())
except Exception as error:errors.append(error)
worker=Thread(target=import_pair);worker.start();assert entered.wait(3)
creator=Thread(target=lambda:(service.create_task('另一个',request_id='other'),created.set()));creator.start()
try:assert created.wait(.5)
finally:release.set();worker.join(5);creator.join(5)
assert not errors
@pytest.mark.parametrize('failure',['cancel','invalid_name','second_capture'])
def test_unsuccessful_import_does_not_leave_unreferenced_captures(service,tmp_path,monkeypatch,failure):
folders=[tmp_path/phase for phase in ('before','after')]
for folder in folders:
folder.mkdir()
before,after=map(project_fixture,folders)
task=service.create_task('导入',request_id='task')['task_id']
stop=Event()
from dx_productivity.trial_task_center import native_netlist
capture=native_netlist.capture_project
def interrupt(project,destination):
result=capture(project,destination)
if failure=='cancel':
stop.set()
if failure=='second_capture' and project==after:
raise OSError('after capture failed before publication')
return result
monkeypatch.setattr(native_netlist,'capture_project',interrupt)
if failure=='invalid_name':
result=service.import_pair(task,before,after,request_id='pair',stop_event=stop,display_name='x'*257)
assert result['rejected'] and not result['accepted']
else:
with pytest.raises(TaskCenterError if failure=='cancel' else OSError):
service.import_pair(task,before,after,request_id='pair',stop_event=stop)
assert service.read_task(task)['items']==[]
assert not list(service.artifacts.root.glob('*'))
@pytest.mark.parametrize('initial',['ready','missing_evidence','fallback'])
def test_handoff_updates_same_project_and_never_replays_an_old_notification(service,tmp_path,initial):
from dx_productivity.trial_task_center.native_netlist import capture_project, _hash
evidence={}
for phase in ('before','after','retry'):
source=tmp_path/phase
source.mkdir()
project=project_fixture(source)
if phase=='retry':
(project.parent/'database/icdb.dat').write_bytes(b'after retry')
capture=capture_project(project,service.data_root/phase/'capture')
path=service.data_root/phase/'export.json'
path.write_text(json.dumps({'capture':capture}),encoding='utf-8')
evidence[phase]={'export_path':str(path),'export_sha256':_hash(path)}
report={'project_path':'board.prj','execution':{'state':'completed','saved_items':1}}
if initial=='ready':
report.update(before=evidence['before'],after=evidence['after'],expected_changes={})
first_receipt={'run_id':'run','netlist_verification':{'board':report}}
if initial=='fallback':
first_receipt={'run_id':'run','tasks':[{'task_id':'board','name':'Board task',
'state':'completed','saved_items':1}]}
first=service.receive_successful_results(first_receipt,submission_id='initial')
item=first['accepted'][0]['item_id']
retry_report=dict(report,before=evidence['before'],after=evidence['retry'],
expected_changes={'u1':{'Value':'NEW'}},execution={'state':'completed','saved_items':2})
retry_receipt=dict(first_receipt,netlist_verification={'board':retry_report})
if initial=='ready':
with service.repo.store.transaction():
service.repo._remember('handoff','retry',retry_receipt,
{'accepted':[],'rejected':[{'code':'verification_conflict'}]})
second=service.receive_successful_results(retry_receipt,submission_id='retry')
assert second['accepted']==[{'item_id':item,'input_version':2}]
original=service.read_item(item,version=1)['payload']
current=service.read_item(item)['payload']
if initial=='ready':
assert current['before_ref']==original['before_ref']
assert current['after_ref']!=original['after_ref']
assert current['input_state']=='ready'
assert service.receive_successful_results(retry_receipt,submission_id='checkpoint')['duplicates']==second['accepted']
service.receive_successful_results(first_receipt,submission_id='late-checkpoint')
assert service.read_item(item)['versions']==[2,1]
updated_report=dict(retry_report,expected_changes={'u1':{'Value':'NEWER'}})
updated_receipt=dict(first_receipt,netlist_verification={'board':updated_report})
third=service.receive_successful_results(updated_receipt,submission_id='latest')
assert third['accepted']==[{'item_id':item,'input_version':3}]
assert service.read_item(item)['payload']['before_ref']==current['before_ref']
@@ -0,0 +1,70 @@
from test_independent_verification_store import repo
from test_independent_verification_contracts import payload
def test_current_counts_and_attempt_replacement(repo):
from dx_productivity.trial_task_center.verification.queries import VerificationQueries
task=repo.create_task('相同名称',request_id='c')['task_id']
for n in range(24):
row=payload(); row['item_key']=str(n)
if n==19: row['before_ref']=None
item=repo.publish(task,(row,),submission_id=str(n))['accepted'][0]['item_id']
if n<19:
a=repo.create_attempt(item,1,request_id='a'+str(n)); repo.claim(a['attempt_id'],owner_id='o')
verdict='CONSISTENT' if n<16 else 'WARNING' if n<18 else 'DIFFERENT'
repo.finish(a['attempt_id'],generation=1,result={'resource_state':'released','verdict':verdict})
queries=VerificationQueries(repo)
page=queries.read_task(task,limit=10)
assert page['summary']==dict(total=24,processed=20,consistent=16,warning=2,different=1,unavailable=1,waiting=4,running=0,stopped=0,interrupted=0)
assert len(page['items'])==10 and page['cursor']
assert len(queries.read_task(task,cursor=page['cursor'],limit=10)['items'])==10
first=page['items'][0]
repo.create_attempt(first['item_id'],1,request_id='again')
assert queries.read_task(task)['summary']['consistent']==15
def test_new_version_has_no_old_green_and_filters_are_literal(repo):
from dx_productivity.trial_task_center.verification.queries import VerificationQueries
from dx_productivity.trial_task_center.errors import TaskCenterError
import pytest
task=repo.create_task('任务',request_id='c')['task_id']
row=payload(); row['display_name']='100%_board'
item=repo.publish(task,(row,),submission_id='s')['accepted'][0]['item_id']
a=repo.create_attempt(item,1,request_id='a'); repo.claim(a['attempt_id'],owner_id='o')
repo.finish(a['attempt_id'],generation=1,result={'resource_state':'released','verdict':'CONSISTENT'})
row['input_version']=2; repo.publish(task,(row,),submission_id='new')
q=VerificationQueries(repo)
assert q.read_item(item)['status']=='waiting'
assert q.read_item(item,version=1)['status']=='consistent'
assert len(q.read_task(task,query='%_')['items'])==1
assert not q.read_task(task,query='missing')['items']
with pytest.raises(TaskCenterError):q.read_task(task,cursor={'offset':1,'binding':'bad'})
def test_slow_evidence_read_does_not_lock_task_creation(repo):
from threading import Event,Thread
from dx_productivity.trial_task_center.verification.queries import VerificationQueries
task=repo.create_task('读取',request_id='c')['task_id']
item=repo.publish(task,(payload(),),submission_id='s')['accepted'][0]['item_id']
a=repo.create_attempt(item,1,request_id='a');repo.claim(a['attempt_id'],owner_id='o')
repo.finish(a['attempt_id'],generation=1,result={'resource_state':'released','verdict':'CONSISTENT'})
entered=Event();release=Event();created=Event();q=VerificationQueries(repo)
def validate(_):entered.set();release.wait(3)
q.validator=validate
read=Thread(target=lambda:q.read_task(task));read.start();assert entered.wait(2)
writer=Thread(target=lambda:(repo.create_task('新任务',request_id='new'),created.set()));writer.start()
try:assert created.wait(.5)
finally:release.set();read.join(3);writer.join(3)
def test_previous_attempt_is_readable_without_replacing_current_result(repo):
from dx_productivity.trial_task_center.verification.queries import VerificationQueries
task=repo.create_task('历史',request_id='c')['task_id']
item=repo.publish(task,(payload(),),submission_id='s')['accepted'][0]['item_id']
attempts=[]
for n,verdict in enumerate(('DIFFERENT','CONSISTENT')):
a=repo.create_attempt(item,1,request_id=str(n));repo.claim(a['attempt_id'],owner_id='o')
repo.finish(a['attempt_id'],generation=a['generation'],result={'resource_state':'released','verdict':verdict});attempts.append(a)
q=VerificationQueries(repo)
assert q.read_item(item,attempt_id=attempts[0]['attempt_id'])['verdict']=='DIFFERENT'
assert q.read_item(item)['verdict']=='CONSISTENT'
@@ -0,0 +1,107 @@
import copy
import pytest
from dx_productivity.trial_task_center.verification.contracts import default_plan
def export():
components={}
for uid,ref,pins in [('a','R12',{'loop':('1',['LOOP']),'GND':('2',['GND'])}),
('b','U1',{'out':('3',['LOOP'])}),('c','C5',{'gnd':('2',['GND'])})]:
components[uid]={'refdes':ref,'attributes':{'Ref Designator':ref,'Part Number':'OLD','Value':'10K'},
'pins':{k:{'number':num,'nets':nets} for k,(num,nets) in pins.items()}}
return {'status':'success','complete':True,'graph':{'components':components,'nets':[
{'name':'LOOP','endpoints':[['a','loop'],['b','out']]},{'name':'GND','endpoints':[['a','GND'],['c','gnd']]}]}}
def evaluate(left,right,**kwargs):
from dx_productivity.trial_task_center.verification.rules import evaluate
return evaluate(left,right,expectations=kwargs.pop('expectations',None),check_plan=kwargs.pop('check_plan',default_plan()),**kwargs)
def test_equal_graph_and_uid_change_preserve_refdes_identity():
a=export();b=copy.deepcopy(a)
b['graph']['components']['new']=b['graph']['components'].pop('a')
for net in b['graph']['nets']:
for endpoint in net['endpoints']:
if endpoint[0]=='a':endpoint[0]='new'
assert evaluate(a,b)['verdict']=='CONSISTENT'
def test_swap_physical_pin_connections_is_hard_error():
a=export();b=copy.deepcopy(a)
b['graph']['components']['a']['pins']['loop']['number']='2'
b['graph']['components']['a']['pins']['GND']['number']='1'
result=evaluate(a,b)
assert result['verdict']=='DIFFERENT'
assert any(i['check_id']=='connections' and i.get('pin_number')=='1' for i in result['issues'])
def test_pin_rename_is_warning_without_connection_error():
a=export();b=copy.deepcopy(a)
b['graph']['components']['a']['pins']['outloop']=b['graph']['components']['a']['pins'].pop('loop')
b['graph']['nets'][0]['endpoints'][0][1]='outloop'
result=evaluate(a,b)
assert result['verdict']=='WARNING'
assert any(i['check_id']=='pin_text' for i in result['issues'])
assert not any(i['check_id']=='connections' for i in result['issues'])
@pytest.mark.parametrize('change',['disconnect','short','refdes','number','netname'])
def test_structural_changes_are_errors(change):
a=export();b=copy.deepcopy(a)
if change=='disconnect':
b['graph']['nets'][0]['endpoints'].pop(0);b['graph']['components']['a']['pins']['loop']['nets']=[]
if change=='short':
b['graph']['nets'][0]['endpoints']+=b['graph']['nets'][1]['endpoints'];b['graph']['nets'].pop()
for component in b['graph']['components'].values():
for pin in component['pins'].values():pin['nets']=['LOOP']
if change=='refdes':b['graph']['components']['a']['refdes']='R13';b['graph']['components']['a']['attributes']['Ref Designator']='R13'
if change=='number':b['graph']['components']['a']['pins']['loop']['number']='9'
if change=='netname':
b['graph']['nets'][0]['name']='RENAMED'
for uid,pin in [('a','loop'),('b','out')]:b['graph']['components'][uid]['pins'][pin]['nets']=['RENAMED']
assert evaluate(a,b)['verdict']=='DIFFERENT'
def test_declared_values_exact_and_undeclared_changes_warn():
a=export();b=copy.deepcopy(a);b['graph']['components']['a']['attributes']['Value']='NEW'
assert evaluate(a,b)['verdict']=='WARNING'
assert evaluate(a,b,expectations={'changes':{'a':{'Value':'NEW'}}})['verdict']=='CONSISTENT'
assert evaluate(a,b,expectations={'changes':{'a':{'Value':'WRONG'}}})['verdict']=='DIFFERENT'
assert evaluate(a,b,expectations={'changes':{}})['verdict']=='DIFFERENT'
def test_missing_required_mapping_never_passes_and_duplicate_ref_is_unknown():
a=export();plan=default_plan();plan['excluded_checks']=[];plan['required_checks'].append('footprint_mapping')
assert evaluate(a,a,check_plan=plan)['verdict']=='INCOMPLETE'
b=copy.deepcopy(a);b['graph']['components']['c']['refdes']='R12'
assert evaluate(a,b)['verdict']=='INCOMPLETE'
def test_empty_native_networks_cannot_prove_coverage():
value=export()
value['graph']['nets']=[]
for component in value['graph']['components'].values():
for pin in component['pins'].values():
pin['nets']=[]
assert evaluate(value,value)['verdict']=='INCOMPLETE'
def test_missing_pin_number_cannot_prove_equal_and_error_beats_unknown():
a=export();b=copy.deepcopy(a);b['graph']['components']['a']['pins']['loop']['number']=''
assert evaluate(a,b)['verdict']=='INCOMPLETE'
b['graph']['components']['b']['attributes']['Value']='WRONG'
result=evaluate(a,b,expectations={'changes':{}})
assert result['verdict']=='DIFFERENT' and result['unknown_checks']
def test_duplicate_physical_number_introduced_is_hard_error():
a=export();b=copy.deepcopy(a);b['graph']['components']['a']['pins']['loop']['number']='2'
result=evaluate(a,b)
assert result['verdict']=='DIFFERENT'
assert any(i['check_id']=='physical_pins' and i['state']=='error' for i in result['issues'])
def test_required_semantics_without_proven_type_is_incomplete():
plan=default_plan();plan['optional_checks'].remove('pin_semantics');plan['required_checks'].append('pin_semantics')
assert evaluate(export(),export(),check_plan=plan)['verdict']=='INCOMPLETE'
@@ -0,0 +1,46 @@
from threading import Event
from test_independent_verification_intake import service
from test_native_cli_netlist import project_fixture, graph
def imported(service,tmp_path):
a=tmp_path/'a';b=tmp_path/'b';a.mkdir();b.mkdir()
task=service.create_task('独立',request_id='c')['task_id']
item=service.import_pair(task,project_fixture(a),project_fixture(b),request_id='i',stop_event=Event())['accepted'][0]['item_id']
return task,item
def test_runner_uses_frozen_captures_and_publishes_attempt(service,tmp_path,monkeypatch):
from dx_productivity.trial_task_center.verification.runner import run_attempt
from dx_productivity.trial_task_center import netlist_verification
task,item=imported(service,tmp_path)
before=service.repo.revision(item,1)['payload']
captured=service.artifacts.read(before['before_ref'],'snapshot')
original=open(captured['database_path'],'rb').read()
calls=[]
def export(capture,directory,*,stop_event):
calls.append(capture['root'])
directory.mkdir(parents=True,exist_ok=True)
return {'status':'success','complete':True,'graph':graph(directory),'outputs':{}}
monkeypatch.setattr(netlist_verification,'_export_saved_capture',export)
attempt=service.repo.create_attempt(item,1,request_id='a')
result=run_attempt(service,attempt['attempt_id'],stop_event=Event())
assert result['published'] and len(calls)==2
assert service.repo.attempt(attempt['attempt_id'])['state']=='succeeded'
assert open(captured['database_path'],'rb').read()==original
assert service.repo.store._connection.execute('SELECT COUNT(*) FROM execution_operations').fetchone()[0]==0
assert not run_attempt(service,attempt['attempt_id'],stop_event=Event())['published']
def test_corrupt_input_does_not_export_and_failure_is_not_green(service,tmp_path,monkeypatch):
from dx_productivity.trial_task_center.verification.runner import run_attempt
from dx_productivity.trial_task_center import netlist_verification
_,item=imported(service,tmp_path)
capture=service.artifacts.read(service.repo.revision(item,1)['payload']['before_ref'],'snapshot')
open(capture['database_path'],'wb').write(b'corrupt')
def forbidden(*a,**k):raise AssertionError('must not export corrupt capture')
monkeypatch.setattr(netlist_verification,'_export_saved_capture',forbidden)
attempt=service.repo.create_attempt(item,1,request_id='a')
run_attempt(service,attempt['attempt_id'],stop_event=Event())
assert service.repo.attempt(attempt['attempt_id'])['state']=='failed'
assert service.read_item(item)['status']=='unavailable'
@@ -0,0 +1,111 @@
import pytest
from dx_productivity.trial_task_center.store import TaskStore
from dx_productivity.trial_task_center.errors import TaskCenterError
from test_independent_verification_contracts import payload
@pytest.fixture
def repo(tmp_path):
from dx_productivity.trial_task_center.verification.store import VerificationRepository
store = TaskStore(tmp_path/'tasks.db')
try: yield VerificationRepository(store)
finally: store.close()
def test_tasks_are_independent_and_create_is_idempotent(repo):
task = repo.create_task('校验', request_id='one')
assert repo.create_task('校验',request_id='one') == task
assert repo.create_task('校验',request_id='two')['task_id'] != task['task_id']
with pytest.raises(TaskCenterError): repo.create_task('changed',request_id='one')
assert repo.store.list_tasks() == ()
def test_versions_are_immutable_and_delivery_is_idempotent(repo):
task = repo.create_task('校验',request_id='a')['task_id']
first = repo.publish(task,(payload(),),submission_id='s1')
item = first['accepted'][0]['item_id']
assert repo.publish(task,(payload(),),submission_id='s1') == first
assert len(repo.publish(task,(payload(),),submission_id='s2')['duplicates']) == 1
newer = payload(); newer['input_version'] = 3; newer['after_ref']['sha256'] = '3'*64
repo.publish(task,(newer,),submission_id='s3')
older = payload(); older['input_version'] = 2
assert repo.publish(task,(older,),submission_id='s4')['stale_ignored']
assert repo.item(item)['current_version'] == 3
bad = payload(); bad['after_ref']['sha256'] = '5'*64
assert repo.publish(task,(bad,),submission_id='s5')['rejected']
assert repo.revision(item,1)['payload']['after_ref']['sha256'] == '2'*64
def test_bad_item_does_not_erase_other_input_and_bad_task_does_not_publish(repo):
task = repo.create_task('校验',request_id='a')['task_id']
bad = payload(); bad['input_version'] = -1
result = repo.publish(task,(bad,payload()),submission_id='mixed')
assert len(result['accepted']) == len(result['rejected']) == 1
with pytest.raises(TaskCenterError): repo.publish('missing',(payload(),),submission_id='x')
def test_single_active_attempt_and_late_result_cannot_override_new_attempt(repo):
task = repo.create_task('校验',request_id='a')['task_id']
item = repo.publish(task,(payload(),),submission_id='s')['accepted'][0]['item_id']
first = repo.create_attempt(item,1,request_id='run-1')
assert repo.create_attempt(item,1,request_id='run-2')['attempt_id'] == first['attempt_id']
claimed = repo.claim(first['attempt_id'],owner_id='owner')
assert repo.claim(first['attempt_id'],owner_id='other') is None
assert not repo.finish(first['attempt_id'],generation=99,result={'resource_state':'released'})
assert repo.finish(first['attempt_id'],generation=claimed['generation'],
result={'resource_state':'released','verdict':'DIFFERENT'})
second = repo.create_attempt(item,1,request_id='run-3')
assert second['generation'] > first['generation']
assert not repo.finish(first['attempt_id'],generation=first['generation'],result={'resource_state':'released'})
assert repo.attempt(second['attempt_id'])['state'] == 'queued'
def test_old_input_attempt_completion_does_not_move_current_revision(repo):
task = repo.create_task('校验',request_id='a')['task_id']
item = repo.publish(task,(payload(),),submission_id='s')['accepted'][0]['item_id']
attempt = repo.create_attempt(item,1,request_id='run'); repo.claim(attempt['attempt_id'],owner_id='owner')
newer = payload(); newer['input_version'] = 2
repo.publish(task,(newer,),submission_id='s2')
assert repo.finish(attempt['attempt_id'],generation=attempt['generation'],result={'resource_state':'released','verdict':'CONSISTENT'})
assert repo.item(item)['current_version'] == 2
assert repo.latest_attempt(item,2) is None
def test_schema_survives_reopen_and_does_not_change_execution_tables(tmp_path):
from dx_productivity.trial_task_center.verification.store import VerificationRepository
path = tmp_path/'tasks.db'
store = TaskStore(path); repo = VerificationRepository(store)
task = repo.create_task('持久任务',request_id='p')
store.close(); store = TaskStore(path)
try:
assert VerificationRepository(store).task(task['task_id'])['name'] == '持久任务'
assert store._connection.execute('SELECT COUNT(*) FROM execution_operations').fetchone()[0] == 0
finally: store.close()
def test_commit_acknowledgement_loss_can_be_retried_without_duplicates(repo,monkeypatch):
from contextlib import contextmanager
original=repo.store.transaction
fired=False
@contextmanager
def lost_reply():
nonlocal fired
with original():yield
if not fired:
fired=True;raise OSError('lost response after commit')
with monkeypatch.context() as patch:
patch.setattr(repo.store,'transaction',lost_reply)
with pytest.raises(OSError):repo.create_task('持久结果',request_id='lost')
result=repo.create_task('持久结果',request_id='lost')
assert repo.task(result['task_id'])['name']=='持久结果'
assert repo.connection.execute('SELECT COUNT(*) FROM verification_tasks').fetchone()[0]==1
def test_two_threads_cannot_claim_same_attempt(repo):
from concurrent.futures import ThreadPoolExecutor
task=repo.create_task('任务',request_id='c')['task_id']
item=repo.publish(task,(payload(),),submission_id='s')['accepted'][0]['item_id']
attempt=repo.create_attempt(item,1,request_id='a')
with ThreadPoolExecutor(2) as pool:
results=list(pool.map(lambda owner:repo.claim(attempt['attempt_id'],owner_id=owner),('one','two')))
assert sum(row is not None for row in results)==1
@@ -0,0 +1,105 @@
from threading import Event
import pytest
from test_independent_verification_intake import service
from test_native_cli_netlist import project_fixture
def project(root, relative):
folder = root / relative
folder.mkdir(parents=True)
return project_fixture(folder)
def test_preview_matches_relative_paths_and_lists_missing_sides(service, tmp_path):
before, after = tmp_path/'before', tmp_path/'after'
for root in (before, after):
project(root, 'A')
project(root, 'B')
project(before, 'removed')
project(after, 'added')
preview = service.preview_pairs(before, after, stop_event=Event())
rows = {r['relative_path']: r for r in preview}
assert {key: row['status'] for key, row in rows.items()} == {
'A/source/board.prj': 'ready', 'B/source/board.prj': 'ready',
'added/source/board.prj': 'missing_before', 'removed/source/board.prj': 'missing_after'}
assert rows['A/source/board.prj']['before'] == str(before/'A/source/board.prj')
assert rows['A/source/board.prj']['after'] == str(after/'A/source/board.prj')
assert rows['B/source/board.prj']['after'] == str(after/'B/source/board.prj')
assert service.repo.connection.execute('SELECT COUNT(*) FROM verification_items').fetchone()[0] == 0
@pytest.mark.parametrize('nested', [False, True])
def test_preview_rejects_shared_or_nested_roots(service, tmp_path, nested):
before = tmp_path/'before'
before.mkdir()
after = before/'after' if nested else before
after.mkdir(exist_ok=True)
from dx_productivity.trial_task_center.errors import TaskCenterError
with pytest.raises(TaskCenterError):
service.preview_pairs(before, after, stop_event=Event())
def test_batch_continues_after_bad_pair_and_repeated_submission_is_idempotent(service, tmp_path):
before, after = tmp_path/'before', tmp_path/'after'
left, right = project(before, 'A'), project(after, 'A')
other_left, other_right = project(before, 'B'), project(after, 'B')
task = service.create_task('批量', request_id='create')['task_id']
pairs = ((left, right), (left, left), (other_left, other_right))
result = service.import_pairs(task, pairs, request_id='batch', stop_event=Event())
assert [r['status'] for r in result['rows']] == ['imported', 'failed', 'imported']
assert result['processed'] == 3 and not result['cancelled']
assert service.import_pairs(task, pairs, request_id='batch', stop_event=Event()) == result
assert service.repo.connection.execute('SELECT COUNT(*) FROM verification_items').fetchone()[0] == 2
assert service.repo.connection.execute('SELECT COUNT(*) FROM verification_attempts').fetchone()[0] == 0
def test_cancel_keeps_imported_items_and_same_request_can_resume_without_duplicates(service, tmp_path):
pairs = tuple((project(tmp_path/'before', str(n)), project(tmp_path/'after', str(n))) for n in range(3))
task = service.create_task('取消', request_id='create')['task_id']
stop = Event()
def progress(row, processed, total):
assert total == 3
stop.set()
partial = service.import_pairs(task, pairs, request_id='batch', stop_event=stop, on_progress=progress)
assert partial['processed'] == 1 and partial['cancelled']
assert service.repo.connection.execute('SELECT COUNT(*) FROM verification_items').fetchone()[0] == 1
complete = service.import_pairs(task, pairs, request_id='batch', stop_event=Event())
assert complete['processed'] == 3 and not complete['cancelled']
assert service.repo.connection.execute('SELECT COUNT(*) FROM verification_items').fetchone()[0] == 3
def test_batch_does_not_continue_writes_after_storage_exhaustion(service, tmp_path, monkeypatch):
import errno
pairs = tuple((project(tmp_path/'before', str(n)), project(tmp_path/'after', str(n))) for n in range(2))
task = service.create_task('磁盘', request_id='create')['task_id']
capture = service.artifacts.capture
def disk_full(path, **kwargs):
if str(path) == str(pairs[0][0]):
raise OSError(errno.ENOSPC, 'disk full', str(service.data_root/'verification'))
return capture(path, **kwargs)
monkeypatch.setattr(service.artifacts, 'capture', disk_full)
with pytest.raises(OSError):
service.import_pairs(task, pairs, request_id='batch', stop_event=Event())
assert service.repo.connection.execute('SELECT COUNT(*) FROM verification_items').fetchone()[0] == 0
def test_cancelled_request_cannot_be_reused_for_different_input(service, tmp_path):
pairs = ((project(tmp_path/'before', 'A'), project(tmp_path/'after', 'A')),)
task = service.create_task('请求绑定', request_id='create')['task_id']
stop = Event(); stop.set()
service.import_pairs(task, pairs, request_id='batch', stop_event=stop)
from dx_productivity.trial_task_center.errors import TaskCenterError
with pytest.raises(TaskCenterError) as error:
service.import_pairs(task, (), request_id='batch', stop_event=Event())
assert error.value.code == 'verification_conflict'
def test_rejected_display_name_is_not_reported_as_imported(service, tmp_path):
pairs = ((project(tmp_path/'before', 'A'), project(tmp_path/'after', 'A')),)
task = service.create_task('拒绝', request_id='create')['task_id']
result = service.import_pairs(task, pairs, request_id='batch', stop_event=Event(), display_names=('x'*257,))
assert result['rows'][0]['status'] == 'failed'
assert result['rows'][0]['reason']
assert service.repo.connection.execute('SELECT COUNT(*) FROM verification_items').fetchone()[0] == 0
+138
View File
@@ -0,0 +1,138 @@
import copy
import json
from pathlib import Path
from threading import Event
import pytest
from test_independent_verification_intake import service
from test_independent_verification_runner import imported
from test_native_cli_netlist import graph
from test_verification_control import wait_idle
def complete(service, tmp_path, monkeypatch):
from tools.verification_closed_loop import freeze_inputs
from dx_productivity.trial_task_center import netlist_verification
task, item = imported(service, tmp_path)
scope = freeze_inputs(service, task, expected_count=1)
def native(capture, output, *, stop_event):
output.mkdir(parents=True, exist_ok=True)
return {'status': 'success', 'complete': True, 'capture': capture, 'graph': graph(output),
'outputs': {'effective': str(output/'effective.txt'), 'keyin': str(output/'design.kyn')}}
monkeypatch.setattr(netlist_verification, '_export_saved_capture', native)
run = service.start(task, request_id='loop-start'); wait_idle(service)
report = service.export_task(task, tmp_path/'reports', request_id='loop-report')
return task, item, scope, run, report
def test_complete_scope_report_and_inputs_pass_same_attempt_checks(service, tmp_path, monkeypatch):
from tools.verification_closed_loop import verify_closed_loop
task, item, scope, run, report = complete(service, tmp_path, monkeypatch)
result = verify_closed_loop(service, task, scope, run, report, expected_verdicts={item: 'CONSISTENT'})
assert result['passed'] and all(c['state']=='passed' for c in result['checks'])
def test_empty_task_cannot_be_frozen_as_a_closed_loop(service):
from tools.verification_closed_loop import freeze_inputs
task = service.create_task('空', request_id='empty')['task_id']
with pytest.raises(ValueError): freeze_inputs(service, task, expected_count=0)
@pytest.mark.parametrize('fault', ['run_member', 'report_attempt', 'html_binding', 'source', 'expected_verdict', 'resource_proof', 'evidence_binding'])
def test_closed_loop_rejects_wrong_members_stale_reports_and_changed_sources(service, tmp_path, monkeypatch, fault):
from tools.verification_closed_loop import verify_closed_loop
task, item, scope, run, report = complete(service, tmp_path, monkeypatch)
expected = {item: 'CONSISTENT'}
if fault=='run_member':
run = copy.deepcopy(run); run['members'] = []
elif fault=='report_attempt':
path = report/'task.json'; value = json.loads(path.read_text(encoding='utf-8'))
value['items'][0]['attempt_id'] = 'old-attempt'
path.write_text(json.dumps(value), encoding='utf-8')
elif fault=='html_binding':
path = report/f'{item}-v1.html'; path.write_text('<html>CONSISTENT</html>', encoding='utf-8')
elif fault=='source':
capture = service.artifacts.read(scope['items'][0]['before_ref'], 'snapshot')
Path(capture['project']).write_text('changed', encoding='utf-8')
elif fault=='expected_verdict':
expected[item] = 'DIFFERENT'
elif fault=='resource_proof':
attempt = service.repo.latest_attempt(item, 1)
(service.data_root/'verification/attempts'/attempt['attempt_id']/'resource-released.json').write_text(
json.dumps({'owner_id': 'another-owner', 'resource_state': 'released'}), encoding='utf-8')
else:
path = report/'task.json'; value = json.loads(path.read_text(encoding='utf-8'))
value['items'][0]['attempt']['result']['evidence']['binding']['input_digest'] = 'f'*64
path.write_text(json.dumps(value), encoding='utf-8')
result = verify_closed_loop(service, task, scope, run, report, expected_verdicts=expected)
assert not result['passed'] and any(c['state']=='failed' for c in result['checks'])
def test_stopped_attempt_is_not_a_completed_closed_loop(service, tmp_path):
from tools.verification_closed_loop import freeze_inputs, verify_closed_loop
task, item = imported(service, tmp_path)
scope = freeze_inputs(service, task, expected_count=1)
attempt = service.repo.create_attempt(item, 1, request_id='cancelled')
service.repo.finish(attempt['attempt_id'], generation=attempt['generation'], result={
'attempt_state': 'cancelled', 'resource_state': 'released', 'verdict': 'INCOMPLETE', 'reason': 'stop'})
run = {'run_id': None, 'members': [{'item_id': item, 'input_version': 1, 'attempt_id': attempt['attempt_id']}]}
report = service.export_task(task, tmp_path/'reports', request_id='cancelled-report')
result = verify_closed_loop(service, task, scope, run, report, expected_verdicts={item: 'INCOMPLETE'})
assert not result['passed']
def test_selected_rerun_is_checked_against_its_scope_inside_a_whole_task_report(service, tmp_path, monkeypatch):
from tools.verification_closed_loop import freeze_inputs, verify_closed_loop
task, item, _, _, _ = complete(service, tmp_path, monkeypatch)
payload = {key: value for key, value in service.repo.revision(item, 1)['payload'].items()
if key not in ('payload_digest', 'input_state')}
payload.update(item_key='second', display_name='second')
service.publish_inputs(task, (payload,), submission_id='second')
scope = freeze_inputs(service, task, expected_count=2)
whole = service.start(task, selection=tuple((row['item_id'], 1) for row in scope['items']), request_id='whole-task'); wait_idle(service)
subset = dict(scope, items=[row for row in scope['items'] if row['item_id']==item])
selected_run = dict(whole, members=[row for row in whole['members'] if row['item_id']==item])
whole_report = service.export_task(task, tmp_path/'whole-report', request_id='whole-report')
assert verify_closed_loop(service, task, subset, selected_run, whole_report, expected_verdicts={item: 'CONSISTENT'}, selected_only=True)['passed']
run = service.rerun(item, 1, request_id='selected'); wait_idle(service)
scope['items'] = [row for row in scope['items'] if row['item_id']==item]
report = service.export_task(task, tmp_path/'selected-report', request_id='selected-report')
result = verify_closed_loop(service, task, scope, run, report, expected_verdicts={item: 'CONSISTENT'}, selected_only=True)
assert result['passed']
assert not verify_closed_loop(service, task, scope, run, report, expected_verdicts={item: 'CONSISTENT'})['passed']
def test_existing_replacement_history_is_allowed_but_new_replacement_is_rejected(service, tmp_path, monkeypatch):
from tools.verification_closed_loop import verify_closed_loop
def operation(key):
with service.repo.store.transaction():
service.repo.connection.execute('''INSERT INTO execution_operations
(task_id,round_id,operation_key,command_json,state) VALUES ('prior','round',?,'{}','verified')''', (key,))
operation('before-verification')
task, item, scope, run, report = complete(service, tmp_path, monkeypatch)
assert verify_closed_loop(service, task, scope, run, report, expected_verdicts={item: 'CONSISTENT'})['passed']
with service.repo.store.transaction():
service.repo.connection.execute("UPDATE execution_operations SET generation=1 WHERE operation_key='before-verification'")
assert not verify_closed_loop(service, task, scope, run, report, expected_verdicts={item: 'CONSISTENT'})['passed']
with service.repo.store.transaction():
service.repo.connection.execute("UPDATE execution_operations SET generation=0 WHERE operation_key='before-verification'")
operation('during-verification')
assert not verify_closed_loop(service, task, scope, run, report, expected_verdicts={item: 'CONSISTENT'})['passed']
def test_saved_handoff_freezes_current_source_without_reinventing_historical_before(service, tmp_path):
from tools.verification_closed_loop import freeze_inputs
from test_native_cli_netlist import project_fixture
folder=tmp_path/'live';folder.mkdir();path=project_fixture(folder)
before=service.artifacts.capture(path,stop_event=Event())
(path.parent/'database/icdb.dat').write_bytes(b'saved-after')
after=service.artifacts.capture(path,stop_event=Event())
expected=service.artifacts.put('expectations',{'changes':{}})
from dx_productivity.trial_task_center.verification.contracts import default_plan
task=service.create_task('交接',request_id='handoff')['task_id']
service.publish_inputs(task,({'item_key':'saved','project_key':str(path),'input_version':1,
'before_ref':before,'after_ref':after,'expectation_ref':expected,'check_plan':default_plan()},),submission_id='saved')
with pytest.raises(ValueError):freeze_inputs(service,task,expected_count=1)
scope=freeze_inputs(service,task,expected_count=1,historical_before=True)
assert scope['historical_before'] is True
assert service.artifacts.read(before,'snapshot')['source_hashes']!=scope['source_hashes']
+169
View File
@@ -0,0 +1,169 @@
import time
from threading import Event
import pytest
from dx_productivity.trial_task_center.errors import TaskCenterError
from test_independent_verification_intake import service
from test_independent_verification_runner import imported
from test_native_cli_netlist import graph
def wait_idle(service):
deadline=time.monotonic()+5
while service.busy and time.monotonic()<deadline:time.sleep(.01)
assert not service.busy
def test_start_idempotency_and_frozen_members_do_not_swallow_new_version(service,tmp_path,monkeypatch):
from dx_productivity.trial_task_center import netlist_verification
entered=Event();release=Event();calls=[]
def export(capture,output,*,stop_event):
calls.append(str(output));entered.set();release.wait(3);output.mkdir(parents=True,exist_ok=True)
return {'status':'success','complete':True,'graph':graph(output),'outputs':{}}
monkeypatch.setattr(netlist_verification,'_export_saved_capture',export)
task,item=imported(service,tmp_path)
first=service.start(task,selection=None,request_id='run')
assert entered.wait(2)
assert service.start(task,selection=None,request_id='run')==first
payload=service.repo.revision(item,1)['payload']
newer={k:v for k,v in payload.items() if k not in {'input_state','payload_digest'}};newer['input_version']=2
service.publish_inputs(task,(newer,),submission_id='new')
try:
assert service.start(task,selection=((item,1),),request_id='same-member')==first
with pytest.raises(TaskCenterError,match='当前校验'):
service.rerun(item,2,request_id='start-new-version')
finally:
release.set()
wait_idle(service)
assert len(calls)==2 and service.read_item(item)['status']=='waiting'
assert service.read_item(item,version=1)['status']=='consistent'
def test_stop_during_export_is_cancelled_and_rerun_is_new_generation(service,tmp_path,monkeypatch):
from dx_productivity.trial_task_center import netlist_verification
entered=Event()
def slow(capture,output,*,stop_event):
entered.set();stop_event.wait(3)
return {'status':'cancelled','complete':False,'reason':'stopped'}
monkeypatch.setattr(netlist_verification,'_export_saved_capture',slow)
task,item=imported(service,tmp_path)
run=service.start(task,selection=None,request_id='start');assert entered.wait(2)
service.stop(run['run_id'],request_id='stop');wait_idle(service)
assert service.read_item(item)['status']=='stopped'
def normal(capture,output,*,stop_event):
output.mkdir(parents=True,exist_ok=True)
return {'status':'success','complete':True,'graph':graph(output),'outputs':{}}
monkeypatch.setattr(netlist_verification,'_export_saved_capture',normal)
service.rerun(item,1,request_id='again');wait_idle(service)
assert service.read_item(item)['attempt']['generation']==2
def test_recovery_never_automatically_runs_and_unknown_owner_blocks(service,tmp_path):
task,item=imported(service,tmp_path)
attempt=service.repo.create_attempt(item,1,request_id='lost')
service.repo.claim(attempt['attempt_id'],owner_id='lost-owner')
result=service.recover()
assert result['blocked']==1 and not service.busy
assert service.repo.attempt(attempt['attempt_id'])['state']=='stopping'
assert service.read_item(item)['verdict'] is None
def test_durable_stop_wins_race_with_final_result_commit(service,tmp_path,monkeypatch):
from dx_productivity.trial_task_center import netlist_verification
task,item=imported(service,tmp_path)
def native(capture,output,*,stop_event):
output.mkdir(parents=True,exist_ok=True)
return {'status':'success','complete':True,'graph':graph(output),'outputs':{}}
monkeypatch.setattr(netlist_verification,'_export_saved_capture',native)
finish=service.repo.finish
def stop_before_commit(attempt_id,*,generation,result):
if result.get('attempt_state')=='succeeded':
attempt=service.repo.attempt(attempt_id)
service.stop(attempt['run_id'],request_id='race-stop')
return finish(attempt_id,generation=generation,result=result)
monkeypatch.setattr(service.repo,'finish',stop_before_commit)
service.start(task,request_id='run');wait_idle(service)
assert service.read_item(item)['status']=='stopped'
def test_storage_failure_pauses_dispatcher_without_replaying_forever(service,tmp_path,monkeypatch):
from dx_productivity.trial_task_center import netlist_verification
task,item=imported(service,tmp_path);calls=[]
def native(capture,output,*,stop_event):
output.mkdir(parents=True,exist_ok=True)
return {'status':'success','complete':True,'graph':graph(output),'outputs':{}}
def unavailable(*args,**kwargs):calls.append(1);raise OSError('storage unavailable')
monkeypatch.setattr(netlist_verification,'_export_saved_capture',native)
monkeypatch.setattr(service.repo,'finish',unavailable)
service.start(task,request_id='run');wait_idle(service)
assert service.control.closing and len(calls)<=2
assert (service.data_root/'verification/engine-paused.json').is_file()
def test_other_window_recovery_and_close_do_not_interrupt_live_owner(service,tmp_path,monkeypatch):
from dx_productivity.trial_task_center.store import TaskStore
from dx_productivity.trial_task_center.verification.service import VerificationService
from dx_productivity.trial_task_center import netlist_verification
entered=Event();release=Event()
def native(capture,output,*,stop_event):
entered.set();release.wait(5);output.mkdir(parents=True,exist_ok=True)
return {'status':'success','complete':True,'graph':graph(output),'outputs':{}}
monkeypatch.setattr(netlist_verification,'_export_saved_capture',native)
task,item=imported(service,tmp_path);run=service.start(task,request_id='owner');assert entered.wait(3)
other_store=TaskStore(service.repo.store.path);other=VerificationService(other_store,service.data_root)
try:
recovered=other.recover()
assert recovered.get('live_owners')==1
assert service.repo.latest_attempt(item,1)['state']=='running'
other.start(task,request_id='observe')
assert not other.busy
other.begin_shutdown()
assert not service.repo._one('verification_runs','run_id',run['run_id'])['stop_requested']
finally:release.set();wait_idle(service);other.begin_shutdown();other_store.close()
assert service.read_item(item)['status']=='consistent'
def test_stop_from_another_window_is_observed_during_native_export(service,tmp_path,monkeypatch):
from dx_productivity.trial_task_center.store import TaskStore
from dx_productivity.trial_task_center.verification.service import VerificationService
from dx_productivity.trial_task_center import netlist_verification
entered=Event()
def native(capture,output,*,stop_event):
entered.set();stop_event.wait(2)
return {'status':'cancelled','complete':False}
monkeypatch.setattr(netlist_verification,'_export_saved_capture',native)
task,item=imported(service,tmp_path);run=service.start(task,request_id='owner');assert entered.wait(3)
other_store=TaskStore(service.repo.store.path);other=VerificationService(other_store,service.data_root)
try:
other.stop(run['run_id'],request_id='foreign-stop');wait_idle(service)
assert service.read_item(item)['status']=='stopped'
finally:other.begin_shutdown();other_store.close()
def test_owner_exit_without_cli_exit_proof_remains_unknown(service,tmp_path,monkeypatch):
from dx_productivity.trial_task_center.verification import ownership
task,item=imported(service,tmp_path)
attempt=service.repo.create_attempt(item,1,request_id='lost')
service.repo.claim(attempt['attempt_id'],owner_id=service.control.owner_id)
ownership.write_owner(service,'attempts',attempt['attempt_id'],service.control.owner_id)
# This includes a reused PID: the original creation identity is gone.
monkeypatch.setattr(ownership,'_process_gone',lambda identity:True)
recovered=service.recover()
assert recovered['blocked']==1 and recovered['published']==0
assert service.repo.attempt(attempt['attempt_id'])['resource_state']=='unknown'
def test_recovery_publishes_intact_staged_result_without_reexport(service,tmp_path,monkeypatch):
from dx_productivity.trial_task_center import netlist_verification
from dx_productivity.trial_task_center.verification.runner import run_attempt
calls=[]
def native(capture,output,*,stop_event):
calls.append(1);output.mkdir(parents=True,exist_ok=True)
return {'status':'success','complete':True,'graph':graph(output),'outputs':{}}
monkeypatch.setattr(netlist_verification,'_export_saved_capture',native)
_,item=imported(service,tmp_path);attempt=service.repo.create_attempt(item,1,request_id='staged')
with monkeypatch.context() as patch:
patch.setattr(service.repo,'finish',lambda *args,**kwargs:False)
assert not run_attempt(service,attempt['attempt_id'],stop_event=Event())['published']
recovered=service.recover()
assert recovered['published']==1 and len(calls)==2
assert service.read_item(item)['status']=='consistent' and not service.busy
@@ -0,0 +1,30 @@
import pytest
from test_independent_verification_intake import service
from test_independent_verification_runner import imported
from threading import Event
def test_stopped_acceptance_requires_unstarted_members_to_remain_waiting(service, tmp_path):
from tools.verification_control_acceptance import verify_stopped
task, item = imported(service, tmp_path)
attempt = service.repo.create_attempt(item, 1, request_id='attempt')
with service.repo.store.transaction():
service.repo.connection.execute("UPDATE verification_attempts SET state='cancelled',resource_state='released',reason='run_stopped_before_dispatch' WHERE attempt_id=?",(attempt['attempt_id'],))
run = {'members':[{'item_id':item, 'input_version':1, 'attempt_id':attempt['attempt_id']}]}
result = verify_stopped(service, run, unstarted={attempt['attempt_id']})
assert result['passed']
with service.repo.store.transaction():
service.repo.connection.execute("UPDATE verification_attempts SET state='running' WHERE attempt_id=?",(attempt['attempt_id'],))
assert not verify_stopped(service, run, unstarted={attempt['attempt_id']})['passed']
def test_unknown_acceptance_rejects_released_or_automatically_rerun_attempt(service, tmp_path):
from tools.verification_control_acceptance import verify_unknown
task, item = imported(service, tmp_path)
attempt = service.repo.create_attempt(item, 1, request_id='attempt')
service.repo.claim(attempt['attempt_id'], owner_id='lost-owner')
service.recover()
assert verify_unknown(service, attempt['attempt_id'], expected_attempts=1)['passed']
with service.repo.store.transaction():
service.repo.connection.execute("UPDATE verification_attempts SET resource_state='released' WHERE attempt_id=?",(attempt['attempt_id'],))
assert not verify_unknown(service, attempt['attempt_id'], expected_attempts=1)['passed']
+29
View File
@@ -0,0 +1,29 @@
import copy
from test_independent_verification_rules import export,evaluate
def test_swap_diagram_uses_fixed_pin_order_and_same_connection_facts():
from dx_productivity.trial_task_center.verification.evidence import build_evidence,connection_view
a=export();b=copy.deepcopy(a)
b['graph']['components']['a']['pins']['loop']['number']='2'
b['graph']['components']['a']['pins']['GND']['number']='1'
result=evaluate(a,b)
evidence=build_evidence(a['graph'],b['graph'],result['issues'],binding={'attempt_id':'attempt','input_version':1})
issue=next(i for i in result['issues'] if i['check_id']=='connections' and i['refdes']=='R12')
view=connection_view(evidence,issue['issue_id'])
assert [p['endpoint'][2] for p in view['pins']]==['1','2']
assert all(p['connection_changed'] for p in view['pins'])
assert view['pins'][0]['before']['nets'][0]['name']=='LOOP'
assert view['pins'][0]['after']['nets'][0]['name']=='GND'
assert view['page'] is None and evidence['digest']
def test_pure_rename_has_no_false_red_connection():
from dx_productivity.trial_task_center.verification.evidence import build_evidence
a=export();b=copy.deepcopy(a)
b['graph']['components']['a']['pins']['outloop']=b['graph']['components']['a']['pins'].pop('loop')
b['graph']['nets'][0]['endpoints'][0][1]='outloop'
result=evaluate(a,b)
evidence=build_evidence(a['graph'],b['graph'],result['issues'],binding={})
assert any(p['text_changed'] for p in evidence['pins'])
assert not any(p['connection_changed'] for p in evidence['pins'])
@@ -0,0 +1,20 @@
from test_native_cli_netlist import graph
def test_native_pin_type_has_raw_proof_but_component_value_is_not_pin_value(tmp_path):
from dx_productivity.trial_task_center.verification.pin_metadata import inspect_pin_metadata
g=graph(tmp_path)
result=inspect_pin_metadata({'graph':g,'outputs':{'effective':str(tmp_path/'effective.txt')}},evidence_root=tmp_path)
pin=result['pins'][0]
assert pin['logical_name']['value']=='A' and pin['logical_name']['confidence']=='proven'
assert pin['electrical_type']['value']=='1'
assert pin['pin_value']['value'] is None and pin['pin_value']['confidence']=='unknown'
assert pin['raw']['sha256'] and pin['raw']['line']>0
def test_missing_or_mismatched_raw_does_not_prove_metadata(tmp_path):
from dx_productivity.trial_task_center.verification.pin_metadata import inspect_pin_metadata,inspect_footprint_mapping
g=graph(tmp_path);g['components']['$1I1']['pins']['A']['number']='9'
result=inspect_pin_metadata({'graph':g,'outputs':{'effective':str(tmp_path/'effective.txt')}},evidence_root=tmp_path)
assert not result['pins']
assert inspect_footprint_mapping({'evidence':None})['mapping'] is None
+109
View File
@@ -0,0 +1,109 @@
import copy
import json
from threading import Event
import pytest
from test_independent_verification_intake import service
from test_independent_verification_runner import imported
from test_independent_verification_rules import export,evaluate
from dx_productivity.trial_task_center.errors import TaskCenterError
def test_html_escapes_and_uses_same_fixed_pin_facts(tmp_path):
from dx_productivity.trial_task_center.verification.report import render_item_report
from dx_productivity.trial_task_center.verification.evidence import build_evidence
a=export();b=copy.deepcopy(a);b['graph']['components']['a']['pins']['loop']['number']='2';b['graph']['components']['a']['pins']['GND']['number']='1'
result=evaluate(a,b);result['evidence']=build_evidence(a['graph'],b['graph'],result['issues'],binding={})
result['display_name']='<script>alert(1)</script>'
path=render_item_report(result,tmp_path/'report.html')
html=path.read_text(encoding='utf-8')
assert '<script>' not in html and '&lt;script&gt;' in html
assert 'R12' in html and 'LOOP' in html and 'GND' in html and 'DIFFERENT' in html
with pytest.raises(TaskCenterError):render_item_report(result,path)
def test_task_export_is_immutable_and_incomplete_items_are_explicit(service,tmp_path):
task,item=imported(service,tmp_path)
output=service.export_task(task,tmp_path/'reports',request_id='export')
value=json.loads((output/'task.json').read_text(encoding='utf-8'))
assert value['items'][0]['status']=='waiting'
assert service.export_task(task,tmp_path/'reports',request_id='export')==output
assert (output/'index.html').is_file()
@pytest.mark.parametrize('change,label',[('rename','网名变化'),('add','器件新增'),('remove','器件删除')])
def test_historical_pin_evidence_reports_the_detected_change(tmp_path,change,label):
from dx_productivity.trial_task_center.verification.report import render_item_report
from dx_productivity.trial_task_center.verification.evidence import build_evidence
a,b=export(),export()
if change=='rename':
b['graph']['nets'][0]['name']='RENAMED'
for uid,pin in [('a','loop'),('b','out')]:
b['graph']['components'][uid]['pins'][pin]['nets']=['RENAMED']
else:
graph=(b if change=='add' else a)['graph']
graph['components']['isolated']={'refdes':'R99','attributes':{'Part Number':'PART'},
'pins':{'open':{'number':'1','nets':[]}}}
result=evaluate(a,b)
result['evidence']=build_evidence(a['graph'],b['graph'],result['issues'],binding={})
path=render_item_report(result,tmp_path/'report.html')
html=path.read_text(encoding='utf-8')
assert result['verdict']=='DIFFERENT'
assert f'<td>{label}</td>' in html and '#b83d4a' in html.split('<svg',1)[1]
def test_report_filename_limit_does_not_depend_on_destination_name(tmp_path):
from dx_productivity.trial_task_center.path_access import internal_path
from dx_productivity.trial_task_center.verification.report import render_item_report
path=tmp_path/('r'*235+'.html')
assert render_item_report({},path)==path
assert internal_path(path).read_text(encoding='utf-8').startswith('<!doctype html>')
assert list(tmp_path.iterdir())==[path]
def test_task_report_can_be_written_beyond_windows_legacy_path_limit(service,tmp_path):
from dx_productivity.trial_task_center.path_access import internal_path
task=service.create_task('报告',request_id='task')['task_id']
destination=tmp_path
while len(str(destination))<270:
destination=destination/('report-folder-'+'a'*30)
output=service.export_task(task,destination,request_id='export')
assert internal_path(output/'index.html').is_file()
assert service.export_task(task,destination,request_id='export')==output
def test_corrupt_evidence_cannot_remain_green_or_export(service,tmp_path,monkeypatch):
from test_native_cli_netlist import graph
from dx_productivity.trial_task_center import netlist_verification
from dx_productivity.trial_task_center.verification.runner import run_attempt
task,item=imported(service,tmp_path)
def native(capture,output,*,stop_event):
output.mkdir(parents=True,exist_ok=True);g=graph(output)
return {'status':'success','complete':True,'graph':g,'outputs':{'effective':str(output/'effective.txt')}}
monkeypatch.setattr(netlist_verification,'_export_saved_capture',native)
attempt=service.repo.create_attempt(item,1,request_id='a');run_attempt(service,attempt['attempt_id'],stop_event=Event())
assert service.read_item(item)['status']=='consistent'
raw=service.repo.attempt(attempt['attempt_id'])['result']['evidence']['binding']['raw'][0]
from pathlib import Path
Path(raw['path']).write_text('corrupt')
assert service.read_item(item)['status']=='unavailable'
assert service.read_task(task)['summary']['consistent']==0
with pytest.raises(TaskCenterError):service.export_task(task,tmp_path/'reports',request_id='bad')
def test_missing_fixed_expectation_cannot_keep_a_green_result(service,tmp_path,monkeypatch):
from test_native_cli_netlist import graph
from dx_productivity.trial_task_center import netlist_verification
from dx_productivity.trial_task_center.verification.runner import run_attempt
_,item=imported(service,tmp_path)
expected=service.artifacts.put('expectations',{'changes':{}})
row={k:v for k,v in service.repo.revision(item,1)['payload'].items() if k not in {'payload_digest','input_state'}}
row.update(input_version=2,expectation_ref=expected)
service.publish_inputs(service.repo.item(item)['task_id'],(row,),submission_id='expectations')
def native(capture,output,*,stop_event):
output.mkdir(parents=True,exist_ok=True)
return {'status':'success','complete':True,'graph':graph(output),'outputs':{}}
monkeypatch.setattr(netlist_verification,'_export_saved_capture',native)
attempt=service.repo.create_attempt(item,2,request_id='a');run_attempt(service,attempt['attempt_id'],stop_event=Event())
assert service.read_item(item)['status']=='consistent'
(service.artifacts.directory(expected['manifest_id'])/'manifest.json').unlink()
assert service.read_item(item)['status']=='unavailable'
+67 -7
View File
@@ -1,14 +1,74 @@
param() param(
[string]$Version
)
$ErrorActionPreference = 'Stop' $ErrorActionPreference = 'Stop'
$dshRepoRoot = Split-Path -Parent $PSScriptRoot $dshRepoRoot = Split-Path -Parent $PSScriptRoot
$dshRuntimeRoot = Join-Path $dshRepoRoot 'integration/dsh' $dshRuntimeRoot = Join-Path $dshRepoRoot 'integration/dsh'
$dshNodeCommand = Get-Command node -ErrorAction Stop $dshNodeCommand = Get-Command node -ErrorAction Stop
$dshNodeVersion = & $dshNodeCommand.Source -p 'process.versions.node' $dshNodeVersion = & $dshNodeCommand.Source -p 'process.versions.node'
if ([version]$dshNodeVersion -lt [version]'24.9.0') { throw 'DSH requires Node.js 24.9.0 or later.' } if ([version]$dshNodeVersion -lt [version]'24.9.0') { throw 'DSH requires Node.js 24.9.0 or later.' }
Push-Location -LiteralPath $dshRuntimeRoot $dshNpm = (Get-Command npm.cmd -ErrorAction Stop).Source
$dshRegistry = 'https://registry.npmjs.org/'
$dshBuild = Join-Path $dshRepoRoot 'build'
New-Item -ItemType Directory -Path $dshBuild -Force | Out-Null
$dshInstallLock = [IO.File]::Open((Join-Path $dshBuild 'dsh-install.lock'), 'OpenOrCreate', 'ReadWrite', 'None')
try { try {
& npm.cmd ci --ignore-scripts --no-audit --no-fund if (-not $Version) {
if ($LASTEXITCODE -ne 0) { throw 'DSH installation failed.' } & $dshNpm --prefix $dshRuntimeRoot ci --ignore-scripts --no-audit --no-fund
& $dshNodeCommand.Source start.mjs --doctor if ($LASTEXITCODE -ne 0) { throw 'DSH installation failed.' }
if ($LASTEXITCODE -ne 0) { throw 'DSH runtime verification failed.' } & $dshNodeCommand.Source (Join-Path $dshRuntimeRoot 'start.mjs') --doctor
} finally { Pop-Location } if ($LASTEXITCODE -ne 0) { throw 'DSH runtime verification failed.' }
return
}
if ($Version -cnotmatch '\A(?:latest|\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)\z') {
throw 'Use latest or an exact version, for example 0.2.2-rc.5.'
}
# Keep the candidate and previous installation on the same volume for rename.
$dshStage = Join-Path $dshBuild ('dsh-update-' + [Guid]::NewGuid().ToString('N'))
$dshCandidate = Join-Path $dshStage 'candidate'
$dshPrevious = Join-Path $dshStage 'previous'
$dshEntries = @('package.json', 'package-lock.json', 'node_modules')
$dshBackedUp = @()
$dshPublished = @()
New-Item -ItemType Directory -Path $dshCandidate, $dshPrevious -Force | Out-Null
try {
Copy-Item -LiteralPath @(
(Join-Path $dshRuntimeRoot 'package.json')
(Join-Path $dshRuntimeRoot 'package-lock.json')
(Join-Path $dshRuntimeRoot 'start.mjs')
(Join-Path $dshRuntimeRoot 'task-plugin')
) -Destination $dshCandidate -Recurse
& $dshNpm --prefix $dshCandidate install --save-exact --ignore-scripts --no-audit --no-fund --registry=$dshRegistry "@deepseek-ai/dsh@$Version"
if ($LASTEXITCODE -ne 0) { throw 'DSH candidate installation failed.' }
& $dshNodeCommand.Source (Join-Path $PSScriptRoot 'verify_dsh_runtime.mjs') $dshCandidate (Join-Path $dshStage 'verification')
if ($LASTEXITCODE -ne 0) { throw 'DSH candidate failed the runtime check. The previous runtime is still available.' }
foreach ($dshEntry in $dshEntries) {
$dshLive = Join-Path $dshRuntimeRoot $dshEntry
if (Test-Path -LiteralPath $dshLive) {
Move-Item -LiteralPath $dshLive -Destination (Join-Path $dshPrevious $dshEntry)
$dshBackedUp += $dshEntry
}
Move-Item -LiteralPath (Join-Path $dshCandidate $dshEntry) -Destination $dshLive
$dshPublished += $dshEntry
}
} catch {
try {
foreach ($dshEntry in $dshPublished) {
Move-Item -LiteralPath (Join-Path $dshRuntimeRoot $dshEntry) -Destination (Join-Path $dshCandidate $dshEntry)
}
foreach ($dshEntry in $dshBackedUp) {
Move-Item -LiteralPath (Join-Path $dshPrevious $dshEntry) -Destination (Join-Path $dshRuntimeRoot $dshEntry)
}
} catch {
throw "DSH rollback failed. Previous files: $dshPrevious. $($_.Exception.Message)"
}
throw
}
Write-Output "DSH updated. Previous files and verification: $dshStage"
} finally {
$dshInstallLock.Dispose()
}
+2 -1
View File
@@ -13,7 +13,8 @@ const {loadProfileDirectory,composeEntries}=await load('@deepseek-ai/dsh-app-boo
const {runProfile,INSTALL_ANCHOR}=await load('@deepseek-ai/dsh/profile-boot'); const {runProfile,INSTALL_ANCHOR}=await load('@deepseek-ai/dsh/profile-boot');
const {createLaunchEnvironmentSnapshot}=await load('@deepseek-ai/dsh-launch-environment'); const {createLaunchEnvironmentSnapshot}=await load('@deepseek-ai/dsh-launch-environment');
const installed=require('@deepseek-ai/dsh/package.json'); const installed=require('@deepseek-ai/dsh/package.json');
if(installed.version!=='0.2.1-rc.5')throw Error('Runtime version mismatch'); const expected=require('../package.json').dependencies['@deepseek-ai/dsh'];
if(installed.version!==expected)throw Error('Runtime version mismatch');
const original=loadProfileDirectory('paired-source',path.resolve(source),INSTALL_ANCHOR); const original=loadProfileDirectory('paired-source',path.resolve(source),INSTALL_ANCHOR);
const effective=composeEntries([...original.layers.map(layer=>layer.patches),original.patches]); const effective=composeEntries([...original.layers.map(layer=>layer.patches),original.patches]);
// Copy effective routing/model/shell budgets, never credential values to reports. // Copy effective routing/model/shell budgets, never credential values to reports.
+321
View File
@@ -0,0 +1,321 @@
"""Actual Windows EXE: batch import, native run, report, restart, rerun, report.
Use saved test copies. Expectations must be supplied before launch. This tool
never creates replacement receipts or changes task state directly in SQLite.
"""
import argparse
from contextlib import contextmanager
import json
import os
import shutil
from pathlib import Path
import sqlite3
import subprocess
import sys
import time
sys.path.insert(0, str(Path(__file__).resolve().parents[1]/'src'))
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
from dx_productivity.trial_task_center.store import TaskStore
from dx_productivity.trial_task_center.verification.service import VerificationService
from dx_productivity.trial_task_center.native_netlist import _hash
from verification_closed_loop import freeze_inputs, verify_closed_loop, require
def main(argv=None):
parser = argparse.ArgumentParser(description=__doc__)
for name in ('exe', 'before-root', 'after-root', 'output'):
parser.add_argument('--'+name, type=Path, required=True)
parser.add_argument('--expected-items', nargs='+', required=True, help='Exact relative paths, e.g. A/input.prj B/input.prj')
parser.add_argument('--expect-verdict', choices=('CONSISTENT', 'WARNING', 'DIFFERENT'), required=True)
parser.add_argument('--fault-batch', action='store_true', help='Use private copies and prepend one deliberately invalid database fixture')
parser.add_argument('--control-scenario', choices=('stop','owner-exit'), help='Separate C08 scenario; no fault switches in the product')
parser.add_argument('--handoff-data',type=Path,help='Existing disposable data root containing real saved execution receipts; never import a pair')
args = parser.parse_args(argv)
output = args.output.resolve(); exe = args.exe.resolve()
before, after = args.before_root.resolve(), args.after_root.resolve()
if output.exists(): parser.error('output must be a new directory')
if output.is_relative_to(before) or output.is_relative_to(after): parser.error('output must be outside input roots')
if len(set(args.expected_items))!=len(args.expected_items): parser.error('expected-items must be unique')
output.mkdir(parents=True)
# Import UI automation only for the EXE path; service acceptance remains portable.
import win32con
import win32gui
from packaged_window_driver import WindowDriver, window_image
from accept_packaged_ui import wait
data = args.handoff_data.resolve(strict=True) if args.handoff_data else output/'data'
if args.handoff_data and (args.fault_batch or args.control_scenario):parser.error('handoff-data is a separate scenario')
report = {'standard': 'verification-closed-loop-v1', 'validation_scope': 'independent-native:C01-C07',
'evidence_kind': 'native-packaged-ui', 'executable': str(exe), 'executable_sha256': _hash(exe),
'expected_items': args.expected_items, 'expected_verdict': args.expect_verdict, 'checks': [],
'not_run': ['C08:packaged-fault-cases', 'actual-successful-replacement-handoff', 'continuous-full-regression']}
if args.handoff_data:report['not_run'].remove('actual-successful-replacement-handoff')
if args.control_scenario:report['not_run'][0]='C08:'+('owner-exit' if args.control_scenario=='stop' else 'stop')
original = {str(p): _hash(p) for root in (before, after) for p in root.rglob('*') if p.is_file()}
failed_name = '00-invalid/input.prj' if args.fault_batch else None
if args.fault_batch:
for phase, source in (('before', before), ('after', after)):
destination = output/'inputs'/phase
shutil.copytree(source, destination)
fixture = destination/'00-invalid'; (fixture/'database').mkdir(parents=True)
(fixture/'input.prj').write_text('KEY RootBlock "board"\nKEY FrontEndSnapshot "DxD"\nKEY iCDBDir "database"\n', encoding='utf-8')
(fixture/'database/icdb.dat').write_bytes(b'deliberately-invalid-acceptance-fixture')
before, after = output/'inputs/before', output/'inputs/after'
original.update((str(p), _hash(p)) for root in (before, after) for p in root.rglob('*') if p.is_file())
report.update(evidence_kind='native-real-copies-and-invalid-database-fixture', expected_failed_items=[failed_name])
expected_names = sorted(args.expected_items + ([failed_name] if failed_name else []))
process = driver = main_window = None
def sql(query, params=()):
with sqlite3.connect(data/'task-center.db') as db:
db.row_factory = sqlite3.Row
return [dict(row) for row in db.execute(query, params)]
@contextmanager
def reader():
store = TaskStore(data/'task-center.db')
try: yield VerificationService(store, data)
finally: store.close()
def launch():
nonlocal process, driver, main_window
environment = dict(os.environ)
for name in ('PYTHONPATH', 'PYTHONHOME', 'DX_TASK_CENTER_HOME', 'QT_QPA_PLATFORM'): environment.pop(name, None)
p = subprocess.Popen([str(exe), '--data-root', str(data)], cwd=exe.parent, env=environment,
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, creationflags=subprocess.CREATE_NO_WINDOW)
process = p
d = WindowDriver(p.pid, output); driver = d
def ready():
try: return d.main()
except TimeoutError:
require(p.poll() is None, 'Application exited before its main window appeared')
return None
window = wait(ready, timeout=90); main_window = window
d.click(d.find(automation_id='verification_navigation'))
return p, d, window
def close():
for window in driver.windows():
if win32gui.GetClassName(window.handle)=='#32770':
cancel = next((c for c in window.descendants(control_type='Button') if c.element_info.automation_id=='2'), None)
if cancel: win32gui.PostMessage(cancel.handle, win32con.BM_CLICK, 0, 0)
win32gui.PostMessage(main_window.handle, win32con.WM_CLOSE, 0, 0)
require(process.wait(45)==0, 'Application did not exit normally')
def run_record(run_id):
row = sql('SELECT * FROM verification_runs WHERE run_id=?', (run_id,))[0]
require(row['state']=='completed', 'Run stopped, blocked or interrupted')
return {'run_id': run_id, 'members': json.loads(row['members_json'])}
def finished(run_id):
rows = sql('SELECT state FROM verification_runs WHERE run_id=?', (run_id,))
return rows and rows[0]['state'] not in ('queued', 'running', 'stopping')
def export_report():
destination = output/'reports'; destination.mkdir(exist_ok=True)
previous = set(destination.glob('verification-*'))
driver.click(driver.find('导出报告', kind='Button'))
dialog = wait(lambda: next((w for w in driver.windows() if win32gui.GetClassName(w.handle)=='#32770'), None), timeout=15)
# The native folder picker has FolderName edit 1152, unlike file picker 1001.
field = next(c for c in dialog.descendants(control_type='Edit') if c.element_info.automation_id=='1152')
field.iface_value.SetValue(str(destination))
require(field.get_value()==str(destination), 'Folder picker path differs from the requested destination')
confirm = next(c for c in dialog.descendants(control_type='Button') if c.element_info.automation_id=='1')
win32gui.PostMessage(confirm.handle, win32con.BM_CLICK, 0, 0)
wait(lambda: not win32gui.IsWindow(dialog.handle), timeout=20)
return wait(lambda: next((p for p in destination.glob('verification-*') if p not in previous and (p/'task.json').is_file()), None), timeout=60)
def selected_cell(name):
tables = [w for kind in ('Table', 'DataGrid') for w in main_window.descendants(control_type=kind) if w.is_visible()]
table = min(tables, key=lambda w: w.rectangle().left)
return next((c for c in table.children() if c.window_text()==name), None)
def verify_report(scope, run, directory, label, *, selected_only=False):
with reader() as service:
validation = verify_closed_loop(service, task, scope, run, directory,
expected_verdicts={row['item_id']: args.expect_verdict for row in scope['items']}, selected_only=selected_only)
(output/(label+'.json')).write_text(json.dumps(validation, ensure_ascii=False, indent=2), encoding='utf-8')
report['checks'].extend(validation['checks'])
require(validation['passed'], label+' failed: '+json.dumps(validation['checks'], ensure_ascii=False))
def import_pairs_ui(*, create=True):
if create:
driver.click(wait(lambda: driver.find(automation_id='verificationNew')))
dialog = wait(lambda: next((w for w in driver.windows() if w.window_text()=='新建校验'), None))
ok = next(b for b in dialog.descendants(control_type='Button') if b.window_text().replace('&', '') in ('OK', '确定'))
driver.click(ok)
button = wait(lambda: driver.find(automation_id='verificationBatchImport'))
wait(lambda: button.is_enabled()); driver.click(button)
dialog = wait(lambda: next((w for w in driver.windows() if w.window_text()=='批量添加工程对'), None))
driver.type_text(driver.find(automation_id='verificationBeforeRoot', window=dialog), str(before))
driver.type_text(driver.find(automation_id='verificationAfterRoot', window=dialog), str(after))
driver.click(driver.find(automation_id='verificationScanPairs', window=dialog))
button = driver.find(automation_id='verificationImportPairs', window=dialog)
wait(lambda: button.is_enabled()); window_image(dialog.handle).save(output/'01-pairs.png')
driver.click(button)
wait(lambda: driver.find(f'本批导入完成:已导入 {len(expected_names)} 对,失败 0 对;尚未开始校验。', kind='Text', window=dialog), timeout=120)
driver.click(driver.find('关闭', kind='Button', window=dialog))
try:
process, driver, main_window = launch()
reduce = driver.find('减少透明度', kind='Button', optional=True)
if reduce: driver.click(reduce)
if args.handoff_data:
wait(lambda:len(sql('SELECT item_id FROM verification_items'))==len(args.expected_items),timeout=30)
report['evidence_kind']='native-packaged-real-saved-handoff'
else:
import_pairs_ui()
imported = sql('SELECT * FROM verification_items ORDER BY display_name')
require([r['display_name'] for r in imported]==expected_names, 'Imported names differ from the predeclared scope')
require(not sql('SELECT attempt_id FROM verification_attempts'), 'Import started verification automatically')
task = imported[0]['task_id']
with reader() as service: scope = freeze_inputs(service, task, expected_count=len(expected_names),historical_before=bool(args.handoff_data))
(output/'frozen-scope.json').write_text(json.dumps(dict(scope, expected_verdict=args.expect_verdict,
expected_failed_items=[failed_name] if failed_name else []), ensure_ascii=False, indent=2), encoding='utf-8')
driver.click(driver.find('开始全部', kind='Button'))
run_id = wait(lambda: next((r['run_id'] for r in sql('SELECT run_id FROM verification_runs')), None))
if args.control_scenario:
from tools.verification_control_acceptance import verify_stopped, verify_unknown
active = wait(lambda: next((r for r in sql("SELECT * FROM verification_attempts WHERE state='running'")), None), timeout=30)
pending = {r['attempt_id'] for r in sql("SELECT attempt_id FROM verification_attempts WHERE state='queued'")}
require(bool(pending), 'No undispatched member remains; this scenario is inconclusive')
raw_run = sql('SELECT members_json FROM verification_runs WHERE run_id=?', (run_id,))[0]
original_run = {'run_id':run_id,'members':json.loads(raw_run['members_json'])}
if args.control_scenario=='stop':
stop_button = driver.find('停止', kind='Button')
wait(lambda:stop_button.is_enabled(), timeout=10); driver.click(stop_button)
wait(lambda:finished(run_id), timeout=120)
with reader() as service: checked = verify_stopped(service, original_run, unstarted=pending)
require(checked['passed'], str(checked))
report['checks'].append({'check_id':'C08:stop','state':'passed','details':checked})
stopped_snapshot = sql('SELECT attempt_id,state,generation FROM verification_attempts ORDER BY attempt_id')
window_image(main_window.handle).save(output/'stop.png')
close(); process,driver,main_window=launch()
wait(lambda:selected_cell(sorted(args.expected_items)[0]), timeout=30)
time.sleep(2)
require(sql('SELECT attempt_id,state,generation FROM verification_attempts ORDER BY attempt_id')==stopped_snapshot,
'Restart replayed a stopped batch')
old_runs={r['run_id'] for r in sql('SELECT run_id FROM verification_runs')}
driver.click(driver.find('开始全部',kind='Button'))
continuation=wait(lambda:next((r['run_id'] for r in sql('SELECT run_id FROM verification_runs') if r['run_id'] not in old_runs),None),timeout=30)
wait(lambda:finished(continuation),timeout=900)
continued=run_record(continuation)
require({r['item_id'] for r in continued['members']}=={m['item_id'] for m in original_run['members'] if m['attempt_id'] in pending},
'Continue did not run exactly the previously undispatched items')
subset=dict(scope,items=[r for r in scope['items'] if r['item_id'] in {m['item_id'] for m in continued['members']}])
verify_report(subset,continued,export_report(),'continued',selected_only=True)
stopped_ids={r['item_id'] for r in sql("SELECT item_id FROM verification_attempts WHERE state='cancelled' AND reason!='run_stopped_before_dispatch'")}
for item_id in stopped_ids:
name=next(r['display_name'] for r in imported if r['item_id']==item_id)
driver.click(wait(lambda:selected_cell(name),timeout=20))
existing={r['run_id'] for r in sql('SELECT run_id FROM verification_runs')}
button=driver.find('重校验',kind='Button');wait(button.is_enabled,timeout=15);driver.click(button)
new_id=wait(lambda:next((r['run_id'] for r in sql('SELECT run_id FROM verification_runs') if r['run_id'] not in existing),None),timeout=30)
wait(lambda:finished(new_id),timeout=900)
subset=dict(scope,items=[r for r in scope['items'] if r['item_id']==item_id])
verify_report(subset,run_record(new_id),export_report(),'stopped-item-rerun',selected_only=True)
report['checks'].append({'check_id':'C08:continue-and-explicit-rerun','state':'passed'})
else:
import win32api,win32process
owner_path=data/'verification/attempts'/active['attempt_id']/'owner.json'
owner=json.loads(owner_path.read_text(encoding='utf-8'))
require(owner['process']['pid']==process.pid and owner['owner_id']==active['owner_id'], 'Owner does not belong to this test')
require(not (owner_path.parent/'resource-released.json').exists(), 'Too late: resources already released')
handle=win32api.OpenProcess(0x1000|0x100000|1,False,process.pid)
try:
require(str(win32process.GetProcessTimes(handle)['CreationTime'])==owner['process']['creation_time'], 'PID creation identity changed')
require(sql('SELECT state FROM verification_attempts WHERE attempt_id=?',(active['attempt_id'],))[0]['state']=='running','Attempt already finished')
# This Popen handle belongs exclusively to the disposable acceptance instance.
process.terminate();process.wait(30)
finally:handle.Close()
(output/'owner-exit.json').write_text(json.dumps(owner,ensure_ascii=False,indent=2),encoding='utf-8')
attempt_count=len(sql('SELECT attempt_id FROM verification_attempts'))
process,driver,main_window=launch()
wait(lambda:sql('SELECT resource_state FROM verification_attempts WHERE attempt_id=?',(active['attempt_id'],))[0]['resource_state']=='unknown',timeout=30)
with reader() as service: checked=verify_unknown(service,active['attempt_id'],expected_attempts=attempt_count)
require(checked['passed'],str(checked))
# New task creation must remain available while the native executor is blocked.
driver.click(driver.find(automation_id='verificationNew'))
dialog=wait(lambda:next((w for w in driver.windows() if w.window_text()=='新建校验'),None),timeout=15)
ok=next(b for b in dialog.descendants(control_type='Button') if b.window_text().replace('&','') in ('OK','确定'));driver.click(ok)
wait(lambda:len(sql('SELECT task_id FROM verification_tasks'))==2,timeout=15)
import_pairs_ui(create=False)
require(len(sql('SELECT item_id FROM verification_items'))==2*len(args.expected_items), 'Resource protection blocked input registration')
require(len(sql('SELECT attempt_id FROM verification_attempts'))==attempt_count, 'Unknown resources caused an automatic attempt')
require(not any((data/'verification/attempts'/aid).exists() for aid in pending),'Undispatched item launched native export')
window_image(main_window.handle).save(output/'resource-unknown.png')
report['checks'].append({'check_id':'C08:owner-exit-remains-unknown','state':'passed','details':checked})
require(all(_hash(Path(p))==sha for p,sha in original.items()), 'Source inputs changed')
require(sql('SELECT COUNT(*) total FROM execution_operations')[0]['total']==0, 'Replacement operations occurred')
close();report.update(passed=True,validation_scope='C08:'+args.control_scenario)
return 0
wait(lambda: finished(run_id), timeout=900)
run = run_record(run_id)
if failed_name:
failed_item = next(r['item_id'] for r in imported if r['display_name']==failed_name)
with reader() as service:
failure = service.read_item(failed_item)
require(run['members'][0]['item_id']==failed_item, 'Fault fixture did not run before the healthy projects')
require(failure['attempt_state']=='failed' and failure['verdict']=='INCOMPLETE'
and failure['attempt']['result']['resource_state']=='released', 'Invalid database did not fail and release resources as expected')
report['checks'].append({'check_id': 'C08:failed-native-item-continues', 'state': 'passed',
'item_id': failed_item, 'observed_state': failure['attempt_state'], 'observed_verdict': failure['verdict']})
report['not_run'][0] = 'C08:packaged-stop-and-uncertain-resources'
scope = dict(scope, items=[row for row in scope['items'] if row['item_id']!=failed_item])
run = dict(run, members=[row for row in run['members'] if row['item_id']!=failed_item])
name = sorted(args.expected_items)[0]
driver.click(wait(lambda: selected_cell(name)))
label = {'CONSISTENT': '一致', 'WARNING': '需关注', 'DIFFERENT': '异常'}[args.expect_verdict]
wait(lambda: driver.find(name+' · '+label, kind='Text'), timeout=60)
window_image(main_window.handle).save(output/'02-result.png')
directory = export_report(); verify_report(scope, run, directory, 'first-run', selected_only=bool(failed_name))
first_report_hashes = {str(p): _hash(p) for p in directory.iterdir() if p.is_file()}
attempts = sql('SELECT attempt_id,input_version,generation,state,result_json FROM verification_attempts ORDER BY attempt_id')
report['first_report'] = str(directory)
close(); process, driver, main_window = launch()
driver.click(wait(lambda: selected_cell(name)))
wait(lambda: driver.find(name+' · '+label, kind='Text'), timeout=60)
# Wait for startup recovery and at least one normal workspace polling interval.
time.sleep(2)
require(sql('SELECT attempt_id,input_version,generation,state,result_json FROM verification_attempts ORDER BY attempt_id')==attempts, 'Restart changed attempts or started another run')
verify_report(scope, run, directory, 'restart-readback', selected_only=bool(failed_name))
report['checks'].append({'check_id': 'C06:restart', 'state': 'passed'})
window_image(main_window.handle).save(output/'03-restart.png')
old_ids = {r['run_id'] for r in sql('SELECT run_id FROM verification_runs')}
driver.click(driver.find('重校验', kind='Button'))
rerun_id = wait(lambda: next((r['run_id'] for r in sql('SELECT run_id FROM verification_runs') if r['run_id'] not in old_ids), None))
wait(lambda: finished(rerun_id), timeout=900)
rerun = run_record(rerun_id)
subset = dict(scope, items=[r for r in scope['items'] if r['display_name']==name])
member = rerun['members'][0]
previous = next(r for r in attempts if r['attempt_id']==next(m['attempt_id'] for m in run['members'] if m['item_id']==member['item_id']))
latest = sql('SELECT * FROM verification_attempts WHERE attempt_id=?', (member['attempt_id'],))[0]
require(latest['generation']==previous['generation']+1 and latest['input_version']==previous['input_version'], 'Rerun did not create the next attempt on the same input')
require(all(_hash(Path(p))==sha for p, sha in first_report_hashes.items()), 'Rerun overwrote the first report')
require(sql('SELECT result_json FROM verification_attempts WHERE attempt_id=?', (previous['attempt_id'],))[0]['result_json']==previous['result_json'], 'Rerun changed the old result')
second_report = export_report()
verify_report(subset, rerun, second_report, 'rerun', selected_only=True)
report['checks'].append({'check_id': 'C07:rerun', 'state': 'passed'})
report['rerun_report'] = str(second_report)
require(all(_hash(Path(p))==sha for p, sha in original.items()), 'Input files changed during the loop')
require(sql('SELECT COUNT(*) total FROM execution_operations')[0]['total']==scope['replacement_operations_before'], 'Verification replayed replacement')
close(); report['passed'] = True
except Exception as error:
report.update(passed=False, reason=str(error), error=type(error).__name__)
if driver:
for n, window in enumerate(driver.windows()):
try: window_image(window.handle).save(output/f'failure-{n}.png')
except Exception: pass
if process and process.poll() is None and main_window:
try: close()
except Exception: report['process_left_running'] = process.pid
elif process and process.poll() is None:
report['process_left_running'] = process.pid
finally:
report['input_sha256'] = original
(output/'acceptance.json').write_text(json.dumps(report, ensure_ascii=False, indent=2), encoding='utf-8')
print(json.dumps(report, ensure_ascii=False))
return 0 if report.get('passed') else 1
if __name__=='__main__': raise SystemExit(main())
+138
View File
@@ -0,0 +1,138 @@
"""One real replacement on a NEW disposable copy, then the packaged verification loop."""
import argparse
from contextlib import closing
import json
import os
from pathlib import Path
import re
import shutil
import sqlite3
import subprocess
import sys
ROOT=Path(__file__).resolve().parents[1]
sys.path[:0]=[str(ROOT),str(ROOT/'src'),str(ROOT/'tools')]
from dx_productivity.trial_task_center.native_netlist import capture_project,export_netlist,_hash
from dx_productivity.trial_task_center.store import TaskStore
from dx_productivity.trial_task_center.service import TaskCenterService
from dx_productivity.trial_task_center.logging_setup import configure_logging
from dx_productivity.trial_task_center.bom_plan import write_bom_template
from verification_closed_loop import require
def main(argv=None):
parser=argparse.ArgumentParser(description=__doc__)
for name in ('source','library','exe','output'):parser.add_argument('--'+name,type=Path,required=True)
args=parser.parse_args(argv)
source,library,exe=(p.resolve(strict=True) for p in (args.source,args.library,args.exe))
output=args.output.resolve()
require(not output.exists() and not output.is_relative_to(source.parent) and not output.is_relative_to(library.parent), 'Use a new external disposable output directory')
output.mkdir(parents=True)
original={str(p):_hash(p) for p in source.parent.rglob('*') if p.is_file()}
original[str(library)]=_hash(library)
report={'scenario':'actual-saved-replacement-handoff','source':str(source),'library':str(library),
'executable':str(exe),'executable_sha256':_hash(exe), 'expected':{'refdes':'RV05','old':'4100-CA0000-T7','new':'4100-CA0000-T0','keep':'RV11'}}
process=driver=window=None
def rows(query):
with sqlite3.connect(output/'data/task-center.db') as db:
db.row_factory=sqlite3.Row
return [dict(row) for row in db.execute(query)]
try:
project_root=output/'projects'/'sample';shutil.copytree(source.parent,project_root)
project=project_root/source.name
body,count=re.subn(r'(?m)^KEY CentralLibrary "[^"\r\n]*"',lambda _:f'KEY CentralLibrary "{library.as_posix()}"',project.read_text(encoding='utf-8-sig'))
require(count==1,'Expected one explicit central library in the sample')
project.write_text(body,encoding='utf-8')
before=export_netlist(capture_project(project,output/'baseline-capture'),output/'baseline-export')
require(before['status']=='success' and before['complete'],'Baseline native export failed')
components=before['graph']['components']
target=[c for c in components.values() if c['refdes']=='RV05'];keep=[c for c in components.values() if c['refdes']=='RV11']
require(len(target)==len(keep)==1 and target[0]['attributes']['Part Number']=='4100-CA0000-T7'
and keep[0]['attributes']['Part Number']=='4100-CA0000-T7','Sample does not match fixed RV05/RV11 prerequisites')
store=TaskStore(output/'data/task-center.db')
try:
service=TaskCenterService(store,configure_logging(output/'data'),supervised=True)
task,=service.create_project_tasks(output/'projects',selected_paths=(project,))
book=write_bom_template(output/'rv05.xlsx',({'project_path':str(project),'old_part_number':'4100-CA0000-T7',
'new_part_number':'4100-CA0000-T0','refdes':'RV05','enabled':True,'sync_nc':True},))
imported=service.import_bom_drafts(task.task_id,(book,))
require(imported.deferred and imported.failed_rows==0,'Pending BOM was not accepted')
require(not rows('SELECT * FROM execution_operations'),'Preparation unexpectedly executed a replacement')
finally:store.close()
(output/'predeclared.json').write_text(json.dumps(dict(report,original_sha256=original),ensure_ascii=False,indent=2),encoding='utf-8')
import win32gui,win32con
from packaged_window_driver import WindowDriver,window_image
from accept_packaged_ui import wait
env=dict(os.environ)
for key in ('PYTHONPATH','PYTHONHOME','DX_TASK_CENTER_HOME','QT_QPA_PLATFORM'):env.pop(key,None)
process=subprocess.Popen([str(exe),'--data-root',str(output/'data')],cwd=exe.parent,env=env,
stdout=subprocess.DEVNULL,stderr=subprocess.DEVNULL,creationflags=subprocess.CREATE_NO_WINDOW)
driver=WindowDriver(process.pid,output)
def ready():
try:return driver.main()
except TimeoutError:return None
window=wait(ready,timeout=90)
task_list=wait(lambda:driver.find(automation_id='taskList'),timeout=30)
candidate=wait(lambda:next((c for c in task_list.children() if task.name in c.window_text()),None),timeout=30)
driver.click(candidate)
wait(lambda:source.name in driver.find(automation_id='boundProjectPath').window_text(),timeout=30)
button=wait(lambda:driver.find(automation_id='executeProjectTasks'),timeout=30)
wait(button.is_enabled,timeout=30);driver.click(button)
confirmation=wait(lambda:next((w for w in driver.windows() if w.window_text()=='确认顺序执行本批任务'),None),timeout=30)
yes=next(b for b in confirmation.descendants(control_type='Button') if b.window_text().replace('&','') in ('Yes','是(Y)','是'))
window_image(confirmation.handle).save(output/'execution-confirmation.png');driver.click(yes)
def execution_done():
tasks=rows('SELECT status,error_id FROM tasks')
if any(t['status']=='failed' for t in tasks):raise ValueError('Replacement failed; no automatic replay: '+str(tasks))
return tasks and all(t['status']=='completed' for t in tasks)
wait(execution_done,timeout=1200)
require(rows('SELECT COUNT(*) n FROM execution_operations')[0]['n']==1,'Expected exactly one RV05 replacement operation')
operation=rows('SELECT * FROM execution_operations')[0]
require(operation['state']=='verified','Replacement was not saved and verified')
driver.click(driver.find(automation_id='verification_navigation'))
wait(lambda:len(rows('SELECT item_id FROM verification_items'))==1,timeout=30)
item=rows('SELECT * FROM verification_items')[0]
with closing(TaskStore(output/'data/task-center.db')) as store:
from dx_productivity.trial_task_center.verification.service import VerificationService
verification=VerificationService(store,output/'data')
payload=verification.repo.revision(item['item_id'],1)['payload']
require(payload['input_state']=='ready' and payload['expectation_ref'] is not None,'Real receipt did not deliver frozen before/after/expectations')
window_image(window.handle).save(output/'automatic-handoff.png')
win32gui.PostMessage(window.handle,win32con.WM_CLOSE,0,0);require(process.wait(45)==0,'Replacement window did not close normally')
after=export_netlist(capture_project(project,output/'saved-capture'),output/'saved-export')
require(after['status']=='success' and after['complete'],'Saved readback native export failed')
actual={c['refdes']:c for c in after['graph']['components'].values() if c['refdes'] in ('RV05','RV11')}
require(actual['RV05']['attributes']['Part Number']=='4100-CA0000-T0','RV05 was not replaced')
require(actual['RV11']==keep[0],'Non-target RV11 changed')
# Freeze the saved replacement journal; the verification subprocess must leave it intact.
prior=rows('SELECT * FROM execution_operations')
command=[sys.executable,'-X','utf8',str(ROOT/'tools/accept_verification_closed_loop.py'),
'--exe',str(exe),'--before-root',str(output/'projects'),'--after-root',str(output/'projects'),
'--expected-items',item['display_name'],'--expect-verdict','WARNING','--handoff-data',str(output/'data'),
'--output',str(output/'verification-loop')]
completed=subprocess.run(command,cwd=ROOT,timeout=1200,capture_output=True)
(output/'loop-output.txt').write_bytes(completed.stdout+b'\n'+completed.stderr)
require(completed.returncode==0,'Packaged handoff loop failed; inspect loop-output.txt')
require(rows('SELECT * FROM execution_operations')==prior,'Verification changed the replacement journal')
require(len(rows('SELECT * FROM verification_items'))==1,'Repeated delivery duplicated the project')
report.update(passed=True,item_id=item['item_id'],replacement_operations=1,verification_replacement_delta=0,
rv05_replaced=True,rv11_unchanged=True,loop=str(output/'verification-loop/acceptance.json'))
except Exception as error:
report.update(passed=False,error=type(error).__name__,reason=str(error))
if driver:
for n,w in enumerate(driver.windows()):
try:window_image(w.handle).save(output/f'failure-{n}.png')
except Exception:pass
if process and process.poll() is None and window:
try:
win32gui.PostMessage(window.handle,win32con.WM_CLOSE,0,0);process.wait(45)
except Exception:report['process_left_running']=process.pid
finally:
report['originals_unchanged']=all(_hash(Path(p))==sha for p,sha in original.items())
if not report['originals_unchanged']:report['passed']=False
(output/'acceptance.json').write_text(json.dumps(report,ensure_ascii=False,indent=2),encoding='utf-8')
print(json.dumps(report,ensure_ascii=False))
return 0 if report.get('passed') else 1
if __name__=='__main__':raise SystemExit(main())
+2 -1
View File
@@ -1,4 +1,5 @@
/** Check actual shell file access separately from model behavior. */ /** Check actual shell file access separately from model behavior. */
import {executeTool} from './dsh_tool_probe.mjs';
import {mkdir,mkdtemp,writeFile} from 'node:fs/promises'; import {mkdir,mkdtemp,writeFile} from 'node:fs/promises';
import path from 'node:path'; import path from 'node:path';
import os from 'node:os'; import os from 'node:os';
@@ -17,7 +18,7 @@ try{
const agent=ctx.agents.get(sessionId); const agent=ctx.agents.get(sessionId);
const filename=path.join(process.env.DX_DSH_WORKSPACE,'input.txt'); const filename=path.join(process.env.DX_DSH_WORKSPACE,'input.txt');
await writeFile(filename,'SHELL_FILE_READ_OK'); await writeFile(filename,'SHELL_FILE_READ_OK');
const result=await ctx.tools.execute({agent,callId:crypto.randomUUID(),name:'pwsh', const result=await executeTool(ctx, {agent,callId:crypto.randomUUID(),name:'pwsh',
arguments:{description:'Read the owned shell verification file',command:`[System.IO.File]::ReadAllText('${filename.replaceAll("'","''")}')`},signal:AbortSignal.timeout(30000)}); arguments:{description:'Read the owned shell verification file',command:`[System.IO.File]::ReadAllText('${filename.replaceAll("'","''")}')`},signal:AbortSignal.timeout(30000)});
console.log(JSON.stringify({root,result})); console.log(JSON.stringify({root,result}));
}finally{await shutdown.shutdown(0);} }finally{await shutdown.shutdown(0);}
+8
View File
@@ -0,0 +1,8 @@
/** Run one tool through the installed Harness batch executor. */
export async function executeTool(ctx, {callId, name, arguments: args, ...options}) {
const {results} = await ctx.tools.execute({
...options,
calls: [{type: 'tool-call', id: callId, name, arguments: JSON.stringify(args ?? {})}],
});
return results[0].result;
}
+18
View File
@@ -0,0 +1,18 @@
"""Read an existing managed native export; never launch or write CAD."""
import argparse
import json
from pathlib import Path
import sys
sys.path.insert(0,str(Path(__file__).resolve().parents[1]/'src'))
from dx_productivity.trial_task_center.verification.pin_metadata import inspect_pin_metadata
def main():
parser=argparse.ArgumentParser();parser.add_argument('export',type=Path)
args=parser.parse_args()
result=inspect_pin_metadata(json.loads(args.export.read_text(encoding='utf-8')),evidence_root=args.export.parent)
print(json.dumps(result,ensure_ascii=False,indent=2))
return 0 if result['pins'] else 1
if __name__=='__main__':raise SystemExit(main())
+159
View File
@@ -0,0 +1,159 @@
"""Independent acceptance checks against a scope recorded BEFORE execution."""
from html.parser import HTMLParser
import json
from pathlib import Path
from dx_productivity.trial_task_center.native_netlist import _hash
from dx_productivity.trial_task_center.verification.contracts import digest
def require(condition, message):
if not condition:
raise ValueError(message)
def journal_digest(service):
with service.repo.store.transaction():
return digest([dict(row) for row in service.repo.connection.execute(
'SELECT * FROM execution_operations ORDER BY task_id,round_id,operation_key')])
def records(service, task_id):
result, cursor = [], None
while True:
page = service.read_task(task_id, cursor=cursor)
result.extend(service.read_item(row['item_id']) for row in page['items'])
cursor = page['cursor']
if cursor is None:
return result
def freeze_inputs(service, task_id, *, expected_count, historical_before=False):
rows = records(service, task_id)
require(type(expected_count) is int and expected_count>0 and len(rows)==expected_count,
'验收必须事先指定非空、准确的工程数量。')
sources, items = {}, []
for row in rows:
require(row['input_state']=='ready', '开始前输入尚未就绪。')
payload = row['payload']
if historical_before:
require(payload['expectation_ref'] is not None, '交接验收需要冻结预期清单。')
for name in ('before_ref', 'after_ref'):
capture = service.artifacts.read(payload[name], 'snapshot')
if historical_before and name=='before_ref':
# Historical before is proven by its immutable capture, not today's live bytes.
continue
for path, sha in capture['source_hashes'].items():
require(path not in sources or sources[path]==sha, '同一源文件出现不同摘要。')
require(_hash(Path(path))==sha, '源文件已偏离导入时的版本。')
sources[path] = sha
items.append({'item_id': row['item_id'], 'input_version': row['input_version'],
'input_digest': payload['payload_digest'], 'before_ref': payload['before_ref'],
'after_ref': payload['after_ref'], 'policy': payload['check_plan'], 'display_name': row['display_name']})
operations = service.repo.connection.execute('SELECT COUNT(*) FROM execution_operations').fetchone()[0]
return {'standard': 'verification-closed-loop-v1', 'task_id': task_id, 'items': items,
'source_hashes': sources, 'replacement_operations_before': operations,
'replacement_journal_digest':journal_digest(service), 'historical_before':historical_before}
class _ReportHTML(HTMLParser):
def __init__(self, text):
super().__init__(); self.mains = []; self.diagrams = 0
self.feed(text)
def handle_starttag(self, tag, attrs):
if tag=='main': self.mains.append(dict(attrs))
if tag=='svg': self.diagrams += 1
def verify_closed_loop(service, task_id, scope, run, report, *, expected_verdicts, selected_only=False):
checks = []
def check(name, action):
try:
action()
checks.append({'check_id': name, 'state': 'passed'})
except (ValueError, OSError, KeyError, TypeError) as error:
checks.append({'check_id': name, 'state': 'failed', 'reason': str(error)})
frozen = {r['item_id']: r for r in scope['items']}
members = {r['item_id']: r for r in run['members']}
report = Path(report)
current = {r['item_id']: r for r in records(service, task_id)}
if selected_only:
current = {key: row for key, row in current.items() if key in frozen}
def membership():
require(scope['task_id']==task_id and bool(frozen), '冻结任务为空或身份错误。')
require(len(frozen)==len(scope['items']) and len(members)==len(run['members']), '工程或运行成员重复。')
require(set(frozen)==set(members)==set(current)==set(expected_verdicts), '冻结范围、运行成员、当前工程或预期清单不一致。')
durable = service.repo.connection.execute('SELECT state,members_json FROM verification_runs WHERE run_id=?', (run['run_id'],)).fetchone()
require(durable is not None and durable['state']=='completed', '运行未完成。')
persisted = json.loads(durable['members_json'])
require(all(row in persisted for row in run['members']) if selected_only else persisted==run['members'],
'运行成员与持久记录不同。')
require(all(v in ('CONSISTENT', 'WARNING', 'DIFFERENT') for v in expected_verdicts.values()),
'正常完整闭环必须事先指定可核验的工程结论。')
check('C01-C02:scope', membership)
saved = {}
def report_scope():
value = json.loads((report/'task.json').read_text(encoding='utf-8'))
require(value['task_id']==task_id, '报告任务不符。')
identities = {r['item_id'] for r in value['items']}
require(len(identities)==len(value['items']) and (set(frozen)<=identities if selected_only else identities==set(frozen)), '报告工程范围不符。')
require((report/'index.html').is_file(), '缺少报告首页。')
saved.update((r['item_id'], r) for r in value['items'])
check('C04:report_scope', report_scope)
for item, original in frozen.items():
def item_result(item=item, original=original):
row, member = current[item], members[item]
require(row['input_version']==member['input_version']==original['input_version'], '输入版本不符。')
require(row['payload']['payload_digest']==original['input_digest'], '输入摘要变化。')
for key in ('before_ref', 'after_ref'):
require(row['payload'][key]==original[key], '冻结副本引用变化。')
attempt = row['attempt']
require(attempt is not None and attempt['state']=='succeeded', '尝试未成功完成,停止/失败不能算闭环。')
require(attempt['run_id']==run['run_id'] and row['attempt_id']==member['attempt_id'], '尝试不属于本次运行。')
service.validate_attempt(attempt)
result = attempt['result']; evidence = result['evidence']; binding = evidence['binding']
require(result['verdict']==expected_verdicts[item], '工程结论与预期不符。')
for key, expected in (('item_id', item), ('attempt_id', attempt['attempt_id']),
('generation', attempt['generation']), ('input_version', original['input_version']),
('input_digest', original['input_digest']), ('policy', original['policy'])):
require(result[key]==expected, '结果身份不符:'+key)
for key in ('attempt_id', 'input_version', 'input_digest'):
require(binding[key]==result[key], '图表证据绑定不符:'+key)
require(result['resource_state']=='released', '执行资源退出未确认。')
released = json.loads((service.data_root/'verification/attempts'/attempt['attempt_id']/'resource-released.json').read_text(encoding='utf-8'))
require(released['resource_state']=='released' and released['owner_id']==attempt['owner_id'], '资源退出证明不属于本次尝试。')
if result['verdict'] in ('CONSISTENT', 'WARNING'):
states = {c['check_id']: c['state'] for c in result['checks']}
require(all(states.get(key) in ('equal', 'expected_change', 'warning')
for key in original['policy']['required_checks']), '必查项缺失或未知。')
else:
require(any(c['state']=='error' for c in result['checks']), '异常结论缺少错误事实。')
published = saved[item]
require(published['input_version']==original['input_version'] and published['attempt_id']==attempt['attempt_id'],
'报告引用旧输入或旧尝试。')
require(published['attempt']['result']==result, 'JSON报告事实与当前结果不同。')
html = _ReportHTML((report/f'{item}-v{original["input_version"]}.html').read_text(encoding='utf-8'))
require(len(html.mains)==1, 'HTML报告缺少唯一绑定。')
for key, value in (('item-id', item), ('attempt-id', attempt['attempt_id']), ('generation', attempt['generation']),
('input-version', original['input_version']), ('input-digest', original['input_digest']),
('evidence-digest', evidence['digest'])):
require(html.mains[0].get('data-'+key)==str(value), 'HTML报告绑定不符:'+key)
require(not evidence['pins'] or html.diagrams>0, '有逐脚事实却没有报告接线图。')
check('C02-C04:'+item, item_result)
def unchanged():
require(bool(scope['source_hashes']), '没有冻结源文件摘要。')
require(all(_hash(Path(path))==sha for path, sha in scope['source_hashes'].items()), '源文件被改写。')
count = service.repo.connection.execute('SELECT COUNT(*) FROM execution_operations').fetchone()[0]
# Early v1 standalone fixtures recorded an implicit zero baseline.
require(count==scope.get('replacement_operations_before', 0), '校验期间出现了新的换料操作或历史记录变化。')
if 'replacement_journal_digest' in scope:
require(journal_digest(service)==scope['replacement_journal_digest'], '已有换料回执或执行代次发生变化。')
check('C05:read_only', unchanged)
return {'standard': scope['standard'], 'task_id': task_id, 'run_id': run['run_id'],
'validation_scope': 'single-run:C01-C05', 'not_run': ['C06', 'C07', 'C08'],
'passed': all(c['state']=='passed' for c in checks), 'checks': checks}
+34
View File
@@ -0,0 +1,34 @@
"""Read-only checks for expected stop and resource-unknown protection states."""
from .verification_closed_loop import require
def verify_stopped(service, run, *, unstarted):
errors = []
for member in run['members']:
attempt = service.repo.attempt(member['attempt_id'])
row = service.read_item(member['item_id'])
try:
require(attempt['state'] not in ('queued','running','publishing','stopping','interrupted'), '停止后仍有活动尝试')
require(attempt['resource_state']=='released', '停止后的资源退出未确认')
if member['attempt_id'] in unstarted:
require(attempt['state']=='cancelled' and attempt['reason']=='run_stopped_before_dispatch'
and row['status']=='waiting', '未派发项没有保持待校验')
if attempt['state']=='cancelled' and member['attempt_id'] not in unstarted:
require(row['status']=='stopped', '已开始项取消未显示已停止')
except ValueError as error: errors.append(str(error))
return {'passed':not errors, 'errors':errors, 'unstarted':sorted(unstarted)}
def verify_unknown(service, attempt_id, *, expected_attempts):
from dx_productivity.trial_task_center.verification.runner import can_start_native_export
errors = []
try:
attempt = service.repo.attempt(attempt_id)
row = service.read_item(attempt['item_id'])
require(attempt['state']=='stopping' and attempt['resource_state']=='unknown', '没有保留资源未知状态')
require(row['status'] not in ('consistent','warning','different'), '未知资源被显示成有效结论')
require(not can_start_native_export(service)['allowed'], '未知资源仍允许派发')
count=service.repo.connection.execute('SELECT COUNT(*) FROM verification_attempts').fetchone()[0]
require(count==expected_attempts, '重启后创建了额外尝试')
except ValueError as error: errors.append(str(error))
return {'passed':not errors, 'errors':errors}
+33 -6
View File
@@ -1,13 +1,19 @@
/** Real native Harness incident diagnosis; no engineering mutations or issue writes. */ /** Real native Harness incident diagnosis; no engineering mutations or issue writes. */
import {executeTool} from './dsh_tool_probe.mjs';
import assert from 'node:assert/strict'; import assert from 'node:assert/strict';
import {mkdir,writeFile} from 'node:fs/promises'; import {mkdir,mkdtemp,writeFile} from 'node:fs/promises';
import {createRequire} from 'node:module';
import path from 'node:path'; import path from 'node:path';
import {pathToFileURL} from 'node:url';
import {bootRuntime} from '../integration/dsh/start.mjs'; import {bootRuntime} from '../integration/dsh/start.mjs';
const output=path.resolve('build/dsh-auto-runtime'); const output=path.resolve('build/dsh-auto-runtime');
await mkdir(output,{recursive:true}); await mkdir(output,{recursive:true});
process.env.DX_DSH_HOME=path.join(output,'home'); const offline=process.argv.includes('--fixture');
process.env.DX_DSH_CONTEXT_FILE=path.join(output,'context.json'); const fixture=offline?await mkdtemp(path.join(output,'run-')):output;
if(offline)for(const key of ['DSH_API_KEY','DSH_API_BASE','DSH_MODEL','DX_DSH_MODELS'])delete process.env[key];
process.env.DX_DSH_HOME=path.join(fixture,'home');
process.env.DX_DSH_CONTEXT_FILE=path.join(fixture,'context.json');
await writeFile(process.env.DX_DSH_CONTEXT_FILE,JSON.stringify({task_id:'different-current-task',revision:'other',status:'draft'})); await writeFile(process.env.DX_DSH_CONTEXT_FILE,JSON.stringify({task_id:'different-current-task',revision:'other',status:'draft'}));
const snapshot={task_id:'auto-failure-fixture',revision:'incident',status:'failed',issue_code:'worker_error', const snapshot={task_id:'auto-failure-fixture',revision:'incident',status:'failed',issue_code:'worker_error',
issue:'受控诊断验收:执行前 worker 失败,没有工程写入。',rules_count:1,progress:{failed_items:1,total:1,completed:0}}; issue:'受控诊断验收:执行前 worker 失败,没有工程写入。',rules_count:1,progress:{failed_items:1,total:1,completed:0}};
@@ -31,6 +37,27 @@ process.stdout.write=function(chunk,...args){
}; };
let timer; let timer;
try{ try{
if(offline){
const require=createRequire(new URL('../integration/dsh/start.mjs',import.meta.url));
const {LlmAdapter}=await import(pathToFileURL(require.resolve('@deepseek-ai/dsh-llm')).href);
let snapshotRequested=false;
class DiagnosticFixture extends LlmAdapter{
providerInfo(provider){return {id:provider,name:'Auto runtime fixture'};}
async listModels(provider){return [{provider,id:'fixture',name:'Fixture'}];}
async *stream(options){
const readSnapshot=options.purpose!=='session-title'&&!snapshotRequested;
if(readSnapshot)snapshotRequested=true;
const block=readSnapshot
?{type:'tool-call',id:crypto.randomUUID(),name:'dx_task_snapshot',arguments:'{}'}
:{type:'text',text:'Controlled diagnosis fixture. {"action":"none"}'};
yield {type:'block-start',index:0,blockType:block.type};
yield {type:'block-end',index:0,block};
yield {type:'finish',reason:{kind:readSnapshot?'tool-calls':'stop'}};
}
}
ctx.llm.registerAdapter(['auto-runtime-fixture'],new DiagnosticFixture());
await ctx.agentDefaultModel.saveSelection({provider:'auto-runtime-fixture',model:'fixture'});
}
timer=setTimeout(()=>rejectResult(Error('native_auto_test_timeout')),135000); timer=setTimeout(()=>rejectResult(Error('native_auto_test_timeout')),135000);
ctx.emit('dx/diagnose-request',{request_id:'cli-auto-request',incident_id:'0123456789abcdef01234567', ctx.emit('dx/diagnose-request',{request_id:'cli-auto-request',incident_id:'0123456789abcdef01234567',
phase:'diagnose',snapshot,evidence:JSON.stringify(snapshot)}); phase:'diagnose',snapshot,evidence:JSON.stringify(snapshot)});
@@ -38,7 +65,7 @@ try{
const previousParent=process.env.DX_DSH_PARENT_PIPE; const previousParent=process.env.DX_DSH_PARENT_PIPE;
process.env.DX_DSH_PARENT_PIPE='1'; process.env.DX_DSH_PARENT_PIPE='1';
try{ try{
const denial=await ctx.tools.execute({callId:'automatic-creation-denial',name:'dx_task_create', const denial=await executeTool(ctx, {callId:'automatic-creation-denial',name:'dx_task_create',
arguments:{name:'Must never open a dialog'},agent:ctx.agents.get(sessionId),signal:AbortSignal.timeout(1500)}); arguments:{name:'Must never open a dialog'},agent:ctx.agents.get(sessionId),signal:AbortSignal.timeout(1500)});
assert.equal(denial.isError,true); assert.equal(denial.isError,true);
assert.equal(creationBodyRan,false,'Automatic incident must be denied before desktop request emission'); assert.equal(creationBodyRan,false,'Automatic incident must be denied before desktop request emission');
@@ -48,7 +75,7 @@ try{
['dx_task_execute',{operation:'start',task_ids:['auto-failure-fixture']}], ['dx_task_execute',{operation:'start',task_ids:['auto-failure-fixture']}],
['dx_task_operations',{operation:'history'}], ['dx_task_operations',{operation:'history'}],
]){ ]){
const result=await ctx.tools.execute({callId:'automatic-denial-'+name,name,arguments:args, const result=await executeTool(ctx, {callId:'automatic-denial-'+name,name,arguments:args,
agent:ctx.agents.get(sessionId),signal:AbortSignal.timeout(1500)}); agent:ctx.agents.get(sessionId),signal:AbortSignal.timeout(1500)});
assert.equal(result.isError,true); assert.equal(result.isError,true);
assert.equal(creationBodyRan,false); assert.equal(creationBodyRan,false);
@@ -65,7 +92,7 @@ try{
assert.ok(!text.includes('different-current-task')); assert.ok(!text.includes('different-current-task'));
const report={status:'passed',session_id:value.session_id,reply:value.reply, const report={status:'passed',session_id:value.session_id,reply:value.reply,
incidentBoundSnapshot:true,automaticTaskCreationDenied:true,toolResults:tools}; incidentBoundSnapshot:true,automaticTaskCreationDenied:true,toolResults:tools};
await writeFile(path.join(output,'report.json'),JSON.stringify(report,null,2)); await writeFile(path.join(fixture,'report.json'),JSON.stringify(report,null,2));
original(JSON.stringify(report)+'\n'); original(JSON.stringify(report)+'\n');
}finally{ }finally{
clearTimeout(timer); clearTimeout(timer);
+2 -1
View File
@@ -1,4 +1,5 @@
/** Exercise actual Harness file tools against owned folders and ZIP archives. */ /** Exercise actual Harness file tools against owned folders and ZIP archives. */
import {executeTool} from './dsh_tool_probe.mjs';
import assert from 'node:assert/strict'; import assert from 'node:assert/strict';
import {mkdir,mkdtemp,writeFile,readFile,readdir} from 'node:fs/promises'; import {mkdir,mkdtemp,writeFile,readFile,readdir} from 'node:fs/promises';
import path from 'node:path'; import path from 'node:path';
@@ -24,7 +25,7 @@ try{
const names=ctx.tools.schemas(agent).map(x=>x.name); const names=ctx.tools.schemas(agent).map(x=>x.name);
for(const name of ['read','read_image','write','edit','glob','grep','working_directory','extract_zip']) for(const name of ['read','read_image','write','edit','glob','grep','working_directory','extract_zip'])
assert.ok(names.includes(name),'Missing file capability: '+name); assert.ok(names.includes(name),'Missing file capability: '+name);
const call=async(name,args)=>ctx.tools.execute({name,arguments:args,callId:crypto.randomUUID(),agent,signal:AbortSignal.timeout(20000)}); const call=async(name,args)=>executeTool(ctx, {name,arguments:args,callId:crypto.randomUUID(),agent,signal:AbortSignal.timeout(20000)});
const ok=async(name,args)=>{ const ok=async(name,args)=>{
const result=await call(name,args);assert.equal(result.isError,false,name+': '+JSON.stringify(result));return result; const result=await call(name,args);assert.equal(result.isError,false,name+': '+JSON.stringify(result));return result;
}; };
+2 -1
View File
@@ -1,4 +1,5 @@
/** Real Harness, two processes: automatic diagnosis must stay isolated after restart. */ /** Real Harness, two processes: automatic diagnosis must stay isolated after restart. */
import {executeTool} from './dsh_tool_probe.mjs';
import assert from 'node:assert/strict'; import assert from 'node:assert/strict';
import {mkdir,mkdtemp,writeFile,readFile,unlink,symlink} from 'node:fs/promises'; import {mkdir,mkdtemp,writeFile,readFile,unlink,symlink} from 'node:fs/promises';
import path from 'node:path'; import path from 'node:path';
@@ -96,7 +97,7 @@ if(!phase){
const resumed=await ctx.sessionController.resolveAgent(sessionId); const resumed=await ctx.sessionController.resolveAgent(sessionId);
assert.ok(resumed.agent,JSON.stringify(resumed.error)); assert.ok(resumed.agent,JSON.stringify(resumed.error));
const agent=resumed.agent; const agent=resumed.agent;
const call=(owner,name,args={})=>ctx.tools.execute({name,arguments:args,callId:crypto.randomUUID(),agent:owner,signal:AbortSignal.timeout(5000)}); const call=(owner,name,args={})=>executeTool(ctx, {name,arguments:args,callId:crypto.randomUUID(),agent:owner,signal:AbortSignal.timeout(5000)});
const snapshot=await call(agent,'dx_task_snapshot'); const snapshot=await call(agent,'dx_task_snapshot');
assert.equal(snapshot.isError,false,JSON.stringify(snapshot)); assert.equal(snapshot.isError,false,JSON.stringify(snapshot));
assert.equal(snapshot.value.task_id,'incident-original','historical diagnosis must not read the current task'); assert.equal(snapshot.value.task_id,'incident-original','historical diagnosis must not read the current task');
+5 -4
View File
@@ -12,8 +12,9 @@ export async function verifyModelSettings(c, output) {
}); });
await new Promise(resolve=>server.listen(0,'127.0.0.1',resolve)); await new Promise(resolve=>server.listen(0,'127.0.0.1',resolve));
const endpoint=`http://127.0.0.1:${server.address().port}/v1`; const endpoint=`http://127.0.0.1:${server.address().port}/v1`;
const visible=selector=>`[...document.querySelectorAll(${JSON.stringify(selector)})].find(e=>e.getBoundingClientRect().width>0)`; const rendered=`e.getBoundingClientRect().width>0&&!e.closest('details:not([open])')`;
const button=text=>`[...document.querySelectorAll('button')].find(e=>e.getBoundingClientRect().width>0&&e.textContent.trim()===${JSON.stringify(text)})`; const visible=selector=>`[...document.querySelectorAll(${JSON.stringify(selector)})].find(e=>${rendered})`;
const button=text=>`[...document.querySelectorAll('button')].find(e=>${rendered}&&e.textContent.trim()===${JSON.stringify(text)})`;
async function wait(expression){ async function wait(expression){
const end=Date.now()+20000; const end=Date.now()+20000;
while(Date.now()<end){if(await c.evaluate(expression))return;await new Promise(r=>setTimeout(r,100));} while(Date.now()<end){if(await c.evaluate(expression))return;await new Promise(r=>setTimeout(r,100));}
@@ -49,7 +50,7 @@ export async function verifyModelSettings(c, output) {
const candidate=`[...document.querySelectorAll('[role="dialog"] label')].find(e=>e.textContent.includes('issue16-fixture-model'))?.querySelector('input[type="checkbox"]')`; const candidate=`[...document.querySelectorAll('[role="dialog"] label')].find(e=>e.textContent.includes('issue16-fixture-model'))?.querySelector('input[type="checkbox"]')`;
if(!await c.evaluate(`(${candidate})?.checked`))await c.click(candidate); if(!await c.evaluate(`(${candidate})?.checked`))await c.click(candidate);
assert.equal(await c.evaluate(`(${candidate})?.checked`),true); assert.equal(await c.evaluate(`(${candidate})?.checked`),true);
await c.click(button('添加所选')); await c.click(button('更新列表'));
await wait(`!![...document.querySelectorAll('input')].find(x=>x.value==='issue16-fixture-model')`); await wait(`!![...document.querySelectorAll('input')].find(x=>x.value==='issue16-fixture-model')`);
await c.screenshot(path.join(output,'custom-model-discovery.png')); await c.screenshot(path.join(output,'custom-model-discovery.png'));
await c.click(button('创建提供商')); await c.click(button('创建提供商'));
@@ -58,7 +59,7 @@ export async function verifyModelSettings(c, output) {
// Reopen the real editor to read committed fields, not the submitted draft. // Reopen the real editor to read committed fields, not the submitted draft.
await c.click(`[...document.querySelectorAll('li')].find(e=>e.textContent.includes('issue16-fixture'))?.querySelector('button')`); await c.click(`[...document.querySelectorAll('li')].find(e=>e.textContent.includes('issue16-fixture'))?.querySelector('button')`);
await wait(`document.body.innerText.includes('自定义设置')`); await wait(`document.body.innerText.includes('自定义设置')`);
await c.click(`[...document.querySelectorAll('summary')].find(e=>e.textContent.includes('自定义设置'))`); await c.click(`[...document.querySelectorAll('summary')].find(e=>e.textContent.includes('自定义设置')&&e.closest('details').querySelector('input[aria-label="API 地址"]')?.value===${JSON.stringify(endpoint)})`);
await wait(`!![...document.querySelectorAll('input')].find(x=>x.value==='issue16-fixture-model')`); await wait(`!![...document.querySelectorAll('input')].find(x=>x.value==='issue16-fixture-model')`);
await c.screenshot(path.join(output,'custom-model-persisted.png')); await c.screenshot(path.join(output,'custom-model-persisted.png'));
return {status:'passed',provider:'issue16-fixture',model:'issue16-fixture-model',requests, return {status:'passed',provider:'issue16-fixture',model:'issue16-fixture-model',requests,
+2 -1
View File
@@ -1,4 +1,5 @@
/** Compare the embedded assistant with the installed official Standard preset. */ /** Compare the embedded assistant with the installed official Standard preset. */
import {executeTool} from './dsh_tool_probe.mjs';
import assert from 'node:assert/strict'; import assert from 'node:assert/strict';
import {mkdir,mkdtemp,writeFile,readFile} from 'node:fs/promises'; import {mkdir,mkdtemp,writeFile,readFile} from 'node:fs/promises';
import path from 'node:path'; import path from 'node:path';
@@ -29,7 +30,7 @@ try{
assert.deepEqual(names(embedded),names(native),'Existing dx-task sessions must retain the full native tool catalog'); assert.deepEqual(names(embedded),names(native),'Existing dx-task sessions must retain the full native tool catalog');
for(const tool of ['read','write','edit','pwsh','get_goal','create_goal','update_goal','todo_write','subagent']) for(const tool of ['read','write','edit','pwsh','get_goal','create_goal','update_goal','todo_write','subagent'])
assert.ok(names(embedded).includes(tool),'Missing native capability: '+tool); assert.ok(names(embedded).includes(tool),'Missing native capability: '+tool);
const call=(name,args)=>ctx.tools.execute({name,arguments:args,callId:crypto.randomUUID(),agent:embedded,signal:AbortSignal.timeout(20000)}); const call=(name,args)=>executeTool(ctx, {name,arguments:args,callId:crypto.randomUUID(),agent:embedded,signal:AbortSignal.timeout(20000)});
const filename=path.join(process.env.DX_DSH_WORKSPACE,'native-write.txt'); const filename=path.join(process.env.DX_DSH_WORKSPACE,'native-write.txt');
const written=await call('write',{file_path:filename,content:'native file operations'}); const written=await call('write',{file_path:filename,content:'native file operations'});
assert.equal(written.isError,false,JSON.stringify(written)); assert.equal(written.isError,false,JSON.stringify(written));
+14 -8
View File
@@ -1,20 +1,26 @@
/** Exercise the real official runtime and policy pipeline without CAD or a model. */ /** Exercise the real official runtime and policy pipeline without CAD or a model. */
import {executeTool} from './dsh_tool_probe.mjs';
import assert from 'node:assert/strict'; import assert from 'node:assert/strict';
import {mkdir,writeFile} from 'node:fs/promises'; import {mkdir,writeFile} from 'node:fs/promises';
import path from 'node:path'; import path from 'node:path';
import {fileURLToPath,pathToFileURL} from 'node:url'; import {fileURLToPath,pathToFileURL} from 'node:url';
import {createRequire} from 'node:module'; import {createRequire} from 'node:module';
import {bootRuntime,TASK_TOOLS} from '../integration/dsh/start.mjs';
const repo=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..'); const repo=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
const output=path.join(repo,'build/dsh-native-cli-verification'); const runtime=path.resolve(process.argv[2]??path.join(repo,'integration/dsh'));
const {bootRuntime,TASK_TOOLS,VERSION}=await import(pathToFileURL(path.join(runtime,'start.mjs')).href);
const output=path.resolve(process.argv[3]??path.join(repo,'build/dsh-native-cli-verification'));
await mkdir(output,{recursive:true}); await mkdir(output,{recursive:true});
delete process.env.DX_DSH_PARENT_PIPE;
if(process.argv[2]){
for(const key of ['DSH_API_KEY','DSH_API_BASE','DSH_MODEL','DX_DSH_MODELS','DSH_PERMISSION_MODE'])delete process.env[key];
}
process.env.DX_DSH_HOME=path.join(output,'home'); process.env.DX_DSH_HOME=path.join(output,'home');
process.env.DX_DSH_CONTEXT_FILE=path.join(output,'context.json'); process.env.DX_DSH_CONTEXT_FILE=path.join(output,'context.json');
await writeFile(process.env.DX_DSH_CONTEXT_FILE,JSON.stringify({task_id:'cli-verification',status:'paused', await writeFile(process.env.DX_DSH_CONTEXT_FILE,JSON.stringify({task_id:'cli-verification',status:'paused',
revision:'cli-revision',rules_count:2,progress:{},issue:'',issue_code:'',events:[]})); revision:'cli-revision',rules_count:2,progress:{},issue:'',issue_code:'',events:[]}));
const {ctx,shutdown}=await bootRuntime({announce:false}); const {ctx,shutdown}=await bootRuntime({announce:false});
const report={}; const report={version:VERSION};
try { try {
const schemas=ctx.tools.schemas(); const schemas=ctx.tools.schemas();
report.tools=schemas.map(x=>x.name); report.tools=schemas.map(x=>x.name);
@@ -26,10 +32,10 @@ try {
report.configuredModels=(await ctx.llm.listModels('dx')).map(model=>model.id); report.configuredModels=(await ctx.llm.listModels('dx')).map(model=>model.id);
assert.ok(report.configuredModels.includes(process.env.DSH_MODEL)); assert.ok(report.configuredModels.includes(process.env.DSH_MODEL));
} }
const snapshot=await ctx.tools.execute({callId:'verify-read',name:'dx_task_snapshot',arguments:{},signal:new AbortController().signal}); const snapshot=await executeTool(ctx, {callId:'verify-read',name:'dx_task_snapshot',arguments:{},signal:new AbortController().signal});
assert.equal(snapshot.isError,false,JSON.stringify(snapshot)); assert.equal(snapshot.isError,false,JSON.stringify(snapshot));
report.snapshotRead=true; report.snapshotRead=true;
const desktopOnly=await ctx.tools.execute({callId:'verify-desktop-only',name:'dx_task_create',arguments:{name:'CLI must not mutate'},signal:new AbortController().signal}); const desktopOnly=await executeTool(ctx, {callId:'verify-desktop-only',name:'dx_task_create',arguments:{name:'CLI must not mutate'},signal:new AbortController().signal});
assert.equal(desktopOnly.isError,true); assert.equal(desktopOnly.isError,true);
report.creationRequiresDesktopConfirmation=true; report.creationRequiresDesktopConfirmation=true;
for(const [name,args] of [ for(const [name,args] of [
@@ -38,16 +44,16 @@ try {
['dx_task_execute',{operation:'start',task_ids:['fixture']}], ['dx_task_execute',{operation:'start',task_ids:['fixture']}],
['dx_task_operations',{operation:'history'}], ['dx_task_operations',{operation:'history'}],
]){ ]){
const result=await ctx.tools.execute({callId:'desktop-only-'+name,name,arguments:args,signal:AbortSignal.timeout(2000)}); const result=await executeTool(ctx, {callId:'desktop-only-'+name,name,arguments:args,signal:AbortSignal.timeout(2000)});
assert.equal(result.isError,true,name+' requires parent desktop'); assert.equal(result.isError,true,name+' requires parent desktop');
} }
report.lifecycleRequiresDesktop=true; report.lifecycleRequiresDesktop=true;
const require=createRequire(path.join(repo,'integration/dsh/package.json')); const require=createRequire(path.join(runtime,'package.json'));
const {defineTool}=await import(pathToFileURL(require.resolve('@deepseek-ai/dsh-tools')).href); const {defineTool}=await import(pathToFileURL(require.resolve('@deepseek-ai/dsh-tools')).href);
let bodyRan=false; let bodyRan=false;
const release=ctx.tools.register(defineTool({name:'forbidden_probe',description:'Never executes',parameters:{}, const release=ctx.tools.register(defineTool({name:'forbidden_probe',description:'Never executes',parameters:{},
output:{schema:{type:'boolean'},render:()=>[{type:'text',text:'probe'}]},execute:async()=>{bodyRan=true;return true;}})); output:{schema:{type:'boolean'},render:()=>[{type:'text',text:'probe'}]},execute:async()=>{bodyRan=true;return true;}}));
const extension=await ctx.tools.execute({callId:'verify-extension',name:'forbidden_probe',arguments:{},signal:new AbortController().signal}); const extension=await executeTool(ctx, {callId:'verify-extension',name:'forbidden_probe',arguments:{},signal:new AbortController().signal});
release(); release();
assert.equal(extension.isError,false); assert.equal(extension.isError,false);
assert.equal(bodyRan,true); assert.equal(bodyRan,true);
+2 -1
View File
@@ -1,4 +1,5 @@
/** PR18 #197: no silently omitted names, bounded workers, real cancellation. */ /** PR18 #197: no silently omitted names, bounded workers, real cancellation. */
import {executeTool} from './dsh_tool_probe.mjs';
import assert from 'node:assert/strict'; import assert from 'node:assert/strict';
import {mkdir,mkdtemp,writeFile,readdir,readFile} from 'node:fs/promises'; import {mkdir,mkdtemp,writeFile,readdir,readFile} from 'node:fs/promises';
import {spawnSync} from 'node:child_process'; import {spawnSync} from 'node:child_process';
@@ -25,7 +26,7 @@ process.env.DX_DSH_HOME=path.join(root,'home');process.env.DX_DSH_CONTEXT_FILE=p
await writeFile(process.env.DX_DSH_CONTEXT_FILE,'{"task_id":"zip-review","revision":"zip-review","status":"observe"}'); await writeFile(process.env.DX_DSH_CONTEXT_FILE,'{"task_id":"zip-review","revision":"zip-review","status":"observe"}');
const {ctx,shutdown}=await bootRuntime({announce:false}); const {ctx,shutdown}=await bootRuntime({announce:false});
try{ try{
const call=(file,signal=AbortSignal.timeout(30000))=>ctx.tools.execute({name:'extract_zip', const call=(file,signal=AbortSignal.timeout(30000))=>executeTool(ctx, {name:'extract_zip',
arguments:{file_path:path.join(root,file),output_directory:root},callId:crypto.randomUUID(),signal}); arguments:{file_path:path.join(root,file),output_directory:root},callId:crypto.randomUUID(),signal});
const before=await readdir(root); const before=await readdir(root);
for(const file of ['proto.zip','proto-bad.zip']){ for(const file of ['proto.zip','proto-bad.zip']){
+85
View File
@@ -0,0 +1,85 @@
"""Acceptance through public verification interfaces; fixture/native evidence are labelled."""
import argparse
import json
from pathlib import Path
import shutil
import sys
import time
from threading import Event
sys.path.insert(0,str(Path(__file__).resolve().parents[1]/'src'))
from dx_productivity.trial_task_center.store import TaskStore
from dx_productivity.trial_task_center.verification.service import VerificationService
from dx_productivity.trial_task_center import native_netlist,netlist_verification
from dx_productivity.trial_task_center.batch_resources import write_record
from verification_closed_loop import freeze_inputs,verify_closed_loop
def main(argv=None):
parser=argparse.ArgumentParser(description=__doc__)
group=parser.add_mutually_exclusive_group(required=True)
group.add_argument('--fixture-root',type=Path)
group.add_argument('--native-before',type=Path)
parser.add_argument('--native-after',type=Path);parser.add_argument('--output',type=Path,required=True)
parser.add_argument('--expect-verdict',choices=('CONSISTENT','WARNING','DIFFERENT'),default='CONSISTENT',
help='Expected conclusion fixed before running; defaults to CONSISTENT')
args=parser.parse_args(argv)
if args.native_before and not args.native_after:parser.error('--native-after is required')
root=args.output.resolve()
if root.exists():parser.error('output must be a new directory')
root.mkdir(parents=True)
store=TaskStore(root/'tasks.db');service=VerificationService(store,root/'data')
original=netlist_verification._export_saved_capture
try:
if args.fixture_root:
fixture=args.fixture_root.resolve();before=next((fixture/'before').rglob('*.prj'));after=next((fixture/'after').rglob('*.prj'))
def controlled(capture,output,*,stop_event):
phase='before' if capture['project']==str(before.resolve()) else 'after'
source=fixture/phase;output.mkdir(parents=True,exist_ok=True)
for name in ('effective.txt','design.kyn'):shutil.copyfile(source/name,output/name)
graph=native_netlist.read_graph(output/'effective.txt',output/'design.kyn')
return {'status':'success','complete':True,'graph':graph,'capture':capture,
'outputs':{'effective':str(output/'effective.txt'),'keyin':str(output/'design.kyn')},
'runs':[],'evidence_kind':'controlled-format-fixture'}
netlist_verification._export_saved_capture=controlled
evidence_kind='controlled-format-fixture'
else:before,after=args.native_before.resolve(),args.native_after.resolve();evidence_kind='native-read-only'
# Capture verifies source stability. Record live bytes to prove no mutation as well.
from dx_productivity.trial_task_center.native_inventory import _project_options
paths=[before,after,Path(_project_options(before)[3]),Path(_project_options(after)[3])]
initial={str(p):native_netlist._hash(p) for p in paths}
task=service.create_task('独立校验验收',request_id='acceptance-create')['task_id']
accepted=service.import_pair(task,before,after,request_id='acceptance-import',stop_event=Event())
if not accepted['accepted']:raise ValueError('No input accepted')
frozen=freeze_inputs(service,task,expected_count=1)
expectations={row['item_id']:args.expect_verdict for row in frozen['items']}
write_record(root/'frozen-scope.json',dict(frozen,expected_verdicts=expectations,evidence_kind=evidence_kind))
run=service.start(task,request_id='acceptance-run')
deadline=time.monotonic()+900
while service.busy:
if time.monotonic()>deadline:raise TimeoutError('Native acceptance timed out')
time.sleep(.05)
current=service.read_task(task);report=service.export_task(task,root/'reports',request_id='acceptance-report')
unchanged=all(native_netlist._hash(Path(p))==sha for p,sha in initial.items())
closed_loop=verify_closed_loop(service,task,frozen,run,report,expected_verdicts=expectations)
write_record(root/'closed-loop.json',closed_loop)
summary={'evidence_kind':evidence_kind,'task_id':task,'run':run,'summary':current['summary'],
'input_sha256':initial,'inputs_unchanged':unchanged,'report':str(report),
'policy':'verification-v1','closed_loop':closed_loop,
'replacement_operations':store._connection.execute('SELECT COUNT(*) FROM execution_operations').fetchone()[0]}
write_record(root/'acceptance.json',summary);print(json.dumps(summary,ensure_ascii=False))
if not unchanged:return 4
if not closed_loop['passed']:return 3
return 0
except Exception as error:
write_record(root/'failure.json',{'error':type(error).__name__,'reason':str(error)})
print(str(error),file=sys.stderr);return 1
finally:
service.begin_shutdown()
deadline=time.monotonic()+10
while service.busy and time.monotonic()<deadline:time.sleep(.05)
netlist_verification._export_saved_capture=original
if not service.busy:store.close()
if __name__=='__main__':raise SystemExit(main())