# Mapeo contable sin decisiones internas — plan de implementación (parte A)

> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.

**Goal:** Que ningún asiento automático elija una cuenta por su cuenta: todo destino es un concepto mapeable, si falta el asiento queda pendiente con aviso al contador y al usuario, y cada mapeo deja constancia de quién lo decidió.

**Architecture:** Un error tipado (`FaltaMapeoError`) reemplaza todos los respaldos silenciosos; cada `integrar*` lo captura en un único envoltorio que registra el pendiente y dispara avisos vía la bandeja de alertas existente (`AlertasEmpresaService`). `cont_mapeo_cuentas` gana modo, origen y constancia de confirmación; las recomendaciones viven en código junto al catálogo de asientos. Conciliación y la pantalla de Mapeo consumen esa información.

**Tech Stack:** NestJS + Prisma + PostgreSQL (`/var/www/html/proyectos/novasispy-backend-api`), React + styled-components + TanStack Query (`/var/www/html/proyectos/novasispy-erp`), Jest.

**Spec:** `docs/superpowers/specs/2026-10-13-mapeo-sin-decisiones-internas-design.md` (leerlo antes de cada tarea).

## Global Constraints

- Todo aplica solo a empresas con el módulo Contabilidad activo (`tieneModuloContabilidad`).
- Ningún respaldo silencioso: si el concepto necesario no está mapeado → `FaltaMapeoError`, nunca otra cuenta.
- La operación del usuario nunca falla por falta de mapeo (los `integrar*` no relanzan `FaltaMapeoError`).
- El día del despliegue ningún asiento cambia de cuenta: la precarga reproduce lo que hace hoy el código.
- Mensaje de `FaltaMapeoError` empieza con `No hay cuenta mapeada para el concepto` (código existente compara por ese texto).
- Commits: **no commitear**. El usuario maneja el git a mano; cada tarea termina con los archivos listos y los tests en verde.
- Frontend: seguir `docs/ui-standards.md` del ERP y reutilizar `src/components/_standards/`; formularios con el kit estándar; textos en español rioplatense neutro como el resto de la app.
- Backend local: tests con `npx jest <ruta>`; compilación con `npx tsc --noEmit` (criterio: sin errores nuevos en los archivos tocados).
- Migraciones: carpeta `prisma/migrations/<timestamp>_<nombre>/migration.sql`, aplicar con `npx prisma migrate deploy` y `npx prisma generate`.

## Review Focus

1. **Documento con dos conceptos faltantes a la vez** (p. ej. recibo con cheque y retención sin mapear): el aviso debe listar ambos, no solo el primero que falló.
2. **Concepto mapeado a una cuenta desactivada o de agrupación**: `getCuentaPorConcepto` ya lanza `BadRequestException`; no debe confundirse con `FaltaMapeoError` ni quedar sin aviso → se trata igual que falta de mapeo (la cuenta no es usable), con el mismo aviso.
3. **Regenerar desde Conciliación un documento pendiente después de mapear**: tiene que asentar con la cuenta nueva y cerrar las alertas (contador y usuario).
4. **Importación con despacho revertido y corregido a mano** (caso DOBA IMP-2026-000001): el cierre solo suma lo que entró a la puente por documentos del sistema; con 0 no crea asiento.
5. **Usuario destino que ya no existe o sin `usuario_id` en el documento**: solo se avisa al contador, sin error.

Cada línea tiene su test en la tarea dueña (marcado `[RF-n]`).

---

## Mapa de archivos

Backend (`novasispy-backend-api`):

| Archivo | Responsabilidad |
|---|---|
| `prisma/migrations/20261016000000_mapeo_constancia/migration.sql` (nuevo) | Columnas de constancia/modo, `ai_alertas.usuario_destino_id`, `tes_movimiento_det.concepto_contable` |
| `prisma/schema.prisma` | Reflejar la migración |
| `src/contabilidad/services/falta-mapeo.error.ts` (nuevo) | Error tipado con empresa y conceptos |
| `src/contabilidad/services/recomendaciones-mapeo.ts` (nuevo) | Recomendación por concepto + conceptos con modo |
| `src/contabilidad/services/avisos-mapeo.service.ts` (nuevo) | Registrar pendiente, alertas contador/usuario, sincronizar |
| `src/contabilidad/services/mapeo-cuentas.service.ts` | `FaltaMapeoError`, `resolverConcepto`, constancia, confirmar, recomendaciones en listado y catálogo |
| `src/contabilidad/controllers/mapeo-cuentas.controller.ts` | Pasar usuario, endpoint confirmar |
| `src/contabilidad/services/integracion.service.ts` | Envoltorio, sin respaldos, conceptos de importación, cierre por saldo real |
| `src/contabilidad/services/catalogo-asientos.ts` | Conceptos nuevos; `respaldo` → recomendación |
| `src/contabilidad/seeds/plan-cuentas-paraguay.seed.ts` | Conceptos nuevos en `MAPEO_DEFAULT` |
| `src/contabilidad/contabilidad.module.ts` | Importar `AlertasEmpresaModule`, proveer `AvisosMapeoService` |
| `src/alertas-empresa/*` | `usuarioDestinoId`, filtro por destinatario, `resolverPorPrefijo` |
| `src/rendicion-viaticos/rendicion-viaticos-contabilidad.service.ts`, `src/rrhh/services/{anticipos,acreditaciones-bancarias,reportes-ips,desvinculaciones}.service.ts` | Sin respaldos; guardar concepto en el detalle |
| `src/contabilidad-conciliacion/{causa-pendiente.ts,contabilidad-conciliacion.service.ts,registry.seed.ts,salud-contable.service.ts}` | Causa `FALTA_MAPEO`, `imp_cierre`, controles nuevos |
| `scripts/data_script/precarga-mapeo-sin-decisiones.ts` (nuevo) | Precarga idempotente |
| `src/ayuda-ia/ingesta/seed-catalogo.ts` | Catálogo de NovaIA |

Frontend (`novasispy-erp`):

| Archivo | Responsabilidad |
|---|---|
| `src/components/contabilidad/MapeoCuentasTab.jsx` | Estados, recomendación, modo, confirmar todo, advertencia doble ingreso, conceptos nuevos |
| `src/components/contabilidad/AsientosEjemploPanel.jsx` | "Falta mapear — recomendado: X" en lugar de respaldo |
| `src/tanstack/ContabilidadStack.jsx` + `src/api/*` donde está `getMapeoCuentas` | Mutación confirmar todo, body con modo |
| `src/pages/ConciliacionContablePage.jsx` | Botón a Mapeo en causa `FALTA_MAPEO` |
| `docs/guias/**` (guías de contabilidad) | Documentar recomendaciones y confirmación |

---

### Task 1: Esquema — constancia del mapeo, destinatario de alertas, concepto en detalle de tesorería

**Files:**
- Create: `prisma/migrations/20261016000000_mapeo_constancia/migration.sql`
- Modify: `prisma/schema.prisma` (modelos `cont_mapeo_cuentas` ~7327, `ai_alertas` ~6861, `tes_movimiento_det`)
- Modify: todo consumidor de `cont_mapeo_cuentas.cuenta` que deje de compilar por la relación opcional

**Interfaces:**
- Produces: columnas `cont_mapeo_cuentas.{modo, origen, cuenta_recomendada_codigo, confirmado_por, confirmado_at}`, `cuenta_id` nullable; `ai_alertas.usuario_destino_id`; `tes_movimiento_det.concepto_contable`.

- [ ] **Step 1: Escribir la migración**

```sql
-- Mapeo contable sin decisiones internas (spec 2026-10-13).
-- Constancia: quién decidió cada mapeo, qué recomendábamos y si lo cargó el
-- sistema (PRECARGA) o un usuario (CONTADOR). Todo lo existente arranca como
-- PRECARGA sin confirmar: muchos mapeos los cargó soporte, no el contador.

ALTER TABLE cont_mapeo_cuentas ALTER COLUMN cuenta_id DROP NOT NULL;
ALTER TABLE cont_mapeo_cuentas
  ADD COLUMN IF NOT EXISTS modo varchar(20) NOT NULL DEFAULT 'CUENTA',
  ADD COLUMN IF NOT EXISTS origen varchar(20) NOT NULL DEFAULT 'PRECARGA',
  ADD COLUMN IF NOT EXISTS cuenta_recomendada_codigo varchar(30),
  ADD COLUMN IF NOT EXISTS confirmado_por uuid REFERENCES usuario(id) ON DELETE SET NULL,
  ADD COLUMN IF NOT EXISTS confirmado_at timestamp(6);

ALTER TABLE cont_mapeo_cuentas DROP CONSTRAINT IF EXISTS cont_mapeo_modo_check;
ALTER TABLE cont_mapeo_cuentas ADD CONSTRAINT cont_mapeo_modo_check
  CHECK (modo IN ('CUENTA', 'SUMAR_A_PRINCIPAL'));
ALTER TABLE cont_mapeo_cuentas DROP CONSTRAINT IF EXISTS cont_mapeo_cuenta_segun_modo;
ALTER TABLE cont_mapeo_cuentas ADD CONSTRAINT cont_mapeo_cuenta_segun_modo
  CHECK ((modo = 'CUENTA' AND cuenta_id IS NOT NULL) OR (modo = 'SUMAR_A_PRINCIPAL' AND cuenta_id IS NULL));
ALTER TABLE cont_mapeo_cuentas DROP CONSTRAINT IF EXISTS cont_mapeo_origen_check;
ALTER TABLE cont_mapeo_cuentas ADD CONSTRAINT cont_mapeo_origen_check
  CHECK (origen IN ('PRECARGA', 'CONTADOR'));

-- Alerta personal: con valor, solo la ve ese usuario (aviso a quien cargó el documento).
ALTER TABLE ai_alertas ADD COLUMN IF NOT EXISTS usuario_destino_id uuid REFERENCES usuario(id) ON DELETE CASCADE;

-- Movimientos de RRHH: se guarda el concepto, no la cuenta ya resuelta, para que
-- un movimiento pendiente por falta de mapeo se asiente bien después de mapear.
ALTER TABLE tes_movimiento_det ADD COLUMN IF NOT EXISTS concepto_contable varchar(50);
```

- [ ] **Step 2: Reflejar en `schema.prisma`**

```prisma
model cont_mapeo_cuentas {
  id                        String             @id @default(dbgenerated("uuid_generate_v4()")) @db.Uuid
  empresa_id                String             @db.Uuid
  concepto                  String             @db.VarChar(50)
  cuenta_id                 String?            @db.Uuid
  /// CUENTA | SUMAR_A_PRINCIPAL (solo IMPORTACION_GASTO, IVA_NO_DEDUCIBLE)
  modo                      String             @default("CUENTA") @db.VarChar(20)
  /// PRECARGA (sistema) | CONTADOR (lo eligió un usuario)
  origen                    String             @default("PRECARGA") @db.VarChar(20)
  cuenta_recomendada_codigo String?            @db.VarChar(30)
  confirmado_por            String?            @db.Uuid
  confirmado_at             DateTime?          @db.Timestamp(6)
  created_at                DateTime?          @default(now()) @db.Timestamp(6)
  updated_at                DateTime?          @default(now()) @db.Timestamp(6)
  empresa                   empresas           @relation(fields: [empresa_id], references: [id], onDelete: Cascade)
  cuenta                    cont_plan_cuentas? @relation(fields: [cuenta_id], references: [id], onDelete: Restrict)

  @@unique([empresa_id, concepto])
  @@index([empresa_id])
}
```

En `ai_alertas` agregar después de `datos`:

```prisma
  /// Con valor, la alerta es personal: solo la ve ese usuario.
  usuario_destino_id   String?               @db.Uuid
```

En `tes_movimiento_det` agregar después de `cuenta_contable_id`:

```prisma
  /// Concepto de mapeo a resolver al asentar (RRHH). Ver integrarMovimientoTesoreria.
  concepto_contable  String?         @db.VarChar(50)
```

(No se agrega relación Prisma para `confirmado_por` ni `usuario_destino_id`: se leen por id, como `resuelta_por`.)

- [ ] **Step 0: Línea de base de `tsc`**

Run: `NODE_OPTIONS=--max-old-space-size=6144 npx tsc --noEmit 2>&1 | grep -c "error TS"`
Anotar la cifra en el reporte de la tarea: es el criterio de "sin errores nuevos" de todo el plan.

- [ ] **Step 3: Aplicar y regenerar el cliente**

Run: `npx prisma migrate deploy && npx prisma generate`
Expected: `1 migration applied` y cliente generado.

- [ ] **Step 4: Compilar y corregir los consumidores de `cuenta` opcional**

Run: `NODE_OPTIONS=--max-old-space-size=6144 npx tsc --noEmit 2>&1 | grep "error TS"`
Expected: además de los de la línea de base, errores solo donde se usa `m.cuenta.<campo>` de un mapeo. Corregir cada uno con `m.cuenta?.<campo>` (p. ej. en `mapeo-cuentas.service.ts`, `getCuentaPorConcepto`: `const cuenta = mapeo.cuenta;` ya es tolerante). En `getCuentaPorConcepto`, si `mapeo.cuenta_id` es null (modo `SUMAR_A_PRINCIPAL`), lanzar:

```ts
if (!mapeo.cuenta_id) {
  throw new BadRequestException(
    `El concepto "${concepto}" está configurado para sumarse a la cuenta principal: usá resolverConcepto().`,
  );
}
return mapeo.cuenta_id;
```

Volver a correr `tsc` hasta que no queden errores nuevos.

- [ ] **Step 5: Correr los tests de contabilidad**

Run: `npx jest src/contabilidad src/contabilidad-conciliacion src/alertas-empresa`
Expected: todos PASS (los mismos que antes).

---

### Task 2: `FaltaMapeoError`, recomendaciones y `resolverConcepto`

**Files:**
- Create: `src/contabilidad/services/falta-mapeo.error.ts`
- Create: `src/contabilidad/services/recomendaciones-mapeo.ts`
- Modify: `src/contabilidad/services/mapeo-cuentas.service.ts` (`getCuentaPorConcepto` ~líneas 175-205)
- Modify: `src/contabilidad/seeds/plan-cuentas-paraguay.seed.ts` (`MAPEO_DEFAULT` ~194, `MAPEO_DEFAULT_MODULOS` ~290)
- Test: `src/contabilidad/services/mapeo-cuentas-constancia.spec.ts` (nuevo)

**Interfaces:**
- Produces:
  - `class FaltaMapeoError extends NotFoundException { readonly empresaId: string; readonly conceptos: string[] }`
  - `RECOMENDACIONES: Record<string, Recomendacion>`; `type Recomendacion = { concepto: string } | { modo: 'SUMAR_A_PRINCIPAL' }`
  - `CONCEPTOS_CON_MODO: ReadonlySet<string>` = `IMPORTACION_GASTO`, `IVA_NO_DEDUCIBLE`
  - `CONCEPTOS_NUEVOS: string[]` (los seis de la sección 1 del spec)
  - `MapeoCuentasService.resolverConcepto(empresaId: string, concepto: string): Promise<{ modo: 'CUENTA'; cuentaId: string } | { modo: 'SUMAR_A_PRINCIPAL' }>`
  - `getCuentaPorConcepto` lanza `FaltaMapeoError` (sin mapeo) y también para cuenta desactivada / de agrupación [RF-2].

- [ ] **Step 1: Test que falla**

```ts
// src/contabilidad/services/mapeo-cuentas-constancia.spec.ts
import { FaltaMapeoError } from './falta-mapeo.error';
import { MapeoCuentasService } from './mapeo-cuentas.service';
import { CONCEPTOS_CON_MODO, CONCEPTOS_NUEVOS, RECOMENDACIONES } from './recomendaciones-mapeo';
import { MAPEO_DEFAULT } from '../seeds/plan-cuentas-paraguay.seed';

const servicio = (mapeo: any) => {
  const s = Object.create(MapeoCuentasService.prototype) as any;
  s.prisma = { cont_mapeo_cuentas: { findUnique: jest.fn().mockResolvedValue(mapeo) } };
  return s as MapeoCuentasService;
};

describe('getCuentaPorConcepto sin respaldo', () => {
  it('sin mapeo lanza FaltaMapeoError con empresa y concepto', async () => {
    const err = await servicio(null).getCuentaPorConcepto('emp', 'CHEQUES_EN_CARTERA').catch((e) => e);
    expect(err).toBeInstanceOf(FaltaMapeoError);
    expect(err.empresaId).toBe('emp');
    expect(err.conceptos).toEqual(['CHEQUES_EN_CARTERA']);
    expect(err.message).toMatch(/^No hay cuenta mapeada para el concepto/);
  });

  it('[RF-2] cuenta desactivada también es falta de mapeo', async () => {
    const err = await servicio({ cuenta_id: 'c1', modo: 'CUENTA', cuenta: { codigo: 'X', active: false, acepta_movimientos: true } })
      .getCuentaPorConcepto('emp', 'INVENTARIO')
      .catch((e) => e);
    expect(err).toBeInstanceOf(FaltaMapeoError);
    expect(err.message).toMatch(/desactivada/);
  });
});

describe('resolverConcepto', () => {
  it('devuelve el modo sumar a la principal', async () => {
    const r = await servicio({ cuenta_id: null, modo: 'SUMAR_A_PRINCIPAL', cuenta: null }).resolverConcepto('emp', 'IVA_NO_DEDUCIBLE');
    expect(r).toEqual({ modo: 'SUMAR_A_PRINCIPAL' });
  });
  it('devuelve la cuenta', async () => {
    const r = await servicio({ cuenta_id: 'c1', modo: 'CUENTA', cuenta: { codigo: 'X', active: true, acepta_movimientos: true } }).resolverConcepto('emp', 'IMPORTACION_GASTO');
    expect(r).toEqual({ modo: 'CUENTA', cuentaId: 'c1' });
  });
  it('sin mapeo lanza FaltaMapeoError', async () => {
    await expect(servicio(null).resolverConcepto('emp', 'IMPORTACION_GASTO')).rejects.toBeInstanceOf(FaltaMapeoError);
  });
});

describe('recomendaciones', () => {
  it('cada concepto nuevo existe en MAPEO_DEFAULT y tiene recomendación', () => {
    for (const c of CONCEPTOS_NUEVOS) {
      expect(Object.keys(MAPEO_DEFAULT)).toContain(c);
      expect(RECOMENDACIONES[c]).toBeDefined();
    }
  });
  it('solo los conceptos con modo recomiendan sumar a la principal', () => {
    for (const [c, r] of Object.entries(RECOMENDACIONES)) {
      if ('modo' in r) expect(CONCEPTOS_CON_MODO.has(c)).toBe(true);
    }
  });
});
```

- [ ] **Step 2: Correr y ver que falla**

Run: `npx jest src/contabilidad/services/mapeo-cuentas-constancia.spec.ts`
Expected: FAIL, `Cannot find module './falta-mapeo.error'`.

- [ ] **Step 3: Implementar**

```ts
// src/contabilidad/services/falta-mapeo.error.ts
import { NotFoundException } from '@nestjs/common';

/**
 * Un asiento automático necesita un concepto que la empresa no mapeó (o mapeó a
 * una cuenta inutilizable). Nunca se cae a otra cuenta: el documento queda
 * pendiente y se avisa (ver AvisosMapeoService). Ver
 * docs/superpowers/specs/2026-10-13-mapeo-sin-decisiones-internas-design.md.
 *
 * El mensaje conserva el prefijo "No hay cuenta mapeada para el concepto": hay
 * código que lo reconoce por texto.
 */
export class FaltaMapeoError extends NotFoundException {
  constructor(
    readonly empresaId: string,
    readonly conceptos: string[],
    detalle?: string,
  ) {
    super(
      `No hay cuenta mapeada para el concepto "${conceptos.join('", "')}"` +
        (detalle ? ` (${detalle})` : '') +
        '. Configurá el mapeo en Contabilidad → Mapeo de cuentas',
    );
  }
}
```

```ts
// src/contabilidad/services/recomendaciones-mapeo.ts
/**
 * Lo que el sistema RECOMIENDA para cada concepto. Nunca se aplica solo: se
 * muestra en Mapeo y queda en la constancia (`cuenta_recomendada_codigo`).
 * Una recomendación apunta a otro concepto (se muestra la cuenta que la empresa
 * tiene en él) o a un modo.
 */
export type Recomendacion = { concepto: string } | { modo: 'SUMAR_A_PRINCIPAL' };

/** Conceptos que admiten "sumar a la cuenta principal" en vez de una cuenta. */
export const CONCEPTOS_CON_MODO: ReadonlySet<string> = new Set(['IMPORTACION_GASTO', 'IVA_NO_DEDUCIBLE']);

export const CONCEPTOS_NUEVOS = [
  'IMPORTACION_COMPRA',
  'IMPORTACION_GASTO',
  'IMPORTACION_PAGO_PROVEEDOR',
  'IMPORTACION_TRIBUTOS',
  'IMPORTACION_ANTICIPO_IRE',
  'IVA_NO_DEDUCIBLE',
];

export const RECOMENDACIONES: Record<string, Recomendacion> = {
  IMPORTACION_COMPRA: { concepto: 'IMPORTACIONES_EN_CURSO' },
  IMPORTACION_GASTO: { concepto: 'IMPORTACIONES_EN_CURSO' },
  IMPORTACION_PAGO_PROVEEDOR: { concepto: 'IMPORTACIONES_EN_CURSO' },
  IMPORTACION_TRIBUTOS: { concepto: 'IMPORTACIONES_EN_CURSO' },
  IMPORTACION_ANTICIPO_IRE: { concepto: 'RETENCION_RENTA_FAVOR' },
  IVA_NO_DEDUCIBLE: { modo: 'SUMAR_A_PRINCIPAL' },
};

/** Texto corto de la recomendación con las cuentas que la empresa tiene hoy. */
export function describirRecomendacion(
  concepto: string,
  cuentaDe: (concepto: string) => { codigo: string; descripcion: string } | null,
): { texto: string; codigo: string | null } | null {
  const r = RECOMENDACIONES[concepto];
  if (!r) return null;
  if ('modo' in r) return { texto: 'Sumar a la cuenta principal (la del gasto)', codigo: null };
  const c = cuentaDe(r.concepto);
  return c
    ? { texto: `${c.codigo} ${c.descripcion} (la de ${r.concepto})`, codigo: c.codigo }
    : { texto: `La cuenta de ${r.concepto} (todavía no mapeada)`, codigo: null };
}
```

En `MAPEO_DEFAULT` (empresas nuevas del plan estándar) agregar:

```ts
  IMPORTACION_COMPRA: '1.1.4.04',
  IMPORTACION_GASTO: '1.1.4.04',
  IMPORTACION_PAGO_PROVEEDOR: '1.1.4.04',
  IMPORTACION_TRIBUTOS: '1.1.4.04',
  IMPORTACION_ANTICIPO_IRE: '1.1.3.04',
  IVA_NO_DEDUCIBLE: '',
```

y en `MAPEO_DEFAULT_MODULOS` los cinco `IMPORTACION_*` con `'IMPORTACIONES'`. En `seed.service.ts`, en los dos bucles `for (const [concepto, codigo] of Object.entries(MAPEO_DEFAULT))`, agregar al principio:

```ts
      // Conceptos con modo: el estándar es sumar a la cuenta principal, sin cuenta.
      if (codigo === '') {
        await this.prisma.cont_mapeo_cuentas.upsert({
          where: { empresa_id_concepto: { empresa_id: empresaId, concepto } },
          update: {},
          create: { empresa_id: empresaId, concepto, modo: 'SUMAR_A_PRINCIPAL', cuenta_id: null },
        });
        continue;
      }
```

(respetando el `if (existentesSet.has(concepto)) continue;` del segundo bucle, que va antes).

En `mapeo-cuentas.service.ts` reemplazar `getCuentaPorConcepto` y agregar `resolverConcepto`:

```ts
  async getCuentaPorConcepto(empresaId: string, concepto: string): Promise<string> {
    const r = await this.resolverConcepto(empresaId, concepto);
    if (r.modo !== 'CUENTA') {
      throw new BadRequestException(
        `El concepto "${concepto}" está configurado para sumarse a la cuenta principal: usá resolverConcepto().`,
      );
    }
    return r.cuentaId;
  }

  /**
   * La cuenta del concepto, o "sumar a la principal" para los conceptos que lo
   * admiten. Sin mapeo, o con una cuenta que no se puede usar, lanza
   * FaltaMapeoError: nunca se elige otra cuenta.
   */
  async resolverConcepto(
    empresaId: string,
    concepto: string,
  ): Promise<{ modo: 'CUENTA'; cuentaId: string } | { modo: 'SUMAR_A_PRINCIPAL' }> {
    const mapeo = await this.prisma.cont_mapeo_cuentas.findUnique({
      where: { empresa_id_concepto: { empresa_id: empresaId, concepto } },
      select: {
        cuenta_id: true,
        modo: true,
        cuenta: { select: { codigo: true, active: true, acepta_movimientos: true } },
      },
    });
    if (!mapeo) throw new FaltaMapeoError(empresaId, [concepto]);
    if (mapeo.modo === 'SUMAR_A_PRINCIPAL') return { modo: 'SUMAR_A_PRINCIPAL' };

    // Un mapeo puede quedar apuntando a una cuenta dada de baja o de agrupación:
    // para el asiento es lo mismo que no tenerlo.
    const cuenta = mapeo.cuenta;
    if (!mapeo.cuenta_id || !cuenta) throw new FaltaMapeoError(empresaId, [concepto]);
    if (!cuenta.active) {
      throw new FaltaMapeoError(empresaId, [concepto], `mapeado a ${cuenta.codigo}, que está desactivada`);
    }
    if (!cuenta.acepta_movimientos) {
      throw new FaltaMapeoError(empresaId, [concepto], `mapeado a ${cuenta.codigo}, que es de agrupación`);
    }
    return { modo: 'CUENTA', cuentaId: mapeo.cuenta_id };
  }
```

Import: `import { FaltaMapeoError } from './falta-mapeo.error';`

- [ ] **Step 4: Correr y ver que pasa**

Run: `npx jest src/contabilidad/services/mapeo-cuentas-constancia.spec.ts src/contabilidad/services/catalogo-asientos.spec.ts src/contabilidad/services/seed-gating-submodulos.spec.ts`
Expected: PASS. Si `catalogo-asientos.spec` falla por `MAPEO_DEFAULT` con `''`, ajustar el test "todos los conceptos existen" (usa `Object.keys`, no debería).

---

### Task 3: Bandeja de alertas — destinatario personal y resolver por prefijo

**Files:**
- Modify: `src/alertas-empresa/alertas-empresa.types.ts`, `src/alertas-empresa/alertas-empresa.service.ts`
- Test: `src/alertas-empresa/alertas-empresa.service.spec.ts` (agregar casos)

**Interfaces:**
- Produces:
  - `RegistrarAlertaInput.usuarioDestinoId?: string | null`
  - `AlertasEmpresaService.resolverPorPrefijo(empresaId: string, prefijo: string, resolucion: ResolucionAlerta): Promise<number>`
  - `listarParaUsuario` muestra alertas personales solo a su destinatario, sin exigirle el privilegio.

- [ ] **Step 1: Tests que fallan** (en `alertas-empresa.service.spec.ts`, siguiendo su helper de prisma mockeado existente)

```ts
describe('alertas personales', () => {
  it('una alerta con usuario destino solo la ve ese usuario y sin pedirle privilegio', async () => {
    const alertas = [
      { id: 'a1', usuario_destino_id: 'u1', modulo: 'CONTABILIDAD', privilegio_requerido: 'CONT_MAP_MAPEO_EDITAR', sucursal_id: null, criticidad: 'media', updated_at: new Date() },
      { id: 'a2', usuario_destino_id: 'u2', modulo: 'CONTABILIDAD', privilegio_requerido: null, sucursal_id: null, criticidad: 'media', updated_at: new Date() },
    ];
    const service = crearServicioConAlertas(alertas, { privilegios: [] , modulos: ['CONTABILIDAD'] });
    const vistas = await service.listarParaUsuario('u1', 'emp');
    expect(vistas.map((a) => a.id)).toEqual(['a1']);
  });

  it('resolverPorPrefijo cierra todas las alertas abiertas con esa clave inicial', async () => {
    const updateMany = jest.fn().mockResolvedValue({ count: 3 });
    const service = Object.create(AlertasEmpresaService.prototype) as any;
    service.prisma = { ai_alertas: { updateMany } };
    const n = await service.resolverPorPrefijo('emp', 'contabilidad.falta_mapeo', 'auto');
    expect(n).toBe(3);
    expect(updateMany.mock.calls[0][0].where).toEqual({ empresa_id: 'emp', resuelta: false, clave: { startsWith: 'contabilidad.falta_mapeo' } });
  });
});
```

`crearServicioConAlertas` (agregar al spec si no existe un helper equivalente): arma el servicio con `prisma.ai_alertas.findMany` → `alertas`, `prisma.ai_alertas_lecturas.findMany` → `[]`, y `jest.mock('./permisos-usuario')` / `jest.mock('src/utils/alcance-sucursal')` devolviendo `{ todosLosModulos: false, todosLosPrivilegios: false, modulos: new Set(opts.modulos), privilegios: new Set(opts.privilegios) }` y `null`.

- [ ] **Step 2: Correr y ver que falla**

Run: `npx jest src/alertas-empresa/alertas-empresa.service.spec.ts`
Expected: FAIL (a2 visible / `resolverPorPrefijo is not a function`).

- [ ] **Step 3: Implementar**

En `alertas-empresa.types.ts`, dentro de `RegistrarAlertaInput`:

```ts
  /** Alerta personal: solo la ve este usuario (p. ej. a quien cargó un documento). */
  usuarioDestinoId?: string | null;
```

En `registrar`, en `campos`: `usuario_destino_id: input.usuarioDestinoId ?? null,`.

En `listarParaUsuario`, reemplazar el filtro `visibles`:

```ts
    const visibles = alertas.filter((a) => {
      // Personal: solo su destinatario, y no se le exige el privilegio (el aviso
      // es justamente para quien no puede resolverlo).
      if (a.usuario_destino_id) return a.usuario_destino_id === usuarioId;
      return (
        puedeVerAlerta(permisos, a) &&
        (!a.sucursal_id || !alcance || alcance.sucursalIds.includes(a.sucursal_id))
      );
    });
```

Agregar después de `resolver`:

```ts
  /** Cierra todas las alertas abiertas cuya clave empieza con `prefijo`. */
  async resolverPorPrefijo(empresaId: string, prefijo: string, resolucion: ResolucionAlerta): Promise<number> {
    const { count } = await this.prisma.ai_alertas.updateMany({
      where: { empresa_id: empresaId, resuelta: false, clave: { startsWith: prefijo } },
      data: { resuelta: true, resuelta_at: new Date(), resolucion, updated_at: new Date() },
    });
    return count;
  }
```

- [ ] **Step 4: Correr y ver que pasa**

Run: `npx jest src/alertas-empresa`
Expected: PASS.

---

### Task 4: `AvisosMapeoService` — pendiente, constancia y alertas

**Files:**
- Create: `src/contabilidad/services/avisos-mapeo.service.ts`
- Modify: `src/contabilidad/contabilidad.module.ts` (imports `AlertasEmpresaModule`; providers/exports `AvisosMapeoService`)
- Test: `src/contabilidad/services/avisos-mapeo.service.spec.ts`

**Interfaces:**
- Consumes: `AlertasEmpresaService.registrar/resolver/resolverPorPrefijo` (Task 3), `FaltaMapeoError` (Task 2), `describirRecomendacion` (Task 2).
- Produces:
  - `registrarFaltaMapeo(p: { empresaId: string; origenTipo: string; origenId: string; conceptos: string[] }): Promise<void>`
  - `sincronizar(empresaId: string): Promise<void>` — abre/cierra `contabilidad.falta_mapeo`, `contabilidad.falta_mapeo.usuario.*`, `contabilidad.mapeo_sin_confirmar`.
  - Constante `ACCION_FALTA_MAPEO = 'CONT_FALTA_MAPEO'` (audit_logs.action; `entity_type` = origen_tipo, `entity_id` = id, `new_value` = `{ origen_tipo, conceptos }`).

- [ ] **Step 1: Tests que fallan**

```ts
// src/contabilidad/services/avisos-mapeo.service.spec.ts
import { AvisosMapeoService, ACCION_FALTA_MAPEO } from './avisos-mapeo.service';

const crear = (over: any = {}) => {
  const s = Object.create(AvisosMapeoService.prototype) as any;
  s.logger = { warn: jest.fn(), error: jest.fn(), log: jest.fn() };
  s.alertas = { registrar: jest.fn().mockResolvedValue({}), resolver: jest.fn(), resolverPorPrefijo: jest.fn() };
  s.prisma = {
    audit_logs: { create: jest.fn(), findMany: jest.fn().mockResolvedValue(over.pendientes ?? []) },
    cont_mapeo_cuentas: {
      findMany: jest.fn().mockResolvedValue(over.mapeos ?? []),
      count: jest.fn().mockResolvedValue(over.sinConfirmar ?? 0),
    },
    cont_documentos: { findMany: jest.fn().mockResolvedValue(over.confirmados ?? []) },
    suscripcion_modulos: { findFirst: jest.fn().mockResolvedValue(over.sinModulo ? null : { id: 'm' }) },
    gasto_cab: { findUnique: jest.fn().mockResolvedValue(over.gasto ?? { usuario_id: 'u1' }) },
    usuario: { findUnique: jest.fn().mockResolvedValue(over.usuarioExiste === false ? null : { id: 'u1' }) },
  };
  return s as AvisosMapeoService & any;
};

describe('AvisosMapeoService', () => {
  it('registra el pendiente con todos los conceptos y avisa al contador y a quien cargó [RF-1]', async () => {
    const pendiente = { entity_id: 'g1', new_value: { origen_tipo: 'gasto_cab', conceptos: ['IMPORTACION_GASTO', 'IVA_NO_DEDUCIBLE'] } };
    const s = crear({ pendientes: [pendiente] });
    await s.registrarFaltaMapeo({ empresaId: 'emp', origenTipo: 'gasto_cab', origenId: 'g1', conceptos: ['IMPORTACION_GASTO', 'IVA_NO_DEDUCIBLE'] });

    expect(s.prisma.audit_logs.create.mock.calls[0][0].data).toMatchObject({
      empresa_id: 'emp', action: ACCION_FALTA_MAPEO, entity_type: 'gasto_cab', entity_id: 'g1',
      new_value: { origen_tipo: 'gasto_cab', conceptos: ['IMPORTACION_GASTO', 'IVA_NO_DEDUCIBLE'] },
    });
    const claves = s.alertas.registrar.mock.calls.map((c: any) => c[0].clave);
    expect(claves).toContain('contabilidad.falta_mapeo');
    expect(claves).toContain('contabilidad.falta_mapeo.usuario.u1');
    const personal = s.alertas.registrar.mock.calls.find((c: any) => c[0].clave.endsWith('u1'))[0];
    expect(personal.usuarioDestinoId).toBe('u1');
    expect(personal.descripcion).toMatch(/IMPORTACION_GASTO/);
    expect(personal.descripcion).toMatch(/IVA_NO_DEDUCIBLE/);
  });

  it('[RF-5] sin usuario en el documento solo avisa al contador', async () => {
    const s = crear({ gasto: { usuario_id: null }, pendientes: [{ entity_id: 'g1', new_value: { origen_tipo: 'gasto_cab', conceptos: ['X'] } }] });
    await s.registrarFaltaMapeo({ empresaId: 'emp', origenTipo: 'gasto_cab', origenId: 'g1', conceptos: ['X'] });
    expect(s.alertas.registrar.mock.calls.map((c: any) => c[0].clave)).toEqual(['contabilidad.falta_mapeo']);
  });

  it('[RF-3] sincronizar cierra las alertas cuando el concepto ya se mapeó', async () => {
    const s = crear({
      pendientes: [{ entity_id: 'g1', new_value: { origen_tipo: 'gasto_cab', conceptos: ['X'] } }],
      mapeos: [{ concepto: 'X', cuenta_id: 'c', modo: 'CUENTA' }],
    });
    await s.sincronizar('emp');
    expect(s.alertas.resolverPorPrefijo).toHaveBeenCalledWith('emp', 'contabilidad.falta_mapeo', 'auto');
  });

  it('sin el módulo Contabilidad no avisa y cierra lo abierto', async () => {
    const s = crear({ sinModulo: true });
    await s.registrarFaltaMapeo({ empresaId: 'emp', origenTipo: 'gasto_cab', origenId: 'g1', conceptos: ['X'] });
    expect(s.prisma.audit_logs.create).not.toHaveBeenCalled();
    expect(s.alertas.registrar).not.toHaveBeenCalled();
  });

  it('abre la alerta de sin confirmar mientras haya mapeos sin confirmar', async () => {
    const s = crear({ sinConfirmar: 4 });
    await s.sincronizar('emp');
    const alerta = s.alertas.registrar.mock.calls.find((c: any) => c[0].clave === 'contabilidad.mapeo_sin_confirmar')[0];
    expect(alerta.criticidad).toBe('media');
    expect(alerta.titulo).toMatch(/4/);
  });
});
```

- [ ] **Step 2: Correr y ver que falla**

Run: `npx jest src/contabilidad/services/avisos-mapeo.service.spec.ts`
Expected: FAIL, módulo no encontrado.

- [ ] **Step 3: Implementar**

```ts
// src/contabilidad/services/avisos-mapeo.service.ts
import { Injectable, Logger } from '@nestjs/common';
import { PrismaService } from '../../prisma/prisma.service';
import { AlertasEmpresaService } from '../../alertas-empresa/alertas-empresa.service';

export const ACCION_FALTA_MAPEO = 'CONT_FALTA_MAPEO';
const CLAVE_CONTADOR = 'contabilidad.falta_mapeo';
const CLAVE_SIN_CONFIRMAR = 'contabilidad.mapeo_sin_confirmar';
const PRIVILEGIO_MAPEO = 'CONT_MAP_MAPEO_EDITAR';
const RUTA_MAPEO = '/contabilidad?tab=mapeo';

/** Tabla, campo del usuario que lo cargó y nombre legible, por origen contable. */
const ORIGENES: Record<string, { modelo: string; campoUsuario: string; nombre: string }> = {
  compra_cab: { modelo: 'compra_cab', campoUsuario: 'usuario_id', nombre: 'factura de compra' },
  nota_credito_compra_cab: { modelo: 'nota_credito_compra_cab', campoUsuario: 'usuario_id', nombre: 'nota de crédito de compra' },
  gasto_cab: { modelo: 'gasto_cab', campoUsuario: 'usuario_id', nombre: 'gasto' },
  recibos_cobro: { modelo: 'recibos_cobro', campoUsuario: 'usuario_id', nombre: 'recibo' },
  recibos_multi: { modelo: 'recibos_cobro', campoUsuario: 'usuario_id', nombre: 'recibo' },
  pagos_proveedor: { modelo: 'pagos_proveedor', campoUsuario: 'usuario_id', nombre: 'pago a proveedor' },
  orden_pago_proveedor_cab: { modelo: 'orden_pago_proveedor_cab', campoUsuario: 'usuario_id', nombre: 'orden de pago' },
  tes_movimientos: { modelo: 'tes_movimientos', campoUsuario: 'created_by', nombre: 'movimiento de tesorería' },
  imp_despacho: { modelo: 'imp_despachos', campoUsuario: 'usuario_id', nombre: 'despacho de importación' },
  imp_cierre: { modelo: 'imp_embarques', campoUsuario: 'usuario_id', nombre: 'cierre de importación' },
};

/**
 * Avisos de la regla "el contador decide las cuentas" (spec 2026-10-13):
 * cuando un asiento no sale por falta de mapeo queda constancia, se avisa al
 * contador (bandeja, privilegio de Mapeo) y a quien cargó el documento (alerta
 * personal). Las alertas se cierran solas cuando ya no falta nada.
 * Solo con el módulo Contabilidad activo.
 */
@Injectable()
export class AvisosMapeoService {
  private readonly logger = new Logger(AvisosMapeoService.name);

  constructor(
    private readonly prisma: PrismaService,
    private readonly alertas: AlertasEmpresaService,
  ) {}

  async registrarFaltaMapeo(p: { empresaId: string; origenTipo: string; origenId: string; conceptos: string[] }): Promise<void> {
    if (!(await this.tieneContabilidad(p.empresaId))) return;
    const conceptos = [...new Set(p.conceptos)];

    await this.prisma.audit_logs.create({
      data: {
        empresa_id: p.empresaId,
        action: ACCION_FALTA_MAPEO,
        entity_type: p.origenTipo,
        entity_id: p.origenId,
        new_value: { origen_tipo: p.origenTipo, conceptos },
        descripcion: `Sin asiento: falta mapear ${conceptos.join(', ')}`.slice(0, 255),
      },
    });

    await this.sincronizar(p.empresaId);

    const usuarioId = await this.usuarioDelOrigen(p.origenTipo, p.origenId);
    if (!usuarioId) return;
    const nombre = ORIGENES[p.origenTipo]?.nombre ?? 'documento';
    await this.alertas.registrar({
      empresaId: p.empresaId,
      clave: `${CLAVE_CONTADOR}.usuario.${usuarioId}`,
      tipo: 'CONTABILIDAD_FALTA_MAPEO',
      criticidad: 'media',
      titulo: `Tu ${nombre} se guardó, pero no se contabilizó`,
      descripcion: `Falta que el contador mapee: ${conceptos.join(', ')}. Ya se le avisó; no tenés que hacer nada.`,
      modulo: 'CONTABILIDAD',
      usuarioDestinoId: usuarioId,
      entidadTipo: p.origenTipo.slice(0, 30),
      entidadId: p.origenId,
      datos: { conceptos },
      origen: 'sistema',
    });
  }

  /** Abre o cierra las alertas del contador según lo que falta hoy. */
  async sincronizar(empresaId: string): Promise<void> {
    if (!(await this.tieneContabilidad(empresaId))) {
      await this.alertas.resolverPorPrefijo(empresaId, CLAVE_CONTADOR, 'auto');
      await this.alertas.resolver(empresaId, CLAVE_SIN_CONFIRMAR, 'auto');
      return;
    }

    const faltantes = await this.conceptosFrenando(empresaId);
    if (faltantes.size === 0) {
      await this.alertas.resolverPorPrefijo(empresaId, CLAVE_CONTADOR, 'auto');
    } else {
      const lista = [...faltantes.entries()].map(([c, n]) => `${c} (${n} documento${n === 1 ? '' : 's'})`);
      const total = [...faltantes.values()].reduce((a, b) => a + b, 0);
      await this.alertas.registrar({
        empresaId,
        clave: CLAVE_CONTADOR,
        tipo: 'CONTABILIDAD_FALTA_MAPEO',
        criticidad: 'alta',
        titulo: `Faltan mapear ${faltantes.size} concepto${faltantes.size === 1 ? '' : 's'}: ${total} documento${total === 1 ? '' : 's'} sin contabilizar`,
        descripcion: `Sin estas cuentas los asientos no se generan: ${lista.join('; ')}.`,
        accionSugerida: 'Mapealos en Contabilidad → Mapeo de cuentas (cada uno muestra la cuenta recomendada) y regenerá los pendientes en Conciliación.',
        modulo: 'CONTABILIDAD',
        privilegioRequerido: PRIVILEGIO_MAPEO,
        ruta: RUTA_MAPEO,
        datos: { conceptos: Object.fromEntries(faltantes) },
        origen: 'sistema',
      });
    }

    const sinConfirmar = await this.prisma.cont_mapeo_cuentas.count({ where: { empresa_id: empresaId, confirmado_at: null } });
    if (sinConfirmar === 0) {
      await this.alertas.resolver(empresaId, CLAVE_SIN_CONFIRMAR, 'auto');
    } else {
      await this.alertas.registrar({
        empresaId,
        clave: CLAVE_SIN_CONFIRMAR,
        tipo: 'CONTABILIDAD_MAPEO_SIN_CONFIRMAR',
        criticidad: 'media',
        titulo: `${sinConfirmar} cuenta${sinConfirmar === 1 ? '' : 's'} del mapeo sin confirmar por el contador`,
        descripcion: 'Las cargó el sistema con lo que hacía hasta hoy. Los asientos las usan, pero la elección tiene que confirmarla el contador.',
        accionSugerida: 'Revisalas en Contabilidad → Mapeo de cuentas y confirmalas (o cambialas).',
        modulo: 'CONTABILIDAD',
        privilegioRequerido: PRIVILEGIO_MAPEO,
        ruta: RUTA_MAPEO,
        origen: 'sistema',
      });
    }
  }

  /**
   * Concepto → cantidad de documentos todavía sin asiento confirmado que lo
   * necesitan. Sale de las constancias CONT_FALTA_MAPEO cuyo concepto sigue sin
   * un mapeo usable y cuyo documento no tiene asiento confirmado.
   */
  private async conceptosFrenando(empresaId: string): Promise<Map<string, number>> {
    const registros = await this.prisma.audit_logs.findMany({
      where: { empresa_id: empresaId, action: ACCION_FALTA_MAPEO },
      orderBy: { created_at: 'desc' },
      select: { entity_id: true, new_value: true },
    });
    if (registros.length === 0) return new Map();

    const mapeados = new Set(
      (
        await this.prisma.cont_mapeo_cuentas.findMany({
          where: { empresa_id: empresaId },
          select: { concepto: true, cuenta_id: true, modo: true },
        })
      )
        .filter((m) => m.modo === 'SUMAR_A_PRINCIPAL' || !!m.cuenta_id)
        .map((m) => m.concepto),
    );

    // Último registro por documento.
    const porDoc = new Map<string, { origen: string; id: string; conceptos: string[] }>();
    for (const r of registros) {
      const nv = (r.new_value ?? {}) as { origen_tipo?: string; conceptos?: string[] };
      if (!r.entity_id || !nv.origen_tipo) continue;
      const clave = `${nv.origen_tipo}:${r.entity_id}`;
      if (porDoc.has(clave)) continue;
      porDoc.set(clave, { origen: nv.origen_tipo, id: r.entity_id, conceptos: nv.conceptos ?? [] });
    }
    if (porDoc.size === 0) return new Map();

    const confirmados = await this.prisma.cont_documentos.findMany({
      where: {
        empresa_id: empresaId,
        estado: 'CONFIRMADO',
        OR: [...porDoc.values()].map((d) => ({ origen_tipo: d.origen, origen_id: d.id })),
      },
      select: { origen_tipo: true, origen_id: true },
    });
    const yaAsentados = new Set(confirmados.map((d) => `${d.origen_tipo}:${d.origen_id}`));

    const resultado = new Map<string, number>();
    for (const [clave, d] of porDoc) {
      if (yaAsentados.has(clave)) continue;
      for (const c of d.conceptos) {
        if (mapeados.has(c)) continue;
        resultado.set(c, (resultado.get(c) ?? 0) + 1);
      }
    }
    return resultado;
  }

  private async usuarioDelOrigen(origenTipo: string, origenId: string): Promise<string | null> {
    const cfg = ORIGENES[origenTipo];
    if (!cfg) return null;
    const modelo = (this.prisma as unknown as Record<string, { findUnique: (a: unknown) => Promise<Record<string, unknown> | null> }>)[cfg.modelo];
    const fila = await modelo?.findUnique({ where: { id: origenId }, select: { [cfg.campoUsuario]: true } }).catch(() => null);
    const usuarioId = (fila?.[cfg.campoUsuario] as string | null | undefined) ?? null;
    if (!usuarioId) return null;
    const existe = await this.prisma.usuario.findUnique({ where: { id: usuarioId }, select: { id: true } });
    return existe ? usuarioId : null;
  }

  private async tieneContabilidad(empresaId: string): Promise<boolean> {
    const r = await this.prisma.suscripcion_modulos.findFirst({
      where: { activo: true, modulos: { codigo: 'CONTABILIDAD' }, suscripciones: { empresa_id: empresaId } },
      select: { id: true },
    });
    return !!r;
  }
}
```

Nota sobre "mapeado": un concepto con cuenta desactivada cuenta como mapeado acá; la próxima regeneración vuelve a fallar y registra de nuevo, con el detalle en el mensaje. Es aceptable (la alerta se reabre).

En `contabilidad.module.ts`: `imports: [PrismaModule, AlertasEmpresaModule]`, agregar `AvisosMapeoService` a `providers` y `exports`.

- [ ] **Step 4: Correr y ver que pasa**

Run: `npx jest src/contabilidad/services/avisos-mapeo.service.spec.ts`
Expected: PASS.

---

### Task 5: Mapeo — constancia al guardar, confirmar todo, recomendaciones en el listado

**Files:**
- Modify: `src/contabilidad/services/mapeo-cuentas.service.ts` (`listar`, `actualizarBulk`, nuevo `confirmarTodo`)
- Modify: `src/contabilidad/controllers/mapeo-cuentas.controller.ts`
- Test: `src/contabilidad/services/mapeo-cuentas-constancia.spec.ts` (agregar)

**Interfaces:**
- Consumes: `AvisosMapeoService.sincronizar` (Task 4), `describirRecomendacion`, `CONCEPTOS_CON_MODO` (Task 2).
- Produces:
  - `actualizarBulk(empresaId: string, usuarioId: string, items: Array<{ concepto: string; cuenta_id: string | null; modo?: 'CUENTA' | 'SUMAR_A_PRINCIPAL' }>)`
  - `confirmarTodo(empresaId: string, usuarioId: string): Promise<{ confirmados: number }>`
  - `listar` devuelve por fila: `modo`, `origen`, `confirmado_at`, `confirmado_por_nombre`, `recomendacion: { texto, codigo } | null`, `distinto_de_recomendacion: boolean`
  - Endpoints: `PUT contabilidad/mapeo-cuentas` (body con `modo` opcional), `POST contabilidad/mapeo-cuentas/confirmar`.

- [ ] **Step 1: Tests que fallan**

```ts
describe('constancia del mapeo', () => {
  const crear = () => {
    const s = Object.create(MapeoCuentasService.prototype) as any;
    s.avisos = { sincronizar: jest.fn() };
    s.prisma = {
      cont_plan_cuentas: { findFirst: jest.fn().mockResolvedValue({ id: 'c1', codigo: '1.01', active: true, acepta_movimientos: true }) },
      cont_mapeo_cuentas: {
        findUnique: jest.fn().mockResolvedValue({ cuenta_id: 'c0', modo: 'CUENTA', cuenta: { codigo: '9.99' } }),
        findMany: jest.fn().mockResolvedValue([{ concepto: 'IMPORTACIONES_EN_CURSO', cuenta: { codigo: '1.01.04.11', descripcion: 'Imp. en curso' } }]),
        upsert: jest.fn().mockResolvedValue({}),
        updateMany: jest.fn().mockResolvedValue({ count: 5 }),
      },
      audit_logs: { create: jest.fn(), createMany: jest.fn() },
    };
    return s;
  };

  it('guardar marca CONTADOR, quién y cuándo, la recomendación vigente y deja audit', async () => {
    const s = crear();
    await s.actualizarBulk('emp', 'u1', [{ concepto: 'IMPORTACION_COMPRA', cuenta_id: 'c1' }]);
    const data = s.prisma.cont_mapeo_cuentas.upsert.mock.calls[0][0];
    expect(data.update).toMatchObject({ cuenta_id: 'c1', modo: 'CUENTA', origen: 'CONTADOR', confirmado_por: 'u1', cuenta_recomendada_codigo: '1.01.04.11' });
    expect(data.update.confirmado_at).toBeInstanceOf(Date);
    expect(s.prisma.audit_logs.create.mock.calls[0][0].data).toMatchObject({
      action: 'CONT_MAPEO_CAMBIO', entity_type: 'cont_mapeo_cuentas',
      old_value: { cuenta_codigo: '9.99', modo: 'CUENTA' },
      new_value: { concepto: 'IMPORTACION_COMPRA', cuenta_codigo: '1.01', modo: 'CUENTA', recomendado: '1.01.04.11' },
    });
    expect(s.avisos.sincronizar).toHaveBeenCalledWith('emp');
  });

  it('el modo sumar solo se acepta en los conceptos que lo admiten', async () => {
    const s = crear();
    await expect(s.actualizarBulk('emp', 'u1', [{ concepto: 'INVENTARIO', cuenta_id: null, modo: 'SUMAR_A_PRINCIPAL' }])).rejects.toThrow(/no admite/);
  });

  it('confirmar todo marca los pendientes con quién y cuándo', async () => {
    const s = crear();
    const r = await s.confirmarTodo('emp', 'u1');
    expect(r).toEqual({ confirmados: 5 });
    expect(s.prisma.cont_mapeo_cuentas.updateMany.mock.calls[0][0]).toMatchObject({
      where: { empresa_id: 'emp', confirmado_at: null },
      data: { confirmado_por: 'u1' },
    });
    expect(s.avisos.sincronizar).toHaveBeenCalledWith('emp');
  });
});
```

- [ ] **Step 2: Correr y ver que falla**

Run: `npx jest src/contabilidad/services/mapeo-cuentas-constancia.spec.ts -t "constancia"`
Expected: FAIL.

- [ ] **Step 3: Implementar**

Constructor: agregar `private readonly avisos: AvisosMapeoService` (import desde `./avisos-mapeo.service`). Reemplazar `actualizarBulk`:

```ts
  /**
   * Guarda lo que eligió el contador. Cada fila queda con constancia: CONTADOR,
   * quién, cuándo y qué recomendábamos en ese momento; el cambio va a audit_logs.
   */
  async actualizarBulk(
    empresaId: string,
    usuarioId: string,
    items: Array<{ concepto: string; cuenta_id: string | null; modo?: 'CUENTA' | 'SUMAR_A_PRINCIPAL' }>,
  ) {
    const cuentaDe = await this.cuentasPorConcepto(empresaId);
    const resultados: unknown[] = [];

    for (const item of items) {
      const modo = item.modo ?? 'CUENTA';
      if (modo === 'SUMAR_A_PRINCIPAL' && !CONCEPTOS_CON_MODO.has(item.concepto)) {
        throw new BadRequestException(`El concepto "${item.concepto}" no admite "sumar a la cuenta principal".`);
      }
      let cuenta: { id: string; codigo: string } | null = null;
      if (modo === 'CUENTA') {
        if (!item.cuenta_id) throw new BadRequestException(`Elegí una cuenta para "${item.concepto}".`);
        cuenta = await this.prisma.cont_plan_cuentas.findFirst({
          where: { id: item.cuenta_id, OR: [{ empresa_id: empresaId }, { empresa_id: null }] },
          select: { id: true, codigo: true },
        });
        if (!cuenta) throw new NotFoundException('La cuenta contable seleccionada no existe o fue eliminada');
      }

      const anterior = await this.prisma.cont_mapeo_cuentas.findUnique({
        where: { empresa_id_concepto: { empresa_id: empresaId, concepto: item.concepto } },
        select: { cuenta_id: true, modo: true, cuenta: { select: { codigo: true } } },
      });
      const recomendado = describirRecomendacion(item.concepto, cuentaDe)?.codigo ?? null;
      const ahora = new Date();
      const datos = {
        cuenta_id: cuenta?.id ?? null,
        modo,
        origen: 'CONTADOR',
        cuenta_recomendada_codigo: recomendado,
        confirmado_por: usuarioId,
        confirmado_at: ahora,
        updated_at: ahora,
      };
      resultados.push(
        await this.prisma.cont_mapeo_cuentas.upsert({
          where: { empresa_id_concepto: { empresa_id: empresaId, concepto: item.concepto } },
          update: datos,
          create: { empresa_id: empresaId, concepto: item.concepto, ...datos },
        }),
      );
      await this.prisma.audit_logs.create({
        data: {
          empresa_id: empresaId,
          user_id: usuarioId,
          action: 'CONT_MAPEO_CAMBIO',
          entity_type: 'cont_mapeo_cuentas',
          old_value: anterior ? { cuenta_codigo: anterior.cuenta?.codigo ?? null, modo: anterior.modo } : undefined,
          new_value: { concepto: item.concepto, cuenta_codigo: cuenta?.codigo ?? null, modo, recomendado },
          descripcion: `Mapeo ${item.concepto}`.slice(0, 255),
        },
      });
    }

    await this.avisos.sincronizar(empresaId);
    return resultados;
  }

  /** El contador confirma de una vez todo lo que cargó el sistema. */
  async confirmarTodo(empresaId: string, usuarioId: string): Promise<{ confirmados: number }> {
    const ahora = new Date();
    const { count } = await this.prisma.cont_mapeo_cuentas.updateMany({
      where: { empresa_id: empresaId, confirmado_at: null },
      data: { confirmado_por: usuarioId, confirmado_at: ahora, updated_at: ahora },
    });
    await this.prisma.audit_logs.create({
      data: {
        empresa_id: empresaId,
        user_id: usuarioId,
        action: 'CONT_MAPEO_CONFIRMAR_TODO',
        entity_type: 'cont_mapeo_cuentas',
        new_value: { confirmados: count },
        descripcion: `Confirmó ${count} cuentas del mapeo`,
      },
    });
    await this.avisos.sincronizar(empresaId);
    return { confirmados: count };
  }

  /** Concepto → cuenta (código y descripción) de la empresa, para resolver recomendaciones. */
  private async cuentasPorConcepto(empresaId: string) {
    const mapeos = await this.prisma.cont_mapeo_cuentas.findMany({
      where: { empresa_id: empresaId },
      select: { concepto: true, cuenta: { select: { codigo: true, descripcion: true } } },
    });
    const por = new Map(mapeos.map((m) => [m.concepto, m.cuenta ?? null]));
    return (c: string) => por.get(c) ?? null;
  }
```

Reemplazar `listar`:

```ts
  async listar(empresaId: string) {
    const filas = await this.prisma.cont_mapeo_cuentas.findMany({
      where: { empresa_id: empresaId },
      include: { cuenta: { select: { codigo: true, descripcion: true, tipo: true } } },
      orderBy: { concepto: 'asc' },
    });
    const por = new Map(filas.map((f) => [f.concepto, f.cuenta ?? null]));
    const cuentaDe = (c: string) => por.get(c) ?? null;
    const usuarios = await this.prisma.usuario.findMany({
      where: { id: { in: [...new Set(filas.map((f) => f.confirmado_por).filter((v): v is string => !!v))] } },
      select: { id: true, nombre: true },
    });
    const nombre = new Map(usuarios.map((u) => [u.id, u.nombre]));
    return filas.map((f) => {
      const recomendacion = describirRecomendacion(f.concepto, cuentaDe);
      const distinto =
        !!recomendacion &&
        (recomendacion.codigo ? f.cuenta?.codigo !== recomendacion.codigo : f.modo !== 'SUMAR_A_PRINCIPAL');
      return {
        ...f,
        confirmado_por_nombre: f.confirmado_por ? nombre.get(f.confirmado_por) ?? null : null,
        recomendacion,
        distinto_de_recomendacion: distinto,
      };
    });
  }
```

(Verificar el nombre real del campo de nombre en `usuario` con `awk '/^model usuario \{/,/^\}/' prisma/schema.prisma`; si es `nombre_completo` o `name`, usar ese.)

Controller:

```ts
  @Put()
  @RequirePermission('CONTABILIDAD', 'CONT_MAP_MAPEO_EDITAR')
  @ApiOperation({ summary: 'Actualizar mapeo (bulk): [{concepto, cuenta_id, modo?}]. Deja constancia de quién eligió.' })
  actualizar(
    @GetUser() user: LoginUserInfo,
    @Body() body: Array<{ concepto: string; cuenta_id: string | null; modo?: 'CUENTA' | 'SUMAR_A_PRINCIPAL' }>,
  ) {
    return this.service.actualizarBulk(user.empresa_id, user.id, body);
  }

  @Post('confirmar')
  @RequirePermission('CONTABILIDAD', 'CONT_MAP_MAPEO_EDITAR')
  @ApiOperation({ summary: 'El contador confirma todos los mapeos cargados por el sistema' })
  confirmar(@GetUser() user: LoginUserInfo) {
    return this.service.confirmarTodo(user.empresa_id, user.id);
  }
```

(Verificar que `LoginUserInfo` tenga `id`; si el campo se llama distinto, usar el mismo que otros controllers para el autor.) Buscar otros llamadores de `actualizarBulk` con `rtk proxy grep -rn "actualizarBulk(" src` y pasarles el usuario.

- [ ] **Step 4: Correr y ver que pasa**

Run: `npx jest src/contabilidad/services/mapeo-cuentas-constancia.spec.ts src/contabilidad/services/catalogo-asientos.spec.ts`
Expected: PASS (los tests del catálogo crean el servicio sin `avisos`; no llaman `actualizarBulk`).

---

### Task 6: Integrador — envoltorio y fin de los respaldos silenciosos

**Files:**
- Modify: `src/contabilidad/services/integracion.service.ts`
- Test: `src/contabilidad/services/integracion-sin-respaldos.spec.ts` (nuevo); ajustar `asientos-cobros-pagos.spec.ts` donde dependía de un respaldo

**Interfaces:**
- Consumes: `FaltaMapeoError` (Task 2), `AvisosMapeoService.registrarFaltaMapeo` (Task 4).
- Produces:
  - `private async conAvisoDeMapeo(origenTipo: string, origenId: string, fn: () => Promise<void>): Promise<void>` — captura `FaltaMapeoError`, registra y NO relanza.
  - `private requerir(cuentaId: string | null | undefined, empresaId: string, concepto: string): string`
  - Cada `integrar*` público envuelve su cuerpo con `conAvisoDeMapeo` usando su `origen_tipo` (tabla de abajo).

| Método | origen_tipo | id |
|---|---|---|
| integrarFacturaVenta | factura_cab | facturaId |
| integrarNotaCredito | nota_credito_cab | notaCreditoId |
| integrarFacturaCompra | compra_cab | compraId |
| integrarNotaCreditoCompra | nota_credito_compra_cab | ncId |
| integrarCierreDespacho | imp_despacho | despachoId |
| integrarCierreImportacion | imp_cierre | embarqueId |
| integrarGasto | gasto_cab | gastoId |
| integrarCobro | recibos_cobro | cobroId |
| integrarPago | pagos_proveedor | pagoId |
| integrarOrdenPago | orden_pago_proveedor_cab | ordenId |
| integrarMovimientoTesoreria | tes_movimientos | movimientoId |
| integrarTransferenciaTes | tes_transferencias | transferenciaId |
| integrarPagoBancard | pago_bancard | pagoBancardId |
| integrarLiquidacionRrhh | rrhh_liquidacion | liquidacionId |
| integrarReciboMulti | recibos_multi | reciboId |
| integrarDevengamientoComisiones | liquidacion_comisiones_deveng | liquidacionId |
| integrarPagoComisiones | liquidacion_comisiones_pago | liquidacionId |
| integrarComisionSupervisor | comision_supervisor | comisionId |

- [ ] **Step 1: Tests que fallan**

```ts
// src/contabilidad/services/integracion-sin-respaldos.spec.ts
import { ContabilidadIntegracionService } from './integracion.service';
import { FaltaMapeoError } from './falta-mapeo.error';

const cuentaDe = (c: string) => `cta-${c}`;

/** Servicio con mapeo: los conceptos de `faltan` no están mapeados. */
const crear = (prisma: any, faltan: string[] = []) => {
  const s = Object.create(ContabilidadIntegracionService.prototype) as any;
  s.logger = { log: jest.fn(), warn: jest.fn(), error: jest.fn() };
  s.prisma = {
    cont_documentos: { findFirst: jest.fn().mockResolvedValue(null), upsert: jest.fn().mockResolvedValue({ id: 'd' }), create: jest.fn().mockResolvedValue({ id: 'd' }) },
    $transaction: jest.fn().mockImplementation((fn: any) => fn(s.prisma)),
    imp_componentes_costo: { findFirst: jest.fn().mockResolvedValue(null) },
    ...prisma,
  };
  s.tieneModuloContabilidad = jest.fn().mockResolvedValue(true);
  s.periodos = { resolverPeriodoPorFecha: jest.fn().mockResolvedValue('p') };
  const resolver = (e: string, c: string) => (faltan.includes(c) ? Promise.reject(new FaltaMapeoError(e, [c])) : Promise.resolve(cuentaDe(c)));
  s.mapeo = {
    getCuentaPorConcepto: jest.fn().mockImplementation(resolver),
    resolverConcepto: jest.fn().mockImplementation((e: string, c: string) => resolver(e, c).then((id) => ({ modo: 'CUENTA', cuentaId: id }))),
  };
  s.mediosPago = { resolverPorCodigoMedio: jest.fn().mockResolvedValue(new Map()), resolverPorMedio: jest.fn().mockResolvedValue(new Map()), idMedioPorCodigo: jest.fn().mockResolvedValue(7) };
  s.tipoCambio = { getTasa: jest.fn() };
  s.asientos = { crearConfirmado: jest.fn().mockResolvedValue({}) };
  s.avisosMapeo = { registrarFaltaMapeo: jest.fn().mockResolvedValue(undefined) };
  return s;
};

describe('sin respaldos silenciosos', () => {
  it('la orden de pago con cheque y sin CHEQUES_A_PAGAR no asienta, no falla y avisa', async () => {
    const orden = {
      id: 'op1', empresa_id: 'emp', estado: 'CONFIRMADA', monto_total: 100, moneda: { codigo: 'PYG' }, cotizacion: null,
      fecha: new Date('2026-10-13'), numero: 'OP-1', usuario_id: 'u1',
      orden_pago_proveedor_det: [{ monto: 100, medio_pago: { codigo: 'CHEQUE' }, cuenta_bancaria_id: 'tes1', cuentas_pagar: { cuenta_pasivo_id: 'pas', compra_id: null } }],
    };
    const s = crear({
      orden_pago_proveedor_cab: { findUnique: jest.fn().mockResolvedValue(orden) },
      tes_reglas: { findMany: jest.fn().mockResolvedValue([]) },
      tes_cuentas: { findMany: jest.fn().mockResolvedValue([{ id: 'tes1', cuenta_contable_id: 'cta-banco' }]) },
    }, ['CHEQUES_A_PAGAR']);

    await expect(s.integrarOrdenPago('op1')).resolves.toBeUndefined();
    expect(s.asientos.crearConfirmado).not.toHaveBeenCalled();
    expect(s.avisosMapeo.registrarFaltaMapeo).toHaveBeenCalledWith({
      empresaId: 'emp', origenTipo: 'orden_pago_proveedor_cab', origenId: 'op1', conceptos: ['CHEQUES_A_PAGAR'],
    });
  });

  it('el pago de comisiones sin PAGO_COMISIONES_FONDOS no cae a caja', async () => {
    const s = crear({
      liquidaciones_comisiones: { findFirst: jest.fn().mockResolvedValue({ id: 'l1', empresa_id: 'emp', estado: 'PAGADA', total_neto: 100, total_comision: 100, fecha_pago: new Date(), regimen: 'EMPLEADO' }) },
    }, ['PAGO_COMISIONES_FONDOS']);
    await s.integrarPagoComisiones('l1', 'emp');
    expect(s.mapeo.getCuentaPorConcepto).not.toHaveBeenCalledWith('emp', 'CAJA_GENERAL');
    expect(s.asientos.crearConfirmado).not.toHaveBeenCalled();
    expect(s.avisosMapeo.registrarFaltaMapeo.mock.calls[0][0].conceptos).toEqual(['PAGO_COMISIONES_FONDOS']);
  });

  it('un proveedor del exterior sin PROVEEDORES_EXTERIOR no cae a PROVEEDORES', async () => {
    const s = crear({ proveedores: { findFirst: jest.fn().mockResolvedValue({ tipo_entidad: 'PROVEEDOR_EXTERIOR', cuenta_contable_id: null }) } }, ['PROVEEDORES_EXTERIOR']);
    await expect(s.resolverCuentaPasivo('p1', 'emp')).rejects.toBeInstanceOf(FaltaMapeoError);
    expect(s.mapeo.getCuentaPorConcepto).not.toHaveBeenCalledWith('emp', 'PROVEEDORES');
  });

  it('otros errores se siguen propagando', async () => {
    const s = crear({ gasto_cab: { findUnique: jest.fn().mockRejectedValue(new Error('db caída')) } });
    await expect(s.integrarGasto('g1')).rejects.toThrow('db caída');
  });
});
```

Agregar también, en `asientos-cobros-pagos.spec.ts` (que ya tiene el armado de recibo y venta), casos equivalentes para: venta contado con cheque sin `CHEQUES_EN_CARTERA`; recibo multi con cheque diferido sin `CHEQUES_EN_TRANSITO`; recibo multi con retención de IVA y cheque, ambos sin mapear → `conceptos` contiene los dos **[RF-1]** (el recibo junta los faltantes antes de lanzar: ver Step 3). En ese spec, el helper `crearServicio` debe sumar `service.avisosMapeo = { registrarFaltaMapeo: jest.fn() }` y el mapeo de `getCuentaPorConcepto` debe rechazar con `FaltaMapeoError` los conceptos ausentes de una lista (hoy siempre resuelve).

Si al cambiar el comportamiento algún test existente que dependía del respaldo (p. ej. "el cheque emitido acredita Caja") queda en contradicción con el spec, actualizarlo al nuevo comportamiento y dejar un comentario con la fecha y el motivo.

- [ ] **Step 2: Correr y ver que fallan**

Run: `npx jest src/contabilidad/services/integracion-sin-respaldos.spec.ts`
Expected: FAIL (`integrarOrdenPago` asienta contra el banco / `avisosMapeo` no se llama).

- [ ] **Step 3: Implementar**

Constructor: agregar `private readonly avisosMapeo: AvisosMapeoService`.

Agregar:

```ts
  /**
   * Regla de la casa (spec 2026-10-13): si falta un mapeo, el documento queda
   * sin asiento, con constancia y aviso, y la operación del usuario NO falla.
   * Cualquier otro error se propaga como siempre.
   */
  private async conAvisoDeMapeo(origenTipo: string, origenId: string, fn: () => Promise<void>): Promise<void> {
    try {
      await fn();
    } catch (e) {
      if (!(e instanceof FaltaMapeoError)) throw e;
      this.logger.warn(`${origenTipo} ${origenId} sin asiento: ${e.message}`);
      await this.avisosMapeo
        .registrarFaltaMapeo({ empresaId: e.empresaId, origenTipo, origenId, conceptos: e.conceptos })
        .catch((err) => this.logger.error(`No se pudo registrar el aviso de mapeo de ${origenTipo} ${origenId}: ${err?.message ?? err}`));
    }
  }

  /** Cuenta obligatoria para una línea que el documento sí tiene. */
  private requerir(cuentaId: string | null | undefined, empresaId: string, concepto: string): string {
    if (!cuentaId) throw new FaltaMapeoError(empresaId, [concepto]);
    return cuentaId;
  }
```

Envolver cada método público de la tabla. Patrón (repetir en cada uno, sin cambiar la firma):

```ts
  async integrarOrdenPago(ordenId: string) {
    return this.conAvisoDeMapeo('orden_pago_proveedor_cab', ordenId, async () => {
      // ...cuerpo anterior sin cambios, salvo lo indicado abajo...
    });
  }
```

Donde el cuerpo hoy captura el error de mapeo por texto y llama `upsertDocumentoBorrador(message); return;` (compra, NC compra, gasto, OP), cambiar a:

```ts
    } catch (e) {
      if (e instanceof FaltaMapeoError) {
        await upsertDocumentoBorrador(e.message);
        throw e;
      }
      throw e;
    }
```

Respaldos a eliminar (buscar cada uno; los números de línea son del estado al 2026-10-13):

1. `resolverCuentaPasivo` (~156-176): borrar el `try/catch` del paso 3; queda `return this.mapeo.getCuentaPorConcepto(empresaId, concepto);` y actualizar el JSDoc (sin "Fallback duro").
2. `agregarChequeAlMapa` (~61-66): nueva firma `agregarChequeAlMapa(empresaId, mapaMedios, partes: Array<{ medioPagoId: number | string | null; monto: number }>)`:

```ts
  private async agregarChequeAlMapa(
    empresaId: string,
    mapaMedios: Map<string, string>,
    partes: Array<{ medioPagoId: unknown; monto: number }>,
  ): Promise<void> {
    const idCheque = await this.mediosPago.idMedioPorCodigo(CODIGO_MEDIO_POR_NOMBRE.CHEQUE);
    if (!idCheque) return;
    const hayCheque = partes.some((p) => String(p.medioPagoId) === String(idCheque) && p.monto > 0);
    if (!hayCheque) return;
    // Sin respaldo: el cheque no entra a la caja si no se mapeó su cuenta.
    mapaMedios.set(idCheque as never, await this.mapeo.getCuentaPorConcepto(empresaId, 'CHEQUES_EN_CARTERA'));
  }
```

   y en los dos llamadores (~270 venta, ~1284 cobro) pasar `partes` (ya están armadas justo después: mover la llamada debajo de la construcción de `partes`).
3. Orden de pago (~1535 y la línea `acreditar(cChequesAPagar ?? cuentaElegida ?? cCajaFallback, ...)` ~1594): `this.mapeo.getCuentaPorConcepto(empresaId, 'CHEQUES_A_PAGAR').catch(() => null)` se deja (se pide una vez), y la línea pasa a
   `acreditar(this.requerir(cChequesAPagar, empresaId, 'CHEQUES_A_PAGAR'), importe, 'Cheque emitido a pagar');`
4. Recibo multi (~2373-2382 y usos ~2546-2595): mantener la carga con `.catch(() => null)`, pero **juntar los faltantes** antes de armar líneas:

```ts
    const faltan: string[] = [];
    const necesito = (cuenta: string | null, monto: number, concepto: string) => {
      if (monto > 0 && !cuenta) faltan.push(concepto);
    };
    necesito(cChequesCartera, totalChequesCartera, 'CHEQUES_EN_CARTERA');
    necesito(cChequesDiferidos, totalChequesDiferidos, 'CHEQUES_EN_TRANSITO');
    necesito(cRetIVA, totalRetIVA, 'RETENCION_IVA_FAVOR');
    necesito(cRetRenta, totalRetRenta, 'RETENCION_RENTA_FAVOR');
    necesito(cAnticipos, totalSaldoFavor, 'ANTICIPOS_CLIENTES');
    necesito(cProveedores, totalFacturasCompra, 'PROVEEDORES');
    necesito(cIntereses, totalIntereses, 'INTERESES_MORATORIOS_COBRADOS');
    // (y el excedente a favor del cliente, consumo por planilla y sueldos: mismo patrón con sus totales)
    if (faltan.length) throw new FaltaMapeoError(empresaId, faltan);
```

   y en las líneas reemplazar `cChequesCartera ?? cCaja` por `cChequesCartera!`, `cChequesDiferidos ?? cChequesCartera ?? cCaja` por `cChequesDiferidos!`, y quitar las condiciones `&& cRetIVA` / `&& cRetRenta` / `&& cAnticipos` / `&& cProveedores` (ya garantizadas). En `DESCUENTO_PLANILLA` sin `cConsumoPuente`: sumar `'CONSUMO_FUNCIONARIO_PUENTE'` a `faltan` en vez del `logger.warn` + `continue`. En gastos asociados: `if (!cuentaId) cuentaId = cProveedores;` → si sigue null, `faltan.push('PROVEEDORES')`. Usar los nombres de variables reales del método (leerlo entero antes de editar).
5. Liquidación RRHH (~2131-2142 y armado ~2203-2251): `SUELDOS_JORNALES`/`SUELDOS_A_PAGAR` faltantes → `throw new FaltaMapeoError(empresaId, [...faltantes])` en vez de `warn + return`. Para los opcionales, juntar faltantes con montos: patronal total > 0 sin `cAportePatronal` → `APORTE_PATRONAL_IPS`; admin > 0 → `APORTE_ADMIN_IPS`; `totalIps > 0` → `IPS_A_DEPOSITAR`; `descuentosVarios > 0` → `DESCUENTOS_VARIOS_RRHH`; lanzar si hay alguno, antes del bucle de líneas.
6. Bancard (~2005-2011): `if (!cClientes) { warn; return; }` → `this.requerir(cClientes, empresaId, 'CLIENTES')`.
7. Devengamiento de comisiones (~2698): si `iva > 0` y la cuenta de IVA es null → `requerir(..., 'IVA_CREDITO_10')`.
8. Pago de comisiones y comisión de supervisor (~2784, ~2848): quitar `.catch(() => this.mapeo.getCuentaPorConcepto(empresaId, 'CAJA_GENERAL'))`.
9. Movimiento de tesorería imputado a importación (~1723-1734): si el concepto no está mapeado hoy se cae a la categoría. Cambiar a `cuentaImportacionId = await this.mapeo.getCuentaPorConcepto(empresaId, concepto);` (sin `.catch`), con `concepto = tipo === 'DESPACHO' ? 'ANTICIPO_DESPACHO' : 'IMPORTACION_PAGO_PROVEEDOR'` (el cambio de concepto es de la Task 7; acá dejar `'IMPORTACIONES_EN_CURSO'` si se hace en este orden, y la Task 7 lo reemplaza).
10. Despacho con anticipo y sin `ANTICIPO_DESPACHO` (~776-790): quitar el `.catch(() => null)` y el `warn`; con anticipo, la cuenta es obligatoria.

Imports al principio del archivo:
```ts
import { AvisosMapeoService } from './avisos-mapeo.service';
import { FaltaMapeoError } from './falta-mapeo.error';
```

Verificar que no queden respaldos: `rtk proxy grep -n "catch(() => null)\|catch(() => this.mapeo" src/contabilidad/services/integracion.service.ts` → solo cargas que después pasan por `requerir`/`necesito` (revisar una por una).

- [ ] **Step 4: Correr y ver que pasa**

Run: `npx jest src/contabilidad src/contabilidad-conciliacion`
Expected: PASS (incluido el `integrador-sombra.spec`, que construye el servicio real: si falla por el nuevo parámetro del constructor, agregar `avisosMapeo` al armado de la sombra con un stub que no escribe —la sombra bloquea escrituras—).

---

### Task 7: Importaciones e IVA no deducible con conceptos propios

**Files:**
- Modify: `src/contabilidad/services/integracion.service.ts` (`integrarFacturaCompra` ~418-590, `integrarGasto` ~966-1250, `integrarCierreDespacho` ~685-860, `integrarMovimientoTesoreria` ~1723)
- Test: `src/contabilidad/services/integracion-importaciones.spec.ts` (nuevo)

**Interfaces:**
- Consumes: `resolverConcepto` (Task 2), `conAvisoDeMapeo`/`requerir` (Task 6).
- Produces: comportamiento — compra con componente de importación → debe a `IMPORTACION_COMPRA`; gasto con componente → `IMPORTACION_GASTO` (o cuenta del tipo con `SUMAR_A_PRINCIPAL`); egreso PROVEEDOR imputado → `IMPORTACION_PAGO_PROVEEDOR`; tributos del despacho → `IMPORTACION_TRIBUTOS`; IRE del despacho → `IMPORTACION_ANTICIPO_IRE`; gasto no deducible → IVA a `IVA_NO_DEDUCIBLE` o sumado al gasto.

- [ ] **Step 1: Tests que fallan**

```ts
// src/contabilidad/services/integracion-importaciones.spec.ts
// Reutiliza el helper `crear` de integracion-sin-respaldos.spec.ts: moverlo a
// src/contabilidad/services/__helpers__/integracion-mock.ts y exportarlo como
// `crearIntegracionMock(prisma, faltan, modos?)`, donde `modos` es
// Record<concepto, 'SUMAR_A_PRINCIPAL'> para resolverConcepto.
import { crearIntegracionMock } from './__helpers__/integracion-mock';

const lineas = (s: any) => s.asientos.crearConfirmado.mock.calls[0][3].lineas;

const compra = { id: 'c1', empresa_id: 'emp', condicion_compra: 'CREDITO', total: 1100, total_iva_10: 100, total_iva_5: 0, moneda: { codigo: 'PYG' }, cotizacion: null, fecha_emision: new Date('2026-10-13'), proveedor_id: 'p1', numero: '1', estado: 'confirmada' };

describe('compra cargada a una importación', () => {
  it('va a IMPORTACION_COMPRA, no a INVENTARIO', async () => {
    const s = crearIntegracionMock({
      compra_cab: { findUnique: jest.fn().mockResolvedValue(compra) },
      imp_componentes_costo: { findFirst: jest.fn().mockResolvedValue({ id: 'comp' }) },
    });
    s.resolverCuentaPasivo = jest.fn().mockResolvedValue('cta-PROVEEDORES_EXTERIOR');
    await s.integrarFacturaCompra('c1');
    const debe = lineas(s).filter((l: any) => l.debe_moneda > 0).map((l: any) => l.cuenta_id);
    expect(debe).toContain('cta-IMPORTACION_COMPRA');
    expect(debe).not.toContain('cta-INVENTARIO');
  });

  it('una compra común sigue yendo a INVENTARIO', async () => {
    const s = crearIntegracionMock({ compra_cab: { findUnique: jest.fn().mockResolvedValue(compra) } });
    s.resolverCuentaPasivo = jest.fn().mockResolvedValue('cta-PROVEEDORES');
    await s.integrarFacturaCompra('c1');
    expect(lineas(s)[0].cuenta_id).toBe('cta-INVENTARIO');
  });
});

describe('gasto', () => {
  const gasto = (over: any = {}) => ({
    id: 'g1', empresa_id: 'emp', anulado: false, deducible: true, forma_pago: 'CREDITO', proveedor_id: 'p1',
    moneda: { codigo: 'PYG' }, cotizacion: null, fecha_emision: new Date('2026-10-13'), total: 1100, total_iva_10: 100, total_iva_5: 0,
    gasto_det: [{ subtotal: 1100, monto_iva: 100, tipo_gasto: { cuenta_contable_id: 'cta-11.22', descripcion: 'Gastos de importación' } }],
    ...over,
  });
  const base = (g: any, extra: any = {}) => ({
    gasto_cab: { findUnique: jest.fn().mockResolvedValue(g) },
    config_compras: { findUnique: jest.fn().mockResolvedValue(null) },
    tes_reglas: { findMany: jest.fn().mockResolvedValue([]) },
    ...extra,
  });

  it('cargado a una importación con cuenta propia va a IMPORTACION_GASTO', async () => {
    const s = crearIntegracionMock(base(gasto(), { imp_componentes_costo: { findFirst: jest.fn().mockResolvedValue({ id: 'comp' }) } }));
    s.resolverCuentaPasivo = jest.fn().mockResolvedValue('cta-PROVEEDORES');
    await s.integrarGasto('g1');
    expect(lineas(s).find((l: any) => l.debe_moneda === 1000).cuenta_id).toBe('cta-IMPORTACION_GASTO');
  });

  it('con SUMAR_A_PRINCIPAL conserva la cuenta del tipo de gasto (lo de hoy)', async () => {
    const s = crearIntegracionMock(base(gasto(), { imp_componentes_costo: { findFirst: jest.fn().mockResolvedValue({ id: 'comp' }) } }), [], { IMPORTACION_GASTO: 'SUMAR_A_PRINCIPAL' });
    s.resolverCuentaPasivo = jest.fn().mockResolvedValue('cta-PROVEEDORES');
    await s.integrarGasto('g1');
    expect(lineas(s).find((l: any) => l.debe_moneda === 1000).cuenta_id).toBe('cta-11.22');
  });

  it('no deducible con cuenta propia separa el IVA', async () => {
    const s = crearIntegracionMock(base(gasto({ deducible: false })));
    s.resolverCuentaPasivo = jest.fn().mockResolvedValue('cta-PROVEEDORES');
    await s.integrarGasto('g1');
    const l = lineas(s);
    expect(l.find((x: any) => x.cuenta_id === 'cta-11.22').debe_moneda).toBe(1000);
    expect(l.find((x: any) => x.cuenta_id === 'cta-IVA_NO_DEDUCIBLE').debe_moneda).toBe(100);
  });

  it('no deducible con SUMAR_A_PRINCIPAL suma el IVA al gasto (lo de hoy)', async () => {
    const s = crearIntegracionMock(base(gasto({ deducible: false })), [], { IVA_NO_DEDUCIBLE: 'SUMAR_A_PRINCIPAL' });
    s.resolverCuentaPasivo = jest.fn().mockResolvedValue('cta-PROVEEDORES');
    await s.integrarGasto('g1');
    expect(lineas(s).find((x: any) => x.cuenta_id === 'cta-11.22').debe_moneda).toBe(1100);
  });
});
```

Despacho: agregar en `src/importaciones/__tests__/importacion-contable-fase2.e2e.spec.ts` (E2E contra base, ya existente) en el `it('acumula en la cuenta puente…')`: mapear `IMPORTACION_TRIBUTOS` a la puente (`asegurarMapeo(empresaId, 'IMPORTACION_TRIBUTOS', '1.1.4.04', …)`) y `IMPORTACION_ANTICIPO_IRE`; y un caso nuevo: sin `IMPORTACION_TRIBUTOS` mapeado el despacho no asienta y queda `CONT_FALTA_MAPEO` en `audit_logs`. Egreso imputado: el `it('el anticipo al proveedor del exterior va DIRECTO a importaciones en curso')` pasa a mapear `IMPORTACION_PAGO_PROVEEDOR`.

- [ ] **Step 2: Correr y ver que falla**

Run: `npx jest src/contabilidad/services/integracion-importaciones.spec.ts`
Expected: FAIL (va a `cta-INVENTARIO` / `cta-11.22`).

- [ ] **Step 3: Implementar**

Compra (dentro del `try` de cuentas, ~511): reemplazar `this.mapeo.getCuentaPorConcepto(empresaId, 'INVENTARIO')` por:

```ts
        this.cuentaCostoCompra(empresaId, compraId),
```

y agregar el helper:

```ts
  /** Una compra cargada a una importación va a donde el contador mapeó IMPORTACION_COMPRA. */
  private async cuentaCostoCompra(empresaId: string, compraId: string): Promise<string> {
    const deImportacion = await this.prisma.imp_componentes_costo.findFirst({
      where: { compra_id: compraId, activo: true },
      select: { id: true },
    });
    return this.mapeo.getCuentaPorConcepto(empresaId, deImportacion ? 'IMPORTACION_COMPRA' : 'INVENTARIO');
  }
```

Gasto (antes del armado de `debePorCuenta`, ~1146):

```ts
    // Cargado a una importación: el contador decide si va a su cuenta propia o
    // conserva la del tipo de gasto (SUMAR_A_PRINCIPAL).
    const deImportacion = await this.prisma.imp_componentes_costo.findFirst({
      where: { gasto_id: gastoId, activo: true },
      select: { id: true },
    });
    const destinoImportacion = deImportacion ? await this.mapeo.resolverConcepto(empresaId, 'IMPORTACION_GASTO') : null;
    const cuentaImportacion = destinoImportacion?.modo === 'CUENTA' ? destinoImportacion.cuentaId : null;

    // IVA de un gasto no deducible: a su cuenta o sumado al gasto.
    const destinoIvaNoDeducible = deducible ? null : await this.mapeo.resolverConcepto(empresaId, 'IVA_NO_DEDUCIBLE');
    const ivaAparte = destinoIvaNoDeducible?.modo === 'CUENTA' ? destinoIvaNoDeducible.cuentaId : null;
```

En el bucle de `gasto_det`:

```ts
      const cuentaGastoId = cuentaImportacion ?? det.tipo_gasto?.cuenta_contable_id ?? cuentaFallbackGasto;
      ...
      const monto = this.round((deducible || ivaAparte ? netoSinIva : subtotal) * tipoCambio, 2);
```

Después de las líneas de IVA deducible:

```ts
    if (ivaAparte && iva10 + iva5 > 0) {
      lineas.push({ cuenta_id: ivaAparte, debe_moneda: this.round(iva10 + iva5, 2), haber_moneda: 0, descripcion: 'IVA no deducible' });
    }
```

Nota: `cuentaFallbackGasto` (`GASTOS_GENERALES` cuando el tipo de gasto no tiene cuenta) **es** un concepto mapeado, no un respaldo silencioso: se mantiene (el catálogo ya lo muestra así).

Despacho (~756-762): reemplazar `const cuentaCosto = cPuente ?? cInventario;` por

```ts
    const cuentaCosto = await this.mapeo.getCuentaPorConcepto(empresaId, 'IMPORTACION_TRIBUTOS');
```

(dejar `cPuente` solo para decidir si se aplica el anticipo; quitar `cInventario` del `Promise.all` si queda sin uso). Línea de IRE (~808-822): reemplazar el bloque por

```ts
    if (noCostoGs > 0) {
      lineas.push({
        cuenta_id: await this.mapeo.getCuentaPorConcepto(empresaId, 'IMPORTACION_ANTICIPO_IRE'),
        debe_moneda: noCostoGs,
        haber_moneda: 0,
        descripcion: 'Anticipo IRE importación',
      });
    }
```

Descripción de la línea de costo: `'Costo de importación'`.

Movimiento de tesorería (~1724-1727): `'IMPORTACIONES_EN_CURSO'` → `'IMPORTACION_PAGO_PROVEEDOR'` y actualizar el comentario.

- [ ] **Step 4: Correr y ver que pasa**

Run: `npx jest src/contabilidad/services/integracion-importaciones.spec.ts src/contabilidad`
Expected: PASS. Si hay base local de prueba: `npx jest src/importaciones/__tests__/importacion-contable-fase2.e2e.spec.ts --runInBand` → PASS.

---

### Task 8: Cierre de importación por lo que entró a la puente + Conciliación del cierre

**Files:**
- Modify: `src/contabilidad/services/integracion.service.ts` (`integrarCierreImportacion` ~877-957)
- Modify: `src/contabilidad-conciliacion/registry.seed.ts`, `src/contabilidad-conciliacion/contabilidad-conciliacion.service.ts` (`resumen` ~308, `detalle` ~423)
- Test: `src/contabilidad/services/cierre-importacion.spec.ts` (nuevo)

**Interfaces:**
- Produces:
  - `private async saldoPuenteDeImportacion(empresaId: string, embarqueId: string, cuentaPuente: string): Promise<number>`
  - Registro `imp_cierre` (tabla `imp_embarques`, `filtro_extra: { estado: 'CERRADO' }`, método `integrarCierreImportacion`).
  - `ORIGENES_SOLO_CON_MAPEO: Record<string, string> = { imp_cierre: 'IMPORTACIONES_EN_CURSO' }` en el servicio de conciliación.

- [ ] **Step 1: Tests que fallan**

```ts
// src/contabilidad/services/cierre-importacion.spec.ts
import { crearIntegracionMock } from './__helpers__/integracion-mock';

const embarque = { id: 'e1', empresa_id: 'emp', numero: 'IMP-1', estado: 'CERRADO', costo_total_gs: 1000, usuario_id: 'u1', despacho: { id: 'd1', fecha_despacho: new Date() } };

const crear = (saldo: { debe: number; haber: number }) =>
  crearIntegracionMock({
    imp_embarques: { findUnique: jest.fn().mockResolvedValue(embarque) },
    imp_despachos: { findMany: jest.fn().mockResolvedValue([{ id: 'd1' }]) },
    imp_componentes_costo: { findMany: jest.fn().mockResolvedValue([{ compra_id: 'c1', gasto_id: null }, { compra_id: null, gasto_id: 'g1' }]), findFirst: jest.fn() },
    tes_movimientos: { findMany: jest.fn().mockResolvedValue([{ id: 't1' }]) },
    cont_documentos: {
      findFirst: jest.fn().mockResolvedValue(null),
      findMany: jest.fn().mockResolvedValue([{ id: 'doc-d1' }, { id: 'doc-c1' }]),
      create: jest.fn().mockResolvedValue({ id: 'doc-cierre' }),
    },
    cont_asientos: { findMany: jest.fn().mockResolvedValue([{ id: 'a1' }, { id: 'a2' }]) },
    cont_asientos_det: { aggregate: jest.fn().mockResolvedValue({ _sum: { debe_pyg: saldo.debe, haber_pyg: saldo.haber } }) },
  });

describe('cierre de importación', () => {
  it('traslada solo lo que entró a la cuenta puente', async () => {
    const s = crear({ debe: 800, haber: 0 });
    await s.integrarCierreImportacion('e1');
    const l = s.asientos.crearConfirmado.mock.calls[0][3].lineas;
    expect(l).toEqual([
      expect.objectContaining({ cuenta_id: 'cta-INVENTARIO', debe_moneda: 800 }),
      expect.objectContaining({ cuenta_id: 'cta-IMPORTACIONES_EN_CURSO', haber_moneda: 800 }),
    ]);
  });

  it('[RF-4] con saldo 0 (despacho revertido) no crea asiento', async () => {
    const s = crear({ debe: 500, haber: 500 });
    await s.integrarCierreImportacion('e1');
    expect(s.asientos.crearConfirmado).not.toHaveBeenCalled();
  });

  it('busca los documentos del despacho, compras, gastos y pagos de la importación', async () => {
    const s = crear({ debe: 800, haber: 0 });
    await s.integrarCierreImportacion('e1');
    const where = s.prisma.cont_documentos.findMany.mock.calls[0][0].where;
    expect(where.OR).toEqual(expect.arrayContaining([
      { origen_tipo: 'imp_despacho', origen_id: { in: ['d1'] } },
      { origen_tipo: 'compra_cab', origen_id: { in: ['c1'] } },
      { origen_tipo: 'gasto_cab', origen_id: { in: ['g1'] } },
      { origen_tipo: 'tes_movimientos', origen_id: { in: ['t1'] } },
    ]));
    expect(s.prisma.cont_asientos_det.aggregate.mock.calls[0][0].where).toEqual({ asiento_id: { in: ['a1', 'a2'] }, cuenta_id: 'cta-IMPORTACIONES_EN_CURSO' });
  });
});
```

- [ ] **Step 2: Correr y ver que falla**

Run: `npx jest src/contabilidad/services/cierre-importacion.spec.ts`
Expected: FAIL (usa `costo_total_gs` = 1000).

- [ ] **Step 3: Implementar**

En `integrarCierreImportacion`, reemplazar el cálculo de `costo`:

```ts
    // Se traslada lo que efectivamente entró a la puente por esta importación,
    // no el costeo: si el contador mandó una compra directo a Mercaderías, no se
    // vuelve a sumar. La diferencia contra el costeo la informa Salud contable.
    const costo = await this.saldoPuenteDeImportacion(empresaId, embarqueId, cPuente);
    if (costo <= 0) {
      this.logger.warn(`Embarque ${embarqueId}: la cuenta puente no tiene saldo de esta importación`);
      return;
    }
```

Helper:

```ts
  private async saldoPuenteDeImportacion(empresaId: string, embarqueId: string, cuentaPuente: string): Promise<number> {
    const [despachos, componentes, pagos] = await Promise.all([
      this.prisma.imp_despachos.findMany({ where: { embarque_id: embarqueId }, select: { id: true } }),
      this.prisma.imp_componentes_costo.findMany({
        where: { embarque_id: embarqueId, empresa_id: empresaId, activo: true },
        select: { compra_id: true, gasto_id: true },
      }),
      this.prisma.tes_movimientos.findMany({ where: { embarque_id: embarqueId, estado: { not: 'ANULADO' } }, select: { id: true } }),
    ]);
    const ids = (xs: Array<string | null>) => [...new Set(xs.filter((x): x is string => !!x))];
    const origenes = [
      { origen_tipo: 'imp_despacho', origen_id: { in: despachos.map((d) => d.id) } },
      { origen_tipo: 'compra_cab', origen_id: { in: ids(componentes.map((c) => c.compra_id)) } },
      { origen_tipo: 'gasto_cab', origen_id: { in: ids(componentes.map((c) => c.gasto_id)) } },
      { origen_tipo: 'tes_movimientos', origen_id: { in: pagos.map((p) => p.id) } },
    ].filter((o) => o.origen_id.in.length > 0);
    if (origenes.length === 0) return 0;

    const docs = await this.prisma.cont_documentos.findMany({
      where: { empresa_id: empresaId, OR: origenes },
      select: { id: true },
    });
    if (docs.length === 0) return 0;
    const asientos = await this.prisma.cont_asientos.findMany({
      where: { documento_id: { in: docs.map((d) => d.id) }, estado: 'CONFIRMADO' },
      select: { id: true },
    });
    if (asientos.length === 0) return 0;
    const agg = await this.prisma.cont_asientos_det.aggregate({
      where: { asiento_id: { in: asientos.map((a) => a.id) }, cuenta_id: cuentaPuente },
      _sum: { debe_pyg: true, haber_pyg: true },
    });
    return this.round(Number(agg._sum.debe_pyg ?? 0) - Number(agg._sum.haber_pyg ?? 0), 2);
  }
```

Actualizar el JSDoc del método (el monto ya no sale de `costo_total_gs`) y quitar `costo_total_gs` del `select` si queda sin uso (Salud contable lo lee por su cuenta).

Registro de conciliación (`registry.seed.ts`, después de `imp_despacho`):

```ts
  {
    origen_tipo: 'imp_cierre',
    descripcion: 'Cierre de importación (descarga de la cuenta puente)',
    modulo: 'IMPORTACIONES',
    tabla_origen: 'imp_embarques',
    campo_fecha: 'updated_at',
    campo_monto: 'costo_total_gs',
    campo_numero: 'numero',
    filtro_extra: { estado: 'CERRADO' },
    service_name: 'ContabilidadIntegracionService',
    service_method: 'integrarCierreImportacion',
    conceptos_req: ['IMPORTACIONES_EN_CURSO', 'INVENTARIO'],
    orden: 69,
  },
```

(Verificar con `awk '/^model imp_embarques \{/,/^\}/' prisma/schema.prisma` que existan `updated_at` y `numero`; si la fecha de cierre tiene campo propio, usarlo.)

En `contabilidad-conciliacion.service.ts`, arriba de la clase:

```ts
/**
 * Orígenes que solo existen si la empresa mapeó un concepto: sin cuenta puente
 * no hay asiento de cierre de importación, así que no es un pendiente.
 */
const ORIGENES_SOLO_CON_MAPEO: Record<string, string> = { imp_cierre: 'IMPORTACIONES_EN_CURSO' };
```

y en `resumen` y `detalle`, al recorrer entradas, saltear la que no aplique:

```ts
      const requiere = ORIGENES_SOLO_CON_MAPEO[entry.origen_tipo];
      if (requiere && !(await this.tieneMapeo(empresaId, requiere))) continue;
```

con

```ts
  private async tieneMapeo(empresaId: string, concepto: string): Promise<boolean> {
    const m = await this.prisma.cont_mapeo_cuentas.findUnique({
      where: { empresa_id_concepto: { empresa_id: empresaId, concepto } },
      select: { cuenta_id: true },
    });
    return !!m?.cuenta_id;
  }
```

(En `detalle`, si el origen pedido no aplica, devolver `{ items: [], total: 0 }`.)

- [ ] **Step 4: Correr y ver que pasa**

Run: `npx jest src/contabilidad/services/cierre-importacion.spec.ts src/contabilidad-conciliacion`
Expected: PASS.

---

### Task 9: Respaldos fuera del integrador (viáticos y RRHH)

**Files:**
- Modify: `src/rendicion-viaticos/rendicion-viaticos-contabilidad.service.ts` (~108-150, ~262-300, ~351, ~432)
- Modify: `src/rrhh/services/anticipos.service.ts` (~85-105), `acreditaciones-bancarias.service.ts` (~92-104), `reportes-ips.service.ts` (~90-100), `desvinculaciones.service.ts` (~140-220)
- Modify: `src/contabilidad/services/integracion.service.ts` (`integrarMovimientoTesoreria`, resolución por detalle ~1736-1790)
- Test: `src/contabilidad/services/movimiento-concepto-contable.spec.ts` (nuevo) + specs existentes de esos servicios si cubren la cuenta

**Interfaces:**
- Consumes: `tes_movimiento_det.concepto_contable` (Task 1), `conAvisoDeMapeo`, `FaltaMapeoError` (Tasks 2, 6), `AvisosMapeoService.registrarFaltaMapeo` (Task 4).
- Produces: los servicios de RRHH guardan `concepto_contable` en el detalle en lugar de resolver la cuenta; `integrarMovimientoTesoreria` resuelve `concepto_contable` sin respaldo.

- [ ] **Step 1: Test que falla**

```ts
// src/contabilidad/services/movimiento-concepto-contable.spec.ts
import { crearIntegracionMock } from './__helpers__/integracion-mock';

const mov = (det: any) => ({
  id: 'm1', empresa_id: 'emp', tipo: 'EGRESO', fecha: new Date('2026-10-13'), estado: 'CONFIRMADO', descripcion: 'Anticipo',
  embarque_id: null, tipo_pago_importacion: null, cuenta: { cuenta_contable_id: 'cta-banco' }, cuenta_id: 'tes1',
  detalles: [{ categoria_id: 'cat', monto: 100, cuenta_contable_id: null, categoria: { nombre: 'Anticipo', cuenta_contable_id: 'cta-categoria' }, ...det }],
});

it('un detalle con concepto se asienta con el concepto, no con la categoría', async () => {
  const s = crearIntegracionMock({
    tes_movimientos: { findUnique: jest.fn().mockResolvedValue(mov({ concepto_contable: 'DESCUENTOS_VARIOS_RRHH' })) },
    tes_categoria_cuenta_contable: { findMany: jest.fn().mockResolvedValue([]) },
  });
  await s.integrarMovimientoTesoreria('m1');
  expect(s.asientos.crearConfirmado.mock.calls[0][3].lineas[0].cuenta_id).toBe('cta-DESCUENTOS_VARIOS_RRHH');
});

it('sin el concepto mapeado no cae a la categoría: queda pendiente y avisa', async () => {
  const s = crearIntegracionMock({
    tes_movimientos: { findUnique: jest.fn().mockResolvedValue(mov({ concepto_contable: 'SUELDOS_A_PAGAR' })) },
    tes_categoria_cuenta_contable: { findMany: jest.fn().mockResolvedValue([]) },
  }, ['SUELDOS_A_PAGAR']);
  await s.integrarMovimientoTesoreria('m1');
  expect(s.asientos.crearConfirmado).not.toHaveBeenCalled();
  expect(s.avisosMapeo.registrarFaltaMapeo.mock.calls[0][0]).toMatchObject({ origenTipo: 'tes_movimientos', origenId: 'm1', conceptos: ['SUELDOS_A_PAGAR'] });
});
```

(Ajustar los nombres de campos del mock a lo que `integrarMovimientoTesoreria` lee realmente: leer el método entero antes, ~1677-1830.)

- [ ] **Step 2: Correr y ver que falla**

Run: `npx jest src/contabilidad/services/movimiento-concepto-contable.spec.ts`
Expected: FAIL (usa `cta-categoria`).

- [ ] **Step 3: Implementar**

`integrarMovimientoTesoreria`: antes de los dos bucles que calculan `ccat`, resolver los conceptos de una vez (juntando faltantes):

```ts
    const conceptos = [...new Set(detalles.map((d) => d.concepto_contable).filter((c): c is string => !!c))];
    const cuentaPorConcepto = new Map<string, string>();
    const faltan: string[] = [];
    for (const c of conceptos) {
      try {
        cuentaPorConcepto.set(c, await this.mapeo.getCuentaPorConcepto(empresaId, c));
      } catch (e) {
        if (e instanceof FaltaMapeoError) faltan.push(c);
        else throw e;
      }
    }
    if (faltan.length) throw new FaltaMapeoError(empresaId, faltan);
```

y en ambos bucles:

```ts
      const ccat =
        cuentaImportacionId ??
        det.cuenta_contable_id ??
        (det.concepto_contable ? cuentaPorConcepto.get(det.concepto_contable) : undefined) ??
        mapeoIndex[det.categoria_id] ??
        det.categoria?.cuenta_contable_id;
```

(Agregar `concepto_contable` al `select`/`include` de `detalles` si el método no trae todos los campos.)

Servicios RRHH — en vez de resolver la cuenta, guardar el concepto. `anticipos.service.ts` (~93-102): borrar el bucle de conceptos y el respaldo a la categoría; en el `create` del detalle poner `concepto_contable: 'DESCUENTOS_VARIOS_RRHH'` y `cuenta_contable_id: null`. Mismo patrón:
- `acreditaciones-bancarias.service.ts`: `concepto_contable: 'SUELDOS_A_PAGAR'`.
- `reportes-ips.service.ts`: `concepto_contable: 'IPS_A_DEPOSITAR'`.
- `desvinculaciones.service.ts`: cada componente con monto > 0 crea su detalle con `concepto_contable: <concepto del componente>` (en lugar de `tryMapeo` y omitir la línea). Leer el método (~140-230) entero: si hoy netea descuentos contra componentes, conservar los montos y solo cambiar cómo se identifica la cuenta.

Comentarios: reemplazar los que explican el respaldo ("ANTICIPO_PERSONAL queda de respaldo…") por una línea que diga que la cuenta la decide el mapeo del concepto y que sin mapeo el movimiento queda pendiente con aviso.

Viáticos (`rendicion-viaticos-contabilidad.service.ts`): los cuatro bloques `try { ANTICIPO_VIATICO } catch { try { ANTICIPO_PERSONAL } … }` pasan a `await this.mapeo.getCuentaPorConcepto(empresaId, 'ANTICIPO_VIATICO')` sin respaldo; `(await …('BANCO')) ?? (await …('CAJA_GENERAL'))` pasa a `await this.mapeo.getCuentaPorConcepto(empresaId, 'BANCO')`. Los `catch` que hoy loguean y omiten el asiento: si el error es `FaltaMapeoError`, llamar `this.avisosMapeo.registrarFaltaMapeo({ empresaId, origenTipo: 'rendicion_adelanto' | 'rendicion_devolucion' | <el origen del bloque>, origenId, conceptos: e.conceptos })` y salir sin asiento (inyectar `AvisosMapeoService`; el módulo de viáticos debe importar `ContabilidadModule` o el módulo que lo exporte — verificar con `rtk proxy grep -n "imports" src/rendicion-viaticos/*.module.ts`). Agregar `rendicion_adelanto` y `rendicion_devolucion` a `ORIGENES` de `avisos-mapeo.service.ts` con su tabla y campo de usuario (ver `registry.seed.ts` ~62-88 para la tabla).

- [ ] **Step 4: Correr y ver que pasa**

Run: `npx jest src/contabilidad src/rrhh src/rendicion-viaticos`
Expected: PASS (ajustar specs existentes de RRHH que verificaban `cuenta_contable_id` del detalle: ahora verifican `concepto_contable`).

---

### Task 10: Conciliación — causa `FALTA_MAPEO` y controles de Salud contable

**Files:**
- Modify: `src/contabilidad-conciliacion/causa-pendiente.ts`, `causa-pendiente.spec.ts`
- Modify: `src/contabilidad-conciliacion/contabilidad-conciliacion.service.ts` (`explicarPendientes` ~526-657)
- Modify: `src/contabilidad-conciliacion/salud-contable.service.ts`, `salud-contable.service.spec.ts`

**Interfaces:**
- Consumes: `ACCION_FALTA_MAPEO` (Task 4), `describirRecomendacion` (Task 2).
- Produces:
  - `EvidenciaPendiente.faltaMapeo?: { conceptos: string[]; recomendaciones: Record<string, string> } | null`
  - `ExplicacionPendiente.conceptos?: string[]` (para el botón a Mapeo)
  - Controles: `saldo_acreedor_activo` incluye cuentas de `IMPORTACIONES_EN_CURSO`/`ANTICIPO_DESPACHO`; nuevos `importacion_cierre_diferencia`, `mapeo_pendiente`.

- [ ] **Step 1: Tests que fallan**

En `causa-pendiente.spec.ts`:

```ts
it('falta de mapeo gana sobre un intento fallido y dice qué mapear', () => {
  const r = explicarPendiente({
    creadoEn: new Date('2026-10-10'), activacionContabilidad: new Date('2026-01-01'), origenTipo: null,
    mapeosPosteriores: [], ultimoIntento: { fecha: new Date('2026-10-11'), error: 'otro' },
    faltaMapeo: { conceptos: ['IMPORTACION_COMPRA'], recomendaciones: { IMPORTACION_COMPRA: '1.01.04.11 IMPORTACIONES EN CURSO' } },
  });
  expect(r.codigo).toBe('FALTA_MAPEO');
  expect(r.texto).toMatch(/IMPORTACION_COMPRA/);
  expect(r.texto).toMatch(/1\.01\.04\.11/);
  expect(r.conceptos).toEqual(['IMPORTACION_COMPRA']);
});
```

En `salud-contable.service.spec.ts` (siguiendo su armado existente): un caso con la cuenta mapeada en `IMPORTACIONES_EN_CURSO` (código `1.01.04.11`, fuera de los prefijos 1.01.01/1.01.03) con saldo −507.271.894 → el control de saldo acreedor da `ERROR` y lista esa cuenta; un caso de `mapeo_pendiente` con 2 conceptos frenando → `ERROR` con ruta a Mapeo.

- [ ] **Step 2: Correr y ver que fallan**

Run: `npx jest src/contabilidad-conciliacion/causa-pendiente.spec.ts src/contabilidad-conciliacion/salud-contable.service.spec.ts`
Expected: FAIL.

- [ ] **Step 3: Implementar**

`causa-pendiente.ts`: agregar `'FALTA_MAPEO'` al tipo; `conceptos?: string[]` a `ExplicacionPendiente`; `faltaMapeo?` a `EvidenciaPendiente`; en `explicarPendiente`, como **primer** chequeo después de `ANTERIOR_A_CONTABILIDAD` e `IMPORTADO`:

```ts
  if (e.faltaMapeo && e.faltaMapeo.conceptos.length > 0) {
    const detalle = e.faltaMapeo.conceptos
      .map((c) => (e.faltaMapeo!.recomendaciones[c] ? `${c} (recomendado: ${e.faltaMapeo!.recomendaciones[c]})` : c))
      .join(', ');
    return {
      codigo: 'FALTA_MAPEO',
      texto: `No se contabilizó porque falta mapear ${detalle}. El sistema no elige cuentas por su cuenta: mapealo y regenerá desde acá.`,
      conceptos: e.faltaMapeo.conceptos,
    };
  }
```

`explicarPendientes`: sumar una consulta a `audit_logs` con `action: ACCION_FALTA_MAPEO`, `entity_type: entry.origen_tipo`, `entity_id: { in: ids }` (último por id), quedarse solo con los conceptos que **siguen** sin mapeo usable (consultar `cont_mapeo_cuentas` de la empresa), resolver recomendaciones con `describirRecomendacion` y pasar `faltaMapeo` a `explicarPendiente`.

`salud-contable.service.ts`:
- En el control que usa `PREFIJOS_ACTIVO_SIN_SALDO_ACREEDOR`, además de los prefijos incluir las cuentas mapeadas en `IMPORTACIONES_EN_CURSO` y `ANTICIPO_DESPACHO` (consultar `cont_mapeo_cuentas` de esos dos conceptos; `como_resolver`: "Una cuenta transitoria de activo no puede quedar en negativo: hay cancelaciones sin su ingreso. En importaciones, revisá que compras, gastos y pagos estén cargados a la importación con su concepto de mapeo.").
- Nuevo `importacion_cierre_diferencia` (`ALERTA`): para cada `imp_embarques` CERRADO con documento `imp_cierre`, comparar el haber del asiento de cierre en la puente con `costo_total_gs` (sin IVA); listar los que difieren en más de `TOLERANCIA_GS`.
- Nuevo `mapeo_pendiente` (`ERROR` si hay conceptos frenando documentos, `ALERTA` si solo hay mapeos sin confirmar, `OK` si nada): reutilizar la lógica de `AvisosMapeoService` exponiendo un método público `resumenPendiente(empresaId): Promise<{ frenando: Map<string, number>; sinConfirmar: number }>` (refactor: `conceptosFrenando` pasa a ser usado por este método; inyectar `AvisosMapeoService` en `SaludContableService` y agregar `ContabilidadModule` a los imports del módulo de conciliación si no está). `ruta`: `/contabilidad?tab=mapeo`.

- [ ] **Step 4: Correr y ver que pasa**

Run: `npx jest src/contabilidad-conciliacion`
Expected: PASS.

---

### Task 11: Catálogo de asientos — recomendación en lugar de respaldo, conceptos nuevos

**Files:**
- Modify: `src/contabilidad/services/catalogo-asientos.ts`, `src/contabilidad/services/mapeo-cuentas.service.ts` (`previsualizacionAsientos`), `src/contabilidad/services/catalogo-asientos.spec.ts`

**Interfaces:**
- Consumes: `describirRecomendacion` (Task 2).
- Produces: cada línea del catálogo devuelve `recomendacion: { texto, codigo } | null` y ya no `respaldo`, `respaldo_dinamico`, `concepto_respaldo`. `LineaCatalogo` pierde `respaldo`/`respaldoDinamico`.

- [ ] **Step 1: Tests que fallan** (reemplazan el `describe('una línea sin su concepto cae a la cuenta que usa el integrador')` agregado el 2026-10-13)

```ts
  describe('sin respaldo: la línea sin mapear muestra la recomendación', () => {
    const linea = (r: any, clave: string, concepto: string) =>
      r.situaciones.find((s: any) => s.clave === clave).lineas.find((l: any) => l.concepto === concepto);

    it('la compra de importación sin mapear es una falta con la cuenta recomendada', async () => {
      const r = await crear([{ concepto: 'IMPORTACIONES_EN_CURSO', codigo: '1.01.04.11', descripcion: 'Importaciones en curso' }]).previsualizacionAsientos('emp');
      const l = linea(r, 'COMPRA_IMPORTACION', 'IMPORTACION_COMPRA');
      expect(l.sin_mapear).toBe(true);
      expect(l.recomendacion.codigo).toBe('1.01.04.11');
    });

    it('el cheque sin CHEQUES_EN_CARTERA ya no cae a caja', async () => {
      const r = await crear([{ concepto: 'CAJA_GENERAL', codigo: '1.01.01.01', descripcion: 'Caja' }]).previsualizacionAsientos('emp');
      expect(linea(r, 'VENTA_CONTADO', 'CHEQUES_EN_CARTERA').sin_mapear).toBe(true);
    });
  });
```

- [ ] **Step 2: Correr y ver que falla**

Run: `npx jest src/contabilidad/services/catalogo-asientos.spec.ts`
Expected: FAIL.

- [ ] **Step 3: Implementar**

`catalogo-asientos.ts`:
- Quitar `respaldo` y `respaldoDinamico` de `LineaCatalogo` y de todas las líneas (`rtk proxy grep -n "respaldo" src/contabilidad/services/catalogo-asientos.ts`).
- `DESPACHO_IMPORTACION`, base y variante: debe de costo → `concepto: 'IMPORTACION_TRIBUTOS'`; IRE → `concepto: 'IMPORTACION_ANTICIPO_IRE'`; en la variante la contrapartida sigue `ANTICIPO_DESPACHO` con `condicion: 'Si no hay anticipo de despacho pagado, va a la cuenta del proveedor del embarque'`.
- `PAGO_IMPORTACION_PROVEEDOR`: debe → `IMPORTACION_PAGO_PROVEEDOR`.
- Nuevas situaciones (grupo Compras / Gastos):

```ts
  {
    clave: 'COMPRA_IMPORTACION',
    grupo: 'Compras',
    titulo: 'Factura de compra cargada a una importación',
    cuando: 'Al confirmarse una compra que es componente de costo de una importación (p. ej. la factura del exterior)',
    documento: 'Factura de compra',
    lineas: [
      { lado: 'DEBE', concepto: 'IMPORTACION_COMPRA', etiqueta: 'Costo de la importación (sin IVA)', monto: BASE_10 },
      { lado: 'DEBE', concepto: 'IVA_CREDITO_10', etiqueta: 'IVA crédito 10%', monto: IVA_10, condicion: 'Solo si la factura tiene IVA' },
      { lado: 'HABER', fuente: 'CUENTA_PROVEEDOR', cuentaDinamica: 'Cuenta del proveedor; si no tiene una propia, la de su tipo', etiqueta: 'Deuda con el proveedor', monto: TOTAL },
    ],
    nota: 'Si esta cuenta y la del pago al proveedor de la importación son la misma, el costo del proveedor entra dos veces: elegí un esquema (ver Mapeo).',
  },
  {
    clave: 'GASTO_IMPORTACION',
    grupo: 'Gastos',
    titulo: 'Gasto cargado a una importación',
    cuando: 'Al confirmarse un gasto que es componente de costo de una importación (flete, despachante…)',
    documento: 'Gasto',
    lineas: [
      { lado: 'DEBE', concepto: 'IMPORTACION_GASTO', etiqueta: 'Costo de la importación (o la cuenta del tipo de gasto, si así se eligió)', monto: BASE_10 },
      { lado: 'DEBE', concepto: 'IVA_CREDITO_10', etiqueta: 'IVA crédito 10%', monto: IVA_10, condicion: 'Solo si el gasto tiene IVA deducible' },
      { lado: 'HABER', concepto: 'CAJA_GENERAL', etiqueta: 'Contrapartida según cómo se pagó', monto: TOTAL },
    ],
  },
```

- `GASTO`: agregar la línea `{ lado: 'DEBE', concepto: 'IVA_NO_DEDUCIBLE', etiqueta: 'IVA no deducible (o sumado al gasto, si así se eligió)', monto: 0, condicion: 'Solo si el gasto no es deducible' }`.

`previsualizacionAsientos` (`armarLinea`): quitar la lógica de `respaldo`; agregar `recomendacion: linea.concepto ? describirRecomendacion(linea.concepto, cuentaDeConcepto) : null`. Una línea cuyo concepto tiene modo `SUMAR_A_PRINCIPAL` mapeado: `cuenta: null`, `cuenta_dinamica: 'Se suma a la cuenta principal'`, `sin_mapear: false` (agregar `modo` al `select` de mapeos y un `Map` concepto→modo). Las situaciones nuevas no llevan `soloSiMapeado` (aplican siempre que haya importaciones).

- [ ] **Step 4: Correr y ver que pasa**

Run: `npx jest src/contabilidad/services/catalogo-asientos.spec.ts`
Expected: PASS (los tests de respaldo del 2026-10-13 se reemplazaron en el Step 1).

---

### Task 12: Script de precarga

**Files:**
- Create: `scripts/data_script/precarga-mapeo-sin-decisiones.ts`
- Test: `scripts/data_script/precarga-mapeo-sin-decisiones.spec.ts` (función pura de decisión)

**Interfaces:**
- Produces: `decidirPrecarga(mapeados: Map<string, { cuentaId: string | null; modo: string }>, ctx: { cuentaCategoria: Record<string, string | null> }): Array<{ concepto: string; cuentaId: string | null; modo: 'CUENTA' | 'SUMAR_A_PRINCIPAL' }>`

- [ ] **Step 1: Test que falla**

```ts
// scripts/data_script/precarga-mapeo-sin-decisiones.spec.ts
import { decidirPrecarga } from './precarga-mapeo-sin-decisiones';

const m = (o: Record<string, string>) => new Map(Object.entries(o).map(([k, v]) => [k, { cuentaId: v, modo: 'CUENTA' }]));
const sinCategorias = { cuentaCategoria: { ANTICIPO: null, PAGO_SUELDOS: null, PAGO_IPS: null } };

it('reproduce lo que hace hoy el código, sin pisar lo mapeado', () => {
  const r = decidirPrecarga(m({ CAJA_GENERAL: 'caja', INVENTARIO: 'inv', IMPORTACIONES_EN_CURSO: 'puente', PROVEEDORES: 'prov', CHEQUES_EN_CARTERA: 'cart', RETENCION_RENTA_FAVOR: 'ire', ANTICIPO_PERSONAL: 'antp' }), sinCategorias);
  const de = (c: string) => r.find((x) => x.concepto === c);
  expect(de('CHEQUES_EN_CARTERA')).toBeUndefined(); // ya mapeado
  expect(de('CHEQUES_EN_TRANSITO')).toEqual({ concepto: 'CHEQUES_EN_TRANSITO', cuentaId: 'cart', modo: 'CUENTA' });
  expect(de('CHEQUES_A_PAGAR')?.cuentaId).toBe('caja');
  expect(de('PAGO_COMISIONES_FONDOS')?.cuentaId).toBe('caja');
  expect(de('PROVEEDORES_EXTERIOR')?.cuentaId).toBe('prov');
  expect(de('ACREEDORES_VARIOS')?.cuentaId).toBe('prov');
  expect(de('IMPORTACION_COMPRA')?.cuentaId).toBe('inv');
  expect(de('IMPORTACION_GASTO')).toEqual({ concepto: 'IMPORTACION_GASTO', cuentaId: null, modo: 'SUMAR_A_PRINCIPAL' });
  expect(de('IMPORTACION_PAGO_PROVEEDOR')?.cuentaId).toBe('puente');
  expect(de('IMPORTACION_TRIBUTOS')?.cuentaId).toBe('puente');
  expect(de('IMPORTACION_ANTICIPO_IRE')?.cuentaId).toBe('ire');
  expect(de('IVA_NO_DEDUCIBLE')?.modo).toBe('SUMAR_A_PRINCIPAL');
  expect(de('ANTICIPO_VIATICO')?.cuentaId).toBe('antp');
  expect(de('ANTICIPO_DESPACHO')).toBeUndefined();
});

it('sin cuenta puente, tributos e IRE van a inventario y no se precarga el pago al proveedor', () => {
  const r = decidirPrecarga(m({ CAJA_GENERAL: 'caja', INVENTARIO: 'inv' }), sinCategorias);
  const de = (c: string) => r.find((x) => x.concepto === c);
  expect(de('IMPORTACION_TRIBUTOS')?.cuentaId).toBe('inv');
  expect(de('IMPORTACION_ANTICIPO_IRE')?.cuentaId).toBe('inv');
  expect(de('IMPORTACION_PAGO_PROVEEDOR')).toBeUndefined();
});

it('es idempotente: con todo precargado no propone nada', () => {
  const primera = decidirPrecarga(m({ CAJA_GENERAL: 'caja', INVENTARIO: 'inv', PROVEEDORES: 'prov' }), sinCategorias);
  const todo = new Map([...m({ CAJA_GENERAL: 'caja', INVENTARIO: 'inv', PROVEEDORES: 'prov' }), ...primera.map((p) => [p.concepto, { cuentaId: p.cuentaId, modo: p.modo }] as const)]);
  expect(decidirPrecarga(todo, sinCategorias)).toEqual([]);
});
```

- [ ] **Step 2: Correr y ver que falla**

Run: `npx jest scripts/data_script/precarga-mapeo-sin-decisiones.spec.ts`
Expected: FAIL (módulo no existe). Si jest no toma `scripts/`, correr con `npx jest --rootDir . scripts/data_script/precarga-mapeo-sin-decisiones.spec.ts`.

- [ ] **Step 3: Implementar** (patrón one-shot con PrismaClient directo, sin AppModule)

```ts
// scripts/data_script/precarga-mapeo-sin-decisiones.ts
/**
 * Precarga de la regla "el contador decide las cuentas" (spec 2026-10-13).
 *
 * Para cada empresa con Contabilidad, completa los conceptos nuevos y los que
 * antes tenían respaldo con la cuenta que el código usaba hasta hoy, marcados
 * PRECARGA sin confirmar. Así ningún asiento cambia el día del despliegue y el
 * contador ve y confirma cada decisión. Idempotente: no pisa lo ya mapeado.
 *
 * Uso: npx ts-node -T scripts/data_script/precarga-mapeo-sin-decisiones.ts [--dry] [--empresa <uuid>]
 */
import { PrismaClient } from '@prisma/client';

type Mapeado = Map<string, { cuentaId: string | null; modo: string }>;
type Propuesta = { concepto: string; cuentaId: string | null; modo: 'CUENTA' | 'SUMAR_A_PRINCIPAL' };

export function decidirPrecarga(mapeados: Mapeado, ctx: { cuentaCategoria: Record<string, string | null> }): Propuesta[] {
  const cuenta = (c: string) => mapeados.get(c)?.cuentaId ?? null;
  const propuestas: Propuesta[] = [];
  const proponer = (concepto: string, cuentaId: string | null) => {
    if (mapeados.has(concepto) || !cuentaId) return;
    propuestas.push({ concepto, cuentaId, modo: 'CUENTA' });
  };
  const proponerSumar = (concepto: string) => {
    if (mapeados.has(concepto)) return;
    propuestas.push({ concepto, cuentaId: null, modo: 'SUMAR_A_PRINCIPAL' });
  };

  // Respaldos que desaparecen: la cuenta a la que caían.
  proponer('CHEQUES_EN_CARTERA', cuenta('CAJA_GENERAL'));
  proponer('CHEQUES_EN_TRANSITO', cuenta('CHEQUES_EN_CARTERA') ?? cuenta('CAJA_GENERAL'));
  proponer('CHEQUES_A_PAGAR', cuenta('CAJA_GENERAL'));
  proponer('PAGO_COMISIONES_FONDOS', cuenta('CAJA_GENERAL'));
  proponer('PROVEEDORES_EXTERIOR', cuenta('PROVEEDORES'));
  proponer('ACREEDORES_VARIOS', cuenta('PROVEEDORES'));
  proponer('ANTICIPO_VIATICO', cuenta('ANTICIPO_PERSONAL'));
  proponer('DESCUENTOS_VARIOS_RRHH', cuenta('ANTICIPO_PERSONAL') ?? ctx.cuentaCategoria.ANTICIPO);
  proponer('SUELDOS_A_PAGAR', ctx.cuentaCategoria.PAGO_SUELDOS);
  proponer('IPS_A_DEPOSITAR', ctx.cuentaCategoria.PAGO_IPS);

  // Conceptos nuevos: lo que hacía el código.
  const puente = cuenta('IMPORTACIONES_EN_CURSO');
  const tributos = puente ?? cuenta('INVENTARIO');
  proponer('IMPORTACION_COMPRA', cuenta('INVENTARIO'));
  proponerSumar('IMPORTACION_GASTO');
  proponer('IMPORTACION_PAGO_PROVEEDOR', puente);
  proponer('IMPORTACION_TRIBUTOS', tributos);
  proponer('IMPORTACION_ANTICIPO_IRE', cuenta('RETENCION_RENTA_FAVOR') ?? tributos);
  proponerSumar('IVA_NO_DEDUCIBLE');

  return propuestas;
}

async function main() {
  const dry = process.argv.includes('--dry');
  const i = process.argv.indexOf('--empresa');
  const soloEmpresa = i > -1 ? process.argv[i + 1] : null;
  const prisma = new PrismaClient();
  try {
    const empresas = await prisma.suscripcion_modulos.findMany({
      where: { activo: true, modulos: { codigo: 'CONTABILIDAD' }, ...(soloEmpresa ? { suscripciones: { empresa_id: soloEmpresa } } : {}) },
      select: { suscripciones: { select: { empresa_id: true } } },
    });
    const ids = [...new Set(empresas.map((e) => e.suscripciones?.empresa_id).filter((v): v is string => !!v))];

    for (const empresaId of ids) {
      const filas = await prisma.cont_mapeo_cuentas.findMany({ where: { empresa_id: empresaId }, select: { concepto: true, cuenta_id: true, modo: true } });
      const mapeados: Mapeado = new Map(filas.map((f) => [f.concepto, { cuentaId: f.cuenta_id, modo: f.modo }]));
      const categoria = async (nombre: string) => {
        const c = await prisma.tes_categorias.findFirst({
          where: { nombre: { equals: nombre, mode: 'insensitive' }, OR: [{ empresa_id: empresaId }, { empresa_id: null }] },
          select: { id: true, cuenta_contable_id: true },
        });
        if (!c) return null;
        const propio = await prisma.tes_categoria_cuenta_contable.findFirst({ where: { empresa_id: empresaId, categoria_id: c.id }, select: { cuenta_contable_id: true } });
        return propio?.cuenta_contable_id ?? c.cuenta_contable_id ?? null;
      };
      const propuestas = decidirPrecarga(mapeados, {
        cuentaCategoria: {
          ANTICIPO: await categoria('Anticipo de Sueldo'),
          PAGO_SUELDOS: await categoria('Pago de Sueldos'),
          PAGO_IPS: await categoria('Pago IPS'),
        },
      });
      console.log(`${empresaId}: ${propuestas.length} conceptos a precargar`);
      for (const p of propuestas) console.log(`  ${p.concepto} → ${p.modo === 'CUENTA' ? p.cuentaId : 'sumar a la principal'}`);
      if (dry || propuestas.length === 0) continue;
      await prisma.cont_mapeo_cuentas.createMany({
        data: propuestas.map((p) => ({ empresa_id: empresaId, concepto: p.concepto, cuenta_id: p.cuentaId, modo: p.modo, origen: 'PRECARGA' })),
        skipDuplicates: true,
      });
    }
  } finally {
    await prisma.$disconnect();
  }
}

if (require.main === module) {
  main().catch((e) => {
    console.error(e);
    process.exit(1);
  });
}
```

Antes de correrlo, confirmar los nombres reales de las categorías de tesorería que usan `anticipos.service.ts`, `acreditaciones-bancarias.service.ts` y `reportes-ips.service.ts` (buscar el `findFirst` de `tes_categorias` en cada uno) y reemplazar los tres literales.

- [ ] **Step 4: Correr el test y un dry-run contra la base local**

Run: `npx jest scripts/data_script/precarga-mapeo-sin-decisiones.spec.ts && npx ts-node -T scripts/data_script/precarga-mapeo-sin-decisiones.ts --dry --empresa 40539a9d-ffcc-48c7-b932-5bb08b0828ac`
Expected: PASS y la lista de DOBA local (p. ej. `IMPORTACION_COMPRA → <id de 1.01.04.01.01>`, `IMPORTACION_TRIBUTOS → <id de 1.01.04.11>`).

- [ ] **Step 5: Verificar "ningún asiento cambia"** — en la base local: correr la precarga real para DOBA y simular la recontabilización de un documento de cada tipo con "Rehacer asientos → Simular" (Conciliación) o el endpoint de simulación; esperado: sin diferencias. Anotar el resultado en el reporte de la tarea.

---

### Task 13: Frontend — pantalla de Mapeo

**Files:**
- Modify: `novasispy-erp/src/components/contabilidad/MapeoCuentasTab.jsx`
- Modify: `novasispy-erp/src/tanstack/ContabilidadStack.jsx` y el archivo de API donde está `getMapeoCuentas` (buscar con `rtk proxy grep -rn "export const getMapeoCuentas" src`)

**Interfaces:**
- Consumes: `GET contabilidad/mapeo-cuentas` (campos de Task 5), `PUT` con `modo`, `POST contabilidad/mapeo-cuentas/confirmar`.
- Produces: `useConfirmarMapeoMutation()` en `ContabilidadStack.jsx` (invalida `mapeo-cuentas` y `asientos-ejemplo`).

- [ ] **Step 1: API y mutación**

```js
// en el archivo de API de contabilidad, junto a getMapeoCuentas
export const confirmarMapeoCuentas = async () => (await api.post("/contabilidad/mapeo-cuentas/confirmar")).data;
```

```js
// ContabilidadStack.jsx
export const useConfirmarMapeoMutation = () => {
  const queryClient = useQueryClient();
  return useMutation({
    mutationFn: () => confirmarMapeoCuentas(),
    onSuccess: () => {
      queryClient.invalidateQueries({ queryKey: ["mapeo-cuentas"] });
      queryClient.invalidateQueries({ queryKey: ["asientos-ejemplo"] });
    },
  });
};
```

(usar el mismo cliente `api` y estilo que `getMapeoCuentas`.)

- [ ] **Step 2: Conceptos nuevos en `CONCEPTOS`**

En el grupo `Importaciones` (línea ~58), después de `ANTICIPO_DESPACHO`:

```js
      { key: "IMPORTACION_COMPRA",         label: "Compra cargada a una importación",      icon: "lucide:file-text" },
      { key: "IMPORTACION_GASTO",          label: "Gasto cargado a una importación",        icon: "lucide:receipt", conModo: true },
      { key: "IMPORTACION_PAGO_PROVEEDOR", label: "Pago al proveedor de la importación",    icon: "lucide:banknote" },
      { key: "IMPORTACION_TRIBUTOS",       label: "Tributos y gastos del despacho",         icon: "lucide:landmark" },
      { key: "IMPORTACION_ANTICIPO_IRE",   label: "Anticipo de IRE del despacho",           icon: "lucide:percent" },
```

Actualizar el comentario del grupo: ya no "son OPCIONALES"; `IMPORTACIONES_EN_CURSO` activa el cierre de la importación y los `IMPORTACION_*` deciden a dónde va cada costo. En el grupo Gastos: `{ key: "IVA_NO_DEDUCIBLE", label: "IVA no deducible", icon: "lucide:percent", conModo: true }`. Verificar que los conceptos con respaldo eliminado (`CHEQUES_A_PAGAR`, `PAGO_COMISIONES_FONDOS`, `PROVEEDORES_EXTERIOR`, `ACREEDORES_VARIOS`, `ANTICIPO_VIATICO`, `SUELDOS_A_PAGAR`, `IPS_A_DEPOSITAR`, `DESCUENTOS_VARIOS_RRHH`, `CHEQUES_EN_TRANSITO`) estén en algún grupo; si alguno falta, agregarlo en el grupo que corresponda.

- [ ] **Step 3: Estado, recomendación y modo por concepto**

Donde se renderiza cada concepto (buscar el map que usa `currentMap[key]`, ~391), debajo del selector de cuenta:

```jsx
{(() => {
  const fila = mapeosPorConcepto.get(item.key); // Map concepto → fila del GET (crear con useMemo a partir de `mapeos`)
  const estado = !fila
    ? { texto: "Sin mapear", tono: "error" }
    : !fila.confirmado_at
      ? { texto: "Cargado por el sistema — sin confirmar", tono: "alerta" }
      : fila.distinto_de_recomendacion
        ? { texto: `Confirmado por ${fila.confirmado_por_nombre ?? "—"} · distinto de lo recomendado`, tono: "info" }
        : { texto: `Confirmado por ${fila.confirmado_por_nombre ?? "—"}`, tono: "ok" };
  return (
    <EstadoMapeo $tono={estado.tono}>
      {estado.texto}
      {fila?.recomendacion && (
        <Recomendado>
          Recomendado: {fila.recomendacion.texto}
          {fila.recomendacion.codigo && (
            <button type="button" onClick={() => usarRecomendacion(item.key, fila.recomendacion.codigo)}>Usar</button>
          )}
        </Recomendado>
      )}
    </EstadoMapeo>
  );
})()}
```

`usarRecomendacion(key, codigo)`: busca en `cuentas` la de ese código y la pone en `localMap[key]` (mismo setter que el selector). Para conceptos sin fila (sin mapear), la recomendación viene del catálogo: agregar al `GET` de Task 5 las recomendaciones de conceptos sin fila es más simple — en `listar` devolver también `recomendaciones: Record<concepto, {texto, codigo}>` para todos los conceptos de `RECOMENDACIONES`, y usar esa cuando no hay fila.

Para `item.conModo`: un selector de dos opciones con el componente estándar de selección del kit (`Seleccion` de `_standards`), "Una cuenta" / "Sumar a la cuenta principal"; con la segunda, el selector de cuenta se oculta y `localMap[key] = "__SUMAR__"`. En `handleGuardar` (~287), armar el payload:

```js
const payload = Object.entries(currentMap)
  .filter(([concepto]) => cambiados.has(concepto)) // conservar el filtro actual
  .map(([concepto, valor]) =>
    valor === "__SUMAR__" ? { concepto, cuenta_id: null, modo: "SUMAR_A_PRINCIPAL" } : { concepto, cuenta_id: valor, modo: "CUENTA" },
  );
```

(adaptar a cómo arma hoy el payload; `currentMap` para filas con `modo === "SUMAR_A_PRINCIPAL"` debe inicializarse en `"__SUMAR__"`.)

- [ ] **Step 4: Confirmar todo y advertencia de doble ingreso**

Arriba de la lista (junto a `SaveBtn`, ~353): si hay filas con `!confirmado_at`, un banner con el estándar `InlineValidationBanner` (o el aviso informativo del kit) que diga "N cuentas las cargó el sistema con lo que hacía hasta hoy. Revisalas y confirmalas: la elección queda registrada a tu nombre." y un botón "Confirmar todo" → `useConfirmarMapeoMutation().mutate()`; deshabilitado si `dirty` (primero guardar).

Advertencia: si `currentMap.IMPORTACION_COMPRA` y `currentMap.IMPORTACION_PAGO_PROVEEDOR` son la misma cuenta (y no vacías), mostrar en el grupo Importaciones un aviso:
"La factura del exterior y el pago al proveedor van a la misma cuenta: el costo del proveedor entraría dos veces. Elegí un esquema: (a) el pago a Importaciones en curso y la factura a otra cuenta, o (b) la factura a Importaciones en curso y el pago a la cuenta del proveedor del exterior."

Estilos: `EstadoMapeo`, `Recomendado` con styled-components usando los tokens del theme ya usados en el archivo (no colores hardcodeados).

- [ ] **Step 5: Verificar**

Run: `curl -s -o /dev/null -w "%{http_code}\n" http://localhost:5173/src/components/contabilidad/MapeoCuentasTab.jsx` → `200`.
Recorrer con Playwright (ver memoria del entorno: `dispatchEvent('click')`, quitar `.tsqd-parent-container`) con un usuario de una empresa con Contabilidad en la base local: ver estados, usar una recomendación, guardar, confirmar todo, ver que la alerta "sin confirmar" desaparece de la bandeja. Captura en el reporte.

---

### Task 14: Frontend — catálogo y Conciliación

**Files:**
- Modify: `novasispy-erp/src/components/contabilidad/AsientosEjemploPanel.jsx`
- Modify: `novasispy-erp/src/pages/ConciliacionContablePage.jsx` (~469)

**Interfaces:**
- Consumes: `recomendacion` por línea (Task 11), `causa.codigo === 'FALTA_MAPEO'` y `causa.conceptos` (Task 10).

- [ ] **Step 1: Catálogo**

En `resolverPorConcepto` quitar el manejo de `respaldo`/`respaldo_dinamico`/`concepto_respaldo` agregado el 2026-10-13: si el concepto no está en `mapeoActual` → `{ ...linea, cuenta: null, sin_mapear: true }`; si está como `"__SUMAR__"` → `{ ...linea, cuenta: null, cuenta_dinamica: "Se suma a la cuenta principal", sin_mapear: false }`. En `renderCuenta`, rama `sin_mapear`:

```jsx
      return (
        <SinMapear type="button" onClick={() => onIrAConcepto?.(l.concepto)} title="Ir al concepto para mapearlo">
          <Icon icon="lucide:triangle-alert" /> Falta mapear: {etiquetasConcepto?.[l.concepto] ?? l.concepto}
          {l.recomendacion && <span> — recomendado: {l.recomendacion.texto}</span>}
        </SinMapear>
      );
```

Borrar la rama `concepto_respaldo` y su uso de `SinCuentaPropia as="button"` (dejar `SinCuentaPropia` para medios de pago). Actualizar el comentario de cabecera: ya no "un concepto sin mapear puede caer a otro".

- [ ] **Step 2: Conciliación**

En la celda de la causa (~469):

```jsx
{r.causa && (
  <>
    {r.causa.texto}
    {r.causa.codigo === "FALTA_MAPEO" && (
      <Link to="/contabilidad?tab=mapeo">Ir a Mapeo de cuentas</Link>
    )}
  </>
)}
```

(usar el `Link`/botón de navegación que ya use la página; verificar la ruta real de la pestaña de Mapeo en el router de contabilidad.)

- [ ] **Step 3: Verificar**

Run: `curl` de transform de los dos archivos → `200`. Playwright: en DOBA local, desmapear `IMPORTACION_TRIBUTOS`, confirmar un despacho de prueba → Conciliación "Sin asiento" muestra la causa con el botón; mapear y "Regenerar" → asienta y las alertas se cierran **[RF-3]**.

---

### Task 15: NovaIA, catálogo de ayuda y cierre

**Files:**
- Modify: guías de contabilidad en `novasispy-erp/docs/guias/` (buscar con `rtk proxy grep -rln "Mapeo de cuentas\|IMPORTACIONES_EN_CURSO" docs/guias`)
- Modify: `novasispy-backend-api/src/ayuda-ia/ingesta/seed-catalogo.ts`
- Modify: `novasispy-backend-api/docs/plan-importaciones-fase2-contable.md` (sección de estado)

- [ ] **Step 1: Guías** — agregar a la guía de Mapeo: qué significa "sin confirmar", "recomendado", "Confirmar todo", el modo "sumar a la cuenta principal", los conceptos `IMPORTACION_*` e `IVA_NO_DEDUCIBLE`, y que si falta un mapeo el documento queda sin asiento con aviso (el sistema no elige cuentas). A la guía de Conciliación: la causa "falta mapeo" y los controles nuevos. A la de importaciones: los dos esquemas (DOBA / clásico) y la advertencia de doble ingreso.
- [ ] **Step 2: `seed-catalogo.ts`** — reflejar las rutas/pantallas tocadas siguiendo el formato del archivo.
- [ ] **Step 3: Re-ingesta de NovaIA** según la memoria del proyecto (default dev: solo guías) — correr el comando de ingesta que usa el proyecto (ver `src/ayuda-ia/ingesta/` y el README/guía de ingesta).
- [ ] **Step 4: Verificación final**

Run: `npx jest src/contabilidad src/contabilidad-conciliacion src/alertas-empresa src/rrhh src/rendicion-viaticos && NODE_OPTIONS=--max-old-space-size=6144 npx tsc --noEmit 2>&1 | grep -c "error TS"`
Expected: todos PASS; la cantidad de errores de `tsc` igual a la de antes de empezar (anotar la cifra inicial en la Task 1).
Revisar que no queden respaldos: `rtk proxy grep -rn "catch(() => null)\|catch(() => this.mapeo\|?? cCaja\|cae a PROVEEDORES" src/contabilidad src/rrhh src/rendicion-viaticos` y justificar cada resultado restante en el reporte.

---

## Despliegue (no es tarea de código; checklist para el usuario)

1. Backend: `prisma migrate deploy` → build → reinicio.
2. `npx ts-node -T scripts/data_script/precarga-mapeo-sin-decisiones.ts --dry` en prod, revisar la salida con el usuario, después sin `--dry`.
3. Frontend: build y deploy.
4. Avisar al contador de DOBA: confirmar el mapeo (alerta "sin confirmar") y decidir `IMPORTACION_COMPRA` / `IMPORTACION_PAGO_PROVEEDOR` según su esquema. La regularización de IMP-2026-000001 (−507M) va aparte.
