Part Quote Automation

#At a glance

#Lines of code by language

Counts are physical lines, blank lines and comments included.

Excluded from the counts:

• Dependencies: node_modules, the Python virtual environment, vendor.
• Build output: dist and Rust target folders.
• Bundled third-party programs: Blender, a native CAD converter, an external blank solver, a tunnelling client, a compiled 2D CAD editor, and a copy of three.js.
• Runtime and backup folders: backups, outputs, results, uploads, tmp, logs, data, transfer packaging.
• Customer data: every test-part CAD file and the customer CAD reference library.
• Generated output: test-run subfolders (renders, reports, strip simulations), Python caches and minified files.
• The legacy AutoLISP sources (about 57,800 lines) that the 2D CAD module was ported from.
• One legacy-format conversion utility.

Also not counted: 9,544 lines of Markdown documentation in 100 files, and about 159,000 lines of JSON (fixtures, catalogs, extracted tables).

#Lines of code by module

#The problem

A stamping shop quotes many parts it never builds. For each request, a sales engineer has to work out the blank size, how the part runs in a progressive die, how many stations the die needs, how big the die is, and what it costs to build. They also want to know whether the shop has already made something similar. Normally this means opening the customer's model in desktop CAD, unfolding it by hand, sketching a strip and filling in a spreadsheet.

AutoQuote moves that work into a browser. A user uploads a STEP or IGES file and the server runs a chain of geometry workers. Every stage either produces a result it can defend or says plainly why it cannot. A result that can't be trusted is never passed off as a quote.

 customer CAD (STEP / IGES / native)
          │  import + validate (one solid, units, B-Rep check)
          ▼
 ┌──────────────────┐   rejected / review  ──►  manual-analysis queue (engineer claims job)
 │  Flat blank      │──────────────────────────►  AI self-repair attempt (sandboxed)
 │  (OCP unfold)    │
 └────────┬─────────┘
          │ accepted flat (DXF + flat STEP + metrics)
          ├──────────────►  Geometric Match: 5 most similar past parts (+ their real debug hours)
          ▼
 ┌──────────────────┐     ┌──────────────────┐     ┌──────────────────┐
 │  Strip layout    │ ──► │  Strip tooling   │ ──► │  Mock die        │
 │  pitch · width · │     │  punches · forms │     │  assembly from   │
 │  tabs · stations │     │  pilots · forces │     │  template + audit│
 └────────┬─────────┘     └────────┬─────────┘     └────────┬─────────┘
          │                        │                        │
          ▼                        ▼                        ▼
   ERP quote workbook       press tonnage            Blender renders · 3D press
   (6 cells filled)         estimate                 simulator · detailed estimate

An optional automatic mode runs the whole chain as one job. At each design choice an LLM picks one option from a list the engine has already checked.

#1. Flat blank development

The core engine unfolds a sheet-metal solid on its real B-Rep using OpenCascade. It does not approximate a mesh.

Thickness.

• A first guess is $t_0 = 2V/A$, where $V$ is the solid's volume and $A$ its surface area.
• The guess is refined by pairing anti-parallel planar faces with $\mathbf{n}_a\cdot\mathbf{n}_b \le -0.997$ whose projected footprints overlap by at least 25 %.
• The pair spacings are binned and weighted by overlap area. The dominant bin must hold at least half the weight.
• Thickness is the overlap-weighted median of the actual spacings in that bin. An early version used the bin centre, which read a 1.5 mm part as 1.470 mm; this fixed it.

Analytic recovery. B-spline faces that are really planes or cylinders are refit when every sample lies within 0.002 mm. Cones and free-form faces are counted as unsupported area.

Bend graph.

• Planar faces are nodes. Two planes that share a cylinder become a bend edge.
• Normal bends need the hinge $\mathbf{n}_a\times\mathbf{n}_b$ to line up with the cylinder axis ($|\cos| \ge 0.9$). They get weight $\max(1-|\mathbf{n}_a\cdot\mathbf{n}_b|,\ \tfrac12(1-\mathbf{n}_a\cdot\mathbf{n}_b))$.
• Joggles (parallel normals with an offset) get weight 0.5. Hems (anti-parallel normals across a gap) get 1.0. Coplanar split faces are effectively welded with weight $10^9$.
• Each edge scores shared-edge length × weight. Gates on edge ratio and score ratio keep hole bores from being mistaken for bends.

Unfolding.

• A Prim-style maximum-weight spanning tree is grown from a seed face. This breaks the cycles that would otherwise over-constrain the unfold.
• Faces are placed breadth-first. Each child is rotated about the exact hinge by the signed angle between its normal and its parent's.
• The child is then pushed away by the developed bend length:

$$L_b = \theta\,(r_i + K t), \qquad r_i = \begin{cases} r & \text{concave skin}\\ r - t & \text{convex skin}\end{cases}$$

The default is $K = 0.44$, which can be overridden per job, and the neutral radius is floored at $0.05t$.

• Cylinders are developed exactly, as $u = r\theta$ along the arc against axial distance, with the angle unwrapped about the face's mid-angle so wraps past 180° stay continuous.

Contour.

• The placed triangles are rasterised and unioned at 6–28 px/mm, closed morphologically, and traced.
• The outline is simplified at $\min(0.18\text{ mm}, 0.1t)$.
• Parts that are already flat skip this and use their planar contours directly, which keeps every hole and narrow tab.

Outputs. An inch-unit DXF, a PNG preview, a flat STEP made by extruding the outline through $t$, and a JSON report of net and hole area, envelope, minimum rotated rectangle and confidence.

#Acceptance policy

A flat is quote-acceptable only if every check passes:

• Area coverage: flat area must be 0.90–1.10 × $V/t$.
• Completeness:
  • At least 98 % of the planar skin is retained.
  • The flat is a single component.
  • At most 1 % of the area, or 0.5 mm of extent, is discarded.
  • No skin face is missing entirely, because a narrow tab can set the stock width.
• Overlap and support:
  • At most 3 % self-overlap.
  • At most 1 % unsupported surface.
• Measurement quality:
  • Thickness confidence of at least 0.8.
  • Jaggedness of at most 1.10.
  • Candidate dimensions spread by at most 5 %.

The program's exit code is non-zero unless the part passes. Confidence is capped at "medium" and labelled as resting on geometric sanity checks, not on empirical accuracy. The docs also say plainly that the area-coverage ratio and the volume ratio are the same number, so the second is not an independent check.

#Surface fallback (review only)

Smooth or doubly curved skins go to a mesh-parameterisation path, and its results always carry a review flag.

1. Find the skin and offset it to an approximate mid-surface.
2. Flatten with LSCM, pinning the farthest boundary pair.
3. Refine with ARAP until no vertex moves more than $10^{-4}$ mm.
4. If triangles fold over, close holes temporarily to make a disk (checked with $V - E + F = 1$). Then take a Tutte embedding on a circle of radius $\sqrt{A/2\pi}$ and refine with SLIM symmetric-Dirichlet.

Strain is reported per edge as $|\mathbf{uv}_{ij}|/|\mathbf{v}_{ij}| - 1$ (RMS, p95, min, max). Any foldover, union overlap or lost boundary loop rejects the result.

#Other blank tools

• Unbend by steps: a bend is a group of coaxial cylinder faces.
  • Each step cuts the bend zone out with a Boolean and extrudes a strip of length $\theta(r_i + Kt)$.
  • The downstream body is rotated back and translated, then everything is fused.
  • Each step checks volume change and B-Rep validity.
  • On a hat section with four 60° bends the result is 177.847 × 50.8 mm, the same as the main engine and an independent CAD-API implementation.
• Blank for formed parts:
  • Drawn and formed parts go to an external inverse-approach solver, with mesh presets from 4,000 to 14,400 triangles.
  • Hardening can be Hollomon $\sigma = K\varepsilon^n$ or Swift $\sigma = K(\varepsilon_0 + \varepsilon)^n$.
  • The solver reports blank area, perimeter, strain, thinning and p99.5 stress.
• Forming analysis (opt-in):
  • A Code_Aster run on a 4-layer prism mesh driven by the strip animation, using von Mises isotropic hardening from a true stress–strain table and Simo–Miehe finite strain.
  • ParaView reads out stress, strain and plastic strain.
  • It does not model tool contact, friction, anisotropy or springback.
• Flatten animation: a topology-preserving preview that plays the unfold. The user can reorder the bends.

#2. Strip layout

The strip stage turns an accepted flat into a progressive-die strip. It builds one welded material mesh through every forming station, with pilot rails, carrier tabs, and the exact customer CAD at the final stations.

Width and pitch. With stock thickness $T$:

$$\text{pitch} = X_\text{env} + 3T, \qquad W_\text{min} = Y_\text{env} + 2(0.5T + T)$$

• $X_\text{env}$ and $Y_\text{env}$ come from the swept envelope of every forming stage, offset $\pm T/2$ along the normals.
• Multi-out lanes share a rail: $W = n\,w_\text{lane} - (n-1)\,w_\text{rail}$.
• The figure of merit is stock area per piece, $W\cdot\text{pitch}/n_\text{parts}$.
• A user override below the minimum is rejected, never clipped.

Orientation search.

• Candidates are 0–165° in 15° steps, plus exact alignments taken from a curvature-weighted histogram of bend axes.
• They are ranked by the share of bend weight within 3° of parallel or perpendicular to the feed, then by mean deviation, then by stock area.
• Results are flagged as not proven optimal.

Single-lane optimizer.

• Pitch is bounded below by $A/\text{breadth}$.
• It is scanned in 120 steps and then refined in 20, at rotations of 0/90/180/270°.
• A candidate is feasible when every repeat clears its neighbours by at least the spacing.
• Material to buy is $\lceil\lceil q/\text{yield}\rceil/n\rceil\cdot\text{pitch} + \text{start-up} + \text{tail}$.

Carrier tabs and pilots.

• Tabs sit on straight datum edges and are at least $\max(3T, 5\text{ mm})$ wide. Long bridges are widened, up to $20T$.
• Tab angles are limited to ±60°, and a pair of tabs is chosen on opposite rails as far apart as possible.
• Pilots go in the sacrificial tabs with a $0.5T$ ligament. If no pilot fits, the report says so rather than widening the rails or piercing part holes early.

Station sequencing.

• Start-up stations: pilot pierce → pilot only → bulk profile → pilot profile.
• Bend recognition: two CAD cylinders are one physical bend when they are coaxial within 0.002 mm and their radii differ by $T$ (within 0.2 %).
• Z-legs: parent/child bends with opposite axes (within 5°) are Z-legs. They can be formed as two hits, one hit, merged legs, or individually.
• Holes: precision holes stay closed until a post-form pierce. A non-convex relief is cut early only if it passes a 0.005 mm distortion test.
• Idle stations: 0–8, default 1.

Preview. The station shapes are interpolated with SVD rigid fits and a sparse solve. Seams must close within 0.005 mm, and each station solid is re-imported and compared with the source CAD.

#3. Strip tooling: punches, forms and press load

All dimensions are in mm, and station $n$ sits at $X = (n-1)\cdot\text{pitch}$.

Profile punches.

• Punches never overlap, and the sum of punch areas equals the scrap area exactly.
• The centre punch removes only the narrowest stretch between blanks, and U-trims take the rest.
• Sections or gaps narrower than $1T$ are flagged.

Pierces. These come from inner wires on planar faces. Angled holes get a normal-direction punch and a side-action note.

Forming blocks. The footprint is the region that changed between stations, plus $T/2$, plus a land of $\max(0.5\text{ mm}, 0.25T)$. Lower inserts are paired to upper punches by reciprocal IDs.

Pilots. Diameter is $2T$ rounded to the nearest 1/16 in, with a 1/8 in minimum. The pierce is 0.002 in larger.

Shop rules.

• Working height is at least $\max(1\text{ in}, 8T)$, with wire-EDM straight-through bodies.
• Poka-yoke corner chamfers use six asymmetric codes so that no two punches can be swapped.
• Pockets carry 0.0002 in per side.

Punch editor. Punches can be moved to another station, scaled, offset, rotated or split in two, and their outlines edited. Edits are replayed on every rebuild and published atomically per revision. A down-position preview drives each cutter through $T$ + 0.060 in.

Press forces.

$$F_\text{cut} = L\,T\,\tau_s, \qquad F_\text{wipe} = \frac{0.333\,\sigma_\text{UTS}\,L\,T^2}{R_p + R_d + c}, \quad R_d = 3T,\ c = T$$

• $L$ counts only the edges that actually shear in that hit. There is no credit for rooftop shear.
• When tensile strength is missing, it is estimated from shear strength by material family (steel 0.80, stainless 0.75, copper 0.65, aluminium/titanium 0.60).
• Stripping force is 10 % of cutting force (20 % recommended for springs), or 50 % of wipe force at forming stations if that is larger.
• Minimum rated press = total peak load / 0.80, the shop standard's 80 %-of-tonnage rule.
• A missing material is reported as a gap, never as zero force.

#4. Mock die assembly and visuals

The punch hand-off is combined with a template die (a STEP file with named components) to build a complete concept die.

Sizing and clearances.

• The shoe can be up to 144 × 60 in. Internal details are capped at 24 in, and longer plates are sectioned at station boundaries.
• Defaults: rail clearance 0.010 in per side, feed lift ≥ 0.375 in, punch retract 0.125 in, penetration 1/16 in.
• Margins are sized in 0.5 in steps.

Hardware.

• Keyed inserts with blind pockets and socket-head screws.
• Catalog guide pins and retainers.
• Nitrogen springs sized to each section's stripper force, or 1.5 × stripper weight if no force is given.
• Quick-change parallels.

Audit. Every pair of components is checked for CAD interference above 0.03 mm³. A changed component rebuilds only what it touches.

Rendering.

• A bundled Blender produces exploded, assembled and split-die images plus an editable scene. Each component family gets a procedural material.
• Renders run one at a time, cached by assembly hash.
• An optional GPU render worker on the LAN takes over when it answers a health check, with local rendering as the fallback.

3D press simulator (three.js + Rapier).

• Views: open, closed, exploded and split poses, plus section planes and group filters.
• A crank-angle animation with $\text{ram}(\theta) = \tfrac{s}{2}(1+\cos\theta)$, where stroke $s$ is twice the feed clearance. The feed follows a smoothstep in the window where the ram is clear.
• Finished parts drop under gravity into a tray, and slugs fall into a bin per pierce station.

#5. Quotes

ERP workbook quote.

• On each strip run, the server pulls the current tooling-quote template from the ERP's document store.
• It writes six inputs straight into the workbook's XML: thickness, width, progression, debug difficulty, working stations and total stations. No macros run, and every legacy workbook feature is kept.
• The web strip report re-implements the workbook's tooling module, but only after confirming that 30 named cell formulas match the template exactly. Any change in the template turns pricing off rather than showing a stale number.
• The model's structure:
  • Die size comes from strip width and progression × stations plus allowances.
  • Wire-EDM time comes from cut perimeter × wire thickness / wire speed.
  • CNC hours scale with the number of forms.
  • Steel and heat treatment are ratios of the die set.
  • Build labour scales with working stations.
  • Debug is a percentage of build hours by difficulty class.
  • Lead time is in weeks, derived from hours.

Detailed build estimate.

• A bottom-up takeoff from the mock die:
  • Made parts are priced as rectangular stock plus finish allowance × density, with the steel grade inferred.
  • Catalog hardware is counted once per kind.
• Hour models for engineering, waterjet, machining (by removal volume), wire EDM (perimeter × height), grinding, heat treatment, assembly, inspection and debug. Debug can use real posted hours from similar past tools.
• Totals go direct cost → contingency → markup, with markup and margin shown separately.
• Saves are revision- and hash-checked (20 revisions kept), and CSV export blocks formula injection.

#6. Geometric Match: "have we made this before?"

Every new flat or strip job automatically searches the company's CAD library and the user's past jobs, and returns the five closest parts.

Profile extraction.

• STEP/IGES:
  • The file must hold exactly one solid. It is tessellated at 0.08 mm, up to 150k triangles.
  • Up to six view directions come from area-weighted covariance PCA plus the dominant face normals. Each direction uses a right-handed basis, so a part is never matched to its mirror image.
  • Triangles are projected and unioned into a silhouette. Through-holes survive this; pockets and depth do not.
• DWG/DXF: DWG is converted to DXF first.
  • Units come from the header or an operator override. Files with no units are quarantined.
  • Blocks are resolved up to 20 levels deep.
  • Annotation, hidden and title-block layers are dropped, as are sheet borders.
  • Curves are flattened at 0.03 mm and the outer faces kept.
• Normalisation: each profile is centred and rotated to its minimum-area rectangle. Size is kept on purpose.

Stage 1: exact scan.

• The descriptor is [short side, long side, area, perimeter, hole count].
• Every pair of views is costed as

$$c = \tfrac14\sum_{k=1}^{4}\left|\ln\frac{d_k^{q}}{d_k^{c}}\right| + 0.08\,|h^q - h^c|$$

• Each file is ranked by its best view pair.

Stage 2: rerank the top 30.

• Contours are resampled (128 outer points, 48 per hole).
• Rotation is swept in 15° steps with a KD-tree chamfer cost, and the best three angles are refined to 0.015°.
• Holes are paired with the Hungarian algorithm. Then:

$$S = 100\left(0.65\,P + 0.20\,H + 0.15\,Z\right)$$

$$P = 0.55\,\text{IoU} + 0.45\,e^{-8d/\text{diag}}, \qquad H = \frac{\sum e^{-15 d_i}}{\max(n_q, n_c)}, \qquad Z = e^{-1.5\sum|\ln(\text{side ratio})|}$$

Index and viewer.

• The index is a SQLite table keyed by content hash and extractor version, so unchanged files are skipped on rebuild.
• Extraction runs in up to six isolated processes, each with a 110 s timeout. Failures are quarantined with a reason.
• A split-screen three.js viewer shows the query and the chosen match side by side at a common scale.
• For each match it can look up how many tryout/debug labour hours that past tool actually took. It reads this live from the shop-floor system and does not store it.

Scores are labelled "uncalibrated, not a probability", and the UI hides anything below 90.

#7. AI in the loop

All model calls go through a command-line coding agent run as a sandboxed subprocess. There is no hard-wired model SDK.

• Automatic design decisions:
  • At nine choice points the engine builds 1–64 options that have already passed its own clearance and tab checks: flat candidate, bend grouping, part flip, attachment face, feed orientation, tab pair, idle stations, finishing preset and die sizing.
  • The model sees numeric geometry, up to 8 screenshots and a 460-line machine-readable digest of the company's die-design standard.
  • It must return exactly {choiceId, reason, confidence} for an eligible option. The prompt tells it to treat every input as evidence, not as instructions.
  • Decisions are stored immutably and can be replayed. A replay refuses any choice whose geometry has changed.
  • A timeout or invalid answer stops the run rather than falling back to a default.
• Die analysis chat: image-based advice on station count, punches and carrier type, then follow-up questions with the full context passed in each time.
• Material lookup:
  • A web-search-enabled lookup fills in properties the blank tool is missing: Hollomon $K$ and $n$, $E$, $\nu$, yield and UTS.
  • Answers must follow a strict schema and cite their sources, and they are cached.
• Self-repair of failed jobs:
  • When flattening or strip generation fails, an agent works in an isolated copy of the source and may edit only the allowlisted solver files.
  • It may not touch the acceptance policy, tests or fixtures.
  • A fix counts only if the unit tests pass, the quick accuracy regression passes, an independent artifact audit passes, and the original part now passes the unchanged acceptance policy.
  • Fixes are never applied to live source automatically; they wait for review.

#8. DieDesign: legacy die-detailing tools in a browser CAD editor

The shop's older 2D die-detailing toolkit was a large set of AutoLISP commands and dialogs. These have been re-implemented command by command as JavaScript tools inside an open-source browser CAD editor (WebAssembly) that reads and writes DWG/DXF. There is no Lisp interpreter; each tool reproduces the original behaviour, and engineering tables were carried over from the original data files.

• Bridge API: reads entities, layers, styles, blocks and the current selection.
  • Single-undo-step creates and atomic annotation creates, which make any missing layers and styles first.
  • Edits that must quote each property's current value, so a stale edit fails.
  • Every tool runs form → preview → apply and reads the drawing back after apply.
• Tools:
  • Coordinate hole charts with 16 recognised hole families and thread tables (metric, numbered, fractional, tapped counterbore, rail).
  • Ordinate dimensioning and smart leader notes.
  • Fastener side views.
  • Blank reports and calculators for bend allowance, bend force, rings and cylinders.
  • Plan-view blocks and supplier components (nitrogen springs, die sets).
  • Detail balloons and BOMs, about 30 drafting utilities, and the original menu presets.
• Editor patches: a small set of Rust patches to the editor add annotation, text-layout and atomic-edit support.
• Status:
  • 414 features implemented, 320 partial and 11 blocked. Each blocked item records its exact reason, such as an editor gap or a missing source file.
  • The original menus have 436 macros.

#Web app, pages and API

Pages.

• Sign-in, and the main upload page with workflow tiles and live part pipelines.
• Quote dashboard (including die-plane orientation).
• Strip report with dimensioned layout, tooling inputs and cost breakdown, and the detailed quote.
• Viewers for forming results, strip attachment faces, strip punches, the tool assembly and general 3D.
• The unbend and blank-for-formed-part tools, the engineer claim page and the admin console.

API (88 route registrations), grouped:

• Auth:
  • Request and verify an email code, read the session, log out.
  • Single sign-on from the company's shop-floor portal: a one-time ticket is redeemed server to server with a shared secret.
• Jobs:
  • Upload (multi-file), status, rework, review, hide.
  • Run a strip layout or forming analysis; read and save the tooling estimate, dashboard data and orientation.
  • Saved design decisions; downloads of the original, the flat STEP and STL.
  • Per-job AI chat.
• Manual analysis: request manual analysis, then an engineer claims the job, checks claim status and closes the claim.
• Tools:
  • Unbend (load, inspect, step, download) and blank (materials, AI material lookup, load, run, artifacts).
  • DXF nesting (parse, run), viewer conversion and quick STEP metrics.
  • 2D editor uploads.
• Admin:
  • System status, and suspend/resume/clear the queue.
  • Analytics, notification recipients and per-user feature flags.
  • Manual requests, job lists, failed-state downloads and completing manual work.
• Live updates: socket.io rooms per session and for admins (jobUpdate, systemStatus, suspend/resume).

Job system.

• Queue: a FIFO persisted to disk that resumes after a restart. It runs 1–32 concurrent workers (default 4) and can be paused globally by an admin.
• Python workers:
  • Each runs as a child process with a 40-minute timeout (1–2 hours for forming), an 8 MB output cap, a heartbeat and a process-tree kill on timeout.
  • A worker reports its result as the last JSON line of its output.
• When a job fails: the failure becomes a manual-analysis job, with the original file and the failed-state STEP saved, so an engineer can claim it and upload the finished work.

Sign-in and access.

• Passwordless six-digit email codes. Only a SHA-256 hash of the code is stored, and it is compared in constant time. Codes expire after 10 minutes, with a 60 s resend cooldown and 5 attempts.
• 8-hour sessions.
• A domain allowlist and an admin allowlist.
• Ownership middleware returns 404 for any job the user does not own.
• Seven experimental features sit behind per-user flags.

#Integrations

• CAD formats:
  • 3D input: STEP and IGES, read natively through OpenCascade.
  • Native CAD (Inventor, SolidWorks, CATIA, Fusion, Rhino, NX/Creo, ACIS and others) is converted to STEP through a bundled converter, and any geometry or topology loss rejects the conversion. Inventor parts can also go through headless FreeCAD.
  • Parasolid is disabled until it passes validation.
  • 2D: DXF, and DWG via conversion, for nesting, matching and the editor.
  • Output: DXF, STEP, STL and PNG.
• DXF nesting:
  • Raster bottom-left fill: rotated parts go onto an occupancy grid dilated by the spacing radius, over candidate sheet widths and four part orderings.
  • Rotation can be free, grain-aligned or locked.
  • An exact shelf search covers small counts.
  • Every layout is checked with exact polygon geometry, and the smallest valid one wins.
• ERP:
  • The quote-workbook template is read from the ERP document store at run time.
  • The shop's CAD library (about 19,600 document records) feeds the match index and the batch flatten run.
• Shop-floor system ("War Room"): single sign-on, and the debug-hours lookup for matched past tools.
• Notifications: SMTP email for sign-in codes, quote completion, tool-assembly-ready and manual requests, plus chat-channel notifications for manual claims.

#Testing and validation

Analytic flattening suite.

• STEP fixtures are built in OCP with closed-form expected sizes. For example, an L-bend should flatten to $65 + \tfrac{\pi}{2}(2.5 + 0.44\cdot1.5) = 69.9637$ mm × 30 mm.
• The flats are measured independently from the exported DXF and STEP.

• Overall: 21 / 21 cases behave correctly. 14 are accepted with verified sizes, and 7 (cones, double curvature, open surfaces, multiple bodies, conflicting inputs) are correctly rejected.
• Re-import check: all 17 accepted single-run outputs reopen as one valid solid whose volume equals area × $t$.
• Paired check: a paired K-factor/thickness test confirms the expected difference of $\tfrac{\pi}{2}\cdot1.5\cdot(0.44-0.30)$ mm.
• Earlier baseline: before this rework, an image comparison against a commercial unfolder passed 0 of 5 parts. It was dropped because image normalisation hides scale errors.

Library-scale run.

• 9,292 company part models (STEP, IGES and Inventor parts, sheet metal or not) went through the full flattening policy with no retries and no AI repair. The run took 49,434 s on 8 workers.

Real test parts.

• Five customer parts: 4 produce a flat, 3 pass screening, 1 goes to review for overlap, and 1 spline-surface part is unsupported.
• An 11-part strip set: all 11 generate a strip (6 bend-by-bend, 5 whole-part previews), and all 11 are marked for review.

Strip tooling and die.

• 293 exported tools were reopened and checked in the first baseline, and later revisions passed 65 / 65 CAD-valid exports.
• 55 / 55 punch down-positions are within 0.002 mm. There were 232 pocket pose and swap checks.
• Two mock dies, one 169-component and one 139-component, have 376 and 227 contact pairs with zero interferences. 36 fits are measured at 0.0002 in.

Geometric Match.

• Of 470 library files, 341 are searchable. The 129 quarantined files had missing units (43), multiple or surface-only bodies (38), DWG conversion failures (27) and other causes.
• Six out of six self-retrieval checks returned the source first at 100. DWG queries take 6.6–9.0 s and STEP queries 8.7–19.2 s.

Test inventory.

• About 851 Node test cases in 101 suites and 324 Python test functions. These are counted from source; the case counts were not re-run for this write-up.
• 47 browser proofs drive the real 2D editor: preview, apply, single undo, then save and reopen as DWG.

Accuracy against real quotes. There is no measured comparison yet. The project has no set of verified shop blanks or historical quotes to score against. The docs call for 20–30 verified blanks for flattening and 20–50 reviewed cases for matching, with proposed targets of about 3 % net area and 90 % correct first match. Neither target has been measured.

#Honest status

• Solid:
  • Flattening of plane-and-cylinder sheet-metal parts with a strict, honest acceptance gate.
  • The job system, sign-in and admin tooling.
  • Geometric Match as a search tool.
  • The punch, tooling and mock-die chain on the reference parts.
• Not calibrated:
  • $K = 0.44$ is an assumption, not a shop bend table.
  • Flat confidence is capped at "medium".
  • Match scores are not probabilities.
  • No output has been compared against real quoted outcomes.
• Experimental or concept-only:
  • Bend sequencing and draw preforms.
  • Every press force.
  • The surface-flatten fallback.
  • Forming analysis, which has no contact or springback.
  • Mock-die motion and press clearance.
  • Detailed-estimate rates, which are planning assumptions.
  • Every strip in the test set still requires review.
• Known gaps:
  • Cones, embosses, coining and drawn regions are rejected.
  • The raster contour union is a known error source; a vector union is planned.
  • Unbend-by-steps loses holes inside a bend zone.
  • Nesting is single-lane with four orientations.
  • The 2D CAD port has 320 partial and 11 blocked features.
  • Automatic mode is not yet wired into the 2D editor.
• Removed: the older native-CAD desktop automation, the first-generation "Quote Analysis" and an injection-mold quote path have all been taken out. Saved historical jobs from them remain viewable.
• Process: the snapshot has no version control. Several design notes contradict each other on small defaults; for example, the code's default bend grouping differs from the one the docs describe.