Trazza

Texto del repositorio público, commit 8729248. Fuente: docs/claude/finance.md.

Motor financiero: algoritmos y consistencia del valor de cartera

Detalle movido desde CLAUDE.md el 2026-10-04 para que el fichero que se carga en cada sesión solo lleve el índice y las reglas críticas. Léelo antes de tocar esta zona.

Financial algorithms

Portfolio Value consistency rules

Single source of truth for prices: assets.current_price in DB is the last price written by the hourly snapshot cron (server/lib/assetPrices.js, service role only since 2026-10-26 — audit 7f2c915d A1). Dashboard and CarteraPage show live prices but NO LONGER write them back: a client-callable price RPC let any account poison the shared table. Never use entry_price as a proxy for current market price.

¿Es liquidez o es un activo? UNA función: isCashPosition (src/lib/positionKind.js) (2026-08-01). El mismo test de dos señales estaba copiado a mano en ~15 sitios, la MITAD sensibles a mayúsculas (asset_class === 'Cash') y la otra mitad no (asset_class?.toLowerCase() === 'cash'), así que una fila guardada como 'cash'/'CASH' era liquidez en la tabla de posiciones y activo invertido en el Dashboard. Medido en demo con una fila asset_class: 'cash', ticker EUR: 9 pos. en vez de 7, "Cash" a 0 € e "Invertido" a 595.060 € en vez de 213.974 € (además el treemap intentaba cotizar el ticker EUR como si fuese una acción). El módulo exporta también isHeldInvestedPosition (no-liquidez + quantity > 0.0001), que es lo que cuenta el "N pos." del widget INVERTIDO: la liquidez NO es una posición. Al añadir una superficie que separe efectivo de activos, importa la función — no vuelvas a escribir el ||. Es Node-compatible (la importan portfolioHistory/portfolioStats, que usa el share server): imports relativos con .js desde services/.

matchesCashIdentity vs isCashPosition (2026-10-28): no son intercambiables. matchesCashIdentity (src/lib/cashIdentity.js) se usa para casar/reutilizar filas de caja en imports y asientos manuales (solo tickers canónicos CASH_XXX / CASH_XXX (XXX) y divisa coherente). isCashPosition clasifica liquidez para métricas y UI (regla más amplia por asset_class o prefijo CASH). Si separas invertido vs efectivo, usa isCashPosition; si decides si una fila existente de caja puede reutilizarse, usa matchesCashIdentity.

Valor de mercado: UNA función, tres pantallas (2026-08-01). computeInvestedMarketValue(positions, rates) (services/portfolioStats.js, puro) es la ÚNICA definición del valor de mercado de las posiciones no-cash; la consumen computePortfolioStats (brokers → "Valor en Mercado"), el Dashboard (tanto el valor con precio de BD como el liveInvestedValue → "Invertido") y ExpensesPage ("Invertido en cartera" → "Patrimonio total"). Antes cada pantalla tenía su propio reduce "espejo" y los tres números se separaban. Reglas al tocarlo: maneja las DOS formas de fila (merged con _valueComponents/_totalValueInPref y fila plana de BD) y compara current_price con != null (un precio 0 legítimo no puede caer al entry_price).

Dashboard Portfolio Value calculation order:

  1. Fetch positions from DB (with last-known current_price)
  2. Fetch live quotes for all tickers (for treemap AND for Portfolio Value)
  3. Compute liveInvestedValue using live prices, falling back to DB price if quote failed
  4. totalWealth = liveInvestedValue + totalCashConverted
  5. (No write-back: the server cron owns assets.current_price.)

Exchange rate caching: currencyService.getExchangeRate caches in both memory (in-process) and localStorage (survives reload) with a 10-minute TTL. This prevents portfolio values from jittering between page reloads due to minor FX moves. Cache key format: wf_fx_rates in localStorage.

CarteraPage stats: computed in src/services/portfolioStats.js (pure module, decimal.js) and memoized in CarteraPage with React.useMemo. New aggregation logic goes in that service with unit tests (portfolioStats.test.js) — never inline financial formulas in the component.

Shared history pipeline (Dashboard ↔ brokers screen ↔ shared portfolio): the FIFO/cost-basis/P&L computation over DB transactions lives ONLY in src/services/portfolioHistory.js (computeHistoryTotals). usePositions (brokers screen), Dashboard.jsx AND the share endpoint (server/routes/sharePortfolio.js, which imports it directly from src/) call it — that is what makes "Invertido", realized P&L, dividends and fees identical everywhere. NEVER re-implement or "mirror" this logic locally; any change goes in the service + its tests (portfolioHistory.test.js). The module is Node-compatible (relative imports, injectable rate deps) — keep it that way.

Annualized return (CAGR): always annualize the cumulative TWR — (1 + TWR)^(1/years) − 1, only shown with ≥ 6 months. Never annualize Simple ROI: its denominator (totalBuyCost) counts recycled capital and assumes all capital was deployed on day one, which understates CAGR for periodic contributions.

⚠️ Los años se cuentan desde el primer día INVERTIDO, no desde el primer apunte (2026-09-20, reportado por el owner: TWR +60,44% desde el 6-oct-2024 que salía como +19,08% anual en vez de +27,36%). calculateDailyTWR arranca la serie en la primera transacción de CUALQUIER tipo ("first transaction day to today"), así que un ingreso de efectivo, una comisión o un traspaso meses antes de la primera compra mete un tramo de puntos con value: 0. Ese tramo NO toca el TWR —la cadena multiplica por 1 mientras no hay activos— pero la ventana es el DIVISOR: nueve meses de caja parada convertían una ventana de 1,95 años en una de 2,70 y hundían la anualizada 8 puntos, sin que nada en pantalla lo explicara. Es el mismo fallo que ya se arregló en el benchmark del gráfico, y se arregla con la misma regla: el primer punto con value > 0.

La decisión vive en DOS funciones puras y testeadas de performanceService.js (annualizedReturn.test.js, 12 tests): firstInvestedDate(series) y annualizeReturn(pct, inicio, fin, { minYears }). Las comparten las TRES superficies que enseñan esta métrica —la pantalla de brokers, SharePortfolioModal y el endpoint del share (server/routes/sharePortfolio.js)— porque si divergen, la cartera compartida enseña un número distinto del que ve su dueño. Al añadir una cuarta, importa las funciones; no repitas la fórmula.

Dos corolarios: (a) value sale SOLO de las cantidades de activos (currentAssetQtys, que alimentan BUY/SELL), nunca de la liquidez — por eso > 0 distingue de verdad "invertido" de "tengo el dinero en el broker"; (b) el share guarda el primer día invertido en cached.invested_since para que el server anualice sobre la misma ventana, y los shares creados antes caen a first_trade_date como hasta ahora.

Y no es un promedio, es una tasa compuesta. La intuición de dividir entre los años (60,44 / 2 ≈ 30%) siempre da de más, porque el segundo año crece sobre el primero: lo correcto es 27,36%, y comprobarlo es elevarlo (1,2736^1,955 = 1,6044). El texto del diálogo "¿Cómo se calcula?" (cartera.metric_cagr_desc) lo dice explícitamente desde el mismo commit, junto con la ventana que se usa.

✅ Resuelto el 2026-10-02: la calculadora de interés compuesto ya precarga la MISMA cifra que brokers. Antes DashboardLayout anualizaba portfolioValue / totalInvested entre la primera y la ÚLTIMA compra (CAGR inflado para quien dejó de comprar, y además suponía todo el dinero invertido el día uno). Ahora usa annualizedTwrFromSeries (performanceService, testeada) sobre la serie que ya calculó el Dashboard, leída con peekPerformanceSeries (usePortfolioPerformance, sin descargar nada; acepta series de hasta 6 h). Sin serie a mano devuelve null y la calculadora usa su valor por defecto — no se inventa una cifra.

Per-position FIFO cost is reconciled to the held quantity (scaleOpenCostToHeldQty in portfolioHistory.js, applied in usePositions before attaching _prefCostTotal): when the FIFO open lots cover fewer/more shares than positions.quantity (histories damaged by the old import dedupe, manual edits, partial saves), the cost is scaled by heldQty/openQty (AVCO per remaining share). Never pair a partial FIFO cost with the full market value: the shortfall shows up as a fake FX gain in the G/P Moneda breakdown and inflates the return % (the +186% Amazon / +114% MA bug).

Latent-gain cost basis is the HYBRID per-position cost (investedHybrid), never the raw global FIFO openPositionCost. Broker histories are split between the transactions table (saved) and imported_data JSON (unsaved); openPositionCost only covers the saved ones, so using it directly pairs a partial cost with the full market value and wildly inflates Ganancia Total (this happened the moment the first Binance import was saved). The hybrid lives in computeInvestedHybrid(positions, history, rates) (portfolioHistory.js, pure, tested: per FIFO queue consumed ONCE and scaled to held qty → AVCO buy totals → entry×rate): usePositions publishes it in historyTotals + the metrics cache, and the Dashboard fallback computes it with the SAME function over its DB positions — the cache is a perf shortcut, never a prerequisite for correct numbers. The share server still falls back to entry-based openInvestedEur.

Cross-screen metrics cache: portfolio_metrics_cache (user_id + scope) holds the brokers screen's computed computeHistoryTotals output (+ txCount + posFingerprint). usePositions publishes it on every load; Dashboard uses it verbatim when scope/currency match AND metrics.txCount equals the live transaction count AND metrics.posFingerprint equals computePositionsFingerprint(positions) (txCount alone missed mutations that change cost basis without adding transactions — manual position edits/adds froze the Dashboard's "Invertido" until the next brokers visit); the share server checks scope/currency/txCount. Any mismatch falls back to recomputing (Dashboard's fallback includes computeInvestedHybrid, so it matches the brokers number even on a cache miss). This is why "Invertido" is identical and instant on all three surfaces.

Share exactness (scope <bId>:display): además, CarteraPage publica (effect debounced, tras el memo de stats) las stats de cabecera EXACTAS que el usuario ve — investedValue/gain/gainPercent/realized/dividends/fees/totalCapitalDeployed + su eurRate de cliente y txCount — bajo scope '<bId>:display'. El share live (server/routes/sharePortfolio.js) las sirve VERBATIM (convertidas a EUR con ese mismo eurRate) cuando el scope coincide (general o un solo broker) y txCount iguala las transacciones vivas; si el dueño operó sin volver a abrir la app, cae al recálculo del pipeline compartido. Es lo que garantiza que la página compartida muestre exactamente los números del que comparte.

Binance Transaction History parser: trade legs are grouped by the Observación/Remark value when present (the "Buy Crypto With Fiat" pattern writes its fiat and crypto legs up to ~6 s apart, linked only by the remark), and by ≤3 s gaps between consecutive rows otherwise. Reconstructed BUY/SELLs are real events (isConsolidated: false — they MUST reach the transactions table); fiat deposits/withdrawals become TRANSFER rows so the broker cash balance exists; crypto-denominated fees are deducted from quantity, excluded from the BUY cost basis and emitted once as a FEE row. Regression fixture from a real export lives in binanceCsvParser.test.js.

La serie de rendimiento (TWR/TTWROR/ROI) tiene UNA implementación: usePortfolioPerformance (2026-09-11). La pantalla de brokers llamaba a calculateDailyTWR por su cuenta con otros argumentos (sin roiTransactions, rango 10y frente a 5y, sin la caché de localStorage) y el MISMO indicador daba números distintos según la pantalla — reportado por el owner: +54,80% en el Dashboard contra +54,69% en brokers. CarteraPage consume ahora el hook (refreshKey fuerza el recálculo tras un import o un alta manual, que es lo que hacían las deps de su efecto). Misma regla que portfolioHistory: no reimplementes la serie en una pantalla nueva.

El ROI del gráfico usa precios VIVOS con el rango completo, no el último cierre (2026-09-11). La serie valora con el cierre diario y la cabecera de brokers con precios vivos: mismo coste base, distinto valor, dos ROI que no cuadran (medido con la cartera del owner: 22,67% en el gráfico contra 22,07% en el chip — 26.245 € de coste en ambos, 32.196 € de valor contra 32.038 €). Con timeRange === 'ALL', PortfolioGrowthChart deriva el % de los DOS números que la propia tarjeta ya enseña en vivo (breakdownStats.liveInvested ÷ capitalInvertido), que es la definición exacta del chip "ROI Cartera actual"; y sobrescribe también el último punto de la línea, para que el tooltip no cuente otra cosa que la cabecera. Verificado en demo: +73,65% en las dos pantallas. El texto de "¿Cómo se calcula?" (portfolio_growth.roi_note / roi_actual_desc) lo explica — al cambiar esta regla, cámbialo en el mismo commit.

El benchmark (S&P 500 TR) se basa en el primer día INVERTIDO, no en el primer punto de la serie (2026-09-11). calculateDailyTWR arranca la serie en la primera transacción, que puede ser un apunte de caja meses antes de comprar nada: ese primer punto tiene value: 0. Basar ahí el índice le regala toda la subida de un tramo en el que la cartera no podía capturar nada — sesgo sistemático A FAVOR del benchmark. Medido: en la demo el primer punto es 2023-01-01 con valor 0 € y el primer día con posiciones es 2023-01-10; nueve días de ventaja movían el marcador de −9,87% a −5,55%. En la cartera del owner el desfase eran meses: la línea del S&P arrancaba ya en +25% y el marcador cantaba "−12,89% vs S&P 500" con la cartera en realidad por delante. La base es rebased.find(d => (d.value || 0) > 0), antes de esa fecha NO se pinta índice (sp500Return: null) y el primer día arranca en 0 aunque caiga en festivo (lastSP ?? 0). La regla vive en UNA función desde el 2026-10-04, mergeBenchmarkSeries (performanceService.js, tests en benchmarkSeries.test.js), que consume PortfolioGrowthChart (Dashboard). La copia de CarteraPage (getFilteredPerformanceData, con su filtro por rango, S&P 500, CAGR y drawdown) resultó ser CÓDIGO MUERTO —restos de un gráfico retirado de esa pantalla: nadie leía sus resultados y setShowSP500 no se llamaba nunca— y se BORRÓ el 2026-10-04. El dateKey: 'name' se conserva por si otra serie con esa forma lo necesita.

El modo ROI del gráfico SOLO se ofrece con el rango completo (2026-09-19, decisión del owner). Sobre un tramo, rebaseFiltered reencuadra la línea a 0% en su primera fecha, así que lo que se pinta deja de ser una rentabilidad: es cuánto ha CAMBIADO el múltiplo valor/coste. Y una aportación suma los MISMOS euros al valor y al coste, lo que arrastra ese cociente hacia el 0% por bien que vaya el mercado — se puede ganar dinero y ver el número en rojo. Medido con la cartera del owner: TTWROR YTD +19,79% con el titular del ROI en −2,39%, y la plusvalía latente pasando de ~3.900 € a 7.155 € en ese mismo periodo. Mismo criterio que retiró gainPercent de la pantalla de brokers: la métrica se sigue calculando, lo que se quita es el sitio donde convivía con otra que mide algo distinto e invitaba a compararlas.

La regla es UNA línea — effectiveChartMode = timeRange === 'ALL' ? chartMode : 'TTWROR' — y se DERIVA a propósito en lugar de corregir el estado desde un efecto: así el modo que se pinta y el rango no pueden desincronizarse ni un solo render, y al volver a ALL se recupera el ROI que el usuario había elegido. Todo lo de aguas abajo (yieldKey, modeConfig, benchmarkApplies, liveRoiPct, el lienzo y la leyenda) consume el modo EFECTIVO: si añades un consumidor nuevo y le pasas chartMode a secas, reabres el fallo. El botón se DESHABILITA con su explicación (portfolio_growth.roi_only_all), no desaparece, igual que el del S&P.

Corolario: fuera de ALL la línea es siempre TTWROR, así que ya no hay dos métricas compartiendo la palabra "ROI" en la misma tarjeta. El número del pie tampoco se llama ya "ROI total" sino Rentabilidad total (total_roi + total_return_tooltip): es totalGainPct, ganancia total con realizado, dividendos y comisiones sobre TODO el capital desplegado — otra magnitud que el latente de las posiciones abiertas que dibuja la línea.

Otras dos reglas del benchmark, de la misma revisión:

Which TWR series to consume: calculateDailyTWR emits TWO chains per point: ttwror (price + currency return in base currency — the correct portfolio TWR) and yield/cumulativeReturn (native-currency price-only — blind to FX). UI surfaces (TWR tile, CAGR, evolution charts, share sampling) must consume ttwror (with cumulativeReturn fallback for old cached series). Regression tests in performanceService.test.js pin both the FX inclusion and the sold-asset behaviour.

Al cambiar lo que MIDE una métrica, actualiza su explicación en el mismo commit. Los textos del diálogo "¿Cómo se calcula?" del gráfico viven en portfolio_growth.* (es/en) y los pinta GrowthChartExplainer; describen la fórmula, así que envejecen mal en silencio y el usuario acaba leyendo algo que el código ya no hace (roi_note seguía diciendo que el selector de período era "solo un zoom" mucho después de que la línea se rebasase a 0% en la primera fecha del rango).

Component split: extracted pieces of CarteraPage live in src/components/cartera/: PortfolioStatsCards, MetricExplainerDialog, MonthlyBreakdownChart, BrokerDialogs, Import* (selector/method/upload/preview), TransactionListCard, y desde 2026-07-16 DeletePositionDialog, PositionActionBar, HistoryPeriodFilterBar, BrokerTabBar, AddEditPositionDialog, PositionsMobileList, PositionsDesktopTable y TaxReportDialog (informe fiscal anual: agrupa por año fiscal los MISMOS salesWithPL/dividends/commissions de processedImportData vía services/taxReportService.js — puro, testeado; dividendos NETOS porque el parser DeGiro fusiona la retención en el dividendo; export CSV dialecto Excel-ES). Shared display formatters (formatNumber, getCurrencySymbol) are in src/lib/formatters.js. New extractions follow the same pattern: pure presentation components receiving pre-computed values + callbacks (Supabase I/O stays in the page — see handleAddBroker/handleStartEditPosition).

Row metrics compartidas: el cálculo por fila de posición (coste FIFO→AVCO→entry, G/P Producto/Moneda/Obtenida) y el del bullet-chart de target (posición y liquidez) viven en src/services/positionRowMetrics.js (computePositionRowMetrics, computeTargetMetrics, resolveCashTarget) con tests. PositionsMobileList y PositionsDesktopTable los consumen — NUNCA reimplementar esa matemática inline en una vista: era duplicación literal móvil/desktop antes de la extracción.

Total Gain / Total Return formula (CarteraPage & Dashboard):

General view position grouping: In "All Brokers" mode, positions are grouped by ISIN only (same stock on different exchanges/currencies → one row). Cash rows stay separate by ticker (CASH_EUR ≠ CASH_USD). The representative asset (highest qty sub-position) provides the display currency and current_price. entry_price is computed in step 3.5 after FX rates are fetched: all cost components are converted to preferredCurrency as intermediate, then back to the representative's native currency, so the stats IIFE qty × entry_price × rate[currency] stays correct. all_asset_ids (array) is exposed on each merged position so loadTransactionsForAsset can load transactions from all underlying assets when expanding a row.

CSV import — smart position closing: After saving an import, only positions whose asset had explicit BUY/SELL activity in that CSV are eligible to be closed (set to qty=0). Positions absent from the CSV (e.g. only dividends, or bought before the export date range) are left untouched. This is tracked via processedAssetIds Set inside saveImportedData.

Fund look-through (donut widgets): for index funds, assets.currency is the SHARE CLASS (all EUR) and the ISIN prefix is the legal DOMICILE (IE/LU) — classifying by them shows a 100%-EUR / "Europa+Luxembourg" portfolio for a US/Japan/EM fund mix. src/services/fundExposure.js (getFundExposure(asset), pure, tested) returns the UNDERLYING index exposure (region/currency/sector codes): curated ISIN map for the MyInvestor cartera funds first (same philosophy as MYINVESTOR_FUNDS), then CURATED_BY_SYMBOL (Yahoo symbol root — for ACTIVE funds with opaque names like "Gestión Value A FI", whose exposure must be verified against Yahoo quoteSummary?modules=topHoldings before adding), then name rules (hedge tag EUR H stripped before region matching; trailing share-class Acc EUR never implies Europe; returns null when unsure → caller keeps its stock derivation). The Dashboard donut keyFns (divisaKey/sectorKey/regionKey) consult it FIRST for divisa/región; sector uses the DB sector first (funds have none). Misclassified/unclassified fund → add its ISIN to CURATED_BY_ISIN or its symbol to CURATED_BY_SYMBOL with a test. Only affects donut GROUPING — values/rates still use the share-class currency.

Fund sector look-through (Sectores donut): for fund positions the Sectores donut splits the position's VALUE across the fund's real sector weights: fundSectors.js fetches Yahoo quoteSummary?modules=topHoldings through the crumb proxy (/api/yahoo-profile/:ticker?modules=topHoldings, dev-only like getProfile), reduces it with extractFundSectorWeights (in fundExposure.js: requires stockPosition ≥ 0.5 — bond funds report a junk "financial_services 100%" row and must keep their FUND_BOND bucket; labels are the exact assetProfile sector strings so fund slices MERGE with stock slices), and caches per ticker in localStorage (wf_fund_sectors_v1, 24h, null "no data" results cached too, network errors NOT cached). Fetches are SEQUENTIAL + paced (Yahoo rate limit). Dashboard holds the weights in fundSectorWeights state; buildDonut/buildCompanyMap accept keyFns returning either a string or [{key, weight}] portions. Symbols without data (.MU listings) or fetch failures gracefully keep the single fundExposure bucket.

Previsión de dividendos del año (widget "Próximos dividendos", 2026-10-15)

services/dividendProjection.js (con tests). "AÑO (est.)" = cobrado este año + los pagos cuyo ex-dividendo cae entre hoy y el 31-dic (frecuencia deducida de anual/importe por pago; sin fecha, prorrateo por días). Antes sumaba lo cobrado + el dividendo anual COMPLETO: en la demo, a 15-oct, 825 € en vez de 211 €. "AÑO+1 (est.)" = ritmo anual actual, sin el ×1,05 inventado de antes. Si falla la consulta de lo cobrado, las dos primeras tarjetas dicen "No disponible" — nunca un 0 € que parece real.

Fechas de la serie de rendimiento (2026-10-15)

Informe fiscal: dividendos, retenciones y comisiones por separado (2026-10-16)

DEGIRO e IBKR apuntan la retención del dividendo como línea propia (TAX). El informe la sumaba en "Comisiones y tasas" y llamaba "netos" a unos dividendos que eran BRUTOS. buildTaxReport lleva ahora withholding aparte (filas TAX, misma regla de moneda que las comisiones) y dividendsReceived (lo que apunta el broker: bruto en DEGIRO/IBKR, neto en los que pagan ya neto). Para declarar: el bruto y la retención van por separado. En la pantalla de brokers la retención sigue dentro de Comisiones (lo dice su explicación).

Informe fiscal: tipo de cambio de la fecha de cada operación (2026-10-22)

Hasta esta fecha el informe convertía TODO al cambio de HOY y, en las ventas, el beneficio neto. La AEAT pide: valor de transmisión al tipo del día de la VENTA y valor de adquisición al tipo del día de CADA COMPRA (lote FIFO); dividendos y comisiones al tipo de su fecha. Piezas:

Informe fiscal: FIFO por ISIN, no el de la pantalla (2026-10-22, revisión F1F2 punto 2)

Con buys (lo que pasa SIEMPRE desde TaxReportDialog) el informe decide todo con el FIFO por ISIN del núcleo tax/twoMonthRule: el estado de cada venta (missing_buy_data si ninguna acción vendida tiene compra del ISIN, partial_history, missing_fx), el importe (al tipo de la fecha de la venta, aunque la pantalla no tenga lotes) y los lotes del detalle (en la moneda del informe, con el tipo de cada compra). No lee lots, isMissingBuyData ni sharesMissingHistory de la pantalla.

Informe fiscal: comisiones dentro de los valores (2026-10-22, revisión F1F2 punto 1)

Art. 35.1.b y 35.2 LIRPF: los gastos de la operación suman al valor de adquisición y restan del de transmisión, y así lo piden las casillas de la Renta. Con buys, buildTaxReport mete la comisión de la fila (comisiones, facturada en EUR: commissionCurrency) en el importe que recibe el núcleo: compra → unitCostEur = (qty·precio·tipo + comisión·tipoEUR)/qty; venta → netProceedsEur = max(0, qty·precio·tipo − comisión·tipoEUR), cada tipo de SU fecha. Es la misma fórmula que computeCapitalGains, así que app y calculadora pública dan lo mismo para el mismo caso (test de cuadre en taxReportService.twoMonth.test.js). En una venta parcial la comisión de compra se prorratea sola porque va en el coste unitario del lote, y entra también en la pérdida aplazada de los dos meses.

Informe fiscal: historial parcial, la parte conocida computa (2026-10-22, revisión F1F2 punto 3)

Antes una venta con PARTE de las acciones sin compra se excluía entera: el total escondía la pérdida o la ganancia de la parte conocida (caso R8F-3: 9 compradas a 100, 10 vendidas a 50 → −450 € que desaparecían). Ahora el informe llama al núcleo con applyTwoMonthRule(ops, { knownPartOnly: true }): gain = importe × conocidas/vendidas − coste de los lotes, y isLoss y lo aplazado se calculan solo sobre las conocidas. La venta sigue en estado partial_history, pero con importes y DENTRO de los totales; las unidades sin coste y su importe de transmisión excluido van a byYear[y].partialHistory (y partialHistoryCount), que el diálogo enseña en «Unidades vendidas sin coste» y el CSV en su sección. unreliableCount cuenta solo las ventas sin compra de NINGUNA acción, que siguen fuera.

transactions.fx_rate — sentido y estado (comprobado 2026-10-22): el COMMENT de la migración 20260610 dice transaction_currency → EUR, y así lo interpreta brokerFxFor (solo con preferida EUR y para la divisa de la propia fila). Pero hoy ningún parser lo rellena (importPlanner escribe t.fxRate, que nadie pone) y la transformación de filas de BD tampoco lo lee, así que en la práctica siempre se usa la tabla histórica. OJO al cablearlo en DEGIRO: su columna «Tipo» del Account.csv (y fxRate de publicTools/degiroTransactions) va en el sentido CONTRARIO, divisa por EUR (800 USD / 740 EUR = 1,0811) — hay que invertirla antes de guardarla en fx_rate.