feat: add DesignState memory + localStorage persistence

- agents/design_state.py: Pydantic DesignState model with regex-based
extraction of materials, dimensions, fasteners, axis recommendations,
and design decisions from agent messages (no extra LLM call)
- agents/prompts.py: inject "Current Design Spec" block into LLM
context so decisions survive history truncation
- agents/orchestrator.py: both orchestrators maintain and return
design_state across turns
- server/routes.py: pass design_state through API
- web/index.html: localStorage persistence for chat history and
design state, restore on page load, "NEW" button to start fresh

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

agents/crew_orchestrator.py

@@ -10,10 +10,7 @@ Note: Falls back to SingleCallOrchestrator if CrewAI is not installed.
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Optional
 
-from agents.definitions import AGENTS, AGENT_COLORS, AGENT_NAMES, AGENT_AVATARS
-from agents.prompts import route_by_keywords
 
 
 DEFAULT_OUTPUT_DIR = Path(__file__).parent.parent / "output"
@@ -46,13 +43,14 @@ class CrewOrchestrator:
         history: list[dict],
         mentions: list[str] | None = None,
         max_history: int = 30,
+        design_state: dict | None = None,
     ) -> dict:
         """Run one chat turn using CrewAI multi-call process.
 
         Falls back to SingleCallOrchestrator if CrewAI is not available.
 
         Returns same format as SingleCallOrchestrator:
-            {"responses": [...], "preview": None | {...}}
+            {"responses": [...], "preview": None | {...}, "design_state": {...}}
         """
         if not self._crew_available:
             # Fallback to single-call
@@ -67,12 +65,12 @@ class CrewOrchestrator:
             except Exception:
                 from agents.orchestrator import MockChatBackend
                 mock = MockChatBackend()
-                return mock.chat_turn(message, history, mentions)
+                return mock.chat_turn(message, history, mentions, design_state=design_state)
 
             orchestrator = SingleCallOrchestrator(
                 backend=backend, output_dir=self.output_dir
             )
-            return orchestrator.chat_turn(message, history, mentions, max_history)
+            return orchestrator.chat_turn(message, history, mentions, max_history, design_state=design_state)
 
         # TODO: Implement CrewAI hierarchical process
         # For now, delegate to single-call as well
@@ -87,9 +85,9 @@ class CrewOrchestrator:
         except Exception:
             from agents.orchestrator import MockChatBackend
             mock = MockChatBackend()
-            return mock.chat_turn(message, history, mentions)
+            return mock.chat_turn(message, history, mentions, design_state=design_state)
 
         orchestrator = SingleCallOrchestrator(
             backend=backend, output_dir=self.output_dir
         )
-        return orchestrator.chat_turn(message, history, mentions, max_history)
+        return orchestrator.chat_turn(message, history, mentions, max_history, design_state=design_state)

agents/design_state.py

@@ -0,0 +1,175 @@
+"""Design state accumulator — extracts and persists key decisions from agent messages."""
+
+from __future__ import annotations
+
+import re
+from pydantic import BaseModel, Field
+
+
+class DesignState(BaseModel):
+    """Structured state tracking design decisions across chat turns."""
+    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)
+    decisions: list[str] = Field(default_factory=list)
+    axis_recommendation: str = ""
+
+    def render(self) -> str:
+        """Render non-empty fields as a concise spec block for LLM context."""
+        lines = []
+        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.decisions:
+            lines.append("Decisions:")
+            for d in self.decisions[-5:]:  # Last 5 decisions to keep it concise
+                lines.append(f"  - {d}")
+        return "\n".join(lines) if lines else ""
+
+
+# ── Material patterns ──────────────────────────────────────────────────────
+
+_MATERIALS = [
+    "aluminum", "aluminium", "steel", "stainless steel", "brass", "copper",
+    "titanium", "nylon", "delrin", "acetal", "abs", "polycarbonate", "peek",
+]
+_MATERIAL_GRADES = {
+    "6061": "aluminum 6061", "7075": "aluminum 7075",
+    "304": "stainless steel 304", "316": "stainless steel 316",
+    "t6": "aluminum 6061-T6",
+}
+
+# ── Dimension context words ────────────────────────────────────────────────
+
+_DIM_CONTEXTS = {
+    "wide": "width", "width": "width",
+    "tall": "height", "height": "height", "high": "height",
+    "thick": "thickness", "thickness": "thickness",
+    "deep": "depth", "depth": "depth",
+    "long": "length", "length": "length",
+    "diameter": "diameter", "dia": "diameter",
+    "radius": "radius",
+    "arm": "arm_length",
+}
+
+
+def extract_decisions(
+    agent_responses: list[dict],
+    current_state: DesignState,
+    user_message: str = "",
+) -> DesignState:
+    """Extract design decisions from agent responses and update state.
+
+    Uses regex/keyword matching — no extra LLM call.
+    """
+    state = current_state.model_copy(deep=True)
+
+    # Combine all text for scanning
+    all_text = user_message + " " + " ".join(r.get("message", "") for r in agent_responses)
+    lower = all_text.lower()
+
+    # Extract material
+    for grade, full_name in _MATERIAL_GRADES.items():
+        if grade in lower:
+            state.material = full_name
+            break
+    else:
+        for mat in _MATERIALS:
+            if mat in lower:
+                state.material = mat
+                break
+
+    # Extract dimensions: "60mm wide", "width of 60mm", "60 mm thick"
+    dim_pattern = re.compile(
+        r'(\d+\.?\d*)\s*mm\s+(' + '|'.join(_DIM_CONTEXTS.keys()) + r')',
+        re.IGNORECASE,
+    )
+    for match in dim_pattern.finditer(all_text):
+        value = float(match.group(1))
+        word = match.group(2).lower()
+        dim_name = _DIM_CONTEXTS.get(word, word)
+        state.dimensions[dim_name] = value
+
+    # Also match "width: 60mm" or "width of 60mm" patterns
+    dim_pattern2 = re.compile(
+        r'(' + '|'.join(_DIM_CONTEXTS.keys()) + r')\s*(?:of|:|\s)\s*(\d+\.?\d*)\s*mm',
+        re.IGNORECASE,
+    )
+    for match in dim_pattern2.finditer(all_text):
+        word = match.group(1).lower()
+        value = float(match.group(2))
+        dim_name = _DIM_CONTEXTS.get(word, word)
+        state.dimensions[dim_name] = value
+
+    # Extract fastener features: "4x M6 holes", "M4 clearance holes"
+    fastener_pattern = re.compile(r'(\d+)\s*[x\u00d7]\s*(M\d+)\s+\w*\s*hole', re.IGNORECASE)
+    for match in fastener_pattern.finditer(all_text):
+        feature = f"{match.group(1)}x {match.group(2).upper()} holes"
+        if feature not in state.features:
+            state.features.append(feature)
+
+    # Single fastener mention: "M6 holes", "M3 clearance holes"
+    single_fastener = re.compile(r'(M\d+)\s+(?:clearance\s+)?(?:hole|bolt|screw)', re.IGNORECASE)
+    for match in single_fastener.finditer(all_text):
+        feature = f"{match.group(1).upper()} holes"
+        if feature not in state.features and not any(feature.split()[0] in f for f in state.features):
+            state.features.append(feature)
+
+    # Extract axis recommendation
+    axis_pattern = re.compile(r'(3-axis|3\+2[\s-]*axis|5-axis)', re.IGNORECASE)
+    axis_match = axis_pattern.search(all_text)
+    if axis_match:
+        state.axis_recommendation = axis_match.group(1).lower()
+
+    # Extract constraint keywords
+    constraint_patterns = [
+        (r'min(?:imum)?\s+wall\s+(?:thickness\s+)?(\d+\.?\d*)\s*mm', "min wall {}mm"),
+        (r'max(?:imum)?\s+(?:part\s+)?size\s+(\d+\.?\d*)\s*mm', "max size {}mm"),
+    ]
+    for pattern, template in constraint_patterns:
+        match = re.search(pattern, all_text, re.IGNORECASE)
+        if match:
+            constraint = template.format(match.group(1))
+            if constraint not in state.constraints:
+                state.constraints.append(constraint)
+
+    # Extract decisions: sentences with agreement language from agent messages only
+    for resp in agent_responses:
+        msg = resp.get("message", "")
+        sentences = re.split(r'[.!?]+', msg)
+        for sentence in sentences:
+            s = sentence.strip()
+            if len(s) > 15 and any(kw in s.lower() for kw in [
+                "recommend", "suggest", "should use", "let's go with",
+                "i'd use", "best to", "we'll need", "i'll specify",
+            ]):
+                if s not in state.decisions and len(state.decisions) < 20:
+                    state.decisions.append(s)
+
+    # Extract part name from user message if not set
+    if not state.part_name and user_message:
+        name_patterns = [
+            r'(?:need|want|design|make|create)\s+(?:a|an)\s+(.{5,40?})\s*(?:with|for|that|,|$)',
+        ]
+        for pattern in name_patterns:
+            match = re.search(pattern, user_message, re.IGNORECASE)
+            if match:
+                state.part_name = match.group(1).strip()
+                break
+
+    return state

agents/orchestrator.py

@@ -25,6 +25,7 @@ from agents.prompts import (
     parse_orchestrator_response,
     CAD_TRIGGER_KEYWORDS,
 )
+from agents.design_state import DesignState, extract_decisions
 from core.backends import LLMBackend, MockBackend
 from core.executor import execute_cadquery, export_all
 from core.validator import validate_for_cnc
@@ -154,8 +155,10 @@ class MockChatBackend:
         history: list[dict],
         mentions: list[str] | None = None,
         max_history: int = 30,
+        design_state: dict | None = None,
     ) -> dict:
-        """Return ``{"responses": [...], "preview": ...}``."""
+        """Return ``{"responses": [...], "preview": ..., "design_state": ...}``."""
+        state = DesignState(**(design_state or {}))
         lower = message.lower()
 
         # Determine which agents respond
@@ -197,7 +200,10 @@ class MockChatBackend:
             )
             preview = _execute_cad_code(code, message, self.output_dir)
 
-        return {"responses": responses, "preview": preview}
+        # Update design state from responses
+        updated_state = extract_decisions(responses, state, message)
+
+        return {"responses": responses, "preview": preview, "design_state": updated_state.model_dump()}
 
     # -- canned response templates -------------------------------------------
 
@@ -283,6 +289,7 @@ class SingleCallOrchestrator:
         history: list[dict],
         mentions: list[str] | None = None,
         max_history: int = 30,
+        design_state: dict | None = None,
     ) -> dict:
         """Run one chat turn: user message -> agent responses.
 
@@ -291,10 +298,13 @@ class SingleCallOrchestrator:
             history: Previous messages [{role, agent_id, content}, ...].
             mentions: Agent IDs explicitly mentioned by user. ``None`` = auto-route.
             max_history: Max history messages to include in context.
+            design_state: Persisted design state dict from previous turns.
 
         Returns:
-            ``{"responses": [...], "preview": None | {...}}``
+            ``{"responses": [...], "preview": None | {...}, "design_state": {...}}``
         """
+        state = DesignState(**(design_state or {}))
+
         # Determine which agents are active
         active_agents = mentions if mentions else None  # None lets orchestrator decide
 
@@ -315,6 +325,7 @@ class SingleCallOrchestrator:
             history=history,
             system_prompt=system_prompt,
             max_history=max_history,
+            design_state_text=state.render(),
         )
 
         # Single LLM call
@@ -350,7 +361,10 @@ class SingleCallOrchestrator:
                     resp["code"], message, self.output_dir, backend=self.backend,
                 )
 
-        return {"responses": formatted, "preview": preview}
+        # Update design state from responses
+        updated_state = extract_decisions(formatted, state, message)
+
+        return {"responses": formatted, "preview": preview, "design_state": updated_state.model_dump()}
 
 
 # ---------------------------------------------------------------------------

agents/prompts.py

@@ -99,6 +99,7 @@ def build_chat_messages(
     history: list[dict],
     system_prompt: str,
     max_history: int = 30,
+    design_state_text: str = "",
 ) -> list[dict]:
     """Build the message list for the orchestrator LLM call.
 
@@ -107,6 +108,7 @@ def build_chat_messages(
         history: Previous messages [{role, agent_id, content}, ...].
         system_prompt: The orchestrator system prompt.
         max_history: Maximum number of history messages to include.
+        design_state_text: Rendered design state spec to inject as context.
     """
     messages = [{"role": "system", "content": system_prompt}]
 
@@ -115,6 +117,9 @@ def build_chat_messages(
 
     # Bundle history into a single context block to avoid Gemini
     # treating prior agent messages as its own output and repeating them.
+    content_parts = []
+    if design_state_text:
+        content_parts.append(f"## Current Design Spec (agreed so far)\n{design_state_text}\n")
     if recent:
         history_lines = []
         for msg in recent:
@@ -126,14 +131,10 @@ def build_chat_messages(
                 history_lines.append(f"{agent_name.upper()}: {msg['content']}")
 
         history_block = "\n".join(history_lines)
-        messages.append({
-            "role": "user",
-            "content": f"## Conversation so far:\n{history_block}\n\n"
-                       f"## User's new message:\n{user_message}\n\n"
-                       "Respond to the user's NEW message above. Do NOT repeat prior responses."
-        })
-    else:
-        messages.append({"role": "user", "content": user_message})
+        content_parts.append(f"## Conversation so far:\n{history_block}\n")
+    content_parts.append(f"## User's new message:\n{user_message}\n\nRespond to the user's NEW message above. Do NOT repeat prior responses.")
+
+    messages.append({"role": "user", "content": "\n".join(content_parts)})
 
     return messages
 

server/routes.py

@@ -33,6 +33,7 @@ class ChatRequest(BaseModel):
     history: list[ChatMessage] = Field(default_factory=list)
     mentions: list[str] = Field(default_factory=list)
     backend: str = "mock"
+    design_state: dict = Field(default_factory=dict)
 
 
 class ReportRequest(BaseModel):
@@ -74,6 +75,7 @@ async def chat(body: ChatRequest):
             message=message,
             history=history,
             mentions=mentions,
+            design_state=body.design_state,
         )
         return JSONResponse(result)
     except Exception as e:

web/index.html

@@ -1143,6 +1143,7 @@
       <div class="chat-header">
         <div class="chat-header-left">
           <span class="chat-header-title">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;">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>
@@ -1244,6 +1245,7 @@
 
 let currentBackend = 'mock';
 let chatHistory = [];
+let designState = {};
 let chatPanelOpen = true;
 let currentPartName = '';
 let currentCode = '';
@@ -1252,6 +1254,58 @@ const galleryItems = [];
 let mentionActive = false;
 let mentionIndex = 0;
 
+// Persist/restore from localStorage
+function saveState() {
+  try {
+    localStorage.setItem('neuralcad_history', JSON.stringify(chatHistory));
+    localStorage.setItem('neuralcad_state', JSON.stringify(designState));
+  } catch (e) { /* quota exceeded, ignore */ }
+}
+
+function loadState() {
+  try {
+    const h = localStorage.getItem('neuralcad_history');
+    const s = localStorage.getItem('neuralcad_state');
+    if (h) chatHistory = JSON.parse(h);
+    if (s) designState = JSON.parse(s);
+  } catch (e) { /* corrupted, ignore */ }
+}
+
+function clearState() {
+  chatHistory = [];
+  designState = {};
+  localStorage.removeItem('neuralcad_history');
+  localStorage.removeItem('neuralcad_state');
+}
+
+function newDesign() {
+  if (!confirm('Start a new design? Current conversation will be cleared.')) return;
+  clearState();
+  // Clear chat UI
+  const msgs = document.getElementById('chat-messages');
+  if (msgs) msgs.innerHTML = '';
+  // Show examples again
+  const examples = document.getElementById('quick-examples');
+  if (examples) examples.style.display = '';
+  // Clear 3D viewer
+  if (currentMesh) {
+    scene.remove(currentMesh);
+    currentMesh.geometry.dispose();
+    currentMesh.material.dispose();
+    currentMesh = null;
+  }
+  // Hide overlays
+  const geo = document.getElementById('geo-stats');
+  if (geo) geo.classList.remove('visible');
+  const cnc = document.getElementById('cnc-badge');
+  if (cnc) cnc.classList.remove('visible');
+  const dl = document.getElementById('download-btns');
+  if (dl) dl.classList.remove('visible');
+  // Show empty state
+  const empty = document.getElementById('viewer-empty');
+  if (empty) empty.style.display = '';
+}
+
 const AGENTS = {
   design:      { name: 'Design',      color: '#7c3aed', avatar: 'D' },
   engineering: { name: 'Engineering', color: '#00b4d8', avatar: 'E' },
@@ -1440,11 +1494,13 @@ async function sendMessage(text) {
         history: chatHistory,
         mentions: mentions,
         backend: currentBackend,
+        design_state: designState,
       }),
     });
 
     // Add to history AFTER sending (so it's included in future turns)
     chatHistory.push({ role: 'user', content: text });
+    saveState();
     const data = await resp.json();
 
     hideTyping();
@@ -1463,6 +1519,11 @@ async function sendMessage(text) {
       chatHistory.push({ role: 'agent', agent_id: r.agent_id, content: r.message });
     }
 
+    if (data.design_state) {
+      designState = data.design_state;
+    }
+    saveState();
+
     // If preview available, load 3D model
     if (data.preview && data.preview.success) {
       setViewerLoading(true, 'LOADING 3D MODEL...');
@@ -1907,6 +1968,16 @@ document.addEventListener('keydown', (e) => {
 initViewer();
 checkServer();
 setInterval(checkServer, 15000);
+
+loadState();
+// Re-render restored messages
+if (chatHistory.length > 0) {
+  const examples = document.getElementById('quick-examples');
+  if (examples) examples.style.display = 'none';
+  for (const msg of chatHistory) {
+    addMessage(msg);
+  }
+}
 </script>
 </body>
 </html>