@gabrielerandelli/minus-tracker 0.6.0 → 0.8.0

package/dist/cli/index.js

@@ -13,6 +13,8 @@ var it = {
   warnUnsupportedCurrency: (row, currency) => `Riga ${row}: valuta non supportata ${currency} \u2014 riga ignorata`,
   warnNoEcbRate: (row, currency, date) => `Riga ${row}: nessun tasso BCE per ${currency} in data ${date} \u2014 riga ignorata`,
   warnQuantityZero: (row) => `Riga ${row}: quantit\xE0 pari a 0 \u2014 riga ignorata`,
+  warnMissingIsinIncome: (row) => `Riga ${row}: ISIN mancante su riga di reddito \u2014 riga ignorata`,
+  warnOrphanWithholding: (isin, date) => `Riga di ritenuta su ${isin}/${date} senza riga di reddito corrispondente \u2014 riga ignorata`,
   warnMultipleYears: "Il CSV contiene transazioni di pi\xF9 anni \u2014 filtra per un singolo anno per un calcolo accurato.",
   headerMethod: "METODO",
   headerTaxYear: "ANNO FISCALE",
@@ -64,7 +66,30 @@ var it = {
   headerBucket: "BUCKET",
   warnUnclassifiedIsin: (isin) => `ISIN ${isin} non trovato nella mappa di classificazione \u2014 assegnato a Bucket B.`,
   carryForwardInvalidFormat: "Formato --carry-forward non valido. Usa: AAAA:importo (es. 2023:2500)",
-  disclaimer: "minus-tracker \xE8 un ausilio al calcolo, non consulenza fiscale."
+  disclaimer: "minus-tracker \xE8 un ausilio al calcolo, non consulenza fiscale.",
+  // v0.7.0 dichiarazione section
+  dichiarazioneHeader: (anno) => `\u2500\u2500 MODELLO REDDITI PF [ANNO D'IMPOSTA: ${anno}]`,
+  dichiarazioneNota: "Nota: i valori riportano i codici riga indicativi \u2014 verificare la modulistica ufficiale.",
+  dichiarazioneWarningRow: "\u26A0  I codici riga tra parentesi quadre sono indicativi. Verificare la versione corrente del modello.",
+  quadroRTHeader: "QUADRO RT \u2014 SEZIONE II (redditi diversi)",
+  quadroRTPlusvalenze: "[RT-P]  Plusvalenze totali",
+  quadroRTMinusvalenze: "[RT-M]  Minusvalenze totali",
+  quadroRTDifferenza: "[RT-D]  Differenza",
+  quadroRTRiporto: (anno) => `[RT-C*] Riporto ${anno} (consumato)`,
+  quadroRTImponibile: "[RT-N]  Imponibile netto",
+  quadroRTImposta: "[RT-I]  Imposta (26%)",
+  quadroRTRiportabile: "[RT-R]  Minusvalenze da riportare",
+  quadroRTPerdita: "perdita netta:",
+  quadroRMHeader: "QUADRO RM (redditi da capitale)",
+  quadroRMEtf26: "[RM-A1] ETF/OICR plusvalenze (26%)",
+  quadroRMImposta: "Imposta sostitutiva",
+  quadroRMBtp: "[RM-A2] BTP/WL plusvalenze (12,5%)",
+  quadroRMDividendi: "[RM-D]  Dividendi esteri lordi",
+  quadroRMRitenuta: "Ritenuta estera (credito)",
+  quadroRMCedole: "[RM-C]  Cedole obbligazionarie",
+  dichiarazioneDisclaimer: "minus-tracker \xE8 un ausilio al calcolo, non consulenza fiscale.",
+  warnNoDichiarazioneSidecar: "Eseguire prima: minus-tracker classify <file>",
+  warnNoCarryForwardProvided: "(eventuali perdite pregresse non applicate)"
 };
 
 // src/i18n/en.ts
@@ -77,6 +102,8 @@ var en = {
   warnUnsupportedCurrency: (row, currency) => `Row ${row}: unsupported currency ${currency} \u2014 skipped`,
   warnNoEcbRate: (row, currency, date) => `Row ${row}: no ECB rate for ${currency} on ${date} \u2014 skipped`,
   warnQuantityZero: (row) => `Row ${row}: quantity is 0 \u2014 skipped`,
+  warnMissingIsinIncome: (row) => `Row ${row}: income row has blank ISIN \u2014 skipped`,
+  warnOrphanWithholding: (isin, date) => `Withholding row on ${isin}/${date} has no matching income row \u2014 skipped`,
   warnMultipleYears: "CSV contains transactions from multiple years \u2014 filter to a single year for accurate reporting.",
   headerMethod: "METHOD",
   headerTaxYear: "TAX YEAR",
@@ -128,7 +155,30 @@ var en = {
   headerBucket: "BUCKET",
   warnUnclassifiedIsin: (isin) => `ISIN ${isin} not found in classification map \u2014 assigned to Bucket B.`,
   carryForwardInvalidFormat: "Invalid --carry-forward format. Use: YYYY:amount (e.g. 2023:2500)",
-  disclaimer: "minus-tracker \xE8 un ausilio al calcolo, non consulenza fiscale."
+  disclaimer: "minus-tracker \xE8 un ausilio al calcolo, non consulenza fiscale.",
+  // v0.7.0 dichiarazione section
+  dichiarazioneHeader: (anno) => `\u2500\u2500 MODELLO REDDITI PF [TAX YEAR: ${anno}]`,
+  dichiarazioneNota: "Note: row codes are indicative \u2014 verify against the official tax form.",
+  dichiarazioneWarningRow: "\u26A0  Row codes in square brackets are indicative. Check the current form version.",
+  quadroRTHeader: "QUADRO RT \u2014 SECTION II (capital gains)",
+  quadroRTPlusvalenze: "[RT-P]  Total gains",
+  quadroRTMinusvalenze: "[RT-M]  Total losses",
+  quadroRTDifferenza: "[RT-D]  Difference",
+  quadroRTRiporto: (anno) => `[RT-C*] Prior loss ${anno} (applied)`,
+  quadroRTImponibile: "[RT-N]  Net taxable",
+  quadroRTImposta: "[RT-I]  Tax (26%)",
+  quadroRTRiportabile: "[RT-R]  Losses to carry forward",
+  quadroRTPerdita: "net loss:",
+  quadroRMHeader: "QUADRO RM (capital income)",
+  quadroRMEtf26: "[RM-A1] ETF/OICR gains (26%)",
+  quadroRMImposta: "Substitute tax",
+  quadroRMBtp: "[RM-A2] BTP/WL gains (12.5%)",
+  quadroRMDividendi: "[RM-D]  Foreign dividends (gross)",
+  quadroRMRitenuta: "Foreign withholding (credit)",
+  quadroRMCedole: "[RM-C]  Bond coupons",
+  dichiarazioneDisclaimer: "minus-tracker \xE8 un ausilio al calcolo, non consulenza fiscale.",
+  warnNoDichiarazioneSidecar: "Run first: minus-tracker classify <file>",
+  warnNoCarryForwardProvided: "(prior-year losses not applied)"
 };
 
 // src/i18n/settings.ts
@@ -223,9 +273,9 @@ var ClassificationError = class extends Error {
 };
 
 // src/cli/commands/calc.ts
-import * as fs5 from "fs";
-import * as path4 from "path";
-import * as os3 from "os";
+import * as fs4 from "fs";
+import * as path3 from "path";
+import * as os2 from "os";
 
 // src/rates/index.ts
 import { fileURLToPath } from "url";
@@ -276,18 +326,6 @@ function getActiveSnapshot() {
   }
   return merged;
 }
-function isSnapshotStale(snapshot, today) {
-  const todayStr = today ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-  let maxDate = "0000-01-01";
-  for (const dates of Object.values(snapshot)) {
-    for (const d of Object.keys(dates)) {
-      if (d > maxDate) maxDate = d;
-    }
-  }
-  if (maxDate === "0000-01-01") return true;
-  const diffDays = (new Date(todayStr).getTime() - new Date(maxDate).getTime()) / (1e3 * 60 * 60 * 24);
-  return diffDays >= 7;
-}
 function subtractDays(isoDate, days) {
   const d = /* @__PURE__ */ new Date(isoDate + "T00:00:00Z");
   d.setUTCDate(d.getUTCDate() - days);
@@ -318,6 +356,10 @@ function warningToEnglish(w) {
       return `Row ${w.row}: no ECB rate for ${w.currency} on ${w.date} \u2014 skipped`;
     case "QUANTITY_ZERO":
       return `Row ${w.row}: quantity is 0 \u2014 skipped`;
+    case "MISSING_ISIN_INCOME":
+      return `Row ${w.row}: blank ISIN on income row \u2014 skipped`;
+    case "ORPHAN_WITHHOLDING":
+      return `Withholding row for ${w.isin} on ${w.date}: no matching income row \u2014 skipped`;
   }
 }
 
@@ -333,6 +375,8 @@ var REQUIRED_COLUMNS = [
   "Transaction costs currency",
   "Product"
 ];
+var INCOME_KEYWORDS = ["DIVIDEND", "COUPON", "INTEREST", "CEDOLA"];
+var TAX_KEYWORDS = ["DIVIDEND TAX", "WITHHOLDING", "RITENUTA"];
 function parseCSVRow(line) {
   const fields = [];
   let i = 0;
@@ -374,6 +418,7 @@ function parseDate(ddmmyyyy) {
 var DEGIROParser = class {
   _warningEntries = [];
   _snapshot;
+  _incomeRows = [];
   constructor(snapshot) {
     this._snapshot = snapshot;
   }
@@ -390,6 +435,7 @@ var DEGIROParser = class {
    */
   parse(csv) {
     this._warningEntries = [];
+    this._incomeRows = [];
     if (typeof csv !== "string" || csv.includes("\0")) {
       throw new ParseError("INVALID_CSV");
     }
@@ -414,17 +460,70 @@ var DEGIROParser = class {
     }
     const snapshot = this._snapshot ?? getActiveSnapshot();
     const transactions = [];
+    const incomeCandidates = [];
+    const withholdingCandidates = [];
     for (let r = 1; r < rows.length; r++) {
       const row = rows[r];
       const rowIndex = r + 1;
       if (row.every((cell) => cell.trim() === "")) continue;
       const get2 = (col) => (row[colIndex[col]] ?? "").trim();
       const isin = get2("ISIN");
+      const product = get2("Product");
+      const qtyStr = get2("Quantity");
+      const rawQty = parseFloat(qtyStr);
+      const qtyIsZeroOrBlank = qtyStr === "" || isNaN(rawQty) || rawQty === 0;
+      if (qtyIsZeroOrBlank) {
+        const upperProduct = product.toUpperCase();
+        const isTaxKeyword = TAX_KEYWORDS.some((k) => upperProduct.includes(k));
+        const isIncomeKeyword = !isTaxKeyword && INCOME_KEYWORDS.some((k) => upperProduct.includes(k));
+        if (isTaxKeyword || isIncomeKeyword) {
+          const rawLocalValue = parseFloat(get2("Local value"));
+          const localValue = isNaN(rawLocalValue) ? 0 : rawLocalValue;
+          const isoDate2 = parseDate(get2("Date"));
+          if (isTaxKeyword && localValue < 0) {
+            if (!isin) {
+              this._warningEntries.push({
+                code: "MISSING_ISIN_INCOME",
+                row: rowIndex
+              });
+              continue;
+            }
+            withholdingCandidates.push({
+              isin,
+              date: isoDate2,
+              amount: Math.abs(localValue),
+              row: rowIndex
+            });
+            continue;
+          }
+          if (isIncomeKeyword && localValue > 0) {
+            if (!isin) {
+              this._warningEntries.push({
+                code: "MISSING_ISIN_INCOME",
+                row: rowIndex
+              });
+              continue;
+            }
+            const incomeType = upperProduct.includes(
+              "DIVIDEND"
+            ) ? "dividend" : "coupon";
+            incomeCandidates.push({
+              isin,
+              product,
+              date: isoDate2,
+              incomeType,
+              localValue,
+              currency: get2("Local value currency"),
+              row: rowIndex
+            });
+            continue;
+          }
+        }
+      }
       if (!isin) {
         this._warningEntries.push({ code: "MISSING_ISIN", row: rowIndex });
         continue;
       }
-      const rawQty = parseFloat(get2("Quantity"));
       if (isNaN(rawQty) || rawQty === 0) {
         this._warningEntries.push({ code: "QUANTITY_ZERO", row: rowIndex });
         continue;
@@ -465,7 +564,6 @@ var DEGIROParser = class {
       const rawFees = parseFloat(get2("Transaction costs"));
       const feesEUR = Math.abs(isNaN(rawFees) ? 0 : rawFees);
       const pricePerUnit = parseFloat(get2("Price"));
-      const product = get2("Product");
       transactions.push({
         isin,
         product,
@@ -480,6 +578,73 @@ var DEGIROParser = class {
         fxRate
       });
     }
+    const withholdingByKey = /* @__PURE__ */ new Map();
+    for (const w of withholdingCandidates) {
+      const key = `${w.isin}|${w.date}`;
+      const existing = withholdingByKey.get(key);
+      withholdingByKey.set(key, {
+        isin: w.isin,
+        date: w.date,
+        amount: (existing?.amount ?? 0) + w.amount
+      });
+    }
+    const consumedKeys = /* @__PURE__ */ new Set();
+    const incomeRows = [];
+    for (const c of incomeCandidates) {
+      const key = `${c.isin}|${c.date}`;
+      const matchedWithholding = withholdingByKey.get(key);
+      let grossAmount;
+      let withholdingTax;
+      let fxRate;
+      if (c.currency === "EUR") {
+        grossAmount = Math.abs(c.localValue);
+        withholdingTax = matchedWithholding?.amount ?? 0;
+        fxRate = void 0;
+      } else {
+        const rate = lookupRate(c.currency, c.date, snapshot);
+        if (rate === null) {
+          if (snapshot[c.currency] === void 0) {
+            this._warningEntries.push({
+              code: "UNSUPPORTED_CURRENCY",
+              row: c.row,
+              currency: c.currency
+            });
+          } else {
+            this._warningEntries.push({
+              code: "NO_ECB_RATE",
+              row: c.row,
+              currency: c.currency,
+              date: c.date
+            });
+          }
+          continue;
+        }
+        grossAmount = Math.abs(c.localValue) / rate;
+        withholdingTax = matchedWithholding ? matchedWithholding.amount / rate : 0;
+        fxRate = rate;
+      }
+      if (matchedWithholding) consumedKeys.add(key);
+      incomeRows.push({
+        isin: c.isin,
+        product: c.product,
+        date: c.date,
+        incomeType: c.incomeType,
+        grossAmount,
+        withholdingTax,
+        currency: c.currency,
+        fxRate
+      });
+    }
+    for (const [key, w] of withholdingByKey) {
+      if (!consumedKeys.has(key)) {
+        this._warningEntries.push({
+          code: "ORPHAN_WITHHOLDING",
+          isin: w.isin,
+          date: w.date
+        });
+      }
+    }
+    this._incomeRows = incomeRows;
     return transactions;
   }
   get warnings() {
@@ -488,12 +653,136 @@ var DEGIROParser = class {
   get warningEntries() {
     return this._warningEntries;
   }
+  get incomeRows() {
+    return this._incomeRows;
+  }
 };
 
-// src/calculator/index.ts
+// src/dichiarazione/engine.ts
+import { writeFile } from "fs/promises";
 function roundHalfUp(x) {
   return Math.sign(x) * Math.round(Math.abs(x) * 100) / 100;
 }
+function buildQuadroRT(bucketB, carryForward, taxYear) {
+  const plusvalenze = bucketB.plusvalenze;
+  const minusvalenze = bucketB.minusvalenze;
+  const differenza = roundHalfUp(plusvalenze - minusvalenze);
+  if (differenza > 0) {
+    const sorted = [...carryForward].sort((a, b) => a.year - b.year);
+    let remaining = differenza;
+    const carryForwardApplied = [];
+    for (const entry of sorted) {
+      if (taxYear - entry.year > 4) continue;
+      const consumed = Math.min(entry.amount, remaining);
+      if (consumed > 0) {
+        carryForwardApplied.push({
+          annoOrigine: entry.year,
+          importo: roundHalfUp(consumed)
+        });
+        remaining -= consumed;
+      }
+    }
+    const imponibileNetto = roundHalfUp(remaining);
+    const imposta = roundHalfUp(imponibileNetto * 0.26);
+    return {
+      plusvalenze,
+      minusvalenze,
+      differenza,
+      carryForwardApplied,
+      imponibileNetto,
+      imposta,
+      carryForwardRiportato: []
+    };
+  } else if (differenza < 0) {
+    return {
+      plusvalenze,
+      minusvalenze,
+      differenza,
+      carryForwardApplied: [],
+      imponibileNetto: 0,
+      imposta: 0,
+      carryForwardRiportato: [
+        { annoOrigine: taxYear, importo: roundHalfUp(Math.abs(differenza)) }
+      ]
+    };
+  } else {
+    return {
+      plusvalenze,
+      minusvalenze,
+      differenza: 0,
+      carryForwardApplied: [],
+      imponibileNetto: 0,
+      imposta: 0,
+      carryForwardRiportato: []
+    };
+  }
+}
+function buildQuadroRM(bucketA, incomeRows, taxYear) {
+  const groups = bucketA?.groups ?? [];
+  const group26 = groups.find((g) => g.taxRate === 0.26);
+  const group125 = groups.find((g) => g.taxRate === 0.125);
+  const capitaleAliquota26 = {
+    plusvalenze: group26?.plusvalenze ?? 0,
+    imposta: group26?.imposta ?? 0
+  };
+  const capitaleAliquota125 = {
+    plusvalenze: group125?.plusvalenze ?? 0,
+    imposta: group125?.imposta ?? 0
+  };
+  const dividendiEsteri = incomeRows.filter((r) => r.incomeType === "dividend").map((r) => ({
+    isin: r.isin,
+    prodotto: r.product,
+    lordo: r.grossAmount,
+    rittenutaEstera: r.withholdingTax
+  }));
+  const cedole = incomeRows.filter((r) => r.incomeType === "coupon").map((r) => ({
+    isin: r.isin,
+    prodotto: r.product,
+    importo: r.grossAmount,
+    rittenutaEstera: r.withholdingTax
+  }));
+  return {
+    capitaleAliquota26,
+    capitaleAliquota125,
+    dividendiEsteri,
+    cedole
+  };
+}
+function buildDichiarazioneReport(quadroRT, quadroRM, taxYear) {
+  const version = 1;
+  const modello = "Redditi PF";
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    version,
+    annoImposta: taxYear,
+    modello,
+    generatedAt,
+    quadroRT,
+    quadroRM,
+    exportTo: async (path7) => {
+      await writeFile(
+        path7,
+        JSON.stringify(
+          {
+            version,
+            annoImposta: taxYear,
+            modello,
+            generatedAt,
+            quadroRT,
+            quadroRM
+          },
+          null,
+          2
+        )
+      );
+    }
+  };
+}
+
+// src/calculator/index.ts
+function roundHalfUp2(x) {
+  return Math.sign(x) * Math.round(Math.abs(x) * 100) / 100;
+}
 function inferTaxYear(transactions) {
   const counts = {};
   for (const t of transactions) {
@@ -585,9 +874,9 @@ var Calculator = class {
             sellDate: tx.date,
             buyPriceEUR: lot.pricePerUnitEUR,
             sellPriceEUR: sellPricePerUnitEUR,
-            buyCostEUR: roundHalfUp(buyCostEUR),
-            sellProceedsEUR: roundHalfUp(sellProceedsEUR),
-            gainLossEUR: roundHalfUp(gainLossEUR),
+            buyCostEUR: roundHalfUp2(buyCostEUR),
+            sellProceedsEUR: roundHalfUp2(sellProceedsEUR),
+            gainLossEUR: roundHalfUp2(gainLossEUR),
             buyFxRate: lot.fxRate,
             sellFxRate: tx.fxRate
           });
@@ -642,12 +931,12 @@ var Calculator = class {
       const bucketAGroups = [...groupsByRate.entries()].map(([taxRate, g]) => ({
         taxRate,
         assetClasses: [...g.assetClasses],
-        plusvalenze: roundHalfUp(g.plusvalenze),
-        imposta: roundHalfUp(g.plusvalenze * taxRate)
+        plusvalenze: roundHalfUp2(g.plusvalenze),
+        imposta: roundHalfUp2(g.plusvalenze * taxRate)
       }));
       const bucketAReport = {
         groups: bucketAGroups,
-        totalImposta: roundHalfUp(
+        totalImposta: roundHalfUp2(
           bucketAGroups.reduce((s, g) => s + g.imposta, 0)
         )
       };
@@ -658,8 +947,8 @@ var Calculator = class {
         if (lot.gainLossEUR >= 0) bPlusvalenze += lot.gainLossEUR;
         else bMinusvalenze += Math.abs(lot.gainLossEUR);
       }
-      bPlusvalenze = roundHalfUp(bPlusvalenze);
-      bMinusvalenze = roundHalfUp(bMinusvalenze);
+      bPlusvalenze = roundHalfUp2(bPlusvalenze);
+      bMinusvalenze = roundHalfUp2(bMinusvalenze);
       const carryForwards = [...this._options.carryForward ?? []].sort(
         (a, b) => a.year - b.year
       );
@@ -672,11 +961,11 @@ var Calculator = class {
         carryForwardApplied += consumed;
         remaining -= consumed;
       }
-      carryForwardApplied = roundHalfUp(carryForwardApplied);
-      const bNetResult = roundHalfUp(
+      carryForwardApplied = roundHalfUp2(carryForwardApplied);
+      const bNetResult = roundHalfUp2(
         bPlusvalenze - bMinusvalenze - carryForwardApplied
       );
-      const carryForwardRemaining = roundHalfUp(Math.max(0, -bNetResult));
+      const carryForwardRemaining = roundHalfUp2(Math.max(0, -bNetResult));
       const bucketBReport = {
         plusvalenze: bPlusvalenze,
         minusvalenze: bMinusvalenze,
@@ -684,18 +973,41 @@ var Calculator = class {
         carryForwardRemaining,
         netResult: bNetResult
       };
+      const allIncomeRows = this._options.incomeRows ?? [];
+      const filteredIncomeRows = allIncomeRows.filter(
+        (row) => new Date(row.date).getFullYear() === taxYear
+      );
+      if (filteredIncomeRows.length < allIncomeRows.length) {
+        warnings.push(`Income rows outside tax year ${taxYear} were skipped.`);
+      }
+      const quadroRT = buildQuadroRT(
+        bucketBReport,
+        this._options.carryForward ?? [],
+        taxYear
+      );
+      const quadroRM = buildQuadroRM(
+        bucketAGroups.length > 0 ? bucketAReport : void 0,
+        filteredIncomeRows,
+        taxYear
+      );
+      const dichiarazioneReport = buildDichiarazioneReport(
+        quadroRT,
+        quadroRM,
+        taxYear
+      );
       return {
         method,
         taxYear,
-        plusvalenze: roundHalfUp(plusvalenze),
-        minusvalenze: roundHalfUp(minusvalenze),
-        netResult: roundHalfUp(plusvalenze - minusvalenze),
+        plusvalenze: roundHalfUp2(plusvalenze),
+        minusvalenze: roundHalfUp2(minusvalenze),
+        netResult: roundHalfUp2(plusvalenze - minusvalenze),
         lots: matchedLots,
         ratesUsed,
         warnings,
         generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
         bucketA: bucketAGroups.length > 0 ? bucketAReport : void 0,
-        bucketB: bucketBReport
+        bucketB: bucketBReport,
+        dichiarazione: dichiarazioneReport
       };
     } else {
       const allIsins = [...new Set(this._transactions.map((t) => t.isin))];
@@ -710,9 +1022,9 @@ var Calculator = class {
     return {
       method,
       taxYear,
-      plusvalenze: roundHalfUp(plusvalenze),
-      minusvalenze: roundHalfUp(minusvalenze),
-      netResult: roundHalfUp(plusvalenze - minusvalenze),
+      plusvalenze: roundHalfUp2(plusvalenze),
+      minusvalenze: roundHalfUp2(minusvalenze),
+      netResult: roundHalfUp2(plusvalenze - minusvalenze),
       lots: matchedLots,
       ratesUsed,
       warnings,
@@ -934,7 +1246,7 @@ function classifyByType(isin, securityType, product, warnings) {
     };
   }
   warnings.push(
-    `Unrecognized type: ${securityType}. Please classify manually.`
+    `Unrecognized type for ${isin}: ${securityType}. Please classify manually.`
   );
   return {
     product,
@@ -947,6 +1259,84 @@ function classifyByType(isin, securityType, product, warnings) {
     source: "user"
   };
 }
+var ASSET_CLASS_DEFAULTS = {
+  ETF: {
+    assetClass: "ETF",
+    bucketGain: "A",
+    bucketLoss: "B",
+    taxRate: 0.26,
+    whiteListed: null
+  },
+  Stock: {
+    assetClass: "Stock",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null
+  },
+  ETC: {
+    assetClass: "ETC",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null
+  },
+  GovtBondWL: {
+    assetClass: "GovtBondWL",
+    bucketGain: "A",
+    bucketLoss: "B",
+    taxRate: 0.125,
+    whiteListed: true
+  },
+  GovtBondOther: {
+    assetClass: "GovtBondOther",
+    bucketGain: "A",
+    bucketLoss: "B",
+    taxRate: 0.26,
+    whiteListed: false
+  },
+  CorpBond: {
+    assetClass: "CorpBond",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null
+  },
+  Derivative: {
+    assetClass: "Derivative",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null
+  },
+  LeverageCert: {
+    assetClass: "LeverageCert",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null
+  },
+  CapProtectedCert: {
+    assetClass: "CapProtectedCert",
+    bucketGain: "A",
+    bucketLoss: "B",
+    taxRate: 0.26,
+    whiteListed: null
+  }
+};
+function buildEntryFromAssetClass(assetClass, product) {
+  const mapped = ASSET_CLASS_DEFAULTS[assetClass];
+  return {
+    product,
+    assetClass: mapped.assetClass,
+    bucketGain: mapped.bucketGain,
+    bucketLoss: mapped.bucketLoss,
+    taxRate: mapped.taxRate,
+    whiteListed: mapped.whiteListed,
+    confirmedByUser: true,
+    source: "user"
+  };
+}
 var Classifier = class {
   interactive;
   constructor(options) {
@@ -968,7 +1358,7 @@ var Classifier = class {
     }
     return parsed.classifications;
   }
-  async classify(transactions, sidecarPath, _httpPost = httpsPost) {
+  async classify(transactions, sidecarPath, options, _httpPost = httpsPost) {
     const isinToProduct = /* @__PURE__ */ new Map();
     for (const tx of transactions) {
       if (tx.isin && !isinToProduct.has(tx.isin)) {
@@ -976,13 +1366,21 @@ var Classifier = class {
       }
     }
     const confirmed = {};
-    if (fs3.existsSync(sidecarPath)) {
-      const existingMap = await this.load(sidecarPath);
-      for (const [isin, entry] of Object.entries(existingMap)) {
-        if (entry.confirmedByUser) {
-          confirmed[isin] = entry;
+    if (sidecarPath !== void 0) {
+      if (fs3.existsSync(sidecarPath)) {
+        const existingMap = await this.load(sidecarPath);
+        for (const [isin, entry] of Object.entries(existingMap)) {
+          if (entry.confirmedByUser) {
+            confirmed[isin] = entry;
+          }
         }
       }
+    } else if (options?.existingClassification) {
+      Object.assign(confirmed, options.existingClassification);
+    }
+    for (const [isin, assetClass] of Object.entries(options?.overrides ?? {})) {
+      const product = isinToProduct.get(isin) ?? isin;
+      confirmed[isin] = buildEntryFromAssetClass(assetClass, product);
     }
     const toProcess = [];
     for (const isin of isinToProduct.keys()) {
@@ -992,76 +1390,100 @@ var Classifier = class {
     }
     const warnings = [];
     const newEntries = {};
-    const BATCH_SIZE = 10;
-    for (let i = 0; i < toProcess.length; i += BATCH_SIZE) {
-      if (i > 0) {
-        await new Promise((resolve2) => setTimeout(resolve2, 6e3));
+    if (options?.offline) {
+      for (const isin of toProcess) {
+        const product = isinToProduct.get(isin) ?? isin;
+        warnings.push(
+          `Unrecognized type for ${isin}: unknown. Please classify manually.`
+        );
+        newEntries[isin] = {
+          product,
+          assetClass: "Stock",
+          bucketGain: "B",
+          bucketLoss: "B",
+          taxRate: 0,
+          whiteListed: null,
+          confirmedByUser: false,
+          source: "user"
+        };
       }
-      const batch = toProcess.slice(i, i + BATCH_SIZE);
-      const requestBody = JSON.stringify(
-        batch.map((isin) => ({ idType: "ID_ISIN", idValue: isin }))
-      );
-      let response = null;
-      for (let attempt = 0; attempt < 2; attempt++) {
-        try {
-          const r = await _httpPost(
-            "https://api.openfigi.com/v3/mapping",
-            requestBody,
-            1e4
-          );
-          if (r.status < 500) {
-            response = r;
-            break;
+    } else {
+      const BATCH_SIZE = 10;
+      const totalBatches = Math.ceil(toProcess.length / BATCH_SIZE);
+      for (let i = 0; i < toProcess.length; i += BATCH_SIZE) {
+        if (i > 0) {
+          await new Promise((resolve2) => setTimeout(resolve2, 6e3));
+        }
+        const batch = toProcess.slice(i, i + BATCH_SIZE);
+        const requestBody = JSON.stringify(
+          batch.map((isin) => ({ idType: "ID_ISIN", idValue: isin }))
+        );
+        let response = null;
+        for (let attempt = 0; attempt < 2; attempt++) {
+          try {
+            const r = await _httpPost(
+              "https://api.openfigi.com/v3/mapping",
+              requestBody,
+              1e4
+            );
+            if (r.status < 500) {
+              response = r;
+              break;
+            }
+          } catch {
+            throw new ClassificationError("NETWORK_ERROR");
           }
-        } catch {
+        }
+        if (response === null) {
           throw new ClassificationError("NETWORK_ERROR");
         }
-      }
-      if (response === null) {
-        throw new ClassificationError("NETWORK_ERROR");
-      }
-      const results = JSON.parse(response.data);
-      for (let j = 0; j < batch.length; j++) {
-        const isin = batch[j];
-        const result = results[j];
-        const product = isinToProduct.get(isin) ?? isin;
-        if (!result || result.error || !result.data || result.data.length === 0) {
-          warnings.push(
-            `Unrecognized type: unknown. Please classify manually.`
-          );
-          newEntries[isin] = {
-            product,
-            assetClass: "Stock",
-            bucketGain: "B",
-            bucketLoss: "B",
-            taxRate: 0,
-            whiteListed: null,
-            confirmedByUser: false,
-            source: "user"
-          };
-          continue;
+        const results = JSON.parse(response.data);
+        for (let j = 0; j < batch.length; j++) {
+          const isin = batch[j];
+          const result = results[j];
+          const product = isinToProduct.get(isin) ?? isin;
+          if (!result || result.error || !result.data || result.data.length === 0) {
+            warnings.push(
+              `Unrecognized type for ${isin}: unknown. Please classify manually.`
+            );
+            newEntries[isin] = {
+              product,
+              assetClass: "Stock",
+              bucketGain: "B",
+              bucketLoss: "B",
+              taxRate: 0,
+              whiteListed: null,
+              confirmedByUser: false,
+              source: "user"
+            };
+            continue;
+          }
+          const st = result.data[0]?.securityType;
+          const st2 = result.data[0]?.securityType2;
+          const typeToUse = st && isKnownType(st) ? st : st2 && isKnownType(st2) ? st2 : st ?? st2 ?? "Unknown";
+          newEntries[isin] = classifyByType(isin, typeToUse, product, warnings);
         }
-        const st = result.data[0]?.securityType;
-        const st2 = result.data[0]?.securityType2;
-        const typeToUse = st && isKnownType(st) ? st : st2 && isKnownType(st2) ? st2 : st ?? st2 ?? "Unknown";
-        newEntries[isin] = classifyByType(isin, typeToUse, product, warnings);
+        const batchIndex = i / BATCH_SIZE;
+        options?.onBatchProgress?.(batchIndex + 1, totalBatches);
       }
     }
     const mergedMap = { ...newEntries, ...confirmed };
-    const sidecarContent = JSON.stringify(
-      {
-        version: 1,
-        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        classifications: mergedMap,
-        warnings
-      },
-      null,
-      2
-    );
-    try {
-      fs3.writeFileSync(sidecarPath, sidecarContent, "utf-8");
-    } catch {
-      throw new ClassificationError("WRITE_ERROR");
+    if (sidecarPath !== void 0) {
+      const sidecarContent = JSON.stringify(
+        {
+          version: 1,
+          generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          classifications: mergedMap,
+          warnings
+        },
+        null,
+        2
+      );
+      try {
+        fs3.writeFileSync(sidecarPath, sidecarContent, "utf-8");
+      } catch {
+        throw new ClassificationError("WRITE_ERROR");
+      }
     }
     return mergedMap;
   }
@@ -1084,7 +1506,80 @@ function assetClassLabel(ac, s) {
   if (ac === "GovtBondWL" || ac === "GovtBondOther") return s.bucketABtpWl;
   return ac;
 }
-function renderReport(report, s) {
+function renderDichiarazione(report, s, carryForwardWasProvided) {
+  const d = report.dichiarazione;
+  const rt = d.quadroRT;
+  const rm = d.quadroRM;
+  const fmt = (n) => formatEUR(n, s.numberLocale);
+  const lines = [];
+  lines.push(SEPARATOR);
+  lines.push(s.dichiarazioneHeader(d.annoImposta));
+  lines.push(s.dichiarazioneNota);
+  lines.push("");
+  lines.push(s.quadroRTHeader);
+  lines.push(`  ${s.quadroRTPlusvalenze}  ${fmt(rt.plusvalenze)}`);
+  lines.push(`  ${s.quadroRTMinusvalenze}  ${fmt(rt.minusvalenze)}`);
+  lines.push(`  ${s.quadroRTDifferenza}  ${fmt(rt.differenza)}`);
+  for (const entry of rt.carryForwardApplied) {
+    lines.push(
+      `  ${s.quadroRTRiporto(entry.annoOrigine)}  ${fmt(entry.importo)}`
+    );
+  }
+  let rtNLine = `  ${s.quadroRTImponibile}  ${fmt(rt.imponibileNetto)}`;
+  if (rt.differenza < 0) {
+    rtNLine += `   (${s.quadroRTPerdita} ${fmt(Math.abs(rt.differenza))})`;
+  }
+  if (rt.differenza > 0 && !carryForwardWasProvided) {
+    rtNLine += ` ${s.warnNoCarryForwardProvided}`;
+  }
+  lines.push(rtNLine);
+  lines.push(`  ${s.quadroRTImposta}  ${fmt(rt.imposta)}`);
+  if (rt.differenza < 0) {
+    const riportato = rt.carryForwardRiportato.reduce(
+      (sum, e) => sum + e.importo,
+      0
+    );
+    lines.push(
+      `  ${s.quadroRTRiportabile}  ${fmt(riportato)}  ${s.bucketBCarryNote}`
+    );
+  }
+  lines.push("");
+  lines.push(s.quadroRMHeader);
+  if (rm.capitaleAliquota26.plusvalenze > 0) {
+    lines.push(
+      `  ${s.quadroRMEtf26}  ${fmt(rm.capitaleAliquota26.plusvalenze)}`
+    );
+    lines.push(
+      `  [RM-A1] ${s.quadroRMImposta}  ${fmt(rm.capitaleAliquota26.imposta)}`
+    );
+  }
+  if (rm.capitaleAliquota125.plusvalenze > 0) {
+    lines.push(
+      `  ${s.quadroRMBtp}  ${fmt(rm.capitaleAliquota125.plusvalenze)}`
+    );
+    lines.push(
+      `  [RM-A2] ${s.quadroRMImposta}  ${fmt(rm.capitaleAliquota125.imposta)}`
+    );
+  }
+  for (const div of rm.dividendiEsteri) {
+    lines.push(
+      `  ${s.quadroRMDividendi} \u2014 ${div.prodotto} (${div.isin})  ${fmt(div.lordo)}`
+    );
+    lines.push(
+      `  [RM-D]  ${s.quadroRMRitenuta} \u2014 ${div.prodotto} (${div.isin})  ${fmt(div.rittenutaEstera)}`
+    );
+  }
+  for (const c of rm.cedole) {
+    lines.push(
+      `  ${s.quadroRMCedole} \u2014 ${c.prodotto} (${c.isin})  ${fmt(c.importo)}`
+    );
+  }
+  lines.push("");
+  lines.push(s.dichiarazioneWarningRow);
+  lines.push(s.dichiarazioneDisclaimer);
+  return lines.join("\n");
+}
+function renderReport(report, s, carryForwardWasProvided) {
   const fmt = (n) => formatEUR(n, s.numberLocale);
   const lines = [];
   const hasBuckets = !!(report.bucketA || report.bucketB);
@@ -1173,111 +1668,12 @@ function renderReport(report, s) {
     lines.push(s.warnMixedBuckets);
     lines.push("");
   }
-  lines.push(s.disclaimer);
-  return lines.join("\n");
-}
-
-// src/cli/commands/rates.ts
-import * as fs4 from "fs";
-import * as path3 from "path";
-import * as os2 from "os";
-import * as https2 from "https";
-function getSnapshotPath() {
-  const platform = process.platform;
-  let configDir;
-  if (platform === "win32") {
-    configDir = process.env.APPDATA ?? path3.join(os2.homedir(), "AppData", "Roaming");
+  if (report.dichiarazione) {
+    lines.push(renderDichiarazione(report, s, carryForwardWasProvided));
   } else {
-    configDir = process.env.XDG_CONFIG_HOME ?? path3.join(os2.homedir(), ".config");
+    lines.push(s.disclaimer);
   }
-  return path3.join(configDir, "minus-tracker", "ecb-rates.json");
-}
-function getCoverage(snapshot) {
-  let start = "9999-12-31";
-  let end = "0000-01-01";
-  const currencies = [];
-  for (const [ccy, dates] of Object.entries(snapshot)) {
-    currencies.push(ccy);
-    for (const d of Object.keys(dates)) {
-      if (d < start) start = d;
-      if (d > end) end = d;
-    }
-  }
-  return { start, end, currencies: currencies.sort().join(", ") };
-}
-async function fetchEcbData(currency) {
-  return new Promise((resolve2, reject) => {
-    const url = `https://data-api.ecb.europa.eu/service/data/EXR/D.${currency}.EUR.SP00.A?format=csvdata&startPeriod=2019-01-01`;
-    https2.get(url, (res) => {
-      let data = "";
-      res.on("data", (chunk) => data += chunk);
-      res.on("end", () => {
-        const rates = {};
-        const lines = data.split("\n");
-        for (const line of lines) {
-          const parts = line.split(",");
-          if (parts.length < 8) continue;
-          const date = parts[6].trim();
-          const rate = parseFloat(parts[7].trim());
-          if (/^\d{4}-\d{2}-\d{2}$/.test(date) && !isNaN(rate) && rate > 0) {
-            rates[date] = rate;
-          }
-        }
-        resolve2(rates);
-      });
-      res.on("error", reject);
-    }).on("error", reject);
-  });
-}
-async function updateRates(snapshotPath, stdout, stderr, s) {
-  stdout.write(s.ratesUpdateFetching + "\n");
-  let existing = {};
-  try {
-    existing = JSON.parse(
-      fs4.readFileSync(snapshotPath, "utf8")
-    );
-  } catch {
-  }
-  let addedCount = 0;
-  for (const currency of ["USD", "GBP", "CHF"]) {
-    try {
-      const newRates = await fetchEcbData(currency);
-      const existing_ccy = existing[currency] ?? {};
-      let added = 0;
-      for (const [date, rate] of Object.entries(newRates)) {
-        if (!existing_ccy[date]) added++;
-        existing_ccy[date] = rate;
-      }
-      existing[currency] = existing_ccy;
-      addedCount += added;
-    } catch {
-      stderr.write(`Failed to fetch ${currency} rates
-`);
-    }
-  }
-  fs4.mkdirSync(path3.dirname(snapshotPath), { recursive: true });
-  fs4.writeFileSync(
-    snapshotPath,
-    JSON.stringify(existing, null, 2) + "\n",
-    "utf8"
-  );
-  stdout.write(s.ratesUpdateDone(addedCount) + "\n");
-  stdout.write(s.ratesSnapshotWritten(snapshotPath) + "\n");
-}
-async function runRates(positional, flags, s, stdout, stderr) {
-  if (flags["check"]) {
-    const snapshot = getActiveSnapshot();
-    const { start, end, currencies } = getCoverage(snapshot);
-    stdout.write(s.ratesCoverage(start, end, currencies) + "\n");
-    stdout.write(s.ratesGapsNone + "\n");
-    return 0;
-  }
-  if (flags["update"]) {
-    await updateRates(getSnapshotPath(), stdout, stderr, s);
-    return 0;
-  }
-  stderr.write("Usage: minus-tracker rates --check | --update\n");
-  return 2;
+  return lines.join("\n");
 }
 
 // src/cli/commands/calc.ts
@@ -1291,30 +1687,12 @@ async function runCalc(positional, flags, s, stdout, stderr) {
   }
   let csv;
   try {
-    csv = fs5.readFileSync(filePath, "utf8");
+    csv = fs4.readFileSync(filePath, "utf8");
   } catch {
     stderr.write(`Cannot read file: ${filePath}
 `);
     return 1;
   }
-  try {
-    const snapshot = getActiveSnapshot();
-    if (isSnapshotStale(snapshot)) {
-      stderr.write(s.ratesAutoUpdateStart + "\n");
-      try {
-        await updateRates(getSnapshotPath(), stdout, stderr, s);
-      } catch {
-        stderr.write(s.ratesAutoUpdateFailed + "\n");
-      }
-    }
-  } catch {
-    stderr.write(s.ratesAutoUpdateStart + "\n");
-    try {
-      await updateRates(getSnapshotPath(), stdout, stderr, s);
-    } catch {
-      stderr.write(s.ratesAutoUpdateFailed + "\n");
-    }
-  }
   const method = flags["method"] ?? "LIFO";
   if (method !== "LIFO" && method !== "FIFO") {
     stderr.write("--method must be LIFO or FIFO\n");
@@ -1322,7 +1700,7 @@ async function runCalc(positional, flags, s, stdout, stderr) {
   }
   const sidecarPath = filePath.replace(/\.csv$/i, "") + ".classify.json";
   let classification;
-  if (fs5.existsSync(sidecarPath)) {
+  if (fs4.existsSync(sidecarPath)) {
     try {
       const classifier = new Classifier({ interactive: false });
       classification = await classifier.load(sidecarPath);
@@ -1332,6 +1710,13 @@ async function runCalc(positional, flags, s, stdout, stderr) {
       return 1;
     }
   }
+  const exportFlagRaw = flags["export-dichiarazione"];
+  const exportRequested = exportFlagRaw !== void 0 && exportFlagRaw !== false;
+  const exportPath = typeof exportFlagRaw === "string" ? exportFlagRaw : filePath.replace(/\.csv$/i, "") + ".dichiarazione.json";
+  if (exportRequested && classification === void 0) {
+    stderr.write(s.warnNoDichiarazioneSidecar + "\n");
+    return 1;
+  }
   const rawCf = flags["carry-forward"];
   const rawCarryForwards = Array.isArray(rawCf) ? rawCf : rawCf ? [rawCf] : [];
   const cfRegex = /^\d{4}:\d+(\.\d+)?$/;
@@ -1341,16 +1726,16 @@ async function runCalc(positional, flags, s, stdout, stderr) {
       return 2;
     }
   }
-  const xdgConfig = process.env["XDG_CONFIG_HOME"] ?? path4.join(os3.homedir(), ".config");
-  const cfConfigPath = path4.join(
+  const xdgConfig = process.env["XDG_CONFIG_HOME"] ?? path3.join(os2.homedir(), ".config");
+  const cfConfigPath = path3.join(
     xdgConfig,
     "minus-tracker",
     "carryforward.json"
   );
   const cfFromFile = {};
-  if (fs5.existsSync(cfConfigPath)) {
+  if (fs4.existsSync(cfConfigPath)) {
     try {
-      const raw = JSON.parse(fs5.readFileSync(cfConfigPath, "utf-8"));
+      const raw = JSON.parse(fs4.readFileSync(cfConfigPath, "utf-8"));
       for (const entry of raw.losses ?? []) {
         cfFromFile[entry.year] = entry.amount;
       }
@@ -1382,19 +1767,36 @@ async function runCalc(positional, flags, s, stdout, stderr) {
   }
   const calculator = new Calculator(transactions, parser.warnings, {
     classification,
-    carryForward: carryForward.length > 0 ? carryForward : void 0
+    carryForward: carryForward.length > 0 ? carryForward : void 0,
+    incomeRows: parser.incomeRows
   });
   const report = calculator.calculateGains(method);
+  const carryForwardWasProvided = carryForward.length > 0;
+  if (exportRequested) {
+    try {
+      await report.dichiarazione.exportTo(exportPath);
+    } catch {
+      stderr.write(`Cannot write dichiarazione export: ${exportPath}
+`);
+      return 1;
+    }
+  }
   if (flags["json"]) {
-    stdout.write(JSON.stringify(report, null, 2) + "\n");
+    const { dichiarazione: _dichiarazione, ...jsonReport } = report;
+    stdout.write(JSON.stringify(jsonReport, null, 2) + "\n");
   } else {
-    stdout.write(renderReport(report, s) + "\n");
+    stdout.write(renderReport(report, s, carryForwardWasProvided) + "\n");
+  }
+  if (exportRequested) {
+    stdout.write(s.classifyWritten(exportPath) + "\n");
+  } else if (!report.dichiarazione) {
+    stderr.write(s.warnNoDichiarazioneSidecar + "\n");
   }
   return 0;
 }
 
 // src/cli/commands/validate.ts
-import * as fs6 from "fs";
+import * as fs5 from "fs";
 async function runValidate(positional, flags, s, stdout, stderr) {
   const filePath = positional[0];
   if (!filePath) {
@@ -1403,7 +1805,7 @@ async function runValidate(positional, flags, s, stdout, stderr) {
   }
   let csv;
   try {
-    csv = fs6.readFileSync(filePath, "utf8");
+    csv = fs5.readFileSync(filePath, "utf8");
   } catch {
     stderr.write(`Cannot read file: ${filePath}
 `);
@@ -1440,12 +1842,121 @@ async function runValidate(positional, flags, s, stdout, stderr) {
       case "QUANTITY_ZERO":
         reason = s.warnQuantityZero(entry.row);
         break;
+      case "MISSING_ISIN_INCOME":
+        reason = s.warnMissingIsinIncome(entry.row);
+        break;
+      case "ORPHAN_WITHHOLDING":
+        reason = s.warnOrphanWithholding(entry.isin, entry.date);
+        break;
     }
     stdout.write(reason + "\n");
   }
   return 0;
 }
 
+// src/cli/commands/rates.ts
+import * as fs6 from "fs";
+import * as path4 from "path";
+import * as os3 from "os";
+import * as https2 from "https";
+function getSnapshotPath() {
+  const platform = process.platform;
+  let configDir;
+  if (platform === "win32") {
+    configDir = process.env.APPDATA ?? path4.join(os3.homedir(), "AppData", "Roaming");
+  } else {
+    configDir = process.env.XDG_CONFIG_HOME ?? path4.join(os3.homedir(), ".config");
+  }
+  return path4.join(configDir, "minus-tracker", "ecb-rates.json");
+}
+function getCoverage(snapshot) {
+  let start = "9999-12-31";
+  let end = "0000-01-01";
+  const currencies = [];
+  for (const [ccy, dates] of Object.entries(snapshot)) {
+    currencies.push(ccy);
+    for (const d of Object.keys(dates)) {
+      if (d < start) start = d;
+      if (d > end) end = d;
+    }
+  }
+  return { start, end, currencies: currencies.sort().join(", ") };
+}
+async function fetchEcbData(currency) {
+  return new Promise((resolve2, reject) => {
+    const url = `https://data-api.ecb.europa.eu/service/data/EXR/D.${currency}.EUR.SP00.A?format=csvdata&startPeriod=2019-01-01`;
+    https2.get(url, (res) => {
+      let data = "";
+      res.on("data", (chunk) => data += chunk);
+      res.on("end", () => {
+        const rates = {};
+        const lines = data.split("\n");
+        for (const line of lines) {
+          const parts = line.split(",");
+          if (parts.length < 8) continue;
+          const date = parts[6].trim();
+          const rate = parseFloat(parts[7].trim());
+          if (/^\d{4}-\d{2}-\d{2}$/.test(date) && !isNaN(rate) && rate > 0) {
+            rates[date] = rate;
+          }
+        }
+        resolve2(rates);
+      });
+      res.on("error", reject);
+    }).on("error", reject);
+  });
+}
+async function updateRates(snapshotPath, stdout, stderr, s) {
+  stdout.write(s.ratesUpdateFetching + "\n");
+  let existing = {};
+  try {
+    existing = JSON.parse(
+      fs6.readFileSync(snapshotPath, "utf8")
+    );
+  } catch {
+  }
+  let addedCount = 0;
+  for (const currency of ["USD", "GBP", "CHF"]) {
+    try {
+      const newRates = await fetchEcbData(currency);
+      const existing_ccy = existing[currency] ?? {};
+      let added = 0;
+      for (const [date, rate] of Object.entries(newRates)) {
+        if (!existing_ccy[date]) added++;
+        existing_ccy[date] = rate;
+      }
+      existing[currency] = existing_ccy;
+      addedCount += added;
+    } catch {
+      stderr.write(`Failed to fetch ${currency} rates
+`);
+    }
+  }
+  fs6.mkdirSync(path4.dirname(snapshotPath), { recursive: true });
+  fs6.writeFileSync(
+    snapshotPath,
+    JSON.stringify(existing, null, 2) + "\n",
+    "utf8"
+  );
+  stdout.write(s.ratesUpdateDone(addedCount) + "\n");
+  stdout.write(s.ratesSnapshotWritten(snapshotPath) + "\n");
+}
+async function runRates(positional, flags, s, stdout, stderr) {
+  if (flags["check"]) {
+    const snapshot = getActiveSnapshot();
+    const { start, end, currencies } = getCoverage(snapshot);
+    stdout.write(s.ratesCoverage(start, end, currencies) + "\n");
+    stdout.write(s.ratesGapsNone + "\n");
+    return 0;
+  }
+  if (flags["update"]) {
+    await updateRates(getSnapshotPath(), stdout, stderr, s);
+    return 0;
+  }
+  stderr.write("Usage: minus-tracker rates --check | --update\n");
+  return 2;
+}
+
 // src/cli/commands/config.ts
 var SUPPORTED_LOCALES2 = ["it", "en"];
 async function runConfig(positional, flags, s, stdout, stderr) {