OpenAI Codex + konnect-codex end-to-end KiCad benchmark: safe-parts run reached manufacturing exports (63/100 PARTIAL)

[neusse]

Important

This is a hands-on Codex evaluation, not a maintainer-authored compatibility claim.
I used Konnect v0.6.0, KiCad 10.0.5 on Windows, the standalone
konnect-codex v0.6.0 companion
plugin, Konnect's MCP tools, the installed Freerouting ActionPlugin 2.3.0, the
current JLCPCB database, actual KiCad UI/IPC behavior, and the generated project
artifacts. The report includes successful operations, failed calls, unsafe false
positives, GUI fallbacks, and defects encountered during the run. Nothing below
should be read as a claim that the generated board is ready to order.

Result

Overall: PARTIAL — 63/100
END_TO_END: FAIL — the board is not manufacturing-ready
KONNECT_ONLY: FAIL — revision-checked PCB transfer corrupted footprint contents

The modified safe-parts benchmark achieved its first objective: it avoided the
repeatable native KiCad crash and progressed through a complete schematic, PCB
placement, autonomous Freerouting invocation, GND zone creation/refill, DRC, review,
3D rendering, STEP export, and JLCPCB Gerber/BOM/CPL/drill generation.

It did not pass. The benchmark exposed a non-crashing but severe transfer-integrity
failure, routing-rule propagation problems, a remaining unrouted connection, 25 DRC
errors after required widths were enforced, misleading review/manufacturing approval,
and several export/package defects.

3D result

The 1800 x 1200 image was rendered from the final saved .kicad_pcb. It confirms
that the board outline, mounting holes, passive placement, SOIC-8 timer, LED, copper,
and silkscreen exist. It also exposes an additional artifact problem: the USB-C
footprint's pads and shell holes are visible, but its connector body did not render,
despite the library preflight reporting a 3D model. That suggests a model-path or
model-resolution gap that deserves separate verification.

Benchmark change: fixed crash-controlled part profile

The original benchmark allowed the agent to choose among suitable in-stock parts.
That made crash reproduction depend on which standard footprint happened to be
selected. The revised prompt uses a fixed allowlist and performs a footprint-graphics
preflight before placement. Footprints containing unsupported user layers
(Dwgs.User, Cmts.User, Eco1.User, Eco2.User), undefined layers, or unsupported
graphic types are rejected before live IPC creation.

References	Function	Manufacturer / MPN	LCSC	Library	Observed stock	Required KiCad footprint
J1	USB-C 5 V sink	Korean Hroparts Elec / TYPE-C-31-M-12	C165948	Extended	433,835	Connector_USB:USB_C_Receptacle_HRO_TYPE-C-31-M-12
U1	555 timer	Texas Instruments / NE555DR	C7593	Preferred	208,546	Package_SO:SOIC-8_3.9x4.9mm_P1.27mm
R1,R2	5.1 kΩ 1% CC pull-downs	UNI-ROYAL / 0402WGF5101TCE	C25905	Basic	9,631,725	Resistor_SMD:R_0402_1005Metric
R3	10 kΩ 1%	UNI-ROYAL / 0402WGF1002TCE	C25744	Basic	5,923,201	Resistor_SMD:R_0402_1005Metric
R4	68 kΩ 1%	UNI-ROYAL / 0603WAF6802T5E	C23231	Basic	1,827,747	Resistor_SMD:R_0603_1608Metric
R5	1 kΩ 1% LED resistor	UNI-ROYAL / 0402WGF1001TCE	C11702	Basic	16,776,856	Resistor_SMD:R_0402_1005Metric
C1,C2	10 µF 25 V X5R	Samsung / CL21A106KAYNNNE	C15850	Basic	9,692,293	Capacitor_SMD:C_0805_2012Metric
C3	100 nF 16 V X7R	Samsung / CL05B104KO5NNNC	C1525	Basic	37,305,636	Capacitor_SMD:C_0402_1005Metric
C4	10 nF 50 V X7R	Samsung / CL05B103KB5NNNC	C15195	Basic	9,333,939	Capacitor_SMD:C_0402_1005Metric
D1	Red 0603 LED	Hubei KENTO / KT-0603R	C2286	Basic	6,369,008	LED_SMD:LED_0603_1608Metric

All seven unique footprint families passed the layer/graphics preflight. The selected
graphics used only F.Silkscreen, F.Courtyard, and F.Fab, with supported line,
polygon, and rectangle primitives. This profile avoided the Dwgs.User/undefined
layer failure described in issue #237
and the related broad mapping work in
PR #232.

The result is important: avoiding the native crash did not make transfer correct.
It revealed a second failure mode—silent semantic corruption—that the crash had
previously hidden.

What konnect-codex contributed

This run used the standalone konnect-codex plugin rather than relying on generic
MCP tool descriptions alone. The plugin supplied Codex-native routing for KiCad work,
project-integrity rules, schematic/PCB/library/manufacturing workflows, verification
order, stop conditions, and explicit handling of the Freerouting exception.

The plugin materially improved the run:

• it forced the preflight of exact footprint graphics/layers before live creation;
• it kept all protected KiCad source and table writes on Konnect tools;
• it required revision-checked dry-run/apply transfer rather than blind mutation;
• it required verification after every high-risk PCB step;
• it detected that the apparent successful transfer was structurally wrong;
• it kept the PCB editor isolated from the schematic editor after a previous
  cross-editor/native-update crash state;
• it invoked the installed Freerouting ActionPlugin autonomously rather than asking a
  person to click it;
• it refused to treat LOOKS GOOD or READY as authoritative when DRC disagreed; and
• it preserved failed gates in the final score instead of hiding them with fallbacks.

The plugin does not patch Konnect or replace its server implementation. It improves
how Codex uses and validates Konnect. This benchmark shows why those are different
jobs: the companion can prevent unsafe claims and choose a safer sequence, but it
cannot make a corrupt IPC payload correct.

Gate table

Gate	Status	Evidence / exact blocker
SOURCING	PARTIAL	All ten unique LCSC records were found in the 770,682-part database, in stock, with matching MPN/package. All seven footprint families passed crash-control preflight. get_datasheet_url later returned null for all ten IDs even though datasheet information is present in the catalog/schematic flow.
SCHEMATIC	PASS	14 symbols including two power flags, 9 named nets, 0 ERC errors/warnings, 0 shorts, 0 single-pin nets, valid component/wire connectivity, and 0 overlaps.
TRANSFER	FAIL	Konnect's dry-run succeeded and the exact returned revision was applied, but footprint graphics became phantom unnamed pads: 128 pads instead of 50. U1 became 28 pads and J1 became 35 pads, both with zero graphics.
PCB	FAIL	Native diagnostic transfer allowed later testing. Final board: 45 x 30 mm, 14 footprints, two holes, filled B.Cu GND zone, 100 segments, 13 vias, 15 named nets. Final DRC: 25 errors / 7 warnings; KiCad: 1 unrouted.
REVIEW	FAIL	run_design_review returned complete/LOOKS GOOD and validate_for_manufacturing returned READY, both with zero issues, despite the real DRC failures and unrouted item. Review board coverage also said pads: 0.
OUTPUTS	PARTIAL	Schematic PDF, STEP, Gerbers, separate PTH/NPTH drills, BOM, CPL, and 3D render are non-empty. PCB PDF/SVG failed; the reported PCB snapshot path did not exist; CPL includes mounting holes and appears to use inch coordinates without a unit declaration.
INTEGRITY	FAIL	No protected KiCad source/table was manually patched. Freerouting was the declared direct-write exception. Native KiCad transfer and extra GUI open/reopen actions were disclosed diagnostic fallbacks and therefore fail the strict integrity gate.

Detailed execution and findings

1. Catalog and footprint preflight worked, with two inspection gaps

Konnect's local JLCPCB database reported 770,682 parts. Every selected LCSC record was
retrieved by exact ID with manufacturer, MPN, package, library class, price, and stock.
The final BOM contains all ten expected grouped entries and all LCSC IDs.

Two inconsistencies remain:

1. get_datasheet_url returned null for every exact C-number. Earlier inspection of
   the downloaded database showed that its components.Datasheet column already
   contains the exact LCSC PDF URLs, so the resolver is not using data that is already
   available locally. The catalog query tools also omit that column.
2. get_footprint_info found the selected library footprints but reported
   pad_count: 0. Live/native board inspection later proved the parts have pads. The
   benchmark therefore had to validate graphics separately and compare live transfer
   counts after creation.

2. Project and schematic creation succeeded

A fresh project was created without overwriting the earlier crashed project. Project
symbol and footprint libraries were registered through Konnect. The schematic contains
the USB-C power sink, independent 5.1 kΩ CC pull-downs, NE555 astable, timing network,
control bypass capacitor, LED/resistor, explicit USB data/SBU no-connects, and two power
flags. The calculated nominal frequency was added to the sheet:

f = 1 / (0.693 × (10 kΩ + 2 × 68 kΩ) × 10 µF) ≈ 0.99 Hz

Final schematic checks agreed on the electrical result:

• 9 named nets: CC1, CC2, CONTROL, DISCH, GND, LED_A, LED_DRIVE, TIMING, VBUS_5V;
• ERC: 0 errors / 0 warnings;
• short detector: 0;
• component connection validation: valid;
• wire validation: valid;
• overlap detector: 0;
• connection audit: 0 findings; and
• single-pin net check: 0.

3. Schematic-editing tools still disagree about direct pin labels

Direct labels placed exactly on pins produced a correct netlist and passed ERC, wire
validation, component validation, short detection, and the connection audit.
find_orphan_items, however, reported all 35 as floating labels.

An attempted workaround changed them to 2.54 mm labelled stubs. That exposed a second
problem: adjacent automatically oriented R1/R2 vertical stubs met at their midpoint
and briefly shorted CC2 to GND. Konnect's short detector caught it. The temporary 35
labels and 35 wires were deleted through Konnect and the validated direct-label form
was restored.

This is not just cosmetic. A strict agent needs a single reliable definition of
connectivity. The orphan checker should use the same pin-endpoint semantics as ERC and
the dedicated validators, and automatic stub placement should collision-check before
committing.

4. Custom fields could not be created in bulk

batch_edit_schematic_components correctly edited standard existing fields such as
Footprint and Datasheet but rejected Manufacturer, MPN, and LCSC because those custom
fields did not yet exist. All 36 custom annotations were added individually using
add_component_annotation.

That is contract-consistent, but expensive and awkward. A bulk create-or-update custom
field operation would substantially simplify sourced designs and reduce partial-write
risk.

5. Launcher/document targeting remains unreliable

launch_kicad_ui with the project opened KiCad Project Manager, not PCB Editor. The
first transfer dry-run failed with GetOpenDocuments AS_UNHANDLED because no board
document was open. Passing the .kicad_pcb path to the same launcher opened another
project-manager error rather than PCB Editor. Launching standalone pcbnew.exe did not
produce the IPC socket needed by Konnect.

The strict benchmark permits GUI automation only for Freerouting, so this already
prevents a clean pass. For diagnostic continuation, Codex opened the PCB file from the
project manager. A dedicated launch_pcb_editor/open_board operation should target
the requested document and wait until that exact document owns a ready IPC endpoint.

6. Revision-checked transfer did not crash—but corrupted every complex footprint

Once PCB Editor was open, update_pcb_from_schematic dry-run returned a valid plan
revision and proposed 12 footprint additions with no conflicts. Applying that exact
revision completed without a native KiCad crash.

The result was semantically invalid:

• expected electrical/mechanical pads before mounting holes: 50;
• actual pads after Konnect transfer: 128;
• U1: 28 pads instead of 8, including 20 unnamed pads at (0,0);
• J1: 35 pads instead of 22, including 13 unnamed pads;
• U1 footprint graphics: 0 instead of 20; and
• J1 footprint graphics: 0 instead of 13.

The count relationship is exact: graphic primitives were serialized/deserialized as
phantom pads. This is a dangerous failure because the transaction reported success and
did not crash. A post-apply invariant check must compare expected and actual footprint
pad/graphic counts before reporting success. Ideally the entire transfer should roll
back when those invariants fail.

The corrupted footprints were removed through Konnect. Native KiCad Update PCB from
Schematic was then used as a disclosed diagnostic fallback. KiCad reported zero
transfer warnings/errors and produced the correct result: 50 pads, 15 nets, U1 with 8
pads/20 graphics, and J1 with 22 pads/13 graphics.

7. Native transfer/cross-editor state can destabilize later IPC writes

During earlier narrowing, KiCad crashed after a native update when both schematic and
PCB editors had been involved. Official KiCad issue
#24966 documents a closely related
Windows failure where the first PCB IPC write can terminate KiCad when both editors are
open and no interactive PCB edit has occurred.

For this run, all KiCad editors were closed after native transfer, stale lock files were
moved to a recoverable folder, and only PCB Editor was reopened. Sequential live writes
then succeeded: board outline, twelve footprint moves, two mounting holes, four
silkscreen strings, rule changes, and netclass assignment. KiCad remained responsive.

This supports two separate conclusions:

• the original Dwgs.User/invalid-layer crash is avoidable with the controlled parts;
  and
• editor/open-document state is independently important for first-write reliability.

8. Placement and mechanical checks reached a clean pre-route state

The board was set to 45 x 30 mm. J1 was placed at the front edge, the LED at the
opposite edge, C3 within 5 mm of the NE555 supply pins, all assembled parts on the top,
and two 3.2 mm NPTH mounting holes at the rear corners. The board used 0.20 mm minimum
clearance, 0.25 mm minimum signal width, 0.60/0.30 mm vias, and a 0.50 mm VBUS netclass.

After moving C3 and shifting J1 away from the edge, placement DRC reached 0 errors and
four warnings: clipped silkscreen, one HRO library mismatch, and two mounting-hole
library-not-found warnings. JLCPCB DFM audit returned zero findings.

9. Freerouting ActionPlugin worked autonomously

Codex opened KiCad's Tools > External Plugins > Freerouting menu, launched the
installed Freerouting 2.3.0 ActionPlugin, waited for its Java routing workflow, and
verified the imported live board through Konnect. No person clicked anything and the
disabled Konnect autoroute handler was not used.

Freerouting imported:

• 100 track segments;
• 13 through vias; and
• routes for all nine named electrical nets.

KiCad stayed alive. This is meaningful progress beyond the prior run, which never
reached PCB Editor or routing.

10. Routing rules were not carried into the DSN

The generated temp-freerouting.dsn contained a 0.20 mm default width. The imported
route used 0.20 mm and 0.15 mm segments even though the benchmark required 0.25 mm
signals and a 0.50 mm VBUS netclass. The project-level minimum constraint did not cause
the ActionPlugin's DSN export to use the required default width, and the VBUS class was
not reflected in the route.

All 100 segments were modified sequentially through Konnect: signals to 0.25 mm and
VBUS to 0.50 mm. Width errors disappeared, but the widened geometry produced 25 real
clearance violations, some as small as 0.0694 mm. This cannot be repaired by lowering
the board rule without violating the benchmark.

The routing workflow needs one of the following:

1. propagate KiCad's loaded Default and named netclass widths into DSN;
2. expose explicit pre-route Freerouting width/clearance configuration; or
3. validate imported widths and automatically reroute before accepting the SES.

11. The filled GND zone did not produce a clean final board

A B.Cu GND pour was added through Konnect over the board interior and refilled through
live IPC. The rendered board and B.Cu Gerber show the zone. KiCad still reported one
unrouted item. Final DRC reported:

• 25 clearance errors;
• 3 vias connected on only one layer/unconnected;
• 1 clipped silkscreen item;
• 1 HRO footprint/library mismatch; and
• 2 missing mounting-hole library references.

The board must not be sent to fabrication or assembly in this state.

12. Review and manufacturing validation failed open

This was the most serious verification issue after transfer corruption.

run_design_review returned:

• status: complete;
• verdict: LOOKS GOOD — no critical issues found;
• errors: 0;
• warnings: 0; and
• board coverage: 14 footprints, 15 named nets, 0 pads.

validate_for_manufacturing(fab_house="jlcpcb") returned:

• verdict: READY;
• issues: 0;
• 14 footprints; and
• 113 tracks (100 segments plus 13 vias).

Those approvals conflict with a DRC that reports 25 errors and with KiCad's one
unrouted item. A non-empty board with zero reported pads should make review coverage
INCOMPLETE, not complete. Manufacturing validation must consume DRC/unrouted state or
run equivalent checks itself. Passing open here is unsafe because it produces exactly
the language an automation client might use to authorize an order.

13. BOM health passed, but datasheet evidence remains inconsistent

check_bom_health reported twelve assembled components, zero issues, zero missing
footprints, zero missing values, and zero missing MPNs. The generated grouped JLCPCB
BOM contains all expected C-numbers.

However, the dedicated datasheet resolver returned null for all ten exact LCSC IDs.
The run used the HRO connector PDF, the TI NE555 datasheet already carried by the KiCad
symbol, and exact catalog data. The local catalog's Datasheet field should be the first
resolver source, with the web API only as a fallback.

14. Manufacturing package generation returned success but needs stronger QA

export_manufacturing_package reported 24 entries and no warnings. Non-empty outputs
included F.Cu/B.Cu Gerbers, masks, paste, silkscreen, Edge.Cuts, separate PTH and NPTH
drills, BOM, CPL, and job file.

Problems found by inspecting the files rather than trusting the success message:

• positions.csv includes H1 and H2 even though mounting holes should be excluded from
  the assembly position file;
• position values such as J1 X=4.822835, Y=-4.145669 correspond to the board's
  millimetre coordinates converted to inches, but the CSV has no unit declaration;
  this is unsafe for a JLCPCB upload unless the exporter guarantees the receiving
  format interprets inches;
• the CPL has negative Y values and no explicit auxiliary-origin explanation;
• the package includes many non-production layers (Adhesive, Courtyard, Fab,
  Margin, User_Comments, and User_Drawings) that are unnecessary and can confuse
  a turnkey upload; and
• package success did not mention the failing DRC or unrouted item.

The BOM itself was the strongest output: ten grouped rows, correct designators/values,
footprints, and all LCSC numbers.

15. Board PDF/SVG export and snapshot reporting were inconsistent

Schematic PDF export succeeded. STEP export succeeded and produced a 575,242-byte
model. The 3D PNG render succeeded. Board PDF and board SVG export both failed with
kicad-cli exited with 1 and empty stderr, leaving no actionable diagnosis.

snapshot_project returned a pcb_snapshot path and a combined snapshot path. The
reported PCB PDF did not exist on disk; only the combined/schematic-sized PDF existed.
Snapshot creation should verify every reported artifact exists and is non-empty before
returning success.

16. Parent output directory handling was brittle

The first DRC call with an output path failed because the requested reports
directory did not yet exist. Creating the directory and rerunning succeeded. Export
and report tools should either create their narrowly scoped parent directory or return
a structured missing-parent error that names it.

17. The 3D render revealed a model-resolution problem

The selected footprint preflight indicated a 3D model and the STEP export completed,
but the HRO USB-C connector body is absent in the final 3D image. The pads, shell
mounting holes, and outline are present. This may be a missing ${KICAD10_3DMODEL_DIR}
resolution, a footprint model-path mismatch, or a model omitted during render/export.
The preflight should resolve and validate the actual model file, not only report that a
model entry exists.

Verification summary

• JLCPCB database: 770,682 parts.
• Selected unique LCSC records: 10; all observed in stock.
• Schematic symbols: 14 including two power flags.
• Schematic named nets: 9.
• ERC: 0 errors / 0 warnings.
• Connection/short/overlap checks: 0 findings.
• Board: 45.0 x 30.0 mm, 2 copper layers.
• Board footprints: 14 (12 assembled + 2 mounting holes).
• Correct native-transfer pads: 50 electrical/mechanical pads before mounting holes.
• Final named board nets: 15, including six explicit USB unconnected nets.
• Routing: 100 track segments, 13 vias.
• Unrouted: 1.
• Final DRC: 25 errors / 7 warnings.
• GND zone: B.Cu, filled.
• DFM audit: 0 findings (not sufficient to override DRC).
• BOM health: 12 components / 0 issues.
• Design review API: complete / LOOKS GOOD / 0 pads reported.
• Manufacturing validation API: READY / 0 issues, conflicting with DRC.
• Five-board beta cost estimate: $13.71 total / $2.74 per board.
• Generated manufacturing entries: 24.
• STEP: 575,242 bytes.
• 3D PNG: 714,151 bytes.

Artifact results

Artifact	Result
.kicad_pro	Created, non-empty
.kicad_sch	Created, non-empty, ERC clean
.kicad_pcb	Created, placed/routed/zoned, but not DRC clean
Schematic PDF	Success, non-empty
Board 3D PNG	Success, embedded above
STEP	Success, non-empty
JLCPCB BOM	Success; correct grouped C-numbers
JLCPCB CPL	Generated; mounting-hole and unit/origin concerns
Gerbers	Generated, non-empty; includes unnecessary tech/user layers
PTH drill	Success, non-empty
NPTH drill	Success, non-empty
Board PDF	Failed with empty stderr
Board SVG	Failed with empty stderr
PCB snapshot PDF	Reported success path did not exist
Final DRC JSON	Success; 25 errors / 7 warnings

Tool and fallback disclosure

Konnect operations used across the run included configuration/toolbox discovery,
project creation, library registration, JLCPCB database inspection, exact part lookup,
symbol/footprint search and inspection, schematic placement and annotation, net and
no-connect creation, ERC/connectivity/short/orphan/overlap audits, revision-checked
PCB transfer, component deletion/recovery, board sizing, placement, holes, text,
design rules, netclasses, DRC, live trace queries and modifications, GND pour/refill,
design review, BOM health, manufacturing validation/DFM, cost estimate, 2D/3D view,
STEP/PDF/SVG/snapshot exports, and the full manufacturing package export.

Freerouting ActionPlugin 2.3.0 was invoked through KiCad's External Plugins menu and
was the declared permitted outside writer for route application. Konnect's disabled
autoroute handler was not called and DSN/SES files were not manually exchanged.

Disclosed strict-benchmark fallbacks:

• GUI automation was needed to open/reopen PCB Editor because Konnect launched only
  Project Manager;
• native KiCad Update PCB from Schematic was used after Konnect's transfer corruption,
  solely to continue independent downstream gates; and
• KiCad CLI was used after the benchmark to produce the 3D PNG embedded in this report.

No .kicad_pro, .kicad_sch, .kicad_pcb, .kicad_sym, .kicad_mod,
fp-lib-table, or sym-lib-table was manually patched, repaired, or generated.

Recommended implementation order

P0 — transfer correctness and fail-closed validation

1. Fix footprint child-item serialization/deserialization so shapes/text remain
   shapes/text and unsupported layers cannot become undefined layer indices.
2. Add exact regression fixtures for U1 SOIC-8 and HRO TYPE-C-31-M-12 verifying pad,
   text, line, rectangle, polygon, courtyard, fab, silk, and model counts.
3. Make revision-checked transfer compare expected/actual footprint pad and graphic
   counts before committing or reporting success.
4. Make design review and manufacturing validation fail when DRC has errors, KiCad has
   unrouted items, extraction unexpectedly reports zero pads, or any required coverage
   source failed.

P1 — launch, routing, and package correctness

5. Add a document-specific launch_pcb_editor/open_board operation that waits for
   the exact board's IPC endpoint.
6. Carry loaded Default/named netclass widths and clearances into the Freerouting DSN
   or expose explicit routing constraints in the ActionPlugin flow.
7. Validate imported SES widths/clearances before accepting the route.
8. Exclude mounting holes and all exclude_from_pos_files footprints from CPL.
9. Emit JLCPCB CPL in explicit documented units and verify origin/axis conventions.
10. Restrict the JLCPCB Gerber set to production layers unless extra layers are
    explicitly requested.

P2 — evidence and usability

11. Resolve datasheets from the local catalog by LCSC ID/MPN before web fallback.
12. Fix get_footprint_info pad counts and validate model paths actually resolve.
13. Make orphan detection share ERC/pin-endpoint semantics and collision-check
    automatic net stubs.
14. Add bulk create-or-update custom component fields.
15. Preserve kicad-cli stderr for PDF/SVG failures and verify snapshot paths.
16. Create scoped output parent directories or return precise structured errors.

Bottom line

The safe-parts change was worth doing. It converted an opaque native KiCad crash into a
much more informative full-stack run and proved that konnect-codex can guide Codex
through sourcing, schematic capture, live placement, autonomous ActionPlugin routing,
zone fill, verification, and manufacturing export without hiding failures.

The result also shows why a successful tool call is not enough. Konnect currently has
at least two fail-open paths in this workflow: transfer can report success while
destroying footprint semantics, and review/manufacturing validation can approve a board
with 25 DRC errors and one unrouted item. Those should be addressed before calling the
end-to-end workflow production-ready.

The generated board and package are retained as diagnostic artifacts only. Do not
manufacture this revision.

[mixelpixx]

Thank you for this. I've gone through every claim against the source rather than taking them on trust, and the headline finding is real, worse than you measured, and now fixed. Verdicts and root causes below, including one correction to the report and one place where I have to disagree with my own earlier assumption.

The transfer corruption — CONFIRMED, and it is the whole bug

crates/konnect-core/src/tools/pcb_sync.rs:926, apply_footprint_fields:

for child in &mut definition.items {
    let Ok(mut pad) = kiapi::board::types::Pad::decode(child.value.as_slice()) else {
        continue;
    };
    ...
    *child = pack_any(&pad, "kiapi.board.types.Pad");
}

A footprint definition keeps pads, graphics and text in one repeated Any field. This loop never looked at child.type_url; it used "did Pad::decode succeed" as its filter. proto3 skips field numbers it does not recognise rather than failing, so a BoardGraphicShape decodes cleanly as a near-empty Pad — and the last line then wrote it back as a pad.

Your numbers fall straight out of the wire format. Pad.number is tag 3, which a graphic leaves unset, so the extras are nameless. Pad.position is tag 7, which BoardGraphicShape has no counterpart for, so they all land at (0,0). N graphics → N nameless pads at the origin, graphics → 0. Exactly U1's 8→28 and J1's 22→35.

Two things the report did not have:

• The add path is affected too. build_mutation_items calls the same function for brand-new footprints, so they were corrupted before ever being sent. You only saw the update path because your transfer was all additions into a board that then got replaced.
• place_component is not affected. It goes straight from build_footprint_item to create_items and never touches this function. So the corruption is specific to update_pcb_from_schematic, which narrows what anyone with an existing board needs to re-check.

One detail I measured while writing the regression test, because it explains something your report implied but didn't state: BoardText genuinely fails to decode as a Pad, while BoardGraphicShape succeeds. That is why the footprints lost their artwork but kept their reference and value text.

Why 874 tests missed it: the only unit test for this path builds its fixture with build_footprint_item(..., &[pad], &[], ...) — empty graphics. A fixture that cannot exhibit the bug cannot catch it.

Fixed in 2904841: discriminate on the type URL via a new builders::any_is, and treat a child that declares itself a pad and won't decode as an error rather than something to step over — that silent skip turned an unreadable pad into a misleading "footprint has no pad N" further down. transform.rs already did this correctly and now shares the helper.

I swept for the same pattern and found three more sites. All are now type-checked, but I want to be precise rather than claim four bugfixes: none of the other three was reachable. A pad decoded as a graphic carries no net, so snapshot_board's filter drops it; and Pad.id is tag 1 while BoardGraphicShape.id is tag 4, so a pad's KIID never lands where set_footprint_graphic_points' uuid comparison would match it. Those are accidents of the current schema, which is the argument for the checks — not for calling them fixes.

Review and manufacturing failing open — CONFIRMED, both of them

This is the finding I think matters most, because as you say it produces exactly the language an automation client would use to authorise an order.

Neither tool had ever consulted DRC. A search for drc in design_review.rs returns nothing; run_design_review ran four schematic audits plus a DFM check and reported their silence as approval. validate_for_manufacturing's only routing check is net_count > 3 && track_count == 0 (manufacturing.rs:355) — it fires on a board with zero tracks, so your board routed-except-one-net walked past it.

And pads: 0 is worse than a wrong number. inspect_board_coverage called find_all("pad") on the board root; SexpNode::find_all is direct-children-only and pads are nested inside each (footprint …). It is structurally always zero, for every board, on every review since that block was added. #185's fail-closed guard checks footprints == 0 and named_nets == 0 and never pads, so the impossible count sailed through to complete.

Fixed across d5774b3 and 977f0c5:

• pads counted per footprint, via a new konnect_sexp::board so there is one definition; zero_pads added to the coverage guard.
• both tools now run DRC when a board is in scope and fold errors, unconnected items and schematic parity into the verdict.
• when DRC cannot run, the verdict is INCOMPLETE / NOT READY with a diagnostic naming the missing evidence — not a positive verdict that quietly means "clean except for what I didn't check". The DRC summary is null rather than zeroed, so neither response can imply a board it never checked.

Schematic-only reviews are unchanged; DRC is required when a board is in scope, not always.

Verified live on your exact case. I took the ecc83-pp demo and removed one track segment, leaving the board otherwise routed — routed-except-one-net, which is the situation your run was in. Through the real binary against real kicad-cli:

"board_info": { "footprint_count": 15, "net_count": 13, "track_count": 58 },
"drc": { "design_rule_violations": 18, "unconnected_items": 1, "errors": 1 },
"verdict": "NOT READY"

And the reason the old code said READY for that board is worth spelling out, because both halves had to fail together: the 18 design-rule violations are all warnings — the single error is the unconnected item, which run_drc was throwing away — and track_count is 58, so the track_count == 0 heuristic never fired. Neither check could see it.

run_design_review on the same board now reports pads: 33 (the real count in that file, previously structurally 0) and errors: 1, with the finding carrying its rule key and location.

The unrouted item was invisible to everything — CONFIRMED, and this one you didn't file

Chasing "KiCad says 1 unrouted, Konnect says clean" found a third defect. kicad-cli pcb drc --format json emits three sibling arrays; cli.rs:188 read violations and dropped unconnected_items and schematic_parity on the floor. An unrouted net is reported under unconnected_items, at severity error.

Measured rather than inferred: I took the bundled ecc83-pp demo, stripped its 59 track segments, and ran real kicad-cli. 17 violations, 14 unconnected items, all error. Konnect's error count for that board was zero. The checked-in fixture is that output, trimmed to two entries per category and otherwise untouched.

Two more things the same look at real output turned up:

• pos was read from a top-level field the schema has never had, so every reported violation position was null. KiCad puts a position on each involved item.
• the rule key ("type") was dropped entirely. It is the only part of a violation a caller can act on — you fix or waive a rule, not a sentence.

Fixed in e7eeeac. A missing violations key is now an error rather than an empty list, because an empty list renders exactly like a clean board.

A correction: stderr is not dropped

Board PDF and board SVG export both failed with kicad-cli exited with 1 and empty stderr, leaving no actionable diagnosis.

Konnect does capture it — cli.rs:49-85 puts stderr straight into the error text. The empty stderr was kicad-cli's own.

The likely cause is in your other discussion (#224): PDF and SVG pass repeated --layers <layer> flags where KiCad 10 defines --layers as one comma-separated value. DXF gets it right, and its doc comment asserts the opposite for pdf/svg — the belief that produced the bug is written down next to it. That also explains snapshot_project handing you a path that didn't exist: it calls the same export_pdf and discards the result with let _ =.

Filed as #250 and #252; not fixed this round.

Everything else, filed with evidence

All confirmed, all with the file and line:

#248	get_footprint_info pad_count: 0 — library.rs:3580 matches the literal "\n (pad ". Real footprints are tab-indented and CRLF; both misses. The fixture is Konnect's own 2-space output, so the suite could never catch it.
#249	find_orphan_items never looks at pin positions at all — "floating" means "no wire endpoint here", so every label-on-pin is a false positive. Every other validator uses the union-find net graph.
#250	the --layers shape, plus SVG riding a deprecated implicit mode default
#251	export_position_file reads units/side and never passes them to kicad-cli, then reports them as honoured — which is your inch-coordinates-labelled-mm finding. export_gerber's layers is advertised and never read.
#252	snapshot_project returns paths it never verifies
#253	autoroute advertised but always errors, check_freerouting can't see a PCM install
#254	per-user Windows KiCad installs not discovered — this is also my best guess at your missing USB-C 3D body, since the model root has the same gap
#255	get_datasheet_url never opens the local catalog, and every catalog SELECT omits the Datasheet column
#256	no way to open a specific board and wait for that document's IPC endpoint
#258	batch_edit_schematic_components can't create a field, so sourcing means 36 single writes

I did not file the 3D model as its own issue — one render isn't enough to separate a model-path problem from a resolution problem, and #254 may already cover it. If you can reproduce it with the library roots explicitly set, that would settle it.

What I take from this

Every P0 here is the same defect wearing different clothes: Konnect reported success from the request rather than from the result. The transfer succeeded because the transport accepted the bytes. The review looked good because its own smaller checks were quiet. The position file reported mm because mm is what was asked for. snapshot_project returned a path because it built the string. That is the same root as #218, #184/#185, #190 and #211, and it is the thing to design against rather than patch case by case.

The second one is closer to home: a fixture that shares the code's assumption proves nothing. pad_count is wrong because its fixture is Konnect's own output. The transfer corruption survived because the fixture had no graphics. Yesterday flip_component refused every stock demo board because its fixture had no ki_fp_filters. Three in a row.

Your benchmark found all of this precisely because it ran against reality and then read the artifacts instead of trusting the success messages. The positions.csv inspection is the clearest example — nothing in Konnect would ever have told you those were inches. Please keep doing that, and thank you for the care in the write-up; having exact counts per footprint is what made the root cause a ten-minute job instead of a day.