@fullqueso/mcp-bc-gastos 1.23.1 → 1.25.0

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # CHANGELOG
 
+## [1.25.0] — 2026-06-05
+
+### Added
+- **`get_financial_statements` — separación de ventas intercompañía (40310/50110) → P&L "core" comparable.** La cuenta **40310 "Ventas Materia Prima otras tiendas"** (venta de insumos a otras tiendas de la marca, bajo margen) y su costo directo **50110 "Costo Directo Intercompañía"** inflaban el ingreso y distorsionaban el margen del local, rompiendo la comparabilidad con tiendas que no venden a otras (p.ej. FQ28). Ahora se separan:
+  - Nuevo bloque `intercompany_sales: { revenue (40310), cost (50110), gross_margin:{amount,pct}, revenue_account, cost_account }`.
+  - Nuevo bloque `core` = P&L excluyendo intercompañía (`income`, `cogs`, `gross_margin`, `operating_income`, `ebitda`, `ratios`, `score`), calculado sobre `coreIncome = income − 40310` y `coreCogs = cogs − 50110`. **Core es la métrica principal** del reporte (comparable entre tiendas); el total se mantiene como cifra actual.
+  - Campos top-level (`income`, `cogs`, `gross_margin`, `operating_income`, `ebitda`, `ratios`, `score`) **siguen siendo TOTAL** (actual) → `get_cash_flow` no cambia (la venta intercompañía es caja real; su FCF la sigue incluyendo).
+  - `insights` y la comparación MoM (`buildComparison`) pasan a basarse en **core**. HTML: score ring + KPIs de margen + ratios + comparativo multi-tienda sobre core; tarjeta del P&L agrega memo "Ventas a otras tiendas (intercompañía)" + subtotal "= CORE (comparable)" (solo si hay ventas intercompañía en el período).
+  - Corregido el nombre de la cuenta 40310 en `config/income-accounts.js` (decía "Ventas Facturación Directa" → "Ventas Materia Prima otras tiendas").
+  - **Verificado contra BC real (mayo 2026):** FQ28 (no vende a otras) core == total (39.42%); FQ01 GM% 38.86→**41.34** core; FQ88 GM% 41.25→**42.24** core y OM% 11.12→**8.49** core (las ventas intercompañía estaban inflando el margen operativo — el core revela la rentabilidad real). Reconcilia: core + intercompañía == total en las 3 tiendas.
+
+### Pendiente (fases futuras)
+- **Efecto cambiario sobre caja VES** (Fase 2): línea reconciliadora bajo el FCF. La brecha entre el margen intercompañía reportado (26–33%) y el nominal (5–9%) es la pérdida cambiaria del insumo (tasa Binance) no contabilizada en 50110 — se conecta con este tema.
+
+---
+
+## [1.24.0] — 2026-06-05
+
+### Changed
+- **`get_cash_flow` — working capital 100% desde net-change G/L (7 líneas) + D&A/EBITDA.** Se unificó todo el capital de trabajo sobre el Chart of Accounts real de BC, con la regla universal de impacto en caja `delta = −Σ(debit − credit)` (vale para activos: sube = uso, y pasivos: sube = fuente). Antes ΔAR/ΔAP venían del customer/vendor ledger y ΔInventario del item ledger (fuentes mezcladas); ahora las 7 líneas salen del balance general, misma base USD que el EBIT.
+  - **7 líneas de WC** (orden del bridge): ΔAR `15100–15199 + 15900–15998` · Δ Impuestos (activo) `15200–15299` · Δ Prepagados `16000–16999` · Δ Inventario `14000–14999` · ΔAP `22000–22999` · **Δ Impuestos por pagar `23000–23999`** (nueva) · **Δ Pasivos laborales `24000–25999`** (nueva). `net_wc_change` = suma de las 7.
+  - **CapEx** afinado a PP&E `11110–11190 + 12110–12240` (excluye `12900` depreciación). Implementado con **2 umbrella queries** (activos `11110–16999`, pasivos `22000–25999`) bucketizadas en código por rango de cuenta — `12900` se trae pero no matchea bucket → se descarta; `17xxx`/`18xxx` quedan fuera de rango. Reemplaza 6 consultas (3 G/L + 3 subledger) por 2.
+  - **D&A / EBITDA**: `get_financial_statements` ahora calcula D&A = `Σ(debit−credit)` en `58000–58999` (COGS) + `80000–89999` (OpEx) — filtrando las entries que ya trae (sin query nueva) — y expone `depreciation_amortization` + `ebitda` (`{amount, pct}`). EBIT no cambia; EBITDA = EBIT + D&A. `get_cash_flow` los hereda. Insight automático cuando D&A = 0 ("verificar si se registra depreciación en BC, cuentas 58100-58300 / 81000-82000"). Hoy D&A ≈ 0 → EBIT ≈ EBITDA.
+  - `fcf_bridge` pasa a **13 filas** (7 líneas WC). HTML: tarjeta de Capital de Trabajo con las 7 líneas; KPIs EBITDA + D&A; CapEx etiquetado `PP&E 11110-12240`; fila D&A + EBITDA en el P&L de `get_financial_statements`; fila EBITDA en el comparativo multi-tienda.
+  - **Verificado contra BC real (FQ88, mayo 2026):** CapEx ANTES `$8,760.92` (cuentas 151xx/152xx) → `$0.00` (sin movimientos PP&E). Cross-check G/L vs subledger casi idéntico (ΔInventario 8,643.73 → 8,644.31; ΔAP 10,559.77 → 10,594.77). Nuevas líneas: Δ Imp. por pagar `+$6,052.21`, Δ Pasivos laborales `+$1,294.00`. Bridge cuadra: NOPAT `$12,340.71` + ΔWC `$17,824.37` − CapEx `$0` = FCF `$30,165.08`. EBIT/EBITDA `$18,698.05` (D&A 0).
+
+### Pendiente (Fase 2)
+- **Efecto cambiario sobre caja VES** — línea reconciliadora bajo el FCF (`FCF + Efecto cambiario = Δ Caja real USD`) para reflejar la erosión en USD del saldo en bolívares por la devaluación diaria (~0.75–1%). Se estimará desde el saldo VES de las cuentas 18xxx-VES × tasas. No incluido en esta versión.
+
+---
+
 ## [1.23.1] — 2026-06-05
 
 ### Fixed

package/config/income-accounts.js

@@ -5,7 +5,7 @@
 export const REVENUE_ACCOUNTS = {
   40110: { name: 'Ventas Productos (Pedidos)', nameEn: 'Product Sales (Orders)' },
   40160: { name: 'Ventas Productos (Órdenes)', nameEn: 'Product Sales (Orders)' },
-  40310: { name: 'Ventas Facturación Directa', nameEn: 'Direct Invoice Sales' },
+  40310: { name: 'Ventas Materia Prima otras tiendas', nameEn: 'Raw Material Sales to Other Stores (intercompany)' },
   40450: { name: 'Ingresos Varios Pedidos', nameEn: 'Misc Order Revenue' },
   40460: { name: 'Ingresos Varios Órdenes', nameEn: 'Misc Order Revenue' },
   40520: { name: 'Ventas Diarias', nameEn: 'Daily Sales' },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fullqueso/mcp-bc-gastos",
-  "version": "1.23.1",
+  "version": "1.25.0",
   "description": "MCP server for Business Central operational expense analysis, bank reconciliation, POS reconciliation, accounts receivable/payable, multi-payment draft visibility, payroll, inventory cost analysis, and manager reports - Full Queso franchise stores",
   "main": "server.js",
   "bin": {

package/tools/financials/aggregator.js

@@ -289,10 +289,21 @@ export function calcScore(ratios) {
 // generateInsights — array ordenado por severidad (critical → warning → success)
 // ─────────────────────────────────────────────────────────────────────────────
 
-export function generateInsights(categories, ratios) {
+export function generateInsights(categories, ratios, da = null) {
   const insights = [];
   const sevOrder = { critical: 0, warning: 1, success: 2 };
 
+  // D&A en cero — la depreciación periódica no se está contabilizando en BC
+  // (por eso EBIT ≈ EBITDA). Avisar para que se verifique el registro.
+  if (da === 0) {
+    insights.push({
+      type: 'warning',
+      category: 'depreciation',
+      message: 'D&A en cero — verificar si se registra depreciación en BC (cuentas 58100-58300 y 81000-82000).',
+      action: 'Confirmar con contabilidad si falta contabilizar la depreciación periódica del período.',
+    });
+  }
+
   // Margen operativo
   const op = ratios.operating_margin_pct;
   if (op.status === 'critical') {

package/tools/financials/cash-flow-html.js

@@ -208,9 +208,11 @@ function renderKpis(s) {
   const fcfCls = statusValClass(s.fcf.status);
   return `<div class="kpi-grid cf-kpis">
   ${cell('EBIT', signed(s.ebit.amount), `${s.ebit.pct}%`)}
+  ${cell('D&amp;A', signed(s.da ? s.da.amount : 0), 'dep. 58xxx+8xxxx')}
+  ${cell('EBITDA', signed(s.ebitda ? s.ebitda.amount : s.ebit.amount), `${s.ebitda ? s.ebitda.pct : s.ebit.pct}%`)}
   ${cell('NOPAT', signed(s.nopat.amount), `tax ${signed(-s.tax_estimated.amount)}`)}
   ${cell('CFO', signed(s.cfo.amount), `${s.cfo.pct}%`)}
-  ${cell('CapEx', signed(-s.capex.amount), 'PP&amp;E 11110-12899')}
+  ${cell('CapEx', signed(-s.capex.amount), 'PP&amp;E 11110-12240')}
   ${cell('FCF', signed(s.fcf.amount), statusWord(s.fcf.status), fcfCls)}
   ${cell('FCF Margin', `${s.fcf.pct}%`, '% ingresos', fcfCls)}
 </div>`;
@@ -236,10 +238,12 @@ function renderWorkingCapital(s) {
   <div class="card-bd">
     <div class="wc">
       ${row('Δ Cobranzas (AR)', wc.delta_ar)}
-      ${row('Δ Proveedores (AP)', wc.delta_ap)}
-      ${row('Δ Inventario', wc.delta_inventory)}
-      ${row('Δ Impuestos corrientes', wc.delta_taxes || 0)}
+      ${row('Δ Impuestos (activo)', wc.delta_taxes || 0)}
       ${row('Δ Prepagados', wc.delta_prepaid || 0)}
+      ${row('Δ Inventario', wc.delta_inventory)}
+      ${row('Δ Proveedores (AP)', wc.delta_ap)}
+      ${row('Δ Impuestos por pagar', wc.delta_taxes_payable || 0)}
+      ${row('Δ Pasivos laborales', wc.delta_labor || 0)}
       <div class="wc-row total">
         <span class="wc-label">Cambio neto WC</span>
         <span class="wc-arrow ${wc.net_wc_change >= 0 ? 'up' : 'down'}">${wc.net_wc_change >= 0 ? '&#x2191;' : '&#x2193;'}</span>
@@ -279,6 +283,7 @@ function renderStoresComparison(result) {
 
   const body = [
     row('EBIT', (c) => signed(c.ebit.amount)),
+    row('EBITDA', (c) => signed(c.ebitda ? c.ebitda.amount : c.ebit.amount)),
     row('NOPAT', (c) => signed(c.nopat.amount)),
     row('CFO', (c) => `<span class="${c.cfo.amount >= 0 ? 'val-green' : 'val-red'}">${signed(c.cfo.amount)}</span>`),
     row('CapEx', (c) => signed(-c.capex.amount)),

package/tools/financials/cash-flow.js

@@ -1,24 +1,31 @@
 // tools/financials/cash-flow.js
 //
 // Tool get_cash_flow — Free Cash Flow (FCF) por método indirecto para tiendas FQ.
-// Reutiliza el bloque P&L/EBIT de get_financial_statements (fetchStoreFinancials) y
-// le agrega impuesto estimado, capital de trabajo (ΔAR/ΔAP/ΔInventario), CapEx,
-// CFO, FCF, bridge tipo waterfall e insights. READ-ONLY.
+// Reutiliza el bloque P&L/EBIT/D&A/EBITDA de get_financial_statements
+// (fetchStoreFinancials) y le agrega impuesto estimado, capital de trabajo (7 líneas),
+// CapEx, CFO, FCF, bridge tipo waterfall e insights. READ-ONLY.
 //
-// CONVENCIÓN DE SIGNOS (impacto en caja; + = fuente de caja, − = uso de caja):
-//   delta_ar        = −Σ amountLocalCurrency(customerLedgerEntries)  → + = cobró más de lo facturado (AR 15110–15199)
-//   delta_ap        = −Σ amountLocalCurrency(vendorLedgerEntries)    → + = debe más (fuente)
-//   delta_inventory = −Σ costAmountActual(itemLedgerEntries)         → + = inventario bajó (fuente) (14000–14999)
-//   delta_taxes     = −Σ(debit−credit) G/L 15210–15280              → + = impuestos corrientes bajaron (fuente)
-//   delta_prepaid   = −Σ(debit−credit) G/L 16110–16900              → + = prepagados bajaron (fuente)
-//   net_wc_change   = delta_ar + delta_ap + delta_inventory + delta_taxes + delta_prepaid
-//   nopat = ebit − tax ;  cfo = nopat + net_wc_change ;  fcf = cfo − capex
-// (Resuelve la inconsistencia del spec entre los comentarios del schema y la fórmula:
-//  se adopta la convención de los comentarios — los deltas ya con signo de caja.)
+// WORKING CAPITAL — las 7 líneas salen de net-change G/L (balance general), misma
+// base USD que el EBIT. REGLA UNIVERSAL de impacto en caja (+ = fuente, − = uso):
+//   delta = −Σ(debit − credit) sobre el rango de cuenta. Vale para activos (sube =
+//   uso) y pasivos (sube = fuente). Rangos (Chart of Accounts real de BC):
+//     delta_ar            = 15100–15199 + 15900–15998   (cuentas por cobrar + otras CxC)
+//     delta_taxes         = 15200–15299                 (impuestos corrientes activo)
+//     delta_prepaid       = 16000–16999                 (anticipos y prepagados)
+//     delta_inventory     = 14000–14999                 (inventarios)
+//     delta_ap            = 22000–22999                 (cuentas por pagar)
+//     delta_taxes_payable = 23000–23999                 (impuestos por pagar)
+//     delta_labor         = 24000–25999                 (pasivos laborales)
+//   net_wc_change = suma de las 7 ; nopat = ebit − tax ; cfo = nopat + net_wc_change ;
+//   fcf = cfo − capex.
 //
-// CAPEX = net change (debit−credit) en PP&E 11110–12899 (intangibles 11110–11190 +
-//   tangibles 12110–12240). EXCLUYE 12900 (depreciación acumulada), 17000–17999
-//   (inversiones corto plazo) y 18000–18999 (caja y bancos = posición de caja final).
+// CAPEX = +Σ(debit − credit) en PP&E 11110–11190 (intangibles) + 12110–12240
+//   (tangibles). EXCLUYE 12900 (depreciación acumulada), 17000–17999 (inversiones
+//   corto plazo) y 18000–18999 (caja y bancos = posición de caja final).
+//
+// D&A / EBITDA: D&A = Σ(debit−credit) en 58000–58999 (COGS) + 80000–89999 (OpEx),
+//   calculada por get_financial_statements. EBITDA = EBIT + D&A (KPI; no es paso del
+//   bridge). Hoy D&A suele ser 0 (no se contabiliza depreciación) → EBIT ≈ EBITDA.
 //
 // Montos en USD (LCY = Additional Reporting Currency), igual que get_financial_statements.
 
@@ -44,8 +51,9 @@ export const cashFlowTool = {
   description:
     'Free Cash Flow (FCF) por método indirecto para una o más tiendas Full Queso (FQ01, FQ28, FQ88). ' +
     'Parte del EBIT (igual que get_financial_statements), resta impuesto estimado (ISLR 34%), ajusta por capital de trabajo ' +
-    '(Δ cuentas por cobrar, Δ cuentas por pagar, Δ inventario, Δ impuestos corrientes, Δ prepagados) para obtener el flujo de ' +
-    'caja operativo (CFO), y resta CapEx (PP&E / activos fijos 11110-12899) para el FCF. Incluye NOPAT, margen FCF, status ' +
+    '(7 líneas desde net-change G/L: Δ cuentas por cobrar, Δ impuestos corrientes, Δ prepagados, Δ inventario, Δ cuentas por pagar, ' +
+    'Δ impuestos por pagar, Δ pasivos laborales) para obtener el flujo de caja operativo (CFO), y resta CapEx (PP&E 11110-12240) ' +
+    'para el FCF. Reporta también D&A y EBITDA (EBIT + D&A). Incluye NOPAT, margen FCF, status ' +
     '(healthy/positive_low/negative_watch/' +
     'negative_critical), bridge tipo waterfall e insights automáticos. Multi-tienda calcula consolidado. Con render_html=true ' +
     'genera un dashboard HTML (lo guarda en ~/Downloads y retorna la ruta). Úsalo cuando el usuario pida flujo de caja, ' +
@@ -209,11 +217,15 @@ async function buildStoreCashFlow(bcClient, store, start, end) {
       cogs: financials.cogs.total,
       gross_margin_amount: financials.gross_margin.amount,
       ebit: financials.operating_income.amount,
+      da: financials.depreciation_amortization.amount,
+      ebitda: financials.ebitda.amount,
       delta_ar: wc.delta_ar,
-      delta_ap: wc.delta_ap,
-      delta_inventory: wc.delta_inventory,
       delta_taxes: wc.delta_taxes,
       delta_prepaid: wc.delta_prepaid,
+      delta_inventory: wc.delta_inventory,
+      delta_ap: wc.delta_ap,
+      delta_taxes_payable: wc.delta_taxes_payable,
+      delta_labor: wc.delta_labor,
       capex: wc.capex,
       capex_accounts: wc.capex_accounts,
       warnings: wc.warnings,
@@ -221,91 +233,90 @@ async function buildStoreCashFlow(bcClient, store, start, end) {
   );
 }
 
-// Consultas BC para capital de trabajo (AR/AP/Inventario) + CapEx — todas en paralelo
+// Buckets del balance general (Chart of Accounts real de BC), por rango de cuenta.
+// REGLA UNIVERSAL de impacto en caja: delta = −Σ(debit − credit) sobre el rango.
+//   - Activo que sube (debit) → −Σ < 0 = uso de caja.
+//   - Pasivo que sube (credit) → −Σ > 0 = fuente de caja.
+// CapEx es la excepción: capex = +Σ(debit − credit) sobre PP&E (un débito = inversión).
+// Montos en USD (LCY = Additional Reporting Currency), consistentes con el EBIT.
+const ASSET_BUCKETS = [
+  { key: 'capex',           ranges: [[11110, 11190], [12110, 12240]] }, // PP&E (excluye 12900 deprec.)
+  { key: 'delta_inventory', ranges: [[14000, 14999]] },                 // Inventarios
+  { key: 'delta_ar',        ranges: [[15100, 15199], [15900, 15998]] }, // Cuentas por cobrar + otras CxC
+  { key: 'delta_taxes',     ranges: [[15200, 15299]] },                 // Impuestos corrientes (activo)
+  { key: 'delta_prepaid',   ranges: [[16000, 16999]] },                 // Anticipos y prepagados
+];
+const LIAB_BUCKETS = [
+  { key: 'delta_ap',            ranges: [[22000, 22999]] }, // Cuentas por pagar
+  { key: 'delta_taxes_payable', ranges: [[23000, 23999]] }, // Impuestos por pagar (pasivo)
+  { key: 'delta_labor',         ranges: [[24000, 25999]] }, // Pasivos laborales
+];
+
+function bucketOf(accountNumber, buckets) {
+  const n = parseInt(accountNumber, 10);
+  for (const b of buckets) for (const [lo, hi] of b.ranges) if (n >= lo && n <= hi) return b.key;
+  return null; // 12900 (deprec.), gaps, etc. → fuera de todo bucket = descartado
+}
+
+// Capital de trabajo + CapEx desde 2 umbrella queries G/L (activos + pasivos),
+// bucketizadas en código por rango de cuenta. Reemplaza el enfoque mixto
+// subledger/G/L: ahora TODO el WC sale del balance general (net-change G/L),
+// misma base USD que el EBIT. AR/Inventario/AP ya no usan customer/vendor/item
+// ledger — todo es net change de las cuentas de balance.
 async function fetchWorkingCapitalAndCapex(bcClient, companyId, start, end) {
-  const sd = bcClient._sanitizeOData(start);
-  const ed = bcClient._sanitizeOData(end);
-  const periodFilter = `postingDate ge ${sd} and postingDate le ${ed}`;
-
-  const arUrl = bcClient.buildBetaApiUrl(companyId, 'customerLedgerEntries', {
-    $filter: periodFilter,
-    $select: 'postingDate,documentType,amountLocalCurrency',
-  });
-  const apUrl = bcClient.buildBetaApiUrl(companyId, 'vendorLedgerEntries', {
-    $filter: periodFilter,
-    $select: 'postingDate,documentType,amountLocalCurrency',
-  });
-  const ileUrl = bcClient.buildApiUrl(companyId, 'itemLedgerEntries', {
-    $filter: periodFilter,
-    $select: 'postingDate,entryType,quantity,costAmountActual',
-  });
-
-  // Rangos G/L del Chart of Accounts real de BC (activos 10000–19999):
-  //   CapEx → PP&E 11110–12899 (excluye 12900 depreciación acumulada)
-  //   Impuestos corrientes → 15210–15280 (IVA crédito, retenciones, anticipos ISLR)
-  //   Prepagados → 16110–16900 (anticipos a proveedores, alquileres/otros prepagados)
-  // AR (15110–15199) e Inventario (14000–14999) ya se calculan vía subledger
-  // (customer/item ledger) — NO consultarlos aquí para no duplicar.
-  // Excluidos del FCF: 17000–17999 (inversiones corto plazo) y 18000–18999 (caja/bancos).
-  const [arEntries, apEntries, ileEntries, capexEntries, taxEntries, prepaidEntries] = await Promise.all([
-    bcClient.apiCallAllPages(arUrl).catch((e) => { logger.warn(`[cash-flow] AR fetch failed: ${e.message}`); return null; }),
-    bcClient.apiCallAllPages(apUrl).catch((e) => { logger.warn(`[cash-flow] AP fetch failed: ${e.message}`); return null; }),
-    bcClient.apiCallAllPages(ileUrl).catch((e) => { logger.warn(`[cash-flow] ILE fetch failed: ${e.message}`); return null; }),
-    bcClient.getGLEntries(companyId, start, end, '11110', '12899').catch((e) => { logger.warn(`[cash-flow] CapEx fetch failed: ${e.message}`); return null; }),
-    bcClient.getGLEntries(companyId, start, end, '15210', '15280').catch((e) => { logger.warn(`[cash-flow] Impuestos fetch failed: ${e.message}`); return null; }),
-    bcClient.getGLEntries(companyId, start, end, '16110', '16900').catch((e) => { logger.warn(`[cash-flow] Prepagados fetch failed: ${e.message}`); return null; }),
+  // Umbrella de activos 11110–16999: cubre CapEx (11xxx–12xxx), inventario (14xxx),
+  // AR (151xx/159xx), impuestos activo (152xx) y prepagados (16xxx). 12900 cae dentro
+  // pero no matchea bucket → se descarta. 17xxx (inversiones) y 18xxx (caja) quedan fuera.
+  // Umbrella de pasivos 22000–25999: AP (22xxx), impuestos por pagar (23xxx), laborales (24-25xxx).
+  const [assetEntries, liabEntries] = await Promise.all([
+    bcClient.getGLEntries(companyId, start, end, '11110', '16999').catch((e) => { logger.warn(`[cash-flow] activos G/L fetch failed: ${e.message}`); return null; }),
+    bcClient.getGLEntries(companyId, start, end, '22000', '25999').catch((e) => { logger.warn(`[cash-flow] pasivos G/L fetch failed: ${e.message}`); return null; }),
   ]);
 
   const warnings = [];
+  const raw = { capex: 0, delta_inventory: 0, delta_ar: 0, delta_taxes: 0, delta_prepaid: 0, delta_ap: 0, delta_taxes_payable: 0, delta_labor: 0 };
+  const capex_accounts = {};
 
-  // ΔAR — impacto en caja = −Σ amountLocalCurrency (invoices +, payments −)
-  let delta_ar = 0;
-  if (arEntries == null) warnings.push('Customer ledger no disponible — ΔAR asumido en 0.');
-  else delta_ar = round2(-arEntries.reduce((s, e) => s + (e.amountLocalCurrency || 0), 0));
-
-  // ΔAP — impacto en caja = −Σ amountLocalCurrency (invoices −, payments +)
-  let delta_ap = 0;
-  if (apEntries == null) warnings.push('Vendor ledger no disponible — ΔAP asumido en 0.');
-  else delta_ap = round2(-apEntries.reduce((s, e) => s + (e.amountLocalCurrency || 0), 0));
-
-  // ΔInventario — impacto en caja = −Σ costAmountActual (compras +, ventas −)
-  // costAmountActual ya es el costo total de la entrada (no multiplicar por quantity).
-  let delta_inventory = 0;
-  if (ileEntries == null) warnings.push('Item ledger no disponible — Δinventario asumido en 0.');
-  else {
-    delta_inventory = round2(-ileEntries.reduce((s, e) => s + (e.costAmountActual || 0), 0));
-    if (ileEntries._truncated) warnings.push('Item ledger truncado (muchas entradas) — Δinventario puede estar incompleto.');
+  if (assetEntries == null) {
+    warnings.push('G/L de activos (11110–16999) no disponible — CapEx/ΔAR/ΔImpuestos/ΔPrepagados/ΔInventario asumidos en 0.');
+  } else {
+    for (const e of assetEntries) {
+      const key = bucketOf(e.accountNumber, ASSET_BUCKETS);
+      if (!key) continue;
+      const net = (e.debitAmount || 0) - (e.creditAmount || 0);
+      raw[key] += net;
+      if (key === 'capex') capex_accounts[e.accountNumber] = round2((capex_accounts[e.accountNumber] || 0) + net);
+    }
+    if (assetEntries._truncated) warnings.push('G/L de activos truncado (muchas entradas) — WC de activos puede estar incompleto.');
   }
 
-  // ΔImpuestos corrientes — impacto en caja = −Σ(debit−credit) G/L 15210–15280
-  // (activo corriente: aumenta = uso de caja, baja = fuente de caja)
-  let delta_taxes = 0;
-  if (taxEntries == null) warnings.push('G/L de impuestos corrientes (15210–15280) no disponible — ΔImpuestos asumido en 0.');
-  else delta_taxes = round2(-taxEntries.reduce((s, e) => s + ((e.debitAmount || 0) - (e.creditAmount || 0)), 0));
-
-  // ΔPrepagados — impacto en caja = −Σ(debit−credit) G/L 16110–16900
-  let delta_prepaid = 0;
-  if (prepaidEntries == null) warnings.push('G/L de prepagados (16110–16900) no disponible — ΔPrepagados asumido en 0.');
-  else delta_prepaid = round2(-prepaidEntries.reduce((s, e) => s + ((e.debitAmount || 0) - (e.creditAmount || 0)), 0));
-
-  // CapEx — net change (debit−credit) en PP&E 11110–12899 (excluye 12900 depreciación,
-  // 17xxx inversiones corto plazo y 18xxx bancos)
-  let capex = 0;
-  const capex_accounts = {};
-  if (capexEntries == null) {
-    warnings.push('G/L de PP&E (activos fijos 11110–12899) no disponible — CapEx asumido en 0.');
+  if (liabEntries == null) {
+    warnings.push('G/L de pasivos (22000–25999) no disponible — ΔAP/ΔImpuestos x pagar/ΔPasivos laborales asumidos en 0.');
   } else {
-    for (const e of capexEntries) {
-      const net = (e.debitAmount || 0) - (e.creditAmount || 0);
-      capex += net;
-      capex_accounts[e.accountNumber] = round2((capex_accounts[e.accountNumber] || 0) + net);
+    for (const e of liabEntries) {
+      const key = bucketOf(e.accountNumber, LIAB_BUCKETS);
+      if (!key) continue;
+      raw[key] += (e.debitAmount || 0) - (e.creditAmount || 0);
     }
-    capex = round2(capex);
-    // limpiar cuentas con neto 0
-    for (const k of Object.keys(capex_accounts)) if (capex_accounts[k] === 0) delete capex_accounts[k];
+    if (liabEntries._truncated) warnings.push('G/L de pasivos truncado (muchas entradas) — WC de pasivos puede estar incompleto.');
   }
 
-  return { delta_ar, delta_ap, delta_inventory, delta_taxes, delta_prepaid, capex, capex_accounts, warnings };
+  // Aplicar signos: CapEx = +Σ(debit−credit); cada delta de WC = −Σ(debit−credit).
+  const capex = round2(raw.capex);
+  for (const k of Object.keys(capex_accounts)) if (capex_accounts[k] === 0) delete capex_accounts[k];
+
+  return {
+    delta_ar: round2(-raw.delta_ar),
+    delta_taxes: round2(-raw.delta_taxes),
+    delta_prepaid: round2(-raw.delta_prepaid),
+    delta_inventory: round2(-raw.delta_inventory),
+    delta_ap: round2(-raw.delta_ap),
+    delta_taxes_payable: round2(-raw.delta_taxes_payable),
+    delta_labor: round2(-raw.delta_labor),
+    capex,
+    capex_accounts,
+    warnings,
+  };
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -321,12 +332,22 @@ function assembleCashFlow(meta, c) {
   const tax = ebit > 0 ? round2(ebit * TAX_RATE) : 0;
   const nopat = round2(ebit - tax);
 
+  // D&A / EBITDA — EBIT no cambia (D&A ya está en COGS/OpEx); EBITDA la re-suma.
+  const da = round2(c.da || 0);
+  const ebitda = round2(c.ebitda != null ? c.ebitda : ebit + da);
+  const ebitdaPct = income > 0 ? round2((ebitda / income) * 100) : 0;
+
+  // Working capital — las 7 líneas desde net-change G/L (regla −Σ(debit−credit)).
   const delta_ar = round2(c.delta_ar);
-  const delta_ap = round2(c.delta_ap);
-  const delta_inventory = round2(c.delta_inventory);
   const delta_taxes = round2(c.delta_taxes || 0);
   const delta_prepaid = round2(c.delta_prepaid || 0);
-  const net_wc_change = round2(delta_ar + delta_ap + delta_inventory + delta_taxes + delta_prepaid);
+  const delta_inventory = round2(c.delta_inventory);
+  const delta_ap = round2(c.delta_ap);
+  const delta_taxes_payable = round2(c.delta_taxes_payable || 0);
+  const delta_labor = round2(c.delta_labor || 0);
+  const net_wc_change = round2(
+    delta_ar + delta_taxes + delta_prepaid + delta_inventory + delta_ap + delta_taxes_payable + delta_labor
+  );
 
   const cfo = round2(nopat + net_wc_change);
   const cfoPct = income > 0 ? round2((cfo / income) * 100) : 0;
@@ -336,8 +357,9 @@ function assembleCashFlow(meta, c) {
   const fcfPct = income > 0 ? round2((fcf / income) * 100) : 0;
 
   const status = fcfStatus(fcf, fcfPct, ebit);
-  const bridge = buildBridge({ ebit, tax, nopat, delta_ar, delta_ap, delta_inventory, delta_taxes, delta_prepaid, cfo, capex, fcf });
-  const insights = buildInsights({ ebit, delta_ar, delta_ap, delta_inventory, delta_taxes, delta_prepaid, capex, fcf, fcfPct, status, warnings: c.warnings || [] });
+  const wc = { delta_ar, delta_taxes, delta_prepaid, delta_inventory, delta_ap, delta_taxes_payable, delta_labor };
+  const bridge = buildBridge({ ebit, tax, nopat, ...wc, cfo, capex, fcf });
+  const insights = buildInsights({ ebit, ...wc, da, capex, fcf, fcfPct, status, warnings: c.warnings || [] });
 
   return {
     store_code: meta.store_code,
@@ -346,9 +368,11 @@ function assembleCashFlow(meta, c) {
     cogs: { total: round2(c.cogs) },
     gross_margin: { amount: round2(c.gross_margin_amount), pct: gmPct },
     ebit: { amount: ebit, pct: ebitPct },
+    da: { amount: da },
+    ebitda: { amount: ebitda, pct: ebitdaPct },
     tax_estimated: { amount: tax, rate: TAX_RATE, note: 'Estimado ISLR 34%' },
     nopat: { amount: nopat },
-    working_capital: { delta_ar, delta_ap, delta_inventory, delta_taxes, delta_prepaid, net_wc_change },
+    working_capital: { ...wc, net_wc_change },
     cfo: { amount: cfo, pct: cfoPct },
     capex: { amount: capex, accounts: c.capex_accounts || {} },
     fcf: { amount: fcf, pct: fcfPct, status },
@@ -363,33 +387,37 @@ function fcfStatus(fcf, fcfPct, ebit) {
   return fcf > ebit * -0.2 ? 'negative_watch' : 'negative_critical';
 }
 
-function buildBridge({ ebit, tax, nopat, delta_ar, delta_ap, delta_inventory, delta_taxes, delta_prepaid, cfo, capex, fcf }) {
+function buildBridge({ ebit, tax, nopat, delta_ar, delta_taxes, delta_prepaid, delta_inventory, delta_ap, delta_taxes_payable, delta_labor, cfo, capex, fcf }) {
   const flow = (label, amount) => ({ label, amount: round2(amount), type: amount >= 0 ? 'source' : 'use' });
   return [
     { label: 'EBIT', amount: ebit, type: 'source' },
     { label: 'Impuesto est.', amount: round2(-tax), type: 'use' },
     { label: 'NOPAT', amount: nopat, type: 'subtotal' },
     flow('Δ Cob. (AR)', delta_ar),
-    flow('Δ Prov. (AP)', delta_ap),
-    flow('Δ Inventario', delta_inventory),
-    flow('Δ Impuestos', delta_taxes),
+    flow('Δ Impuestos (activo)', delta_taxes),
     flow('Δ Prepagados', delta_prepaid),
+    flow('Δ Inventario', delta_inventory),
+    flow('Δ Prov. (AP)', delta_ap),
+    flow('Δ Imp. x pagar', delta_taxes_payable),
+    flow('Δ Pasivos laborales', delta_labor),
     { label: 'CFO', amount: cfo, type: 'subtotal' },
     { label: 'CapEx', amount: round2(-capex), type: 'use' },
     { label: 'FCF', amount: fcf, type: 'total' },
   ];
 }
 
-function buildInsights({ ebit, delta_ar, delta_ap, delta_inventory, delta_taxes, delta_prepaid, capex, fcf, fcfPct, status, warnings }) {
+function buildInsights({ ebit, delta_ar, delta_taxes, delta_prepaid, delta_inventory, delta_ap, delta_taxes_payable, delta_labor, da, capex, fcf, fcfPct, status, warnings }) {
   const insights = [];
 
-  // Mayor driver negativo entre los usos de capital de trabajo
+  // Mayor driver negativo entre los usos de capital de trabajo (7 líneas)
   const uses = [
     { key: 'delta_inventory', label: 'Inventario', val: delta_inventory },
     { key: 'delta_ar', label: 'Cobranza (AR)', val: delta_ar },
     { key: 'delta_ap', label: 'Pagos a proveedores (AP)', val: delta_ap },
     { key: 'delta_taxes', label: 'Impuestos corrientes', val: delta_taxes },
     { key: 'delta_prepaid', label: 'Prepagados', val: delta_prepaid },
+    { key: 'delta_taxes_payable', label: 'Impuestos por pagar', val: delta_taxes_payable },
+    { key: 'delta_labor', label: 'Pasivos laborales', val: delta_labor },
   ].filter((u) => u.val < 0).sort((a, b) => a.val - b.val);
   if (uses.length) {
     insights.push(`${uses[0].label} es el mayor uso de caja del período ($${fmtAbs(uses[0].val)}).`);
@@ -400,9 +428,14 @@ function buildInsights({ ebit, delta_ar, delta_ap, delta_inventory, delta_taxes,
     insights.push(`Cobranza lenta presiona caja: ΔAR −$${fmtAbs(delta_ar)} (>20% del EBIT).`);
   }
 
-  // CapEx — solo si hay net change real en PP&E (11110–12899)
+  // D&A en cero — depreciación posiblemente no contabilizada en BC
+  if (da === 0) {
+    insights.push('D&A en cero — verificar si se registra depreciación en BC (cuentas 58100-58300 y 81000-82000).');
+  }
+
+  // CapEx — solo si hay net change real en PP&E (11110–12240)
   if (capex > 0) {
-    insights.push(`CapEx $${fmtAbs(capex)} en PP&E (activos fijos 11110–12899) detectado.`);
+    insights.push(`CapEx $${fmtAbs(capex)} en PP&E (activos fijos 11110–12240) detectado.`);
   } else if (capex < 0) {
     insights.push(`Desinversión neta en PP&E $${fmtAbs(capex)} (fuente de caja).`);
   }
@@ -450,11 +483,15 @@ function consolidateCashFlow(storeObjs) {
       cogs: sum((o) => o.cogs.total),
       gross_margin_amount: sum((o) => o.gross_margin.amount),
       ebit: sum((o) => o.ebit.amount),
+      da: sum((o) => (o.da ? o.da.amount : 0)),
+      ebitda: sum((o) => (o.ebitda ? o.ebitda.amount : 0)),
       delta_ar: sum((o) => o.working_capital.delta_ar),
-      delta_ap: sum((o) => o.working_capital.delta_ap),
-      delta_inventory: sum((o) => o.working_capital.delta_inventory),
       delta_taxes: sum((o) => o.working_capital.delta_taxes || 0),
       delta_prepaid: sum((o) => o.working_capital.delta_prepaid || 0),
+      delta_inventory: sum((o) => o.working_capital.delta_inventory),
+      delta_ap: sum((o) => o.working_capital.delta_ap),
+      delta_taxes_payable: sum((o) => o.working_capital.delta_taxes_payable || 0),
+      delta_labor: sum((o) => o.working_capital.delta_labor || 0),
       capex: sum((o) => o.capex.amount),
       capex_accounts,
       warnings: allWarnings,

package/tools/financials/html-template.js

@@ -28,7 +28,7 @@ export function buildHTML(result) {
 function renderSingle(result, code) {
   const store = result.stores[code];
   const comparison = result.comparison ? result.comparison[code] : null;
-  const headerHtml = renderHeader(store.store_code, store.store_name, store.score, result, comparison);
+  const headerHtml = renderHeader(store.store_code, store.store_name, store.core ? store.core.score : store.score, result, comparison);
   const body = `
 ${renderTldr(store.insights)}
 ${renderKpiGrid(store)}
@@ -46,7 +46,7 @@ ${comparison ? renderComparisonCard({ [code]: comparison }, result) : ''}
 
 function renderMulti(result) {
   const con = result.consolidated;
-  const headerHtml = renderHeader('FQ', con ? con.store_name : 'Consolidado Full Queso', con ? con.score : 0, result, null);
+  const headerHtml = renderHeader('FQ', con ? con.store_name : 'Consolidado Full Queso', con ? (con.core ? con.core.score : con.score) : 0, result, null);
 
   const storeBlocks = Object.keys(result.stores)
     .map((code) => {
@@ -55,7 +55,7 @@ function renderMulti(result) {
   <summary>
     <span class="sd-icon">▸</span>
     <span class="sd-name">${esc(s.store_name)}</span>
-    <span class="sd-meta">$${fmt(s.income.total)} · MB ${s.gross_margin.pct}% · MO ${s.operating_income.pct}% · ${scoreBadge(s.score)}</span>
+    <span class="sd-meta">$${fmt(s.income.total)} · MB ${(s.core || s).gross_margin.pct}% · MO ${(s.core || s).operating_income.pct}% · ${scoreBadge((s.core || s).score)}</span>
   </summary>
   <div class="sd-body">
     ${renderKpiGrid(s)}
@@ -158,26 +158,30 @@ function insightGlyph(type) {
 // ─────────────────────────────────────────────────────────────────────────────
 
 function renderKpiGrid(s) {
-  const gmStatus = s.ratios.gross_margin_pct.status;
-  const opStatus = s.ratios.operating_margin_pct.status;
-  const e2iPct = s.ratios.expense_to_income_pct.value;
+  // Márgenes sobre CORE (comparable entre tiendas); ingresos = total real.
+  const c = s.core || s;
+  const cr = c.ratios || s.ratios;
+  const gmStatus = cr.gross_margin_pct.status;
+  const opStatus = cr.operating_margin_pct.status;
+  const e2iPct = cr.expense_to_income_pct.value;
+  const hasInterco = s.intercompany_sales && s.intercompany_sales.revenue > 0;
 
   return `<div class="kpi-grid">
   <div class="kpi-cell">
     <span class="kpi-cell-v">$${fmt(s.income.total)}</span>
-    <span class="kpi-cell-l">Ingresos</span>
+    <span class="kpi-cell-l">Ingresos${hasInterco ? `<br><span class="kpi-cell-sub">core $${fmt(c.income.total)}</span>` : ''}</span>
   </div>
   <div class="kpi-cell">
-    <span class="kpi-cell-v ${valClass(gmStatus)}">${s.gross_margin.pct}%</span>
-    <span class="kpi-cell-l">Margen Bruto<br><span class="kpi-cell-sub">$${fmt(s.gross_margin.amount)}</span></span>
+    <span class="kpi-cell-v ${valClass(gmStatus)}">${c.gross_margin.pct}%</span>
+    <span class="kpi-cell-l">Margen Bruto (core)<br><span class="kpi-cell-sub">$${fmt(c.gross_margin.amount)}</span></span>
   </div>
   <div class="kpi-cell">
-    <span class="kpi-cell-v ${valClass(opStatus)}">${s.operating_income.pct}%</span>
-    <span class="kpi-cell-l">Margen Operativo<br><span class="kpi-cell-sub">$${fmt(s.operating_income.amount)}</span></span>
+    <span class="kpi-cell-v ${valClass(opStatus)}">${c.operating_income.pct}%</span>
+    <span class="kpi-cell-l">Margen Operativo (core)<br><span class="kpi-cell-sub">$${fmt(c.operating_income.amount)}</span></span>
   </div>
   <div class="kpi-cell">
     <span class="kpi-cell-v">$${fmt(s.expenses.total)}</span>
-    <span class="kpi-cell-l">Gastos Op.<br><span class="kpi-cell-sub">${e2iPct}% de ingresos</span></span>
+    <span class="kpi-cell-l">Gastos Op.<br><span class="kpi-cell-sub">${e2iPct}% de ingresos core</span></span>
   </div>
 </div>`;
 }
@@ -222,12 +226,33 @@ function renderPnlCard(s) {
       ${expenseRows}
       <div class="pnl-row total"><span class="pnl-label">(&minus;) Total Gastos Operativos</span><span class="pnl-amt">$${fmt(s.expenses.total)}</span></div>
 
-      <div class="pnl-row operating"><span class="pnl-label">= Utilidad Operativa <span class="pnl-pct ${valClass(s.ratios.operating_margin_pct.status)}">${s.operating_income.pct}%</span></span><span class="pnl-amt ${valClass(s.ratios.operating_margin_pct.status)}">$${fmt(s.operating_income.amount)}</span></div>
+      <div class="pnl-row operating"><span class="pnl-label">= Utilidad Operativa (EBIT) <span class="pnl-pct ${valClass(s.ratios.operating_margin_pct.status)}">${s.operating_income.pct}%</span></span><span class="pnl-amt ${valClass(s.ratios.operating_margin_pct.status)}">$${fmt(s.operating_income.amount)}</span></div>
+      ${s.ebitda ? `<div class="pnl-row sub"><span class="pnl-label">(+) Depreciación y Amortización</span><span class="pnl-amt">$${fmt(s.depreciation_amortization.amount)}</span></div>
+      <div class="pnl-row gross"><span class="pnl-label">= EBITDA <span class="pnl-pct">${s.ebitda.pct}%</span></span><span class="pnl-amt">$${fmt(s.ebitda.amount)}</span></div>` : ''}
+      ${renderCoreBlock(s)}
     </div>
   </div>
 </div>`;
 }
 
+// Bloque intercompañía + CORE (solo si hay ventas a otras tiendas en el período).
+function renderCoreBlock(s) {
+  const ic = s.intercompany_sales;
+  const c = s.core;
+  if (!ic || !c || !(ic.revenue > 0)) return '';
+  return `
+      <div class="pnl-section-hd">Ventas a otras tiendas (intercompañía)</div>
+      <div class="pnl-row sub"><span class="pnl-label">Ventas Materia Prima <span class="pnl-acct">${esc(ic.revenue_account)}</span></span><span class="pnl-amt">$${fmt(ic.revenue)}</span></div>
+      <div class="pnl-row sub"><span class="pnl-label">(&minus;) Costo Directo Intercompañía <span class="pnl-acct">${esc(ic.cost_account)}</span></span><span class="pnl-amt">$${fmt(ic.cost)}</span></div>
+      <div class="pnl-row sub"><span class="pnl-label">= Margen intercompañía <span class="pnl-pct">${ic.gross_margin.pct}%</span></span><span class="pnl-amt">$${fmt(ic.gross_margin.amount)}</span></div>
+
+      <div class="pnl-section-hd">Core (comparable, sin intercompañía)</div>
+      <div class="pnl-row sub"><span class="pnl-label">Ingresos core</span><span class="pnl-amt">$${fmt(c.income.total)}</span></div>
+      <div class="pnl-row sub"><span class="pnl-label">(&minus;) COGS core</span><span class="pnl-amt">$${fmt(c.cogs.total)}</span></div>
+      <div class="pnl-row gross"><span class="pnl-label">= Margen Bruto core <span class="pnl-pct ${valClass(c.ratios.gross_margin_pct.status)}">${c.gross_margin.pct}%</span></span><span class="pnl-amt ${valClass(c.ratios.gross_margin_pct.status)}">$${fmt(c.gross_margin.amount)}</span></div>
+      <div class="pnl-row operating"><span class="pnl-label">= Utilidad Operativa core <span class="pnl-pct ${valClass(c.ratios.operating_margin_pct.status)}">${c.operating_income.pct}%</span></span><span class="pnl-amt ${valClass(c.ratios.operating_margin_pct.status)}">$${fmt(c.operating_income.amount)}</span></div>`;
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Barras horizontales de desglose de gastos
 // ─────────────────────────────────────────────────────────────────────────────
@@ -264,6 +289,8 @@ function renderExpenseBars(s) {
 // ─────────────────────────────────────────────────────────────────────────────
 
 function renderRatiosCard(s) {
+  // Ratios sobre CORE (consistente con el score core del ring).
+  const ratios = s.core ? s.core.ratios : s.ratios;
   const order = [
     ['gross_margin_pct', 'Margen Bruto'],
     ['operating_margin_pct', 'Margen Operativo'],
@@ -274,9 +301,9 @@ function renderRatiosCard(s) {
     ['marketing_pct', 'Marketing'],
   ];
   const rows = order
-    .filter(([k]) => s.ratios[k])
+    .filter(([k]) => ratios[k])
     .map(([k, label]) => {
-      const r = s.ratios[k];
+      const r = ratios[k];
       return `<div class="ratio-row">
       <span class="ratio-name">${esc(label)}</span>
       <span class="ratio-val ${valClass(r.status)}">${r.value}%</span>
@@ -287,7 +314,7 @@ function renderRatiosCard(s) {
     .join('');
 
   return `<div class="card">
-  <div class="card-hd"><span class="card-icon">&#x1F4C8;</span><span class="card-title">Ratios vs Benchmark</span></div>
+  <div class="card-hd"><span class="card-icon">&#x1F4C8;</span><span class="card-title">Ratios vs Benchmark (core)</span></div>
   <div class="card-bd"><div class="ratios">${rows}</div></div>
 </div>`;
 }
@@ -312,13 +339,15 @@ function renderMultiComparisonTable(result) {
       ${cols.map((c) => `<div class="ctbl-cell">${fn(c)}</div>`).join('')}
     </div>`;
 
+  const core = (c) => c.core || c;
   const body = [
     row('Ingresos', (c) => `$${fmt(c.income.total)}`),
+    row('Vtas. intercompañía', (c) => `$${fmt(c.intercompany_sales ? c.intercompany_sales.revenue : 0)}`),
     row('COGS', (c) => `$${fmt(c.cogs.total)}`),
-    row('Margen Bruto', (c) => `<span class="${valClass(c.ratios.gross_margin_pct.status)}">${c.gross_margin.pct}%</span>`),
+    row('MB core', (c) => `<span class="${valClass(core(c).ratios.gross_margin_pct.status)}">${core(c).gross_margin.pct}%</span>`),
     row('Gastos Op.', (c) => `$${fmt(c.expenses.total)}`),
-    row('Margen Oper.', (c) => `<span class="${valClass(c.ratios.operating_margin_pct.status)}">${c.operating_income.pct}%</span>`, 'em'),
-    row('Score', (c) => scoreBadge(c.score), 'em'),
+    row('MO core', (c) => `<span class="${valClass(core(c).ratios.operating_margin_pct.status)}">${core(c).operating_income.pct}%</span>`, 'em'),
+    row('Score core', (c) => scoreBadge(core(c).score), 'em'),
   ].join('');
 
   return `<div class="card">

package/tools/financials/statements.js

@@ -39,9 +39,56 @@ function buildStoreFinancials(storeCode, storeName, incomeEntries, cogsEntries,
   const opAmount = round2(gmAmount - expenses.total);
   const opPct = income.total > 0 ? round2((opAmount / income.total) * 100) : 0;
 
+  // D&A — depreciación/amortización ya contenida en COGS (58000-58999) y OpEx
+  // (80000-89999). Se calcula filtrando las entries ya traídas (sin query nueva).
+  // EBIT NO cambia (D&A ya está restada); EBITDA = EBIT + D&A la re-suma.
+  const da = computeDepreciation(cogsEntries, expenseEntries);
+  const ebitdaAmount = round2(opAmount + da);
+  const ebitdaPct = income.total > 0 ? round2((ebitdaAmount / income.total) * 100) : 0;
+
+  // ── Intercompañía: ventas de materia prima a otras tiendas (40310) y su costo
+  // directo (50110). Bajo margen (manejo 5-9%); se separan para una métrica core
+  // comparable entre tiendas (las que no venden a otras tienen 40310 = 0). ──
+  const intercoRevenue = round2(sumIncomeAccount(incomeEntries, '40310'));
+  const intercoCost = round2(cogs.accounts['50110'] || 0);
+  const intercoGm = round2(intercoRevenue - intercoCost);
+  const intercoGmPct = intercoRevenue > 0 ? round2((intercoGm / intercoRevenue) * 100) : 0;
+  const intercompany_sales = {
+    revenue: intercoRevenue,
+    cost: intercoCost,
+    gross_margin: { amount: intercoGm, pct: intercoGmPct },
+    revenue_account: '40310',
+    cost_account: '50110',
+  };
+
+  // ── CORE = P&L excluyendo intercompañía (comparable entre tiendas). El margen,
+  // ratios y score core son la métrica principal del reporte; el total queda como
+  // cifra actual. EBIT total NO cambia (get_cash_flow lo sigue usando). ──
+  const coreIncome = round2(income.total - intercoRevenue);
+  const coreCogs = round2(cogs.total - intercoCost);
+  const coreGm = round2(coreIncome - coreCogs);
+  const coreGmPct = coreIncome > 0 ? round2((coreGm / coreIncome) * 100) : 0;
+  const coreOp = round2(coreGm - expenses.total);
+  const coreOpPct = coreIncome > 0 ? round2((coreOp / coreIncome) * 100) : 0;
+  const coreEbitda = round2(coreOp + da);
+  const coreEbitdaPct = coreIncome > 0 ? round2((coreEbitda / coreIncome) * 100) : 0;
+  const coreRatios = calcRatios({ total: coreIncome }, { total: coreCogs }, expenses);
+  const coreScore = calcScore(coreRatios);
+  const core = {
+    income: { total: coreIncome },
+    cogs: { total: coreCogs },
+    gross_margin: { amount: coreGm, pct: coreGmPct },
+    operating_income: { amount: coreOp, pct: coreOpPct },
+    ebitda: { amount: coreEbitda, pct: coreEbitdaPct },
+    ratios: coreRatios,
+    score: coreScore,
+  };
+
+  // Ratios/score TOTAL (compat + base del cash flow). Insights sobre CORE — más
+  // representativo de la rentabilidad real de la operación del local.
   const ratios = calcRatios(income, cogs, expenses);
   const score = calcScore(ratios);
-  const insights = generateInsights(expenses.categories, ratios);
+  const insights = generateInsights(expenses.categories, coreRatios, da);
 
   return {
     store_code: storeCode,
@@ -51,12 +98,33 @@ function buildStoreFinancials(storeCode, storeName, incomeEntries, cogsEntries,
     gross_margin: { amount: gmAmount, pct: gmPct },
     expenses,
     operating_income: { amount: opAmount, pct: opPct },
+    depreciation_amortization: { amount: da },
+    ebitda: { amount: ebitdaAmount, pct: ebitdaPct },
+    intercompany_sales,
+    core,
     ratios,
     insights,
     score,
   };
 }
 
+// D&A = Σ(debit − credit) sobre 58000-58999 (en COGS) + 80000-89999 (en OpEx).
+// Mismas entries del P&L — no requiere consulta adicional a BC.
+function computeDepreciation(cogsEntries, expenseEntries) {
+  const inRange = (acct, lo, hi) => { const n = parseInt(acct, 10); return n >= lo && n <= hi; };
+  let da = 0;
+  for (const e of cogsEntries) if (inRange(e.accountNumber, 58000, 58999)) da += (e.debitAmount || 0) - (e.creditAmount || 0);
+  for (const e of expenseEntries) if (inRange(e.accountNumber, 80000, 89999)) da += (e.debitAmount || 0) - (e.creditAmount || 0);
+  return round2(da);
+}
+
+// Σ(credit − debit) de una cuenta de ingreso específica (40000-49999 = saldo crédito).
+function sumIncomeAccount(incomeEntries, accountNumber) {
+  let sum = 0;
+  for (const e of incomeEntries) if (e.accountNumber === accountNumber) sum += (e.creditAmount || 0) - (e.debitAmount || 0);
+  return sum;
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // fetchStoreFinancials — 3 queries BC en paralelo para una tienda
 // Devuelve { financials, raw } (raw se usa para consolidar sin re-consultar BC)
@@ -202,27 +270,33 @@ function buildComparison(current, previous, prevPeriod) {
 
   const varPct = (cur, prev) => (prev !== 0 ? round2(((cur - prev) / Math.abs(prev)) * 100) : null);
 
+  // Comparar sobre CORE (margen/EBIT/score) para datos comparables entre tiendas;
+  // income se compara sobre total (ingreso real). Fallback a total si falta `core`.
+  const curCore = current.core || current;
+  const prevCore = previous.core || previous;
+
   return {
     previous_period: prevPeriod,
+    basis: 'core',
     income: {
       current: current.income.total,
       previous: previous.income.total,
       variance_pct: varPct(current.income.total, previous.income.total),
     },
     gross_margin_pct: {
-      current: current.gross_margin.pct,
-      previous: previous.gross_margin.pct,
-      variance_pts: round2(current.gross_margin.pct - previous.gross_margin.pct),
+      current: curCore.gross_margin.pct,
+      previous: prevCore.gross_margin.pct,
+      variance_pts: round2(curCore.gross_margin.pct - prevCore.gross_margin.pct),
     },
     operating_income: {
-      current: current.operating_income.amount,
-      previous: previous.operating_income.amount,
-      variance_pct: varPct(current.operating_income.amount, previous.operating_income.amount),
+      current: curCore.operating_income.amount,
+      previous: prevCore.operating_income.amount,
+      variance_pct: varPct(curCore.operating_income.amount, prevCore.operating_income.amount),
     },
     operating_margin_pct: {
-      current: current.operating_income.pct,
-      previous: previous.operating_income.pct,
-      variance_pts: round2(current.operating_income.pct - previous.operating_income.pct),
+      current: curCore.operating_income.pct,
+      previous: prevCore.operating_income.pct,
+      variance_pts: round2(curCore.operating_income.pct - prevCore.operating_income.pct),
     },
     expenses: {
       current: current.expenses.total,
@@ -230,9 +304,9 @@ function buildComparison(current, previous, prevPeriod) {
       variance_pct: varPct(current.expenses.total, previous.expenses.total),
     },
     score: {
-      current: current.score,
-      previous: previous.score,
-      variance: current.score - previous.score,
+      current: curCore.score,
+      previous: prevCore.score,
+      variance: curCore.score - prevCore.score,
     },
   };
 }