AI Flow

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

@@ -0,0 +1,167 @@+//! Steps that do not apply to a board (issue #84), recorded with their reason instead of faked.+//!+//! The fields step: a spec with no loads, no hot parts and no signal checks gives Adom Fields nothing+//! to solve ("the spec has no loads, hot parts or signal checks: nothing to solve"). `tour fields`+//! then records the step's proof (`tour-fields`) as not applicable, with that reason, the way+//! `thermal-vias` records 0 vias when spec.hot is empty. Never when the design is a switching+//! converter (converter.rs) or the spec names any load, hot part or signal check. finish lists it,+//! and refuses a stale record once the spec gains any of them.+//!+//! The pattern lane: a passive copper-pattern board (a reflector disc, a carrier plate): no parts, no+//! BOM, no schematic, no electrical load. `intake --kind pattern` (or requirements.json+//! `"boardKind": "pattern"`) selects the `pattern` sequence in flows/board.json: intake, rules,+//! models, outline, silkscreen, 3d, finish, export. finish keeps the native DRC (the live full DRC with+//! the fab's rules), the fab rules gate, the mechanical and silkscreen checks, the 3D model and the+//! export re-read, and reports every electrical step it does not run and why.+//!+//! The lane is refused (conservatively) for a board that needs routing: footprint pads on more than+//! one net, or on a net no zone (pour) carries, or tracks or vias on such a net. A spec with loads,+//! hot parts, signal checks or a converter is refused too. Footprints whose pads carry no net (a+//! mounting hole) or only the single pour net (machine pins on a GND plate) are allowed; a profile's+//! sourcing check still applies to any of them that go in the BOM.++use aiflow_board::Board;+use serde_json::Value;+use std::collections::BTreeSet;++pub const PATTERN: &str = "pattern";++/// The fields step's not-applicable reason.+pub const FIELDS_NA: &str = "no loads, hot parts or signal checks in the spec";++/// The electrical steps the pattern lane leaves out, each with its reason (finish reports them).+pub const PATTERN_NA: &[(&str, &str)] = &[+    ("design, sourcing, parts, project-page, library, schematic, simulation, components, libraries", "no parts, BOM or schematic: a passive copper pattern"),+    ("test-plan", "no circuit to probe"),+    ("placement", "no parts to place"),+    ("routing", "no net needs routing (pads, if any, only on a single pour net)"),+    ("thermal-vias", "no hot parts"),+    ("pours", "the copper is the pattern itself, not a planned pour"),+    ("current, thermal", "nothing carries current"),+    ("fields", FIELDS_NA),+    ("nets", "no nets to walk through"),+];++fn requirements(data: &Value) -> Value {+    data["intake"]["requirements"].as_str().or(data["requirements"].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)+}++/// The run is a pattern board: `intake --kind pattern`, or requirements.json "boardKind": "pattern".+pub fn is_pattern(data: &Value) -> bool {+    data["kind"] == PATTERN || requirements(data)["boardKind"] == PATTERN+}++fn nonempty(v: &Value) -> bool {+    match v { Value::Object(o) => !o.is_empty(), Value::Array(a) => !a.is_empty(), Value::Null => false, Value::Bool(b) => *b, _ => true }+}++/// Why the fields step applies to this spec (empty: it does not). `calcs` is the run's calcs evidence.+pub fn fields_applies(spec: &Value, calcs: Option<&Value>) -> Vec<String> {+    let mut why = Vec::new();+    if nonempty(&spec["loads"]) { why.push("spec.loads names loads".to_string()); }+    if nonempty(&spec["hot"]) { why.push("spec.hot names hot parts".to_string()); }+    if nonempty(&spec["signals"]) { why.push("spec.signals names signal checks".to_string()); }+    if let Some(c) = crate::converter::detect(spec, calcs) { why.push(format!("the design is a switching converter ({c})")); }+    why+}++/// Why this board cannot take the pattern lane (None: it can).+pub fn pattern_refusal(b: &Board) -> Option<String> {+    let zone_nets: BTreeSet<String> = b.zones().into_iter().map(|z| z.net).filter(|n| !n.trim().is_empty()).collect();+    let mut pad_nets: BTreeSet<String> = BTreeSet::new();+    let mut refs: BTreeSet<String> = BTreeSet::new();+    for p in b.pads.iter().filter(|p| !p.net.trim().is_empty()) { pad_nets.insert(p.net.clone()); refs.insert(p.reference.clone()); }+    let copper_nets: BTreeSet<String> = b.tracks().into_iter().map(|t| t.net).chain(b.vias().into_iter().map(|v| v.net)).filter(|n| !n.trim().is_empty()).collect();+    let list = |s: &BTreeSet<String>| s.iter().take(8).cloned().collect::<Vec<_>>().join(", ");+    if pad_nets.len() > 1 {+        return Some(format!("footprint pads are on {} nets ({}): a board with nets to connect needs the electrical lane", pad_nets.len(), list(&pad_nets)));+    }+    if let Some(n) = pad_nets.iter().next() {+        if !zone_nets.contains(n) {+            return Some(format!("footprint pads ({}) are on net {n}, which no zone (pour) carries: it needs routing", list(&refs)));+        }+    }+    let loose: BTreeSet<String> = copper_nets.into_iter().filter(|n| !zone_nets.contains(n) || (!pad_nets.is_empty() && !pad_nets.contains(n))).collect();+    if !loose.is_empty() {+        return Some(format!("tracks or vias carry net(s) {} that no single pour net joins: a routed board needs the electrical lane", list(&loose)));+    }+    None+}++/// The spec cannot be a pattern board's: it names loads, hot parts, signal checks or a converter.+pub fn pattern_spec_refusal(spec: &Value, calcs: Option<&Value>) -> Option<String> {+    let why = fields_applies(spec, calcs);+    (!why.is_empty()).then(|| format!("the spec is an electrical board's: {}", why.join("; ")))+}++/// finish's lines for the steps that did not apply: the pattern lane's electrical steps, and a fields+/// step recorded as not applicable.+pub fn finish_lines(data: &Value) -> Vec<String> {+    let mut out = Vec::new();+    let pattern = data["sequence"].as_array().map(|s| !s.iter().any(|x| x == "routing")).unwrap_or(false) && is_pattern(data);+    if pattern { for (steps, why) in PATTERN_NA { out.push(format!("{steps}: not applicable ({why})")); } }+    let tf = &data["outcomes"]["tour-fields"];+    if tf["notApplicable"] == true && !pattern { out.push(format!("fields: not applicable ({})", tf["reason"].as_str().unwrap_or(FIELDS_NA))); }+    out+}++#[cfg(test)]+mod tests {+    use super::*;+    use serde_json::json;++    const HEAD: &str = r#"(kicad_pcb (version 20260101) (net 0 "") (net 1 "GND") (net 2 "SIG") (layers (0 "F.Cu" signal) (31 "B.Cu" signal)) (gr_rect (start 0 0) (end 20 20) (layer "Edge.Cuts"))"#;+    fn pin(r: &str, x: f64, net: &str) -> String {+        let n = match net { "GND" => "(net 1 \"GND\")", "SIG" => "(net 2 \"SIG\")", _ => "" };+        format!(r#" (footprint "MP" (layer "F.Cu") (at {x} 5) (property "Reference" "{r}") (pad "1" thru_hole circle (at 0 0) (size 2 2) (drill 1) (layers "*.Cu") {n}))"#)+    }+    const GND_ZONE: &str = r#" (zone (net 1) (net_name "GND") (layer "F.Cu") (uuid "z1") (polygon (pts (xy 1 1) (xy 19 1) (xy 19 19) (xy 1 19))))"#;+    fn board(body: &str) -> Board { Board::from_text("t", format!("{HEAD}{body})")).unwrap() }++    #[test]+    fn fields_is_not_applicable_only_on_an_empty_spec() {+        assert!(fields_applies(&json!({}), None).is_empty());+        assert!(fields_applies(&json!({"loads": {}, "hot": {}, "signals": {}, "pours": [{"net": "GND"}]}), None).is_empty());+        assert_eq!(fields_applies(&json!({"loads": {"5V": {"amps": 1}}}), None).len(), 1);+        assert_eq!(fields_applies(&json!({"hot": {"U1": {"watts": 0.2}}}), None).len(), 1);+        assert_eq!(fields_applies(&json!({"signals": {"capacitance": [{"a": "X"}]}}), None).len(), 1);+        // a converter is never not applicable, whatever the spec leaves out+        let why = fields_applies(&json!({"switchNodes": ["SW"]}), None);+        assert!(why.iter().any(|w| w.contains("converter")), "{why:?}");+        assert!(!fields_applies(&json!({}), Some(&json!({"fsw_kHz": 500}))).is_empty());+    }++    #[test]+    fn pattern_lane_refuses_a_board_that_needs_routing() {+        // a bare pattern, and machine pins on a single GND plate: allowed+        assert_eq!(pattern_refusal(&board("")), None);+        assert_eq!(pattern_refusal(&board(&format!("{}{}{GND_ZONE}", pin("MP1", 3.0, "GND"), pin("MP2", 15.0, "GND")))), None);+        // a mounting hole without a net: allowed+        assert_eq!(pattern_refusal(&board(&pin("H1", 3.0, ""))), None);+        // two nets: refused+        let w = pattern_refusal(&board(&format!("{}{}{GND_ZONE}", pin("MP1", 3.0, "GND"), pin("J1", 15.0, "SIG")))).unwrap();+        assert!(w.contains("2 nets"), "{w}");+        // one net no zone carries: refused+        let w = pattern_refusal(&board(&format!("{}{}", pin("MP1", 3.0, "GND"), pin("MP2", 15.0, "GND")))).unwrap();+        assert!(w.contains("no zone (pour) carries"), "{w}");+        // a routed net beside the plate: refused+        let w = pattern_refusal(&board(&format!("{}{GND_ZONE} (segment (start 2 2) (end 8 2) (width 0.25) (layer \"B.Cu\") (net 2))", pin("MP1", 3.0, "GND")))).unwrap();+        assert!(w.contains("SIG"), "{w}");+        assert!(pattern_spec_refusal(&json!({"loads": {"GND": {"amps": 1}}}), None).is_some());+        assert!(pattern_spec_refusal(&json!({}), None).is_none());+    }++    #[test]+    fn finish_names_what_did_not_apply() {+        let flow: Value = serde_json::from_str(include_str!("../../../flows/board.json")).unwrap();+        let seq = crate::sequence::sequence_of(&flow, PATTERN);+        let d = json!({"kind": "pattern", "sequence": seq});+        let lines = finish_lines(&d);+        assert!(lines.iter().any(|l| l.starts_with("routing: not applicable")), "{lines:?}");+        assert!(lines.iter().any(|l| l.starts_with("fields: not applicable (no loads, hot parts or signal checks in the spec)")), "{lines:?}");+        let d = json!({"sequence": ["routing", "fields"], "outcomes": {"tour-fields": {"notApplicable": true, "reason": FIELDS_NA}}});+        assert_eq!(finish_lines(&d), vec![format!("fields: not applicable ({FIELDS_NA})")]);+        assert!(finish_lines(&json!({"sequence": ["routing"]})).is_empty());+    }+}

@@ -43,6 +43,7 @@ mod decoupling_check; mod placement_intent; mod rules_card; mod demo;+mod boardkind; use std::collections::BTreeMap; use std::path::{Path, PathBuf}; @@ -132,7 +133,8 @@ enum Cmd {     #[arg(long)] requirements: Option<String>, #[arg(long)] engine: Option<String>, /// the desktop for pre-board clips (a monitor recording while no editor is open)     #[arg(long)] target: Option<String>, /// the run's wiki page (owner/slug)     #[arg(long)] page: Option<String>, /// the EDA tool the board is built in (default: the brief's own words, else KiCad); fixes the run's step sequence-    #[arg(long, value_parser = ["kicad", "fusion", "altium"])] eda: Option<String> },+    #[arg(long, value_parser = ["kicad", "fusion", "altium"])] eda: Option<String>, /// `pattern`: a passive copper-pattern KiCad board (no parts, BOM, schematic or electrical load) takes the short pattern sequence; finish reports the electrical steps as not applicable. Refused later for a board with pads on nets that need routing.+    #[arg(long, value_parser = ["pattern"])] kind: Option<String> },     /// `sourcing check --bom <csv>`: every electrical board reference in the BOM with an MPN, sources that fit the profile (fab: Mouser or Adom stock, no LCSC/JLCPCB parts; jlcpcb: LCSC numbers), a dated stock check, thin stock warned. finish requires a pass when the spec or requirements name a profile.     Sourcing { what: String, #[arg(long)] bom: String, #[arg(long, value_parser = ["fab", "jlcpcb"])] profile: Option<String>, /// boards to build (default: requirements build.quantity, else 10)     #[arg(long)] qty: Option<u64>, /// the board to diff against (default: the run's current board)@@ -389,6 +391,12 @@ 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.+/// finish's "not applicable" block (issue #84): each step the run did not do, and why.+fn na_text(v: &Value) -> String {+    let lines: Vec<&str> = v.as_array().into_iter().flatten().filter_map(Value::as_str).collect();+    if lines.is_empty() { String::new() } else { format!("\nnot applicable to this board:\n  {}", lines.join("\n  ")) }+}+ fn spec_soft(r: &Run) -> Value {     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())@@ -2526,7 +2534,7 @@ fn main() {         Cmd::SilkscreenAudit { input, out, record, board } => {             thread(&cli); let mut r = load_run(&cli);             let result = std::process::Command::new(aiflow_python()).arg("-c").arg(include_str!("../../../tools/silkscreen-obstacle-check.py")).arg("--input").arg(input).arg("--out").arg(out).output().unwrap_or_else(|e| err(&format!("silkscreen audit needs python3: {e}"), &[]));-            if !result.status.success() { err(&String::from_utf8_lossy(&result.stdout), &["Supply every fitted body and every via/hole on both faces; audit the entire board, then verify label association and native 2D/3D views.".into()]); }+            if !result.status.success() { err(&silkproof::checker_failure(&String::from_utf8_lossy(&result.stdout), &String::from_utf8_lossy(&result.stderr)), &["Supply every fitted body and every via/hole on both faces; audit the entire board, then verify label association and native 2D/3D views.".into()]); }             if *record {                 // the step proof: this audit passed, on an inventory that covers the board it claims to audit                 let board_path = board.clone().unwrap_or_else(|| r.current_board());@@ -2717,13 +2725,14 @@ fn main() {             ok(&format!("run started for engine {engine} at {}; the clock started at the prompt, {pt}", dir.display()), &start_hints);             print_next(&cli);         }-        Cmd::Intake { prompt_time, brief, requirements, engine, target, page, eda } => {+        Cmd::Intake { prompt_time, brief, requirements, engine, target, page, eda, kind } => {             let t = thread(&cli);             if aiflow_run::parse(prompt_time).is_none() { err(&format!("--prompt-time {prompt_time} is not a time (RFC 3339 UTC, e.g. 2026-09-29T00:39:00Z)"), &["Use the human message's own timestamp, not the moment you got to it.".into()]); }             if let Some(r) = Run::open(&dir) {                 err(&format!("a run already exists at {} (engine {}, prompt time {})", dir.display(), r.data["engine"], r.data["clock"]["promptTime"]), &["Pick another --run directory: intake opens a new run. A follow-up prompt on this run is `prompt --text ...`.".into()]);             }             for f in brief.iter().chain(requirements.iter()) { if !Path::new(f).is_file() { err(&format!("not found: {f}"), &[]); } }+            if kind.is_some() && eda.as_deref().is_some_and(|e| e != "kicad") { err("--kind pattern is a KiCad lane", &["Build the pattern board in KiCad (--eda kicad, or leave --eda out).".into()]); }             let canon = |p: &String| std::fs::canonicalize(p).map(|x| x.display().to_string()).unwrap_or(p.clone());             // a brief that is already a requirements file (aiflow-intake's shape) is recorded as both             let req = requirements.as_ref().map(canon).or_else(|| brief.as_ref().filter(|b| std::fs::read_to_string(b).ok().and_then(|t| serde_json::from_str::<Value>(&t).ok()).map(|v| v.get("fab").is_some() || v.get("sourcing").is_some() || v.get("outputs").is_some()).unwrap_or(false)).map(canon));@@ -2732,6 +2741,8 @@ fn main() {             // the EDA tool, named: the step sequence is fixed at the first step after intake, before any             // backend project exists, so a brief that never says "Altium" must not fall into kicad-new             if let Some(e) = eda { r.data["eda"] = json!(e); }+            // a passive copper-pattern board: the pattern sequence (boardkind.rs)+            if let Some(k) = kind { r.data["kind"] = json!(k); }             let idx = r.turn_begin(&command_line());             record_usage(&mut r, "start");             r.save().unwrap();@@ -2955,6 +2966,9 @@ fn main() {             let parts = r.data["outcomes"]["parts"].clone();             if parts["pass"] != true { err("the parts are not all on the wiki yet: run `parts` until it passes", &[]); }             if !page.contains('/') { err("--page is <owner>/<slug>", &[]); }+            let bom_path = parts["bom"].as_str().unwrap_or("").to_string();+            let stale = project_lib::stale(&parts, &bom_path, std::fs::read_to_string(&bom_path).ok().as_deref());+            if !stale.is_empty() { err(&format!("the parts record is stale: {}", stale.join("; ")), &[format!("Run `parts` again (`parts --bom <current BOM>{}`), then `project-page` again.", parts["projectLib"].as_str().map(|d| format!(" --project-lib {d}")).unwrap_or_default())]); }             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.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());@@ -2981,9 +2995,12 @@ fn main() {                 let url = signed_in_wiki_url(page).unwrap_or_else(|| v["url"].as_str().unwrap_or("").to_string());                 let _ = std::process::Command::new("adom-cli").args(["hydrogen", "webview", "open-or-refresh", "--name", "Project page", "--url", &url, "--ai-thread", &t, "--reason", "adom-aiflow: the board's project page, revision 1"]).stdin(std::process::Stdio::null()).output();             }+            // --no-push builds everything locally: never claim the page was created or updated (issue #82)+            let page_said = if *no_push { format!("project page built locally in {} (--no-push: nothing pushed; {} was not created or updated)", dir.join("project-page").display(), v["url"].as_str().unwrap_or(page)) }+                else { format!("project page {} ({})", v["url"].as_str().unwrap_or(""), if v["created"] == true { "created" } else { "updated" }) };             if lane == "altium" {                 let from_lib: Vec<&str> = v["projectLibParts"].as_array().into_iter().flatten().filter_map(|x| x.as_str()).collect();-                ok(&format!("project page {} ({}): README revision 1 with {} parts and the component table (Altium Designer: the library step builds the SchLib and PcbLib from these same wiki pages{})", v["url"].as_str().unwrap_or(""), if v["created"] == true { "created" } else { "updated" }, v["parts"], if from_lib.is_empty() { String::new() } else { format!(" and, for {}, from the board's project library", from_lib.join(", ")) }),+                ok(&format!("{}: README revision 1 with {} parts and the component table (Altium Designer: the library step builds the SchLib and PcbLib from these same wiki pages{})", page_said, v["parts"], if from_lib.is_empty() { String::new() } else { format!(" and, for {}, from the board's project library", from_lib.join(", ")) }),                    &[if from_lib.is_empty() { String::new() } else { format!("from the board's project library (no public page yet): {}", from_lib.join(", ")) },                      "Next: `step library`, then `adom-aiflow altium library`: one SchLib and one PcbLib from the parts' wiki pages (project-library parts from their own KiCad files, through the same converters). Every step you leave is pushed to this page as steps/<nn>-<step>/README.md.".into()]);                 return;@@ -2991,8 +3008,8 @@ fn main() {             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());+            ok(&format!("{}: README revision 1 with {} parts, KiCad PCM repository {} ({} symbols, {} footprints, {} models for {} distinct parts; symbol library version {}, KiCad load check: {})", page_said, 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, if *no_push { vec![format!("Local build only: the README, PCM zip and repository files are in {}. The repository URL above works only after `project-page` runs without --no-push.", dir.join("project-page").display())] } else { vec![] }, 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);@@ -3273,7 +3290,7 @@ fn main() {                         if rep["errorCode"] == "board_mismatch" {                             err(&format!("live placement refused before part {}: requested {rb}; IPC openBoards {}",i+1,rep["openBoards"]), &["Save and gracefully close only your own conflicting KiCad editors, then `capture open` to reopen this board first. Never close another user's editor or restart a shared bridge. Inspect place-land-log.json; no failed part was moved.".into()]);                         }-                        err(&format!("live placement refused at part {} of {total}: {} {}", i + 1, rep["errorCode"], rep["message"].as_str().or(rep["error"].as_str()).unwrap_or("")), &[format!("offendingRefs: {}", rep["offendingRefs"]), "The bridge checks courtyards and the outline exactly; pack again. The parts before it are already placed, so fix the wish and land the rest.".into()]);+                        err(&format!("live placement refused at part {} of {total}: {} {}", i + 1, rep["errorCode"], rep["message"].as_str().or(rep["error"].as_str()).unwrap_or("")), &[placement_verify::locked_hint(&rep).unwrap_or_default(), format!("offendingRefs: {}", rep["offendingRefs"]), "The bridge checks courtyards and the outline exactly; pack again. The parts before it are already placed, so fix the wish and land the rest.".into()]);                     }                     ok(&format!("{accepted} part(s) landed live, one at a time, {:.1} s", t0.elapsed().as_secs_f64()), &["Each part is its own undo step and its own moment in the clip.".into()]);                 }@@ -3319,15 +3336,17 @@ fn main() {             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();-            let has_copper = bc["trackPieces"].as_u64().unwrap_or(0) + bc["vias"].as_u64().unwrap_or(0) > 0;+            // filled zone islands count: a pour alone can join a net's pads (issue #84)+            let has_copper = bc["trackPieces"].as_u64().unwrap_or(0) + bc["vias"].as_u64().unwrap_or(0) + bc["zoneIslands"].as_u64().unwrap_or(0) > 0;+            for w in bc["warnings"].as_array().into_iter().flatten().filter_map(|w| w.as_str()) { eprintln!("WARNING {w}"); }             let mut plan_doc = json!({"engine": "adom-aiflow router", "nets": plan});             if has_copper {                 let complete = bc["netsComplete"].as_array().map(|a| a.len()).unwrap_or(0);                 plan_doc["boardCopper"] = bc.clone();                 plan_doc["note"] = json!(if plan.is_empty() && failed == 0 {-                    format!("nothing to route: the board's own copper ({} track pieces, {} vias, filled zones) already joins every net ({complete} complete); this empty plan is the route result, and gate, land route and finish accept it", bc["trackPieces"], bc["vias"])+                    format!("nothing to route: the board's own copper ({} track pieces, {} vias, {} filled zone islands) already joins every net ({complete} complete); this empty plan is the route result, and gate, land route and finish accept it", bc["trackPieces"], bc["vias"], bc["zoneIslands"])                 } else {-                    format!("the board's own copper is kept as fixed copper ({} track pieces, {} vias); {complete} nets are complete on it and the plan carries only the {} connection(s) it left open", bc["trackPieces"], bc["vias"], bc["openConnections"])+                    format!("the board's own copper is kept as fixed copper ({} track pieces, {} vias, {} filled zone islands); {complete} nets are complete on it ({}) and the plan carries only the {} connection(s) it left open", bc["trackPieces"], bc["vias"], bc["zoneIslands"], bc["netsComplete"].as_array().map(|a| a.iter().filter_map(|v| v.as_str()).collect::<Vec<_>>().join(", ")).unwrap_or_default(), bc["openConnections"])                 });             }             if !regions.is_empty() {@@ -3366,9 +3385,9 @@ fn main() {             }             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]);+                ok(&format!("nothing to route: the board's own copper already joins every net ({} track pieces, {} vias, {} filled zone islands); empty plan {}", bc["trackPieces"], bc["vias"], bc["zoneIslands"], 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() };+                let copper_line = if has_copper { format!("; the board's own copper was kept (nets already complete on it, skipped: {}) and {} connection(s) it left open were planned", bc["netsComplete"].as_array().filter(|a| !a.is_empty()).map(|a| a.iter().filter_map(|v| v.as_str()).collect::<Vec<_>>().join(", ")).unwrap_or_else(|| "none".into()), bc["openConnections"]) } else { String::new() };                 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]);             }         }@@ -3555,6 +3574,18 @@ fn main() {                     return;                 }             }+            if what == "pours" {+                // zones adopted with this exact plan that still match it: nothing to land, no bridge call (issue #83)+                if let Some(zp) = r.outcomes().get("pour").and_then(|p| p["pours"].as_str()).map(str::to_string) {+                    let b = board_of(&r);+                    if let Ok(n) = pourverify::adopted_unchanged(&r.data, Path::new(&zp), &b) {+                        r.log("land-pours-skipped", json!({"plan": zp, "zones": n, "why": "adopted zones already match the plan"}));+                        r.save().unwrap();+                        ok(&format!("adopted zones already match the plan; nothing to land ({n} zone(s) adopted by `verify-pours --adopt` with this plan, unchanged on the saved board)"), &[if pourverify::is_existing(&r.data["outcomes"]["land-pours"]) { "The adopted-existing pours proof stands. Next: adom-aiflow measure, analyze current, analyze thermal, finish.".to_string() } else { format!("The pours proof was replaced by a later landing attempt: run `verify-pours --plan {zp}` again to record it (no copper changes), then measure, analyze current, analyze thermal, finish.") }]);+                        return;+                    }+                }+            }             let br = bridge_of(&r, &cli);             let rb = r.data["remoteBoard"].as_str().unwrap_or("").to_string();             match what.as_str() {@@ -3573,7 +3604,7 @@ fn main() {                     r.save().unwrap();                     if let Some(i) = stopped {                         let rep = replies.last().cloned().unwrap_or(Value::Null);-                        err(&format!("live placement refused at part {} of {total}: {} {}", i + 1, rep["errorCode"], rep["message"].as_str().or(rep["error"].as_str()).unwrap_or("")), &[format!("offendingRefs: {}", rep["offendingRefs"]), "The bridge checks courtyards and the outline exactly; pack again. The parts before it are already placed, so fix the wish and land the rest.".into()]);+                        err(&format!("live placement refused at part {} of {total}: {} {}", i + 1, rep["errorCode"], rep["message"].as_str().or(rep["error"].as_str()).unwrap_or("")), &[placement_verify::locked_hint(&rep).unwrap_or_default(), format!("offendingRefs: {}", rep["offendingRefs"]), "The bridge checks courtyards and the outline exactly; pack again. The parts before it are already placed, so fix the wish and land the rest.".into()]);                     }                     ok(&format!("{accepted} part(s) landed live, one at a time, {:.1} s", t0.elapsed().as_secs_f64()), &["Each part is its own undo step and its own moment in the clip.".into()]);                 }@@ -3603,6 +3634,11 @@ fn main() {                         }                     }                     let mut copper_cache: Option<Vec<Copper>> = None;+                    // and keep the spec's hole-to-hole minimum and via-to-via clearance from every via and+                    // hole, live or planned, of any net (issue #83): checked for every trace before any lands+                    let spec_v = r.data["spec"].as_str().filter(|p| Path::new(p).is_file()).map(read_json).unwrap_or(Value::Null);+                    let (h2h, via_clearance) = (aiflow_pours::hole_to_hole(&spec_v), spec_v["clearance"].as_f64().unwrap_or(0.2));+                    let mut holes_cache: Option<Vec<landing::Hole>> = None;                     let precheck = |_i: usize, e: &Value, live: &landing::LiveCopper| -> Option<Value> {                         let t = landing::resolve(e, &live.pads)?;                         if t.vias.is_empty() { return None; }@@ -3612,7 +3648,15 @@ fn main() {                             for p in &plans { c.extend(landing::plan_copper(p, &live.pads)); }                             c                         });-                        t.vias.iter().find_map(|v| landing::via_touch(&t.net, *v, t.via_size / 2.0, copper).map(|what| json!({"success": false, "errorCode": "via_touches_other_net", "net": t.net, "at": [v.0, v.1], "touches": what, "message": format!("the planned {} via at ({:.2}, {:.2}) would touch {what}; KiCad would give it that net", t.net, v.0, v.1)})))+                        if let Some(refusal) = t.vias.iter().find_map(|v| landing::via_touch(&t.net, *v, t.via_size / 2.0, copper).map(|what| json!({"success": false, "errorCode": "via_touches_other_net", "net": t.net, "at": [v.0, v.1], "touches": what, "message": format!("the planned {} via at ({:.2}, {:.2}) would touch {what}; KiCad would give it that net", t.net, v.0, v.1)}))) { return Some(refusal); }+                        let holes = holes_cache.get_or_insert_with(|| {+                            let mut h = landing::live_holes(live);+                            h.extend(landing::board_holes(&b));+                            for p in &plans { h.extend(landing::plan_holes(p, &live.pads)); }+                            h+                        });+                        let drill = e["viaDrill"].as_f64().unwrap_or(t.via_size / 2.0);+                        t.vias.iter().find_map(|v| landing::via_hole_clash(&t.net, *v, t.via_size, drill, holes, h2h, via_clearance).map(|what| json!({"success": false, "errorCode": "via_hole_clash", "net": t.net, "at": [v.0, v.1], "clashes": what, "message": format!("the planned {} via at ({:.2}, {:.2}) is too close to {what}", t.net, v.0, v.1)})))                     };                     let stage = format!("land-{what}");                     r.stage_start(&stage, Some("binary"), None);@@ -3661,7 +3705,7 @@ fn main() {                     }                     if let Some(i) = stopped {                         let rep = res.replies.last().cloned().unwrap_or(Value::Null);-                        if rep["errorCode"] == "via_touches_other_net" {+                        if rep["errorCode"] == "via_touches_other_net" || rep["errorCode"] == "via_hole_clash" {                             err(&format!("live {what} refused before landing anything: trace {} of {traces}: {}", i + 1, rep["message"].as_str().unwrap_or("")), &["Move the via clear of that copper (spec thermalVias/stitchVias or the plan), run `pour` or `gate` again, then land. Nothing was landed by this command.".into()]);                         }                         err(&format!("live {what} stopped at trace {} of {}: {} {}", i + 1, traces, rep["errorCode"], rep["message"].as_str().unwrap_or("")), &["A drc_rejected means the live board differs from the gated copy; read kicad_routing_state and gate again.".into(), format!("Rerun `land {what}` once fixed: traces already on the live board are skipped. To resume at this trace: `adom-aiflow land {what}{} --from {}`. The log has every reply.", plan.as_ref().map(|p| format!(" --plan {p}")).unwrap_or_default(), i + 1)]);@@ -3706,15 +3750,11 @@ fn main() {                     if !Bridge::ok(&after) { results.push(("post-landing-readback".into(), after.clone())); }                     let failed: Vec<&(String, Value)> = results.iter().filter(|(_, rep)| !Bridge::ok(rep)).collect();                     r.stage_end("land-pours", Some(json!({"groups": results.len(), "failed": failed.len()})), None);-                    r.outcome("land-pours", json!({"before": before["filledAreaByLayerMm2"], "after": after["filledAreaByLayerMm2"], "coverageAfter": after["filledCoverageByLayerPercent"], "failed": failed.iter().map(|(n, _)| n.clone()).collect::<Vec<_>>(), "groups": results.iter().map(|(n, rep)| json!({"net": n, "ok": Bridge::ok(rep), "itemIds": rep["itemIds"], "errorCode": rep["errorCode"]})).collect::<Vec<_>>()}));+                    r.outcome("land-pours", json!({"before": before["filledAreaByLayerMm2"], "after": after["filledAreaByLayerMm2"], "coverageAfter": after["filledCoverageByLayerPercent"], "failed": failed.iter().map(|(n, _)| n.clone()).collect::<Vec<_>>(), "groups": results.iter().map(|(n, rep)| json!({"net": n, "ok": Bridge::ok(rep), "itemIds": rep["itemIds"], "errorCode": rep["errorCode"], "message": rep["message"], "reply": if Bridge::ok(rep) { Value::Null } else { json!(aiflow_run::clip_text(&rep.to_string(), 1200)) }})).collect::<Vec<_>>()}));                     write_json(&dir.join("land-pours-log.json"), &json!({"before": before, "results": results, "after": after}));                     r.save().unwrap();                     if let Some((net, rep)) = failed.first() {-                        let mut types: BTreeMap<String, usize> = BTreeMap::new();-                        for v in rep["violations"].as_array().cloned().unwrap_or_default() {-                            *types.entry(v["type"].as_str().unwrap_or("?").to_string()).or_insert(0) += 1;-                        }-                        err(&format!("pour for {net} refused by the preflight: {} {:?}", rep["errorCode"], types), &["starved_thermal: tighter spokes (thermalGap 0.3, thermalBridge 0.35) or a solid patch at the pad (spec.solidAt). zones_intersect: merge same-net same-priority zones or change a priority. clearance: the polygon reaches another net's copper too closely; shrink it.".into()]);+                        err(&pourverify::refusal(net, rep, &zones), &[format!("Full replies: {}. A zone adopted with `verify-pours --adopt` and unchanged since is not landed again; this plan was sent because {}.", dir.join("land-pours-log.json").display(), pourverify::adopted_unchanged(&r.data, Path::new(&zp), &b).err().unwrap_or_default()),"starved_thermal: tighter spokes (thermalGap 0.3, thermalBridge 0.35) or a solid patch at the pad (spec.solidAt). zones_intersect: merge same-net same-priority zones or change a priority. clearance: the polygon reaches another net's copper too closely; shrink it.".into()]);                     }                     ok(&format!("pours landed: copper per layer before {} after {}", before["filledAreaByLayerMm2"], after["filledAreaByLayerMm2"]), &["Next: adom-aiflow measure, analyze current, analyze thermal, finish.".into()]);                 }@@ -3868,12 +3908,23 @@ fn main() {             }             let o = r.outcomes().clone();             let mut missing = Vec::new();+            // a pattern board's run (boardkind.rs): the electrical steps are not applicable, the native DRC is the live one+            let pattern = boardkind::is_pattern(&r.data) && r.data["sequence"].as_array().is_some_and(|s| !s.iter().any(|x| x == "routing"));+            let not_applicable = boardkind::finish_lines(&r.data);+            if pattern {+                if let Some(why) = boardkind::pattern_refusal(&board_of(&r)).or_else(|| boardkind::pattern_spec_refusal(&spec_soft(&r), converter::calcs_of_run(&r.data).as_ref())) { missing.push(format!("pattern lane: {why} (start a run on the electrical lane)")); }+                if r.data["target"].is_null() { missing.push("native DRC: a pattern board's DRC is finish's live full DRC with the fab rules; bind the board on a test box (start --target <box> --remote-board <path>, bind-remote-board) and finish again".into()); }+            }+            if o.get("tour-fields").is_some_and(|f| f["notApplicable"] == true) {+                let why = boardkind::fields_applies(&spec_soft(&r), converter::calcs_of_run(&r.data).as_ref());+                if !why.is_empty() { missing.push(format!("fields: recorded as not applicable, but now {} (solve with adom-fields, then `tour fields`)", why.join("; "))); }+            }             let placement=o.get("place-land").cloned().unwrap_or(Value::Null);             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) {+            if !pattern && (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); }@@ -3884,13 +3935,13 @@ fn main() {             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") {+            if !pattern && !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) || 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) {+            if !pattern && 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")) {+            if !pattern && !measurement_usable(o.get("measure")) {                 missing.push("measure (successful native copper readback)".into());             }             // a Fusion run is judged on the board as it is in Fusion now@@ -3899,6 +3950,7 @@ fn main() {             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 pattern { continue; }                 if o.get(k).and_then(|a| a["pass"].as_bool()) != Some(true) {                     missing.push(format!("{k} (pass)"));                 } else {@@ -4003,7 +4055,9 @@ fn main() {             }             // the work before the board: the sourcing check when a profile is named, the evidence the spec asks for             let (spec_v, req_v) = (spec_soft(&r), requirements_of(&r));-            if let Some(p) = preboard::named_profile(&spec_v).or_else(|| preboard::named_profile(&req_v)) {+            // a pattern board with nothing in its BOM has nothing to source; any BOM footprint keeps the check+            let nothing_to_source = pattern && preboard::board_refs(&board_now()).0.is_empty();+            if let Some(p) = preboard::named_profile(&spec_v).or_else(|| preboard::named_profile(&req_v)).filter(|_| !nothing_to_source) {                 let sc = o.get("sourcing").cloned().unwrap_or(Value::Null);                 if sc["pass"] != true { missing.push(format!("sourcing check on the {p} profile (sourcing check --bom <csv>)")); }                 else if sc["boardChecked"] != true { missing.push("sourcing check against the board's references (run it again now the board exists)".into()); }@@ -4079,9 +4133,11 @@ fn main() {             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.data["summary"]["notApplicable"] = json!(not_applicable);+            if nothing_to_source { r.data["summary"]["notApplicable"].as_array_mut().unwrap().push(json!("sourcing check: not applicable (no footprint in the BOM)")); }             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\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()]);+            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("; ")) }) + &na_text(&r.data["summary"]["notApplicable"]) + &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);@@ -4491,9 +4547,9 @@ fn main() {         Cmd::Timeline { action, port, json: presentation } => {             let mut r = load_run(&cli);             let flow_full: Value = serde_json::from_str(include_str!("../../../flows/board.json")).unwrap();-            if r.data["steps"].as_object().map(|o| o.keys().all(|k| k == "intake")).unwrap_or(true) {-                let want = json!(sequence::sequence_of(&flow_full, &sequence::sequence_key(&dir, &r.data)));-                if r.data["sequence"] != want { r.data["sequence"] = want; r.save().unwrap(); }+            {+                let want = sequence::sequence_of(&flow_full, &sequence::sequence_key(&dir, &r.data));+                if sequence::may_resequence(&r.data, &want) && r.data["sequence"] != json!(want) { r.data["sequence"] = json!(want); r.save().unwrap(); }             }             let seq: Vec<String> = r.data["sequence"].as_array().map(|a| a.iter().filter_map(|x| x.as_str().map(str::to_string)).collect()).unwrap_or_else(|| sequence::sequence_of(&flow_full, &sequence::sequence_key(&dir, &r.data)));             let tl = sequence::timeline(&dir, &r.data, &flow_full, &seq, &r.step_report());@@ -4799,6 +4855,18 @@ fn main() {         Cmd::Tour { what, nets, port, on } => {             let t = thread(&cli);             let mut r = load_run(&cli);+            // nothing for Adom Fields to solve (issue #84): the fields step is recorded as not applicable, never faked+            if what == "fields" && !r.board_pending() {+                let spec_path = r.data["spec"].as_str().unwrap_or("").to_string();+                let calcs = converter::calcs_of_run(&r.data);+                if Path::new(&spec_path).is_file() && boardkind::fields_applies(&spec_soft(&r), calcs.as_ref()).is_empty() {+                    r.outcome("tour-fields", json!({"notApplicable": true, "reason": boardkind::FIELDS_NA, "spec": spec_path, "specSha256": sha256_file(&spec_path), "board": r.current_board()}));+                    r.log("step-not-applicable", json!({"step": "fields", "reason": boardkind::FIELDS_NA}));+                    r.save().unwrap();+                    ok(&format!("fields: not applicable ({}); recorded as the fields step's proof (tour-fields), nothing solved or filmed", boardkind::FIELDS_NA), &["finish lists the fields step as not applicable, and refuses this record if the spec later names a load, hot part or signal check (then solve with adom-fields and `tour fields` again). Never add a load only to get a solve.".into()]);+                    return;+                }+            }             // a localhost Fields URL ({{port}}.localhost, 127.0.0.1) is reachable only on the machine             // hosting this container: film it there (the user's primary machine), not on the test box             let local_proxy = what == "fields" && std::env::var("VSCODE_PROXY_URI").map(|u| preboard::proxy_is_local(&u)).unwrap_or(false);@@ -5136,9 +5204,16 @@ fn main() {             let flow_full: Value = serde_json::from_str(include_str!("../../../flows/board.json")).unwrap();             // the lane can still change while only intake is done (the run learns it is a Fusion board from the             // brief or the requirements written during intake)-            if r.data["steps"].as_object().map(|o| o.keys().all(|k| k == "intake")).unwrap_or(true) {-                let want = json!(sequence::sequence_of(&flow_full, &sequence::sequence_key(&dir, &r.data)));-                if r.data["sequence"] != want { r.data["sequence"] = want; }+            {+                let want = sequence::sequence_of(&flow_full, &sequence::sequence_key(&dir, &r.data));+                if sequence::may_resequence(&r.data, &want) && r.data["sequence"] != json!(want) { r.data["sequence"] = json!(want); }+            }+            // the pattern lane is for boards with nothing to connect (issue #84): refuse it for one that needs routing+            if boardkind::is_pattern(&r.data) && !r.board_pending() && sequence::sequence_key(&dir, &r.data) == boardkind::PATTERN {+                let calcs = converter::calcs_of_run(&r.data);+                if let Some(why) = boardkind::pattern_refusal(&board_of(&r)).or_else(|| boardkind::pattern_spec_refusal(&spec_soft(&r), calcs.as_ref())) {+                    err(&format!("this run is a pattern board (`intake --kind pattern` or requirements boardKind), but {why}"), &["The pattern lane leaves out placement, routing, pours, current, thermal and fields. A board with nets to connect, loads or hot parts takes the electrical lane: start a new run without --kind pattern (and without requirements boardKind).".into()]);+                }             }             let seq: Vec<String> = r.data["sequence"].as_array().map(|a| a.iter().filter_map(|x| x.as_str().map(str::to_string)).collect()).unwrap_or_default();             // --back is a return: it may only go to an earlier step of the flow, never jump ahead past the checks

@@ -538,6 +538,52 @@ pub fn adopt(data: &mut Value, proof: &Value, why: &str) -> Result<Vec<String>,     Ok(ids) } +/// Issue #83: `land pours` after `verify-pours --adopt`. When the latest adoption of this exact plan+/// (same sha256) owns every zone the plan matches, and the saved board's zones still match the plan+/// exactly, there is nothing to land: re-landing them would only ask the bridge to replace zones with+/// themselves. Ok(zone count) then; Err(why not) sends `land pours` on to the bridge as before.+pub fn adopted_unchanged(data: &Value, plan: &Path, board: &Board) -> Result<usize, String> {+    let sha = hash(plan)?;+    let adoption = data["zoneAdoptions"].as_array().into_iter().flatten().rev()+        .find(|a| a["planSha256"].as_str() == Some(sha.as_str()))+        .ok_or("no `verify-pours --adopt` of this plan (same sha256) is recorded")?;+    let plan_v: Value = serde_json::from_str(&std::fs::read_to_string(plan).map_err(|e| format!("{}: {e}", plan.display()))?).map_err(|e| format!("{}: {e}", plan.display()))?;+    let proof = check(board, &plan_v)?;+    if proof["pass"] != true {+        return Err(format!("the saved zones no longer match the adopted plan: {}", proof["failed"]));+    }+    let adopted: Vec<&str> = adoption["zones"].as_array().into_iter().flatten().filter_map(|z| z["uuid"].as_str()).collect();+    let owned: Vec<&str> = data["ownedZoneIds"].as_array().into_iter().flatten().filter_map(Value::as_str).collect();+    let groups = proof["groups"].as_array().cloned().unwrap_or_default();+    for g in &groups {+        let id = g["boardZoneUuid"].as_str().unwrap_or("");+        if id.is_empty() || !adopted.contains(&id) || !owned.contains(&id) {+            return Err(format!("zone {} ({}) was not adopted with this plan", g["name"].as_str().unwrap_or("?"), if id.is_empty() { "no uuid" } else { id }));+        }+    }+    Ok(groups.len())+}++/// Issue #83: a `land pours` refusal with everything the bridge said (clipped) and what aiflow sent.+pub fn refusal(step: &str, reply: &Value, zones: &[Value]) -> String {+    let mut types: std::collections::BTreeMap<String, usize> = std::collections::BTreeMap::new();+    for v in reply["violations"].as_array().into_iter().flatten() {+        *types.entry(v["type"].as_str().unwrap_or("?").to_string()).or_insert(0) += 1;+    }+    let code = reply["errorCode"].as_str().unwrap_or("no errorCode");+    let msg = reply["message"].as_str().or(reply["error"].as_str()).unwrap_or("");+    let sent: Vec<String> = zones.iter().map(|z| {+        let layers: Vec<&str> = z["layers"].as_array().into_iter().flatten().filter_map(Value::as_str).collect();+        format!("{} ({}, {})", z["name"].as_str().unwrap_or("unnamed"), z["net"].as_str().unwrap_or(if z.get("keepout").is_some() { "keepout" } else { "no net" }), layers.join("+"))+    }).collect();+    let mut out = format!("{step} refused: {code}");+    if !msg.is_empty() { out.push_str(&format!(": {msg}")); }+    if !types.is_empty() { out.push_str(&format!("; violations {types:?}")); }+    out.push_str(&format!("\nbridge reply: {}", aiflow_run::clip_text(&reply.to_string(), 1200)));+    out.push_str(&format!("\nsent {} zone(s): {}", zones.len(), sent.join("; ")));+    out+}+ type Reply = Result<(String, Vec<String>), (String, Vec<String>)>;  /// `verify-pours`: compare, bind the plan's provenance, and optionally record a reviewed plan or@@ -913,4 +959,38 @@ mod tests {         let _ = std::fs::remove_dir_all(d);         let _ = std::fs::remove_dir_all(d2);     }+    // -- issue #83: land pours after adoption, and refusal detail ----------------------------------+    #[test]+    fn adopted_zones_that_still_match_need_no_landing() {+        let d = tmpdir("adopted");+        let plan = write_plan(&d, "plan.json");+        let pv: Value = serde_json::from_str(&std::fs::read_to_string(&plan).unwrap()).unwrap();+        let mut proof = check(&offline(), &pv).unwrap();+        proof["planSha256"] = json!(hash(&plan).unwrap());+        let mut data = json!({});+        assert!(adopted_unchanged(&data, &plan, &offline()).unwrap_err().contains("no `verify-pours --adopt`"));+        adopt(&mut data, &proof, "written offline").unwrap();+        assert_eq!(adopted_unchanged(&data, &plan, &offline()).unwrap(), 1);+        // a zone edited after the adoption: land as before+        let moved = Board::from_text("o", format!("{PREFIX} {})", OFFLINE.replace("(xy 9 9) (xy 1 9)", "(xy 9 8) (xy 1 9)"))).unwrap();+        assert!(adopted_unchanged(&data, &plan, &moved).unwrap_err().contains("no longer match"));+        // a different plan (another sha256) was not adopted+        let other = d.join("other.json");+        std::fs::write(&other, format!("{} ", pv)).unwrap();+        assert!(adopted_unchanged(&data, &other, &offline()).is_err());+        // ownership given up since: not adopted any more+        data["ownedZoneIds"] = json!([]);+        assert!(adopted_unchanged(&data, &plan, &offline()).unwrap_err().contains("not adopted"));+        let _ = std::fs::remove_dir_all(d);+    }+    #[test]+    fn a_refusal_names_the_reply_and_what_was_sent() {+        let zones = vec![json!({"name":"GND top","net":"GND","layers":["F.Cu"]}), json!({"name":"GND bottom","net":"GND","layers":["B.Cu","In1.Cu"]})];+        let m = refusal("native-zone-plan", &json!({"success":false,"errorCode":"zone_plan_refused","details":{}}), &zones);+        assert!(m.starts_with("native-zone-plan refused: zone_plan_refused"), "{m}");+        assert!(m.contains("bridge reply: {") && m.contains("\"details\":{}"), "{m}");+        assert!(m.contains("sent 2 zone(s): GND top (GND, F.Cu); GND bottom (GND, B.Cu+In1.Cu)"), "{m}");+        let m = refusal("native-zone-plan", &json!({"errorCode":"drc","message":"clearance at (1, 2)","violations":[{"type":"clearance"},{"type":"clearance"}]}), &zones);+        assert!(m.contains("drc: clearance at (1, 2); violations {\"clearance\": 2}"), "{m}");+    } }

@@ -16,7 +16,7 @@ pub const SAME_POINT_MM: f64 = 0.05; pub struct LiveSeg { pub net: String, pub a: Pt, pub b: Pt, pub width: f64, pub uuid: String }  #[derive(Clone, Debug)]-pub struct LiveVia { pub net: String, pub at: Pt, pub size: f64, pub uuid: String }+pub struct LiveVia { pub net: String, pub at: Pt, pub size: f64, pub drill: f64, pub uuid: String }  /// The copper a kicad_routing_state reply describes, plus the pads by name (J5.1) with net and centre. #[derive(Clone, Debug, Default)]@@ -39,7 +39,9 @@ impl LiveCopper {         }         for v in state["vias"].as_array().into_iter().flatten() {             let Some(at) = xy(&v["position"]) else { continue };-            live.vias.push(LiveVia { net: v["net_name"].as_str().unwrap_or("").to_string(), at, size: v["size"].as_f64().unwrap_or(0.0), uuid: v["uuid"].as_str().unwrap_or("").to_string() });+            let size = v["size"].as_f64().unwrap_or(0.0);+            // a reply without the drill: half the copper, the usual via ring+            live.vias.push(LiveVia { net: v["net_name"].as_str().unwrap_or("").to_string(), at, size, drill: v["drill"].as_f64().unwrap_or(size / 2.0), uuid: v["uuid"].as_str().unwrap_or("").to_string() });         }         for p in state["pads"].as_array().into_iter().flatten() {             let (Some(name), Some(at)) = (p["name"].as_str(), xy(p)) else { continue };@@ -154,6 +156,56 @@ pub fn via_touch(net: &str, at: Pt, r: f64, copper: &[Copper]) -> Option<String>     copper.iter().find(|c| c.net() != net && c.touches(at, r)).map(|c| c.what().to_string()) } +/// A drilled hole a planned via must keep the hole-to-hole minimum from, and (a via) the copper+/// clearance too, whatever its net: a live or planned via, a through-hole pad, a bare drill.+#[derive(Clone, Debug)]+pub struct Hole { pub at: Pt, pub size: f64, pub drill: f64, pub net: String, pub via: bool, pub what: String }++/// The live board's vias as holes.+pub fn live_holes(live: &LiveCopper) -> Vec<Hole> {+    live.vias.iter().map(|v| Hole { at: v.at, size: v.size, drill: v.drill, net: v.net.clone(), via: true, what: format!("live {} via at ({:.2}, {:.2})", v.net, v.at.0, v.at.1) }).collect()+}++/// A board's through-hole pads and bare drills as holes (vias come from the live board instead).+pub fn board_holes(board: &aiflow_board::Board) -> Vec<Hole> {+    let mut out: Vec<Hole> = board.pads.iter().filter(|p| p.thru).filter_map(|p| Some(Hole { at: (p.x, p.y), size: 2.0 * p.half_long, drill: p.drill?, net: p.net.clone(), via: false, what: format!("pad {} hole", p.key) })).collect();+    out.extend(board.holes.iter().map(|h| Hole { at: (h.x, h.y), size: h.diameter(), drill: h.diameter(), net: String::new(), via: false, what: format!("drilled hole {}{}", h.reference, if h.name.is_empty() { String::new() } else { format!(".{}", h.name) }) }));+    out+}++/// A routing plan's vias as holes, pads resolved on the live board.+pub fn plan_holes(plan: &Value, pads: &BTreeMap<String, (String, Pt)>) -> Vec<Hole> {+    let entries = plan["nets"].as_array().cloned().unwrap_or_default();+    let mut out = Vec::new();+    for e in expand_traces(&entries) {+        let Some(t) = resolve(&e, pads) else { continue };+        let drill = e["viaDrill"].as_f64().unwrap_or(t.via_size / 2.0);+        out.extend(t.vias.iter().map(|v| Hole { at: *v, size: t.via_size, drill, net: t.net.clone(), via: true, what: format!("planned {} via at ({:.2}, {:.2})", t.net, v.0, v.1) }));+    }+    out+}++/// The first hole a planned via of `net` at `at` (copper `size`, `drill`) clashes with: drill edge+/// to drill edge under `h2h`, or, for another via of any net, copper edge to copper edge under+/// `clearance` (a same-net via on top of another is still a drill clash; issue #83). The same via+/// (same net, same point) is not a clash with itself.+pub fn via_hole_clash(net: &str, at: Pt, size: f64, drill: f64, holes: &[Hole], h2h: f64, clearance: f64) -> Option<String> {+    let eps = 1e-4;+    holes.iter().find_map(|h| {+        let d = (h.at.0 - at.0).hypot(h.at.1 - at.1);+        if h.net == net && same(h.at, at) { return None; }+        let drills = (drill + h.drill) / 2.0 + h2h;+        if d + eps < drills {+            return Some(format!("{}: centres {d:.2} mm apart, under the {:.2} mm hole-to-hole minimum ({h2h} mm drill edge to drill edge)", h.what, drills));+        }+        let copper = (size + h.size) / 2.0 + clearance;+        if h.via && d + eps < copper {+            return Some(format!("{}: centres {d:.2} mm apart, under the {:.2} mm via-to-via spacing ({clearance} mm copper clearance)", h.what, copper));+        }+        None+    })+}+ /// A landed via that came back on a net other than the planned one. #[derive(Clone, Debug, PartialEq)] pub struct ViaMismatch { pub trace: usize, pub planned: String, pub actual: String, pub at: Pt, pub uuid: String }@@ -365,6 +417,22 @@ mod tests {         assert_eq!(via_touch("GND", (112.0, 80.4), 0.3, &plan_copper(&plan, &live.pads)).as_deref(), Some("planned /SW track"));     } +    #[test]+    fn a_planned_via_over_an_existing_same_net_via_is_refused() {+        // issue #83: an in-pad 0.5/0.25 GND via on the live board, and a planned 0.8/0.4 GND via 0.6 mm away+        let live = LiveCopper::from_state(&state("r", &[], &[json!({"position": {"x": 112.4, "y": 82.0}, "net_name": "GND", "size": 0.5, "drill": 0.25, "uuid": "ep1"})]));+        let holes = live_holes(&live);+        let clash = via_hole_clash("GND", (111.8, 82.0), 0.8, 0.4, &holes, 0.25, 0.2).expect("refused");+        assert!(clash.contains("live GND via at (112.40, 82.00)") && clash.contains("0.60 mm apart"), "{clash}");+        // with a hole-to-hole minimum the drills pass, the copper spacing still refuses it+        assert!(via_hole_clash("GND", (111.8, 82.0), 0.8, 0.4, &holes, 0.2, 0.2).unwrap().contains("via-to-via"));+        assert!(via_hole_clash("GND", (111.4, 82.0), 0.8, 0.4, &holes, 0.25, 0.2).is_none(), "1.0 mm away is clear");+        assert!(via_hole_clash("GND", (112.4, 82.0), 0.5, 0.25, &holes, 0.25, 0.2).is_none(), "the same via is not a clash");+        // a planned via of another plan counts the same way+        let plan = json!({"nets": [via_entry("GND", 120.0, 80.0)]});+        assert!(via_hole_clash("GND", (120.5, 80.0), 0.6, 0.3, &plan_holes(&plan, &live.pads), 0.25, 0.2).is_some());+    }+     #[test]     fn a_landed_via_on_another_net_is_named_with_both_nets() {         let live = LiveCopper::from_state(&state("r", &[], &[json!({"position": {"x": 113.3, "y": 92.55}, "net_name": "/SW", "size": 0.6, "uuid": "vsw"})]));

@@ -123,6 +123,26 @@ pub fn hole_clear(x: f64, y: f64, size: f64, drill: f64, net: &str, holes: &[Hol     }) } +/// `hole_clear`, and also copper to copper at least `clearance` from every via and hole whatever its+/// net: two vias of one net may not overlap or crowd each other either (a 0.8 mm via 0.6 mm from a+/// 0.5 mm in-pad via is a drill and copper clash KiCad's DRC reports; issue #83).+pub fn via_clear(x: f64, y: f64, size: f64, drill: f64, net: &str, holes: &[Hole], h2h: f64, clearance: f64) -> bool {+    hole_clear(x, y, size, drill, net, holes, h2h, clearance)+        && holes.iter().all(|(hx, hy, hs, _, _)| (hx - x).hypot(hy - y) + 1e-6 >= (size + hs) / 2.0 + clearance)+}++/// The vias already at a pad: every via of `net` (any size), and every through-hole pad of `net` in+/// the same footprint (a footprint's own in-pad via pads), whose centre lies within the pad's copper+/// box grown by `grow` mm; the pad itself left out.+pub fn vias_at_pad(board: &Board, pad: &aiflow_board::Pad, net: &str, grow: f64) -> usize {+    let pts: Vec<Pt> = pad.polys.iter().flatten().copied().collect();+    let (x0, y0, x1, y1) = if pts.is_empty() { (pad.x - pad.half_long, pad.y - pad.half_long, pad.x + pad.half_long, pad.y + pad.half_long) } else { geom::bbox(&pts) };+    let within = |x: f64, y: f64| x >= x0 - grow && x <= x1 + grow && y >= y0 - grow && y <= y1 + grow;+    let vias = board.vias().into_iter().filter(|v| v.net == net && within(v.x, v.y)).count();+    let thru = board.pads.iter().filter(|q| q.thru && q.drill.is_some() && q.net == net && q.reference == pad.reference && !std::ptr::eq(*q, pad) && within(q.x, q.y)).count();+    vias + thru+}+ /// The pad connection and island settings a pour may carry, so a reviewed plan can describe a zone /// exactly: `connection` thermal (default), solid (or full) or none; `thermalGap` and /// `thermalBridge` in mm; `islandRemoval` always (default), never or area, with `islandAreaMin` in mm2.@@ -215,11 +235,19 @@ pub fn build_with(board: &Board, spec: &Value, plan: Option<&Value>, planned: &[     for tv in spec.get("thermalVias").and_then(|v| v.as_array()).cloned().unwrap_or_default() {         let Some(key) = tv.get("pad").and_then(|p| p.as_str()) else { continue };         let Some(p) = board.pad_by_key(key) else { continue };+        // a footprint can repeat a pad name (an exposed pad and its own in-pad via pads all "29"):+        // the heat pad is the largest copper of that name+        let p = board.pads.iter().filter(|q| q.reference == p.reference && q.name == p.name).max_by(|a, b| (a.half_long * a.half_short).partial_cmp(&(b.half_long * b.half_short)).unwrap_or(std::cmp::Ordering::Equal)).unwrap_or(p);         let net = tv.get("net").and_then(|n| n.as_str()).unwrap_or(&p.net).to_string();-        let n = tv.get("count").and_then(|c| c.as_u64()).unwrap_or(2) as usize;+        let want = tv.get("count").and_then(|c| c.as_u64()).unwrap_or(2) as usize;         let (size, drill) = (tv.get("size").and_then(|v| v.as_f64()).unwrap_or(0.8), tv.get("drill").and_then(|v| v.as_f64()).unwrap_or(0.4));-        let mut placed = 0;         let fits_inside = p.half_long - 0.4 > 0.0 && p.half_short - 0.4 > 0.0 && size <= 2.0 * p.half_short;+        // the pad's vias already on the board (any size) count toward `count`, as `thermal-vias plan`+        // counts them: in the pad for a pad that takes vias, on the ring just outside it for a small pin+        let existing = vias_at_pad(board, p, &net, if fits_inside { 0.0 } else { 0.25 + 0.6 + 3.0 * 0.35 });+        let n = want.saturating_sub(existing);+        if existing > 0 { eprintln!("thermal vias at {key}: {existing} via(s) of {net} already at the pad count toward {want}; planning {n} more"); }+        let mut placed = 0;         if fits_inside {             for (dx, dy) in [(-1.2, 0.0), (1.2, 0.0), (-1.2, -1.3), (1.2, -1.3), (-1.2, 1.3), (1.2, 1.3), (0.0, -1.3), (0.0, 1.3), (0.0, 0.0)] {                 if placed >= n {@@ -230,7 +258,7 @@ pub fn build_with(board: &Board, spec: &Value, plan: Option<&Value>, planned: &[                     continue;                 }                 let (x, y) = (((p.x + dx) * 100.0).round() / 100.0, ((p.y + dy) * 100.0).round() / 100.0);-                if clear(x, y, &net, &blockers) && hole_clear(x, y, size, drill, &net, &holes, h2h, clearance) {+                if clear(x, y, &net, &blockers) && via_clear(x, y, size, drill, &net, &holes, h2h, clearance) {                     vias.push(via_entry(&net, x, y, size, drill));                     holes.push((x, y, size, drill, net.clone()));                     placed += 1;@@ -278,7 +306,7 @@ pub fn build_with(board: &Board, spec: &Value, plan: Option<&Value>, planned: &[                     (x - nx).hypot(y - ny) < vr + 0.1                 });                 let near_mine = mine.iter().any(|m| (m.0 - x).hypot(m.1 - y) < size + 0.3);-                if !near_other_pad && !near_own_pad && !near_mine && clear(x, y, &net, &blockers) && hole_clear(x, y, size, drill, &net, &holes, h2h, clearance) {+                if !near_other_pad && !near_own_pad && !near_mine && clear(x, y, &net, &blockers) && via_clear(x, y, size, drill, &net, &holes, h2h, clearance) {                     vias.push(via_entry(&net, x, y, size, drill));                     mine.push((x, y)); holes.push((x, y, size, drill, net.clone()));                     placed += 1;@@ -286,14 +314,14 @@ pub fn build_with(board: &Board, spec: &Value, plan: Option<&Value>, planned: &[             }         }         if placed < n {-            eprintln!("thermal vias at {key}: placed {placed} of {n}; no more room clear of other nets (add stitchVias by hand, or accept fewer)");+            eprintln!("thermal vias at {key}: {} of {want} ({existing} already there, {placed} planned); no more room clear of other nets and of the vias and holes already there (add stitchVias by hand, or accept fewer)", existing + placed);         }     }     for sv in spec.get("stitchVias").and_then(|v| v.as_array()).cloned().unwrap_or_default() {         let (Some(net), Some(x), Some(y)) = (sv.get("net").and_then(|n| n.as_str()), sv.get("x").and_then(|v| v.as_f64()), sv.get("y").and_then(|v| v.as_f64())) else { continue };         let (size, drill) = (sv.get("size").and_then(|v| v.as_f64()).unwrap_or(0.8), sv.get("drill").and_then(|v| v.as_f64()).unwrap_or(0.4));         // a stitch via on top of a heatsink via (or any hole) is a drill hit: left out, said why-        if !hole_clear(x, y, size, drill, net, &holes, h2h, clearance) { eprintln!("stitch via {net} at ({x:.2}, {y:.2}) left out: within the hole-to-hole minimum ({h2h} mm) or the clearance of a via or hole already there or planned"); continue; }+        if !via_clear(x, y, size, drill, net, &holes, h2h, clearance) { eprintln!("stitch via {net} at ({x:.2}, {y:.2}) left out: within the hole-to-hole minimum ({h2h} mm) or the clearance of a via or hole already there or planned"); continue; }         if clear(x, y, net, &blockers) {             vias.push(via_entry(net, x, y, size, drill));             holes.push((x, y, size, drill, net.to_string()));@@ -557,6 +585,48 @@ mod hole_tests {             assert!(build(&b, &spec, None).is_err(), "{bad}");         }     }+    /// A QFN with a 3.4 mm exposed pad U1.29 at (113, 82) on GND carrying 10 in-pad 0.5/0.25 vias+    /// (2 x 5, x 112.4 and 113.6), as board vias or as the footprint's own through-hole "29" pads.+    fn qfn(as_pads: bool) -> Board {+        let ys = [80.8, 81.4, 82.0, 82.6, 83.2];+        let mut fp_vias = String::new();+        let mut board_vias = String::new();+        for x in [112.4, 113.6] {+            for y in ys {+                if as_pads { fp_vias.push_str(&format!(" (pad \"29\" thru_hole circle (at {} {}) (size 0.5 0.5) (drill 0.25) (layers \"*.Cu\") (net 1 \"GND\"))", ((x - 113.0) * 10.0f64).round() / 10.0, ((y - 82.0) * 10.0f64).round() / 10.0)); }+                else { board_vias.push_str(&format!(" (via (at {x} {y}) (size 0.5) (drill 0.25) (layers \"F.Cu\" \"B.Cu\") (net 1))")); }+            }+        }+        Board::from_text("fixture", format!("(kicad_pcb (net 0 \"\") (net 1 \"GND\") (layers (0 \"F.Cu\" signal)(31 \"B.Cu\" signal)) (gr_rect (start 100 70)(end 126 94)(layer \"Edge.Cuts\")) (footprint \"QFN\" (layer \"F.Cu\") (at 113 82) (property \"Reference\" \"U1\") (pad \"29\" smd rect (at 0 0) (size 3.4 3.4) (layers \"F.Cu\") (net 1 \"GND\")){fp_vias}){board_vias})")).unwrap()+    }++    #[test]+    fn thermal_vias_count_and_clear_a_pads_existing_in_pad_vias() {+        // issue #83: count 12 planned three 0.8/0.4 vias 0.6 mm from the existing ones, count 10 the same+        for as_pads in [false, true] {+            let b = qfn(as_pads);+            let p = b.pads.iter().find(|p| p.key == "U1.29" && !p.thru).unwrap();+            assert_eq!(vias_at_pad(&b, p, "GND", 0.0), 10, "as pads: {as_pads}");+            let holes = board_holes(&b);+            for count in [10, 12] {+                let spec = json!({"thermalVias": [{"pad": "U1.29", "net": "GND", "count": count}]});+                let (_, vias, _) = build(&b, &spec, None).unwrap();+                if count == 10 { assert!(vias.is_empty(), "the 10 there already meet count 10: {vias:?}"); }+                for v in &vias {+                    let (x, y) = (v["paths"][0][0][0].as_f64().unwrap(), v["paths"][0][0][1].as_f64().unwrap());+                    for (hx, hy, hs, _, _) in &holes {+                        assert!((hx - x).hypot(hy - y) >= (0.8 + hs) / 2.0 + 0.2 - 1e-6, "planned via at ({x}, {y}) crowds the existing one at ({hx}, {hy})");+                    }+                }+            }+        }+        // the same pad bare: the planner still places its vias+        let bare = Board::from_text("fixture", "(kicad_pcb (net 0 \"\") (net 1 \"GND\") (layers (0 \"F.Cu\" signal)(31 \"B.Cu\" signal)) (gr_rect (start 100 70)(end 126 94)(layer \"Edge.Cuts\")) (footprint \"QFN\" (layer \"F.Cu\") (at 113 82) (property \"Reference\" \"U1\") (pad \"29\" smd rect (at 0 0) (size 3.4 3.4) (layers \"F.Cu\") (net 1 \"GND\"))))".into()).unwrap();+        let (_, vias, _) = build(&bare, &json!({"thermalVias": [{"pad": "U1.29", "net": "GND", "count": 3}]}), None).unwrap();+        assert_eq!(vias.len(), 3);+        assert!(!via_clear(111.8, 82.0, 0.8, 0.4, "GND", &[(112.4, 82.0, 0.5, 0.25, "GND".into())], 0.2, 0.2), "same net still keeps via-to-via spacing");+    }+     #[test]     fn mask_only_npth_is_a_board_hole_for_stitch_vias() {         let b = Board::from_text("fixture", "(kicad_pcb (net 0 \"\") (net 1 \"GND\") (layers (0 \"F.Cu\" signal)(31 \"B.Cu\" signal)) (gr_rect (start 0 0)(end 20 20)(layer \"Edge.Cuts\")) (footprint \"T:USBC\" (layer \"F.Cu\") (at 10 10) (property \"Reference\" \"J9\") (pad \"\" np_thru_hole circle (at 0 0) (size 0.65 0.65) (drill 0.65) (layers \"*.Mask\"))))".into()).unwrap();

@@ -44,7 +44,9 @@ impl Router {         let tracks: Vec<Track> = self.board.tracks().into_iter().filter(|t| t.width > 0.0).collect();         let vias: Vec<Via> = self.board.vias();         let zones = self.board.zones();-        if tracks.is_empty() && vias.is_empty() {+        // a board whose only copper is filled zones (a chassis pour joining through-hole pins, no+        // tracks or vias) still has connections made: read its islands too (issue #84)+        if tracks.is_empty() && vias.is_empty() && zones.iter().all(|z| z.fills.is_empty()) {             return;         }         let g = self.grid.clone();@@ -169,6 +171,19 @@ impl Router {         if self.nets[net].plane.is_some() { cc.via_or_zone } else { cc.copper }     } +    /// A plane net's cluster that its plane reaches with no stub and no via: a through-hole pad+    /// (on every layer), or a pad on the plane's own outer layer (an F.Cu pad on an F.Cu plane sits in+    /// that pour; issue #84). An inner-layer plane reaches only through-hole pads.+    pub fn on_plane(&self, net: usize, c: usize) -> bool {+        let p = &self.board.pads[self.nets[net].clusters[c].primary];+        if p.thru { return true; }+        match self.nets[net].plane.as_deref() {+            Some("F.Cu") => p.on_f,+            Some("B.Cu") => p.on_b,+            _ => false,+        }+    }+     /// Mark every cluster of the net in the same fixed-copper group as `c` connected; returns them.     pub fn connect_group(&mut self, net: usize, c: usize) -> Vec<usize> {         let comp = self.comp_of(net, c);@@ -345,4 +360,71 @@ pub(crate) mod tests {         assert!(r.nets[r.net_ids["A"]].done_by_board);         assert_eq!(nets_in(&plan), vec!["B".to_string()]);     }++    /// A zone of `net` over the whole board on `layer`, filled or not.+    fn full_zone(net: &str, layer: &str, filled: bool) -> String {+        let fill = if filled { format!("\t\t(filled_polygon\n\t\t\t(layer \"{layer}\")\n\t\t\t(pts\n\t\t\t\t(xy 0.5 0.5) (xy 19.5 0.5) (xy 19.5 9.5) (xy 0.5 9.5)\n\t\t\t)\n\t\t)\n") } else { String::new() };+        format!("\t(zone\n\t\t(net \"{net}\")\n\t\t(layer \"{layer}\")\n\t\t(polygon\n\t\t\t(pts\n\t\t\t\t(xy 0.5 0.5) (xy 19.5 0.5) (xy 19.5 9.5) (xy 0.5 9.5)\n\t\t\t)\n\t\t)\n{fill}\t)\n")+    }++    // issue #84: a mechanical carrier, four through-hole GND pins and GND filled on both layers, no+    // tracks or vias. The pour joins them: route plans nothing (it planned 393 mm of track).+    const PINS: [(&str, &str, f64, f64, bool); 4] = [("H1", "GND", 2.0, 2.0, true), ("H2", "GND", 18.0, 2.0, true), ("H3", "GND", 2.0, 8.0, true), ("H4", "GND", 18.0, 8.0, true)];++    #[test]+    fn filled_zones_alone_join_a_net_with_no_tracks_or_vias() {+        let zones = full_zone("GND", "F.Cu", true) + &full_zone("GND", "B.Cu", true);+        let (r, plan, report, failed) = route(board(&PINS, &zones));+        assert_eq!(failed, 0);+        assert!(plan.is_empty(), "{plan:?}");+        assert!(r.nets[r.net_ids["GND"]].done_by_board);+        assert_eq!(report["boardCopper"]["netsComplete"], serde_json::json!(["GND"]));+        assert_eq!(report["boardCopper"]["zoneIslands"], 2);+        assert!(report["boardCopper"]["warnings"].as_array().unwrap().is_empty());+    }++    #[test]+    fn a_fill_on_one_side_joins_only_the_pads_it_reaches() {+        // the F.Cu fill reaches the left pair only; the right pair is planned, and nothing more+        let left = "\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 0.5 0.5) (xy 6 0.5) (xy 6 9.5) (xy 0.5 9.5)\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 0.5 0.5) (xy 6 0.5) (xy 6 9.5) (xy 0.5 9.5)\n\t\t\t)\n\t\t)\n\t)\n";+        let (r, _, report, failed) = route(board(&PINS, left));+        assert_eq!(failed, 0);+        let g = r.net_ids["GND"];+        assert!(!r.nets[g].done_by_board);+        assert_eq!(r.nets[g].routes.len(), 2, "three groups (the joined left pair, H2, H4): two connections");+        assert_eq!(report["boardCopper"]["netsPartial"], serde_json::json!(["GND"]));+    }++    #[test]+    fn an_unfilled_zone_of_a_tracked_net_is_warned() {+        let zones = full_zone("GND", "F.Cu", false) + &full_zone("GND", "B.Cu", false);+        let (_, plan, report, failed) = route(board(&PINS, &zones));+        assert_eq!(failed, 0);+        assert!(!plan.is_empty(), "no fill: nothing joins the pins yet");+        let w = report["boardCopper"]["warnings"].as_array().unwrap();+        assert_eq!(w.len(), 1, "{w:?}");+        let w = w[0].as_str().unwrap();+        assert!(w.starts_with("GND has a zone on B.Cu and F.Cu with no fill") && w.contains("refill"), "{w}");+    }++    #[test]+    fn a_pad_on_its_outer_layer_plane_gets_no_via() {+        // issue #84: planes {"GND": "F.Cu"} on a 2-layer board; TP1 is an F.Cu pad on the F.Cu plane+        let pads = [("H1", "GND", 2.0, 2.0, true), ("TP1", "GND", 10.0, 5.0, false), ("H2", "GND", 18.0, 8.0, true)];+        for (plane, vias) in [("F.Cu", 0usize), ("B.Cu", 1)] {+            let zone = full_zone("GND", plane, false);+            let mut rules = Rules::default();+            rules.planes.insert("GND".into(), plane.into());+            let mut r = Router::new(board(&pads, &zone), rules, false);+            let (plan, _, failed) = crate::drive::route_board(&mut r, 2, 4, 50);+            assert_eq!(failed, 0, "{plane}");+            let g = r.net_ids["GND"];+            let planned_vias = plan.iter().map(|e| e["paths"].to_string().matches("\"layer\"").count()).sum::<usize>();+            if vias == 0 {+                assert!(plan.is_empty() && r.nets[g].routes.is_empty(), "{plane}: {plan:?}");+            } else {+                assert!(planned_vias >= 1 || !r.nets[g].via_in_pad.is_empty(), "{plane}: an F.Cu pad reaches a B.Cu plane through a via: {plan:?}");+            }+        }+    } }