fix(assembly): classify datum plane references in Distance joints

When a Distance joint references a datum plane (XY_Plane, XZ_Plane,
YZ_Plane), getDistanceType() failed to recognize it because datum
plane sub-names yield an empty element type. This caused the fallback
to DistanceType::Other → BaseJointKind::Planar, which adds spurious
parallel-normal residuals that overconstrain the system.

For example, three vertex-to-datum-plane Distance joints produced
10 residuals (3×Planar) with 6 mutually contradictory orientation
constraints, causing the solver to find garbage least-squares
solutions.

Add early detection of App::Plane datum objects before the main
geometry classification chain. Datum planes are now correctly mapped:
- Vertex + DatumPlane → PointPlane → PointInPlane (1 residual)
- Edge + DatumPlane → LinePlane → LineInPlane
- Face/DatumPlane + DatumPlane → PlanePlane → Planar

CMakeLists.txt

@@ -53,7 +53,7 @@ project(KindredCreate)
 # Kindred Create version
 set(KINDRED_CREATE_VERSION_MAJOR "0")
 set(KINDRED_CREATE_VERSION_MINOR "1")
-set(KINDRED_CREATE_VERSION_PATCH "0")
+set(KINDRED_CREATE_VERSION_PATCH "5")
 set(KINDRED_CREATE_VERSION "${KINDRED_CREATE_VERSION_MAJOR}.${KINDRED_CREATE_VERSION_MINOR}.${KINDRED_CREATE_VERSION_PATCH}")
 
 # Underlying FreeCAD version

README.md

@@ -2,7 +2,7 @@
 
 **An engineering-focused parametric 3D CAD platform built on FreeCAD 1.0+**
 
-Kindred Create 0.1.0 | FreeCAD 1.2.0 base
+Kindred Create 0.1.5 | FreeCAD 1.2.0 base
 
 [Website](https://www.kindred-systems.com/create) |
 [Downloads](https://git.kindred-systems.com/kindred/create/releases) |

docs/src/SUMMARY.md

@@ -12,6 +12,7 @@
 - [Workbenches](./guide/workbenches.md)
   - [ztools](./guide/ztools.md)
   - [Silo](./guide/silo.md)
+  - [Document Templates](./guide/templates.md)
 
 # Architecture
 
@@ -49,6 +50,16 @@
 - [Solver Service](./silo-server/SOLVER.md)
 - [Roadmap](./silo-server/ROADMAP.md)
 
+# Kindred Solver
+
+- [Overview](./solver/overview.md)
+- [Expression DAG](./solver/expression-dag.md)
+- [Constraints](./solver/constraints.md)
+- [Solving Algorithms](./solver/solving.md)
+- [Diagnostics](./solver/diagnostics.md)
+- [Assembly Integration](./solver/assembly-integration.md)
+- [Writing a Custom Solver](./solver/writing-a-solver.md)
+
 # Reference
 
 - [Configuration](./reference/configuration.md)

docs/src/development/build-system.md

@@ -13,7 +13,7 @@ Kindred Create uses **CMake** for build configuration, **pixi** (conda-based) fo
 ## CMake configuration
 
 The root `CMakeLists.txt` defines:
-- **Kindred Create version:** `0.1.0` (via `KINDRED_CREATE_VERSION`)
+- **Kindred Create version:** `0.1.5` (via `KINDRED_CREATE_VERSION`)
 - **FreeCAD base version:** `1.0.0` (via `FREECAD_VERSION`)
 - CMake policy settings for compatibility
 - ccache auto-detection
@@ -25,7 +25,7 @@ The root `CMakeLists.txt` defines:
 The version flows from CMake to Python via `configure_file()`:
 
 ```
-CMakeLists.txt (KINDRED_CREATE_VERSION = "0.1.0")
+CMakeLists.txt (KINDRED_CREATE_VERSION = "0.1.5")
     → src/Mod/Create/version.py.in (template)
     → build/*/Mod/Create/version.py (generated)
     → update_checker.py (imports VERSION)

docs/src/development/gui-build-integration.md

@@ -157,7 +157,7 @@ Edit only the canonical file in `Stylesheets/` — the preference pack copy is g
 Defined in the top-level `CMakeLists.txt` and injected as compiler definitions:
 
 ```cmake
-set(KINDRED_CREATE_VERSION "0.1.0")
+set(KINDRED_CREATE_VERSION "0.1.5")
 set(FREECAD_VERSION "1.0.0")
 
 add_definitions(-DKINDRED_CREATE_VERSION="${KINDRED_CREATE_VERSION}")

docs/src/guide/silo.md

@@ -53,6 +53,7 @@ The silo-mod repository was split from a monorepo into three repos: `silo-client
 | `Silo_TagProjects` | Multi-select dialog for assigning project tags to items |
 | `Silo_Rollback` | Select a previous revision and create a new revision from that point with optional comment |
 | `Silo_SetStatus` | Change revision lifecycle status: draft → review → released → obsolete |
+| `Silo_SaveAsTemplate` | Save a copy of the current document as a reusable [template](./templates.md) with metadata |
 
 ### Administration
 
@@ -129,9 +130,11 @@ mods/silo/
 ├── freecad/
 │   ├── InitGui.py             # SiloWorkbench registration
 │   ├── schema_form.py         # Schema-driven item creation dialog (SchemaFormDialog)
-│   ├── silo_commands.py       # 14 commands + dock widgets
+│   ├── silo_commands.py       # 15 commands + dock widgets
 │   ├── silo_origin.py         # FileOrigin backend
 │   ├── silo_start.py          # Native start panel (database items, activity feed)
+│   ├── templates.py           # Template discovery, filtering, injection
+│   ├── templates/             # System template .kc files + CLI injection tool
 │   └── resources/icons/       # 10 silo-*.svg icons
 ├── silo-client/               # Shared Python API client (nested submodule)
 │   └── silo_client/

docs/src/guide/templates.md

@@ -0,0 +1,140 @@
+# Document Templates
+
+Templates let you create new parts and assemblies from pre-configured `.kc` files. Instead of starting from a bare `App::Part` or `Assembly::AssemblyObject`, a template can include predefined tree structures, jobs, metadata, and workbench-specific features.
+
+## How templates work
+
+A template is a normal `.kc` file with an extra `silo/template.json` descriptor inside the ZIP archive. When you select a template during **Silo > New**:
+
+1. The template `.kc` is **copied** to the canonical file path
+2. `silo/template.json` and `silo/manifest.json` are **stripped** from the copy
+3. The document is **opened** in FreeCAD
+4. Silo properties (part number, item ID, revision, type) are **stamped** onto the root object
+5. On **save**, `kc_format.py` auto-creates a fresh manifest
+
+The original template file is never modified.
+
+## Using templates
+
+### Creating a new item from a template
+
+1. **Silo > New** (Ctrl+N)
+2. Select an **Item Type** (Part, Assembly, etc.)
+3. The **Template** dropdown shows templates matching the selected type and category
+4. Select a template (or leave as "No template" for a blank document)
+5. Fill in the remaining fields and click **Create**
+
+The template combo updates automatically when you change the item type or category.
+
+### Saving a document as a template
+
+1. Open the document you want to use as a template
+2. **Silo > Save as Template**
+3. Fill in the template metadata:
+   - **Name** — display name shown in the template picker (pre-filled from document label)
+   - **Description** — what the template is for
+   - **Item Types** — which types this template applies to (part, assembly, etc.)
+   - **Categories** — category prefix filter (e.g. `F`, `M01`); leave empty for all categories
+   - **Author** — pre-filled from your Silo login
+   - **Tags** — comma-separated search tags
+4. Click **Save Template**
+5. Optionally upload to Silo for team sharing
+
+The template is saved as a copy to your personal templates directory. The original document is unchanged.
+
+## Template search paths
+
+Templates are discovered from three locations, checked in order. Later paths shadow earlier ones by name (so you can override a system template with a personal one).
+
+| Priority | Path | Purpose |
+|----------|------|---------|
+| 1 (lowest) | `mods/silo/freecad/templates/` | System templates shipped with the addon |
+| 2 | `~/.local/share/FreeCAD/Templates/` | Personal templates (sister to `Macro/`) |
+| 3 (highest) | `~/projects/templates/` | Org-shared project templates |
+
+The personal templates directory (`Templates/`) is created automatically when you first save a template. It lives alongside the `Macro/` directory in your FreeCAD user data.
+
+## Template descriptor schema
+
+The `silo/template.json` file inside the `.kc` ZIP has the following structure:
+
+```json
+{
+  "template_version": "1.0",
+  "name": "Sheet Metal Part",
+  "description": "Body with SheetMetal base feature and laser-cut job",
+  "item_types": ["part"],
+  "categories": [],
+  "icon": "sheet-metal",
+  "author": "Kindred Systems",
+  "tags": ["sheet metal", "fabrication"]
+}
+```
+
+| Field | Type | Required | Description |
+|-------|------|----------|-------------|
+| `template_version` | string | yes | Schema version, currently `"1.0"` |
+| `name` | string | yes | Display name in the template picker |
+| `description` | string | no | Human-readable purpose |
+| `item_types` | string[] | yes | Controls visibility — `["part"]`, `["assembly"]`, or both |
+| `categories` | string[] | no | Category prefix filter. Empty array means all categories |
+| `icon` | string | no | Icon identifier (reserved for future use) |
+| `author` | string | no | Template author |
+| `tags` | string[] | no | Searchable metadata tags |
+
+### Filtering rules
+
+- **item_types**: The template only appears when the selected item type is in this list
+- **categories**: If non-empty, the template only appears when the selected category starts with one of the listed prefixes. An empty list means the template is available for all categories
+
+## Creating templates from the command line
+
+The `inject_template.py` CLI tool can inject `silo/template.json` into any `.kc` file:
+
+```bash
+cd mods/silo/freecad/templates/
+
+# Create a template from an existing .kc file
+python inject_template.py my-part.kc "My Custom Part" \
+    --type part \
+    --description "Part with custom features" \
+    --author "Your Name" \
+    --tag "custom"
+
+# Assembly template
+python inject_template.py my-assembly.kc "My Assembly" \
+    --type assembly \
+    --description "Assembly with predefined joint groups"
+
+# Template with category filtering
+python inject_template.py sheet-metal.kc "Sheet Metal Part" \
+    --type part \
+    --category S \
+    --category X \
+    --tag "sheet metal" \
+    --tag "fabrication"
+```
+
+## Module structure
+
+```
+mods/silo/freecad/
+├── templates.py               # Discovery, filtering, injection helpers
+├── templates/
+│   └── inject_template.py     # CLI tool for injecting template.json
+├── schema_form.py             # Template combo in New Item form
+└── silo_commands.py           # SaveAsTemplateDialog, Silo_SaveAsTemplate,
+                               # SiloSync.create_document_from_template()
+```
+
+### Key functions
+
+| Function | File | Purpose |
+|----------|------|---------|
+| `discover_templates()` | `templates.py` | Scan search paths for `.kc` files with `silo/template.json` |
+| `filter_templates()` | `templates.py` | Filter by item type and category prefix |
+| `inject_template_json()` | `templates.py` | Inject/replace `silo/template.json` in a `.kc` ZIP |
+| `get_default_template_dir()` | `templates.py` | Returns `{userAppData}/Templates/`, creating if needed |
+| `get_search_paths()` | `templates.py` | Returns the 3-tier search path list |
+| `create_document_from_template()` | `silo_commands.py` | Copy template, strip identity, stamp Silo properties |
+| `_clean_template_zip()` | `silo_commands.py` | Strip `silo/template.json` and `silo/manifest.json` from a copy |

docs/src/reference/configuration.md

@@ -77,7 +77,7 @@ Defined in the root `CMakeLists.txt`:
 
 | Constant | Value | Description |
 |----------|-------|-------------|
-| `KINDRED_CREATE_VERSION` | `0.1.0` | Kindred Create version |
+| `KINDRED_CREATE_VERSION` | `0.1.5` | Kindred Create version |
 | `FREECAD_VERSION` | `1.0.0` | FreeCAD base version |
 
 These are injected into `src/Mod/Create/version.py` at build time via `version.py.in`.

docs/src/solver/assembly-integration.md

@@ -0,0 +1,165 @@
+# Assembly Integration
+
+The Kindred solver integrates with FreeCAD's Assembly workbench through the KCSolve pluggable solver framework. This page describes the bridge layer, preference system, and interactive drag protocol.
+
+## KindredSolver class
+
+**Source:** `mods/solver/kindred_solver/solver.py`
+
+`KindredSolver` subclasses `kcsolve.IKCSolver` and implements the solver interface:
+
+```python
+class KindredSolver(kcsolve.IKCSolver):
+    def name(self):
+        return "Kindred (Newton-Raphson)"
+
+    def supported_joints(self):
+        return list(_SUPPORTED)  # 20 of 24 BaseJointKind values
+
+    def solve(self, ctx):        # Static solve
+    def diagnose(self, ctx):     # Constraint analysis
+    def pre_drag(self, ctx, drag_parts):   # Begin drag session
+    def drag_step(self, drag_placements):  # Mouse move during drag
+    def post_drag(self):                   # End drag session
+    def is_deterministic(self):  # Returns True
+```
+
+### Registration
+
+The solver is registered at addon load time via `Init.py`:
+
+```python
+import kcsolve
+from kindred_solver import KindredSolver
+kcsolve.register_solver("kindred", KindredSolver)
+```
+
+The `mods/solver/` directory is a FreeCAD addon discovered by the addon loader through its `package.xml` manifest.
+
+### Supported joints
+
+The Kindred solver handles 20 of the 24 `BaseJointKind` values. The remaining 4 are stubs that produce no residuals:
+
+| Supported | Stub (no residuals) |
+|-----------|-------------------|
+| Coincident, PointOnLine, PointInPlane, Concentric, Tangent, Planar, LineInPlane, Parallel, Perpendicular, Angle, Fixed, Revolute, Cylindrical, Slider, Ball, Screw, Universal, Gear, RackPinion, DistancePointPoint | Cam, Slot, DistanceCylSph, Custom |
+
+### Joint limits
+
+Joint travel limits (`Constraint.limits`) are accepted but not enforced. The solver logs a warning once per instance when limits are encountered. Enforcing inequality constraints requires active-set or barrier-method extensions beyond the current Newton-Raphson formulation.
+
+## Solver selection
+
+### C++ preference
+
+`AssemblyObject::getOrCreateSolver()` reads the user preference to select the solver backend:
+
+```cpp
+ParameterGrp::handle hGrp = App::GetApplication().GetParameterGroupByPath(
+    "User parameter:BaseApp/Preferences/Mod/Assembly");
+std::string solverName = hGrp->GetASCII("Solver", "");
+solver_ = KCSolve::SolverRegistry::instance().get(solverName);
+```
+
+An empty string (`""`) returns the registry default (the first solver registered, which is OndselSolver). Setting `"kindred"` selects the Kindred solver.
+
+`resetSolver()` clears the cached solver instance so the next solve picks up preference changes.
+
+### Preferences UI
+
+The Assembly preferences page (`Edit > Preferences > Assembly`) includes a "Solver backend" combo box populated from the registry at load time:
+
+- **Default** -- empty string, uses the registry default (OndselSolver)
+- **OndselSolver (Lagrangian)** -- `"ondsel"`
+- **Kindred (Newton-Raphson)** -- `"kindred"` (available when the solver addon is loaded)
+
+The preference is stored as `Mod/Assembly/Solver` in the FreeCAD parameter system.
+
+### Programmatic switching
+
+From the Python console:
+
+```python
+import FreeCAD
+pref = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Mod/Assembly")
+
+# Switch to Kindred
+pref.SetString("Solver", "kindred")
+
+# Switch back to default
+pref.SetString("Solver", "")
+
+# Force the active assembly to pick up the change
+if hasattr(FreeCADGui, "ActiveDocument"):
+    for obj in FreeCAD.ActiveDocument.Objects:
+        if hasattr(obj, "resetSolver"):
+            obj.resetSolver()
+```
+
+## Interactive drag protocol
+
+The drag protocol provides real-time constraint solving during viewport part dragging. It is a three-phase protocol:
+
+### pre_drag(ctx, drag_parts)
+
+Called when the user begins dragging. Stores the context and dragged part IDs, then runs a full solve to establish the starting state.
+
+```python
+def pre_drag(self, ctx, drag_parts):
+    self._drag_ctx = ctx
+    self._drag_parts = set(drag_parts)
+    return self.solve(ctx)
+```
+
+### drag_step(drag_placements)
+
+Called on each mouse move. Updates the dragged parts' placements in the stored context, then re-solves. Since the parts moved only slightly from the previous position, Newton-Raphson converges in 1-2 iterations.
+
+```python
+def drag_step(self, drag_placements):
+    ctx = self._drag_ctx
+    for pr in drag_placements:
+        for part in ctx.parts:
+            if part.id == pr.id:
+                part.placement = pr.placement
+                break
+    return self.solve(ctx)
+```
+
+### post_drag()
+
+Called when the drag ends. Clears the stored state.
+
+```python
+def post_drag(self):
+    self._drag_ctx = None
+    self._drag_parts = None
+```
+
+### Performance notes
+
+The current implementation re-solves from scratch on each drag step, using the updated placements as the initial guess. This is correct and simple. For assemblies with fewer than ~50 parts, interactive frame rates are maintained because:
+
+- Newton-Raphson converges in 1-2 iterations from a nearby initial guess
+- Pre-passes eliminate fixed parameters before the iterative loop
+- The symbolic Jacobian is recomputed each step (no caching yet)
+
+For larger assemblies, cached incremental solving (reusing the decomposition and Jacobian structure across drag steps) is planned as a future optimization.
+
+## Diagnostics integration
+
+`diagnose(ctx)` builds the constraint system and runs overconstrained detection, returning a list of `kcsolve.ConstraintDiagnostic` objects. The Assembly module calls this to populate the constraint diagnostics panel.
+
+```python
+def diagnose(self, ctx):
+    system = _build_system(ctx)
+    residuals = substitution_pass(system.all_residuals, system.params)
+    return _run_diagnostics(residuals, system.params, system.residual_ranges, ctx)
+```
+
+## Not yet implemented
+
+- **Kinematic simulation** (`run_kinematic`, `num_frames`, `update_for_frame`) -- the base class defaults return `Failed`. Requires time-stepping integration with motion driver expression evaluation.
+- **Joint limit enforcement** -- inequality constraints need active-set or barrier solver extensions.
+- **Fixed-joint bundling** (`supports_bundle_fixed()` returns `False`) -- the solver receives unbundled parts; the Assembly module pre-bundles when needed.
+- **Native export** (`export_native()`) -- no solver-native debug format defined.

docs/src/solver/constraints.md

@@ -0,0 +1,116 @@
+# Constraints
+
+Each constraint type maps to a class that produces residual expressions. The residuals equal zero when the constraint is satisfied. The number of residuals equals the number of degrees of freedom removed.
+
+**Source:** `mods/solver/kindred_solver/constraints.py`, `mods/solver/kindred_solver/geometry.py`
+
+## Constraint vocabulary
+
+### Point constraints
+
+| Type | DOF removed | Residuals |
+|------|-------------|-----------|
+| **Coincident** | 3 | `p_i - p_j` (world-frame marker origins coincide) |
+| **PointOnLine** | 2 | Two components of `(p_i - p_j) x z_j` (point lies on line through `p_j` along `z_j`) |
+| **PointInPlane** | 1 | `(p_i - p_j) . z_j - offset` (signed distance to plane) |
+
+### Orientation constraints
+
+| Type | DOF removed | Residuals |
+|------|-------------|-----------|
+| **Parallel** | 2 | Two components of `z_i x z_j` (cross product of Z-axes is zero) |
+| **Perpendicular** | 1 | `z_i . z_j` (dot product of Z-axes is zero) |
+| **Angle** | 1 | `z_i . z_j - cos(angle)` |
+
+### Axis/surface constraints
+
+| Type | DOF removed | Residuals |
+|------|-------------|-----------|
+| **Concentric** | 4 | Parallel Z-axes (2) + point-on-line (2) |
+| **Tangent** | 1 | `(p_i - p_j) . z_j` (signed distance along normal) |
+| **Planar** | 3 | Parallel normals (2) + point-in-plane (1) |
+| **LineInPlane** | 2 | Point-in-plane (1) + `z_i . n_j` (line direction perpendicular to normal) (1) |
+
+### Kinematic joints
+
+| Type | DOF removed | DOF remaining | Residuals |
+|------|-------------|---------------|-----------|
+| **Fixed** | 6 | 0 | Coincident origins (3) + quaternion error imaginary parts (3) |
+| **Ball** | 3 | 3 | Coincident origins (same as Coincident) |
+| **Revolute** | 5 | 1 (rotation about Z) | Coincident origins (3) + parallel Z-axes (2) |
+| **Cylindrical** | 4 | 2 (rotation + slide) | Parallel Z-axes (2) + point-on-line (2) |
+| **Slider** | 5 | 1 (slide along Z) | Parallel Z-axes (2) + point-on-line (2) + twist lock: `x_i . y_j` (1) |
+| **Screw** | 5 | 1 (helical) | Cylindrical (4) + pitch coupling: `axial - pitch * qz_rel / pi` (1) |
+| **Universal** | 4 | 2 (rotation about each Z) | Coincident origins (3) + perpendicular Z-axes (1) |
+
+### Mechanical elements
+
+| Type | DOF removed | Residuals |
+|------|-------------|-----------|
+| **Gear** | 1 | `r_i * qz_i + r_j * qz_j` (coupled rotation via quaternion Z-components) |
+| **RackPinion** | 1 | `translation - 2 * pitch_radius * qz_i` (rotation-translation coupling) |
+| **Cam** | 0 | Stub (no residuals) |
+| **Slot** | 0 | Stub (no residuals) |
+
+### Distance constraints
+
+| Type | DOF removed | Residuals |
+|------|-------------|-----------|
+| **DistancePointPoint** | 1 | `\|p_i - p_j\|^2 - d^2` (squared form avoids sqrt in Jacobian) |
+| **DistanceCylSph** | 0 | Stub (geometry classification dependent) |
+
+## Marker convention
+
+Every constraint references two parts (`body_i`, `body_j`) with local coordinate frames called markers. Each marker has a position (attachment point on the part) and a quaternion (orientation).
+
+The marker Z-axis defines the constraint direction:
+- **Revolute:** Z-axis = hinge axis
+- **Planar:** Z-axis = face normal
+- **PointOnLine:** Z-axis = line direction
+- **Slider:** Z-axis = slide direction
+
+The solver computes world-frame marker axes by composing the body quaternion with the marker quaternion: `q_world = q_body * q_marker`, then rotating unit vectors through the result.
+
+## Fixed constraint orientation
+
+The Fixed constraint locks all 6 DOF using a quaternion error formulation:
+
+1. Compute total orientation: `q_i = q_body_i * q_marker_i`, `q_j = q_body_j * q_marker_j`
+2. Compute relative quaternion: `q_err = conj(q_i) * q_j`
+3. When orientations match, `q_err` is the identity quaternion `(1, 0, 0, 0)`
+4. Residuals are the three imaginary components of `q_err` (should be zero)
+
+The quaternion normalization constraint on each body provides the fourth equation needed to fully determine the quaternion.
+
+## Rotation proxies for mechanical constraints
+
+Gear, RackPinion, and Screw constraints need to measure rotation angles. Rather than extracting Euler angles (which would introduce transcendentals), they use the Z-component of a relative quaternion as a proxy:
+
+```
+q_local = conj(q_marker) * q_body * q_marker
+angle ~ 2 * qz_local  (for small angles)
+```
+
+This is exact at the solution and has correct gradient direction, which is sufficient for Newton-Raphson convergence from a nearby initial guess.
+
+## Geometry helpers
+
+The `geometry.py` module provides Expr-level vector operations used by constraint classes:
+
+- `marker_z_axis(body, marker_quat)` -- world-frame Z-axis via `quat_rotate(q_body * q_marker, [0,0,1])`
+- `marker_x_axis(body, marker_quat)` -- world-frame X-axis (used by Slider twist lock)
+- `marker_y_axis(body, marker_quat)` -- world-frame Y-axis (used by Slider twist lock)
+- `dot3(a, b)` -- dot product of Expr triples
+- `cross3(a, b)` -- cross product of Expr triples
+- `point_plane_distance(point, origin, normal)` -- signed distance
+- `point_line_perp_components(point, origin, dir)` -- two perpendicular distance components
+
+## Writing a new constraint
+
+To add a constraint type:
+
+1. Subclass `ConstraintBase` in `constraints.py`
+2. Implement `residuals()` returning a list of `Expr` nodes
+3. Add a case in `solver.py:_build_constraint()` to instantiate it from `BaseJointKind`
+4. Add the `BaseJointKind` value to `_SUPPORTED` in `solver.py`
+5. Add the residual count to the tables in `decompose.py`

docs/src/solver/diagnostics.md

@@ -0,0 +1,117 @@
+# Diagnostics
+
+The solver provides three levels of constraint analysis: system-wide DOF counting, per-entity DOF decomposition, and overconstrained/conflicting constraint detection.
+
+## DOF counting
+
+**Source:** `mods/solver/kindred_solver/dof.py`
+
+Degrees of freedom are computed from the Jacobian rank:
+
+```
+DOF = n_free_params - rank(J)
+```
+
+Where `n_free_params` is the number of non-fixed parameters and `rank(J)` is the numerical rank of the Jacobian evaluated at current parameter values (SVD with tolerance `1e-8`).
+
+A well-constrained assembly has `DOF = 0` (exactly enough constraints to determine all positions). Positive DOF means underconstrained (parts can still move). Negative DOF is not possible with this formulation -- instead, rank deficiency in an overdetermined system indicates redundant constraints.
+
+The DOF value is reported in `SolveResult.dof` after every solve.
+
+## Per-entity DOF
+
+**Source:** `mods/solver/kindred_solver/diagnostics.py`
+
+`per_entity_dof()` breaks down the DOF count per body, identifying which motions remain free for each part:
+
+1. Build the full Jacobian
+2. For each non-grounded body, extract the 7 columns corresponding to its parameters
+3. Compute SVD of the sub-matrix; rank = number of constrained directions
+4. `remaining_dof = 7 - rank` (includes the quaternion normalization constraint counted in the rank)
+5. Classify null-space vectors as free motions by analyzing their translation vs. rotation components:
+   - Pure translation: >80% of the null vector's energy is in `tx, ty, tz` components
+   - Pure rotation: >80% of the energy is in `qw, qx, qy, qz` components
+   - Helical: mixed
+
+Returns a list of `EntityDOF` dataclasses:
+
+```python
+@dataclass
+class EntityDOF:
+    entity_id: str
+    remaining_dof: int
+    free_motions: list[str]  # e.g., ["rotation about Z", "translation along X"]
+```
+
+## Overconstrained detection
+
+**Source:** `mods/solver/kindred_solver/diagnostics.py`
+
+`find_overconstrained()` identifies redundant and conflicting constraints when the system is overconstrained (Jacobian is rank-deficient). It runs automatically when `solve()` fails to converge.
+
+### Algorithm
+
+Following the approach used by SolvSpace:
+
+1. **Check rank.** Build the full Jacobian `J`, compute its rank via SVD. If `rank == n_residuals`, the system is not overconstrained -- return empty.
+
+2. **Find redundant constraints.** For each constraint, temporarily remove its rows from J and re-check rank. If the rank is preserved, the constraint is **redundant** (removing it doesn't change the system's effective equations).
+
+3. **Distinguish conflicting from merely redundant.** Compute the left null space of J (columns of U beyond the rank). Project the residual vector onto this null space:
+   ```
+   null_residual = U_null^T @ r
+   residual_projection = U_null @ null_residual
+   ```
+   If a redundant constraint's residuals have significant projection onto the null space, it is **conflicting** -- it's both redundant and unsatisfied, meaning it contradicts other constraints.
+
+### Diagnostic output
+
+Returns `ConstraintDiag` dataclasses:
+
+```python
+@dataclass
+class ConstraintDiag:
+    constraint_index: int
+    kind: str           # "redundant" or "conflicting"
+    detail: str         # Human-readable explanation
+```
+
+These are converted to `kcsolve.ConstraintDiagnostic` objects in the IKCSolver bridge:
+
+| ConstraintDiag.kind | kcsolve.DiagnosticKind |
+|---------------------|----------------------|
+| `"redundant"` | `Redundant` |
+| `"conflicting"` | `Conflicting` |
+
+### Example
+
+Two Fixed joints between the same pair of parts:
+
+- Joint A: 6 residuals (3 position + 3 orientation)
+- Joint B: 6 residuals (same as Joint A)
+
+Jacobian rank = 6 (Joint B's rows are linearly dependent on Joint A's). Both joints are detected as redundant. If the joints specify different relative positions, both are also flagged as conflicting.
+
+## Solution preferences
+
+**Source:** `mods/solver/kindred_solver/preference.py`
+
+Solution preferences guide the solver toward physically intuitive solutions when multiple valid configurations exist.
+
+### Minimum-movement weighting
+
+The weight vector scales the Newton step to prefer solutions near the initial configuration. Translation parameters get weight `1.0`, quaternion parameters get weight `(180/pi)^2 ~ 3283`. This makes a 1-radian rotation equally "expensive" as a ~57-unit translation.
+
+The weighted minimum-norm step is:
+
+```
+J_scaled = J @ diag(W^{-1/2})
+dx_scaled = lstsq(J_scaled, -r)
+dx = dx_scaled * W^{-1/2}
+```
+
+This produces the minimum-norm solution in the weighted parameter space, biasing toward small movements.
+
+### Half-space tracking
+
+Described in detail in [Solving Algorithms: Half-space tracking](solving.md#half-space-tracking). Preserves the initial configuration's "branch" for constraints with multiple valid solutions by detecting and correcting branch crossings during iteration.

docs/src/solver/expression-dag.md

@@ -0,0 +1,96 @@
+# Expression DAG
+
+The expression DAG is the foundation of the Kindred solver. All constraint equations, Jacobian entries, and residuals are built as immutable trees of `Expr` nodes. This lets the solver compute exact symbolic derivatives and simplify constant sub-expressions before the iterative solve loop.
+
+**Source:** `mods/solver/kindred_solver/expr.py`
+
+## Node types
+
+Every node is a subclass of `Expr` and implements three methods:
+
+- `eval(env)` -- evaluate the expression given a name-to-value dictionary
+- `diff(var)` -- return a new Expr tree for the partial derivative with respect to `var`
+- `simplify()` -- return an algebraically simplified copy
+
+### Leaf nodes
+
+| Node | Description | diff(x) |
+|------|-------------|---------|
+| `Const(v)` | Literal floating-point value | 0 |
+| `Var(name)` | Named parameter (from `ParamTable`) | 1 if name matches, else 0 |
+
+### Unary nodes
+
+| Node | Description | diff(x) |
+|------|-------------|---------|
+| `Neg(f)` | Negation: `-f` | `-f'` |
+| `Sin(f)` | Sine: `sin(f)` | `cos(f) * f'` |
+| `Cos(f)` | Cosine: `cos(f)` | `-sin(f) * f'` |
+| `Sqrt(f)` | Square root: `sqrt(f)` | `f' / (2 * sqrt(f))` |
+
+### Binary nodes
+
+| Node | Description | diff(x) |
+|------|-------------|---------|
+| `Add(a, b)` | Sum: `a + b` | `a' + b'` |
+| `Sub(a, b)` | Difference: `a - b` | `a' - b'` |
+| `Mul(a, b)` | Product: `a * b` | `a'b + ab'` (product rule) |
+| `Div(a, b)` | Quotient: `a / b` | `(a'b - ab') / b^2` (quotient rule) |
+| `Pow(a, n)` | Power: `a^n` (constant exponent only) | `n * a^(n-1) * a'` |
+
+### Sentinels
+
+`ZERO = Const(0.0)` and `ONE = Const(1.0)` are pre-allocated constants used by `diff()` to avoid allocating trivial nodes.
+
+## Operator overloading
+
+Python's arithmetic operators are overloaded on `Expr`, so constraints can be written in natural notation:
+
+```python
+from kindred_solver.expr import Var, Const
+
+x = Var("x")
+y = Var("y")
+
+# Build the expression: x^2 + 2*x*y - 1
+expr = x**2 + 2*x*y - Const(1.0)
+
+# Evaluate at x=3, y=4
+expr.eval({"x": 3.0, "y": 4.0})  # 32.0
+
+# Symbolic derivative w.r.t. x
+dx = expr.diff("x").simplify()  # 2*x + 2*y
+dx.eval({"x": 3.0, "y": 4.0})   # 14.0
+```
+
+The `_wrap()` helper coerces plain `int` and `float` values to `Const` nodes automatically, so `2 * x` works without wrapping the `2`.
+
+## Simplification
+
+`simplify()` applies algebraic identities bottom-up:
+
+- Constant folding: `Const(2) + Const(3)` becomes `Const(5)`
+- Identity elimination: `x + 0 = x`, `x * 1 = x`, `x^0 = 1`, `x^1 = x`
+- Zero propagation: `0 * x = 0`
+- Negation collapse: `-(-x) = x`
+- Power expansion: `x^2` becomes `x * x` (avoids `pow()` in evaluation)
+
+Simplification is applied once to each Jacobian entry after symbolic differentiation, before the solve loop begins. This reduces the expression tree size and speeds up repeated evaluation.
+
+## How the solver uses expressions
+
+1. **Parameter registration.** `ParamTable.add("Part001/tx", 10.0)` creates a `Var("Part001/tx")` node and records its current value.
+
+2. **Constraint building.** Constraint classes compose `Var` nodes with arithmetic to produce residual `Expr` trees. For example, `CoincidentConstraint` builds `body_i.world_point() - body_j.world_point()`, producing 3 residual expressions.
+
+3. **Jacobian construction.** Newton-Raphson calls `r.diff(name).simplify()` for every (residual, free parameter) pair to build the symbolic Jacobian. This happens once before the solve loop.
+
+4. **Evaluation.** Each Newton iteration calls `expr.eval(env)` on every residual and Jacobian entry using the current parameter snapshot. `eval()` is a simple recursive tree walk with dictionary lookups.
+
+## Design notes
+
+**Why not numpy directly?** Symbolic expressions give exact derivatives without finite-difference approximations, and enable pre-passes (substitution, single-equation solve) that can eliminate variables before the iterative solver runs. The overhead of tree evaluation is acceptable for the problem sizes encountered in assembly solving (typically tens to hundreds of variables).
+
+**Why immutable?** Immutability means `diff()` can safely share sub-tree references between the original and derivative expressions. It also simplifies the substitution pass, which rebuilds trees with `Const` nodes replacing fixed `Var` nodes.
+
+**Limitations.** `Pow` differentiation only supports constant exponents. Variable exponents would require logarithmic differentiation (`d/dx f^g = f^g * (g' * ln(f) + g * f'/f)`), which hasn't been needed for assembly constraints.

docs/src/solver/overview.md

@@ -0,0 +1,92 @@
+# Kindred Solver Overview
+
+The Kindred solver is an expression-based Newton-Raphson constraint solver for the Assembly workbench. It is a pure-Python implementation that registers as a pluggable backend through the [KCSolve framework](../architecture/ondsel-solver.md), providing an alternative to the built-in OndselSolver (Lagrangian) backend.
+
+## Architecture
+
+```
+                            Assembly Module
+                                  │
+                      ┌───────────┴───────────┐
+                      │    SolverRegistry      │
+                      │  get("kindred")        │
+                      └───────────┬───────────┘
+                                  │
+                      ┌───────────┴───────────┐
+                      │    KindredSolver       │
+                      │  (kcsolve.IKCSolver)   │
+                      └───────────┬───────────┘
+                                  │
+              ┌───────────────────┼───────────────────┐
+              │                   │                   │
+     ┌────────┴────────┐  ┌──────┴──────┐  ┌────────┴────────┐
+     │  _build_system  │  │  Solve      │  │  Diagnostics    │
+     │  ────────────── │  │  ─────      │  │  ───────────    │
+     │  ParamTable     │  │  pre-passes │  │  DOF counting   │
+     │  RigidBody      │  │  Newton-R   │  │  overconstrained│
+     │  Constraints    │  │  BFGS       │  │  per-entity DOF │
+     │  Residuals      │  │  decompose  │  │  half-spaces    │
+     └─────────────────┘  └─────────────┘  └─────────────────┘
+```
+
+## Design principles
+
+**Symbolic differentiation.** All constraint equations are built as immutable expression DAGs (`Expr` trees). The Jacobian is computed symbolically via `expr.diff()` rather than finite differences. This gives exact derivatives, avoids numerical step-size tuning, and allows pre-passes to simplify or eliminate trivial equations before the iterative solver runs.
+
+**Residual-based formulation.** Each constraint produces a list of residual expressions that should evaluate to zero when satisfied. A Coincident constraint produces 3 residuals (dx, dy, dz), a Revolute produces 5 (3 position + 2 axis alignment), and so on. The solver minimizes the residual vector norm.
+
+**Unit quaternions for rotation.** Orientation is parameterized as a unit quaternion (w, x, y, z) rather than Euler angles, avoiding gimbal lock. A quaternion normalization residual (qw^2 + qx^2 + qy^2 + qz^2 - 1 = 0) is added for each free body, and quaternions are re-projected onto the unit sphere after each Newton step.
+
+**Current placements as initial guess.** The solver uses the parts' current positions as the initial guess, so it naturally converges to the nearest solution. Combined with half-space tracking, this produces physically intuitive results without branch-switching surprises.
+
+## Solve pipeline
+
+When `KindredSolver.solve(ctx)` is called with a `SolveContext`:
+
+1. **Build system** (`_build_system`) -- Create a `ParamTable` with 7 parameters per part (tx, ty, tz, qw, qx, qy, qz). Grounded parts have all parameters fixed. Build constraint objects from the context, collect their residual expressions, and add quaternion normalization residuals for free bodies.
+
+2. **Solution preferences** -- Compute half-space trackers for branching constraints (Distance, Parallel, Angle, Perpendicular) and build a minimum-movement weight vector that penalizes quaternion changes more than translation changes.
+
+3. **Pre-passes** -- Run the substitution pass (replace fixed parameters with constants) and the single-equation pass (analytically solve residuals with only one free variable).
+
+4. **Solve** -- For assemblies with 8+ free bodies, decompose the constraint graph into biconnected components and solve each cluster independently. For smaller assemblies, solve the full system monolithically. In both cases, use Newton-Raphson first, falling back to L-BFGS-B if Newton doesn't converge.
+
+5. **Post-process** -- Count degrees of freedom via Jacobian SVD rank. On failure, run overconstrained detection to identify redundant or conflicting constraints. Extract solved placements from the parameter table.
+
+## Module map
+
+| Module | Purpose |
+|--------|---------|
+| `solver.py` | `KindredSolver` class: IKCSolver bridge, solve/diagnose/drag entry points |
+| `expr.py` | Immutable expression DAG with eval, diff, simplify |
+| `params.py` | Parameter table: named variables with fixed/free tracking |
+| `entities.py` | `RigidBody`: 7-DOF entity owning solver parameters |
+| `quat.py` | Quaternion rotation as polynomial Expr trees |
+| `geometry.py` | Marker axis extraction, vector ops (dot, cross, point-plane, point-line) |
+| `constraints.py` | 24 constraint classes producing residual expressions |
+| `newton.py` | Newton-Raphson with symbolic Jacobian, quaternion renormalization |
+| `bfgs.py` | L-BFGS-B fallback via scipy |
+| `prepass.py` | Substitution pass and single-equation analytical solve |
+| `decompose.py` | Biconnected component graph decomposition and cluster-by-cluster solving |
+| `dof.py` | DOF counting via Jacobian SVD rank |
+| `diagnostics.py` | Overconstrained detection, per-entity DOF classification |
+| `preference.py` | Half-space tracking and minimum-movement weighting |
+
+## File locations
+
+- **Solver addon:** `mods/solver/` (git submodule)
+- **KCSolve C++ framework:** `src/Mod/Assembly/Solver/`
+- **Python bindings:** `src/Mod/Assembly/Solver/bindings/`
+- **Integration tests:** `src/Mod/Assembly/AssemblyTests/TestKindredSolverIntegration.py`
+- **Unit tests:** `mods/solver/tests/`
+
+## Related
+
+- [Expression DAG](expression-dag.md) -- the Expr type system
+- [Constraints](constraints.md) -- constraint vocabulary and residuals
+- [Solving algorithms](solving.md) -- Newton-Raphson, BFGS, decomposition
+- [Diagnostics](diagnostics.md) -- DOF counting, overconstrained detection
+- [Assembly integration](assembly-integration.md) -- IKCSolver bridge, preferences, drag
+- [Writing a custom solver](writing-a-solver.md) -- tutorial
+- [KCSolve architecture](../architecture/ondsel-solver.md) -- pluggable solver framework
+- [KCSolve Python API](../reference/kcsolve-python.md) -- kcsolve module reference

docs/src/solver/solving.md

@@ -0,0 +1,128 @@
+# Solving Algorithms
+
+The Kindred solver uses a multi-stage pipeline: pre-passes reduce the system, Newton-Raphson iterates toward a solution, and L-BFGS-B provides a fallback. For large assemblies, graph decomposition splits the system into independent clusters solved in sequence.
+
+## Pre-passes
+
+**Source:** `mods/solver/kindred_solver/prepass.py`
+
+Pre-passes run before the iterative solver and can eliminate variables analytically, reducing the problem size and improving convergence.
+
+### Substitution pass
+
+Replaces all fixed-parameter `Var` nodes with `Const` nodes carrying their current values, then simplifies. This compiles grounded-body parameters and previously-solved variables out of the expression trees.
+
+After substitution, residuals involving only fixed parameters simplify to constants (typically zero), and Jacobian entries for those parameters become exactly zero. This reduces the effective system size without changing the linear algebra.
+
+### Single-equation pass
+
+Scans residuals for any that depend on exactly one free variable. If the residual is linear in that variable (`a*x + b = 0`), it solves `x = -b/a` analytically, fixes the variable, and re-substitutes.
+
+The pass repeats until no more single-variable residuals can be solved. This handles cascading dependencies: solving one variable may reduce another residual to single-variable form.
+
+## Newton-Raphson
+
+**Source:** `mods/solver/kindred_solver/newton.py`
+
+The primary iterative solver. Each iteration:
+
+1. Evaluate the residual vector `r` and check convergence (`||r|| < tol`)
+2. Evaluate the Jacobian matrix `J` by calling `expr.eval()` on pre-computed symbolic derivatives
+3. Solve `J @ dx = -r` via `numpy.linalg.lstsq` (handles rank-deficient systems)
+4. Update parameters: `x += dx`
+5. Apply half-space correction (if configured)
+6. Re-normalize quaternions to unit length
+
+### Symbolic Jacobian
+
+The Jacobian is built once before the solve loop by calling `r.diff(name).simplify()` for every (residual, free parameter) pair. The resulting `Expr` trees are stored and re-evaluated at the current parameter values each iteration. This gives exact derivatives with no step-size tuning.
+
+### Weighted minimum-norm
+
+When a weight vector is provided, the step is column-scaled to produce the weighted minimum-norm solution. The solver scales J by W^{-1/2}, solves the scaled system, then unscales the step. This biases the solver toward solutions requiring smaller parameter changes in high-weight dimensions.
+
+The default weight vector assigns `1.0` to translation parameters and `~3283` to quaternion parameters (the square of 180/pi), making a 1-radian rotation equivalent to a ~57-unit translation. This produces physically intuitive solutions that prefer translating over rotating.
+
+### Quaternion renormalization
+
+After each Newton step, quaternion parameter groups `(qw, qx, qy, qz)` are re-projected onto the unit sphere by dividing by their norm. This prevents the quaternion from drifting away from unit length during iteration (the quaternion normalization residual only enforces this at convergence, not during intermediate steps).
+
+If a quaternion degenerates to near-zero norm, it is reset to the identity quaternion `(1, 0, 0, 0)`.
+
+### Convergence
+
+Newton-Raphson runs for up to 100 iterations with tolerance `1e-10` on the residual norm. For well-conditioned systems near the solution, convergence is typically quadratic (3-5 iterations). Interactive drag from a nearby position typically converges in 1-2 iterations.
+
+## L-BFGS-B fallback
+
+**Source:** `mods/solver/kindred_solver/bfgs.py`
+
+If Newton-Raphson fails to converge, L-BFGS-B minimizes the sum of squared residuals: `f(x) = 0.5 * sum(r_i^2)`. This is a quasi-Newton method that approximates the Hessian from gradient history, with bounded memory usage.
+
+The gradient is computed analytically from the same symbolic Jacobian: `grad = J^T @ r`. This is passed directly to `scipy.optimize.minimize` via the `jac=True` interface to avoid redundant function evaluations.
+
+L-BFGS-B is more robust for ill-conditioned systems where the Jacobian is nearly singular, but converges more slowly (superlinear rather than quadratic). It runs for up to 200 iterations.
+
+If scipy is not available, the fallback is skipped gracefully.
+
+## Graph decomposition
+
+**Source:** `mods/solver/kindred_solver/decompose.py`
+
+For assemblies with 8 or more free bodies, the solver decomposes the constraint graph into clusters and solves them independently. This improves performance for large assemblies by reducing the Jacobian size from O(n^2) to the sum of smaller cluster Jacobians.
+
+### Algorithm
+
+1. **Build constraint graph.** Bodies are nodes, constraints are edges weighted by their residual count (DOF removed). Grounded bodies are tagged.
+
+2. **Find biconnected components.** Using `networkx.biconnected_components()`, decompose the graph into rigid clusters. Articulation points (bodies shared between clusters) are identified.
+
+3. **Build block-cut tree.** A bipartite graph of clusters and articulation points, rooted at a grounded cluster.
+
+4. **BFS ordering.** Traverse the block-cut tree root-to-leaf, producing a solve order where grounded clusters come first and boundary conditions propagate outward.
+
+5. **Solve each cluster.** For each cluster in order:
+   - Fix boundary bodies that were already solved by previous clusters (their parameters become constants)
+   - Collect the cluster's residuals and quaternion normalization equations
+   - Run substitution pass (compiles fixed boundary values to constants)
+   - Newton-Raphson + BFGS fallback on the reduced system
+   - Mark the cluster's bodies as solved
+   - Unfix boundary parameters for downstream clusters
+
+### Example
+
+Consider a chain of 4 bodies: `Ground -- A -- B -- C` with joints at each connection. This decomposes into two biconnected components (if the joints create articulation points):
+
+- Cluster 1: {Ground, A} -- solved first (grounded)
+- Cluster 2: {A, B, C} -- solved second with A's parameters fixed to Cluster 1's result
+
+The 21-variable monolithic system (3 free bodies x 7 params) becomes two smaller systems solved in sequence.
+
+### Disconnected sub-assemblies
+
+The decomposition also handles disconnected components. Each connected component of the constraint graph is decomposed independently. Components without a grounded body will fail to solve (returning `NoGroundedParts`).
+
+### Pebble game integration
+
+The `classify_cluster_rigidity()` function uses the pebble game algorithm from `GNN/solver/datagen/` to classify clusters as well-constrained, underconstrained, overconstrained, or mixed. This provides fast O(n) rigidity analysis without running the full solver.
+
+## Half-space tracking
+
+**Source:** `mods/solver/kindred_solver/preference.py`
+
+Many constraints have multiple valid solutions (branches). A distance constraint between two points can be satisfied with the points on either side of each other. Parallel axes can point in the same or opposite directions.
+
+Half-space tracking preserves the initial configuration branch:
+
+1. **At setup:** Evaluate an indicator function for each branching constraint. Record its sign as the reference branch.
+
+2. **After each Newton step:** Re-evaluate the indicator. If the sign flipped, apply a correction to push the solution back to the reference branch.
+
+Tracked constraint types:
+
+| Constraint | Indicator | Correction |
+|-----------|-----------|------------|
+| DistancePointPoint (d > 0) | Dot product of displacement with reference direction | Reflect the moving body's position |
+| Parallel | `z_i . z_j` (same vs. opposite direction) | None (tracked for monitoring) |
+| Angle | Dominant cross product component | None (tracked for monitoring) |
+| Perpendicular | Dominant cross product component | None (tracked for monitoring) |

docs/src/solver/writing-a-solver.md

@@ -0,0 +1,256 @@
+# Writing a Custom Solver
+
+The KCSolve framework lets you implement a solver backend in pure Python, register it at runtime, and select it through the Assembly preferences. This tutorial walks through building a minimal solver and then extending it.
+
+## Minimal solver
+
+A solver must subclass `kcsolve.IKCSolver` and implement three methods:
+
+```python
+import kcsolve
+
+class MySolver(kcsolve.IKCSolver):
+    def __init__(self):
+        super().__init__()  # required for pybind11 trampoline
+
+    def name(self):
+        return "My Custom Solver"
+
+    def supported_joints(self):
+        return [
+            kcsolve.BaseJointKind.Fixed,
+            kcsolve.BaseJointKind.Revolute,
+        ]
+
+    def solve(self, ctx):
+        result = kcsolve.SolveResult()
+
+        # Find grounded parts
+        grounded = {p.id for p in ctx.parts if p.grounded}
+        if not grounded:
+            result.status = kcsolve.SolveStatus.NoGroundedParts
+            return result
+
+        # Your solving logic here...
+        # For each non-grounded part, compute its solved placement
+        for part in ctx.parts:
+            if part.grounded:
+                continue
+            pr = kcsolve.SolveResult.PartResult()
+            pr.id = part.id
+            pr.placement = part.placement  # use current placement as placeholder
+            result.placements = result.placements + [pr]
+
+        result.status = kcsolve.SolveStatus.Success
+        result.dof = 0
+        return result
+```
+
+Register it:
+
+```python
+kcsolve.register_solver("my_solver", MySolver)
+```
+
+Test it from the FreeCAD console:
+
+```python
+solver = kcsolve.load("my_solver")
+print(solver.name())  # "My Custom Solver"
+
+ctx = kcsolve.SolveContext()
+# ... build context ...
+result = solver.solve(ctx)
+print(result.status)  # SolveStatus.Success
+```
+
+## Addon packaging
+
+To make your solver load automatically, create a FreeCAD addon:
+
+```
+my_solver_addon/
+  package.xml          # Addon manifest
+  Init.py              # Registration entry point
+  my_solver/
+    __init__.py
+    solver.py          # MySolver class
+```
+
+**package.xml:**
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<package format="1">
+  <name>MyCustomSolver</name>
+  <description>Custom assembly constraint solver</description>
+  <version>0.1.0</version>
+  <content>
+    <preferencepack>
+      <name>MySolver</name>
+    </preferencepack>
+  </content>
+</package>
+```
+
+**Init.py:**
+```python
+import kcsolve
+from my_solver.solver import MySolver
+kcsolve.register_solver("my_solver", MySolver)
+```
+
+Place the addon in the FreeCAD Mod directory or as a git submodule in `mods/`.
+
+## Working with SolveContext
+
+The `SolveContext` contains everything the solver needs:
+
+### Parts
+
+```python
+for part in ctx.parts:
+    print(f"{part.id}: grounded={part.grounded}")
+    print(f"  position: {list(part.placement.position)}")
+    print(f"  quaternion: {list(part.placement.quaternion)}")
+    print(f"  mass: {part.mass}")
+```
+
+Each part has 7 degrees of freedom: 3 translation (x, y, z) and 4 quaternion components (w, x, y, z) with a unit-norm constraint reducing the rotational DOF to 3.
+
+**Quaternion convention:** `(w, x, y, z)` where `w` is the scalar part. This differs from FreeCAD's `Base.Rotation(x, y, z, w)`. The adapter layer handles the swap.
+
+### Constraints
+
+```python
+for c in ctx.constraints:
+    if not c.activated:
+        continue
+    print(f"{c.id}: {c.type} between {c.part_i} and {c.part_j}")
+    print(f"  marker_i: pos={list(c.marker_i.position)}, "
+          f"quat={list(c.marker_i.quaternion)}")
+    print(f"  params: {list(c.params)}")
+    print(f"  limits: {len(c.limits)}")
+```
+
+The marker transforms define local coordinate frames on each part. The constraint type determines what geometric relationship is enforced between these frames.
+
+### Returning results
+
+```python
+result = kcsolve.SolveResult()
+result.status = kcsolve.SolveStatus.Success
+result.dof = computed_dof
+
+placements = []
+for part_id, pos, quat in solved_parts:
+    pr = kcsolve.SolveResult.PartResult()
+    pr.id = part_id
+    pr.placement = kcsolve.Transform()
+    pr.placement.position = list(pos)
+    pr.placement.quaternion = list(quat)
+    placements.append(pr)
+result.placements = placements
+
+return result
+```
+
+**Important:** pybind11 list fields return copies. Use `result.placements = [...]` (whole-list assignment), not `result.placements.append(...)`.
+
+## Adding optional capabilities
+
+### Diagnostics
+
+Override `diagnose()` to detect overconstrained or malformed assemblies:
+
+```python
+def diagnose(self, ctx):
+    diagnostics = []
+    # ... analyze constraints ...
+    d = kcsolve.ConstraintDiagnostic()
+    d.constraint_id = "Joint001"
+    d.kind = kcsolve.DiagnosticKind.Redundant
+    d.detail = "This joint duplicates Joint002"
+    diagnostics.append(d)
+    return diagnostics
+```
+
+### Interactive drag
+
+Override the three drag methods for real-time viewport dragging:
+
+```python
+def pre_drag(self, ctx, drag_parts):
+    self._ctx = ctx
+    self._dragging = set(drag_parts)
+    return self.solve(ctx)
+
+def drag_step(self, drag_placements):
+    # Update dragged parts in stored context
+    for pr in drag_placements:
+        for part in self._ctx.parts:
+            if part.id == pr.id:
+                part.placement = pr.placement
+                break
+    return self.solve(self._ctx)
+
+def post_drag(self):
+    self._ctx = None
+    self._dragging = None
+```
+
+For responsive dragging, the solver should converge quickly from a nearby initial guess. Use warm-starting (current placements as initial guess) and consider caching internal state across drag steps.
+
+### Incremental update
+
+Override `update()` for the case where only constraint parameters changed (not topology):
+
+```python
+def update(self, ctx):
+    # Reuse cached factorization, only re-evaluate changed residuals
+    return self.solve(ctx)  # default: just re-solve
+```
+
+## Testing
+
+### Unit tests (without FreeCAD)
+
+Test your solver logic with hand-built `SolveContext` objects:
+
+```python
+import kcsolve
+
+def test_fixed_joint():
+    ctx = kcsolve.SolveContext()
+
+    base = kcsolve.Part()
+    base.id = "base"
+    base.grounded = True
+
+    arm = kcsolve.Part()
+    arm.id = "arm"
+    arm.placement.position = [100.0, 0.0, 0.0]
+
+    joint = kcsolve.Constraint()
+    joint.id = "Joint001"
+    joint.part_i = "base"
+    joint.part_j = "arm"
+    joint.type = kcsolve.BaseJointKind.Fixed
+
+    ctx.parts = [base, arm]
+    ctx.constraints = [joint]
+
+    solver = MySolver()
+    result = solver.solve(ctx)
+    assert result.status == kcsolve.SolveStatus.Success
+```
+
+### Integration tests (with FreeCAD)
+
+For integration testing within FreeCAD, follow the pattern in `TestKindredSolverIntegration.py`: set the solver preference in `setUp()`, create document objects, and verify solve results.
+
+## Reference
+
+- [KCSolve Python API](../reference/kcsolve-python.md) -- complete type and function reference
+- [KCSolve Architecture](../architecture/ondsel-solver.md) -- C++ framework details
+- [Constraints](constraints.md) -- constraint types and residual counts
+- [Kindred Solver Overview](overview.md) -- how the built-in Kindred solver works

package/debian/build-deb.sh

@@ -30,7 +30,7 @@ fi
 
 # Get version from git if not provided
 if [ -z "$VERSION" ]; then
-    VERSION=$(cd "$PROJECT_ROOT" && git describe --tags --always 2>/dev/null || echo "0.1.0")
+    VERSION=$(cd "$PROJECT_ROOT" && git describe --tags --always 2>/dev/null || echo "0.1.5")
 fi
 
 # Convert version to Debian-compatible format

package/rattler-build/recipe.yaml

@@ -155,6 +155,7 @@ requirements:
     - lark
     - lxml
     - matplotlib-base
+    - networkx
     - nine
     - noqt5
     - numpy>=1.26,<2

src/Gui/Application.cpp

@@ -1046,6 +1046,9 @@ void Application::slotNewDocument(const App::Document& Doc, bool isMainDoc)
     );
     pDoc->signalInEdit.connect(std::bind(&Gui::Application::slotInEdit, this, sp::_1));
     pDoc->signalResetEdit.connect(std::bind(&Gui::Application::slotResetEdit, this, sp::_1));
+    pDoc->signalActivatedViewProvider.connect(
+        std::bind(&Gui::Application::slotActivatedViewProvider, this, sp::_1, sp::_2)
+    );
     // NOLINTEND
 
     signalNewDocument(*pDoc, isMainDoc);
@@ -1352,6 +1355,12 @@ void Application::slotResetEdit(const Gui::ViewProviderDocumentObject& vp)
     this->signalResetEdit(vp);
 }
 
+void Application::slotActivatedViewProvider(
+    const Gui::ViewProviderDocumentObject* vp, const char* name)
+{
+    this->signalActivatedViewProvider(vp, name);
+}
+
 void Application::onLastWindowClosed(Gui::Document* pcDoc)
 {
     try {

src/Gui/Application.h

@@ -153,6 +153,9 @@ public:
     fastsignals::signal<void(const Gui::ViewProviderDocumentObject&)> signalInEdit;
     /// signal on leaving edit mode
     fastsignals::signal<void(const Gui::ViewProviderDocumentObject&)> signalResetEdit;
+    /// signal on activated view-provider (active-object change, e.g. "pdbody", "part")
+    fastsignals::signal<void(const Gui::ViewProviderDocumentObject*, const char*)>
+        signalActivatedViewProvider;
     /// signal on changing user edit mode
     fastsignals::signal<void(int)> signalUserEditModeChanged;
     //@}
@@ -174,6 +177,7 @@ protected:
     void slotActivatedObject(const ViewProvider&);
     void slotInEdit(const Gui::ViewProviderDocumentObject&);
     void slotResetEdit(const Gui::ViewProviderDocumentObject&);
+    void slotActivatedViewProvider(const Gui::ViewProviderDocumentObject*, const char*);
 
 public:
     /// message when a GuiDocument is about to vanish

src/Gui/EditingContext.cpp

@@ -121,6 +121,9 @@ EditingContextResolver::EditingContextResolver()
     app.signalActiveDocument.connect([this](const Document& doc) { onActiveDocument(doc); });
     app.signalActivateView.connect([this](const MDIView* view) { onActivateView(view); });
     app.signalActivateWorkbench.connect([this](const char*) { refresh(); });
+    app.signalActivatedViewProvider.connect(
+        [this](const ViewProviderDocumentObject*, const char*) { refresh(); }
+    );
 }
 
 EditingContextResolver::~EditingContextResolver()
@@ -172,6 +175,23 @@ static App::DocumentObject* getActivePartObject()
     return view->getActiveObject<App::DocumentObject*>("part");
 }
 
+// ---------------------------------------------------------------------------
+// Helper: get the active "pdbody" object from the active view
+// ---------------------------------------------------------------------------
+
+static App::DocumentObject* getActivePdBodyObject()
+{
+    auto* guiDoc = Application::Instance->activeDocument();
+    if (!guiDoc) {
+        return nullptr;
+    }
+    auto* view = guiDoc->getActiveView();
+    if (!view) {
+        return nullptr;
+    }
+    return view->getActiveObject<App::DocumentObject*>("pdbody");
+}
+
 // ---------------------------------------------------------------------------
 // Helper: get the label of the active "part" object
 // ---------------------------------------------------------------------------
@@ -213,6 +233,34 @@ static QString getInEditLabel()
 
 void EditingContextResolver::registerBuiltinContexts()
 {
+    // --- PartDesign body active inside an assembly (supersedes assembly.edit) ---
+    registerContext({
+        /*.id =*/QStringLiteral("partdesign.in_assembly"),
+        /*.labelTemplate =*/QStringLiteral("Body: {name}"),
+        /*.color =*/QLatin1String(CatppuccinMocha::Mauve),
+        /*.toolbars =*/
+        {QStringLiteral("Part Design Helper Features"),
+         QStringLiteral("Part Design Modeling Features"),
+         QStringLiteral("Part Design Dress-Up Features"),
+         QStringLiteral("Part Design Transformation Features"),
+         QStringLiteral("Sketcher")},
+        /*.priority =*/95,
+        /*.match =*/
+        []() {
+            auto* body = getActivePdBodyObject();
+            if (!body || !objectIsDerivedFrom(body, "PartDesign::Body")) {
+                return false;
+            }
+            // Only match when we're inside an assembly edit session
+            auto* doc = Application::Instance->activeDocument();
+            if (!doc) {
+                return false;
+            }
+            auto* vp = doc->getInEdit();
+            return vp && vpObjectIsDerivedFrom(vp, "Assembly::AssemblyObject");
+        },
+    });
+
     // --- Sketcher edit (highest priority — VP in edit) ---
     registerContext({
         /*.id =*/QStringLiteral("sketcher.edit"),
@@ -272,7 +320,10 @@ void EditingContextResolver::registerBuiltinContexts()
         /*.priority =*/40,
         /*.match =*/
         []() {
-            auto* obj = getActivePartObject();
+            auto* obj = getActivePdBodyObject();
+            if (!obj) {
+                obj = getActivePartObject();
+            }
             if (!obj || !objectIsDerivedFrom(obj, "PartDesign::Body")) {
                 return false;
             }
@@ -301,7 +352,10 @@ void EditingContextResolver::registerBuiltinContexts()
         /*.priority =*/30,
         /*.match =*/
         []() {
-            auto* obj = getActivePartObject();
+            auto* obj = getActivePdBodyObject();
+            if (!obj) {
+                obj = getActivePartObject();
+            }
             return obj && objectIsDerivedFrom(obj, "PartDesign::Body");
         },
     });
@@ -488,6 +542,13 @@ EditingContext EditingContextResolver::resolve() const
             if (label.contains(QStringLiteral("{name}"))) {
                 // For edit-mode contexts, use the in-edit object name
                 QString name = getInEditLabel();
+                if (name.isEmpty()) {
+                    // Try pdbody first for PartDesign contexts
+                    auto* bodyObj = getActivePdBodyObject();
+                    if (bodyObj) {
+                        name = QString::fromUtf8(bodyObj->Label.getValue());
+                    }
+                }
                 if (name.isEmpty()) {
                     name = getActivePartLabel();
                 }
@@ -548,6 +609,25 @@ QStringList EditingContextResolver::buildBreadcrumb(const EditingContext& ctx) c
         return crumbs;
     }
 
+    // Assembly > Body breadcrumb for in-assembly part editing
+    if (ctx.id == QStringLiteral("partdesign.in_assembly")) {
+        auto* guiDoc = Application::Instance->activeDocument();
+        if (guiDoc) {
+            auto* vp = guiDoc->getInEdit();
+            if (vp) {
+                auto* vpd = dynamic_cast<ViewProviderDocumentObject*>(vp);
+                if (vpd && vpd->getObject()) {
+                    crumbs << QString::fromUtf8(vpd->getObject()->Label.getValue());
+                }
+            }
+        }
+        auto* body = getActivePdBodyObject();
+        if (body) {
+            crumbs << QString::fromUtf8(body->Label.getValue());
+        }
+        return crumbs;
+    }
+
     // Always start with the active part/body/assembly label
     QString partLabel = getActivePartLabel();
     if (!partLabel.isEmpty()) {
@@ -582,6 +662,14 @@ QStringList EditingContextResolver::buildBreadcrumbColors(const EditingContext&
 {
     QStringList colors;
 
+    if (ctx.id == QStringLiteral("partdesign.in_assembly")) {
+        for (int i = 0; i < ctx.breadcrumb.size(); ++i) {
+            colors << (i == 0 ? QLatin1String(CatppuccinMocha::Blue)
+                              : QLatin1String(CatppuccinMocha::Mauve));
+        }
+        return colors;
+    }
+
     if (ctx.breadcrumb.size() <= 1) {
         colors << ctx.color;
         return colors;

src/Mod/Assembly/App/AssemblyObject.cpp

@@ -30,6 +30,7 @@
 
 #include <App/Application.h>
 #include <App/Datums.h>
+#include <App/Origin.h>
 #include <App/Document.h>
 #include <App/DocumentObjectGroup.h>
 #include <App/FeaturePythonPyImp.h>
@@ -106,6 +107,24 @@ AssemblyObject::AssemblyObject()
 
 AssemblyObject::~AssemblyObject() = default;
 
+void AssemblyObject::setupObject()
+{
+    App::Part::setupObject();
+
+    // Relabel origin planes with assembly-friendly names (SolidWorks convention)
+    if (auto* origin = getOrigin()) {
+        if (auto* xy = origin->getXY()) {
+            xy->Label.setValue("Top");
+        }
+        if (auto* xz = origin->getXZ()) {
+            xz->Label.setValue("Front");
+        }
+        if (auto* yz = origin->getYZ()) {
+            yz->Label.setValue("Right");
+        }
+    }
+}
+
 PyObject* AssemblyObject::getPyObject()
 {
     if (PythonObject.is(Py::_None())) {
@@ -157,6 +176,10 @@ KCSolve::IKCSolver* AssemblyObject::getOrCreateSolver()
         std::string solverName = hGrp->GetASCII("Solver", "");
         solver_ = KCSolve::SolverRegistry::instance().get(solverName);
         // get("") returns the registry default (first registered solver)
+        if (solver_) {
+            FC_LOG("Assembly : loaded solver '" << solver_->name()
+                   << "' (requested='" << solverName << "')");
+        }
     }
     return solver_.get();
 }
@@ -193,14 +216,22 @@ int AssemblyObject::solve(bool enableRedo, bool updateJCS)
 
     auto groundedObjs = getGroundedParts();
     if (groundedObjs.empty()) {
+        FC_LOG("Assembly : solve skipped — no grounded parts");
         return -6;
     }
 
     std::vector<App::DocumentObject*> joints = getJoints(updateJCS);
     removeUnconnectedJoints(joints, groundedObjs);
 
+    FC_LOG("Assembly : solve on '" << getFullLabel()
+           << "' — " << groundedObjs.size() << " grounded, "
+           << joints.size() << " joints");
+
     KCSolve::SolveContext ctx = buildSolveContext(joints);
 
+    FC_LOG("Assembly : solve context — " << ctx.parts.size() << " parts, "
+           << ctx.constraints.size() << " constraints");
+
     // Always save placements to enable orientation flip detection
     savePlacementsForUndo();
 
@@ -222,6 +253,13 @@ int AssemblyObject::solve(bool enableRedo, bool updateJCS)
     }
 
     if (lastResult_.status == KCSolve::SolveStatus::Failed) {
+        FC_LOG("Assembly : solve failed — status="
+               << static_cast<int>(lastResult_.status)
+               << ", " << lastResult_.diagnostics.size() << " diagnostics");
+        for (const auto& d : lastResult_.diagnostics) {
+            Base::Console().warning("Assembly : diagnostic [%s]: %s\n",
+                                    d.constraint_id.c_str(), d.detail.c_str());
+        }
         updateSolveStatus();
         return -1;
     }
@@ -229,6 +267,7 @@ int AssemblyObject::solve(bool enableRedo, bool updateJCS)
     // Validate that the solve didn't cause any parts to flip orientation
     if (!validateNewPlacements()) {
         // Restore previous placements - the solve found an invalid configuration
+        FC_LOG("Assembly : solve rejected — placement validation failed, undoing");
         undoSolve();
         lastSolverStatus = -2;
         updateSolveStatus();
@@ -246,6 +285,9 @@ int AssemblyObject::solve(bool enableRedo, bool updateJCS)
 
     updateSolveStatus();
 
+    FC_LOG("Assembly : solve succeeded — dof=" << lastResult_.dof
+           << ", " << lastResult_.placements.size() << " placements");
+
     return 0;
 }
 
@@ -256,8 +298,14 @@ void AssemblyObject::updateSolveStatus()
     //+1 because there's a grounded joint to origin
     lastDoF = (1 + numberOfComponents()) * 6;
 
-    if (!solver_ || lastResult_.placements.empty()) {
+    // Guard against re-entrancy: solve() calls updateSolveStatus(), so if
+    // placements are legitimately empty (e.g. zero constraints / all parts
+    // grounded) the recursive solve() would never terminate.
+    static bool updating = false;
+    if (!updating && (!solver_ || lastResult_.placements.empty())) {
+        updating = true;
         solve();
+        updating = false;
     }
 
     if (!solver_) {
@@ -390,6 +438,8 @@ size_t Assembly::AssemblyObject::numberOfFrames()
 void AssemblyObject::preDrag(std::vector<App::DocumentObject*> dragParts)
 {
     bundleFixed = true;
+    dragStepCount_ = 0;
+    dragStepRejected_ = 0;
 
     auto* solver = getOrCreateSolver();
     if (!solver) {
@@ -402,6 +452,7 @@ void AssemblyObject::preDrag(std::vector<App::DocumentObject*> dragParts)
 
     auto groundedObjs = getGroundedParts();
     if (groundedObjs.empty()) {
+        FC_LOG("Assembly : preDrag skipped — no grounded parts");
         bundleFixed = false;
         return;
     }
@@ -455,6 +506,10 @@ void AssemblyObject::preDrag(std::vector<App::DocumentObject*> dragParts)
         }
     }
 
+    FC_LOG("Assembly : preDrag — " << dragPartIds.size() << " drag part(s), "
+           << joints.size() << " joints, " << ctx.parts.size() << " parts, "
+           << ctx.constraints.size() << " constraints");
+
     savePlacementsForUndo();
 
     try {
@@ -463,11 +518,13 @@ void AssemblyObject::preDrag(std::vector<App::DocumentObject*> dragParts)
     }
     catch (...) {
         // If pre_drag fails, we still need to be in a valid state
+        FC_LOG("Assembly : preDrag — solver pre_drag threw exception");
     }
 }
 
 void AssemblyObject::doDragStep()
 {
+    dragStepCount_++;
     try {
         std::vector<KCSolve::SolveResult::PartResult> dragPlacements;
 
@@ -487,9 +544,21 @@ void AssemblyObject::doDragStep()
 
         lastResult_ = solver_->drag_step(dragPlacements);
 
+        if (lastResult_.status == KCSolve::SolveStatus::Failed) {
+            FC_LOG("Assembly : dragStep #" << dragStepCount_ << " — solver failed");
+        }
+
         if (validateNewPlacements()) {
             setNewPlacements();
 
+            // Update the baseline positions after each accepted drag step so that
+            // the orientation-flip check in validateNewPlacements() compares against
+            // the last accepted state rather than the pre-drag origin.  Without this,
+            // cumulative rotation during a long drag easily exceeds the 91-degree
+            // threshold and causes the solver result to be rejected ("flipped
+            // orientation"), making parts appear to explode.
+            savePlacementsForUndo();
+
             auto joints = getJoints(false);
             for (auto* joint : joints) {
                 if (joint->Visibility.getValue()) {
@@ -498,9 +567,12 @@ void AssemblyObject::doDragStep()
                 }
             }
         }
+        else {
+            dragStepRejected_++;
+        }
     }
     catch (...) {
-        // We do nothing if a solve step fails.
+        FC_LOG("Assembly : dragStep #" << dragStepCount_ << " — exception");
     }
 }
 
@@ -612,6 +684,8 @@ bool AssemblyObject::validateNewPlacements()
 
 void AssemblyObject::postDrag()
 {
+    FC_LOG("Assembly : postDrag — " << dragStepCount_ << " steps, "
+           << dragStepRejected_ << " rejected");
     if (solver_) {
         solver_->post_drag();
     }
@@ -1041,10 +1115,19 @@ KCSolve::SolveContext AssemblyObject::buildSolveContext(
                         break;
 
                     default:
+                        FC_WARN("Assembly : Distance joint '" << joint->getFullName()
+                                << "' — unhandled DistanceType "
+                                << distanceTypeName(distType)
+                                << ", falling back to Planar");
                         kind = KCSolve::BaseJointKind::Planar;
                         params.push_back(distance);
                         break;
                 }
+
+                FC_LOG("Assembly : Distance joint '" << joint->getFullName()
+                       << "' — DistanceType=" << distanceTypeName(distType)
+                       << ", kind=" << static_cast<int>(kind)
+                       << ", distance=" << distance);
                 break;
             }
             default:
@@ -1323,6 +1406,23 @@ KCSolve::SolveContext AssemblyObject::buildSolveContext(
         ctx.simulation = sp;
     }
 
+    // Log context summary
+    {
+        int nGrounded = 0, nFree = 0, nLimits = 0;
+        for (const auto& p : ctx.parts) {
+            if (p.grounded) nGrounded++;
+            else nFree++;
+        }
+        for (const auto& c : ctx.constraints) {
+            if (!c.limits.empty()) nLimits++;
+        }
+        FC_LOG("Assembly : buildSolveContext — "
+               << nGrounded << " grounded + " << nFree << " free parts, "
+               << ctx.constraints.size() << " constraints"
+               << (nLimits ? (std::string(", ") + std::to_string(nLimits) + " with limits") : "")
+               << (ctx.bundle_fixed ? ", bundle_fixed=true" : ""));
+    }
+
     return ctx;
 }
 

src/Mod/Assembly/App/AssemblyObject.h

@@ -84,6 +84,7 @@ public:
         return "AssemblyGui::ViewProviderAssembly";
     }
 
+    void setupObject() override;
     App::DocumentObjectExecReturn* execute() override;
     void onChanged(const App::Property* prop) override;
     /* Solve the assembly. It will update first the joints, solve, update placements of the parts
@@ -279,6 +280,10 @@ private:
 
     bool bundleFixed;
 
+    // Drag diagnostic counters (reset in preDrag, reported in postDrag)
+    int dragStepCount_ = 0;
+    int dragStepRejected_ = 0;
+
     int lastDoF;
     bool lastHasConflict;
     bool lastHasRedundancies;

src/Mod/Assembly/App/AssemblyUtils.cpp

@@ -54,10 +54,56 @@
 
 namespace PartApp = Part;
 
+FC_LOG_LEVEL_INIT("Assembly", true, true, true)
+
 // ======================================= Utils ======================================
 namespace Assembly
 {
 
+const char* distanceTypeName(DistanceType dt)
+{
+    switch (dt) {
+        case DistanceType::PointPoint:       return "PointPoint";
+        case DistanceType::LineLine:         return "LineLine";
+        case DistanceType::LineCircle:       return "LineCircle";
+        case DistanceType::CircleCircle:     return "CircleCircle";
+        case DistanceType::PlanePlane:       return "PlanePlane";
+        case DistanceType::PlaneCylinder:    return "PlaneCylinder";
+        case DistanceType::PlaneSphere:      return "PlaneSphere";
+        case DistanceType::PlaneCone:        return "PlaneCone";
+        case DistanceType::PlaneTorus:       return "PlaneTorus";
+        case DistanceType::CylinderCylinder: return "CylinderCylinder";
+        case DistanceType::CylinderSphere:   return "CylinderSphere";
+        case DistanceType::CylinderCone:     return "CylinderCone";
+        case DistanceType::CylinderTorus:    return "CylinderTorus";
+        case DistanceType::ConeCone:         return "ConeCone";
+        case DistanceType::ConeTorus:        return "ConeTorus";
+        case DistanceType::ConeSphere:       return "ConeSphere";
+        case DistanceType::TorusTorus:       return "TorusTorus";
+        case DistanceType::TorusSphere:      return "TorusSphere";
+        case DistanceType::SphereSphere:     return "SphereSphere";
+        case DistanceType::PointPlane:       return "PointPlane";
+        case DistanceType::PointCylinder:    return "PointCylinder";
+        case DistanceType::PointSphere:      return "PointSphere";
+        case DistanceType::PointCone:        return "PointCone";
+        case DistanceType::PointTorus:       return "PointTorus";
+        case DistanceType::LinePlane:        return "LinePlane";
+        case DistanceType::LineCylinder:     return "LineCylinder";
+        case DistanceType::LineSphere:       return "LineSphere";
+        case DistanceType::LineCone:         return "LineCone";
+        case DistanceType::LineTorus:        return "LineTorus";
+        case DistanceType::CurvePlane:       return "CurvePlane";
+        case DistanceType::CurveCylinder:    return "CurveCylinder";
+        case DistanceType::CurveSphere:      return "CurveSphere";
+        case DistanceType::CurveCone:        return "CurveCone";
+        case DistanceType::CurveTorus:       return "CurveTorus";
+        case DistanceType::PointLine:        return "PointLine";
+        case DistanceType::PointCurve:       return "PointCurve";
+        case DistanceType::Other:            return "Other";
+    }
+    return "Unknown";
+}
+
 void swapJCS(const App::DocumentObject* joint)
 {
     if (!joint) {
@@ -164,6 +210,56 @@ DistanceType getDistanceType(App::DocumentObject* joint)
     auto* obj1 = getLinkedObjFromRef(joint, "Reference1");
     auto* obj2 = getLinkedObjFromRef(joint, "Reference2");
 
+    // Datum planes (App::Plane) have empty element types because their
+    // sub-name ends with "." and yields no Face/Edge/Vertex element.
+    // Detect them here and classify before the main geometry chain,
+    // which cannot handle the empty element type.
+    const bool datum1 = type1.empty() && obj1 && obj1->isDerivedFrom<App::Plane>();
+    const bool datum2 = type2.empty() && obj2 && obj2->isDerivedFrom<App::Plane>();
+
+    if (datum1 || datum2) {
+        if (datum1 && datum2) {
+            FC_LOG("Assembly : getDistanceType('" << joint->getFullName()
+                   << "') — datum+datum → PlanePlane");
+            return DistanceType::PlanePlane;
+        }
+
+        // One side is a datum plane, the other has a real element type.
+        // For PointPlane/LinePlane, the solver's PointInPlaneConstraint
+        // reads the plane normal from marker_j (Reference2).  Unlike
+        // real Face+Vertex joints (where both Placements carry the
+        // face normal from findPlacement), datum planes only carry
+        // their normal through computeMarkerTransform.  So the datum
+        // must end up on Reference2 for the normal to reach marker_j.
+        //
+        // For PlanePlane the convention matches the existing Face+Face
+        // path (plane on Reference1).
+        const auto& otherType = datum1 ? type2 : type1;
+
+        if (otherType == "Vertex" || otherType == "Edge") {
+            // Datum must be on Reference2 (j side).
+            if (datum1) {
+                swapJCS(joint);  // move datum from Ref1 → Ref2
+            }
+            DistanceType result = (otherType == "Vertex")
+                ? DistanceType::PointPlane : DistanceType::LinePlane;
+            FC_LOG("Assembly : getDistanceType('" << joint->getFullName()
+                   << "') — datum+" << otherType << " → "
+                   << distanceTypeName(result)
+                   << (datum1 ? " (swapped)" : ""));
+            return result;
+        }
+
+        // Face + datum or unknown + datum → PlanePlane.
+        // No swap needed: PlanarConstraint is symmetric (uses both
+        // z_i and z_j), and preserving the original Reference order
+        // keeps the initial Placement values consistent so the solver
+        // stays in the correct orientation branch.
+        FC_LOG("Assembly : getDistanceType('" << joint->getFullName()
+               << "') — datum+" << otherType << " → PlanePlane");
+        return DistanceType::PlanePlane;
+    }
+
     if (type1 == "Vertex" && type2 == "Vertex") {
         return DistanceType::PointPoint;
     }
@@ -591,6 +687,19 @@ App::DocumentObject* getObjFromRef(App::DocumentObject* comp, const std::string&
         if (obj->isDerivedFrom<App::Part>() || obj->isLinkGroup()) {
             continue;
         }
+        else if (obj->isDerivedFrom<App::LocalCoordinateSystem>()) {
+            // Resolve LCS → child datum element (e.g. Origin → XY_Plane)
+            auto nextIt = std::next(it);
+            if (nextIt != names.end()) {
+                for (auto* child : obj->getOutList()) {
+                    if (child->getNameInDocument() == *nextIt
+                        && child->isDerivedFrom<App::DatumElement>()) {
+                        return child;
+                    }
+                }
+            }
+            return obj;
+        }
         else if (obj->isDerivedFrom<PartDesign::Body>()) {
             return handlePartDesignBody(obj, it);
         }

src/Mod/Assembly/App/AssemblyUtils.h

@@ -148,6 +148,7 @@ AssemblyExport double getFaceRadius(const App::DocumentObject* obj, const std::s
 AssemblyExport double getEdgeRadius(const App::DocumentObject* obj, const std::string& elName);
 
 AssemblyExport DistanceType getDistanceType(App::DocumentObject* joint);
+AssemblyExport const char* distanceTypeName(DistanceType dt);
 AssemblyExport JointGroup* getJointGroup(const App::Part* part);
 
 AssemblyExport std::vector<App::DocumentObject*> getAssemblyComponents(const AssemblyObject* assembly);

src/Mod/Assembly/AssemblyTests/TestAssemblyOriginPlanes.py

@@ -0,0 +1,314 @@
+# SPDX-License-Identifier: LGPL-2.1-or-later
+# /****************************************************************************
+#                                                                           *
+#    Copyright (c) 2025 Kindred Systems <development@kindred-systems.com>   *
+#                                                                           *
+#    This file is part of FreeCAD.                                          *
+#                                                                           *
+#    FreeCAD is free software: you can redistribute it and/or modify it     *
+#    under the terms of the GNU Lesser General Public License as            *
+#    published by the Free Software Foundation, either version 2.1 of the   *
+#    License, or (at your option) any later version.                        *
+#                                                                           *
+#    FreeCAD is distributed in the hope that it will be useful, but         *
+#    WITHOUT ANY WARRANTY; without even the implied warranty of             *
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU       *
+#    Lesser General Public License for more details.                        *
+#                                                                           *
+#    You should have received a copy of the GNU Lesser General Public       *
+#    License along with FreeCAD. If not, see                                *
+#    <https://www.gnu.org/licenses/>.                                       *
+#                                                                           *
+# ***************************************************************************/
+
+"""
+Tests for assembly origin reference planes.
+
+Verifies that new assemblies have properly labeled, grounded origin planes
+and that joints can reference them for solving.
+"""
+
+import os
+import tempfile
+import unittest
+
+import FreeCAD as App
+import JointObject
+import UtilsAssembly
+
+
+class TestAssemblyOriginPlanes(unittest.TestCase):
+    """Tests for assembly origin planes (Top/Front/Right)."""
+
+    def setUp(self):
+        doc_name = self.__class__.__name__
+        if App.ActiveDocument:
+            if App.ActiveDocument.Name != doc_name:
+                App.newDocument(doc_name)
+        else:
+            App.newDocument(doc_name)
+        App.setActiveDocument(doc_name)
+        self.doc = App.ActiveDocument
+
+        self.assembly = self.doc.addObject("Assembly::AssemblyObject", "Assembly")
+        self.jointgroup = self.assembly.newObject("Assembly::JointGroup", "Joints")
+
+    def tearDown(self):
+        App.closeDocument(self.doc.Name)
+
+    # ── Helpers ─────────────────────────────────────────────────────
+
+    def _get_origin(self):
+        return self.assembly.Origin
+
+    def _make_box(self, x=0, y=0, z=0, size=10):
+        box = self.assembly.newObject("Part::Box", "Box")
+        box.Length = size
+        box.Width = size
+        box.Height = size
+        box.Placement = App.Placement(App.Vector(x, y, z), App.Rotation())
+        return box
+
+    def _make_joint(self, joint_type, ref1, ref2):
+        joint = self.jointgroup.newObject("App::FeaturePython", "Joint")
+        JointObject.Joint(joint, joint_type)
+        refs = [
+            [ref1[0], ref1[1]],
+            [ref2[0], ref2[1]],
+        ]
+        joint.Proxy.setJointConnectors(joint, refs)
+        return joint
+
+    # ── Structure tests ─────────────────────────────────────────────
+
+    def test_assembly_has_origin(self):
+        """New assembly has an Origin with 3 planes, 3 axes, 1 point."""
+        origin = self._get_origin()
+        self.assertIsNotNone(origin)
+        self.assertTrue(origin.isDerivedFrom("App::LocalCoordinateSystem"))
+
+        planes = origin.planes()
+        self.assertEqual(len(planes), 3)
+
+        axes = origin.axes()
+        self.assertEqual(len(axes), 3)
+
+    def test_origin_planes_labeled(self):
+        """Origin planes are labeled Top, Front, Right."""
+        origin = self._get_origin()
+
+        xy = origin.getXY()
+        xz = origin.getXZ()
+        yz = origin.getYZ()
+
+        self.assertEqual(xy.Label, "Top")
+        self.assertEqual(xz.Label, "Front")
+        self.assertEqual(yz.Label, "Right")
+
+    def test_origin_planes_have_correct_roles(self):
+        """Origin planes retain correct internal Role names."""
+        origin = self._get_origin()
+
+        self.assertEqual(origin.getXY().Role, "XY_Plane")
+        self.assertEqual(origin.getXZ().Role, "XZ_Plane")
+        self.assertEqual(origin.getYZ().Role, "YZ_Plane")
+
+    # ── Grounding tests ─────────────────────────────────────────────
+
+    def test_origin_in_grounded_set(self):
+        """Origin is part of the assembly's grounded set."""
+        grounded = self.assembly.getGroundedParts()
+        origin = self._get_origin()
+
+        grounded_names = {obj.Name for obj in grounded}
+        self.assertIn(origin.Name, grounded_names)
+
+    # ── Reference resolution tests ──────────────────────────────────
+
+    def test_getObject_resolves_origin_plane(self):
+        """UtilsAssembly.getObject correctly resolves an origin plane ref."""
+        origin = self._get_origin()
+        xy = origin.getXY()
+
+        # Ref structure: [Origin, ["XY_Plane.", "XY_Plane."]]
+        ref = [origin, [xy.Name + ".", xy.Name + "."]]
+        obj = UtilsAssembly.getObject(ref)
+        self.assertEqual(obj, xy)
+
+    def test_findPlacement_origin_plane_returns_identity(self):
+        """findPlacement for an origin plane (whole-object) returns identity."""
+        origin = self._get_origin()
+        xy = origin.getXY()
+
+        ref = [origin, [xy.Name + ".", xy.Name + "."]]
+        plc = UtilsAssembly.findPlacement(ref)
+
+        # For datum planes with no element, identity is returned.
+        # The actual orientation comes from the solver's getGlobalPlacement.
+        self.assertTrue(
+            plc.isSame(App.Placement(), 1e-6),
+            "findPlacement for origin plane should return identity",
+        )
+
+    # ── Joint / solve tests ─────────────────────────────────────────
+
+    def test_fixed_joint_to_origin_plane(self):
+        """Fixed joint referencing an origin plane solves correctly."""
+        origin = self._get_origin()
+        xy = origin.getXY()
+
+        box = self._make_box(50, 50, 50)
+
+        # Fixed joint (type 0): origin XY plane ↔ box Face1 (bottom, Z=0)
+        self._make_joint(
+            0,
+            [origin, [xy.Name + ".", xy.Name + "."]],
+            [box, ["Face1", "Vertex1"]],
+        )
+
+        # After solve, the box should have moved so that its Face1 (bottom)
+        # aligns with the XY plane (Z=0). The box bottom vertex1 is at (0,0,0).
+        self.assertAlmostEqual(
+            box.Placement.Base.z,
+            0.0,
+            places=3,
+            msg="Box should be on XY plane after fixed joint to Top plane",
+        )
+
+    def test_solve_return_code_with_origin_plane(self):
+        """Solve with an origin plane joint returns success (0)."""
+        origin = self._get_origin()
+        xz = origin.getXZ()
+
+        box = self._make_box(0, 100, 0)
+
+        self._make_joint(
+            0,
+            [origin, [xz.Name + ".", xz.Name + "."]],
+            [box, ["Face1", "Vertex1"]],
+        )
+
+        result = self.assembly.solve()
+        self.assertEqual(result, 0, "Solve should succeed with origin plane joint")
+
+    # ── Distance joint to datum plane tests ────────────────────────
+
+    def test_distance_vertex_to_datum_plane_solves(self):
+        """Distance(0) joint: vertex → datum plane solves and pins position."""
+        origin = self._get_origin()
+        xy = origin.getXY()  # Top (Z normal)
+        xz = origin.getXZ()  # Front (Y normal)
+        yz = origin.getYZ()  # Right (X normal)
+
+        box = self._make_box(50, 50, 50)
+
+        # 3 Distance joints, each vertex→datum, distance=0.
+        # This should pin the box's Vertex1 (corner at local 0,0,0) to the
+        # origin, giving 3 PointInPlane constraints (1 residual each = 3 total).
+        for plane in [xy, xz, yz]:
+            joint = self._make_joint(
+                5,  # Distance
+                [box, ["Vertex1", "Vertex1"]],
+                [origin, [plane.Name + ".", plane.Name + "."]],
+            )
+            joint.Distance = 0.0
+
+        result = self.assembly.solve()
+        self.assertEqual(
+            result, 0, "Solve should succeed for vertex→datum Distance joints"
+        )
+
+        # The box's Vertex1 (at local 0,0,0) should be at the origin.
+        v = box.Placement.Base
+        self.assertAlmostEqual(v.x, 0.0, places=2, msg="X should be pinned to 0")
+        self.assertAlmostEqual(v.y, 0.0, places=2, msg="Y should be pinned to 0")
+        self.assertAlmostEqual(v.z, 0.0, places=2, msg="Z should be pinned to 0")
+
+    def test_distance_vertex_to_datum_plane_preserves_orientation(self):
+        """Distance(0) vertex→datum should not constrain orientation."""
+        origin = self._get_origin()
+        xy = origin.getXY()
+        xz = origin.getXZ()
+        yz = origin.getYZ()
+
+        # Start box with a known rotation (45° about Z).
+        rot = App.Rotation(App.Vector(0, 0, 1), 45)
+        box = self._make_box(50, 50, 50)
+        box.Placement = App.Placement(App.Vector(50, 50, 50), rot)
+
+        for plane in [xy, xz, yz]:
+            joint = self._make_joint(
+                5,
+                [box, ["Vertex1", "Vertex1"]],
+                [origin, [plane.Name + ".", plane.Name + "."]],
+            )
+            joint.Distance = 0.0
+
+        self.assembly.solve()
+
+        # 3 PointInPlane constraints pin position (3 DOF) but leave
+        # orientation free (3 DOF).  The solver should keep the original
+        # orientation since it's the lowest-energy solution from the
+        # initial placement.
+        dof = self.assembly.getLastDoF()
+        self.assertEqual(
+            dof, 3, "3 PointInPlane constraints should leave 3 DOF (orientation)"
+        )
+
+    def test_distance_face_to_datum_plane_solves(self):
+        """Distance(0) joint: face → datum plane solves (PlanePlane/Planar)."""
+        origin = self._get_origin()
+        xy = origin.getXY()
+
+        box = self._make_box(0, 0, 50)
+
+        # Face1 is the -Z face of a Part::Box.
+        joint = self._make_joint(
+            5,
+            [box, ["Face1", "Vertex1"]],
+            [origin, [xy.Name + ".", xy.Name + "."]],
+        )
+        joint.Distance = 0.0
+
+        result = self.assembly.solve()
+        self.assertEqual(
+            result, 0, "Solve should succeed for face→datum Distance joint"
+        )
+
+    # ── Round-trip test ──────────────────────────────────────────────
+
+    def test_save_load_preserves_labels(self):
+        """Labels survive save/load round-trip."""
+        origin = self._get_origin()
+
+        # Verify labels before save
+        self.assertEqual(origin.getXY().Label, "Top")
+        self.assertEqual(origin.getXZ().Label, "Front")
+        self.assertEqual(origin.getYZ().Label, "Right")
+
+        # Save to temp file
+        tmp = tempfile.mktemp(suffix=".FCStd")
+        try:
+            self.doc.saveAs(tmp)
+
+            # Close and reopen
+            doc_name = self.doc.Name
+            App.closeDocument(doc_name)
+            App.openDocument(tmp)
+            doc = App.ActiveDocument
+
+            assembly = doc.getObject("Assembly")
+            self.assertIsNotNone(assembly)
+
+            origin = assembly.Origin
+            self.assertEqual(origin.getXY().Label, "Top")
+            self.assertEqual(origin.getXZ().Label, "Front")
+            self.assertEqual(origin.getYZ().Label, "Right")
+
+            App.closeDocument(doc.Name)
+        finally:
+            if os.path.exists(tmp):
+                os.remove(tmp)
+
+        # Reopen a fresh doc for tearDown
+        App.newDocument(self.__class__.__name__)

src/Mod/Assembly/CMakeLists.txt

@@ -60,6 +60,7 @@ SET(AssemblyTests_SRCS
     AssemblyTests/TestSolverIntegration.py
     AssemblyTests/TestKindredSolverIntegration.py
     AssemblyTests/TestKCSolvePy.py
+    AssemblyTests/TestAssemblyOriginPlanes.py
     AssemblyTests/mocks/__init__.py
     AssemblyTests/mocks/MockGui.py
 )

src/Mod/Assembly/CommandCreateAssembly.py

@@ -22,15 +22,14 @@
 # **************************************************************************/
 
 import FreeCAD as App
-
 from PySide.QtCore import QT_TRANSLATE_NOOP
 
 if App.GuiUp:
     import FreeCADGui as Gui
     from PySide import QtCore, QtGui, QtWidgets
 
-import UtilsAssembly
 import Preferences
+import UtilsAssembly
 
 translate = App.Qt.translate
 
@@ -78,14 +77,22 @@ class CommandCreateAssembly:
                 'assembly = activeAssembly.newObject("Assembly::AssemblyObject", "Assembly")\n'
             )
         else:
-            commands = (
-                'assembly = App.ActiveDocument.addObject("Assembly::AssemblyObject", "Assembly")\n'
-            )
+            commands = 'assembly = App.ActiveDocument.addObject("Assembly::AssemblyObject", "Assembly")\n'
 
         commands = commands + 'assembly.Type = "Assembly"\n'
         commands = commands + 'assembly.newObject("Assembly::JointGroup", "Joints")'
 
         Gui.doCommand(commands)
+
+        # Make origin planes visible by default so they serve as
+        # reference geometry (like SolidWorks Front/Top/Right planes).
+        Gui.doCommandGui(
+            "assembly.Origin.ViewObject.Visibility = True\n"
+            "for feat in assembly.Origin.OriginFeatures:\n"
+            "    if feat.isDerivedFrom('App::Plane'):\n"
+            "        feat.ViewObject.Visibility = True\n"
+        )
+
         if not activeAssembly:
             Gui.doCommandGui("Gui.ActiveDocument.setEdit(assembly)")
 
@@ -98,7 +105,9 @@ class ActivateAssemblyTaskPanel:
     def __init__(self, assemblies):
         self.assemblies = assemblies
         self.form = QtWidgets.QWidget()
-        self.form.setWindowTitle(translate("Assembly_ActivateAssembly", "Activate Assembly"))
+        self.form.setWindowTitle(
+            translate("Assembly_ActivateAssembly", "Activate Assembly")
+        )
 
         layout = QtWidgets.QVBoxLayout(self.form)
         label = QtWidgets.QLabel(
@@ -132,9 +141,12 @@ class CommandActivateAssembly:
     def GetResources(self):
         return {
             "Pixmap": "Assembly_ActivateAssembly",
-            "MenuText": QT_TRANSLATE_NOOP("Assembly_ActivateAssembly", "Activate Assembly"),
+            "MenuText": QT_TRANSLATE_NOOP(
+                "Assembly_ActivateAssembly", "Activate Assembly"
+            ),
             "ToolTip": QT_TRANSLATE_NOOP(
-                "Assembly_ActivateAssembly", "Sets an assembly as the active one for editing."
+                "Assembly_ActivateAssembly",
+                "Sets an assembly as the active one for editing.",
             ),
             "CmdType": "ForEdit",
         }
@@ -156,7 +168,9 @@ class CommandActivateAssembly:
 
     def Activated(self):
         doc = App.ActiveDocument
-        assemblies = [o for o in doc.Objects if o.isDerivedFrom("Assembly::AssemblyObject")]
+        assemblies = [
+            o for o in doc.Objects if o.isDerivedFrom("Assembly::AssemblyObject")
+        ]
 
         if len(assemblies) == 1:
             # If there's only one, activate it directly without showing a dialog

src/Mod/Assembly/TestAssemblyWorkbench.py

@@ -22,6 +22,7 @@
 # **************************************************************************/
 
 import TestApp
+from AssemblyTests.TestAssemblyOriginPlanes import TestAssemblyOriginPlanes
 from AssemblyTests.TestCommandInsertLink import TestCommandInsertLink
 from AssemblyTests.TestCore import TestCore
 from AssemblyTests.TestKCSolvePy import (
@@ -36,5 +37,6 @@ from AssemblyTests.TestSolverIntegration import TestSolverIntegration
 # Use the modules so that code checkers don't complain (flake8)
 True if TestCore else False
 True if TestCommandInsertLink else False
+True if TestAssemblyOriginPlanes else False
 True if TestSolverIntegration else False
 True if TestKindredSolverIntegration else False

src/Mod/Create/kc_format.py

@@ -162,34 +162,28 @@ class _KcFormatObserver:
                     f"kc_format: pre_reinject hook failed: {exc}\n"
                 )
         try:
+            # Ensure silo/manifest.json exists in entries and update modified_at.
+            # All manifest mutations happen here so only one copy is written.
+            if "silo/manifest.json" in entries:
+                try:
+                    manifest = json.loads(entries["silo/manifest.json"])
+                except (json.JSONDecodeError, ValueError):
+                    manifest = _default_manifest()
+            else:
+                manifest = _default_manifest()
+            manifest["modified_at"] = datetime.now(timezone.utc).strftime(
+                "%Y-%m-%dT%H:%M:%SZ"
+            )
+            entries["silo/manifest.json"] = (
+                json.dumps(manifest, indent=2) + "\n"
+            ).encode("utf-8")
+
             with zipfile.ZipFile(filename, "a") as zf:
                 existing = set(zf.namelist())
-                # Re-inject cached silo/ entries
-                if entries:
-                    for name, data in entries.items():
-                        if name not in existing:
-                            zf.writestr(name, data)
-                            existing.add(name)
-                # Ensure silo/manifest.json exists
-                if "silo/manifest.json" not in existing:
-                    manifest = _default_manifest()
-                    zf.writestr(
-                        "silo/manifest.json",
-                        json.dumps(manifest, indent=2) + "\n",
-                    )
-                else:
-                    # Update modified_at timestamp
-                    raw = zf.read("silo/manifest.json")
-                    manifest = json.loads(raw)
-                    now = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
-                    if manifest.get("modified_at") != now:
-                        manifest["modified_at"] = now
-                        # ZipFile append mode can't overwrite; write new entry
-                        # (last duplicate wins in most ZIP readers)
-                        zf.writestr(
-                            "silo/manifest.json",
-                            json.dumps(manifest, indent=2) + "\n",
-                        )
+                for name, data in entries.items():
+                    if name not in existing:
+                        zf.writestr(name, data)
+                        existing.add(name)
         except Exception as e:
             FreeCAD.Console.PrintWarning(
                 f"kc_format: failed to update .kc silo/ entries: {e}\n"
@@ -209,17 +203,36 @@ def update_manifest_fields(filename, updates):
         return
     if not os.path.isfile(filename):
         return
+    import shutil
+    import tempfile
+
     try:
-        with zipfile.ZipFile(filename, "a") as zf:
-            if "silo/manifest.json" not in zf.namelist():
-                return
-            raw = zf.read("silo/manifest.json")
-            manifest = json.loads(raw)
-            manifest.update(updates)
-            zf.writestr(
-                "silo/manifest.json",
-                json.dumps(manifest, indent=2) + "\n",
-            )
+        fd, tmp = tempfile.mkstemp(suffix=".kc", dir=os.path.dirname(filename))
+        os.close(fd)
+        try:
+            with (
+                zipfile.ZipFile(filename, "r") as zin,
+                zipfile.ZipFile(tmp, "w", compression=zipfile.ZIP_DEFLATED) as zout,
+            ):
+                found = False
+                for item in zin.infolist():
+                    if item.filename == "silo/manifest.json":
+                        if found:
+                            continue  # skip duplicate entries
+                        found = True
+                        raw = zin.read(item.filename)
+                        manifest = json.loads(raw)
+                        manifest.update(updates)
+                        zout.writestr(
+                            item.filename,
+                            json.dumps(manifest, indent=2) + "\n",
+                        )
+                    else:
+                        zout.writestr(item, zin.read(item.filename))
+            shutil.move(tmp, filename)
+        except BaseException:
+            os.unlink(tmp)
+            raise
     except Exception as e:
         FreeCAD.Console.PrintWarning(f"kc_format: failed to update manifest: {e}\n")