randomonkey05/SolidCraft-Agent-Skills

# FDM design-for-print checklist (SolidCraft -> desktop FDM printer)

Written for a 0.4 mm nozzle on a Bambu Lab A1 mini (180 x 180 x 180 mm bed). The rules come from a public DFM guide (Unionfab, 2026) plus lessons from real prints. Items marked (UNVERIFIED) are working values that no real print has confirmed yet. Adjust them to your own printer and tell the maintainers what you measured.

## Before modelling
- Decide the PRINT ORIENTATION first and model in that pose (flat face on Z=0). Layers are weakest along Z, so loads must not pull layers apart.
- Keep the part inside about 170 mm on the A1 mini bed. Avoid tall thin features.
- Prefer a self-supporting design over supports. Target: no support at all.

## Geometry rules (0.4 mm nozzle)
- Walls: minimum 0.8 mm, in multiples of 0.4 (0.8, 1.2, 1.6, ...). Structural plates >= 2 mm. Thin tall plates need ribs or gussets rather than more thickness.
- Overhangs: <= 45 deg from vertical. Use 45 deg chamfers or teardrop profiles under horizontal holes and lips.
- Bridges: unsupported spans <= about 5 mm.
- Horizontal holes print slightly oval and undersize: add about 0.2 mm radius or use a teardrop. Vertical holes are more accurate. (compensation value UNVERIFIED)

# SolidCraft assemblies: repeatability first, no collisions in motion

Applies to any assembly: static (enclosures, frames, fixtures) and moving (linkages, suspensions, legs, arms). The goal is an assembly that is easy to edit later: change one body and every instance follows.

## 0. Housekeeping
- One folder per model, all its files inside. Changes go in the same folder under a new name (`model_v2`); never overwrite earlier versions. If your setup restricts where the app may save files, create the folder first.
- Always deliver a screenshot of the result (and, for moving assemblies, one in a non-home pose).
- Reply in the user's language.

## 1. Plan repeatability BEFORE modelling
Write a short part table first: part type, how many instances, how each instance is derived. Target: number of distinct bodies = number of part types, not number of physical parts.

Look for, in this order:
1. **Identical parts** -> one component, N instances (wheels, fasteners, standoffs, identical links, brackets).

# SolidCraft checking

`solidcraft-modeling` and `solidcraft-editing` cover the commands, plane axes, ids, edge picks and the MCP workflow: load the one that fits first. This skill adds checks for errors SolidCraft does not report, and the work around a design kept in a repo.

`$SKILL` below is the folder this file is in (`~/.claude/skills/solidcraft-checking` for a user install). The scripts and `test_facts.py` were written against SolidCraft 0.21.0 and have NOT been re-run on 0.25 - 0.29 (the app is now at 0.29.0, file format `solidcraft/46`). `scripts/tests/test_facts.py` checks every trap and convention below, and the facts behind the corrections in `solidcraft-modeling`. After a SolidCraft upgrade, run the tests and fix the text where they fail:
`PYTHONDONTWRITEBYTECODE=1 uv run --no-project --with pytest --with build123d pytest -p no:cacheprovider $SKILL/scripts/tests`

## Scripts

An MCP `batch` and a command script (`{"commands": [...]}`, run by `solidcraft-cli run`) take the same command list. Build with a script when the design goes into a repo or must be rebuilt later: a script rebuilds the design from scratch on every run. Subagents share the session's one MCP design, so agents that run in parallel use `solidcraft-cli` only.

In `$SKILL/scripts/`:
- `python3 $SKILL/scripts/run.py script.json [--in <design>] [--save <name>.json]` runs a script and prints `FAIL`, a `WARN` line per feature warning, a `SKETCH` line per sketch above dof 0 and a `BODY` line per body, for the end state and for each `document.inspect` inside the script.
- `scb.py` gives a generator a `Script` with sketch helpers that come out at dof 0 (`hexagon`, `circle`, `rounded_rectangle`, `place`) and `cmd` for any other command. It rejects repeated sketch, feature and body names. Import it with `sys.path.insert(0, "<$SKILL>/scripts")`.

# Delivery gate

An export that succeeded only proves a file was written. Check the final files, not the working design, before saying "done".

(Idea source: the final-verification, artifact-inspection and evidence-ledger gates of capwitf/mechanical-cad-skills, MIT. Rewritten for SolidCraft; no text copied.)

## Checks on the final files

| Check | How |
|---|---|
| Exists and is fresh | every promised file is in the model's folder and newer than the last design change; no leftovers from an earlier version (new versions get a new name, e.g. `_v2`) |
| Non-empty | size > 0; STL: triangle count > 0 and a bounding box; DXF: entity count by type and layer names; PDF: page count; STEP: header and entity count |
| Matches the design | bounding box and volume of the export (re-open the STEP in SolidCraft, or parse the STL/DXF) agree with the last `measure`, in mm |
| Final look | `screenshot` of the model (iso, plus top or underside when features hide there) and send it to the user |

# Design-for-manufacturing review (sheet metal and CNC)

Adapted from the `dfm` skill of earthtojake/text-to-cad (MIT, see NOTICE), rewritten for SolidCraft's measuring tools. Injection moulding is not covered here. For FDM printing use `solidcraft-3d-print-dfm`. For building the sheet-metal part itself use `solidcraft-sheet-metal`; this skill is the review that follows it.

This is a guided review, not an automatic feature-recognition engine and not a manufacturing certificate. Report the checks you could not make.

## 1. Pick the process, then read its reference
| Process | Reference |
|---|---|
| Sheet metal (laser, bend, flat pack) | [references/sheet-metal.md](references/sheet-metal.md) |
| Sheet metal made by SendCutSend (their per-SKU limits and DXF measurement) | [references/sendcutsend.md](references/sendcutsend.md), after sheet-metal.md |
| CNC milling and turning | [references/cnc.md](references/cnc.md) |

When comparing processes, review each one separately.

# Reading drawings, PDFs, videos and transcripts for SolidCraft

Use with `solidcraft-modeling` (commands), `solidcraft-tutorial-recipes` (validated recipes and traps) and `solidcraft-sweep-and-boolean-hangs`.

## 1. Extract the source
- **PDF drawing:** rasterize the page (for example `pdftoppm -r 150`) and also extract its text. Read every dimension, note, fillet callout and the material or density. Anything missing (a density, an undimensioned fillet) is reported as an assumption in the notes you hand over.
- **Video without a transcript:** an agent cannot hear audio, so transcribe it first with any speech-to-text tool you have (for example `faster-whisper`, model `small`, runs on CPU). Where the tool must run depends on your setup: if the machine that holds the video cannot install it, run it somewhere that can. Two practical notes: load the audio as a 16 kHz wav with numpy if the decoder in your `av` version fails, and always hand the `.txt` or `.srt` back to the user.
- **Use both sources:** the transcript gives the ORDER of operations and the intent. Frames give the NUMBERS (`ffmpeg -ss <time> -i file.mp4 -frames:v 1 -vf scale=1100:-1 out.png`, or a contact sheet). Spoken numbers are often wrong ("14 / 18 / 19" for 40 / 80 / 90), and tutorials with similar names can have different dimensions.
- **Video plus a written transcript (.docx):** read it (a .docx is a zip, the text is in `word/document.xml`). Machine translation mangles numbers.
- **Silent videos** give an empty transcript. Read dimensions from frames and measure unlabeled positions in pixels against a known width.
- Work on copies. Keep scratch frames outside the folder that holds your skills.

## 2. Plan in numbers before touching the app
- Write a parameter table and a coordinate list for each profile. Choose the origin to match the drawing's datum.

# SolidCraft editing

## Overview
Edit an existing design through its parameters instead of rebuilding it. Every sketch dimension and feature input is already a parameter (`d1`, `d2`, ...), so most edits are a `parameters.change` each, sent together in one batch. Map the design with a few compact calls rather than walking the timeline one feature at a time. For command shapes and traps, in SolidCraft's own chat or any MCP client, call `skill_reference {"skill":"solidcraft-modeling"}`. Elsewhere, use `reference.md` from the `solidcraft-modeling` skill.

## Map the design (3-4 calls)
1. **Open:** if the design is not open yet, run `open {path}`. When the server is bridged to the app and the current design is `dirty`, ask before opening anything.
   - `open` of a path that is already open and changed keeps the changed design (tested on 0.29.0: volume and sketches were not reloaded). To get back to the saved file, copy it to a new name and open the copy.
2. **Overview:** `inspect_design {"measure":false,"sketches":false}` lists the user parameters, the sketch dimensions (`d1`, `d2`, ... with their expressions), the features in order, and their errors.
3. **Feature inputs:** `execute parameters.list {"filter":"feature"}` gives every feature input as an object such as `{"name":"d9","expression":"(6) / 2","feature":"Cylinder1","input":"Radius"}`. `inspect_design` leaves these out.
   - Match sketch dimensions by expression.
   - If that is ambiguous, `sketch.inspect {sketch}` that one sketch, which also shows its points in world coordinates.
4. **Baseline:** `measure {}`, so you can predict every change against it.

# Engineering drawings from SolidCraft

The content checklist is adapted from the `engineering-drawing` skill of earthtojake/text-to-cad (MIT, see NOTICE). That skill generates a PDF through its own `cadgen` engine, which SolidCraft does not have, so this skill covers what a drawing must contain and what SolidCraft can supply. SolidCraft 0.25.1 does not lay out a dimensioned ISO sheet by itself, so the sheet comes from `assets/sheet-template-a2.dxf`.

A drawing is a document derived from the part. Every number on it should come from the model (measured), not retyped, so that changing the model changes the drawing.

## What SolidCraft can supply
- **View linework (verified).** `view.apply {view: "top"}` returns the camera. Pass that exact camera object to `file.export_view_dxf {camera, hidden: "dashed", path}`: `camera` is required, and a shortened or hand-made camera was rejected as "invalid camera". The result is an orthographic DXF in mm (`$INSUNITS` 4) with layers `VISIBLE` (LINE) and `HIDDEN` (LWPOLYLINE, dashed); sketch curves go on `SKETCH`. Export one file per standard view (front, top, right, plus iso if useful).
- Curves are tessellated into short segments (a top view of a bolt and a bearing gave about 1,500 visible lines). Raise `tolerance` (0.01 to 0.1 mm) if the file is too heavy for the drafting tool. The segments are not dimensionable arcs, so dimensions must be added from measured values, not from the exported curves.
- **Flat pattern** for sheet metal: `sheet.export_dxf` (layers OUTLINE, CUT, BEND_UP, BEND_DOWN, BEND_NOTES) and `sheet.export_bend_table` (CSV). Send these as the manufacturing drawing for laser-cut and bent parts.
- **Numbers**: `measure` for overall size, hole diameters, centre distances, wall thickness; `inspect_design` for parameters.
- **Sketch outlines**: `sketch.export_dxf` for a single profile.

## What a good drawing contains

# Holes, fasteners, pockets and spur gears: reference values

This skill holds data, not a procedure. The checks that use it live in `solidcraft-requirements-and-sanity` (before building) and `solidcraft-delivery-gate` (before delivering).

(Idea source: wzyn20051216/solidworks-automation-skill, MIT. Process values there are initial suggestions for CNC, sheet metal and plastic parts; restated here, not copied. Confirm against the real process, supplier and load.)

## 1. Decide the hole type before modelling
"An M5 screw hole" is ambiguous. State or ask which one it is, and never default it to a tapped hole:
- **Clearance** (through, screw passes freely)
- **Counterbore or countersink** (head sits below the surface)
- **Tapped** (the thread is cut in the part)

Starting diameters, mm:

# SolidCraft mechanisms

## Overview
An assembly is components placed by joints. Work the mechanism out as world points and axes first: every pin, slide and hinge, which part each one joins, and the value you expect at each pose. Then give every joint origin by those coordinates, and check each step against a number you computed yourself. A drive that reports success can still have moved nothing. Command shapes, a worked example, the traps and reply sizes are in `reference.md` next to this file. To build the parts themselves, use `solidcraft-modeling`.

Written against SolidCraft `main` after 0.11.1, which counts the degrees of freedom of closed loops, carries motion links through chains made in any order, and answers drives in degrees with `moved` (and a `reason` when nothing could move).

## Before the first call
1. In SolidCraft's own chat or any MCP client, call `skill_reference {"skill":"solidcraft-mechanisms"}`. Elsewhere, read `reference.md`.
2. **Open:** if the design is not open yet, run `open {path}`. When the server is bridged to the app and the current design is `dirty`, ask before opening anything.
3. **Map it:** run `inspect_design {"measure":false,"sketches":false}`, then `execute joint.list`. `joint.list` shows `fixed` (the grounded occurrences, always with the root, 0), `dof` per occurrence, `conflicts`, the joints, links and named origins, at about 0.5 KB per joint. `execute motion.list` lists the motion studies.
4. **Existing design:** take `edit.checkpoint` in its own call before you move bodies into components. `edit.restore_checkpoint {checkpoint}` goes back exactly.
5. **Write the plan:**
   - the components, and which one is grounded

# SolidCraft modeling

## Overview
Work the part out as numbers first. Then build it in a few large `batch` calls, and check each stage with `measure` against values you computed yourself. A clean build takes 3-4 build batches, about 10-13 calls with the checks. Command shapes, plane axes, ids, reply sizes and known traps are in `reference.md` next to this file, so you do not need to explore the command catalog.

## Before the first call
1. In SolidCraft's own chat or any MCP client, call `skill_reference {"skill":"solidcraft-modeling"}`. Elsewhere, read `reference.md`.
2. Run `inspect_design {"measure":false,"sketches":false}`, even when you think the session is empty.
   - The SolidCraft server's instructions end with `Backend: connected to the SolidCraft app` when it drives the user's open app, and with `Backend: headless` otherwise.
   - If the design has timeline features, ask before calling `new_design` or `open`, because both discard unsaved work. You can also build into the open design.
3. Write a plan:
   - the parameters
   - the placement: centre the part on the origin so patterns and mirrors can work from the planes
   - every feature, with the world point you will use for each edge or face pick

# Clarify first, then build, then check plausibility

A part can build cleanly and still be wrong because units, interfaces or loads were guessed. Building on too little information costs a rebuild; one round of good questions costs seconds. Get the facts first, check plausibility at the end, and label every claim.

(Idea source: the process gates of capwitf/mechanical-cad-skills, MIT. Rewritten for SolidCraft; no text copied.)

## 1. Clarify before the first build call

### 1.1 Fill the lock from what is already known
Read the message, attached files and any drawing first. Fill what you can; never ask for something you can read or measure.

| Field | Blocking when missing? |
|---|---|
| What it is and what it must do | always |

# SolidCraft: robust general modeling workflow

General lessons validated on tapered and pocketed arm parts from timed speed-modeling tests and on a tutorial hook. Apply them to any part, timed or not.

## 1. Build order (fewest failures)
1. Base body from one profile sketch, extruded symmetric (operation new).
2. Second profile (other plane) extruded with operation `intersect` on the base body. Do the intersect BEFORE other cuts. Never intersect after a bore is cut: it once returned a silently wrong solid (centre of mass shifted, volume +60%) with no error.
3. Bores and holes as `solid.cylinder` cuts with explicit base, axis and targets (then a circular or linear pattern of the cylinder cut if repeated), or a simple sketch-circle extrude cut.
4. Pockets and cavities: sketch a polygon, extrude it as a separate "Cutter" body, trim it with `solid.box` or cylinders (targets `[Cutter]`). A cut through the middle splits it into `Cutter` and `Cutter (1)`. Finish with `solid.combine` cut using ALL tool bodies.
5. Fillets and chamfers: on a simple prismatic body do them right after the base and holes (section 3a). On a complex body (sphere, loft, sweep, draft, cavity) do them last, or before the complex feature is added (section 3b).

Keep the model as few features and as few bodies as you can. Fillets work best on one simple body, and the kernel has less to compute.

## 2. Boolean rules

# SolidCraft sheet metal: complete reference

Validated on an edge-flange bracket (75 and 45 deg flanges), a U-channel (contour flange), a box converted to sheet metal (convert plus edge flange), a C-clamp (contour R50 plus hem plus holes), a reference test plate (angles, then-bends, `height_from`, `position`, fold, path flange, perforate), a phone stand (contour plus flat-state cuts) and a chamfered block converted with a hole (convert). Commands go through the SolidCraft MCP server. `batch` takes the key `command` plus `params`, never `cmd`. If your client defers tool schemas, load them first. The two tutorial-based models (phone stand, converted block) are written up in [`references/elite-engineers-phone-stand-and-convert.md`](references/elite-engineers-phone-stand-and-convert.md), and their files (3MF, design, flat pattern, bend table) are in [`examples/sheet-metal-tutorials/`](../../examples/sheet-metal-tutorials/README.md).

Suggested habits: send a screenshot of the folded and the flat state, and keep one folder per model with `_v2` names for changes.

**Flat-pack enclosures** (laser-cut plates, ear tabs, bend slits, perforation, side plates; for example a CD-ROM player enclosure): use the separate skill [`solidcraft-sheet-metal-flatpack`](../solidcraft-sheet-metal-flatpack/SKILL.md) together with this one. Key limits found there: `sheet.fold` is a half-plane fold; a fold whose moving side already has a bend is refused (fold from the fixed side outward); the default direction of an edge flange is the bottom-face normal (`flip:true` for the opposite); about 700 real holes per sheet is the boolean budget.

## 1. Read the source first
- A bent part has TWO sets of dimensions, folded and flat. If no flat pattern is given, build the part, then state that the flat dimensions are assumed and ask for the expected flat pattern. (On the edge-flange bracket the first build gave 98.069 against 103.217 expected.)
- Tutorial videos: transcribe the audio first. A silent video (mean volume around -91 dB gives an empty transcript) needs its dimensions read from frames: make contact sheets with ffmpeg and timestamps, then take full-resolution frames of the dimensioned sketch and of the Create Flat Pattern dialog, and measure unlabeled positions in pixels against a known width, for example 50 mm = 260 px. The flat-pattern dialog lists the bend count, the angles and the flat size, so use them as a check (phone stand: 7 bends, matched).
- A drawing whose edges are not parallel to the base axes (an isometric view of an angled plate) hides the real bend line: say which interpretation you built (hinge parallel to x, rotated hinge, slanted outer face) and ask the user. In one angled-plate test the left plate's edges looked about 43 deg and 55 deg against 18 deg for the base; the model was built with the hinge parallel to x and flagged as unconfirmed.
- Spoken numbers are often wrong. The frames give the numbers.
- When real flat patterns are provided, compare them against the model feature by feature (perforation, windows, steps, ears, holes, relief notches) before rebuilding.

# SolidCraft flat-pack sheet metal (extends solidcraft-sheet-metal)

Load `solidcraft-sheet-metal` first for the base commands. This skill adds the flat-pack method learned on a CD-ROM player enclosure (the das_POD CD-ROM Player 01, second version of the model). Send several screenshots from different views, keep one folder per model and name changes `_v2`.

Background material is in `references/`:
- [`references/flat-pack-dfm-and-bend-formulas.md`](references/flat-pack-dfm-and-bend-formulas.md): design rules for slits, bridges and tabs, bend formulas and K-factors.
- [`references/cdrom-player-das-pod-analysis.md`](references/cdrom-player-das-pod-analysis.md): architecture and dimensions read from the maker's assembly video, and what the reference build did.
- [`examples/cdrom-player-flatpack/`](../../examples/cdrom-player-flatpack/README.md): the two CD-ROM player models (3MF and SolidCraft design files). v1 folds tall walls straight from the base. v2 uses large folded panels with round ear tabs at the screw locations.

## 1. Read the architecture first
- A flat pack is a few flat sheets: 2 main plates joined by a perforated or slit bend line, 2 separate side plates and hardware. Side plates are NOT folded from the base. Check the real flat patterns or photos before modelling: the first version of the CD-ROM model was wrong because the walls were assumed instead of read.
- Typical set: BASE sheet (rear plus bottom), LID sheet (top plus front), 2 side plates, rear panel, fasteners (M3/M4 plus nut), feet, placeholders for internals.
- Dimensions taken from video frames or photos carry about +-8-10 %. Say so. Spoken numbers are unreliable. Use a known part as the scale (a 5.25" drive bezel is 148 mm wide).
- If real flat patterns are supplied later, diff them against the model list: perforation, windows and grids, steps, ear count and positions, feet and fan holes, relief notches, part count.

# solid.shell in SolidCraft: how it works, how it fails, how to get around it

## Syntax
`solid.shell {faces:[[x,y,z]], thickness, direction:"inside"|"outside"|"both", tangent_chain?, body?}`
- `faces` are points on the faces to REMOVE (open). For an underside cavity pick a point on the bottom face z=0 that lies inside the outline and outside bosses and bores, for example [-38,0,0].
- `direction:"inside"` keeps the outer shape. `body` names the target body.

## Failure 1: "offset: a corner whose faces don't meet the same way after the move"
- Cause: arcs that are meant to be tangent (for example a convex R12 around a hole boss and concave R75 side arcs) were entered with 5-decimal coordinates, so the faces are only nearly tangent. The offset treats the joints as real corners and fails for any thickness, even on the bare extruded base.
- Fix: compute the tangent points analytically (the point on the line between the two arc centres at distance r1 from the first centre) and enter the coordinates with 10 decimals in `sketch.arc.three_point` (start, end, through). The shell then works on the base and on base plus cylinder.
- `solid.fillet` on such an edge answers `edge is smooth` when the joint is truly tangent, so you can use it as a tangency test.
- `tangent_chain:true` did not help for this failure.

## Failure 2: shell hangs SolidCraft (minutes, needs a restart)

# SolidCraft speed-modeling lessons

Collected from about a dozen timed builds of SolidWorks Model Mania speed-modeling drawings (2001-2005 editions) plus a 2024 phase-1 part. The drawings and solution files belong to their authors and are not included. Only the lessons are. Each build was done blind from the drawing first and then redone after watching the author's solution video. Use with `solidcraft-modeling`, `solidcraft-robust-build-order` and `solidcraft-drawing-and-tutorial-reading`.

## 1. Habits that worked
- Save a checkpoint before fillets and before any heavy batch.
- Order: flat parts and fillets, then holes, then spheres and cavities LAST.
- Watch and transcribe the audio of the solution video BEFORE rebuilding, and only then measure against the solution file.
- Compare every `measure` with an analytic estimate. The bounding box can match while the volume still exposes wrong details.
- For several configurations of one drawing, generate the commands with a parametric Python script (D, L, A, ...). This produced all configurations of one test without boolean errors.
- Keep to one simple body and few features when fillets are needed (see `solidcraft-robust-build-order`).

## 2. Failures: the app (crash, timeout)
- A device call times out at about 60 s. Heavy batches and slow fillets exceed it, but the work may still finish. Check with `inspect_design` before resending.

# Real hardware in assemblies (step.parts to SolidCraft)

Adapted from the `step-parts` skill of earthtojake/text-to-cad (MIT, see NOTICE). The workflow and the helper script are rewritten for SolidCraft. Everything marked "verified" was run on SolidCraft 0.25.1 in October 2026.

Search the catalog BEFORE modelling a placeholder cylinder for a screw or a bearing. A real part gives the right envelope, mass and hole size, and the assembly stays honest.

## Workflow
1. **Search.** `python scripts/step_parts.py "M3 socket head 12" --standard "ISO 4762" --limit 5` (standard library only, prints JSON). Facets: `--category`, `--family`, `--standard`, `--tag`. Catalog about 16,800 parts (about 2,100 fasteners, 86 bearings, standoffs, motors, boards, profiles).
2. **Check the attributes, not the name.** Query tokens match as substrings, so "M3" also returns M30 parts. Read `attributes.thread`, `lengthMm`, the standard and the bore before choosing. If several fit, show the best two or three with their ids.
3. **Download into the model's own folder.** `python scripts/step_parts.py --id <id> --download --out-dir <model folder>/parts`. The script verifies the SHA-256 against the catalog and refuses to save on a mismatch. `--download` takes the first result, so use `--id` once you have chosen.
4. **Insert.** `file.insert_step {path, name, matrix?}`. The path must be a path the SolidCraft app can open (a Windows path when the app runs on Windows, not a path inside the agent's shell).
5. **Verify** with `measure` (bounding box against the catalog attributes) and a screenshot.
6. **Place.** Pass `matrix` at insert time, or move the occurrence afterwards (`occurrence.move`, which composes with the current transform; see `solidcraft-assemblies`).

# SolidCraft: sweep recipes and boolean hang avoidance

Use with `solidcraft-modeling` and `solidcraft-tutorial-recipes`. Validated on public sweep tutorials (a twisted vase and a hex cup) and consistent with the timed-test lessons in `solidcraft-speed-modeling-lessons` (joins with coincident circular faces hang the app).

## 1. Sweep recipe (MCP)
1. Profile sketch on the plane where the profile lives (XY, or XY with an offset when it sits on top of a base).
2. Path sketch as a SEPARATE sketch on an upright plane `{origin:[0,0,0], x_dir:[1,0,0], y_dir:[0,0,1]}`: `sketch.line [[0,0],[0,H]]`.
3. `solid.sweep {sketch:"Profile", profiles:[{point:[x,y]}...], path_sketch:"Path", path:["l1"], twist:"90 deg", scale:2.2, operation:"new", body_name:"X"}`. Pick every closed region with a point inside it (for crossing arcs or circles pick all the lens regions and the ring).
4. Always use `operation:"new"`. A sweep joined to another body is a Boolean and very slow (the tutorial author says the same).
5. `measure` right after: the bbox height is the path length (plus the base), compare the volume with a numeric estimate. 400-1000+ faces are normal for twisted bodies.

## 2. Verified examples
- **Hex cup:** hexagon across flats 40 (`sketch.polygon.inscribed radius 23.0940108 sides 6 angle 0`), `sketch.fillet` R4 on the 6 corners, `sketch.offset` 2 inward (2 profiles give a wall ring), path 80 mm, twist 90 deg, end scale 2.2, profile pick [0,19]: 55 612.7 mm3, z 0-80. The transcript said 14 / 18 / 19 but the frames show 40 / 80 / 90. Bottom: `solid.extrude` of the outer profile 2 mm negative as a separate body (2 760.9 mm3).
- **Vase:** base dia 120 x 10. Profile sketch on XY offset 10 with circles r50 and r45 plus 8 arcs R6 (centres on the r49.6387 circle every 45 deg). Path 120 mm, twist 100 deg, scale 2, new body: 537 948 mm3, z 10-130.

# SolidCraft: GUI tutorial steps -> MCP commands (validated)

Public SolidCraft video tutorials teach the GUI. Every recipe below was re-run through the MCP server and checked with `measure` against hand-computed volumes. The tutorials themselves are not reproduced here, only the numbers needed to check a rebuild. Use together with `solidcraft-modeling` (command shapes, plane table, ids). For sweep recipes (twist, scale, vase, cup) and the rules for booleans that hang the app see `solidcraft-sweep-and-boolean-hangs`.

## GUI -> MCP mapping
| GUI step | MCP |
|---|---|
| New design | `new_design` (ask first if the open design has unsaved work) |
| Create sketch on the Right / Front / Top plane | `sketch.create plane` `YZ` / `XZ` / `XY`. On XZ the sketch y axis is -Z, so for a profile drawn upright use a custom plane `{origin:[0,0,0], x_dir:[1,0,0], y_dir:[0,0,1]}` (normal -Y) |
| Sketch on a top face or offset plane | `sketch.create {plane:"XY", offset:10}` or `construct.plane.offset` |
| Draw a line chain with horizontal/vertical constraints | `sketch.line {points:[[..],..]}` (`points`, not p0/p1; tested on 0.29.0). A polyline already gets horizontal and vertical constraints where lines are axis-aligned. Give exact coordinates instead of constrain-and-dimension steps |
| Polygon with a dimension across flats | `sketch.polygon.inscribed {center, radius, sides, angle}`; radius = across-flats / (2 cos(180/n)), for example a hexagon across flats 40 gives radius 23.0940108 |
| Sketch fillet on polygon corners | `sketch.fillet {points:[p1..pn], radius}` |
| Sketch chamfer on several corners (0.29 "several corners in one operation") | `sketch.chamfer.equal_distance {points:[corners], distance}`, `sketch.chamfer.two_distance`, `sketch.chamfer.distance_angle`. One call, one operation; the sketch gets more degrees of freedom. Tested on 0.29.0 on a 60 x 40 x 10 plate: 4 corners d=5 -> 23 500 mm3, 3 corners 8/4 -> 23 520 mm3, 4 corners d=6 at 30 deg -> 23 584.3 mm3, all exact |