pumuki 6.3.112 → 6.3.114

package/CHANGELOG.md

@@ -6,12 +6,59 @@ This project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
-## [6.3.112] - 2026-04-23
+## [6.3.114] - 2026-04-24
 
 ### Fixed
 
-- **Alignment commands now respect the consumer runtime declaration:** `status`, `doctor` and the lifecycle helpers prepend the matching Node runtime switch when the consumer declares `volta`, `.nvmrc`, or `package.json.engines.node` and the current shell Node does not match.
-- **Reproducible remediation stays repo-aware:** the suggested command keeps the consumer's runtime manager in the loop before the Pumuki install/alignment step, so fixes stay tied to the repo that is being audited.
+- **`status` y `doctor` exponen `issues` canónicos también en evidencia `WARN`:** la línea publicada deja de reservar la lista de findings a estados bloqueados y pasa a emitir una advertencia consumible por automatización cuando governance está en atención operativa real.
+- **Hotfix mínimo sobre la superficie estable de `main`:** el contrato bloqueado existente se conserva, pero ahora la evidencia `WARN` produce `Governance requires attention (...)` como issue canónico sin arrastrar snapshots adicionales de `develop`.
+- **Cobertura de regresión de `INC-084` en la línea publicada:** nuevas pruebas fijan el caso `WARN` tanto en `status` como en `doctor`, manteniendo la semántica previa para estados `BLOCK`.
+
+## [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.
 
 ## [6.3.102] - 2026-04-22
 
@@ -40,7 +87,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 semántica de fallo real cuando el gate bloquea y fuerza remediación explícita antes de continuar.
+- **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.
 - **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` 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. |
+| **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. |
 | **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,6 +50,8 @@ 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)
@@ -69,7 +71,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 **`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.
+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.
 
 Fallback (equivalent in pasos separados):
 

package/VERSION

@@ -1 +1 @@
-v6.3.102
+v6.3.114

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

@@ -13,12 +13,6 @@ import {
   findUndefinedInBaseTypeUnionLines,
   findUnknownWithoutGuardLines,
   findUnknownTypeAssertionLines,
-  findAnemicDomainModelLines,
-  findControllerBusinessLogicLines,
-  findMagicNumberLiteralLines,
-  findProductionMockArtifactUsageLines,
-  hasAnemicDomainModel,
-  hasControllerBusinessLogic,
   hasAsyncPromiseExecutor,
   hasConcreteDependencyInstantiation,
   hasConsoleErrorCall,
@@ -30,8 +24,6 @@ import {
   hasExplicitAnyType,
   hasFrameworkDependencyImport,
   hasFunctionConstructorUsage,
-  hasMagicNumberLiteral,
-  hasProductionMockArtifactUsage,
   hasNetworkCallWithoutErrorHandling,
   hasMixedCommandQueryClass,
   hasMixedCommandQueryInterface,
@@ -892,227 +884,6 @@ 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,13 +21,6 @@ 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';
@@ -414,101 +407,6 @@ 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') {
@@ -1648,96 +1546,6 @@ 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');
 };
@@ -1951,92 +1759,6 @@ 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') {