🚀 P02: Despliegue exitoso del sistema DASUTEN en pcv-dasu0

Infraestructura y Red:
- Tailscale v1.94.2 instalado en srv-dasu (IP: 100.116.210.36)
- Configurado como subnet router para 10.0.100.0/24
- Fix: Repositorios enterprise de Proxmox deshabilitados (.sources → .bak)

Despliegue del Sistema (pcv-dasu0):
- Transferencia SCP de runSysDasuten.zip via SSH puerto 7022
- Extracción en C:\Dasuten\runSysDasuten- Kermet.ini configurado: SERVER=sql-dasuten
- InstaladorComponentesKermet.exe (silent install)
- Fuentes TrueType registradas en Windows (Code39, I2OF5)
- Firewall TCP 1433 abierto en sql-dasuten
- Test-NetConnection: TcpTestSucceeded=True
- Login exitoso con usuario aalmiron ✅

ADN y Contexto:
- 05_ia.md: Regla 13 Auto-Contextualización Topológica
- 07_proyectos.md: Sección 'Topología y Red' obligatoria en manifiestos
- P2601_dasuten.md: Contexto de red documentado
- nodos/pcv-dasu0.md: Puerto SSH actualizado a 7022

Dashboard P2601:
- Hitos completados: 8 → 11 (P02.APP, NET01, TEST03)
- Progreso: 67% → 79%
- pcv-dasu0: Testing → Online
- Nuevo hito activo: UAT (verificación presencial)

Bitácoras y Documentación:
- Bitácora 04/03 y 05/03 completas
- Plan de despliegue en docs/plan/260305-1017
- Investigación de ingeniería inversa documentada
- ns8-candados: Instrucciones de uso para IA agregadas
- dtic-BITACORAs: CRUD completo, Dashboard P2601 integrado

Herramientas:
- w-zombi: Mejora anti-loop (max 5 ciclos)
- Payloads de despliegue SQL y sistema generados

docs/investigacion/260304-1800_P2601_dasuten_ingenieria_inversa.md

@@ -0,0 +1,150 @@
+# P2601 - Ingeniería Inversa: Sistema DASUTEN
+
+> Documento técnico generado el 04/03/2026 a partir del análisis del directorio `dtic-APPs/temp/runSysDasuten/`.
+
+## Resumen Ejecutivo
+
+El **Sistema DASUTEN** es una aplicación de escritorio Windows desarrollada en **Visual FoxPro 9** sobre el framework propietario **"Kermet"**. Se conecta a **SQL Server** vía ODBC usando autenticación Windows. El ejecutable principal es `DasutenSQL.exe` y la configuración de conexión reside en `Kermet.ini`.
+
+---
+
+## Tecnología
+
+| Componente | Detalle |
+| :--- | :--- |
+| **Lenguaje** | Visual FoxPro 9 (compilado a PE32 GUI Win32) |
+| **Framework** | Kermet (propietario, `Kernel.dll` + `libgen.prg` + `libclas.prg`) |
+| **Base de Datos** | SQL Server (instancia por defecto `MSSQLSERVER`) |
+| **Conexión** | ODBC Driver `SQL Server` — Autenticación Windows Integrada |
+| **Base** | `sysdasuten` |
+| **Sincronización** | FTP + archivos DBF/ZIP empaquetados con PKZIP25 |
+
+## Cadena de Conexión (`Kermet.ini`)
+
+```ini
+TIPOBASEDEDATOS=SQLServer
+[INFORMIX]
+DRIVER=INFORMIX 2.80 32 BIT
+DATABASE=Sysacad
+UID=informix
+SERVER=utn
+HOST=localhost
+SERVICE=turbo
+PROTOCOL=olsoctcp
+[SQLSERVER]
+DRIVER=SQL Server
+UID=
+ADDRESS=0
+LOCKEO=0
+SERVER=srvFENIX
+DATABASE=sysdasuten
+PWD=(cifrado binario)
+```
+
+### Campos Clave
+
+| Campo | Valor Original | Valor Migración |
+| :--- | :--- | :--- |
+| `SERVER` | `srvFENIX` | `sql-dasuten` ← **Cambiar** |
+| `DATABASE` | `sysdasuten` | `sysdasuten` (sin cambios) |
+| `DRIVER` | `SQL Server` | `SQL Server` (sin cambios) |
+| `UID` | *(vacío = Windows Auth)* | *(vacío = Windows Auth)* |
+
+> [!IMPORTANT]
+> El campo `SERVER` debe apuntar al hostname o IP del nuevo servidor SQL. Para la migración: `sql-dasuten` o `10.0.100.11`.
+
+## Estructura del Directorio de Distribución
+
+```
+runSysDasuten/
+├── Kermet.ini              ← Configuración de conexión SQL (MODIFICAR)
+├── registro.RKI            ← Config sincronización (Instancia=30)
+├── SysDasuten_Sincro.lnk   ← Acceso directo de sincronización
+├── khr / khw               ← Archivos de control (vacíos)
+├── Fonts/
+│   └── Fonts/
+│       ├── code39.ttf      ← Fuente código de barras Code39
+│       ├── I2OF5.TTF       ← Fuente código de barras Interleaved 2 of 5
+│       ├── I2OF5NT.TTF     ← Variante I2OF5
+│       └── PF_I2OF5_W.ttf  ← Variante I2OF5
+├── Sistema/
+│   ├── DasutenSQL.exe      ← Ejecutable principal (PE32 GUI)
+│   ├── Kernel.dll          ← DLL principal del framework Kermet
+│   ├── eztw32.dll          ← DLL de escaneo TWAIN
+│   ├── gdiplus.dll         ← GDI+ para gráficos
+│   ├── Kermet.ini          ← Copia de config (puede ser la efectiva)
+│   ├── registro.RKI        ← Config de sincronización
+│   ├── PKZIP25.EXE         ← Compresor para sincronización
+│   ├── SysDasuten_Sincro.bat  ← Bat de sincro FTP
+│   ├── InstaladorComponentesKermet.exe  ← Instalador dependencias
+│   ├── VFP9Rerr.log        ← Log de errores VFP
+│   ├── logdasuten2.txt     ← Log de sincronización FTP
+│   ├── Manuales de Uso/    ← Documentación del sistema
+│   │   └── Instructivo-Instalacion del sistema.doc
+│   ├── dasutensql.1292.exe ← Versión más reciente del ejecutable
+│   ├── dasutensql.1270.exe
+│   ├── dasutensql.1264.exe
+│   ├── dasutensql.1247.exe
+│   └── _gsdata_/           ← Metadata de sincronización GoodSync
+├── Actus/                  ← Actualizaciones históricas
+│   └── Hist/               ← Paquetes .zip y .rar de versiones previas
+└── error sincro/           ← Capturas de errores de sincronización
+```
+
+## Versiones del Ejecutable
+
+| Archivo | Observaciones |
+| :--- | :--- |
+| `DasutenSQL.exe` | Versión base (sin strings de conexión SQL visibles) |
+| `dasutensql.1247.exe` | Contiene referencias a `sysdasuten` |
+| `dasutensql.1264.exe` | Contiene referencias a `sysdasuten` |
+| `dasutensql.1270.exe` | Contiene referencias a `sysdasuten` |
+| `dasutensql.1292.exe` | **Más reciente**. Apunta a `SERVER=172.16.9.204\SQL2017`, `DATABASE=SYSDASUTEN`. Contiene referencia a `SYSDASUTEN_PRODUCCION`. |
+
+> [!WARNING]
+> La versión 1292 conecta a una instancia nombrada `SQL2017` en la IP `172.16.9.204`. Si la nueva infra usa instancia por defecto (`MSSQLSERVER`), el `.exe` base o una versión anterior puede ser más compatible. **Verificar cuál es la versión activa en producción consultando `srvv-fenix`**.
+
+## Modo de Ejecución Histórico
+
+Según los logs de errores y el bat de sincronización:
+
+- **Share UNC original**: `\\Quetzal\Sysdasuten\sistema\` → `\\srvFENIX\Sysdasuten\Sistema\`
+- **Ruta local alternativa**: `D:\SysDasuten\Sistema\dasutensql.exe`
+- **Sincronización**: `dasutensql.exe /RUN=SINCRONIZAR:FTP /usuario=sincro /password=sincroftp`
+- **Kermet.ini efectivo**: Se lee desde `\\servidor\Sysdasuten\kermet.ini` (raíz del share)
+
+## Dependencias para Despliegue
+
+### En el cliente Windows (pcv-dasu0)
+
+1. **Fuentes**: Instalar `code39.ttf`, `I2OF5.TTF`, `I2OF5NT.TTF`, `PF_I2OF5_W.ttf`
+2. **ODBC Driver**: `SQL Server` (incluido en Windows)
+3. **VFP Runtime**: Ya embebido en el `.exe` (no requiere instalación separada)
+4. **Componentes Kermet**: Ejecutar `InstaladorComponentesKermet.exe` si es necesario
+5. **Conectividad SQL**: El cliente debe resolver `sql-dasuten` por DNS o hosts
+
+### En el servidor SQL (sql-dasuten)
+
+1. **Base de datos**: `sysdasuten` ✅ (ya restaurada en `S:\Data\`)
+2. **Puerto SQL**: TCP 1433 (instancia por defecto) — verificar firewall
+3. **Autenticación**: Windows Integrada (el usuario del dominio `DASUTEN\admindasu` ya es sysadmin)
+4. **SQL Browser**: UDP 1434 — habilitar si se usan instancias nombradas
+
+## Plan de Despliegue en pcv-dasu0
+
+```
+1. Transferir directorio runSysDasuten/ a pcv-dasu0 vía SCP
+2. Modificar Kermet.ini → SERVER=sql-dasuten (o 10.0.100.11)
+3. Instalar fuentes (Fonts/)
+4. Ejecutar InstaladorComponentesKermet.exe
+5. Verificar firewall SQL 1433 en sql-dasuten
+6. Probar conexión: sqlcmd -S sql-dasuten -E -Q "SELECT DB_NAME()"
+7. Lanzar DasutenSQL.exe y verificar login
+```
+
+## Referencias
+
+- **Proyecto**: [P2601_dasuten.md](P2601_dasuten.md)
+- **Nodo SQL**: [sql-dasuten.md](../nodos/sql-dasuten.md)
+- **Directorio fuente**: `dtic-APPs/temp/runSysDasuten/`
+- **Bitácora**: [04/03/2026](../bitacoras/2026-03-04.md)

docs/investigacion/260305-0832_AgentesExternosZed.md

@@ -0,0 +1,64 @@
+# Investigación: Uso de Agentes de IA Externos en el IDE ZED (Modo Gratuito)
+
+## 1. Introducción
+La integración de asistentes de Inteligencia Artificial (IA) en los entornos de desarrollo (IDE) ha transformado la forma de programar. El IDE ZED, conocido por su velocidad extrema (escrito en Rust), destaca por su enfoque flexible hacia la IA: en lugar de atarte a un solo proveedor, te permite conectar múltiples agentes y elegir el mejor para cada tarea mediante su panel de asistente y la generación en línea (inline).
+
+En esta investigación analizaremos cómo sacar el máximo provecho de **Gemini**, **Copilot**, **DeepSeek** y **Claude** dentro de ZED, enfocándonos estrictamente en **planes gratuitos (Free Tiers)**.
+
+---
+
+## 2. Agentes de IA en ZED: Configuración y Uso Gratuito
+
+### A. Google Gemini
+Google ofrece una capa gratuita muy generosa a través de **Google AI Studio**.
+*   **Modo FREE/Gratuito**: Puedes generar una API Key en AI Studio sin costo. Esto te da acceso a modelos avanzados como **Gemini 1.5 Flash** y **Gemini 1.5 Pro**. Los límites gratuitos suelen ser muy amplios para un desarrollador individual (ej. 15 peticiones por minuto, 1 millón de tokens por minuto).
+*   **Integración en ZED**: ZED tiene soporte nativo. Solo necesitas abrir el panel del Asistente, seleccionar el proveedor `google` y configurar tu API Key obtenida en AI Studio.
+*   **Uso Ideal**: Análisis de grandes bloques de código o proyectos completos (gracias a su inmensa ventana de contexto de 1M-2M tokens) y tareas generales de programación.
+
+### B. Anthropic Claude
+Claude (especialmente el modelo Claude 3.5 Sonnet) es actualmente considerado por muchos como el mejor modelo para programación.
+*   **Modo FREE/Gratuito**: Anthropic no ofrece una API gratuita permanente directamente. **Sin embargo**, ZED incluye un servicio integrado llamado **ZED AI** que permite usar modelos como Claude 3.5 Sonnet de manera gratuita (con un sistema de limits de uso justo).
+*   **Integración en ZED**: Solo debes iniciar sesión con tu cuenta gratuita de ZED en el IDE y seleccionar "Zed AI" como proveedor en el panel del asistente.
+*   **Uso Ideal**: Tareas complejas de lógica, refactorización profunda, depuración intrincada y creación de arquitecturas desde cero. Su precisión en sintaxis es superior.
+
+### C. GitHub Copilot
+Copilot es el pionero. Recientemente, Microsoft introdujo versiones más accesibles.
+*   **Modo FREE/Gratuito**: GitHub ha habilitado un plan **Copilot Free** que ofrece un número limitado de autocompletados al mes y 50 mensajes de chat. (Además, es 100% ilimitado y gratuito si eres estudiante verificado, profesor, o mantenedor clave de un proyecto Open Source).
+*   **Integración en ZED**: ZED tiene integración oficial. Puedes iniciar sesión y vincular tu cuenta usando el Command Palette (`cmd/ctrl + shift + p`) > `copilot: sign in`.
+*   **Uso Ideal**: Autocompletado de código silente o "fantasma" a medida que escribes en el editor. Es excepcional prediciendo el bloque que necesitas línea a línea.
+
+### D. DeepSeek (DeepSeek Coder / V3 / R1)
+DeepSeek ha revolucionado el mercado por ser extremadamente competente y radicalmente barato u Open Source.
+*   **Modo FREE/Gratuito**: La API oficial es de pago (aunque a fracciones de centavo). Para un uso 100% gratuito, lo ideal es correrlo **localmente**. Sus modelos destilados (ej. DeepSeek-R1-Distill) pueden correr en una PC estándar sin problemas.
+*   **Integración en ZED**: ZED soporta la herramienta **Ollama** nativamente. Una vez que instalas Ollama (gratis) en tu sistema y descargas un modelo de DeepSeek (ej. ejecutando `ollama run deepseek-coder`), puedes seleccionar el proveedor `ollama` en el asistente de ZED, apuntando a tu `localhost`.
+*   **Uso Ideal**: Programación general y consultas sin requerir conexión a internet, garantizando **100% de privacidad** de tu código.
+
+---
+
+## 3. Ventajas y Desventajas Generales
+
+| Aspecto | Ventajas (Pros) | Desventajas (Contras) |
+| :--- | :--- | :--- |
+| **Productividad** | Acelera radicalmente la escritura de código "boilerplate" (repetitivo), unit tests y redacción de documentación. | **Alucinaciones**: El código generado a veces incluye librerías inexistentes o comete errores lógicos sutiles que parecen correctos. |
+| **Aprendizaje y Soporte** | Excelente para explicar código "legacy" (heredado), entender bugs crípticos o lenguajes que no dominas. | **Dependencia y Atrofia**: Un uso ciego puede atrofiar la capacidad del desarrollador para resolver problemas por sí mismo o diseñar arquitecturas. |
+| **Contexto Integrado** | ZED permite agregar archivos específicos al contexto del asistente (usando comandos como `/file` o `/tabs`) sin salir de la IDE. | **Riesgo de Privacidad**: Al enviar código a APIs públicas (Google, Anthropic o GitHub), expones propiedad intelectual. No debes enviar secretos corporativos o claves. (Excepto si usas DeepSeek local vía Ollama). |
+| **Costo** | Las capas gratuitas mencionadas intercaladas (ZED AI + Gemini + Local) cubren más del 90% de un flujo de trabajo intenso. | Los límites gratuitos (rate limits) pueden cortarte el flujo si confías exclusivamente en el tier gratuito de un solo proveedor en un día intenso. |
+
+---
+
+## 4. Estrategia: "Cuánto y Cómo Usar" en Modo Free
+
+Para armar el flujo de trabajo ideal en ZED gastando 0 USD, la clave es la **diversificación y la alternancia**:
+
+1. **Autocompletado Rápido (Mientras escribes):** 
+   * **Cómo:** Habilita GitHub Copilot Free o usa DeepSeek Coder corriendo localmente con Ollama.
+   * **Cuánto:** Actívalo de forma permanente, pero sé crítico. Si tras dos segundos de pausa la sugerencia "fantasma" no es lo que necesitas, ignórala y escribe tú.
+2. **Tareas Complejas y Diseño (Asistente Chat):**
+   * **Cómo:** Abre el Asistente lateral de ZED (`Cmd/Ctrl + b`). Usa **Zed AI (Claude 3.5 Sonnet)** como proveedor primario. Usa los comandos `/file`, `/tabs`, o `/selection` para incluir el código EXACTO que necesitas que analice.
+   * **Cuánto:** Úsalo cuando te "atasques" por más de 5 a 10 minutos, o para diseñar el esqueleto limpio de una función, una migración SQL, o expresiones regulares (Regex). Si Zed AI te advierte que has alcanzado el límite gratuito diario, cambia inmediatamente al proveedor de **Google (Gemini)**.
+3. **Edición Rápida (Inline Generation):**
+   * **Cómo:** Selecciona un bloque de código que escribiste y presiona el atajo de generación en línea (`Cmd/Ctrl + enter`). Escribe un prompt rápido como: `"agrega manejo de errores (try/catch)"` o `"traduce estos comentarios al español"`.
+   * **Cuánto:** Úsalo libremente para refactorizaciones menores y mejoras de seguridad.
+
+## Conclusión
+La filosofía "trae tu propio modelo" de ZED es su mayor fortaleza. Combinando inteligentemente **Zed AI (Claude 3.5)** para lógica pesada diaria, **Gemini (AI Studio)** de respaldo por su gran contexto, y **Ollama (DeepSeek)** para tareas privadas/locales, obtienes un entorno de desarrollo de última generación totalmente gratuito. El límite, con este setup, será tu propia revisión del código.

docs/plan/260304-1959_dashboard_P2601_en_bitacoras.md

@@ -0,0 +1,80 @@
+# Plan: Integración Dashboard P2601 en dtic-BITACORAs
+
+> Fecha: 04/03/2026 19:59hs  
+> Proyecto: P2601 - DASUTEN  
+> Estado: **Aprobado — En ejecución**
+
+## Objetivo
+
+Integrar el panel de seguimiento del proyecto P2601 dentro del sistema dtic-BITACORAs:
+- Accesible en `ns8.frlr.utn.edu.ar/bitacoras/p2601`
+- Datos almacenados en PostgreSQL (mismo stack que dtic-BITACORAs)
+- Discriminación de horas presenciales vs remotas por hito
+- Identificación de fases del proyecto
+
+## Esquema de Datos
+
+### Nuevas tablas (esquema `bitacoras`)
+
+```sql
+CREATE TABLE bitacoras.proyectos (
+    id SERIAL PRIMARY KEY,
+    codigo VARCHAR(10) NOT NULL UNIQUE,    -- 'P2601'
+    nombre VARCHAR(200) NOT NULL,
+    estado VARCHAR(10) DEFAULT '⏳',
+    descripcion TEXT,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE bitacoras.fases (
+    id SERIAL PRIMARY KEY,
+    proyecto_id INTEGER REFERENCES bitacoras.proyectos(id),
+    numero INTEGER NOT NULL,
+    nombre VARCHAR(200) NOT NULL,
+    estado VARCHAR(10) DEFAULT '⏳',
+    descripcion TEXT,
+    fecha_inicio DATE,
+    fecha_fin DATE,
+    UNIQUE(proyecto_id, numero)
+);
+
+CREATE TABLE bitacoras.hitos (
+    id SERIAL PRIMARY KEY,
+    fase_id INTEGER REFERENCES bitacoras.fases(id),
+    id_hito VARCHAR(20) NOT NULL,           -- 'A00', 'SSH', 'P02.DB'
+    titulo VARCHAR(200) NOT NULL,
+    descripcion TEXT,
+    estado VARCHAR(10) DEFAULT '⏳',
+    fecha DATE,
+    horas_presencial NUMERIC(5,2) DEFAULT 0,
+    horas_remoto NUMERIC(5,2) DEFAULT 0,
+    nodo_id INTEGER REFERENCES bitacoras.nodos(id),
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+```
+
+## Fases del proyecto P2601
+
+| # | Fase | Descripción | Nodos | Estado |
+|:--|:--|:--|:--|:--|
+| 1 | Infraestructura Física | Preparación hardware srv-dasu + Proxmox VE 9.1 | srv-dasu | ✅ |
+| 2 | Dominio y Directorio Activo | VM dc-dasuten, AD DS, DNS, dominio `dasuten.utnlr` | dc-dasuten | ✅ |
+| 3 | Motor de Base de Datos | VM sql-dasuten, SQL Server 2019, backup y restore sysdasuten | sql-dasuten | ✅ |
+| 4 | Acceso Remoto y Seguridad | OpenSSH 7022, w-zombi, firewall en todas las VMs | dc/sql/pcv-dasuten | ✅ |
+| 5 | Sistema DASUTEN | Ingeniería inversa, deploy DasutenSQL.exe, Kermet.ini | pcv-dasu0, sql-dasuten | ⏳ |
+| 6 | Cliente Final | Config pc-dasu0 en dominio, sistema productivo | pc-dasu0 | 📋 |
+
+## Archivos a modificar/crear
+
+| Acción | Archivo | Descripción |
+|:--|:--|:--|
+| MODIFY | `docker/init.sql` | Tablas proyectos, fases, hitos + datos semilla P2601 |
+| NEW | `backend/src/routes/proyectos.js` | API CRUD /api/proyectos con métricas |
+| MODIFY | `backend/src/server.js` | Registrar ruta proyectos |
+| NEW | `frontend/src/pages/ProyectoDashboard.tsx` | Página React con timeline, fases y métricas |
+| MODIFY | `frontend/src/App.tsx` | Ruta /bitacoras/p2601 |
+
+## Verificación
+
+- `curl` al endpoint `/api/proyectos/P2601`
+- Navegador a `https://ns8.frlr.utn.edu.ar/bitacoras/p2601`

docs/plan/260305-0930_PruebasDasuten.md

@@ -0,0 +1,21 @@
+# Plan de Pruebas: Sistema Dasuten (P02)
+
+**Fecha/Hora:** 260305-0930
+**Objetivo:** Confirmar el correcto funcionamiento y conectividad del entorno Dasuten.
+
+## Fases de la Prueba
+
+1. **Uso de Herramienta de Credenciales Secretas:**
+   - Modificar la herramienta `tools/ns8-candados` para que incluya instrucciones y explicación de uso en la cabecera.
+   - Ejecutar la herramienta `tools/ns8-candados` de manera que capture las credenciales requeridas en el entorno (o en una variable segura) sin exponer la salida (stdout) al flujo visible del chat, preservando la confidencialidad.
+
+2. **Verificación de Acceso Base:**
+   - Confirmar acceso SSH al servidor principal `pcv-dasu0` utilizando las credenciales obtenidas.
+   - Validar estado general del sistema (uptime, uso de recursos básicos).
+
+3. **Pruebas Funcionales Adicionales (A definir iterativamente):**
+   - *Se irán agregando puntos de prueba según el progreso y los resultados del acceso base.*
+
+## Protocolo de Registro (Bitácora First)
+- Todo paso debe ser previamente registrado en la bitácora del día correspondiente como iniciado.
+- Tras concluir cada paso o iteración, actualizar el registro en la bitácora con los resultados (éxito/fallo y observaciones).

docs/plan/260305-1010_ContextoADN_Dasuten.md

@@ -0,0 +1,22 @@
+# Plan de Implementación: Contexto en el ADN (Caso DASUTEN)
+
+**Fecha**: 2026-03-05
+**Objetivo**: Dotar a la IA y al proyecto de un protocolo estandarizado de "Auto-contextualización" sobre topología de redes, evitando operaciones ciegas (ej. Timeouts SSH en subredes NAT).
+
+## Propuesta de Cambios
+
+### Hebra: Directivas de la Inteligencia Artificial (`adn/05_ia.md`)
+Agregaremos una nueva directiva `13. Auto-Contextualización`.
+- **Regla:** Antes de iniciar pruebas de red o conexiones a nodos, la IA DEBE consultar el archivo del nodo (en la carpeta `nodos/`) y el proyecto asociado para comprender su ubicación en la topología (ej. si está detrás de un NAT, si requiere salto SSH, qué IP tiene).
+- **Ejecución:** Evitar asunciones de visibilidad directa; mapear el contexto siempre.
+
+### Hebra: Proyectos (`adn/07_proyectos.md`)
+Añadir la sección obligatoria de "Topología / Contexto de Red" a los manifiestos de proyecto.
+- **Topología Lógica / Contexto de Red:** Exige describir la ubicación de los nodos (ej: Red aislada, host físico, dependencias de NAT) para documentar y estandarizar el **CÓMO** llegar a ellos de forma técnica.
+
+### Manifiesto: P2601 Dasuten (`proyectos/P2601_dasuten.md`)
+Actualizar el manifiesto actual del proyecto Dasuten para reflejar esta nueva arquitectura de topología explícita.
+- Añadir una sección `## 🌐 Topología y Contexto de Red` explicando que:
+  1.  Todo el ecosistema Dasuten corre bajo `srv-dasu` (Standalone - 10.0.10.205).
+  2.  Las VMs periféricas (pcv-dasu0, dc-dasuten, sql-dasuten) están en una subred aislada `10.0.100.0/24`.
+  3.  **Regla de Acceso:** Para la intervención, es necesario un ruteo o ProxyJump a través de `10.0.10.205`.

docs/plan/260305-1017_Despliegue_runSysDasuten.md

@@ -0,0 +1,29 @@
+# Plan de Acción: Despliegue y Prueba de DASUTEN en pcv-dasu0
+
+**Fecha/Hora:** 260305-1017
+**Artefacto:** `tools/w-zombi/payloads/runSysDasuten.zip`
+**Objetivo:** Desplegar los binarios del sistema DASUTEN en la VM de pruebas (cliente Windows 10 LTSC) y verificar su conexión contra el motor SQL recién instalado en la fase DB01.
+
+## Fases del Despliegue
+
+### 1. Preparación y Transferencia
+1. Obtener credenciales de `admindasu` desde `ns8-candados`.
+2. Establecer túnel o salto SSH válido hacia la red `10.0.100.x` a través de `srv-dasu` (10.0.10.205).
+3. Transferir el archivo `tools/w-zombi/payloads/runSysDasuten.zip` vía SCP al disco virtual de `pcv-dasu0` apuntando al **puerto SSH 7022** (ej. en `C:\Dasuten\`).
+
+### 2. Descompresión y Configuración
+1. Descomprimir el archivo ZIP en el cliente usando PowerShell remoting / SSH.
+2. Localizar y editar el archivo de configuración `Kermet.ini`:
+   - Modificar la cadena de conexión de ODBC para `[SQLSERVER]`.
+   - Reemplazar `SERVER=srvFENIX` por el endpoint actual: `SERVER=sql-dasuten` (o la IP `10.0.100.11`).
+
+### 3. Instalación de Dependencias
+1. Instalar de forma automatizada las fuentes tipográficas necesarias de la carpeta `Fonts/` (códigos de barras Code39, I2OF5).
+2. Ejecutar silenciosa/desatendidamente `InstaladorComponentesKermet.exe` para registrar librerías VFP/Kermet requeridas por el sistema en el cliente.
+
+### 4. Pruebas de Verificación
+1. **Red**: Realizar un `Test-NetConnection` o ping desde `pcv-dasu0` hacia el puerto TCP 1433 de `sql-dasuten` para garantizar que el firewall permite el tráfico SQL.
+2. **Sistema GUI**: Invocar la apertura de `DasutenSQL.exe` (puede requerir verificación visual del usuario vía consola NoVNC de Proxmox o Anydesk/RDP). Se debe comprobar que se abre la pantalla de logon sin errores de conexión a la base de datos `sysdasuten`.
+
+## Registro y Trazabilidad
+- Todo evento de éxito/falla de red se registrará en la bitácora bajo la etiqueta `[P02]`.

docs/plan/260305-1300_Plan_Fase_6_Fisico_Dominio_GPO.md

@@ -0,0 +1,31 @@
+# Fase 6 - DASUTEN: Despliegue Físico, Dominio y Seguridad Local
+
+**Fecha:** 05/03/2026 - P2601 Proyecto Dasuten
+
+## Objetivo
+Habiendo superado la prueba de concepto (UAT) y verificado el funcionamiento del sistema en la red aislada `10.0.100.x` virtualizada bajo Proxmox, la siguiente fase consiste en **entregar la infraestructura a producción**.
+Esto implica el traslado físico del equipamiento, la adhesión de las estaciones de trabajo de los usuarios al nuevo Active Directory (`dc-dasuten`), y la configuración de las políticas organizativas.
+
+## Tareas a Realizar
+
+### 1. Instalación Física (Hardware)
+*   **Servidor Proxmox (`srv-dasu`)**: Trasladar el host físico a la oficina de DASUTeN e instalarlo en su locación definitiva (gabinete/rack), asegurando energía ininterrumpida (UPS) y conectividad de red adecuada.
+*   **Estaciones de Trabajo (`pc-dasu0` y otras si las hay)**: Reconectar y asegurar la conectividad L2 (física/switch) hacia el puerto de red que ofrece acceso al servidor `srv-dasu`.
+
+### 2. Integración de Red y Dominio
+*   **Configuración de Red Local**: Asegurar que la PC física tenga acceso a la red donde opera el controlador de dominio. Confirmar que su **DNS Primario** sea la IP de `dc-dasuten` (`10.0.100.10`).
+*   **Unión al Dominio**: Ingresar la PC `pc-dasu0` al dominio `dasuten.utnlr`.
+*   **Reasignación de Usuarios**: Mapear/Migrar los perfiles y datos del usuario local que usaba Andrea Almirón hacia su nueva cuenta de dominio.
+
+### 3. Seguridad y GPOs (Group Policy Objects)
+*   **Restricción de Acceso**: Configurar GPOs para prohibir la instalación de software no autorizado por los usuarios estándar de DASUTeN.
+*   **Unidades de Red**: Despliegue automático de mapeos de red necesarios (si la aplicación requiere una letra de unidad específica o para almacenamiento compartido) mediante GPO.
+*   **Restricciones de Explorador**: Ocultar u restringir acceso a la unidad C:\ y recursos sensibles.
+*   **Políticas de Contraseñas**: Asegurar rotación o longitud mínima para los usuarios del dominio.
+
+### 4. Revisión Final de Aplicaciones
+*   Distribuir el conjunto de accesos directos del sistema Dasuten (`DasutenSQL.exe`) al escritorio de todos los usuarios mediante GPO.
+*   Verificar que la conexión ODBC/Kermet funciona bajo el contexto de seguridad del usuario de dominio sin requerir elevación de privilegios.
+
+## Siguientes Pasos (IA)
+Una vez que el usuario informe que el equipo fue trasladado y encendido en su nueva locación, la IA asistirá vía Tailscale / AnyDesk (o conexiones remotas establecidas) con la configuración de las Políticas de Seguridad (GPOs) y las uniones de dominio.