docs: add implementation plan for planning review gate & guided wizard

docs/superpowers/plans/2026-04-12-planning-review-gate.md

@@ -0,0 +1,1755 @@
+# Planning Review Gate & Guided Wizard 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 a planning phase with user approval before CAD generation, a guided wizard UI, 3MF export, and organized downloads.
+
+**Architecture:** `DesignState` gains `phase` and `plan` fields. A scoring function triggers plan presentation when completeness crosses a configurable threshold. Two new API endpoints handle approve/reject. The frontend adds a Chat/Guided tab switcher with a 7-step wizard and inline plan cards.
+
+**Tech Stack:** Python/Pydantic (backend), FastAPI (API), vanilla JS/HTML (frontend), CadQuery (3MF export)
+
+---
+
+### Task 1: PlanningConfig in settings
+
+**Files:**
+- Modify: `config/settings.py:82-96` (insert before `AgentConfig`)
+- Modify: `config/settings.py:121-123` (add `planning` field to `Settings`)
+- Modify: `config.yaml:72-73` (add `planning` section before `agents`)
+- Test: `tests/test_settings.py`
+
+- [ ] **Step 1: Write failing test**
+
+```python
+# tests/test_settings.py — add to existing file
+
+class TestPlanningConfig:
+    def test_planning_defaults(self):
+        from config.settings import Settings
+        s = Settings()
+        assert s.planning.threshold == 8.0
+        assert s.planning.weights["material"] == 3
+        assert s.planning.caps["dimension"] == 4
+        assert "plan" in s.planning.trigger_keywords
+        assert "cad" in s.planning.approved_agents
+
+    def test_planning_threshold_from_yaml(self):
+        from config.settings import settings
+        assert settings.planning.threshold == 8.0
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `cd /home/daniel/NeuralCAD && python -m pytest tests/test_settings.py::TestPlanningConfig -v`
+Expected: FAIL with `AttributeError: 'Settings' object has no attribute 'planning'`
+
+- [ ] **Step 3: Add PlanningConfig model to settings.py**
+
+Add after `RoutingConfig` class (line 96):
+
+```python
+class PlanningConfig(BaseModel):
+    threshold: float = 8.0
+    weights: dict[str, float] = Field(default_factory=lambda: {
+        "material": 3, "dimension": 1, "feature": 1,
+        "constraint": 1, "part_name": 1, "description": 1,
+        "axis_recommendation": 2,
+    })
+    caps: dict[str, int] = Field(default_factory=lambda: {
+        "dimension": 4, "feature": 4, "constraint": 2,
+    })
+    trigger_keywords: list[str] = Field(default_factory=lambda: [
+        "plan", "review", "ready", "show plan", "summarize", "what do we have",
+    ])
+    approved_agents: list[str] = Field(default_factory=lambda: ["cad", "cnc"])
+```
+
+Add to `Settings` class after `cam` field (line 121):
+
+```python
+    planning: PlanningConfig = Field(default_factory=PlanningConfig)
+```
+
+- [ ] **Step 4: Add planning section to config.yaml**
+
+Add before the `agents:` line (line 73 in config.yaml):
+
+```yaml
+planning:
+  threshold: 8
+  weights:
+    material: 3
+    dimension: 1
+    feature: 1
+    constraint: 1
+    part_name: 1
+    description: 1
+    axis_recommendation: 2
+  caps:
+    dimension: 4
+    feature: 4
+    constraint: 2
+  trigger_keywords:
+    - "plan"
+    - "review"
+    - "ready"
+    - "show plan"
+    - "summarize"
+    - "what do we have"
+  approved_agents:
+    - "cad"
+    - "cnc"
+```
+
+- [ ] **Step 5: Run test to verify it passes**
+
+Run: `cd /home/daniel/NeuralCAD && python -m pytest tests/test_settings.py::TestPlanningConfig -v`
+Expected: PASS
+
+- [ ] **Step 6: Run full test suite**
+
+Run: `cd /home/daniel/NeuralCAD && python -m pytest tests/ -v --tb=short`
+Expected: All existing tests pass
+
+- [ ] **Step 7: Commit**
+
+```bash
+git add config/settings.py config.yaml tests/test_settings.py
+git commit -m "feat: add PlanningConfig to settings with threshold, weights, caps"
+```
+
+---
+
+### Task 2: DesignPlan model and compute_score()
+
+**Files:**
+- Modify: `agents/design_state.py:1-10` (add imports)
+- Modify: `agents/design_state.py:40-49` (add fields to DesignState)
+- Create new class and function in `agents/design_state.py`
+- Test: `tests/test_design_state.py`
+
+- [ ] **Step 1: Write failing tests**
+
+```python
+# tests/test_design_state.py — add to existing file
+
+from agents.design_state import DesignPlan, compute_score
+
+
+class TestDesignPlan:
+    def test_create_from_state(self):
+        state = DesignState(
+            part_name="bracket",
+            description="mounting bracket",
+            material="aluminum 6061",
+            dimensions={"width": 60.0, "height": 40.0, "depth": 20.0},
+            features=["4x M6 holes"],
+            constraints=["min wall 3mm"],
+            axis_recommendation="3-axis",
+            decisions=["use aluminum"],
+        )
+        plan = DesignPlan.from_state(state, confidence_score=9.0)
+        assert plan.part_name == "bracket"
+        assert plan.material == "aluminum 6061"
+        assert plan.dimensions == {"width": 60.0, "height": 40.0, "depth": 20.0}
+        assert plan.confidence_score == 9.0
+        assert plan.machining_notes == []
+
+    def test_plan_render(self):
+        plan = DesignPlan(
+            part_name="bracket",
+            description="test",
+            material="aluminum 6061",
+            dimensions={"width": 60.0},
+            features=["4x M6 holes"],
+            constraints=[],
+            axis_recommendation="3-axis",
+            machining_notes=["No undercuts"],
+            confidence_score=9.0,
+        )
+        rendered = plan.render_approved()
+        assert "APPROVED DESIGN PLAN" in rendered
+        assert "aluminum 6061" in rendered
+        assert "No undercuts" in rendered
+
+
+class TestComputeScore:
+    def test_empty_state_scores_zero(self):
+        assert compute_score(DesignState()) == 0.0
+
+    def test_material_scores_3(self):
+        state = DesignState(material="aluminum")
+        assert compute_score(state) == 3.0
+
+    def test_full_state_above_threshold(self):
+        state = DesignState(
+            part_name="bracket",
+            description="test bracket",
+            material="aluminum 6061",
+            dimensions={"width": 60.0, "height": 40.0, "depth": 20.0},
+            features=["4x M6 holes"],
+            constraints=["min wall 3mm"],
+            axis_recommendation="3-axis",
+        )
+        score = compute_score(state)
+        assert score >= 8.0  # threshold
+
+    def test_dimension_cap_at_4(self):
+        state = DesignState(dimensions={
+            "width": 60, "height": 40, "depth": 20,
+            "length": 100, "diameter": 10, "radius": 5,
+        })
+        score = compute_score(state)
+        assert score == 4.0  # 6 dims but capped at 4
+
+    def test_feature_cap_at_4(self):
+        state = DesignState(features=["a", "b", "c", "d", "e", "f"])
+        score = compute_score(state)
+        assert score == 4.0  # 6 features but capped at 4
+
+    def test_constraint_cap_at_2(self):
+        state = DesignState(constraints=["a", "b", "c", "d"])
+        score = compute_score(state)
+        assert score == 2.0  # 4 constraints but capped at 2
+
+
+class TestDesignStatePhase:
+    def test_default_phase_exploring(self):
+        state = DesignState()
+        assert state.phase == "exploring"
+        assert state.plan is None
+
+    def test_phase_serialization(self):
+        plan = DesignPlan(
+            part_name="b", description="", material="steel",
+            dimensions={}, features=[], constraints=[],
+            axis_recommendation="", machining_notes=[],
+            confidence_score=5.0,
+        )
+        state = DesignState(phase="planning", plan=plan)
+        d = state.model_dump()
+        assert d["phase"] == "planning"
+        assert d["plan"]["material"] == "steel"
+
+    def test_roundtrip_from_dict(self):
+        state = DesignState(phase="approved", material="brass")
+        d = state.model_dump()
+        restored = DesignState(**d)
+        assert restored.phase == "approved"
+        assert restored.material == "brass"
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `cd /home/daniel/NeuralCAD && python -m pytest tests/test_design_state.py::TestDesignPlan -v`
+Expected: FAIL with `ImportError: cannot import name 'DesignPlan'`
+
+- [ ] **Step 3: Add DesignPlan model, compute_score(), and new DesignState fields**
+
+In `agents/design_state.py`, add `DesignPlan` class before `DesignState`:
+
+```python
+class DesignPlan(BaseModel):
+    """Structured plan presented to user for review/editing before generation."""
+    part_name: str = ""
+    description: str = ""
+    material: str = ""
+    dimensions: dict[str, float] = Field(default_factory=dict)
+    features: list[str] = Field(default_factory=list)
+    constraints: list[str] = Field(default_factory=list)
+    axis_recommendation: str = ""
+    machining_notes: list[str] = Field(default_factory=list)
+    confidence_score: float = 0.0
+
+    @classmethod
+    def from_state(cls, state: "DesignState", confidence_score: float) -> "DesignPlan":
+        """Create a plan snapshot from the current design state."""
+        return cls(
+            part_name=state.part_name,
+            description=state.description,
+            material=state.material,
+            dimensions=dict(state.dimensions),
+            features=list(state.features),
+            constraints=list(state.constraints),
+            axis_recommendation=state.axis_recommendation,
+            machining_notes=[],
+            confidence_score=confidence_score,
+        )
+
+    def render_approved(self) -> str:
+        """Render as an approved plan context block for LLM agents."""
+        lines = ["## APPROVED DESIGN PLAN (user-confirmed)"]
+        if self.part_name:
+            lines.append(f"Part: {self.part_name}")
+        if self.description:
+            lines.append(f"Description: {self.description}")
+        if self.material:
+            lines.append(f"Material: {self.material}")
+        if self.dimensions:
+            dims = ", ".join(f"{k}={v}mm" for k, v in self.dimensions.items())
+            lines.append(f"Dimensions: {dims}")
+        if self.features:
+            lines.append(f"Features: {'; '.join(self.features)}")
+        if self.constraints:
+            lines.append(f"Constraints: {'; '.join(self.constraints)}")
+        if self.axis_recommendation:
+            lines.append(f"Axis: {self.axis_recommendation}")
+        if self.machining_notes:
+            lines.append(f"Machining Notes: {'; '.join(self.machining_notes)}")
+        lines.append("")
+        lines.append("This plan has been reviewed and approved by the user.")
+        lines.append("Generate the model according to these specifications.")
+        return "\n".join(lines)
+```
+
+Add two new fields to `DesignState` (after `axis_recommendation`):
+
+```python
+    phase: str = "exploring"
+    plan: DesignPlan | None = None
+```
+
+Add `compute_score()` function after the `DesignState` class:
+
+```python
+def compute_score(state: DesignState) -> float:
+    """Compute completeness score for a design state using configured weights and caps."""
+    cfg = settings.planning
+    score = 0.0
+    if state.material:
+        score += cfg.weights.get("material", 3)
+    if state.part_name:
+        score += cfg.weights.get("part_name", 1)
+    if state.description:
+        score += cfg.weights.get("description", 1)
+    if state.axis_recommendation:
+        score += cfg.weights.get("axis_recommendation", 2)
+    dim_cap = cfg.caps.get("dimension", 4)
+    dim_count = min(len(state.dimensions), dim_cap)
+    score += dim_count * cfg.weights.get("dimension", 1)
+    feat_cap = cfg.caps.get("feature", 4)
+    feat_count = min(len(state.features), feat_cap)
+    score += feat_count * cfg.weights.get("feature", 1)
+    const_cap = cfg.caps.get("constraint", 2)
+    const_count = min(len(state.constraints), const_cap)
+    score += const_count * cfg.weights.get("constraint", 1)
+    return score
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `cd /home/daniel/NeuralCAD && python -m pytest tests/test_design_state.py -v`
+Expected: All pass (existing + new)
+
+- [ ] **Step 5: Run full test suite**
+
+Run: `cd /home/daniel/NeuralCAD && python -m pytest tests/ -v --tb=short`
+Expected: All pass
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add agents/design_state.py tests/test_design_state.py
+git commit -m "feat: add DesignPlan model, compute_score(), phase/plan fields to DesignState"
+```
+
+---
+
+### Task 3: Plan approve/reject API endpoints
+
+**Files:**
+- Modify: `server/routes.py:1-10` (add imports)
+- Modify: `server/routes.py:38-39` (add request models)
+- Add new endpoints at end of `server/routes.py`
+- Test: `tests/test_api_routes.py`
+
+- [ ] **Step 1: Write failing tests**
+
+```python
+# tests/test_api_routes.py — add to existing file
+
+class TestPlanApproveEndpoint:
+    def test_approve_sets_phase(self):
+        resp = client.post("/api/plan/approve", json={
+            "plan": {
+                "part_name": "bracket",
+                "description": "test",
+                "material": "aluminum 6061",
+                "dimensions": {"width": 60},
+                "features": ["4x M6 holes"],
+                "constraints": ["min wall 3mm"],
+                "axis_recommendation": "3-axis",
+                "machining_notes": [],
+                "confidence_score": 9.0,
+            },
+            "design_state": {
+                "part_name": "bracket",
+                "material": "steel",
+                "dimensions": {"width": 50},
+                "phase": "planning",
+            },
+        })
+        assert resp.status_code == 200
+        data = resp.json()
+        assert data["design_state"]["phase"] == "approved"
+        assert data["design_state"]["material"] == "aluminum 6061"
+        assert data["design_state"]["dimensions"]["width"] == 60
+
+    def test_approve_merges_plan_into_state(self):
+        resp = client.post("/api/plan/approve", json={
+            "plan": {
+                "part_name": "gear",
+                "description": "spur gear",
+                "material": "brass",
+                "dimensions": {"diameter": 40},
+                "features": [],
+                "constraints": [],
+                "axis_recommendation": "3-axis",
+                "machining_notes": ["No undercuts"],
+                "confidence_score": 8.0,
+            },
+            "design_state": {"phase": "planning"},
+        })
+        data = resp.json()
+        assert data["design_state"]["part_name"] == "gear"
+        assert data["design_state"]["plan"]["material"] == "brass"
+
+
+class TestPlanRejectEndpoint:
+    def test_reject_resets_phase(self):
+        resp = client.post("/api/plan/reject", json={
+            "design_state": {
+                "phase": "planning",
+                "material": "aluminum",
+                "plan": {"part_name": "x", "description": "", "material": "aluminum",
+                         "dimensions": {}, "features": [], "constraints": [],
+                         "axis_recommendation": "", "machining_notes": [],
+                         "confidence_score": 5.0},
+            },
+        })
+        assert resp.status_code == 200
+        data = resp.json()
+        assert data["design_state"]["phase"] == "exploring"
+        assert data["design_state"]["plan"] is None
+        assert data["design_state"]["material"] == "aluminum"
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `cd /home/daniel/NeuralCAD && python -m pytest tests/test_api_routes.py::TestPlanApproveEndpoint -v`
+Expected: FAIL with 404 (endpoint doesn't exist)
+
+- [ ] **Step 3: Add endpoints to routes.py**
+
+Add imports at top of `server/routes.py`:
+
+```python
+from agents.design_state import DesignState, DesignPlan
+```
+
+Add request models after `ReportRequest`:
+
+```python
+class PlanApproveRequest(BaseModel):
+    plan: dict = Field(...)
+    design_state: dict = Field(default_factory=dict)
+
+
+class PlanRejectRequest(BaseModel):
+    design_state: dict = Field(default_factory=dict)
+```
+
+Add endpoints at end of file:
+
+```python
+@router.post("/api/plan/approve")
+async def plan_approve(body: PlanApproveRequest):
+    """Approve (possibly edited) design plan, merge into state."""
+    plan = DesignPlan(**body.plan)
+    state = DesignState(**body.design_state)
+    # Merge plan edits back into state
+    state.part_name = plan.part_name
+    state.description = plan.description
+    state.material = plan.material
+    state.dimensions = dict(plan.dimensions)
+    state.features = list(plan.features)
+    state.constraints = list(plan.constraints)
+    state.axis_recommendation = plan.axis_recommendation
+    state.phase = "approved"
+    state.plan = plan
+    return JSONResponse({"design_state": state.model_dump()})
+
+
+@router.post("/api/plan/reject")
+async def plan_reject(body: PlanRejectRequest):
+    """Reject plan, reset to exploring."""
+    state = DesignState(**body.design_state)
+    state.phase = "exploring"
+    state.plan = None
+    return JSONResponse({"design_state": state.model_dump()})
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `cd /home/daniel/NeuralCAD && python -m pytest tests/test_api_routes.py -v`
+Expected: All pass (existing + new)
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add server/routes.py tests/test_api_routes.py
+git commit -m "feat: add /api/plan/approve and /api/plan/reject endpoints"
+```
+
+---
+
+### Task 4: Orchestrator phase branching
+
+**Files:**
+- Modify: `agents/crew_orchestrator.py:17` (add imports)
+- Modify: `agents/crew_orchestrator.py:30-55` (update `_build_agent_context`)
+- Modify: `agents/crew_orchestrator.py:93-105` (update `chat_turn` entry)
+- Modify: `agents/crew_orchestrator.py:122-135` (update `_run_crew` top)
+- Test: `tests/test_crew_orchestrator.py`
+
+- [ ] **Step 1: Read existing crew orchestrator tests**
+
+Read `tests/test_crew_orchestrator.py` to understand the current test patterns and mock setup before writing new tests.
+
+- [ ] **Step 2: Write failing tests**
+
+```python
+# tests/test_crew_orchestrator.py — add to existing file
+
+class TestPlanningPhase:
+    """Tests for planning phase in CrewOrchestrator."""
+
+    def test_manual_plan_trigger(self):
+        """User typing a trigger keyword returns plan without running crew."""
+        orch = CrewOrchestrator(backend_name="mock")
+        state = DesignState(
+            part_name="bracket",
+            material="aluminum 6061",
+            dimensions={"width": 60, "height": 40, "depth": 20},
+            axis_recommendation="3-axis",
+        )
+        result = orch.chat_turn(
+            message="show plan",
+            history=[],
+            design_state=state.model_dump(),
+        )
+        assert result["design_state"]["phase"] == "planning"
+        assert result["design_state"]["plan"] is not None
+        assert result["design_state"]["plan"]["material"] == "aluminum 6061"
+
+    def test_auto_plan_trigger_on_threshold(self):
+        """Score crossing threshold auto-triggers planning phase."""
+        orch = CrewOrchestrator(backend_name="mock")
+        # State that's above default threshold of 8:
+        # material(3) + 3 dims(3) + axis(2) = 8
+        state = DesignState(
+            material="aluminum 6061",
+            dimensions={"width": 60, "height": 40, "depth": 20},
+            axis_recommendation="3-axis",
+        )
+        result = orch.chat_turn(
+            message="looks good",
+            history=[],
+            design_state=state.model_dump(),
+        )
+        # After extract_decisions + score check, should transition to planning
+        ds = result["design_state"]
+        # State already has enough score, so after this turn it should trigger
+        assert ds["phase"] in ("planning", "exploring")
+        # If mock fallback runs, it might not trigger — check score directly
+        from agents.design_state import compute_score
+        assert compute_score(DesignState(**ds)) >= 8.0 or ds["phase"] == "planning"
+
+    def test_approved_phase_not_reset_by_normal_message(self):
+        """When phase is approved, orchestrator keeps it approved."""
+        orch = CrewOrchestrator(backend_name="mock")
+        from agents.design_state import DesignPlan
+        plan = DesignPlan(
+            part_name="bracket", description="test", material="aluminum",
+            dimensions={"width": 60}, features=[], constraints=[],
+            axis_recommendation="3-axis", machining_notes=[],
+            confidence_score=9.0,
+        )
+        state = DesignState(
+            phase="approved",
+            plan=plan,
+            material="aluminum",
+            dimensions={"width": 60},
+        )
+        result = orch.chat_turn(
+            message="Generate the approved design",
+            history=[],
+            design_state=state.model_dump(),
+        )
+        # Should stay in approved or transition based on CAD result
+        assert "responses" in result
+```
+
+- [ ] **Step 3: Run tests to verify they fail**
+
+Run: `cd /home/daniel/NeuralCAD && python -m pytest tests/test_crew_orchestrator.py::TestPlanningPhase -v`
+Expected: FAIL (planning logic not implemented yet)
+
+- [ ] **Step 4: Add planning imports to crew_orchestrator.py**
+
+Add to imports at top:
+
+```python
+from agents.design_state import DesignState, DesignPlan, extract_decisions, compute_score
+```
+
+Remove the existing import:
+```python
+from agents.design_state import DesignState, extract_decisions
+```
+
+- [ ] **Step 5: Add trigger keyword detection function**
+
+Add after `_build_agent_context` function:
+
+```python
+def _is_plan_trigger(message: str) -> bool:
+    """Check if user message is requesting a plan review."""
+    lower = message.lower().strip()
+    for keyword in settings.planning.trigger_keywords:
+        if keyword in lower:
+            return True
+    return False
+```
+
+- [ ] **Step 6: Update _build_agent_context for approved phase**
+
+Modify `_build_agent_context` to accept an optional `DesignPlan` and render it differently when approved:
+
+```python
+def _build_agent_context(
+    message: str,
+    history: list[dict],
+    design_state: DesignState,
+    max_history: int = 20,
+    approved_plan: DesignPlan | None = None,
+) -> str:
+    """Build a shared context string that each CrewAI agent receives."""
+    parts = []
+
+    if approved_plan:
+        parts.append(approved_plan.render_approved())
+    else:
+        spec = design_state.render()
+        if spec:
+            parts.append(f"## Current Design Spec\n{spec}")
+
+    recent = history[-max_history:] if len(history) > max_history else history
+    if recent:
+        lines = []
+        for msg in recent:
+            if msg.get("role") == "user":
+                lines.append(f"USER: {msg.get('content', '')}")
+            else:
+                aid = msg.get("agent_id", "unknown")
+                name = AGENTS.get(aid, AGENTS["design"]).name
+                lines.append(f"{name.upper()}: {msg.get('content', '')}")
+        parts.append("## Recent conversation\n" + "\n".join(lines))
+
+    parts.append(f"## User's latest message\n{message}")
+    return "\n\n".join(parts)
+```
+
+- [ ] **Step 7: Add phase branching to chat_turn/_run_crew**
+
+At the start of `_run_crew`, before the existing agent selection logic, add phase handling:
+
+```python
+        state = DesignState(**(design_state_dict or {}))
+
+        # Phase: manual plan trigger
+        if state.phase == "exploring" and _is_plan_trigger(message):
+            score = compute_score(state)
+            plan = DesignPlan.from_state(state, confidence_score=score)
+            state.phase = "planning"
+            state.plan = plan
+            return {
+                "responses": [],
+                "preview": None,
+                "design_state": state.model_dump(),
+            }
+
+        # Phase: if somehow in planning and user sends a message, reset to exploring
+        if state.phase == "planning":
+            state.phase = "exploring"
+            state.plan = None
+
+        # Phase: approved — override routing to approved_agents
+        if state.phase == "approved" and state.plan:
+            active_ids = list(settings.planning.approved_agents)
+            approved_plan = state.plan
+        else:
+            approved_plan = None
+```
+
+Then pass `approved_plan` to `_build_agent_context`:
+
+```python
+        context = _build_agent_context(message, history, state, max_history, approved_plan=approved_plan)
+```
+
+For the approved phase, skip the normal routing (the `active_ids` were already set above). Wrap the existing routing block with a condition:
+
+```python
+        if not (state.phase == "approved" and state.plan):
+            # Select which agents should respond
+            if mentions:
+                active_ids = list(mentions)
+            else:
+                active_ids = _router.route(message)
+
+            # Check CAD trigger
+            if "cad" not in active_ids and _router.has_cad_trigger(message):
+                active_ids.append("cad")
+```
+
+After the crew result processing, before `return`, add auto-trigger for exploring phase:
+
+```python
+        # Auto-trigger plan if score crosses threshold
+        if updated_state.phase == "exploring":
+            score = compute_score(updated_state)
+            if score >= settings.planning.threshold:
+                plan = DesignPlan.from_state(updated_state, confidence_score=score)
+                updated_state.phase = "planning"
+                updated_state.plan = plan
+
+        # If approved and CAD said NOT READY, reset
+        if state.phase == "approved":
+            for r in responses:
+                if r.get("agent_id") == "cad" and r.get("message", "").upper().startswith("NOT READY:"):
+                    updated_state.phase = "exploring"
+                    updated_state.plan = None
+                    break
+```
+
+- [ ] **Step 8: Run tests to verify they pass**
+
+Run: `cd /home/daniel/NeuralCAD && python -m pytest tests/test_crew_orchestrator.py -v`
+Expected: All pass
+
+- [ ] **Step 9: Run full test suite**
+
+Run: `cd /home/daniel/NeuralCAD && python -m pytest tests/ -v --tb=short`
+Expected: All pass
+
+- [ ] **Step 10: Commit**
+
+```bash
+git add agents/crew_orchestrator.py tests/test_crew_orchestrator.py
+git commit -m "feat: add planning phase branching to CrewOrchestrator"
+```
+
+---
+
+### Task 5: 3MF export and endpoint
+
+**Files:**
+- Modify: `core/executor.py:183-190` (add `export_3mf`, update `export_all`)
+- Modify: `server/web.py:205-206` (add 3MF endpoint after gcode endpoint)
+- Test: `tests/test_executor.py`
+
+- [ ] **Step 1: Write failing test**
+
+```python
+# tests/test_executor.py — add to existing file
+
+class TestExport3MF:
+    def test_export_3mf(self, tmp_path):
+        import cadquery as cq
+        from core.executor import export_3mf
+        shape = cq.Workplane("XY").box(10, 10, 10)
+        path = tmp_path / "test.3mf"
+        result = export_3mf(shape, path)
+        assert result.exists()
+        assert result.suffix == ".3mf"
+        assert result.stat().st_size > 0
+
+    def test_export_all_includes_3mf(self, tmp_path):
+        import cadquery as cq
+        from core.executor import export_all
+        shape = cq.Workplane("XY").box(10, 10, 10)
+        base = tmp_path / "part"
+        files = export_all(shape, base)
+        assert "3mf" in files
+        assert files["3mf"].exists()
+        assert files["step"].exists()
+        assert files["stl"].exists()
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `cd /home/daniel/NeuralCAD && python -m pytest tests/test_executor.py::TestExport3MF -v`
+Expected: FAIL with `ImportError: cannot import name 'export_3mf'`
+
+- [ ] **Step 3: Add export_3mf and update export_all**
+
+In `core/executor.py`, add after `export_stl` function:
+
+```python
+def export_3mf(result: cq.Workplane, path: str | Path) -> Path:
+    """Export a CadQuery workplane to 3MF format (slicer-ready)."""
+    path = Path(path)
+    cq.exporters.export(result, str(path), exportType="3MF")
+    return path
+```
+
+Update `export_all` to include 3MF:
+
+```python
+def export_all(result: cq.Workplane, base_path: str | Path) -> dict[str, Path]:
+    """Export to STEP, STL, and 3MF."""
+    base = Path(base_path)
+    return {
+        "step": export_step(result, base.with_suffix(".step")),
+        "stl": export_stl(result, base.with_suffix(".stl")),
+        "3mf": export_3mf(result, base.with_suffix(".3mf")),
+    }
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `cd /home/daniel/NeuralCAD && python -m pytest tests/test_executor.py::TestExport3MF -v`
+Expected: PASS
+
+- [ ] **Step 5: Add 3MF serving endpoint to web.py**
+
+In `server/web.py`, add after the `get_gcode` endpoint (line 205):
+
+```python
+@app.get("/api/models/{name}.3mf")
+async def get_3mf(name: str):
+    path = OUTPUT_DIR / f"{name}.3mf"
+    if not path.exists():
+        return JSONResponse({"error": f"3MF not found: {name}"}, status_code=404)
+    return FileResponse(path, media_type="model/3mf", filename=f"{name}.3mf")
+```
+
+- [ ] **Step 6: Run full test suite**
+
+Run: `cd /home/daniel/NeuralCAD && python -m pytest tests/ -v --tb=short`
+Expected: All pass
+
+- [ ] **Step 7: Commit**
+
+```bash
+git add core/executor.py server/web.py tests/test_executor.py
+git commit -m "feat: add 3MF export and /api/models/{name}.3mf endpoint"
+```
+
+---
+
+### Task 6: 3MF in orchestrator preview response
+
+**Files:**
+- Modify: `agents/crew_orchestrator.py:296-310` (add `threemf_url` to preview dict)
+
+- [ ] **Step 1: Update preview dict in _run_crew**
+
+In `agents/crew_orchestrator.py`, find the block where `preview` dict is created (around line 303) and add `threemf_url`:
+
+```python
+                            preview = {
+                                "success": True,
+                                "part_name": part_name,
+                                "stl_url": f"/api/models/{part_name}.stl",
+                                "step_url": f"/api/models/{part_name}.step",
+                                "threemf_url": f"/api/models/{part_name}.3mf",
+                                "execution": {"success": True},
+                                "validation": validation.model_dump(),
+                            }
+```
+
+- [ ] **Step 2: Run full test suite**
+
+Run: `cd /home/daniel/NeuralCAD && python -m pytest tests/ -v --tb=short`
+Expected: All pass
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add agents/crew_orchestrator.py
+git commit -m "feat: include threemf_url in preview response"
+```
+
+---
+
+### Task 7: Frontend tab switcher and guided wizard
+
+**Files:**
+- Modify: `web/index.html:1256-1283` (chat panel header, add tabs)
+- Modify: `web/index.html` (add wizard HTML, CSS, JS)
+
+This is the largest frontend task. It adds the tab bar, guided wizard panel, and state sync logic.
+
+- [ ] **Step 1: Add tab switcher CSS**
+
+In `web/index.html`, add CSS after the existing chat panel styles (find the `#chat-panel` CSS block):
+
+```css
+  /* ---- TAB SWITCHER ---- */
+  .chat-tabs {
+    display: flex;
+    border-bottom: 1px solid var(--border);
+    background: var(--bg-panel);
+    flex-shrink: 0;
+  }
+  .chat-tab {
+    flex: 1;
+    padding: 8px 0;
+    text-align: center;
+    font-family: var(--font-mono);
+    font-size: 11px;
+    font-weight: 500;
+    color: var(--text-secondary);
+    background: none;
+    border: none;
+    cursor: pointer;
+    border-bottom: 2px solid transparent;
+    transition: color 0.2s, border-color 0.2s;
+  }
+  .chat-tab:hover { color: var(--text-primary); }
+  .chat-tab.active {
+    color: var(--accent);
+    border-bottom-color: var(--accent);
+  }
+  #guided-panel { display: none; overflow-y: auto; flex: 1; padding: 12px; }
+  #guided-panel.active { display: flex; flex-direction: column; gap: 12px; }
+  #chat-messages.hidden { display: none; }
+
+  /* ---- WIZARD STEPS ---- */
+  .wizard-step {
+    background: var(--bg-surface);
+    border: 1px solid var(--border);
+    border-radius: 8px;
+    padding: 12px;
+  }
+  .wizard-step.completed { border-color: var(--success); }
+  .wizard-step-header {
+    display: flex; justify-content: space-between; align-items: center;
+    margin-bottom: 8px;
+  }
+  .wizard-step-title {
+    font-family: var(--font-mono); font-size: 11px;
+    color: var(--text-secondary); font-weight: 600;
+  }
+  .wizard-step-check { color: var(--success); font-size: 14px; }
+  .wizard-chips {
+    display: flex; flex-wrap: wrap; gap: 6px;
+  }
+  .wizard-chip {
+    padding: 5px 12px; border-radius: 14px;
+    font-family: var(--font-mono); font-size: 11px;
+    background: var(--bg-input); border: 1px solid var(--border);
+    color: var(--text-primary); cursor: pointer;
+    transition: border-color 0.15s, background 0.15s;
+  }
+  .wizard-chip:hover { border-color: var(--accent); }
+  .wizard-chip.selected {
+    border-color: var(--accent); background: var(--accent-glow);
+    color: var(--accent);
+  }
+  .wizard-input {
+    width: 100%; padding: 6px 10px; margin-top: 6px;
+    background: var(--bg-input); border: 1px solid var(--border);
+    border-radius: 6px; color: var(--text-primary);
+    font-family: var(--font-mono); font-size: 12px;
+  }
+  .wizard-input:focus { outline: none; border-color: var(--accent); }
+  .wizard-dim-row {
+    display: flex; gap: 8px; align-items: center; margin-top: 6px;
+  }
+  .wizard-dim-label {
+    font-family: var(--font-mono); font-size: 11px;
+    color: var(--text-secondary); min-width: 50px;
+  }
+  .wizard-dim-input {
+    width: 80px; padding: 4px 8px;
+    background: var(--bg-input); border: 1px solid var(--border);
+    border-radius: 4px; color: var(--text-primary);
+    font-family: var(--font-mono); font-size: 12px;
+  }
+  .wizard-dim-unit {
+    font-family: var(--font-mono); font-size: 10px;
+    color: var(--text-muted);
+  }
+  .wizard-review-field {
+    display: flex; justify-content: space-between; align-items: center;
+    padding: 4px 0; border-bottom: 1px solid var(--border);
+  }
+  .wizard-review-label {
+    font-family: var(--font-mono); font-size: 10px;
+    color: var(--text-secondary);
+  }
+  .wizard-review-value {
+    font-family: var(--font-mono); font-size: 11px;
+    color: var(--text-primary);
+  }
+  .wizard-btn-row { display: flex; gap: 8px; margin-top: 10px; }
+  .wizard-btn {
+    flex: 1; padding: 8px; border-radius: 6px;
+    font-family: var(--font-mono); font-size: 11px;
+    font-weight: 600; cursor: pointer; border: 1px solid var(--border);
+    transition: background 0.15s;
+  }
+  .wizard-btn-primary {
+    background: var(--accent); color: var(--bg-void); border-color: var(--accent);
+  }
+  .wizard-btn-secondary {
+    background: var(--bg-surface); color: var(--text-secondary);
+  }
+```
+
+- [ ] **Step 2: Add tab bar HTML**
+
+Replace the `chat-header` div (lines 1260-1271) with:
+
+```html
+      <div class="chat-tabs">
+        <button class="chat-tab active" id="tab-chat" onclick="switchTab('chat')">Chat</button>
+        <button class="chat-tab" id="tab-guided" onclick="switchTab('guided')">Guided</button>
+      </div>
+
+      <div class="chat-header">
+        <div class="chat-header-left">
+          <span class="chat-header-title" data-i18n="designChat">Design Chat</span>
+          <button onclick="newDesign()" title="New Design" style="background:none;border:1px solid var(--border);border-radius:4px;color:var(--text-secondary);padding:2px 8px;font-size:10px;cursor:pointer;margin-left:8px;" data-i18n="newBtn">NEW</button>
+          <div class="agent-dots">
+            <div class="agent-dot" style="background: var(--agent-design);" title="Design Agent"></div>
+            <div class="agent-dot" style="background: var(--agent-engineering);" title="Engineering Agent"></div>
+            <div class="agent-dot" style="background: var(--agent-cnc);" title="CNC Agent"></div>
+            <div class="agent-dot" style="background: var(--agent-cad);" title="CAD Coder Agent"></div>
+          </div>
+        </div>
+      </div>
+```
+
+- [ ] **Step 3: Add guided panel HTML after chat-messages div**
+
+After the closing `</div>` of `#chat-messages` (line 1283), add:
+
+```html
+      <div id="guided-panel">
+        <!-- Step 1: Part Type -->
+        <div class="wizard-step" id="wiz-step-1">
+          <div class="wizard-step-header">
+            <span class="wizard-step-title">1. PART TYPE</span>
+            <span class="wizard-step-check" id="wiz-check-1"></span>
+          </div>
+          <div class="wizard-chips">
+            <button class="wizard-chip" onclick="wizSetPart('bracket','Mounting bracket')">Bracket</button>
+            <button class="wizard-chip" onclick="wizSetPart('enclosure','Enclosure housing')">Enclosure</button>
+            <button class="wizard-chip" onclick="wizSetPart('plate','Flat plate')">Plate</button>
+            <button class="wizard-chip" onclick="wizSetPart('shaft','Cylindrical shaft')">Shaft</button>
+            <button class="wizard-chip" onclick="wizSetPart('gear','Spur gear')">Gear</button>
+            <button class="wizard-chip" onclick="wizSetPart('flange','Pipe flange')">Flange</button>
+          </div>
+          <input class="wizard-input" placeholder="Or type custom part name..." onchange="wizSetPart(this.value, this.value)">
+        </div>
+
+        <!-- Step 2: Material -->
+        <div class="wizard-step" id="wiz-step-2">
+          <div class="wizard-step-header">
+            <span class="wizard-step-title">2. MATERIAL</span>
+            <span class="wizard-step-check" id="wiz-check-2"></span>
+          </div>
+          <div class="wizard-chips">
+            <button class="wizard-chip" onclick="wizSetMaterial('aluminum 6061')">Aluminum 6061</button>
+            <button class="wizard-chip" onclick="wizSetMaterial('aluminum 7075')">Aluminum 7075</button>
+            <button class="wizard-chip" onclick="wizSetMaterial('stainless steel 304')">Steel 304</button>
+            <button class="wizard-chip" onclick="wizSetMaterial('stainless steel 316')">Steel 316</button>
+            <button class="wizard-chip" onclick="wizSetMaterial('brass')">Brass</button>
+            <button class="wizard-chip" onclick="wizSetMaterial('titanium')">Titanium</button>
+            <button class="wizard-chip" onclick="wizSetMaterial('nylon')">Nylon</button>
+            <button class="wizard-chip" onclick="wizSetMaterial('delrin')">Delrin</button>
+          </div>
+          <input class="wizard-input" placeholder="Or type custom material..." onchange="wizSetMaterial(this.value)">
+        </div>
+
+        <!-- Step 3: Dimensions -->
+        <div class="wizard-step" id="wiz-step-3">
+          <div class="wizard-step-header">
+            <span class="wizard-step-title">3. DIMENSIONS (mm)</span>
+            <span class="wizard-step-check" id="wiz-check-3"></span>
+          </div>
+          <div class="wizard-dim-row">
+            <span class="wizard-dim-label">Width</span>
+            <input class="wizard-dim-input" id="wiz-dim-width" type="number" onchange="wizSetDim('width', this.value)">
+            <span class="wizard-dim-unit">mm</span>
+          </div>
+          <div class="wizard-dim-row">
+            <span class="wizard-dim-label">Height</span>
+            <input class="wizard-dim-input" id="wiz-dim-height" type="number" onchange="wizSetDim('height', this.value)">
+            <span class="wizard-dim-unit">mm</span>
+          </div>
+          <div class="wizard-dim-row">
+            <span class="wizard-dim-label">Depth</span>
+            <input class="wizard-dim-input" id="wiz-dim-depth" type="number" onchange="wizSetDim('depth', this.value)">
+            <span class="wizard-dim-unit">mm</span>
+          </div>
+        </div>
+
+        <!-- Step 4: Features -->
+        <div class="wizard-step" id="wiz-step-4">
+          <div class="wizard-step-header">
+            <span class="wizard-step-title">4. FEATURES</span>
+            <span class="wizard-step-check" id="wiz-check-4"></span>
+          </div>
+          <div class="wizard-chips">
+            <button class="wizard-chip" id="wiz-feat-holes" onclick="wizToggleFeature(this, 'holes')">Mounting Holes</button>
+            <button class="wizard-chip" id="wiz-feat-fillets" onclick="wizToggleFeature(this, 'fillets')">Fillets</button>
+            <button class="wizard-chip" id="wiz-feat-chamfers" onclick="wizToggleFeature(this, 'chamfers')">Chamfers</button>
+            <button class="wizard-chip" id="wiz-feat-pockets" onclick="wizToggleFeature(this, 'pockets')">Pockets</button>
+            <button class="wizard-chip" id="wiz-feat-slots" onclick="wizToggleFeature(this, 'slots')">Slots</button>
+          </div>
+          <div id="wiz-holes-config" style="display:none;margin-top:8px;">
+            <div class="wizard-dim-row">
+              <span class="wizard-dim-label">Count</span>
+              <input class="wizard-dim-input" id="wiz-hole-count" type="number" value="4" min="1" onchange="wizUpdateHoles()">
+            </div>
+            <div class="wizard-chips" style="margin-top:6px;">
+              <button class="wizard-chip" id="wiz-hole-m3" onclick="wizSetHoleSize('M3')">M3</button>
+              <button class="wizard-chip" id="wiz-hole-m4" onclick="wizSetHoleSize('M4')">M4</button>
+              <button class="wizard-chip selected" id="wiz-hole-m6" onclick="wizSetHoleSize('M6')">M6</button>
+              <button class="wizard-chip" id="wiz-hole-m8" onclick="wizSetHoleSize('M8')">M8</button>
+            </div>
+          </div>
+          <input class="wizard-input" placeholder="Or type custom feature..." onkeydown="if(event.key==='Enter'){wizAddCustomFeature(this.value);this.value='';}">
+        </div>
+
+        <!-- Step 5: Constraints -->
+        <div class="wizard-step" id="wiz-step-5">
+          <div class="wizard-step-header">
+            <span class="wizard-step-title">5. CONSTRAINTS</span>
+            <span class="wizard-step-check" id="wiz-check-5"></span>
+          </div>
+          <div class="wizard-dim-row">
+            <span class="wizard-dim-label">Min wall</span>
+            <input class="wizard-dim-input" id="wiz-min-wall" type="number" value="3" step="0.5" onchange="wizUpdateConstraints()">
+            <span class="wizard-dim-unit">mm</span>
+          </div>
+          <div class="wizard-dim-row">
+            <span class="wizard-dim-label">Max size</span>
+            <input class="wizard-dim-input" id="wiz-max-size" type="number" value="500" onchange="wizUpdateConstraints()">
+            <span class="wizard-dim-unit">mm</span>
+          </div>
+        </div>
+
+        <!-- Step 6: Machining -->
+        <div class="wizard-step" id="wiz-step-6">
+          <div class="wizard-step-header">
+            <span class="wizard-step-title">6. MACHINING</span>
+            <span class="wizard-step-check" id="wiz-check-6"></span>
+          </div>
+          <div class="wizard-chips">
+            <button class="wizard-chip" onclick="wizSetAxis('3-axis', this)">3-axis</button>
+            <button class="wizard-chip" onclick="wizSetAxis('3+2-axis', this)">3+2-axis</button>
+            <button class="wizard-chip" onclick="wizSetAxis('5-axis', this)">5-axis</button>
+            <button class="wizard-chip" onclick="wizSetAxis('', this)">Auto</button>
+          </div>
+        </div>
+
+        <!-- Step 7: Review -->
+        <div class="wizard-step" id="wiz-step-7">
+          <div class="wizard-step-header">
+            <span class="wizard-step-title">7. REVIEW</span>
+            <span class="wizard-step-check" id="wiz-check-7"></span>
+          </div>
+          <div id="wiz-review-content"></div>
+          <div id="wiz-score" style="font-family:var(--font-mono);font-size:11px;color:var(--text-secondary);margin-top:8px;"></div>
+          <div class="wizard-btn-row">
+            <button class="wizard-btn wizard-btn-primary" onclick="wizApprove()">Approve &amp; Generate</button>
+            <button class="wizard-btn wizard-btn-secondary" onclick="switchTab('chat')">Back to Chat</button>
+          </div>
+        </div>
+      </div>
+```
+
+- [ ] **Step 4: Add wizard JavaScript**
+
+Add to the `<script>` section, after the existing state variables:
+
+```javascript
+// ── WIZARD STATE ──────────────────────────────────────
+let activeTab = 'chat';
+let wizHoleSize = 'M6';
+let wizFeatures = new Set();
+
+function switchTab(tab) {
+  activeTab = tab;
+  document.getElementById('tab-chat').classList.toggle('active', tab === 'chat');
+  document.getElementById('tab-guided').classList.toggle('active', tab === 'guided');
+  document.getElementById('chat-messages').classList.toggle('hidden', tab === 'guided');
+  document.querySelector('.chat-header').style.display = tab === 'chat' ? 'flex' : 'none';
+  document.getElementById('guided-panel').classList.toggle('active', tab === 'guided');
+  if (tab === 'guided') syncWizardFromState();
+}
+
+function wizSetPart(name, desc) {
+  designState.part_name = name;
+  designState.description = desc;
+  wizMarkStep(1); saveState();
+  document.querySelectorAll('#wiz-step-1 .wizard-chip').forEach(c => c.classList.remove('selected'));
+  event.target.classList.add('selected');
+}
+
+function wizSetMaterial(mat) {
+  designState.material = mat;
+  wizMarkStep(2); saveState();
+  document.querySelectorAll('#wiz-step-2 .wizard-chip').forEach(c => c.classList.remove('selected'));
+  if (event && event.target) event.target.classList.add('selected');
+}
+
+function wizSetDim(name, val) {
+  if (!designState.dimensions) designState.dimensions = {};
+  const v = parseFloat(val);
+  if (v > 0) designState.dimensions[name] = v;
+  else delete designState.dimensions[name];
+  wizMarkStep(3); saveState();
+}
+
+function wizToggleFeature(el, feat) {
+  if (wizFeatures.has(feat)) {
+    wizFeatures.delete(feat);
+    el.classList.remove('selected');
+  } else {
+    wizFeatures.add(feat);
+    el.classList.add('selected');
+  }
+  if (feat === 'holes') {
+    document.getElementById('wiz-holes-config').style.display = wizFeatures.has('holes') ? 'block' : 'none';
+  }
+  wizRebuildFeatures();
+  wizMarkStep(4); saveState();
+}
+
+function wizSetHoleSize(size) {
+  wizHoleSize = size;
+  document.querySelectorAll('#wiz-holes-config .wizard-chip').forEach(c => c.classList.remove('selected'));
+  document.getElementById('wiz-hole-' + size.toLowerCase()).classList.add('selected');
+  wizRebuildFeatures();
+  saveState();
+}
+
+function wizUpdateHoles() { wizRebuildFeatures(); saveState(); }
+
+function wizRebuildFeatures() {
+  if (!designState.features) designState.features = [];
+  // Remove auto-generated features, keep custom ones
+  designState.features = designState.features.filter(f => f.startsWith('custom:'));
+  if (wizFeatures.has('holes')) {
+    const count = document.getElementById('wiz-hole-count')?.value || 4;
+    designState.features.push(count + 'x ' + wizHoleSize + ' holes');
+  }
+  if (wizFeatures.has('fillets')) designState.features.push('fillets');
+  if (wizFeatures.has('chamfers')) designState.features.push('chamfers');
+  if (wizFeatures.has('pockets')) designState.features.push('pockets');
+  if (wizFeatures.has('slots')) designState.features.push('slots');
+  // Re-add custom features without prefix
+  designState.features = designState.features.map(f => f.replace('custom:', ''));
+}
+
+function wizAddCustomFeature(val) {
+  if (!val.trim()) return;
+  if (!designState.features) designState.features = [];
+  designState.features.push(val.trim());
+  wizMarkStep(4); saveState();
+}
+
+function wizUpdateConstraints() {
+  designState.constraints = [];
+  const wall = document.getElementById('wiz-min-wall')?.value;
+  const size = document.getElementById('wiz-max-size')?.value;
+  if (wall) designState.constraints.push('min wall ' + wall + 'mm');
+  if (size && parseFloat(size) < 500) designState.constraints.push('max size ' + size + 'mm');
+  wizMarkStep(5); saveState();
+}
+
+function wizSetAxis(axis, el) {
+  designState.axis_recommendation = axis;
+  document.querySelectorAll('#wiz-step-6 .wizard-chip').forEach(c => c.classList.remove('selected'));
+  if (el) el.classList.add('selected');
+  wizMarkStep(6); saveState();
+}
+
+function wizMarkStep(n) {
+  const check = document.getElementById('wiz-check-' + n);
+  const step = document.getElementById('wiz-step-' + n);
+  if (check) check.textContent = '\u2713';
+  if (step) step.classList.add('completed');
+  if (n <= 6) wizUpdateReview();
+}
+
+function wizUpdateReview() {
+  const el = document.getElementById('wiz-review-content');
+  if (!el) return;
+  let html = '';
+  const fields = [
+    ['Part', designState.part_name || ''],
+    ['Material', designState.material || ''],
+    ['Dimensions', Object.entries(designState.dimensions || {}).map(([k,v]) => k + '=' + v + 'mm').join(', ') || ''],
+    ['Features', (designState.features || []).join(', ') || ''],
+    ['Constraints', (designState.constraints || []).join(', ') || ''],
+    ['Machining', designState.axis_recommendation || 'Auto'],
+  ];
+  for (const [label, value] of fields) {
+    html += '<div class="wizard-review-field"><span class="wizard-review-label">' + label + '</span><span class="wizard-review-value">' + (value || '\u2014') + '</span></div>';
+  }
+  el.innerHTML = html;
+
+  // Show score
+  const score = wizComputeScore();
+  const scoreEl = document.getElementById('wiz-score');
+  if (scoreEl) scoreEl.textContent = 'Score: ' + score.toFixed(0) + '/8 ' + (score >= 8 ? '\u2713 Ready' : '\u2717 Need more info');
+}
+
+function wizComputeScore() {
+  let s = 0;
+  if (designState.material) s += 3;
+  if (designState.part_name) s += 1;
+  if (designState.description) s += 1;
+  if (designState.axis_recommendation) s += 2;
+  s += Math.min(Object.keys(designState.dimensions || {}).length, 4);
+  s += Math.min((designState.features || []).length, 4);
+  s += Math.min((designState.constraints || []).length, 2);
+  return s;
+}
+
+async function wizApprove() {
+  const plan = {
+    part_name: designState.part_name || '',
+    description: designState.description || '',
+    material: designState.material || '',
+    dimensions: designState.dimensions || {},
+    features: designState.features || [],
+    constraints: designState.constraints || [],
+    axis_recommendation: designState.axis_recommendation || '',
+    machining_notes: [],
+    confidence_score: wizComputeScore(),
+  };
+  try {
+    const resp = await fetch('/api/plan/approve', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ plan: plan, design_state: designState }),
+    });
+    const data = await resp.json();
+    designState = data.design_state;
+    saveState();
+    switchTab('chat');
+    await sendMessage('Generate the approved design');
+  } catch (err) {
+    console.error('Plan approve failed:', err);
+  }
+}
+
+function syncWizardFromState() {
+  // Sync dimension inputs
+  const dims = designState.dimensions || {};
+  for (const key of ['width', 'height', 'depth']) {
+    const el = document.getElementById('wiz-dim-' + key);
+    if (el && dims[key]) el.value = dims[key];
+  }
+  // Sync step checks
+  if (designState.part_name) wizMarkStep(1);
+  if (designState.material) wizMarkStep(2);
+  if (Object.keys(dims).length > 0) wizMarkStep(3);
+  if ((designState.features || []).length > 0) wizMarkStep(4);
+  if ((designState.constraints || []).length > 0) wizMarkStep(5);
+  if (designState.axis_recommendation) wizMarkStep(6);
+  wizUpdateReview();
+}
+```
+
+- [ ] **Step 5: Test manually**
+
+Run: `cd /home/daniel/NeuralCAD && python -m server.web --port 5000`
+Open browser at `http://localhost:5000`. Verify:
+- Tab switcher shows "Chat" and "Guided" tabs
+- Clicking "Guided" shows 7 wizard steps
+- Selecting chips updates designState
+- Dimension inputs work
+- Review step shows accumulated values and score
+- "Back to Chat" switches back
+- State syncs between tabs
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add web/index.html
+git commit -m "feat: add Chat/Guided tab switcher with 7-step wizard"
+```
+
+---
+
+### Task 8: Plan card in chat mode
+
+**Files:**
+- Modify: `web/index.html` (add plan card rendering in `sendMessage`)
+
+- [ ] **Step 1: Add plan card CSS**
+
+Add to the CSS section:
+
+```css
+  /* ---- PLAN CARD ---- */
+  .plan-card {
+    background: var(--bg-surface);
+    border: 1px solid var(--accent);
+    border-radius: 8px;
+    padding: 14px;
+    margin: 8px 0;
+  }
+  .plan-card-title {
+    font-family: var(--font-mono);
+    font-size: 11px;
+    font-weight: 700;
+    color: var(--accent);
+    margin-bottom: 10px;
+  }
+  .plan-card .wizard-review-field { padding: 3px 0; }
+  .plan-card-score {
+    font-family: var(--font-mono); font-size: 11px;
+    color: var(--text-secondary); margin-top: 8px;
+  }
+  .plan-card-actions { display: flex; gap: 8px; margin-top: 10px; }
+  .plan-card-btn {
+    flex: 1; padding: 7px; border-radius: 5px;
+    font-family: var(--font-mono); font-size: 11px;
+    font-weight: 600; cursor: pointer; border: 1px solid var(--border);
+  }
+  .plan-card-approve {
+    background: var(--success); color: var(--bg-void); border-color: var(--success);
+  }
+  .plan-card-reject {
+    background: var(--bg-surface); color: var(--text-secondary);
+  }
+```
+
+- [ ] **Step 2: Add plan card rendering function**
+
+Add to the JavaScript section:
+
+```javascript
+function renderPlanCard(plan) {
+  const fields = [
+    ['Part', plan.part_name],
+    ['Material', plan.material],
+    ['Dimensions', Object.entries(plan.dimensions || {}).map(([k,v]) => k + '=' + v + 'mm').join(', ')],
+    ['Features', (plan.features || []).join(', ')],
+    ['Constraints', (plan.constraints || []).join(', ')],
+    ['Axis', plan.axis_recommendation || 'Auto'],
+  ];
+  let html = '<div class="plan-card" id="active-plan-card">';
+  html += '<div class="plan-card-title">\u25c6 PLAN READY FOR REVIEW</div>';
+  for (const [label, value] of fields) {
+    html += '<div class="wizard-review-field"><span class="wizard-review-label">' + label + '</span><span class="wizard-review-value">' + (value || '\u2014') + '</span></div>';
+  }
+  if (plan.machining_notes && plan.machining_notes.length) {
+    html += '<div class="wizard-review-field"><span class="wizard-review-label">Notes</span><span class="wizard-review-value">' + plan.machining_notes.join('; ') + '</span></div>';
+  }
+  html += '<div class="plan-card-score">Score: ' + (plan.confidence_score || 0).toFixed(0) + '/8</div>';
+  html += '<div class="plan-card-actions">';
+  html += '<button class="plan-card-btn plan-card-approve" onclick="approvePlanCard()">Approve</button>';
+  html += '<button class="plan-card-btn plan-card-reject" onclick="rejectPlanCard()">Reject</button>';
+  html += '</div></div>';
+  return html;
+}
+
+async function approvePlanCard() {
+  const plan = designState.plan;
+  if (!plan) return;
+  try {
+    const resp = await fetch('/api/plan/approve', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ plan: plan, design_state: designState }),
+    });
+    const data = await resp.json();
+    designState = data.design_state;
+    saveState();
+    const card = document.getElementById('active-plan-card');
+    if (card) card.remove();
+    await sendMessage('Generate the approved design');
+  } catch (err) {
+    console.error('Plan approve failed:', err);
+  }
+}
+
+async function rejectPlanCard() {
+  try {
+    const resp = await fetch('/api/plan/reject', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ design_state: designState }),
+    });
+    const data = await resp.json();
+    designState = data.design_state;
+    saveState();
+    const card = document.getElementById('active-plan-card');
+    if (card) card.remove();
+  } catch (err) {
+    console.error('Plan reject failed:', err);
+  }
+}
+```
+
+- [ ] **Step 3: Update sendMessage to render plan card**
+
+In the `sendMessage` function, after `if (data.design_state) { designState = data.design_state; }`, add:
+
+```javascript
+    // If phase transitioned to planning, show plan card
+    if (designState.phase === 'planning' && designState.plan) {
+      const old = document.getElementById('active-plan-card');
+      if (old) old.remove();
+      const msgs = document.getElementById('chat-messages');
+      const cardDiv = document.createElement('div');
+      cardDiv.innerHTML = renderPlanCard(designState.plan);
+      msgs.appendChild(cardDiv.firstChild);
+      msgs.scrollTop = msgs.scrollHeight;
+    }
+```
+
+- [ ] **Step 4: Test manually**
+
+Run the dev server and test:
+- Chat enough info to cross the scoring threshold (material + dimensions + axis)
+- Verify plan card appears inline in chat
+- Click "Approve" — should trigger generation
+- On a fresh conversation, click "Reject" — card should disappear, chat continues
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add web/index.html
+git commit -m "feat: add inline plan card in chat with approve/reject"
+```
+
+---
+
+### Task 9: Download panel with 3MF
+
+**Files:**
+- Modify: `web/index.html:1230-1234` (add 3MF button to download panel)
+- Modify: `web/index.html:2257-2274` (update `updateDownloads` function)
+- Modify: `web/index.html:2352-2355` (update gallery card downloads)
+
+- [ ] **Step 1: Add 3MF download button**
+
+In the download buttons div (line 1230-1234), add the 3MF button:
+
+```html
+      <div id="download-btns">
+        <a class="dl-btn" id="dl-step" download>STEP</a>
+        <a class="dl-btn" id="dl-stl" download>STL</a>
+        <a class="dl-btn" id="dl-3mf" download>3MF</a>
+        <a id="dl-gcode" class="dl-btn" download style="display:none"><span class="dl-icon">&#8615;</span> G-CODE</a>
+        <a class="dl-btn" id="dl-report" download>REPORT</a>
+      </div>
+```
+
+- [ ] **Step 2: Update updateDownloads function**
+
+In the `updateDownloads` function, add 3MF URL:
+
+```javascript
+function updateDownloads(partName) {
+  const el = document.getElementById('download-btns');
+  if (!partName) { el.classList.remove('visible'); return; }
+  el.classList.add('visible');
+
+  document.getElementById('dl-step').href = '/api/models/' + partName + '.step';
+  document.getElementById('dl-stl').href = '/api/models/' + partName + '.stl';
+  document.getElementById('dl-3mf').href = '/api/models/' + partName + '.3mf';
+  document.getElementById('dl-report').href = '/api/models/' + partName + '_report.json';
+
+  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'; });
+  }
+}
+```
+
+- [ ] **Step 3: Update gallery card downloads**
+
+Find the gallery card download section (around line 2352) and add 3MF:
+
+```javascript
+    html += '<div class="gallery-card-downloads">';
+    html += '<a class="gallery-dl" href="/api/models/' + name + '.step" download>STEP</a>';
+    html += '<a class="gallery-dl" href="/api/models/' + name + '.stl" download>STL</a>';
+    html += '<a class="gallery-dl" href="/api/models/' + name + '.3mf" download>3MF</a>';
+    html += '<a class="gallery-dl" href="/api/models/' + name + '.gcode" download>GCODE</a>';
+```
+
+- [ ] **Step 4: Test manually**
+
+Run dev server, generate a model, verify:
+- STEP, STL, 3MF buttons all visible after generation
+- G-CODE button only visible when CAM has run
+- Gallery cards show all 4 download options
+- All downloads work (correct file served)
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add web/index.html
+git commit -m "feat: add 3MF download button and update gallery cards"
+```
+
+---
+
+### Task 10: i18n entries for new UI
+
+**Files:**
+- Modify: `web/index.html` (add translations to `I18N` object)
+
+- [ ] **Step 1: Add i18n keys**
+
+Add to the `I18N.en` object:
+
+```javascript
+    tabChat: 'Chat',
+    tabGuided: 'Guided',
+    wizPartType: '1. PART TYPE',
+    wizMaterial: '2. MATERIAL',
+    wizDimensions: '3. DIMENSIONS (mm)',
+    wizFeatures: '4. FEATURES',
+    wizConstraints: '5. CONSTRAINTS',
+    wizMachining: '6. MACHINING',
+    wizReview: '7. REVIEW',
+    wizApprove: 'Approve & Generate',
+    wizBackToChat: 'Back to Chat',
+    planReady: 'PLAN READY FOR REVIEW',
+    planApprove: 'Approve',
+    planReject: 'Reject',
+    planScoreReady: 'Ready',
+    planScoreNeed: 'Need more info',
+```
+
+Add corresponding entries to `I18N['zh-TW']`:
+
+```javascript
+    tabChat: '\u5c0d\u8a71',
+    tabGuided: '\u5f15\u5c0e',
+    wizPartType: '1. \u96f6\u4ef6\u985e\u578b',
+    wizMaterial: '2. \u6750\u6599',
+    wizDimensions: '3. \u5c3a\u5bf8 (mm)',
+    wizFeatures: '4. \u7279\u5fb5',
+    wizConstraints: '5. \u7d04\u675f',
+    wizMachining: '6. \u52a0\u5de5',
+    wizReview: '7. \u5be9\u67e5',
+    wizApprove: '\u6279\u51c6\u4e26\u751f\u6210',
+    wizBackToChat: '\u8fd4\u56de\u5c0d\u8a71',
+    planReady: '\u8a08\u756b\u5df2\u6e96\u5099\u5be9\u67e5',
+    planApprove: '\u6279\u51c6',
+    planReject: '\u62d2\u7d55',
+    planScoreReady: '\u5df2\u5c31\u7dd2',
+    planScoreNeed: '\u9700\u8981\u66f4\u591a\u8cc7\u8a0a',
+```
+
+Add corresponding entries to `I18N.vi`:
+
+```javascript
+    tabChat: 'Tr\u00f2 Chuy\u1ec7n',
+    tabGuided: 'H\u01b0\u1edbng D\u1eabn',
+    wizPartType: '1. LO\u1ea0I CHI TI\u1ebET',
+    wizMaterial: '2. V\u1eacT LI\u1ec6U',
+    wizDimensions: '3. K\u00cdCH TH\u01af\u1edaC (mm)',
+    wizFeatures: '4. T\u00cdNH N\u0102NG',
+    wizConstraints: '5. R\u00c0NG BU\u1ed8C',
+    wizMachining: '6. GIA C\u00d4NG',
+    wizReview: '7. XEM L\u1ea0I',
+    wizApprove: 'Duy\u1ec7t & T\u1ea1o',
+    wizBackToChat: 'V\u1ec1 Tr\u00f2 Chuy\u1ec7n',
+    planReady: 'K\u1ebe HO\u1ea0CH S\u1eb4N S\u00c0NG',
+    planApprove: 'Duy\u1ec7t',
+    planReject: 'T\u1eeb Ch\u1ed1i',
+    planScoreReady: 'S\u1eb5n s\u00e0ng',
+    planScoreNeed: 'C\u1ea7n th\u00eam th\u00f4ng tin',
+```
+
+- [ ] **Step 2: Apply `data-i18n` attributes to new HTML elements**
+
+Add `data-i18n` attributes to the tab buttons and wizard step titles so `applyTranslations()` picks them up.
+
+- [ ] **Step 3: Test i18n**
+
+Run dev server, switch language to zh-TW and VI, verify wizard labels translate.
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add web/index.html
+git commit -m "feat: add i18n translations for wizard and plan card UI"
+```
+
+---
+
+### Task 11: Full integration test
+
+**Files:**
+- Run all tests and manual verification
+
+- [ ] **Step 1: Run full test suite**
+
+Run: `cd /home/daniel/NeuralCAD && python -m pytest tests/ -v --tb=short`
+Expected: All pass
+
+- [ ] **Step 2: Manual end-to-end test — Chat flow**
+
+Run: `cd /home/daniel/NeuralCAD && python -m server.web --port 5000`
+
+1. Open `http://localhost:5000`
+2. Chat: "I need a servo bracket, 60mm wide, 40mm high, 20mm deep, aluminum 6061, 4x M6 holes, 3-axis"
+3. Verify plan card appears (score should be >= 8)
+4. Click "Approve" on the plan card
+5. Verify CAD generation triggers
+6. Verify 3D preview loads
+7. Verify downloads: STEP, STL, 3MF all work
+8. Verify G-CODE appears if CAM agent ran
+
+- [ ] **Step 3: Manual end-to-end test — Guided flow**
+
+1. Click "NEW" to reset
+2. Switch to "Guided" tab
+3. Step through: Bracket → Aluminum 6061 → 60/40/20 → M6 holes → min wall 3mm → 3-axis
+4. Review step shows all values, score >= 8
+5. Click "Approve & Generate"
+6. Verify switches to Chat, generation message sent
+7. Verify 3D preview and downloads
+
+- [ ] **Step 4: Manual test — Reject flow**
+
+1. In chat, accumulate enough info for plan card to appear
+2. Click "Reject"
+3. Verify card disappears, phase resets to "exploring"
+4. Continue chatting normally
+
+- [ ] **Step 5: Manual test — Language switching**
+
+1. Switch to zh-TW
+2. Open Guided tab — verify labels are in Chinese
+3. Switch to VI — verify Vietnamese translations
+
+- [ ] **Step 6: Commit any fixes**
+
+```bash
+git add -A
+git commit -m "fix: integration test fixes for planning review gate"
+```