AI Flow

@@ -4,7 +4,7 @@ version = 4  [[package]] name = "adom-aiflow"-version = "0.2.2"+version = "0.2.3" dependencies = [  "aiflow-analyze",  "aiflow-board",@@ -25,7 +25,7 @@ dependencies = [  [[package]] name = "aiflow-analyze"-version = "0.2.2"+version = "0.2.3" dependencies = [  "aiflow-board",  "serde",@@ -35,7 +35,7 @@ dependencies = [  [[package]] name = "aiflow-board"-version = "0.2.2"+version = "0.2.3" dependencies = [  "roxmltree",  "serde",@@ -44,7 +44,7 @@ dependencies = [  [[package]] name = "aiflow-bridge"-version = "0.2.2"+version = "0.2.3" dependencies = [  "aiflow-board",  "serde",@@ -53,7 +53,7 @@ dependencies = [  [[package]] name = "aiflow-copper"-version = "0.2.2"+version = "0.2.3" dependencies = [  "aiflow-board",  "aiflow-grid",@@ -63,7 +63,7 @@ dependencies = [  [[package]] name = "aiflow-grid"-version = "0.2.2"+version = "0.2.3" dependencies = [  "aiflow-board",  "serde",@@ -72,7 +72,7 @@ dependencies = [  [[package]] name = "aiflow-place"-version = "0.2.2"+version = "0.2.3" dependencies = [  "aiflow-board",  "serde",@@ -81,7 +81,7 @@ dependencies = [  [[package]] name = "aiflow-pours"-version = "0.2.2"+version = "0.2.3" dependencies = [  "aiflow-board",  "aiflow-copper",@@ -91,7 +91,7 @@ dependencies = [  [[package]] name = "aiflow-router"-version = "0.2.2"+version = "0.2.3" dependencies = [  "aiflow-board",  "aiflow-grid",@@ -101,7 +101,7 @@ dependencies = [  [[package]] name = "aiflow-run"-version = "0.2.2"+version = "0.2.3" dependencies = [  "serde",  "serde_json",

@@ -177,7 +177,7 @@ wrong part at its component page, not just on this board.  The clock starts at the prompt even when there is no board yet. -- **`intake --prompt-time <UTC of the prompt> [--brief <file>] [--requirements requirements.json] [--target <box>] [--page <owner/slug>]`** opens the run with the `intake` step and no board. Pre-board steps are steps like any other: `step sourcing`, `step design`, `step simulation`, `step schematic`; every command is a turn charged to the step, and with `--target` each records a clip of the desktop until a PCB editor is open. `start --board ... --spec ...` on the same `--run` attaches the board: same clock, same ledger, the steps before the board stay on the page.+- **`intake --prompt-time <UTC of the prompt> [--brief <file>] [--requirements requirements.json] [--target <box>] [--page <owner/slug>]`** opens the run with the `intake` step and no board. Pre-board steps are steps like any other: `step sourcing`, `step design`, `step simulation`, `step schematic`; every command is a turn charged to the step, and with `--target` each films the tool's own window when the step works in it, else Hydrogen with the run's dashboard, else the AI's terminal window, or records a skip when nothing meaningful is on screen. `start --board ... --spec ...` on the same `--run` attaches the board: same clock, same ledger, the steps before the board stay on the page. - **`sourcing check --bom design/bom.csv [--profile fab|jlcpcb] [--qty N] [--requirements requirements.json]`** gates the BOM. The profile comes from the spec or the requirements (`sourcing.profile` or `fab.target`), `fab` by default. Every electrical reference on the board needs a row with an MPN (contacts and pads the footprint does not exclude from the BOM take a `no part` row; the diff lists missing and extra references). On `fab` every row is from Mouser or Adom stock and no row is an LCSC/JLCPCB part; on `jlcpcb` every row carries its LCSC number. The stock column carries its check date (`stock_checked_2026-09-29`, or a `stock_date` column); under twice the build quantity is a thin-stock warning. Before the board it checks the BOM alone; run it again after `start --board`, because `finish` wants the diff. - **`evidence add --kind calcs|simulation|vendor-model --file <json|md> [--note ...]`** records the design record in the run and the ledger with its sha256 (a copy lands in `<run>/evidence/`). A simulation result that says it fails (a top-level `"pass": false`, or a `"checks"` row `{"name","value","limit","pass"}` that fails) is refused. Vendor PSpice/LTspice runs belong to the separately published adom/adom-spice-skillpack; `--kind vendor-model` records their result. - **`finish`** also refuses without a passed sourcing check against the board when the spec or the requirements name a sourcing profile, and without the evidence kinds the spec lists in `"requireEvidence": ["calcs", "simulation"]`.@@ -231,6 +231,16 @@ Deterministic checks that refuse, each an OK/ERROR with hints:  The judgement is in these skills, which this tool executes: kicad-place-route-loop (place for routability, the levers when routing cannot close, go back to placement), kicad-copper-pours (which nets get a pour and which never do, priorities, the Kelvin pair, the preflight lessons), and the tool-neutral eda-engineering skillpack (eda-end-to-end-layout, eda-kelvin-current-sense, eda-copper-ablation, eda-pour-planning-measurement, eda-thermal-bottlenecks, eda-multilayer-current-review). +## Checks from an outside engineer's trial, skill paths in hints, clips that film something (0.2.3)++- **Schematic.** `schematic check` (and `netlist check`) also checks custom symbols' polarity drawings against their pin names, active-device pin types (no `passive` amplifier inputs, outputs or power pins) and readability (labels instead of wires, text over pins, items outside the border). `finish` requires the pass (outcome `schematic-check`). Skill aiflow-schematic-to-board.+- **Parts and datasheet numbers.** `sourcing check` wants an `mpn_url` per purchased row: the exact MPN's own page (an error with `sourcing.requireExactMpnEvidence`). `evidence add --kind calcs` warns on datasheet numbers without `kind` typ/min/max and on worst-case math resting on a typical value; `--kind simulation` warns when the requirements name a full-scale input and no case is at full scale. Skills aiflow-sourcing, aiflow-circuit-design, aiflow-simulate.+- **Courtyards and bodies are errors.** `place check`, `gate` and `finish` require a courtyard on every footprint with a pad and refuse overlapping courtyards or part bodies whatever the project's DRC severities say; `spec.bodies` gives connectors and large parts their datasheet size. `route` replaces staircases with 45 degree runs and reports vertices per net; `gate` warns about staircases left in the copper. Skill aiflow-power-layout.+- **The board that ships.** `export` and `finish` check that every copper zone of the saved board has filled polygons and that each poured copper layer's Gerber carries region (G36) data. `step-export` keeps the native STEP export's warnings apart from its exit status; geometry warnings block `board-glb copper` and `deliver` until reviewed (`step-export --ack --why`). Skill aiflow-molecule.+- **Honest messages.** `gate`, `export`, `finish` and `deliver` list what was verified (schematic parity, connectivity, ERC, DRC, symbols, courtyards, bodies, fills in the saved board and in the Gerbers) as yes, no or not known. Never tell the human the board is ready to fabricate unless every item is yes, and advise a human review even then.+- **Skill files by path.** `step <name>` names each companion skill of the step by absolute path (`~/.claude/skills/<skill>/SKILL.md` and the package's own copy under `adom_modules/adom/adom-aiflow/skills/`), and every ERROR names the skill file and section that describe the failing command's input. An engine without a skill loader opens those files instead of reading the binary. The step map is `skills` in `flows/board.json`.+- **Clips.** Pre-board steps film Hydrogen's dashboard, the AI's window or the tool's own window, or record a skip with the reason; a take that died is restarted on the step's current window with the gap recorded; a truncated MP4 (no moov atom) is flagged when it stops. Skill aiflow-live-clips.+ ## Companion skills (load the one for the step you are on)  AI Flow's binary is the instrument, the gates and the hands; the judgement for each step lives in a skill. Load it when the step begins:@@ -292,6 +302,20 @@ The gates read the board and the tools' own output, so a file written to look li - **Thermal counts the board's vias (0.1.96).** `analyze thermal` counts the vias on each tab net in the saved board as well as the routing plan, so thermal vias landed after routing count once the board is saved. - **Budgets are fixed once placement begins (0.1.95).** The spec's budgets and physical models (`loads`, `hot` watts and `tabNet`, `hotMaxRiseC`/`maxRiseC`, `switchNodeMaxLengthMm`, `wideNets`/`midNets`, `fab` and copper weights, via/drill power, package cooling) freeze at placement in `<run>/spec-budgets.json`. When a check fails, change the board: more copper, vias, a tighter placement. Every gate refuses a spec whose budgets moved since. Layout keys (`pours`, `thermalVias`, fixed coordinates, `planeUnder`) stay editable. If a budget really is wrong (a misread datasheet value), `adom-aiflow spec-amend --why "<datasheet page and what was misread>"` records the change; amendments are listed in the run ledger and the finish summary. +## Spec intent checked by the binary (0.2.3)++### Assigned-pin decoupling (`spec.decoupling`)++Declare each decoupling cap with the supply pin it serves: `"decoupling": [{"cap": "C6", "pin": "U1.39", "returnPins": ["U1.38"], "maxLengthMm": 3.0, "maxVias": 0, "severity": "warning"}]`. Only `cap` and `pin` are required; the cap's supply pad is its pad on the pin's net (`capPad` to name it) and its ground pad the pad on its other net (`gndPad`). `route` lays each pair's direct connection before any rail distribution and plane stubs, keeps it through rip-up, and reports per pair whether it routed directly and why not. After `route` and in `gate`, `decoupling-<stage>.json` measures the copper path cap pad to assigned pin along the net's real copper (length, vias, other pads it passes), the nearest same-net pin of that part and the straight pad distance, and flags a path that detours through the rail. The budgets are this board's own; there is no default. A finding is a warning or, with `"severity": "error"`, fails `route`, `gate` and `finish`. A ground return is `copper` or `fill` only by connectivity; a return joined only by planned pours or by fills that are not a native refill is labelled `unverified` or `fill-unverified`, never measured as a straight line. Decoupling budgets freeze with the other budgets at placement. DRC 0/0 does not prove this intent.++### Placement intent (`spec.placement`)++`placement.proximity: [{"ref": "D2", "nearRef": "U4", "pin": "5", "maxMm": 5}]` (pad edge to pad edge), `placement.cluster: [{"name": "buck", "refs": ["U4", "C7", "L1"], "radiusMm": 6}]` or `"region": "<name in placement.regions>" | [[x, y], ...]`, and `placement.anchor: [{"ref": "U4", "cluster": "buck"}]`. These are intent for you, the placer: the binary verifies, it does not move parts. `place check` and `place verify` fail with the distance and the pin named (`proximity D2 near U4 pin 5: 8.00 mm pad edge to pad edge (D2.1 to U4.5), over maxMm 5`), write `placement-intent.json` and record the outcome `finish` reads. A cluster radius is measured between pad-box centres, from the anchor when there is one. `place pack` honours an anchor only in the simple case: a member with no wish of its own follows the anchor's wish at its present offset (turned with the anchor when the anchor's wish names one rotation); it prints the intent verdicts on the packed spots as advice.++### Design-rule card at `start`++`start` reads the spec's track widths, clearances, via pads, drills, edge clearance, copper thickness and load currents, checks each against the fab lane's range (generic: trace 0.1 to 2 mm, drill 0.2 mm and up, copper 12 to 210 um; raised by the minimums in the `.kicad_dru` beside the board) and prints a `WARNING:` line for each value outside it. The same card, drawn to scale beside the board outline, appears on the run dashboard (`rulesCard` in `<run>/timeline/presentation.json`, also `<run>/rules-card.json`). It is read-only and changes no gate: fix a unit slip in the spec before placement.+ ## Component coverage before placement  The early `components` step audits component identity, library coverage and model quality before `models` and placement. Run `plan` to read its ordered sourcing workflow. Inventory every reference on the actual board and schematic, and track exact manufacturer/MPN, supplier code, package and required ratings. Reuse exact wiki component pages first; check their assets rather than assuming a page contains a complete CAD bundle. Use `adom-parts-search` next and manufacturer/distributor sites for gaps. Pup is the browser fallback for JavaScript or blocked curl/fetch downloads; read its skill for current commands.@@ -312,7 +336,7 @@ MPN marking is on by default for ICs: every IC's model carries its laser-etched  1. **Let the planner place it.** `adom-aiflow-etch --in part.step --mpn MPN --out part-etched.step --footprint part.kicad_mod` (`adom-aiflow-etch plan part.step --footprint ... --mpn ...` shows the plan JSON first). Never hand-pick an axis, a rotation or an `/outline` rot. 2. **The rule it enforces.** The mark runs along the longest usable dimension of the marking face: chip R/C/L along the body, in the band between the metal end caps; ICs parallel to the pin rows (a SOT-23-6 along its 2.9 mm length; two pin rows are read from the footprint pads, and a pin-1 dimple only shortens the band, it never turns the mark across the rows); LEDs on the front long side wall, window clear. As large as fits the band minus 12 % / 15 % margins, one line, two equal lines only when both are larger. Upright and left to right in the standard pose: pin 1 / pad 1 lower left seen from the top (two-terminal: pad 1 on the left; polarised parts follow pin 1 / cathode); the iso outline shows pin 1 (pins 1 to 3) toward the viewer. A flat light mark, coplanar with the face, in `Adom.Chip` / `Adom.LaserEtch`; never raised or recessed lettering. The top face is found by position (the flat face at the top of the part), so models that store it with a reversed normal, like KiCad's stock SOIC and TSSOP, work as they are.-3. **The outline's name is the same mark.** `adom-aiflow-etch outline part.step --etched part-etched.step --footprint part.kicad_mod` (adom-chip-thumbnailer does the same): same face, same direction, same place.+3. **The outline's name is the same mark.** `adom-aiflow-etch outline part.step --etched part-etched.step --footprint part.kicad_mod` (adom-chip-thumbnailer does the same): same face, same direction, same place, same line split. The outline reads the split from the etch's own `<etched>.mark-plan.json` (so a forced `--lines "A|B"` carries over); pass `--lines` or `--plan` when that file is elsewhere. `check --outline` FAILs an outline whose text lines differ from the mark. 4. **Run the gate and look before you report.** `adom-aiflow-etch check part-etched.step --outline <named.svg>` must say PASS (it runs after every etch too). Open `<etched>.check.png` (top view in the standard pose, band in green, reading arrow) and the outline at 320 px. A FAIL's `Hint:` lines say exactly what to rerun. The verdict is judged in the normalized pose (footprint frame after the stand-up turns), not the mounted pose on a board; `<etched>.check.json` `frame` records the turns from the source and to the outputs, and whether model up (`--up`) and the face (`--face`) were supplied or inferred. 5. **Overrides are exceptions.** `--along x|y` only keeps a polarity stripe or printed band clear; the tool warns when it puts text across the short side and the gate still judges against the planner (text across an IC's pin rows always FAILs). A vendor model that already prints its marking stays as it is (the tool refuses unless `--over-vendor-mark`). Everything runs on the shared STEP service with plain python3: nothing to install (`--legacy` is the old OpenCascade path). @@ -375,7 +399,7 @@ Custom manual stages default to AI. `take custom-stage=ai` or `take custom-stage  A pour's area or presence is not proof of current capacity or acceptable temperature. `analyze current` and `analyze thermal` now require both the heuristic checks and a matching Adom Fields solve. Run `adom-fields analyze --board <current saved board> --spec <run spec> --out <run>/fields`, then `analyze current --fields <run>/fields/fields.json` and `analyze thermal --fields <run>/fields/fields.json`. Fields records SHA-256 identities for the exact inputs. Changed boards or specs invalidate the result; unsolved loaded nets or hot parts are not a pass. `finish` rechecks the evidence. This is an engineering screen under the solver's documented assumptions, not junction-temperature certification. -Placement checks compare individual native DRC findings with the baseline, not just their counts. Conservative courtyard bounding boxes guide packing but do not override native courtyard checks. Project `.kicad_pro` and `.kicad_dru` constraints follow board snapshots. When present, they require a native `kicad-cli` (optionally set `ADOM_AIFLOW_KICAD_CLI`); the single-file headless service must not silently discard them. In a container without native KiCad, `ADOM_AIFLOW_KICAD_CLI=adom-aiflow-kicad-cli-remote` (installed with AI Flow) runs `pcb drc` on a desktop's KiCad through Adom Bridge (`KICAD_REMOTE_TARGET` names the desktop); a stock distro kicad-cli that lacks `pcb drc --refill-zones` is ignored. The gate refills zones natively when it has a native kicad-cli, so zone fills are KiCad's own, not the raster estimate, and the current and thermal analyses read the board's own copper when the routing plan leaves nets out (an adopted, already-routed board). Manufacturing-rule warnings, including hole spacing, remain blocking.+Placement checks compare individual native DRC findings with the baseline, not just their counts. Conservative courtyard bounding boxes guide packing but do not override native courtyard checks. Project `.kicad_pro` and `.kicad_dru` constraints follow board snapshots. When present, they require a native `kicad-cli` (optionally set `ADOM_AIFLOW_KICAD_CLI`); the single-file headless service must not silently discard them. In a container without native KiCad, `ADOM_AIFLOW_KICAD_CLI=adom-aiflow-kicad-cli-remote` (installed with AI Flow) runs `pcb drc`, `sch erc`, `sch export netlist` and `pcb export gerbers|drill|pos` on a desktop's KiCad through Adom Bridge (`KICAD_REMOTE_TARGET` names the desktop; Windows or Linux, detected from the bridge; on Linux the job folder is `~/.adom-aiflow-kicad`, removed after each call; relative output paths are fine); a stock distro kicad-cli that lacks `pcb drc --refill-zones` is ignored. The gate refills zones natively when it has a native kicad-cli, so zone fills are KiCad's own, not the raster estimate, and the current and thermal analyses read the board's own copper when the routing plan leaves nets out (an adopted, already-routed board). Manufacturing-rule warnings, including hole spacing, remain blocking.  Component library footage: keep the full `library-tour` separate. A reviewed five-second `library-overview` artifact may enter compose, with `--review` binding the exact selected STEP/GLB variants, current board, clip and native readback/screenshot. See [the review contract](https://wiki.adom.inc/adom/adom-aiflow/files/docs/library-overview-review.md). Never claim native model matching from a tour alone. @@ -444,7 +468,19 @@ When multiple physical lands share one logical pin number, use the reviewed Fiel  ### Existing pours after board adoption -Use `verify-pours --plan <reviewed-plan.json>` for read-only validation of already present saved pours against a reconciled explicit plan. Read `docs/existing-pours.md`. It records input-bound verification, not creation ownership; never replay a native mutation simply to repair dashboard evidence. A stale plan must fail. Native DRC, measurement and electrical/thermal gates remain required.+`verify-pours --plan <plan.json>` compares saved, filled zones with an explicit plan without landing them. Read `docs/existing-pours.md`. A failure names, per zone, the closest board zone and every field that differs: geometry, net, layer, priority, clearance, min thickness, pad connection, thermal gap, thermal bridge and island removal. `spec.pours` (and so the plan `pour` writes) can carry `connection` (thermal, solid or none), `thermalGap`, `thermalBridge`, `islandRemoval` (always, never or area) and `islandAreaMin`, so zones written outside the flow can be described exactly. `land pours` refuses pad connection none and island removal other than always before any bridge call, because the KiCad bridge cannot land them faithfully.++The plan needs provenance: the plan `pour` wrote (its hash is recorded in the run), or a reviewed plan recorded with `verify-pours --plan <file> --record-plan` before the board's zones changed. Any other plan, such as one written from the board after the zones changed, is refused unless `--why "<reason>"` explains why it is independent of the board; the why is stored with the proof. Never write a plan from the board to make the check pass.++`verify-pours --plan <plan> --adopt --why "<reason>"` takes ownership of the matched zones: their saved IDs join the run's owned zones (so a later `land pours` may replace them), the grant is logged in `zoneAdoptions`, and the outcome is `mode: adopted-existing`. `finish`, `status` and the summary report the pours as adopted, not landed. Native DRC, measurement and current/thermal gates remain required.++### Silk-only adoption keeps copper evidence++`adopt-board` compares the copper fingerprint of the current and adopted boards: tracks, vias, zones with settings, pads with geometry, net and drill, footprint placement, outline, stackup, nets and project rules, but not silkscreen, fab, courtyard, text or 3D models. When it is unchanged, gate, land, measure, the analyses, place verify and the Fields report are kept, with a carry record holding both board hashes and the fingerprint. Every board-hash check accepts the older board only through that record, re-verified from both snapshot files. Any copper change, an unreadable rule file or a non-KiCad board invalidates the evidence as before. The silkscreen and export proofs are always dropped; record them again.++### Holes with no copper++A drilled pad with no copper layer (an NPTH that lists only `*.Mask`, such as a USB-C shell peg) is read as a board hole, not a pad. The router, the stitching and heatsink via planners and the pour masks keep clearance from it; pad, net, BOM and netlist consumers never see it.  ### Artifact evidence is copied without overwriting @@ -479,3 +515,11 @@ After board adoption, `rules check` records a fresh input-bound result when chec ### Rebind native saved files after adoption  Read `docs/native-board-binding.md` when the adopted board differs from the desktop checkpoint. Use `bind-remote-board` with the exact intended desktop path; `models` refuses mismatched board or required rule-sidecar bytes. This does not validate the live editor or waive engineering gates. Preserve older checkpoint files.++### Reviewed current peaks and board-face sinks++`analyze current --ack [email protected]|NET@x,y --why "..."` records a reviewed part-limited density peak (net, place, peak, reason, ai thread). It covers only that pad or 0.5 mm around the point, keeps the number reported, shows in `finish`, and expires when the copper fingerprint (the one copper carry-over uses) or the spec changes. A whole-net acknowledgement is refused. Read `docs/current-peak-acknowledgements.md`.++`spec.boardSink` declares a pedestal or plate on a board face for named tabless parts: a conservative via, mask, interface and sink series estimate in `analyze thermal`, or the same-input Fields solve with the named conducting block. Both record their assumption in the run summary and `finish`; other parts keep the still-air check. Read `docs/board-sink.md`.++`outline check` reads only Edge.Cuts: board items and footprint Edge.Cuts items placed in board coordinates.

@@ -0,0 +1,299 @@+//! Clips that film something, and clips that survive (issue #59).+//!+//! 1. The camera for a step before the board. An AI that does the pre-board steps (intake, rules,+//!    sourcing, design, simulation, schematic...) with its own scripts leaves nothing on screen in+//!    the EDA tool, so a clip of the editor window (or of a cached handle) is one flat colour. Those+//!    steps film, in order: the tool's own window when the step really works in it (the schematic+//!    editor for `schematic`, the library tool for `library`), else Hydrogen with the run's+//!    dashboard (the timeline moves at every command), else the AI's terminal or IDE window. When+//!    none is on the test box the clip is skipped and the skip is recorded with its reason.+//! 2. A clip whose recording died (the window closed, the bridge restarted, the take failed). The+//!    command that comes next asks the recorder about the running take (at most once every+//!    WATCH_SECONDS); a dead take is stopped and pulled for what it holds, and a new take starts on+//!    the step's current window. The capture records the gap (from, to, why) so the clip page, the+//!    composed video and `deliver` say so, instead of a truncated file found only at deliver.+//! 3. A truncated MP4 (no moov atom: the recorder never finalised it) is named at the clip's stop+//!    by ffprobe, not later.++use serde_json::{json, Value};++/// Steps whose work has no board window: their camera is chosen by `preboard_camera`.+pub fn preboard_step(step: &str) -> bool {+    crate::preboard::PREBOARD_STEPS.contains(&step) || matches!(step, "parts" | "project-page" | "library")+}++/// Steps where the tool's own window shows the work (when the tool has one open).+pub fn tool_step(step: &str) -> bool { matches!(step, "schematic" | "library") }++/// What a step's clip films.+#[derive(Debug, Clone, PartialEq)]+pub enum Camera {+    Window { hwnd: i64, what: String },+    Skip(String),+}++/// The windows of a `desktop_list_windows` reply (the reply as is, or wrapped in `output`).+pub fn windows_of(reply: &Value) -> Vec<Value> {+    let out = reply.get("output").and_then(|o| o.as_str()).and_then(|s| serde_json::from_str::<Value>(s).ok()).unwrap_or(reply.clone());+    out["data"]["windows"].as_array().or(out["windows"].as_array()).cloned().unwrap_or_default()+}++/// Terminal and IDE programs an AI engine runs in on Windows.+const TERMINALS: &[&str] = &["windowsterminal.exe", "code.exe", "cursor.exe", "antigravity.exe", "codex.exe", "claude.exe", "windsurf.exe", "pwsh.exe", "powershell.exe", "cmd.exe", "wezterm-gui.exe", "alacritty.exe", "conemu64.exe", "mintty.exe"];++fn image(w: &Value) -> String { w["image"].as_str().unwrap_or("").to_ascii_lowercase() }+fn visible(w: &Value) -> bool { w["kind"].as_str().map(|k| k == "normal").unwrap_or(true) && w["minimized"] != true && w["hwnd"].as_i64().is_some() }++/// The camera for a pre-board step: the tool window when given, else Hydrogen, else the AI's+/// terminal (one whose title names the engine first), else a skip with its reason.+pub fn preboard_camera(step: &str, windows: &[Value], engine: &str, tool: Option<(i64, String)>) -> Camera {+    if let Some((hwnd, what)) = tool { return Camera::Window { hwnd, what }; }+    if let Some(h) = windows.iter().filter(|w| visible(w)).find(|w| image(w) == "hydrogen.exe").and_then(|w| w["hwnd"].as_i64()) {+        return Camera::Window { hwnd: h, what: "Hydrogen with the run's dashboard".into() };+    }+    let eng = engine.to_ascii_lowercase();+    let first_word = eng.split(|c: char| !c.is_ascii_alphanumeric()).find(|s| s.len() >= 3).unwrap_or("").to_string();+    let terms: Vec<&Value> = windows.iter().filter(|w| visible(w) && TERMINALS.contains(&image(w).as_str())).collect();+    let named = terms.iter().find(|w| !first_word.is_empty() && (w["title"].as_str().unwrap_or("").to_ascii_lowercase().contains(&first_word) || image(w).contains(&first_word)));+    if let Some(w) = named.or(terms.first()) {+        return Camera::Window { hwnd: w["hwnd"].as_i64().unwrap_or(0), what: format!("the AI's window ({})", w["title"].as_str().filter(|t| !t.is_empty()).unwrap_or(w["image"].as_str().unwrap_or("terminal"))) };+    }+    Camera::Skip(format!("nothing meaningful on screen for the {step} step: no Hydrogen, terminal or tool window on the test box (the work is in scripts); the clip is skipped rather than filming an idle window"))+}++/// The schematic or library window of the run's tool for a tool step: KiCad's schematic editor+/// (any editor that is not the PCB editor) from `kicad_window_info`, else the tool's main window.+pub fn tool_window(step: &str, eda_id: &str, kicad_info: &Value, main: Option<i64>) -> Option<(i64, String)> {+    if !tool_step(step) { return None; }+    if eda_id == "kicad" {+        let d = kicad_info.get("data").cloned().unwrap_or(kicad_info.clone());+        let eds = d["editors"].as_array().cloned().unwrap_or_default();+        let want = |w: &Value| { let k = w["kind"].as_str().unwrap_or("").to_ascii_lowercase(); if step == "schematic" { k.contains("sch") } else { k.contains("symbol") || k.contains("footprint") || k.contains("lib") } };+        return eds.iter().find(|w| want(w)).and_then(|w| w["hwnd"].as_i64().map(|h| (h, format!("KiCad's {}", w["kind"].as_str().unwrap_or("editor").replace('_', " ")))));+    }+    main.map(|h| (h, format!("the {eda_id} window")))+}++/// Ask the live desktop: the camera for a pre-board step.+pub fn choose_preboard(br: &aiflow_bridge::Bridge, cam: &dyn aiflow_bridge::eda::Eda, step: &str, engine: &str) -> Camera {+    let tx = |v: &str, a: &Value| br.raw_call(v, a);+    let tool = if tool_step(step) {+        let info = if cam.id() == "kicad" { br.raw_call("kicad_window_info", &json!({})) } else { Value::Null };+        let main = if cam.id() == "kicad" { None } else { cam.main_window(&tx) };+        tool_window(step, cam.id(), &info, main)+    } else { None };+    let windows = windows_of(&br.raw_call("desktop_list_windows", &json!({})));+    preboard_camera(step, &windows, engine, tool)+}++// -- dead takes -------------------------------------------------------------------------------++/// Seconds between two health checks of the running take.+pub const WATCH_SECONDS: u64 = 45;++/// Why a take is dead, from `desktop_record_status {recordingId}`; None when it runs (or when the+/// answer says nothing either way: a transport error is not a dead take).+pub fn dead_reason(status: &Value) -> Option<String> {+    if status.is_null() || status["status"] == "parse_error" || status["status"] == "error" { return None; }+    let code = status["errorCode"].as_str().unwrap_or("").to_ascii_lowercase();+    let text = format!("{} {}", status["error"].as_str().unwrap_or(""), status["message"].as_str().unwrap_or("")).to_ascii_lowercase();+    if status["success"] == false {+        if code.contains("not_found") || code.contains("unknown") || code.contains("no_recording") || text.contains("not found") || text.contains("no such recording") || text.contains("unknown recording") || text.contains("nothing running") {+            return Some("the recorder no longer knows this take (the bridge restarted, or the take was dropped)".into());+        }+        return None;+    }+    let d = status.get("data").filter(|d| d.is_object()).unwrap_or(status);+    let state = d["state"].as_str().unwrap_or("").to_ascii_lowercase();+    if state == "failed" { return Some(format!("the take failed: {}", d["finaliseError"].as_str().or(d["error"].as_str()).unwrap_or("no reason given"))); }+    if d["captureItemClosed"] == true { return Some("the captured window or display went away (window closed, display change or graphics reset)".into()); }+    if d["autoStopped"] == true { return Some("the take hit its maximum duration and stopped".into()); }+    if matches!(state.as_str(), "stopped" | "finalised" | "finalized") && d["stillRunning"] != true { return Some(format!("the take is {state}, though the run never stopped it")); }+    None+}++/// Whether the health check is due (the last check is in `clipWatch.lastCheck`, seconds).+pub fn due(data: &Value, now: u64) -> bool {+    data["clipWatch"]["lastCheck"].as_u64().map(|t| now.saturating_sub(t) >= WATCH_SECONDS).unwrap_or(true)+}++/// The capture entry of a take restarted after `dead` (the capture that died) on `hwnd`.+pub fn resumed_entry(dead: &Value, rid: &str, hwnd: i64, what: &str, died_at: &str, now: &str, why: &str) -> Value {+    json!({"recordingId": rid, "start": now, "kind": "window", "hwnd": hwnd, "camera": what,+        "step": dead["step"], "visit": dead["visit"], "back": dead["back"], "why": dead["why"],+        "part": dead["part"].as_u64().unwrap_or(1) + 1,+        "resumedAfterGap": {"from": died_at, "to": now, "why": why}})+}++/// The running take of the run: (its capture index, recording id).+pub fn running(data: &Value) -> Option<(usize, String)> {+    let caps = data["captures"].as_array()?;+    let pos = caps.iter().rposition(|c| c.get("recordingId").is_some() && c.get("file").is_none())?;+    Some((pos, caps[pos]["recordingId"].as_str()?.to_string()))+}++/// Check the running take; when it died, collect what it holds and restart it on the step's+/// current window. Returns a line for the AI, None when nothing happened.+pub fn watch(r: &mut aiflow_run::Run, br: &aiflow_bridge::Bridge, dir: &std::path::Path) -> Option<String> {+    let now_s = aiflow_run::parse(&aiflow_run::now()).unwrap_or(0);+    if !due(&r.data, now_s) { return None; }+    let (pos, rid) = running(&r.data)?;+    r.data["clipWatch"] = json!({"lastCheck": now_s});+    let status = br.raw_call("desktop_record_status", &json!({"recordingId": rid}));+    let Some(why) = dead_reason(&status) else { return None };+    let died_at = aiflow_run::now();+    let cap = r.data["captures"][pos].clone();+    let step = cap["step"].as_str().unwrap_or("").to_string();+    let tag = format!("{}-{}", step, cap["visit"].as_u64().unwrap_or(1));+    // collect what the dead take holds (it may be truncated: the stop's own check says so)+    let save_to = std::fs::canonicalize(dir).unwrap_or(dir.to_path_buf()).display().to_string();+    let stop = br.record_stop(&rid, &save_to);+    let local = crate::settle_clip_stop(r, pos, &stop, dir);+    r.data["captures"][pos]["died"] = json!({"at": died_at, "why": why});+    r.log("clip-stop", crate::clip_stop_event(json!({"step": tag, "recordingId": rid, "by": "clip watch: the take died", "why": why}), &stop));+    if let Some(f) = local.filter(|f| std::path::Path::new(f).is_file()) { crate::clip_artifacts(r, &json!(tag), &f, 10); }+    // the step's current window, looked up live (a cached handle is what died)+    let eda = aiflow_bridge::eda::active();+    let camera = if preboard_step(&step) {+        choose_preboard(br, &*eda, &step, r.data["engine"].as_str().unwrap_or(""))+    } else {+        let tx = |v: &str, a: &Value| br.raw_call(v, a);+        match eda.camera_window(&tx, &step, None) { Some(h) => Camera::Window { hwnd: h, what: format!("{}'s window", eda.name()) }, None => Camera::Skip(format!("no {} window open for {step} any more", eda.name())) }+    };+    let line = match camera {+        Camera::Window { hwnd, what } => match br.record_window_start(hwnd, &format!("aiflow step {step} (resumed after the take died)")) {+            Ok(new_rid) => {+                let t = aiflow_run::now();+                r.data["captures"].as_array_mut().map(|a| a.push(resumed_entry(&cap, &new_rid, hwnd, &what, &died_at, &t, &why)));+                r.log("clip-gap", json!({"step": tag, "from": died_at, "to": t, "why": why, "recordingId": new_rid, "window": what}));+                r.mark(&format!("clip {tag} died ({why}); restarted on {what}"));+                format!("clip {tag} died ({why}); it was stopped and pulled, and a new take started on {what}; the gap is recorded")+            }+            Err(rep) => {+                r.log("clip-gap", json!({"step": tag, "from": died_at, "to": Value::Null, "why": why, "restart": rep["errorCode"]}));+                format!("clip {tag} died ({why}); restarting it failed ({}): `capture start` once the window is back", rep["errorCode"].as_str().unwrap_or("?"))+            }+        },+        Camera::Skip(s) => {+            r.log("clip-gap", json!({"step": tag, "from": died_at, "to": Value::Null, "why": why, "restart": s}));+            format!("clip {tag} died ({why}); not restarted: {s}")+        }+    };+    Some(line)+}++// -- truncated files --------------------------------------------------------------------------++/// The verdict from ffprobe's run on a clip: Some(why) when the MP4 is truncated (no moov atom, or+/// ffprobe cannot read the container at all).+pub fn truncation_verdict(ffprobe_ok: bool, stderr: &str, duration: Option<f64>) -> Option<String> {+    let e = stderr.to_ascii_lowercase();+    if e.contains("moov atom not found") { return Some("truncated: the MP4 has no moov atom (the recording died before it was finalised)".into()); }+    if !ffprobe_ok && (e.contains("invalid data found") || e.contains("end of file")) { return Some(format!("truncated: ffprobe cannot read the container ({})", stderr.lines().next().unwrap_or("").trim())); }+    if ffprobe_ok && duration.is_none() && e.contains("error") { return Some("truncated: no duration in the container".into()); }+    None+}++/// Run ffprobe on a clip: Some(why) when it is truncated. A missing ffprobe is not a verdict.+pub fn truncated(file: &str) -> Option<String> {+    let o = std::process::Command::new("ffprobe").args(["-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0", file]).output().ok()?;+    let d = String::from_utf8_lossy(&o.stdout).trim().parse::<f64>().ok();+    truncation_verdict(o.status.success(), &String::from_utf8_lossy(&o.stderr), d)+}++#[cfg(test)]+mod tests {+    use super::*;++    fn wins() -> Vec<Value> {+        vec![+            json!({"hwnd": 11, "image": "kicad.exe", "kind": "normal", "title": "pcbnew"}),+            json!({"hwnd": 22, "image": "WindowsTerminal.exe", "kind": "normal", "title": "PowerShell"}),+            json!({"hwnd": 33, "image": "Antigravity.exe", "kind": "normal", "title": "board - Antigravity"}),+            json!({"hwnd": 44, "image": "hydrogen.exe", "kind": "normal", "title": "Hydrogen"}),+        ]+    }++    #[test]+    fn preboard_steps_film_hydrogen_then_the_ai_window_never_an_idle_editor() {+        assert!(preboard_step("sourcing") && preboard_step("schematic") && preboard_step("parts") && !preboard_step("placement"));+        assert_eq!(preboard_camera("design", &wins(), "antigravity", None), Camera::Window { hwnd: 44, what: "Hydrogen with the run's dashboard".into() });+        // no Hydrogen: the engine's own window before any other terminal+        let no_h: Vec<Value> = wins().into_iter().filter(|w| w["hwnd"] != 44).collect();+        match preboard_camera("design", &no_h, "Antigravity (Gemini 4 Argon)", None) { Camera::Window { hwnd, .. } => assert_eq!(hwnd, 33), c => panic!("{c:?}") }+        match preboard_camera("design", &no_h, "codex", None) { Camera::Window { hwnd, .. } => assert_eq!(hwnd, 22), c => panic!("{c:?}") }+        // only the PCB editor (nothing of the step's work on it): skipped with the reason+        let only_kicad = vec![wins()[0].clone()];+        match preboard_camera("simulation", &only_kicad, "claude", None) { Camera::Skip(why) => assert!(why.contains("simulation") && why.contains("skipped"), "{why}"), c => panic!("{c:?}") }+        // a tool step with the tool's window open films the tool+        assert_eq!(preboard_camera("schematic", &wins(), "claude", Some((55, "KiCad's schematic editor".into()))), Camera::Window { hwnd: 55, what: "KiCad's schematic editor".into() });+        // minimised windows do not count; the wrapped reply form is read+        let wrapped = json!({"output": json!({"data": {"windows": [{"hwnd": 44, "image": "hydrogen.exe", "kind": "normal", "minimized": true}]}}).to_string()});+        assert!(matches!(preboard_camera("rules", &windows_of(&wrapped), "claude", None), Camera::Skip(_)));+    }++    #[test]+    fn the_schematic_editor_is_the_tool_window_of_the_schematic_step() {+        let info = json!({"data": {"editors": [{"kind": "pcb_editor", "hwnd": 1}, {"kind": "schematic_editor", "hwnd": 2}]}});+        assert_eq!(tool_window("schematic", "kicad", &info, None), Some((2, "KiCad's schematic editor".into())));+        assert_eq!(tool_window("schematic", "kicad", &json!({"data": {"editors": [{"kind": "pcb_editor", "hwnd": 1}]}}), None), None);+        assert_eq!(tool_window("design", "kicad", &info, None), None);+        assert_eq!(tool_window("library", "fusion", &Value::Null, Some(9)), Some((9, "the fusion window".into())));+    }++    #[test]+    fn dead_takes_are_told_from_running_and_unknown_answers() {+        assert!(dead_reason(&json!({"success": true, "state": "recording", "stillRunning": true, "lastFrameAgoMs": 30000})).is_none());+        assert!(dead_reason(&json!({"success": true, "data": {"state": "recording", "captureItemClosed": true}})).unwrap().contains("went away"));+        assert!(dead_reason(&json!({"success": false, "errorCode": "recording_not_found"})).unwrap().contains("no longer knows"));+        assert!(dead_reason(&json!({"success": false, "error": "No such recording: abc"})).is_some());+        assert!(dead_reason(&json!({"success": true, "state": "failed", "finaliseError": "sink error"})).unwrap().contains("sink error"));+        assert!(dead_reason(&json!({"success": true, "autoStopped": true})).is_some());+        // a transport failure or an unrelated refusal is not a dead take+        assert!(dead_reason(&json!({"status": "parse_error", "raw": ""})).is_none());+        assert!(dead_reason(&json!({"success": false, "errorCode": "permission_denied"})).is_none());+        assert!(dead_reason(&Value::Null).is_none());+    }++    #[test]+    fn the_watch_is_throttled_and_a_resumed_take_carries_its_gap() {+        assert!(due(&json!({}), 1000));+        assert!(!due(&json!({"clipWatch": {"lastCheck": 990}}), 1000));+        assert!(due(&json!({"clipWatch": {"lastCheck": 900}}), 1000));+        let dead = json!({"recordingId": "a", "step": "silkscreen", "visit": 2, "back": true, "why": "labels", "file": "x.mp4"});+        let e = resumed_entry(&dead, "b", 77, "KiCad's window", "2026-10-15T10:00:00Z", "2026-10-15T10:01:00Z", "the bridge restarted");+        assert_eq!((e["step"].as_str(), e["visit"].as_u64(), e["part"].as_u64()), (Some("silkscreen"), Some(2), Some(2)));+        assert_eq!(e["resumedAfterGap"]["why"], "the bridge restarted");+        assert!(e.get("file").is_none(), "a resumed take is running: no file yet");+        let data = json!({"captures": [dead, e]});+        assert_eq!(running(&data), Some((1, "b".to_string())));+    }++    #[test]+    fn a_missing_moov_atom_is_a_truncated_clip() {+        assert!(truncation_verdict(false, "[mov,mp4,m4a,3gp,3g2,mj2 @ 0x55] moov atom not found\nx.mp4: Invalid data found when processing input", None).unwrap().contains("moov"));+        assert!(truncation_verdict(false, "x.mp4: Invalid data found when processing input", None).unwrap().starts_with("truncated"));+        assert!(truncation_verdict(true, "", Some(12.5)).is_none());+        // a file that is not there is not called truncated (the pull check says so)+        assert!(truncation_verdict(false, "x.mp4: No such file or directory", None).is_none());+    }++    #[cfg(unix)]+    #[test]+    fn ffprobe_reads_a_cut_off_mp4_as_truncated() {+        if std::process::Command::new("ffmpeg").arg("-version").output().is_err() { return; }+        let dir = std::env::temp_dir().join(format!("aiflow-trunc-{}", std::process::id()));+        std::fs::create_dir_all(&dir).unwrap();+        let f = dir.join("c.mp4");+        let ok = std::process::Command::new("ffmpeg").args(["-v", "error", "-y", "-f", "lavfi", "-i", "testsrc=size=160x90:rate=10", "-t", "2", "-pix_fmt", "yuv420p", f.to_str().unwrap()]).status().map(|s| s.success()).unwrap_or(false);+        if !ok { return; }+        assert!(truncated(f.to_str().unwrap()).is_none());+        // cut the file before its moov atom (written at the end by default): the shape of a take that died+        let bytes = std::fs::read(&f).unwrap();+        let cut = dir.join("cut.mp4");+        let moov = bytes.windows(4).position(|w| w == b"moov").unwrap_or(bytes.len() / 2);+        std::fs::write(&cut, &bytes[..moov.saturating_sub(4)]).unwrap();+        assert!(truncated(cut.to_str().unwrap()).is_some());+        let _ = std::fs::remove_dir_all(&dir);+    }+}

@@ -0,0 +1,456 @@+//! Copper fingerprint and carried-over copper evidence (issue #48 item 4).+//!+//! `adopt-board` normally voids the copper evidence (gate, land, measure, analyses, the Fields+//! report) because that evidence is bound to the whole board file. A silkscreen-only rework does+//! not change any copper, so re-solving Fields for it wastes the run's time. The copper fingerprint+//! is a canonical hash of everything electrically or thermally relevant in a `.kicad_pcb` plus its+//! project rule sidecars; text, silkscreen, fab, courtyard and 3D model references are left out.+//!+//! When the adopted board's fingerprint equals the current board's, the evidence is kept and a+//! carry record (both whole-board hashes, both files, the fingerprint) is stored in the run. A check+//! that binds evidence to a whole-board hash accepts an older hash only through `carried_from`,+//! which re-reads both snapshot files and recomputes their hashes and fingerprints; a missing,+//! edited or mismatching file refuses. Anything uncertain (an EAGLE source, an unreadable rule+//! file, a parse error) has no fingerprint, so the evidence is invalidated as before.+use aiflow_board::sx::{self, Item, Node};+use aiflow_run::Run;+use serde_json::{json, Value};+use sha2::{Digest, Sha256};+use std::path::Path;++pub const SCHEME: &str = "copper-fp-v1";++/// Outcomes bound to the board's silkscreen: re-done after any adoption that changes the file.+pub const SILK_OUTCOMES: [&str; 2] = ["silkscreen", "export"];++pub fn sha256_file(p: &Path) -> Result<String, String> {+    std::fs::read(p).map(|b| format!("{:x}", Sha256::digest(b))).map_err(|e| format!("{}: {e}", p.display()))+}++/// Footprint children and top-level items that never carry copper, whatever their layer.+const NEVER_COPPER: [&str; 13] = ["model", "descr", "tags", "path", "sheetname", "sheetfile", "embedded_fonts", "embedded_files", "group", "generator", "generator_version", "paper", "title_block"];+/// Items whose relevance depends on their layer (copper or the board edge count).+const LAYERED: [&str; 7] = ["property", "dimension", "image", "target", "table", "barcode", "text"];++fn atoms(n: &Node) -> impl Iterator<Item = &str> {+    n.items.iter().filter_map(|it| if let Item::Atom { text, .. } = it { Some(text.as_str()) } else { None })+}++/// The layers an item names (`(layer ..)` and `(layers ..)`); None when it names none.+fn item_layers(n: &Node) -> Option<Vec<String>> {+    let mut out: Vec<String> = Vec::new();+    if let Some(l) = n.find("layer") { out.extend(atoms(l).take(1).map(str::to_string)); }+    if let Some(l) = n.find("layers") { out.extend(atoms(l).map(str::to_string)); }+    if out.is_empty() { None } else { Some(out) }+}++fn electrical_layer(l: &str) -> bool { l.ends_with(".Cu") || l == "Edge.Cuts" }++/// Graphic or text-like items count only on copper or the board edge; one with no layer counts.+fn layered_relevant(n: &Node) -> bool {+    match item_layers(n) { Some(ls) => ls.iter().any(|l| electrical_layer(l)), None => true }+}++fn graphic(tag: &str) -> bool { tag.starts_with("gr_") || tag.starts_with("fp_") || LAYERED.contains(&tag) }++fn canon(n: &Node) -> Value {+    let mut v = vec![json!(n.tag)];+    for it in &n.items {+        match it { Item::Atom { text, .. } => v.push(json!(text)), Item::Node(c) => v.push(canon(c)) }+    }+    Value::Array(v)+}++fn canon_without(n: &Node, drop: &[&str]) -> Value {+    let mut v = vec![json!(n.tag)];+    for it in &n.items {+        match it {+            Item::Atom { text, .. } => v.push(json!(text)),+            Item::Node(c) if drop.contains(&c.tag.as_str()) => {}+            Item::Node(c) => v.push(canon(c)),+        }+    }+    Value::Array(v)+}++fn footprint(fp: &Node) -> Value {+    let mut parts: Vec<String> = Vec::new();+    for it in &fp.items {+        let Item::Node(c) = it else { continue };+        let t = c.tag.as_str();+        if NEVER_COPPER.contains(&t) { continue; }+        if graphic(t) && !layered_relevant(c) { continue; }+        parts.push(canon(c).to_string());+    }+    parts.sort();+    let head: Vec<&str> = atoms(fp).collect();+    json!(["footprint", head, aiflow_board::reference_of(fp), parts])+}++/// The project rules that change DRC: the whole `.kicad_dru`, and the `.kicad_pro`'s design+/// settings (less the defaults for new items) and net settings (net classes).+fn rules_part(board: &Path) -> Result<Value, String> {+    let dru = board.with_extension("kicad_dru");+    let dru_v = if dru.is_file() { json!(sha256_file(&dru)?) } else { Value::Null };+    let pro = board.with_extension("kicad_pro");+    let pro_v = if pro.is_file() {+        let t = std::fs::read_to_string(&pro).map_err(|e| format!("{}: {e}", pro.display()))?;+        let v: Value = serde_json::from_str(&t).map_err(|e| format!("{}: {e}", pro.display()))?;+        let mut ds = v["board"]["design_settings"].clone();+        if let Some(o) = ds.as_object_mut() { o.remove("defaults"); }+        json!({"designSettings": ds, "netSettings": v["net_settings"]})+    } else { Value::Null };+    Ok(json!({"kicad_dru": dru_v, "kicad_pro": pro_v}))+}++/// The canonical text the fingerprint hashes (exposed for tests and review).+pub fn canonical_text(text: &str) -> Result<String, String> {+    if aiflow_board::eagle::is_eagle(text) { return Err("an EAGLE source has no copper fingerprint".into()); }+    let root = sx::parse(text)?;+    if root.tag != "kicad_pcb" { return Err("not a kicad_pcb".into()); }+    let mut items: Vec<String> = Vec::new();+    for it in &root.items {+        match it {+            Item::Atom { text, .. } => items.push(json!(["atom", text]).to_string()),+            Item::Node(n) => {+                let t = n.tag.as_str();+                // everything not named here stays in (the format version, layers, nets, tracks, zones)+                if NEVER_COPPER.contains(&t) { continue; }+                match t {+                    "footprint" => items.push(footprint(n).to_string()),+                    "setup" => items.push(canon_without(n, &["pcbplotparams"]).to_string()),+                    // board-level text variables feed text, never copper+                    "property" if item_layers(n).is_none() => {}+                    _ if graphic(t) => { if layered_relevant(n) { items.push(canon(n).to_string()); } }+                    _ => items.push(canon(n).to_string()),+                }+            }+        }+    }+    items.sort();+    Ok(items.join("\n"))+}++/// The copper fingerprint of a saved board and its project rule files.+pub fn fingerprint(board: &Path) -> Result<String, String> {+    let text = std::fs::read_to_string(board).map_err(|e| format!("{}: {e}", board.display()))?;+    let body = canonical_text(&text)?;+    let rules = rules_part(board)?;+    let mut h = Sha256::new();+    h.update(SCHEME.as_bytes());+    h.update(b"\0");+    h.update(body.as_bytes());+    h.update(b"\0");+    h.update(rules.to_string().as_bytes());+    Ok(format!("{:x}", h.finalize()))+}++/// A carry record when `new` has the same copper fingerprint as `old`; otherwise why not.+pub fn carry_record(old: &Path, new: &Path) -> Result<Value, String> {+    let a = fingerprint(old).map_err(|e| format!("current board: {e}"))?;+    let b = fingerprint(new).map_err(|e| format!("adopted board: {e}"))?;+    if a != b { return Err("copper changed (tracks, vias, zones, pads, footprint placement, outline, stackup, nets or rules)".into()); }+    Ok(json!({"scheme": SCHEME, "fromBoard": old.display().to_string(), "fromSha256": sha256_file(old)?,+        "toBoard": new.display().to_string(), "toSha256": sha256_file(new)?, "copperFingerprint": a, "at": aiflow_run::now()}))+}++/// Adopt `dest` as the run's board: keep the copper evidence when the fingerprint is unchanged,+/// otherwise invalidate it as before. Silkscreen and export proofs for another file are always+/// dropped. Returns (carried, a sentence for the user).+pub fn adopt(r: &mut Run, dest: &str) -> (bool, String) {+    let old = r.current_board();+    let dest_sha = sha256_file(Path::new(dest)).ok();+    let decision = if old.is_empty() { Err("no current board".to_string()) } else { carry_record(Path::new(&old), Path::new(dest)) };+    let (carried, note) = match decision {+        Ok(rec) => {+            let fp = rec["copperFingerprint"].as_str().unwrap_or("").to_string();+            r.add_board_carrying(dest, Some(rec));+            (true, format!("copper unchanged (fingerprint {}): gate, land, measure and analyses evidence (Fields included) carried over, bound to both board hashes", &fp[..12.min(fp.len())]))+        }+        Err(why) => {+            r.log("copper-carry-refused", json!({"newBoard": dest, "why": why}));+            r.add_board(dest);+            (false, format!("copper evidence invalidated ({why})"))+        }+    };+    let mut dropped = Vec::new();+    if let Some(o) = r.data["outcomes"].as_object_mut() {+        for k in SILK_OUTCOMES {+            if o.get(k).is_some_and(|v| v["boardSha256"].as_str().is_none() || v["boardSha256"].as_str() != dest_sha.as_deref()) {+                o.remove(k);+                dropped.push(k);+            }+        }+    }+    if !dropped.is_empty() {+        r.log("board-evidence-invalidated", json!({"newBoard": dest, "outcomes": dropped, "reason": "silkscreen and export proofs belong to one board file"}));+        return (carried, format!("{note}; {} must be recorded again on this board", dropped.join(" and ")));+    }+    (carried, note)+}++/// Accept evidence recorded on board hash `recorded` for the board file `current` through the+/// run's carry records: a chain of adoptions, each re-verified from its snapshot files, from the+/// recorded board to the current one with one unchanged copper fingerprint. Ok(chain) or why not.+pub fn carried_from(data: &Value, recorded: &str, current: &Path) -> Result<Vec<Value>, String> {+    let cur = sha256_file(current)?;+    if cur == recorded { return Ok(Vec::new()); }+    let records = data["copperCarry"].as_array().cloned().unwrap_or_default();+    if records.is_empty() { return Err("no copper carry-over is recorded".into()); }+    let fp = fingerprint(current)?;+    let boards: Vec<String> = data["boards"].as_array().map(|a| a.iter().filter_map(|b| b.as_str().map(str::to_string)).collect()).unwrap_or_default();+    let check = |file: &Value, sha: &Value| -> Result<(), String> {+        let f = file.as_str().ok_or("carry record without a board file")?;+        if !boards.iter().any(|b| b == f) { return Err(format!("{f} is not one of the run's board snapshots")); }+        let p = Path::new(f);+        if sha.as_str() != Some(sha256_file(p)?.as_str()) { return Err(format!("{f} changed since it was adopted")); }+        if fingerprint(p)? != fp { return Err(format!("{f} copper fingerprint differs")); }+        Ok(())+    };+    let mut target = cur;+    let mut chain = Vec::new();+    for _ in 0..records.len() {+        let rec = records.iter().rev().find(|r| r["scheme"] == SCHEME && r["toSha256"].as_str() == Some(target.as_str()) && r["copperFingerprint"].as_str() == Some(fp.as_str()))+            .ok_or_else(|| "no carry record with this board's copper fingerprint reaches the recorded board".to_string())?;+        check(&rec["toBoard"], &rec["toSha256"])?;+        check(&rec["fromBoard"], &rec["fromSha256"])?;+        chain.push(rec.clone());+        let from = rec["fromSha256"].as_str().unwrap_or("").to_string();+        if from == recorded { return Ok(chain); }+        target = from;+    }+    Err("the carry records do not reach the recorded board".into())+}++fn chain_note(what: &str, chain: &[Value]) -> String {+    let fp = chain.first().and_then(|c| c["copperFingerprint"].as_str()).unwrap_or("");+    format!("{what}: carried over from board {} (copper fingerprint {} unchanged across {} adoption(s))",+        chain.last().and_then(|c| c["fromBoard"].as_str()).unwrap_or("?"), &fp[..12.min(fp.len())], chain.len())+}++/// `pourverify::bound` that also accepts a verified-existing proof carried over a copper-unchanged+/// adoption. Ok(Some(note)) when it was carried, Ok(None) when bound directly, Err when not bound.+pub fn pours_bound(data: &Value, outcome: &Value, board: &Path, spec: &Path) -> Result<Option<String>, String> {+    if crate::pourverify::bound(outcome, board, spec) { return Ok(None); }+    let recorded = outcome["boardSha256"].as_str().ok_or("verify-pours proof has no board hash")?;+    let chain = carried_from(data, recorded, board)?;+    let mut o = outcome.clone();+    o["boardSha256"] = json!(sha256_file(board)?);+    if crate::pourverify::bound(&o, board, spec) { Ok(Some(chain_note("verify-pours", &chain))) } else { Err("spec or plan changed".into()) }+}++/// `placement_verify::bound` that also accepts a verified-existing placement proof carried over a+/// copper-unchanged adoption (footprint placement is part of the fingerprint).+pub fn placement_bound(data: &Value, proof: &Value, board: &Path, spec: &Path) -> Result<Option<String>, String> {+    if crate::placement_verify::bound(proof, board, spec) { return Ok(None); }+    let recorded = proof["boardSha256"].as_str().ok_or("place verify proof has no board hash")?;+    let chain = carried_from(data, recorded, board)?;+    let mut p = proof.clone();+    p["boardSha256"] = json!(sha256_file(board)?);+    if crate::placement_verify::bound(&p, board, spec) { Ok(Some(chain_note("place verify", &chain))) } else { Err("spec changed or the proof did not pass".into()) }+}++/// `aiflow_analyze::field_screen` on the board file `board`, also accepting a Fields report solved+/// on a board whose copper was carried over. Ok(Some(note)) when carried.+pub fn field_screen(data: &Value, report: &Value, spec: &Value, board: &Path, spec_bytes: &[u8], kind: &str) -> Result<Option<String>, String> {+    field_screen_with_acks(data, report, spec, board, spec_bytes, kind, &[]).map(|(n, _)| n)+}++/// `field_screen` with live current-peak acknowledgements (issue #70); also returns the covered points.+pub fn field_screen_with_acks(data: &Value, report: &Value, spec: &Value, board: &Path, spec_bytes: &[u8], kind: &str, acks: &[Value]) -> Result<(Option<String>, Vec<Value>), String> {+    let board_bytes = std::fs::read(board).unwrap_or_default();+    let cur = format!("{:x}", Sha256::digest(&board_bytes));+    let recorded = report["inputIdentity"]["board"].as_str().unwrap_or("");+    let screen = |r: &Value| aiflow_analyze::field_screen_with_acks(r, spec, &board_bytes, spec_bytes, kind, acks);+    if recorded.is_empty() || recorded == cur { return screen(report).map(|c| (None, c)); }+    let chain = match carried_from(data, recorded, board) {+        Ok(c) => c,+        // not carried: the plain screen reports the stale identity+        Err(why) => return screen(report).map(|c| (None, c)).map_err(|e| format!("{e} (not carried over: {why})")),+    };+    let mut r = report.clone();+    r["inputIdentity"]["board"] = json!(cur);+    screen(&r).map(|c| (Some(chain_note(&format!("Fields {kind} report"), &chain)), c))+}++/// A silkscreen proof was recorded and then dropped by an adoption: finish needs it again.+pub fn silk_dropped(data: &Value) -> bool {+    !data["outcomeAt"]["silkscreen"].is_null() && data["outcomes"].get("silkscreen").is_none()+}++#[cfg(test)]+mod tests {+    use super::*;++    const HEAD: &str = "(kicad_pcb (version 20260206) (generator \"pcbnew\") (general (thickness 1.6))\n (layers (0 \"F.Cu\" signal) (2 \"B.Cu\" signal) (5 \"F.SilkS\" user) (25 \"Edge.Cuts\" user))\n (setup (stackup (layer \"F.Cu\" (type \"copper\") (thickness 0.035))) (pcbplotparams (outputdirectory \"a\")))\n (net 0 \"\") (net 1 \"GND\") (net 2 \"VIN\")\n";+    fn fp(silk_at: &str, model: &str) -> String {+        format!(" (footprint \"R:R0603\" (layer \"F.Cu\") (uuid \"f1\") (at 10 10 90)\n  (property \"Reference\" \"R1\" (at {silk_at}) (layer \"F.SilkS\"))\n  (property \"Value\" \"10k\" (at 0 1) (layer \"F.Fab\"))\n  (fp_line (start -1 -1) (end 1 -1) (layer \"F.SilkS\") (stroke (width 0.12)))\n  (fp_rect (start -1.5 -1) (end 1.5 1) (layer \"F.CrtYd\"))\n  (pad \"1\" smd roundrect (at -0.8 0 90) (size 0.8 0.9) (layers \"F.Cu\" \"F.Mask\") (net 1 \"GND\") (uuid \"p1\"))\n  (pad \"2\" smd roundrect (at 0.8 0 90) (size 0.8 0.9) (layers \"F.Cu\" \"F.Mask\") (net 2 \"VIN\") (uuid \"p2\"))\n  (model \"{model}\"))\n")+    }+    const COPPER: &str = " (segment (start 1 1) (end 5 1) (width 0.25) (layer \"F.Cu\") (net 1) (uuid \"s1\"))\n (via (at 5 1) (size 0.6) (drill 0.3) (layers \"F.Cu\" \"B.Cu\") (net 1) (uuid \"v1\"))\n (zone (net 1) (net_name \"GND\") (layer \"B.Cu\") (uuid \"z1\") (priority 1) (connect_pads (clearance 0.2)) (min_thickness 0.2) (fill yes (thermal_gap 0.5) (thermal_bridge_width 0.5)) (polygon (pts (xy 0 0) (xy 20 0) (xy 20 20) (xy 0 20))))\n (gr_rect (start 0 0) (end 20 20) (layer \"Edge.Cuts\"))\n";+    fn board(silk: &str, fp_silk_at: &str, model: &str, copper: &str) -> String {+        format!("{HEAD}{}{copper}{silk})\n", fp(fp_silk_at, model))+    }+    fn fpr(text: &str) -> String { canonical_text(text).unwrap() }++    #[test]+    fn silk_fab_courtyard_text_and_models_are_outside_the_fingerprint() {+        let a = board("", "0 -1.5", "a.step", COPPER);+        let b = board(" (gr_text \"HELLO\" (at 3 3) (layer \"F.SilkS\"))\n (gr_line (start 0 0) (end 3 3) (layer \"F.SilkS\"))\n", "0 1.5 90", "b.step", COPPER)+            .replace("(outputdirectory \"a\")", "(outputdirectory \"gerbers\")").replace("\"10k\"", "\"10k 1%\"");+        assert_eq!(fpr(&a), fpr(&b));+        // order of items does not matter either+        let swapped = a.replace(COPPER, &COPPER.lines().rev().map(|l| format!("{l}\n")).collect::<String>());+        assert_eq!(fpr(&a), fpr(&swapped));+    }++    #[test]+    fn any_copper_change_changes_the_fingerprint() {+        let a = fpr(&board("", "0 -1.5", "a.step", COPPER));+        let changes = [+            ("(at 5 1) (size 0.6)", "(at 5.1 1) (size 0.6)"),           // a moved via+            ("(end 5 1) (width 0.25)", "(end 5 1.2) (width 0.25)"),    // a moved track+            ("(xy 20 20) (xy 0 20)", "(xy 20 19) (xy 0 20)"),           // a zone outline+            ("(priority 1)", "(priority 2)"),                          // zone priority+            ("(thermal_gap 0.5)", "(thermal_gap 0.3)"),                // zone fill settings+            ("(at -0.8 0 90) (size 0.8 0.9)", "(at -0.9 0 90) (size 0.8 0.9)"), // a moved pad+            ("(size 0.8 0.9) (layers \"F.Cu\" \"F.Mask\") (net 1", "(size 0.8 1.0) (layers \"F.Cu\" \"F.Mask\") (net 1"), // pad size+            ("(net 2 \"VIN\") (uuid \"p2\")", "(net 1 \"GND\") (uuid \"p2\")"), // pad net+            ("(at 10 10 90)", "(at 10 10 0)"),                         // footprint rotation+            ("(footprint \"R:R0603\" (layer \"F.Cu\")", "(footprint \"R:R0603\" (layer \"B.Cu\")"), // side+            ("(end 20 20) (layer \"Edge.Cuts\")", "(end 20 21) (layer \"Edge.Cuts\")"), // outline+            ("(thickness 0.035)", "(thickness 0.07)"),                 // copper weight+            ("(net 2 \"VIN\")\n", "(net 2 \"VBUS\")\n"),               // nets+        ];+        for (from, to) in changes {+            let b = board("", "0 -1.5", "a.step", COPPER);+            assert!(b.contains(from), "{from}");+            assert_ne!(a, fpr(&b.replacen(from, to, 1)), "{from} -> {to} must change the fingerprint");+        }+        // copper text and copper graphics count+        assert_ne!(a, fpr(&board(" (gr_text \"X\" (at 3 3) (layer \"F.Cu\"))\n", "0 -1.5", "a.step", COPPER)));+        assert!(canonical_text("<eagle></eagle>").is_err());+    }++    fn tmp(name: &str) -> std::path::PathBuf {+        let d = std::env::temp_dir().join(format!("aiflow-copper-carry-{name}-{}", std::process::id()));+        let _ = std::fs::remove_dir_all(&d);+        std::fs::create_dir_all(&d).unwrap();+        d+    }++    #[test]+    fn rules_sidecars_are_part_of_the_fingerprint() {+        let d = tmp("rules");+        let (a, b) = (d.join("a.kicad_pcb"), d.join("b.kicad_pcb"));+        let text = board("", "0 -1.5", "a.step", COPPER);+        std::fs::write(&a, &text).unwrap();+        std::fs::write(&b, &text).unwrap();+        assert_eq!(fingerprint(&a).unwrap(), fingerprint(&b).unwrap());+        std::fs::write(b.with_extension("kicad_dru"), "(version 1)").unwrap();+        assert!(carry_record(&a, &b).is_err());+        std::fs::write(a.with_extension("kicad_dru"), "(version 1)").unwrap();+        std::fs::write(a.with_extension("kicad_pro"), r#"{"board":{"design_settings":{"defaults":{"silk_text_size_h":1.0},"rules":{"min_clearance":0.2}}},"net_settings":{}}"#).unwrap();+        std::fs::write(b.with_extension("kicad_pro"), r#"{"board":{"design_settings":{"defaults":{"silk_text_size_h":0.8},"rules":{"min_clearance":0.2}},"viewports":[1]},"net_settings":{}}"#).unwrap();+        assert!(carry_record(&a, &b).is_ok(), "silk defaults and viewports are not copper");+        std::fs::write(b.with_extension("kicad_pro"), r#"{"board":{"design_settings":{"rules":{"min_clearance":0.15}}},"net_settings":{}}"#).unwrap();+        assert!(carry_record(&a, &b).is_err(), "a clearance rule is");+        std::fs::write(b.with_extension("kicad_pro"), "not json").unwrap();+        assert!(carry_record(&a, &b).is_err(), "an unreadable project file is uncertain: invalidate");+        let _ = std::fs::remove_dir_all(d);+    }++    /// A run with board-0, Fields/pours/gate evidence recorded on it, and a spec and plan.+    fn run_with_evidence(d: &Path) -> (Run, std::path::PathBuf, std::path::PathBuf, Value, Value) {+        let b0 = d.join("board-0.kicad_pcb");+        std::fs::write(&b0, board("", "0 -1.5", "a.step", COPPER)).unwrap();+        let spec = d.join("spec.json");+        std::fs::write(&spec, "{}").unwrap();+        let plan = d.join("pours.json");+        std::fs::write(&plan, "{\"zones\":[]}").unwrap();+        let b0sha = sha256_file(&b0).unwrap();+        let pours = json!({"mode":"verified-existing","pass":true,"failed":[],"boardSha256":b0sha,"specSha256":sha256_file(&spec).unwrap(),"plan":plan,"planSha256":sha256_file(&plan).unwrap()});+        let fields = json!({"inputIdentity":{"board":b0sha,"spec":format!("{:x}",Sha256::digest(b"{}"))}});+        let mut outcomes = serde_json::Map::new();+        for k in Run::COPPER_OUTCOMES { outcomes.insert(k.into(), json!({"pass": true})); }+        outcomes.insert("land-pours".into(), pours.clone());+        outcomes.insert("silkscreen".into(), json!({"ok": true, "boardSha256": b0sha}));+        let r = Run { dir: d.to_path_buf(), data: json!({"boards":[b0], "spec": spec, "outcomes": outcomes, "outcomeAt": {"silkscreen": "2026-10-15T00:00:00Z"}}) };+        (r, b0, spec, pours, fields)+    }++    #[test]+    fn silk_only_adoption_keeps_copper_evidence_and_finish_checks_accept_it() {+        let d = tmp("silk");+        let (mut r, _b0, spec, pours, fields) = run_with_evidence(&d);+        let b1 = d.join("board-1.kicad_pcb");+        std::fs::write(&b1, board(" (gr_text \"REV B\" (at 3 3) (layer \"F.SilkS\"))\n", "0 1.5 90", "a.step", COPPER)).unwrap();+        let (carried, note) = adopt(&mut r, &b1.display().to_string());+        assert!(carried, "{note}");+        for k in Run::COPPER_OUTCOMES { assert!(r.data["outcomes"].get(k).is_some(), "{k} kept"); }+        assert!(r.data["outcomes"].get("silkscreen").is_none(), "silk proof must be re-done");+        assert!(silk_dropped(&r.data));+        let rec = &r.data["copperCarry"][0];+        assert_eq!(rec["toSha256"].as_str().unwrap(), sha256_file(&b1).unwrap());+        assert!(rec["fromSha256"].is_string() && rec["copperFingerprint"].is_string());+        // the hash-bound checks accept the carried evidence, and say so+        assert!(pours_bound(&r.data, &pours, &b1, &spec).unwrap().unwrap().contains("carried over"));+        let mut f = fields.clone();+        f["nets"] = json!([]);+        f["issues"] = json!([]);+        f["peakJDefinition"] = json!({"statistic":"unclipped-cell-maximum","rounded":false,"minimumCopperFraction":0.25});+        assert!(field_screen(&r.data, &f, &json!({}), &b1, b"{}", "current").unwrap().unwrap().contains("carried over"));+        // a second silk-only adoption chains back to board-0+        let b2 = d.join("board-2.kicad_pcb");+        std::fs::write(&b2, board(" (gr_text \"REV C\" (at 4 3) (layer \"F.SilkS\"))\n", "0 1.5 90", "c.step", COPPER)).unwrap();+        assert!(adopt(&mut r, &b2.display().to_string()).0);+        assert_eq!(carried_from(&r.data, pours["boardSha256"].as_str().unwrap(), &b2).unwrap().len(), 2);+        assert!(pours_bound(&r.data, &pours, &b2, &spec).unwrap().is_some());+        let placed = json!({"ok": true, "mode": "verified-existing", "boardSha256": pours["boardSha256"], "specSha256": sha256_file(&spec).unwrap()});+        assert!(placement_bound(&r.data, &placed, &b2, &spec).unwrap().unwrap().contains("carried over"));+        let mut not_ok = placed.clone();+        not_ok["ok"] = json!(false);+        assert!(placement_bound(&r.data, &not_ok, &b2, &spec).is_err());+        let _ = std::fs::remove_dir_all(d);+    }++    #[test]+    fn copper_changes_invalidate_and_tampering_is_refused() {+        for (i, (from, to)) in [("(at 5 1) (size 0.6)", "(at 5.2 1) (size 0.6)"), ("(end 5 1) (width 0.25)", "(end 5 1.5) (width 0.25)"), ("(xy 20 20) (xy 0 20)", "(xy 18 20) (xy 0 20)"), ("(at 0.8 0 90) (size", "(at 0.9 0 90) (size")].iter().enumerate() {+            let d = tmp(&format!("moved{i}"));+            let (mut r, _b0, spec, pours, _) = run_with_evidence(&d);+            let b1 = d.join("board-1.kicad_pcb");+            let text = board("", "0 -1.5", "a.step", COPPER);+            assert!(text.contains(from));+            std::fs::write(&b1, text.replacen(from, to, 1)).unwrap();+            let (carried, note) = adopt(&mut r, &b1.display().to_string());+            assert!(!carried && note.contains("invalidated"), "{from}: {note}");+            for k in Run::COPPER_OUTCOMES { assert!(r.data["outcomes"].get(k).is_none(), "{k} voided"); }+            assert!(pours_bound(&r.data, &pours, &b1, &spec).is_err());+            let _ = std::fs::remove_dir_all(d);+        }+        // tampering: a forged record, an edited old snapshot, a forged fingerprint, a report for another board+        let d = tmp("tamper");+        let (mut r, b0, spec, pours, fields) = run_with_evidence(&d);+        let b1 = d.join("board-1.kicad_pcb");+        std::fs::write(&b1, board(" (gr_text \"REV B\" (at 3 3) (layer \"F.SilkS\"))\n", "0 -1.5", "a.step", COPPER)).unwrap();+        assert!(adopt(&mut r, &b1.display().to_string()).0);+        let good = r.data.clone();+        r.data["copperCarry"][0]["copperFingerprint"] = json!("0".repeat(64));+        assert!(pours_bound(&r.data, &pours, &b1, &spec).is_err(), "forged fingerprint");+        r.data = good.clone();+        r.data["copperCarry"][0]["fromSha256"] = json!("f".repeat(64));+        assert!(pours_bound(&r.data, &pours, &b1, &spec).is_err(), "forged hash");+        r.data = good.clone();+        r.data["copperCarry"] = json!([]);+        assert!(pours_bound(&r.data, &pours, &b1, &spec).is_err(), "no record");+        assert!(placement_bound(&r.data, &json!({"ok": true, "boardSha256": pours["boardSha256"], "specSha256": pours["specSha256"]}), &b1, &spec).is_err(), "no record, no placement carry");+        r.data = good.clone();+        let mut f = fields.clone();+        f["inputIdentity"]["board"] = json!("e".repeat(64));+        assert!(field_screen(&r.data, &f, &json!({}), &b1, b"{}", "current").unwrap_err().contains("identity"));+        // the old snapshot is edited after adoption: its copper no longer matches what the evidence saw+        std::fs::write(&b0, board("", "0 -1.5", "a.step", &COPPER.replace("(at 5 1)", "(at 6 1)"))).unwrap();+        assert!(pours_bound(&r.data, &pours, &b1, &spec).is_err(), "edited old snapshot");+        let _ = std::fs::remove_dir_all(d);+    }+}

@@ -0,0 +1,352 @@+//! The decoupling acceptance review (spec "decoupling", issue #32), after `route` and in `gate`.+//!+//! Per declared pair it measures the routed copper path from the cap's supply pad to its assigned+//! pin on the board with the plan applied (this net's planned plus existing copper), apart from the+//! copper distance to the nearest same-net pin of that part and the straight pad distance, and checks+//! the pair's own budgets (`maxLengthMm`, `maxVias`) and whether the path runs through the rail tree.+//! Findings are warnings or errors per the pair's `severity`; without a budget the length is reported+//! only. Ground returns are judged by connectivity: a return joined only by planned or stale pours is+//! labelled unverified, never given a straight line as if it were a path.+//! The measurement itself is `aiflow_router::copper_path`; the router's pre-routing is+//! `aiflow_router::decoupling`.+use std::path::Path;++use aiflow_board::Board;+use aiflow_router::copper_path::{self, FillContext};+use aiflow_router::decoupling::{self, Pair};+use aiflow_run::Run;+use serde_json::{json, Value};++pub struct Review {+    pub value: Value,+    pub errors: u64,+    pub warnings: u64,+}++pub const HINT: &str = "Each pair's budget is this board's own (spec decoupling maxLengthMm / maxVias). Route again (the router lays each pair's direct connection before the rail), move the cap closer to its pin in placement, or change the budget with the datasheet's reason; a warning-severity pair is reported only.";++/// Refuse a spec whose decoupling entries do not parse or do not resolve on this board.+pub fn refuse_bad_spec(spec: &Value, board: &Board) {+    let pairs = match Pair::from_spec(spec) {+        Ok(p) => p,+        Err(e) => crate::err(&format!("spec.decoupling: {e}"), &[shape_hint()]),+    };+    let (_, problems) = decoupling::resolve(board, &pairs);+    if !problems.is_empty() {+        crate::err(&format!("spec.decoupling does not resolve on this board:\n  {}", problems.join("\n  ")), &[shape_hint()]);+    }+}++fn shape_hint() -> String {+    "Use [{\"cap\": \"C6\", \"pin\": \"U1.39\"}] with optional \"capPad\" (default: the cap pad on the pin's net), \"gndPad\", \"returnPins\": [\"U1.38\"], \"maxLengthMm\", \"maxVias\" and \"severity\": \"warning\" | \"error\". There is no default budget.".into()+}++/// Nets with pours planned by `pour` (plan-pours.json), whether or not they are on the board yet.+fn planned_pour_nets(pour_outcome: Option<&Value>) -> Vec<String> {+    let Some(p) = pour_outcome.and_then(|o| o["pours"].as_str()) else { return Vec::new() };+    let Ok(text) = std::fs::read_to_string(p) else { return Vec::new() };+    let v: Value = serde_json::from_str(&text).unwrap_or(Value::Null);+    let mut nets: Vec<String> = v["zones"].as_array().map(|a| a.iter().filter_map(|z| z["net"].as_str().map(str::to_string)).collect()).unwrap_or_default();+    nets.sort();+    nets.dedup();+    nets+}++/// Review the pairs on a board text that already carries the plan's copper.+/// `fills_current`: the zone fills in the text are a native refill of this copper.+pub fn review_text(stage: &str, spec: &Value, board_path: &str, text: &str, fills_current: bool, fill_source: &str, plan: &Value, router_pairs: Option<&Value>, pour_outcome: Option<&Value>) -> Option<Review> {+    let pairs = Pair::from_spec(spec).ok()?;+    if pairs.is_empty() {+        return None;+    }+    let board = Board::from_text(board_path, text.to_string()).ok()?;+    let (resolved, problems) = decoupling::resolve(&board, &pairs);+    let ctx = FillContext { fills_current, fill_source: fill_source.to_string(), planned_pour_nets: planned_pour_nets(pour_outcome) };+    let mut v = copper_path::review(&board, &resolved, &ctx);+    // what routed each pair: the router's own report (route), or the plan's labelled entries (gate)+    let in_plan: Vec<String> = plan["nets"].as_array().map(|a| a.iter().filter_map(|e| e["decoupling"].as_str().map(str::to_string)).collect()).unwrap_or_default();+    if let Some(entries) = v["entries"].as_array_mut() {+        for e in entries.iter_mut() {+            let label = e["pair"].as_str().unwrap_or("").to_string();+            e["directInPlan"] = json!(in_plan.contains(&label));+            if let Some(rp) = router_pairs.and_then(|r| r.as_array()).and_then(|a| a.iter().find(|x| x["pair"] == label.as_str())) {+                e["router"] = rp.clone();+            }+        }+    }+    v["stage"] = json!(stage);+    v["unresolved"] = json!(problems);+    let errors = v["errors"].as_u64().unwrap_or(0);+    let warnings = v["warnings"].as_u64().unwrap_or(0);+    Some(Review { value: v, errors, warnings })+}++/// After `route`: the plan applied to the board it was planned on (no zone refill).+pub fn review_route(spec: &Value, board: &Board, plan: &Value, router_report: &Value, pour_outcome: Option<&Value>) -> Option<Review> {+    Pair::from_spec(spec).ok().filter(|p| !p.is_empty())?;+    let empty = plan["nets"].as_array().map(|a| a.is_empty()).unwrap_or(true);+    let (text, _) = match aiflow_copper::apply(board, plan, false) {+        Ok(x) => x,+        Err(e) => {+            eprintln!("Warning: decoupling review skipped, the plan does not apply: {e}");+            return None;+        }+    };+    review_text("route", spec, &board.path, &text, empty, "the zone fills saved in the board file, before this plan's copper", plan, Some(&router_report["decoupling"]), pour_outcome)+}++/// One line per pair, then every finding.+pub fn lines(d: &Review) -> Vec<String> {+    let mut out = Vec::new();+    for e in d.value["entries"].as_array().cloned().unwrap_or_default() {+        let a = &e["assignedPin"];+        let path = if a["connected"] == true {+            format!("path {} mm, {} via(s){}{}", a["pathMm"], a["vias"], if a["detour"] == true { ", detours through the rail" } else { "" }, if a["throughFill"] == true { ", through a zone fill" } else { "" })+        } else {+            "not joined by copper yet".to_string()+        };+        let budget = match (e["budget"]["maxLengthMm"].as_f64(), e["budget"]["maxVias"].as_u64()) {+            (None, None) => "no budget (report only)".to_string(),+            (l, v) => format!("budget {}{}", l.map(|x| format!("{x} mm")).unwrap_or_default(), v.map(|x| format!(" {x} via(s)")).unwrap_or_default()),+        };+        let nearest = e["nearestSameNetPin"]["pin"].as_str().map(|p| format!("; nearest same-net pin {p} at {} mm", e["nearestSameNetPin"]["pathMm"])).unwrap_or_default();+        let routed = match (&e["router"]["direct"], e["directInPlan"].as_bool()) {+            (Value::Bool(true), _) | (_, Some(true)) => "; direct pair route".to_string(),+            (Value::Bool(false), _) => format!("; no direct pair route ({})", e["router"]["note"].as_str().unwrap_or("fell back to normal routing")),+            _ => String::new(),+        };+        let mut l = format!("decoupling {} ({}): {path}, straight {} mm (pad gap {} mm), {budget}{nearest}{routed}", e["pair"].as_str().unwrap_or(""), e["net"].as_str().unwrap_or(""), e["straightMm"], e["padGapMm"]);+        for r in e["groundReturn"]["returns"].as_array().cloned().unwrap_or_default() {+            l.push_str(&format!("; return {} {}{}", r["pin"].as_str().unwrap_or(""), r["status"].as_str().unwrap_or(""), r["pathMm"].as_f64().map(|x| format!(" {x} mm")).unwrap_or_default()));+        }+        out.push(l);+        for f in e["findings"].as_array().cloned().unwrap_or_default() {+            out.push(format!("  {}: {}", f["severity"].as_str().unwrap_or("warning"), f["text"].as_str().unwrap_or("")));+        }+    }+    for p in d.value["unresolved"].as_array().cloned().unwrap_or_default() {+        out.push(format!("  warning: {}", p.as_str().unwrap_or("")));+    }+    out+}++/// Write `<dir>/decoupling-<stage>.json`, record the run outcome `decoupling` and print the lines.+/// A spec without pairs clears an older outcome so it cannot block `finish`.+pub fn record(r: &mut Run, dir: &Path, d: &Option<Review>) {+    match d {+        Some(d) => {+            let stage = d.value["stage"].as_str().unwrap_or("route").to_string();+            let file = dir.join(format!("decoupling-{stage}.json"));+            std::fs::write(&file, serde_json::to_string_pretty(&d.value).unwrap_or_default()).ok();+            let mut o = json!({"stage": stage, "report": file.display().to_string(), "pairs": d.value["pairs"], "warnings": d.warnings, "errors": d.errors});+            o["entries"] = json!(d.value["entries"].as_array().map(|a| a.iter().map(|e| json!({"pair": e["pair"], "pathMm": e["assignedPin"]["pathMm"], "vias": e["assignedPin"]["vias"], "detour": e["assignedPin"]["detour"], "straightMm": e["straightMm"], "nearestSameNetPin": e["nearestSameNetPin"], "findings": e["findings"].as_array().map(|f| f.len()).unwrap_or(0)})).collect::<Vec<_>>()).unwrap_or_default());+            r.outcome("decoupling", o);+            for l in lines(d) {+                eprintln!("{l}");+            }+        }+        None => {+            if r.outcomes().contains_key("decoupling") {+                r.outcome("decoupling", json!({"pairs": 0, "warnings": 0, "errors": 0, "note": "the spec declares no decoupling pairs"}));+            }+        }+    }+}++/// The stage fails on an error-severity finding.+pub fn refuse_errors(stage: &str, d: &Option<Review>) {+    if let Some(d) = d {+        if d.errors > 0 {+            let first: Vec<String> = d.value["entries"].as_array().into_iter().flatten().flat_map(|e| e["findings"].as_array().cloned().unwrap_or_default()).filter(|f| f["severity"] == "error").filter_map(|f| f["text"].as_str().map(str::to_string)).take(6).collect();+            crate::err(&format!("{stage}: {} decoupling error(s):\n  {}", d.errors, first.join("\n  ")), &[HINT.into(), format!("The full review is {}.", d.value["stage"].as_str().map(|s| format!("decoupling-{s}.json in the run folder")).unwrap_or_default())]);+        }+    }+}++/// For `finish`: the last decoupling review has an error-severity finding.+pub fn blocks_finish(o: Option<&Value>) -> Option<String> {+    let o = o?;+    let n = o["errors"].as_u64().unwrap_or(0);+    if n > 0 { Some(format!("decoupling: {n} error-severity finding(s) in the last review ({}); see {}", o["stage"].as_str().unwrap_or("?"), o["report"].as_str().unwrap_or("the run folder"))) } else { None }+}++#[cfg(test)]+mod tests {+    use super::*;+    use aiflow_router::{drive, Router, Rules};++    /// A 24 x 12 mm two-layer board. `parts`: (reference, [(pad name, net, local x, local y)], at x, y).+    fn board(parts: &[(&str, Vec<(&str, &str, f64, f64)>, f64, f64)], extra: &str) -> Board {+        let mut t = String::from("(kicad_pcb\n\t(version 20260206)\n\t(generator \"test\")\n\t(layers\n\t\t(0 \"F.Cu\" signal)\n\t\t(2 \"B.Cu\" signal)\n\t\t(25 \"Edge.Cuts\" user)\n\t)\n");+        for (r, pads, x, y) in parts {+            t.push_str(&format!("\t(footprint \"T:{r}\"\n\t\t(layer \"F.Cu\")\n\t\t(at {x} {y})\n\t\t(property \"Reference\" \"{r}\")\n"));+            // a connector's pads are larger: the router starts each net's tree there+            let size = if r.starts_with('J') { 1.5 } else { 0.8 };+            for (name, net, px, py) in pads {+                t.push_str(&format!("\t\t(pad \"{name}\" smd rect\n\t\t\t(at {px} {py})\n\t\t\t(size {size} {size})\n\t\t\t(layers \"F.Cu\")\n\t\t\t(net \"{net}\")\n\t\t)\n"));+            }+            t.push_str("\t)\n");+        }+        t.push_str(extra);+        t.push_str("\t(gr_rect\n\t\t(start 0 0)\n\t\t(end 24 12)\n\t\t(layer \"Edge.Cuts\")\n\t)\n)\n");+        Board::from_text("test.kicad_pcb", t).unwrap()+    }++    fn seg(net: &str, a: (f64, f64), b: (f64, f64)) -> String {+        format!("\t(segment\n\t\t(start {} {})\n\t\t(end {} {})\n\t\t(width 0.25)\n\t\t(layer \"F.Cu\")\n\t\t(net \"{net}\")\n\t)\n", a.0, a.1, b.0, b.1)+    }++    /// GND is a plane net in these specs (via stubs only), so the ground returns stay open unless a+    /// pour or a fill joins them.+    /// The rail: J1.1 (the source) to U1.1 along y = 5 and up, already on the board. The cap C1 sits+    /// 1 mm under that rail and 2.5 mm from its assigned pin U1.2, which sits 2 mm under the rail too:+    /// left to the tree, each lands on the rail and the cap reaches its pin along it.+    fn rail_board() -> Board {+        let parts = vec![+            ("J1", vec![("1", "+3V3", 0.0, 0.0), ("2", "GND", 0.0, 2.0)], 2.0, 5.0),+            ("U1", vec![("1", "+3V3", 0.0, 0.0), ("2", "+3V3", -6.0, 5.0), ("3", "GND", -4.0, 7.0)], 16.0, 2.0),+            ("C1", vec![("1", "+3V3", 0.0, 0.0), ("2", "GND", 0.0, 1.5)], 12.5, 6.0),+        ];+        board(&parts, &(seg("+3V3", (2.0, 5.0), (16.0, 5.0)) + &seg("+3V3", (16.0, 5.0), (16.0, 2.0))))+    }++    fn route(spec: &Value) -> (Router, Value, Value) {+        let b = rail_board();+        let mut router = Router::new(b, Rules::from_spec(spec), false);+        let (plan, report, failed) = drive::route_board(&mut router, 2, 4, 50);+        assert_eq!(failed, 0, "{:?}", router.log_lines);+        (router, json!({"nets": plan}), report)+    }++    fn entry(spec: &Value) -> (Value, Value) {+        let (router, plan, report) = route(spec);+        let d = review_route(spec, &router.board, &plan, &report, None).expect("a review");+        (d.value["entries"][0].clone(), json!({"errors": d.errors, "warnings": d.warnings, "router": report["decoupling"], "plan": plan}))+    }++    #[test]+    fn the_pair_route_is_short_where_the_rail_tree_detours() {+        // a rail tree drawn the long way: the cap and its pin each land on the rail with a stub, so+        // the copper path runs along the rail between two landings; the review sees the detour+        let tree = json!({"planes": {"GND": "B.Cu"}, "decoupling": [{"cap": "C1", "pin": "U1.2", "returnPins": ["U1.3"]}]});+        let stubs = seg("+3V3", (2.0, 5.0), (16.0, 5.0)) + &seg("+3V3", (16.0, 5.0), (16.0, 2.0)) + &seg("+3V3", (12.5, 6.0), (12.5, 5.0)) + &seg("+3V3", (10.0, 7.0), (10.0, 5.0));+        let b = board(&[+            ("J1", vec![("1", "+3V3", 0.0, 0.0), ("2", "GND", 0.0, 2.0)], 2.0, 5.0),+            ("U1", vec![("1", "+3V3", 0.0, 0.0), ("2", "+3V3", -6.0, 5.0), ("3", "GND", -4.0, 7.0)], 16.0, 2.0),+            ("C1", vec![("1", "+3V3", 0.0, 0.0), ("2", "GND", 0.0, 1.5)], 12.5, 6.0),+        ], &stubs);+        let d = review_text("gate", &tree, "t.kicad_pcb", &b.text, false, "the zone fills saved in the board file", &json!({"nets": []}), None, None).unwrap();+        let e = &d.value["entries"][0];+        let detour = e["assignedPin"]["pathMm"].as_f64().unwrap();+        assert_eq!(e["assignedPin"]["detour"], true, "{e:#}");+        assert!(detour > e["straightMm"].as_f64().unwrap() + 0.5, "{e:#}");+        assert_eq!(d.warnings, 1, "no budget: the detour is the one finding");+        // with the pair declared: routed first, direct, short, and the plan names it+        let (e, info) = entry(&tree);+        let direct = e["assignedPin"]["pathMm"].as_f64().unwrap();+        assert_eq!(info["router"][0]["direct"], true, "{info:#}");+        assert_eq!(e["assignedPin"]["detour"], false, "{e:#}");+        assert!(direct < detour - 0.5, "direct {direct} vs tree {detour}");+        assert!(direct < e["straightMm"].as_f64().unwrap() * 1.3, "{e:#}");+        assert_eq!(e["assignedPin"]["vias"], 0);+        assert_eq!(e["directInPlan"], true);+        assert!(info["plan"]["nets"].as_array().unwrap().iter().any(|x| x["decoupling"] == "C1.1->U1.2"));+        assert_eq!(e["capPad"], "C1.1");+        assert_eq!(e["nearestSameNetPin"]["pin"], "U1.2");+        assert_eq!(info["warnings"], 0);+        assert_eq!(info["errors"], 0);+        // ground: C1.2 and U1.3 have no copper and no pour: open, not a straight line+        let r = &e["groundReturn"]["returns"][0];+        assert_eq!(r["status"], "open");+        assert!(r["pathMm"].is_null());+    }++    #[test]+    fn a_budget_violation_warns_or_errors_per_severity() {+        // a 1 mm budget the 2.5 mm spacing cannot meet: the router falls back and the review flags it+        for (sev, errs, warns) in [("warning", 0, 1), ("error", 1, 0)] {+            let spec = json!({"planes": {"GND": "B.Cu"}, "decoupling": [{"cap": "C1", "pin": "U1.2", "maxLengthMm": 1.0, "severity": sev}]});+            let (e, info) = entry(&spec);+            assert_eq!(info["router"][0]["direct"], false, "{info:#}");+            assert!(info["router"][0]["note"].as_str().unwrap().contains("maxLengthMm"), "{info:#}");+            assert!(e["findings"].as_array().unwrap().iter().any(|f| f["text"].as_str().unwrap().contains("over maxLengthMm") && f["severity"] == sev), "{e:#}");+            assert_eq!(info["errors"].as_u64().unwrap() >= errs, true, "{info:#}");+            if errs == 0 { assert_eq!(info["errors"], 0); assert!(info["warnings"].as_u64().unwrap() >= warns); }+        }+        // a generous budget: no finding, the length is still reported+        let (e, info) = entry(&json!({"planes": {"GND": "B.Cu"}, "decoupling": [{"cap": "C1", "pin": "U1.2", "maxLengthMm": 6.0, "maxVias": 0, "severity": "error"}]}));+        assert_eq!(info["errors"], 0, "{e:#}");+        assert!(e["assignedPin"]["pathMm"].as_f64().unwrap() > 0.0);+    }++    #[test]+    fn a_planned_pour_ground_return_is_unverified() {+        let dir = std::env::temp_dir().join(format!("aiflow-dec-{}", std::process::id()));+        std::fs::create_dir_all(&dir).unwrap();+        let pours = dir.join("plan-pours.json");+        std::fs::write(&pours, r#"{"zones": [{"net": "GND"}]}"#).unwrap();+        let spec = json!({"planes": {"GND": "B.Cu"}, "decoupling": [{"cap": "C1", "pin": "U1.2", "returnPins": ["U1.3"]}]});+        let (router, plan, report) = route(&spec);+        let d = review_route(&spec, &router.board, &plan, &report, Some(&json!({"pours": pours.display().to_string()}))).unwrap();+        let r = &d.value["entries"][0]["groundReturn"]["returns"][0];+        assert_eq!(r["status"], "unverified", "{r:#}");+        assert_eq!(r["verified"], false);+        assert!(r["pathMm"].is_null());+        std::fs::remove_dir_all(&dir).ok();+    }++    #[test]+    fn a_ground_return_through_a_saved_fill_is_labelled() {+        let zone = "\t(zone\n\t\t(net \"GND\")\n\t\t(layer \"F.Cu\")\n\t\t(polygon\n\t\t\t(pts\n\t\t\t\t(xy 11 7) (xy 14 7) (xy 14 9.6) (xy 11 9.6)\n\t\t\t)\n\t\t)\n\t\t(filled_polygon\n\t\t\t(layer \"F.Cu\")\n\t\t\t(pts\n\t\t\t\t(xy 11 7) (xy 14 7) (xy 14 9.6) (xy 11 9.6)\n\t\t\t)\n\t\t)\n\t)\n";+        let parts = vec![+            ("U1", vec![("2", "+3V3", -6.0, 5.0), ("3", "GND", -4.0, 7.0)], 16.0, 2.0),+            ("C1", vec![("1", "+3V3", 0.0, 0.0), ("2", "GND", 0.0, 1.5)], 12.5, 6.0),+        ];+        let b = board(&parts, &(seg("+3V3", (12.5, 6.0), (10.0, 7.0)) + zone));+        let spec = json!({"planes": {"GND": "B.Cu"}, "decoupling": [{"cap": "C1", "pin": "U1.2", "returnPins": ["U1.3"]}]});+        let plan = json!({"nets": []});+        let d = review_text("gate", &spec, "t.kicad_pcb", &b.text, false, "an approximate raster fill", &plan, None, None).unwrap();+        let r = &d.value["entries"][0]["groundReturn"]["returns"][0];+        assert_eq!(r["status"], "fill-unverified", "{r:#}");+        let d = review_text("gate", &spec, "t.kicad_pcb", &b.text, true, "a native refill", &plan, None, None).unwrap();+        assert_eq!(d.value["entries"][0]["groundReturn"]["returns"][0]["status"], "fill");+        // the supply side is the hand-drawn track: direct, no detour+        assert_eq!(d.value["entries"][0]["assignedPin"]["detour"], false);+    }++    #[test]+    fn rip_up_keeps_the_pair_route() {+        let spec = json!({"planes": {"GND": "B.Cu"}, "decoupling": [{"cap": "C1", "pin": "U1.2"}]});+        let mut router = Router::new(rail_board(), Rules::from_spec(&spec), false);+        router.route_decoupling();+        let net = router.net_ids["+3V3"];+        let pair_cells = |r: &Router| r.nets[net].routes.iter().filter(|x| x.pair == Some(0)).map(|x| x.cells.clone()).collect::<Vec<_>>();+        let before = pair_cells(&router);+        assert_eq!(before.len(), 1);+        router.route_net(net);+        router.rip(net);+        assert_eq!(pair_cells(&router), before, "rip keeps the pair");+        assert!(router.nets[net].routes.iter().all(|x| x.pair.is_some()));+        router.route_net(net);+        assert_eq!(pair_cells(&router), before, "route_net keeps the pair");+        assert!(router.nets[net].failed.is_empty(), "{:?}", router.nets[net].failed);+        // a rail route landed on the pair's island once it joined the tree, not on a second copy+        assert_eq!(router.nets[net].routes.iter().filter(|x| x.pair.is_some()).count(), 1);+        router.reset();+        assert!(router.nets[net].routes.is_empty(), "reset clears pairs too");+    }++    #[test]+    fn a_bad_entry_is_named() {+        let b = rail_board();+        let (_, p) = decoupling::resolve(&b, &Pair::from_spec(&json!({"planes": {"GND": "B.Cu"}, "decoupling": [{"cap": "C9", "pin": "U1.2"}, {"cap": "C1", "pin": "U1.9"}, {"cap": "C1", "pin": "U1.2", "returnPins": ["U1.1"]}]})).unwrap());+        assert_eq!(p.len(), 3, "{p:?}");+        assert!(p[0].contains("no part C9"));+        assert!(p[1].contains("pin U1.9 is not a pad"), "{}", p[1]);+        assert!(p[2].contains("return pin U1.1"));+        assert!(Pair::from_spec(&json!({"planes": {"GND": "B.Cu"}, "decoupling": [{"cap": "C1", "pin": "U1.2", "severity": "fatal"}]})).is_err());+        assert!(Pair::from_spec(&json!({"planes": {"GND": "B.Cu"}, "decoupling": [{"cap": "C1", "pin": "U1.2", "maxLengthMm": 0}]})).is_err());+        let (ok, _) = decoupling::resolve(&b, &Pair::from_spec(&json!({"planes": {"GND": "B.Cu"}, "decoupling": {"cap": "C1", "pin": "U1.2"}})).unwrap());+        assert_eq!((ok[0].cap_pad.as_str(), ok[0].gnd_pad.as_deref(), ok[0].gnd_net.as_deref()), ("C1.1", Some("C1.2"), Some("GND")));+    }+}

@@ -0,0 +1,210 @@+//! Checks on the design record before the board (issue #39, items 4, 5 and 13):+//!+//! - `sourcing check`: every purchased BOM row cites a manufacturer or distributor page for the exact+//!   MPN (value, tolerance, dielectric, voltage, package), not only the family datasheet. Missing is a+//!   warning, an error when `sourcing.requireExactMpnEvidence` is true in the spec or requirements.+//! - `evidence add --kind calcs`: every datasheet-sourced number is tagged typ, min or max, and a+//!   worst-case use names a guaranteed limit (warnings only).+//! - `evidence add --kind simulation`: when the requirements name a full-scale input, the simulation+//!   has a case at that amplitude (warning only).+//!+//! Pure functions; main.rs wires them to the run.+use serde_json::{json, Value};++/// Header names for the exact-MPN evidence column (normalised: lower case, `_` for spaces and dashes).+const EVIDENCE_COLS: &[&str] = &["mpn_url", "exact_mpn_url", "mpn_evidence", "exact_mpn_evidence", "mpn_page", "product_url", "part_url", "evidence_url", "evidence"];++fn norm_header(s: &str) -> String { s.trim().to_ascii_lowercase().replace([' ', '-', '#'], "_") }+fn alnum(s: &str) -> String { s.chars().filter(|c| c.is_ascii_alphanumeric()).collect::<String>().to_ascii_lowercase() }++fn no_part(mpn: &str) -> bool {+    matches!(mpn.trim().to_ascii_lowercase().as_str(), "no part" | "none" | "n/a" | "na" | "dnp" | "-" | "no_part" | "")+}++/// True when the spec or the requirements ask for the exact-MPN column to be an error.+pub fn require_exact(spec: &Value, req: &Value) -> bool {+    [spec, req].iter().any(|v| v["sourcing"]["requireExactMpnEvidence"].as_bool() == Some(true))+}++/// Add the exact-MPN evidence findings to a `sourcing check` outcome: `exactMpnEvidence` counts,+/// warnings, and errors (which fail the check) when `strict`.+pub fn exact_mpn_evidence(bom: &str, strict: bool, out: &mut Value) {+    let rows = crate::preboard::parse_csv(bom);+    let Some(header) = rows.first() else { return };+    let find = |names: &[&str]| header.iter().position(|h| names.contains(&norm_header(h).as_str()));+    let c_mpn = find(&["mpn", "mfr_part", "mfr_pn", "manufacturer_part_number", "part_number", "mfr_part_number"]);+    let c_ref = find(&["ref", "refs", "reference", "references", "designator", "designators", "refdes"]);+    let c_ev = find(EVIDENCE_COLS);+    let Some(c_mpn) = c_mpn else { return };+    let get = |row: &Vec<String>, c: Option<usize>| c.and_then(|i| row.get(i)).map(|s| s.trim().to_string()).unwrap_or_default();+    let (mut cited, mut missing, mut soft) = (0usize, Vec::<String>::new(), Vec::<String>::new());+    for row in rows.iter().skip(1) {+        let mpn = get(row, Some(c_mpn));+        if no_part(&mpn) { continue; }+        let label = format!("{} ({mpn})", get(row, c_ref));+        let url = get(row, c_ev);+        if !(url.starts_with("http://") || url.starts_with("https://")) { missing.push(label); continue; }+        cited += 1;+        let path = url.split(['?', '#']).next().unwrap_or("").to_ascii_lowercase();+        if path.ends_with(".pdf") { soft.push(format!("{label}: the evidence is a PDF, usually the family datasheet; cite the manufacturer or distributor page for this exact MPN")); }+        else if !alnum(&url).contains(&alnum(&mpn)) { soft.push(format!("{label}: the evidence URL does not name the MPN; make sure the page is for this exact part, not its family")); }+    }+    out["exactMpnEvidence"] = json!({"column": c_ev.map(|i| header[i].clone()), "cited": cited, "missing": missing.len(), "required": strict});+    let mut warn: Vec<Value> = out["warnings"].as_array().cloned().unwrap_or_default();+    let mut errs: Vec<Value> = out["errors"].as_array().cloned().unwrap_or_default();+    if !missing.is_empty() {+        let msg = format!("{} row(s) without an exact-MPN page ({}{}): add an mpn_url column with the manufacturer or distributor page for that exact MPN (value, tolerance, dielectric, voltage, package); a family datasheet or a decoded part-number grammar is not proof the part is made", missing.len(), missing.iter().take(8).cloned().collect::<Vec<_>>().join(", "), if missing.len() > 8 { ", ..." } else { "" });+        if strict { errs.push(json!(msg)); } else { warn.push(json!(msg)); }+    }+    warn.extend(soft.into_iter().map(Value::from));+    out["warnings"] = json!(warn);+    if strict && !errs.is_empty() { out["pass"] = json!(false); }+    out["errors"] = json!(errs);+}++// -- calcs: typ/min/max tags --------------------------------------------------------------------------++fn datasheet_sourced(o: &serde_json::Map<String, Value>) -> bool {+    o.contains_key("datasheet") || o.get("source").and_then(|s| s.as_str()).map(|s| { let s = s.to_ascii_lowercase(); s.contains("datasheet") || s.contains(".pdf") }).unwrap_or(false)+}++fn kind_of(o: &serde_json::Map<String, Value>) -> Option<String> {+    let k = o.get("kind").and_then(|k| k.as_str())?.trim().to_ascii_lowercase();+    Some(match k.as_str() { "typical" => "typ".into(), "minimum" => "min".into(), "maximum" => "max".into(), _ => k })+}++fn walk<'a>(v: &'a Value, path: String, out: &mut Vec<(String, &'a serde_json::Map<String, Value>)>) {+    match v {+        Value::Object(o) => {+            out.push((path.clone(), o));+            for (k, c) in o { walk(c, if path.is_empty() { k.clone() } else { format!("{path}.{k}") }, out); }+        }+        Value::Array(a) => for (i, c) in a.iter().enumerate() { walk(c, format!("{path}[{i}]"), out); },+        _ => {}+    }+}++/// Warnings for a calcs JSON. The shape: any object with a numeric `value` and a `source` naming a+/// datasheet (or a `datasheet` field) is a datasheet number, and carries `"kind": "typ" | "min" | "max"`.+/// An object with `"worstCase": true` (or `"use": "worst-case"`) must not rest on a typ number.+pub fn calcs_warnings(v: &Value) -> Vec<String> {+    let mut objs = Vec::new();+    walk(v, String::new(), &mut objs);+    let mut out = Vec::new();+    for (path, o) in objs {+        let name = o.get("name").and_then(|n| n.as_str()).map(str::to_string).unwrap_or_else(|| if path.is_empty() { "(top)".into() } else { path.clone() });+        let numeric = o.get("value").map(|x| x.is_number()).unwrap_or(false);+        let kind = kind_of(o);+        if numeric && datasheet_sourced(o) {+            match kind.as_deref() {+                None => out.push(format!("{name}: a datasheet number with no \"kind\": tag it typ, min or max as the datasheet table does")),+                Some("typ" | "min" | "max") => {}+                Some(k) => out.push(format!("{name}: kind `{k}` is not typ, min or max")),+            }+        }+        let worst = o.get("worstCase").and_then(|w| w.as_bool()) == Some(true) || o.get("use").and_then(|u| u.as_str()).map(|u| u.to_ascii_lowercase().replace([' ', '_'], "-") == "worst-case").unwrap_or(false);+        if worst && kind.as_deref() == Some("typ") {+            out.push(format!("{name}: worst-case math on a typical value; use the guaranteed min or max limit (or derate it and say how)"));+        }+    }+    out+}++// -- simulation: full-scale input ---------------------------------------------------------------------++/// A voltage from a number or a string like "12 Vpp", "12Vpp", "500 mV": (volts, unit text).+fn volts(v: &Value) -> Option<f64> {+    if let Some(x) = v.as_f64() { return Some(x); }+    if let Some(o) = v.as_object() { return o.get("value").and_then(volts).or_else(|| o.get("vpp").and_then(volts)).or_else(|| o.get("amplitude").and_then(volts)); }+    let s = v.as_str()?.trim().to_ascii_lowercase();+    let num: String = s.chars().take_while(|c| c.is_ascii_digit() || *c == '.' || *c == '-' || *c == '+').collect();+    let x: f64 = num.parse().ok()?;+    let rest = s[num.len()..].trim_start();+    Some(if rest.starts_with("mv") { x / 1000.0 } else if rest.starts_with("uv") || rest.starts_with("µv") { x / 1e6 } else { x })+}++/// The full-scale input the requirements name: any key named like `fullScale`, `fullScaleInput`,+/// `full_scale_vpp` (a number in volts, a string with units, or {"value": ...}).+pub fn full_scale(req: &Value) -> Option<(String, f64)> {+    let mut objs = Vec::new();+    walk(req, String::new(), &mut objs);+    for (path, o) in objs {+        for (k, v) in o {+            let key = k.to_ascii_lowercase().replace(['_', '-', ' '], "");+            if key.contains("fullscale") { if let Some(x) = volts(v) { if x != 0.0 { return Some((if path.is_empty() { k.clone() } else { format!("{path}.{k}") }, x.abs())); } } }+        }+    }+    None+}++/// Warnings for a simulation result when the requirements name a full-scale input: a case is at+/// full scale when it says `"fullScale": true`, or a field named like amplitude / input / vin / vpp /+/// level holds that value within 5 % (or 50 % to 200 % of it for a peak-vs-peak-to-peak reading).+pub fn simulation_warnings(req: &Value, sim: &Value) -> Vec<String> {+    let Some((key, fs)) = full_scale(req) else { return Vec::new() };+    let mut objs = Vec::new();+    walk(sim, String::new(), &mut objs);+    let near = |x: f64| { let x = x.abs(); (x - fs).abs() <= 0.05 * fs || (x - fs / 2.0).abs() <= 0.05 * fs || (x - fs * 2.0).abs() <= 0.1 * fs };+    let hit = objs.iter().any(|(_, o)| o.iter().any(|(k, v)| {+        let key = k.to_ascii_lowercase().replace(['_', '-', ' '], "");+        if key.contains("fullscale") && v.as_bool() == Some(true) { return true; }+        ["amplitude", "input", "vin", "vpp", "level", "vpk", "vpeak"].iter().any(|n| key.contains(n)) && volts(v).map(near).unwrap_or(false)+    }));+    if hit { return Vec::new(); }+    vec![format!("the requirements name a full-scale input ({key} = {fs} V) but this simulation has no case at that amplitude: simulate at full scale too (a case with \"fullScale\": true or \"inputVpp\": {fs}) and say whether the topology only works small-signal (aiflow-simulate)")]+}++#[cfg(test)]+mod tests {+    use super::*;++    fn base() -> Value { json!({"pass": true, "errors": [], "warnings": []}) }++    #[test]+    fn exact_mpn_column_warns_then_errors_when_required() {+        let bom = "ref,mpn,source,stock_checked_2026-10-01,mpn_url\nC1,C0805C104K5RACTU,Mouser,5000,https://www.mouser.com/ProductDetail/KEMET/C0805C104K5RACTU\nC2,C0805C103F5GACTU,Mouser,100,\nR1,RC0805FR-0715K8L,Mouser,900,https://www.yageo.com/upload/media/product/RCseries.pdf\nTP1,no part,,,\n";+        let mut out = base();+        exact_mpn_evidence(bom, false, &mut out);+        assert_eq!(out["pass"], true);+        assert_eq!(out["exactMpnEvidence"]["cited"], 2);+        let w: Vec<String> = out["warnings"].as_array().unwrap().iter().map(|x| x.as_str().unwrap().to_string()).collect();+        assert!(w.iter().any(|x| x.contains("1 row(s) without an exact-MPN page") && x.contains("C2")), "{w:?}");+        assert!(w.iter().any(|x| x.contains("R1") && x.contains("PDF")), "{w:?}");+        let mut out = base();+        exact_mpn_evidence(bom, true, &mut out);+        assert_eq!(out["pass"], false);+        assert!(out["errors"][0].as_str().unwrap().contains("C2"));+        // no column at all: every purchased row is missing+        let mut out = base();+        exact_mpn_evidence("ref,mpn,source\nU1,MCP6001T-I/OT,Mouser\n", false, &mut out);+        assert_eq!(out["exactMpnEvidence"]["missing"], 1);+        assert!(require_exact(&json!({"sourcing": {"requireExactMpnEvidence": true}}), &Value::Null));+    }++    #[test]+    fn calcs_need_typ_min_max_on_datasheet_numbers() {+        let v = json!({"inputs": [+            {"name": "Ib MCP6001 at 85C", "value": 19e-12, "unit": "A", "source": "MCP6001 datasheet table 1-1", "kind": "typ", "worstCase": true},+            {"name": "Vos", "value": 4.5e-3, "source": "datasheet p.3", "kind": "max"},+            {"name": "Cin", "value": 6e-12, "datasheet": "p.4"},+            {"name": "R1", "value": 15800, "source": "chosen"}+        ]});+        let w = calcs_warnings(&v);+        assert_eq!(w.len(), 2, "{w:?}");+        assert!(w.iter().any(|x| x.starts_with("Ib MCP6001") && x.contains("typical")));+        assert!(w.iter().any(|x| x.starts_with("Cin") && x.contains("no \"kind\"")));+    }++    #[test]+    fn full_scale_input_needs_a_simulation_case() {+        let req = json!({"signal": {"fullScaleInput": "12 Vpp", "smallSignal": "100 mVpp"}});+        assert_eq!(full_scale(&req).unwrap().1, 12.0);+        let small = json!({"pass": true, "cases": [{"name": "small", "inputVpp": 0.1, "attenuationDb": 10.5}]});+        assert_eq!(simulation_warnings(&req, &small).len(), 1);+        let full = json!({"pass": true, "cases": [{"name": "small", "inputVpp": 0.1}, {"name": "full", "inputVpp": 12, "attenuationDb": 0.83}]});+        assert!(simulation_warnings(&req, &full).is_empty());+        let flagged = json!({"cases": [{"fullScale": true}]});+        assert!(simulation_warnings(&req, &flagged).is_empty());+        assert!(simulation_warnings(&json!({}), &small).is_empty());+    }+}

@@ -0,0 +1,151 @@+//! The board checked is the board that ships (issue #39, item 10). A zone that KiCad never filled+//! (or whose fill was dropped before saving) is outline only: DRC on a refilled copy passes, the+//! saved file and the Gerbers made from it carry no copper there.+//!+//! `saved` reads the saved board: every copper zone that should fill (not a keepout or rule area,+//! with a real outline) has at least one `filled_polygon` on each of its copper layers.+//! `gerbers` reads the exported copper Gerbers: every copper layer that carries a filled zone in+//! the saved board has region data (G36) in its Gerber.++use aiflow_board::{sx, Board};+use serde_json::{json, Value};++pub const HINT: &str = "Refill the zones in KiCad (Edit > Fill All Zones, or `kicad_refill_zones` through the bridge), save the board, then run the check (and `export`) again on the saved file. Never hand over a board or Gerbers whose pours exist only in a DRC copy.";++fn atoms(n: &sx::Node) -> Vec<String> {+    n.items.iter().filter_map(|it| if let sx::Item::Atom { text, .. } = it { Some(text.clone()) } else { None }).collect()+}++fn copper(name: &str) -> bool { name.ends_with(".Cu") }++/// The copper layers a zone is on, expanded against the board's copper layers.+fn zone_layers(z: &sx::Node, board_copper: &[String]) -> Vec<String> {+    let mut names: Vec<String> = Vec::new();+    if let Some(l) = z.find("layer").and_then(|l| l.value()) { names.push(l.to_string()); }+    if let Some(ls) = z.find("layers") { names.extend(atoms(ls)); }+    let mut out = Vec::new();+    for n in names {+        let expanded: Vec<String> = match n.as_str() {+            "*.Cu" => board_copper.to_vec(),+            "F&B.Cu" => vec!["F.Cu".into(), "B.Cu".into()],+            _ if copper(&n) => vec![n],+            _ => vec![],+        };+        for l in expanded { if !out.contains(&l) { out.push(l); } }+    }+    out+}++fn outline_area(z: &sx::Node) -> f64 {+    let pts: Vec<(f64, f64)> = z.find("polygon").and_then(|p| p.find("pts")).map(|p| p.find_all("xy").filter_map(|q| Some((q.number(1)?, q.number(2)?))).collect()).unwrap_or_default();+    aiflow_board::geom::polygon_area(&pts).abs()+}++/// The saved board's zones: (report, problems, copper layers that carry fill).+pub fn saved(b: &Board) -> (Value, Vec<String>, Vec<String>) {+    let mut problems = Vec::new();+    let mut zones = Vec::new();+    let mut filled_layers: Vec<String> = Vec::new();+    let (mut should, mut ok) = (0usize, 0usize);+    for z in b.root.find_all("zone") {+        let net = z.find("net_name").and_then(|n| n.value()).map(str::to_string).unwrap_or_else(|| b.item_net(z));+        let name = z.find("name").and_then(|n| n.value()).map(str::to_string);+        let label = match &name { Some(n) if !n.is_empty() => format!("zone \"{n}\" ({})", if net.is_empty() { "no net" } else { &net }), _ => format!("zone on {}", if net.is_empty() { "no net" } else { &net }) };+        let layers = zone_layers(z, &b.copper_layers);+        let keepout = z.find("keepout").is_some();+        let area = outline_area(z);+        if keepout || layers.is_empty() || area < 1e-6 {+            zones.push(json!({"zone": label, "layers": layers, "skipped": if keepout { "keepout / rule area" } else if layers.is_empty() { "not on copper" } else { "empty outline" }}));+            continue;+        }+        should += 1;+        let mut per_layer = serde_json::Map::new();+        let mut missing = Vec::new();+        for l in &layers {+            let n = z.find_all("filled_polygon").filter(|f| f.find("layer").and_then(|x| x.value()) == Some(l.as_str())).count();+            per_layer.insert(l.clone(), json!(n));+            if n == 0 { missing.push(l.clone()); } else if !filled_layers.contains(l) { filled_layers.push(l.clone()); }+        }+        if missing.is_empty() { ok += 1; } else { problems.push(format!("{label} has no filled polygon on {} in the saved board", missing.join(", "))); }+        zones.push(json!({"zone": label, "layers": layers, "filledPolygons": per_layer, "outlineMm2": (area * 100.0).round() / 100.0}));+    }+    (json!({"zones": zones, "shouldFill": should, "filled": ok, "pass": problems.is_empty(), "filledLayers": filled_layers}), problems, filled_layers)+}++/// KiCad's Gerber copper index of a layer: F.Cu L1, In<k>.Cu L(k+1), B.Cu Ln.+pub fn gerber_index(layer: &str, copper_count: usize) -> Option<usize> {+    match layer {+        "F.Cu" => Some(1),+        "B.Cu" => Some(copper_count.max(2)),+        _ => layer.strip_prefix("In").and_then(|r| r.strip_suffix(".Cu")).and_then(|k| k.parse::<usize>().ok()).map(|k| k + 1),+    }+}++/// G36 regions per copper Gerber, against the layers whose saved zones carry fill.+pub fn gerbers(files: &[(String, String)], filled_layers: &[String], copper_count: usize) -> (Value, Vec<String>) {+    let mut by_index: std::collections::BTreeMap<usize, (String, usize)> = std::collections::BTreeMap::new();+    for (name, text) in files {+        let Some(f) = crate::export::gerber_function(text) else { continue };+        let parts: Vec<&str> = f.split(',').collect();+        if parts.first() != Some(&"Copper") { continue; }+        if let Some(n) = parts.get(1).and_then(|l| l.strip_prefix('L')).and_then(|n| n.parse::<usize>().ok()) {+            by_index.insert(n, (name.clone(), text.matches("G36").count()));+        }+    }+    let mut problems = Vec::new();+    let mut layers = serde_json::Map::new();+    for l in filled_layers {+        let Some(i) = gerber_index(l, copper_count) else { continue };+        match by_index.get(&i) {+            Some((name, regions)) => {+                layers.insert(l.clone(), json!({"gerber": name, "regions": regions}));+                if *regions == 0 { problems.push(format!("{l} has poured zones in the saved board but its Gerber {name} has no region (G36) data: the pour did not reach the fab files")); }+            }+            None => problems.push(format!("{l} has poured zones but no copper Gerber L{i} was found")),+        }+    }+    (json!({"layersWithPours": layers, "pass": problems.is_empty()}), problems)+}++#[cfg(test)]+mod tests {+    use super::*;++    fn board(zones: &str) -> Board {+        Board::from_text("t.kicad_pcb", format!("(kicad_pcb (version 20240108) (generator \"t\")\n (layers (0 \"F.Cu\" signal) (31 \"B.Cu\" signal) (44 \"Edge.Cuts\" user))\n (net 0 \"\") (net 1 \"GND\")\n{zones}\n (gr_rect (start 0 0) (end 20 20) (layer \"Edge.Cuts\") (width 0.1)))")).unwrap()+    }+    const OUTLINE: &str = "(polygon (pts (xy 0 0) (xy 20 0) (xy 20 20) (xy 0 20)))";+    fn filled(l: &str) -> String { format!("(filled_polygon (layer \"{l}\") (pts (xy 1 1) (xy 19 1) (xy 19 19)))") }++    #[test]+    fn a_zone_without_filled_polygons_fails_and_keepouts_do_not_count() {+        let b = board(&format!("(zone (net 1) (net_name \"GND\") (layer \"B.Cu\") (name \"gnd\") {OUTLINE})\n (zone (net 0) (net_name \"\") (layers \"F.Cu\" \"B.Cu\") (keepout (tracks not_allowed)) {OUTLINE})"));+        let (rep, p, layers) = saved(&b);+        assert_eq!(p.len(), 1, "{p:?}");+        assert!(p[0].contains("\"gnd\"") && p[0].contains("B.Cu"), "{p:?}");+        assert!(layers.is_empty());+        assert_eq!(rep["shouldFill"], 1);+        let b = board(&format!("(zone (net 1) (net_name \"GND\") (layers \"F.Cu\" \"B.Cu\") {OUTLINE} {} {})", filled("F.Cu"), filled("B.Cu")));+        let (_, p, layers) = saved(&b);+        assert!(p.is_empty(), "{p:?}");+        assert_eq!(layers, vec!["F.Cu", "B.Cu"]);+        // a two-layer zone filled on one layer only+        let b = board(&format!("(zone (net 1) (net_name \"GND\") (layers \"F.Cu\" \"B.Cu\") {OUTLINE} {})", filled("F.Cu")));+        assert!(saved(&b).1[0].contains("B.Cu"));+    }++    #[test]+    fn gerbers_need_regions_on_poured_layers() {+        let g = |f: &str, body: &str| format!("%TF.FileFunction,{f}*%\n{body}\nM02*\n");+        let files = vec![("b-F_Cu.gbr".to_string(), g("Copper,L1,Top", "X0Y0D02*\nX1Y1D01*")), ("b-B_Cu.gbr".to_string(), g("Copper,L2,Bot", "X0Y0D02*\nX1Y1D01*"))];+        let (_, p) = gerbers(&files, &["B.Cu".to_string()], 2);+        assert!(p.len() == 1 && p[0].contains("B.Cu") && p[0].contains("G36"), "{p:?}");+        let mut ok = files.clone();+        ok[1].1 = g("Copper,L2,Bot", "G36*\nX0Y0D02*\nX5Y0D01*\nX5Y5D01*\nX0Y0D01*\nG37*");+        let (rep, p) = gerbers(&ok, &["B.Cu".to_string()], 2);+        assert!(p.is_empty(), "{p:?}");+        assert_eq!(rep["layersWithPours"]["B.Cu"]["regions"], 1);+        assert_eq!(gerber_index("In2.Cu", 4), Some(3));+        assert_eq!(gerber_index("B.Cu", 4), Some(4));+    }+}

@@ -1,6 +1,7 @@ //! adom-aiflow: the board loop as one command, with the clock, the negotiation and the finish line. //! Every reply starts with OK: or ERROR: and carries Hint: lines that depend on this board and run. mod continuation;+mod copper_carry; mod artifact_store; mod pourverify; mod dashboard;@@ -17,14 +18,29 @@ mod remote_binding; mod placement_verify; mod provenance; mod spec_freeze;+mod spec_nets;+mod schematic_check; mod export; mod silkproof;+mod schematic_symbols;+mod design_evidence;+mod silk_polarity;+mod project_lib;  /// The timeline dashboard (tools/timeline/index.html): it receives state over SSE from its run server. const TIMELINE_PAGE: &str = include_str!("../../../tools/timeline/index.html"); mod library_review; mod checks; mod preboard;+mod mechanical;+mod fills;+mod verified;+mod step_export;+mod skill_hints;+mod clipwatch;+mod decoupling_check;+mod placement_intent;+mod rules_card; use std::collections::BTreeMap; use std::path::{Path, PathBuf}; @@ -121,12 +137,14 @@ enum Cmd {     BindRemoteBoard { #[arg(long)] remote_board: String },     /// Adopt a native-saved board after AI-owned edits, preserving project rules and checking baseline DRC.     AdoptBoard { #[arg(long)] board: String, #[arg(long)] evidence: String },-    /// `parts [--bom <csv>] [--show] [--dwell 4]`: the from-scratch board's parts on the wiki. Every BOM row with an MPN (default: the BOM the sourcing check passed) is matched to its Adom wiki component page; --show walks a Hydrogen tab through each page so the viewer sees the parts being chosen. A part with no page fails: make it (wiki-component skill) and run again.-    Parts { #[arg(long)] bom: Option<String>, #[arg(long)] show: bool, #[arg(long, default_value_t = 4)] dwell: u64 },+    /// `parts [--bom <csv>] [--show] [--dwell 4]`: the from-scratch board's parts on the wiki. Every BOM row with an MPN (default: the BOM the sourcing check passed) is matched to its Adom wiki component page; --show walks a Hydrogen tab through each page so the viewer sees the parts being chosen. A part with no page fails: make it (wiki-component skill) and run again, or give it from the board's own project library (--project-lib).+    Parts { #[arg(long)] bom: Option<String>, #[arg(long)] show: bool, #[arg(long, default_value_t = 4)] dwell: u64, /// a project library folder for parts with no public component page: KiCad .kicad_sym, .pretty footprints, STEP models and a provenance.json naming each MPN's source (default: the spec's or requirements' "projectLib"). Each listed MPN needs a symbol, a footprint, a model and provenance; project-page packages them, finish reports them.+    #[arg(long)] project_lib: Option<String> },     /// `project-page --page <owner/slug> [--create]`: revision 1 of the board's project page before any EDA work: a README that says what the board is with the component table, and a KiCad PCM repository of every part (an Adom Cloud Library, exported and repackaged for KiCad's Plugin and Content Manager). Opens the page in Hydrogen.     ProjectPage { #[arg(long)] page: String, /// push every visited step's sub-readme and the README's "How this board was built" section now (each step's is also pushed in the background when the run leaves it)     #[arg(long)] sync: bool, #[arg(long)] create: bool, /// the page already exists and is this same board's own page (an earlier run of it); refused otherwise-    #[arg(long)] existing: bool, #[arg(long)] private: bool, #[arg(long)] title: Option<String>, #[arg(long)] brief: Option<String>, #[arg(long)] replace_readme: bool, #[arg(long)] no_push: bool },+    #[arg(long)] existing: bool, #[arg(long)] private: bool, #[arg(long)] title: Option<String>, /// what the board is: text, or a path to a file (for example design/brief.md) whose contents are read+    #[arg(long)] brief: Option<String>, #[arg(long)] replace_readme: bool, #[arg(long)] no_push: bool },     /// `pcm check`: the project page's PCM package is installed in the test box's KiCad (kicad_pcm_list), so the schematic can use every part. Install it first with kicad_pcm_add_repository + kicad_pcm_install (the URLs project-page printed).     Pcm { #[arg(value_parser = ["check"])] what: String },     /// `schematic check --sch <file.kicad_sch>`: the from-scratch KiCad schematic, drawn in KiCad: kicad-cli ERC with no errors, every BOM reference on the sheet, every part from the project's PCM library (PCM_<lib>). Records the schematic for the netlist check that follows the board.@@ -156,6 +174,12 @@ enum Cmd {     Export { /// the board (default: the run's current board)     #[arg(long)] board: Option<String>, /// where the set goes (default: <run>/manufacturing)     #[arg(long)] out: Option<PathBuf> },+    /// The board twin's native STEP export (kicad-cli pcb export step with models, tracks, pads, zones, mask and silkscreen; never fewer layers). Its output is kept and classified (geometry, model, other) apart from the exit status; geometry warnings block `board-glb copper` and `deliver` until `step-export --ack --why` after a review of the STEP. --log classifies the output of an export run elsewhere (the desktop).+    StepExport { /// the board (default: the run's current board)+    #[arg(long)] board: Option<String>, /// the STEP to write (default: <run>/twin/<board>.step), or with --log the STEP that export wrote+    #[arg(long)] out: Option<PathBuf>, /// classify this saved export output instead of running kicad-cli+    #[arg(long)] log: Option<PathBuf>, /// record that the geometry warnings of the last export were reviewed (needs --why)+    #[arg(long)] ack: bool, #[arg(long)] why: Option<String> },     /// Take nets' tracks and vias back up on the live board (to route them again, wider or another way); pours stay     Unroute { #[arg(long, required = true)] net: Vec<String> },     /// KiCad DRC offline on the routing plan@@ -163,12 +187,21 @@ enum Cmd {     /// Replay live through the bridge: route, vias, pours, moves     Land { what: String, #[arg(long)] plan: Option<String>, #[arg(long)] moves: Option<String>, #[arg(long, default_value_t = 600)] pause_ms: u64, /// route/vias: start at this trace number (1-based, as the progress lines count); traces already on the live board are skipped anyway     #[arg(long)] from: Option<usize> },-    /// Verify existing saved filled zones against an explicit reviewed plan, without landing or claiming ownership.-    VerifyPours { #[arg(long)] plan: String },+    /// Verify existing saved filled zones against an explicit reviewed plan, without landing or claiming ownership (--adopt --why takes ownership; --record-plan records a reviewed plan before the zones change)+    VerifyPours {+        /// the zone plan: the one `pour` wrote, or a reviewed plan recorded with --record-plan before the zones changed+        #[arg(long)] plan: String,+        /// take ownership of the matched zones (needs --why); recorded as adopted, not landed+        #[arg(long)] adopt: bool,+        /// reason for --adopt, or for accepting a plan whose provenance is not established; recorded with the proof+        #[arg(long)] why: Option<String>,+        /// only record this reviewed plan's hash now, before the zones it describes change+        #[arg(long)] record_plan: bool,+    },     /// Filled copper per layer from the live board     Measure,-    /// current or thermal-    Analyze { what: String, #[arg(long)] plan: Option<String>, #[arg(long)] fields: Option<PathBuf> },+    /// current or thermal. `analyze current --ack [email protected]|NET@x,y --why "..."` records a reviewed part-limited peak over the Fields density screen (repeat --ack for more); it covers only that place (the pad or 0.5 mm), keeps the number reported and expires when the copper fingerprint or the spec changes. spec.boardSink declares a board-face heat sink for named parts (thermal).+    Analyze { what: String, #[arg(long)] plan: Option<String>, #[arg(long)] fields: Option<PathBuf>, #[arg(long)] ack: Vec<String>, #[arg(long)] why: Option<String> },     /// The finish line; refuses until every check passes     Finish,     /// Record a change to the spec's budgets (loads, hot, rise limits, switch-node length, net widths, fab) after placement began. Budgets are frozen at placement; this is the only way to move one, and it stays on the record.@@ -274,6 +307,10 @@ fn ok(msg: &str, hints: &[String]) {     } } +/// Where this command's input is described (issue #56: the skill file by absolute path and its+/// section), set once in main and printed under every ERROR of the command.+static INPUT_HINT: std::sync::OnceLock<String> = std::sync::OnceLock::new();+ fn err(msg: &str, hints: &[String]) -> ! {     close_turn(false, msg.lines().next().unwrap_or(""));     println!("ERROR: {msg}");@@ -282,6 +319,7 @@ fn err(msg: &str, hints: &[String]) -> ! {             println!("Hint: {h}");         }     }+    if let Some(h) = INPUT_HINT.get() { println!("Hint: {h}"); }     std::process::exit(2) } @@ -308,11 +346,17 @@ fn read_json(p: &str) -> Value {     serde_json::from_str(&std::fs::read_to_string(p).unwrap_or_else(|e| err(&format!("{p}: {e}"), &[]))).unwrap_or_else(|e| err(&format!("{p}: not JSON: {e}"), &[])) } +/// The `start` hint for the design-rule card (rules_card.rs).+fn rules_card_hint(flags: &[String]) -> String {+    if flags.is_empty() { "Design-rule card: every spec size is inside the fab lane's range (drawn to scale on the dashboard; rules-card.json). It changes no gate.".into() }+    else { format!("Design-rule card: {} value(s) outside the fab lane's range (the WARNING lines above; rules-card.json and the dashboard). Fix the spec before placement if it is a unit slip; the card changes no gate.", flags.len()) }+}+ fn spec_of(r: &Run) -> Value {     if r.data["spec"].is_null() { err("this run has no spec yet (an intake run before its board)", &["Attach the board and its spec: adom-aiflow start --board B.kicad_pcb --spec spec.json --engine <you> (the clock stays at the prompt).".into()]); }     let spec = read_json(r.data["spec"].as_str().unwrap_or(""));     guard_budgets(r, &spec);-    spec+    spec_nets::align(spec, &r.current_board()) }  /// Once placement has begun the spec's budgets are frozen (`spec_freeze`): freeze them on the first read, and@@ -337,7 +381,8 @@ fn guard_budgets(r: &Run, spec: &Value) {  /// The spec when there is one, Null before the board (an intake run) or when it does not read. fn spec_soft(r: &Run) -> Value {-    r.data["spec"].as_str().and_then(|p| std::fs::read_to_string(p).ok()).and_then(|t| serde_json::from_str(&t).ok()).unwrap_or(Value::Null)+    let spec = r.data["spec"].as_str().and_then(|p| std::fs::read_to_string(p).ok()).and_then(|t| serde_json::from_str(&t).ok()).unwrap_or(Value::Null);+    spec_nets::align(spec, &r.current_board()) }  /// requirements.json (aiflow-intake) when the run knows one, else Null.@@ -984,7 +1029,7 @@ fn clip_verdict(file: &str, tools: &[&str]) -> Result<Option<String>, String> {  /// Verdicts that only the blank check gives; a later passing check (recut) clears them. An AI's own rejection stays. fn blank_check_verdict(why: &str) -> bool {-    why == "no frames" || why == "could not read frames" || why.contains("sampled frames are one flat colour")+    why == "no frames" || why == "could not read frames" || why.contains("sampled frames are one flat colour") || why.starts_with("truncated") }  /// Sample eight frames spread through a clip; for each, the centre 60 % of the frame (where a@@ -1064,6 +1109,14 @@ fn clip_artifacts_with(r: &mut Run, step: &Value, file: &str, speed: u32, tools:             return;         }     };+    // issue #59: a take that died before it was finalised has no moov atom; say so now, not at deliver+    let truncated = clipwatch::truncated(file);+    if let Some(t) = &truncated {+        eprintln!("WARNING clip {} is {t}. Re-record the step (`step <name> --back --why \"clip truncated\"`) while the work is fresh.", Path::new(file).file_name().and_then(|n| n.to_str()).unwrap_or(""));+        if let Some(c) = r.data["captures"].as_array_mut().and_then(|a| a.iter_mut().find(|c| c["file"].as_str() == Some(file))) { c["truncated"] = json!(true); }+        r.log("clip-truncated", json!({"step": step, "file": file, "why": t}));+    }+    let verdict = truncated.or(verdict);     let dir = r.dir.clone();     let tag = step.as_str().unwrap_or("step").to_string();     // the clip's offset from the prompt, so the overlay can show the run's own clock@@ -1787,9 +1840,11 @@ fn build_report(r: &Run, dir: &Path, page: &str) -> (PathBuf, String, PathBuf) {     if let Some(x) = o.get("route") { md.push_str(&format!("- routing: {} unrouted after {} passes\n", x["unrouted"], x["passes"])); }     if let Some(x) = o.get("gate") { md.push_str(&format!("- gate: {} new DRC errors, {} unconnected, {} inherited\n", x["newErrors"], x["unconnected"], x["inheritedErrors"])); }     if let Some(x) = o.get("land-route") { md.push_str(&format!("- landed live: {} of {} route entries\n", x["accepted"], x["entries"])); }-    if let Some(x) = o.get("land-pours") { md.push_str(&format!("- pours ({}): {} groups, failed {}\n", x["mode"].as_str().unwrap_or("landed"), x["groups"].as_array().map(|a| a.len()).unwrap_or(0), x["failed"])); }+    if let Some(x) = o.get("land-pours") { md.push_str(&format!("- pours ({}): {} groups, failed {}\n", pourverify::mode_label(x), x["groups"].as_array().map(|a| a.len()).unwrap_or(0), x["failed"])); }     if let Some(x) = o.get("measure") { md.push_str(&format!("- copper kept (mm2 per layer): {}\n", x["filledAreaByLayerMm2"])); }     for k in ["analyze-current", "analyze-thermal"] { if let Some(x) = o.get(k) { md.push_str(&format!("- {k}: {}\n", if x["pass"].as_bool() == Some(true) { "pass" } else { "fail" })); } }+    for c in o.get("analyze-current").and_then(|x| x["acknowledgedPeaks"].as_array()).into_iter().flatten() { md.push_str(&format!("- acknowledged current peak: {} {:.1} A/mm2 at ({:.2}, {:.2}) ({}): {} (by {})\n", c["net"].as_str().unwrap_or(""), c["peakJ"].as_f64().unwrap_or(0.0), c["at"][0].as_f64().unwrap_or(0.0), c["at"][1].as_f64().unwrap_or(0.0), c["ack"].as_str().unwrap_or(""), c["why"].as_str().unwrap_or(""), c["aiThread"].as_str().unwrap_or(""))); }+    for a in o.get("analyze-thermal").and_then(|x| x["boardSinkAssumptions"].as_array()).into_iter().flatten() { md.push_str(&format!("- board-sink assumption: {}\n", a.as_str().unwrap_or(""))); }     md.push_str("\n");     // clips and screenshots per visit     md.push_str("## The steps on camera\n\nOne clip per step visit, sped up 10x, with the editor at the start and the end of the visit. A caption above every clip and screenshot says what it shows.\n\n");@@ -1991,6 +2046,10 @@ fn live_board(r: &Run, cli: &Cli, dir: &std::path::Path) -> Option<(String, Stri /// Why a field-screen neck happens, from the board the solve ran on: a via whose copper ring is the /// narrowest copper of its net, or another net's track cutting a net's patch pour off from its pin. /// Each hint names the spec change that fixes it, so a refine pass is a decision, not a search.+/// The copper fingerprint current-peak acknowledgements bind to (issue #70): copper_carry's, the+/// same one that carries Fields evidence over a copper-unchanged adoption.+fn ack_copper(board: &str) -> Result<String, String> { copper_carry::fingerprint(Path::new(board)) }+ fn refine_hints(fields: &Value, board_text: &str, spec: &Value) -> Vec<String> {     let num = |s: &str| s.parse::<f64>().unwrap_or(0.0);     let via_re = regex_lite::Regex::new(r#"\(via \(at ([-\d.]+) ([-\d.]+)\) \(size ([\d.]+)\) \(drill ([\d.]+)\)[^\n]*?\(net \d+ "([^"]+)"\)"#).unwrap();@@ -2241,7 +2300,17 @@ fn lane_script(lane: &str, script: &str) -> std::path::PathBuf { }  fn main() {-    let cli = Cli::parse();+    let (skill_home, skill_pkg) = skill_hints::here();+    let input_hint = skill_hints::command_hint(&command_line(), &skill_home, skill_pkg.as_deref());+    let cli = match Cli::try_parse() {+        Ok(c) => c,+        Err(e) => {+            // a malformed command line names the skill section that describes the command's input+            if e.use_stderr() { let _ = e.print(); if let Some(h) = &input_hint { eprintln!("Hint: {h}"); } std::process::exit(e.exit_code()); }+            e.exit()+        }+    };+    if let Some(h) = input_hint { let _ = INPUT_HINT.set(h); }     // A host stop hook must not open windows, start captures or append timing events.     if let Cmd::FinishGuard { json: as_json, stop_evidence } = &cli.cmd {         let r = load_run(&cli);@@ -2289,7 +2358,16 @@ fn main() {                     let age = aiflow_run::parse(&now()).unwrap_or(0).saturating_sub(started);                     let step = caps[pos]["step"].as_str().unwrap_or("").to_string();                     let budget_min = match step.as_str() { "placement" => 40, "routing" => 30, "pours" => 15, "intake" => 10, "models" => 20, "sourcing" => 20, "design" | "simulation" | "schematic" => 30, _ => 10 } as u64;-                    if age > budget_min * 60 * 2 || age > 3600 {+                    let guard_due = age > budget_min * 60 * 2 || age > 3600;+                    // issue #59: a take that died (window gone, bridge restarted) is restarted on the step's window now+                    if !guard_due && !matches!(cli.cmd, Cmd::Step { .. } | Cmd::Capture { .. } | Cmd::Finish | Cmd::Deliver { .. }) {+                        if let Some(mut r2) = Run::open(&dir) {+                            let br = Bridge { ai_thread: t.clone(), target: target.clone() };+                            if let Some(line) = clipwatch::watch(&mut r2, &br, &dir) { eprintln!("WARNING: {line}"); }+                            let _ = r2.save();+                        }+                    }+                    if guard_due {                         let br = Bridge { ai_thread: t, target };                         if let Some(mut r2) = Run::open(&dir) {                             r2.mark(&format!("clip guard: the {step} clip ran {} min, past its {budget_min} min budget twice over; stopped by the guard", age / 60));@@ -2345,6 +2423,11 @@ fn main() {         Cmd::BoardGlb { action, glb, board, out, finish, paste, report } => {             let mut run = Run::open(&dir);             if run.is_some() { thread(&cli); }+            if action == "copper" {+                if let Some(open) = run.as_ref().and_then(|r| step_export::open_issue(r.outcomes().get("step-export").unwrap_or(&Value::Null))) {+                    err(&format!("board twin not delivered: {open}"), &["The STEP behind this GLB carries exporter geometry warnings nobody has reviewed. Review the STEP at those spots, then `adom-aiflow step-export --ack --why \"...\"`; never drop a layer to silence the exporter.".into()]);+                }+            }             let board_path = board.clone().map(|b| b.display().to_string()).or_else(|| run.as_ref().map(|r| r.current_board())).unwrap_or_else(|| err("board-glb needs --board <file.kicad_pcb> outside a run", &["Pass the .kicad_pcb the STEP was exported from.".into()]));             let spec_finish = run.as_ref().map(spec_soft).and_then(|v| v["fab"]["finish"].as_str().map(String::from));             let finish = finish.clone().or(spec_finish).unwrap_or_else(|| "copper".into());@@ -2404,6 +2487,40 @@ fn main() {             }             ok(&String::from_utf8_lossy(&result.stdout), &["Geometry audit only; native CAD review remains required. `--record` records the silkscreen step proof from a passing audit that covers the board.".into()]);         }+        Cmd::StepExport { board, out, log, ack, why } => {+            thread(&cli); let mut r = load_run(&cli);+            if *ack {+                let why = why.as_deref().filter(|w| !w.trim().is_empty()).unwrap_or_else(|| err("step-export --ack needs --why \"what you reviewed in the STEP and why it is complete\"", &[]));+                let mut rec = r.outcomes().get("step-export").cloned().unwrap_or_else(|| err("no STEP export recorded in this run", &["Run `adom-aiflow step-export` first.".into()]));+                if rec["geometryWarnings"].as_u64().unwrap_or(0) == 0 { ok("nothing to acknowledge: the last STEP export has no geometry warnings", &[]); return; }+                rec["ack"] = json!({"why": why, "at": now(), "stepSha256": rec["stepSha256"].clone()});+                r.outcome("step-export", rec.clone());+                r.log("step-export-ack", json!({"why": why, "step": rec["step"], "geometryWarnings": rec["geometryWarnings"]}));+                r.save().unwrap();+                ok(&format!("acknowledged {} STEP geometry warning(s) for {} (bound to this STEP file; a new export needs a new review)", rec["geometryWarnings"], rec["step"].as_str().unwrap_or("")), &[]);+                return;+            }+            let board_path = board.clone().unwrap_or_else(|| r.current_board());+            let stem = Path::new(&board_path).file_stem().and_then(|s| s.to_str()).unwrap_or("board").to_string();+            let step = out.clone().unwrap_or_else(|| dir.join("twin").join(format!("{stem}.step")));+            let rec = match log {+                Some(l) => { let text = std::fs::read_to_string(l).unwrap_or_else(|e| err(&format!("{}: {e}", l.display()), &[])); let mut v = step_export::record(&board_path, Some(&step), Some(0), &text, &format!("output of an export run elsewhere: {}", l.display())); v["exitCode"] = Value::Null; v["log"] = json!(l.display().to_string()); if !v["stepWritten"].as_bool().unwrap_or(false) { err(&format!("--log needs --out <the STEP that export wrote>; {} is not here", step.display()), &[]); } v["exitCode"] = json!(0); v["exitCodeSource"] = json!("assumed 0: the export ran elsewhere and wrote the STEP"); v }+                None => {+                    let _ = std::fs::create_dir_all(step.parent().unwrap_or(Path::new(".")));+                    let kicad = std::env::var("ADOM_AIFLOW_KICAD_CLI").unwrap_or_else(|_| "kicad-cli".into());+                    step_export::run(&board_path, &step, &kicad)+                }+            };+            write_json(&step.with_extension("export.json"), &rec);+            r.outcome("step-export", rec.clone());+            r.save().unwrap();+            let (g, m, o) = (rec["geometryWarnings"].as_u64().unwrap_or(0), rec["modelWarnings"].as_u64().unwrap_or(0), rec["otherWarnings"].as_u64().unwrap_or(0));+            if let Some(open) = step_export::open_issue(&rec) {+                let spots: Vec<String> = rec["diagnostics"].as_array().into_iter().flatten().map(|d| format!("{}: {}{}", d["kind"].as_str().unwrap_or(""), d["message"].as_str().unwrap_or(""), d["location"].as_object().map(|l| format!(" at z {} box ({}, {})-({}, {}) near {}", l["z"], l["x0"], l["y0"], l["x1"], l["y1"], d["nearbyFootprints"].as_array().map(|n| n.iter().filter_map(|x| x["ref"].as_str()).collect::<Vec<_>>().join("/")).unwrap_or_default())).unwrap_or_default())).take(12).collect();+                err(&format!("STEP export recorded with open issues: {open}\n  {}", spots.join("\n  ")), &[format!("Exit status {} and the file are recorded separately from these diagnostics ({}).", rec["exitCode"], step.with_extension("export.json").display()), "Do not re-export without silkscreen or mask to hide them. Review the STEP at each spot; if it is complete, `step-export --ack --why \"...\"`; if not, fix the board geometry and export again.".into()]);+            }+            ok(&format!("STEP export {}: exit {}, {g} geometry, {m} model, {o} other warning(s){}", step.display(), rec["exitCode"], if g > 0 { " (acknowledged)" } else { "" }), &[if m > 0 { "Model warnings: a part may be missing from the twin; check the models step.".into() } else { String::new() }, "Next: step2glb convert, then `board-glb copper` (skill aiflow-molecule).".into()]);+        }         Cmd::Export { board, out } => {             thread(&cli); let mut r = load_run(&cli);             let lane = sequence::lane(&dir, &r.data);@@ -2419,14 +2536,17 @@ fn main() {                     let mut hints: Vec<String> = report["files"].as_array().into_iter().flatten().filter_map(|f| f.as_str()).map(|f| format!("file: {f}")).collect();                     hints.extend(report["notes"].as_array().into_iter().flatten().filter_map(|n| n.as_str()).map(str::to_string));                     hints.push("Tell the human where every file is. Bottom-side CPL rotations follow kicad-cli's convention and were counted, not compared; check them against the fab's preview.".into());-                    ok(&format!("manufacturing files in {}, checked against the board: Gerbers ({} copper layers of {}), drill ({} hits = vias and drilled pads), pick and place ({} parts), BOM ({} lines)", out_dir.display(), report["gerbers"]["copperLayers"], report["gerbers"]["boardCopperLayers"], report["drill"]["hits"], report["cpl"]["refs"], report["bom"]["lines"]), &hints);+                    let facts = Board::load(&board_path).ok().filter(|_| mechanical::applies(&board_path)).map(|b| verified::board_facts(&b, &board_path, &project_dir_of(&r), &spec_soft(&r)));+                    let checked = verified::run_items(&r, facts.as_ref());+                    ok(&format!("manufacturing files in {}, checked against the board: Gerbers ({} copper layers of {}, pours present as regions on {} poured layer(s)), drill ({} hits = vias and drilled pads), pick and place ({} parts), BOM ({} lines)\n{}", out_dir.display(), report["gerbers"]["copperLayers"], report["gerbers"]["boardCopperLayers"], report["fillsGerbers"]["layersWithPours"].as_object().map(|o| o.len()).unwrap_or(0), report["drill"]["hits"], report["cpl"]["refs"], report["bom"]["lines"], verified::message(&checked)), &hints);                 }                 Err((report, problems)) => {                     let _ = std::fs::create_dir_all(&out_dir);                     write_json(&out_dir.join("export-check.json"), &report);                     r.log("export-refused", json!({"board": board_path, "dir": out_dir, "problems": problems}));                     r.save().unwrap();-                    err(&format!("manufacturing files do not check out against the board: {}", problems.join("; ")), &["Fix the board or its footprint attributes (DNP, exclude from BOM/position files) and run `export` again; never hand the human files that do not match the board.".into(), "kicad-cli: ADOM_AIFLOW_KICAD_CLI picks it; in a container with no native KiCad, ADOM_AIFLOW_KICAD_CLI=adom-aiflow-kicad-cli-remote KICAD_REMOTE_TARGET=<desktop>.".into()]);+                    let fill_hint = if problems.iter().any(|p| p.contains("filled polygon") || p.contains("G36")) { fills::HINT.to_string() } else { String::new() };+                    err(&format!("manufacturing files do not check out against the board: {}", problems.join("; ")), &[fill_hint, "Fix the board or its footprint attributes (DNP, exclude from BOM/position files) and run `export` again; never hand the human files that do not match the board.".into(), "kicad-cli: ADOM_AIFLOW_KICAD_CLI picks it; in a container with no native KiCad, ADOM_AIFLOW_KICAD_CLI=adom-aiflow-kicad-cli-remote KICAD_REMOTE_TARGET=<desktop>.".into()]);                 }             }         }@@ -2503,6 +2623,9 @@ fn main() {                     if let Some(w) = warning { attach_hints.push(format!("Fab rules: {w}.")); }                     if let Err((e, hint)) = checks::rules_gate(&p, &copy.display().to_string(), layers) { attach_hints.push(format!("Fab rules: {e}. {hint}")); }                 }+                let rc_flags = rules_card::at_start(&dir, &read_json(spec), &copy, &r.data["fabRules"]);+                for f in &rc_flags { eprintln!("WARNING: {f}"); }+                attach_hints.push(rules_card_hint(&rc_flags));                 ok(&format!("board attached to the intake run at {} for engine {engine}; the clock still counts from the prompt, {pt} ({:.1} min so far; steps before the board: {})", dir.display(), r.elapsed_minutes(), if steps.is_empty() { "none".into() } else { steps.join(", ") }), &attach_hints);                 print_next(&cli);                 return;@@ -2521,6 +2644,9 @@ fn main() {             else { start_hints.push("No --sch: finish will not ask for schematic-to-board netlist equivalence. When the board came from a schematic, start with --sch <file.kicad_sch> (or run `netlist check --sch <file>` to record it).".into()); }             let spec_v = read_json(spec);             if let Some((p, layers, _)) = checks::rules_target(&spec_v, &Value::Null) { if let Err((e, hint)) = checks::rules_gate(&p, board, layers) { start_hints.push(format!("Fab rules: {e}. {hint}")); } }+            let rc_flags = rules_card::at_start(&dir, &spec_v, &copy, &r.data["fabRules"]);+            for f in &rc_flags { eprintln!("WARNING: {f}"); }+            start_hints.push(rules_card_hint(&rc_flags));             if spec_v.get("molecule").is_some() { start_hints.push("The spec is a molecule: `adom-aiflow molecule check` before placement; place check, gate and finish run it too.".into()); }             start_hints.extend(["Then name the run's page once: `report --page <owner/slug> --user-machine <the human's box> --push --refresh` (or `--surface webview` when you run inside Adom Hydrogen and the human watches a workspace tab). From then on the run's own README (steps, times, returns, every step's clip and screenshots) rebuilds, pushes and reloads in the human's browser at every step change, by itself.".into(), "Record the paste time exactly: --prompt-time 2026-09-14T15:04:05Z when you start late.".into()]);             ok(&format!("run started for engine {engine} at {}; the clock started at the prompt, {pt}", dir.display()), &start_hints);@@ -2544,7 +2670,7 @@ fn main() {             let _ = TURN.set((dir.clone(), idx));             let profile = preboard::named_profile(&requirements_of(&r));             ok(&format!("intake run started at {}; the clock started at the prompt, {prompt_time}; step intake is open and there is no board yet", dir.display()), &[-                "Pre-board steps are steps like any other: `step sourcing`, `step design`, `step simulation`, `step schematic`; every command is a turn charged to the step you declared, and with --target each step records a clip of the desktop until a PCB editor is open.".into(),+                "Pre-board steps are steps like any other: `step sourcing`, `step design`, `step simulation`, `step schematic`; every command is a turn charged to the step you declared, and with --target each step before the board films the tool's own window when the step works in it, else Hydrogen with the run's dashboard, else your own terminal window (nothing meaningful on screen is a recorded skip): work in a visible window.".into(),                 match profile { Some(p) => format!("Sourcing profile {p} (from the requirements): `sourcing check --bom design/bom.csv` gates the BOM; finish requires it."), None => "No sourcing profile named yet: write requirements.json with fab.target `fab` (default) or `jlcpcb` (aiflow-intake), then `sourcing check --bom <csv> --requirements requirements.json`.".into() },                 "Record the design record as it lands: `evidence add --kind calcs --file design/calcs.json`, `evidence add --kind simulation --file sim/<results>.json` (a failing simulation is refused), `evidence add --kind vendor-model --file <result>` for a vendor PSpice/LTspice run (adom/adom-spice-skillpack).".into(),                 "When the board exists: `start --board B.kicad_pcb --spec spec.json --engine <you> [--target <box> --remote-board <path>]` on this same --run attaches it; the clock stays at the prompt.".into(),@@ -2570,6 +2696,7 @@ fn main() {             let board_path = board.clone().or_else(|| (!r.board_pending()).then(|| r.current_board()));             let refs = board_path.as_ref().map(|p| Board::load(p).map(|b| preboard::board_refs(&b)).unwrap_or_else(|e| err(&format!("board {p}: {e}"), &[])));             let mut out = preboard::sourcing_check(&text, refs.as_ref(), &prof, qty);+            design_evidence::exact_mpn_evidence(&text, design_evidence::require_exact(&spec, &req), &mut out);             let bomp = std::fs::canonicalize(bom).map(|p| p.display().to_string()).unwrap_or(bom.clone());             out["bom"] = json!(bomp);             out["bomSha256"] = json!(library_review::hash(Path::new(bom)).unwrap_or_default());@@ -2621,7 +2748,8 @@ fn main() {                 std::fs::copy(&src, &dest).unwrap_or_else(|e| err(&format!("copy into the run: {e}"), &[]));                 std::fs::canonicalize(&dest).unwrap_or(dest)             };-            let entry = json!({"kind": kind, "file": canon.display().to_string(), "copy": copy.display().to_string(), "sha256": sha, "bytes": text.len(), "note": note, "step": step, "at": now(), "pass": pass, "checks": checks});+            let review: Vec<String> = match (kind.as_str(), serde_json::from_str::<Value>(&text)) { ("calcs", Ok(v)) => design_evidence::calcs_warnings(&v), ("simulation", Ok(v)) => design_evidence::simulation_warnings(&requirements_of(&r), &v), _ => Vec::new() };+            let entry = json!({"kind": kind, "file": canon.display().to_string(), "copy": copy.display().to_string(), "sha256": sha, "bytes": text.len(), "note": note, "step": step, "at": now(), "pass": pass, "checks": checks, "warnings": review});             if !r.data["evidence"].is_array() { r.data["evidence"] = json!([]); }             r.data["evidence"].as_array_mut().unwrap().push(entry.clone());             r.log("evidence", entry);@@ -2633,7 +2761,9 @@ fn main() {                 "simulation" => if pass.is_none() { "This result states no pass or fail: add a top-level \"pass\" or a \"checks\" list against the requirements so the gate can read it (the file is recorded either way).".to_string() } else { "Next: the vendor model if the brief asks for one (`evidence add --kind vendor-model`), then `step schematic`.".to_string() },                 _ => format!("Vendor PSpice/LTspice runs belong to the adom/adom-spice-skillpack (`adom-wiki pkg install adom/adom-spice-skillpack`: PSpice for TI and LTspice on a Windows desktop through Adom Bridge); this records its result{}. Publish results, never solver speed numbers.", if pass == Some(false) { ", which says it fails: write the design conclusion in sim/<vendor>-validation.md" } else { "" }),             };-            ok(&format!("{kind} evidence recorded ({n} of that kind in this run): {} sha256 {}, {state}", canon.display(), &sha[..12.min(sha.len())]), &[hint, "finish requires the kinds the spec lists in \"requireEvidence\" (e.g. [\"calcs\", \"simulation\"]).".into()]);+            let mut hints = vec![hint, "finish requires the kinds the spec lists in \"requireEvidence\" (e.g. [\"calcs\", \"simulation\"]).".into()];+            hints.extend(review.iter().map(|w| format!("warning: {w}")));+            ok(&format!("{kind} evidence recorded ({n} of that kind in this run): {} sha256 {}, {state}", canon.display(), &sha[..12.min(sha.len())]), &hints);         }         Cmd::Clips { page, push } => {             thread(&cli);@@ -2676,13 +2806,14 @@ fn main() {             let dest=dir.join(format!("board-{n}.kicad_pcb"));             std::fs::copy(board,&dest).unwrap_or_else(|e|err(&e.to_string(),&[]));             aiflow_copper::copy_project_rules(board,&dest.display().to_string()).unwrap_or_else(|e|err(&e,&[]));-            r.add_board(&dest.display().to_string());+            let (carried, carry_note) = copper_carry::adopt(&mut r, &dest.display().to_string());             r.data["remoteBinding"]=Value::Null;-            r.log("adopt-board",json!({"source":board,"board":dest,"evidence":evidence,"drc":summary}));+            r.log("adopt-board",json!({"source":board,"board":dest,"evidence":evidence,"drc":summary,"copperCarried":carried}));             r.save().unwrap();-            ok("native-saved board adopted; historical snapshots preserved", &["Run plan, then route: it keeps the board's own tracks and vias and plans only the connections they leave open (a fully routed board gets an empty plan that gate, land route and finish accept). Re-solve Fields before finish.".into()]);+            if carried { ok(&format!("native-saved board adopted; historical snapshots preserved; {carry_note}"), &["Silkscreen changed: record the silkscreen proof again (`silkscreen-audit --record`) and export again; finish reruns the full native DRC. Bind the desktop board again (bind-remote-board) before live commands.".into()]); }+            else { ok(&format!("native-saved board adopted; historical snapshots preserved; {carry_note}"), &["Run plan, then route: it keeps the board's own tracks and vias and plans only the connections they leave open (a fully routed board gets an empty plan that gate, land route and finish accept). Re-solve Fields before finish.".into()]); }         }-        Cmd::Parts { bom, show, dwell } => {+        Cmd::Parts { bom, show, dwell, project_lib } => {             let t = thread(&cli);             let mut r = load_run(&cli);             let bom = bom.clone().or_else(|| r.data["outcomes"]["sourcing"]["bom"].as_str().map(str::to_string))@@ -2701,8 +2832,17 @@ fn main() {                 if page.is_none() && !missing.contains(&mpn) { missing.push(mpn.clone()); }                 row["wiki"] = json!(page);             }+            // parts with no public page may come from the board's own project library (issue #66)+            let plib = project_lib.clone().or_else(|| spec_soft(&r)["projectLib"].as_str().or(requirements_of(&r)["projectLib"].as_str()).map(str::to_string));+            let mut why_missing: Vec<(String, String)> = Vec::new();+            if let Some(d) = &plib {+                let lib = project_lib::ProjectLib::load(Path::new(d)).unwrap_or_else(|e| err(&e, &["A project library is a folder with *.kicad_sym, *.pretty/*.kicad_mod, STEP models and provenance.json (see the aiflow-sourcing skill).".into()]));+                why_missing = project_lib::resolve(&mut rows, &lib);+                missing.retain(|m| why_missing.iter().any(|(w, _)| w == m));+            }+            let from_lib: Vec<String> = rows.iter().filter(|x| x["projectLib"].is_object()).filter_map(|x| x["mpn"].as_str().map(str::to_string)).collect();             let pass = missing.is_empty();-            r.outcome("parts", json!({"pass": pass, "bom": std::fs::canonicalize(&bom).map(|p| p.display().to_string()).unwrap_or(bom.clone()), "parts": rows, "missing": missing}));+            r.outcome("parts", json!({"pass": pass, "bom": std::fs::canonicalize(&bom).map(|p| p.display().to_string()).unwrap_or(bom.clone()), "parts": rows, "missing": missing, "projectLib": plib, "projectLibParts": from_lib, "projectLibGaps": why_missing.iter().map(|(m, w)| json!({"mpn": m, "why": w})).collect::<Vec<_>>()}));             r.save().unwrap();             if *show {                 // one named tab walks through the pages (never a tab per part)@@ -2713,11 +2853,12 @@ fn main() {                     std::thread::sleep(std::time::Duration::from_secs(*dwell));                 }             }-            let list: Vec<String> = rows.iter().map(|x| format!("  {:<22} {:<10} {}", x["mpn"].as_str().unwrap_or(""), x["refs"].as_array().map(|a| a.iter().filter_map(|v| v.as_str()).collect::<Vec<_>>().join(",")).unwrap_or_default(), x["wiki"].as_str().unwrap_or("MISSING"))).collect();+            let list: Vec<String> = rows.iter().map(|x| format!("  {:<22} {:<10} {}", x["mpn"].as_str().unwrap_or(""), x["refs"].as_array().map(|a| a.iter().filter_map(|v| v.as_str()).collect::<Vec<_>>().join(",")).unwrap_or_default(), x["wiki"].as_str().map(str::to_string).or_else(|| x["projectLib"].is_object().then(|| "project library".to_string())).unwrap_or_else(|| "MISSING".into()))).collect();             if !pass {-                err(&format!("{} of {} parts have no Adom wiki component page:\n{}", missing.len(), rows.len(), list.join("\n")), &["Make each missing part's page (the wiki-component skill: symbol, footprint and STEP from the datasheet), then run `parts` again. The project page and the KiCad library are built from these pages.".into()]);+                let gaps: Vec<String> = why_missing.iter().map(|(m, w)| format!("  {m}: project library: {w}")).collect();+                err(&format!("{} of {} parts have no Adom wiki component page{}:\n{}{}", missing.len(), rows.len(), if plib.is_some() { " and no complete project-library entry" } else { "" }, list.join("\n"), if gaps.is_empty() { String::new() } else { format!("\n{}", gaps.join("\n")) }), &["Make each missing part's page (the wiki-component skill: symbol, footprint and STEP from the datasheet), then run `parts` again. The project page and the KiCad library are built from these pages.".into(), "A part whose page cannot be public yet: `parts --project-lib <dir>` with its symbol, footprint, STEP model and a provenance.json entry (aiflow-sourcing skill).".into()]);             }-            ok(&format!("every part is on the wiki ({} parts):\n{}", rows.len(), list.join("\n")), &["Next: `step project-page`, then `project-page --page <owner/slug> --create`: the board's page, revision 1, with the component table and the KiCad PCM repository.".into()]);+            ok(&format!("every part is on the wiki{} ({} parts):\n{}", if from_lib.is_empty() { String::new() } else { format!(" or in the project library ({} from {})", from_lib.len(), plib.as_deref().unwrap_or("")) }, rows.len(), list.join("\n")), &["Next: `step project-page`, then `project-page --page <owner/slug> --create`: the board's page, revision 1, with the component table and the KiCad PCM repository.".into()]);         }         Cmd::ProjectPage { page, sync, create, existing, private, title, brief, replace_readme, no_push } => {             let t = thread(&cli);@@ -2735,22 +2876,30 @@ fn main() {             if !page.contains('/') { err("--page is <owner>/<slug>", &[]); }             let (spec, req) = (spec_soft(&r), requirements_of(&r));             let title = title.clone().or_else(|| req["title"].as_str().map(str::to_string)).or_else(|| spec["title"].as_str().map(str::to_string)).unwrap_or_else(|| sequence::title(&r.data));-            let brief = brief.clone().or_else(|| req["summary"].as_str().or(req["description"].as_str()).map(str::to_string)).unwrap_or_else(|| title.clone());-            let cfg = json!({"run": dir.display().to_string(), "page": page, "title": title, "brief": brief, "summary": req["description"].as_str().unwrap_or(""), "parts": parts["parts"], "create": create, "push": !no_push, "private": private, "replaceReadme": replace_readme, "existing": existing, "version": "1.0.0"});+            let brief = brief.as_deref().map(preboard::brief_text).or_else(|| req["summary"].as_str().or(req["description"].as_str()).map(str::to_string)).unwrap_or_else(|| title.clone());+            let cfg = json!({"run": dir.display().to_string(), "page": page, "title": title, "brief": brief, "summary": req["description"].as_str().unwrap_or(""), "parts": parts["parts"], "create": create, "push": !no_push, "private": private, "replaceReadme": replace_readme, "existing": existing, "version": "1.0.0",+                "libRef": r.data["cloudLibrary"].as_str().or(r.data["outcomes"]["project-page"]["cloudLibrary"].as_str())});             let cfgp = dir.join("project-page").join("config.json");             let _ = std::fs::create_dir_all(cfgp.parent().unwrap());             std::fs::write(&cfgp, serde_json::to_string_pretty(&cfg).unwrap()).unwrap();             let o = std::process::Command::new("python3").arg("-c").arg(include_str!("../../../tools/project-page.py")).arg(&cfgp).stdin(std::process::Stdio::null()).output().unwrap_or_else(|e| err(&format!("python3: {e}"), &[]));             let v: Value = serde_json::from_slice(&o.stdout).unwrap_or_else(|_| json!({"ok": false, "error": String::from_utf8_lossy(&o.stderr).chars().rev().take(600).collect::<String>().chars().rev().collect::<String>()}));-            if v["ok"] != true { err(&format!("project page: {}", v["error"].as_str().unwrap_or("failed")), &[]); }+            if v["ok"] != true {+                if let Some(l) = v["cloudLibrary"].as_str().filter(|l| l.starts_with("lib_")) { r.data["cloudLibrary"] = json!(l); r.save().unwrap(); }+                err(&format!("project page: {}", v["error"].as_str().unwrap_or("failed")), &["Nothing was published. Rate-limited adds are retried with backoff; rerun `project-page` after the wait and it reuses the same Cloud Library (never a second one).".into()]);+            }             r.outcome("project-page", v.clone());             r.data["projectPage"] = json!(page);+            if let Some(l) = v["cloudLibrary"].as_str().filter(|l| l.starts_with("lib_")) { r.data["cloudLibrary"] = json!(l); }             r.save().unwrap();             if !no_push {                 let _ = std::process::Command::new("adom-cli").args(["hydrogen", "webview", "open-or-refresh", "--name", "Project page", "--url", v["url"].as_str().unwrap_or(""), "--ai-thread", &t, "--reason", "adom-aiflow: the board's project page, revision 1"]).stdin(std::process::Stdio::null()).output();             }-            ok(&format!("project page {} ({}): README revision 1 with {} parts, KiCad PCM repository {}", v["url"].as_str().unwrap_or(""), if v["created"] == true { "created" } else { "updated" }, v["parts"], v["repositoryUrl"].as_str().unwrap_or("")),-               &[format!("Next: `step libraries`, then install the parts in KiCad: kicad_pcm_add_repository {{\"url\":\"{}\"}} and kicad_pcm_install {{\"repositoryUrl\":\"{}\",\"identifier\":\"{}\"}}, restart KiCad, then `pcm check`.", v["repositoryUrl"].as_str().unwrap_or(""), v["repositoryUrl"].as_str().unwrap_or(""), v["identifier"].as_str().unwrap_or(""))]);+            let c = &v["counts"];+            let mut hints: Vec<String> = v["adds"]["notes"].as_array().into_iter().flatten().filter_map(|n| n.as_str().map(str::to_string)).collect();+            if let Some(pl) = v["projectLibParts"].as_array().filter(|a| !a.is_empty()) { hints.push(format!("from the board's project library: {}", pl.iter().filter_map(|x| x.as_str()).collect::<Vec<_>>().join(", "))); }+            ok(&format!("project page {} ({}): README revision 1 with {} parts, KiCad PCM repository {} ({} symbols, {} footprints, {} models for {} distinct parts; symbol library version {}, KiCad load check: {})", v["url"].as_str().unwrap_or(""), if v["created"] == true { "created" } else { "updated" }, v["parts"], v["repositoryUrl"].as_str().unwrap_or(""), c["symbols"], c["footprints"], c["models"], c["distinctParts"], v["libraryCheck"]["symVersion"], v["libraryCheck"]["kicadCli"].as_str().unwrap_or("?")),+               &[hints, vec![format!("Next: `step libraries`, then install the parts in KiCad: kicad_pcm_add_repository {{\"url\":\"{}\"}} and kicad_pcm_install {{\"repositoryUrl\":\"{}\",\"identifier\":\"{}\"}}, restart KiCad, then `pcm check`.", v["repositoryUrl"].as_str().unwrap_or(""), v["repositoryUrl"].as_str().unwrap_or(""), v["identifier"].as_str().unwrap_or(""))]].concat());         }         Cmd::Pcm { what: _ } => {             thread(&cli);@@ -2773,25 +2922,19 @@ fn main() {             let kc = std::env::var("ADOM_AIFLOW_KICAD_CLI").unwrap_or_else(|_| "kicad-cli".into());             let sdir = dir.join("schematic"); let _ = std::fs::create_dir_all(&sdir);             let erc = sdir.join("erc.json");-            let _ = std::process::Command::new(&kc).args(["sch", "erc", "--format", "json", "--severity-error", "--output"]).arg(&erc).arg(sch).stdin(std::process::Stdio::null()).output();-            let ercv: Value = std::fs::read_to_string(&erc).ok().and_then(|t| serde_json::from_str(&t).ok()).unwrap_or(Value::Null);-            let erc_errors: Vec<String> = ercv["sheets"].as_array().cloned().unwrap_or_default().iter().flat_map(|sh| sh["violations"].as_array().cloned().unwrap_or_default()).filter(|v| v["severity"] == "error").map(|v| v["description"].as_str().unwrap_or("").to_string()).collect();+            let (_, erc_errors) = schematic_check::run_erc(&kc, sch, &erc).unwrap_or_else(|e| err(&format!("schematic check: {e}"), &["ERC must run and its report come back before the schematic can pass. In a container: ADOM_AIFLOW_KICAD_CLI=adom-aiflow-kicad-cli-remote KICAD_REMOTE_TARGET=<desktop> (it runs `sch erc` on the desktop's KiCad).".into()]));             let net = sdir.join("netlist.net");             export_sch_netlist(sch, &net).unwrap_or_else(|e| err(&e, &[]));-            let root = aiflow_board::sx::parse(&std::fs::read_to_string(&net).unwrap_or_default()).unwrap_or_else(|e| err(&format!("netlist: {e}"), &[]));-            let mut on_sheet: BTreeMap<String, (String, String)> = BTreeMap::new();-            for comp in root.find_all("comp") {-                let Some(rf) = comp.find("ref").and_then(|n| n.atom(1)) else { continue };-                let lib = comp.find("libsource").and_then(|l| l.find("lib")).and_then(|n| n.atom(1)).unwrap_or("").to_string();-                let fp = comp.find("footprint").and_then(|n| n.atom(1)).unwrap_or("").to_string();-                on_sheet.insert(rf.to_string(), (lib, fp));-            }+            let on_sheet = schematic_check::sheet_symbols(&std::fs::read_to_string(&net).unwrap_or_default()).unwrap_or_else(|e| err(&format!("netlist: {e}"), &[]));             let lib = r.data["outcomes"]["project-page"]["libName"].as_str().map(|l| format!("PCM_{l}"));             let bom_refs: Vec<String> = r.data["outcomes"]["parts"]["parts"].as_array().cloned().unwrap_or_default().iter().flat_map(|p| p["refs"].as_array().cloned().unwrap_or_default()).filter_map(|v| v.as_str().map(str::to_string)).collect();             let missing: Vec<String> = bom_refs.iter().filter(|rf| !on_sheet.contains_key(*rf)).cloned().collect();             let foreign: Vec<String> = match &lib { Some(l) => on_sheet.iter().filter(|(rf, (sl, fp))| bom_refs.contains(rf) && (sl != l || !fp.starts_with(&format!("{l}:")))).map(|(rf, (sl, fp))| format!("{rf} ({sl} / {fp})")).collect(), None => Vec::new() };             let extra: Vec<String> = on_sheet.keys().filter(|rf| !bom_refs.contains(rf)).cloned().collect();-            let pass = erc_errors.is_empty() && missing.is_empty() && foreign.is_empty();+            // issue #39: symbol polarity drawings, active-device pin types and readability (schematic_symbols.rs)+            let symbols = schematic_symbols::check(Path::new(sch), &spec_soft(&r)).unwrap_or_else(|e| json!({"ok": false, "errors": [format!("could not read the hierarchy: {e}")], "warnings": []}));+            schematic_symbols::record(&mut r, sch, &symbols);+            let pass = erc_errors.is_empty() && missing.is_empty() && foreign.is_empty() && symbols["ok"] == true;             let canon = std::fs::canonicalize(sch).map(|p| p.display().to_string()).unwrap_or(sch.clone());             r.outcome("schematic", json!({"pass": pass, "schematic": canon, "sha256": sha256_file(sch), "ercErrors": erc_errors, "symbols": on_sheet.len(), "missingRefs": missing, "notFromProjectLibrary": foreign, "notInBom": extra, "library": lib}));             if pass { r.data["schematic"] = json!(canon); }@@ -2801,10 +2944,14 @@ fn main() {                 if !erc_errors.is_empty() { why.push(format!("ERC: {} error(s): {}", erc_errors.len(), erc_errors.iter().take(6).cloned().collect::<Vec<_>>().join("; "))); }                 if !missing.is_empty() { why.push(format!("not on the sheet: {}", missing.join(", "))); }                 if !foreign.is_empty() { why.push(format!("not from the project library {}: {}", lib.clone().unwrap_or_default(), foreign.join(", "))); }-                err(&format!("schematic check failed:\n  {}", why.join("\n  ")), &["Fix it in KiCad's schematic editor on camera (kicad_sch_place_symbol / kicad_sch_wire / kicad_sch_label / kicad_sch_set_property), save, and check again.".into()]);+                why.extend(symbols["errors"].as_array().into_iter().flatten().filter_map(|e| e.as_str().map(str::to_string)));+                let mut hints = vec!["Fix it in KiCad's schematic editor on camera (kicad_sch_place_symbol / kicad_sch_wire / kicad_sch_label / kicad_sch_set_property), save, and check again.".to_string()];+                hints.extend(schematic_symbols::render(&symbols, true).1);+                hints.push(schematic_symbols::warning_hint(&symbols));+                err(&format!("schematic check failed:\n  {}", why.join("\n  ")), &hints);             }             ok(&format!("schematic {canon}: {} symbols, ERC clean, every BOM reference placed from {}{}", on_sheet.len(), lib.unwrap_or_else(|| "the project library".into()), if extra.is_empty() { String::new() } else { format!(" ({} not in the BOM: {})", extra.len(), extra.join(", ")) }),-               &["Next: make the board from it (KiCad: Update PCB from Schematic), draw the outline, save, bind it (`bind-remote-board` / `start --board`), then `step components`.".into()]);+               &[schematic_symbols::warning_hint(&symbols), "Next: make the board from it (KiCad: Update PCB from Schematic), draw the outline, save, bind it (`bind-remote-board` / `start --board`), then `step components`.".into()]);         }         Cmd::Components { etch } => {             thread(&cli);@@ -2924,6 +3071,9 @@ fn main() {                     if let Some(f)=molecule_findings(&spec_of(&r),&b,Some(&r)) {                         if !f.errors.is_empty() { err(&format!("placement violates molecule: {}",f.errors.join("; ")),&[]); }                     }+                    let spec_i=spec_of(&r);+                    let intent_lines=placement_intent::check(&mut r,&dir,&spec_i,&b,"place verify").unwrap_or_else(|e|{r.save().ok();err(&e,&[placement_intent::HINT.into()])});+                    for l in &intent_lines { eprintln!("{l}"); }                     let rb=r.data["remoteBoard"].as_str().filter(|s|!s.is_empty()).unwrap_or_else(||err("place verify requires the named native board",&[])).to_string();                     let br=bridge_of(&r,&cli);                     let before=br.call("kicad_placement_state",&json!({"filePath":rb,"detail":true}));@@ -2945,8 +3095,12 @@ fn main() {                     let spec = spec_of(&r);                     let courtyard_edge=spec["placement"]["courtyardEdgeClearance"].as_f64().unwrap_or(0.0);                     let chains = aiflow_place::chains_from_spec(&spec).unwrap_or_else(|e| err(&format!("spec.chains: {e}"), &[]));+                    let intent = placement_intent::of_spec(&spec);+                    let (wishes, anchor_lines) = aiflow_place::intent::apply_anchors(&b, &wishes, &intent);                     let (wishes, chain_plans, chain_lines) = aiflow_place::apply_chains(&b, &wishes, &chains, 0.05);-                    let (mv, lines) = aiflow_place::pack(&b, &wishes, 0.05, courtyard_edge);+                    let (mv, mut lines) = aiflow_place::pack(&b, &wishes, 0.05, courtyard_edge);+                    lines.extend(anchor_lines);+                    lines.extend(placement_intent::pack_lines(&b, &mv, &intent));                     write_json(Path::new(out), &serde_json::to_value(&mv).unwrap());                     let missing = lines.iter().filter(|l| l.contains("NO SPOT")).count();                     let verdicts = aiflow_place::chain_report(&b, &mv, &chain_plans);@@ -2978,6 +3132,8 @@ fn main() {                             err(&format!("the moved board is not a conforming molecule:\n{}", f.lines.iter().filter(|l| !l.starts_with("OK")).cloned().collect::<Vec<_>>().join("\n")), &h);                         }                     }+                    let spec_i = spec_of(&r);+                    if let Err(e) = placement_intent::check(&mut r, &dir, &spec_i, &nb, "place check") { r.save().ok(); err(&e, &[placement_intent::HINT.into(), format!("The run's current board is unchanged; the moved board is {}.", outp.display())]); }                     let drc = aiflow_copper::run_drc(&outp.display().to_string()).unwrap_or_else(|e| err(&format!("DRC on the moved board failed: {e}"), &[]));                     let baseline = aiflow_copper::run_drc(&r.current_board()).unwrap_or_else(|e| err(&format!("baseline DRC failed: {e}"), &[]));                     let s = aiflow_copper::summarize(&drc, Some(&baseline));@@ -2988,9 +3144,16 @@ fn main() {                     if s["newErrors"].as_u64() != Some(0) {                         err(&format!("the moved board adds {} native DRC violations: {}", s["newErrors"], s["newErrorTypes"]), &[format!("Change the wishes and pack again; inspect {}. Findings are matched by identity, not an inherited-error count.", outp.display())]);                     }+                    // issue #39: courtyards present and clear, part bodies clear, whatever the project severities say+                    let mech_line = if mechanical::applies(&outp.display().to_string()) {+                        let mech = mechanical::check_board(&nb, &outp.display().to_string(), &project_dir_of(&r), &spec_soft(&r));+                        for n in &mech.severity_notes { eprintln!("Warning: {n}"); }+                        if !mech.errors().is_empty() { err(&format!("the moved board fails the courtyard and body checks:\n  {}", mech.errors().join("\n  ")), &[mech.hint(), format!("The run's current board is unchanged; see {}.", outp.display())]); }+                        format!("; courtyards on all {} footprint(s) with pads and clear, {} part bodies clear", mech.with_courtyard, mech.bodies_checked)+                    } else { "; courtyards and bodies not checked (Fusion board: check them in Fusion's DRC)".to_string() };                     r.add_board(&outp.display().to_string());                     r.save().unwrap();-                    ok(&format!("{}\nmoved board {} is DRC-clean ({errors} errors, all inherited) and is now the run's current board", lines.join("\n"), outp.display()), &["Land the same moves live with `place land --moves ...`.".into()]);+                    ok(&format!("{}\nmoved board {} is DRC-clean ({errors} errors, all inherited){mech_line} and is now the run's current board", lines.join("\n"), outp.display()), &["Land the same moves live with `place land --moves ...`.".into()]);                 }                 "land" => {                     let m = moves.as_deref().unwrap_or_else(|| err("place land needs --moves moves.json", &[]));@@ -3047,10 +3210,15 @@ fn main() {                 err("spec.planeUnder has an entry that does not parse", &["Use {\"layer\": \"B.Cu\", \"net\": \"GND\", \"around\": [\"U1\", \"C2\"], \"margin\": 1.0} or {\"layer\": ..., \"net\": ..., \"polygon\": [[x, y], ...]}.".into()]);             }             let preexisting = aiflow_router::plane_under::issues(&b, &regions);+            decoupling_check::refuse_bad_spec(&spec, &b);             if spec["stub"].as_f64().map(|s|s<rules.stub).unwrap_or(false){eprintln!("Hint: escape width raised to {} mm to satisfy minTrackWidth (default: track width). Declare a smaller manufacturing minimum only when the board process supports it.",rules.stub);}             r.stage_start("route", Some("binary"), Some(&format!("passes={passes}")));             let mut router = aiflow_router::Router::new(b, rules, true);-            let (plan, report, failed) = aiflow_router::drive::route_board(&mut router, *passes, *rip_per_net, *rip_global);+            let (mut plan, mut report, failed) = aiflow_router::drive::route_board(&mut router, *passes, *rip_per_net, *rip_global);+            // issue #39: staircases to clean 45 degree runs before the gate (the router's own clearance check decides)+            let simp = aiflow_router::simplify::simplify_plan(&mut router, &mut plan);+            report["simplify"] = simp.clone();+            let simp_line = format!("simplified: {} staircase(s) replaced, {} kept (no clear 45 degree path), {} collinear point(s) merged; vertices {} -> {} (per net in plan-route-report.json \"simplify\")", simp["staircasesReplaced"], simp["staircasesKept"], simp["collinearMerged"], simp["verticesBefore"], simp["verticesAfter"]);             std::fs::write(dir.join("router.log"), router.log_lines.join("\n")).ok();             let planp = dir.join("plan-route.json");             let bc = report["boardCopper"].clone();@@ -3070,6 +3238,8 @@ fn main() {             }             write_json(&planp, &plan_doc);             write_json(&dir.join("plan-route-report.json"), &report);+            let dec = decoupling_check::review_route(&spec, &router.board, &plan_doc, &report, r.outcomes().get("pour"));+            decoupling_check::record(&mut r, &dir, &dec);             let unrouted = report["unrouted"].as_array().cloned().unwrap_or_default();             r.stage_end("route", Some(json!({"unrouted": failed, "passes": passes})), None);             r.outcome("route", json!({"plan": planp.display().to_string(), "unrouted": failed, "detail": unrouted.iter().take(20).cloned().collect::<Vec<_>>(), "boardCopper": if has_copper { bc.clone() } else { Value::Null }, "planeUnder": regions.len()}));@@ -3097,11 +3267,12 @@ fn main() {                 let region_hint = if regions.is_empty() { String::new() } else { "A planeUnder region is a keepout for every other net on its layer: a pin inside it can only leave on the other layer. Shrink the margin, list fewer parts, or give the region a polygon that leaves that pin a way out.".to_string() };                 err(&format!("routing closed {failed} connection(s) short after {passes} passes: {}", detail.join("; ")), &[format!("More passes: --passes {}.", passes + 4), format!("Or go back to placement: the blockers are {:?}; move the parts on those nets, or the test points and indicators in the escape band, with `place pack` and `place check`, then route again.", blockers.iter().take(8).collect::<Vec<_>>()), region_hint, policy_hint, "Or take the stage yourself: `adom-aiflow take route=ai`.".into()]);             }+            decoupling_check::refuse_errors("route", &dec);             if has_copper && plan.is_empty() {                 ok(&format!("nothing to route: the board's own copper already joins every net ({} track pieces, {} vias); empty plan {}", bc["trackPieces"], bc["vias"], planp.display()), &["Next: adom-aiflow gate (DRC on the board as it is), then land route (lands nothing and records it), pour, land vias, land pours.".into(), policy_hint]);             } else {                 let copper_line = if has_copper { format!("; the board's own copper was kept and {} connection(s) it left open were planned", bc["openConnections"]) } else { String::new() };-                ok(&format!("routing closed: 0 unrouted after {passes} passes; plan {}{copper_line}", planp.display()), &["Next: adom-aiflow gate (KiCad DRC offline on the plan).".into(), policy_hint]);+                ok(&format!("routing closed: 0 unrouted after {passes} passes; plan {}{copper_line}\n{simp_line}", planp.display()), &["Next: adom-aiflow gate (KiCad DRC offline on the plan).".into(), policy_hint]);             }         }         Cmd::Pour { plan } => {@@ -3119,6 +3290,7 @@ fn main() {             let zp = dir.join("plan-pours.json");             let vp = dir.join("plan-vias.json");             write_json(&zp, &json!({"zones": zones}));+            pourverify::record_plan(&mut r.data, &zp, "pour").unwrap_or_else(|e| err(&e, &[]));             write_json(&vp, &json!({"engine": "adom-aiflow pour plan (thermal and stitching vias)", "nets": vias}));             r.stage_end("pour", Some(json!({"zones": zones.len(), "keepouts": keepouts, "vias": vias.len()})), None);             r.outcome("pour", json!({"pours": zp.display().to_string(), "vias": vp.display().to_string(), "zones": zones.len(), "keepouts": keepouts, "viaCount": vias.len()}));@@ -3209,13 +3381,21 @@ fn main() {             // the switch node: short, and never under another part (switchnode.rs)             let sw_issues = { let rb = Board::from_text(&routed.display().to_string(), text.clone()).unwrap_or_else(|e| err(&e, &[])); switchnode::findings(&spec_g, &rb) };             s["switchNodeIssues"] = json!(sw_issues);+            let dec = decoupling_check::review_text("gate", &spec_g, &routed.display().to_string(), &text, !adds_copper, if adds_copper && !aiflow_copper::native_drc_available() { "an approximate raster fill by the gate, not a native refill" } else { "the zone fills saved in the board file" }, &plan_v, None, r.outcomes().get("pour"));+            if let Some(d) = &dec { s["decoupling"] = d.value.clone(); }+            // issue #39: courtyards and bodies (aiflow's own geometry), staircases left in the copper (a warning)+            let mech = mechanical::applies(&r.current_board()).then(|| { let rb = Board::from_text(&routed.display().to_string(), text.clone()).unwrap_or_else(|e| err(&e, &[])); mechanical::check_board(&rb, &routed.display().to_string(), &project_dir_of(&r), &spec_g) });+            let stairs = Board::from_text(&routed.display().to_string(), text.clone()).map(|rb| aiflow_router::simplify::board_staircases(&rb)).unwrap_or_default();+            s["mechanical"] = mech.as_ref().map(|m| m.to_json()).unwrap_or(json!("not checked: Fusion board"));+            s["staircases"] = json!(stairs);+            decoupling_check::record(&mut r, &dir, &dec);             if plan_v["nets"].as_array().map(|a| a.is_empty()).unwrap_or(false) { s["note"] = plan_v.get("note").cloned().unwrap_or(json!("empty plan: the board is gated as it is")); }             if !plan_notes.is_empty() { s["planNormalised"] = json!(plan_notes); }             write_json(&dir.join("gate.json"), &s);             let (newe, unc, inh) = (s["newErrors"].as_u64().unwrap_or(1), s["unconnected"].as_u64().unwrap_or(1), s["inheritedErrors"].as_u64().unwrap_or(0));             let npu = pu_issues.len() as u64;             r.stage_end("gate", Some(json!({"newErrors": newe, "unconnected": unc, "inheritedErrors": inh, "planeUnderIssues": npu})), None);-            r.outcome("gate", json!({"report": dir.join("gate.json").display().to_string(), "newErrors": newe, "unconnected": unc, "planeUnderIssues": npu, "routedBoard": routed.display().to_string(), "plan": planp, "planNormalised": plan_notes}));+            r.outcome("gate", json!({"report": dir.join("gate.json").display().to_string(), "newErrors": newe, "unconnected": unc, "planeUnderIssues": npu, "courtyardsOk": mech.as_ref().map(|m| m.courtyards_ok()), "bodiesOk": mech.as_ref().map(|m| m.bodies_ok()), "staircases": stairs.len(), "routedBoard": routed.display().to_string(), "plan": planp, "planNormalised": plan_notes}));             r.save().unwrap();             if !sw_issues.is_empty() {                 r.outcome("switch-node", json!({"issues": sw_issues}));@@ -3249,15 +3429,22 @@ fn main() {                 let pu_hint = if npu > 0 { format!("Also {npu} planeUnder issue(s): {}", pu_issues.iter().take(4).cloned().collect::<Vec<_>>().join("; ")) } else { String::new() };                 err(&format!("gate failed: {newe} new DRC errors, {unc} unconnected (inherited {inh})"), &[pu_hint, format!("New errors: {}", s["newErrorTypes"]), format!("Unconnected: {}", s["unconnectedList"].as_array().map(|a| a.iter().take(6).map(|x| x.to_string()).collect::<Vec<_>>().join("; ")).unwrap_or_default()), hair_hint, "Fix the plan (route again, or move parts) and gate again; nothing lands until this passes.".into()]);             }+            decoupling_check::refuse_errors("gate", &dec);+            if let Some(m) = &mech {+                for n in &m.severity_notes { eprintln!("Warning: {n}"); }+                if !m.errors().is_empty() { err(&format!("gate failed: courtyards or part bodies:\n  {}", m.errors().join("\n  ")), &[m.hint(), "See gate.json \"mechanical\". Courtyard overlap is an error here whatever severity the project gives it.".into()]); }+            } else { eprintln!("Warning: courtyards and part bodies not checked: a Fusion board carries no courtyard geometry aiflow reads; check them in Fusion's DRC"); }+            if !stairs.is_empty() { eprintln!("Warning: {} staircase run(s) left in the copper (tiny alternating 0/90 degree steps; redraw as one 45 degree segment):\n  {}", stairs.len(), stairs.iter().take(8).cloned().collect::<Vec<_>>().join("\n  ")); }+            let checked = match &mech { Some(m) => format!("; courtyards present and clear on {} footprint(s), {} part bodies clear", m.with_courtyard, m.bodies_checked), None => "; courtyards and bodies not checked (Fusion board)".into() };             let empty = plan_v["nets"].as_array().map(|a| a.is_empty()).unwrap_or(false);-            ok(&format!("gate passed: 0 new DRC errors ({inh} inherited), 0 unconnected{}; copper {}", if pu.is_empty() { String::new() } else { format!(", {} planeUnder region(s) clear", pu.len()) }, s["copper"]), &[if empty { "The plan is empty: the board's own copper already joins every net. Next: adom-aiflow land route (records that nothing needs landing), then pour, land vias, land pours.".into() } else { "Next: adom-aiflow land route (then pour, land vias, land pours).".into() }]);+            ok(&format!("gate passed: 0 new DRC errors ({inh} inherited), 0 unconnected{}{checked}; copper {}\nThis is the routing gate (DRC, connectivity, courtyards, bodies), not a fabrication check: pours in the saved board, Gerbers and human review come later.", if pu.is_empty() { String::new() } else { format!(", {} planeUnder region(s) clear", pu.len()) }, s["copper"]), &[if empty { "The plan is empty: the board's own copper already joins every net. Next: adom-aiflow land route (records that nothing needs landing), then pour, land vias, land pours.".into() } else { "Next: adom-aiflow land route (then pour, land vias, land pours).".into() }]);         }         Cmd::Land { what, plan, moves, pause_ms, from } => {             let mut r = load_run(&cli);             if what == "route" {                 // a gated empty plan (the board's own copper already joins every net): nothing to land, no bridge call                 let gate = r.outcomes().get("gate").cloned().unwrap_or(Value::Null);-                let gate_ok = gate["newErrors"].as_u64() == Some(0) && gate["unconnected"].as_u64() == Some(0) && gate["planeUnderIssues"].as_u64().unwrap_or(0) == 0;+                let gate_ok = gate["newErrors"].as_u64() == Some(0) && gate["unconnected"].as_u64() == Some(0) && gate["planeUnderIssues"].as_u64().unwrap_or(0) == 0 && mechanical::gate_clear(&gate);                 let planp = plan.clone().or_else(|| gate["plan"].as_str().map(str::to_string));                 let empty_after_normalising = |p: &String| { let (v, _) = read_plan_normalised(p, &board_of(&r)); v["nets"].as_array().map(|a| a.is_empty()).unwrap_or(false) };                 if let Some(planp) = planp.filter(|p| gate_ok && plan.is_none() && empty_after_normalising(p)) {@@ -3294,7 +3481,7 @@ fn main() {                 }                 "route" | "vias" => {                     let planp = if what == "route" {-                        let gate_ok = r.outcomes().get("gate").and_then(|g| g.get("newErrors")).and_then(|v| v.as_u64()) == Some(0) && r.outcomes().get("gate").and_then(|g| g.get("unconnected")).and_then(|v| v.as_u64()) == Some(0) && r.outcomes().get("gate").and_then(|g| g.get("planeUnderIssues")).and_then(|v| v.as_u64()).unwrap_or(0) == 0;+                        let gate_ok = r.outcomes().get("gate").and_then(|g| g.get("newErrors")).and_then(|v| v.as_u64()) == Some(0) && r.outcomes().get("gate").and_then(|g| g.get("unconnected")).and_then(|v| v.as_u64()) == Some(0) && r.outcomes().get("gate").and_then(|g| g.get("planeUnderIssues")).and_then(|v| v.as_u64()).unwrap_or(0) == 0 && r.outcomes().get("gate").map(mechanical::gate_clear).unwrap_or(false);                         if !gate_ok && plan.is_none() {                             err("the gate has not passed for this plan", &["Run `adom-aiflow gate` first; the finish line needs it.".into()]);                         }@@ -3388,6 +3575,7 @@ fn main() {                     let zp = r.outcomes().get("pour").and_then(|p| p.get("pours")).and_then(|p| p.as_str()).map(str::to_string).unwrap_or_else(|| err("no pours plan; run `adom-aiflow pour` first", &[]));                     let b = board_of(&r);                     let zones = aiflow_pours::resolve_outline(&b, read_json(&zp)["zones"].as_array().unwrap_or(&Vec::new()));+                    pourverify::landable(&zones).unwrap_or_else(|e| err(&e, &["Write that zone natively in KiCad, save and fill it, then accept it with `verify-pours --plan <plan>` (add --adopt --why to own it). Nothing was landed.".into()]));                     r.stage_start("land-pours", Some("binary"), None);                     let before = br.zone_state(&rb, true);                     if !Bridge::ok(&before) { err("cannot read settled zones before landing", &[before.to_string()]); }@@ -3435,25 +3623,10 @@ fn main() {                 other => err(&format!("land {other}: use moves, route, vias or pours"), &[]),             }         }-        Cmd::VerifyPours { plan } => {+        Cmd::VerifyPours { plan, adopt, why, record_plan } => {+            if *adopt || *record_plan { thread(&cli); }             let mut r = load_run(&cli);-            let board_hash = pourverify::hash(Path::new(&r.current_board())).unwrap_or_else(|e|err(&e,&[]));-            let plan_hash = pourverify::hash(Path::new(plan)).unwrap_or_else(|e|err(&e,&[]));-            let b = board_of(&r);-            let mut proof = pourverify::check(&b, &read_json(plan)).unwrap_or_else(|e| err(&e, &[]));-            if pourverify::hash(Path::new(&r.current_board())).ok().as_deref()!=Some(&board_hash)-                || pourverify::hash(Path::new(plan)).ok().as_deref()!=Some(&plan_hash) {-                err("board or plan changed during verification; retry after the writer finishes", &[]);-            }-            proof["boardSha256"] = json!(board_hash);-            proof["specSha256"] = json!(pourverify::hash(Path::new(r.data["spec"].as_str().unwrap_or(""))).unwrap_or_else(|e|err(&e,&[])));-            proof["planSha256"] = json!(plan_hash);-            proof["plan"] = json!(std::fs::canonicalize(plan).unwrap_or_else(|e|err(&e.to_string(),&[])));-            write_json(&dir.join("verify-pours.json"), &proof);-            r.outcome("land-pours", proof.clone());-            r.save().unwrap();-            if proof["pass"] != true { err(&format!("saved pours do not match the plan: {}",proof["failed"]), &["Review the actual geometry and intended plan; never replay pours merely to restore evidence. No board or ownership was changed.".into()]); }-            ok("existing saved pours match the reviewed plan; no copper or ownership changed", &["Native DRC, live measurement, current and thermal checks remain required. Changed board, spec or plan invalidates this proof.".into()]);+            match pourverify::command(&mut r, &dir, plan, *adopt, why.as_deref(), *record_plan) { Ok((m, h)) => ok(&m, &h), Err((m, h)) => err(&m, &h) }         }         Cmd::Measure => {             let mut r = load_run(&cli);@@ -3473,8 +3646,9 @@ fn main() {             r.save().unwrap();             ok(&format!("copper kept per layer ({}'s fills): {}; coverage {}", aiflow_bridge::eda::active().name(), zs["filledAreaByLayerMm2"], zs["filledCoverageByLayerPercent"]), &["Next: adom-aiflow analyze current, analyze thermal.".into()]);         }-        Cmd::Analyze { what, plan, fields } => {-            thread(&cli);+        Cmd::Analyze { what, plan, fields, ack, why } => {+            let t = thread(&cli);+            if !ack.is_empty() && what != "current" { err("--ack acknowledges a current-density peak: `analyze current --ack [email protected] --why ...`", &[]); }             let mut r = load_run(&cli);             let planp = plan.clone().or_else(|| r.outcomes().get("route").and_then(|o| o.get("plan")).and_then(|p| p.as_str()).map(str::to_string)).unwrap_or_else(|| err("no routing plan", &["Run route, or pass --plan.".into()]));             // a Fusion run analyzes the board as it is in Fusion now, not the placement snapshot@@ -3487,7 +3661,7 @@ fn main() {             let zs = if zsp.is_file() { Some(read_json(&zsp.display().to_string())) } else { None };             let name = format!("analyze-{what}");             r.stage_start(&name, Some("binary"), None);-            let (heuristic_passed, res) = match what.as_str() { "current" => aiflow_analyze::analyze_current_on_board(&plan_v, &spec, zs.as_ref(), Some(&pad_layers_of(&board_now)), &board_now), "thermal" => aiflow_analyze::analyze_thermal_on_board(&plan_v, &spec, zs.as_ref(), &board_now), other => err(&format!("analyze {other}: use current or thermal"), &[]) };+            let (mut heuristic_passed, mut res) = match what.as_str() { "current" => aiflow_analyze::analyze_current_on_board(&plan_v, &spec, zs.as_ref(), Some(&pad_layers_of(&board_now)), &board_now), "thermal" => aiflow_analyze::analyze_thermal_on_board(&plan_v, &spec, zs.as_ref(), &board_now), other => err(&format!("analyze {other}: use current or thermal"), &[]) };             let mut fields_file=fields.clone().unwrap_or_else(||dir.join("fields/fields.json"));             // provenance: a fields.json is evidence only when it is the output of a solve aiflow ran or watched;             // any other file (copied, edited, or written to look like one) is solved again here, same inputs@@ -3502,18 +3676,52 @@ fn main() {                     Err(e) => { unobserved = Some(format!("{} was not produced by an Adom Fields solve this run watched, and adom-fields could not start ({e}): install adom-fields, then `adom-aiflow exec -- adom-fields {}`", fields_file.display(), args.join(" "))); }                 }             }-            let screen=if let Some(u)=unobserved.clone() { Err(u) } else if !aiflow_analyze::needs_field_screen(&spec,what) { Ok(()) } else if fields_file.is_file() {+            if !ack.is_empty() && (unobserved.is_some() || !fields_file.is_file()) { err("--ack needs a same-input Fields solve this run watched to read the peak from; analyze current without --ack first", &[]); }+            let mut expired_acks: Vec<Value> = Vec::new();+            let mut sink_notes: Vec<String> = Vec::new();+            let screen=if let Some(u)=unobserved.clone() { Err(u) } else if !aiflow_analyze::needs_field_screen(&spec,what) { Ok(Vec::new()) } else if fields_file.is_file() {                 let f=read_json(&fields_file.display().to_string());-                let board_bytes=std::fs::read(&solved_board).unwrap_or_else(|e|err(&e.to_string(),&[]));+                if let Err(e)=std::fs::metadata(&solved_board) { err(&e.to_string(),&[]); }                 let spec_bytes=std::fs::read(r.data["spec"].as_str().unwrap_or("")).unwrap_or_else(|e|err(&e.to_string(),&[]));-                aiflow_analyze::field_screen(&f,&spec,&board_bytes,&spec_bytes,what).map_err(|e| if e.contains("identity") { format!("{e}: adom-fields analyze --board {solved_board} --spec {} --out {}",r.data["spec"].as_str().unwrap_or(""),dir.join("fields").display()) } else { e })+                // issue #70: record reviewed part-limited peaks, then screen with the live ones+                let live_acks = if what == "current" {+                    let copper = ack_copper(live.as_ref().map(|l| l.1.as_str()).unwrap_or(&solved_board));+                    if !ack.is_empty() {+                        let spec_sha = { use sha2::{Digest, Sha256}; format!("{:x}", Sha256::digest(&spec_bytes)) };+                        if f["inputIdentity"]["spec"].as_str() != Some(spec_sha.as_str()) || copper_carry::carried_from(&r.data, f["inputIdentity"]["board"].as_str().unwrap_or(""), Path::new(&solved_board)).is_err() { err("--ack: the Fields report is not of this saved board (or its carried-over copper) and spec; solve again, then acknowledge", &[]); }+                        let copper = copper.clone().unwrap_or_else(|e| err(&format!("--ack: this board has no copper fingerprint to bind the acknowledgement to ({e})"), &[]));+                        let w = why.clone().unwrap_or_else(|| err("--ack needs --why \"<what limits the peak and why the board cannot change it>\"", &[]));+                        let limit = spec["maxCurrentDensityAperMm2"].as_f64().unwrap_or(60.0);+                        for a in ack.iter() {+                            let rec = aiflow_analyze::current_acks::record(a, &w, &t, &f, &board_now, &copper, limit, &now()).unwrap_or_else(|e| err(&e, &["The place is a pad of the part that limits the peak (REF.PAD on that net) or the Fields peak location x,y within 0.5 mm.".into()]));+                            let mut list: Vec<Value> = r.data["currentAcks"].as_array().cloned().unwrap_or_default();+                            list.retain(|x| x["target"] != rec["target"]);+                            list.push(rec);+                            r.data["currentAcks"] = json!(list);+                        }+                        r.save().unwrap();+                    }+                    let (live_a, expired) = aiflow_analyze::current_acks::split_live(&r.data["currentAcks"], &copper.unwrap_or_else(|_| "unavailable".into()), f["inputIdentity"]["spec"].as_str().unwrap_or(""));+                    expired_acks = expired;+                    live_a+                } else { Vec::new() };+                let s = copper_carry::field_screen_with_acks(&r.data,&f,&spec,Path::new(&solved_board),&spec_bytes,what,&live_acks).map(|(n, c)| { if let Some(n) = n { eprintln!("{n}"); } c }).map_err(|e| if e.contains("identity") { format!("{e}: adom-fields analyze --board {solved_board} --spec {} --out {}",r.data["spec"].as_str().unwrap_or(""),dir.join("fields").display()) } else { e });+                // issue #67: the same-input solve with a declared board-sink block stands in for the estimate+                if what == "thermal" && s.is_ok() { sink_notes = aiflow_analyze::board_sink::accept_solve(&mut res, &spec, &f); heuristic_passed = res.iter().all(|x| x["status"] == "pass"); }+                s             } else { Err(format!("no field solve at {}; run adom-fields analyze --board {} --spec {} --out {}, then analyze {what} --fields {}",fields_file.display(),solved_board,r.data["spec"].as_str().unwrap_or(""),dir.join("fields").display(),dir.join("fields/fields.json").display())) };             let passed=heuristic_passed && screen.is_ok();+            let covered_acks = screen.as_ref().map(|c| c.clone()).unwrap_or_default();+            let sink_assumptions = aiflow_analyze::board_sink::assumptions(&res);             let field_note=screen.err().unwrap_or_else(||"same-input field screen passed under its stated assumptions".into());             r.stage_end(&name, Some(json!({"pass": passed})), None);-            r.outcome(&name, json!({"pass": passed, "heuristicPass":heuristic_passed, "fieldReport":fields_file, "fieldNote":field_note, "results": res}));+            r.outcome(&name, json!({"pass": passed, "heuristicPass":heuristic_passed, "fieldReport":fields_file, "fieldNote":field_note, "results": res, "acknowledgedPeaks": covered_acks, "expiredAcks": expired_acks, "boardSinkAssumptions": sink_assumptions, "boardSinkNotes": sink_notes}));             r.save().unwrap();-            let lines: Vec<String> = res.iter().map(|x| format!("{} {}: {}", x.get("net").or(x.get("ref")).and_then(|v| v.as_str()).unwrap_or("?"), x["status"].as_str().unwrap_or(""), x.get("how").or(x.get("hint")).and_then(|v| v.as_str()).unwrap_or(""))).collect();+            let mut lines: Vec<String> = res.iter().map(|x| format!("{} {}: {}", x.get("net").or(x.get("ref")).and_then(|v| v.as_str()).unwrap_or("?"), x["status"].as_str().unwrap_or(""), x.get("how").or(x.get("hint")).and_then(|v| v.as_str()).unwrap_or(""))).collect();+            for c in &covered_acks { lines.push(format!("acknowledged peak: {} {:.1} A/mm2 at ({:.2}, {:.2}) {} by --ack {}: \"{}\" ({}); Fields reports one maximum per net, so check its density map for a second spot", c["net"].as_str().unwrap_or(""), c["peakJ"].as_f64().unwrap_or(0.0), c["at"][0].as_f64().unwrap_or(0.0), c["at"][1].as_f64().unwrap_or(0.0), c["layer"].as_str().unwrap_or(""), c["ack"].as_str().unwrap_or(""), c["why"].as_str().unwrap_or(""), c["aiThread"].as_str().unwrap_or(""))); }+            for a in &expired_acks { lines.push(format!("expired acknowledgement (copper or spec changed since the review; acknowledge again if it still holds): {}", aiflow_analyze::current_acks::describe(a, "expired"))); }+            for a in &sink_assumptions { lines.push(format!("board-sink assumption: {a}")); }+            for n in &sink_notes { lines.push(format!("board sink: {n}")); }             // the copper this analysis judged: the nets with pours, for the drawing and the walkthrough             let mut pour_nets: Vec<String> = Vec::new();             for x in &res {@@ -3559,20 +3767,25 @@ fn main() {             let o = r.outcomes().clone();             let mut missing = Vec::new();             let placement=o.get("place-land").cloned().unwrap_or(Value::Null);-            if placement["mode"]=="verified-existing" && !placement_verify::bound(&placement,Path::new(&r.current_board()),Path::new(r.data["spec"].as_str().unwrap_or(""))) {+            if placement["mode"]=="verified-existing" && copper_carry::placement_bound(&r.data,&placement,Path::new(&r.current_board()),Path::new(r.data["spec"].as_str().unwrap_or(""))).map(|n| { if let Some(n) = n { eprintln!("{n}"); } }).is_err() {                 missing.push("place verify (saved board or spec changed; verify again)".into());             }             let gate = o.get("gate").cloned().unwrap_or(Value::Null);             if gate["newErrors"].as_u64() != Some(0) || gate["unconnected"].as_u64() != Some(0) {                 missing.push("gate: 0 new DRC errors and 0 unconnected (run gate)".to_string());             }+            if let Some(m) = decoupling_check::blocks_finish(o.get("decoupling")) { missing.push(m); }+            if let Some(m) = placement_intent::blocks_finish(o.get("placement-intent")) { missing.push(m); }+            if !mechanical::gate_clear(&gate) {+                missing.push("gate: courtyards and part bodies (missing or overlapping; see gate.json \"mechanical\")".to_string());+            }             if gate["planeUnderIssues"].as_u64().unwrap_or(0) > 0 {                 missing.push(format!("gate: {} planeUnder issue(s) (other-net copper inside a plane region; see gate.json)", gate["planeUnderIssues"]));             }             if !o.contains_key("land-route") {                 missing.push("land route".into());             }-            if o.get("land-pours").map(|p| !p["failed"].as_array().map(|a| a.is_empty()).unwrap_or(false) || !pourverify::bound(p, Path::new(&r.current_board()), Path::new(r.data["spec"].as_str().unwrap_or("")))).unwrap_or(true) {+            if o.get("land-pours").map(|p| !p["failed"].as_array().map(|a| a.is_empty()).unwrap_or(false) || copper_carry::pours_bound(&r.data, p, Path::new(&r.current_board()), Path::new(r.data["spec"].as_str().unwrap_or(""))).map(|n| { if let Some(n) = n { eprintln!("{n}"); } }).is_err()).unwrap_or(true) {                 missing.push("land pours or verify-pours (every planned zone accepted; current inputs required)".into());             }             if !measurement_usable(o.get("measure")) {@@ -3582,22 +3795,27 @@ fn main() {             let live_board = live_board(&r, &cli, &dir);             let solved_board = live_board.as_ref().map(|l| l.0.clone()).unwrap_or_else(|| r.current_board());             let board_now = || match &live_board { Some((_, k)) => Board::load(k).unwrap_or_else(|e| err(&e, &[])), None => board_of(&r) };+            let mut acked_peaks: Vec<Value> = Vec::new();             for k in ["analyze-current", "analyze-thermal"] {                 if o.get(k).and_then(|a| a["pass"].as_bool()) != Some(true) {                     missing.push(format!("{k} (pass)"));                 } else {                     if !aiflow_analyze::needs_field_screen(&spec_of(&r),k.trim_start_matches("analyze-")){continue;}                     let report=o[k]["fieldReport"].as_str().and_then(|p|std::fs::read(p).ok()).and_then(|b|serde_json::from_slice::<Value>(&b).ok());-                    let board_bytes=std::fs::read(&solved_board).unwrap_or_default();                     let spec_bytes=std::fs::read(r.data["spec"].as_str().unwrap_or("")).unwrap_or_default();                     if let Some(report)=report {                         let report_path=o[k]["fieldReport"].as_str().unwrap_or("").to_string();                         if !fields_observed(&r, Path::new(&report_path)) { missing.push(format!("{k}: the field report was not produced by an Adom Fields solve this run watched (analyze {} again; aiflow solves it)", k.trim_start_matches("analyze-"))); }-                        if let Err(reason)=aiflow_analyze::field_screen(&report,&spec_of(&r),&board_bytes,&spec_bytes,k.trim_start_matches("analyze-")) { missing.push(format!("{k}: {reason}")); }+                        // issue #70: only acknowledgements of this copper fingerprint and this Fields spec identity cover a peak+                        let live_acks = if k == "analyze-current" { aiflow_analyze::current_acks::split_live(&r.data["currentAcks"], &ack_copper(live_board.as_ref().map(|l| l.1.as_str()).unwrap_or(&solved_board)).unwrap_or_else(|_| "unavailable".into()), report["inputIdentity"]["spec"].as_str().unwrap_or("")).0 } else { Vec::new() };+                        match copper_carry::field_screen_with_acks(&r.data,&report,&spec_of(&r),Path::new(&solved_board),&spec_bytes,k.trim_start_matches("analyze-"),&live_acks) { Err(reason) => missing.push(format!("{k}: {reason}")), Ok((n, c)) => { if let Some(n) = n { eprintln!("{n}"); } acked_peaks.extend(c); } }                     } else { missing.push(format!("{k}: same-input field report required; rerun analyze")); }                 }             }             if let Err(m) = netlist_gate(&r) { missing.push(m); }+            if let Err(m) = schematic_symbols::gate(&r) { missing.push(m); }+            let silk_warnings = silk_polarity::warnings(&board_now());+            for w in &silk_warnings { eprintln!("Warning: {w}"); }             let spec_f = spec_of(&r);             if let Some((p, layers, warning)) = checks::rules_target(&spec_f, &r.data["fabRules"]) {                 if let Some(w) = warning { eprintln!("Warning: {w}"); }@@ -3606,20 +3824,25 @@ fn main() {             if let Some(f) = molecule_findings(&spec_f, &board_now(), Some(&r)) {                 if !f.errors.is_empty() { missing.push(format!("molecule check ({})", f.errors.join("; "))); }             }+            // issue #39: courtyards, part bodies and the pours in the saved board (the board that ships)+            let facts = (live_board.is_none() && mechanical::applies(&solved_board)).then(|| verified::board_facts(&board_now(), &solved_board, &project_dir_of(&r), &spec_soft(&r)));+            match &facts {+                Some(f) => {+                    for n in &f.mech.severity_notes { eprintln!("Warning: {n}"); }+                    for e in f.mech.errors() { missing.push(format!("mechanical: {e} ({})", f.mech.hint())); }+                    for p in &f.fill_problems { missing.push(format!("pours in the saved board: {p} ({})", fills::HINT)); }+                }+                None => eprintln!("Warning: courtyards, bodies and saved pours not checked here (Fusion board); the summary says so"),+            }             {-                let (mut labels, fps) = provenance::silk_labels(&board_now());+                let (labels, fps) = provenance::silk_labels(&board_now());                 // On the Fusion lane the board checked here is the KiCad copy converted from the Fusion .brd,-                // and the converter carries no silkscreen text (issue #74: 44 texts in the .brd, 0 in the copy),-                // so every Fusion board failed. There the count comes from `fusion silkscreen`'s own proof.+                // which now carries its silkscreen text (issue #74); `fusion silkscreen`'s proof is the second source.                 if aiflow_bridge::eda::active().id() == "fusion" {-                    match std::fs::read_to_string(dir.join("proofs").join("silkscreen.json")).ok().and_then(|t| serde_json::from_str::<Value>(&t).ok()) {-                        Some(p) => {-                            labels = labels.max(p["data"]["labels"].as_u64().unwrap_or(0) as usize);-                            let failed = p["data"]["failed"].as_u64().unwrap_or(0);-                            if failed > 0 { missing.push(format!("silkscreen: {failed} step(s) of `adom-aiflow fusion silkscreen` failed; run it again (skill aiflow-silkscreen)")); }-                        }-                        None => missing.push("silkscreen: not drawn yet on the Fusion board; run `adom-aiflow fusion silkscreen` (skill aiflow-silkscreen)".to_string()),-                    }+                    let proof = std::fs::read_to_string(dir.join("proofs").join("silkscreen.json")).ok().and_then(|t| serde_json::from_str::<Value>(&t).ok());+                    let (m, w) = provenance::fusion_silk(labels, fps, proof.as_ref());+                    missing.extend(m);+                    if let Some(w) = w { eprintln!("Warning: {w}"); }                 }                 if fps > 0 && (labels as f64) < provenance::MIN_SILK_PER_FOOTPRINT * fps as f64 {                     missing.push(format!("silkscreen: {labels} visible label(s) for {fps} footprints (finished boards carry at least {:.1} per footprint): references, values and contact labels belong on the silkscreen (skill aiflow-silkscreen)", provenance::MIN_SILK_PER_FOOTPRINT));@@ -3707,6 +3930,7 @@ fn main() {                     }                 }             }+            if copper_carry::silk_dropped(&r.data) { missing.push("silkscreen proof (adopt-board changed the board file; `silkscreen-audit --record` again)".into()); }             // the test plan again, on the finished board: every measurement still has a landing             if let Some(tp) = r.data["testPlan"].as_str().map(str::to_string) {                 let list = testplan::tests_of(&read_json(&tp));@@ -3721,6 +3945,10 @@ fn main() {                 for b in sequence::blockers(&st, "finish") { missing.push(format!("step {b}")); }                 sequence::write_timeline(&dir, &sequence::timeline(&dir, &r.data, &flow_full, &seq, &r.step_report()), TIMELINE_PAGE);             }+            // parts from the board's own project library stay visible as evidence (issue #66)+            let parts_v = o.get("parts").map(|p| p["parts"].clone()).unwrap_or(Value::Null);+            let lib_parts = project_lib::report(&parts_v);+            for g in project_lib::recheck(&parts_v) { missing.push(format!("parts: project library: {g}")); }             if !missing.is_empty() {                 err(&format!("not finished: {}", missing.join("; ")), &["A board with any of these open is not a result. Keep going: the hints of the failing stage say what to change.".into()]);             }@@ -3730,12 +3958,18 @@ fn main() {             }             r.data["clock"]["finishTime"] = json!(now());             record_usage(&mut r, "finish");-            let summary = json!({"engine": r.data["engine"], "promptToFinishMinutes": r.elapsed_minutes(), "steps": Value::Object(r.step_report()), "turns": r.data["turns"].as_array().map(|a| a.len()).unwrap_or(0), "stageMinutes": Value::Object(r.stage_minutes()), "decisions": r.data["decisions"], "copper": o.get("measure"), "gate": o.get("gate"), "live": {"errors": live["errors"], "unconnected": live["unconnected"], "warnings": live["warnings"]}, "current": true, "thermal": true});+            let sink_assumptions = o.get("analyze-thermal").map(|x| x["boardSinkAssumptions"].clone()).filter(|v| v.is_array()).unwrap_or(json!([]));+            let mut reviewed: Vec<String> = acked_peaks.iter().map(|c| format!("acknowledged current peak: {} {:.1} A/mm2 at ({:.2}, {:.2}) {} ({}): \"{}\" by {}", c["net"].as_str().unwrap_or(""), c["peakJ"].as_f64().unwrap_or(0.0), c["at"][0].as_f64().unwrap_or(0.0), c["at"][1].as_f64().unwrap_or(0.0), c["layer"].as_str().unwrap_or(""), c["ack"].as_str().unwrap_or(""), c["why"].as_str().unwrap_or(""), c["aiThread"].as_str().unwrap_or(""))).collect();+            reviewed.extend(sink_assumptions.as_array().into_iter().flatten().filter_map(|a| a.as_str()).map(|a| format!("board-sink assumption: {a}")));+            let checked = verified::run_items(&r, facts.as_ref());+            let summary = json!({"verified": verified::to_json(&checked), "mechanical": facts.as_ref().map(|f| f.mech.to_json()), "poursInSavedBoard": facts.as_ref().map(|f| f.fills.clone()), "engine": r.data["engine"], "promptToFinishMinutes": r.elapsed_minutes(), "steps": Value::Object(r.step_report()), "turns": r.data["turns"].as_array().map(|a| a.len()).unwrap_or(0), "stageMinutes": Value::Object(r.stage_minutes()), "decisions": r.data["decisions"], "copper": o.get("measure"), "gate": o.get("gate"), "live": {"errors": live["errors"], "unconnected": live["unconnected"], "warnings": live["warnings"]}, "current": true, "thermal": true, "acknowledgedPeaks": acked_peaks, "boardSinkAssumptions": sink_assumptions});             r.data["summary"] = summary;             if let Some(rec) = spec_freeze::read(&r.dir) { r.data["summary"]["specAmendments"] = json!(spec_freeze::amendments(&rec)); }+            r.data["summary"]["projectLibraryParts"] = json!(lib_parts);+            r.data["summary"]["silkscreenWarnings"] = json!(silk_warnings);             r.log("finish", json!({"minutes": r.elapsed_minutes(), "steps": Value::Object(r.step_report())}));             r.save().unwrap();-            ok(&format!("finished: {} from the prompt to a board passing the configured screens, {:.1} min\n{}", r.data["engine"], r.elapsed_minutes(), step_table(&r)), &["The run is not delivered yet: cut the video, then `adom-aiflow deliver --video <mp4> --message \"<what you tell the human>\"`; the clock stops there, not here.".into(), "Add your token and dollar accounting to run.json under tokens and usd; the manifest is the row on the chart.".into(), give_back_hint()]);+            ok(&(format!("finished: {} from the prompt to a board passing the configured screens, {:.1} min\npours: {}\n{}{}", r.data["engine"], r.elapsed_minutes(), pourverify::mode_label(r.outcomes().get("land-pours").unwrap_or(&Value::Null)), step_table(&r), if lib_parts.is_empty() { String::new() } else { format!("\nparts from a project library (no public component page): {}", lib_parts.join("; ")) }) + &if reviewed.is_empty() { String::new() } else { format!("\nreviewed exceptions and assumptions:\n  {}", reviewed.join("\n  ")) } + "\n" + &verified::message(&checked)), &["Tell the human exactly the verified list above; never call the board ready to fabricate unless every item says yes, and even then advise a human review.".into(), "The run is not delivered yet: cut the video, then `adom-aiflow deliver --video <mp4> --message \"<what you tell the human>\"`; the clock stops there, not here.".into(), "Add your token and dollar accounting to run.json under tokens and usd; the manifest is the row on the chart.".into(), give_back_hint()]);         }         Cmd::Capture { action, label, reason } => {             let mut r = load_run(&cli);@@ -3799,6 +4033,7 @@ fn main() {                         err(&format!("recording stopped, but {} did not reach the run after {} pulls", p.clone().unwrap_or_default(), stop.attempts), &["The capture is flagged pullFailed with its desktop path; `adom-aiflow recut` pulls it again. Do it soon: the desktop cleans its recordings folder.".into()]);                     }                     let clips_note = auto_clips(&r, &dir);+                    if r.data["captures"][pos]["truncated"] == true { err(&format!("recording stopped, but the clip {} is truncated (no moov atom: the take died before it was finalised)", p.unwrap_or_default()), &["Re-record the step (`step <name> --back --why \"clip truncated\"`) while the work is fresh.".into(), clips_note]); }                     ok(&format!("recording stopped; {} pulled into the run", p.unwrap_or_default()), &["Frames arrive only when the screen changes on ab's recorder: the cut states real time from the markers.".into(), clips_note]);                 }                 "reject" => {@@ -3823,7 +4058,7 @@ fn main() {             ok(&format!("run {}, engine {}, {:.1} min since the prompt ({})\nstages (min): {}\ndecisions: {}\nroute: {} unrouted; gate: {} new / {} unconnected; pours: {}; measure: {}; current: {}; thermal: {}; finished: {}",                 dir.display(), r.data["engine"], r.elapsed_minutes(), r.data["clock"]["promptTime"], Value::Object(r.stage_minutes()), r.data["decisions"],                 o.get("route").map(|x| x["unrouted"].to_string()).unwrap_or("-".into()), o.get("gate").map(|x| x["newErrors"].to_string()).unwrap_or("-".into()), o.get("gate").map(|x| x["unconnected"].to_string()).unwrap_or("-".into()),-                if o.get("land-pours").map(|p| p["failed"].as_array().map(|a| a.is_empty()).unwrap_or(false)).unwrap_or(false) { if o["land-pours"]["mode"]=="verified-existing" { "verified existing" } else { "landed" } } else { "no" }, o.get("measure").map(|x| x["filledAreaByLayerMm2"].to_string()).unwrap_or("-".into()),+                if o.get("land-pours").map(|p| p["failed"].as_array().map(|a| a.is_empty()).unwrap_or(false)).unwrap_or(false) { pourverify::mode_label(&o["land-pours"]) } else { "no" }, o.get("measure").map(|x| x["filledAreaByLayerMm2"].to_string()).unwrap_or("-".into()),                 o.get("analyze-current").map(|x| x["pass"].to_string()).unwrap_or("-".into()), o.get("analyze-thermal").map(|x| x["pass"].to_string()).unwrap_or("-".into()), r.data["clock"]["finishTime"]), &[step_table(&r)]);         }         Cmd::Report { page, push, refresh, user_machine, surface } => {@@ -4030,6 +4265,9 @@ fn main() {             for m in rep["mismatches"].as_array().cloned().unwrap_or_default() {                 lines.push(format!("  {:<10} schematic {:<12} board {:<12} {}", m["pin"].as_str().unwrap_or(""), m["schematic"].as_str().unwrap_or("-"), m["board"].as_str().unwrap_or("-"), m["why"].as_str().unwrap_or("")));             }+            let sch_check = schematic_symbols::check(Path::new(&sch), &run.as_ref().map(spec_soft).unwrap_or(Value::Null));+            lines.push(schematic_symbols::summary_line(&sch_check));+            if let (Some(r), Ok(sc)) = (run.as_mut(), &sch_check) { schematic_symbols::record(r, &sch, sc); }             let fpd: Vec<String> = rep["footprintDifferences"].as_array().map(|a| a.iter().filter_map(|x| x.as_str().map(str::to_string)).collect()).unwrap_or_default();             if let Some(r) = run.as_mut() {                 let report = dir.join("netlist.json");@@ -4042,7 +4280,7 @@ fn main() {             if !passed {                 err(&format!("the board does not match the schematic\n{}", lines.join("\n")), &["Fix the side that is wrong: regenerate the board from the same netlist, or correct the schematic and export again (skill aiflow-schematic-to-board). Net names compare without the root sheet's leading /; unlabelled Net-(...) nets compare by their pins.".into(), fp_hint]);             }-            ok(&lines.join("\n"), &[if run.is_some() { "Recorded in the run; finish re-checks the stored netlist against the board it finishes on.".into() } else { "No run here: nothing recorded. Start the run with --sch so finish requires this check.".into() }, fp_hint]);+            ok(&lines.join("\n"), &["This is electrical parity between schematic and board only: not ERC, DRC, courtyards, pours or fabrication readiness; never tell the human the board can go to the fab on this result.".into(), if run.is_some() { "Recorded in the run; finish re-checks the stored netlist against the board it finishes on.".into() } else { "No run here: nothing recorded. Start the run with --sch so finish requires this check.".into() }, fp_hint]);         }         Cmd::Molecule { action: _, board, spec } => {             let mut run = Run::open(&dir);@@ -4399,15 +4637,12 @@ fn main() {             let d = v.get("data").cloned().unwrap_or(v.clone());             let counts = d["counts"].clone();             let unresolved = counts["unresolvedModel"].as_u64().unwrap_or(0) + counts["missingModel"].as_u64().unwrap_or(0);-            let mut missing: Vec<String> = Vec::new();-            for f in d["footprintsWithWarnings"].as_array().cloned().unwrap_or_default() {-                let fp = f["footprint"].as_str().unwrap_or("").to_string();-                let refs = f["references"].as_array().map(|a| a.iter().filter_map(|x| x.as_str()).collect::<Vec<_>>().join(",")).unwrap_or_default();-                let models: Vec<String> = f["models"].as_array().cloned().unwrap_or_default().iter().filter(|m| m["exists"].as_bool() != Some(true)).filter_map(|m| m["reference"].as_str().map(|s| s.to_string())).collect();-                if !models.is_empty() { missing.push(format!("{fp}{}: {}", if refs.is_empty() { String::new() } else { format!(" ({refs})") }, models.join(", "))); }-            }+            // complete modelBindings + viewer classes (KiCad Bridge 1.0.22+); file resolution is not render proof+            let mc = aiflow_bridge::model_check_summary(&d);+            let missing = mc.missing.clone();+            let vis = if mc.hidden.is_empty() { String::new() } else { format!("; NOT visible proof, {}: read/set with kicad_3d_viewer_settings (KiCad closed) and confirm in the 3D frame, never by changing BOM/POS/DNP flags", mc.hidden.join("; ")) };             r.stage_end("models", Some(json!({"counts": counts, "unresolved": unresolved})), None);-            r.outcome("models", json!({"counts": counts, "unresolved": unresolved, "missing": missing}));+            r.outcome("models", json!({"counts": counts, "unresolved": unresolved, "missing": missing, "viewerHidden": mc.hidden, "bindingsComplete": mc.bindings_complete, "evidenceSource": mc.evidence}));             r.log("artifact", json!({"step": "models", "kind": "model-check", "counts": counts}));             r.save().unwrap();             if !Bridge::ok(&v) && d["counts"].is_null() {@@ -4423,7 +4658,7 @@ fn main() {             if !unacked.is_empty() {                 err(&format!("every footprint has its 3D model, but {} model(s) may not be right way up:\n{}", unacked.len(), orient_lines.join("\n")), &[orient_hint]);             }-            ok(&format!("every footprint has its 3D model ({} with a model, {} expect none); 3D orientation: {} warning(s), all acknowledged; {} not checked here{}", counts["withModel"], counts["noModelExpected"], orient.len(), orient_notes.len(), if orient_lines.is_empty() { String::new() } else { format!("\n{}", orient_lines.join("\n")) }), &["Next: step placement.".into()]);+            ok(&format!("every footprint has its 3D model ({} with a model, {} expect none{vis}); 3D orientation: {} warning(s), all acknowledged; {} not checked here{}", counts["withModel"], counts["noModelExpected"], orient.len(), orient_notes.len(), if orient_lines.is_empty() { String::new() } else { format!("\n{}", orient_lines.join("\n")) }), &["Next: step placement.".into()]);         }         Cmd::Tour { what, nets, port, on } => {             let t = thread(&cli);@@ -4780,6 +5015,7 @@ fn main() {                         clip_artifacts(&mut r, &st, &f, 10);                     }                     clip_note.push_str(&format!("clip for {} stopped and pulled; ", prev.clone().unwrap_or_default()));+                    if r.data["captures"][pos]["truncated"] == true { clip_note.push_str(&format!("WARNING: clip {} is truncated (no moov atom): re-record it with `step {} --back --why \"clip truncated\"` if it matters; ", st.as_str().unwrap_or(""), cs.as_str().unwrap_or(""))); }                     clip_stopped = true;                 }                 // Recording can be delegated to another host without changing the EDA target.@@ -4819,7 +5055,11 @@ fn main() {                     if !HYDROGEN.contains(&name.as_str()) && !matches!(name.as_str(), "library" | "schematic") { br.bring_front(br.pcb_editor_hwnd(), "KiCad"); }                 }                 let cached = r.data["captures"].as_array().and_then(|c| c.iter().rev().find_map(|e| e.get("hwnd").and_then(|h| h.as_i64())));-                let hwnd = if name == "fields" { None } else { cam.camera_window(&tx, name, cached) };+                // issue #59: a step before the board films Hydrogen's dashboard, the AI's window or the tool's own+                // window, never an idle editor; nothing meaningful on screen is a recorded skip+                let pre_cam = (name != "fields" && clipwatch::preboard_step(name)).then(|| clipwatch::choose_preboard(&br, &*cam, name, r.data["engine"].as_str().unwrap_or("")));+                if let Some(clipwatch::Camera::Window { what, .. }) = &pre_cam { if what.starts_with("Hydrogen") { ensure_dashboard(&dir, &thread(&cli), true); } }+                let hwnd = match &pre_cam { Some(clipwatch::Camera::Window { hwnd, .. }) => Some(*hwnd), Some(clipwatch::Camera::Skip(_)) => None, None => if name == "fields" { None } else { cam.camera_window(&tx, name, cached) } };                 let disk = disk_check(&dir, &br, name);                 if let Err(e) = &disk {                     r.log("clip-refused", json!({"step": name, "why": e}));@@ -4832,6 +5072,7 @@ fn main() {                             // every visit is its own clip: placement-1, then placement-2 when a later step sends the AI back                             let visit = r.data["steps"][name]["visits"].as_array().map(|a| a.len()).unwrap_or(1);                             r.data["captures"].as_array_mut().unwrap().push(json!({"recordingId": rid, "start": now(), "kind": "window", "hwnd": h, "step": name, "visit": visit, "back": *back, "why": why}));+                            if let Some(clipwatch::Camera::Window { what, .. }) = &pre_cam { if let Some(c) = r.data["captures"].as_array_mut().and_then(|a| a.last_mut()) { c["camera"] = json!(what); } clip_note.push_str(&format!("filming {what}; ")); }                             r.mark(&format!("clip-start:{name}-{visit}"));                             let save_to = std::fs::canonicalize(&dir).unwrap_or(dir.clone()).display().to_string();                             if let Some(pth) = br.screenshot_window(h, &save_to, &format!("shot-{name}-{visit}-start")) {@@ -4854,16 +5095,14 @@ fn main() {                     },                     None if name == "fields" => clip_note.push_str("the fields step films the app: `tour fields` brings its own camera"),                     // before the board there is no editor to film: the desktop is the camera-                    None if preboard::PREBOARD_STEPS.contains(&name.as_str()) => match br.record_start(&format!("aiflow step {name} (before the board)")) {-                        Ok(rid) => {-                            let visit = r.data["steps"][name]["visits"].as_array().map(|a| a.len()).unwrap_or(1);-                            r.data["captures"].as_array_mut().unwrap().push(json!({"recordingId": rid, "start": now(), "kind": "monitor", "step": name, "visit": visit, "back": *back, "why": why}));-                            r.mark(&format!("clip-start:{name}-{visit}"));-                            r.log("clip-start", json!({"step": name, "visit": visit, "back": *back, "why": why, "recordingId": rid, "window": "monitor"}));-                            clip_note.push_str(&format!("clip {name}-{visit} recording the desktop (no PCB editor before the board)"));-                        }-                        Err(rep) => clip_note.push_str(&format!("no clip for {name}: recorder did not start ({})", rep["errorCode"].as_str().unwrap_or("?"))),-                    },+                    None if matches!(pre_cam, Some(clipwatch::Camera::Skip(_))) => {+                        let why_skip = match &pre_cam { Some(clipwatch::Camera::Skip(w)) => w.clone(), _ => String::new() };+                        let visit = r.data["steps"][name]["visits"].as_array().map(|a| a.len()).unwrap_or(1);+                        if !r.data["clipSkips"].is_array() { r.data["clipSkips"] = json!([]); }+                        r.data["clipSkips"].as_array_mut().unwrap().push(json!({"step": name, "visit": visit, "at": now(), "why": why_skip}));+                        r.log("clip-skipped", json!({"step": name, "visit": visit, "why": why_skip}));+                        clip_note.push_str(&format!("no clip for {name}-{visit}: {why_skip}"));+                    }                     None => clip_note.push_str(&format!("no clip for {name}: no PCB editor open on the test box (capture open first)")),                 }                 }@@ -4875,10 +5114,11 @@ fn main() {                 let (url, notes) = publish_report(&r, &dir, &pg, true, true, &thread(&cli));                 report_note = format!("Progress page: {url} ({})", notes.join("; "));             }+            let skill_lines = skill_hints::step_hints(&flow_full, name, &skill_home, skill_pkg.as_deref());             let record_hint = r.data["flow"]["steps"].as_array().and_then(|a| a.iter().find(|s| s["name"].as_str() == Some(name))).and_then(|s| s["record"].as_str()).map(|t| format!("What this step's clip should show: {t}")).unwrap_or_default();             let hint = if *back { format!("Return to {name} recorded{}. Every command from here is charged to {name} until the next `step`.", why.as_ref().map(|w| format!(": {w}")).unwrap_or_default()) } else if known.contains(&name.as_str()) { format!("Every command from here is charged to {name} until the next `step`.") } else { format!("{name} is your own step name (the known ones: {}); it is charged like any other.", known.join(", ")) };             let back_hint = if *back { "If the binary sent you back for its own fault (a wrong refusal, a missing lever, a rigid rule), that is a bug for the page, not a design lesson: file it so the next run does not pay for it.".to_string() } else { String::new() };-            ok(&format!("step {name}{}{}{}", if *back { " (back)" } else { "" }, prev.map(|p| format!(", leaving {p}")).unwrap_or_default(), if clip_note.is_empty() { String::new() } else { format!("; {clip_note}") }), &[hint, record_hint, back_hint, report_note, clips_note]);+            ok(&format!("step {name}{}{}{}", if *back { " (back)" } else { "" }, prev.map(|p| format!(", leaving {p}")).unwrap_or_default(), if clip_note.is_empty() { String::new() } else { format!("; {clip_note}") }), &[vec![hint, record_hint], skill_lines, vec![back_hint, report_note, clips_note]].concat());             print_next(&cli);         }         Cmd::ProjectPageCheck { project, live_json } => {@@ -4907,6 +5147,12 @@ fn main() {             if !vp.is_file() {                 err(&format!("video not found: {video}"), &["Cut it first; deliver takes the final MP4 the human will watch.".into()]);             }+            if let Some(open) = step_export::open_issue(r.outcomes().get("step-export").unwrap_or(&Value::Null)) {+                err(&format!("not delivered: the board twin's STEP export: {open}"), &["Never drop a layer (silkscreen, mask, zones) to make an exporter warning go away. Review the STEP at the reported spots in a STEP viewer, then acknowledge with a reason, or fix the geometry and export again.".into()]);+            }+            let board_path = r.current_board();+            let facts = Board::load(&board_path).ok().filter(|_| mechanical::applies(&board_path)).map(|b| verified::board_facts(&b, &board_path, &project_dir_of(&r), &spec_soft(&r)));+            let checked = verified::run_items(&r, facts.as_ref());             let bytes = std::fs::metadata(vp).map(|m| m.len()).unwrap_or(0);             if let Some(target) = r.data["target"].as_str().map(str::to_string) {                 let brs = Bridge { ai_thread: thread(&cli), target };@@ -4919,9 +5165,11 @@ fn main() {             if let Some(a) = agy_report(&r) { r.data["summary"]["antigravity"] = a; }             r.data["delivery"] = json!({"at": t, "video": std::fs::canonicalize(vp).map(|p| p.display().to_string()).unwrap_or(video.clone()), "videoBytes": bytes, "message": message});             r.data["summary"]["promptToDeliveredMinutes"] = json!(r.delivered_minutes());+            r.data["summary"]["verifiedAtDelivery"] = verified::to_json(&checked);             r.data["summary"]["steps"] = Value::Object(r.step_report());             r.data["summary"]["turns"] = json!(r.data["turns"].as_array().map(|a| a.len()).unwrap_or(0));-            r.data["summary"]["clips"] = json!(r.data["captures"].as_array().map(|a| a.iter().filter(|c| c.get("file").is_some()).map(|c| json!({"step": c["step"], "visit": c["visit"], "back": c["back"], "why": c["why"], "start": c["start"], "stop": c["stop"], "file": c["file"]})).collect::<Vec<_>>()).unwrap_or_default());+            r.data["summary"]["clips"] = json!(r.data["captures"].as_array().map(|a| a.iter().filter(|c| c.get("file").is_some()).map(|c| json!({"step": c["step"], "visit": c["visit"], "back": c["back"], "why": c["why"], "start": c["start"], "stop": c["stop"], "file": c["file"], "camera": c["camera"], "died": c["died"], "resumedAfterGap": c["resumedAfterGap"], "truncated": c["truncated"]})).collect::<Vec<_>>()).unwrap_or_default());+            r.data["summary"]["clipSkips"] = r.data["clipSkips"].clone();             r.log("deliver", json!({"minutes": r.delivered_minutes(), "activeMinutes": r.delivered_active_minutes(), "video": video, "videoBytes": bytes, "message": message, "steps": Value::Object(r.step_report())}));             r.save().unwrap();             let gb = r.data["giveback"].as_array().map(|a| a.len()).unwrap_or(0);@@ -4930,7 +5178,8 @@ fn main() {                 let (url, notes) = publish_report(&r, &dir, &pg, true, true, &thread(&cli));                 report_note.push_str(&format!(" Run page: {url} ({})", notes.join("; ")));             }-            ok(&format!("delivered: {} from the prompt to \"done, here is your video\", {:.1} min (finish was at {:.1} min)\n{}", r.data["engine"], r.delivered_minutes().unwrap_or(0.0), r.elapsed_minutes(), step_table(&r)), &["This is the number on the chart. The per-step table is the run's shape: thinking is the AI, binary is the tool, returns are the reworks.".into(), report_note, give_back_hint()]);+            let verified_text = verified::message(&checked);+            ok(&format!("delivered: {} from the prompt to \"done, here is your video\", {:.1} min (finish was at {:.1} min)\n{}\n{verified_text}", r.data["engine"], r.delivered_minutes().unwrap_or(0.0), r.elapsed_minutes(), step_table(&r)), &["Your message to the human must state the verified list as it stands; no \"ready to fabricate\" unless every item is yes, and still advise a human review.".into(), "This is the number on the chart. The per-step table is the run's shape: thinking is the AI, binary is the tool, returns are the reworks.".into(), report_note, give_back_hint()]);         }     } }

@@ -0,0 +1,510 @@+//! Mechanical checks on a placed board (issue #39, items 7 and 8): every footprint has a courtyard,+//! no two courtyards on one side overlap, and no two part bodies on one side intersect.+//!+//! Courtyards come from the footprint's own F.CrtYd / B.CrtYd graphics (rect, poly, circle, and+//! lines or arcs chained into closed outlines). Bodies come from the F.Fab / B.Fab graphics (their+//! convex hull: fab layers also carry pin-1 marks and chevrons, so the hull is the body envelope),+//! else from the 3D model's bounding box when the caller can supply it.+//!+//! The exemption rule is deliberately narrow: a footprint with no pads at all (a logo, board art,+//! a text block) carries nothing to assemble or solder and needs no courtyard. Every footprint with+//! a pad needs one, test pads, fiducials, mounting holes and machine pins included (KiCad's own+//! libraries draw courtyards for all of them). Footprints excluded from both the BOM and the+//! position files (bare test pads, mounting holes) are not bodies for the body-overlap check: the+//! fab places nothing there, so a fab ring around a bare pad is not a part body.+//!+//! This is aiflow's own geometry, run whatever the project's DRC severities say, so a project that+//! sets `courtyards_overlap` or `missing_courtyard` to ignore cannot hide either finding. The+//! severities are still read and reported so the gate says when KiCad's DRC was told to look away.++use aiflow_board::{geom, sx, Board, Pt};+use serde_json::{json, Value};+use std::path::Path;++/// Smallest overlap depth reported, in mm: below this two outlines only touch.+pub const MIN_OVERLAP_MM: f64 = 0.005;++#[derive(Debug, Clone)]+pub struct Shape {+    pub reference: String,+    pub front: bool,+    pub polys: Vec<Vec<Pt>>,+}++#[derive(Debug, Clone, PartialEq)]+pub struct Overlap {+    pub a: String,+    pub b: String,+    pub front: bool,+    /// The overlap region's smaller axis extent (mm): how far the outlines run into each other.+    pub depth: f64,+    pub area: f64,+}++impl Overlap {+    pub fn line(&self, what: &str) -> String {+        format!("{} and {} {what} overlap by {:.2} mm ({:.2} mm2) on the {}", self.a, self.b, self.depth, self.area, if self.front { "front" } else { "back" })+    }+}++#[derive(Debug, Default)]+pub struct Report {+    pub footprints: usize,+    pub with_courtyard: usize,+    pub missing_courtyards: Vec<String>,+    pub exempt: Vec<(String, String)>,+    pub courtyard_overlaps: Vec<Overlap>,+    pub body_overlaps: Vec<Overlap>,+    pub bodies_checked: usize,+    pub no_body: Vec<String>,+    pub severity_notes: Vec<String>,+    pub notes: Vec<String>,+    /// Item 9: drawn bodies that disagree with the datasheet size in spec.bodies.+    pub body_size_errors: Vec<String>,+    /// Connectors and large parts with no datasheet size in spec.bodies (not verified, a note).+    pub body_size_unverified: Vec<String>,+}++impl Report {+    pub fn courtyards_ok(&self) -> bool { self.missing_courtyards.is_empty() && self.courtyard_overlaps.is_empty() }+    pub fn bodies_ok(&self) -> bool { self.body_overlaps.is_empty() && self.body_size_errors.is_empty() }++    /// Every blocking finding, one line each.+    pub fn errors(&self) -> Vec<String> {+        let mut out = Vec::new();+        if !self.missing_courtyards.is_empty() {+            out.push(format!("{} footprint(s) without a courtyard (F.CrtYd/B.CrtYd): {}", self.missing_courtyards.len(), short(&self.missing_courtyards)));+        }+        out.extend(self.courtyard_overlaps.iter().map(|o| o.line("courtyards")));+        out.extend(self.body_overlaps.iter().map(|o| o.line("bodies")));+        out.extend(self.body_size_errors.iter().cloned());+        out+    }++    pub fn hint(&self) -> String {+        let mut h = Vec::new();+        if !self.missing_courtyards.is_empty() { h.push("Give each listed footprint a closed courtyard on F.CrtYd (B.CrtYd on the back) around its body and pads plus the IPC margin (0.25 mm for chip parts, 0.5 mm for larger parts and connectors), from the datasheet land pattern; KiCad's library footprints already have one."); }+        if !self.courtyard_overlaps.is_empty() || !self.body_overlaps.is_empty() { h.push("Move the overlapping parts apart (place pack / place check again) or fix a body or courtyard drawn larger than the real part; never shrink a courtyard below the part to get a pass."); }+        if !self.body_size_errors.is_empty() { h.push("Redraw the footprint's F.Fab body (and its courtyard) to the datasheet's package drawing, then place check and gate again; a body drawn smaller than the part hides real collisions."); }+        h.join(" ")+    }++    pub fn to_json(&self) -> Value {+        let ov = |v: &[Overlap]| v.iter().map(|o| json!({"a": o.a, "b": o.b, "side": if o.front { "front" } else { "back" }, "overlapMm": round3(o.depth), "areaMm2": round3(o.area)})).collect::<Vec<_>>();+        json!({+            "footprints": self.footprints, "withCourtyard": self.with_courtyard,+            "missingCourtyards": self.missing_courtyards,+            "exempt": self.exempt.iter().map(|(r, w)| json!({"ref": r, "why": w})).collect::<Vec<_>>(),+            "courtyardOverlaps": ov(&self.courtyard_overlaps), "bodyOverlaps": ov(&self.body_overlaps),+            "bodiesChecked": self.bodies_checked, "noBody": self.no_body,+            "bodySizeErrors": self.body_size_errors, "bodySizeNotVerified": self.body_size_unverified,+            "projectSeverities": self.severity_notes, "notes": self.notes,+            "courtyardsOk": self.courtyards_ok(), "bodiesOk": self.bodies_ok(),+            "exemptionRule": "only footprints with no pads (logos, board art) need no courtyard; footprints excluded from both BOM and position files are not bodies",+        })+    }+}++fn round3(v: f64) -> f64 { (v * 1000.0).round() / 1000.0 }++fn short(v: &[String]) -> String {+    if v.len() > 12 { format!("{} and {} more", v[..12].join(", "), v.len() - 12) } else { v.join(", ") }+}++fn flag(fp: &sx::Node, name: &str) -> bool {+    let in_attr = fp.find("attr").map(|a| a.items.iter().any(|it| matches!(it, sx::Item::Atom { text, .. } if text == name))).unwrap_or(false);+    in_attr || fp.find(name).map(|n| n.value() != Some("no")).unwrap_or(false)+}++fn xy(n: &sx::Node, tag: &str) -> Option<Pt> {+    let p = n.find(tag)?;+    Some((p.number(1)?, p.number(2)?))+}++/// Closed outlines and loose points of a footprint's graphics on one layer, in its own frame.+fn layer_geometry(fp: &sx::Node, layer: &str) -> (Vec<Vec<Pt>>, Vec<Vec<Pt>>) {+    let (mut closed, mut open) = (Vec::new(), Vec::new());+    for n in fp.nodes() {+        if !matches!(n.tag.as_str(), "fp_line" | "fp_rect" | "fp_poly" | "fp_circle" | "fp_arc") { continue; }+        if n.find("layer").and_then(|l| l.value()) != Some(layer) { continue; }+        match n.tag.as_str() {+            "fp_rect" => if let (Some(a), Some(b)) = (xy(n, "start"), xy(n, "end")) { closed.push(vec![a, (b.0, a.1), b, (a.0, b.1)]); },+            "fp_poly" => {+                let pts: Vec<Pt> = n.find("pts").map(|p| p.find_all("xy").filter_map(|q| Some((q.number(1)?, q.number(2)?))).collect()).unwrap_or_default();+                if pts.len() >= 3 { closed.push(pts); }+            }+            "fp_circle" => if let (Some(c), Some(e)) = (xy(n, "center"), xy(n, "end")) { closed.push(geom::circle_poly(c.0, c.1, (e.0 - c.0).hypot(e.1 - c.1), 32)); },+            "fp_line" => if let (Some(a), Some(b)) = (xy(n, "start"), xy(n, "end")) { open.push(vec![a, b]); },+            "fp_arc" => if let (Some(a), Some(m), Some(b)) = (xy(n, "start"), xy(n, "mid"), xy(n, "end")) { open.push(geom::arc_points(a, m, b, 0.1)); },+            _ => {}+        }+    }+    (closed, open)+}++/// Join open pieces into closed loops; whatever does not close is returned as leftover points.+fn close_loops(mut pieces: Vec<Vec<Pt>>, tol: f64) -> (Vec<Vec<Pt>>, Vec<Pt>) {+    let d = |a: Pt, b: Pt| (a.0 - b.0).hypot(a.1 - b.1);+    let (mut loops, mut left) = (Vec::new(), Vec::new());+    pieces.retain(|p| p.len() >= 2);+    while !pieces.is_empty() {+        let mut cur = pieces.remove(0);+        loop {+            if cur.len() > 2 && d(cur[0], *cur.last().unwrap()) < tol { break; }+            let end = *cur.last().unwrap();+            let Some((i, rev)) = pieces.iter().enumerate().find_map(|(i, p)| if d(end, p[0]) < tol { Some((i, false)) } else if d(end, *p.last().unwrap()) < tol { Some((i, true)) } else { None }) else { break };+            let mut p = pieces.remove(i);+            if rev { p.reverse(); }+            cur.extend(p.into_iter().skip(1));+        }+        if cur.len() > 3 && d(cur[0], *cur.last().unwrap()) < tol { cur.pop(); loops.push(cur); } else { left.extend(cur); }+    }+    (loops, left)+}++/// The convex hull (monotone chain), counter-clockwise.+pub fn hull(pts: &[Pt]) -> Vec<Pt> {+    let mut p: Vec<Pt> = pts.to_vec();+    p.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));+    p.dedup_by(|a, b| (a.0 - b.0).abs() < 1e-9 && (a.1 - b.1).abs() < 1e-9);+    if p.len() < 3 { return p; }+    let cross = |o: Pt, a: Pt, b: Pt| (a.0 - o.0) * (b.1 - o.1) - (a.1 - o.1) * (b.0 - o.0);+    let mut lower: Vec<Pt> = Vec::new();+    for &q in &p { while lower.len() >= 2 && cross(lower[lower.len() - 2], lower[lower.len() - 1], q) <= 0.0 { lower.pop(); } lower.push(q); }+    let mut upper: Vec<Pt> = Vec::new();+    for &q in p.iter().rev() { while upper.len() >= 2 && cross(upper[upper.len() - 2], upper[upper.len() - 1], q) <= 0.0 { upper.pop(); } upper.push(q); }+    lower.pop(); upper.pop();+    lower.extend(upper);+    lower+}++fn place(polys: Vec<Vec<Pt>>, x: f64, y: f64, rot: f64) -> Vec<Vec<Pt>> {+    polys.into_iter().map(|poly| poly.into_iter().map(|(dx, dy)| { let (a, b) = geom::rot_kicad(dx, dy, rot); (x + a, y + b) }).collect()).collect()+}++/// Overlap of two polygon sets: (depth, area) when they share area deeper than MIN_OVERLAP_MM.+/// Sampled on a grid fine enough for 0.01 mm over the shared box (capped at 600 x 600 samples).+pub fn overlap(a: &[Vec<Pt>], b: &[Vec<Pt>]) -> Option<(f64, f64)> {+    let all = |s: &[Vec<Pt>]| geom::bbox(&s.iter().flatten().copied().collect::<Vec<_>>());+    let (ba, bb) = (all(a), all(b));+    let (x0, y0, x1, y1) = (ba.0.max(bb.0), ba.1.max(bb.1), ba.2.min(bb.2), ba.3.min(bb.3));+    if x1 - x0 <= 1e-9 || y1 - y0 <= 1e-9 { return None; }+    let res = ((x1 - x0).max(y1 - y0) / 600.0).max(0.005);+    let inside = |s: &[Vec<Pt>], x: f64, y: f64| s.iter().any(|p| geom::point_in_poly(x, y, p));+    let (nx, ny) = (((x1 - x0) / res).ceil() as usize, ((y1 - y0) / res).ceil() as usize);+    let (mut hits, mut hx0, mut hy0, mut hx1, mut hy1) = (0usize, f64::MAX, f64::MAX, f64::MIN, f64::MIN);+    for j in 0..ny {+        let y = y0 + (j as f64 + 0.5) * res;+        if y > y1 { break; }+        for i in 0..nx {+            let x = x0 + (i as f64 + 0.5) * res;+            if x > x1 { break; }+            if inside(a, x, y) && inside(b, x, y) {+                hits += 1;+                hx0 = hx0.min(x); hy0 = hy0.min(y); hx1 = hx1.max(x); hy1 = hy1.max(y);+            }+        }+    }+    if hits == 0 { return None; }+    let depth = ((hx1 - hx0) + res).min((hy1 - hy0) + res).min(x1 - x0).min(y1 - y0);+    (depth > MIN_OVERLAP_MM).then_some((depth, hits as f64 * res * res))+}++/// Same-side overlaps among shapes.+pub fn overlaps(shapes: &[Shape]) -> Vec<Overlap> {+    let mut out = Vec::new();+    for i in 0..shapes.len() {+        for j in i + 1..shapes.len() {+            let (s, t) = (&shapes[i], &shapes[j]);+            if s.front != t.front || s.reference == t.reference { continue; }+            if let Some((depth, area)) = overlap(&s.polys, &t.polys) {+                out.push(Overlap { a: s.reference.clone(), b: t.reference.clone(), front: s.front, depth, area });+            }+        }+    }+    out+}++/// The project's DRC severities for the courtyard rules (from <board>.kicad_pro), as notes for+/// every rule set to ignore or downgraded below error.+pub fn project_severities(board_path: &str) -> Vec<String> {+    let pro = Path::new(board_path).with_extension("kicad_pro");+    let Some(v) = std::fs::read(&pro).ok().and_then(|b| serde_json::from_slice::<Value>(&b).ok()) else { return Vec::new() };+    let sev = &v["board"]["design_settings"]["rule_severities"];+    let mut out = Vec::new();+    for rule in ["courtyards_overlap", "missing_courtyard", "malformed_courtyard"] {+        match sev[rule].as_str() {+            Some("ignore") => out.push(format!("the project sets {rule} to ignore, so KiCad's DRC reports nothing for it; aiflow's own courtyard check below decides")),+            Some("warning") if rule == "courtyards_overlap" => out.push(format!("the project sets {rule} to warning; aiflow treats it as an error (its own courtyard check and the gate's blocking list)")),+            _ => {}+        }+    }+    out+}++/// The whole check. `model_box(reference)` gives a footprint's 3D model box in its own frame+/// (x0, y0, x1, y1, board y down) for parts with no fab outline; pass `|_| None` when unknown.+pub fn check(b: &Board, board_path: &str, model_box: &dyn Fn(&str) -> Option<(f64, f64, f64, f64)>) -> Report {+    let mut rep = Report { severity_notes: project_severities(board_path), ..Default::default() };+    let (mut courts, mut bodies) = (Vec::new(), Vec::new());+    for fp in b.root.find_all("footprint") {+        let Some(reference) = aiflow_board::reference_of(fp) else { continue };+        rep.footprints += 1;+        let at = fp.find("at");+        let (x, y, rot) = (at.and_then(|a| a.number(1)).unwrap_or(0.0), at.and_then(|a| a.number(2)).unwrap_or(0.0), at.and_then(|a| a.number(3)).unwrap_or(0.0));+        let back = fp.find("layer").and_then(|l| l.value()) == Some("B.Cu");+        let pads = fp.find_all("pad").count();+        // courtyards+        let mut found = false;+        for (layer, front) in [("F.CrtYd", true), ("B.CrtYd", false)] {+            let (mut closed, open) = layer_geometry(fp, layer);+            if closed.is_empty() && open.is_empty() { continue; }+            found = true;+            let (loops, left) = close_loops(open, 0.01);+            closed.extend(loops);+            if !left.is_empty() {+                rep.notes.push(format!("{reference}: the {layer} outline is not closed; its convex hull is used"));+                let mut pts = left;+                pts.extend(closed.iter().flatten().copied());+                closed = vec![hull(&pts)];+            }+            courts.push(Shape { reference: reference.clone(), front, polys: place(closed, x, y, rot) });+        }+        if found { rep.with_courtyard += 1; }+        else if pads == 0 { rep.exempt.push((reference.clone(), "no pads (graphics only)".into())); }+        else { rep.missing_courtyards.push(reference.clone()); }+        // bodies+        if pads == 0 || (flag(fp, "exclude_from_bom") && flag(fp, "exclude_from_pos_files")) { continue; }+        let mut got = false;+        for (layer, front) in [("F.Fab", true), ("B.Fab", false)] {+            let (closed, open) = layer_geometry(fp, layer);+            let pts: Vec<Pt> = closed.into_iter().chain(open).flatten().collect();+            if pts.len() < 3 { continue; }+            let h = hull(&pts);+            if h.len() < 3 { continue; }+            got = true;+            bodies.push(Shape { reference: reference.clone(), front, polys: place(vec![h], x, y, rot) });+        }+        if !got {+            if let Some((x0, y0, x1, y1)) = model_box(&reference) {+                got = true;+                bodies.push(Shape { reference: reference.clone(), front: !back, polys: place(vec![vec![(x0, y0), (x1, y0), (x1, y1), (x0, y1)]], x, y, rot) });+            }+        }+        if got { rep.bodies_checked += 1; } else { rep.no_body.push(reference.clone()); }+    }+    rep.courtyard_overlaps = overlaps(&courts);+    rep.body_overlaps = overlaps(&bodies);+    if !rep.no_body.is_empty() { rep.notes.push(format!("no fab outline and no readable 3D model box, body not checked: {}", short(&rep.no_body))); }+    rep+}++/// The gate outcome's courtyard and body verdicts: false only when the gate checked and found a+/// problem (a Fusion board, or a gate recorded before this check, carries none and is not refused here).+pub fn gate_clear(gate: &Value) -> bool { gate["courtyardsOk"] != false && gate["bodiesOk"] != false }++/// False for a Fusion (EAGLE) board: its KiCad rendering carries no footprint courtyard or fab+/// graphics, so these checks cannot run on it and the stage says so instead of passing.+pub fn applies(board_path: &str) -> bool {+    std::fs::read_to_string(board_path).map(|t| !aiflow_board::eagle::is_eagle(&t)).unwrap_or(false)+}++/// `check` with the 3D model fallback read from the model files that resolve here (their STEP+/// points, no service call), for parts without a fab outline.+pub fn check_board(b: &Board, board_path: &str, project_dir: &Path, spec: &Value) -> Report {+    let mut boxes: std::collections::BTreeMap<String, (f64, f64, f64, f64)> = std::collections::BTreeMap::new();+    let no_fab: std::collections::BTreeSet<String> = b.root.find_all("footprint").filter(|fp| {+        let (c1, o1) = layer_geometry(fp, "F.Fab"); let (c2, o2) = layer_geometry(fp, "B.Fab");+        c1.is_empty() && o1.is_empty() && c2.is_empty() && o2.is_empty()+    }).filter_map(aiflow_board::reference_of).collect();+    for m in crate::checks::model_refs(b) {+        if !no_fab.contains(&m.reference) || boxes.contains_key(&m.reference) { continue; }+        let Some(file) = crate::checks::resolve_model(&m.path, project_dir) else { continue };+        let Some(bb) = std::fs::read(&file).ok().and_then(|t| crate::checks::step_points_bbox(&String::from_utf8_lossy(&t))) else { continue };+        let p = crate::checks::transform_bbox(&bb, m.offset, m.scale, m.rotate);+        // the 3D frame is y up, the board's y down+        boxes.insert(m.reference.clone(), (p[0][0], -p[1][1], p[0][1], -p[1][0]));+    }+    let mut rep = check(b, board_path, &|r: &str| boxes.get(r).copied());+    let (errors, unverified) = declared_bodies(b, spec);+    rep.body_size_errors = errors;+    rep.body_size_unverified = unverified;+    if !rep.body_size_unverified.is_empty() { rep.notes.push(format!("body size not checked against a datasheet (no spec.bodies entry): {}", short(&rep.body_size_unverified))); }+    rep+}++/// A body is "large" for the datasheet note above this many mm on its longer side.+pub const LARGE_BODY_MM: f64 = 8.0;++/// The drawn body's size in the footprint's own frame: the F.Fab/B.Fab extents, (longer, shorter) in mm.+pub fn fab_extent(fp: &sx::Node) -> Option<(f64, f64)> {+    let mut pts: Vec<Pt> = Vec::new();+    for layer in ["F.Fab", "B.Fab"] {+        let (closed, open) = layer_geometry(fp, layer);+        pts.extend(closed.into_iter().chain(open).flatten());+    }+    if pts.len() < 2 { return None; }+    let (x0, y0, x1, y1) = geom::bbox(&pts);+    let (w, h) = (x1 - x0, y1 - y0);+    Some((w.max(h), w.min(h)))+}++fn connector_ref(r: &str) -> bool {+    let p: String = r.chars().take_while(|c| c.is_ascii_alphabetic()).collect::<String>().to_ascii_uppercase();+    matches!(p.as_str(), "J" | "P" | "CN" | "X" | "CON" | "TB")+}++/// Item 9: every footprint named in `spec.bodies` ({"J1": {"lengthMm": 9.8, "widthMm": 7.6,+/// "tolMm": 0.3, "source": "datasheet page"}}) has a drawn body of that size (longer side against+/// lengthMm, shorter against widthMm, within tolMm, default 0.25 mm). Returns (errors, connectors and+/// parts over LARGE_BODY_MM with no entry).+pub fn declared_bodies(b: &Board, spec: &Value) -> (Vec<String>, Vec<String>) {+    let decl = spec["bodies"].as_object();+    let (mut errors, mut unverified) = (Vec::new(), Vec::new());+    for fp in b.root.find_all("footprint") {+        let Some(reference) = aiflow_board::reference_of(fp) else { continue };+        let ext = fab_extent(fp);+        match decl.and_then(|d| d.get(&reference)) {+            Some(want) => {+                let tol = want["tolMm"].as_f64().unwrap_or(0.25);+                let Some((long, short)) = ext else { errors.push(format!("{reference}: spec.bodies gives its datasheet size but the footprint draws no F.Fab body to compare")); continue };+                let (wl, ws) = (want["lengthMm"].as_f64(), want["widthMm"].as_f64());+                let (wl, ws) = match (wl, ws) { (Some(a), Some(b)) => (Some(a.max(b)), Some(a.min(b))), (a, b) => (a.or(b), None) };+                let src = want["source"].as_str().map(|s| format!(" ({s})")).unwrap_or_default();+                if let Some(wl) = wl { if (long - wl).abs() > tol { errors.push(format!("{reference}: the drawn body is {long:.2} mm long, the datasheet says {wl:.2} mm{src}")); } }+                if let Some(ws) = ws { if (short - ws).abs() > tol { errors.push(format!("{reference}: the drawn body is {short:.2} mm wide, the datasheet says {ws:.2} mm{src}")); } }+            }+            None => {+                if fp.find_all("pad").count() == 0 { continue; }+                if connector_ref(&reference) || ext.map(|e| e.0 > LARGE_BODY_MM).unwrap_or(false) { unverified.push(reference.clone()); }+            }+        }+    }+    (errors, unverified)+}++#[cfg(test)]+pub(crate) mod tests {+    use super::*;++    /// A footprint at (x, y) with a body of w x h on F.Fab and, when `crt` is set, a courtyard grown by `crt`.+    pub(crate) fn part(r: &str, x: f64, y: f64, w: f64, h: f64, crt: Option<f64>, extra_attr: &str) -> String {+        let (hw, hh) = (w / 2.0, h / 2.0);+        let mut s = format!("  (footprint \"T:Cap\" (layer \"F.Cu\") (at {x} {y})\n    (property \"Reference\" \"{r}\" (at 0 0 0) (layer \"F.Fab\"))\n    (attr smd {extra_attr})\n");+        for (a, b) in [((-hw, -hh), (hw, -hh)), ((hw, -hh), (hw, hh)), ((hw, hh), (-hw, hh)), ((-hw, hh), (-hw, -hh))] {+            s.push_str(&format!("    (fp_line (start {} {}) (end {} {}) (layer \"F.Fab\") (width 0.1))\n", a.0, a.1, b.0, b.1));+        }+        if let Some(g) = crt { s.push_str(&format!("    (fp_rect (start {} {}) (end {} {}) (layer \"F.CrtYd\") (width 0.05))\n", -hw - g, -hh - g, hw + g, hh + g)); }+        s.push_str(&format!("    (pad \"1\" smd rect (at {} 0) (size 0.5 0.5) (layers \"F.Cu\"))\n    (pad \"2\" smd rect (at {} 0) (size 0.5 0.5) (layers \"F.Cu\")))\n", -hw + 0.3, hw - 0.3));+        s+    }++    pub(crate) fn board(parts: &[String]) -> Board {+        let mut t = String::from("(kicad_pcb (version 20240108) (generator \"t\")\n  (layers (0 \"F.Cu\" signal) (31 \"B.Cu\" signal) (44 \"Edge.Cuts\" user))\n");+        for p in parts { t.push_str(p); }+        t.push_str("  (gr_rect (start 90 60) (end 130 100) (layer \"Edge.Cuts\") (width 0.1))\n)\n");+        Board::from_text("t.kicad_pcb", t).unwrap()+    }++    #[test]+    fn the_issue_example_two_5mm_bodies_4mm_apart_overlap_by_1mm() {+        // C6 at (105, 75.5) and C7 at (105, 79.5), each a 5 mm body: no courtyards, bodies overlap 1 mm+        let b = board(&[part("C6", 105.0, 75.5, 2.5, 5.0, None, ""), part("C7", 105.0, 79.5, 2.5, 5.0, None, "")]);+        let r = check(&b, "/nonexistent/t.kicad_pcb", &|_| None);+        assert_eq!(r.missing_courtyards, vec!["C6", "C7"]);+        assert_eq!(r.body_overlaps.len(), 1);+        let o = &r.body_overlaps[0];+        assert!((o.depth - 1.0).abs() < 0.02, "{o:?}");+        assert!((o.area - 2.5).abs() < 0.05, "{o:?}");+        assert!(r.errors().iter().any(|e| e.contains("C6 and C7 bodies overlap by 1.00 mm")), "{:?}", r.errors());+    }++    #[test]+    fn courtyards_overlap_is_an_error_and_touching_is_not() {+        let b = board(&[part("R1", 100.0, 80.0, 1.0, 0.5, Some(0.25), ""), part("R2", 101.4, 80.0, 1.0, 0.5, Some(0.25), "")]);+        let r = check(&b, "/nonexistent/t.kicad_pcb", &|_| None);+        assert!(r.missing_courtyards.is_empty());+        assert_eq!(r.courtyard_overlaps.len(), 1, "{:?}", r.courtyard_overlaps);+        assert!((r.courtyard_overlaps[0].depth - 0.1).abs() < 0.02);+        assert!(r.body_overlaps.is_empty());+        assert!(!r.courtyards_ok());+        // courtyards that only share an edge (1.5 mm apart, each 0.75 wide half) do not overlap+        let b = board(&[part("R1", 100.0, 80.0, 1.0, 0.5, Some(0.25), ""), part("R2", 101.5, 80.0, 1.0, 0.5, Some(0.25), "")]);+        assert!(check(&b, "/nonexistent/t.kicad_pcb", &|_| None).courtyards_ok());+    }++    #[test]+    fn only_padless_footprints_are_exempt_and_bare_pads_are_not_bodies() {+        let logo = "  (footprint \"T:Logo\" (layer \"F.Cu\") (at 95 65)\n    (property \"Reference\" \"G1\" (at 0 0 0) (layer \"F.Fab\"))\n    (fp_poly (pts (xy -1 -1) (xy 1 -1) (xy 1 1)) (layer \"F.SilkS\")))\n".to_string();+        let tp = part("TP1", 110.0, 80.0, 1.0, 1.0, None, "exclude_from_pos_files exclude_from_bom");+        let r1 = part("R1", 110.2, 80.0, 1.0, 1.0, Some(0.2), "");+        let r = check(&board(&[logo, tp, r1]), "/nonexistent/t.kicad_pcb", &|_| None);+        assert_eq!(r.exempt, vec![("G1".to_string(), "no pads (graphics only)".to_string())]);+        // the test pad still needs a courtyard, but it is not a body+        assert_eq!(r.missing_courtyards, vec!["TP1"]);+        assert!(r.body_overlaps.is_empty());+        assert_eq!(r.bodies_checked, 1);+    }++    #[test]+    fn a_courtyard_drawn_with_lines_is_closed_and_an_l_shape_is_not_hulled() {+        // an L-shaped courtyard: a part tucked into the notch must not count as overlapping+        let l = "  (footprint \"T:L\" (layer \"F.Cu\") (at 100 80)\n    (property \"Reference\" \"U1\" (at 0 0 0) (layer \"F.Fab\"))\n".to_string()+            + &[((0.0, 0.0), (4.0, 0.0)), ((4.0, 0.0), (4.0, 2.0)), ((4.0, 2.0), (2.0, 2.0)), ((2.0, 2.0), (2.0, 4.0)), ((2.0, 4.0), (0.0, 4.0)), ((0.0, 4.0), (0.0, 0.0))]+                .iter().map(|(a, b)| format!("    (fp_line (start {} {}) (end {} {}) (layer \"F.CrtYd\") (width 0.05))\n", a.0, a.1, b.0, b.1)).collect::<String>()+            + "    (pad \"1\" smd rect (at 1 1) (size 0.5 0.5) (layers \"F.Cu\")))\n";+        let r = check(&board(&[l, part("C1", 103.0, 83.0, 1.0, 1.0, Some(0.2), "")]), "/nonexistent/t.kicad_pcb", &|_| None);+        assert!(r.courtyard_overlaps.is_empty(), "{:?} {:?}", r.courtyard_overlaps, r.notes);+        assert!(!r.notes.iter().any(|n| n.contains("not closed")), "{:?}", r.notes);+        assert_eq!(r.no_body, vec!["U1"]);+    }++    #[test]+    fn rotation_and_the_model_box_fallback_are_used() {+        // a part with no fab outline: its 3D model box (3 x 1 mm) stands in, rotated 90 degrees+        let nofab = "  (footprint \"T:J\" (layer \"F.Cu\") (at 100 80 90)\n    (property \"Reference\" \"J1\" (at 0 0 0) (layer \"F.SilkS\"))\n    (fp_rect (start -2 -1) (end 2 1) (layer \"F.CrtYd\") (width 0.05))\n    (pad \"1\" thru_hole circle (at 0 0) (size 1 1) (drill 0.6) (layers \"*.Cu\")))\n".to_string();+        let near = part("C1", 100.0, 81.9, 1.0, 1.0, Some(0.1), "");+        let r = check(&board(&[nofab, near]), "/nonexistent/t.kicad_pcb", &|r| (r == "J1").then_some((-1.5, -0.5, 1.5, 0.5)));+        // J1 rotated: its model box spans y 78.5..81.5, C1's body y 81.4..82.4: 0.1 mm into each other+        assert_eq!(r.body_overlaps.len(), 1, "{:?}", r.body_overlaps);+        assert!((r.body_overlaps[0].depth - 0.1).abs() < 0.02);+        // and the rotated courtyards (J1 y 78..82, C1 81.3..82.5) overlap too+        assert_eq!(r.courtyard_overlaps.len(), 1);+    }++    #[test]+    fn a_body_drawn_smaller_than_the_datasheet_is_an_error() {+        // the trial's Phoenix 1715721: a 7 mm body drawn, the datasheet says 9.8 mm+        let b = board(&[part("J1", 100.0, 80.0, 7.0, 5.0, Some(0.5), ""), part("C1", 120.0, 80.0, 2.0, 1.25, Some(0.25), "")]);+        let (errors, unverified) = declared_bodies(&b, &json!({"bodies": {"J1": {"lengthMm": 9.8, "widthMm": 5.0, "source": "1715721 datasheet"}}}));+        assert_eq!(errors.len(), 1, "{errors:?}");+        assert!(errors[0].contains("7.00 mm long") && errors[0].contains("9.80"), "{errors:?}");+        assert!(unverified.is_empty());+        // with no entry the connector is listed as not verified; the small capacitor is not+        let (errors, unverified) = declared_bodies(&b, &Value::Null);+        assert!(errors.is_empty());+        assert_eq!(unverified, vec!["J1"]);+        let r = check_board(&b, "/nonexistent/t.kicad_pcb", Path::new("/nonexistent"), &json!({"bodies": {"J1": {"lengthMm": 9.8}}}));+        assert!(!r.bodies_ok() && r.errors().iter().any(|e| e.contains("J1")), "{:?}", r.errors());+        assert!(check_board(&b, "/nonexistent/t.kicad_pcb", Path::new("/nonexistent"), &json!({"bodies": {"J1": {"lengthMm": 7.0, "widthMm": 5.0}}})).bodies_ok());+    }++    #[test]+    fn gate_clear_reads_the_recorded_verdicts() {+        assert!(gate_clear(&json!({"newErrors": 0})));+        assert!(gate_clear(&json!({"courtyardsOk": null, "bodiesOk": null})));+        assert!(!gate_clear(&json!({"courtyardsOk": false, "bodiesOk": true})));+        assert!(!gate_clear(&json!({"courtyardsOk": true, "bodiesOk": false})));+    }++    #[test]+    fn ignored_courtyard_severities_are_reported() {+        let dir = std::env::temp_dir().join(format!("aiflow-mech-{}", std::process::id()));+        std::fs::create_dir_all(&dir).unwrap();+        std::fs::write(dir.join("b.kicad_pro"), r#"{"board":{"design_settings":{"rule_severities":{"courtyards_overlap":"ignore","missing_courtyard":"ignore"}}}}"#).unwrap();+        let notes = project_severities(&dir.join("b.kicad_pcb").display().to_string());+        assert_eq!(notes.len(), 2, "{notes:?}");+        assert!(notes[0].contains("courtyards_overlap to ignore"));+        let _ = std::fs::remove_dir_all(&dir);+    }+}

@@ -12,10 +12,10 @@ fn near(p: (f64, f64), q: (f64, f64)) -> bool { (p.0 - q.0).hypot(p.1 - q.1) < 0 pub fn sharp_corners(edges: &[Edge]) -> Vec<(f64, f64)> {     let mut out: Vec<(f64, f64)> = Vec::new();     for (i, e) in edges.iter().enumerate() {-        if e.arc { continue; }+        if e.arc || near(e.a, e.b) { continue; }         for p in [e.a, e.b] {             if out.iter().any(|q| near(*q, p)) { continue; }-            let others: Vec<&Edge> = edges.iter().enumerate().filter(|(j, f)| *j != i && (near(f.a, p) || near(f.b, p))).map(|(_, f)| f).collect();+            let others: Vec<&Edge> = edges.iter().enumerate().filter(|(j, f)| *j != i && !near(f.a, f.b) && (near(f.a, p) || near(f.b, p))).map(|(_, f)| f).collect();             let Some(f) = others.first() else { continue };             if f.arc { continue; }             let d1 = if near(e.a, p) { (e.b.0 - p.0, e.b.1 - p.1) } else { (e.a.0 - p.0, e.a.1 - p.1) };@@ -44,34 +44,91 @@ pub fn eagle_edges(src: &str) -> Vec<Edge> {     out } -/// The outline of a KiCad board: Edge.Cuts gr_line / gr_arc / gr_rect (a rect is four sharp corners).+/// The outline of a KiCad board, read with the S-expression parser (issue #71): the board-level+/// Edge.Cuts items (gr_line, gr_arc, gr_rect, gr_poly, gr_curve) plus any footprint item on+/// Edge.Cuts (fp_line, fp_arc, fp_rect, fp_poly, fp_curve), transformed from footprint-local to+/// board coordinates. Graphics on every other layer (silk, fab, courtyard, pad shapes) are not+/// outline and are ignored. KiCad writes a back-side footprint's children already mirrored in its+/// local frame, so the transform is the footprint's position and rotation (the same convention the+/// pads use); the side needs no second mirror. Circles are closed curves with no corner and are+/// skipped. An EAGLE/Fusion board is read with `eagle_edges`. pub fn kicad_edges(text: &str) -> Vec<Edge> {+    if aiflow_board::eagle::is_eagle(text) { return eagle_edges(text); }+    // a fragment (items without the kicad_pcb wrapper) reads as the items of one board+    let root = match aiflow_board::sx::parse(text) {+        Ok(r) if r.tag == "kicad_pcb" => r,+        _ => match aiflow_board::sx::parse(&format!("(kicad_pcb\n{text}\n)")) { Ok(r) => r, Err(_) => return Vec::new() },+    };     let mut out = Vec::new();-    // a gr_poly on Edge.Cuts is a closed chain of straight edges-    for blk in text.split("(gr_poly").skip(1) {-        let end = blk.find("\n  (").unwrap_or(blk.len());-        let blk = &blk[..end];-        if !blk.contains("Edge.Cuts") { continue; }-        let pts: Vec<(f64, f64)> = blk.split("(xy ").skip(1).filter_map(|r| { let v: Vec<f64> = r.split(')').next()?.split_whitespace().filter_map(|x| x.parse().ok()).collect(); if v.len() >= 2 { Some((v[0], v[1])) } else { None } }).collect();-        for k in 0..pts.len() { if pts.len() > 2 { out.push(Edge { a: pts[k], b: pts[(k + 1) % pts.len()], arc: false }); } }+    let ident = |p: (f64, f64)| p;+    for n in root.nodes() {+        if n.tag.starts_with("gr_") { node_edges(n, "gr_", &ident, &mut out); }     }-    for (tag, arc) in [("(gr_line", false), ("(gr_arc", true), ("(gr_rect", false)] {-        for blk in text.split(tag).skip(1) {-            let end = blk.find("\n  (").unwrap_or(blk.len().min(600));-            let blk = &blk[..end];-            if !blk.contains("Edge.Cuts") { continue; }-            let xy = |k: &str| blk.split(&format!("({k} ")).nth(1).and_then(|r| { let v: Vec<f64> = r.split(')').next()?.split_whitespace().filter_map(|x| x.parse().ok()).collect(); if v.len() >= 2 { Some((v[0], v[1])) } else { None } });-            if let (Some(a), Some(b)) = (xy("start"), xy("end")) {-                if tag == "(gr_rect" {-                    let (c, d) = ((b.0, a.1), (a.0, b.1));-                    for (p, q) in [(a, c), (c, b), (b, d), (d, a)] { out.push(Edge { a: p, b: q, arc: false }); }-                } else { out.push(Edge { a, b, arc }); }-            }+    for fp in root.find_all("footprint") {+        let at = fp.find("at");+        let (fx, fy, rot) = (at.and_then(|a| a.number(1)).unwrap_or(0.0), at.and_then(|a| a.number(2)).unwrap_or(0.0), at.and_then(|a| a.number(3)).unwrap_or(0.0));+        let to_board = move |p: (f64, f64)| { let (rx, ry) = aiflow_board::geom::rot_kicad(p.0, p.1, rot); (fx + rx, fy + ry) };+        for n in fp.nodes() {+            if n.tag.starts_with("fp_") { node_edges(n, "fp_", &to_board, &mut out); }         }     }     out } +fn on_edge_cuts(n: &aiflow_board::sx::Node) -> bool {+    if n.find("layer").and_then(|l| l.value()) == Some("Edge.Cuts") { return true; }+    n.find("layers").map(|l| l.items.iter().any(|it| matches!(it, aiflow_board::sx::Item::Atom { text, .. } if text == "Edge.Cuts"))).unwrap_or(false)+}++fn node_edges(n: &aiflow_board::sx::Node, prefix: &str, tf: &dyn Fn((f64, f64)) -> (f64, f64), out: &mut Vec<Edge>) {+    if !on_edge_cuts(n) { return; }+    let p2 = |m: Option<&aiflow_board::sx::Node>| -> Option<(f64, f64)> { let m = m?; Some((m.number(1)?, m.number(2)?)) };+    match &n.tag[prefix.len()..] {+        "line" => if let (Some(a), Some(b)) = (p2(n.find("start")), p2(n.find("end"))) { out.push(Edge { a: tf(a), b: tf(b), arc: false }); },+        "arc" => {+            if let (Some(a), Some(_), Some(b)) = (p2(n.find("start")), p2(n.find("mid")), p2(n.find("end"))) {+                out.push(Edge { a: tf(a), b: tf(b), arc: true });+            } else if let (Some(c), Some(s), Some(ang)) = (p2(n.find("start")), p2(n.find("end")), n.find("angle").and_then(|x| x.number(1))) {+                // KiCad 5 arc: start is the centre, end the first point, angle the sweep+                let (dx, dy) = (s.0 - c.0, s.1 - c.1);+                let t = ang.to_radians();+                let e = (c.0 + dx * t.cos() - dy * t.sin(), c.1 + dx * t.sin() + dy * t.cos());+                out.push(Edge { a: tf(s), b: tf(e), arc: true });+            }+        }+        "curve" => {+            let pts: Vec<(f64, f64)> = n.find("pts").map(|p| p.find_all("xy").filter_map(|xy| Some((xy.number(1)?, xy.number(2)?))).collect()).unwrap_or_default();+            if let (Some(a), Some(b)) = (pts.first(), pts.last()) { out.push(Edge { a: tf(*a), b: tf(*b), arc: true }); }+        }+        "rect" => if let (Some(a), Some(b)) = (p2(n.find("start")), p2(n.find("end"))) {+            let c = [a, (b.0, a.1), b, (a.0, b.1)].map(tf);+            for k in 0..4 { out.push(Edge { a: c[k], b: c[(k + 1) % 4], arc: false }); }+        },+        "poly" => {+            // a closed chain: (xy) vertices joined by straight edges, (arc) pieces as arcs+            let mut chain: Vec<((f64, f64), (f64, f64), bool)> = Vec::new();+            let mut cur: Option<(f64, f64)> = None;+            let mut first: Option<(f64, f64)> = None;+            for it in n.find("pts").map(|p| p.nodes().collect::<Vec<_>>()).unwrap_or_default() {+                let (s, e, arc) = match it.tag.as_str() {+                    "xy" => match (it.number(1), it.number(2)) { (Some(x), Some(y)) => ((x, y), (x, y), false), _ => continue },+                    "arc" => match (p2(it.find("start")), p2(it.find("end"))) { (Some(s), Some(e)) => (s, e, true), _ => continue },+                    _ => continue,+                };+                if first.is_none() { first = Some(s); }+                if let Some(c) = cur { if !near(c, s) { chain.push((c, s, false)); } }+                if arc { chain.push((s, e, true)); }+                cur = Some(e);+            }+            if let (Some(c), Some(f)) = (cur, first) { if !near(c, f) { chain.push((c, f, false)); } }+            if chain.len() > 2 || chain.iter().any(|x| x.2) {+                for (a, b, arc) in chain { out.push(Edge { a: tf(a), b: tf(b), arc }); }+            }+        }+        _ => {}+    }+}+ #[cfg(test)] mod tests {     use super::*;@@ -100,4 +157,50 @@ mod tests {         assert_eq!((e.len(), e.iter().filter(|x| x.arc).count()), (8, 4));         assert!(sharp_corners(&e).is_empty());     }+    #[test]+    fn a_rounded_kicad_board_with_busy_footprints_has_no_sharp_corner() {+        // issue #71: tab-indented KiCad 10 text, an R4-rounded Edge.Cuts outline, and footprints+        // full of silk/fab polygons and lines in local coordinates; none of them is outline+        let fp = |r: &str, x: f64, y: f64, rot: f64| {+            let mut s = format!("\t(footprint \"Pkg:SOT-23\"\n\t\t(layer \"F.Cu\")\n\t\t(at {x} {y} {rot})\n\t\t(property \"Reference\" \"{r}\" (at 0 -2.4 0) (layer \"F.SilkS\"))\n");+            for k in 0..40 {+                let d = k as f64 * 0.01;+                s += &format!("\t\t(fp_poly (pts (xy {} -6.4) (xy -9 -6.9) (xy -9.5 -6.9)) (stroke (width 0.12) (type solid)) (fill yes) (layer \"F.SilkS\"))\n", -9.25 + d);+                s += &format!("\t\t(fp_line (start -0.62 {}) (end -0.9 -1.41) (stroke (width 0.1) (type solid)) (layer \"F.Fab\"))\n", -1.69 + d);+            }+            s += "\t\t(pad \"1\" smd roundrect (at -0.95 1.1) (size 0.6 1.0) (layers \"F.Cu\" \"F.Paste\" \"F.Mask\"))\n\t)\n";+            s+        };+        let mut t = String::from("(kicad_pcb\n\t(version 20250114)\n\t(generator \"pcbnew\")\n");+        t += &fp("U1", 40.0, 30.0, 0.0);+        t += &fp("Q1", 60.0, 30.0, 90.0);+        for (a, b) in [((24.0, 20.0), (96.0, 20.0)), ((100.0, 24.0), (100.0, 56.0)), ((96.0, 60.0), (24.0, 60.0)), ((20.0, 56.0), (20.0, 24.0))] {+            t += &format!("\t(gr_line\n\t\t(start {} {})\n\t\t(end {} {})\n\t\t(stroke (width 0.05) (type default))\n\t\t(layer \"Edge.Cuts\")\n\t)\n", a.0, a.1, b.0, b.1);+        }+        for (s, m, e) in [((96.0, 20.0), (98.828427, 21.171573), (100.0, 24.0)), ((100.0, 56.0), (98.828427, 58.828427), (96.0, 60.0)), ((24.0, 60.0), (21.171573, 58.828427), (20.0, 56.0)), ((20.0, 24.0), (21.171573, 21.171573), (24.0, 20.0))] {+            t += &format!("\t(gr_arc\n\t\t(start {} {})\n\t\t(mid {} {})\n\t\t(end {} {})\n\t\t(stroke (width 0.05) (type default))\n\t\t(layer \"Edge.Cuts\")\n\t)\n", s.0, s.1, m.0, m.1, e.0, e.1);+        }+        t += "\t(gr_poly (pts (xy 30 30) (xy 35 30) (xy 35 35)) (stroke (width 0.1) (type solid)) (fill no) (layer \"F.SilkS\"))\n)\n";+        let e = kicad_edges(&t);+        assert_eq!((e.len(), e.iter().filter(|x| x.arc).count()), (8, 4));+        assert!(sharp_corners(&e).is_empty());+        // the same board with square corners reads four+        let sq = "(kicad_pcb\n\t(gr_rect (start 20 20) (end 100 60) (stroke (width 0.05) (type default)) (fill no) (layer \"Edge.Cuts\"))\n)";+        let c = sharp_corners(&kicad_edges(sq));+        assert_eq!(c.len(), 4);+        for p in [(20.0, 20.0), (100.0, 20.0), (100.0, 60.0), (20.0, 60.0)] { assert!(c.iter().any(|q| near(*q, p)), "{p:?}"); }+    }+    #[test]+    fn a_footprint_edge_cuts_cutout_is_read_in_board_coordinates() {+        // a slot drawn in a footprint on Edge.Cuts, the footprint at (50, 30) turned 90 degrees+        let t = "(kicad_pcb\n\t(footprint \"Slot\" (layer \"F.Cu\") (at 50 30 90)\n\t\t(property \"Reference\" \"H1\")\n\t\t(fp_rect (start -1 -2) (end 1 2) (stroke (width 0.05) (type solid)) (fill no) (layer \"Edge.Cuts\"))\n\t\t(fp_line (start -3 0) (end 3 0) (layer \"F.SilkS\"))\n\t)\n\t(footprint \"Notch\" (layer \"B.Cu\") (at 10 10 180)\n\t\t(property \"Reference\" \"H2\")\n\t\t(fp_line (start 0 0) (end 2 0) (layer \"Edge.Cuts\"))\n\t\t(fp_arc (start 2 0) (mid 2.7071 0.7071) (end 3 1) (layer \"Edge.Cuts\"))\n\t)\n)";+        let e = kicad_edges(t);+        assert_eq!(e.len(), 6);+        let c = sharp_corners(&e);+        assert_eq!(c.len(), 4, "{c:?}");+        // rot_kicad(-1, -2, 90) = (-2, 1): the corner lands at (48, 31), not near the origin+        for p in [(48.0, 31.0), (48.0, 29.0), (52.0, 29.0), (52.0, 31.0)] { assert!(c.iter().any(|q| near(*q, p)), "{p:?} in {c:?}"); }+        // the back-side footprint: position and rotation (180 degrees) map (2, 0) to (8, 10)+        assert!(e.iter().any(|x| x.arc && near(x.a, (8.0, 10.0)) && near(x.b, (7.0, 9.0))));+    } }

@@ -1,10 +1,16 @@-//! Read-only comparison of a saved board with an explicit pour plan.-//! This creates no zone ownership and never changes native copper.+//! Read-only comparison of a saved board with an explicit pour plan, plus the two explicit,+//! recorded exceptions around it: adopting matching zones (ownership, `--adopt --why`) and+//! accepting a plan whose provenance is not established (`--why`). Verification alone creates no+//! zone ownership and never changes native copper. use aiflow_board::{sx::Node, Board};-use serde_json::{json, Value};+use aiflow_run::Run;+use serde_json::{json, Map, Value}; use sha2::{Digest, Sha256}; use std::path::Path; +/// The modes of a `land-pours` outcome that accept zones already on the saved board.+pub const EXISTING_MODES: [&str; 2] = ["verified-existing", "adopted-existing"];+ pub fn hash(path: &Path) -> Result<String, String> {     std::fs::read(path)         .map(|b| format!("{:x}", Sha256::digest(b)))@@ -34,6 +40,7 @@ fn canonical(n: &Node) -> Value {         .collect();     json!([n.tag, atoms, children]) }+/// The geometry and settings of one zone, normalised to the plan's words so both sides compare. fn signature(board: &Board, n: &Node) -> Value {     let mut layers: Vec<String> = n         .find("layer")@@ -56,7 +63,13 @@ fn signature(board: &Board, n: &Node) -> Value {         v["priority"] = json!(number(n, "priority", 0.0));         v["minThickness"] = json!(number(n, "min_thickness", 0.25));         let cp = n.find("connect_pads");-        v["connection"] = json!(cp.and_then(Node::value).unwrap_or("thermal"));+        v["connection"] = json!(match cp.and_then(Node::value) {+            None => "thermal",+            Some("yes") => "solid",+            Some("no") => "none",+            Some("thru_hole_only") => "thru-hole only",+            Some(other) => other,+        });         v["clearance"] = json!(cp.map(|x| number(x, "clearance", 0.0)).unwrap_or(0.0));         let fill = n.find("fill");         for (key, default) in [@@ -68,10 +81,90 @@ fn signature(board: &Board, n: &Node) -> Value {         ] {             v[key] = json!(fill.map(|x| number(x, key, default)).unwrap_or(default));         }+        let mode = v["island_removal_mode"].as_f64().unwrap_or(0.0);+        v["island_removal_mode"] = json!(match mode as i64 { 0 => "always", 1 => "never", 2 => "area", _ => "unknown" });+        // the minimum area means something only for the area mode+        if mode as i64 != 2 {+            v["island_area_min"] = Value::Null;+        }     }     v } +/// The plan's words for each signature field, as the per-zone report names them.+fn field_label(key: &str) -> &str {+    match key {+        "layers" => "layer",+        "polygons" => "geometry",+        "net" => "net",+        "priority" => "priority",+        "clearance" => "clearance",+        "minThickness" => "min thickness",+        "connection" => "pad connection",+        "thermal_gap" => "thermal gap",+        "thermal_bridge_width" => "thermal bridge",+        "island_removal_mode" => "island removal",+        "island_area_min" => "island area min",+        "mode" => "fill mode",+        "keepout" => "keepout rules",+        "placement" => "placement rule area",+        other => other,+    }+}++fn points(n: &Node) -> Vec<(f64, f64)> {+    n.find_all("polygon")+        .filter_map(|p| p.find("pts"))+        .flat_map(|pts| pts.find_all("xy").filter_map(|xy| Some((xy.number(1)?, xy.number(2)?))).collect::<Vec<_>>())+        .collect()+}++/// Each field where the board zone differs from the plan zone, with both values.+fn differences(want: &Value, have: &Value, want_node: &Node, have_node: &Node) -> Vec<Value> {+    let empty = Map::new();+    let (w, h) = (want.as_object().unwrap_or(&empty), have.as_object().unwrap_or(&empty));+    let mut keys: Vec<&String> = w.keys().chain(h.keys()).collect();+    keys.sort();+    keys.dedup();+    let mut out = Vec::new();+    for k in keys {+        let (a, b) = (w.get(k).unwrap_or(&Value::Null), h.get(k).unwrap_or(&Value::Null));+        if a == b {+            continue;+        }+        if k == "polygons" {+            let (pa, pb) = (points(want_node), points(have_node));+            let first = pa.iter().zip(pb.iter()).position(|(x, y)| x != y);+            let detail = match first {+                Some(i) => format!("vertex {i}: plan ({}, {}), board ({}, {})", pa[i].0, pa[i].1, pb[i].0, pb[i].1),+                None => format!("plan {} vertices, board {}", pa.len(), pb.len()),+            };+            out.push(json!({"field":"geometry","plan":format!("{} vertices", pa.len()),"board":format!("{} vertices", pb.len()),"detail":detail}));+        } else {+            out.push(json!({"field":field_label(k),"plan":a,"board":b}));+        }+    }+    out+}++fn diff_line(d: &[Value]) -> String {+    d.iter()+        .map(|x| match x["detail"].as_str() {+            Some(detail) => format!("{} ({detail})", x["field"].as_str().unwrap_or("")),+            None => format!("{} (plan {}, board {})", x["field"].as_str().unwrap_or(""), x["plan"], x["board"]),+        })+        .collect::<Vec<_>>()+        .join("; ")+}++fn zone_name(n: &Node) -> &str {+    n.find("name").and_then(Node::value).unwrap_or("unnamed")+}++fn zone_id(n: &Node) -> Option<String> {+    n.find("uuid").or_else(|| n.find("tstamp")).and_then(Node::value).filter(|s| !s.is_empty()).map(str::to_string)+}+ pub fn check(board: &Board, plan: &Value) -> Result<Value, String> {     let zones = plan["zones"]         .as_array()@@ -79,9 +172,11 @@ pub fn check(board: &Board, plan: &Value) -> Result<Value, String> {         .ok_or("nonempty zones plan required")?;     let resolved = aiflow_pours::resolve_outline(board, zones);     let actual: Vec<_> = board.root.find_all("zone").collect();+    let signatures: Vec<Value> = actual.iter().map(|n| signature(board, n)).collect();     let mut used = std::collections::BTreeSet::new();     let mut groups = Vec::new();     let mut failed = Vec::new();+    let mut report = Vec::new();     for (index, z) in resolved.iter().enumerate() {         let label = z["name"].as_str().unwrap_or("unnamed zone");         let allowed = [@@ -95,6 +190,8 @@ pub fn check(board: &Board, plan: &Value) -> Result<Value, String> {             "minThickness",             "thermalGap",             "thermalBridge",+            "islandRemoval",+            "islandAreaMin",             "type",             "keepout",         ];@@ -125,19 +222,10 @@ pub fn check(board: &Board, plan: &Value) -> Result<Value, String> {         }) {             return Err(format!("{label}: finite polygon coordinates required"));         }-        for key in ["clearance", "minThickness", "thermalGap", "thermalBridge"] {-            if !z[key].is_null() && !z[key].as_f64().is_some_and(|x| x.is_finite() && x >= 0.0) {-                return Err(format!("{label}: invalid {key}"));-            }-        }+        aiflow_pours::check_settings(z).map_err(|e| format!("{label}: {e}"))?;         if !z["priority"].is_null() && z["priority"].as_u64().is_none() {             return Err(format!("{label}: invalid priority"));         }-        if !z["connection"].is_null()-            && !matches!(z["connection"].as_str(), Some("solid" | "full" | "thermal"))-        {-            return Err(format!("{label}: unsupported connection"));-        }         if !z["type"].is_null() && !matches!(z["type"].as_str(), Some("keepout" | "copper")) {             return Err(format!("{label}: unsupported zone type"));         }@@ -152,19 +240,39 @@ pub fn check(board: &Board, plan: &Value) -> Result<Value, String> {         }         let expected = aiflow_board::sx::parse(&aiflow_pours::zone_sexpr(board, z)?)?;         let wanted = signature(board, &expected);-        let matches: Vec<_> = actual-            .iter()-            .enumerate()-            .filter(|(i, n)| !used.contains(i) && signature(board, n) == wanted)+        let matches: Vec<usize> = (0..actual.len())+            .filter(|i| !used.contains(i) && signatures[*i] == wanted)             .collect();         if matches.len() != 1 {-            failed.push(format!(+            // name the closest unused board zone and every field where it differs+            let closest = (0..actual.len())+                .filter(|i| !used.contains(i))+                .map(|i| (i, differences(&wanted, &signatures[i], &expected, actual[i])))+                .min_by_key(|(i, d)| (d.len(), *i));+            let mut line = format!(                 "{index}: {label}: expected one exact geometry/settings match, found {}",                 matches.len()-            ));+            );+            let mut entry = json!({"zone":index,"name":label,"matches":matches.len()});+            if matches.is_empty() {+                if let Some((i, d)) = closest {+                    line.push_str(&format!("; closest board zone {i} ({}) differs in: {}", zone_name(actual[i]), diff_line(&d)));+                    entry["closestBoardZone"] = json!(i);+                    entry["closestBoardZoneName"] = json!(zone_name(actual[i]));+                    entry["fields"] = json!(d);+                } else {+                    line.push_str("; no unmatched board zone is left");+                }+            } else {+                line.push_str(" (ambiguous: several board zones carry the same geometry and settings)");+                entry["boardZones"] = json!(matches);+            }+            failed.push(line);+            report.push(entry);             continue;         }-        let (i, n) = matches[0];+        let i = matches[0];+        let n = actual[i];         used.insert(i);         let supported = [             "net",@@ -172,6 +280,7 @@ pub fn check(board: &Board, plan: &Value) -> Result<Value, String> {             "layer",             "layers",             "uuid",+            "tstamp",             "name",             "hatch",             "priority",@@ -221,23 +330,34 @@ pub fn check(board: &Board, plan: &Value) -> Result<Value, String> {                 }             }         }-        groups.push(json!({"name":label,"boardZoneIndex":i,"ok":true}));+        groups.push(json!({"name":label,"boardZoneIndex":i,"boardZoneUuid":zone_id(n),"ok":true}));     }     // No hidden extra copper or keepout: every saved zone needs an explicit plan entry.     for (i, n) in actual.iter().enumerate().filter(|(i, _)| !used.contains(i)) {-        failed.push(format!(-            "unplanned board zone {i}: {}",-            n.find("name").and_then(Node::value).unwrap_or("unnamed")-        ));+        failed.push(format!("unplanned board zone {i}: {}", zone_name(n)));     }     Ok(-        json!({"mode":"verified-existing","pass":failed.is_empty(),"failed":failed,"groups":groups,+        json!({"mode":"verified-existing","pass":failed.is_empty(),"failed":failed,"groups":groups,"differences":report,         "ownershipGranted":false,"scope":"saved filled polygons and planned zone geometry/settings; native DRC, measured copper and electrical/thermal checks remain separate"}),     ) } +/// True for a `land-pours` outcome that accepted zones already on the saved board.+pub fn is_existing(outcome: &Value) -> bool {+    outcome["mode"].as_str().is_some_and(|m| EXISTING_MODES.contains(&m))+}++/// How finish and the summary name the pours evidence.+pub fn mode_label(outcome: &Value) -> &'static str {+    match outcome["mode"].as_str() {+        Some("verified-existing") => "verified existing",+        Some("adopted-existing") => "adopted existing (not landed by this run)",+        _ => "landed",+    }+}+ pub fn bound(outcome: &Value, board: &Path, spec: &Path) -> bool {-    if outcome["mode"] != "verified-existing" {+    if !is_existing(outcome) {         return true;     }     outcome["boardSha256"].as_str() == hash(board).ok().as_deref()@@ -250,6 +370,252 @@ pub fn bound(outcome: &Value, board: &Path, spec: &Path) -> bool {         && outcome["planSha256"].is_string() } +/// Settings the KiCad Bridge's `kicad_apply_zone_plan` cannot land faithfully (it lands thermal or+/// solid pad connection with islands always removed). Such a zone is refused before any call, so+/// a landing never silently differs from the plan; write it natively and verify or adopt it.+pub fn landable(zones: &[Value]) -> Result<(), String> {+    for z in zones {+        if z.get("keepout").is_some() || z["type"] == "keepout" {+            continue;+        }+        let name = z["name"].as_str().unwrap_or("unnamed zone");+        if z["connection"] == "none" {+            return Err(format!("{name}: pad connection none cannot be landed through kicad_apply_zone_plan (it lands thermal or solid)"));+        }+        if z.get("islandRemoval").is_some_and(|v| v != "always") {+            return Err(format!("{name}: islandRemoval {} cannot be landed through kicad_apply_zone_plan (it always removes islands)", z["islandRemoval"]));+        }+    }+    Ok(())+}++// -- plan provenance (issue #57) --------------------------------------------------------------++/// A hash of the board's zone definitions (outline, net, layers, settings), leaving out fills and+/// item IDs, so a refill or a re-save does not count as a zone change.+pub fn zone_fingerprint(board: &Board) -> String {+    fn strip(n: &Node) -> Value {+        let mut children: Vec<Value> = n+            .nodes()+            .filter(|c| !matches!(c.tag.as_str(), "filled_polygon" | "fill_segments" | "uuid" | "tstamp"))+            .map(strip)+            .collect();+        if n.tag != "pts" {+            children.sort_by_key(Value::to_string);+        }+        let atoms: Vec<&str> = (1..).map_while(|i| n.atom(i)).collect();+        json!([n.tag, atoms, children])+    }+    let mut zones: Vec<String> = board.root.find_all("zone").map(|z| strip(z).to_string()).collect();+    zones.sort();+    format!("{:x}", Sha256::digest(zones.join("\n").as_bytes()))+}++fn mtime(p: &Path) -> Option<u64> {+    std::fs::metadata(p).ok()?.modified().ok()?.duration_since(std::time::UNIX_EPOCH).ok().map(|d| d.as_secs())+}++/// When the current board's zones last changed: the time the run added the oldest snapshot of the+/// latest unbroken series whose zones equal the current ones (`boardAddedAt`, else the snapshot+/// file's modification time). An unreadable older snapshot ends the series (later, stricter).+pub fn zones_changed_at(data: &Value) -> Result<(u64, String), String> {+    let boards: Vec<String> = data["boards"].as_array().map(|a| a.iter().filter_map(|b| b.as_str().map(str::to_string)).collect()).unwrap_or_default();+    let current = boards.last().ok_or("the run has no board")?;+    let fp = zone_fingerprint(&Board::load(current)?);+    let mut first = current.clone();+    for b in boards.iter().rev().skip(1) {+        match Board::load(b) {+            Ok(old) if zone_fingerprint(&old) == fp => first = b.clone(),+            _ => break,+        }+    }+    let t = data["boardAddedAt"][first.as_str()]+        .as_str()+        .and_then(aiflow_run::parse)+        .or_else(|| mtime(Path::new(&first)))+        .ok_or_else(|| format!("{first}: no time for this board snapshot"))?;+    Ok((t, first))+}++/// Record a plan in the run: `pour` for one aiflow wrote, `reviewed` for one recorded before+/// the zones it describes change (`verify-pours --record-plan`).+pub fn record_plan(data: &mut Value, path: &Path, source: &str) -> Result<Value, String> {+    let sha = hash(path).map_err(|e| format!("{}: {e}", path.display()))?;+    let canon = std::fs::canonicalize(path).map_err(|e| format!("{}: {e}", path.display()))?;+    let mut entry = json!({"source": source, "sha256": sha, "path": canon, "at": aiflow_run::now()});+    if source == "reviewed" {+        if let Some(b) = data["boards"].as_array().and_then(|a| a.last()).and_then(Value::as_str) {+            entry["boardSha256"] = json!(hash(Path::new(b)).ok());+            entry["zoneFingerprint"] = json!(Board::load(b).ok().map(|b| zone_fingerprint(&b)));+        }+    }+    if !data["pourPlans"].is_array() {+        data["pourPlans"] = json!([]);+    }+    data["pourPlans"].as_array_mut().unwrap().push(entry.clone());+    Ok(entry)+}++/// Where the plan came from: Ok with the accepted record, or Err saying why it is not bound.+/// Accepted: a plan `pour` wrote (its hash recorded by the run), or a reviewed plan recorded+/// strictly before the current board's zones changed. Anything else is circular until shown+/// otherwise: a plan written from the board always matches the board.+pub fn provenance(data: &Value, plan_sha: &str, plan: &Path) -> Result<Value, String> {+    let plans = data["pourPlans"].as_array().cloned().unwrap_or_default();+    let same: Vec<&Value> = plans.iter().filter(|p| p["sha256"].as_str() == Some(plan_sha)).collect();+    if let Some(p) = same.iter().rev().find(|p| p["source"] == "pour") {+        return Ok(json!({"kind": "aiflow-pour", "recordedAt": p["at"], "path": p["path"]}));+    }+    let (changed, board) = zones_changed_at(data)?;+    let reviewed = same+        .iter()+        .filter(|p| p["source"] == "reviewed")+        .filter_map(|p| Some((aiflow_run::parse(p["at"].as_str()?)?, *p)))+        .min_by_key(|(t, _)| *t);+    if let Some((t, p)) = reviewed {+        if t < changed {+            return Ok(json!({"kind": "reviewed-before-zone-change", "recordedAt": p["at"], "zonesChangedAt": aiflow_run::iso(changed), "zonesChangedBoard": board}));+        }+    }+    let when = aiflow_run::iso(changed);+    let recorded = match reviewed {+        Some((t, _)) => format!("it was recorded at {} (not before)", aiflow_run::iso(t)),+        None => "it was not recorded with `verify-pours --record-plan` before then".into(),+    };+    let file = match mtime(plan) {+        Some(m) if m >= changed => format!("; the plan file was modified at {}, after the zones changed", aiflow_run::iso(m)),+        Some(m) => format!("; the plan file was modified at {}", aiflow_run::iso(m)),+        None => String::new(),+    };+    Err(format!("plan provenance not established: `pour` did not write this plan, and the board's zones last changed at {when} (snapshot {board}) while {recorded}{file}. A plan written from the board always matches the board."))+}++/// Grant ownership of the zones a passing verification matched: their saved IDs join+/// `ownedZoneIds` (so a later `land pours` may replace them) and the grant is recorded with its+/// why in `zoneAdoptions`. Every matched zone needs a saved ID; nothing is inferred from names.+pub fn adopt(data: &mut Value, proof: &Value, why: &str) -> Result<Vec<String>, String> {+    if proof["pass"] != true {+        return Err("only a passing verification can adopt zones".into());+    }+    if why.trim().is_empty() {+        return Err("--adopt needs --why".into());+    }+    let groups = proof["groups"].as_array().cloned().unwrap_or_default();+    let mut ids = Vec::new();+    for g in &groups {+        let id = g["boardZoneUuid"].as_str().filter(|s| !s.is_empty()).ok_or_else(|| format!("{}: the saved zone has no uuid to own", g["name"]))?;+        ids.push(id.to_string());+    }+    if ids.is_empty() {+        return Err("no zones to adopt".into());+    }+    // Before the first grant, keep the legacy creation receipts the landing used to read.+    if data.get("ownedZoneIds").is_none_or(Value::is_null) {+        let mut legacy: Vec<Value> = Vec::new();+        for g in data["outcomes"]["land-pours"]["groups"].as_array().into_iter().flatten().filter(|g| g["ok"] == true) {+            for id in g["itemIds"].as_array().into_iter().flatten().filter(|v| v.is_string()) {+                if !legacy.contains(id) {+                    legacy.push(id.clone());+                }+            }+        }+        data["ownedZoneIds"] = json!(legacy);+    }+    let owned = data["ownedZoneIds"].as_array_mut().ok_or("ownedZoneIds is not a list")?;+    for id in &ids {+        if !owned.iter().any(|x| x.as_str() == Some(id)) {+            owned.push(json!(id));+        }+    }+    if !data["zoneAdoptions"].is_array() {+        data["zoneAdoptions"] = json!([]);+    }+    data["zoneAdoptions"].as_array_mut().unwrap().push(json!({+        "at": aiflow_run::now(), "why": why, "plan": proof["plan"], "planSha256": proof["planSha256"],+        "boardSha256": proof["boardSha256"], "planProvenance": proof["planProvenance"],+        "zones": groups.iter().map(|g| json!({"name": g["name"], "uuid": g["boardZoneUuid"]})).collect::<Vec<_>>()+    }));+    Ok(ids)+}++type Reply = Result<(String, Vec<String>), (String, Vec<String>)>;++/// `verify-pours`: compare, bind the plan's provenance, and optionally record a reviewed plan or+/// adopt the matched zones. Writes the `land-pours` outcome only for a comparison.+pub fn command(r: &mut Run, dir: &Path, plan: &str, adopt_zones: bool, why: Option<&str>, record: bool) -> Reply {+    let e = |m: String| (m, Vec::<String>::new());+    let why = why.map(str::trim).filter(|w| !w.is_empty());+    let plan_path = Path::new(plan);+    if record {+        if adopt_zones {+            return Err(e("--record-plan only records the plan; verify (and adopt) in a later call".into()));+        }+        let v: Value = serde_json::from_str(&std::fs::read_to_string(plan_path).map_err(|x| e(format!("{plan}: {x}")))?).map_err(|x| e(format!("{plan}: not JSON: {x}")))?;+        if v["zones"].as_array().is_none_or(Vec::is_empty) {+            return Err(e("nonempty zones plan required".into()));+        }+        let entry = record_plan(&mut r.data, plan_path, "reviewed").map_err(e)?;+        r.log("pour-plan-recorded", entry.clone());+        r.save().map_err(e)?;+        return Ok((format!("reviewed pour plan recorded (sha256 {}); verify-pours accepts it once the board's zones change after this moment", &entry["sha256"].as_str().unwrap_or("")[..12]),+            vec!["Record the plan before the zones it describes are drawn or edited. A plan recorded after the zones changed still needs --why.".into()]));+    }+    if adopt_zones && why.is_none() {+        return Err(("--adopt needs --why <reason>: adoption grants this run ownership of zones it did not land".into(), vec![]));+    }+    let board_path = r.current_board();+    let board_hash = hash(Path::new(&board_path)).map_err(e)?;+    let plan_hash = hash(plan_path).map_err(|x| e(format!("{plan}: {x}")))?;+    let board = Board::load(&board_path).map_err(e)?;+    let plan_v: Value = serde_json::from_str(&std::fs::read_to_string(plan_path).map_err(|x| e(format!("{plan}: {x}")))?).map_err(|x| e(format!("{plan}: not JSON: {x}")))?;+    let mut proof = check(&board, &plan_v).map_err(e)?;+    if hash(Path::new(&board_path)).ok().as_deref() != Some(&board_hash) || hash(plan_path).ok().as_deref() != Some(&plan_hash) {+        return Err(e("board or plan changed during verification; retry after the writer finishes".into()));+    }+    let provenance = match provenance(&r.data, &plan_hash, plan_path) {+        Ok(p) => p,+        Err(reason) => match why {+            Some(w) => json!({"kind": "accepted-with-why", "why": w, "refusal": reason}),+            None => {+                r.log("verify-pours-refused", json!({"plan": plan, "planSha256": plan_hash, "reason": reason}));+                return Err((reason, vec![+                    "Verify against the plan `pour` wrote (adom-aiflow pour), or a plan recorded with `verify-pours --plan <file> --record-plan` before the zones changed.".into(),+                    "If this plan is honestly independent of the board, pass --why <reason>; the why is recorded with the proof. No board or ownership was changed.".into(),+                ]));+            }+        },+    };+    proof["planProvenance"] = provenance;+    proof["boardSha256"] = json!(board_hash);+    proof["specSha256"] = json!(hash(Path::new(r.data["spec"].as_str().unwrap_or(""))).map_err(e)?);+    proof["planSha256"] = json!(plan_hash);+    proof["plan"] = json!(std::fs::canonicalize(plan).map_err(|x| e(x.to_string()))?);+    if proof["pass"] == true && adopt_zones {+        let ids = adopt(&mut r.data, &proof, why.unwrap_or("")).map_err(e)?;+        proof["mode"] = json!("adopted-existing");+        proof["ownershipGranted"] = json!(true);+        proof["adoptedZoneIds"] = json!(ids);+        proof["why"] = json!(why);+    }+    let out = dir.join("verify-pours.json");+    std::fs::write(&out, serde_json::to_string_pretty(&proof).unwrap()).map_err(|x| e(format!("{}: {x}", out.display())))?;+    r.outcome("land-pours", proof.clone());+    r.save().map_err(e)?;+    if proof["pass"] != true {+        return Err((format!("saved pours do not match the plan: {}", proof["failed"]), vec![+            "Each failure names the closest board zone and the fields that differ (also in verify-pours.json `differences`). spec.pours can carry connection (thermal, solid, none), thermalGap, thermalBridge, islandRemoval (always, never, area) and islandAreaMin; run `pour` again after a spec change.".into(),+            "Review the actual geometry and intended plan; never replay pours or write a plan from the board merely to restore evidence. No board or ownership was changed.".into(),+        ]));+    }+    let kind = proof["planProvenance"]["kind"].as_str().unwrap_or("").to_string();+    if adopt_zones {+        return Ok((format!("existing saved pours match the reviewed plan ({kind}); {} zone(s) adopted: owned by this run, recorded as adopted, not landed", proof["adoptedZoneIds"].as_array().map(|a| a.len()).unwrap_or(0)),+            vec!["A later `land pours` may now replace these zones through the native bridge. Native DRC, live measurement, current and thermal checks remain required. Changed board, spec or plan invalidates this proof.".into()]));+    }+    Ok((format!("existing saved pours match the reviewed plan ({kind}); no copper or ownership changed"),+        vec!["Native DRC, live measurement, current and thermal checks remain required. Changed board, spec or plan invalidates this proof. Add --adopt --why <reason> to take ownership of these zones.".into()]))+}+ #[cfg(test)] mod tests {     use super::*;@@ -319,7 +685,7 @@ mod tests {     #[test]     fn invalid_connection_refuses() {         let (b, mut p) = fixture();-        p["zones"][0]["connection"] = json!("none");+        p["zones"][0]["connection"] = json!("spokes");         assert!(check(&b, &p).is_err());     }     #[test]@@ -355,4 +721,196 @@ mod tests {         p["zones"][0]["typo"] = json!(1);         assert!(check(&b, &p).is_err());     }++    // -- issue #69: zones written offline, field-by-field report, settings, adoption ----------+    const PREFIX: &str = r#"(kicad_pcb (version 20260101) (net 0 "") (net 1 "5V0") (layers (0 "F.Cu" signal) (31 "B.Cu" signal)) (gr_rect (start 0 0) (end 20 20) (layer "Edge.Cuts")) (footprint "R" (layer "F.Cu") (at 5 5) (property "Reference" "R1") (pad "1" smd rect (at 0 0) (size 1 1) (layers "F.Cu") (net 1 "5V0")))"#;+    /// A zone the way the issue's offline script wrote it: solid pads, clearance 0.25,+    /// min thickness 0.2, thermal gap 0.3, bridge 0.4, island removal written out as 0.+    const OFFLINE: &str = r#"(zone (net 1) (net_name "5V0") (layer "F.Cu") (uuid "aaaa-1") (name "P3 5V0 power") (hatch edge 0.5) (priority 2) (connect_pads yes (clearance 0.25)) (min_thickness 0.2) (filled_areas_thickness no) (fill yes (thermal_gap 0.3) (thermal_bridge_width 0.4) (island_removal_mode 0)) (polygon (pts (xy 1 1) (xy 9 1) (xy 9 9) (xy 1 9))) (filled_polygon (layer "F.Cu") (pts (xy 1 1) (xy 9 1) (xy 9 9))))"#;+    fn offline() -> Board {+        Board::from_text("offline", format!("{PREFIX} {OFFLINE})")).unwrap()+    }+    fn offline_plan() -> Value {+        json!({"zones":[{"name":"P3 5V0 power","net":"5V0","layers":["F.Cu"],"polygon":[[1,1],[9,1],[9,9],[1,9]],"priority":2,"clearance":0.25,"minThickness":0.2,"connection":"solid"}]})+    }+    #[test]+    fn offline_zone_report_names_each_differing_field() {+        let r = check(&offline(), &offline_plan()).unwrap();+        assert_eq!(r["pass"], false);+        let line = r["failed"][0].as_str().unwrap();+        assert!(line.contains("closest board zone 0 (P3 5V0 power)"), "{line}");+        assert!(line.contains("thermal gap (plan 0.5, board 0.3)") && line.contains("thermal bridge (plan 0.5, board 0.4)"), "{line}");+        let fields: Vec<&str> = r["differences"][0]["fields"].as_array().unwrap().iter().map(|f| f["field"].as_str().unwrap()).collect();+        assert_eq!(fields, ["thermal bridge", "thermal gap"]);+        // every other field is named too when it differs+        let mut p = offline_plan();+        p["zones"][0]["polygon"][2] = json!([9, 8]);+        p["zones"][0]["priority"] = json!(1);+        p["zones"][0]["clearance"] = json!(0.3);+        p["zones"][0]["minThickness"] = json!(0.25);+        p["zones"][0]["connection"] = json!("thermal");+        p["zones"][0]["islandRemoval"] = json!("never");+        let line = check(&offline(), &p).unwrap()["failed"][0].as_str().unwrap().to_string();+        for want in ["geometry (vertex 2: plan (9, 8), board (9, 9))", "priority", "clearance", "min thickness", "pad connection (plan \"thermal\", board \"solid\")", "island removal (plan \"never\", board \"always\")"] {+            assert!(line.contains(want), "{want} in {line}");+        }+        p["zones"][0]["layers"] = json!(["B.Cu"]);+        assert!(check(&offline(), &p).unwrap()["failed"][0].as_str().unwrap().contains("layer (plan [\"B.Cu\"], board [\"F.Cu\"])"));+    }+    #[test]+    fn plan_settings_describe_offline_zones_exactly() {+        let mut p = offline_plan();+        p["zones"][0]["thermalGap"] = json!(0.3);+        p["zones"][0]["thermalBridge"] = json!(0.4);+        let r = check(&offline(), &p).unwrap();+        assert_eq!(r["pass"], true, "{}", r["failed"]);+        assert_eq!(r["groups"][0]["boardZoneUuid"], "aaaa-1");+        // pad connection none and island removal never / below an area round-trip too+        for (conn, cp, island, fill) in [("none", "(connect_pads no (clearance 0.25))", json!("never"), "(island_removal_mode 1)"), ("thermal", "(connect_pads (clearance 0.25))", json!("area"), "(island_removal_mode 2) (island_area_min 4)")] {+            let zone = OFFLINE.replace("(connect_pads yes (clearance 0.25))", cp).replace("(island_removal_mode 0)", fill);+            let b = Board::from_text("o", format!("{PREFIX} {zone})")).unwrap();+            let mut q = p.clone();+            q["zones"][0]["connection"] = json!(conn);+            q["zones"][0]["islandRemoval"] = island.clone();+            if island == "area" {+                q["zones"][0]["islandAreaMin"] = json!(4);+            }+            assert_eq!(check(&b, &q).unwrap()["pass"], true, "{conn}: {}", check(&b, &q).unwrap()["failed"]);+            q["zones"][0]["connection"] = json!("solid");+            assert_eq!(check(&b, &q).unwrap()["pass"], false);+        }+    }+    #[test]+    fn bridge_limits_refuse_before_landing() {+        assert!(landable(&[json!({"name":"a","connection":"solid"}), json!({"type":"keepout","connection":"none"})]).is_ok());+        assert!(landable(&[json!({"name":"a","connection":"none"})]).unwrap_err().contains("pad connection none"));+        assert!(landable(&[json!({"name":"a","islandRemoval":"never"})]).is_err());+        assert!(landable(&[json!({"name":"a","islandRemoval":"always"})]).is_ok());+    }+    #[test]+    fn adoption_grants_recorded_ownership_only_for_saved_ids() {+        let mut p = offline_plan();+        p["zones"][0]["thermalGap"] = json!(0.3);+        p["zones"][0]["thermalBridge"] = json!(0.4);+        let proof = check(&offline(), &p).unwrap();+        let mut data = json!({"outcomes":{"land-pours":{"groups":[{"ok":true,"itemIds":["landed-1"]},{"ok":false,"itemIds":["failed-1"]}]}}});+        assert!(adopt(&mut data, &proof, " ").is_err(), "a why is required");+        assert_eq!(adopt(&mut data, &proof, "written offline; KiCad 10 SWIG cannot build outlines").unwrap(), ["aaaa-1"]);+        assert_eq!(data["ownedZoneIds"], json!(["landed-1", "aaaa-1"]), "legacy receipts kept, failed ones never owned");+        assert_eq!(data["zoneAdoptions"][0]["zones"][0]["uuid"], "aaaa-1");+        assert!(data["zoneAdoptions"][0]["why"].as_str().unwrap().contains("SWIG"));+        let mut failing = proof.clone();+        failing["pass"] = json!(false);+        assert!(adopt(&mut data, &failing, "x").is_err());+        let mut no_id = proof.clone();+        no_id["groups"][0]["boardZoneUuid"] = Value::Null;+        assert!(adopt(&mut json!({}), &no_id, "x").unwrap_err().contains("no uuid"));+        assert_eq!(mode_label(&json!({"mode":"adopted-existing"})), "adopted existing (not landed by this run)");+        assert!(is_existing(&json!({"mode":"adopted-existing"})) && !is_existing(&json!({"failed":[]})));+    }++    // -- issue #57: plan provenance ---------------------------------------------------------------+    fn tmpdir(name: &str) -> std::path::PathBuf {+        let d = std::env::temp_dir().join(format!("aiflow-pour-prov-{name}-{}", std::process::id()));+        let _ = std::fs::remove_dir_all(&d);+        std::fs::create_dir_all(&d).unwrap();+        d+    }+    /// board-0 without zones (added at t0), board-1 with the offline zone (added at t1).+    fn prov_run(d: &Path, t0: u64, t1: u64) -> Run {+        let (b0, b1) = (d.join("board-0.kicad_pcb"), d.join("board-1.kicad_pcb"));+        std::fs::write(&b0, format!("{PREFIX})")).unwrap();+        std::fs::write(&b1, format!("{PREFIX} {OFFLINE})")).unwrap();+        let spec = d.join("spec.json");+        std::fs::write(&spec, "{}").unwrap();+        let (b0s, b1s) = (b0.display().to_string(), b1.display().to_string());+        Run { dir: d.to_path_buf(), data: json!({"boards":[b0s, b1s], "spec": spec, "outcomes": {},+            "boardAddedAt": {b0s.as_str(): aiflow_run::iso(t0), b1s.as_str(): aiflow_run::iso(t1)}}) }+    }+    fn write_plan(d: &Path, name: &str) -> std::path::PathBuf {+        let mut p = offline_plan();+        p["zones"][0]["thermalGap"] = json!(0.3);+        p["zones"][0]["thermalBridge"] = json!(0.4);+        let f = d.join(name);+        std::fs::write(&f, p.to_string()).unwrap();+        f+    }+    #[test]+    fn zone_change_time_is_the_first_snapshot_with_the_current_zones() {+        let d = tmpdir("time");+        let mut r = prov_run(&d, 1000, 2000);+        assert_eq!(zones_changed_at(&r.data).unwrap().0, 2000);+        // a later snapshot with the same zones (silk-only, refilled) keeps the change time+        let b2 = d.join("board-2.kicad_pcb");+        std::fs::write(&b2, format!("{PREFIX} {})", OFFLINE.replace("(xy 9 9))))", "(xy 9 8))))").replace("aaaa-1", "bbbb-2"))).unwrap();+        r.data["boards"].as_array_mut().unwrap().push(json!(b2.display().to_string()));+        r.data["boardAddedAt"][b2.display().to_string().as_str()] = json!(aiflow_run::iso(3000));+        assert_eq!(zones_changed_at(&r.data).unwrap(), (2000, d.join("board-1.kicad_pcb").display().to_string()));+        let _ = std::fs::remove_dir_all(d);+    }+    #[test]+    fn plan_provenance_binds_to_pour_or_to_a_record_before_the_change() {+        let d = tmpdir("prov");+        let now = aiflow_run::parse(&aiflow_run::now()).unwrap();+        let mut r = prov_run(&d, now - 200, now - 100);+        let plan = write_plan(&d, "plan.json");+        let sha = hash(&plan).unwrap();+        // written from the board after the zones changed, never recorded: refused+        let e = provenance(&r.data, &sha, &plan).unwrap_err();+        assert!(e.contains("not recorded") && e.contains("after the zones changed"), "{e}");+        // recorded now, after the change: still refused+        record_plan(&mut r.data, &plan, "reviewed").unwrap();+        assert!(provenance(&r.data, &sha, &plan).unwrap_err().contains("not before"));+        // recorded before the zones changed: accepted+        let mut early = r.data.clone();+        early["pourPlans"][0]["at"] = json!(aiflow_run::iso(now - 150));+        assert_eq!(provenance(&early, &sha, &plan).unwrap()["kind"], "reviewed-before-zone-change");+        // the same second as the change is not before it+        early["pourPlans"][0]["at"] = json!(aiflow_run::iso(now - 100));+        assert!(provenance(&early, &sha, &plan).is_err());+        // a plan `pour` wrote is aiflow's own output+        record_plan(&mut r.data, &plan, "pour").unwrap();+        assert_eq!(provenance(&r.data, &sha, &plan).unwrap()["kind"], "aiflow-pour");+        // an edited plan is a different plan+        std::fs::write(&plan, "{\"zones\":[{}]}").unwrap();+        assert!(provenance(&r.data, &hash(&plan).unwrap(), &plan).is_err());+        let _ = std::fs::remove_dir_all(d);+    }+    #[test]+    fn verify_command_refuses_circular_plans_without_why_and_records_adoption() {+        let d = tmpdir("cmd");+        let now = aiflow_run::parse(&aiflow_run::now()).unwrap();+        let mut r = prov_run(&d, now - 200, now - 100);+        let plan = write_plan(&d, "plan-actual.json");+        let ps = plan.display().to_string();+        let (m, _) = command(&mut r, &d, &ps, false, None, false).unwrap_err();+        assert!(m.contains("provenance"), "{m}");+        assert!(r.data["outcomes"].get("land-pours").is_none(), "a refusal records no proof");+        assert!(command(&mut r, &d, &ps, true, None, false).unwrap_err().0.contains("--why"));+        let (m, _) = command(&mut r, &d, &ps, false, Some("plan typed from the native review, not the board"), false).unwrap();+        assert!(m.contains("accepted-with-why"), "{m}");+        let o = r.data["outcomes"]["land-pours"].clone();+        assert_eq!(o["planProvenance"]["why"], "plan typed from the native review, not the board");+        assert_eq!(o["ownershipGranted"], false);+        let spec = r.data["spec"].as_str().unwrap().to_string();+        assert!(bound(&o, Path::new(&r.current_board()), Path::new(&spec)));+        // adoption: owned, recorded, reported as adopted rather than landed+        let (m, _) = command(&mut r, &d, &ps, true, Some("zones written offline (#69)"), false).unwrap();+        assert!(m.contains("adopted"), "{m}");+        let o = r.data["outcomes"]["land-pours"].clone();+        assert_eq!(o["mode"], "adopted-existing");+        assert_eq!(r.data["ownedZoneIds"], json!(["aaaa-1"]));+        assert!(bound(&o, Path::new(&r.current_board()), Path::new(&spec)));+        std::fs::write(&plan, "{}").unwrap();+        assert!(!bound(&o, Path::new(&r.current_board()), Path::new(&spec)), "a changed plan invalidates the adopted proof");+        // a plan recorded with --record-plan before the zones change needs no why+        let d2 = tmpdir("cmd2");+        let mut r2 = prov_run(&d2, now - 200, now + 100);+        let plan2 = write_plan(&d2, "reviewed.json");+        command(&mut r2, &d2, &plan2.display().to_string(), false, None, true).unwrap();+        let (m, _) = command(&mut r2, &d2, &plan2.display().to_string(), false, None, false).unwrap();+        assert!(m.contains("reviewed-before-zone-change"), "{m}");+        let _ = std::fs::remove_dir_all(d);+        let _ = std::fs::remove_dir_all(d2);+    } }

@@ -0,0 +1,222 @@+//! A board's own project library (issue #66): parts that have no public Adom wiki component page yet+//! (a private page, a reviewed project-only footprint, a page waiting for an owner's sign-off) satisfy+//! the `parts` step from a folder that holds KiCad symbols (*.kicad_sym), footprints (*.pretty/*.kicad_mod),+//! STEP models and a provenance.json. Each listed MPN needs a symbol, a footprint, a STEP model and a+//! provenance source, the same evidence a component page carries. `project-page` packages these parts into+//! the board's PCM repository beside the wiki parts, and `finish` reports which parts came from here.+//!+//! provenance.json: {"parts": [{"mpn": "ABC-123", "source": "datasheet rev C, p. 12", "symbol": "ABC-123",+//! "footprint": "QFN-16_3x3", "model": "3dmodels/ABC-123.step"}]} (or {"parts": {"ABC-123": {...}}}).+//! symbol defaults to the MPN, footprint to the symbol's Footprint property, model to the footprint's model.++use aiflow_board::sx;+use serde_json::{json, Value};+use std::collections::BTreeMap;+use std::path::{Path, PathBuf};++struct Symbol { file: PathBuf, footprint: String }+struct Footprint { file: PathBuf, model: Option<String> }++pub struct ProjectLib {+    pub dir: PathBuf,+    entries: BTreeMap<String, Value>,+    symbols: BTreeMap<String, Symbol>,+    footprints: BTreeMap<String, Footprint>,+    models: Vec<PathBuf>,+}++fn walk(dir: &Path, depth: usize, out: &mut Vec<PathBuf>) {+    let Ok(rd) = std::fs::read_dir(dir) else { return };+    for e in rd.flatten() {+        let p = e.path();+        if p.is_dir() { if depth < 4 { walk(&p, depth + 1, out); } } else { out.push(p); }+    }+}++fn ext(p: &Path) -> String { p.extension().and_then(|e| e.to_str()).unwrap_or("").to_ascii_lowercase() }++fn key(s: &str) -> String { s.trim().to_ascii_uppercase() }++/// The part name after a `Lib:` prefix.+fn bare(s: &str) -> &str { s.rsplit_once(':').map(|(_, n)| n).unwrap_or(s) }++fn is_step(p: &Path) -> bool {+    std::fs::read(p).map(|b| String::from_utf8_lossy(&b[..b.len().min(64)]).trim_start().starts_with("ISO-10303-21")).unwrap_or(false)+}++impl ProjectLib {+    pub fn load(dir: &Path) -> Result<ProjectLib, String> {+        if !dir.is_dir() { return Err(format!("project library {}: no such folder", dir.display())); }+        let prov_path = dir.join("provenance.json");+        let prov: Value = std::fs::read_to_string(&prov_path).map_err(|e| format!("{}: {e} (a project library needs a provenance.json)", prov_path.display()))+            .and_then(|t| serde_json::from_str(&t).map_err(|e| format!("{}: {e}", prov_path.display())))?;+        let mut entries = BTreeMap::new();+        let parts = if prov.is_array() { prov.clone() } else { prov["parts"].clone() };+        match parts {+            Value::Array(a) => for p in a { if let Some(m) = p["mpn"].as_str() { entries.insert(key(m), p.clone()); } },+            Value::Object(o) => for (m, p) in o { let mut p = p.clone(); if p.is_object() && p["mpn"].is_null() { p["mpn"] = json!(m); } entries.insert(key(&m), p); },+            _ => return Err(format!("{}: no \"parts\" list", prov_path.display())),+        }+        let mut files = Vec::new();+        walk(dir, 0, &mut files);+        let mut symbols = BTreeMap::new();+        let mut footprints = BTreeMap::new();+        let mut models = Vec::new();+        for f in &files {+            match ext(f).as_str() {+                "kicad_sym" => {+                    let text = std::fs::read_to_string(f).map_err(|e| format!("{}: {e}", f.display()))?;+                    let root = sx::parse(&text).map_err(|e| format!("{}: {e}", f.display()))?;+                    for s in root.nodes().filter(|n| n.tag == "symbol") {+                        let Some(name) = s.atom(1) else { continue };+                        let fp = s.nodes().find(|p| p.tag == "property" && p.atom(1) == Some("Footprint")).and_then(|p| p.atom(2)).unwrap_or("").to_string();+                        symbols.insert(key(name), Symbol { file: f.clone(), footprint: fp });+                    }+                }+                "kicad_mod" if f.parent().map(|p| ext(p) == "pretty").unwrap_or(false) => {+                    let text = std::fs::read_to_string(f).map_err(|e| format!("{}: {e}", f.display()))?;+                    let root = sx::parse(&text).map_err(|e| format!("{}: {e}", f.display()))?;+                    let model = root.find("model").and_then(|m| m.atom(1)).map(str::to_string);+                    let stem = f.file_stem().and_then(|s| s.to_str()).unwrap_or("").to_string();+                    footprints.insert(key(&stem), Footprint { file: f.clone(), model });+                }+                "step" | "stp" => models.push(f.clone()),+                _ => {}+            }+        }+        Ok(ProjectLib { dir: dir.to_path_buf(), entries, symbols, footprints, models })+    }++    /// The part's files when the library has all of them, else what is missing.+    pub fn part(&self, mpn: &str) -> Result<Value, Vec<String>> {+        let Some(e) = self.entries.get(&key(mpn)) else { return Err(vec!["not in provenance.json".into()]) };+        let mut why = Vec::new();+        let source = ["source", "datasheet", "origin"].iter().find_map(|k| e[*k].as_str().filter(|s| !s.trim().is_empty())).map(str::to_string);+        if source.is_none() { why.push("no provenance source (provenance.json \"source\": where the symbol, footprint and model come from)".into()); }+        let sym_name = e["symbol"].as_str().map(|s| bare(s).to_string()).unwrap_or_else(|| mpn.to_string());+        let sym = self.symbols.get(&key(&sym_name));+        if sym.is_none() { why.push(format!("no symbol {sym_name} in a .kicad_sym")); }+        let fp_name = e["footprint"].as_str().map(|s| bare(s).to_string()).or_else(|| sym.map(|s| bare(&s.footprint).to_string())).unwrap_or_default();+        let fp = self.footprints.get(&key(&fp_name));+        if fp.is_none() { why.push(if fp_name.is_empty() { "no footprint (name one in provenance.json or the symbol's Footprint property)".into() } else { format!("no footprint {fp_name}.kicad_mod in a .pretty folder") }); }+        let model = match e["model"].as_str() {+            Some(m) => { let p = self.dir.join(m); if p.is_file() { Some(p) } else { self.find_model(m) } }+            None => fp.and_then(|f| f.model.as_deref()).and_then(|m| self.find_model(m)),+        };+        match &model {+            None => why.push("no STEP model (provenance.json \"model\", or the footprint's model path, naming a .step file in the library)".into()),+            Some(p) if !is_step(p) => why.push(format!("{} is not a STEP file (no ISO-10303-21 header)", p.display())),+            _ => {}+        }+        if !why.is_empty() { return Err(why); }+        let abs = |p: &Path| std::fs::canonicalize(p).unwrap_or_else(|_| p.to_path_buf()).display().to_string();+        Ok(json!({"dir": abs(&self.dir), "symbol": sym_name, "symbolFile": abs(&sym.unwrap().file), "footprint": fp_name, "footprintFile": abs(&fp.unwrap().file),+                  "model": abs(model.as_ref().unwrap()), "source": source, "provenance": e}))+    }++    /// A model by path or by file name anywhere in the library (KiCad paths often carry ${KIPRJMOD} or a 3D variable).+    fn find_model(&self, m: &str) -> Option<PathBuf> {+        let name = m.rsplit(['/', '\\']).next().unwrap_or(m).to_ascii_lowercase();+        self.models.iter().find(|p| p.file_name().and_then(|f| f.to_str()).map(|f| f.to_ascii_lowercase() == name).unwrap_or(false)).cloned()+    }+}++/// Every BOM row with no wiki page is looked up in the project library: a complete part gets+/// row["projectLib"]; the rest come back as (mpn, why) for the parts report.+pub fn resolve(rows: &mut [Value], lib: &ProjectLib) -> Vec<(String, String)> {+    let mut missing = Vec::new();+    for row in rows.iter_mut().filter(|r| r["wiki"].is_null()) {+        let mpn = row["mpn"].as_str().unwrap_or("").to_string();+        match lib.part(&mpn) {+            Ok(p) => { row["projectLib"] = p; row["source"] = json!("project-lib"); }+            Err(why) => if !missing.iter().any(|(m, _): &(String, String)| m == &mpn) { missing.push((mpn, why.join("; "))); },+        }+    }+    missing+}++/// The parts that came from a project library (for `finish`): "MPN (refs) from <dir>".+pub fn report(parts: &Value) -> Vec<String> {+    parts.as_array().into_iter().flatten().filter(|p| p["projectLib"].is_object()).map(|p| {+        let refs = p["refs"].as_array().map(|a| a.iter().filter_map(|v| v.as_str()).collect::<Vec<_>>().join(",")).unwrap_or_default();+        format!("{} ({refs}) from project library {}", p["mpn"].as_str().unwrap_or(""), p["projectLib"]["dir"].as_str().unwrap_or(""))+    }).collect()+}++/// Recheck at finish: every project-library part still has its files.+pub fn recheck(parts: &Value) -> Vec<String> {+    let mut gaps = Vec::new();+    let mut libs: BTreeMap<String, Option<ProjectLib>> = BTreeMap::new();+    for p in parts.as_array().into_iter().flatten().filter(|p| p["projectLib"].is_object()) {+        let dir = p["projectLib"]["dir"].as_str().unwrap_or("").to_string();+        let lib = libs.entry(dir.clone()).or_insert_with(|| ProjectLib::load(Path::new(&dir)).ok());+        let mpn = p["mpn"].as_str().unwrap_or("");+        match lib {+            None => gaps.push(format!("project library {dir} no longer loads ({mpn})")),+            Some(l) => if let Err(why) = l.part(mpn) { gaps.push(format!("{mpn}: {}", why.join("; "))); },+        }+    }+    gaps+}++#[cfg(test)]+mod tests {+    use super::*;++    pub fn fixture(dir: &Path, with_model: bool) {+        std::fs::create_dir_all(dir.join("lib.pretty")).unwrap();+        std::fs::create_dir_all(dir.join("3dmodels")).unwrap();+        std::fs::write(dir.join("lib.kicad_sym"), "(kicad_symbol_lib (version 20241209) (generator \"kicad_symbol_editor\")\n  (symbol \"ABC-123\" (property \"Reference\" \"U\") (property \"Footprint\" \"lib:QFN-16\"))\n  (symbol \"XYZ-9\" (property \"Footprint\" \"\"))\n)\n").unwrap();+        std::fs::write(dir.join("lib.pretty/QFN-16.kicad_mod"), "(footprint \"QFN-16\" (layer \"F.Cu\") (model \"${KIPRJMOD}/3dmodels/ABC-123.step\"))\n").unwrap();+        if with_model { std::fs::write(dir.join("3dmodels/ABC-123.step"), "ISO-10303-21;\nHEADER;\nENDSEC;\n").unwrap(); }+        std::fs::write(dir.join("provenance.json"), r#"{"parts": [{"mpn": "abc-123", "source": "datasheet rev C, p. 12"}, {"mpn": "XYZ-9"}]}"#).unwrap();+    }++    fn tmp(name: &str) -> PathBuf {+        let d = std::env::temp_dir().join(format!("aiflow-projlib-{name}-{}", std::process::id()));+        let _ = std::fs::remove_dir_all(&d);+        d+    }++    #[test]+    fn a_complete_part_resolves_and_gaps_are_named() {+        let d = tmp("ok");+        fixture(&d, true);+        let lib = ProjectLib::load(&d).unwrap();+        let p = lib.part("ABC-123").unwrap();+        assert_eq!(p["footprint"], "QFN-16");+        assert!(p["model"].as_str().unwrap().ends_with("ABC-123.step"));+        assert_eq!(p["source"], "datasheet rev C, p. 12");+        let why = lib.part("XYZ-9").unwrap_err().join("; ");+        assert!(why.contains("no provenance source") && why.contains("no footprint") && why.contains("no STEP model"), "{why}");+        assert_eq!(lib.part("NOPE").unwrap_err()[0], "not in provenance.json");+        let mut rows = vec![json!({"mpn": "ABC-123", "refs": ["U1"], "wiki": null}), json!({"mpn": "R-1", "refs": ["R1"], "wiki": "adom/r-1"}), json!({"mpn": "NOPE", "refs": ["U2"], "wiki": null})];+        let missing = resolve(&mut rows, &lib);+        assert_eq!(missing.len(), 1);+        assert_eq!(missing[0].0, "NOPE");+        assert_eq!(rows[0]["source"], "project-lib");+        assert!(rows[1]["projectLib"].is_null());+        let rep = report(&json!(rows));+        assert_eq!(rep.len(), 1);+        assert!(rep[0].starts_with("ABC-123 (U1) from project library"), "{rep:?}");+        assert!(recheck(&json!(rows)).is_empty());+        let _ = std::fs::remove_dir_all(&d);+    }++    #[test]+    fn a_missing_model_fails_the_part() {+        let d = tmp("nomodel");+        fixture(&d, false);+        let lib = ProjectLib::load(&d).unwrap();+        assert!(lib.part("ABC-123").unwrap_err().join("; ").contains("no STEP model"));+        let _ = std::fs::remove_dir_all(&d);+    }++    #[test]+    fn no_provenance_is_refused() {+        let d = tmp("noprov");+        std::fs::create_dir_all(&d).unwrap();+        assert!(ProjectLib::load(&d).err().unwrap().contains("provenance.json"));+        let _ = std::fs::remove_dir_all(&d);+    }+}

@@ -0,0 +1,357 @@+//! The design-rule sanity card at `start` (issue #54). Read-only: it changes no gate.+//!+//! The spec is written by an AI, which is where a 0.025 that should have been 0.25 slips in. At+//! `start` this reads the spec's track widths, clearances, via pads, drills, copper thickness and+//! load currents, compares each with the fab lane's range (a generic range, tightened by the+//! minimums in the `.kicad_dru` beside the board), writes the card into the dashboard's+//! `timeline/presentation.json` (`rulesCard`, drawn to scale beside the board outline) and returns+//! one line per flag for `start` to print as WARNING.+use std::path::Path;++use aiflow_board::Board;+use serde_json::{json, Map, Value};++/// A fab lane's accepted range per feature, in mm (copper in um).+#[derive(Clone, Debug)]+pub struct Lane {+    pub name: String,+    pub trace: (f64, f64),+    pub clearance: (f64, f64),+    pub via_pad: (f64, f64),+    pub drill: (f64, f64),+    pub annular_min: f64,+    pub edge: (f64, f64),+    pub copper_um: (f64, f64),+    pub amps_max: f64,+    /// Where the lower limits came from.+    pub source: String,+}++impl Lane {+    /// The generic range: what any of the lanes builds without a special order. A trace under+    /// 0.1 mm or over 2 mm, a drill under 0.2 mm, copper outside 12..210 um is almost always a unit slip.+    pub fn generic(name: &str) -> Lane {+        Lane { name: name.into(), trace: (0.1, 2.0), clearance: (0.1, 2.0), via_pad: (0.35, 2.5), drill: (0.2, 1.6), annular_min: 0.075, edge: (0.2, 5.0), copper_um: (12.0, 210.0), amps_max: 60.0, source: "generic fab range".into() }+    }++    /// Tighten the lower limits with a rules pack's minimums (`(constraint track_width (min 0.127mm))`).+    pub fn with_dru(mut self, dru: &str, file: &str) -> Lane {+        let mins = dru_minimums(dru);+        let mut used = Vec::new();+        let mut up = |k: &str, slot: &mut f64| {+            if let Some(v) = mins.get(k).and_then(|v| v.as_f64()) {+                if v > *slot {+                    *slot = v;+                    used.push(format!("{k} {v}"));+                }+            }+        };+        up("track_width", &mut self.trace.0);+        up("clearance", &mut self.clearance.0);+        up("via_diameter", &mut self.via_pad.0);+        up("hole_size", &mut self.drill.0);+        up("annular_width", &mut self.annular_min);+        up("edge_clearance", &mut self.edge.0);+        if !used.is_empty() {+            self.source = format!("generic fab range, minimums from {file} ({})", used.join(", "));+        }+        self+    }+}++/// The least strict `min` of every constraint in a `.kicad_dru`, in mm.+pub fn dru_minimums(text: &str) -> Map<String, Value> {+    let mut out: Map<String, Value> = Map::new();+    let lines: Vec<&str> = text.lines().filter(|l| !l.trim_start().starts_with('#')).collect();+    let text = lines.join("\n");+    let mut rest = text.as_str();+    while let Some(i) = rest.find("(constraint ") {+        rest = &rest[i + 12..];+        let name: String = rest.chars().take_while(|c| c.is_alphanumeric() || *c == '_').collect();+        let end = rest.find("(constraint ").unwrap_or(rest.len());+        let body = &rest[..end];+        if let Some(j) = body.find("(min ") {+            let tok: String = body[j + 5..].chars().take_while(|c| *c != ')' && !c.is_whitespace()).collect();+            let (num, mult) = if let Some(n) = tok.strip_suffix("mm") { (n, 1.0) } else if let Some(n) = tok.strip_suffix("mil") { (n, 0.0254) } else if let Some(n) = tok.strip_suffix("um") { (n, 0.001) } else { (tok.as_str(), 1.0) };+            if let Ok(v) = num.parse::<f64>() {+                let v = ((v * mult) * 1e6).round() / 1e6;+                let cur = out.get(&name).and_then(|x| x.as_f64());+                if cur.map(|c| v < c).unwrap_or(true) {+                    out.insert(name, json!(v));+                }+            }+        }+    }+    out+}++/// One value on the card.+#[derive(Clone, Debug)]+pub struct Item {+    pub key: &'static str,+    pub label: String,+    pub value: f64,+    pub unit: &'static str,+    pub source: String,+    pub range: (f64, f64),+    pub flag: Option<String>,+}++fn item(key: &'static str, label: &str, value: f64, unit: &'static str, source: String, range: (f64, f64), lane: &Lane) -> Item {+    let flag = if !value.is_finite() || value <= 0.0 {+        Some(format!("{label} {value} {unit} ({source}) is not a positive size"))+    } else if value < range.0 - 1e-9 {+        Some(format!("{label} {value} {unit} ({source}) is below the {} lane's {} {unit}; check the unit (a 0.025 that should be 0.25)", lane.name, range.0))+    } else if value > range.1 + 1e-9 {+        Some(format!("{label} {value} {unit} ({source}) is above the {} lane's usual {} {unit}; check the unit", lane.name, range.1))+    } else {+        None+    };+    Item { key, label: label.into(), value, unit, source, range, flag }+}++fn widths(spec: &Value, key: &str) -> Vec<(String, f64)> {+    spec.get(key).and_then(|v| v.as_object()).map(|o| o.iter().flat_map(|(n, a)| a.as_array().cloned().unwrap_or_default().into_iter().filter_map(|w| w.as_f64()).map(|w| (n.clone(), w)).collect::<Vec<_>>()).collect()).unwrap_or_default()+}++/// Every value on the card, with the flags, for a spec against a lane.+pub fn items(spec: &Value, lane: &Lane) -> (Vec<Item>, Vec<Value>, Vec<String>) {+    let rules = aiflow_router::Rules::from_spec(spec);+    let has = |k: &str| spec.get(k).map(|v| !v.is_null()).unwrap_or(false);+    let src = |k: &str| if has(k) { format!("spec {k}") } else { format!("{k} default") };+    let mut out = Vec::new();+    // traces: every declared width is checked; the card draws the smallest+    let mut traces: Vec<(String, f64)> = vec![(src("track"), rules.track)];+    for k in ["minTrackWidth", "stub"] {+        if let Some(v) = spec.get(k).and_then(|v| v.as_f64()) {+            traces.push((format!("spec {k}"), v));+        }+    }+    for k in ["wideNets", "midNets"] {+        for (n, w) in widths(spec, k) {+            traces.push((format!("spec {k} {n}"), w));+        }+    }+    let min_t = traces.iter().cloned().fold((String::new(), f64::INFINITY), |a, b| if b.1 < a.1 { b } else { a });+    out.push(item("minTrace", "min trace", min_t.1, "mm", min_t.0.clone(), lane.trace, lane));+    for (s, w) in &traces {+        if s != &min_t.0 || *w != min_t.1 {+            let it = item("trace", "trace", *w, "mm", s.clone(), lane.trace, lane);+            if it.flag.is_some() {+                out.push(it);+            }+        }+    }+    let mut clr: Vec<(String, f64)> = vec![(src("clearance"), rules.clearance)];+    for (n, v) in &rules.net_clearance {+        clr.push((format!("spec netClearance {n}"), *v));+    }+    let min_c = clr.iter().cloned().fold((String::new(), f64::INFINITY), |a, b| if b.1 < a.1 { b } else { a });+    out.push(item("clearance", "clearance", min_c.1, "mm", min_c.0.clone(), lane.clearance, lane));+    for (s, v) in &clr {+        if s != &min_c.0 {+            let it = item("clearanceNet", "clearance", *v, "mm", s.clone(), lane.clearance, lane);+            if it.flag.is_some() {+                out.push(it);+            }+        }+    }+    let vias = [("viaSignal", "drillSignal", rules.via_small, rules.drill_small), ("viaPower", "drillPower", rules.via, rules.drill)];+    let small = if vias[0].2 <= vias[1].2 { 0 } else { 1 };+    for (k, (vk, dk, pad, drill)) in vias.iter().enumerate() {+        let (kp, kd) = if k == small { ("viaPad", "drill") } else { ("viaPadOther", "drillOther") };+        let dsrc = if has(dk) { format!("spec {dk}") } else if spec.get(*vk).and_then(|v| v.as_array()).map(|a| a.len() > 1).unwrap_or(false) { format!("spec {vk}[1]") } else { format!("{dk} default") };+        let p = item(kp, "via pad", *pad, "mm", src(vk), lane.via_pad, lane);+        let d = item(kd, "drill", *drill, "mm", dsrc, lane.drill, lane);+        let ring = (pad - drill) / 2.0;+        let mut r = item(if k == small { "annular" } else { "annularOther" }, "annular ring", (ring * 1e4).round() / 1e4, "mm", format!("({vk} - drill) / 2"), (lane.annular_min, f64::INFINITY), lane);+        if ring <= 0.0 {+            r.flag = Some(format!("{vk} {pad} mm is not larger than its drill {drill} mm"));+        }+        if k == small {+            out.push(p);+            out.push(d);+            out.push(r);+        } else {+            for it in [p, d, r] {+                if it.flag.is_some() {+                    out.push(it);+                }+            }+        }+    }+    out.push(item("edge", "edge clearance", rules.edge, "mm", src("edgeClearance"), lane.edge, lane));+    let cu = spec.get("copperUm").and_then(|v| v.as_f64());+    let mut c = item("copperUm", "copper", cu.unwrap_or(35.0), "um", if cu.is_some() { "spec copperUm".into() } else { "copperUm default (1 oz)".into() }, lane.copper_um, lane);+    if c.flag.is_some() && cu.map(|v| v < 1.0).unwrap_or(false) {+        c.flag = Some(format!("copper {} um (spec copperUm) looks like mm or oz: copperUm is micrometres, 35 for 1 oz", cu.unwrap_or(0.0)));+    }+    out.push(c);+    if let Some(m) = spec.get("copperUmByLayer").and_then(|v| v.as_object()) {+        for (l, v) in m {+            if let Some(x) = v.as_f64() {+                let it = item("copperLayer", &format!("copper {l}"), x, "um", format!("spec copperUmByLayer {l}"), lane.copper_um, lane);+                if it.flag.is_some() {+                    out.push(it);+                }+            }+        }+    }+    // load currents, with the widest width the spec gives the net+    let mut loads = Vec::new();+    let mut flags: Vec<String> = out.iter().filter_map(|i| i.flag.clone()).collect();+    if let Some(m) = spec.get("loads").and_then(|v| v.as_object()) {+        let all: Vec<(String, f64)> = widths(spec, "wideNets").into_iter().chain(widths(spec, "midNets")).collect();+        for (net, l) in m {+            let amps = l.get("amps").and_then(|a| a.as_f64()).or_else(|| l.as_f64());+            let widest = all.iter().filter(|(n, _)| n == net).map(|x| x.1).fold(None, |a: Option<f64>, w| Some(a.map(|x| x.max(w)).unwrap_or(w)));+            let flag = match amps {+                None => Some(format!("load {net}: no amps")),+                Some(a) if a <= 0.0 => Some(format!("load {net}: {a} A is not a positive current")),+                Some(a) if a > lane.amps_max => Some(format!("load {net}: {a} A is above {} A; check the unit (amps, not mA)", lane.amps_max)),+                _ => None,+            };+            if let Some(f) = &flag {+                flags.push(f.clone());+            }+            loads.push(json!({"net": net, "amps": amps, "widestMm": widest.unwrap_or(rules.track), "widthFrom": if widest.is_some() { "wideNets/midNets" } else { "track" }, "flag": flag}));+        }+    }+    (out, loads, flags)+}++fn outline_of(board: &Board) -> Value {+    let (x0, y0, x1, y1) = board.bbox;+    let pts = &board.outline;+    let step = (pts.len() / 400).max(1);+    let rel: Vec<Value> = pts.iter().step_by(step).map(|p| json!([((p.0 - x0) * 100.0).round() / 100.0, ((p.1 - y0) * 100.0).round() / 100.0])).collect();+    json!({"widthMm": ((x1 - x0) * 100.0).round() / 100.0, "heightMm": ((y1 - y0) * 100.0).round() / 100.0, "outline": rel})+}++/// The card for this board and spec.+pub fn card(spec: &Value, board: Option<&Board>, lane: &Lane, rules_file: Option<&str>) -> (Value, Vec<String>) {+    let (items, loads, mut flags) = items(spec, lane);+    let b = board.map(outline_of).unwrap_or(Value::Null);+    if let Some(bd) = board {+        let (w, h) = (bd.bbox.2 - bd.bbox.0, bd.bbox.3 - bd.bbox.1);+        if w.max(h) < 2.0 || w.max(h) > 600.0 {+            flags.push(format!("board outline {w:.2} x {h:.2} mm; check the board's units"));+        }+    }+    let get = |k: &str| items.iter().find(|i| i.key == k).map(|i| i.value);+    let v = json!({+        "title": "Design rules at start",+        "lane": lane.name, "rangeSource": lane.source, "rulesFile": rules_file,+        "board": b,+        "draw": {"traceMm": get("minTrace"), "clearanceMm": get("clearance"), "viaPadMm": get("viaPad"), "drillMm": get("drill")},+        "items": items.iter().map(|i| json!({"key": i.key, "label": i.label, "value": i.value, "unit": i.unit, "source": i.source, "min": i.range.0, "max": if i.range.1.is_finite() { json!(i.range.1) } else { Value::Null }, "flag": i.flag})).collect::<Vec<_>>(),+        "loads": loads,+        "flags": flags,+        "note": "Read-only: this card changes no gate. The gates use the KiCad project rules, the .kicad_dru and the spec as they are.",+    });+    (v, flags)+}++/// Merge `rulesCard` into `<run>/timeline/presentation.json`, keeping every other field.+pub fn present(dir: &Path, card: &Value) -> Result<(), String> {+    let d = dir.join("timeline");+    std::fs::create_dir_all(&d).map_err(|e| e.to_string())?;+    let path = d.join("presentation.json");+    let mut p: Value = std::fs::read_to_string(&path).ok().and_then(|t| serde_json::from_str(&t).ok()).filter(|v: &Value| v.is_object()).unwrap_or(json!({}));+    p["rulesCard"] = card.clone();+    let tmp = d.join("presentation.rules.tmp");+    std::fs::write(&tmp, serde_json::to_string_pretty(&p).unwrap_or_default()).map_err(|e| e.to_string())?;+    std::fs::rename(&tmp, &path).map_err(|e| e.to_string())+}++/// At `start`: build the card for the run's board copy, write it beside the run (`rules-card.json`)+/// and into the dashboard's presentation, and return the flags. Never fails the start.+pub fn at_start(dir: &Path, spec: &Value, board_copy: &Path, fab_rules: &Value) -> Vec<String> {+    let lane_name = crate::checks::rules_target(spec, fab_rules).map(|t| t.0).unwrap_or_else(|| "default".into());+    let dru = board_copy.with_extension("kicad_dru");+    let mut lane = Lane::generic(&lane_name);+    let rules_file = std::fs::read_to_string(&dru).ok().map(|t| {+        lane = lane.clone().with_dru(&t, &dru.display().to_string());+        dru.display().to_string()+    });+    let board = Board::load(&board_copy.display().to_string()).ok();+    let (v, flags) = card(spec, board.as_ref(), &lane, rules_file.as_deref());+    std::fs::write(dir.join("rules-card.json"), serde_json::to_string_pretty(&v).unwrap_or_default()).ok();+    if let Err(e) = present(dir, &v) {+        eprintln!("Hint: the design-rule card could not be written to the dashboard ({e}); rules-card.json has it.");+    }+    flags+}++#[cfg(test)]+mod tests {+    use super::*;++    fn flags_of(spec: Value) -> Vec<String> {+        items(&spec, &Lane::generic("fab")).2+    }++    #[test]+    fn a_unit_slip_in_a_trace_is_flagged() {+        let f = flags_of(json!({"track": 0.025}));+        assert_eq!(f.len(), 1, "{f:?}");+        assert!(f[0].contains("min trace 0.025 mm") && f[0].contains("below") && f[0].contains("0.1"), "{}", f[0]);+        assert!(flags_of(json!({"track": 0.25, "clearance": 0.2, "copperUm": 35})).is_empty());+        let f = flags_of(json!({"track": 0.25, "wideNets": {"+VBAT": [25.0, 0.5]}}));+        assert!(f.iter().any(|x| x.contains("wideNets +VBAT") && x.contains("above")), "{f:?}");+    }++    #[test]+    fn clearance_via_drill_and_copper_ranges() {+        let f = flags_of(json!({"clearance": 0.02}));+        assert!(f.iter().any(|x| x.contains("clearance 0.02")), "{f:?}");+        let f = flags_of(json!({"viaSignal": [0.45, 0.15]}));+        assert!(f.iter().any(|x| x.starts_with("drill 0.15") && x.contains("spec viaSignal[1]")), "{f:?}");+        let f = flags_of(json!({"viaPower": [0.4, 0.5]}));+        assert!(f.iter().any(|x| x.contains("not larger than its drill")), "{f:?}");+        let f = flags_of(json!({"copperUm": 0.035}));+        assert!(f.iter().any(|x| x.contains("micrometres")), "{f:?}");+        let f = flags_of(json!({"netClearance": {"HV": 25}}));+        assert!(f.iter().any(|x| x.contains("netClearance HV")), "{f:?}");+    }++    #[test]+    fn loads_are_checked_and_shown_with_their_width() {+        let (_, loads, f) = items(&json!({"wideNets": {"+VBAT": [1.0, 0.5]}, "loads": {"+VBAT": {"amps": 20}, "+5V": {"amps": 0}, "SENSE": {"amps": 2500}}}), &Lane::generic("fab"));+        assert!(f.iter().any(|x| x.contains("+5V") && x.contains("not a positive")), "{f:?}");+        assert!(f.iter().any(|x| x.contains("SENSE") && x.contains("mA")), "{f:?}");+        let vbat = loads.iter().find(|l| l["net"] == "+VBAT").unwrap();+        assert_eq!(vbat["widestMm"], 1.0);+        assert!(vbat["flag"].is_null());+    }++    #[test]+    fn a_rules_pack_raises_the_lane_minimums() {+        let m = dru_minimums(crate::checks::JLCPCB_2L);+        assert_eq!(m["track_width"], json!(0.127));+        assert_eq!(m["hole_size"], json!(0.3));+        let lane = Lane::generic("jlcpcb").with_dru(crate::checks::JLCPCB_2L, "b.kicad_dru");+        assert_eq!(lane.trace.0, 0.127);+        assert!(lane.source.contains("b.kicad_dru"));+        let f = items(&json!({"track": 0.12, "viaSignal": [0.6, 0.3]}), &lane).2;+        assert!(f.iter().any(|x| x.contains("min trace 0.12") && x.contains("jlcpcb")), "{f:?}");+        assert_eq!(dru_minimums("(rule a (constraint track_width (min 5mil)))")["track_width"], json!(0.127));+    }++    #[test]+    fn the_card_merges_into_the_presentation() {+        let dir = std::env::temp_dir().join(format!("aiflow-rules-card-{}", std::process::id()));+        std::fs::create_dir_all(dir.join("timeline")).unwrap();+        std::fs::write(dir.join("timeline/presentation.json"), r#"{"caption":"kept"}"#).unwrap();+        let (v, flags) = card(&json!({"track": 0.025}), None, &Lane::generic("fab"), None);+        assert_eq!(flags.len(), 1);+        assert_eq!(v["draw"]["traceMm"], 0.025);+        assert_eq!(v["draw"]["drillMm"], 0.3);+        present(&dir, &v).unwrap();+        let p: Value = serde_json::from_str(&std::fs::read_to_string(dir.join("timeline/presentation.json")).unwrap()).unwrap();+        assert_eq!(p["caption"], "kept");+        assert_eq!(p["rulesCard"]["items"][0]["key"], "minTrace");+        assert!(p["rulesCard"]["items"][0]["flag"].is_string());+        std::fs::remove_dir_all(&dir).ok();+    }+}

@@ -0,0 +1,118 @@+//! What `schematic check` reads back from KiCad (issues #65, #68): the symbols on the sheet from the+//! exported netlist, and the ERC errors from the ERC report. A report that is missing or does not read+//! is a failure, never a clean ERC.++use serde_json::Value;+use std::collections::BTreeMap;+use std::path::Path;++/// Every symbol in a KiCad `kicadsexpr` netlist: reference -> (libsource lib, footprint). The comps sit+/// in `(export ... (components (comp ...)))`, the same place `netlist check` reads them from; power+/// symbols (`#PWR`) are not parts.+pub fn sheet_symbols(text: &str) -> Result<BTreeMap<String, (String, String)>, String> {+    let root = aiflow_board::sx::parse(text)?;+    if root.tag != "export" {+        return Err(format!("not a KiCad netlist (root is ({}), expected (export ...))", root.tag));+    }+    let mut out = BTreeMap::new();+    let Some(comps) = root.find("components") else { return Ok(out) };+    for comp in comps.find_all("comp") {+        let Some(rf) = comp.find("ref").and_then(|n| n.atom(1)) else { continue };+        if rf.starts_with('#') { continue; }+        let lib = comp.find("libsource").and_then(|l| l.find("lib")).and_then(|n| n.atom(1)).unwrap_or("").to_string();+        let fp = comp.find("footprint").and_then(|n| n.atom(1)).unwrap_or("").to_string();+        out.insert(rf.to_string(), (lib, fp));+    }+    Ok(out)+}++/// The error-severity violations in a KiCad ERC JSON report. Err when the report is missing, does not+/// parse, or is not an ERC report (no `sheets` list): ERC did not run, so it did not pass.+pub fn erc_errors(report: &Path) -> Result<(Value, Vec<String>), String> {+    let text = std::fs::read_to_string(report).map_err(|e| format!("no ERC report at {} ({e}): ERC did not run", report.display()))?;+    let v: Value = serde_json::from_str(&text).map_err(|e| format!("the ERC report {} does not read ({e})", report.display()))?;+    let Some(sheets) = v["sheets"].as_array() else { return Err(format!("{} is not a KiCad ERC report (no sheets)", report.display())) };+    let errors = sheets.iter()+        .flat_map(|sh| sh["violations"].as_array().cloned().unwrap_or_default())+        .filter(|x| x["severity"] == "error")+        .map(|x| x["description"].as_str().unwrap_or("").to_string())+        .collect();+    Ok((v, errors))+}++/// Run `kicad-cli sch erc` (`cli`: ADOM_AIFLOW_KICAD_CLI, local or adom-aiflow-kicad-cli-remote) into+/// `report` and read it. A report from an earlier run is removed first so it cannot stand in for this one.+pub fn run_erc(cli: &str, sch: &str, report: &Path) -> Result<(Value, Vec<String>), String> {+    let _ = std::fs::remove_file(report);+    let o = std::process::Command::new(cli)+        .args(["sch", "erc", "--format", "json", "--severity-all", "--output"]).arg(report).arg(sch)+        .stdin(std::process::Stdio::null()).output()+        .map_err(|e| format!("{cli} is not runnable: {e}"))?;+    erc_errors(report).map_err(|e| {+        let tail = |b: &[u8]| { let t = String::from_utf8_lossy(b).to_string(); t.chars().rev().take(400).collect::<String>().chars().rev().collect::<String>() };+        format!("{e}. {cli} sch erc said: {} {}", tail(&o.stdout), tail(&o.stderr)).trim().to_string()+    })+}++#[cfg(test)]+mod tests {+    use super::*;++    const NESTED: &str = r##"(export (version "E")+  (design (source "/x/demo.kicad_sch") (tool "Eeschema 10.0.3"))+  (components+    (comp (ref "U1") (value "TPS") (footprint "PCM_demo:SOT-23-6")+      (libsource (lib "PCM_demo") (part "TPS") (description ""))+      (sheetpath (names "/") (tstamps "/")))+    (comp (ref "C1") (value "10u") (footprint "PCM_demo:C_0603")+      (libsource (lib "PCM_demo") (part "C") (description "")))+    (comp (ref "#PWR01") (value "GND") (libsource (lib "power") (part "GND"))))+  (libparts) (libraries)+  (nets (net (code "1") (name "/GND") (node (ref "U1") (pin "2")) (node (ref "C1") (pin "2")))))"##;++    #[test]+    fn nested_components_are_all_found() {+        let s = sheet_symbols(NESTED).unwrap();+        assert_eq!(s.keys().cloned().collect::<Vec<_>>(), vec!["C1".to_string(), "U1".to_string()]);+        assert_eq!(s["U1"], ("PCM_demo".to_string(), "PCM_demo:SOT-23-6".to_string()));+        // the old reader (direct children of export) found none of them+        let root = aiflow_board::sx::parse(NESTED).unwrap();+        assert_eq!(root.find_all("comp").count(), 0);+        assert!(sheet_symbols("(kicad_sch)").is_err());+    }++    #[test]+    fn missing_or_unreadable_erc_report_is_refused() {+        let dir = std::env::temp_dir().join(format!("aiflow-erc-{}", std::process::id()));+        std::fs::create_dir_all(&dir).unwrap();+        let rep = dir.join("erc.json");+        assert!(erc_errors(&rep).unwrap_err().contains("ERC did not run"));+        std::fs::write(&rep, "not json").unwrap();+        assert!(erc_errors(&rep).is_err());+        std::fs::write(&rep, "{}").unwrap();+        assert!(erc_errors(&rep).unwrap_err().contains("not a KiCad ERC report"));+        std::fs::write(&rep, r#"{"sheets":[{"path":"/","violations":[{"severity":"warning","description":"w"},{"severity":"error","description":"Pin not driven"}]}]}"#).unwrap();+        assert_eq!(erc_errors(&rep).unwrap().1, vec!["Pin not driven".to_string()]);+        std::fs::write(&rep, r#"{"sheets":[]}"#).unwrap();+        assert!(erc_errors(&rep).unwrap().1.is_empty());+        let _ = std::fs::remove_dir_all(&dir);+    }++    /// A kicad-cli that writes no report (the old remote wrapper refusing `sch erc`) must fail the check,+    /// and a stale report from an earlier run must not count.+    #[cfg(unix)]+    #[test]+    fn erc_that_writes_no_report_fails() {+        use std::os::unix::fs::PermissionsExt;+        let dir = std::env::temp_dir().join(format!("aiflow-erc-run-{}", std::process::id()));+        std::fs::create_dir_all(&dir).unwrap();+        let cli = dir.join("kicad-cli");+        std::fs::write(&cli, "#!/bin/sh\necho \"only 'pcb drc' is supported\" >&2\nexit 2\n").unwrap();+        std::fs::set_permissions(&cli, std::fs::Permissions::from_mode(0o755)).unwrap();+        let rep = dir.join("erc.json");+        std::fs::write(&rep, r#"{"sheets":[]}"#).unwrap();+        let e = run_erc(cli.to_str().unwrap(), "x.kicad_sch", &rep).unwrap_err();+        assert!(e.contains("ERC did not run") && e.contains("only 'pcb drc'"), "{e}");+        let _ = std::fs::remove_dir_all(&dir);+    }+}

@@ -0,0 +1,764 @@+//! The symbol, pin-type and readability half of `schematic check` (and of `netlist check`): what a+//! zero-warning ERC does not prove about a native KiCad schematic. The command itself (ERC, the BOM+//! references, the project library) lives in main.rs and calls `check` and `record` here.+//!+//! Reads the root `.kicad_sch` and every child sheet (resolved exactly as the netlist freshness+//! check resolves them, `schematic_identity::capture`) with the symbols each sheet embeds in+//! `lib_symbols`, and checks three things (issue #39, items 1 to 3):+//!+//! 1. Polarity drawings agree with the pin names: a diode's or LED's cathode bar and triangle+//!    point at the pin named K (cathode), a BJT's emitter arrow sits on the lead of the pin named E,+//!    and an op-amp's drawn `+`/`-` texts sit next to the inputs declared with that sign.+//! 2. Pin electrical types on active devices (U/IC references and op-amp/comparator symbols): an+//!    amplifier input or an output (`OUT`, `VOUT`, `OUTA`) declared `passive` is an error; a passive+//!    power pin is an error on op-amps and comparators and a warning on other ICs (vendor symbols often+//!    do it). Stacked pins (KiCad's convention: one typed pin, the rest passive at the same place) and+//!    crystal pins are skipped. Transistor (Q) pins are left alone: KiCad's own transistor symbols+//!    declare them passive.+//! 3. Readability per sheet: many local labels and almost no wires, the same local label used for a+//!    short hop inside one block, free text over pins or symbol bodies, and parts or text outside the+//!    drawing border.+//!+//! Limits (heuristic geometry, documented in skills/aiflow-schematic-to-board/SKILL.md, section "Schematic check: symbols, pin types, readability"): the polarity check+//! recognises polylines, rectangles, circles and arcs only, a single diode per unit (pins named exactly+//! K/A or cathode/anode), BJTs with pins named E and C, and op-amp inputs named `+`/`-`, `IN+`/`IN-`,+//! `INP`/`INN`. Errors are raised only when a drawing clearly contradicts the pin names, and only for+//! custom symbols (no library nickname, a nickname outside KiCad's standard libraries, or a+//! schematic-local copy with `lib_name`); standard-library symbols can at most warn. Text sizes are+//! estimated from the font size, symbol transforms are approximate (rotation, then mirror), symbol+//! fields (reference/value) are not checked for overlap, and feedback loops are not traced.+use std::collections::{BTreeMap, BTreeSet};+use std::path::Path;++use aiflow_board::sx::{self, Node};+use aiflow_run::Run;+use serde_json::{json, Value};++type Pt = (f64, f64);++/// The run outcome key `schematic check` records and `finish` requires.+pub const OUTCOME: &str = "schematic-check";++/// KiCad standard symbol library nicknames: symbols from these are trusted to be drawn right.+const STD_LIBS: &[&str] = &[+    "Device", "Diode", "LED", "Transistor_BJT", "Transistor_FET", "Transistor_Array", "Transistor_IGBT", "Amplifier_Operational",+    "Amplifier_Instrumentation", "Amplifier_Difference", "Amplifier_Audio", "Amplifier_Buffer", "Amplifier_Current",+    "Amplifier_Video", "Comparator", "power", "Connector", "Connector_Generic", "Connector_Audio", "Regulator_Linear",+    "Regulator_Switching", "Regulator_Controller", "Reference_Voltage", "Diode_Bridge", "Simulation_SPICE", "pspice",+    "Switch", "Mechanical", "Jumper", "Analog_Switch", "Analog_ADC", "Analog_DAC", "Interface_UART", "Interface_USB",+    "MCU_Microchip_ATmega", "MCU_ST_STM32F0", "MCU_RaspberryPi", "Timer", "Logic_74xx", "74xx", "4xxx", "Sensor_Temperature",+    "Power_Management", "Battery_Management", "Optocoupler", "Isolator", "Relay", "Fuse", "Inductor", "Oscillator", "Crystal",+];++#[derive(Clone, Copy, PartialEq, Eq, Debug)]+enum Sev { Error, Warn }++#[derive(Debug, Clone)]+struct Pin { name: String, number: String, etype: String, at: Pt, inner: Pt, unit: u32 }++#[derive(Debug, Clone)]+struct Shape { kind: &'static str, pts: Vec<Pt>, closed: bool, unit: u32 }++#[derive(Debug, Clone)]+struct Txt { text: String, at: Pt, unit: u32 }++#[derive(Debug, Clone, Default)]+struct LibSym { name: String, info: String, power: bool, names_hidden: bool, pins: Vec<Pin>, shapes: Vec<Shape>, texts: Vec<Txt> }++#[derive(Debug, Clone)]+struct Inst { lib: String, custom_copy: bool, reference: String, at: Pt, rot: f64, mirror: Option<String>, unit: u32 }++fn close(a: Pt, b: Pt) -> bool { (a.0 - b.0).abs() < 1e-3 && (a.1 - b.1).abs() < 1e-3 }+fn dist(a: Pt, b: Pt) -> f64 { ((a.0 - b.0).powi(2) + (a.1 - b.1).powi(2)).sqrt() }+fn centroid(p: &[Pt]) -> Pt { let n = p.len().max(1) as f64; (p.iter().map(|q| q.0).sum::<f64>() / n, p.iter().map(|q| q.1).sum::<f64>() / n) }+fn xy(n: &Node) -> Option<Pt> { Some((n.number(1)?, n.number(2)?)) }+fn at_of(n: &Node) -> Option<(Pt, f64)> { let a = n.find("at")?; Some(((a.number(1)?, a.number(2)?), a.number(3).unwrap_or(0.0))) }+fn prop<'a>(n: &'a Node, key: &str) -> Option<&'a str> { n.find_all("property").find(|p| p.atom(1).is_some_and(|k| k.eq_ignore_ascii_case(key))).and_then(|p| p.atom(2)) }+fn flag(n: &Node, tag: &str) -> bool {+    n.find(tag).map(|h| h.value() != Some("no")).unwrap_or(false) || n.items.iter().any(|it| matches!(it, sx::Item::Atom { text, .. } if text == tag))+}++/// The unit and body style a lib sub-symbol (`NAME_<unit>_<style>`) draws.+fn unit_style(name: &str) -> (u32, u32) {+    let mut it = name.rsplitn(3, '_');+    let style = it.next().and_then(|s| s.parse().ok()).unwrap_or(1);+    let unit = it.next().and_then(|s| s.parse().ok()).unwrap_or(0);+    (unit, style)+}++fn parse_lib(sym: &Node) -> LibSym {+    let name = sym.atom(1).unwrap_or("").to_string();+    let info = [prop(sym, "ki_keywords"), prop(sym, "ki_description"), prop(sym, "Description"), prop(sym, "Value"), Some(name.as_str())]+        .iter().flatten().map(|s| s.to_ascii_lowercase()).collect::<Vec<_>>().join(" ");+    let names_hidden = sym.find("pin_names").map(|p| flag(p, "hide")).unwrap_or(false);+    let mut out = LibSym { name, info, power: flag(sym, "power"), names_hidden, ..Default::default() };+    let mut parts: Vec<(&Node, u32)> = vec![(sym, 0)];+    for sub in sym.find_all("symbol") {+        let (unit, style) = unit_style(sub.atom(1).unwrap_or(""));+        if style <= 1 { parts.push((sub, unit)); }+    }+    for (n, unit) in parts {+        for c in n.nodes() {+            match c.tag.as_str() {+                "pin" => {+                    let Some((at, ang)) = at_of(c) else { continue };+                    let len = c.find("length").and_then(|l| l.number(1)).unwrap_or(0.0);+                    let r = ang.to_radians();+                    out.pins.push(Pin {+                        name: c.find("name").and_then(|x| x.atom(1)).unwrap_or("").to_string(),+                        number: c.find("number").and_then(|x| x.atom(1)).unwrap_or("").to_string(),+                        etype: c.atom(1).unwrap_or("").to_string(), at, inner: (at.0 + len * r.cos(), at.1 + len * r.sin()), unit,+                    });+                }+                "polyline" => {+                    let mut pts: Vec<Pt> = c.find("pts").map(|p| p.find_all("xy").filter_map(xy).collect()).unwrap_or_default();+                    if pts.len() < 2 { continue; }+                    let filled = c.find("fill").and_then(|f| f.find("type")).and_then(|t| t.value()).map(|t| t != "none").unwrap_or(false);+                    let mut closed = filled;+                    if pts.len() > 2 && close(pts[0], *pts.last().unwrap()) { pts.pop(); closed = true; }+                    out.shapes.push(Shape { kind: "polyline", pts, closed, unit });+                }+                "rectangle" => {+                    if let (Some(a), Some(b)) = (c.find("start").and_then(xy), c.find("end").and_then(xy)) {+                        out.shapes.push(Shape { kind: "rectangle", pts: vec![a, (b.0, a.1), b, (a.0, b.1)], closed: true, unit });+                    }+                }+                "circle" => {+                    if let (Some(ce), Some(r)) = (c.find("center").and_then(xy), c.find("radius").and_then(|x| x.number(1))) {+                        let pts = (0..8).map(|i| { let t = i as f64 * std::f64::consts::FRAC_PI_4; (ce.0 + r * t.cos(), ce.1 + r * t.sin()) }).collect();+                        out.shapes.push(Shape { kind: "circle", pts, closed: true, unit });+                    }+                }+                "arc" => {+                    let pts: Vec<Pt> = ["start", "mid", "end"].iter().filter_map(|k| c.find(k).and_then(xy)).collect();+                    if pts.len() >= 2 { out.shapes.push(Shape { kind: "arc", pts, closed: false, unit }); }+                }+                "text" => {+                    if let (Some(t), Some((at, _))) = (c.atom(1), at_of(c)) { out.texts.push(Txt { text: t.to_string(), at, unit }); }+                }+                _ => {}+            }+        }+    }+    out+}++/// A symbol is custom unless it comes, unmodified, from one of KiCad's standard libraries.+fn is_custom(lib: &str, custom_copy: bool) -> bool {+    if custom_copy { return true; }+    match lib.split_once(':') { Some((nick, _)) => !STD_LIBS.contains(&nick), None => true }+}++fn norm(name: &str) -> String {+    name.trim().to_ascii_uppercase().replace(['{', '}', '~', ' ', '_'], "").replace(['\u{2212}', '\u{2013}'], "-")+}++/// `+` or `-` for a pin named as an amplifier input.+fn amp_input(name: &str) -> Option<char> {+    let n = norm(name);+    if n == "+" { return Some('+'); }+    if n == "-" { return Some('-'); }+    if n.contains("IN") && !n.starts_with('V') {+        if n.contains('+') { return Some('+'); }+        if n.contains('-') { return Some('-'); }+        if n.ends_with("INP") || n == "NONINV" { return Some('+'); }+        if n.ends_with("INN") { return Some('-'); }+    }+    None+}++fn is_output(name: &str) -> bool {+    let n = norm(name);+    let s = n.trim_start_matches(|c: char| c.is_ascii_digit());+    s == "OUT" || s == "VOUT" || (s.starts_with("OUT") && s.len() == 4)+}++fn is_power(name: &str) -> bool {+    let n = norm(name);+    ["V+", "V-", "+V", "-V", "VS", "VS+", "VS-", "+VS", "-VS", "AVDD", "DVDD", "AVSS", "DVSS", "AVCC"].contains(&n.as_str())+        || ["VCC", "VDD", "VEE", "VSS"].iter().any(|p| n.starts_with(p))+        || (n.ends_with("GND") && n.len() <= 5)+}++fn amp_like(s: &LibSym) -> bool {+    let i = &s.info;+    ["opamp", "op amp", "op-amp", "operational", "comparator"].iter().any(|k| i.contains(k))+        || (s.pins.iter().any(|p| amp_input(&p.name) == Some('+')) && s.pins.iter().any(|p| amp_input(&p.name) == Some('-')))+}++fn ref_prefix(r: &str) -> String { r.chars().take_while(|c| c.is_ascii_alphabetic()).collect::<String>().to_ascii_uppercase() }++// -- (1) polarity drawings ------------------------------------------------------------------------++fn named<'a>(pins: &[&'a Pin], names: &[&str]) -> Vec<&'a Pin> {+    pins.iter().copied().filter(|p| names.contains(&norm(&p.name).as_str())).collect()+}++fn diode_check(pins: &[&Pin], shapes: &[&Shape]) -> Option<(Sev, String)> {+    let (k, a) = (named(pins, &["K", "CATHODE", "KATHODE"]), named(pins, &["A", "ANODE"]));+    if k.len() != 1 || a.len() != 1 { return None; }+    let (k, a) = (k[0], a[0]);+    let l = dist(a.at, k.at);+    if l < 0.1 { return None; }+    let u = ((k.at.0 - a.at.0) / l, (k.at.1 - a.at.1) / l);+    let t = |p: Pt| ((p.0 - a.at.0) * u.0 + (p.1 - a.at.1) * u.1) / l; // 0 at A, 1 at K+    let s = |p: Pt| -(p.0 - a.at.0) * u.1 + (p.1 - a.at.1) * u.0; // across the axis, mm+    let who = format!("pin {} ({}) is the cathode, pin {} ({}) the anode", k.number, k.name, a.number, a.name);+    // the body triangle: a base across the axis, the apex on it, pointing at the cathode+    let mut tri: Option<(f64, f64, f64)> = None;+    for sh in shapes.iter().filter(|s| s.kind == "polyline" && s.closed && s.pts.len() == 3) {+        for i in 0..3 {+            let (ap, pj, pk) = (sh.pts[i], sh.pts[(i + 1) % 3], sh.pts[(i + 2) % 3]);+            let width = (s(pj) - s(pk)).abs();+            if width < 0.3 || (t(pj) - t(pk)).abs() * l > 0.25 * width || s(ap).abs() > 0.25 * width || ((s(pj) + s(pk)) / 2.0).abs() > 0.25 * width { continue; }+            if tri.map(|x| width > x.2).unwrap_or(true) { tri = Some(((t(pj) + t(pk)) / 2.0, t(ap), width)); }+        }+    }+    // bars: a stroke across the axis (open polyline or a thin filled rectangle)+    let mut bars: Vec<(f64, f64)> = Vec::new(); // (t, across extent)+    for sh in shapes.iter().filter(|s| (s.kind == "polyline" && !s.closed) || (s.kind == "rectangle" || s.kind == "polyline") && s.closed && s.pts.len() == 4) {+        let ts: Vec<f64> = sh.pts.iter().map(|p| t(*p)).collect();+        let ss: Vec<f64> = sh.pts.iter().map(|p| s(*p)).collect();+        let along = (ts.iter().cloned().fold(f64::MIN, f64::max) - ts.iter().cloned().fold(f64::MAX, f64::min)) * l;+        let (smin, smax) = (ss.iter().cloned().fold(f64::MAX, f64::min), ss.iter().cloned().fold(f64::MIN, f64::max));+        let across = smax - smin;+        let ratio = if sh.closed { 3.0 } else { 1.5 };+        if across < 0.5 || across < ratio * along || smin > -0.2 || smax < 0.2 { continue; }+        // where the bar is: the middle of its longest segment+        let n = sh.pts.len();+        let seg = (0..n - if sh.closed { 0 } else { 1 }).max_by(|&i, &j| dist(sh.pts[i], sh.pts[(i + 1) % n]).total_cmp(&dist(sh.pts[j], sh.pts[(j + 1) % n]))).unwrap_or(0);+        let mid = ((sh.pts[seg].0 + sh.pts[(seg + 1) % n].0) / 2.0, (sh.pts[seg].1 + sh.pts[(seg + 1) % n].1) / 2.0);+        bars.push((t(mid), across));+    }+    let bar = match tri {+        Some((_, apex, _)) => bars.iter().min_by(|x, y| (x.0 - apex).abs().total_cmp(&(y.0 - apex).abs())).map(|b| b.0),+        None => bars.iter().max_by(|x, y| x.1.total_cmp(&y.1)).map(|b| b.0),+    };+    match (tri, bar) {+        (Some((base, apex, _)), b) if apex < base => {+            let bar_at_apex = b.map(|b| (b - apex).abs() < (b - base).abs()).unwrap_or(true);+            if bar_at_apex { Some((Sev::Error, format!("the diode is drawn pointing at the anode: the triangle and cathode bar are at the pin {} end, but {who}", a.number))) }+            else { Some((Sev::Warn, format!("the diode triangle points at pin {} (named {}) while the bar is at the other end; {who}", a.number, a.name))) }+        }+        (Some((base, _, _)), Some(b)) if b < base - 0.02 => Some((Sev::Warn, format!("the cathode bar is on the anode side of the triangle; {who}"))),+        (Some(_), _) => None,+        (None, Some(b)) if b < 0.4 => Some((Sev::Error, format!("the cathode bar is drawn at the pin {} end, but {who}", a.number))),+        (None, Some(b)) if b < 0.6 => Some((Sev::Warn, format!("the cathode bar is near the middle, so the drawing does not show which end is the cathode; {who}"))),+        (None, Some(_)) => None,+        (None, None) => Some((Sev::Warn, format!("no cathode bar or triangle recognised in the drawing; check by eye that the bar is at the cathode ({who})"))),+    }+}++fn bjt_check(pins: &[&Pin], shapes: &[&Shape]) -> Option<(Sev, String)> {+    let (e, c) = (named(pins, &["E", "EMITTER"]), named(pins, &["C", "COLLECTOR"]));+    if e.len() != 1 || c.len() != 1 { return None; }+    let (e, c) = (e[0], c[0]);+    let arrows: Vec<Pt> = shapes.iter().filter(|s| s.kind == "polyline" && s.pts.len() >= 3).filter(|s| {+        let (xs, ys): (Vec<f64>, Vec<f64>) = s.pts.iter().cloned().unzip();+        let w = xs.iter().cloned().fold(f64::MIN, f64::max) - xs.iter().cloned().fold(f64::MAX, f64::min);+        let h = ys.iter().cloned().fold(f64::MIN, f64::max) - ys.iter().cloned().fold(f64::MAX, f64::min);+        (w * w + h * h).sqrt() < 2.5+    }).map(|s| centroid(&s.pts)).collect();+    let best = arrows.iter().min_by(|x, y| dist(**x, e.inner).min(dist(**x, c.inner)).total_cmp(&dist(**y, e.inner).min(dist(**y, c.inner))))?;+    let (de, dc) = (dist(*best, e.inner), dist(*best, c.inner));+    let who = format!("pin {} is named {} and pin {} {}", e.number, e.name, c.number, c.name);+    if dc * 1.5 < de { Some((Sev::Error, format!("the emitter arrow is drawn on the collector lead; {who}"))) }+    else if dc < de { Some((Sev::Warn, format!("the emitter arrow is closer to the collector than to the emitter; {who}"))) }+    else { None }+}++fn opamp_check(sym: &LibSym, pins: &[&Pin], texts: &[&Txt], custom: bool) -> Vec<(Sev, String)> {+    let mut out = Vec::new();+    let inputs: Vec<(&Pin, char)> = pins.iter().filter_map(|p| amp_input(&p.name).map(|s| (*p, s))).collect();+    let signs: Vec<(&Txt, char)> = texts.iter().filter_map(|t| match norm(&t.text).as_str() { "+" => Some((*t, '+')), "-" => Some((*t, '-')), _ => None }).collect();+    if signs.is_empty() {+        if !inputs.is_empty() && sym.names_hidden { out.push((Sev::Warn, "the input pins are named +/- but pin names are hidden and no +/- is drawn: the inputs show no polarity".into())); }+        else if inputs.is_empty() && custom && amp_like(sym) { out.push((Sev::Warn, "an amplifier symbol whose inputs are not named +/- (or IN+/IN-) and no +/- is drawn".into())); }+        return out;+    }+    if inputs.is_empty() {+        if custom { out.push((Sev::Warn, "+/- is drawn but no pin is named as an input (+, -, IN+, IN-): name the inputs so the drawing can be checked".into())); }+        return out;+    }+    for (t, sign) in signs {+        let d = |want: bool| inputs.iter().filter(|(_, s)| (*s == sign) == want).map(|(p, _)| (dist(t.at, p.inner), *p)).min_by(|a, b| a.0.total_cmp(&b.0));+        let (Some((same, _)), Some((other, op))) = (d(true), d(false)) else { continue };+        if other * 1.5 < same { out.push((Sev::Error, format!("the drawn `{sign}` sits at pin {} ({}), the opposite input", op.number, op.name))); }+        else if other < same { out.push((Sev::Warn, format!("the drawn `{sign}` is nearer pin {} ({}), the opposite input", op.number, op.name))); }+    }+    out+}++/// The polarity findings of one lib symbol, per unit.+fn polarity(sym: &LibSym, custom: bool) -> Vec<(Sev, String)> {+    let units: BTreeSet<u32> = sym.pins.iter().map(|p| p.unit).filter(|u| *u > 0).collect();+    let units: Vec<u32> = if units.is_empty() { vec![0] } else { units.into_iter().collect() };+    let mut out = Vec::new();+    for u in units {+        let pins: Vec<&Pin> = sym.pins.iter().filter(|p| p.unit == u || p.unit == 0).collect();+        let shapes: Vec<&Shape> = sym.shapes.iter().filter(|s| s.unit == u || s.unit == 0).collect();+        let texts: Vec<&Txt> = sym.texts.iter().filter(|t| t.unit == u || t.unit == 0).collect();+        let tag = if u > 0 && sym.pins.iter().any(|p| p.unit > 1) { format!("unit {u}: ") } else { String::new() };+        let mut found: Vec<(Sev, String)> = Vec::new();+        found.extend(diode_check(&pins, &shapes));+        match bjt_check(&pins, &shapes) {+            Some(f) => found.push(f),+            None if custom && named(&pins, &["E", "EMITTER"]).len() == 1 && named(&pins, &["C", "COLLECTOR"]).len() == 1 && shapes.iter().all(|s| !(s.kind == "polyline" && s.pts.len() >= 3)) => found.push((Sev::Warn, "a transistor with E and C pins but no emitter arrow recognised in the drawing".into())),+            None => {}+        }+        found.extend(opamp_check(sym, &pins, &texts, custom));+        // a custom diode with no recognisable drawing is a warning; a library one is not worth a line+        for (sev, m) in found {+            if !custom && m.starts_with("no cathode bar") { continue; }+            out.push((if custom { sev } else { Sev::Warn }, format!("{tag}{m}")));+        }+    }+    out+}++// -- (2) pin electrical types --------------------------------------------------------------------++fn pin_types(sym: &LibSym) -> Vec<(Sev, Pin, String)> {+    let mut out = Vec::new();+    let mut seen = BTreeSet::new();+    let amp = amp_like(sym);+    for p in &sym.pins {+        if !seen.insert((p.number.clone(), p.name.clone())) { continue; }+        let et = p.etype.as_str();+        // a stacked pin (same unit, same place as another pin) is passive by KiCad's own convention+        if et == "passive" && sym.pins.iter().any(|q| !std::ptr::eq(q, p) && q.unit == p.unit && close(q.at, p.at) && q.etype != "passive") { continue; }+        if let Some(s) = amp_input(&p.name) {+            if et == "passive" { out.push((Sev::Error, p.clone(), format!("amplifier input `{}` ({s}) is passive; declare it input", p.name))); }+            else if et != "input" { out.push((Sev::Warn, p.clone(), format!("amplifier input `{}` is {et}; amplifier inputs are input", p.name))); }+        } else if is_output(&p.name) {+            if et == "passive" { out.push((Sev::Error, p.clone(), format!("output `{}` is passive; declare it output (or power_out for a regulator output)", p.name))); }+            else if !["output", "tri_state", "open_collector", "open_emitter", "power_out", "bidirectional"].contains(&et) { out.push((Sev::Warn, p.clone(), format!("output `{}` is {et}", p.name))); }+        } else if is_power(&p.name) {+            if et == "passive" { out.push((if amp { Sev::Error } else { Sev::Warn }, p.clone(), format!("power pin `{}` is passive; declare it power_in", p.name))); }+            else if !["power_in", "power_out"].contains(&et) { out.push((Sev::Warn, p.clone(), format!("power pin `{}` is {et}; power pins are power_in", p.name))); }+        }+    }+    out+}++/// `spec.schematic.allowPassive`: [{"ref": "U1", "pin": "3" (number or name; omit for every pin), "why": "datasheet ..."}].+fn passive_allowed(spec: &Value, reference: &str, pin: &Pin) -> Option<bool> {+    let list = spec["schematic"]["allowPassive"].as_array()?;+    let hit = list.iter().find(|e| e["ref"].as_str() == Some(reference) && e["pin"].as_str().map(|x| x == pin.number || x == pin.name).unwrap_or(true))?;+    Some(hit["why"].as_str().map(|w| w.trim().len() >= 8).unwrap_or(false))+}++/// `spec.schematic.polarityReviewed`: [{"symbol": "<lib id or reference>", "why": "..."}] turns a polarity error into a warning.+fn polarity_reviewed(spec: &Value, lib: &str, refs: &[String]) -> bool {+    spec["schematic"]["polarityReviewed"].as_array().map(|a| a.iter().any(|e| {+        let s = e["symbol"].as_str().unwrap_or("");+        (s == lib || refs.iter().any(|r| r == s)) && e["why"].as_str().map(|w| w.trim().len() >= 8).unwrap_or(false)+    })).unwrap_or(false)+}++// -- (3) readability ------------------------------------------------------------------------------++/// Paper size (mm) of a sheet: `(paper "A4" [portrait])` or `(paper "User" w h)`.+fn paper(root: &Node) -> Option<Pt> {+    let p = root.find("paper")?;+    let name = p.atom(1)?;+    let (w, h) = match name {+        "A5" => (210.0, 148.0), "A4" => (297.0, 210.0), "A3" => (420.0, 297.0), "A2" => (594.0, 420.0), "A1" => (841.0, 594.0), "A0" => (1189.0, 841.0),+        "A" | "USLetter" => (279.4, 215.9), "B" | "USLedger" => (431.8, 279.4), "USLegal" => (355.6, 215.9), "C" => (558.8, 431.8), "D" => (863.6, 558.8), "E" => (1117.6, 863.6),+        "User" => (p.number(2)?, p.number(3)?),+        _ => return None,+    };+    Some(if flag(p, "portrait") { (h, w) } else { (w, h) })+}++/// The drawing frame's margin from the paper edge in KiCad's default page layout.+const BORDER_MM: f64 = 10.0;+/// Two uses of one local label this close together are a short hop that wants a wire.+const SHORT_HOP_MM: f64 = 25.4;++#[derive(Clone, Copy, Debug)]+struct BBox { x0: f64, y0: f64, x1: f64, y1: f64 }+impl BBox {+    fn of(pts: &[Pt]) -> Option<BBox> {+        if pts.is_empty() { return None; }+        Some(BBox { x0: pts.iter().map(|p| p.0).fold(f64::MAX, f64::min), y0: pts.iter().map(|p| p.1).fold(f64::MAX, f64::min), x1: pts.iter().map(|p| p.0).fold(f64::MIN, f64::max), y1: pts.iter().map(|p| p.1).fold(f64::MIN, f64::max) })+    }+    fn hits(&self, o: &BBox) -> bool { self.x0 < o.x1 && o.x0 < self.x1 && self.y0 < o.y1 && o.y0 < self.y1 }+    fn has(&self, p: Pt) -> bool { p.0 >= self.x0 && p.0 <= self.x1 && p.1 >= self.y0 && p.1 <= self.y1 }+    fn shrink(&self, d: f64) -> BBox { BBox { x0: self.x0 + d, y0: self.y0 + d, x1: self.x1 - d, y1: self.y1 - d } }+}++/// A lib point on the sheet: lib y is up, the sheet's is down; rotation, then mirror (approximate).+fn place(i: &Inst, p: Pt) -> Pt {+    let (x, y) = (p.0, -p.1);+    let r = i.rot.to_radians();+    let (mut x, mut y) = (x * r.cos() + y * r.sin(), -x * r.sin() + y * r.cos());+    match i.mirror.as_deref() { Some("x") => y = -y, Some("y") => x = -x, _ => {} }+    (i.at.0 + x, i.at.1 + y)+}++/// The box free text covers on the sheet, estimated from its font size and justification.+fn text_box(n: &Node) -> Option<BBox> {+    let text = n.atom(1)?;+    let (at, ang) = at_of(n)?;+    let eff = n.find("effects");+    let size = eff.and_then(|e| e.find("font")).and_then(|f| f.find("size"));+    let (h, w) = (size.and_then(|s| s.number(1)).unwrap_or(1.27), size.and_then(|s| s.number(2)).unwrap_or(1.27));+    let lines: Vec<&str> = text.split('\n').collect();+    let (tw, th) = (lines.iter().map(|l| l.chars().count()).max().unwrap_or(0) as f64 * w * 0.9, lines.len() as f64 * h * 1.4);+    let j: Vec<String> = eff.and_then(|e| e.find("justify")).map(|j| (1..4).filter_map(|i| j.atom(i).map(str::to_string)).collect()).unwrap_or_default();+    let (u0, u1) = if j.iter().any(|s| s == "left") { (0.0, tw) } else if j.iter().any(|s| s == "right") { (-tw, 0.0) } else { (-tw / 2.0, tw / 2.0) };+    let (v0, v1) = if j.iter().any(|s| s == "bottom") { (-th, 0.0) } else if j.iter().any(|s| s == "top") { (0.0, th) } else { (-th / 2.0, th / 2.0) };+    let r = ang.to_radians();+    let pts: Vec<Pt> = [(u0, v0), (u1, v0), (u1, v1), (u0, v1)].iter().map(|(u, v)| (at.0 + u * r.cos() + v * r.sin(), at.1 - u * r.sin() + v * r.cos())).collect();+    BBox::of(&pts)+}++fn instances(root: &Node) -> Vec<Inst> {+    root.find_all("symbol").filter_map(|s| {+        let lib_id = s.find("lib_id")?.value()?.to_string();+        let lib_name = s.find("lib_name").and_then(|n| n.value()).map(str::to_string);+        let (at, rot) = at_of(s)?;+        let mut reference = prop(s, "Reference").unwrap_or("").to_string();+        if reference.is_empty() || reference.contains('?') {+            if let Some(r) = s.find("instances").and_then(|i| i.find("project")).and_then(|p| p.find("path")).and_then(|p| p.find("reference")).and_then(|r| r.value()) { reference = r.to_string(); }+        }+        Some(Inst { lib: lib_name.clone().unwrap_or(lib_id), custom_copy: lib_name.is_some(), reference, at, rot, mirror: s.find("mirror").and_then(|m| m.value()).map(str::to_string), unit: s.find("unit").and_then(|u| u.number(1)).unwrap_or(1.0) as u32 })+    }).collect()+}++fn sheet_readability(file: &str, root: &Node, libs: &BTreeMap<String, LibSym>, insts: &[Inst], warnings: &mut Vec<String>) -> Value {+    let wires = root.find_all("wire").count();+    let labels: Vec<(String, Pt)> = root.find_all("label").filter_map(|l| Some((l.atom(1)?.to_string(), at_of(l)?.0))).collect();+    let short = std::path::Path::new(file).file_name().map(|f| f.to_string_lossy().to_string()).unwrap_or_default();+    if labels.len() >= 8 && wires * 2 < labels.len() {+        warnings.push(format!("{short}: {} local labels and {wires} wire(s): draw the signal path with wires inside each functional block and keep labels for long or cross-sheet nets, so feedback loops can be traced by eye", labels.len()));+    }+    let mut by_name: BTreeMap<&str, Vec<Pt>> = BTreeMap::new();+    for (n, p) in &labels { by_name.entry(n.as_str()).or_default().push(*p); }+    let hops: Vec<String> = by_name.iter().filter(|(_, ps)| ps.len() >= 2 && ps.iter().all(|a| ps.iter().all(|b| dist(*a, *b) <= SHORT_HOP_MM))).map(|(n, ps)| format!("{n} ({} labels)", ps.len())).collect();+    if !hops.is_empty() {+        warnings.push(format!("{short}: {} net(s) joined only by local labels within {SHORT_HOP_MM} mm of each other: {}{}; a short local connection is a drawn wire", hops.len(), hops.iter().take(8).cloned().collect::<Vec<_>>().join(", "), if hops.len() > 8 { ", ..." } else { "" }));+    }+    // where each placed symbol's body and pins land on the sheet+    let mut bodies: Vec<(String, BBox)> = Vec::new();+    let mut pin_segs: Vec<(String, Pt, Pt)> = Vec::new();+    for i in insts {+        let Some(sym) = libs.get(&i.lib) else { continue };+        if sym.power { continue; }+        let pts: Vec<Pt> = sym.shapes.iter().filter(|s| s.unit == 0 || s.unit == i.unit).flat_map(|s| s.pts.iter().map(|p| place(i, *p))).collect();+        let pins: Vec<&Pin> = sym.pins.iter().filter(|p| p.unit == 0 || p.unit == i.unit).collect();+        let body_pts = if pts.is_empty() { pins.iter().map(|p| place(i, p.inner)).collect() } else { pts };+        if let Some(b) = BBox::of(&body_pts) { bodies.push((i.reference.clone(), b)); }+        for p in pins { pin_segs.push((format!("{}.{}", i.reference, p.number), place(i, p.at), place(i, p.inner))); }+    }+    let mut over = Vec::new();+    let texts: Vec<(String, BBox)> = root.find_all("text").filter_map(|t| Some((t.atom(1)?.chars().take(24).collect::<String>(), text_box(t)?))).collect();+    for (t, b) in &texts {+        let on_pin = pin_segs.iter().find(|(_, a, z)| (0..=4).any(|k| { let f = k as f64 / 4.0; b.has((a.0 + (z.0 - a.0) * f, a.1 + (z.1 - a.1) * f)) })).map(|x| format!("pin {}", x.0));+        let on_body = bodies.iter().find(|(_, bb)| bb.shrink(0.2).hits(b)).map(|x| format!("symbol {}", x.0));+        if let Some(w) = on_pin.or(on_body) { over.push(format!("`{t}` over {w}")); }+    }+    if !over.is_empty() { warnings.push(format!("{short}: text over pins or parts: {}{}", over.iter().take(6).cloned().collect::<Vec<_>>().join("; "), if over.len() > 6 { "; ..." } else { "" })); }+    let mut outside = Vec::new();+    if let Some((w, h)) = paper(root) {+        let frame = BBox { x0: BORDER_MM, y0: BORDER_MM, x1: w - BORDER_MM, y1: h - BORDER_MM };+        let inside = |b: &BBox| b.x0 >= frame.x0 && b.y0 >= frame.y0 && b.x1 <= frame.x1 && b.y1 <= frame.y1;+        for (r, b) in &bodies { if !inside(b) { outside.push(format!("symbol {r}")); } }+        for (t, b) in &texts { if !inside(b) { outside.push(format!("text `{t}`")); } }+        for (n, p) in &labels { if !frame.has(*p) { outside.push(format!("label {n}")); } }+        for wire in root.find_all("wire") {+            if wire.find("pts").map(|p| p.find_all("xy").filter_map(xy).any(|q| !frame.has(q))).unwrap_or(false) { outside.push("a wire".into()); break; }+        }+        if !outside.is_empty() { warnings.push(format!("{short}: outside the drawing border: {}{}", outside.iter().take(6).cloned().collect::<Vec<_>>().join(", "), if outside.len() > 6 { ", ..." } else { "" })); }+    }+    json!({"file": file, "symbols": insts.len(), "wires": wires, "localLabels": labels.len(), "shortLabelHops": hops.len(), "textOverlaps": over.len(), "outsideBorder": outside.len()})+}++// -- the check ------------------------------------------------------------------------------------++/// Run the schematic check on a root sheet and its hierarchy. `spec` carries the overrides+/// (`schematic.allowPassive`, `schematic.polarityReviewed`); Null for none.+pub fn check(root: &Path, spec: &Value) -> Result<Value, String> {+    let files = crate::schematic_identity::capture(root)?;+    let (mut errors, mut warnings, mut sheets) = (Vec::<String>::new(), Vec::<String>::new(), Vec::<Value>::new());+    // per lib symbol: the references using it and its findings (deduplicated across sheets)+    let mut seen_lib: BTreeMap<String, (LibSym, bool, BTreeSet<String>)> = BTreeMap::new();+    let mut pin_refs: BTreeMap<String, BTreeSet<String>> = BTreeMap::new();+    let mut symbols = 0usize;+    for file in files.keys() {+        let text = std::fs::read_to_string(file).map_err(|e| format!("{file}: {e}"))?;+        let root_node = sx::parse(&text)?;+        let libs: BTreeMap<String, LibSym> = root_node.find("lib_symbols").map(|l| l.find_all("symbol").map(|s| { let p = parse_lib(s); (p.name.clone(), p) }).collect()).unwrap_or_default();+        let insts = instances(&root_node);+        for i in &insts {+            let Some(sym) = libs.get(&i.lib) else { continue };+            if sym.power || i.reference.starts_with('#') { continue; }+            symbols += 1;+            let custom = is_custom(&i.lib, i.custom_copy);+            let e = seen_lib.entry(i.lib.clone()).or_insert_with(|| (sym.clone(), custom, BTreeSet::new()));+            e.2.insert(i.reference.clone());+            let px = ref_prefix(&i.reference);+            if px == "U" || px == "IC" || amp_like(sym) { pin_refs.entry(i.lib.clone()).or_default().insert(i.reference.clone()); }+        }+        sheets.push(sheet_readability(file, &root_node, &libs, &insts, &mut warnings));+    }+    let mut custom_syms = Vec::new();+    for (lib, (sym, custom, refs)) in &seen_lib {+        if *custom { custom_syms.push(lib.clone()); }+        let refs_v: Vec<String> = refs.iter().cloned().collect();+        let reviewed = polarity_reviewed(spec, lib, &refs_v);+        for (sev, m) in polarity(sym, *custom) {+            let line = format!("{} ({lib}{}): {m}", refs_v.join(","), if *custom { ", custom symbol" } else { "" });+            if sev == Sev::Error && !reviewed { errors.push(format!("polarity drawing: {line}")); } else { warnings.push(format!("polarity drawing: {line}{}", if sev == Sev::Error { " [reviewed in spec.schematic.polarityReviewed]" } else { "" })); }+        }+        if let Some(prefs) = pin_refs.get(lib) {+            for (sev, pin, m) in pin_types(sym) {+                let mut blocked: Vec<String> = Vec::new();+                for r in prefs {+                    match (sev, passive_allowed(spec, r, &pin)) {+                        (Sev::Error, Some(true)) => warnings.push(format!("pin type: {r} pin {} ({lib}): {m} [allowed by spec.schematic.allowPassive]", pin.number)),+                        (Sev::Error, Some(false)) => { warnings.push(format!("pin type: spec.schematic.allowPassive names {r} pin {} without a datasheet `why`; it does not count", pin.number)); blocked.push(r.clone()); }+                        (Sev::Error, None) => blocked.push(r.clone()),+                        _ => {}+                    }+                }+                if sev == Sev::Warn { warnings.push(format!("pin type: {} pin {} ({lib}): {m}", prefs.iter().cloned().collect::<Vec<_>>().join(","), pin.number)); }+                else if !blocked.is_empty() { errors.push(format!("pin type: {} pin {} ({lib}): {m}", blocked.join(","), pin.number)); }+            }+        }+    }+    Ok(json!({+        "ok": errors.is_empty(), "errors": errors, "warnings": warnings, "sheets": sheets, "symbols": symbols,+        "librarySymbols": seen_lib.len(), "customSymbols": custom_syms,+        "limits": "heuristic geometry: polylines/rectangles/circles/arcs only; one diode per unit with pins named K/A; BJTs with pins named E/C; op-amp inputs named +/-, IN+/IN-, INP/INN; transistor (Q) pin types not checked; text sizes estimated; symbol fields not checked for overlap; feedback loops not traced",+    }))+}++/// Record a check in the run (`schematic-check` outcome, `<run>/schematic-check.json`), bound to+/// every sheet's hash so `finish` asks again after any edit.+pub fn record(r: &mut Run, sch: &str, rep: &Value) {+    let report = r.dir.join("schematic-check.json");+    let _ = std::fs::write(&report, serde_json::to_string_pretty(rep).unwrap_or_default());+    let files = crate::schematic_identity::capture(Path::new(sch)).unwrap_or_default();+    r.outcome(OUTCOME, json!({"ok": rep["ok"], "schematic": sch, "schematicFiles": files, "errors": rep["errors"].as_array().map(|a| a.len()).unwrap_or(0), "warnings": rep["warnings"].as_array().map(|a| a.len()).unwrap_or(0), "report": report.display().to_string()}));+}++/// `finish`: a run with a schematic needs a passing schematic check on the hierarchy as it is now.+pub fn gate(r: &Run) -> Result<(), String> {+    let Some(sch) = r.data["schematic"].as_str() else { return Ok(()) };+    let Some(o) = r.outcomes().get(OUTCOME) else { return Err("schematic check (the run has a schematic; run `adom-aiflow schematic check --sch <root>.kicad_sch`, or `netlist check`, which runs it too)".into()) };+    let now = crate::schematic_identity::capture(Path::new(sch)).map_err(|e| format!("schematic check (schematic hierarchy: {e})"))?;+    if o["schematicFiles"] != json!(now) { return Err("schematic check (a sheet changed since the last check; run it again)".into()); }+    if o["ok"] != true { return Err(format!("schematic check ({} error(s) in {}; fix the symbols, then run it again)", o["errors"], o["report"].as_str().unwrap_or("schematic-check.json"))); }+    Ok(())+}++/// The reply: (message, hints).+pub fn render(rep: &Value, in_run: bool) -> (String, Vec<String>) {+    let list = |k: &str| rep[k].as_array().map(|a| a.iter().filter_map(|x| x.as_str().map(|s| format!("  {s}"))).collect::<Vec<_>>()).unwrap_or_default();+    let (errs, warns) = (list("errors"), list("warnings"));+    let head = format!("schematic check: {} sheet(s), {} placed symbol(s), {} custom symbol(s); {} error(s), {} warning(s)", rep["sheets"].as_array().map(|a| a.len()).unwrap_or(0), rep["symbols"], rep["customSymbols"].as_array().map(|a| a.len()).unwrap_or(0), errs.len(), warns.len());+    let mut body = vec![head];+    if !errs.is_empty() { body.push("errors:".into()); body.extend(errs); }+    if !warns.is_empty() { body.push("warnings:".into()); body.extend(warns); }+    let hints = vec![+        "Prefer library symbols (one triangle per op-amp section, a conventional transistor symbol) over custom rectangles and circles. A custom symbol's drawn polarity (diode bar, emitter arrow, op-amp +/-) must agree with its pin names (skill aiflow-circuit-design).".into(),+        "Active-device pins are not passive: amplifier inputs input, outputs output, power pins power_in. When the datasheet really says otherwise, add {\"ref\", \"pin\", \"why\"} to spec.schematic.allowPassive; a reviewed polarity drawing goes in spec.schematic.polarityReviewed.".into(),+        format!("Limits: {}.", rep["limits"].as_str().unwrap_or("")),+        if in_run { "Recorded in the run (schematic-check); finish requires a pass on the schematic as it is then.".into() } else { "No run here: nothing recorded.".into() },+    ];+    (body.join("\n"), hints)+}++/// The warnings as one hint line (empty when there are none).+pub fn warning_hint(rep: &Value) -> String {+    let w: Vec<&str> = rep["warnings"].as_array().into_iter().flatten().filter_map(|x| x.as_str()).collect();+    if w.is_empty() { return String::new(); }+    format!("schematic warnings ({}): {}{}", w.len(), w.iter().take(8).cloned().collect::<Vec<_>>().join("; "), if w.len() > 8 { "; ... (all in schematic-check.json)" } else { "" })+}++/// One line for `netlist check`, which runs this check too.+pub fn summary_line(rep: &Result<Value, String>) -> String {+    match rep {+        Ok(v) => format!("schematic check: {} error(s), {} warning(s){}", v["errors"].as_array().map(|a| a.len()).unwrap_or(0), v["warnings"].as_array().map(|a| a.len()).unwrap_or(0), if v["ok"] == true { "" } else { " (finish requires a pass: `adom-aiflow schematic check` lists them)" }),+        Err(e) => format!("schematic check could not read the schematic: {e}"),+    }+}++#[cfg(test)]+mod tests {+    use super::*;++    struct Fixture(std::path::PathBuf);+    impl Fixture {+        fn new() -> Self {+            static NEXT: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);+            let p = std::env::temp_dir().join(format!("aiflow-schck-{}-{}", std::process::id(), NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed)));+            std::fs::create_dir_all(&p).unwrap(); Self(p)+        }+        fn write(&self, name: &str, text: &str) -> std::path::PathBuf { let p = self.0.join(name); std::fs::write(&p, text).unwrap(); p }+    }+    impl Drop for Fixture { fn drop(&mut self) { let _ = std::fs::remove_dir_all(&self.0); } }++    const HEAD: &str = "(kicad_sch (version 20250610) (generator \"eeschema\") (generator_version \"10.0\") (uuid \"6f1d2c3e-0000-4000-8000-000000000001\") (paper \"A4\")";++    fn diode_lib(name: &str, bar_x: f64, apex_x: f64, base_x: f64) -> String {+        format!(r#"(symbol "{name}" (pin_numbers (hide yes)) (pin_names (offset 1.016) (hide yes)) (exclude_from_sim no) (in_bom yes) (on_board yes)+  (property "Reference" "D" (at 0 2.54 0) (effects (font (size 1.27 1.27))))+  (property "Value" "D" (at 0 -2.54 0) (effects (font (size 1.27 1.27))))+  (symbol "{short}_0_1"+    (polyline (pts (xy {bar_x} 1.27) (xy {bar_x} -1.27)) (stroke (width 0.254) (type default)) (fill (type none)))+    (polyline (pts (xy {base_x} 1.27) (xy {base_x} -1.27) (xy {apex_x} 0) (xy {base_x} 1.27)) (stroke (width 0.254) (type default)) (fill (type none))))+  (symbol "{short}_1_1"+    (pin passive line (at -3.81 0 0) (length 2.54) (name "K" (effects (font (size 1.27 1.27)))) (number "1" (effects (font (size 1.27 1.27)))))+    (pin passive line (at 3.81 0 180) (length 2.54) (name "A" (effects (font (size 1.27 1.27)))) (number "2" (effects (font (size 1.27 1.27))))))+  (embedded_fonts no))"#, short = name.rsplit(':').next().unwrap())+    }++    fn placed(lib: &str, reference: &str, x: f64, y: f64) -> String {+        format!(r#"(symbol (lib_id "{lib}") (at {x} {y} 0) (unit 1) (exclude_from_sim no) (in_bom yes) (on_board yes) (dnp no) (uuid "6f1d2c3e-0000-4000-8000-{n:012}")+  (property "Reference" "{reference}" (at {x} {y} 0) (effects (font (size 1.27 1.27))))+  (pin "1" (uuid "6f1d2c3e-0000-4000-8001-{n:012}")) (pin "2" (uuid "6f1d2c3e-0000-4000-8002-{n:012}")))"#, n = reference.bytes().map(|b| b as u64).sum::<u64>())+    }++    fn sheet(libs: &[String], body: &str) -> String { format!("{HEAD}\n(lib_symbols {})\n{body}\n(sheet_instances (path \"/\" (page \"1\"))) (embedded_fonts no))", libs.join("\n")) }++    #[test]+    fn standard_diode_passes_and_a_custom_mirrored_one_fails() {+        let f = Fixture::new();+        // KiCad's Device:D: pin K left, bar left, triangle pointing left+        let good = f.write("good.kicad_sch", &sheet(&[diode_lib("Device:D", -1.27, -1.27, 1.27)], &placed("Device:D", "D1", 100.0, 80.0)));+        let rep = check(&good, &Value::Null).unwrap();+        assert_eq!(rep["ok"], true, "{rep}");+        assert!(rep["warnings"].as_array().unwrap().iter().all(|w| !w.as_str().unwrap().contains("polarity")), "{rep}");+        // the trial's custom diode: pin 1 = K on the left, bar and triangle drawn at the right+        let bad = f.write("bad.kicad_sch", &sheet(&[diode_lib("Trial:DIODE", 1.27, 1.27, -1.27)], &placed("Trial:DIODE", "D1", 100.0, 80.0)));+        let rep = check(&bad, &Value::Null).unwrap();+        assert_eq!(rep["ok"], false);+        assert!(rep["errors"][0].as_str().unwrap().contains("pointing at the anode"), "{rep}");+        // a reviewed drawing becomes a warning+        let spec = json!({"schematic": {"polarityReviewed": [{"symbol": "Trial:DIODE", "why": "reviewed against the datasheet drawing p.1"}]}});+        assert_eq!(check(&bad, &spec).unwrap()["ok"], true);+        // the same wrong drawing from a standard library only warns+        let lib = f.write("lib.kicad_sch", &sheet(&[diode_lib("Device:D", 1.27, 1.27, -1.27)], &placed("Device:D", "D1", 100.0, 80.0)));+        let rep = check(&lib, &Value::Null).unwrap();+        assert_eq!(rep["ok"], true);+        assert!(rep["warnings"].as_array().unwrap().iter().any(|w| w.as_str().unwrap().contains("pointing at the anode")));+    }++    #[test]+    fn bar_only_diode_on_the_wrong_side_fails() {+        let f = Fixture::new();+        let lib = r#"(symbol "My:D" (symbol "D_0_1" (rectangle (start -1.27 -1.0) (end 1.27 1.0) (stroke (width 0.2)) (fill (type none))) (polyline (pts (xy 1.0 1.27) (xy 1.0 -1.27)) (stroke (width 0.3)) (fill (type none))))+  (symbol "D_1_1" (pin passive line (at -3.81 0 0) (length 2.54) (name "K") (number "1")) (pin passive line (at 3.81 0 180) (length 2.54) (name "A") (number "2"))))"#;+        let p = f.write("s.kicad_sch", &sheet(&[lib.into()], &placed("My:D", "D3", 100.0, 80.0)));+        let rep = check(&p, &Value::Null).unwrap();+        assert!(rep["errors"].as_array().unwrap().iter().any(|e| e.as_str().unwrap().contains("cathode bar is drawn at the pin 2 end")), "{rep}");+    }++    fn opamp_lib(name: &str, in_type: &str, plus_text_y: f64) -> String {+        format!(r#"(symbol "{name}" (pin_names (offset 0.127)) (property "Reference" "U" (at 0 5 0) (effects (font (size 1.27 1.27)))) (property "ki_keywords" "dual opamp" (at 0 0 0) (effects (font (size 1.27 1.27)) (hide yes)))+  (symbol "OPA_1_1"+    (rectangle (start -5.08 5.08) (end 5.08 -5.08) (stroke (width 0.254)) (fill (type background)))+    (text "+" (at -3.81 {plus_text_y} 0) (effects (font (size 1.27 1.27))))+    (pin {in_type} line (at -7.62 2.54 0) (length 2.54) (name "1" (effects (font (size 1.27 1.27)))) (number "3" (effects (font (size 1.27 1.27)))))+    (pin {in_type} line (at -7.62 -2.54 0) (length 2.54) (name "2" (effects (font (size 1.27 1.27)))) (number "2" (effects (font (size 1.27 1.27)))))+    (pin output line (at 7.62 0 180) (length 2.54) (name "OUT" (effects (font (size 1.27 1.27)))) (number "1" (effects (font (size 1.27 1.27))))))+  (symbol "OPA_2_1"+    (pin passive line (at -7.62 2.54 0) (length 2.54) (name "IN+" (effects (font (size 1.27 1.27)))) (number "5" (effects (font (size 1.27 1.27)))))+    (pin {in_type} line (at -7.62 -2.54 0) (length 2.54) (name "IN-" (effects (font (size 1.27 1.27)))) (number "6" (effects (font (size 1.27 1.27)))))+    (text "+" (at -3.81 {plus_text_y} 0) (effects (font (size 1.27 1.27))))+    (pin output line (at 7.62 0 180) (length 2.54) (name "OUT" (effects (font (size 1.27 1.27)))) (number "7" (effects (font (size 1.27 1.27))))))+  (symbol "OPA_3_1"+    (pin power_in line (at 0 7.62 270) (length 2.54) (name "V+" (effects (font (size 1.27 1.27)))) (number "8" (effects (font (size 1.27 1.27)))))+    (pin passive line (at 0 -7.62 90) (length 2.54) (name "V-" (effects (font (size 1.27 1.27)))) (number "4" (effects (font (size 1.27 1.27)))))))"#)+    }++    #[test]+    fn passive_amplifier_and_power_pins_are_errors_unless_justified() {+        let f = Fixture::new();+        let p = f.write("s.kicad_sch", &sheet(&[opamp_lib("Trial:TL072", "input", 2.54)], &placed("Trial:TL072", "U1", 120.0, 90.0)));+        let rep = check(&p, &Value::Null).unwrap();+        let errs: Vec<String> = rep["errors"].as_array().unwrap().iter().map(|e| e.as_str().unwrap().to_string()).collect();+        assert!(errs.iter().any(|e| e.contains("pin 5") && e.contains("amplifier input")), "{errs:?}");+        assert!(errs.iter().any(|e| e.contains("pin 4") && e.contains("power pin")), "{errs:?}");+        assert_eq!(errs.len(), 2, "{errs:?}");+        let spec = json!({"schematic": {"allowPassive": [{"ref": "U1", "pin": "5", "why": "TL072 datasheet table 6.1"}, {"ref": "U1", "pin": "V-"}]}});+        let rep = check(&p, &spec).unwrap();+        let errs = rep["errors"].as_array().unwrap();+        assert_eq!(errs.len(), 1, "{rep}");+        assert!(errs[0].as_str().unwrap().contains("pin 4"));+        assert!(rep["warnings"].as_array().unwrap().iter().any(|w| w.as_str().unwrap().contains("without a datasheet")));+    }++    #[test]+    fn opamp_plus_text_must_sit_at_the_plus_input() {+        let f = Fixture::new();+        // unit 2: pins IN+ (top, y 2.54) and IN- (bottom); the drawn + at the bottom contradicts them+        let p = f.write("s.kicad_sch", &sheet(&[opamp_lib("Trial:OPA", "input", -2.54)], &placed("Trial:OPA", "U2", 120.0, 90.0)));+        let rep = check(&p, &json!({"schematic": {"allowPassive": [{"ref": "U2", "why": "fixture: not testing pin types here"}]}})).unwrap();+        assert!(rep["errors"].as_array().unwrap().iter().any(|e| e.as_str().unwrap().contains("unit 2") && e.as_str().unwrap().contains("opposite input")), "{rep}");+        let p = f.write("t.kicad_sch", &sheet(&[opamp_lib("Trial:OPA", "input", 2.54)], &placed("Trial:OPA", "U2", 120.0, 90.0)));+        let rep = check(&p, &json!({"schematic": {"allowPassive": [{"ref": "U2", "why": "fixture: not testing pin types here"}]}})).unwrap();+        assert_eq!(rep["ok"], true, "{rep}");+    }++    #[test]+    fn emitter_arrow_on_the_collector_fails() {+        let f = Fixture::new();+        let lib = |arrow_y: f64| format!(r#"(symbol "My:NPN" (symbol "NPN_0_1" (circle (center 1.27 0) (radius 2.8) (stroke (width 0.254)) (fill (type none)))+  (polyline (pts (xy 0.635 0.635) (xy 2.54 2.54)) (stroke (width 0)) (fill (type none)))+  (polyline (pts (xy 0.635 -0.635) (xy 2.54 -2.54)) (stroke (width 0)) (fill (type none)))+  (polyline (pts (xy 1.524 {a}) (xy 2.286 {b}) (xy 2.286 {a}) (xy 1.524 {a})) (stroke (width 0)) (fill (type outline))))+  (symbol "NPN_1_1" (pin input line (at -5.08 0 0) (length 5.715) (name "B") (number "1")) (pin passive line (at 2.54 5.08 270) (length 2.54) (name "C") (number "3")) (pin passive line (at 2.54 -5.08 90) (length 2.54) (name "E") (number "2"))))"#, a = arrow_y, b = arrow_y + 0.762 * arrow_y.signum());+        let good = f.write("g.kicad_sch", &sheet(&[lib(-2.0)], &placed("My:NPN", "Q1", 100.0, 80.0)));+        assert_eq!(check(&good, &Value::Null).unwrap()["ok"], true);+        let bad = f.write("b.kicad_sch", &sheet(&[lib(2.0)], &placed("My:NPN", "Q1", 100.0, 80.0)));+        let rep = check(&bad, &Value::Null).unwrap();+        assert!(rep["errors"][0].as_str().unwrap().contains("collector lead"), "{rep}");+    }++    #[test]+    fn label_only_sheets_text_over_parts_and_off_border_warn() {+        let f = Fixture::new();+        let mut body = placed("Device:D", "D1", 100.0, 80.0);+        for i in 0..10 { body.push_str(&format!("\n(label \"N{i}\" (at {} 60 0) (effects (font (size 1.27 1.27)) (justify left bottom)) (uuid \"6f1d2c3e-0000-4000-8003-{i:012}\"))", 60 + 3 * i)); }+        body.push_str("\n(label \"FB\" (at 90 100 0) (effects (font (size 1.27 1.27))) (uuid \"6f1d2c3e-0000-4000-8004-000000000001\"))");+        body.push_str("\n(label \"FB\" (at 100 105 0) (effects (font (size 1.27 1.27))) (uuid \"6f1d2c3e-0000-4000-8004-000000000002\"))");+        body.push_str("\n(text \"servo loop\" (exclude_from_sim no) (at 99 80 0) (effects (font (size 1.27 1.27)) (justify left bottom)) (uuid \"6f1d2c3e-0000-4000-8005-000000000001\"))");+        body.push_str("\n(text \"note\" (exclude_from_sim no) (at 295 205 0) (effects (font (size 1.27 1.27))) (uuid \"6f1d2c3e-0000-4000-8005-000000000002\"))");+        body.push_str("\n(wire (pts (xy 60 60) (xy 70 60)) (stroke (width 0) (type default)) (uuid \"6f1d2c3e-0000-4000-8006-000000000001\"))");+        let p = f.write("s.kicad_sch", &sheet(&[diode_lib("Device:D", -1.27, -1.27, 1.27)], &body));+        let rep = check(&p, &Value::Null).unwrap();+        let w: Vec<String> = rep["warnings"].as_array().unwrap().iter().map(|e| e.as_str().unwrap().to_string()).collect();+        assert!(w.iter().any(|x| x.contains("12 local labels and 1 wire")), "{w:?}");+        assert!(w.iter().any(|x| x.contains("FB (2 labels)")), "{w:?}");+        assert!(w.iter().any(|x| x.contains("`servo loop` over")), "{w:?}");+        assert!(w.iter().any(|x| x.contains("outside the drawing border") && x.contains("note")), "{w:?}");+        assert_eq!(rep["ok"], true);+        assert_eq!(rep["sheets"][0]["localLabels"], 12);+    }++    #[test]+    fn child_sheets_are_checked_and_gate_binds_hashes() {+        let f = Fixture::new();+        f.write("child.kicad_sch", &sheet(&[diode_lib("Trial:DIODE", 1.27, 1.27, -1.27)], &placed("Trial:DIODE", "D9", 100.0, 80.0)));+        let root = f.write("root.kicad_sch", &format!("{HEAD} (lib_symbols) (sheet (at 50 50) (size 20 20) (property \"Sheetname\" \"filter\" (at 50 49 0)) (property \"Sheetfile\" \"child.kicad_sch\" (at 50 71 0))) (embedded_fonts no))"));+        let rep = check(&root, &Value::Null).unwrap();+        assert_eq!(rep["sheets"].as_array().unwrap().len(), 2);+        assert!(rep["errors"][0].as_str().unwrap().starts_with("polarity drawing: D9"), "{rep}");+        let dir = f.0.join("run");+        std::fs::create_dir_all(&dir).unwrap();+        let mut run = Run { dir: dir.clone(), data: json!({"schematic": root, "boards": [], "outcomes": {}}) };+        assert!(gate(&run).unwrap_err().contains("run `adom-aiflow schematic check --sch"));+        record(&mut run, root.to_str().unwrap(), &rep);+        assert!(gate(&run).unwrap_err().contains("error(s)"));+        f.write("child.kicad_sch", &sheet(&[diode_lib("Trial:DIODE", -1.27, -1.27, 1.27)], &placed("Trial:DIODE", "D9", 100.0, 80.0)));+        assert!(gate(&run).unwrap_err().contains("changed"));+        let rep = check(&root, &Value::Null).unwrap();+        assert_eq!(rep["ok"], true, "{rep}");+        record(&mut run, root.to_str().unwrap(), &rep);+        assert!(gate(&run).is_ok());+    }+}

@@ -0,0 +1,146 @@+//! Assembly silkscreen beyond the label count (issue #39, item 11): references that live only on the+//! fabrication layer, and polarized parts (diodes, LEDs, polarized capacitors, batteries, ICs) with+//! no polarity or pin-1 mark on the silkscreen. Warnings only; `finish` prints them.+//!+//! A mark is any silkscreen circle, polygon or arc in the footprint (a pin-1 dot, triangle or notch),+//! a `+`, `1`, `K` or `A` text, footprint silk lines whose length-weighted middle sits clearly on the pad-1+//! side (a diode's extended cathode line), or a board-level silkscreen item within 1.5 mm of pad 1.+use aiflow_board::{sx::Node, Board};++type Pt = (f64, f64);++fn layer(n: &Node) -> Option<&str> { n.find("layer").and_then(|l| l.value()) }+fn on_silk(n: &Node) -> bool { matches!(layer(n), Some("F.SilkS" | "B.SilkS")) }+fn on_fab(n: &Node) -> bool { matches!(layer(n), Some("F.Fab" | "B.Fab")) }+fn hidden(n: &Node) -> bool {+    let h = |m: &Node| m.find("hide").map(|x| x.value() != Some("no")).unwrap_or(false) || m.items.iter().any(|it| matches!(it, aiflow_board::sx::Item::Atom { text, .. } if text == "hide"));+    h(n) || n.find("effects").map(h).unwrap_or(false)+}+fn xy(n: Option<&Node>) -> Option<Pt> { let n = n?; Some((n.number(1)?, n.number(2)?)) }+fn prefix(r: &str) -> String { r.chars().take_while(|c| c.is_ascii_alphabetic()).collect::<String>().to_ascii_uppercase() }++/// References that are not parts to label (holes, fiducials, logos, machine pins).+fn unlabelled(p: &str) -> bool { matches!(p, "H" | "MH" | "FID" | "MP" | "LOGO" | "G" | "REF") || p.is_empty() }++fn polarized(p: &str, lib: &str) -> bool {+    let l = lib.to_ascii_lowercase();+    matches!(p, "D" | "LED" | "CR" | "ZD" | "U" | "IC" | "BT")+        || ((p == "C" || p == "CP") && (l.contains("cp_") || l.contains("elec") || l.contains("tantal") || l.contains("polar") || l.contains("c_pol") || p == "CP"))+}++/// Board-level silkscreen points (texts' anchors, line ends, circle centres, polygon corners) and the+/// words of board-level silkscreen texts.+fn board_silk(b: &Board) -> (Vec<Pt>, Vec<String>) {+    let (mut pts, mut words) = (Vec::new(), Vec::new());+    for n in b.root.nodes().filter(|n| n.tag.starts_with("gr_") && on_silk(n)) {+        for k in ["start", "end", "center", "at", "mid"] { if let Some(p) = xy(n.find(k)) { pts.push(p); } }+        if let Some(ps) = n.find("pts") { pts.extend(ps.find_all("xy").filter_map(|x| xy(Some(x)))); }+        if n.tag == "gr_text" && !hidden(n) { if let Some(t) = n.atom(1) { words.extend(t.split(|c: char| !c.is_ascii_alphanumeric()).filter(|w| !w.is_empty()).map(str::to_string)); } }+    }+    (pts, words)+}++fn ref_on_silk(fp: &Node, reference: &str, words: &[String]) -> (bool, bool) {+    let (mut silk, mut fab) = (false, false);+    for t in fp.nodes().filter(|c| c.tag == "property" || c.tag == "fp_text") {+        let is_ref = (t.tag == "property" && t.atom(1) == Some("Reference")) || (t.tag == "fp_text" && (t.atom(1) == Some("reference") || t.atom(2).map(|s| s.contains("${REFERENCE}") || s == reference).unwrap_or(false)));+        if !is_ref { continue; }+        if on_silk(t) && !hidden(t) { silk = true; }+        if on_fab(t) { fab = true; }+    }+    (silk || words.iter().any(|w| w == reference), fab)+}++fn has_mark(fp: &Node, pad1: Pt, centre: Pt) -> bool {+    let mut weighted = (0.0, 0.0, 0.0);+    for g in fp.nodes().filter(|n| on_silk(n)) {+        match g.tag.as_str() {+            "fp_circle" | "fp_poly" | "fp_arc" => return true,+            "fp_text" | "property" if !hidden(g) => {+                let t = if g.tag == "fp_text" { g.atom(2) } else { g.atom(2).filter(|_| g.atom(1).map(|k| k != "Reference" && k != "Value").unwrap_or(false)) };+                if matches!(t.map(str::trim), Some("+" | "1" | "K" | "A")) { return true; }+            }+            "fp_line" => {+                if let (Some(a), Some(z)) = (xy(g.find("start")), xy(g.find("end"))) {+                    let len = ((a.0 - z.0).powi(2) + (a.1 - z.1).powi(2)).sqrt();+                    weighted.0 += len * (a.0 + z.0) / 2.0; weighted.1 += len * (a.1 + z.1) / 2.0; weighted.2 += len;+                }+            }+            _ => {}+        }+    }+    if weighted.2 <= 0.0 { return false; }+    let mid = (weighted.0 / weighted.2, weighted.1 / weighted.2);+    let d = (pad1.0 - centre.0, pad1.1 - centre.1);+    let dl = (d.0 * d.0 + d.1 * d.1).sqrt();+    if dl < 1e-6 { return false; }+    ((mid.0 - centre.0) * d.0 + (mid.1 - centre.1) * d.1) / dl > 0.15 * dl+}++/// The warnings for a board: references on the fabrication layer only, and polarized parts with no+/// silkscreen polarity or pin-1 mark.+pub fn warnings(b: &Board) -> Vec<String> {+    let (silk_pts, words) = board_silk(b);+    let (mut fab_only, mut unmarked) = (Vec::new(), Vec::new());+    for fp in b.root.find_all("footprint") {+        let Some(reference) = aiflow_board::reference_of(fp) else { continue };+        let p = prefix(&reference);+        if reference.starts_with('#') || unlabelled(&p) { continue; }+        let pads: Vec<(String, Pt)> = fp.find_all("pad").filter_map(|pd| Some((pd.atom(1)?.to_string(), xy(pd.find("at"))?))).collect();+        if pads.is_empty() { continue; }+        let (silk, fab) = ref_on_silk(fp, &reference, &words);+        if !silk && fab { fab_only.push(reference.clone()); }+        if pads.len() < 2 || !polarized(&p, fp.atom(1).unwrap_or("")) { continue; }+        let Some(pad1) = ["1", "K", "A"].iter().find_map(|n| pads.iter().find(|(name, _)| name == n)).map(|x| x.1) else { continue };+        let n = pads.len() as f64;+        let centre = (pads.iter().map(|x| x.1 .0).sum::<f64>() / n, pads.iter().map(|x| x.1 .1).sum::<f64>() / n);+        if has_mark(fp, pad1, centre) { continue; }+        // a board-level mark beside pad 1 (world coordinates)+        let near = b.pads_of(&reference).iter().filter(|q| ["1", "K", "A"].contains(&q.name.as_str())).any(|q| silk_pts.iter().any(|s| ((s.0 - q.x).powi(2) + (s.1 - q.y).powi(2)).sqrt() <= q.half_long + 1.5));+        if !near { unmarked.push(reference.clone()); }+    }+    let list = |v: &[String]| format!("{}{}", v.iter().take(12).cloned().collect::<Vec<_>>().join(", "), if v.len() > 12 { ", ..." } else { "" });+    let mut out = Vec::new();+    if !fab_only.is_empty() { out.push(format!("{} reference(s) only on the fabrication layer, none on the silkscreen: {}. Put readable references on F.SilkS/B.SilkS (skill aiflow-silkscreen)", fab_only.len(), list(&fab_only))); }+    if !unmarked.is_empty() { out.push(format!("{} polarized part(s) with no silkscreen polarity or pin-1 mark: {}. Add a cathode bar, + sign or pin-1 dot beside the pad on the silkscreen (skill aiflow-silkscreen)", unmarked.len(), list(&unmarked))); }+    out+}++#[cfg(test)]+mod tests {+    use super::*;+    const BOARD: &str = r#"(kicad_pcb (version 20241229)+  (layers (0 "F.Cu" signal) (31 "B.Cu" signal))+  (gr_rect (start 0 0) (end 50 20) (layer "Edge.Cuts") (width 0.1))+  (footprint "Diode_SMD:D_SOD-123" (layer "F.Cu") (at 10 10)+    (property "Reference" "D1" (at 0 -2) (layer "F.SilkS") (effects (font (size 1 1))))+    (fp_line (start -2.36 -1) (end 1.65 -1) (layer "F.SilkS")) (fp_line (start -2.36 -1) (end -2.36 1) (layer "F.SilkS")) (fp_line (start -2.36 1) (end 1.65 1) (layer "F.SilkS"))+    (pad "1" smd rect (at -1.65 0) (size 0.9 1.2) (layers "F.Cu")) (pad "2" smd rect (at 1.65 0) (size 0.9 1.2) (layers "F.Cu")))+  (footprint "Custom:DIODE" (layer "F.Cu") (at 20 10)+    (property "Reference" "D2" (at 0 -2) (layer "F.Fab") (effects (font (size 1 1))))+    (fp_rect (start -2 -1) (end 2 1) (layer "F.Fab"))+    (pad "1" smd rect (at -1.65 0) (size 0.9 1.2) (layers "F.Cu")) (pad "2" smd rect (at 1.65 0) (size 0.9 1.2) (layers "F.Cu")))+  (footprint "Resistor_SMD:R_0805" (layer "F.Cu") (at 30 10)+    (property "Reference" "R1" (at 0 -2) (layer "F.Fab") (effects (font (size 1 1))))+    (pad "1" smd rect (at -1 0) (size 1 1.2) (layers "F.Cu")) (pad "2" smd rect (at 1 0) (size 1 1.2) (layers "F.Cu")))+  (footprint "Package_SO:SOIC-8" (layer "F.Cu") (at 40 10)+    (property "Reference" "U1" (at 0 -4) (layer "F.SilkS") (effects (font (size 1 1))))+    (fp_poly (pts (xy -3 -2.5) (xy -3.3 -2.8) (xy -2.7 -2.8)) (layer "F.SilkS"))+    (pad "1" smd rect (at -2.7 -1.9) (size 1.5 0.6) (layers "F.Cu")) (pad "8" smd rect (at 2.7 -1.9) (size 1.5 0.6) (layers "F.Cu")))+  (footprint "MountingHole:MountingHole_3.2mm" (layer "F.Cu") (at 2 2)+    (property "Reference" "H1" (at 0 -4) (layer "F.Fab")) (pad "" np_thru_hole circle (at 0 0) (size 3.2 3.2) (drill 3.2) (layers "*.Cu")))+)"#;++    #[test]+    fn fab_only_refs_and_unmarked_polarized_parts_warn() {+        let b = Board::from_text("t.kicad_pcb", BOARD.to_string()).unwrap();+        let w = warnings(&b);+        assert_eq!(w.len(), 2, "{w:?}");+        assert!(w[0].contains("2 reference(s) only on the fabrication layer") && w[0].contains("D2, R1"), "{w:?}");+        assert!(w[1].contains("1 polarized part(s)") && w[1].contains("D2"), "{w:?}");+        // a board-level + beside pad 1 marks D2; a board text naming the reference labels it+        let fixed = BOARD.replace("\n)", "\n  (gr_text \"+\" (at 18.2 11) (layer \"F.SilkS\") (effects (font (size 1 1))))\n  (gr_text \"D2 R1\" (at 25 14) (layer \"F.SilkS\") (effects (font (size 1 1))))\n)");+        let b = Board::from_text("t.kicad_pcb", fixed).unwrap();+        assert!(warnings(&b).is_empty(), "{:?}", warnings(&b));+    }+}

@@ -81,9 +81,116 @@ pub fn geometry_gaps(input: &Value, board: &Board) -> Vec<String> {     if uncovered_vias > 0 {         why.push(format!("{uncovered_vias} of the board's vias have no via/hole obstacle box covering them"));     }+    why.extend(mark_gaps(input, board));     why } +/// A visible silkscreen text on the board, where it is and how big KiCad draws it.+struct SilkText { owner: Option<String>, kind: String, text: String, layer: String, x: f64, y: f64, w: f64, h: f64 }++/// KiCad's stroke font, as a lower bound: about 0.6 x the glyph width per character (0.3 for the narrow+/// ones), lines of the glyph height, plus the stroke. A box smaller than this cannot hold the text.+fn text_extent(text: &str, size_h: f64, size_w: f64, thick: f64, angle: f64) -> (f64, f64) {+    let lines: Vec<&str> = text.split('\n').collect();+    let per = |c: char| if "iljI1.,:;'!|` ".contains(c) { 0.3 } else { 0.6 };+    let wide = lines.iter().map(|l| l.chars().map(per).sum::<f64>()).fold(0.0, f64::max) * size_w + thick;+    let high = lines.len() as f64 * size_h + thick;+    let (s, c) = angle.to_radians().sin_cos();+    (wide * c.abs() + high * s.abs(), wide * s.abs() + high * c.abs())+}++fn silk_texts(board: &Board) -> Vec<SilkText> {+    use crate::provenance::{is_hidden, on_silk};+    let font = |n: &aiflow_board::sx::Node| {+        let f = n.find("effects").and_then(|e| e.find("font"));+        let size = f.and_then(|f| f.find("size"));+        let h = size.and_then(|s| s.number(1)).unwrap_or(1.0);+        let w = size.and_then(|s| s.number(2)).unwrap_or(h);+        let t = f.and_then(|f| f.find("thickness")).and_then(|t| t.number(1)).unwrap_or(0.15 * h);+        (h, w, t)+    };+    let mut out = Vec::new();+    for n in board.root.nodes() {+        match n.tag.as_str() {+            "footprint" => {+                let reference = aiflow_board::reference_of(n);+                let value = n.nodes().find(|p| p.tag == "property" && p.atom(1) == Some("Value")).and_then(|p| p.atom(2)).unwrap_or("").to_string();+                let at = n.find("at");+                let (fx, fy, fr) = (at.and_then(|a| a.number(1)).unwrap_or(0.0), at.and_then(|a| a.number(2)).unwrap_or(0.0), at.and_then(|a| a.number(3)).unwrap_or(0.0));+                for t in n.nodes().filter(|c| (c.tag == "property" || c.tag == "fp_text") && on_silk(c) && !is_hidden(c)) {+                    let raw = t.atom(2).unwrap_or("");+                    let text = raw.replace("${REFERENCE}", reference.as_deref().unwrap_or("")).replace("${VALUE}", &value);+                    if text.trim().is_empty() { continue; }+                    let ta = t.find("at");+                    let (dx, dy) = aiflow_board::geom::rot_kicad(ta.and_then(|a| a.number(1)).unwrap_or(0.0), ta.and_then(|a| a.number(2)).unwrap_or(0.0), fr);+                    let (h, w, th) = font(t);+                    let (ew, eh) = text_extent(&text, h, w, th, ta.and_then(|a| a.number(3)).unwrap_or(0.0));+                    out.push(SilkText { owner: reference.clone(), kind: t.atom(1).unwrap_or("").to_ascii_lowercase(), text, layer: t.find("layer").and_then(|l| l.value()).unwrap_or("").to_string(), x: fx + dx, y: fy + dy, w: ew, h: eh });+                }+            }+            "gr_text" if on_silk(n) && !is_hidden(n) => {+                let text = n.atom(1).unwrap_or("").to_string();+                if text.trim().is_empty() { continue; }+                let a = n.find("at");+                let (h, w, th) = font(n);+                let (ew, eh) = text_extent(&text, h, w, th, a.and_then(|a| a.number(3)).unwrap_or(0.0));+                out.push(SilkText { owner: None, kind: "text".into(), text, layer: n.find("layer").and_then(|l| l.value()).unwrap_or("").to_string(), x: a.and_then(|a| a.number(1)).unwrap_or(0.0), y: a.and_then(|a| a.number(2)).unwrap_or(0.0), w: ew, h: eh });+            }+            _ => {}+        }+    }+    out+}++/// A mark's boxes (`boxes`, else `box`), each normalised to (x0, y0, x1, y1).+fn mark_boxes(m: &Value) -> Vec<(f64, f64, f64, f64)> {+    let one = |b: &Value| { let v: Vec<f64> = b.as_array()?.iter().filter_map(|x| x.as_f64()).collect(); (v.len() == 4).then(|| (v[0].min(v[2]), v[1].min(v[3]), v[0].max(v[2]), v[1].max(v[3]))) };+    match m["boxes"].as_array() { Some(a) => a.iter().filter_map(one).collect(), None => one(&m["box"]).into_iter().collect() }+}++/// Label (mark) boxes checked against the board's own silk text (issue #58): a mark is the board text it+/// names (`text`), else the text whose anchor its box holds, else (by id) its footprint's reference or value+/// text on that layer; its box must be at least as large as that text's extent from the board's size,+/// length, rotation and stroke. Marks that match no board text (leaders, frames) are not judged here.+pub fn mark_gaps(input: &Value, board: &Board) -> Vec<String> {+    let marks = input["marks"].as_array().cloned().unwrap_or_default();+    if marks.is_empty() { return Vec::new(); }+    let texts = silk_texts(board);+    let mut short = Vec::new();+    for m in &marks {+        let boxes = mark_boxes(m);+        if boxes.is_empty() { continue; }+        let u = boxes.iter().fold((f64::MAX, f64::MAX, f64::MIN, f64::MIN), |a, b| (a.0.min(b.0), a.1.min(b.1), a.2.max(b.2), a.3.max(b.3)));+        let layer = m["layer"].as_str();+        let id = m["id"].as_str().unwrap_or("");+        let on_layer: Vec<&SilkText> = texts.iter().filter(|t| layer.map(|l| l == t.layer).unwrap_or(true)).collect();+        let owner = board.footprints.keys().filter(|r| covers(id, r)).max_by_key(|r| r.len()).cloned();+        let mut matched: Vec<&SilkText> = match m["text"].as_str() {+            Some(want) => {+                let same: Vec<&SilkText> = on_layer.iter().copied().filter(|t| t.text == want).collect();+                let mine: Vec<&SilkText> = same.iter().copied().filter(|t| owner.is_some() && t.owner == owner).collect();+                if mine.is_empty() { same } else { mine }+            }+            None => on_layer.iter().copied().filter(|t| inside((t.x, t.y), u)).collect(),+        };+        if matched.is_empty() && m["text"].is_null() {+            if let Some(o) = &owner {+                let want = if id.to_ascii_lowercase().contains("val") { "value" } else { "reference" };+                matched = on_layer.iter().copied().filter(|t| t.owner.as_ref() == Some(o) && t.kind == want).collect();+            }+        }+        let Some(t) = matched.into_iter().min_by(|a, b| (a.w * a.h).total_cmp(&(b.w * b.h))) else { continue };+        let (bw, bh) = (u.2 - u.0, u.3 - u.1);+        let (bmin, bmax) = (bw.min(bh), bw.max(bh));+        let (tmin, tmax) = (t.w.min(t.h), t.w.max(t.h));+        if bmin < tmin - TOL || bmax < tmax - TOL {+            short.push(format!("{id} {bw:.2} x {bh:.2} mm for \"{}\" (at least {:.2} x {:.2} mm)", t.text.replace('\n', " "), t.w, t.h));+        }+    }+    if short.is_empty() { return Vec::new(); }+    vec![format!("{} label (mark) box(es) are smaller than the board's own silkscreen text ({}{}): label boxes must be the rendered text extents measured from the board (size, length, rotation and stroke)", short.len(), short.iter().take(8).cloned().collect::<Vec<_>>().join("; "), if short.len() > 8 { "; ..." } else { "" })]+}+ #[cfg(test)] mod tests {     use super::*;@@ -135,6 +242,34 @@ mod tests {         assert!(why.contains("1 of the board's vias"), "{why}");     } +    #[test]+    fn label_boxes_smaller_than_the_board_text_are_refused() {+        // R1's reference is 1 mm text at (2, 1); C1's value "1u" at (6, 3); a 0.6 mm square cannot hold either+        let b = Board::from_text("t.kicad_pcb", BOARD.to_string()).unwrap();+        let base = json!({"inventory": [{"id": "R1", "kind": "body"}, {"id": "C1", "kind": "body"}, {"id": "v1", "kind": "via"}],+            "obstacles": [{"id": "R1", "kind": "body", "box": [1.4, 1.4, 2.6, 2.6]}, {"id": "C1", "kind": "body", "box": [5.4, 1.4, 6.6, 2.6]}, {"id": "v1", "kind": "via", "box": [4.7, 4.7, 5.3, 5.3]}]});+        let with = |marks: Value| { let mut v = base.clone(); v["marks"] = marks; v };+        let tiny = with(json!([{"id": "R1:ref", "layer": "F.SilkS", "box": [1.7, 0.7, 2.3, 1.3]}, {"id": "C1:value", "layer": "F.SilkS", "box": [5.7, 2.7, 6.3, 3.3]}]));+        let why = geometry_gaps(&tiny, &b).join("; ");+        assert!(why.contains("2 label (mark) box(es) are smaller") && why.contains("\"R1\"") && why.contains("\"1u\""), "{why}");+        assert!(proof(&json!({"passed": true}), &tiny, &b).is_err());+        // boxes as large as the text pass; a box placed away from the text is still matched by id+        let real = with(json!([{"id": "R1:ref", "layer": "F.SilkS", "box": [1.2, 0.35, 2.8, 1.65]}, {"id": "C1:value", "layer": "F.SilkS", "boxes": [[5.2, 2.35, 6.0, 3.65], [6.0, 2.35, 6.8, 3.65]]}]));+        assert!(geometry_gaps(&real, &b).is_empty(), "{:?}", geometry_gaps(&real, &b));+        let away = with(json!([{"id": "R1-ref", "layer": "F.SilkS", "box": [8.0, 8.0, 8.5, 8.5]}]));+        assert!(geometry_gaps(&away, &b).join("; ").contains("R1-ref 0.50 x 0.50 mm"));+        // a mark that names its text is judged against that text; one that matches nothing is not judged+        let named = with(json!([{"id": "lbl", "text": "10k", "layer": "F.SilkS", "box": [0.0, 0.0, 0.5, 0.5]}, {"id": "frame", "layer": "F.SilkS", "box": [8.0, 8.0, 8.2, 8.2]}]));+        let why = geometry_gaps(&named, &b).join("; ");+        assert!(why.contains("1 label") && why.contains("\"10k\""), "{why}");+        // rotation: a 90 degree text needs a tall box+        let rot = BOARD.replace("(property \"Reference\" \"R1\" (at 0 -1)", "(property \"Reference\" \"R1\" (at 0 -1 90)");+        let b90 = Board::from_text("t.kicad_pcb", rot).unwrap();+        let tall = with(json!([{"id": "R1:ref", "layer": "F.SilkS", "box": [1.35, 0.2, 2.65, 1.8]}]));+        assert!(geometry_gaps(&tall, &b90).is_empty());+        assert!(text_extent("R1234", 1.0, 1.0, 0.15, 90.0).1 > text_extent("R1234", 1.0, 1.0, 0.15, 90.0).0);+    }+     #[test]     fn a_bare_board_is_not_a_silkscreen() {         let bare = BOARD.replace("(layer \"F.SilkS\")", "(layer \"F.Fab\")");

@@ -0,0 +1,199 @@+//! Skill files by absolute path in the Hint lines (issue #56). An engine without a skill loader+//! (Antigravity has no skills directory) never sees ~/.claude/skills, so it reverse-engineered the+//! binary to learn an input format. When a step starts (`step <name>`) and when a command fails,+//! the hints name the SKILL.md to read by absolute path, the installed copy and the package's own+//! copy, and the section that holds the input schema.+//!+//! The step-to-skill map is `skills` in flows/board.json (the Companion skills table of SKILL.md);+//! the command-to-section map is `COMMANDS` below. Both are checked against the shipped skill files+//! by the tests, so a renamed heading fails the build's tests instead of sending an AI to nothing.++use std::path::{Path, PathBuf};++use serde_json::Value;++/// A command (its first word, or its first two words) and where its input is described:+/// (command, skill, section heading in that skill's SKILL.md, a doc in the package or "").+pub const COMMANDS: &[(&str, &str, &str, &str)] = &[+    ("silkscreen-audit", "aiflow-silkscreen", "Input schemas", ""),+    ("silkscreen-layout", "aiflow-silkscreen", "Input schemas", ""),+    ("silkscreen-sections", "aiflow-silkscreen", "Input schemas", ""),+    ("silkscreen-preflight", "aiflow-silkscreen", "Input schemas", ""),+    ("silkscreen-contact-policy", "aiflow-silkscreen", "Input schemas", ""),+    ("silkscreen-mask", "aiflow-silkscreen", "Input schemas", ""),+    ("silkscreen-dashboard", "aiflow-silkscreen", "Inputs and live observation", ""),+    ("analyze current", "aiflow-power-layout", "Input schemas", "docs/plan-schema.md"),+    ("analyze thermal", "aiflow-power-layout", "Input schemas", "docs/plan-schema.md"),+    ("verify-pours", "aiflow-power-layout", "Input schemas", "docs/existing-pours.md"),+    ("gate", "aiflow-power-layout", "Input schemas", "docs/plan-schema.md"),+    ("land route", "aiflow-power-layout", "Input schemas", "docs/plan-schema.md"),+    ("route", "aiflow-power-layout", "3. Routing: keep B.Cu a ground plane under the hot loop", "docs/plan-schema.md"),+    ("pour", "aiflow-power-layout", "4. Pours: small SW, solid heat paths", ""),+    ("thermal-vias", "aiflow-power-layout", "Local thermal-via planning", "docs/thermal-via-acknowledgements.md"),+    ("place", "aiflow-power-layout", "Input schemas", ""),+    ("sourcing", "aiflow-sourcing", "Input schema: the BOM CSV", ""),+    ("parts", "aiflow-sourcing", "Input schema: the BOM CSV", ""),+    ("models", "aiflow-sourcing", "6. Check every model", ""),+    ("evidence", "aiflow-circuit-design", "Input schema: evidence files", ""),+    ("schematic", "aiflow-schematic-to-board", "Schematic check: symbols, pin types, readability", ""),+    ("netlist", "aiflow-schematic-to-board", "6. Verify: ERC and netlist equivalence", ""),+    ("export", "aiflow-schematic-to-board", "5. kicad-cli from the container", ""),+    ("step-export", "aiflow-molecule", "5. Export, convert, publish", ""),+    ("board-glb", "aiflow-molecule", "5. Export, convert, publish", ""),+    ("molecule", "aiflow-molecule", "4. Conformance check before placement", ""),+    ("testplan", "aiflow-test-plan", "2. Give every measurement a spot (before the schematic)", ""),+    ("intake", "aiflow-intake", "5. Write requirements.json", ""),+    ("start", "adom-aiflow", "The spec", ""),+    ("capture", "aiflow-live-clips", "3. Mechanics that bite", ""),+    ("clips", "aiflow-live-clips", "2. After every step", ""),+    ("compose", "aiflow-process-video", "Compose", ""),+    ("recut", "aiflow-process-video", "Review every clip before assembling", ""),+    ("project-page", "aiflow-project-page", "", ""),+];++/// Where the package's own files are: $ADOM_AIFLOW_HOME, else an `adom_modules/adom/adom-aiflow`+/// found walking up from `cwd`, else one under `home` (or `home/project`).+pub fn package_root(home: &Path, cwd: &Path) -> Option<PathBuf> {+    if let Some(p) = std::env::var_os("ADOM_AIFLOW_HOME").map(PathBuf::from).filter(|p| p.join("skills").is_dir()) { return Some(p); }+    let rel = Path::new("adom_modules").join("adom").join("adom-aiflow");+    for d in cwd.ancestors() {+        let c = d.join(&rel);+        if c.join("skills").is_dir() { return Some(c); }+    }+    [home.join(&rel), home.join("project").join(&rel)].into_iter().find(|c| c.join("skills").is_dir())+}++/// The installed SKILL.md (~/.claude/skills, then ~/.codex/skills) and the package's copy, both+/// absolute; the installed path is named even when it is missing, so the line says where it belongs.+pub fn skill_files(skill: &str, home: &Path, pkg: Option<&Path>) -> (PathBuf, Option<PathBuf>) {+    let claude = home.join(".claude").join("skills").join(skill).join("SKILL.md");+    let codex = home.join(".codex").join("skills").join(skill).join("SKILL.md");+    let installed = if claude.is_file() || !codex.is_file() { claude } else { codex };+    let packaged = pkg.map(|p| p.join("skills").join(skill).join("SKILL.md")).filter(|p| p.is_file());+    (installed, packaged)+}++fn where_line(skill: &str, section: &str, doc: &str, home: &Path, pkg: Option<&Path>) -> String {+    let (installed, packaged) = skill_files(skill, home, pkg);+    let mut s = format!("read {}", installed.display());+    if !installed.is_file() { s.push_str(" (not installed here)"); }+    if let Some(p) = packaged { if p != installed { s.push_str(&format!(" or {}", p.display())); } }+    if !section.is_empty() { s.push_str(&format!(", section \"{section}\"")); }+    if !doc.is_empty() {+        match pkg.map(|p| p.join(doc)).filter(|p| p.is_file()) {+            Some(d) => s.push_str(&format!("; also {}", d.display())),+            None => s.push_str(&format!("; also {doc} in the adom-aiflow package")),+        }+    }+    s+}++/// The skills a step needs, from flows/board.json `skills` (step name to a list of skill names).+pub fn step_skills(flow: &Value, step: &str) -> Vec<String> {+    flow["skills"][step].as_array().map(|a| a.iter().filter_map(|s| s.as_str().map(str::to_string)).collect()).unwrap_or_default()+}++/// The `COMMANDS` entry for a command line as typed (flags and the thread already stripped): the+/// two-word form first (`analyze thermal`), then the first word.+pub fn command_entry(cmdline: &str) -> Option<(&'static str, &'static str, &'static str, &'static str)> {+    let words: Vec<&str> = cmdline.split_whitespace().filter(|w| !w.starts_with('-')).collect();+    let first = *words.first()?;+    let two = words.get(1).map(|w| format!("{first} {w}"));+    two.as_deref().and_then(|t| COMMANDS.iter().find(|c| c.0 == t)).or_else(|| COMMANDS.iter().find(|c| c.0 == first)).copied()+}++/// The Hint lines for `step <name>`: the main skill, then each companion skill of the step.+pub fn step_hints(flow: &Value, step: &str, home: &Path, pkg: Option<&Path>) -> Vec<String> {+    let skills = step_skills(flow, step);+    let mut out = Vec::new();+    if skills.is_empty() {+        out.push(format!("Skill for this step: no companion skill; the flow is in the main skill: {}.", where_line("adom-aiflow", "", "", home, pkg)));+        return out;+    }+    for s in &skills {+        out.push(format!("Skill for {step}: {s}: {}. Engines without a skill loader: open that file now, before the step's first command.", where_line(s, "", "", home, pkg)));+    }+    out+}++/// The Hint line for a failed command: where its input is described.+pub fn command_hint(cmdline: &str, home: &Path, pkg: Option<&Path>) -> Option<String> {+    let (cmd, skill, section, doc) = command_entry(cmdline)?;+    Some(format!("Input of `{cmd}` (skill {skill}): {}.", where_line(skill, section, doc, home, pkg)))+}++/// `home` and the package root for this process.+pub fn here() -> (PathBuf, Option<PathBuf>) {+    let home = std::env::var_os("HOME").map(PathBuf::from).unwrap_or_else(|| PathBuf::from("/"));+    let cwd = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));+    let pkg = package_root(&home, &cwd);+    (home, pkg)+}++#[cfg(test)]+mod tests {+    use super::*;++    fn repo() -> PathBuf { Path::new(env!("CARGO_MANIFEST_DIR")).join("../..").canonicalize().unwrap() }++    fn headings(skill: &str) -> Vec<String> {+        let t = std::fs::read_to_string(repo().join("skills").join(skill).join("SKILL.md")).unwrap_or_else(|e| panic!("{skill}: {e}"));+        t.lines().filter(|l| l.starts_with('#')).map(|l| l.trim_start_matches('#').trim().to_string()).collect()+    }++    #[test]+    fn every_command_section_and_doc_exists_in_the_shipped_skills() {+        for (cmd, skill, section, doc) in COMMANDS {+            let h = headings(skill);+            assert!(section.is_empty() || h.iter().any(|x| x == section), "{cmd}: no heading \"{section}\" in {skill}: {h:?}");+            assert!(doc.is_empty() || repo().join(doc).is_file(), "{cmd}: no {doc}");+        }+    }++    #[test]+    fn every_flow_step_names_shipped_skills() {+        let flow: Value = serde_json::from_str(include_str!("../../../flows/board.json")).unwrap();+        let map = flow["skills"].as_object().expect("flows/board.json has a skills map");+        let mut steps: Vec<String> = flow["steps"].as_array().unwrap().iter().filter_map(|s| s["name"].as_str().map(str::to_string)).collect();+        steps.extend(crate::preboard::PREBOARD_STEPS.iter().map(|s| s.to_string()));+        for st in &steps { assert!(map.contains_key(st), "flows/board.json skills has no entry for step {st}"); }+        for (st, list) in map.iter().filter(|(k, _)| k.as_str() != "_") {+            for s in list.as_array().unwrap() {+                let s = s.as_str().unwrap();+                assert!(repo().join("skills").join(s).join("SKILL.md").is_file(), "step {st}: skill {s} is not shipped");+            }+        }+    }++    #[test]+    fn hints_name_absolute_paths_installed_and_packaged() {+        let tmp = std::env::temp_dir().join(format!("aiflow-skillhints-{}", std::process::id()));+        let home = tmp.join("home");+        let pkg = tmp.join("work").join("adom_modules").join("adom").join("adom-aiflow");+        std::fs::create_dir_all(home.join(".claude/skills/aiflow-silkscreen")).unwrap();+        std::fs::write(home.join(".claude/skills/aiflow-silkscreen/SKILL.md"), "# x").unwrap();+        std::fs::create_dir_all(pkg.join("skills/aiflow-silkscreen")).unwrap();+        std::fs::write(pkg.join("skills/aiflow-silkscreen/SKILL.md"), "# x").unwrap();+        std::fs::create_dir_all(pkg.join("docs")).unwrap();+        std::fs::write(pkg.join("docs/plan-schema.md"), "# x").unwrap();+        // found walking up from a run directory below the project+        let cwd = tmp.join("work").join("runs").join("r1");+        std::fs::create_dir_all(&cwd).unwrap();+        let found = package_root(&home, &cwd);+        assert_eq!(found.as_deref(), Some(pkg.as_path()));+        let h = command_hint("silkscreen-audit --input a.json --out b.json", &home, found.as_deref()).unwrap();+        assert!(h.contains(&home.join(".claude/skills/aiflow-silkscreen/SKILL.md").display().to_string()), "{h}");+        assert!(h.contains(&pkg.join("skills/aiflow-silkscreen/SKILL.md").display().to_string()), "{h}");+        assert!(h.contains("section \"Input schemas\""), "{h}");+        // two-word commands; a doc in the package by absolute path; a skill not installed is said+        let h = command_hint("analyze thermal --plan p.json", &home, found.as_deref()).unwrap();+        assert!(h.contains("aiflow-power-layout") && h.contains("(not installed here)") && h.contains(&pkg.join("docs/plan-schema.md").display().to_string()), "{h}");+        assert!(command_hint("ledger", &home, None).is_none());+        let flow = serde_json::json!({"skills": {"silkscreen": ["aiflow-silkscreen"]}});+        let s = step_hints(&flow, "silkscreen", &home, found.as_deref());+        assert_eq!(s.len(), 1);+        assert!(s[0].starts_with("Skill for silkscreen: aiflow-silkscreen: read /"), "{s:?}");+        assert!(step_hints(&flow, "capture", &home, None)[0].contains("adom-aiflow"));+        let _ = std::fs::remove_dir_all(&tmp);+    }+}

@@ -0,0 +1,182 @@+//! The native STEP export of the board twin, with its diagnostics kept (issue #39, reply 2).+//!+//! KiCad's `pcb export step` can exit 0 and write the file while printing geometry warnings such as+//! `Wire self-interference check failed` (followed by a `z: ...; bounding box: ...` line). The+//! exit status says the file exists, not that every face made it. So the output (stdout and+//! stderr) is kept and classified apart from the exit status:+//! - geometry: the exporter could not build a shape cleanly (self-interference, failed outlines);+//! - model: a 3D model was not found or not loaded;+//! - other: any other warning or error line.+//! Geometry warnings block the final twin delivery (`board-glb copper` in a run and `deliver`)+//! until someone reviews the exported STEP and records `step-export --ack --why "..."`, which binds+//! to that STEP file's hash. The export always includes every layer; it never drops silkscreen,+//! mask or zones to make a warning go away.++use aiflow_board::Board;+use serde_json::{json, Value};+use std::path::Path;++/// The full twin: models, tracks, pads, zones, mask and silkscreen. Never trimmed.+pub const LAYER_FLAGS: &[&str] = &["--subst-models", "--include-tracks", "--include-pads", "--include-zones", "--include-soldermask", "--include-silkscreen"];++#[derive(Debug, Clone, PartialEq)]+pub struct Diag { pub kind: &'static str, pub message: String, pub location: Option<[f64; 5]> }++fn kind_of(line: &str) -> Option<&'static str> {+    let l = line.to_ascii_lowercase();+    let geometry = ["self-interference", "self-intersect", "self intersect", "failed to build", "failed to create", "failed to make", "cannot create", "could not create", "unable to create", "invalid shape", "invalid outline", "outline is not closed", "brep", "failed to fix"];+    let model = ["3d model", "model not found", "cannot load model", "could not load", "cannot find", "could not find", "file not found", "no such file", "cannot open"];+    if geometry.iter().any(|k| l.contains(k)) { return Some("geometry"); }+    if model.iter().any(|k| l.contains(k)) { return Some("model"); }+    if l.contains("warning") || l.contains("error") || l.contains("fail") { return Some("other"); }+    None+}++/// `z: 1.585; bounding box: x0: 130.1; y0: 86.5; x1: 130.27; y1: 87.45` as [z, x0, y0, x1, y1].+pub fn location(line: &str) -> Option<[f64; 5]> {+    let l = line.trim();+    if !l.starts_with("z:") || !l.contains("bounding box") { return None; }+    let num = |key: &str| -> Option<f64> {+        let i = l.find(key)? + key.len();+        l[i..].trim_start().split(|c: char| c == ';' || c.is_whitespace()).next()?.parse().ok()+    };+    Some([num("z:")?, num("x0:")?, num("y0:")?, num("x1:")?, num("y1:")?])+}++/// Every warning line of an export's output, with the location line that follows it.+pub fn classify(output: &str) -> Vec<Diag> {+    let mut out: Vec<Diag> = Vec::new();+    for raw in output.lines() {+        let line = raw.trim();+        if line.is_empty() { continue; }+        if let Some(loc) = location(line) {+            if let Some(d) = out.last_mut() { if d.location.is_none() { d.location = Some(loc); continue; } }+            continue;+        }+        if let Some(k) = kind_of(line) { out.push(Diag { kind: k, message: line.to_string(), location: None }); }+    }+    out+}++/// The footprints nearest a warning's box (KiCad prints board coordinates), nearest first.+pub fn nearby(b: &Board, loc: &[f64; 5], n: usize) -> Vec<Value> {+    let (cx, cy) = ((loc[1] + loc[3]) / 2.0, (loc[2] + loc[4]) / 2.0);+    let mut d: Vec<(f64, &String)> = b.footprints.iter().map(|(r, f)| ((f.x - cx).hypot(f.y - cy), r)).collect();+    d.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap_or(std::cmp::Ordering::Equal));+    d.into_iter().take(n).map(|(dist, r)| json!({"ref": r, "distanceMm": (dist * 100.0).round() / 100.0})).collect()+}++/// The run's record of one export.+pub fn record(board_path: &str, step: Option<&Path>, exit_code: Option<i32>, output: &str, command: &str) -> Value {+    let diags = classify(output);+    let board = Board::load(board_path).ok();+    let list: Vec<Value> = diags.iter().map(|d| json!({+        "kind": d.kind, "message": d.message,+        "location": d.location.map(|l| json!({"z": l[0], "x0": l[1], "y0": l[2], "x1": l[3], "y1": l[4]})),+        "nearbyFootprints": match (&board, d.location) { (Some(b), Some(l)) => json!(nearby(b, &l, 3)), _ => Value::Null },+    })).collect();+    let count = |k: &str| diags.iter().filter(|d| d.kind == k).count();+    let step_ok = step.map(|p| p.is_file()).unwrap_or(false);+    json!({+        "board": board_path, "boardSha256": crate::sha256_file(board_path),+        "step": step.map(|p| p.display().to_string()), "stepSha256": if step_ok { json!(crate::sha256_file(&step.unwrap().display().to_string())) } else { Value::Null },+        "exitCode": exit_code, "stepWritten": step_ok, "command": command, "layers": LAYER_FLAGS,+        "diagnostics": list, "geometryWarnings": count("geometry"), "modelWarnings": count("model"), "otherWarnings": count("other"),+        "ack": Value::Null,+        "note": "exit status, file presence and diagnostics are separate facts: exit 0 with geometry warnings still needs a completeness review of the STEP",+    })+}++/// Why the twin may not be delivered yet, if it may not.+pub fn open_issue(rec: &Value) -> Option<String> {+    if rec.is_null() { return None; }+    if rec["exitCode"].as_i64().map(|c| c != 0).unwrap_or(false) || rec["stepWritten"] == false {+        return Some(format!("the native STEP export failed (exit {}, file written {})", rec["exitCode"], rec["stepWritten"]));+    }+    let g = rec["geometryWarnings"].as_u64().unwrap_or(0);+    if g == 0 { return None; }+    let acked = rec["ack"]["stepSha256"].as_str().is_some() && rec["ack"]["stepSha256"] == rec["stepSha256"];+    if acked { return None; }+    Some(format!("{g} STEP geometry warning(s) not reviewed ({}): inspect the exported STEP at those locations, then `step-export --ack --why \"...\"`", rec["diagnostics"].as_array().map(|a| a.iter().filter(|d| d["kind"] == "geometry").take(3).map(|d| format!("{} near {}", d["message"].as_str().unwrap_or(""), d["nearbyFootprints"].as_array().map(|n| n.iter().filter_map(|x| x["ref"].as_str()).collect::<Vec<_>>().join("/")).unwrap_or_default())).collect::<Vec<_>>().join("; ")).unwrap_or_default()))+}++/// Run the native export into `out` and record it.+pub fn run(board_path: &str, out: &Path, cli: &str) -> Value {+    let _ = std::fs::remove_file(out);+    let mut args: Vec<String> = vec!["pcb".into(), "export".into(), "step".into()];+    args.extend(LAYER_FLAGS.iter().map(|s| s.to_string()));+    args.extend(["--output".to_string(), out.display().to_string(), board_path.to_string()]);+    let command = format!("{cli} {}", args.join(" "));+    match std::process::Command::new(cli).args(&args).output() {+        Ok(o) => {+            let text = format!("{}\n{}", String::from_utf8_lossy(&o.stdout), String::from_utf8_lossy(&o.stderr));+            let mut rec = record(board_path, Some(out), o.status.code(), &text, &command);+            rec["outputTail"] = json!(text.chars().rev().take(4000).collect::<String>().chars().rev().collect::<String>());+            rec+        }+        Err(e) => { let mut rec = record(board_path, Some(out), None, "", &command); rec["error"] = json!(format!("{cli} is not runnable: {e}")); rec }+    }+}++#[cfg(test)]+mod tests {+    use super::*;++    /// The Board32 output from the issue's reply (abridged): exit 0, file written, six geometry warnings.+    const BOARD32: &str = "Wire self-interference check failed\r\nz: 1.585; bounding box: x0: 130.149928; y0: 86.550577; x1: 130.27; y1: 87.450463\r\nWire self-interference check failed\r\nz: 1.585; bounding box: x0: 122.877967; y0: 85.800577; x1: 124.52; y1: 86.92\r\nCould not add 3D model to U9.\r\nSTEP file 'C:/x/board32-mechanical.step' created.\r\n\r\nExport time 17.855 s\r\n";++    #[test]+    fn warnings_are_classified_with_their_locations_apart_from_the_exit_status() {+        let d = classify(BOARD32);+        assert_eq!(d.len(), 3, "{d:?}");+        assert_eq!(d[0].kind, "geometry");+        assert_eq!(d[0].location, Some([1.585, 130.149928, 86.550577, 130.27, 87.450463]));+        assert_eq!(d[2].kind, "model");+        assert!(classify("STEP file 'a.step' created.\nExport time 1 s\n").is_empty());+    }++    #[test]+    fn geometry_warnings_need_an_ack_bound_to_the_step_file() {+        let dir = std::env::temp_dir().join(format!("aiflow-step-{}", std::process::id()));+        std::fs::create_dir_all(&dir).unwrap();+        let board = dir.join("b.kicad_pcb");+        std::fs::write(&board, "(kicad_pcb (version 20240108) (generator \"t\") (layers (0 \"F.Cu\" signal) (31 \"B.Cu\" signal) (44 \"Edge.Cuts\" user))\n (footprint \"T:U\" (layer \"F.Cu\") (at 129.3 87) (property \"Reference\" \"U3\"))\n (gr_rect (start 100 60) (end 150 100) (layer \"Edge.Cuts\")))").unwrap();+        let step = dir.join("b.step");+        std::fs::write(&step, "ISO-10303-21;").unwrap();+        let mut rec = record(board.to_str().unwrap(), Some(&step), Some(0), BOARD32, "kicad-cli pcb export step");+        assert_eq!(rec["geometryWarnings"], 2);+        assert_eq!(rec["diagnostics"][0]["nearbyFootprints"][0]["ref"], "U3");+        let open = open_issue(&rec).unwrap();+        assert!(open.contains("2 STEP geometry warning") && open.contains("U3"), "{open}");+        // an ack for another STEP does not count; one for this STEP does+        rec["ack"] = json!({"why": "looked", "stepSha256": "0000"});+        assert!(open_issue(&rec).is_some());+        rec["ack"] = json!({"why": "silkscreen faces present in the viewer at all six spots", "stepSha256": rec["stepSha256"].clone()});+        assert!(open_issue(&rec).is_none());+        // a failed export is never acked away+        let failed = record(board.to_str().unwrap(), Some(&dir.join("none.step")), Some(1), "", "x");+        assert!(open_issue(&failed).unwrap().contains("failed"));+        let _ = std::fs::remove_dir_all(&dir);+    }++    #[cfg(unix)]+    #[test]+    fn run_keeps_the_full_layer_set_and_reads_both_streams() {+        use std::os::unix::fs::PermissionsExt;+        let dir = std::env::temp_dir().join(format!("aiflow-step-run-{}", std::process::id()));+        std::fs::create_dir_all(&dir).unwrap();+        let board = dir.join("b.kicad_pcb");+        std::fs::write(&board, "(kicad_pcb (version 20240108) (generator \"t\") (layers (0 \"F.Cu\" signal)))").unwrap();+        let cli = dir.join("kicad-cli");+        std::fs::write(&cli, "#!/bin/sh\nout=\"\"; prev=\"\"; for a in \"$@\"; do [ \"$prev\" = \"--output\" ] && out=\"$a\"; prev=\"$a\"; done\necho \"$@\" > \"$out.args\"\necho 'Wire self-interference check failed'\necho 'z: 1.585; bounding box: x0: 1; y0: 2; x1: 3; y1: 4' >&2\necho STEP > \"$out\"\n").unwrap();+        std::fs::set_permissions(&cli, std::fs::Permissions::from_mode(0o755)).unwrap();+        let out = dir.join("b.step");+        let rec = run(board.to_str().unwrap(), &out, cli.to_str().unwrap());+        assert_eq!(rec["exitCode"], 0);+        assert_eq!(rec["stepWritten"], true);+        assert_eq!(rec["geometryWarnings"], 1);+        let args = std::fs::read_to_string(dir.join("b.step.args")).unwrap();+        for f in LAYER_FLAGS { assert!(args.contains(f), "{args}"); }+        let _ = std::fs::remove_dir_all(&dir);+    }+}

@@ -0,0 +1,124 @@+//! Honest stage messages (issue #39, item 12). A stage that passes says exactly what was verified,+//! item by item, and never implies the board can go to the fab without a human looking at it.+//! Electrical parity plus DRC is not manufacturing readiness: courtyards, body clearance and the+//! pours in the saved board and in the Gerbers are separate facts, each yes, no or not known.++use serde_json::{json, Map, Value};++#[derive(Debug, Clone, PartialEq)]+pub enum State { Yes, No(String), Unknown(String) }++#[derive(Debug, Clone)]+pub struct Item { pub name: &'static str, pub state: State }++fn yes_no(pass: Option<bool>, no: &str, unknown: &str) -> State {+    match pass { Some(true) => State::Yes, Some(false) => State::No(no.into()), None => State::Unknown(unknown.into()) }+}++/// What the run has verified so far. `mech` (courtyards ok, bodies ok) and `saved_fills` are+/// computed by the caller on the board in hand; the rest comes from the run's recorded outcomes.+pub fn from_run(outcomes: &Map<String, Value>, data: &Value, mech: Option<(bool, bool)>, saved_fills: Option<bool>) -> Vec<Item> {+    let gate = outcomes.get("gate");+    let netlist = outcomes.get("netlist");+    let parity = match (data["schematic"].as_str(), netlist) {+        (_, Some(n)) => yes_no(n["ok"].as_bool(), "the board differs from the schematic", "not recorded"),+        (Some(_), None) => State::Unknown("netlist check not run".into()),+        (None, None) => State::Unknown("no schematic in the run".into()),+    };+    let connectivity = gate.map(|g| yes_no(g["unconnected"].as_u64().map(|u| u == 0), "unconnected items remain", "not recorded")).unwrap_or(State::Unknown("gate not run".into()));+    let erc_rec = outcomes.get("erc").map(|e| e["pass"].as_bool().or(e["ok"].as_bool()))+        .or_else(|| outcomes.get("schematic").filter(|s| s["ercErrors"].is_array()).map(|s| Some(s["ercErrors"].as_array().map(|a| a.is_empty()).unwrap_or(false))))+        .or_else(|| data["evidence"].as_array().and_then(|a| a.iter().rev().find(|e| e["kind"] == "erc")).map(|e| e["pass"].as_bool()));+    let erc = match erc_rec { Some(p) => yes_no(p, "ERC failed", "ERC result states no pass"), None => State::Unknown("no ERC result recorded in the run".into()) };+    let drc = gate.map(|g| yes_no(g["newErrors"].as_u64().map(|n| n == 0), "DRC errors remain", "not recorded")).unwrap_or(State::Unknown("gate not run".into()));+    let gerbers = outcomes.get("export").map(|e| yes_no(e["fillsGerbers"]["pass"].as_bool(), "a poured layer has no Gerber regions", "export predates this check; run export again")).unwrap_or(State::Unknown("not exported yet (run export)".into()));+    vec![+        Item { name: "schematic parity", state: parity },+        Item { name: "connectivity", state: connectivity },+        Item { name: "ERC", state: erc },+        Item { name: "DRC", state: drc },+        Item { name: "schematic symbols and pin types", state: match (outcomes.get(crate::schematic_symbols::OUTCOME), data["schematic"].as_str()) {+            (Some(c), _) => yes_no(c["ok"].as_bool(), "symbol polarity or pin-type errors (schematic-check.json)", "not recorded"),+            (None, Some(_)) => State::Unknown("schematic check not run".into()),+            (None, None) => State::Unknown("no schematic in the run".into()),+        } },+        Item { name: "courtyards", state: mech.map(|m| yes_no(Some(m.0), "missing or overlapping courtyards", "")).unwrap_or(State::Unknown("not checked".into())) },+        Item { name: "body overlap", state: mech.map(|m| yes_no(Some(m.1), "part bodies overlap", "")).unwrap_or(State::Unknown("not checked".into())) },+        Item { name: "fills in saved board", state: yes_no(saved_fills, "a zone has no filled polygons", "not checked") },+        Item { name: "fills in Gerbers", state: gerbers },+    ]+}++pub fn all_passed(items: &[Item]) -> bool { items.iter().all(|i| i.state == State::Yes) }++/// One line: "verified: connectivity yes, ERC not known (...), ...".+pub fn line(items: &[Item]) -> String {+    let parts: Vec<String> = items.iter().map(|i| match &i.state {+        State::Yes => format!("{} yes", i.name),+        State::No(w) => format!("{} NO ({w})", i.name),+        State::Unknown(w) => format!("{} not known ({w})", i.name),+    }).collect();+    format!("verified: {}", parts.join(", "))+}++/// The verdict that follows the line: never a fabrication sign-off.+pub fn verdict(items: &[Item]) -> String {+    if all_passed(items) {+        "Every listed check passed. This is not a fabrication sign-off: a human review of the board, the BOM and the fab files is still advised before ordering.".into()+    } else {+        let open: Vec<&str> = items.iter().filter(|i| i.state != State::Yes).map(|i| i.name).collect();+        format!("Not cleared for fabrication: {} not verified. Do not tell the human the board is ready to fabricate.", open.join(", "))+    }+}++pub fn to_json(items: &[Item]) -> Value {+    let mut m = Map::new();+    for i in items {+        m.insert(i.name.to_string(), match &i.state { State::Yes => json!("yes"), State::No(w) => json!({"state": "no", "why": w}), State::Unknown(w) => json!({"state": "not known", "why": w}) });+    }+    json!({"items": m, "allPassed": all_passed(items), "verdict": verdict(items)})+}++/// The board-side facts a stage computes on the board in hand: courtyards and bodies, and the+/// pours in the saved file.+pub struct BoardFacts { pub mech: crate::mechanical::Report, pub fills: Value, pub fill_problems: Vec<String> }++pub fn board_facts(b: &aiflow_board::Board, board_path: &str, project_dir: &std::path::Path, spec: &Value) -> BoardFacts {+    let mech = crate::mechanical::check_board(b, board_path, project_dir, spec);+    let (fills, fill_problems, _) = crate::fills::saved(b);+    BoardFacts { mech, fills, fill_problems }+}++/// The verified list for a run, with the board facts when the caller has them.+pub fn run_items(r: &aiflow_run::Run, facts: Option<&BoardFacts>) -> Vec<Item> {+    from_run(r.outcomes(), &r.data, facts.map(|f| (f.mech.courtyards_ok(), f.mech.bodies_ok())), facts.map(|f| f.fill_problems.is_empty()))+}++/// "verified: ..." and the verdict, as one message tail.+pub fn message(items: &[Item]) -> String { format!("{}\n{}", line(items), verdict(items)) }++#[cfg(test)]+mod tests {+    use super::*;++    #[test]+    fn unknowns_are_said_and_no_fab_claim_is_made() {+        let o: Map<String, Value> = serde_json::from_value(json!({"gate": {"newErrors": 0, "unconnected": 0}, "netlist": {"ok": true}})).unwrap();+        let items = from_run(&o, &json!({"schematic": "a.kicad_sch"}), Some((true, false)), Some(true));+        let l = line(&items);+        assert!(l.contains("connectivity yes") && l.contains("DRC yes") && l.contains("courtyards yes"), "{l}");+        assert!(l.contains("ERC not known") && l.contains("body overlap NO") && l.contains("fills in Gerbers not known (not exported yet"), "{l}");+        let v = verdict(&items);+        assert!(v.starts_with("Not cleared for fabrication") && v.contains("ERC") && v.contains("body overlap"), "{v}");+    }++    #[test]+    fn all_passed_still_advises_human_review() {+        let o: Map<String, Value> = serde_json::from_value(json!({"gate": {"newErrors": 0, "unconnected": 0}, "netlist": {"ok": true}, "schematic": {"pass": true, "ercErrors": []}, "schematic-check": {"ok": true}, "export": {"fillsGerbers": {"pass": true}}})).unwrap();+        let items = from_run(&o, &json!({"schematic": "a.kicad_sch"}), Some((true, true)), Some(true));+        assert!(all_passed(&items));+        let v = verdict(&items);+        assert!(v.contains("not a fabrication sign-off") && v.contains("human review"), "{v}");+        assert!(!v.to_lowercase().contains("ready to fabricate"));+    }+}

@@ -0,0 +1,307 @@+//! Board-bottom heat sinks (issue #67): a pedestal or plate pressed against one face of the board+//! (usually B.Cu through a gap pad) that cools tabless parts (QFN/SON exposed pads) through their+//! thermal vias. `packageCooling` models a sink on the part's case; this models a sink on the board.+//!+//! spec.boardSink: [{name, region: [[x,y],...] | "outline", layer: "B.Cu" | "F.Cu",+//!   kPerW (sink to ambient) | hWm2K (sink area = region area), interfaceKPerW? (gap pad over the+//!   whole region), maskOpen?, parts: [REF...], note, fieldsHeatsink?}]+//!+//! Two ways to credit it, both recorded as assumptions in the analysis and the finish summary:+//!+//! 1. A conservative series estimate in `analyze thermal` for each named part whose heat path+//!    reaches the region: only tab-net vias within `VIA_REACH_MM` of the part's tab-net pads whose+//!    centres lie inside the region count. Each via: plated barrel (k 385 W/mK, 25 um wall, board+//!    thickness) plus a lateral copper strip from the pad edge to the via. Then solder mask (unless+//!    `maskOpen`) and the interface on a contact patch (the vias' box grown 1 mm when the tab net+//!    has copper on the sink face, else the via lands alone); the interface's K/W is spread over the+//!    region area, so a small patch pays proportionally more. Then the sink's own K/W, heated by the+//!    full power of every part declared on it. No board-copper spreading or air credit on this path;+//!    the part passes when this path or the ordinary copper path alone meets its limit.+//! 2. The same-input Adom Fields solve with a conducting block (spec.heatsinks, Fields 0.4+) named by+//!    `fieldsHeatsink`. When the field screen passes (every chip within its budget with the block in+//!    place) and the block carries heat, the named parts' heuristic failures are replaced by the+//!    solve's result, with the block's assumptions recorded.+//!+//! Parts not named on a declared sink keep the still-air copper check unchanged.++use aiflow_board::geom::{point_in_poly, point_poly_distance, polygon_area, Pt};+use aiflow_board::Board;+use serde_json::{json, Value};++/// Tab-net vias farther than this from the part's tab-net pad copper are not on its heat path here.+pub const VIA_REACH_MM: f64 = 1.0;+const K_CU_W_PER_MM_K: f64 = 0.385;+/// Solder mask between the copper and the interface: about 20 um of LPI at 0.25 W/mK.+pub const MASK_KMM2_PER_W: f64 = 80.0;+/// How far the contact patch grows past the vias when the tab net has copper on the sink face.+const PATCH_GROW_MM: f64 = 1.0;++fn num(v: &Value) -> Option<f64> { v.as_f64().filter(|x| x.is_finite()) }++fn region_of(s: &Value, b: Option<&Board>) -> Result<Vec<Pt>, String> {+    if s["region"] == "outline" {+        return b.map(|b| b.outline.clone()).filter(|o| o.len() >= 3).ok_or_else(|| "region \"outline\" needs the board outline".into());+    }+    let pts: Option<Vec<Pt>> = s["region"].as_array().map(|a| a.iter().map(|p| Some((num(&p[0])?, num(&p[1])?))).collect()).unwrap_or(None);+    match pts { Some(p) if p.len() >= 3 && polygon_area(&p).abs() > 1e-6 => Ok(p), _ => Err("region must be \"outline\" or a polygon of at least three [x, y] points (board mm)".into()) }+}++/// Validate spec.boardSink. Returns the entries (empty when absent).+pub fn validate(spec: &Value) -> Result<Vec<Value>, String> {+    let Some(v) = spec.get("boardSink") else { return Ok(Vec::new()) };+    let list = v.as_array().ok_or("boardSink must be a list")?;+    let mut names = Vec::new();+    let mut seen_parts: Vec<String> = Vec::new();+    for s in list {+        let name = s["name"].as_str().filter(|n| !n.trim().is_empty()).ok_or("each boardSink needs a name")?;+        if names.contains(&name) { return Err(format!("boardSink {name} is declared twice")); }+        names.push(name);+        if !matches!(s["layer"].as_str(), Some("F.Cu") | Some("B.Cu")) { return Err(format!("boardSink {name}: layer must be F.Cu or B.Cu (the board face the sink presses on)")); }+        if s["region"] != "outline" { region_of(s, None).map_err(|e| format!("boardSink {name}: {e}"))?; }+        let k = s.get("kPerW").map(|x| num(x).filter(|x| *x > 0.0).ok_or(format!("boardSink {name}: kPerW must be finite and positive")));+        let h = s.get("hWm2K").map(|x| num(x).filter(|x| *x > 0.0).ok_or(format!("boardSink {name}: hWm2K must be finite and positive")));+        match (k, h) {+            (Some(k), None) => { k?; }+            (None, Some(h)) => { h?; }+            _ => return Err(format!("boardSink {name}: give exactly one of kPerW (sink to ambient) or hWm2K (with the region as the sink area)")),+        }+        if let Some(i) = s.get("interfaceKPerW") { num(i).filter(|x| *x >= 0.0).ok_or(format!("boardSink {name}: interfaceKPerW must be finite and not negative"))?; }+        if s["note"].as_str().map(|n| n.trim().len() < 8).unwrap_or(true) { return Err(format!("boardSink {name}: note must say what the sink is (part, gap pad, mounting) and where its numbers come from")); }+        let parts = s["parts"].as_array().filter(|p| !p.is_empty()).ok_or(format!("boardSink {name}: parts must name the hot parts it cools"))?;+        for p in parts {+            let r = p.as_str().ok_or(format!("boardSink {name}: parts are references"))?;+            if spec["hot"].get(r).is_none() { return Err(format!("boardSink {name}: {r} is not in spec.hot")); }+            if super::package_cooling::definition(spec, r).is_some() { return Err(format!("boardSink {name}: {r} already has a packageCooling path; declare one cooling model per part")); }+            if seen_parts.iter().any(|x| x == r) { return Err(format!("boardSink: {r} is named on two sinks")); }+            seen_parts.push(r.to_string());+        }+        if let Some(f) = s.get("fieldsHeatsink") { f.as_str().filter(|x| !x.is_empty()).ok_or(format!("boardSink {name}: fieldsHeatsink names a spec.heatsinks block"))?; }+    }+    Ok(list.clone())+}++fn sink_of<'a>(sinks: &'a [Value], reference: &str) -> Option<&'a Value> {+    sinks.iter().find(|s| s["parts"].as_array().is_some_and(|p| p.iter().any(|x| x.as_str() == Some(reference))))+}++/// Apply the conservative series estimate to the heuristic rows (analyze thermal on the board).+pub fn apply(results: &mut [Value], spec: &Value, board: &Board, zone_state: Option<&Value>) -> Result<(), String> {+    let sinks = validate(spec)?;+    if sinks.is_empty() { return Ok(()); }+    let thick = num(&spec["boardThicknessMm"]).or(num(&spec["branchCurrentModel"]["boardThicknessMm"])).unwrap_or(1.6);+    let plating = num(&spec["branchCurrentModel"]["barrelPlatingUm"]).unwrap_or(25.0) / 1000.0;+    let t_cu = num(&spec["copperUm"]).unwrap_or(35.0) / 1000.0;+    let pours = super::pours_by_net(zone_state);+    let vias = board.vias();+    for row in results.iter_mut() {+        let reference = row["ref"].as_str().unwrap_or("").to_string();+        let Some(s) = sink_of(&sinks, &reference) else { continue };+        let name = s["name"].as_str().unwrap_or("");+        let layer = s["layer"].as_str().unwrap_or("B.Cu");+        let region = region_of(s, Some(board)).map_err(|e| format!("boardSink {name}: {e}"))?;+        let region_area = polygon_area(&region).abs();+        let net = spec["hot"][&reference]["tabNet"].as_str().unwrap_or("").to_string();+        let watts = num(&spec["hot"][&reference]["watts"]).unwrap_or(0.0);+        let sink_watts: f64 = s["parts"].as_array().into_iter().flatten().filter_map(|p| p.as_str()).map(|p| num(&spec["hot"][p]["watts"]).unwrap_or(0.0)).sum();+        let pads: Vec<_> = board.pads.iter().filter(|p| p.reference == reference && p.net == net).collect();+        let dist = |x: f64, y: f64| pads.iter().flat_map(|p| p.polys.iter()).filter(|poly| poly.len() >= 3).map(|poly| point_poly_distance(x, y, poly)).fold(f64::INFINITY, f64::min);+        let on_path: Vec<(f64, f64, f64, f64)> = vias.iter().filter(|v| v.net == net && point_in_poly(v.x, v.y, &region))+            .map(|v| (v.x, v.y, v.size, v.drill)).filter(|v| dist(v.0, v.1) <= VIA_REACH_MM).collect();+        let note = s["note"].as_str().unwrap_or("");+        if on_path.is_empty() {+            row["boardSink"] = json!({"name": name, "used": false, "assumption": format!("{name} ({note}): no {net} via within {VIA_REACH_MM} mm of {reference}'s {net} pads lands inside the sink region, so the estimate gives it no sink credit")});+            if row["status"] != "pass" { row["hint"] = json!(format!("{}; board sink {name}: no {net} via within {VIA_REACH_MM} mm of {reference}'s tab lands in its region (add thermal vias in the pad over the sink, or a Fields solve with fieldsHeatsink)", row["hint"].as_str().unwrap_or(""))); }+            continue;+        }+        let r_vias = 1.0 / on_path.iter().map(|v| {+            let barrel = thick / (K_CU_W_PER_MM_K * std::f64::consts::PI * plating * (v.3 + plating));+            let lateral = dist(v.0, v.1) / (K_CU_W_PER_MM_K * t_cu * std::f64::consts::PI * v.2);+            1.0 / (barrel + lateral)+        }).sum::<f64>();+        let face_copper = pours.get(&net).map(|z| super::layers_of(z).iter().any(|l| l == layer)).unwrap_or(false);+        let patch = if face_copper {+            let (mut x0, mut y0, mut x1, mut y1) = (f64::INFINITY, f64::INFINITY, f64::NEG_INFINITY, f64::NEG_INFINITY);+            for v in &on_path { x0 = x0.min(v.0 - v.2 / 2.0); y0 = y0.min(v.1 - v.2 / 2.0); x1 = x1.max(v.0 + v.2 / 2.0); y1 = y1.max(v.1 + v.2 / 2.0); }+            (x1 - x0 + 2.0 * PATCH_GROW_MM) * (y1 - y0 + 2.0 * PATCH_GROW_MM)+        } else { on_path.iter().map(|v| std::f64::consts::PI * (v.2 / 2.0).powi(2)).sum() };+        let patch = patch.min(region_area);+        let r_mask = if s["maskOpen"] == true { 0.0 } else { MASK_KMM2_PER_W / patch };+        let r_if = num(&s["interfaceKPerW"]).unwrap_or(0.0) * region_area / patch;+        let r_sink = num(&s["kPerW"]).unwrap_or_else(|| 1e6 / (num(&s["hWm2K"]).unwrap_or(1.0) * region_area));+        let rise = watts * (r_vias + r_mask + r_if) + r_sink * sink_watts;+        let theta = if watts > 0.0 { rise / watts } else { 0.0 };+        let theta_limit = num(&row["limitCPerW"]);+        let rise_limit = num(&row["riseLimitC"]);+        let limit = theta_limit.unwrap_or(if rise_limit.is_some() { f64::INFINITY } else { 60.0 });+        let sink_pass = theta <= limit && rise_limit.map(|l| rise <= l).unwrap_or(true);+        let r1 = |x: f64| (x * 10.0).round() / 10.0;+        let assumption = format!("{name} on {layer} ({note}): heat leaves {reference} only through its {} {net} via(s) inside the sink region (plated barrel {:.0} um, {thick} mm board, lateral copper from the pad edge), {} and {} on a {:.1} mm2 patch, into a sink of {:.2} K/W carrying all {:.2} W of its parts; no board-spreading or air credit on this path",+            on_path.len(), plating * 1000.0, if s["maskOpen"] == true { "no solder mask (maskOpen)".to_string() } else { format!("solder mask at {MASK_KMM2_PER_W} K mm2/W") },+            match num(&s["interfaceKPerW"]) { Some(i) => format!("the interface at {i} K/W over the {:.0} mm2 region", region_area), None => "no interface resistance declared (direct contact assumed)".to_string() }, patch, r_sink, sink_watts);+        row["boardSink"] = json!({"name": name, "layer": layer, "used": sink_pass, "viasOnPath": on_path.len(), "patchMm2": r1(patch), "rViasKPerW": r1(r_vias), "rMaskKPerW": r1(r_mask), "rInterfaceKPerW": r1(r_if), "rSinkKPerW": (r_sink * 100.0).round() / 100.0, "sinkWatts": sink_watts, "riseEstimateC": r1(rise), "thetaEstimateCPerW": r1(theta), "assumption": assumption});+        if row["status"] == "pass" { continue; }+        if sink_pass {+            row["status"] = json!("pass");+            row["how"] = json!(format!("board sink {name}: about {:.0} C/W, {:.0} C at {watts:.2} W through {} vias into the {layer} sink (still-air copper path alone: {} C/W)", theta, rise, on_path.len(), row["thetaEstimateCPerW"]));+            if let Some(o) = row.as_object_mut() { o.remove("hint"); }+        } else {+            row["hint"] = json!(format!("{}; board sink {name}: about {:.0} C/W ({:.0} C) through {} vias (vias {:.0}, mask {:.0}, interface {:.0}, sink {:.1} K/W): more vias in the pad over the sink, or a Fields solve with fieldsHeatsink", row["hint"].as_str().unwrap_or(""), theta, rise, on_path.len(), r_vias, r_mask, r_if, r_sink));+        }+    }+    Ok(())+}++/// Accept the same-input Fields solve with the named conducting block for the sink's parts whose+/// estimate failed. Call only after the field screen passed on this board and spec. Returns notes.+pub fn accept_solve(results: &mut [Value], spec: &Value, fields: &Value) -> Vec<String> {+    let Ok(sinks) = validate(spec) else { return Vec::new() };+    let mut notes = Vec::new();+    for row in results.iter_mut() {+        if row["status"] == "pass" { continue; }+        let reference = row["ref"].as_str().unwrap_or("").to_string();+        let Some(s) = sink_of(&sinks, &reference) else { continue };+        let Some(block_name) = s["fieldsHeatsink"].as_str() else { continue };+        let name = s["name"].as_str().unwrap_or("");+        let block = fields["heatsinks"].as_array().into_iter().flatten().find(|h| h["definition"]["name"].as_str() == Some(block_name));+        let chip = fields["chips"].as_array().into_iter().flatten().find(|c| c["reference"].as_str() == Some(reference.as_str()));+        let why_not = match (block, chip) {+            (None, _) => Some(format!("the Fields report has no heatsink block {block_name}")),+            (_, None) => Some(format!("the Fields report has no chip {reference}")),+            (Some(b), Some(_)) => {+                let d = &b["definition"];+                let bounds: Option<Vec<f64>> = d["boundsMm"].as_array().map(|a| a.iter().filter_map(num).collect());+                let inside = match (region_of(s, None).ok(), bounds) {+                    (Some(reg), Some(bb)) if bb.len() == 4 => {+                        let (x0, y0, x1, y1) = aiflow_board::geom::bbox(&reg);+                        bb[0] >= x0 - 0.05 && bb[1] >= y0 - 0.05 && bb[2] <= x1 + 0.05 && bb[3] <= y1 + 0.05+                    }+                    (None, Some(bb)) if bb.len() == 4 => s["region"] == "outline",+                    _ => false,+                };+                if d["layer"].as_str() != s["layer"].as_str() { Some(format!("block {block_name} is on {}, the sink on {}", d["layer"], s["layer"])) }+                else if !inside { Some(format!("block {block_name} lies outside the {name} region")) }+                else if !num(&b["contactW"]).is_some_and(|w| w > 0.0) || !num(&b["contactMovingW"]).is_some_and(|w| w > 0.0) { Some(format!("block {block_name} carries no heat in the solve")) }+                else { None }+            }+        };+        if let Some(w) = why_not { notes.push(format!("{reference}: Fields evidence for board sink {name} not accepted: {w}")); continue; }+        let (b, c) = (block.unwrap(), chip.unwrap());+        let d = &b["definition"];+        let assumption = format!("{reference} on board sink {name} ({}) is judged by the same-input Adom Fields solve with conducting block {block_name}: {} mm thick, {} W/mK, contact {} K mm2/W on {}, losing heat to still or moving air on its exposed faces; the sink's declared K/W is not part of that solve. Fields: {} C still, {} C moving at {} W; block takes {} W still",+            s["note"].as_str().unwrap_or(""), d["thicknessMm"], d["conductivityWPerMK"], d["contactResistanceMm2KPerW"], d["layer"].as_str().unwrap_or(""), c["riseC"], c["riseMovingC"], c["watts"], b["contactW"]);+        row["status"] = json!("pass");+        row["how"] = json!(format!("board sink {name}: the same-input Fields solve with block {block_name} keeps {reference} at {} C (still) / {} C (moving); the copper-path estimate alone did not", c["riseC"], c["riseMovingC"]));+        row["boardSink"]["evidence"] = json!({"kind": "fields-heatsink", "block": block_name, "riseC": c["riseC"], "riseMovingC": c["riseMovingC"], "contactW": b["contactW"]});+        row["boardSink"]["used"] = json!(true);+        row["boardSink"]["assumption"] = json!(assumption);+        if let Some(o) = row.as_object_mut() { o.remove("hint"); }+        notes.push(format!("{reference}: accepted on the Fields solve with block {block_name}"));+    }+    notes+}++/// The recorded assumptions of every sink that carried a part, for the run summary and finish.+pub fn assumptions(results: &[Value]) -> Vec<String> {+    results.iter().filter(|r| r["boardSink"]["used"] == true).filter_map(|r| r["boardSink"]["assumption"].as_str().map(str::to_string)).collect()+}++#[cfg(test)]+mod tests {+    use super::*;+    // a 4 mm QFN exposed pad on GND at (20, 15), five in-pad vias, B.Cu poured; a sink under it+    fn board(vias: &[(f64, f64)]) -> Board {+        let mut t = String::from(r#"(kicad_pcb (version 20241229) (generator "pcbnew") (net 0 "") (net 1 "GND")+ (gr_rect (start 0 0) (end 40 30) (layer "Edge.Cuts"))+ (footprint "QFN-24" (layer "F.Cu") (at 20 15) (property "Reference" "U1")+  (pad "25" smd rect (at 0 0) (size 4 4) (layers "F.Cu") (net 1 "GND")))+ (footprint "QFN-24" (layer "F.Cu") (at 5 5) (property "Reference" "U2")+  (pad "25" smd rect (at 0 0) (size 3 3) (layers "F.Cu") (net 1 "GND")))+"#);+        for v in vias { t += &format!(" (via (at {} {}) (size 0.6) (drill 0.3) (layers \"F.Cu\" \"B.Cu\") (net 1))\n", v.0, v.1); }+        t += ")";+        Board::from_text("t.kicad_pcb", t).unwrap()+    }+    fn zs() -> Value { json!({"zones":[{"type":"copper","net":"GND","layers":["F.Cu"],"fills":[{"areaMm2":20.0}]},{"type":"copper","net":"GND","layers":["B.Cu"],"fills":[{"areaMm2":20.0}]}]}) }+    fn spec(sink: Value) -> Value {+        json!({"hot":{"U1":{"watts":1.5,"tabNet":"GND"},"U2":{"watts":1.5,"tabNet":"GND"}},"hotMaxRiseC":50,"boardSink":[sink]})+    }+    fn sink() -> Value { json!({"name":"pedestal","region":[[15,10],[25,10],[25,20],[15,20]],"layer":"B.Cu","kPerW":2.0,"interfaceKPerW":1.0,"parts":["U1"],"note":"Al pedestal, 1 mm gap pad 3 W/mK, datasheet values"}) }+    fn rows(b: &Board, sp: &Value) -> Vec<Value> {+        let plan = json!({"nets":[]});+        let (_, mut r) = super::super::analyze_thermal_on_board(&plan, sp, Some(&zs()), b);+        apply(&mut r, sp, b, Some(&zs())).unwrap();+        r+    }++    #[test]+    fn a_tabless_part_on_a_declared_sink_passes_through_its_vias() {+        let b = board(&[(19.0, 14.0), (21.0, 14.0), (20.0, 15.0), (19.0, 16.0), (21.0, 16.0), (19.0, 15.0), (21.0, 15.0), (20.0, 14.0), (20.0, 16.0)]);+        let sp = spec(sink());+        let r = rows(&b, &sp);+        let u1 = r.iter().find(|x| x["ref"] == "U1").unwrap();+        let u2 = r.iter().find(|x| x["ref"] == "U2").unwrap();+        assert_eq!(u1["status"], "pass", "{u1}");+        assert_eq!(u1["boardSink"]["viasOnPath"], 9);+        assert!(u1["boardSink"]["assumption"].as_str().unwrap().contains("no board-spreading"));+        // the part not on the sink keeps its still-air copper check: 40 mm2 of copper fails at 1.5 W+        assert_eq!(u2["status"], "fail", "{u2}");+        assert!(u2.get("boardSink").is_none());+        assert_eq!(assumptions(&r).len(), 1);+    }++    #[test]+    fn no_credit_without_vias_into_the_region_or_with_a_weak_sink() {+        // vias beside the part but outside the region+        let b = board(&[(19.0, 14.0), (21.0, 14.0)]);+        let mut s = sink(); s["region"] = json!([[30,25],[39,25],[39,29],[30,29]]);+        let r = rows(&b, &spec(s));+        let u1 = r.iter().find(|x| x["ref"] == "U1").unwrap();+        assert_eq!(u1["status"], "fail"); assert_eq!(u1["boardSink"]["used"], false);+        // a sink of 30 K/W cannot carry 1.5 W inside a 50 C budget+        let b = board(&[(19.0, 14.0), (21.0, 14.0), (20.0, 15.0)]);+        let mut s = sink(); s["kPerW"] = json!(30.0);+        let r = rows(&b, &spec(s));+        assert_eq!(r.iter().find(|x| x["ref"] == "U1").unwrap()["status"], "fail");+        // h and area instead of K/W: 10 W/m2K on 100 mm2 is 1000 K/W+        let mut s = sink(); s.as_object_mut().unwrap().remove("kPerW"); s["hWm2K"] = json!(10.0);+        let r = rows(&b, &spec(s));+        assert_eq!(r.iter().find(|x| x["ref"] == "U1").unwrap()["boardSink"]["rSinkKPerW"], 1000.0);+    }++    #[test]+    fn declarations_are_validated() {+        for (k, v) in [("layer", json!("In1.Cu")), ("kPerW", json!(-1)), ("parts", json!(["U9"])), ("note", json!("")), ("region", json!([[0,0],[1,1]]))] {+            let mut s = sink(); s[k] = v;+            assert!(validate(&spec(s)).is_err(), "{k}");+        }+        let mut both = sink(); both["hWm2K"] = json!(10.0);+        assert!(validate(&spec(both)).is_err());+        let mut sp = spec(sink()); sp["boardSink"].as_array_mut().unwrap().push({ let mut s = sink(); s["name"] = json!("other"); s });+        assert!(validate(&sp).unwrap_err().contains("two sinks"));+    }++    #[test]+    fn a_fields_solve_with_the_named_block_is_accepted_only_when_it_matches() {+        let b = board(&[(20.0, 15.0)]);+        let mut s = sink(); s["kPerW"] = json!(30.0); s["fieldsHeatsink"] = json!("pedestal-block");+        let sp = spec(s);+        let mut r = rows(&b, &sp);+        assert_eq!(r.iter().find(|x| x["ref"] == "U1").unwrap()["status"], "fail");+        let f = json!({"heatsinks":[{"definition":{"name":"pedestal-block","layer":"B.Cu","boundsMm":[16,11,24,19],"thicknessMm":5,"conductivityWPerMK":200,"contactResistanceMm2KPerW":300},"contactW":1.2,"contactMovingW":1.1}],+            "chips":[{"reference":"U1","watts":1.5,"riseC":31.0,"riseMovingC":22.0}]});+        let mut wrong = f.clone(); wrong["heatsinks"][0]["definition"]["layer"] = json!("F.Cu");+        let mut r2 = r.clone();+        accept_solve(&mut r2, &sp, &wrong);+        assert_eq!(r2.iter().find(|x| x["ref"] == "U1").unwrap()["status"], "fail");+        let mut outside = f.clone(); outside["heatsinks"][0]["definition"]["boundsMm"] = json!([0, 0, 8, 8]);+        let mut r3 = r.clone();+        assert!(accept_solve(&mut r3, &sp, &outside)[0].contains("outside"));+        accept_solve(&mut r, &sp, &f);+        let u1 = r.iter().find(|x| x["ref"] == "U1").unwrap();+        assert_eq!(u1["status"], "pass");+        assert_eq!(u1["boardSink"]["evidence"]["block"], "pedestal-block");+        assert!(assumptions(&r)[0].contains("declared K/W is not part of that solve"));+        // U2 is not on the sink: the solve does not touch its row+        assert_eq!(r.iter().find(|x| x["ref"] == "U2").unwrap()["status"], "fail");+    }+}

@@ -0,0 +1,187 @@+//! Reviewed acknowledgements of part-limited current-density peaks (issue #70).+//!+//! The Fields screen in `analyze current` refuses any net whose peak density is over the screen+//! (60 A/mm2 by default). Some peaks sit on a part's own land (a SOT-23 drain pad, a connector's+//! last millimetre) that the board cannot change. `analyze current --ack [email protected] --why ...` or+//! `--ack NET@x,y --why ...` records one reviewed point: the net, the place, the peak Fields+//! reported there, the reason and the ai thread. The number keeps being reported.+//!+//! An acknowledgement covers an over-screen point when all of these hold:+//! - same net (never a whole net: a location or a pad is required);+//! - the point lies inside the acknowledged pad's copper or within `TOLERANCE_MM` of it, or within+//!   `TOLERANCE_MM` of the acknowledged x,y;+//! - its density is not above the reviewed peak by more than `PEAK_SLACK` (1 percent);+//! - the board's copper fingerprint (the caller's: adom-aiflow passes copper_carry's, the same one+//!   that carries Fields evidence across a silkscreen-only adoption) and the Fields spec identity+//!   are the ones the review saw. Any copper or rules change, or any spec change, expires it.+//!+//! Fields reports one maximum per net. Once that point is acknowledged, a second over-screen spot on+//! the same net is not visible in the report; the reviewer checks the density map for it.++use aiflow_board::geom::{point_poly_distance, Pt};+use aiflow_board::Board;+use serde_json::{json, Value};++/// How far from the acknowledged pad copper or x,y an over-screen point may lie and still be+/// covered: a few Fields cells and a land's edge.+pub const TOLERANCE_MM: f64 = 0.5;+/// How much the density at an acknowledged point may exceed the reviewed peak (rounding, solver noise).+pub const PEAK_SLACK: f64 = 0.01;++/// An over-screen point Fields reported: a net's peak, or a current-neck finding.+#[derive(Debug, Clone)]+pub struct Point { pub net: String, pub at: Pt, pub layer: String, pub peak: f64 }++/// Every over-screen point in a Fields report: each loaded net whose peak is over `limit`, at its+/// peak location, and every `current-neck` finding with a location.+pub fn over_screen(fields: &Value, limit: f64) -> Vec<Point> {+    let mut out = Vec::new();+    for row in fields["nets"].as_array().into_iter().flatten() {+        let peak = row["peakJ"].as_f64().unwrap_or(0.0);+        if peak <= limit { continue; }+        if let (Some(net), Some(x), Some(y)) = (row["net"].as_str(), row["peakAt"][0].as_f64(), row["peakAt"][1].as_f64()) {+            out.push(Point { net: net.to_string(), at: (x, y), layer: row["peakLayer"].as_str().unwrap_or("").to_string(), peak });+        }+    }+    out+}++/// A parsed `--ack` target: [email protected] or NET@x,y. A bare NET (or NET@, NET@*) is refused.+pub enum Target { Pad { net: String, key: String }, At { net: String, at: Pt } }++pub fn parse_target(s: &str) -> Result<Target, String> {+    let blanket = || format!("--ack {s}: name the place, not the whole net: [email protected] (a pad of the part that limits it) or NET@x,y (board mm). A whole-net acknowledgement is never accepted");+    let Some(i) = s.rfind('@') else { return Err(blanket()) };+    let (net, loc) = (s[..i].trim(), s[i + 1..].trim());+    if net.is_empty() || loc.is_empty() || loc == "*" { return Err(blanket()); }+    let nums: Vec<&str> = loc.split(',').map(str::trim).collect();+    if nums.len() == 2 {+        if let (Ok(x), Ok(y)) = (nums[0].parse::<f64>(), nums[1].parse::<f64>()) {+            if x.is_finite() && y.is_finite() { return Ok(Target::At { net: net.into(), at: (x, y) }); }+        }+    }+    if !loc.contains('.') { return Err(format!("--ack {s}: the place is REF.PAD (for example U1.2) or x,y in board mm")); }+    Ok(Target::Pad { net: net.into(), key: loc.into() })+}++/// The region a stored acknowledgement covers, as polygons (a pad's copper) or one point.+fn region(a: &Value) -> (Vec<Vec<Pt>>, Option<Pt>) {+    let polys: Vec<Vec<Pt>> = a["padCopper"].as_array().into_iter().flatten()+        .map(|p| p.as_array().into_iter().flatten().filter_map(|q| Some((q[0].as_f64()?, q[1].as_f64()?))).collect()).collect();+    let at = match (a["location"][0].as_f64(), a["location"][1].as_f64()) { (Some(x), Some(y)) => Some((x, y)), _ => None };+    (polys, at)+}++fn near(a: &Value, p: Pt) -> bool {+    let (polys, at) = region(a);+    if !polys.is_empty() { return polys.iter().any(|poly| poly.len() >= 3 && point_poly_distance(p.0, p.1, poly) <= TOLERANCE_MM); }+    at.map(|q| (q.0 - p.0).hypot(q.1 - p.1) <= TOLERANCE_MM).unwrap_or(false)+}++/// Does this live acknowledgement cover the point?+pub fn covers(a: &Value, p: &Point) -> bool {+    a["net"].as_str() == Some(p.net.as_str())+        && a["peakJ"].as_f64().is_some_and(|v| p.peak <= v * (1.0 + PEAK_SLACK))+        && near(a, p.at)+}++/// Split stored acknowledgements into live and expired for this copper and spec identity.+pub fn split_live(acks: &Value, copper: &str, spec_identity: &str) -> (Vec<Value>, Vec<Value>) {+    let (mut live, mut expired) = (Vec::new(), Vec::new());+    for a in acks.as_array().into_iter().flatten() {+        if a["copperHash"].as_str() == Some(copper) && a["fieldsSpecIdentity"].as_str() == Some(spec_identity) { live.push(a.clone()); } else { expired.push(a.clone()); }+    }+    (live, expired)+}++/// Build one acknowledgement record from the current Fields report. Refuses when nothing over the+/// screen lies at that place (there is nothing to review), or when the pad is not on the net.+pub fn record(target: &str, why: &str, ai_thread: &str, fields: &Value, board: &Board, copper: &str, limit: f64, recorded_at: &str) -> Result<Value, String> {+    if why.trim().chars().count() < 12 { return Err("--why needs the review: what limits the peak (the part's land, a connector pin) and why the board cannot change it".into()); }+    let t = parse_target(target)?;+    let (net, pad_copper, location, pad_key) = match &t {+        Target::Pad { net, key } => {+            let pad = board.pad_by_key(key).ok_or_else(|| format!("--ack {target}: no pad {key} on the board"))?;+            if pad.net != *net { return Err(format!("--ack {target}: pad {key} is on net {}, not {net}", if pad.net.is_empty() { "(none)" } else { &pad.net })); }+            (net.clone(), pad.polys.clone(), None, Some(key.clone()))+        }+        Target::At { net, at } => (net.clone(), Vec::new(), Some(*at), None),+    };+    let mut a = json!({"net": net, "target": target, "pad": pad_key, "padCopper": pad_copper.iter().map(|p| p.iter().map(|q| json!([q.0, q.1])).collect::<Vec<_>>()).collect::<Vec<_>>(), "location": location.map(|p| json!([p.0, p.1])), "toleranceMm": TOLERANCE_MM});+    let pts = over_screen(fields, limit);+    let hit = pts.iter().find(|p| p.net == net && near(&a, p.at));+    let Some(p) = hit else {+        let on_net: Vec<String> = pts.iter().filter(|p| p.net == net).map(|p| format!("{:.1} A/mm2 at ({:.2}, {:.2}) on {}", p.peak, p.at.0, p.at.1, p.layer)).collect();+        return Err(if on_net.is_empty() { format!("--ack {target}: {net} has no point over the {limit} A/mm2 screen in this Fields report; nothing to acknowledge") } else { format!("--ack {target}: the over-screen point of {net} is not within {TOLERANCE_MM} mm of that place ({})", on_net.join("; ")) });+    };+    a["peakJ"] = json!(p.peak);+    a["peakAt"] = json!([p.at.0, p.at.1]);+    a["peakLayer"] = json!(p.layer);+    a["screenAperMm2"] = json!(limit);+    a["why"] = json!(why.trim());+    a["aiThread"] = json!(ai_thread);+    a["recordedAt"] = json!(recorded_at);+    a["copperHash"] = json!(copper);+    a["fieldsSpecIdentity"] = json!(fields["inputIdentity"]["spec"].as_str().unwrap_or(""));+    a["fieldsBoardIdentity"] = json!(fields["inputIdentity"]["board"].as_str().unwrap_or(""));+    Ok(a)+}++/// One line per acknowledgement, for analyze and finish.+pub fn describe(a: &Value, state: &str) -> String {+    format!("{} at {} ({:.1} A/mm2 at ({:.2}, {:.2}) {}, screen {} A/mm2), {state}: \"{}\" by {} {}",+        a["net"].as_str().unwrap_or("?"), a["pad"].as_str().map(str::to_string).unwrap_or_else(|| format!("({}, {})", a["location"][0], a["location"][1])),+        a["peakJ"].as_f64().unwrap_or(0.0), a["peakAt"][0].as_f64().unwrap_or(0.0), a["peakAt"][1].as_f64().unwrap_or(0.0), a["peakLayer"].as_str().unwrap_or(""),+        a["screenAperMm2"], a["why"].as_str().unwrap_or(""), a["aiThread"].as_str().unwrap_or("?"), a["recordedAt"].as_str().unwrap_or(""))+}++#[cfg(test)]+mod tests {+    use super::*;+    const PCB: &str = r#"(kicad_pcb (version 20241229) (generator "pcbnew") (net 0 "") (net 1 "VBUS") (net 2 "GND")+ (gr_rect (start 0 0) (end 30 20) (layer "Edge.Cuts"))+ (footprint "SOT-23" (layer "F.Cu") (at 10 10) (property "Reference" "Q1")+  (pad "3" smd rect (at 0 -1) (size 0.6 0.8) (layers "F.Cu") (net 1 "VBUS"))+  (pad "1" smd rect (at -1 1) (size 0.6 0.8) (layers "F.Cu") (net 2 "GND")))+ (segment (start 10 9) (end 20 9) (width 0.6) (layer "F.Cu") (net 1)))"#;+    fn board(text: &str) -> Board { Board::from_text("t.kicad_pcb", text.to_string()).unwrap() }+    fn fields(peak: f64, at: [f64; 2]) -> Value { json!({"inputIdentity": {"board": "b", "spec": "s"}, "nets": [{"net": "VBUS", "peakJ": peak, "peakAt": at, "peakLayer": "F.Cu"}]}) }++    #[test]+    fn whole_net_acknowledgements_are_refused() {+        for t in ["VBUS", "VBUS@", "VBUS@*", "@Q1.3"] { assert!(parse_target(t).is_err(), "{t}"); }+        assert!(matches!(parse_target("[email protected],9").unwrap(), Target::At { .. }));+        assert!(matches!(parse_target("[email protected]").unwrap(), Target::Pad { .. }));+    }++    #[test]+    fn a_pad_ack_records_the_peak_and_covers_only_its_land() {+        let b = board(PCB);+        let f = fields(67.0, [10.1, 9.1]);+        let a = record("[email protected]", "SOT-23 drain land is 0.6 mm wide; part limited", "astra", &f, &b, "cu", 60.0, "t").unwrap();+        assert_eq!(a["peakJ"], 67.0);+        assert_eq!(a["aiThread"], "astra");+        let p = |x: f64, y: f64, j: f64| Point { net: "VBUS".into(), at: (x, y), layer: "F.Cu".into(), peak: j };+        assert!(covers(&a, &p(10.1, 9.1, 67.0)));+        assert!(covers(&a, &p(10.0, 8.2, 67.0)), "within the tolerance of the land's edge");+        assert!(!covers(&a, &p(15.0, 9.0, 67.0)), "a spot along the track is not the land");+        assert!(!covers(&a, &p(10.1, 9.1, 70.0)), "a higher peak than the one reviewed");+        let mut other = p(10.1, 9.1, 67.0); other.net = "GND".into();+        assert!(!covers(&a, &other));+        // the wrong net's pad, a point with nothing over the screen, a missing reason+        assert!(record("[email protected]", "a reason long enough", "t", &f, &b, "cu", 60.0, "t").unwrap_err().contains("on net GND"));+        assert!(record("VBUS@20,15", "a reason long enough", "t", &f, &b, "cu", 60.0, "t").unwrap_err().contains("not within"));+        assert!(record("[email protected]", "a reason long enough", "t", &fields(50.0, [10.1, 9.1]), &b, "cu", 60.0, "t").unwrap_err().contains("nothing to acknowledge"));+        assert!(record("[email protected]", "ok", "t", &f, &b, "cu", 60.0, "t").is_err());+    }++    #[test]+    fn acknowledgements_expire_when_the_copper_fingerprint_or_the_fields_spec_changes() {+        let b = board(PCB);+        let a = record("[email protected],9.1", "connector shield tab limits the last mm", "t", &fields(67.0, [10.1, 9.1]), &b, "cu", 60.0, "t").unwrap();+        let acks = json!([a]);+        assert_eq!(split_live(&acks, "cu", "s").0.len(), 1);+        assert_eq!(split_live(&acks, "cu", "other spec").1.len(), 1);+        assert_eq!(split_live(&acks, "changed copper", "s").1.len(), 1);+    }+}