pumuki 6.3.109 → 6.3.110

package/CHANGELOG.md

@@ -6,59 +6,12 @@ This project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
-## [6.3.109] - 2026-04-22
+## [6.3.110] - 2026-04-23
 
 ### Fixed
 
-- **`install` materializa policy estricta cuando el repo ya puede reconciliarla:** tras una instalación limpia, Pumuki intenta persistir `.pumuki/policy-as-code.json` con `strict=true` por stage en lugar de dejar `status` y `doctor` en `computed-local`.
-- **Convergencia de `status`/`doctor` tras install en consumers reales:** el runtime deja de depender de `PUMUKI_POLICY_STRICT` para que `PRE_COMMIT`, `PRE_PUSH` y `CI` reflejen el mismo contrato estricto que `PRE_WRITE`.
-- **Cobertura de regresión del ciclo de install:** nuevas pruebas fijan que `runLifecycleInstall` materializa el contrato firmado cuando `AGENTS.md` y `skills.lock.json` exponen los insumos mínimos.
-
-## [6.3.108] - 2026-04-22
-
-### Fixed
-
-- **MCP enterprise visible por defecto en la línea publicada:** `mcp_enterprise` deja de nacer en `off`, así que el editor/agente puede ver `ai_gate_check`, `pre_flight_check` y `auto_execute_ai_start` sin opt-in adicional.
-- **Enforcement temprano más perceptible para `PRE_WRITE`:** el catálogo enterprise visible por defecto reduce el gap entre `status`/`doctor` bloqueados y la ruta real de trabajo del agente/editor.
-- **Cobertura de regresión de la baseline MCP:** nuevas pruebas fijan el catálogo del enterprise server y la proyección de baseline consumer asociada a `mcp_enterprise`.
-
-## [6.3.107] - 2026-04-22
-
-### Fixed
-
-- **Semántica inequívoca para sesión SDD expirada:** una sesión vencida deja de proyectarse como `active=true` y pasa a exponerse como inactiva (`active=false`) manteniendo `valid=false` y `remainingSeconds=0`.
-- **Refresh de sesión expiradas todavía permitido:** `refreshSddSession` ya no exige `active=true`; basta con conservar el `changeId` para poder renovar una sesión caducada sin reabrirla manualmente.
-- **Policy SDD alineada con esa semántica:** `evaluateSddPolicy` trata la sesión como `missing` solo cuando falta `changeId`, y conserva `SDD_SESSION_INVALID` para sesiones expiradas con contexto recuperable.
-
-## [6.3.106] - 2026-04-22
-
-### Fixed
-
-- **Activación advisory de SDD/PRE_WRITE fijada al runtime diagnosticado:** `sdd validate` deja de devolver `activation_command` con `pumuki@latest` cuando el namespace experimental está desactivado por defecto.
-- **Session guidance reproducible en SDD:** las instrucciones de `session --refresh` y `session --open` también quedan fijadas a la versión efectiva del runtime en lugar de depender de `latest`.
-
-## [6.3.105] - 2026-04-22
-
-### Fixed
-
-- **Remediaciones PRE_WRITE fijadas a la versión diagnosticada:** `sdd validate`, `auto_execute_ai_start` y la remediación por defecto dejan de recomendar `pumuki@latest` y pasan a devolver comandos con la versión efectiva del runtime (`pumuki@6.3.105` en esta línea).
-- **Backport útil de `PUMUKI-INC-089` a la línea publicada:** `main` mantiene la ruta reproducible para `install`, `policy reconcile --strict --json` y la revalidación `PRE_WRITE` sin exigir al consumer adivinar la versión correcta.
-
-## [6.3.104] - 2026-04-22
-
-### Fixed
-
-- **Tracking canónico de RuralGo reconocido por el parser de repo-policy:** `appendTrackingActionableContext` ya inspecciona `docs/RURALGO_SEGUIMIENTO.md`, que es la ruta canónica real del consumer.
-- **Filas `| 🚧 | TASK |` tratadas como entradas activas válidas:** el diagnóstico accionable cubre el formato de tabla usado por el hub de seguimiento de RuralGo además del backlog tabular de incidencias.
-- **Cobertura de regresión para el hub canónico:** nuevas pruebas fijan parsing y priorización de `docs/RURALGO_SEGUIMIENTO.md` antes de otros archivos de tracking del consumer.
-
-## [6.3.103] - 2026-04-22
-
-### Fixed
-
-- **Diagnóstico accionable del tracking canónico en consumers:** `status`, `doctor` y el gate repo-policy ya incluyen `TRACKING_CANONICAL_IN_PROGRESS_INVALID` junto con referencias a entradas activas y al board canónico del repo consumidor cuando existe.
-- **Separación explícita entre blocker y warning secundario:** la salida de `PRE_WRITE` conserva un `block-summary` primario y añade `warning-summary` para warnings de higiene (`EVIDENCE_PREWRITE_WORKTREE_WARN`) cuando conviven con un bloqueo duro de tracking.
-- **Cobertura de regresión del hotfix:** nuevas pruebas fijan el parsing de boards tabulares `🚧 reported activo` y la impresión del resumen jerárquico con warning secundario.
+- **`status` expone `issues` canónicos cuando el runtime está bloqueado:** la salida JSON ya no obliga a combinar `governanceEffective`, `attention_codes` y `human_summary_preview` para entender un bloqueo real.
+- **Contrato alineado en `main` y `develop`:** la lista de issues consumible queda fijada en ambas líneas para los consumers que leen `status` como fuente principal de diagnóstico.
 
 ## [6.3.102] - 2026-04-22
 
@@ -87,7 +40,7 @@ This project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 ### Fixed
 
 - **PRE_WRITE visible y coherente en la línea de producción:** `policyValidationSnapshot` refleja `PRE_WRITE` como estricto cuando el enforcement efectivo está activado en `strict`, evitando contradicción entre policy y runtime.
-- **Arranque agentic sin éxito falso:** `auto_execute_ai_start` devuelve `success=false` cuando el gate bloquea y fuerza remediación explícita antes de continuar.
+- **Arranque agentic sin éxito falso:** `auto_execute_ai_start` devuelve semántica de fallo real cuando el gate bloquea y fuerza remediación explícita antes de continuar.
 - **Contrato MCP actualizado:** la superficie HTTP del enterprise server hereda ese mismo contrato de bloqueo para `auto_execute_ai_start`.
 - **Cobertura de regresión del hotfix:** nuevas regresiones fijan la proyección de `PRE_WRITE` y el comportamiento bloqueante del arranque agentic sobre la línea `main`.
 

package/README.md

@@ -32,7 +32,7 @@ Elige un perfil y profundiza en los enlaces; **no** repite aquí reglas largas (
 
 | Perfil | Qué instalar / arrancar | Stages habituales | Opcional típico |
 |--------|-------------------------|-------------------|-----------------|
-| **Mínimo** | `npm install --save-exact pumuki` (en repos Git el `postinstall` ejecuta baseline `pumuki install`; `--with-mcp --agent=repo` es opt-in con `PUMUKI_POSTINSTALL_WITH_MCP=1` o `PUMUKI_POSTINSTALL_MCP_AGENT=repo`). | Hooks Git: **PRE_COMMIT**, **PRE_PUSH**; cadena **PRE_WRITE** cuando el hook lo encadena (según versión y config). | Evidencia [`.ai_evidence.json` v2.1](docs/mcp/ai-evidence-v2.1-contract.md); reglas core embebidas. |
+| **Mínimo** | `npm install --save-exact pumuki` (en repos Git el `postinstall` puede ejecutar `pumuki install` para hooks y lifecycle). | Hooks Git: **PRE_COMMIT**, **PRE_PUSH**; cadena **PRE_WRITE** cuando el hook lo encadena (según versión y config). | Evidencia [`.ai_evidence.json` v2.1](docs/mcp/ai-evidence-v2.1-contract.md); reglas core embebidas. |
 | **Estándar** | Lo anterior + flujo **OpenSpec/SDD** bajo `openspec/` según tu política. | Lo anterior + validación SDD por stage (`pumuki sdd validate --stage=…`). | Sesiones SDD, cambios versionados bajo `openspec/changes/`. |
 | **Enterprise completo** | `pumuki bootstrap --enterprise` (o equivalente documentado) + `skills.lock.json` / reglas custom / [policy-as-code](docs/product/CONFIGURATION.md) donde aplique. | Lo anterior + **CI** (`pumuki-ci`) y comprobaciones de alineación (`doctor`, parity). | [Skills / MCP](docs/mcp/mcp-servers-overview.md), `pumuki doctor --parity`, notificaciones, [hard mode](docs/product/CONFIGURATION.md). |
 
@@ -50,8 +50,6 @@ Cinco entradas que cubren el 80 % del día a día en un consumidor; el detalle e
 4. **Gates locales** — `npx pumuki-pre-write`, `npx pumuki-pre-commit` (y `pumuki-pre-push` cuando toque push). Detalle: [USAGE](docs/product/USAGE.md), [Troubleshooting (USAGE)](docs/product/USAGE.md#troubleshooting).
 5. **SDD por stage (enterprise)** — `npx pumuki sdd validate --stage=PRE_COMMIT` (u otro stage). Detalle: [USAGE](docs/product/USAGE.md), [INSTALLATION](docs/product/INSTALLATION.md#troubleshooting) si falla el bootstrap.
 
-**Desarrollo en este repo (sin depender de GitHub Actions):** barra mínima antes de merge o publicar — `npm run -s validation:local-merge-bar` (`typecheck` + smoke de superficie CLI + `npm test`). Detalle del smoke: [docs/validation/README.md](docs/validation/README.md).
-
 Si algo bloquea o el mensaje no es claro: [Troubleshooting](#troubleshooting) (más abajo en este README), [USAGE § Troubleshooting](docs/product/USAGE.md#troubleshooting) y [GitHub Issues](https://github.com/SwiftEnProfundidad/ast-intelligence-hooks/issues).
 
 ## 5-Minute Quick Start (Consumer)
@@ -71,7 +69,7 @@ npx --yes pumuki status
 npx --yes pumuki doctor --json
 ```
 
-Desde **6.3.63**, `npm install` en la raíz de un repo **Git** dispara un `postinstall` que ejecuta baseline **`pumuki install`** (hooks `pre-commit` / `pre-push`, lifecycle, merge de **`.pumuki/adapter.json`** con comandos MCP stdio, sin rutas de IDE salvo opt-in). El wiring MCP no va activado por defecto; para activarlo en postinstall usa `PUMUKI_POSTINSTALL_WITH_MCP=1` o `PUMUKI_POSTINSTALL_MCP_AGENT=repo/cursor/claude/codex`. **Pumuki no depende de ningún IDE** para el baseline. Opt-out del postinstall: `PUMUKI_SKIP_POSTINSTALL=1`. Ficheros de IDE en postinstall: `PUMUKI_POSTINSTALL_MCP_AGENT=cursor|claude|codex` o comando manual / `bootstrap`. Desde **6.3.68**, cada hook gestionado ejecuta **`pumuki-pre-write` antes** de `pumuki-pre-commit` / `pumuki-pre-push` (stage **PRE_WRITE** vía Git). Saltar solo PRE_WRITE en hooks: `PUMUKI_SKIP_CHAINED_PRE_WRITE=1`. Desde **6.3.69**, esos mismos hooks aplican también **git-flow en ramas protegidas** (`GITFLOW_PROTECTED_BRANCH`) e **higiene de worktree** (`PUMUKI_PREWRITE_WORKTREE_*` / códigos `EVIDENCE_PREWRITE_WORKTREE_*`) cuando la evidencia es válida; el **modal macOS** de bloqueo (Desactivar / Silenciar 30 min / Mantener activas) queda **activo por defecto** si las notificaciones están habilitadas (`"blockedDialogEnabled": false` o `PUMUKI_MACOS_BLOCKED_DIALOG=0` para apagarlo). Desactivar el postinstall: `PUMUKI_SKIP_POSTINSTALL=1`. En CI suele saltarse solo (`CI=true`). En **6.3.64+**, las notificaciones del sistema en plataformas sin banner nativo se reflejan en **stderr** por defecto (`PUMUKI_DISABLE_STDERR_NOTIFICATIONS=1` para silenciarlas). En **6.3.69+**, un `gate.blocked` en macOS también deja una copia en **stderr** por defecto (`PUMUKI_DISABLE_GATE_BLOCKED_STDERR_MIRROR=1` para desactivar solo eso). Desde **6.3.70**, si **`.ai_evidence.json` está versionado** y **PRE_PUSH** no bloquea, ese archivo **no se reescribe** en el push (compatibilidad con **pre-commit** como hook de **pre-push**); para forzar escritura: `PUMUKI_PRE_PUSH_ALWAYS_WRITE_TRACKED_EVIDENCE=1`. Con modal de bloqueo activo, el panel interactivo prioriza foco/clics y se evita el banner duplicado.
+Desde **6.3.63**, `npm install` en la raíz de un repo **Git** dispara un `postinstall` que ejecuta **`pumuki install` solo** (hooks `pre-commit` / `pre-push`, lifecycle, evidencia cuando aplica). **Pumuki no depende de ningún IDE** para el baseline: no toca `.cursor/` ni otros ficheros de editor por defecto. Desde **6.3.68**, cada hook gestionado ejecuta **`pumuki-pre-write` antes** de `pumuki-pre-commit` / `pumuki-pre-push` (stage **PRE_WRITE** vía Git). Saltar solo PRE_WRITE en hooks: `PUMUKI_SKIP_CHAINED_PRE_WRITE=1`. Desde **6.3.69**, esos mismos hooks aplican también **git-flow en ramas protegidas** (`GITFLOW_PROTECTED_BRANCH`) e **higiene de worktree** (`PUMUKI_PREWRITE_WORKTREE_*` / códigos `EVIDENCE_PREWRITE_WORKTREE_*`) cuando la evidencia es válida; el **modal macOS** de bloqueo (Desactivar / Silenciar 30 min / Mantener activas) queda **activo por defecto** si las notificaciones están habilitadas (`"blockedDialogEnabled": false` o `PUMUKI_MACOS_BLOCKED_DIALOG=0` para apagarlo). Tras install, si no existía, aparece **`.pumuki/adapter.json`** con los comandos de hooks y **MCP stdio** para referencia o para clientes que los registren manualmente. Para generar también config de IDE: **`pumuki install --with-mcp --agent=cursor`** (u otro) o **`pumuki bootstrap --enterprise --agent=…`**. Desactivar el postinstall: `PUMUKI_SKIP_POSTINSTALL=1`. En CI suele saltarse solo (`CI=true`). En **6.3.64+**, las notificaciones del sistema en plataformas sin banner nativo se reflejan en **stderr** por defecto (`PUMUKI_DISABLE_STDERR_NOTIFICATIONS=1` para silenciarlas). En **6.3.69+**, un `gate.blocked` en macOS también deja una copia en **stderr** por defecto (`PUMUKI_DISABLE_GATE_BLOCKED_STDERR_MIRROR=1` para desactivar solo eso). Desde **6.3.70**, si **`.ai_evidence.json` está versionado** y **PRE_PUSH** no bloquea, ese archivo **no se reescribe** en el push (compatibilidad con **pre-commit** como hook de **pre-push**); para forzar escritura: `PUMUKI_PRE_PUSH_ALWAYS_WRITE_TRACKED_EVIDENCE=1`. Con modal de bloqueo activo, el panel interactivo prioriza foco/clics y se evita el banner duplicado.
 
 Fallback (equivalent in pasos separados):
 

package/VERSION

@@ -1 +1 @@
-v6.3.109
+v6.3.102

package/core/facts/detectors/typescript/index.test.ts

@@ -13,6 +13,12 @@ import {
   findUndefinedInBaseTypeUnionLines,
   findUnknownWithoutGuardLines,
   findUnknownTypeAssertionLines,
+  findAnemicDomainModelLines,
+  findControllerBusinessLogicLines,
+  findMagicNumberLiteralLines,
+  findProductionMockArtifactUsageLines,
+  hasAnemicDomainModel,
+  hasControllerBusinessLogic,
   hasAsyncPromiseExecutor,
   hasConcreteDependencyInstantiation,
   hasConsoleErrorCall,
@@ -24,6 +30,8 @@ import {
   hasExplicitAnyType,
   hasFrameworkDependencyImport,
   hasFunctionConstructorUsage,
+  hasMagicNumberLiteral,
+  hasProductionMockArtifactUsage,
   hasNetworkCallWithoutErrorHandling,
   hasMixedCommandQueryClass,
   hasMixedCommandQueryInterface,
@@ -884,6 +892,227 @@ test('hasLargeClassDeclaration detecta clases con 300 lineas o mas', () => {
   assert.equal(hasLargeClassDeclaration(compactClassAst), false);
 });
 
+test('hasMagicNumberLiteral detecta literales numericos repetidos en contexto ejecutable y descarta declarativos', () => {
+  const magicAst = {
+    type: 'Program',
+    body: [
+      {
+        type: 'ExpressionStatement',
+        expression: {
+          type: 'CallExpression',
+          callee: { type: 'Identifier', name: 'retry' },
+          arguments: [{ type: 'NumericLiteral', value: 42, loc: { start: { line: 3 }, end: { line: 3 } } }],
+        },
+      },
+      {
+        type: 'VariableDeclaration',
+        kind: 'const',
+        declarations: [
+          {
+            type: 'VariableDeclarator',
+            id: { type: 'Identifier', name: 'timeoutMs' },
+            init: { type: 'NumericLiteral', value: 42, loc: { start: { line: 5 }, end: { line: 5 } } },
+          },
+        ],
+      },
+      {
+        type: 'ExpressionStatement',
+        expression: {
+          type: 'BinaryExpression',
+          operator: '>',
+          left: { type: 'Identifier', name: 'elapsedMs' },
+          right: { type: 'NumericLiteral', value: 42, loc: { start: { line: 7 }, end: { line: 7 } } },
+        },
+      },
+      {
+        type: 'ReturnStatement',
+        argument: { type: 'NumericLiteral', value: 1, loc: { start: { line: 9 }, end: { line: 9 } } },
+      },
+    ],
+  };
+
+  const ignoredAst = {
+    type: 'Program',
+    body: [
+      {
+        type: 'VariableDeclaration',
+        kind: 'const',
+        declarations: [
+          {
+            type: 'VariableDeclarator',
+            id: { type: 'Identifier', name: 'port' },
+            init: { type: 'NumericLiteral', value: 3000, loc: { start: { line: 2 }, end: { line: 2 } } },
+          },
+        ],
+      },
+      {
+        type: 'ReturnStatement',
+        argument: { type: 'NumericLiteral', value: 1, loc: { start: { line: 4 }, end: { line: 4 } } },
+      },
+    ],
+  };
+
+  assert.equal(hasMagicNumberLiteral(magicAst), true);
+  assert.deepEqual(findMagicNumberLiteralLines(magicAst), [3, 7]);
+  assert.equal(hasMagicNumberLiteral(ignoredAst), false);
+  assert.deepEqual(findMagicNumberLiteralLines(ignoredAst), []);
+});
+
+test('hasProductionMockArtifactUsage detecta imports/requires de doubles en runtime productivo', () => {
+  const importAst = {
+    type: 'ImportDeclaration',
+    source: { type: 'StringLiteral', value: '../mocks/user-repository', loc: { start: { line: 3 }, end: { line: 3 } } },
+    specifiers: [],
+    loc: { start: { line: 3 }, end: { line: 3 } },
+  };
+  const requireAst = {
+    type: 'CallExpression',
+    callee: { type: 'Identifier', name: 'require' },
+    arguments: [{ type: 'StringLiteral', value: 'sinon', loc: { start: { line: 7 }, end: { line: 7 } } }],
+    loc: { start: { line: 7 }, end: { line: 7 } },
+  };
+  const cleanAst = {
+    type: 'Program',
+    body: [
+      {
+        type: 'ImportDeclaration',
+        source: { type: 'StringLiteral', value: '../adapters/user-repository', loc: { start: { line: 1 }, end: { line: 1 } } },
+        specifiers: [],
+      },
+    ],
+  };
+  const mixedAst = {
+    type: 'Program',
+    body: [importAst, { type: 'ExpressionStatement', expression: requireAst }],
+  };
+
+  assert.equal(hasProductionMockArtifactUsage(importAst), true);
+  assert.equal(hasProductionMockArtifactUsage(requireAst), true);
+  assert.equal(hasProductionMockArtifactUsage(cleanAst), false);
+  assert.deepEqual(findProductionMockArtifactUsageLines(mixedAst), [3, 7]);
+});
+
+test('hasAnemicDomainModel detecta clases de dominio con solo accessors y sin comportamiento', () => {
+  const anemicAst = {
+    type: 'ClassDeclaration',
+    id: { type: 'Identifier', name: 'OrderEntity' },
+    body: {
+      type: 'ClassBody',
+      body: [
+        { type: 'ClassMethod', kind: 'constructor', key: { type: 'Identifier', name: 'constructor' }, loc: { start: { line: 3 }, end: { line: 3 } } },
+        { type: 'ClassMethod', key: { type: 'Identifier', name: 'getStatus' }, loc: { start: { line: 5 }, end: { line: 5 } } },
+        { type: 'ClassMethod', key: { type: 'Identifier', name: 'setStatus' }, loc: { start: { line: 7 }, end: { line: 7 } } },
+      ],
+    },
+    loc: { start: { line: 1 }, end: { line: 9 } },
+  };
+  const richAst = {
+    type: 'ClassDeclaration',
+    id: { type: 'Identifier', name: 'OrderEntity' },
+    body: {
+      type: 'ClassBody',
+      body: [
+        { type: 'ClassMethod', kind: 'constructor', key: { type: 'Identifier', name: 'constructor' }, loc: { start: { line: 3 }, end: { line: 3 } } },
+        { type: 'ClassMethod', key: { type: 'Identifier', name: 'getStatus' }, loc: { start: { line: 5 }, end: { line: 5 } } },
+        { type: 'ClassMethod', key: { type: 'Identifier', name: 'confirm' }, loc: { start: { line: 7 }, end: { line: 7 } } },
+      ],
+    },
+    loc: { start: { line: 1 }, end: { line: 9 } },
+  };
+  const serviceAst = {
+    type: 'ClassDeclaration',
+    id: { type: 'Identifier', name: 'OrderService' },
+    body: {
+      type: 'ClassBody',
+      body: [
+        { type: 'ClassMethod', kind: 'constructor', key: { type: 'Identifier', name: 'constructor' }, loc: { start: { line: 3 }, end: { line: 3 } } },
+        { type: 'ClassMethod', key: { type: 'Identifier', name: 'getStatus' }, loc: { start: { line: 5 }, end: { line: 5 } } },
+        { type: 'ClassMethod', key: { type: 'Identifier', name: 'setStatus' }, loc: { start: { line: 7 }, end: { line: 7 } } },
+      ],
+    },
+    loc: { start: { line: 1 }, end: { line: 9 } },
+  };
+
+  assert.equal(hasAnemicDomainModel(anemicAst), true);
+  assert.deepEqual(findAnemicDomainModelLines(anemicAst), [1]);
+  assert.equal(hasAnemicDomainModel(richAst), false);
+  assert.equal(hasAnemicDomainModel(serviceAst), false);
+});
+
+test('hasControllerBusinessLogic detecta flow control dentro de handlers en clases Controller', () => {
+  const controllerAst = {
+    type: 'ClassDeclaration',
+    id: { type: 'Identifier', name: 'OrdersController' },
+    body: {
+      type: 'ClassBody',
+      body: [
+        {
+          type: 'ClassMethod',
+          key: { type: 'Identifier', name: 'createOrder' },
+          decorators: [{ expression: { type: 'Identifier', name: 'Post' } }],
+          body: {
+            type: 'BlockStatement',
+            body: [
+              {
+                type: 'VariableDeclaration',
+                declarations: [{ type: 'VariableDeclarator', id: { type: 'Identifier', name: 'status' } }],
+              },
+              {
+                type: 'IfStatement',
+                test: { type: 'Identifier', name: 'isPriority' },
+                consequent: { type: 'BlockStatement', body: [] },
+              },
+            ],
+          },
+          loc: { start: { line: 4 }, end: { line: 10 } },
+        },
+      ],
+    },
+    loc: { start: { line: 1 }, end: { line: 12 } },
+  };
+  const delegatedControllerAst = {
+    type: 'ClassDeclaration',
+    id: { type: 'Identifier', name: 'OrdersController' },
+    body: {
+      type: 'ClassBody',
+      body: [
+        {
+          type: 'ClassMethod',
+          key: { type: 'Identifier', name: 'createOrder' },
+          decorators: [{ expression: { type: 'Identifier', name: 'Post' } }],
+          body: {
+            type: 'BlockStatement',
+            body: [
+              {
+                type: 'ReturnStatement',
+                argument: {
+                  type: 'CallExpression',
+                  callee: {
+                    type: 'MemberExpression',
+                    object: {
+                      type: 'MemberExpression',
+                      object: { type: 'ThisExpression' },
+                      property: { type: 'Identifier', name: 'ordersService' },
+                    },
+                    property: { type: 'Identifier', name: 'create' },
+                  },
+                  arguments: [],
+                },
+              },
+            ],
+          },
+          loc: { start: { line: 4 }, end: { line: 8 } },
+        },
+      ],
+    },
+    loc: { start: { line: 1 }, end: { line: 10 } },
+  };
+
+  assert.equal(hasControllerBusinessLogic(controllerAst), true);
+  assert.deepEqual(findControllerBusinessLogicLines(controllerAst), [1]);
+  assert.equal(hasControllerBusinessLogic(delegatedControllerAst), false);
+});
+
 test('hasRecordStringUnknownType detecta Record<string, unknown>', () => {
   const recordUnknownAst = {
     type: 'TSTypeReference',

package/core/facts/detectors/typescript/index.ts

@@ -21,6 +21,13 @@ const concreteDependencyNames = new Set<string>([
 ]);
 const GOD_CLASS_MAX_LINES = 300;
 const networkCallCalleePattern = /^(fetch|axios|get|post|put|patch|delete|request)$/i;
+const ignoredMagicNumberValues = new Set<number>([0, 1]);
+const runtimeTestDoubleLibraryPattern = /^(sinon|testdouble|ts-mockito|jest-mock|vitest)$/i;
+const runtimeTestDoublePathPattern = /(^|\/)(__mocks__|mocks|fakes|spies|stubs)(\/|$)|\.(mock|fake|spy|stub)$/i;
+const anemicDomainClassNamePattern = /(Entity|Aggregate|Model)$/i;
+const controllerClassNamePattern = /Controller$/i;
+const controllerRoutingDecoratorPattern =
+  /^(Get|Post|Put|Patch|Delete|All|Head|Options|MessagePattern|EventPattern)$/;
 type AstNode = Record<string, string | number | boolean | bigint | symbol | null | Date | object>;
 type TypeScriptSemanticNode = {
   kind: 'class' | 'property' | 'call' | 'member';
@@ -407,6 +414,101 @@ const collectClassMethodDescriptors = (classNode: AstNode): readonly ClassMethod
   return descriptors;
 };
 
+const isAccessorLikeMethodName = (name: string): boolean => {
+  return name === 'constructor' || /^(get|set)[A-Z_]/.test(name);
+};
+
+const isAnemicDomainClassNode = (value: AstNode): boolean => {
+  if (value.type !== 'ClassDeclaration' && value.type !== 'ClassExpression') {
+    return false;
+  }
+
+  const className = classNameFromNode(value);
+  if (!anemicDomainClassNamePattern.test(className)) {
+    return false;
+  }
+
+  const descriptors = collectClassMethodDescriptors(value);
+  if (descriptors.length < 2) {
+    return false;
+  }
+
+  return descriptors.every((descriptor) => isAccessorLikeMethodName(descriptor.name));
+};
+
+const hasDecoratorNamed = (node: unknown, decoratorName: RegExp): boolean => {
+  if (!isObject(node) || !Array.isArray(node.decorators)) {
+    return false;
+  }
+
+  return node.decorators.some((decorator) => {
+    if (!isObject(decorator)) {
+      return false;
+    }
+    const expression = decorator.expression;
+    if (!isObject(expression)) {
+      return false;
+    }
+    const callee = expression.type === 'CallExpression' ? expression.callee : expression;
+    const name = methodNameFromNode(callee) ?? memberExpressionPropertyName(callee);
+    return typeof name === 'string' && decoratorName.test(name);
+  });
+};
+
+const isControllerHandlerMethodNode = (node: AstNode): boolean => {
+  return node.type === 'ClassMethod' && node.kind !== 'constructor';
+};
+
+const statementCountFromMethodNode = (node: AstNode): number => {
+  if (!isObject(node.body) || !Array.isArray(node.body.body)) {
+    return 0;
+  }
+  return node.body.body.filter((statement) => isObject(statement)).length;
+};
+
+const hasControllerBusinessFlow = (node: AstNode): boolean => {
+  return hasNode(node, (value) => {
+    return (
+      value.type === 'IfStatement' ||
+      value.type === 'SwitchStatement' ||
+      value.type === 'ForStatement' ||
+      value.type === 'ForInStatement' ||
+      value.type === 'ForOfStatement' ||
+      value.type === 'WhileStatement' ||
+      value.type === 'DoWhileStatement' ||
+      value.type === 'TryStatement' ||
+      value.type === 'ConditionalExpression'
+    );
+  });
+};
+
+const isControllerBusinessLogicMethodNode = (node: AstNode): boolean => {
+  if (!isControllerHandlerMethodNode(node)) {
+    return false;
+  }
+  if (statementCountFromMethodNode(node) < 2) {
+    return false;
+  }
+  return hasControllerBusinessFlow(node);
+};
+
+const isControllerClassNode = (value: AstNode): boolean => {
+  if (value.type !== 'ClassDeclaration' && value.type !== 'ClassExpression') {
+    return false;
+  }
+  return controllerClassNamePattern.test(classNameFromNode(value));
+};
+
+const findControllerBusinessLogicMethod = (node: AstNode): AstNode | undefined => {
+  const classBody = node.body;
+  if (!isObject(classBody) || !Array.isArray(classBody.body)) {
+    return undefined;
+  }
+  return classBody.body.find((member): member is AstNode => {
+    return isObject(member) && isControllerBusinessLogicMethodNode(member);
+  });
+};
+
 const interfaceNameFromNode = (node: AstNode): string => {
   const idNode = node.id;
   if (isObject(idNode) && idNode.type === 'Identifier' && typeof idNode.name === 'string') {
@@ -1546,6 +1648,96 @@ export const hasAsyncPromiseExecutor = (node: unknown): boolean => {
   });
 };
 
+export const hasMagicNumberLiteral = (node: unknown): boolean => {
+  return [...collectMagicNumberOccurrences(node).values()].some(
+    (occurrence) => occurrence.count >= 2
+  );
+};
+
+export const findMagicNumberLiteralLines = (node: unknown): readonly number[] => {
+  return collectRepeatedMagicNumberLines(node);
+};
+
+const runtimeTestDoubleSpecifier = (node: unknown): string | undefined => {
+  if (!isObject(node) || node.type !== 'StringLiteral' || typeof node.value !== 'string') {
+    return undefined;
+  }
+  return node.value;
+};
+
+const matchesRuntimeTestDoubleImport = (specifier: string): boolean => {
+  return (
+    runtimeTestDoubleLibraryPattern.test(specifier) ||
+    runtimeTestDoublePathPattern.test(specifier)
+  );
+};
+
+const isRuntimeTestDoubleImportNode = (value: AstNode): boolean => {
+  if (value.type === 'ImportDeclaration') {
+    const specifier = runtimeTestDoubleSpecifier(value.source);
+    return typeof specifier === 'string' && matchesRuntimeTestDoubleImport(specifier);
+  }
+
+  if (
+    value.type === 'CallExpression' &&
+    isObject(value.callee) &&
+    value.callee.type === 'Identifier' &&
+    value.callee.name === 'require' &&
+    Array.isArray(value.arguments)
+  ) {
+    return value.arguments.some((argument) => {
+      const specifier = runtimeTestDoubleSpecifier(argument);
+      return typeof specifier === 'string' && matchesRuntimeTestDoubleImport(specifier);
+    });
+  }
+
+  return false;
+};
+
+export const hasProductionMockArtifactUsage = (node: unknown): boolean => {
+  return hasNode(node, (value) => isRuntimeTestDoubleImportNode(value));
+};
+
+export const findProductionMockArtifactUsageLines = (node: unknown): readonly number[] => {
+  return collectLineMatchesWithAncestors(node, (value) => isRuntimeTestDoubleImportNode(value), {
+    max: 8,
+  });
+};
+
+export const hasAnemicDomainModel = (node: unknown): boolean => {
+  return hasNode(node, (value) => isAnemicDomainClassNode(value));
+};
+
+export const findAnemicDomainModelLines = (node: unknown): readonly number[] => {
+  return collectLineMatchesWithAncestors(node, (value) => isAnemicDomainClassNode(value), {
+    max: 8,
+  });
+};
+
+export const hasControllerBusinessLogic = (node: unknown): boolean => {
+  return hasNode(node, (value) => {
+    if (!isControllerClassNode(value)) {
+      return false;
+    }
+    return Boolean(findControllerBusinessLogicMethod(value));
+  });
+};
+
+export const findControllerBusinessLogicLines = (node: unknown): readonly number[] => {
+  return collectLineMatchesWithAncestors(
+    node,
+    (value) => {
+      if (!isControllerClassNode(value)) {
+        return false;
+      }
+      return Boolean(findControllerBusinessLogicMethod(value));
+    },
+    {
+      max: 8,
+    }
+  );
+};
+
 export const hasWithStatement = (node: unknown): boolean => {
   return hasNode(node, (value) => value.type === 'WithStatement');
 };
@@ -1759,6 +1951,92 @@ const nodeLineSpan = (node: unknown): number => {
   return Math.max(0, end - start + 1);
 };
 
+type MagicNumberOccurrence = {
+  count: number;
+  lines: number[];
+};
+
+const magicNumberValueFromNode = (node: unknown): number | undefined => {
+  if (!isObject(node) || node.type !== 'NumericLiteral' || typeof node.value !== 'number') {
+    return undefined;
+  }
+  if (!Number.isFinite(node.value) || ignoredMagicNumberValues.has(node.value)) {
+    return undefined;
+  }
+  return node.value;
+};
+
+const isExecutableMagicNumberContext = (
+  value: AstNode,
+  ancestors: ReadonlyArray<AstNode>
+): boolean => {
+  const parent = ancestors[ancestors.length - 1];
+  if (!isObject(parent)) {
+    return false;
+  }
+  if (parent.type === 'BinaryExpression') {
+    return parent.left === value || parent.right === value;
+  }
+  if (parent.type === 'CallExpression' || parent.type === 'NewExpression') {
+    return Array.isArray(parent.arguments) && parent.arguments.includes(value);
+  }
+  if (parent.type === 'AssignmentExpression') {
+    return parent.right === value;
+  }
+  if (parent.type === 'ReturnStatement') {
+    return parent.argument === value;
+  }
+  if (parent.type === 'SwitchCase') {
+    return parent.test === value;
+  }
+  return false;
+};
+
+const collectMagicNumberOccurrences = (
+  node: unknown
+): ReadonlyMap<number, MagicNumberOccurrence> => {
+  const occurrences = new Map<number, MagicNumberOccurrence>();
+
+  const walk = (value: unknown, ancestors: ReadonlyArray<AstNode>): void => {
+    if (!isObject(value)) {
+      return;
+    }
+
+    const numericValue = magicNumberValueFromNode(value);
+    if (typeof numericValue === 'number' && isExecutableMagicNumberContext(value, ancestors)) {
+      const current = occurrences.get(numericValue) ?? { count: 0, lines: [] };
+      current.count += 1;
+      const line = toPositiveLine(value);
+      if (typeof line === 'number') {
+        current.lines.push(line);
+      }
+      occurrences.set(numericValue, current);
+    }
+
+    const nextAncestors = [...ancestors, value];
+    for (const child of Object.values(value)) {
+      if (Array.isArray(child)) {
+        for (const entry of child) {
+          walk(entry, nextAncestors);
+        }
+        continue;
+      }
+      walk(child, nextAncestors);
+    }
+  };
+
+  walk(node, []);
+  return occurrences;
+};
+
+const collectRepeatedMagicNumberLines = (node: unknown): readonly number[] => {
+  return sortedUniqueLines(
+    [...collectMagicNumberOccurrences(node).values()]
+      .filter((occurrence) => occurrence.count >= 2)
+      .flatMap((occurrence) => occurrence.lines)
+  );
+};
+
 export const hasLargeClassDeclaration = (node: unknown): boolean => {
   return hasNode(node, (value) => {
     if (value.type !== 'ClassDeclaration' && value.type !== 'ClassExpression') {