@ronaldjdevfs/forge 1.3.3 → 1.3.5

package/README.md

@@ -1,6 +1,6 @@
 <img src="favicon.svg" alt="Forge Logo" width="100" height="100">
 
-> **v1.3.2** — Domain Subdirectory Structure & Port Support
+> **v1.3.5** — R13 Platform Domain Guard & Legacy Cleanup
 
 ## Forge — Backend Architecture Operating System
 
@@ -29,10 +29,10 @@ Los proyectos backend degeneran en código acoplado porque la infraestructura t
 |-----------|---------|-------------|
 | **Proyecto nuevo** | `forge` | Inicializa platform/features/shared/infra, detecta stack, crea `ARCHITECTURE.md` |
 | **Crear un nuevo dominio** | `cast` | Genera un feature completo desde cero (verifica platform/shared/infra primero) |
-| **Auditar arquitectura** | `inspect` | Evaluación completa 110pts → 0-100 con ownership, platform y grafo |
+| **Auditar arquitectura** | `inspect` | Evaluación completa 180pts → 0-100 con ownership, platform, grafo e import conventions |
 | **Migrar código legacy** | `relocate` | Traslada código a platform/, shared/, infra/ o features/ |
 | **Refactorizar** | `reforge` | Reestructura features o componentes multi-capa |
-| **Validar reglas** | `quench` | Verifica 9 reglas arquitectónicas (R1-R9) |
+| **Validar reglas** | `quench` | Verifica 12 reglas arquitectónicas (R1-R12) |
 | **Endurecer DI** | `temper` | Aplica inyección por constructor, elimina service locators |
 | **Analizar dependencias** | `chain` | Grafo multi-capa (platform, features, shared, infra), orden topológico, ciclos |
 | **Documentar** | `inscribe` | Genera/actualiza `ARCHITECTURE.md` con métricas, ownership y violaciones |
@@ -72,16 +72,20 @@ src/features/<name>/
 
 ### `inspect` — Auditoría arquitectónica
 
-Evalúa 6 categorías contra un máximo de 110 puntos (normalizado a 0-100):
+Evalúa 10 categorías contra un máximo de 180 puntos (normalizado a 0-100):
 
 | Categoría | Puntos | Qué mide |
 |-----------|--------|----------|
-| Structure | 20 | Organización de platform, features, shared, infra |
-| Layers | 20 | Aislamiento entre capas, imports prohibidos |
+| Structure | 30 | Organización de platform, features, shared, infra |
+| Layers | 25 | Aislamiento entre capas, imports prohibidos |
+| Decorators | 20 | Decoradores @injectable()/@inject() en use cases, controllers, repos |
 | Ownership | 20 | Huérfanos, duplicados, mal ubicados |
 | Platform | 15 | Completitud del backbone técnico (config, server, logger, di, etc.) |
 | Dependencies | 15 | Dirección de dependencias, ciclos, edges inválidos |
 | Graph | 20 | Salud del grafo arquitectónico, risk score |
+| Custom Rules | 5 | Reglas personalizadas desde `.forge/rules.json` |
+| Naming | 10 | Convenciones de nomenclatura PascalCase/kebab |
+| Import Conventions | 20 | R10-R12: bare specifiers, extensión .ts, bootstrap.di.js |
 
 **Resultado**: Score 0-100 con grado A-F y severidades por cada violación.
 
@@ -116,6 +120,10 @@ Ejecuta 9 reglas arquitectónicas (R1-R9) con severidad:
 | R7 | `infra → feature` (prohibido) | WARNING |
 | R8 | Cross-feature direct imports | ERROR |
 | R9 | Ciclos de dependencia | ERROR |
+| R10 | Bare specifiers en imports locales | ERROR |
+| R11 | Extensión `.ts` en imports (debe ser `.js`) | ERROR |
+| R12 | Import a `bootstrap.di.js` (no existe) | CRITICAL |
+| R12b | `registerSingleton` con model() de Mongoose | CRITICAL |
 
 ### `temper` — Endurecimiento de DI
 
@@ -311,8 +319,8 @@ Ver `reference/patterns.md` para el detalle completo.
 - **4 dominios arquitectónicos**: Platform (backbone), Features (negocio), Shared (código puro), Infra (implementaciones)
 - **Architecture graph como fuente de verdad**: 6 tipos de nodo (platform, feature, shared, infra, domain, adapter), 9 reglas (R1-R9), risk score y dependency health
 - **Ownership automático**: Detección de huérfanos, duplicados, componentes mal ubicados y sugerencias de reubicación
-- **Scoring arquitectónico**: 110 puntos en 6 categorías, normalizado a 0-100 con grado A-F
-- **5 perfiles tecnológicos predefinidos**: Express + MongoDB, Express + PostgreSQL, Express + Prisma, Fastify + Prisma, NestJS + Prisma
+- **Scoring arquitectónico**: 180 puntos en 10 categorías, normalizado a 0-100 con grado A-F
+- **10 perfiles tecnológicos predefinidos**: Express + MongoDB, Express + PostgreSQL, Express + Prisma, Express + Drizzle, Fastify + MongoDB, Fastify + PostgreSQL, Fastify + Prisma, NestJS + MongoDB, NestJS + PostgreSQL, NestJS + Prisma
 - **Boot sequence obligatoria**: 9 pasos que garantizan contexto completo antes de cualquier acción
 - **Documentación automática**: `ARCHITECTURE.md` vivo que se actualiza tras cada operación
 - **Sin dependencias runtime**: Solo Node ≥ 18, todo corre con scripts ESM propios
@@ -358,7 +366,7 @@ Donde vive toda la inteligencia arquitectónica:
 | `scripts/profile.mjs` | Matchea stack contra perfiles conocidos o sintetiza uno genérico |
 | `scripts/graph.mjs` | Grafo completo: 6 tipos de nodo, 4 capas, 9 reglas (R1-R9), risk score, dependency health |
 | `scripts/chain.mjs` | Grafo multi-capa (platform, features, shared, infra) con orden topológico |
-| `scripts/detect.mjs` | Validación de reglas R1-R9 con inline ignores y `--fix` |
+| `scripts/detect.mjs` | Validación de reglas R1-R12 con inline ignores, `--fix` e import conventions |
 | `scripts/inspect.mjs` | Orquesta auditoría completa con reporte coloreado |
 | `scripts/architecture.mjs` | Genera/actualiza `ARCHITECTURE.md` vivo |
 | `scripts/bootstrap.mjs` | Inicializa platform/shared/infra según perfil (interno) |
@@ -385,7 +393,7 @@ Donde vive toda la inteligencia arquitectónica:
 | `reference/assay.md` | Documentación del comando assay |
 | `reference/hooks.md` | Documentación del sistema de hooks |
 | `profiles/` | 10 perfiles tecnológicos detallados |
-| `templates/feature/` | 17 templates TypeScript para features |
+| `templates/feature/` | 19 templates TypeScript para features |
 | `templates/platform/` | 6 templates para componentes de platform |
 | `templates/shared/` | 4 templates para shared (errors, contracts, types, utils) |
 | `templates/infra/` | 4 templates para infra (prisma, mongodb, redis, mail) |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ronaldjdevfs/forge",
-  "version": "1.3.3",
+  "version": "1.3.5",
   "description": "Forge — Architecture Operating System for backend systems. Arquitectura Hexagonal, DDD pragmático y vertical slices.",
   "type": "module",
   "bin": {

package/skills/forge/SKILL.md

@@ -150,6 +150,17 @@ El boot usa caché de `.forge/cache/`. Si los archivos `src/` no cambiaron, los
 - Si `ARCHITECTURE.md` está desactualizado (fecha de auditoría > 7 días), sugerir `forge inscribe`.
 - Todos los resultados se muestran con severidades: `[CRITICAL]`, `[ERROR]`, `[WARNING]`, `[INFO]`, `[SUGGESTION]`.
 
+### ⚠️ Regla de Platform: Sin lógica de dominio
+
+Cuando `reforge` o `relocate` operen sobre `src/platform/`, verificar que los archivos movidos/creados no contengan lógica de dominio:
+
+- **No** mover entidades, value objects, casos de uso, mappers de dominio, schemas de entidades, repositorios de dominio a `platform/`
+- **No** crear archivos con sufijos `.entity.ts`, `.uc.ts`, `.mapper.ts`, `.repository.ts` (domain), `.port.ts` dentro de `platform/`
+- **No** importar desde `features/` dentro de `platform/` (viola R2)
+- Si un componente tiene imports hacia `domain/` o `features/`, pertenece a un feature, no a platform
+
+Platform solo acepta: config, database, http, server, logger, cache, security, events, scheduler, observability, di.
+
 ### Inline Ignores
 
 Forge soporta comentarios inline para excepcionar violaciones línea por línea:

package/skills/forge/reference/cast.md

@@ -143,6 +143,49 @@ Usar el perfil detectado para determinar:
 - Convenciones de imports (rutas relativas vs alias)
 - Componentes de platform a usar (config, logger, http, database)
 
+## ⚠️ Post-Cast: Entity Discovery
+
+Antes de crear `<Name>.entity.ts`, verificar si la entidad ya existe como entidad compartida:
+
+1. **Buscar en `src/platform/domain/entities/<Name>.ts`** — si existe, NO crear entidad local
+2. **Si es compartida**: usar `@/domain/entities/<Name>.js` en vez de path relativo en todos los templates
+3. **Verificar también** `src/shared/contracts/` por interfaces/DTOs existentes
+
+Regla: si la entidad vive fuera del feature, todos los imports deben usar path alias `@/domain/`, no `../../`.
+
+## ⚠️ Post-Cast: DI Wiring
+
+Después de crear los archivos del feature, generar `di.ts` siguiendo el template `templates/feature/di.ts.md`:
+
+1. **Feature con DI propia**: crear `src/features/<name>/di.ts` usando el template
+2. **Feature SIN DI propia**: si ya existe `src/platform/setting/dependencies/<name>.di.js`, los controllers deben importar desde allí en vez de `bootstrap.di.js`
+3. **Controllers**: asegurar que el import en el controller apunte a `@/setting/dependencies/<name>.di.js` o `./di.js`, NUNCA a `bootstrap.di.js`
+4. **Mongoose model()**: si el schema exporta `export default model()` (objeto, no clase), el DI debe usar `container.register(..., { useValue: ... })`, NO `registerSingleton`
+
+## ⚠️ Post-Cast: Tests
+
+Después del scaffold, generar tests unitarios para cada use case siguiendo `templates/feature/test.ts.md`:
+
+1. Crear `src/features/<name>/__tests__/Create<Name>.test.ts`
+2. Usar `node:test` (sin dependencias externas)
+3. Convenciones de test:
+   - Extension `.js` en imports (no `.ts`)
+   - `as const` para literales de union types: `status: "activo" as const`
+   - `result!` (non-null assertion) cuando execute() retorna `T | null`
+   - `(result as any)._id` si `_id` no existe en el tipo de dominio
+
+## ⚠️ Post-Cast: Import Validation Checklist
+
+Antes de dar por terminado el feature, verificar CADA archivo generado:
+
+- [ ] Todos los imports locales usan prefijo `./` o `../` — sin bare specifiers (`import X from "domain/..."` ❌)
+- [ ] Todos los imports tienen extensión `.js` — sin extensión `.ts`
+- [ ] Entidades compartidas usan `@/domain/` — sin paths relativos rotos
+- [ ] Controllers importan desde `di.ts` o `@/setting/dependencies/` — no desde `bootstrap.di.js`
+- [ ] Nombres de método del controller coinciden con los de la ruta (ej: `createHandler` en controller → `controller.createHandler` en routes)
+- [ ] DI usa `register({ useValue })` para modelos Mongoose — no `registerSingleton`
+- [ ] Tests: `.js` extension, `as const`, `!`, `as any` para _id
+
 ## Post-creación
 
 - `forge quench` — verificar que no hay violaciones

package/skills/forge/reference/patterns.md

@@ -150,11 +150,70 @@ REST prefiere `/api/v1/resources`. GraphQL schema en `adapters/in/graphql/` dent
 
 ---
 
+## Import Conventions (OBLIGATORIO)
+
+Todo import generado por Forge debe cumplir estas reglas. Violaciones = ERROR en forge quench:
+
+### 1. Prefijo relativo obligatorio
+Los imports locales SIEMPRE deben usar prefijo `./` o `../`. Prohibido el bare specifier:
+```ts
+// ✅ Correcto
+import { X } from "./foo.js";
+import { Y } from "../../bar.js";
+
+// ❌ Incorrecto (bare specifier — se resuelve contra node_modules)
+import { X } from "domain/entities/Task.js";
+import { Y } from "domain/repositories/IRepo.js";
+```
+
+### 2. Extensión .js obligatoria
+Con `moduleResolution: "nodenext"`, todos los imports locales requieren extensión `.js`:
+```ts
+// ✅ Correcto
+import { X } from "./foo.js";
+
+// ❌ Incorrecto
+import { X } from "./foo.ts";
+import { X } from "./foo";
+```
+
+### 3. Path alias para cross-layer
+Usar path alias `@/` para cruzar capas, no paths relativos largos:
+| Capa | Alias | Ejemplo |
+|------|-------|---------|
+| Platform → cualquiera | `@/platform/` | `@/platform/config/App.config.js` |
+| Shared → cualquiera | `@/shared/` | `@/shared/errors/NotFoundError.js` |
+| Infra → cualquiera | `@/infra/` | `@/infra/mongodb/Mongo.config.js` |
+| **Entities compartidas** | **`@/domain/`** | **`@/domain/entities/Task.js`** |
+
+```ts
+// ✅ Correcto — path alias para entidad compartida
+import { Task } from "@/domain/entities/Task.js";
+
+// ❌ Incorrecto — path relativo largo que no resuelve
+import { Task } from "../../../../domain/entities/Task.js";
+```
+
+### 4. Entity Discovery — compartida vs local
+- Si la entidad vive en `src/features/<feature>/domain/entities/` → import relativo (`../../domain/entities/`)
+- Si la entidad vive en `src/platform/domain/entities/` → path alias (`@/domain/entities/`)
+- Verificar existencia ANTES de generar el import
+
+### 5. Controllers y DI
+- Controllers importan desde `./di.js` (feature con DI propia) o `@/setting/dependencies/<name>.di.js` (feature sin DI propia)
+- Prohibido importar desde `bootstrap.di.js` — ese archivo no existe en la arquitectura actual
+
+### 6. Tests
+- Todos los imports con extensión `.js` (nunca `.ts`)
+- Usar `as const` para literales de union types
+- Usar `result!` para valores posiblemente null
+- Usar `(result as any)._id` si `_id` no está en el tipo
+
 ## Export Conventions
 
 - Cada directorio expone un `index.ts` barrel con named exports
 - Usar `export * from "./<Name>.<artifact>.js"` en barrels
 - Preferir `export function` / `export class` sobre `export default`
 - Imports relativos dentro del mismo feature (`../../domain/`)
-- Path alias para cross-layer: `@/platform/`, `@/shared/`, `@/infra/`
+- Path alias para cross-layer: `@/platform/`, `@/shared/`, `@/infra/`, `@/domain/`
 - Extension `.js` en imports (ESM compat): `import { X } from "./foo.js"`

package/skills/forge/reference/principles.md

@@ -28,6 +28,8 @@
 
 12. **Cuatro dominios arquitectónicos con ownership estricto** — Todo backend se modela en cuatro capas: Platform (backbone técnico), Features (negocio), Shared (código puro reutilizable) e Infrastructure (implementaciones concretas). Cada componente tiene un único propietario arquitectónico. Los huérfanos, duplicados y componentes mal ubicados se detectan automáticamente. Las reglas de dependencia entre capas son obligatorias: `feature → platform → infra`, `feature → shared`, `adapter → infra`. Cualquier violación es una degradación arquitectónica.
 
+    **⚠️ Platform es exclusivamente backbone técnico.** Nunca debe contener entidades de dominio, casos de uso, mappers, repositorios de dominio, schemas de entidades, DTOs de negocio ni ninguna lógica con reglas de negocio. Si un archivo en `platform/` tiene sufijos `.entity.ts`, `.uc.ts`, `.mapper.ts`, `.port.ts` o importa desde `features/`, está mal ubicado. Esa lógica pertenece a `src/features/<name>/`. Violar esto introduce acoplamiento `platform → feature` (R2) y contamina el backbone técnico con lógica de dominio (R13).
+
 13. **Errores tipados en el dominio** — Los errores de dominio son clases explícitas, no `throw Error()` genéricos. Viven en `shared/errors/` si son transversales o en `domain/` del feature si son específicos. Los adapters HTTP traducen errores de dominio a códigos HTTP. La capa de aplicación nunca sabe qué códigos HTTP existen. Ver `reference/errors.md`.
 
 14. **Tests como ciudadanos de primera clase** — El dominio y los casos de uso se testean con unit tests sin infraestructura (mocks en las interfaces). Los adapters se testean con integration tests contra infraestructura real. La pirámide de tests es 70% unit / 20% integration / 10% e2e. Sin coverage de use cases no hay aprobación arquitectónica. Ver `reference/testing-patterns.md`.

package/skills/forge/reference/reforge.md

@@ -67,9 +67,15 @@ $ forge reforge src/features/users/domain/userEntity.ts
    - Naming violations (si no se corrigieron en paso 5)
    - Warnings
 7. Ejecutar cambios en el feature o componente
-8. Verificar con `forge rollback verify` — si el score empeora, restaurar
-9. Ejecutar `forge quench` para verificar
-10. Actualizar `ARCHITECTURE.md`
+8. **Eliminar estructura legacy** — después de migrar/refactorizar, limpiar todo el código fuente legacy que ya no tenga referencias activas:
+   - Archivos originales en ubicaciones legacy (`src/domain/`, `src/application/`, `src/adapters/`, etc.)
+   - Barrel files (`index.ts`) que exportaban exclusivamente código legacy
+   - Directorios vacíos que quedaron huérfanos tras la migración
+   - No dejar imports rotos ni archivos sin dueño
+9. Verificar con `forge rollback verify` — si el score empeora, restaurar
+10. Ejecutar `forge quench` para verificar 0 violaciones
+11. Ejecutar `forge armorer` — confirmar ownership saludable (0 huérfanos, 0 duplicados)
+12. Actualizar `ARCHITECTURE.md`
 
 ### Flags
 
@@ -88,11 +94,27 @@ forge rollback list
 forge rollback restore <id>
 ```
 
+## ⚠️ Regla crítica: Platform solo acepta backbone técnico
+
+**Platform NO debe contener lógica de dominio.** Al refactorizar hacia `src/platform/`, verificar que el componente sea exclusivamente técnico:
+
+| ✅ Permitido en Platform | ❌ Prohibido en Platform |
+|---|---|
+| config, server, logger, DI | Entidades de dominio |
+| http, middleware, router | Casos de uso |
+| cache, security, events | Repositorios (domain) |
+| database, scheduler, observability | Mappers de dominio |
+| Conexiones, clientes de infra | Schemas de entidades |
+| Tokens de DI, contenedores | DTOs de negocio |
+| Health checks, métricas | Lógica de reglas de negocio |
+
+Si durante la refactorización un componente tiene lógica de dominio (entidades, `if/switch` con reglas de negocio, casos de uso), **debe ir a `src/features/<name>/`**, no a `platform/`. Violar esto introduce acoplamiento `platform → feature` (R2).
+
 ## Refactorización multi-capa
 
 Reforge ahora considera las cuatro capas arquitectónicas:
 
-- **Platform**: Mover componentes técnicos sueltos a `src/platform/`
+- **Platform**: Mover componentes técnicos sueltos a `src/platform/` (nunca lógica de dominio)
 - **Features**: Reestructurar features con violaciones
 - **Shared**: Extraer código duplicado a `src/shared/`
 - **Infra**: Organizar implementaciones concretas en `src/infra/`

package/skills/forge/reference/relocate.md

@@ -25,10 +25,16 @@ También puede migrar componentes legacy a los layers Platform, Shared o Infrast
 3. Crear la estructura target según el layer
 4. Migrar archivos manteniendo la lógica intacta
 5. Actualizar imports
-6. Eliminar estructura legacy
+6. **Eliminar estructura legacy por completo** — no dejar archivos huérfanos, barrel files (index.ts) vacíos, ni directorios legacy sin contenido. Verificar:
+   - `src/application/use-cases/<name>/` queda vacío y se elimina
+   - `src/adapters/in/http/controllers/` sin archivos del feature migrado
+   - `src/domain/entities/`, `src/domain/repositories/` sin duplicados
+   - `src/setting/dependencies/` sin `.di.ts` del feature migrado
+   - Barrel files (`index.ts`) que solo exportaban código legacy se eliminan
 7. Verificar con `forge rollback verify` — si el score empeora, restaurar con `forge rollback restore <backup-id>`
-8. Ejecutar `forge quench` para verificar
-9. Actualizar `ARCHITECTURE.md`
+8. Ejecutar `forge quench` para verificar 0 violaciones
+9. Ejecutar `forge armorer` — confirmar que no hay huérfanos ni duplicados del código legacy
+10. Actualizar `ARCHITECTURE.md`
 
 ## Rollback
 
@@ -41,6 +47,22 @@ forge rollback restore <id>  # restaurar
 
 El backup se almacena en `.forge/backups/<target>--<timestamp>/` y preserva la estructura original completa.
 
+## ⚠️ Regla crítica: No insertar lógica de dominio en Platform
+
+Al migrar componentes legacy, **nunca colocar lógica de dominio en `src/platform/`**. Platform es exclusivamente backbone técnico.
+
+| Tipo de componente | Layer correcto |
+|---|---|
+| Configuración de framework, servidor, logger, DI | `src/platform/` |
+| Middleware HTTP, routers, guards, interceptors | `src/platform/http/` |
+| Conexiones a BD, clientes Redis, mail | `src/infra/` |
+| Código utilitario puro (sin lógica de negocio) | `src/shared/` |
+| **Entidades, value objects, reglas de dominio** | **`src/features/<name>/domain/`** |
+| **Casos de uso, servicios de aplicación** | **`src/features/<name>/application/`** |
+| **Controladores, repositorios, schemas** | **`src/features/<name>/adapters/`** |
+
+Si un archivo contiene `class`, `interface` con reglas de negocio, `if/switch` con lógica de dominio, o importa desde `features/`, pertenece a un feature, no a platform.
+
 ## Estrategias por layer
 
 | Layer | Desde | Hacia |

package/skills/forge/scripts/armorer.mjs

@@ -246,6 +246,27 @@ export function detectMisplaced(projectRoot = ROOT) {
         suggestion: "Envolver en un adapter dentro de features/<name>/adapters/out/",
       });
     }
+
+    // R13: Platform con lógica de dominio
+    if (isPlatformFile) {
+      const basenamePath = basename(file);
+      const DOMAIN_PATTERNS = /\.(entity|uc|mapper|port|repository)\.(ts|js)$/i;
+      if (DOMAIN_PATTERNS.test(basenamePath)) {
+        misplaced.push({
+          file: relPath,
+          reason: "Platform contiene artefacto de dominio — violación R13",
+          suggestion: "Mover a src/features/<name>/domain/ o application/ según corresponda",
+        });
+      }
+      const featureImportMatch = content.match(featurePattern);
+      if (featureImportMatch) {
+        misplaced.push({
+          file: relPath,
+          reason: "Platform importa de features — violación R2",
+          suggestion: "Platform no debe conocer lógica de negocio. Extraer interfaz a shared/contracts/ o refactorizar.",
+        });
+      }
+    }
   }
 
   return misplaced;

package/skills/forge/scripts/detect.mjs

@@ -848,6 +848,67 @@ export function checkPlatform(ctx) {
   return { score: Math.min(score, 15), checks };
 }
 
+/* ── R13: Domain logic in platform ── */
+
+export function checkPlatformForDomain(ctx) {
+  const checks = [];
+  let score = 10;
+
+  if (!ctx.platform || !ctx.platform.exists) {
+    return { score, checks };
+  }
+
+  const DOMAIN_PATTERNS = /\.(entity|uc|mapper|port|repository)\.(ts|js)$/i;
+  const DOMAIN_KEYWORDS = /\b(entity|useCase|use_case|valueObject|domainService|domain_event|dto)\b/i;
+  const LOGIC_KEYWORDS = /\b(if|for|while|switch|catch|throw|return)\s*\(/g;
+
+  const platformDir = join(ROOT, "src", "platform");
+  if (!isDir(platformDir)) return { score: score, checks };
+
+  const allPlatformFiles = findFiles(platformDir, ".ts", 6).concat(findFiles(platformDir, ".js", 6));
+  let violations = 0;
+
+  for (const f of allPlatformFiles) {
+    const relPath = relative(ROOT, f);
+    const basenamePath = basename(f);
+
+    // Check 1: File naming suggests domain artifact
+    if (DOMAIN_PATTERNS.test(basenamePath)) {
+      checks.push({
+        ...severity(`[R13] Platform contiene artefacto de dominio: ${basenamePath}`, SEVERITY.CRITICAL),
+        pass: false,
+        detail: relPath,
+        fix: "Mover a src/features/<name>/domain/ o application/. Platform no debe tener lógica de negocio.",
+      });
+      violations++;
+      score -= 3;
+      continue;
+    }
+
+    // Check 2: Content references domain concepts
+    const content = read(f);
+    if (!content) continue;
+
+    if (DOMAIN_KEYWORDS.test(content)) {
+      checks.push({
+        ...severity(`[R13] Platform contiene terminología de dominio en ${basenamePath}`, SEVERITY.WARNING),
+        pass: false,
+        detail: relPath,
+        fix: "Si contiene lógica de negocio, mover a features/. Si es naming accidental, renombrar.",
+      });
+      violations++;
+      score -= 2;
+    }
+  }
+
+  if (violations === 0 && allPlatformFiles.length > 0) {
+    checks.push({ ...severity("Platform sin lógica de dominio", SEVERITY.INFO), pass: true });
+    score = 10;
+  }
+
+  return { score: Math.max(score, 0), checks };
+}
+
 export function checkDependencies(ctx) {
   const checks = [];
   let score = 0;
@@ -997,6 +1058,111 @@ export function checkNaming(projectRoot = ROOT) {
   return { score: Math.max(score, 0), checks };
 }
 
+export function checkImportConventions(features) {
+  const checks = [];
+  let score = 20;
+
+  if (features.length === 0) return { score: 20, checks };
+
+  const allFeatureFiles = findFiles(FEATURES, ".ts", 6).concat(findFiles(FEATURES, ".js", 6));
+  const allPlatformFiles = isDir(join(SRC, "platform")) ? findFiles(join(SRC, "platform"), ".ts", 6) : [];
+  const files = [...allFeatureFiles, ...allPlatformFiles];
+
+  let r10Violations = 0; // Bare specifiers
+  let r11Violations = 0; // Missing .js extension
+  let r12Violations = 0; // bootstrap.di.js imports
+
+  for (const f of files) {
+    const content = read(f);
+    if (!content) continue;
+    const imports = parseImportsWithLines(content, f);
+
+    for (const imp of imports) {
+      const src = imp.source;
+
+      // R10: Bare specifier — import from "domain/..." (no ./ ../ @/ prefix)
+      if (
+        !src.startsWith("./") &&
+        !src.startsWith("../") &&
+        !src.startsWith("@/") &&
+        !src.startsWith("/") &&
+        src.includes("/") &&
+        !src.startsWith("tsyringe") &&
+        !src.startsWith("reflect-metadata") &&
+        !src.startsWith("express") &&
+        !src.startsWith("node:") &&
+        !src.startsWith("mongoose") &&
+        !src.startsWith("prisma") &&
+        src !== "tsyringe" &&
+        !src.includes("node_modules")
+      ) {
+        r10Violations++;
+        checks.push({
+          severity: SEVERITY.ERROR,
+          label: `[R10] Bare specifier en import local — debe usar ./ o @/`,
+          pass: false,
+          detail: `${relative(ROOT, f)}:${imp.line} → "${src}"`,
+          fix: `Reemplazar "${src}" por "./${src}.js" (relativo) o "@/shared/${src.split("/").pop()}" (alias)`,
+        });
+        score -= 2;
+      }
+
+      // R11: Import con extensión .ts en vez de .js
+      if (src.endsWith(".ts") && !src.endsWith(".d.ts")) {
+        r11Violations++;
+        checks.push({
+          severity: SEVERITY.ERROR,
+          label: `[R11] Import con extensión .ts — debe usar .js`,
+          pass: false,
+          detail: `${relative(ROOT, f)}:${imp.line} → "${src}"`,
+          fix: src.replace(/\.ts$/, ".js"),
+        });
+        score -= 2;
+      }
+
+      // R12: Import desde bootstrap.di.js
+      if (src.includes("bootstrap.di")) {
+        r12Violations++;
+        checks.push({
+          severity: SEVERITY.ERROR,
+          label: `[R12] Import desde bootstrap.di.js — no existe en arquitectura actual`,
+          pass: false,
+          detail: `${relative(ROOT, f)}:${imp.line} → "${src}"`,
+          fix: `Reemplazar por "./di.js" (feature con DI propia) o "@/setting/dependencies/<feature>.di.js" (feature sin DI propia)`,
+        });
+        score -= 3;
+      }
+    }
+
+    // R12b: registerSingleton con model() (Mongoose)
+    if (content.includes("registerSingleton") && content.includes("model(")) {
+      checks.push({
+        severity: SEVERITY.WARNING,
+        label: `[R12] registerSingleton usado con model() — debe usar register({ useValue })`,
+        pass: false,
+        detail: relative(ROOT, f),
+        fix: 'Reemplazar container.registerSingleton(...) por container.register(..., { useValue: ... as any })',
+      });
+      score -= 2;
+    }
+  }
+
+  if (r10Violations === 0 && files.length > 0) {
+    checks.push({ ...severity("[R10] Sin bare specifiers en imports", SEVERITY.INFO), pass: true });
+    score += 2;
+  }
+  if (r11Violations === 0 && files.length > 0) {
+    checks.push({ ...severity("[R11] Sin imports con extensión .ts", SEVERITY.INFO), pass: true });
+    score += 2;
+  }
+  if (r12Violations === 0 && files.length > 0) {
+    checks.push({ ...severity("[R12] Sin imports a bootstrap.di.js", SEVERITY.INFO), pass: true });
+    score += 2;
+  }
+
+  return { score: Math.max(score, 0), checks };
+}
+
 export function allChecks(features, graph, ctx) {
   const g = graph || getGraph();
   const c = ctx || {};
@@ -1006,10 +1172,12 @@ export function allChecks(features, graph, ctx) {
     decorators: checkDecorators(features),
     ownership: checkOwnership(c),
     platform: checkPlatform(c),
+    platformDomain: checkPlatformForDomain(c),
     dependencies: checkDependencies(c),
     graph: checkGraph(g),
     customRules: checkCustomRules(features),
     naming: checkNaming(),
+    importConventions: checkImportConventions(features),
   };
 }
 
@@ -1103,6 +1271,26 @@ export function applyFixes(checks, projectRoot = ROOT) {
       }
     }
 
+    // Fix R11: .ts → .js in import path
+    if (check.label?.includes("[R11]") && check.fix && check.detail) {
+      const filePath = join(projectRoot, check.detail.split(":")[0]);
+      if (existsSync(filePath)) {
+        const content = readFileSync(filePath, "utf-8");
+        const newContent = content.replace(
+          /(from\s+['"])([^'"]+)\.ts(['"])/g,
+          (match, prefix, path, suffix) => {
+            if (path.endsWith(".d")) return match;
+            return `${prefix}${path}.js${suffix}`;
+          }
+        );
+        if (newContent !== content) {
+          writeFileSync(filePath, newContent);
+          fixed++;
+          details.push(`  ${GREEN}✔${RESET} ${relative(projectRoot, filePath)}: extensión .ts → .js en imports`);
+        }
+      }
+    }
+
     // Fix missing reflect-metadata import
     if (check.fix?.includes('import "reflect-metadata"') && check.detail) {
       const filePath = join(projectRoot, check.detail);

package/skills/forge/scripts/forgeSmith.mjs

@@ -60,11 +60,96 @@ function hasCriticalViolations(result) {
  * Quick check against proposed content.
  * Returns violations that would be introduced by the proposed content.
  */
+/**
+ * Quickly check proposed content for common import violations
+ * before the file is written to disk (preToolUse guard).
+ */
+function checkProposedContentViolations(filePath, content) {
+  const violations = [];
+  const lines = content.split("\n");
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // Match import/export from statements
+    const importMatch = line.match(
+      /(?:import|export)\s+(?:type\s+)?(?:\{[^}]*\}|[^;{]+?)\s+from\s+['"]([^'"]+)['"]/
+    );
+    if (!importMatch) continue;
+
+    const src = importMatch[1];
+    const lineNum = i + 1;
+
+    // R10: Bare specifier — import from "domain/..." (no ./ ../ @/ prefix)
+    if (
+      !src.startsWith("./") &&
+      !src.startsWith("../") &&
+      !src.startsWith("@/") &&
+      !src.startsWith("/") &&
+      src.includes("/") &&
+      !src.startsWith("tsyringe") &&
+      !src.startsWith("reflect-metadata") &&
+      !src.startsWith("express") &&
+      !src.startsWith("node:") &&
+      !src.startsWith("mongoose") &&
+      !src.startsWith("prisma") &&
+      src !== "tsyringe"
+    ) {
+      violations.push({
+        severity: "CRITICAL",
+        label: `[R10] Bare specifier — debe usar ./ o @/ prefix`,
+        detail: `${filePath}:${lineNum} → "${src}"`,
+        fix: `Agregar prefijo "./" o "@/" al import`,
+      });
+    }
+
+    // R11: Import con extensión .ts en vez de .js
+    if (src.endsWith(".ts") && !src.endsWith(".d.ts")) {
+      violations.push({
+        severity: "ERROR",
+        label: `[R11] Import con extensión .ts — debe usar .js`,
+        detail: `${filePath}:${lineNum} → "${src}"`,
+        fix: src.replace(/\.ts$/, ".js"),
+      });
+    }
+
+    // R12: import desde bootstrap.di.js
+    if (src.includes("bootstrap.di")) {
+      violations.push({
+        severity: "CRITICAL",
+        label: `[R12] Import a bootstrap.di.js — no existe en esta arquitectura`,
+        detail: `${filePath}:${lineNum} → "${src}"`,
+        fix: 'Usar "./di.js" o "@/setting/dependencies/<feature>.di.js"',
+      });
+    }
+  }
+
+  // R12b: registerSingleton con model() (Mongoose)
+  if (content.includes("registerSingleton") && content.includes("model(")) {
+    violations.push({
+      severity: "CRITICAL",
+      label: `[R12] registerSingleton con model() — usar register({ useValue })`,
+      detail: filePath,
+      fix: 'container.register("Token", { useValue: Model as any })',
+    });
+  }
+
+  return violations;
+}
+
 async function checkProposedFile(filePath, content) {
   if (!isSourceFile(filePath)) {
     return { violations: [], total: 0, hasCritical: false, hasErrors: false };
   }
 
+  // Fast pre-check on proposed content (before it hits disk)
+  const contentViolations = checkProposedContentViolations(filePath, content);
+  if (contentViolations.length > 0) {
+    const hasCritical = contentViolations.some(v => v.severity === "CRITICAL");
+    const hasErrors = contentViolations.some(v => v.severity === "ERROR");
+    return { violations: contentViolations, total: contentViolations.length, hasCritical, hasErrors };
+  }
+
   const ctx = await buildContext();
   const features = detectFeaturesOnSrc();
   const graph = ctx.graph || getGraph();

package/skills/forge/scripts/inspect.mjs

@@ -18,8 +18,10 @@ const CAT_NAMES = {
   layers: "Capas",
   ownership: "Ownership",
   platform: "Platform",
+  platformDomain: "Platform Domain",
   dependencies: "Dependencias",
   graph: "Grafo",
+  importConventions: "Import Conventions",
 };
 
 const CAT_MAX = {
@@ -28,10 +30,12 @@ const CAT_MAX = {
   decorators: 20,
   ownership: 20,
   platform: 15,
+  platformDomain: 10,
   dependencies: 15,
   graph: 20,
   customRules: 5,
   naming: 10,
+  importConventions: 20,
 };
 
 function countBySeverity(checks) {

package/skills/forge/scripts/registry/rules.mjs

@@ -249,6 +249,31 @@ export const RULES = [
       return violations;
     },
   }),
+
+  defineRule({
+    id: "R13",
+    name: "Platform no contiene lógica de dominio",
+    severity: SEVERITY.CRITICAL,
+    category: CATEGORY.STRUCTURE,
+    description: "Platform es backbone técnico y no debe contener entidades, casos de uso, mappers de dominio, schemas de entidades, repositorios de dominio ni ninguna otra lógica de negocio.",
+    fix: "Mover el archivo con lógica de dominio a src/features/<name>/domain/, src/features/<name>/application/, o src/features/<name>/adapters/ según corresponda.",
+    example: "✘ platform/User.entity.ts, platform/payments/ creando lógica de dominio en platform/",
+    check: (graph, ctx) => {
+      const violations = [];
+      if (!ctx || !ctx.platform || !ctx.platform.exists) return violations;
+      for (const comp of (ctx.platform.components || [])) {
+        const lower = comp.toLowerCase();
+        if (lower.endsWith(".entity") || lower.endsWith(".uc") || lower.endsWith(".mapper") || lower.endsWith(".port")) {
+          violations.push({
+            rule: "R13", severity: SEVERITY.CRITICAL,
+            from: `platform:${comp}`, to: "(domain)",
+            description: `Platform contiene artefacto de dominio: "${comp}"`,
+          });
+        }
+      }
+      return violations;
+    },
+  }),
 ];
 
 /**

package/skills/forge/scripts/rename.mjs

@@ -147,6 +147,15 @@ export function computeExpectedName(filePath) {
   // Platform layer
   if (parts[1] === "platform" && parts[2]) {
     const subdir = parts[2];
+    const DOMAIN_SUFFIXES = /\.(entity|uc|mapper|port|repository)\.(ts|js)$/i;
+    if (DOMAIN_SUFFIXES.test(filename)) {
+      return {
+        current: filePath,
+        expected: filePath,
+        relPath: relPath,
+        rule: `[R13] Platform no debe contener artefactos de dominio: "${filename}" pertenece a src/features/<name>/`,
+      };
+    }
     const rule = PLATFORM_RULES[subdir];
     if (!rule) return null;
 

package/skills/forge/scripts/update.mjs

@@ -17,7 +17,7 @@ const ROOT = process.cwd();
 const CACHE_PATH = join(ROOT, ".forge", "version-cache.json");
 const CACHE_TTL = 86400000; // 24h
 const VERSION_URL = "https://forge.dev/latest";
-const CURRENT_VERSION = "1.0.2";
+const CURRENT_VERSION = "1.3.5";
 
 function readJson(path) {
   try {

package/skills/forge/templates/feature/controller.ts.md

@@ -1,12 +1,20 @@
 ```typescript
 // src/features/<domain>/adapters/in/http/<Domain>.controller.ts
+//
+// IMPORTANTE — Convenciones:
+// 1. Nombres de métodos: usar createHandler (no "add", "store", etc.)
+// 2. Si la entidad <Domain> es compartida desde platform/domain/,
+//    importar con path alias: import type { <Domain> } from "@/domain/entities/<Domain>.js";
+// 3. Si el feature NO tiene di.ts propio, el controller se importa desde
+//    @/setting/dependencies/<domain>.di.js en vez de bootstrap.di.js
+
 import { injectable, inject } from "tsyringe";
 import type { Request, Response, NextFunction } from "express";
-import { Create<Domain> } from "../../../application/use-cases/Create<Domain>.uc.js";
-import { Get<Domain> } from "../../../application/use-cases/Get<Domain>.uc.js";
-import { List<Domain> } from "../../../application/use-cases/List<Domain>.uc.js";
-import { Update<Domain> } from "../../../application/use-cases/Update<Domain>.uc.js";
-import { Delete<Domain> } from "../../../application/use-cases/Delete<Domain>.uc.js";
+import { Create<Domain> } from "../../application/use-cases/Create<Domain>.uc.js";
+import { Get<Domain> } from "../../application/use-cases/Get<Domain>.uc.js";
+import { List<Domain> } from "../../application/use-cases/List<Domain>.uc.js";
+import { Update<Domain> } from "../../application/use-cases/Update<Domain>.uc.js";
+import { Delete<Domain> } from "../../application/use-cases/Delete<Domain>.uc.js";
 
 @injectable()
 export class <Domain>Controller {

package/skills/forge/templates/feature/di.ts.md

@@ -0,0 +1,33 @@
+```typescript
+// src/features/<domain>/di.ts
+// DI container wiring para el feature <Domain>.
+//
+// NOTA: Si el repositorio exporta un modelo Mongoose (model()) en lugar de una clase,
+// usar container.register() con useValue en vez de registerSingleton.
+//
+// Para entidades compartidas desde platform/domain/, usar path alias @/domain/ en vez de relativo.
+
+import { container } from "tsyringe";
+import type { I<Domain>Repository } from "./domain/repositories/I<Domain>.repository.js";
+import { <Domain>Repository } from "./adapters/out/persistence/<Domain>.repository.js";
+import { Create<Domain> } from "./application/use-cases/Create<Domain>.uc.js";
+import { Get<Domain> } from "./application/use-cases/Get<Domain>.uc.js";
+import { List<Domain> } from "./application/use-cases/List<Domain>.uc.js";
+import { Update<Domain> } from "./application/use-cases/Update<Domain>.uc.js";
+import { Delete<Domain> } from "./application/use-cases/Delete<Domain>.uc.js";
+
+// ── Repositorio ──
+// Si <Domain>Repository es una clase (implementación estándar):
+container.registerSingleton<I<Domain>Repository>("I<Domain>Repository", <Domain>Repository);
+
+// Si <Domain>Repository es un modelo Mongoose (export default model()), usar:
+// import <Domain>Model from "./adapters/out/persistence/<Domain>.schema.js";
+// container.register<I<Domain>Repository>("I<Domain>Repository", { useValue: <Domain>Model as any });
+
+// ── Use Cases ──
+container.registerSingleton(Create<Domain>);
+container.registerSingleton(Get<Domain>);
+container.registerSingleton(List<Domain>);
+container.registerSingleton(Update<Domain>);
+container.registerSingleton(Delete<Domain>);
+```

package/skills/forge/templates/feature/mapper.ts.md

@@ -1,5 +1,10 @@
 ```typescript
 // src/features/<domain>/application/mappers/<Domain>.mapper.ts
+//
+// IMPORTANTE: Si la entidad <Domain> está en platform/domain/entities/ (compartida),
+// reemplazar el import relativo por path alias:
+//   import type { <Domain> } from "@/domain/entities/<Domain>.js";
+
 import type { <Domain> } from "../domain/entities/<Domain>.entity.js";
 
 export class <Domain>Mapper {

package/skills/forge/templates/feature/repository-impl.ts.md

@@ -1,9 +1,14 @@
 ```typescript
 // src/features/<domain>/adapters/out/persistence/<Domain>.repository.ts
+//
+// IMPORTANTE: Si la entidad <Domain> está en platform/domain/entities/ (compartida),
+// reemplazar el import relativo por path alias:
+//   import type { <Domain> } from "@/domain/entities/<Domain>.js";
+
 import { injectable } from "tsyringe";
 import type { <Domain> } from "../../../domain/entities/<Domain>.entity.js";
 import type { I<Domain>Repository } from "../../../domain/repositories/I<Domain>.repository.js";
-import { <Domain>Mapper } from "../../../application/mappers/<Domain>.mapper.js";
+import { <Domain>Mapper } from "../../application/mappers/<Domain>.mapper.js";
 import <Domain>Model from "./<Domain>.schema.js";
 import { RepositoryError } from "@/shared/errors/RepositoryError.js";
 

package/skills/forge/templates/feature/routes.ts.md

@@ -1,5 +1,10 @@
 ```typescript
 // src/features/<domain>/adapters/in/http/<Domain>.routes.ts
+//
+// IMPORTANTE: Los nombres de método del controller deben coincidir
+// con los invocados aquí. Si el controller usa "add" en vez de "createHandler",
+// ajustar la ruta: router.post("/", controller.add);
+
 import { Router } from "express";
 import { container } from "tsyringe";
 import { <Domain>Controller } from "./<Domain>.controller.js";

package/skills/forge/templates/feature/schema.ts.md

@@ -12,5 +12,9 @@ const <Domain>Schema = new Schema<<Domain>>(
 
 <Domain>Schema.index({ /* índices */ });
 
+// NOTA DI: model() exporta un objeto Model, NO una clase.
+// En el contenedor DI usar container.register() con useValue, NO registerSingleton:
+//   import <Domain>Model from "./<Domain>.schema.js";
+//   container.register<I<Domain>Repository>("I<Domain>Repository", { useValue: <Domain>Model as any });
 export default model<<Domain>>("<Domain>", <Domain>Schema);
 ```

package/skills/forge/templates/feature/test.ts.md

@@ -0,0 +1,68 @@
+```typescript
+// src/features/<domain>/__tests__/Create<Domain>.test.ts
+//
+// Convenciones para tests:
+// - Usar extension .js en imports (ESM + verbatimModuleSyntax)
+// - Usar "as const" para literales que forman parte de union types
+// - Usar "result!" (non-null assertion) cuando execute() retorna T | null
+// - Usar "(result as any)._id" si _id no existe en el tipo de dominio
+
+import { describe, it, before } from "node:test";
+import assert from "node:assert";
+import { Create<Domain> } from "../application/use-cases/Create<Domain>.uc.js";
+import type { I<Domain>Repository } from "../domain/repositories/I<Domain>.repository.js";
+import type { <Domain> } from "../domain/entities/<Domain>.entity.js";
+
+class Mock<Domain>Repository implements I<Domain>Repository {
+  private store: <Domain>[] = [];
+
+  async create(data: Partial<<Domain>>): Promise<<Domain>> {
+    const entity = { id: "1", ...data } as <Domain>;
+    this.store.push(entity);
+    return entity;
+  }
+
+  async findById(id: string): Promise<<Domain> | null> {
+    return this.store.find(e => (e as any).id === id) || null;
+  }
+
+  async findAll(): Promise<{ data: <Domain>[]; total: number }> {
+    return { data: this.store, total: this.store.length };
+  }
+
+  async update(id: string, data: Partial<<Domain>>): Promise<<Domain> | null> {
+    const idx = this.store.findIndex(e => (e as any).id === id);
+    if (idx === -1) return null;
+    this.store[idx] = { ...this.store[idx], ...data };
+    return this.store[idx];
+  }
+
+  async delete(id: string): Promise<void> {
+    this.store = this.store.filter(e => (e as any).id !== id);
+  }
+}
+
+describe("Create<Domain>", () => {
+  let useCase: Create<Domain>;
+  let mockRepo: Mock<Domain>Repository;
+
+  before(() => {
+    mockRepo = new Mock<Domain>Repository();
+    useCase = new Create<Domain>(mockRepo);
+  });
+
+  it("debería crear una entidad <domain>", async () => {
+    const input = { name: "test" as const };
+    const result = await useCase.execute(input);
+    assert.ok(result!);
+    assert.equal((result as any)._id || result!.id, "1");
+  });
+
+  it("debería lanzar error si faltan datos requeridos", async () => {
+    await assert.rejects(
+      () => useCase.execute(null as any),
+      { message: /requeridos|requerid/i }
+    );
+  });
+});
+```

package/skills/forge/templates/feature/use-case.ts.md

@@ -1,5 +1,10 @@
 ```typescript
 // src/features/<domain>/application/use-cases/Create<Domain>.uc.ts
+//
+// IMPORTANTE: Si la entidad <Domain> está en platform/domain/entities/ (compartida),
+// reemplazar el import relativo por path alias:
+//   import type { <Domain> } from "@/domain/entities/<Domain>.js";
+
 import { injectable, inject } from "tsyringe";
 import type { <Domain> } from "../../domain/entities/<Domain>.entity.js";
 import type { I<Domain>Repository } from "../../domain/repositories/I<Domain>.repository.js";

package/skills/forge/tests/core.test.mjs

@@ -233,11 +233,12 @@ describe("formatter.mjs", () => {
 });
 
 describe("registry/rules.mjs", () => {
-  it("has 9 built-in rules (R1-R9)", async () => {
+  it("has 10 built-in rules (R1-R9 + R13)", async () => {
     const { RULES, RULES_BY_ID } = await import("../scripts/registry/rules.mjs");
-    assert.equal(RULES.length, 9);
+    assert.equal(RULES.length, 10);
     assert.ok(RULES_BY_ID.R1);
     assert.ok(RULES_BY_ID.R9);
+    assert.ok(RULES_BY_ID.R13);
     for (const r of RULES) {
       assert.ok(r.id);
       assert.ok(r.name);