# Informe final: programación y automatización en AutoCAD 2027

Este es el informe de cierre de AutoCADLab 2027, laboratorio realizado del 2026-10-28 al 2026-10-29.

El laboratorio responde a dos preguntas:
- qué se puede hacer con cada vía de programación y automatización de AutoCAD 2027, y a qué precio en rendimiento, depuración y dificultad;
- qué tal programa una IA (Claude Opus 5.5 en Claude Code) contra cada una.

**Fuentes:**
- todas las cifras se midieron en esta instalación;
- el detalle de cada prueba está en el [checklist de las 244 pruebas](checklist-244-pruebas.md).


---

## 1. Resumen

1. **.NET dentro de AutoCAD es la vía principal.** Es la más rápida: 10.000 líneas en 60 ms. También es la más completa y la que mejor se depura: hay breakpoints en Visual Studio y se itera en unos 2,2 s con un runner propio.
   - Su límite estructural es el contexto (aplicación o documento, y un solo hilo).
   - Las DLL no se pueden descargar: hace falta un cargador propio para no reiniciar AutoCAD.
2. **`accoreconsole` es la gran ventaja de AutoCAD para trabajar en lote.** Es oficial, no tiene interfaz y la licencia no limita las instancias: 8 consolas en paralelo dan ×5,6.
   - Admite DLL .NET, LISP sin `vla-*`, y `.dbx`/`.crx` de ObjectARX.
   - No tiene COM ni VBA, y tocar la interfaz tumba el proceso.
3. **AutoLISP sigue siendo la vía más barata para tareas medianas.** Itera en ~0,8 s y es solo de 2 a 6 veces más lento que .NET. La IA no inventó ninguna función en 91 líneas (LSP-15).
   - Sus trampas son silenciosas: errores que no se capturan, rutas largas, ANSI.
4. **COM desde otro proceso sirve para orquestar, no para procesar entidad a entidad.** Cada llamada cuesta 0,7–1 ms, de 100 a 500 veces más que dentro del proceso.
   - Hay que apoyarse en operaciones del lado de AutoCAD: `SelectionSet` filtrado, ObjectDBX, `SendCommand`.
   - Para lotes de DWG, ObjectDBX desde Python tardó 33 ms por archivo.
5. **ObjectARX (C++) es la única vía con descarga y recarga reales** (`arxunload`/`arxload`). También es la única con entidades propias (y sus proxys).
   - A cambio, una excepción nativa mata AutoCAD.
   - La IA escribió unas 230 líneas de C++ con un solo error de compilación.
6. **VBA funciona, pero es la vía peor equipada para automatizar.**
   - No hay `VBASAVE`: el proyecto solo se guarda desde un diálogo.
   - No funciona en la consola.
   - Los errores son genéricos.
   - Lanzar una macro desde un `.scr` puede tumbar AutoCAD.
7. **Design Automation (APS) funcionó a la primera con el motor de AutoCAD 2027.** Un WorkItem tardó 3,7 s en el servidor y el ciclo completo, 18 s. La cuenta de estudiante no pidió pago.
   - Con ella se entendió el fallo local de `/al` (APS-02): hay que pasarle la carpeta que contiene el bundle, y esa carpeta debe ser de confianza.
8. **Lo que ninguna vía hace por programa:**
   - crear bloques dinámicos;
   - restricciones geométricas en .NET;
   - cotas asociativas creadas por código;
   - `RECOVER`;
   - guardar con contraseña.
9. **Hay 5 situaciones que matan el proceso sin `try/catch` posible:** recursión infinita, escribir en un objeto con su transacción cerrada, tocar la interfaz desde la consola, una excepción nativa en un `.arx` y crear una `Database` fuera de AutoCAD. Una sexta, `-VBARUN` desde un `.scr`, está registrada dentro de VBA-02 (⚠️). La consecuencia es que las pruebas peligrosas van en una **instancia propia y desechable**.

---

## 2. Alcance y método

- **Entorno fijo:**
  - AutoCAD 2027 R26.0, build 26.0.118, ENU, licencia EDUCATION;
  - .NET 10 (SDK 10.0.403);
  - Visual Studio 2026 Community (MSVC 14.51, toolset v145);
  - Windows 11 Pro, 24 núcleos y 63 GB.
- **Instalado durante el laboratorio**, siempre con permiso: módulo VBA 26.0.60.0, SDK de ObjectARX 2027, C++ de VS, ACadSharp 3.8.0, WebView2 1.0.4191.47 y una app de APS.
- **Plan:** 244 pruebas en 22 familias. Cada afirmación «X provoca Y» lleva un control que la descarta, y solo se marca *verificado* lo ejecutado aquí.
- **Resultado:** 244/244 probadas (✅ 177, ⚠️ 54, ❌ 8, 💥 5).

| Familia | Pruebas | ✅ | ⚠️ | ❌ | 💥 |
|---|---|---|---|---|---|
| DEV: ciclo de desarrollo y depuración | 15 | 8 | 5 | 1 | 1 |
| ENT: carga de complementos y entorno .NET 10 | 16 | 11 | 3 | 2 | |
| SHL: fuera de AutoCAD | 8 | 6 | 1 | | 1 |
| TRX: transacciones, bloqueos y deshacer | 13 | 8 | 4 | | 1 |
| CTX: contexto de ejecución e hilos | 14 | 11 | 3 | | |
| ELM: entidades, bloques, capas y referencias | 21 | 14 | 6 | 1 | |
| ANO: anotación | 10 | 9 | | 1 | |
| VIS: modelo, papel y vistas | 10 | 9 | 1 | | |
| EXP: exportación, versiones y lotes | 13 | 9 | 3 | 1 | |
| EVT: eventos, reactores y *overrules* | 12 | 12 | | | |
| UI: interfaz de usuario | 13 | 12 | 1 | | |
| LSP: AutoLISP y Visual LISP | 15 | 10 | 5 | | |
| COM: ActiveX dentro y fuera | 14 | 11 | 2 | 1 | |
| CON: `accoreconsole` y `.scr` | 14 | 9 | 4 | | 1 |
| MAC: macros, CUIx, DIESEL, Action Recorder y Express | 9 | 9 | | | |
| JSA: JavaScript y HTML | 5 | 4 | 1 | | |
| VBA | 5 | 2 | 2 | 1 | |
| ARX: ObjectARX en C++ | 6 | 4 | 1 | | 1 |
| APS: Design Automation | 4 | 4 | | | |
| DWG: leer DWG y DXF sin AutoCAD | 7 | 3 | 4 | | |
| CMP: comparación entre vías | 11 | 8 | 3 | | |
| LIM: estrés y límites | 9 | 4 | 5 | | |

**Cómo leer los símbolos:**
- ✅ funciona como se esperaba o se entendió del todo;
- ⚠️ funciona con salvedades, o la medida quedó incompleta;
- ❌ no se puede;
- 💥 el proceso muere.

Un ❌ o un 💥 bien medido es tan útil como un ✅.

---

## 3. Las vías, una por una

### 3.1 .NET (C#, `acdbmgd`/`accoremgd`/`acmgd`)

**Puede hacer:**
- prácticamente todo el modelo de datos: geometría, bloques, atributos, capas, cotas, tablas, campos, presentaciones, xrefs, raster y PDF subyacente, DXF con XData;
- eventos y *overrules* (EVT 12/12 ✅);
- toda la interfaz: cinta, paletas WPF, menús contextuales, *jigs*, transitorios y barra de estado (UI 12/13 ✅);
- procesar DWG sin abrirlos (`ReadDwgFile` en una base lateral: 5–11 ms por archivo);
- un millón de entidades o un DWG de 610 MB sin llegar a ningún límite (LIM-01/03).

**No puede, o le cuesta:**
- crear bloques dinámicos (ELM-09 ❌);
- restricciones geométricas (ELM-18; las variables paramétricas sí);
- cotas asociativas (ANO-02 ❌);
- contraseña (EXP-05 ❌);
- `Hatch.Area` (siempre `eNotApplicable`);
- `AssocArray` en una base lateral;
- zoom y `PurgeAll` sin pasar por COM.

**El límite estructural es el contexto:**
- Desde el contexto de aplicación hay que bloquear el documento (`LockDocument`); sin el bloqueo se obtiene `eLockViolation` (TRX-01/02).
- Tras un `await` que no sea `CommandAsync` se pierde el contexto de comando (CTX-02).
- `UserBreak` solo funciona dentro de un `[CommandMethod]`.
- Con concurrencia, `Application.Idle` se dispara en el hilo de fondo y revienta la cinta (CTX-01).

**Carga:**
- Una DLL cargada no se puede descargar, y `NETLOAD` no recarga (DEV-13).
- «Always Load» de SECURELOAD no se recuerda entre arranques (ENT-02 ❌): la solución es `TRUSTEDPATHS` (ENT-03).
- No hay aislamiento de dependencias: gana siempre el Newtonsoft 13 de AutoCAD (ENT-12, ENT-13 ❌).
- Las DLL net8 (2025) y net48 (2024) cargan en 2027 (ENT-09/10).

**Depuración:**
- Breakpoints de Visual Studio 2026, adjuntándose o con F5 (DEV-08/14 ✅).
- **Hot Reload no funciona** (DEV-00 ❌: «lack of a managed language service»).
- Con un runner propio (`AssemblyLoadContext` descargable + copia sombra + quitar la entrada de `ExtensionLoader.m_extensions`), el ciclo compilar → ejecutar baja a **~2,2 s**, y guardar → resultado a ~3,7 s con `dotnet watch` (DEV-01/04).

**Lo que mata el proceso:**
- recursión infinita (DEV-11 💥);
- escribir con la transacción cerrada (TRX-08 💥);
- hacer actual la presentación de una base lateral (VIS-02).

Una excepción en un hilo secundario **no** mata AutoCAD: la retiene su filtro (LIM-04).

### 3.2 AutoLISP / Visual LISP

**Puede hacer:**
- casi todo el modelo de datos con `entmake`/`entmod`, y con `vla-*` en la interfaz;
- reactores;
- funciones llamables desde .NET (`vl-acad-defun` + `Application.Invoke`, LSP-09).

**Funciona en la consola,** pero sin objeto ActiveX: hay 2.759 funciones en la interfaz y 2.608 en la consola, y las 2.042 `vla-*` existen allí pero no tienen sobre qué actuar.

**Rendimiento:** de 2 a 6 veces más lento que .NET (10.000 líneas: 109 ms con `entmake`, 360 ms con `vla-AddLine`). Es la vía de iteración más corta dentro de AutoCAD (~0,8 s).

**Trampas:**
- `vl-catch-all-apply` no captura las funciones inexistentes (LSP-05);
- a partir de unos 20.000 niveles de recursión, LISP muere en silencio (LSP-13);
- `(command)` está prohibido en los reactores;
- `write-line` escribe en ANSI;
- con rutas de más de 260 caracteres, `open` y `vl-file-*` fallan (LIM-08);
- con `OSNAPCOORD=2`, el OSNAP desvía las coordenadas de LISP, scripts y macros (usar `_non`).

**Depuración:** el adaptador DAP de AutoCAD (`AutoLispDebugAdapter.exe`) se controla desde un cliente propio, con breakpoints y variables (LSP-06 ✅). SECURELOAD 0/1/2 está medido (LSP-02). La carpeta de soporte del perfil no es de confianza: `acaddoc.lsp` pregunta.

### 3.3 COM / ActiveX

**Dentro del proceso** (`Application.AcadApplication` como `dynamic`):
- 10.000 líneas en 163 ms;
- es la única forma de llegar a zoom, perfiles, `AuditInfo`, `PurgeAll`, `LoadDVB`/`RunMacro`.

**Desde otro proceso** (C#, Python, PowerShell):
- **0,7–1 ms por llamada.** Recorrer 100.000 entidades cuesta 176 s, frente a 623 ms con un `SelectionSet` filtrado.
- ObjectDBX procesa 100 DWG en 3,3 s.

**Trampas:**
- `GetActiveObject` y la ROT devuelven siempre la **primera** instancia, que puede ser la del usuario. Para trabajar con una propia, usar `DispatchEx`.
- `RPC_E_CALL_REJECTED` aparece durante minutos sin causa visible; pywin32 lo disfraza de `AttributeError`.
- Con un diálogo modal abierto, COM queda rechazado.
- Un `acad.exe` arrancado por COM y soltado sin `Quit` queda huérfano y oculto (COM-14 ❌).
- Todo se serializa en el hilo de AutoCAD: el runner, COM y un reactor a la vez no dan errores, pero tampoco van en paralelo (LIM-07).

### 3.4 `accoreconsole` y scripts `.scr`

- **Uso:** `accoreconsole /i dibujo.dwg /s script.scr`.
  - Sin `/i` sale con `ErrorStatus=53`.
  - Hay que cerrarle stdin: si no, espera teclado para siempre.
  - Arranca en 1,5–5 s.
- **Carga:** `NETLOAD` solo desde rutas de confianza.
  - `/al` carga un AppBundle si se le pasa la **carpeta que lo contiene** y esa carpeta es de confianza (APS-02).
  - Si no lo es, falla en silencio: el comando simplemente no existe.
- **Rendimiento:**
  - El trabajo es tan rápido como en la interfaz: 10.000 líneas en 25 ms con una DLL o en 31–47 ms con LISP.
  - Con un `.scr` puro tardan 7 s: unas 250 veces más.
  - Para lotes, **un proceso con `ReadDwgFile`** procesa 100 DWG en 0,5 s más 7,8 s de arranque. Lanzar un proceso por DWG cuesta 2,8 s por archivo.
  - En paralelo, 8 consolas dan ×5,6 sin límite de licencia (CON-08).
- **No tiene:**
  - COM;
  - VBA (VBA-03 ❌);
  - la interfaz: `AcadApplication`, `StatusBar` o `GetAcadDocument` tumban el proceso (CON-03 💥).
- **Sí carga:** un `.dbx` y un `.crx` propios de ObjectARX (ARX-06 ✅).
- **Trampas:**
  - `QUIT` con el dibujo modificado la cuelga para siempre;
  - un comando desconocido termina con exit 0 (CON-06);
  - la salida estándar es UTF-16 mezclada con ASCII.
- **Depuración:** Visual Studio se puede adjuntar a la consola, pero solo con CoreCLR ya cargado (CON-14 ✅).

### 3.5 Macros de la interfaz: CUIx, DIESEL, Action Recorder, Express Tools y `acad.pgp`

MAC 9/9 ✅.

- **CUIx:** se genera **desde cero sin `AcCui.dll`** (es un ZIP con XML, MAC-05) o con `AcCui.dll` (MAC-06), y se carga con `LoadPartialMenu`.
  - En los botones, `RibbonItem.Id` debe ser `AcRibbonCommandButton`.
  - `LoadPartialMenu` borra las pestañas añadidas por código.
  - Los paneles se rellenan de forma perezosa.
- **Macros:** en una macro, `\` es una pausa, también dentro de LISP.
- **DIESEL:** se evalúa en `MODEMACRO`, pero en la cinta no se refresca.
- **Action Recorder:** el `.actmx` es JSON editable.
  - `CommandFlags.NoActionRecording` excluye un comando .NET de la grabación.
- **Express Tools:** son cargadores LISP; las funciones `acet-*` no existen hasta el primer uso.
- **`acad.pgp`:** se edita y se recarga con `REINIT`.

### 3.6 JavaScript y HTML

- **Ventana web de AutoCAD:** el motor es WebView2 (Chromium 155 y luego 156).
  - `execAsync` llama a métodos `[JavaScriptCallback]` de .NET, que deben devolver `{"retCode":0,"retValue":…}`; con un JSON libre la página recibe «not present».
  - Funciona en `ShowModelessWindow(Uri)` y en una `PaletteSet`.
- **WebView2 propio** (paquete NuGet) dentro de una paleta: comunicación en las dos direcciones (`PostWebMessageAsString`/`WebMessageReceived`, `ExecuteScriptAsync`), pero sin `execAsync` (JSA-04).
- **Interfaz:** el contenido WPF no hereda el tema oscuro.

### 3.7 VBA

Hace falta el módulo VBA Enabler (59 MB, se descarga aparte). Una vez instalado:

- **Crear y ejecutar:** el proyecto y los módulos se crean por código (`_VBANEW` + `AcadApplication.VBE`), y `RunMacro` ejecuta en 2–7 ms.
- **Guardar:** **no hay forma de guardar por programa.** No existe el comando `VBASAVE` y `VBProject.SaveAs` no se puede usar en este tipo de proyecto. Se guarda con el diálogo VBA Manager, que se puede automatizar con mensajes de Win32 (VBA-02 ⚠️).
- **`-VBARUN`:**
  - desde un `.scr`, con el proyecto solo en memoria, tumba AutoCAD;
  - con el `.dvb` cargado desde disco, funciona;
  - por `SendStringToExecute` o `(vl-vbarun)` da «AutoCAD is busy».
- **Carga y SECURELOAD:** `LoadDVB` respeta SECURELOAD (VBA-04 ✅).
  - Fuera de las rutas de confianza abre un aviso que deja la llamada COM esperando.
  - «Do Not Load» deja el archivo vetado toda la sesión.
  - Con SECURELOAD=2 falla sin diálogo.
  - `RunMacro` necesita la ruta completa del `.dvb`.
- **En la consola:** no existe (VBA-03 ❌).
- **Depuración:** solo interactiva, en VBAIDE; no hay DAP ni DTE.

### 3.8 ObjectARX (C++)

**Preparación:**
- El SDK ocupa 121 MB comprimido y 179 MB extraído.
- Sus ejemplos piden el toolset v143 (VS 2022); con `cl` y v145 (VS 2026) se compila sin problemas.
- Un `.arx` mínimo sin MFC ocupa 15,8 KB y compila en ~1,6 s.

**Resultados:**
- **Recarga real** (ARX-03 ✅): `arxunload` libera el archivo, que mientras está cargado no se puede sobrescribir, y `arxload` carga otra versión en la misma sesión.
- **Entidades propias** (ARX-05 ✅):
  - en un `.dbx` (`dwgIn/OutFields`, `subWorldDraw`…);
  - sin el `.dbx`, el DWG muestra un proxy con sus gráficos guardados que no se puede borrar;
  - el aviso modal «Proxy Information» **bloquea el arranque** si el DWG se abre como argumento.
- **Excepción nativa** (ARX-04 💥): mata AutoCAD.
  - CER identifica el módulo culpable (`module_name=lab_arx.arx`, `0xC0000005`) y guarda un minidump.
  - AutoCAD ofrece guardar un `_recover.dwg`.
- **Consola:** un `.dbx` y un `.crx` funcionan en `accoreconsole` (ARX-06 ✅).

### 3.9 Design Automation (APS, en la nube)

- **Montaje:** una app «Server-to-Server» con OAuth de dos patas. Hay 7 motores de AutoCAD; `Autodesk.AutoCAD+26_0` corresponde a 2027.
- **Un WorkItem** (bucket OSS temporal, AppBundle .NET de 3,8 KB y Activity con `accoreconsole /i /al /s`) dio success al primer intento:
  - 3,7 s en el servidor, 2,2 s de ellos en `accoreconsole`;
  - 18 s el ciclo completo;
  - el DWG devuelto, comprobado (APS-04 ✅).
- **El entorno de la nube:** Windows Server, 2 CPU, .NET 10.0.13, límite de 100 s por trabajo. Un complemento para la nube **no puede referenciar `acmgd`**.
- **Coste:** con la cuenta de estudiante no hubo ningún aviso de pago, y la API no informa del coste de cada WorkItem.

### 3.10 Leer DWG sin AutoCAD

- **Por la licencia:** solo se usaron bibliotecas con licencias que lo permiten.
- **DXF:** ezdxf lo lee y lo escribe bien (DWG-04 ✅).
- **DWG con ACadSharp 3.8.0** (MIT): lee 1.000.000 de entidades en 8,3 s, pero **la cabecera no es fiable** (DWG-05).
- **`acdbmgd` fuera de AutoCAD:** la geometría funciona (SHL-01). `new Database()` muere con un 0xC0000005 nativo en el constructor (SHL-02 💥).

---

## 4. Comparación

### 4.1 Rendimiento (CMP-01 a CMP-10)

| Tarea | .NET | LISP | COM dentro | COM fuera | `accoreconsole` |
|---|---|---|---|---|---|
| 10.000 líneas | 60 ms | 109 ms (`entmake`) | 163 ms | ~7–10 s | DLL 25 ms · LISP 31–47 ms · `.scr` 7 s (+arranque) |
| Contar 100.000 entidades por capa | 326 ms (documento) · 32 ms (base lateral) | 625–891 ms | 469 ms | 623 ms filtrado · 176 s recorriendo | DLL 90 ms · LISP 470 ms |
| Cambiar de capa 10.000 entidades | 106 ms | 312 ms | 446 ms | 17,7 s | DLL 116 ms · LISP 156 ms |
| 100 DWG: atributo y guardar | 1,1 s (base lateral) | — | — | ObjectDBX 3,3 s | 1 proceso: 0,5 s (+7,8 s) · 1 por DWG: 277 s |
| Iteración editar → ver | 2,2 s (runner) | ~0,8 s | — | ~0,08 s | LISP 3,0 s · DLL 3,8 s |

Otras vías:
- **ObjectARX:** compilar 1,6 s, más `arxunload`/`arxload`.
- **VBA:** `RunMacro` de 10 líneas en 2–7 ms.
- **Design Automation:** 3,7 s en el servidor y 18 s de ciclo.

### 4.2 Depuración y recarga

| Vía | Breakpoints | Recarga sin reiniciar | Si algo va mal |
|---|---|---|---|
| .NET | Sí (VS: adjuntarse o F5; también por DTE) | Con un cargador propio; `NETLOAD` no recarga | Casi todo es capturable; 3 casos matan el proceso |
| LISP | Sí (DAP; VS Code o un cliente propio) | Sí (`load`) | Muertes silenciosas (recursión), errores no capturables |
| COM fuera | Los del lenguaje cliente | Sí (es otro proceso) | Rechazos `RPC_E_CALL_REJECTED`, instancias huérfanas |
| Consola | VS adjuntándose tras cargar CoreCLR | Cada proceso es nuevo | Exit 0 con errores; `QUIT` se cuelga |
| ARX | VS (nativo) | **Sí** (`arxunload`/`arxload`) | Una excepción nativa mata AutoCAD |
| VBA | Solo VBAIDE, interactivo | Recargar el `.dvb` | Errores genéricos, «busy», caídas con `-VBARUN` |
| Design Automation | No: solo el informe del WorkItem | Versión nueva del AppBundle + alias | El informe tiene la salida de la consola |

### 4.3 Qué vía para qué

| Necesidad | Vía recomendada | Por qué |
|---|---|---|
| Complemento con interfaz (cinta, paletas, comandos) | .NET | Es la única con toda la interfaz y depuración completa |
| Lotes de cientos de DWG en el mismo equipo | `accoreconsole` con una DLL y `ReadDwgFile` en **un** proceso; o varios en paralelo | 5 ms por DWG; sin interfaz; ×5,6 con 8 procesos |
| Lotes sin AutoCAD instalado, o en un servidor | Design Automation | Mismo código que en la consola; hay que pagar créditos fuera de la cuenta de estudiante |
| Rutinas medianas del día a día, prototipos | AutoLISP | Iteración más corta; la IA casi no inventa funciones |
| Orquestar AutoCAD desde otro programa (Python, scripts de CI) | COM con `DispatchEx` + ObjectDBX o `SendCommand` | Sin compilar; evitar recorrer entidad a entidad |
| Entidades propias o lo que .NET no expone | ObjectARX | Proxys y recarga real; asumir el riesgo de caídas |
| Botones y menús para usuarios | CUIx parcial (generado por código) + macros | Sin código compilado; se distribuye con el bundle |
| Interfaz web dentro de AutoCAD | WebView2 propio en una paleta, o la ventana web con `execAsync` | Las dos funcionan en 2027 |
| Proyectos VBA heredados | Mantenerlos; no escribir VBA nuevo | Sin guardado por código, sin consola y con caídas |
| Solo leer DWG o DXF | ACadSharp / ezdxf | Sin AutoCAD; revisar la cabecera |

---

## 5. Lo que la interfaz hace y ninguna vía expone

Actualización de LIM-09 con las vías que faltaban.

| Capacidad | Estado |
|---|---|
| Crear un bloque dinámico (parámetros y acciones) | Ninguna vía. Solo se cambian las propiedades de bloques ya hechos (ELM-08/09) |
| Restricciones geométricas | No en .NET ni en COM. Solo por comando (`GEOMCONSTRAINT`). ObjectARX tiene `AcDbAssoc*`, sin probar aquí |
| Cota asociativa creada por código | No: hace falta `DIMREASSOCIATE` (ANO-02) |
| `RECOVER` de un DWG dañado | No se pudo automatizar por ninguna vía (LIM-05) |
| Guardar con contraseña | Retirado (EXP-05) |
| Recordar «Always Load» | No; la alternativa es `TRUSTEDPATHS` (ENT-02) |
| Guardar un proyecto VBA | Solo con el diálogo VBA Manager (VBA-02) |

**APIs rotas o incompletas:**
- `Hatch.Area`;
- `AssocArray` en una base lateral;
- `DataLink` con CSV (con XLSX necesita `!Hoja`);
- `IsMerged` (usar `IsMergedCell`);
- los bundles en `%ProgramData%` se ignoran (ENT-08).

---

## 6. Lo que mata el proceso (💥) y cómo protegerse

| Prueba | Causa | Qué queda |
|---|---|---|
| DEV-11 | Recursión infinita en .NET (0xC00000FD), aunque esté dentro de `try/catch` | Diálogo CER y entrada en el Visor de eventos |
| TRX-08 | Escribir en un `DBObject` con su transacción ya cerrada | «INTERNAL ERROR: eNotOpenForWrite» → `_recover.dwg` |
| CON-03 | `AcadApplication`/`StatusBar`/`GetAcadDocument` en la consola (0xC0000005) | Nada: la salida con búfer se pierde (escribir trazas a archivo) |
| ARX-04 | Puntero nulo en un `.arx` | CER con `module_name` y minidump; `_recover.dwg` |
| SHL-02 | `new Database()` fuera de AutoCAD | El proceso muere en 207 ms |
| (en VBA-02) | `-VBARUN` desde un `.scr` con el proyecto solo en memoria | «Unhandled Access Violation Reading 0xffffffff» |

**Protección:**
- Hacer estas pruebas en una instancia propia, arrancada y registrada por el laboratorio.
- Cerrar CER sin enviar.
- Escribir trazas a archivo en cada paso, porque la salida se pierde.

---

## 7. La IA programando contra cada vía

**Datos de `lab`:** 34 tareas, 151 compilaciones (11 fallidas) y 873 ejecuciones (22 fallidas), con ~1,08 M tokens de salida.

Matices:
- Los tokens totales (421 M) son casi todo lectura de caché del contexto.
- Las pruebas con la persona delante y las instalaciones no se registraron como «intervención». El 0 de intervenciones no significa que la persona no hiciera nada.

**Por vía:**
- **.NET:** fallos de compilación pocos y baratos.
  - Símbolos inventados (A1), detectados por el compilador y por el inventario de la API.
  - `using` que faltaban (B1).
  - Lo caro son las rarezas que solo salen al ejecutar (C5): `Hatch.Area`, las bases laterales sin *rollback*, el coste cuadrático de `StartOpenCloseTransaction`.
- **LISP:** 0 funciones inventadas en 91 líneas y 5/5 rutinas a la primera (LSP-15), comprobado contra el inventario de 2.759 funciones.
- **COM desde Python:** la tarea de CMP-09 salió a la primera; los problemas fueron del entorno (rechazos RPC, instancias ajenas).
- **`.scr`:** la IA lo resolvió, pero solo porque conocía el valor de antes: no puede calcular.
- **VBA:** el código salió a la primera. La IA falló en el **entorno**:
  - supuso que existían `VBASAVE` y `VBProject.SaveAs`;
  - supuso que `RunMacro` aceptaba solo el nombre del `.dvb`.
  - Sin compilador ni inventario de comandos, cada suposición falsa cuesta una ejecución en AutoCAD.
  - Lección: comprobar los comandos con `(getcname)` antes de usarlos.
- **ObjectARX:** ~230 líneas de C++ con un solo error de compilación (faltaba `adscodes.h`). Las cabeceras del SDK hacen de inventario (grep de cada firma antes de escribir).
- **Design Automation:** el ciclo completo de REST (OAuth, OSS, AppBundle, Activity, WorkItem) salió a la primera.

**Conclusión:** la dificultad para la IA no depende tanto del lenguaje como de **tres factores**:
- si hay un inventario contra el que comprobar los símbolos;
- si hay un compilador o un bucle de ejecución rápido;
- cuántas rarezas tiene el entorno que solo aparecen al ejecutar.

Ordenadas de menos a más difícil:
1. .NET con runner, LISP y Design Automation;
2. ObjectARX y COM;
3. VBA.

---

## 8. Limitaciones del estudio

- Un solo equipo, una sola licencia (EDUCATION) y un solo modelo de IA (Claude Opus 5.5, condición C0, sin comparar con otros).
- Las medidas son de pocas repeticiones (normalmente 3). Las diferencias pequeñas (<20 %) no son concluyentes.
- LIM-02 (sesión de 8 h) se comprimió a 600 ejecuciones seguidas.
- El coste de Design Automation no se pudo medir desde la API.
- No se probaron:
  - los proyectos de ejemplo del SDK de ObjectARX (`.vcxproj` con v143);
  - las restricciones geométricas por ObjectARX;
  - `SECURELOAD=0` con VBA, para no rebajar la seguridad.

---

## 9. Archivos de referencia (en el repositorio del laboratorio)

- **Checklist con todas las observaciones:** [checklist-244-pruebas.md](checklist-244-pruebas.md).
- **Inventarios de la API** en `pruebas/resultados/`: `api-surface-autocad-2027.tsv` (.NET), `-ui-`, `-com-`, `-lisp-` e `internal-`.
- **Runner y CLI:** `addins/AutoCADLab.Runner`, `tools/Lab` (`lab inicio/build/run/fin/vigilar`).
- **Pruebas por vía:**
  - `pruebas/lisp/`, `pruebas/com/`, `pruebas/con/`, `pruebas/cuix/`, `pruebas/dev/`;
  - `pruebas/vba/`;
  - `pruebas/arx/arx02` y `arx05`;
  - `pruebas/aps/aps04.py`, `addins/AutoCADLab.Aps`.