feat(assembly): add diagnostic logging to solver and assembly

C++ (AssemblyObject): - getOrCreateSolver: log which solver backend was loaded - solve: log assembly name, grounded/joint counts, context size, result status with DOF and placement count, per-constraint diagnostics on failure - preDrag/doDragStep/postDrag: log drag part count, per-step validation failures, and summary (total steps / rejected count) - buildSolveContext: log grounded/free part counts, constraint count, limits count, and bundle_fixed flag Python (kindred_solver submodule): - solver.py: log solve entry/exit with timing, system build stats, decomposition decisions, Newton/BFGS fallback events, drag lifecycle - decompose.py: log cluster stats and per-cluster convergence - Init.py: FreeCAD log handler routing Python logging to Console
2026-02-21 10:08:10 -06:00
24 changed files with 64 additions and 1509 deletions
--- a/.gitmodules
+++ b/.gitmodules
@@ -22,6 +22,3 @@
 	path = mods/solver
 	url = https://git.kindred-systems.com/kindred/solver.git
 	branch = main
-[submodule "mods/quicknav"]
-	path = mods/quicknav
-	url = https://git.kindred-systems.com/kindred/quicknav.git
--- a/CMakeLists.txt
+++ b/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 "5")
+set(KINDRED_CREATE_VERSION_PATCH "0")
 set(KINDRED_CREATE_VERSION "${KINDRED_CREATE_VERSION_MAJOR}.${KINDRED_CREATE_VERSION_MINOR}.${KINDRED_CREATE_VERSION_PATCH}")

 # Underlying FreeCAD version
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@

 **An engineering-focused parametric 3D CAD platform built on FreeCAD 1.0+**

-Kindred Create 0.1.5 | FreeCAD 1.2.0 base
+Kindred Create 0.1.0 | FreeCAD 1.2.0 base

 [Website](https://www.kindred-systems.com/create) |
 [Downloads](https://git.kindred-systems.com/kindred/create/releases) |
--- a/docs/src/development/build-system.md
+++ b/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.5` (via `KINDRED_CREATE_VERSION`)
+- **Kindred Create version:** `0.1.0` (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.5")
+CMakeLists.txt (KINDRED_CREATE_VERSION = "0.1.0")
    → src/Mod/Create/version.py.in (template)
    → build/*/Mod/Create/version.py (generated)
    → update_checker.py (imports VERSION)
--- a/docs/src/development/gui-build-integration.md
+++ b/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.5")
+set(KINDRED_CREATE_VERSION "0.1.0")
 set(FREECAD_VERSION "1.0.0")

 add_definitions(-DKINDRED_CREATE_VERSION="${KINDRED_CREATE_VERSION}")
--- a/docs/src/quicknav/SPEC.md
+++ b/docs/src/quicknav/SPEC.md
@@ -1,441 +0,0 @@
-# QuickNav — Keyboard Navigation Addon Specification
-
-**Addon name:** QuickNav
-**Type:** Pure Python FreeCAD addon (no C++ required)
-**Compatibility:** FreeCAD 1.0+, Kindred Create 0.1+
-**Location:** `mods/quicknav/`
-
---
-
-## 1. Overview
-
-QuickNav provides keyboard-driven command access for FreeCAD and Kindred Create. It replaces mouse-heavy toolbar navigation with a numbered key system organized by workbench and command grouping. The addon is activated by loading its workbench and toggled on/off with the `0` key.
-
-### Design Goals
-
- Numbers `1-9` execute commands within the active command grouping
- `Shift+1-9` switches command grouping within the active workbench
- `Ctrl+1-9` switches workbench context
- All groupings and workbenches are ordered by most-recently-used (MRU) history
- History is unlimited internally, top 9 shown, remainder scrollable/clickable
- Mouse interaction remains fully functional — QuickNav is purely additive
- Configuration persisted via `FreeCAD.ParamGet()`
-
---
-
-## 2. Terminology
-
-| Term | Definition |
-|------|-----------|
-| **Workbench** | A FreeCAD workbench (Sketcher, PartDesign, Assembly, etc.). Fixed assignment to Ctrl+N slots. |
-| **Command Grouping** | A logical group of commands within a workbench, mapped from existing FreeCAD toolbar groupings. Max 9 per tier. |
-| **Active Grouping** | The left-most visible grouping in the navigation bar. Its commands are accessible via `1-9`. |
-| **Navigation Bar** | Bottom toolbar displaying the current state: active workbench, groupings, and numbered commands. |
-| **MRU Stack** | Most-recently-used ordering. Position 0 = currently active, 1 = previously active, etc. |
-| **Tier** | When a workbench has >9 command groupings, they are split: Tier 1 (most common 9), Tier 2 (next 9). |
-
---
-
-## 3. Key Bindings
-
-### 3.1 Mode Toggle
-
-| Key | Action |
-|-----|--------|
-| `0` | Toggle QuickNav on/off. When off, all QuickNav key interception is disabled and the navigation bar hides. |
-
-### 3.2 Command Execution
-
-| Key | Action |
-|-----|--------|
-| `1-9` | Execute the Nth command in the active grouping. If the command is auto-executable (e.g., Pad after closed sketch), execute immediately. Otherwise, enter tool mode (same as clicking the toolbar button). |
-
-### 3.3 Grouping Navigation
-
-| Key | Action |
-|-----|--------|
-| `Shift+1-9` | Switch to the Nth command grouping (MRU ordered) within the current workbench. The newly activated grouping moves to position 0 in the MRU stack. |
-| `Shift+Left/Right` | Scroll through groupings beyond the visible 9. |
-
-### 3.4 Workbench Navigation
-
-| Key | Action |
-|-----|--------|
-| `Ctrl+1` | Sketcher |
-| `Ctrl+2` | Part Design |
-| `Ctrl+3` | Assembly |
-| `Ctrl+4` | Spreadsheet |
-| `Ctrl+5` | TechDraw |
-| `Ctrl+6-9` | User-configurable / additional workbenches |
-
-Switching workbench via `Ctrl+N` also restores that workbench's last-active command grouping.
-
---
-
-## 4. Navigation Bar
-
-The navigation bar is a `QToolBar` positioned at the bottom of the main window (replacing or sitting alongside FreeCAD's default bottom toolbar area).
-
-### 4.1 Layout
-
-```
-┌─────────────────────────────────────────────────────────────────────┐
-│ [WB: Sketcher] │ ❶ Primitives │ ② Constraints │ ③ Dimensions │ ◀▶ │
-│                │ 1:Line 2:Rect 3:Circle 4:Arc 5:Point 6:Slot ...  │
-└─────────────────────────────────────────────────────────────────────┘
-```
-
- **Left section:** Current workbench name with Ctrl+N hint
- **Middle section (top row):** Command groupings, MRU ordered. Active grouping is ❶ (filled circle), others are ②③ etc. Scrollable horizontally if >9.
- **Middle section (bottom row):** Commands within the active grouping, numbered 1-9
- **Right section:** Scroll arrows for overflow groupings
-
-### 4.2 Visual States
-
- **Active grouping:** Bold text, filled number badge, Catppuccin Mocha `blue` (#89b4fa) accent
- **Inactive groupings:** Normal text, outlined number badge, `surface1` (#45475a) text
- **Hovered command:** `surface2` (#585b70) background highlight
- **Active command (tool in use):** `green` (#a6e3a1) underline indicator
-
-### 4.3 Mouse Interaction
-
- Click any grouping to activate it (equivalent to Shift+N)
- Click any command to execute it (equivalent to pressing N)
- Scroll wheel on grouping area to cycle through overflow groupings
- Click scroll arrows to page through overflow
-
---
-
-## 5. Workbench Command Groupings
-
-Each workbench's existing FreeCAD toolbars map to command groupings. Where a workbench has >9 toolbars, split into Tier 1 (default, most common) and Tier 2 (accessible via scrolling or `Shift+Left/Right`).
-
-### 5.1 Sketcher (Ctrl+1)
-
-| Grouping | Commands (1-9) |
-|----------|---------------|
-| Primitives | Line, Rectangle, Circle, Arc, Point, Slot, B-Spline, Polyline, Ellipse |
-| Constraints | Coincident, Horizontal, Vertical, Parallel, Perpendicular, Tangent, Equal, Symmetric, Block |
-| Dimensions | Distance, Horizontal Distance, Vertical Distance, Radius, Diameter, Angle, Lock, Constrain Refraction |
-| Construction | Toggle Construction, External Geometry, Carbon Copy, Offset, Trim, Extend, Split |
-| Tools | Mirror, Array (Linear), Array (Polar), Move, Rotate, Scale, Close Shape, Connect Edges |
-
-### 5.2 Part Design (Ctrl+2)
-
-| Grouping | Commands (1-9) |
-|----------|---------------|
-| Additive | Pad, Revolution, Additive Loft, Additive Pipe, Additive Helix, Additive Box, Additive Cylinder, Additive Sphere, Additive Cone |
-| Subtractive | Pocket, Hole, Groove, Subtractive Loft, Subtractive Pipe, Subtractive Helix, Subtractive Box, Subtractive Cylinder, Subtractive Sphere |
-| Datums | New Sketch, Datum Plane, Datum Line, Datum Point, Shape Binder, Sub-Shape Binder, ZTools Datum Creator, ZTools Datum Manager |
-| Transformations | Mirrored, Linear Pattern, Polar Pattern, MultiTransform, ZTools Rotated Linear Pattern |
-| Modeling | Fillet, Chamfer, Draft, Thickness, Boolean, ZTools Enhanced Pocket |
-
-### 5.3 Assembly (Ctrl+3)
-
-| Grouping | Commands (1-9) |
-|----------|---------------|
-| Components | Insert Component, Create Part, Create Assembly, Ground, BOM |
-| Joints | Fixed, Revolute, Cylindrical, Slider, Ball, Planar, Distance, Angle, Parallel |
-| Patterns | ZTools Linear Pattern, ZTools Polar Pattern |
-
-### 5.4 Spreadsheet (Ctrl+4)
-
-| Grouping | Commands (1-9) |
-|----------|---------------|
-| Editing | Merge Cells, Split Cell, Alias, Import CSV, Export CSV |
-| Formatting | Bold, Italic, Underline, Align Left, Align Center, Align Right, BG Color, Text Color, Quick Alias |
-
-### 5.5 TechDraw (Ctrl+5)
-
-Groupings derived from TechDraw's existing toolbars at runtime.
-
-> **Note:** The exact command lists above are initial defaults. The addon discovers available commands from each workbench's toolbar structure at activation time and falls back to these defaults only if discovery fails.
-
---
-
-## 6. MRU History Behavior
-
-### 6.1 Grouping History (per workbench)
-
-Each workbench maintains its own grouping MRU stack.
-
- When a grouping is activated (via `Shift+N` or mouse click), it moves to position 0
- The previously active grouping moves to position 1, everything else shifts down
- Position 0 is always the active grouping (already selected, shown leftmost)
- `Shift+1` is a no-op (already active), `Shift+2` activates the previous grouping, etc.
-
-### 6.2 Workbench History
-
- Workbenches have fixed Ctrl+N assignments (not MRU ordered)
- However, each workbench remembers its last-active grouping
- Switching to a workbench restores its last-active grouping as position 0
-
-### 6.3 Persistence
-
-Stored in `FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Mod/QuickNav")`:
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| `Enabled` | Bool | Whether QuickNav is currently active |
-| `GroupHistory/<Workbench>` | String | Semicolon-delimited list of grouping names in MRU order |
-| `LastGrouping/<Workbench>` | String | Name of the last-active grouping per workbench |
-| `CustomSlots/Ctrl6` through `Ctrl9` | String | Workbench names for user-configurable slots |
-
---
-
-## 7. Auto-Execution Logic
-
-When a command is invoked via number key, QuickNav checks if the command can be auto-executed:
-
-### 7.1 Auto-Execute Conditions
-
-A command auto-executes (runs and completes without entering a persistent mode) when:
-
-1. **Pad/Pocket after closed sketch:** If the active body has a sketch that was just closed (sketch edit mode exited with a closed profile), pressing the Pad or Pocket command key creates the feature with default parameters. The task panel still opens for parameter adjustment.
-2. **Boolean operations:** If exactly two bodies/shapes are selected, boolean commands execute with defaults.
-3. **Constraint application:** If appropriate geometry is pre-selected in Sketcher, constraint commands apply immediately.
-
-### 7.2 Mode-Entry (Default)
-
-All other commands enter their standard FreeCAD tool mode — identical to clicking the toolbar button. The user interacts with the 3D view and/or task panel as normal.
-
---
-
-## 8. Key Event Handling
-
-### 8.1 Event Filter Architecture
-
-```python
-class QuickNavEventFilter(QObject):
-    """Installed on FreeCAD's main window via installEventFilter().
-
-    Intercepts KeyPress events when QuickNav is active.
-    Passes through all events when QuickNav is inactive.
-    """
-
-    def eventFilter(self, obj, event):
-        if event.type() != QEvent.KeyPress:
-            return False
-        if not self._active:
-            return False
-
-        # Don't intercept when a text input widget has focus
-        focused = QApplication.focusWidget()
-        if isinstance(focused, (QLineEdit, QTextEdit, QPlainTextEdit, QSpinBox, QDoubleSpinBox)):
-            return False
-
-        # Don't intercept when task panel input fields are focused
-        if self._is_task_panel_input(focused):
-            return False
-
-        key = event.key()
-        modifiers = event.modifiers()
-
-        if key == Qt.Key_0 and modifiers == Qt.NoModifier:
-            self.toggle_active()
-            return True
-
-        if key >= Qt.Key_1 and key <= Qt.Key_9:
-            n = key - Qt.Key_0
-            if modifiers == Qt.ControlModifier:
-                self.switch_workbench(n)
-                return True
-            elif modifiers == Qt.ShiftModifier:
-                self.switch_grouping(n)
-                return True
-            elif modifiers == Qt.NoModifier:
-                self.execute_command(n)
-                return True
-
-        return False  # Pass through all other keys
-```
-
-### 8.2 Conflict Resolution
-
-QuickNav's event filter takes priority when active. FreeCAD's existing keybindings for `Ctrl+1` through `Ctrl+9` (if any) are overridden while QuickNav is enabled. The original bindings are restored when QuickNav is toggled off or unloaded.
-
-Existing `Shift+` and bare number key bindings in FreeCAD are similarly overridden only while QuickNav is active. This is safe because:
- FreeCAD does not use bare number keys as shortcuts by default
- Shift+number is not commonly bound in default FreeCAD
-
-### 8.3 Input Widget Safety
-
-The event filter must NOT intercept keys when the user is:
- Typing in the Python console
- Entering values in the task panel (dimensions, parameters)
- Editing spreadsheet cells
- Typing in any `QLineEdit`, `QTextEdit`, `QSpinBox`, or `QDoubleSpinBox`
- Using the Sketcher's inline dimension input
-
---
-
-## 9. Addon Structure
-
-```
-mods/quicknav/
-├── package.xml              # FreeCAD addon manifest with <kindred> extension
-├── Init.py                  # Non-GUI initialization (no-op)
-├── InitGui.py               # Registers QuickNavWorkbench
-├── quicknav/
-│   ├── __init__.py
-│   ├── core.py              # QuickNavManager singleton — orchestrates state
-│   ├── event_filter.py      # QuickNavEventFilter (QObject)
-│   ├── nav_bar.py           # NavigationBar (QToolBar subclass)
-│   ├── workbench_map.py     # Fixed workbench → Ctrl+N mapping + grouping discovery
-│   ├── history.py           # MRU stack with ParamGet persistence
-│   ├── auto_exec.py         # Auto-execution condition checks
-│   ├── commands.py          # FreeCAD command wrappers (QuickNav_Toggle, etc.)
-│   └── resources/
-│       ├── icons/           # Number badge SVGs, QuickNav icon
-│       └── theme.py         # Catppuccin Mocha color tokens
-└── tests/
-    └── test_history.py      # MRU stack unit tests
-```
-
-### 9.1 Manifest
-
-```xml
-<?xml version="1.0" encoding="UTF-8"?>
-<package format="1">
-  <name>QuickNav</name>
-  <description>Keyboard-driven toolbar navigation</description>
-  <version>0.1.0</version>
-  <maintainer email="dev@kindred-systems.com">Kindred Systems</maintainer>
-  <license>LGPL-2.1</license>
-  <content>
-    <workbench>
-      <classname>QuickNavWorkbench</classname>
-    </workbench>
-  </content>
-  <kindred>
-    <min_create_version>0.1.0</min_create_version>
-    <load_priority>10</load_priority>
-    <pure_python>true</pure_python>
-    <dependencies>
-      <dependency>sdk</dependency>
-    </dependencies>
-  </kindred>
-</package>
-```
-
-### 9.2 Activation
-
-QuickNav activates when its workbench is loaded (via the addon loader or manual activation). It installs the event filter on the main window and creates the navigation bar. The workbench itself is invisible — it does not add its own toolbars or menus beyond the navigation bar. It acts as a transparent overlay on whatever workbench the user is actually working in.
-
-```python
-class QuickNavWorkbench(Gui.Workbench):
-    """Invisible workbench that installs QuickNav on load.
-
-    QuickNav doesn't replace the active workbench — it layers on top.
-    Loading QuickNav installs the event filter and nav bar, then
-    immediately re-activates the previously active workbench.
-    """
-
-    def Initialize(self):
-        QuickNavManager.instance().install()
-
-    def Activated(self):
-        # Re-activate the previous workbench so QuickNav is transparent
-        prev = QuickNavManager.instance().previous_workbench
-        if prev:
-            Gui.activateWorkbench(prev)
-
-    def Deactivated(self):
-        pass
-
-    def GetClassName(self):
-        return "Gui::PythonWorkbench"
-```
-
-**Alternative (preferred for Create):** Instead of a workbench, QuickNav can be activated directly from `Create/InitGui.py` at boot, gated by the `Enabled` preference. This avoids the workbench-switching dance entirely. The `QuickNavWorkbench` registration is kept for standalone FreeCAD compatibility.
-
---
-
-## 10. Command Discovery
-
-At activation time, QuickNav introspects each workbench's toolbars to build the command grouping map.
-
-```python
-def discover_groupings(workbench_name: str) -> list[CommandGrouping]:
-    """Discover command groupings from a workbench's toolbar structure.
-
-    1. Temporarily activate the workbench (if not already active)
-    2. Enumerate QToolBars from the main window
-    3. Map toolbar name → list of QAction names
-    4. Filter out non-command actions (separators, widgets)
-    5. Split into tiers if >9 groupings
-    6. Restore the previously active workbench
-    """
-```
-
-### 10.1 Fallback Defaults
-
-If toolbar discovery fails (workbench not initialized, empty toolbars), QuickNav falls back to the hardcoded groupings in Section 5. These are stored as a Python dict in `workbench_map.py`.
-
-### 10.2 ZTools Integration
-
-ZTools commands injected via `WorkbenchManipulator` appear in the discovered toolbars and are automatically included in the relevant groupings. No special handling is needed — QuickNav discovers commands after all manipulators have run.
-
---
-
-## 11. FreeCAD Compatibility
-
-QuickNav is designed as a standalone FreeCAD addon that works without Kindred Create or the SDK.
-
-| Feature | FreeCAD | Kindred Create |
-|---------|---------|----------------|
-| Core navigation (keys, nav bar) | ✅ | ✅ |
-| Catppuccin Mocha theming | ❌ (uses Qt defaults) | ✅ (via SDK theme tokens) |
-| Auto-boot on startup | ❌ (manual workbench activation) | ✅ (via addon loader) |
-| ZTools commands in groupings | ❌ (not present) | ✅ (discovered from manipulated toolbars) |
-
-The SDK dependency is optional — QuickNav checks for `kindred_sdk` availability and degrades gracefully:
-
-```python
-try:
-    from kindred_sdk.theme import get_theme_tokens
-    THEME = get_theme_tokens()
-except ImportError:
-    THEME = None  # Use Qt default palette
-```
-
---
-
-## 12. Implementation Phases
-
-### Phase 1: Core Infrastructure
- Event filter with key interception and input widget safety
- QuickNavManager singleton with toggle on/off
- Navigation bar widget (QToolBar) with basic layout
- Hardcoded workbench/grouping maps from Section 5
- ParamGet persistence for enabled state
-
-### Phase 2: Dynamic Discovery
- Toolbar introspection for command grouping discovery
- MRU history with persistence
- Grouping overflow scrolling
- Workbench restore (last-active grouping per workbench)
-
-### Phase 3: Auto-Execution
- Context-aware auto-execute logic
- Sketcher closed-profile detection for Pad/Pocket
- Pre-selection constraint application
-
-### Phase 4: Polish
- Number badge SVG icons
- Catppuccin Mocha theming (conditional on SDK)
- Scroll animations
- Settings dialog (custom Ctrl+6-9 assignments)
- FreeCAD standalone packaging
-
---
-
-## 13. Open Questions
-
-1. **Tier switching UX:** When a workbench has >9 groupings split into tiers, should `Shift+0` toggle between tiers, or should tiers be purely a scroll/mouse concept?
-
-2. **Visual number badges:** Should the commands in the nav bar show keycap-style badges (like `⌨ 1`) or just prepend the number (`1: Line`)?
-
-3. **Sketcher inline dimension input:** FreeCAD's Sketcher has an inline dimension entry that isn't a standard QLineEdit. Need to verify the event filter correctly identifies and skips this widget.
-
-4. **Ctrl+N conflicts with Create shortcuts:** Verify that Create/Silo don't already bind Ctrl+1 through Ctrl+9. The Silo toggle uses Ctrl+O/S/N, so these should be clear.
--- a/docs/src/reference/configuration.md
+++ b/docs/src/reference/configuration.md
@@ -77,7 +77,7 @@ Defined in the root `CMakeLists.txt`:

 | Constant | Value | Description |
 |----------|-------|-------------|
-| `KINDRED_CREATE_VERSION` | `0.1.5` | Kindred Create version |
+| `KINDRED_CREATE_VERSION` | `0.1.0` | 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`.
--- a/docs/src/solver/assembly-integration.md
+++ b/docs/src/solver/assembly-integration.md
@@ -98,107 +98,53 @@ if hasattr(FreeCADGui, "ActiveDocument"):

 ## Interactive drag protocol

-The drag protocol provides real-time constraint solving during viewport part dragging. It is a three-phase protocol with a caching layer that avoids rebuilding the constraint system on every mouse move.
+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. Builds the constraint system once, runs the substitution pre-pass, constructs the symbolic Jacobian, compiles the evaluator, performs an initial solve, and caches everything in a `_DragCache` for reuse across subsequent `drag_step()` calls.
+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)
-
-    system = _build_system(ctx)
-
-    half_spaces = compute_half_spaces(...)
-    weight_vec = build_weight_vector(system.params)
-
-    residuals = substitution_pass(system.all_residuals, system.params)
-    # single_equation_pass is intentionally skipped — it bakes variable
-    # values as constants that become stale when dragged parts move.
-
-    jac_exprs = [[r.diff(name).simplify() for name in free] for r in residuals]
-    compiled_eval = try_compile_system(residuals, jac_exprs, ...)
-
-    # Initial solve (Newton-Raphson + BFGS fallback)
-    newton_solve(residuals, system.params, ...)
-
-    # Cache for drag_step() reuse
-    cache = _DragCache()
-    cache.system = system
-    cache.residuals = residuals
-    cache.jac_exprs = jac_exprs
-    cache.compiled_eval = compiled_eval
-    cache.half_spaces = half_spaces
-    cache.weight_vec = weight_vec
-    ...
-    return result
+    return self.solve(ctx)
 ```

-**Important:** `single_equation_pass` is not used in the drag path. It analytically solves single-variable equations and bakes the results as `Const()` nodes into downstream expressions. During drag, those baked values become stale when part positions change, causing constraints to silently stop being enforced. Only `substitution_pass` (which replaces genuinely grounded parameters) is safe to cache.
-
 ### drag_step(drag_placements)

-Called on each mouse move. Updates only the dragged part's 7 parameter values in the cached `ParamTable`, then re-solves using the cached residuals, Jacobian, and compiled evaluator. No system rebuild occurs.
+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):
-    cache = self._drag_cache
-    params = cache.system.params
-
-    # Update only the dragged part's parameters
+    ctx = self._drag_ctx
    for pr in drag_placements:
-        pfx = pr.id + "/"
-        params.set_value(pfx + "tx", pr.placement.position[0])
-        params.set_value(pfx + "ty", pr.placement.position[1])
-        params.set_value(pfx + "tz", pr.placement.position[2])
-        params.set_value(pfx + "qw", pr.placement.quaternion[0])
-        params.set_value(pfx + "qx", pr.placement.quaternion[1])
-        params.set_value(pfx + "qy", pr.placement.quaternion[2])
-        params.set_value(pfx + "qz", pr.placement.quaternion[3])
-
-    # Solve with cached artifacts — no rebuild
-    newton_solve(cache.residuals, params, ...,
-                 jac_exprs=cache.jac_exprs,
-                 compiled_eval=cache.compiled_eval)
-
-    return result
+        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 cached state.
+Called when the drag ends. Clears the stored state.

 ```python
 def post_drag(self):
    self._drag_ctx = None
    self._drag_parts = None
-    self._drag_cache = None
 ```

-### _DragCache
+### Performance notes

-The cache holds all artifacts built in `pre_drag()` that are invariant across drag steps (constraint topology doesn't change during a drag):
-
-| Field | Contents |
-|-------|----------|
-| `system` | `_System` -- owns `ParamTable` and `Expr` trees |
-| `residuals` | `list[Expr]` -- after substitution pass |
-| `jac_exprs` | `list[list[Expr]]` -- symbolic Jacobian |
-| `compiled_eval` | `Callable` or `None` -- native compiled evaluator |
-| `half_spaces` | `list[HalfSpace]` -- branch trackers |
-| `weight_vec` | `ndarray` or `None` -- minimum-movement weights |
-| `post_step_fn` | `Callable` or `None` -- half-space correction callback |
-
-### Performance
-
-The caching layer eliminates the expensive per-frame overhead (~150 ms for system build + Jacobian construction + compilation). Each `drag_step()` only evaluates the cached expressions at updated parameter values:
+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
- The compiled evaluator (`codegen.py`) uses native Python `exec` for flat evaluation, avoiding the recursive tree-walk overhead
- The substitution pass compiles grounded-body parameters to constants, reducing the effective system size
- DOF counting is skipped during drag for speed (`result.dof = -1`)
+- 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

--- a/mods/quicknav
+++ b/mods/quicknav
--- a/mods/solver
+++ b/mods/solver
--- a/package/debian/build-deb.sh
+++ b/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.5")
+    VERSION=$(cd "$PROJECT_ROOT" && git describe --tags --always 2>/dev/null || echo "0.1.0")
 fi

 # Convert version to Debian-compatible format
--- a/package/rattler-build/recipe.yaml
+++ b/package/rattler-build/recipe.yaml
@@ -155,7 +155,6 @@ requirements:
    - lark
    - lxml
    - matplotlib-base
-    - networkx
    - nine
    - noqt5
    - numpy>=1.26,<2
--- a/src/Gui/Application.cpp
+++ b/src/Gui/Application.cpp
@@ -1046,9 +1046,6 @@ 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);
@@ -1355,12 +1352,6 @@ 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 {
--- a/src/Gui/Application.h
+++ b/src/Gui/Application.h
@@ -153,9 +153,6 @@ 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;
    //@}
@@ -177,7 +174,6 @@ 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
--- a/src/Gui/EditingContext.cpp
+++ b/src/Gui/EditingContext.cpp
@@ -121,9 +121,6 @@ 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()
@@ -175,23 +172,6 @@ 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
 // ---------------------------------------------------------------------------
@@ -233,34 +213,6 @@ 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"),
@@ -320,10 +272,7 @@ void EditingContextResolver::registerBuiltinContexts()
        /*.priority =*/40,
        /*.match =*/
        []() {
-            auto* obj = getActivePdBodyObject();
-            if (!obj) {
-                obj = getActivePartObject();
-            }
+            auto* obj = getActivePartObject();
            if (!obj || !objectIsDerivedFrom(obj, "PartDesign::Body")) {
                return false;
            }
@@ -352,10 +301,7 @@ void EditingContextResolver::registerBuiltinContexts()
        /*.priority =*/30,
        /*.match =*/
        []() {
-            auto* obj = getActivePdBodyObject();
-            if (!obj) {
-                obj = getActivePartObject();
-            }
+            auto* obj = getActivePartObject();
            return obj && objectIsDerivedFrom(obj, "PartDesign::Body");
        },
    });
@@ -542,13 +488,6 @@ 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();
                }
@@ -609,25 +548,6 @@ 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()) {
@@ -662,14 +582,6 @@ 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;
--- a/src/Mod/Assembly/App/AssemblyObject.cpp
+++ b/src/Mod/Assembly/App/AssemblyObject.cpp
@@ -298,14 +298,8 @@ void AssemblyObject::updateSolveStatus()
    //+1 because there's a grounded joint to origin
    lastDoF = (1 + numberOfComponents()) * 6;

-    // 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;
+    if (!solver_ || lastResult_.placements.empty()) {
        solve();
-        updating = false;
    }

    if (!solver_) {
@@ -1115,19 +1109,10 @@ 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:
--- a/src/Mod/Assembly/App/AssemblyUtils.cpp
+++ b/src/Mod/Assembly/App/AssemblyUtils.cpp
@@ -23,7 +23,6 @@

 #include <BRepAdaptor_Curve.hxx>
 #include <BRepAdaptor_Surface.hxx>
-#include <TopExp_Explorer.hxx>
 #include <TopoDS.hxx>
 #include <TopoDS_Face.hxx>
 #include <gp_Circ.hxx>
@@ -55,56 +54,10 @@

 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) {
@@ -198,120 +151,6 @@ double getEdgeRadius(const App::DocumentObject* obj, const std::string& elt)
    return sf.GetType() == GeomAbs_Circle ? sf.Circle().Radius() : 0.0;
 }

-/// Determine whether \a obj represents a planar datum when referenced with an
-/// empty element type (bare sub-name ending with ".").
-///
-/// Covers three independent class hierarchies:
-///   1. App::Plane  (origin planes, Part::DatumPlane)
-///   2. Part::Datum (PartDesign::Plane — not derived from App::Plane)
-///   3. Any Part::Feature whose whole-object shape is a single planar face
-///      (e.g. Part::Plane primitive referenced without an element)
-static bool isDatumPlane(const App::DocumentObject* obj)
-{
-    if (!obj) {
-        return false;
-    }
-
-    // Origin planes and Part::DatumPlane (both inherit App::Plane).
-    if (obj->isDerivedFrom<App::Plane>()) {
-        return true;
-    }
-
-    // PartDesign datum objects inherit Part::Datum but NOT App::Plane.
-    // Part::Datum is also the base for PartDesign::Line and PartDesign::Point,
-    // so inspect the shape to confirm it is actually planar.
-    if (obj->isDerivedFrom<PartApp::Datum>()) {
-        auto* feat = static_cast<const PartApp::Feature*>(obj);
-        const auto& shape = feat->Shape.getShape().getShape();
-        if (shape.IsNull()) {
-            return false;
-        }
-        TopExp_Explorer ex(shape, TopAbs_FACE);
-        if (ex.More()) {
-            BRepAdaptor_Surface sf(TopoDS::Face(ex.Current()));
-            return sf.GetType() == GeomAbs_Plane;
-        }
-        return false;
-    }
-
-    // Fallback for any Part::Feature (e.g. Part::Plane primitive) referenced
-    // bare — if its shape is a single planar face, treat it as a datum plane.
-    if (auto* feat = dynamic_cast<const PartApp::Feature*>(obj)) {
-        const auto& shape = feat->Shape.getShape().getShape();
-        if (shape.IsNull()) {
-            return false;
-        }
-        TopExp_Explorer ex(shape, TopAbs_FACE);
-        if (!ex.More()) {
-            return false;
-        }
-        BRepAdaptor_Surface sf(TopoDS::Face(ex.Current()));
-        if (sf.GetType() != GeomAbs_Plane) {
-            return false;
-        }
-        ex.Next();
-        // Only treat as datum if there is exactly one face — a multi-face
-        // solid referenced bare is ambiguous and should not be classified.
-        return !ex.More();
-    }
-
-    return false;
-}
-
-/// Same idea for datum lines (App::Line, PartDesign::Line, etc.).
-static bool isDatumLine(const App::DocumentObject* obj)
-{
-    if (!obj) {
-        return false;
-    }
-
-    if (obj->isDerivedFrom<App::Line>()) {
-        return true;
-    }
-
-    if (obj->isDerivedFrom<PartApp::Datum>()) {
-        auto* feat = static_cast<const PartApp::Feature*>(obj);
-        const auto& shape = feat->Shape.getShape().getShape();
-        if (shape.IsNull()) {
-            return false;
-        }
-        TopExp_Explorer ex(shape, TopAbs_EDGE);
-        if (ex.More()) {
-            BRepAdaptor_Curve cv(TopoDS::Edge(ex.Current()));
-            return cv.GetType() == GeomAbs_Line;
-        }
-        return false;
-    }
-
-    return false;
-}
-
-/// Same idea for datum points (App::Point, PartDesign::Point, etc.).
-static bool isDatumPoint(const App::DocumentObject* obj)
-{
-    if (!obj) {
-        return false;
-    }
-
-    if (obj->isDerivedFrom<App::Point>()) {
-        return true;
-    }
-
-    if (obj->isDerivedFrom<PartApp::Datum>()) {
-        auto* feat = static_cast<const PartApp::Feature*>(obj);
-        const auto& shape = feat->Shape.getShape().getShape();
-        if (shape.IsNull()) {
-            return false;
-        }
-        // A datum point has a vertex but no edges or faces.
-        TopExp_Explorer exE(shape, TopAbs_EDGE);
-        TopExp_Explorer exV(shape, TopAbs_VERTEX);
-        return !exE.More() && exV.More();
-    }
-
-    return false;
-}
-
 DistanceType getDistanceType(App::DocumentObject* joint)
 {
    if (!joint) {
@@ -325,179 +164,6 @@ DistanceType getDistanceType(App::DocumentObject* joint)
    auto* obj1 = getLinkedObjFromRef(joint, "Reference1");
    auto* obj2 = getLinkedObjFromRef(joint, "Reference2");

-    // Datum objects referenced bare have empty element types (sub-name
-    // ends with ".").  PartDesign datums referenced through a body can
-    // also produce non-standard element types like "Plane" (from a
-    // sub-name such as "Body.DatumPlane.Plane" — Part::Datum::getSubObject
-    // ignores the trailing element, but splitSubName still extracts it).
-    //
-    // Detect these before the main geometry chain, which only handles
-    // the standard Face/Edge/Vertex element types.
-    //
-    // isDatumPlane/Line/Point cover all three independent hierarchies:
-    //   - App::Plane / App::Line / App::Point  (origin datums)
-    //   - Part::Datum subclasses               (PartDesign datums)
-    //   - Part::Feature with single-face shape  (Part::Plane primitive, bare ref)
-    auto isNonGeomElement = [](const std::string& t) {
-        return t != "Face" && t != "Edge" && t != "Vertex";
-    };
-    const bool datumPlane1 = isNonGeomElement(type1) && isDatumPlane(obj1);
-    const bool datumPlane2 = isNonGeomElement(type2) && isDatumPlane(obj2);
-    const bool datumLine1  = isNonGeomElement(type1) && !datumPlane1 && isDatumLine(obj1);
-    const bool datumLine2  = isNonGeomElement(type2) && !datumPlane2 && isDatumLine(obj2);
-    const bool datumPoint1 = isNonGeomElement(type1) && !datumPlane1 && !datumLine1 && isDatumPoint(obj1);
-    const bool datumPoint2 = isNonGeomElement(type2) && !datumPlane2 && !datumLine2 && isDatumPoint(obj2);
-    const bool datum1 = datumPlane1 || datumLine1 || datumPoint1;
-    const bool datum2 = datumPlane2 || datumLine2 || datumPoint2;
-
-    if (datum1 || datum2) {
-        // Map each datum side to a synthetic element type so the same
-        // classification logic applies regardless of which hierarchy
-        // the object comes from.
-        auto syntheticType = [](bool isPlane, bool isLine, bool isPoint,
-                                const std::string& elemType) -> std::string {
-            if (isPlane)  return "Face";
-            if (isLine)   return "Edge";
-            if (isPoint)  return "Vertex";
-            return elemType;  // non-datum side keeps its real type
-        };
-
-        const std::string syn1 = syntheticType(datumPlane1, datumLine1, datumPoint1, type1);
-        const std::string syn2 = syntheticType(datumPlane2, datumLine2, datumPoint2, type2);
-
-        // Both sides are datum planes.
-        if (datumPlane1 && datumPlane2) {
-            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
-        // (or is another datum kind).
-        // 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
-        // plane 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).
-        if (datumPlane1 || datumPlane2) {
-            const auto& otherSyn = datumPlane1 ? syn2 : syn1;
-
-            if (otherSyn == "Vertex" || otherSyn == "Edge") {
-                // Datum plane must be on Reference2 (j side).
-                if (datumPlane1) {
-                    swapJCS(joint);  // move datum from Ref1 → Ref2
-                }
-                DistanceType result = (otherSyn == "Vertex")
-                    ? DistanceType::PointPlane : DistanceType::LinePlane;
-                FC_LOG("Assembly : getDistanceType('" << joint->getFullName()
-                       << "') — datum+" << otherSyn << " → "
-                       << distanceTypeName(result)
-                       << (datumPlane1 ? " (swapped)" : ""));
-                return result;
-            }
-
-            // Face + datum plane or datum plane + datum plane → 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+" << otherSyn << " → PlanePlane");
-            return DistanceType::PlanePlane;
-        }
-
-        // Datum line or datum point paired with a real element type.
-        // Map to the appropriate pair using synthetic types and fall
-        // through to the main geometry chain below.  The synthetic
-        // types ("Edge", "Vertex") will match the existing if-else
-        // branches — but those branches call isEdgeType/isFaceType on
-        // the object, which requires a real sub-element name.  For
-        // datum lines/points the element is empty, so we classify
-        // directly here.
-        if (datumLine1 && datumLine2) {
-            FC_LOG("Assembly : getDistanceType('" << joint->getFullName()
-                   << "') — datumLine+datumLine → LineLine");
-            return DistanceType::LineLine;
-        }
-        if (datumPoint1 && datumPoint2) {
-            FC_LOG("Assembly : getDistanceType('" << joint->getFullName()
-                   << "') — datumPoint+datumPoint → PointPoint");
-            return DistanceType::PointPoint;
-        }
-        if ((datumLine1 && datumPoint2) || (datumPoint1 && datumLine2)) {
-            if (datumPoint1) {
-                swapJCS(joint);  // line first
-            }
-            FC_LOG("Assembly : getDistanceType('" << joint->getFullName()
-                   << "') — datumLine+datumPoint → PointLine");
-            return DistanceType::PointLine;
-        }
-
-        // One datum line/point + one real element type.
-        if (datumLine1 || datumLine2) {
-            const auto& otherSyn = datumLine1 ? syn2 : syn1;
-            if (otherSyn == "Face") {
-                // Line + Face — need line on Reference2 (edge side).
-                if (datumLine1) {
-                    swapJCS(joint);
-                }
-                // We don't know the face type without inspecting the shape,
-                // but LinePlane is the most common and safest classification.
-                FC_LOG("Assembly : getDistanceType('" << joint->getFullName()
-                       << "') — datumLine+Face → LinePlane");
-                return DistanceType::LinePlane;
-            }
-            if (otherSyn == "Vertex") {
-                if (datumLine2) {
-                    swapJCS(joint);  // line first
-                }
-                FC_LOG("Assembly : getDistanceType('" << joint->getFullName()
-                       << "') — datumLine+Vertex → PointLine");
-                return DistanceType::PointLine;
-            }
-            if (otherSyn == "Edge") {
-                FC_LOG("Assembly : getDistanceType('" << joint->getFullName()
-                       << "') — datumLine+Edge → LineLine");
-                return DistanceType::LineLine;
-            }
-        }
-        if (datumPoint1 || datumPoint2) {
-            const auto& otherSyn = datumPoint1 ? syn2 : syn1;
-            if (otherSyn == "Face") {
-                // Point + Face — face first, point second.
-                if (!datumPoint2) {
-                    swapJCS(joint);  // put face on Ref1
-                }
-                FC_LOG("Assembly : getDistanceType('" << joint->getFullName()
-                       << "') — datumPoint+Face → PointPlane");
-                return DistanceType::PointPlane;
-            }
-            if (otherSyn == "Edge") {
-                // Edge first, point second.
-                if (datumPoint1) {
-                    swapJCS(joint);
-                }
-                FC_LOG("Assembly : getDistanceType('" << joint->getFullName()
-                       << "') — datumPoint+Edge → PointLine");
-                return DistanceType::PointLine;
-            }
-            if (otherSyn == "Vertex") {
-                FC_LOG("Assembly : getDistanceType('" << joint->getFullName()
-                       << "') — datumPoint+Vertex → PointPoint");
-                return DistanceType::PointPoint;
-            }
-        }
-
-        // If we get here, it's an unrecognized datum combination.
-        FC_WARN("Assembly : getDistanceType('" << joint->getFullName()
-                << "') — unrecognized datum combination (syn1="
-                << syn1 << ", syn2=" << syn2 << ")");
-    }
-
    if (type1 == "Vertex" && type2 == "Vertex") {
        return DistanceType::PointPoint;
    }
--- a/src/Mod/Assembly/App/AssemblyUtils.h
+++ b/src/Mod/Assembly/App/AssemblyUtils.h
@@ -148,7 +148,6 @@ 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);
--- a/src/Mod/Assembly/AssemblyTests/TestAssemblyOriginPlanes.py
+++ b/src/Mod/Assembly/AssemblyTests/TestAssemblyOriginPlanes.py
@@ -191,90 +191,6 @@ class TestAssemblyOriginPlanes(unittest.TestCase):
        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):
--- a/src/Mod/Assembly/AssemblyTests/TestDatumClassification.py
+++ b/src/Mod/Assembly/AssemblyTests/TestDatumClassification.py
@@ -1,266 +0,0 @@
-# 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 datum plane classification in Distance joints.
-
-Verifies that getDistanceType correctly classifies joints involving datum
-planes from all three class hierarchies:
-  1. App::Plane          — origin planes (XY, XZ, YZ)
-  2. PartDesign::Plane   — datum planes inside a PartDesign body
-  3. Part::Plane         — Part workbench plane primitives (bare reference)
-"""
-
-import unittest
-
-import FreeCAD as App
-import JointObject
-
-
-class TestDatumClassification(unittest.TestCase):
-    """Tests that Distance joints with datum plane references are
-    classified as PlanePlane (not Other) regardless of the datum
-    object's class hierarchy."""
-
-    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 _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
-
-    def _make_pd_body_with_datum_plane(self, name="Body"):
-        """Create a PartDesign::Body with a datum plane inside the assembly."""
-        body = self.assembly.newObject("PartDesign::Body", name)
-        datum = body.newObject("PartDesign::Plane", "DatumPlane")
-        self.doc.recompute()
-        return body, datum
-
-    def _make_part_plane(self, name="PartPlane"):
-        """Create a Part::Plane primitive inside the assembly."""
-        plane = self.assembly.newObject("Part::Plane", name)
-        plane.Length = 10
-        plane.Width = 10
-        self.doc.recompute()
-        return plane
-
-    # ── Origin plane tests (App::Plane — existing behaviour) ───────
-
-    def test_origin_plane_face_classified_as_plane_plane(self):
-        """Distance joint: box Face → origin datum plane → PlanePlane."""
-        origin = self.assembly.Origin
-        xy = origin.getXY()
-        box = self._make_box(0, 0, 50)
-
-        joint = self._make_joint(
-            5,  # Distance
-            [box, ["Face1", "Vertex1"]],
-            [origin, [xy.Name + ".", xy.Name + "."]],
-        )
-        joint.Distance = 0.0
-
-        result = self.assembly.solve()
-        self.assertEqual(
-            result,
-            0,
-            "Distance joint with origin plane should solve (not produce Other)",
-        )
-
-    # ── PartDesign::Plane tests ────────────────────────────────────
-
-    def test_pd_datum_plane_face_classified_as_plane_plane(self):
-        """Distance joint: box Face → PartDesign::Plane → PlanePlane."""
-        body, datum = self._make_pd_body_with_datum_plane()
-        box = self._make_box(0, 0, 50)
-
-        # Ground the body so the solver has a fixed reference.
-        gnd = self.jointgroup.newObject("App::FeaturePython", "GroundedJoint")
-        JointObject.GroundedJoint(gnd, body)
-
-        # Reference the datum plane with a bare sub-name (ends with ".").
-        joint = self._make_joint(
-            5,  # Distance
-            [box, ["Face1", "Vertex1"]],
-            [body, [datum.Name + ".", datum.Name + "."]],
-        )
-        joint.Distance = 0.0
-
-        result = self.assembly.solve()
-        self.assertNotEqual(
-            result,
-            -1,
-            "Distance joint with PartDesign::Plane should not fail to solve "
-            "(DistanceType should be PlanePlane, not Other)",
-        )
-
-    def test_pd_datum_plane_vertex_classified_as_point_plane(self):
-        """Distance joint: box Vertex → PartDesign::Plane → PointPlane."""
-        body, datum = self._make_pd_body_with_datum_plane()
-        box = self._make_box(0, 0, 50)
-
-        gnd = self.jointgroup.newObject("App::FeaturePython", "GroundedJoint")
-        JointObject.GroundedJoint(gnd, body)
-
-        joint = self._make_joint(
-            5,  # Distance
-            [box, ["Vertex1", "Vertex1"]],
-            [body, [datum.Name + ".", datum.Name + "."]],
-        )
-        joint.Distance = 0.0
-
-        result = self.assembly.solve()
-        self.assertNotEqual(
-            result,
-            -1,
-            "Distance joint vertex → PartDesign::Plane should not fail "
-            "(DistanceType should be PointPlane, not Other)",
-        )
-
-    def test_two_pd_datum_planes_classified_as_plane_plane(self):
-        """Distance joint: PartDesign::Plane → PartDesign::Plane → PlanePlane."""
-        body1, datum1 = self._make_pd_body_with_datum_plane("Body1")
-        body2, datum2 = self._make_pd_body_with_datum_plane("Body2")
-
-        gnd = self.jointgroup.newObject("App::FeaturePython", "GroundedJoint")
-        JointObject.GroundedJoint(gnd, body1)
-
-        joint = self._make_joint(
-            5,  # Distance
-            [body1, [datum1.Name + ".", datum1.Name + "."]],
-            [body2, [datum2.Name + ".", datum2.Name + "."]],
-        )
-        joint.Distance = 0.0
-
-        result = self.assembly.solve()
-        self.assertNotEqual(
-            result,
-            -1,
-            "Distance joint PartDesign::Plane → PartDesign::Plane should not fail "
-            "(DistanceType should be PlanePlane, not Other)",
-        )
-
-    # ── Part::Plane tests (primitive, bare reference) ──────────────
-
-    def test_part_plane_bare_ref_face_classified_as_plane_plane(self):
-        """Distance joint: box Face → Part::Plane (bare ref) → PlanePlane."""
-        plane = self._make_part_plane()
-        box = self._make_box(0, 0, 50)
-
-        gnd = self.jointgroup.newObject("App::FeaturePython", "GroundedJoint")
-        JointObject.GroundedJoint(gnd, plane)
-
-        # Bare reference to Part::Plane (sub-name ends with ".").
-        joint = self._make_joint(
-            5,  # Distance
-            [box, ["Face1", "Vertex1"]],
-            [plane, [".", "."]],
-        )
-        joint.Distance = 0.0
-
-        result = self.assembly.solve()
-        self.assertNotEqual(
-            result,
-            -1,
-            "Distance joint with Part::Plane (bare ref) should not fail "
-            "(DistanceType should be PlanePlane, not Other)",
-        )
-
-    def test_part_plane_with_face1_classified_as_plane_plane(self):
-        """Distance joint: box Face → Part::Plane Face1 → PlanePlane.
-
-        When Part::Plane is referenced with an explicit Face1 element,
-        it should enter the normal Face+Face classification path."""
-        plane = self._make_part_plane()
-        box = self._make_box(0, 0, 50)
-
-        gnd = self.jointgroup.newObject("App::FeaturePython", "GroundedJoint")
-        JointObject.GroundedJoint(gnd, plane)
-
-        joint = self._make_joint(
-            5,  # Distance
-            [box, ["Face1", "Vertex1"]],
-            [plane, ["Face1", "Vertex1"]],
-        )
-        joint.Distance = 0.0
-
-        result = self.assembly.solve()
-        self.assertNotEqual(
-            result,
-            -1,
-            "Distance joint with Part::Plane Face1 should solve normally",
-        )
-
-    # ── Cross-hierarchy tests ──────────────────────────────────────
-
-    def test_origin_plane_and_pd_datum_classified_as_plane_plane(self):
-        """Distance joint: origin App::Plane → PartDesign::Plane → PlanePlane."""
-        origin = self.assembly.Origin
-        xy = origin.getXY()
-        body, datum = self._make_pd_body_with_datum_plane()
-
-        gnd = self.jointgroup.newObject("App::FeaturePython", "GroundedJoint")
-        JointObject.GroundedJoint(gnd, body)
-
-        joint = self._make_joint(
-            5,  # Distance
-            [origin, [xy.Name + ".", xy.Name + "."]],
-            [body, [datum.Name + ".", datum.Name + "."]],
-        )
-        joint.Distance = 0.0
-
-        result = self.assembly.solve()
-        self.assertNotEqual(
-            result,
-            -1,
-            "Distance joint origin plane → PartDesign::Plane should not fail "
-            "(DistanceType should be PlanePlane, not Other)",
-        )
--- a/src/Mod/Assembly/CMakeLists.txt
+++ b/src/Mod/Assembly/CMakeLists.txt
@@ -61,7 +61,6 @@ SET(AssemblyTests_SRCS
    AssemblyTests/TestKindredSolverIntegration.py
    AssemblyTests/TestKCSolvePy.py
    AssemblyTests/TestAssemblyOriginPlanes.py
-    AssemblyTests/TestDatumClassification.py
    AssemblyTests/mocks/__init__.py
    AssemblyTests/mocks/MockGui.py
 )
--- a/src/Mod/Create/CMakeLists.txt
+++ b/src/Mod/Create/CMakeLists.txt
@@ -85,22 +85,6 @@ install(
        mods/sdk
 )

-# Install QuickNav addon
-install(
-    DIRECTORY
-        ${CMAKE_SOURCE_DIR}/mods/quicknav/quicknav
-    DESTINATION
-        mods/quicknav
-)
-install(
-    FILES
-        ${CMAKE_SOURCE_DIR}/mods/quicknav/package.xml
-        ${CMAKE_SOURCE_DIR}/mods/quicknav/Init.py
-        ${CMAKE_SOURCE_DIR}/mods/quicknav/InitGui.py
-    DESTINATION
-        mods/quicknav
-)
-
 # Install Kindred Solver addon
 install(
    DIRECTORY
--- a/src/Mod/Create/kc_format.py
+++ b/src/Mod/Create/kc_format.py
@@ -162,28 +162,34 @@ 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())
-                for name, data in entries.items():
-                    if name not in existing:
-                        zf.writestr(name, data)
-                        existing.add(name)
+                # 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",
+                        )
        except Exception as e:
            FreeCAD.Console.PrintWarning(
                f"kc_format: failed to update .kc silo/ entries: {e}\n"
@@ -203,36 +209,17 @@ def update_manifest_fields(filename, updates):
        return
    if not os.path.isfile(filename):
        return
-    import shutil
-    import tempfile
-
    try:
-        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
+        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",
+            )
    except Exception as e:
        FreeCAD.Console.PrintWarning(f"kc_format: failed to update manifest: {e}\n")

--- a/tests/test_kindred_pure.py
+++ b/tests/test_kindred_pure.py
@@ -101,7 +101,6 @@ sys.path.insert(0, str(_REPO_ROOT / "src" / "Mod" / "Create"))
 sys.path.insert(0, str(_REPO_ROOT / "mods" / "sdk"))
 sys.path.insert(0, str(_REPO_ROOT / "mods" / "ztools" / "ztools"))
 sys.path.insert(0, str(_REPO_ROOT / "mods" / "silo" / "freecad"))
-sys.path.insert(0, str(_REPO_ROOT / "mods" / "quicknav"))

 # ---------------------------------------------------------------------------
 # Now import the modules under test
@@ -124,15 +123,6 @@ from silo_commands import _safe_float  # noqa: E402
 import silo_start  # noqa: E402
 import silo_origin  # noqa: E402

-from quicknav.workbench_map import (  # noqa: E402
-    WORKBENCH_SLOTS,
-    WORKBENCH_GROUPINGS,
-    get_workbench_slot,
-    get_groupings,
-    get_grouping,
-    get_command,
-)
-

 # ===================================================================
 # Test: update_checker._parse_version
@@ -564,110 +554,6 @@ class TestDatumModes(unittest.TestCase):
        self.assertEqual(len(points), 5)


-# ===================================================================
-# Test: quicknav workbench_map
-# ===================================================================
-
-
-class TestWorkbenchMap(unittest.TestCase):
-    """Tests for quicknav.workbench_map data and helpers."""
-
-    def test_all_slots_defined(self):
-        for n in range(1, 6):
-            slot = WORKBENCH_SLOTS.get(n)
-            self.assertIsNotNone(slot, f"Slot {n} missing from WORKBENCH_SLOTS")
-
-    def test_slot_keys(self):
-        for n, slot in WORKBENCH_SLOTS.items():
-            self.assertIn("key", slot)
-            self.assertIn("class_name", slot)
-            self.assertIn("display", slot)
-            self.assertIsInstance(slot["key"], str)
-            self.assertIsInstance(slot["class_name"], str)
-            self.assertIsInstance(slot["display"], str)
-
-    def test_each_slot_has_groupings(self):
-        for n, slot in WORKBENCH_SLOTS.items():
-            groupings = WORKBENCH_GROUPINGS.get(slot["key"])
-            self.assertIsNotNone(groupings, f"No groupings for workbench key '{slot['key']}'")
-            self.assertGreater(len(groupings), 0, f"Empty groupings for slot {n}")
-
-    def test_max_nine_groupings_per_workbench(self):
-        for wb_key, groupings in WORKBENCH_GROUPINGS.items():
-            self.assertLessEqual(len(groupings), 9, f"More than 9 groupings for '{wb_key}'")
-
-    def test_max_nine_commands_per_grouping(self):
-        for wb_key, groupings in WORKBENCH_GROUPINGS.items():
-            for i, grp in enumerate(groupings):
-                self.assertLessEqual(
-                    len(grp["commands"]),
-                    9,
-                    f"More than 9 commands in '{wb_key}' grouping {i}",
-                )
-
-    def test_command_tuples_are_str_str(self):
-        for wb_key, groupings in WORKBENCH_GROUPINGS.items():
-            for i, grp in enumerate(groupings):
-                self.assertIn("name", grp)
-                self.assertIn("commands", grp)
-                for j, cmd in enumerate(grp["commands"]):
-                    self.assertIsInstance(cmd, tuple, f"{wb_key}[{i}][{j}] not tuple")
-                    self.assertEqual(len(cmd), 2, f"{wb_key}[{i}][{j}] not length 2")
-                    self.assertIsInstance(cmd[0], str, f"{wb_key}[{i}][{j}][0] not str")
-                    self.assertIsInstance(cmd[1], str, f"{wb_key}[{i}][{j}][1] not str")
-
-    def test_get_workbench_slot_valid(self):
-        for n in range(1, 6):
-            slot = get_workbench_slot(n)
-            self.assertIsNotNone(slot)
-            self.assertEqual(slot, WORKBENCH_SLOTS[n])
-
-    def test_get_workbench_slot_invalid(self):
-        self.assertIsNone(get_workbench_slot(0))
-        self.assertIsNone(get_workbench_slot(6))
-        self.assertIsNone(get_workbench_slot(99))
-
-    def test_get_groupings_valid(self):
-        for slot in WORKBENCH_SLOTS.values():
-            result = get_groupings(slot["key"])
-            self.assertIsNotNone(result)
-            self.assertIsInstance(result, list)
-
-    def test_get_groupings_invalid(self):
-        self.assertEqual(get_groupings("nonexistent"), [])
-
-    def test_get_grouping_valid(self):
-        for wb_key, groupings in WORKBENCH_GROUPINGS.items():
-            for i in range(len(groupings)):
-                grp = get_grouping(wb_key, i)
-                self.assertIsNotNone(grp)
-                self.assertEqual(grp, groupings[i])
-
-    def test_get_grouping_invalid_index(self):
-        wb_key = WORKBENCH_SLOTS[1]["key"]
-        self.assertIsNone(get_grouping(wb_key, 99))
-        self.assertIsNone(get_grouping(wb_key, -1))
-
-    def test_get_grouping_invalid_key(self):
-        self.assertIsNone(get_grouping("nonexistent", 0))
-
-    def test_get_command_valid(self):
-        for wb_key, groupings in WORKBENCH_GROUPINGS.items():
-            for gi, grp in enumerate(groupings):
-                for ci in range(len(grp["commands"])):
-                    cmd_id = get_command(wb_key, gi, ci + 1)
-                    self.assertIsNotNone(cmd_id, f"None for {wb_key}[{gi}][{ci + 1}]")
-                    self.assertEqual(cmd_id, grp["commands"][ci][0])
-
-    def test_get_command_invalid_number(self):
-        wb_key = WORKBENCH_SLOTS[1]["key"]
-        self.assertIsNone(get_command(wb_key, 0, 0))
-        self.assertIsNone(get_command(wb_key, 0, 99))
-
-    def test_get_command_invalid_workbench(self):
-        self.assertIsNone(get_command("nonexistent", 0, 1))
-
-
 # ===================================================================