cyclecad 3.10.4 → 3.11.0

package/HANDOFF-2026-04-24.md

@@ -0,0 +1,90 @@
+# Handoff — 2026-04-24 session → next chat
+
+Drop this file into the next chat (or tell Claude to read it). Covers both cycleCAD and ExplodeView.
+
+## Who I am
+- SACHIN (vvlars@googlemail.com, GitHub vvlars-cmd)
+- Two repos: `~/cyclecad` (parametric 3D CAD modeler) + `~/explodeview` (CAD viewer for STEP files)
+- Working style: fast iteration, minimal clarifying questions, terminal-paste commands via clipboard, Safari private window for testing
+- Full memory is in `~/cyclecad/CLAUDE.md` and `~/explodeview/CLAUDE.md` — read those first if you need historical context
+
+## What shipped this session
+- **ExplodeView v1.0.22 / v304** live on npm + GitHub Pages
+  - Commit `b47d6a9` (code) + `41471f3` (version bump)
+  - Rewrote `buildPrompt()` in `docs/demo/app.js` line 6595 with preservation-first logic
+  - Added "No Style" preset (`presetSuffixes.none = ''`) + button in `docs/demo/index.html`
+  - Cache bump 303 → 304, version badge updated
+  - Fixes the "Nano Banana v2 ignores the reference CAD object" problem from the 2026-04-24 diagnosis
+- **cycleCAD@3.10.4** confirmed live on npm (from earlier in the day — gear/pulley/shaft AI Copilot templates)
+- **cycleCAD/CLAUDE.md** updated with the new AI Engineering Analyst roadmap spec (see below)
+
+## Top pending item — AI Engineering Analyst (the big one)
+
+**Source of inspiration**: MecAgent demo screenshots in `/Users/sachin/Desktop/mec` (12 PNGs from 11:49–11:51). The demo runs inside Autodesk Inventor and solves a complete bolted joint problem in natural language — parses "4×M12 10.9 bolts, 18kN shear, 18kN axial, 420Nm moment, μ=0.16, preload 39kN, BCD 96mm, K_s=1.5", walks through slip/tension/combined-stress checks with equations, cites textbook pages ("Analysis and Design of Machine Elements" by Wei Jiang, Wiley p.85), verdict "safe".
+
+**Why this matters**: cycleCAD's existing `ai-copilot.js` builds geometry (gears, bolts, flanges), `fusion-simulation.js` has stubbed FEA, `validate.designReview` returns A-F heuristic scores. None of them answer an engineering question with analytical methods and source citations. This is the biggest competitive gap vs MecAgent and the clearest proof of cycleCAD's "agent-first for manufacturing" positioning.
+
+**Target file**: `app/js/modules/ai-engineer.js` (~800–1200 lines)
+
+**Scope v1 — bolted joint (VDI 2230 / Shigley)**:
+- Analytical core: pure JS math, no LLM — functions like `checkSlipResistance({z, Q_F, mu, F_shear, K_s})`, `computeMomentLoad({M, r_i})`, `vonMises({sigma, tau})`
+- Input form: bolt grade (4.6–12.9 dropdown with proof/tensile strength table), count, thread size (M3–M36), preload, external loads (F_shear/F_axial/M + BCD), μ, safety factor target
+- Output: stepwise LaTeX equations (KaTeX preferred over MathJax — faster load, smaller bundle), pass/fail badges per check, final verdict
+- Reuses Fastener Wizard bolt patterns + selected-assembly context as implicit inputs
+
+**Scope v2 — other machine elements**:
+- Spur/helical gear pair (AGMA bending + pitting stress)
+- Shaft fatigue (Goodman/Soderberg, stress concentration at keyways/shoulders)
+- Rolling bearing L10 life (C/P^n relation, dynamic vs static load)
+- Fillet weld sizing (throat stress, weld leg from applied loads)
+
+**RAG / citations**:
+- Let user upload their own machine-element PDF → chunk + embed locally with `@xenova/transformers` MiniLM-L6-v2 → store in IndexedDB
+- Bundled fallback corpus: public-domain machine-element references + legally-redistributable DIN/ISO standard excerpts
+- Every equation gets `{source: "X", page: N}` metadata → rendered as footnote with "Open Document" button (mimics MecAgent UX exactly)
+
+**LLM layer**:
+- Same provider stack as `ai-copilot.js` (Claude Sonnet 4.6 paid, Gemini 2.0 Flash free, Groq Llama 3.3 70B free — already wired)
+- Tool-use pattern: LLM parses natural-language problem → emits structured params → calls analytical JS functions → gets numeric result → writes narrative around it. LLM never fabricates numbers.
+
+**UI**:
+- New "Engineer" tab in right panel alongside existing Properties / Chat / Guide / Parameters
+- Input form at top, stepwise calculation log in middle, citations panel at bottom
+
+## Other pending items (from CLAUDE.md)
+
+### cycleCAD
+- More AI Copilot templates in `app/js/modules/ai-copilot.js` `matchTemplate()` — mounting bracket variants, T-slot extrusions (40/40, 80/40), ball/roller bearings, bearing cutouts. Same pattern as the gear/pulley/shaft block in 3.10.4. Would ship as `3.10.5`.
+- Polyline → geometry support in mini-executor (unblocks true involute gear teeth — today's gear template is a blank cylinder)
+- Dynamic version badge in status bar (currently hardcoded `v0.9.0`, should fetch from package.json)
+- Wire splash buttons (New Sketch / Open-Import / Text-to-CAD / Inventor Project) to actually trigger their actions
+- Run `app/test-agent.html` (113 tests, 15 categories) in Chrome and fix failures
+- Text-to-CAD with live preview
+- Photo-to-CAD reverse engineering
+- 138MB STEP import via server-side `server/converter.py` (safer than opencascade.js v293 path)
+- Docker compose local test
+
+### ExplodeView
+- **Compositing render** for guaranteed CAD preservation: render 3D with transparent background, send only the cropped background region to Nano Banana, composite the 3D foreground over the generated background in canvas. Bypasses "generative ≠ inpainting" completely. Probably the right follow-up to v304.
+- Run `docs/demo/killer-features-test.html` in Chrome, fix failures
+- The `block-only-in-chrome` user report — needs repro
+
+## Critical operational context (don't forget)
+- **Git lock dance**: VM commits leave stale `.git/*.lock` files. Always give ONE combined command: `rm -f ~/REPO/.git/index.lock ~/REPO/.git/HEAD.lock && cd ~/REPO && git add ... && git commit -m "..." && git push origin main`
+- **Clipboard delivery**: Commands go via `mcp__computer-use__write_clipboard` → user pastes in Terminal. Must switch OFF Terminal (make Chrome or other app frontmost) before writing — Terminal is tier-"click" and blocks clipboard writes when it's frontmost.
+- **Egress allowlist**: `explodeview.com` and `cyclecad.com` are NOT on the allowlist. Use `npm registry` (allowed) to verify version bumps. For live-site verification, either ask user to add domain to Settings → Capabilities, or use the Claude-in-Chrome MCP.
+- **Deferred tools**: All tools show as names in the prompt but schemas are loaded on demand via ToolSearch. Load `computer-use` in bulk: `{query: "computer-use", max_results: 30}`. Load `chrome`: `{query: "chrome", max_results: 20}`.
+- **GitHub Pages concurrent-deploy fix** shipped 2026-04-24 in `.github/workflows/pages.yml` with `concurrency: group: pages, cancel-in-progress: true`. If Pages fails with "deployment in progress" again, that's the first check.
+
+## Current npm versions
+- cyclecad: **3.10.4** (next bump should be 3.10.5 if AI Copilot templates added, or 3.11.0 if AI Engineering Analyst ships)
+- explodeview: **1.0.22**
+
+## Latest commits
+- ExplodeView: `41471f3` v1.0.22 tag, `b47d6a9` v304 code
+- cycleCAD: HEAD has CLAUDE.md modified locally (untracked pentacad/mockups/machines files present — leave alone unless asked)
+
+## How to resume
+1. Read `~/cyclecad/CLAUDE.md` and `~/explodeview/CLAUDE.md` for full history
+2. If continuing AI Engineering Analyst: start with `app/js/modules/ai-engineer.js` skeleton — define the analytical functions for bolted joint first (pure math, no LLM), unit-test them against MecAgent's numbers from the screenshots (F_friction = 24960 N, F_max_tensile = 6687.5 N, σ_vm = 558 MPa), THEN wire in KaTeX rendering, THEN LLM layer, THEN RAG
+3. If continuing something else: ask me which of the pending items to prioritize

package/app/index.html

@@ -1014,6 +1014,7 @@
       <button class="menu-item-link" data-action="tools-marketplace">Marketplace...</button>
       <div class="menu-separator"></div>
       <button class="menu-item-link" data-action="tools-ai-copilot">✨ AI Copilot (multi-step)</button>
+      <button class="menu-item-link" data-action="tools-ai-engineer">🔩 AI Engineering Analyst</button>
       <button class="menu-item-link" data-action="tools-text-to-cad">Text-to-CAD (AI)</button>
       <button class="menu-item-link" data-action="tools-photo-to-cad">Photo-to-CAD</button>
       <button class="menu-item-link" data-action="tools-dfm">Manufacturability Check</button>
@@ -1539,6 +1540,7 @@ window._dismissSplash = function(action) {
 <!-- Killer Feature Modules -->
 <script src="/app/js/agent-api.js?v=a41b98a5"></script>
 <script src="/app/js/modules/ai-copilot.js?v=14e5d5d7"></script>
+<script src="/app/js/modules/ai-engineer.js?v=20260424v1"></script>
 <script src="/app/js/modules/text-to-cad.js"></script>
 <script src="/app/js/modules/photo-to-cad.js"></script>
 <script src="/app/js/modules/manufacturability.js"></script>
@@ -1967,6 +1969,13 @@ window._dismissSplash = function(action) {
           if (dbc) { dbc.innerHTML = ''; dbc.appendChild(window.CycleCAD.AICopilot.getUI()); dbc.style.maxHeight = '620px'; dbc.style.overflow = 'auto'; }
         } else { showToast('AI Copilot module not loaded', 'error'); }
         break;
+      case 'tools-ai-engineer':
+        if (window.CycleCAD && window.CycleCAD.AIEngineer) {
+          showDialog('🔩 AI Engineering Analyst — bolted-joint analysis (VDI 2230 / Shigley)', '');
+          const dbe = document.getElementById('dialog-body');
+          if (dbe) { dbe.innerHTML = ''; dbe.appendChild(window.CycleCAD.AIEngineer.getUI()); dbe.style.maxHeight = '680px'; dbe.style.overflow = 'auto'; }
+        } else { showToast('AI Engineering Analyst module not loaded', 'error'); }
+        break;
       case 'tools-text-to-cad':
         if (window.CycleCAD && window.CycleCAD.TextToCAD) {
           showDialog('Text-to-CAD (AI)', '');

package/app/js/modules/ai-copilot.js

@@ -1,4 +1,4 @@
-/* AI Copilot v1.1 — multi-step CAD generation from natural language */
+/* AI Copilot v1.2 — multi-step CAD generation from natural language. 3.10.5 adds sketch.polyline support + templates for ball bearings (ISO 15/DIN 625), bearing housings, T-slot aluminum extrusions (2020–8080), and U-brackets. */
 (function(){
   'use strict';
   window.CycleCAD = window.CycleCAD || {};
@@ -93,6 +93,7 @@
     '- sketch.start {plane:"XY"}',
     '- sketch.rect {width, height}  — rectangle centered at current origin',
     '- sketch.circle {radius}  — OR diameter',
+    '- sketch.polyline {points:[[x,z],[x,z],...]}  — closed polygon in XZ plane (for custom shapes, gear teeth, T-slot profiles, cams)',
     '- sketch.end',
     '- ops.extrude {depth, position:[x,y,z], subtract:bool}  — create solid. subtract:true carves from last body.',
     '- ops.hole {position:[x,y,z], depth, radius OR width+height}  — carves cylinder OR rectangular hole through last body.',
@@ -255,6 +256,14 @@
     if (method === 'sketch.start') { miniState.currentSketch = { plane: params.plane||'XY', origin: getPos(params) }; return {ok:true}; }
     if (method === 'sketch.rect')  { miniState.currentSketch = Object.assign(miniState.currentSketch||{}, { shape:'rect', width: params.width||params.w||50, height: params.height||params.h||30, origin: getPos(params) }); return {ok:true}; }
     if (method === 'sketch.circle'){ miniState.currentSketch = Object.assign(miniState.currentSketch||{}, { shape:'circle', radius: params.radius||params.r||(params.diameter?params.diameter/2:25), origin: getPos(params) }); return {ok:true}; }
+    if (method === 'sketch.polyline' || method === 'sketch.polygon') {
+      // Points arrive as [[x,z],[x,z],...] in world XZ plane. Min 3 pts for a valid polygon.
+      const raw = Array.isArray(params.points) ? params.points : [];
+      const pts = raw.filter(p => Array.isArray(p) && p.length >= 2).map(p => [Number(p[0])||0, Number(p[1])||0]);
+      if (pts.length < 3) return {ok:false, note:'polyline needs at least 3 points'};
+      miniState.currentSketch = Object.assign(miniState.currentSketch||{}, { shape:'polyline', points: pts, origin: getPos(params) });
+      return {ok:true};
+    }
     if (method === 'sketch.line' || method === 'sketch.end') return {ok:true};
     if (method === 'ops.extrude') {
       const d = params.depth||params.height||params.distance||20;
@@ -264,6 +273,20 @@
       let g;
       if (sk.shape==='rect')         g = new THREE.BoxGeometry(sk.width, d, sk.height);
       else if (sk.shape==='circle')  g = new THREE.CylinderGeometry(sk.radius, sk.radius, d, 48);
+      else if (sk.shape==='polyline' && Array.isArray(sk.points) && sk.points.length >= 3) {
+        // Build Shape from [x,z] points. RotateX(-PI/2) maps:
+        //   Shape-X -> world X, Shape-Y -> world -Z, extrude Z -> world +Y.
+        // To preserve user's intent that points[i][1] is world Z, negate Y into Shape.
+        const shape = new THREE.Shape();
+        const pts = sk.points;
+        shape.moveTo(pts[0][0], -pts[0][1]);
+        for (let i = 1; i < pts.length; i++) shape.lineTo(pts[i][0], -pts[i][1]);
+        shape.closePath();
+        g = new THREE.ExtrudeGeometry(shape, { depth: d, bevelEnabled: false, curveSegments: 24 });
+        g.translate(0, 0, -d/2);  // center along extrude axis BEFORE rotating
+        g.rotateX(-Math.PI/2);
+        // After rotation: geometry spans world Y:[-d/2, d/2] centered at origin. Matches BoxGeometry/CylinderGeometry convention.
+      }
       else                           g = new THREE.BoxGeometry(50, d, 30);
       const isSubtract = params.subtract === true || params.operation === 'cut' || params.operation === 'subtract';
       const mat = new THREE.MeshStandardMaterial({color: isSubtract?0x1a1a1a:0x4a90e2, metalness:0.35, roughness:0.45});
@@ -591,6 +614,176 @@
         {method:'view.fit', params:{}}
       ];
     }
+    // Ball bearing (ISO 15 / DIN 625 deep-groove) — simplified solid ring.
+    // Designations: 60x (light), 62x (medium), 63x (heavy), 6x (small single-digit), 625, 608 etc.
+    const bearingDesignations = {
+      '608':  {d:8,  D:22, B:7},
+      '625':  {d:5,  D:16, B:5},
+      '6000': {d:10, D:26, B:8},
+      '6001': {d:12, D:28, B:8},
+      '6002': {d:15, D:32, B:9},
+      '6003': {d:17, D:35, B:10},
+      '6004': {d:20, D:42, B:12},
+      '6005': {d:25, D:47, B:12},
+      '6006': {d:30, D:55, B:13},
+      '6200': {d:10, D:30, B:9},
+      '6201': {d:12, D:32, B:10},
+      '6202': {d:15, D:35, B:11},
+      '6203': {d:17, D:40, B:12},
+      '6204': {d:20, D:47, B:14},
+      '6205': {d:25, D:52, B:15},
+      '6206': {d:30, D:62, B:16},
+      '6300': {d:10, D:35, B:11},
+      '6301': {d:12, D:37, B:12},
+      '6302': {d:15, D:42, B:13},
+      '6303': {d:17, D:47, B:14},
+      '6304': {d:20, D:52, B:15}
+    };
+    const bearingCodeM = p.match(/\b(6[023]0[0-6]|608|625)\b/);
+    // Housing/pocket/seat keywords take priority — a "bearing pocket for 6204" is a housing, not a bearing body.
+    const isHousingIntent = /bearing\s*(?:housing|pocket|seat|recess|mount)/.test(p);
+    if (bearingCodeM && /bearing/.test(p) && !isHousingIntent) {
+      const spec = bearingDesignations[bearingCodeM[1]];
+      if (spec) {
+        const code = bearingCodeM[1];
+        return [
+          {method:'sketch.start', params:{plane:'XY'}},
+          {method:'sketch.circle', params:{radius: spec.D/2}},
+          {method:'ops.extrude', params:{depth: spec.B, position:[0,0,0]}, note:'bearing '+code+' OD Ø'+spec.D+' x width '+spec.B},
+          {method:'ops.hole', params:{position:[0,0,0], radius: spec.d/2, depth: spec.B + 2}, note:code+' bore Ø'+spec.d+' (ISO 15 — simplified ring, real bearing has balls + races)'},
+          {method:'view.set', params:{view:'iso'}},
+          {method:'view.fit', params:{}}
+        ];
+      }
+    }
+    // Generic ball bearing with explicit bore ("ball bearing 10mm bore")
+    const genBearingM = p.match(/(?:ball|deep[- ]?groove|roller)\s*bearing/);
+    if (genBearingM) {
+      const boreM = p.match(/(\d+)\s*mm\s*bore|bore\s+(\d+)|Ø\s*(\d+)/);
+      const bore = boreM ? parseInt(boreM[1]||boreM[2]||boreM[3]) : 10;
+      // Rough approximation matching 62xx series: OD ≈ 2.5*bore + 10, width ≈ 0.4*bore + 4
+      const OD = Math.round(bore * 2.5 + 10);
+      const B = Math.max(5, Math.round(bore * 0.4 + 4));
+      return [
+        {method:'sketch.start', params:{plane:'XY'}},
+        {method:'sketch.circle', params:{radius: OD/2}},
+        {method:'ops.extrude', params:{depth: B, position:[0,0,0]}, note:'ball bearing Ø'+OD+' x '+B+'mm (approx 62xx series)'},
+        {method:'ops.hole', params:{position:[0,0,0], radius: bore/2, depth: B+2}, note:'bore Ø'+bore+' (look up ISO 15 for exact OD)'},
+        {method:'view.set', params:{view:'iso'}},
+        {method:'view.fit', params:{}}
+      ];
+    }
+    // Bearing housing / pocket — block with recess and clearance through-hole
+    if (/bearing\s*(?:housing|pocket|seat|recess|mount)/.test(p)) {
+      const odM = p.match(/(\d+)\s*mm\s*(?:od|outer|outside)|for\s+(?:a\s+)?(\d+)\s*mm|bearing\s+(\d+)\s*mm/);
+      // If the user named a bearing designation, look up its OD
+      const housingBearingCode = p.match(/\b(6[023]0[0-6]|608|625)\b/);
+      const codeSpec = housingBearingCode ? bearingDesignations[housingBearingCode[1]] : null;
+      const OD = odM ? parseInt(odM[1]||odM[2]||odM[3]) : (codeSpec ? codeSpec.D : 32);
+      const pocketDepth = Math.max(6, Math.round(OD * 0.3));
+      const wall = 8;
+      const blockW = OD + 2*wall;
+      const blockH = OD + 2*wall;
+      const blockD = pocketDepth + 5;
+      const throughR = Math.max(3, OD/2 - 4);
+      return [
+        {method:'sketch.start', params:{plane:'XY'}},
+        {method:'sketch.rect', params:{width: blockW, height: blockH}},
+        {method:'ops.extrude', params:{depth: blockD, position:[0,0,0]}, note:'housing block '+blockW+'×'+blockH+'×'+blockD+' for Ø'+OD+' bearing'},
+        {method:'ops.hole', params:{position:[0, blockD - pocketDepth, 0], radius: OD/2, depth: pocketDepth + 0.5}, note:'bearing pocket Ø'+OD+' × '+pocketDepth+'mm deep'},
+        {method:'ops.hole', params:{position:[0,0,0], radius: throughR, depth: blockD + 2}, note:'shaft clearance bore Ø'+(throughR*2).toFixed(0)},
+        // 4 mounting holes at corners
+        {method:'ops.hole', params:{position:[-blockW/2 + 6, 0, -blockH/2 + 6], radius: 2.5, depth: blockD + 2}, note:'mounting hole 1/4'},
+        {method:'ops.hole', params:{position:[ blockW/2 - 6, 0, -blockH/2 + 6], radius: 2.5, depth: blockD + 2}, note:'mounting hole 2/4'},
+        {method:'ops.hole', params:{position:[-blockW/2 + 6, 0,  blockH/2 - 6], radius: 2.5, depth: blockD + 2}, note:'mounting hole 3/4'},
+        {method:'ops.hole', params:{position:[ blockW/2 - 6, 0,  blockH/2 - 6], radius: 2.5, depth: blockD + 2}, note:'mounting hole 4/4'},
+        {method:'view.set', params:{view:'iso'}},
+        {method:'view.fit', params:{}}
+      ];
+    }
+    // T-slot aluminum extrusion (2020/3030/4040/4080 profiles — Bosch/Item/80/20 style)
+    const tSlotKw = /\bt-?slot|aluminum\s*(?:extrusion|profile)|\b80[- ]?20\b|\bitem\s*profile|\bmisumi\s*extrusion|\bbosch\s*extrusion|structural\s*extrusion/.test(p);
+    const codeM = p.match(/\b(20|25|30|40|45|50|60|80|100)\s*(?:x|×)\s*(20|25|30|40|45|50|60|80|100)\b/);
+    const fourDigitM = p.match(/\b(2020|2040|2080|3030|3060|4040|4080|4545|6060|8080)\b/);
+    if (tSlotKw || codeM || (fourDigitM && /extrusion|profile|t-?slot/.test(p))) {
+      let W = 40, H = 40;
+      if (codeM)           { W = parseInt(codeM[1]);        H = parseInt(codeM[2]); }
+      else if (fourDigitM) {
+        const c = fourDigitM[1];
+        W = parseInt(c.slice(0, c.length/2));
+        H = parseInt(c.slice(c.length/2));
+      }
+      const lenM = p.match(/(\d{2,5})\s*mm\s*(?:long|length)|length\s+(\d{2,5})|\b(\d{3,4})\s*mm\s+(?:rail|bar|stick|piece)/);
+      let length = lenM ? parseInt(lenM[1]||lenM[2]||lenM[3]) : 0;
+      if (!length) {
+        // Fallback: take the largest \d+mm value that isn't the profile code itself (e.g. "4040 extrusion 1000mm")
+        const allMm = [...p.matchAll(/\b(\d{2,5})\s*mm\b/g)].map(m => parseInt(m[1]))
+          .filter(n => n !== W && n !== H && n !== W*100 + H && n !== W*10 + H);
+        length = allMm.length ? Math.max(...allMm) : 500;
+      }
+      // Slot geometry scales with profile size — approximation of real T-slot
+      const slotW = W <= 25 ? 6 : W <= 40 ? 8 : 10;   // slot opening (across inward axis)
+      const slotD = Math.max(6, W/3);                  // slot depth
+      const yMargin = 2;  // covers Y range [0, length]
+      const plan = [
+        {method:'sketch.start', params:{plane:'XY'}},
+        {method:'sketch.rect', params:{width: W, height: H}},
+        {method:'ops.extrude', params:{depth: length, position:[0,0,0]}, note:W+'×'+H+' T-slot extrusion, '+length+'mm long (simplified — real profile has T-grooves + hollow center)'},
+        // +X face slot
+        {method:'ops.hole', params:{position:[W/2 - slotD/2, 0, 0], width: slotD, height: slotW, depth: length + yMargin}, note:'+X T-slot'},
+        // -X face slot
+        {method:'ops.hole', params:{position:[-W/2 + slotD/2, 0, 0], width: slotD, height: slotW, depth: length + yMargin}, note:'-X T-slot'},
+        // +Z face slot
+        {method:'ops.hole', params:{position:[0, 0,  H/2 - slotD/2], width: slotW, height: slotD, depth: length + yMargin}, note:'+Z T-slot'},
+        // -Z face slot
+        {method:'ops.hole', params:{position:[0, 0, -H/2 + slotD/2], width: slotW, height: slotD, depth: length + yMargin}, note:'-Z T-slot'},
+        {method:'view.set', params:{view:'iso'}},
+        {method:'view.fit', params:{}}
+      ];
+      // For double-wide profiles (e.g. 4080), the longer face gets two T-slots per side
+      if (Math.max(W, H) >= 2 * Math.min(W, H)) {
+        const longSide = W > H ? 'x' : 'z';
+        const longDim = Math.max(W, H);
+        const offset = longDim / 4;
+        if (longSide === 'x') {
+          // Add extra slots on top/bottom (Z faces) since X-axis is longer
+          plan.splice(-2, 0,
+            {method:'ops.hole', params:{position:[ offset, 0,  H/2 - slotD/2], width: slotW, height: slotD, depth: length + yMargin}, note:'+Z T-slot (extra)'},
+            {method:'ops.hole', params:{position:[-offset, 0,  H/2 - slotD/2], width: slotW, height: slotD, depth: length + yMargin}, note:'+Z T-slot (extra)'},
+            {method:'ops.hole', params:{position:[ offset, 0, -H/2 + slotD/2], width: slotW, height: slotD, depth: length + yMargin}, note:'-Z T-slot (extra)'},
+            {method:'ops.hole', params:{position:[-offset, 0, -H/2 + slotD/2], width: slotW, height: slotD, depth: length + yMargin}, note:'-Z T-slot (extra)'}
+          );
+        }
+      }
+      return plan;
+    }
+    // U-bracket / channel bracket
+    if (/u-?bracket|u-?channel|channel\s*bracket|mounting\s*channel/.test(p)) {
+      const wM = p.match(/(\d+)\s*mm\s*(?:wide|width)|width\s+(\d+)/);
+      const width = wM ? parseInt(wM[1]||wM[2]) : 60;
+      const hM = p.match(/(\d+)\s*mm\s*(?:high|height|tall)|height\s+(\d+)/);
+      const height = hM ? parseInt(hM[1]||hM[2]) : 40;
+      const lM = p.match(/(\d+)\s*mm\s*(?:long|length)|length\s+(\d+)/);
+      const length = lM ? parseInt(lM[1]||lM[2]) : 100;
+      const wall = Math.max(3, Math.round(Math.min(width, height) / 12));
+      const holesM = p.match(/(\d+)\s*holes?/);
+      const nHoles = holesM ? parseInt(holesM[1]) : 2;
+      const plan = [
+        {method:'sketch.start', params:{plane:'XY'}},
+        {method:'sketch.rect', params:{width: width, height: length}},
+        {method:'ops.extrude', params:{depth: height, position:[0,0,0]}, note:'U-bracket blank '+width+'×'+height+'×'+length+'mm'},
+        // Pocket cut from top down to wall thickness above base. Final Y span: [wall-0.5, height+1.5], intersects body at [wall, height].
+        {method:'ops.hole', params:{position:[0, wall, 0], width: width - 2*wall, height: length + 2, depth: height - wall + 2}, note:'U-bracket pocket ('+(width - 2*wall)+'×'+(height - wall)+' leaves base + 2 side walls)'}
+      ];
+      // Mounting holes through the base plate
+      for (let i = 0; i < nHoles; i++) {
+        const y = (nHoles === 1) ? 0 : -length/2 + 12 + i * ((length - 24) / Math.max(1, nHoles - 1));
+        plan.push({method:'ops.hole', params:{position:[0, 0, y], radius: 3, depth: wall + 2}, note:'base mounting hole '+(i+1)+'/'+nHoles});
+      }
+      plan.push({method:'view.set', params:{view:'iso'}});
+      plan.push({method:'view.fit', params:{}});
+      return plan;
+    }
     return null;
   }
   async function run(){
@@ -723,5 +916,5 @@
     abort: () => abort(),
     getState: () => ({ running:S.running, stepIndex:S.stepIndex, results:S.results.length, errors:S.errors.length, model:S.els.model?.value })
   };
-  console.log('AI Copilot v1.1 module loaded');
+  console.log('AI Copilot v1.2 module loaded');
 })();