docs: add CNC slicer/preview implementation plan

8-task TDD plan covering CAM engine, CAM agent config, orchestrator
integration, G-code API endpoint, frontend G-code parser, 3D toolpath
renderer with Part/Toolpath/Overlay view toggle, and G-code download.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

docs/superpowers/plans/2026-04-11-cnc-slicer-preview.md

@@ -0,0 +1,1110 @@
+# CNC Slicer, Preview & CAM Agent Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Add CNC toolpath generation (G-code), 3D toolpath preview in the Three.js viewport, and a CAM agent to orchestrate the process.
+
+**Architecture:** Extends the existing pipeline after CadQuery execution. A new `core/cam.py` wraps `ocp-freecad-cam` to generate G-code from CadQuery shapes. A new CAM agent selects operations/tools. The frontend parses G-code and renders 3D toolpath lines alongside the existing STL view.
+
+**Tech Stack:** ocp-freecad-cam (Python, wraps FreeCAD Path workbench), vanilla JavaScript G-code parser, Three.js LineSegments for toolpath rendering.
+
+---
+
+## File Structure
+
+| File | Action | Responsibility |
+|------|--------|---------------|
+| `core/cam.py` | Create | CAM engine: `generate_gcode()`, `CAMResult` dataclass, `CAMResultSerializer` |
+| `config.yaml` | Modify | Add `cam` agent definition, `cam:` config section, `cam` routing keywords |
+| `agents/definitions.py` | No change | Auto-loads new `cam` agent from config.yaml |
+| `agents/routing.py` | No change | Auto-loads new `cam` keywords from config.yaml |
+| `agents/prompts.py` | Modify | Add CAM agent to orchestrator system prompt, add CAM trigger keywords |
+| `agents/orchestrator.py` | Modify | Call `generate_gcode()` after CAD execution when CAM agent is active |
+| `server/web.py` | Modify | Add `GET /api/models/{name}.gcode` endpoint |
+| `web/index.html` | Modify | Add G-code parser, toolpath renderer, view toggle buttons, G-code download |
+| `tests/test_cam.py` | Create | Tests for CAMResult, generate_gcode, serializer |
+| `tests/test_cam_routing.py` | Create | Tests for CAM keyword routing |
+
+---
+
+### Task 1: CAM Engine — CAMResult and Serializer
+
+**Files:**
+- Create: `core/cam.py`
+- Create: `tests/test_cam.py`
+
+- [ ] **Step 1: Write the failing test for CAMResult dataclass**
+
+```python
+# tests/test_cam.py
+"""Tests for core/cam.py — CAM engine."""
+
+from core.cam import CAMResult, CAMResultSerializer
+
+
+class TestCAMResult:
+    def test_success_result(self):
+        r = CAMResult(
+            success=True,
+            gcode="G21 G90\nG00 X0 Y0 Z10\nM30",
+            operations=["pocket", "profile"],
+            tool_config={"diameter": 6, "h_feed": 800},
+            post_processor="grbl",
+            error=None,
+        )
+        assert r.success is True
+        assert "G21" in r.gcode
+        assert r.operations == ["pocket", "profile"]
+        assert r.error is None
+
+    def test_failure_result(self):
+        r = CAMResult(
+            success=False,
+            gcode=None,
+            operations=[],
+            tool_config={},
+            post_processor="grbl",
+            error="ocp-freecad-cam not available",
+        )
+        assert r.success is False
+        assert r.gcode is None
+        assert r.error == "ocp-freecad-cam not available"
+
+
+class TestCAMResultSerializer:
+    def test_to_dict_success(self):
+        r = CAMResult(
+            success=True,
+            gcode="G21 G90\nM30",
+            operations=["pocket"],
+            tool_config={"diameter": 6},
+            post_processor="grbl",
+            error=None,
+        )
+        d = CAMResultSerializer.to_dict(r)
+        assert d["success"] is True
+        assert d["gcode"] == "G21 G90\nM30"
+        assert d["operations"] == ["pocket"]
+        assert d["tool_config"] == {"diameter": 6}
+        assert d["post_processor"] == "grbl"
+        assert d["error"] is None
+
+    def test_to_dict_failure(self):
+        r = CAMResult(
+            success=False, gcode=None, operations=[], tool_config={},
+            post_processor="grbl", error="failed",
+        )
+        d = CAMResultSerializer.to_dict(r)
+        assert d["success"] is False
+        assert d["gcode"] is None
+        assert d["error"] == "failed"
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `cd /home/daniel/NeuralCAD && python -m pytest tests/test_cam.py -v`
+Expected: FAIL with `ModuleNotFoundError: No module named 'core.cam'`
+
+- [ ] **Step 3: Write the CAMResult dataclass and serializer**
+
+```python
+# core/cam.py
+"""CAM engine — generates CNC toolpaths and G-code from CadQuery shapes.
+
+Wraps ocp-freecad-cam to convert cq.Workplane objects into G-code strings.
+Falls back gracefully when ocp-freecad-cam or FreeCAD is not installed.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class CAMResult:
+    """Result of G-code generation from a CadQuery shape."""
+    success: bool
+    gcode: str | None
+    operations: list[str]
+    tool_config: dict
+    post_processor: str
+    error: str | None = None
+
+
+class CAMResultSerializer:
+    """Serialize CAMResult to JSON-ready dict."""
+
+    @staticmethod
+    def to_dict(result: CAMResult) -> dict:
+        return {
+            "success": result.success,
+            "gcode": result.gcode,
+            "operations": result.operations,
+            "tool_config": result.tool_config,
+            "post_processor": result.post_processor,
+            "error": result.error,
+        }
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `cd /home/daniel/NeuralCAD && python -m pytest tests/test_cam.py -v`
+Expected: All 4 tests PASS
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add core/cam.py tests/test_cam.py
+git commit -m "feat(cam): add CAMResult dataclass and serializer"
+```
+
+---
+
+### Task 2: CAM Engine — generate_gcode function
+
+**Files:**
+- Modify: `core/cam.py`
+- Modify: `tests/test_cam.py`
+
+- [ ] **Step 1: Write the failing test for generate_gcode**
+
+Append to `tests/test_cam.py`:
+
+```python
+from unittest.mock import patch, MagicMock
+from core.cam import generate_gcode
+
+
+class TestGenerateGcode:
+    def test_returns_failure_when_ocp_not_available(self):
+        """When ocp-freecad-cam is not installed, return a failure CAMResult."""
+        # The import of ocp_freecad_cam will fail in test environment
+        mock_shape = MagicMock()
+        result = generate_gcode(
+            shape=mock_shape,
+            operations=["pocket"],
+            tool_config={"diameter": 6, "h_feed": 800, "v_feed": 200, "speed": 18000},
+            post_processor="grbl",
+        )
+        assert result.success is False
+        assert "not available" in result.error.lower() or "not installed" in result.error.lower()
+
+    def test_returns_failure_on_empty_operations(self):
+        mock_shape = MagicMock()
+        result = generate_gcode(
+            shape=mock_shape,
+            operations=[],
+        )
+        assert result.success is False
+        assert "no operations" in result.error.lower()
+
+    def test_uses_default_tool_config_when_none(self):
+        mock_shape = MagicMock()
+        result = generate_gcode(
+            shape=mock_shape,
+            operations=["pocket"],
+            tool_config=None,
+        )
+        # Should still return a result (failure due to no ocp, but tool_config populated)
+        assert result.tool_config is not None
+        assert "diameter" in result.tool_config
+
+    def test_uses_default_post_processor(self):
+        mock_shape = MagicMock()
+        result = generate_gcode(shape=mock_shape, operations=["pocket"])
+        assert result.post_processor == "grbl"
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `cd /home/daniel/NeuralCAD && python -m pytest tests/test_cam.py::TestGenerateGcode -v`
+Expected: FAIL with `ImportError: cannot import name 'generate_gcode'`
+
+- [ ] **Step 3: Write the generate_gcode function**
+
+Add to `core/cam.py` after the existing code:
+
+```python
+from config.settings import settings
+
+
+def _get_default_tool_config() -> dict:
+    """Load default roughing tool config from config.yaml cam section."""
+    cam_cfg = getattr(settings, "cam", None)
+    if cam_cfg and isinstance(cam_cfg, dict):
+        tools = cam_cfg.get("tools", {})
+        roughing = tools.get("roughing", {})
+        if roughing:
+            return dict(roughing)
+    return {"diameter": 6, "h_feed": 800, "v_feed": 200, "speed": 18000}
+
+
+def _get_default_post_processor() -> str:
+    """Load default post-processor from config.yaml cam section."""
+    cam_cfg = getattr(settings, "cam", None)
+    if cam_cfg and isinstance(cam_cfg, dict):
+        return cam_cfg.get("default_post_processor", "grbl")
+    return "grbl"
+
+
+def _get_stock_offset() -> float:
+    """Load stock offset from config.yaml cam section."""
+    cam_cfg = getattr(settings, "cam", None)
+    if cam_cfg and isinstance(cam_cfg, dict):
+        return cam_cfg.get("stock_offset_mm", 2.0)
+    return 2.0
+
+
+def generate_gcode(
+    shape,
+    operations: list[str],
+    tool_config: dict | None = None,
+    post_processor: str | None = None,
+    stock_offset_mm: float | None = None,
+) -> CAMResult:
+    """Generate G-code from a CadQuery Workplane shape.
+
+    Args:
+        shape: A cq.Workplane object from the executor.
+        operations: List of operation names: "adaptive", "pocket", "profile",
+                    "face", "drill", "surface", "waterline".
+        tool_config: Dict with diameter, h_feed, v_feed, speed. Uses config defaults if None.
+        post_processor: Post-processor name (e.g. "grbl", "linuxcnc"). Uses config default if None.
+        stock_offset_mm: Stock offset from bounding box in mm. Uses config default if None.
+
+    Returns:
+        CAMResult with success status and G-code string.
+    """
+    if tool_config is None:
+        tool_config = _get_default_tool_config()
+    if post_processor is None:
+        post_processor = _get_default_post_processor()
+    if stock_offset_mm is None:
+        stock_offset_mm = _get_stock_offset()
+
+    if not operations:
+        return CAMResult(
+            success=False, gcode=None, operations=[], tool_config=tool_config,
+            post_processor=post_processor, error="No operations specified",
+        )
+
+    try:
+        from ocp_freecad_cam import Job, Endmill, Drill, Ballnose
+        from ocp_freecad_cam.fc_impl import Stock
+    except ImportError:
+        return CAMResult(
+            success=False, gcode=None, operations=operations,
+            tool_config=tool_config, post_processor=post_processor,
+            error="ocp-freecad-cam is not installed. Install it with: pip install ocp-freecad-cam (requires FreeCAD >= 1.0.1)",
+        )
+
+    try:
+        # Build tool from config
+        tool = Endmill(
+            diameter=tool_config.get("diameter", 6),
+            h_feed=tool_config.get("h_feed", 800),
+            v_feed=tool_config.get("v_feed", 200),
+            speed=tool_config.get("speed", 18000),
+        )
+
+        # Set up stock with offset from bounding box
+        so = stock_offset_mm
+        stock = Stock(xn=so, xp=so, yn=so, yp=so, zn=0, zp=so)
+
+        # Get top face as work plane
+        top = shape.faces(">Z").workplane()
+
+        # Create job
+        job = Job(top, shape, post_processor, stock=stock)
+
+        # Apply operations in order
+        for op in operations:
+            job = _apply_operation(job, shape, tool, op)
+
+        gcode = job.to_gcode()
+
+        return CAMResult(
+            success=True, gcode=gcode, operations=operations,
+            tool_config=tool_config, post_processor=post_processor,
+        )
+
+    except Exception as exc:
+        return CAMResult(
+            success=False, gcode=None, operations=operations,
+            tool_config=tool_config, post_processor=post_processor,
+            error=f"G-code generation failed: {exc}",
+        )
+
+
+def _apply_operation(job, shape, tool, operation: str):
+    """Apply a single CAM operation to the job. Returns the updated job."""
+    op = operation.lower().strip()
+
+    if op == "adaptive":
+        # Adaptive clearing on recessed faces or full model
+        try:
+            faces = shape.faces(">Z[1]")
+            return job.adaptive(faces, tool, step_over=40, stock_to_leave="0.2 mm")
+        except Exception:
+            return job.adaptive(shape.faces(">Z"), tool, step_over=40)
+
+    elif op == "pocket":
+        try:
+            faces = shape.faces(">Z[1]")
+            return job.pocket(faces, tool, pattern="offset")
+        except Exception:
+            return job.pocket(shape.faces(">Z"), tool, pattern="zigzag")
+
+    elif op == "profile":
+        return job.profile(shape.faces("<Z"), tool, side="out")
+
+    elif op == "face":
+        return job.face(shape.faces(">Z"), tool)
+
+    elif op == "drill":
+        try:
+            from ocp_freecad_cam import Drill as DrillTool
+            drill = DrillTool(
+                diameter=tool._diameter if hasattr(tool, '_diameter') else 5,
+                h_feed=100, v_feed=50, speed=8000,
+            )
+            # Find circular holes on bottom face
+            holes = shape.faces("<Z")
+            return job.drill(holes, drill, peck_depth=2.0)
+        except Exception:
+            return job  # Skip drill if no holes found
+
+    elif op == "surface":
+        return job.surface(None, tool, cut_pattern="zigzag")
+
+    elif op == "waterline":
+        return job.waterline(None, tool)
+
+    else:
+        return job  # Unknown operation, skip
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `cd /home/daniel/NeuralCAD && python -m pytest tests/test_cam.py -v`
+Expected: All 8 tests PASS
+
+- [ ] **Step 5: Run all existing tests to verify no regressions**
+
+Run: `cd /home/daniel/NeuralCAD && python -m pytest --tb=short -q`
+Expected: All existing tests still pass
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add core/cam.py tests/test_cam.py
+git commit -m "feat(cam): add generate_gcode function with ocp-freecad-cam wrapper"
+```
+
+---
+
+### Task 3: Config — CAM agent and cam section
+
+**Files:**
+- Modify: `config.yaml`
+- Create: `tests/test_cam_routing.py`
+
+- [ ] **Step 1: Write the failing test for CAM routing keywords**
+
+```python
+# tests/test_cam_routing.py
+"""Tests for CAM agent routing keywords loaded from config."""
+
+from agents.routing import RoutingEngine
+
+
+class TestCAMRouting:
+    def setup_method(self):
+        self.engine = RoutingEngine()
+
+    def test_cam_keywords_loaded(self):
+        assert "cam" in self.engine.keywords
+
+    def test_route_cam_keywords_toolpath(self):
+        agents = self.engine.route("Generate a toolpath for this part")
+        assert "cam" in agents
+
+    def test_route_cam_keywords_gcode(self):
+        agents = self.engine.route("Create gcode for CNC milling")
+        assert "cam" in agents
+
+    def test_route_cam_keywords_slicer(self):
+        agents = self.engine.route("Run the slicer on this model")
+        assert "cam" in agents
+
+    def test_cam_agent_exists_in_definitions(self):
+        from agents.definitions import AGENTS
+        assert "cam" in AGENTS
+
+    def test_cam_agent_has_color(self):
+        from agents.definitions import AGENT_COLORS
+        assert "cam" in AGENT_COLORS
+
+    def test_cam_agent_has_name(self):
+        from agents.definitions import AGENT_NAMES
+        assert AGENT_NAMES["cam"] == "CAM Agent"
+
+    def test_parse_mentions_cam(self):
+        cleaned, mentions = self.engine.parse_mentions("@cam generate toolpath")
+        assert "cam" in mentions
+        assert "@cam" not in cleaned
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `cd /home/daniel/NeuralCAD && python -m pytest tests/test_cam_routing.py -v`
+Expected: FAIL with `KeyError: 'cam'` or `AssertionError`
+
+- [ ] **Step 3: Add CAM agent and cam config section to config.yaml**
+
+Add after the existing `cad` agent block in `config.yaml` (around line 115):
+
+```yaml
+  cam:
+    name: CAM Agent
+    role: CAM Programmer
+    color: "#ff6b35"
+    avatar: CM
+    goal: >
+      Analyze generated 3D geometry and create optimal CNC machining
+      strategies including operation sequencing, tool selection, and
+      cutting parameters.
+    backstory: >
+      You are an expert CAM programmer who converts 3D CAD models into
+      efficient CNC machining programs. Given a part geometry and
+      material, you determine the optimal sequence of operations
+      (roughing then finishing), select appropriate tools, and specify
+      feeds and speeds. Output your machining plan as a structured JSON
+      with an "operations" array (values: adaptive, pocket, profile,
+      face, drill, surface, waterline), "tool" object with diameter,
+      h_feed, v_feed, speed fields, and "post_processor" string.
+      Always plan roughing before finishing. Consider tool access,
+      pocket depth ratios, and surface finish requirements.
+```
+
+Add after the `export:` section (around line 42):
+
+```yaml
+cam:
+  default_post_processor: grbl
+  stock_offset_mm: 2.0
+  default_step_over_percent: 40
+  tools:
+    roughing:
+      diameter: 6
+      h_feed: 800
+      v_feed: 200
+      speed: 18000
+    finishing:
+      diameter: 3
+      h_feed: 400
+      v_feed: 100
+      speed: 24000
+    drilling:
+      diameter: 5
+      h_feed: 100
+      v_feed: 50
+      speed: 8000
+  post_processors:
+    - grbl
+    - linuxcnc
+    - fanuc
+    - mach3_mach4
+```
+
+Add `cam` to routing keywords section (after the `cnc:` keywords block):
+
+```yaml
+    cam:
+      - toolpath
+      - gcode
+      - g-code
+      - cam
+      - slicer
+      - slice
+      - machine program
+      - feeds and speeds
+      - post-processor
+      - roughing
+      - finishing
+      - operations
+```
+
+- [ ] **Step 4: Reload and run test to verify it passes**
+
+Run: `cd /home/daniel/NeuralCAD && python -m pytest tests/test_cam_routing.py -v`
+Expected: All 8 tests PASS
+
+- [ ] **Step 5: Run all existing tests to verify no regressions**
+
+Run: `cd /home/daniel/NeuralCAD && python -m pytest --tb=short -q`
+Expected: All tests pass (definitions.py and routing.py auto-load from config)
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add config.yaml tests/test_cam_routing.py
+git commit -m "feat(cam): add CAM agent definition and cam config section"
+```
+
+---
+
+### Task 4: Orchestrator — CAM integration after CAD execution
+
+**Files:**
+- Modify: `agents/prompts.py`
+- Modify: `agents/orchestrator.py`
+
+- [ ] **Step 1: Add CAM trigger keywords to prompts.py**
+
+In `agents/prompts.py`, add after the `CAD_TRIGGER_KEYWORDS` list (line 17):
+
+```python
+CAM_TRIGGER_KEYWORDS: list[str] = [
+    "toolpath", "gcode", "g-code", "cam", "slicer", "slice",
+    "machine program", "operations", "roughing", "finishing",
+]
+```
+
+In `build_orchestrator_system_prompt()`, update the agent list default (line 31) to include `cam` when relevant. Add after the existing CAD Coder instructions (around line 86):
+
+```python
+        f"- Include the CAM Agent when the user mentions toolpath, G-code, "
+        f"CAM, slicer, or machining operations. The CAM Agent must output "
+        f"a JSON plan with 'operations' (array of: adaptive, pocket, profile, "
+        f"face, drill, surface, waterline), 'tool' (object with diameter, "
+        f"h_feed, v_feed, speed), and 'post_processor' (string like 'grbl').\n"
+```
+
+- [ ] **Step 2: Add CAM step to _execute_cad_code in orchestrator.py**
+
+In `agents/orchestrator.py`, add import at the top (after line 10):
+
+```python
+from core.cam import generate_gcode, CAMResultSerializer
+```
+
+In the `_execute_cad_code` function, after the validation step (after line 130), add CAM generation. Modify the function to accept a `cam_plan` parameter and return CAM data in the preview dict.
+
+Replace the return block in `_execute_cad_code` (lines 122-130) with:
+
+```python
+    # CNC validation
+    validation = validate_for_cnc(exec_result.result, part_name=part_name)
+
+    preview_data = {
+        "success": True,
+        "part_name": part_name,
+        "stl_url": f"/api/models/{part_name}.stl",
+        "step_url": f"/api/models/{part_name}.step",
+        "execution": ExecutionResultSerializer.to_dict(exec_result),
+        "validation": ValidationResultSerializer.to_dict(validation),
+    }
+
+    # CAM: generate G-code if cam_plan is provided
+    if cam_plan and isinstance(cam_plan, dict):
+        cam_operations = cam_plan.get("operations", [])
+        cam_tool = cam_plan.get("tool", None)
+        cam_post = cam_plan.get("post_processor", None)
+        if cam_operations:
+            cam_result = generate_gcode(
+                shape=exec_result.result,
+                operations=cam_operations,
+                tool_config=cam_tool,
+                post_processor=cam_post,
+            )
+            preview_data["cam"] = CAMResultSerializer.to_dict(cam_result)
+            if cam_result.success and cam_result.gcode:
+                # Save G-code file
+                gcode_path = output_dir / f"{part_name}.gcode"
+                gcode_path.write_text(cam_result.gcode)
+                preview_data["gcode_url"] = f"/api/models/{part_name}.gcode"
+
+    return preview_data
+```
+
+Update the `_execute_cad_code` signature to accept `cam_plan`:
+
+```python
+def _execute_cad_code(
+    code: str,
+    prompt: str,
+    output_dir: Path,
+    backend: LLMBackend | None = None,
+    max_retries: int = 2,
+    cam_plan: dict | None = None,
+) -> dict | None:
+```
+
+- [ ] **Step 3: Parse CAM agent response in SingleCallOrchestrator**
+
+In `SingleCallOrchestrator.chat_turn()`, after the loop that formats responses (around line 352), add CAM plan extraction:
+
+```python
+            # If CAD Coder responded with code, execute it (with retry)
+            if agent_id == "cad" and resp.get("code"):
+                # Check if CAM agent also responded with a plan
+                cam_plan = None
+                for cam_resp in agent_responses:
+                    if cam_resp["id"] == "cam" and cam_resp.get("code"):
+                        try:
+                            import json
+                            cam_plan = json.loads(cam_resp["code"])
+                        except (json.JSONDecodeError, TypeError):
+                            pass
+                preview = _execute_cad_code(
+                    resp["code"], message, self.output_dir, backend=self.backend,
+                    cam_plan=cam_plan,
+                )
+```
+
+Do the same in `MockChatBackend.chat_turn()` (around line 198):
+
+```python
+            preview = _execute_cad_code(code, message, self.output_dir)
+```
+
+(Mock mode does not generate CAM plans, so `cam_plan` stays `None`.)
+
+- [ ] **Step 4: Run all tests**
+
+Run: `cd /home/daniel/NeuralCAD && python -m pytest --tb=short -q`
+Expected: All tests pass
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add agents/prompts.py agents/orchestrator.py
+git commit -m "feat(cam): integrate CAM generation into orchestrator pipeline"
+```
+
+---
+
+### Task 5: API — G-code download endpoint
+
+**Files:**
+- Modify: `server/web.py`
+
+- [ ] **Step 1: Add G-code endpoint to server/web.py**
+
+After the `get_step` endpoint (line 197), add:
+
+```python
+@app.get("/api/models/{name}.gcode")
+async def get_gcode(name: str):
+    path = OUTPUT_DIR / f"{name}.gcode"
+    if not path.exists():
+        return JSONResponse({"error": f"G-code not found: {name}"}, status_code=404)
+    return FileResponse(path, media_type="text/plain", filename=f"{name}.gcode")
+```
+
+- [ ] **Step 2: Run existing API tests**
+
+Run: `cd /home/daniel/NeuralCAD && python -m pytest tests/test_api_routes.py -v`
+Expected: All existing API tests pass
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add server/web.py
+git commit -m "feat(api): add GET /api/models/{name}.gcode endpoint"
+```
+
+---
+
+### Task 6: Frontend — G-code parser
+
+**Files:**
+- Modify: `web/index.html`
+
+- [ ] **Step 1: Add G-code parser function**
+
+In `web/index.html`, add after the `animate()` function (after line 1626), before the `loadSTL` function:
+
+```javascript
+// ── G-CODE PARSER & TOOLPATH RENDERER ─────────────────
+
+function parseGCode(gcodeString) {
+  const segments = [];
+  let pos = { x: 0, y: 0, z: 0 };
+  let mode = 'G0';
+  let feed = 0;
+  let tool = 0;
+  let absolute = true;
+
+  for (const rawLine of gcodeString.split('\n')) {
+    const line = rawLine.split(';')[0].split('(')[0].trim();
+    if (!line) continue;
+
+    const gMatch = line.match(/G(0?[0-3]|9[01])\b/);
+    const xMatch = line.match(/X([-\d.]+)/);
+    const yMatch = line.match(/Y([-\d.]+)/);
+    const zMatch = line.match(/Z([-\d.]+)/);
+    const fMatch = line.match(/F([\d.]+)/);
+    const tMatch = line.match(/T(\d+)/);
+    const iMatch = line.match(/I([-\d.]+)/);
+    const jMatch = line.match(/J([-\d.]+)/);
+
+    if (gMatch) {
+      const code = parseInt(gMatch[1]);
+      if (code <= 3) mode = 'G' + code;
+      else if (code === 90) absolute = true;
+      else if (code === 91) absolute = false;
+    }
+    if (fMatch) feed = parseFloat(fMatch[1]);
+    if (tMatch) tool = parseInt(tMatch[1]);
+
+    const hasMove = xMatch || yMatch || zMatch;
+    if (!hasMove) continue;
+
+    const newPos = absolute
+      ? {
+          x: xMatch ? parseFloat(xMatch[1]) : pos.x,
+          y: yMatch ? parseFloat(yMatch[1]) : pos.y,
+          z: zMatch ? parseFloat(zMatch[1]) : pos.z,
+        }
+      : {
+          x: pos.x + (xMatch ? parseFloat(xMatch[1]) : 0),
+          y: pos.y + (yMatch ? parseFloat(yMatch[1]) : 0),
+          z: pos.z + (zMatch ? parseFloat(zMatch[1]) : 0),
+        };
+
+    if (mode === 'G0' || mode === 'G1') {
+      segments.push({
+        type: mode, start: { ...pos }, end: { ...newPos }, feed, tool,
+      });
+    } else if (mode === 'G2' || mode === 'G3') {
+      const cx = pos.x + (iMatch ? parseFloat(iMatch[1]) : 0);
+      const cy = pos.y + (jMatch ? parseFloat(jMatch[1]) : 0);
+      segments.push({
+        type: mode, start: { ...pos }, end: { ...newPos },
+        center: { x: cx, y: cy }, feed, tool,
+      });
+    }
+
+    pos = newPos;
+  }
+  return segments;
+}
+
+function tessellateArc(seg) {
+  const points = [];
+  const cx = seg.center.x;
+  const cy = seg.center.y;
+  const startAngle = Math.atan2(seg.start.y - cy, seg.start.x - cx);
+  const endAngle = Math.atan2(seg.end.y - cy, seg.end.x - cx);
+  const radius = Math.sqrt(
+    (seg.start.x - cx) ** 2 + (seg.start.y - cy) ** 2
+  );
+
+  let sweep = endAngle - startAngle;
+  if (seg.type === 'G2') {
+    if (sweep > 0) sweep -= 2 * Math.PI;
+  } else {
+    if (sweep < 0) sweep += 2 * Math.PI;
+  }
+
+  const steps = Math.max(Math.ceil(Math.abs(sweep) / (Math.PI / 90)), 4);
+  const zStep = (seg.end.z - seg.start.z) / steps;
+
+  for (let i = 0; i <= steps; i++) {
+    const t = i / steps;
+    const angle = startAngle + sweep * t;
+    points.push({
+      x: cx + radius * Math.cos(angle),
+      y: cy + radius * Math.sin(angle),
+      z: seg.start.z + zStep * i,
+    });
+  }
+  return points;
+}
+```
+
+- [ ] **Step 2: Verify no syntax errors**
+
+Run dev server: `cd /home/daniel/NeuralCAD && python -m server.web --port 5000 &`
+Open http://localhost:5000 in browser. Check browser console for JavaScript errors.
+Expected: No errors. Page loads normally.
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add web/index.html
+git commit -m "feat(frontend): add G-code parser with G0/G1/G2/G3 and arc tessellation"
+```
+
+---
+
+### Task 7: Frontend — Toolpath 3D renderer and view toggle
+
+**Files:**
+- Modify: `web/index.html`
+
+- [ ] **Step 1: Add toolpath renderer and view toggle state**
+
+Add after the `tessellateArc` function:
+
+```javascript
+let gcodeGroup = null;
+let currentViewMode = 'part';  // 'part' | 'toolpath' | 'overlay'
+
+function renderToolpath(segments) {
+  // Remove old toolpath
+  if (gcodeGroup) {
+    scene.remove(gcodeGroup);
+    gcodeGroup.traverse(child => {
+      if (child.geometry) child.geometry.dispose();
+      if (child.material) child.material.dispose();
+    });
+  }
+  gcodeGroup = new THREE.Group();
+
+  const rapids = [];
+  const cuts = [];
+
+  for (const seg of segments) {
+    if (seg.type === 'G2' || seg.type === 'G3') {
+      const pts = tessellateArc(seg);
+      for (let i = 0; i < pts.length - 1; i++) {
+        cuts.push(pts[i].x, pts[i].z, pts[i].y,
+                  pts[i+1].x, pts[i+1].z, pts[i+1].y);
+      }
+    } else if (seg.type === 'G0') {
+      rapids.push(seg.start.x, seg.start.z, seg.start.y,
+                  seg.end.x, seg.end.z, seg.end.y);
+    } else {
+      cuts.push(seg.start.x, seg.start.z, seg.start.y,
+                seg.end.x, seg.end.z, seg.end.y);
+    }
+  }
+
+  if (rapids.length) {
+    const geo = new THREE.BufferGeometry();
+    geo.setAttribute('position', new THREE.Float32BufferAttribute(rapids, 3));
+    gcodeGroup.add(new THREE.LineSegments(geo,
+      new THREE.LineBasicMaterial({ color: 0xff4444, opacity: 0.3, transparent: true })));
+  }
+
+  if (cuts.length) {
+    const geo = new THREE.BufferGeometry();
+    geo.setAttribute('position', new THREE.Float32BufferAttribute(cuts, 3));
+    gcodeGroup.add(new THREE.LineSegments(geo,
+      new THREE.LineBasicMaterial({ color: 0x00b4d8 })));
+  }
+
+  // Center the toolpath
+  const box = new THREE.Box3().setFromObject(gcodeGroup);
+  const center = new THREE.Vector3();
+  box.getCenter(center);
+  gcodeGroup.position.sub(center);
+
+  scene.add(gcodeGroup);
+  applyViewMode();
+}
+
+function setViewMode(mode) {
+  currentViewMode = mode;
+  applyViewMode();
+  document.querySelectorAll('.view-btn').forEach(b => b.classList.remove('active'));
+  const btn = document.getElementById('view-' + mode);
+  if (btn) btn.classList.add('active');
+}
+
+function applyViewMode() {
+  if (!currentMesh && !gcodeGroup) return;
+  if (currentViewMode === 'part') {
+    if (currentMesh) currentMesh.visible = true;
+    if (gcodeGroup) gcodeGroup.visible = false;
+    if (currentMesh && currentMesh.material) {
+      currentMesh.material.transparent = false;
+      currentMesh.material.opacity = 1;
+    }
+  } else if (currentViewMode === 'toolpath') {
+    if (currentMesh) currentMesh.visible = false;
+    if (gcodeGroup) gcodeGroup.visible = true;
+  } else if (currentViewMode === 'overlay') {
+    if (currentMesh) {
+      currentMesh.visible = true;
+      currentMesh.material.transparent = true;
+      currentMesh.material.opacity = 0.3;
+    }
+    if (gcodeGroup) gcodeGroup.visible = true;
+  }
+}
+```
+
+- [ ] **Step 2: Add view toggle buttons to viewport HTML**
+
+Find the viewport container section in the HTML (search for `viewer-empty` or `viewport`). Add a toolbar div inside the viewport area. Look for the 3D viewport section and add right after the `<div id="viewport">` opening tag:
+
+```html
+<div id="view-toolbar" style="position:absolute;top:8px;right:8px;z-index:10;display:none;gap:4px;">
+  <button class="view-btn active" id="view-part" onclick="setViewMode('part')"
+    style="padding:4px 10px;font-size:11px;font-family:var(--font-mono);background:var(--bg-surface);
+    color:var(--text-secondary);border:1px solid var(--border);border-radius:4px;cursor:pointer;">Part</button>
+  <button class="view-btn" id="view-toolpath" onclick="setViewMode('toolpath')"
+    style="padding:4px 10px;font-size:11px;font-family:var(--font-mono);background:var(--bg-surface);
+    color:var(--text-secondary);border:1px solid var(--border);border-radius:4px;cursor:pointer;">Toolpath</button>
+  <button class="view-btn" id="view-overlay" onclick="setViewMode('overlay')"
+    style="padding:4px 10px;font-size:11px;font-family:var(--font-mono);background:var(--bg-surface);
+    color:var(--text-secondary);border:1px solid var(--border);border-radius:4px;cursor:pointer;">Overlay</button>
+</div>
+```
+
+Add CSS for active state (in the `<style>` section):
+
+```css
+.view-btn.active { background: var(--accent-dim) !important; color: var(--text-primary) !important; border-color: var(--accent) !important; }
+```
+
+- [ ] **Step 3: Wire G-code rendering into the chat response handler**
+
+In the `sendMessage` function, after `data.preview.success` handling (around line 1771), where `loadSTL` is called, add:
+
+```javascript
+      // If G-code/CAM data available, render toolpath
+      if (data.preview.cam && data.preview.cam.success && data.preview.cam.gcode) {
+        const segments = parseGCode(data.preview.cam.gcode);
+        if (segments.length > 0) {
+          renderToolpath(segments);
+          document.getElementById('view-toolbar').style.display = 'flex';
+        }
+      }
+```
+
+- [ ] **Step 4: Add G-code download button**
+
+In the `updateDownloads` function (around line 2056), add after the existing download links:
+
+```javascript
+  const dlGcode = document.getElementById('dl-gcode');
+  if (dlGcode) {
+    const gcodePath = '/api/models/' + partName + '.gcode';
+    fetch(gcodePath, { method: 'HEAD' }).then(r => {
+      dlGcode.style.display = r.ok ? 'inline-flex' : 'none';
+      dlGcode.href = gcodePath;
+    }).catch(() => { dlGcode.style.display = 'none'; });
+  }
+```
+
+Find the download buttons HTML section and add a G-code download button:
+
+```html
+<a id="dl-gcode" class="dl-btn" download style="display:none">
+  <span class="dl-icon">&#8615;</span> G-CODE
+</a>
+```
+
+Also add a G-code download link in the `renderGallery` function, after the STL link (around line 2144):
+
+```javascript
+    html += '<a class="gallery-dl" href="/api/models/' + name + '.gcode" download>GCODE</a>';
+```
+
+- [ ] **Step 5: Add agent color for CAM**
+
+In the CSS `:root` section, add:
+
+```css
+    --agent-cam: #ff6b35;
+```
+
+In the `sendMessage` @mention regex (line 1714), update to include `cam`:
+
+```javascript
+  const mentionRegex = /@(design|engineering|cnc|cad|cam)\b/gi;
+```
+
+- [ ] **Step 6: Verify in browser**
+
+Open http://localhost:5000, check:
+1. No JavaScript errors in console
+2. View toggle buttons appear (hidden until toolpath is loaded)
+3. G-code download button appears conditionally
+
+- [ ] **Step 7: Commit**
+
+```bash
+git add web/index.html
+git commit -m "feat(frontend): add 3D toolpath renderer, view toggle, and G-code download"
+```
+
+---
+
+### Task 8: Integration test and final verification
+
+**Files:**
+- All modified files
+
+- [ ] **Step 1: Run full test suite**
+
+Run: `cd /home/daniel/NeuralCAD && python -m pytest --tb=short -q`
+Expected: All tests pass including new test_cam.py and test_cam_routing.py
+
+- [ ] **Step 2: Verify config loads correctly**
+
+Run:
+```bash
+cd /home/daniel/NeuralCAD && python -c "
+from config.settings import settings
+from agents.definitions import AGENTS
+from agents.routing import RoutingEngine
+
+print('CAM agent:', AGENTS['cam'].name, AGENTS['cam'].color)
+print('CAM config:', settings.cam if hasattr(settings, 'cam') else 'N/A')
+engine = RoutingEngine()
+print('CAM routing:', engine.route('generate a toolpath'))
+print('All agents:', list(AGENTS.keys()))
+"
+```
+Expected: Shows CAM Agent with color #ff6b35, cam config with tools, routing includes "cam"
+
+- [ ] **Step 3: Verify G-code endpoint**
+
+Run:
+```bash
+# Create a test gcode file
+echo "G21 G90\nG00 X0 Y0 Z10\nG01 X50 Y50 Z-2 F800\nM30" > /home/daniel/NeuralCAD/output/test_part.gcode
+# Start server and test endpoint
+cd /home/daniel/NeuralCAD && timeout 5 python -c "
+from server.web import app
+from fastapi.testclient import TestClient
+client = TestClient(app)
+resp = client.get('/api/models/test_part.gcode')
+print('Status:', resp.status_code)
+print('Content-Type:', resp.headers.get('content-type'))
+" 2>/dev/null || true
+rm -f /home/daniel/NeuralCAD/output/test_part.gcode
+```
+Expected: Status 200, Content-Type text/plain
+
+- [ ] **Step 4: Manual browser test**
+
+Start dev server and test the full flow:
+1. Open http://localhost:5000
+2. Type a design prompt (e.g., "Design a 60mm wide mounting bracket with M4 holes")
+3. Wait for agents to respond and CAD model to generate
+4. Type "@cam generate toolpath for this part" (or "generate gcode")
+5. Verify:
+   - CAM Agent responds with operation plan
+   - Toolpath renders as colored lines in 3D viewport
+   - View toggle buttons appear (Part / Toolpath / Overlay)
+   - G-code download button appears
+   - Switching views works correctly
+
+- [ ] **Step 5: Final commit with all changes**
+
+```bash
+git add -A
+git status  # verify only expected files
+git commit -m "feat: integrate CNC slicer, 3D toolpath preview, and CAM agent
+
+Adds ocp-freecad-cam wrapper (core/cam.py), CAM agent with tool/operation
+selection, 3D G-code toolpath rendering in Three.js viewport with
+Part/Toolpath/Overlay view toggle, and G-code download endpoint."
+```