@gabrielerandelli/minus-tracker 0.5.8 → 0.7.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",
@@ -36,12 +38,58 @@ var it = {
   ratesGaps: (list) => `Lacune: ${list}`,
   ratesUpdateFetching: "Recupero dati BCE SDMX in corso...",
   ratesUpdateDone: (n) => `Completato. Aggiunte ${n} nuove date.`,
-  ratesSnapshotWritten: (path5) => `Snapshot scritto in ${path5}`,
+  ratesSnapshotWritten: (path7) => `Snapshot scritto in ${path7}`,
   ratesAutoUpdateStart: "Le rate BCE non sono aggiornate. Aggiornamento automatico in corso...",
   ratesAutoUpdateFailed: "Aggiornamento automatico fallito. Si procede con le rate disponibili.",
   configLangSet: (lang) => `Lingua impostata su: ${lang}`,
   configCurrentLang: (lang) => `Lingua corrente: ${lang}`,
-  disclaimer: "minus-tracker \xE8 un ausilio al calcolo, non consulenza fiscale."
+  classifyStarting: (n) => `Classificazione ISIN in corso... (${n} strumenti)`,
+  classifyDetected: (isin, product, bucket, rate) => `Rilevato: ${product} (${isin}) \u2192 ${bucket} | ${rate}`,
+  classifyConfirm: "[Y/n/?]: ",
+  classifyOverridePrompt: "Tipo di strumento:",
+  classifyDone: (confirmed, total) => `Classificazione completata (${confirmed}/${total} confermati).`,
+  classifyWritten: (path7) => `Scritto: ${path7}`,
+  classifyMergePrompt: (existing) => `File gi\xE0 esistente (${existing} ISIN confermati). Aggiungere i nuovi ISIN? [Y/n]: `,
+  classifyOfflineWarning: "Modalit\xE0 offline: ricerca OpenFIGI saltata.",
+  classifyUnknownType: (type) => `Tipo non riconosciuto: ${type}. Classificare manualmente.`,
+  classifyNonTtyError: "Modalit\xE0 interattiva richiede un terminale (TTY). Usa --offline per classificare senza terminale.",
+  bucketAHeader: "BUCKET A \u2014 REDDITI DA CAPITALE (non compensabili)",
+  bucketBHeader: "BUCKET B \u2014 REDDITI DIVERSI",
+  bucketAEtf: "ETF (OICR)",
+  bucketABtpWl: "BTP/WL",
+  bucketATotalTax: "TOTALE IMPOSTA",
+  bucketBCarryApplied: (year) => `RIPORTO ${year}`,
+  bucketBResult: "RISULTATO",
+  bucketBCarryNote: "(riportabile ai prossimi 4 anni)",
+  warnMixedBuckets: "Le perdite in Bucket B non compensano le plusvalenze in Bucket A.",
+  warnMixedAssets: "AVVISO: CSV contiene tipi di strumenti misti (es. ETF + Azioni).\n   Il calcolo a bucket unico pu\xF2 non essere fiscalmente corretto.\n   Esegui: minus-tracker classify trades.csv",
+  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.",
+  // 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
@@ -54,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",
@@ -77,12 +127,58 @@ var en = {
   ratesGaps: (list) => `Gaps: ${list}`,
   ratesUpdateFetching: "Fetching ECB SDMX...",
   ratesUpdateDone: (n) => `Done. Added ${n} new dates.`,
-  ratesSnapshotWritten: (path5) => `Snapshot written to ${path5}`,
+  ratesSnapshotWritten: (path7) => `Snapshot written to ${path7}`,
   ratesAutoUpdateStart: "ECB rates are stale. Auto-updating\u2026",
   ratesAutoUpdateFailed: "Auto-update failed. Proceeding with available rates.",
   configLangSet: (lang) => `Language set to: ${lang}`,
   configCurrentLang: (lang) => `Current language: ${lang}`,
-  disclaimer: "minus-tracker \xE8 un ausilio al calcolo, non consulenza fiscale."
+  classifyStarting: (n) => `Classifying ISINs... (${n} instruments)`,
+  classifyDetected: (isin, product, bucket, rate) => `Detected: ${product} (${isin}) \u2192 ${bucket} | ${rate}`,
+  classifyConfirm: "[Y/n/?]: ",
+  classifyOverridePrompt: "Instrument type:",
+  classifyDone: (confirmed, total) => `Classification complete (${confirmed}/${total} confirmed).`,
+  classifyWritten: (path7) => `Written: ${path7}`,
+  classifyMergePrompt: (existing) => `File already exists (${existing} confirmed ISINs). Add new ISINs? [Y/n]: `,
+  classifyOfflineWarning: "Offline mode: OpenFIGI lookup skipped.",
+  classifyUnknownType: (type) => `Unrecognized type: ${type}. Please classify manually.`,
+  classifyNonTtyError: "Interactive mode requires a TTY. Use --offline to classify without a terminal.",
+  bucketAHeader: "BUCKET A \u2014 CAPITAL INCOME (non-offsettable)",
+  bucketBHeader: "BUCKET B \u2014 MISCELLANEOUS INCOME",
+  bucketAEtf: "ETF (OICR)",
+  bucketABtpWl: "Govt Bond WL",
+  bucketATotalTax: "TOTAL TAX",
+  bucketBCarryApplied: (year) => `CARRY ${year}`,
+  bucketBResult: "RESULT",
+  bucketBCarryNote: "(carriable over the next 4 years)",
+  warnMixedBuckets: "Bucket B losses do not offset Bucket A plusvalenze.",
+  warnMixedAssets: "WARNING: CSV contains mixed instrument types (e.g. ETFs + Stocks).\n   Single-bucket calculation may not be fiscally correct.\n   Run: minus-tracker classify trades.csv",
+  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.",
+  // 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
@@ -165,9 +261,21 @@ var CalculationError = class extends Error {
     this.date = date;
   }
 };
+var ClassificationError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(
+      message ?? (code === "SIDECAR_NOT_FOUND" ? "Sidecar file not found" : code === "SIDECAR_VERSION" ? "Sidecar version mismatch" : code === "SIDECAR_MALFORMED" ? "Sidecar file is malformed JSON" : code === "NETWORK_ERROR" ? "Network error contacting OpenFIGI" : "Failed to write sidecar file")
+    );
+    this.name = "ClassificationError";
+    this.code = code;
+  }
+};
 
 // src/cli/commands/calc.ts
 import * as fs4 from "fs";
+import * as path3 from "path";
+import * as os2 from "os";
 
 // src/rates/index.ts
 import { fileURLToPath } from "url";
@@ -218,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);
@@ -260,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`;
   }
 }
 
@@ -275,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;
@@ -316,6 +418,7 @@ function parseDate(ddmmyyyy) {
 var DEGIROParser = class {
   _warningEntries = [];
   _snapshot;
+  _incomeRows = [];
   constructor(snapshot) {
     this._snapshot = snapshot;
   }
@@ -332,6 +435,7 @@ var DEGIROParser = class {
    */
   parse(csv) {
     this._warningEntries = [];
+    this._incomeRows = [];
     if (typeof csv !== "string" || csv.includes("\0")) {
       throw new ParseError("INVALID_CSV");
     }
@@ -356,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;
@@ -407,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,
@@ -422,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() {
@@ -430,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) {
@@ -453,13 +800,11 @@ function inferTaxYear(transactions) {
 var Calculator = class {
   _transactions;
   _parseWarnings;
-  /**
-   * @param transactions - Normalised Transaction objects from the CSV import step.
-   * @param parseWarnings - Warnings collected during the import step; forwarded into the report.
-   */
-  constructor(transactions, parseWarnings) {
+  _options;
+  constructor(transactions, parseWarnings, options) {
     this._transactions = transactions;
     this._parseWarnings = parseWarnings ?? [];
+    this._options = options ?? {};
   }
   /**
    * Run LIFO or FIFO lot-matching over the transaction list.
@@ -529,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
           });
@@ -553,12 +898,133 @@ var Calculator = class {
       if (lot.gainLossEUR > 0) plusvalenze += lot.gainLossEUR;
       else minusvalenze += Math.abs(lot.gainLossEUR);
     }
+    if (this._options.classification) {
+      const classification = this._options.classification;
+      const unclassifiedIsins = /* @__PURE__ */ new Set();
+      for (const lot of matchedLots) {
+        const entry = classification[lot.isin];
+        if (!entry) {
+          lot.bucket = "B";
+          unclassifiedIsins.add(lot.isin);
+        } else if (entry.bucketGain === "A" && lot.gainLossEUR >= 0) {
+          lot.bucket = "A";
+        } else {
+          lot.bucket = "B";
+        }
+      }
+      for (const isin of unclassifiedIsins) {
+        warnings.push(
+          `ISIN ${isin} not found in classification map \u2014 assigned to Bucket B.`
+        );
+      }
+      const bucketALots = matchedLots.filter((l) => l.bucket === "A");
+      const groupsByRate = /* @__PURE__ */ new Map();
+      for (const lot of bucketALots) {
+        const entry = classification[lot.isin];
+        const rate = entry.taxRate;
+        if (!groupsByRate.has(rate))
+          groupsByRate.set(rate, { assetClasses: /* @__PURE__ */ new Set(), plusvalenze: 0 });
+        const g = groupsByRate.get(rate);
+        g.assetClasses.add(entry.assetClass);
+        g.plusvalenze += lot.gainLossEUR;
+      }
+      const bucketAGroups = [...groupsByRate.entries()].map(([taxRate, g]) => ({
+        taxRate,
+        assetClasses: [...g.assetClasses],
+        plusvalenze: roundHalfUp2(g.plusvalenze),
+        imposta: roundHalfUp2(g.plusvalenze * taxRate)
+      }));
+      const bucketAReport = {
+        groups: bucketAGroups,
+        totalImposta: roundHalfUp2(
+          bucketAGroups.reduce((s, g) => s + g.imposta, 0)
+        )
+      };
+      const bucketBLots = matchedLots.filter((l) => l.bucket === "B");
+      let bPlusvalenze = 0;
+      let bMinusvalenze = 0;
+      for (const lot of bucketBLots) {
+        if (lot.gainLossEUR >= 0) bPlusvalenze += lot.gainLossEUR;
+        else bMinusvalenze += Math.abs(lot.gainLossEUR);
+      }
+      bPlusvalenze = roundHalfUp2(bPlusvalenze);
+      bMinusvalenze = roundHalfUp2(bMinusvalenze);
+      const carryForwards = [...this._options.carryForward ?? []].sort(
+        (a, b) => a.year - b.year
+      );
+      let remaining = bPlusvalenze - bMinusvalenze;
+      let carryForwardApplied = 0;
+      for (const entry of carryForwards) {
+        if (taxYear - entry.year > 4) continue;
+        if (remaining <= 0) break;
+        const consumed = Math.min(entry.amount, remaining);
+        carryForwardApplied += consumed;
+        remaining -= consumed;
+      }
+      carryForwardApplied = roundHalfUp2(carryForwardApplied);
+      const bNetResult = roundHalfUp2(
+        bPlusvalenze - bMinusvalenze - carryForwardApplied
+      );
+      const carryForwardRemaining = roundHalfUp2(Math.max(0, -bNetResult));
+      const bucketBReport = {
+        plusvalenze: bPlusvalenze,
+        minusvalenze: bMinusvalenze,
+        carryForwardApplied,
+        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: 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,
+        dichiarazione: dichiarazioneReport
+      };
+    } else {
+      const allIsins = [...new Set(this._transactions.map((t) => t.isin))];
+      const hasIePrefix = allIsins.some((isin) => isin.startsWith("IE"));
+      const hasOther = allIsins.some((isin) => !isin.startsWith("IE"));
+      if (hasIePrefix && hasOther) {
+        warnings.push(
+          "AVVISO: CSV contiene tipi di strumenti misti (es. ETF + Azioni).\n   Il calcolo a bucket unico pu\xF2 non essere fiscalmente corretto.\n   Esegui: minus-tracker classify trades.csv"
+        );
+      }
+    }
     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,
@@ -567,6 +1033,352 @@ var Calculator = class {
   }
 };
 
+// src/classifier/index.ts
+import * as fs3 from "fs";
+import * as https from "https";
+function httpsPost(url, body, timeoutMs) {
+  return new Promise((resolve2, reject) => {
+    const u = new URL(url);
+    const req = https.request(
+      {
+        hostname: u.hostname,
+        path: u.pathname + u.search,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(body)
+        }
+      },
+      (res) => {
+        let data = "";
+        res.on("data", (chunk) => {
+          data += chunk;
+        });
+        res.on("end", () => resolve2({ status: res.statusCode ?? 0, data }));
+      }
+    );
+    req.setTimeout(timeoutMs, () => {
+      req.destroy();
+      reject(new Error("timeout"));
+    });
+    req.on("error", reject);
+    req.write(body);
+    req.end();
+  });
+}
+var GOVT_BOND_WHITELIST = /* @__PURE__ */ new Set([
+  "IT",
+  "DE",
+  "FR",
+  "AT",
+  "BE",
+  "NL",
+  "ES",
+  "PT",
+  "FI",
+  "IE",
+  "LU",
+  "GR",
+  "SK",
+  "SI",
+  "LT",
+  "LV",
+  "EE",
+  "MT",
+  "CY",
+  "US",
+  "GB",
+  "CH",
+  "NO",
+  "SE",
+  "DK",
+  "JP",
+  "CA",
+  "AU",
+  "NZ",
+  "SG",
+  "HK",
+  "KR"
+]);
+var SECURITY_TYPE_MAP = {
+  ETP: {
+    assetClass: "ETF",
+    bucketGain: "A",
+    bucketLoss: "B",
+    taxRate: 0.26,
+    whiteListed: null
+  },
+  ETF: {
+    assetClass: "ETF",
+    bucketGain: "A",
+    bucketLoss: "B",
+    taxRate: 0.26,
+    whiteListed: null
+  },
+  "Mutual Fund": {
+    assetClass: "ETF",
+    bucketGain: "A",
+    bucketLoss: "B",
+    taxRate: 0.26,
+    whiteListed: null
+  },
+  "Open-End Fund": {
+    assetClass: "ETF",
+    bucketGain: "A",
+    bucketLoss: "B",
+    taxRate: 0.26,
+    whiteListed: null
+  },
+  "Common Stock": {
+    assetClass: "Stock",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null
+  },
+  Equity: {
+    assetClass: "Stock",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null
+  },
+  "Exchange Traded Commodity": {
+    assetClass: "ETC",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null
+  },
+  "Corporate Bond": {
+    assetClass: "CorpBond",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null
+  },
+  Option: {
+    assetClass: "Derivative",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null
+  },
+  Future: {
+    assetClass: "Derivative",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null
+  },
+  Warrant: {
+    assetClass: "Derivative",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null
+  },
+  CFD: {
+    assetClass: "Derivative",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null
+  },
+  Swap: {
+    assetClass: "Derivative",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null
+  },
+  "Leverage Certificate": {
+    assetClass: "LeverageCert",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null
+  },
+  "Turbo Certificate": {
+    assetClass: "LeverageCert",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null
+  },
+  "Capital Protected Certificate": {
+    assetClass: "CapProtectedCert",
+    bucketGain: "A",
+    bucketLoss: "B",
+    taxRate: 0.26,
+    whiteListed: null
+  }
+};
+function isKnownType(t) {
+  return t === "Government Bond" || t in SECURITY_TYPE_MAP;
+}
+function classifyByType(isin, securityType, product, warnings) {
+  if (securityType === "Government Bond") {
+    const prefix = isin.slice(0, 2).toUpperCase();
+    const whiteListed = GOVT_BOND_WHITELIST.has(prefix);
+    return {
+      product,
+      assetClass: whiteListed ? "GovtBondWL" : "GovtBondOther",
+      bucketGain: "A",
+      bucketLoss: "B",
+      taxRate: whiteListed ? 0.125 : 0.26,
+      whiteListed,
+      confirmedByUser: false,
+      source: "openfigi"
+    };
+  }
+  const mapped = SECURITY_TYPE_MAP[securityType];
+  if (mapped) {
+    return {
+      product,
+      assetClass: mapped.assetClass,
+      bucketGain: mapped.bucketGain,
+      bucketLoss: mapped.bucketLoss,
+      taxRate: mapped.taxRate,
+      whiteListed: mapped.whiteListed,
+      confirmedByUser: false,
+      source: "openfigi"
+    };
+  }
+  warnings.push(
+    `Unrecognized type: ${securityType}. Please classify manually.`
+  );
+  return {
+    product,
+    assetClass: "Stock",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null,
+    confirmedByUser: false,
+    source: "user"
+  };
+}
+var Classifier = class {
+  interactive;
+  constructor(options) {
+    this.interactive = options?.interactive ?? true;
+  }
+  async load(sidecarPath) {
+    if (!fs3.existsSync(sidecarPath)) {
+      throw new ClassificationError("SIDECAR_NOT_FOUND");
+    }
+    let parsed;
+    try {
+      const raw = fs3.readFileSync(sidecarPath, "utf-8");
+      parsed = JSON.parse(raw);
+    } catch {
+      throw new ClassificationError("SIDECAR_MALFORMED");
+    }
+    if (typeof parsed !== "object" || parsed === null || parsed["version"] !== 1) {
+      throw new ClassificationError("SIDECAR_VERSION");
+    }
+    return parsed.classifications;
+  }
+  async classify(transactions, sidecarPath, _httpPost = httpsPost) {
+    const isinToProduct = /* @__PURE__ */ new Map();
+    for (const tx of transactions) {
+      if (tx.isin && !isinToProduct.has(tx.isin)) {
+        isinToProduct.set(tx.isin, tx.product);
+      }
+    }
+    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;
+        }
+      }
+    }
+    const toProcess = [];
+    for (const isin of isinToProduct.keys()) {
+      if (!(isin in confirmed)) {
+        toProcess.push(isin);
+      }
+    }
+    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));
+      }
+      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");
+        }
+      }
+      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 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 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");
+    }
+    return mergedMap;
+  }
+};
+
 // src/cli/renderer.ts
 var SEPARATOR = "\u2500".repeat(72);
 function formatEUR(amount, locale) {
@@ -579,14 +1391,99 @@ function formatGainLoss(amount, locale) {
   const formatted = formatEUR(Math.abs(amount), locale);
   return amount >= 0 ? `+${formatted}` : `-${formatted}`;
 }
-function renderReport(report, s) {
+function assetClassLabel(ac, s) {
+  if (ac === "ETF") return s.bucketAEtf;
+  if (ac === "GovtBondWL" || ac === "GovtBondOther") return s.bucketABtpWl;
+  return ac;
+}
+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);
   lines.push(
     `${s.headerMethod}: ${report.method} | ${s.headerTaxYear}: ${report.taxYear}`
   );
   lines.push("");
-  const headers = [
+  for (const w of report.warnings) {
+    if (w.startsWith("AVVISO:") || w.startsWith("WARNING:")) {
+      lines.push(w);
+      lines.push("");
+    }
+  }
+  const headerCols = [
     s.headerIsin.padEnd(14),
     s.headerProduct.padEnd(20),
     s.headerQty.padStart(5),
@@ -595,10 +1492,13 @@ function renderReport(report, s) {
     s.headerBuyEur.padStart(14),
     s.headerSellEur.padStart(13),
     s.headerGainLoss.padStart(17)
-  ].join("  ");
-  lines.push(headers);
+  ];
+  if (hasBuckets) {
+    headerCols.push(s.headerBucket.padStart(8));
+  }
+  lines.push(headerCols.join("  "));
   for (const lot of report.lots) {
-    const row = [
+    const rowCols = [
       lot.isin.padEnd(14),
       lot.product.substring(0, 20).padEnd(20),
       String(lot.quantity).padStart(5),
@@ -607,8 +1507,11 @@ function renderReport(report, s) {
       fmt(lot.buyCostEUR).padStart(14),
       fmt(lot.sellProceedsEUR).padStart(13),
       formatGainLoss(lot.gainLossEUR, s.numberLocale).padStart(17)
-    ].join("  ");
-    lines.push(row);
+    ];
+    if (hasBuckets) {
+      rowCols.push((lot.bucket ?? "").padStart(8));
+    }
+    lines.push(rowCols.join("  "));
   }
   lines.push("");
   lines.push(SEPARATOR);
@@ -619,111 +1522,48 @@ function renderReport(report, s) {
   lines.push(`${s.summaryWarnings}: ${report.warnings.length}`);
   lines.push(`${s.summaryGenerated}: ${report.generatedAt}`);
   lines.push("");
-  lines.push(s.disclaimer);
-  return lines.join("\n");
-}
-
-// src/cli/commands/rates.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
-import * as os2 from "os";
-import * as https from "https";
-function getSnapshotPath() {
-  const platform = process.platform;
-  let configDir;
-  if (platform === "win32") {
-    configDir = process.env.APPDATA ?? path3.join(os2.homedir(), "AppData", "Roaming");
-  } else {
-    configDir = process.env.XDG_CONFIG_HOME ?? path3.join(os2.homedir(), ".config");
-  }
-  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;
+  if (report.bucketA && report.bucketA.groups.length > 0) {
+    lines.push(SEPARATOR);
+    lines.push(s.bucketAHeader);
+    lines.push(SEPARATOR);
+    for (const g of report.bucketA.groups) {
+      const label = g.assetClasses.map((ac) => assetClassLabel(ac, s)).join(", ");
+      const rateDisplay = (g.taxRate * 100).toFixed(0);
+      lines.push(
+        `${label}: ${fmt(g.plusvalenze)} EUR \u2192 imposta: ${fmt(g.imposta)} EUR (${rateDisplay}%)`
+      );
     }
+    lines.push(`${s.bucketATotalTax}: ${fmt(report.bucketA.totalImposta)} EUR`);
+    lines.push("");
   }
-  return { start, end, currencies: currencies.sort().join(", ") };
-}
-async function fetchEcbData(currency) {
-  return new Promise((resolve, reject) => {
-    const url = `https://data-api.ecb.europa.eu/service/data/EXR/D.${currency}.EUR.SP00.A?format=csvdata&startPeriod=2019-01-01`;
-    https.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;
-          }
-        }
-        resolve(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(
-      fs3.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
-`);
+  if (report.bucketB) {
+    lines.push(SEPARATOR);
+    lines.push(s.bucketBHeader);
+    lines.push(SEPARATOR);
+    lines.push(`PLUSVALENZE: ${fmt(report.bucketB.plusvalenze)} EUR`);
+    lines.push(`MINUSVALENZE: ${fmt(report.bucketB.minusvalenze)} EUR`);
+    if (report.bucketB.carryForwardApplied > 0) {
+      lines.push(
+        `${s.bucketBCarryApplied(0)}: ${fmt(report.bucketB.carryForwardApplied)} EUR`
+      );
     }
+    let resultLine = `${s.bucketBResult}: ${fmt(report.bucketB.netResult)} EUR`;
+    if (report.bucketB.carryForwardRemaining > 0) {
+      resultLine += ` ${s.bucketBCarryNote}`;
+    }
+    lines.push(resultLine);
+    lines.push("");
   }
-  fs3.mkdirSync(path3.dirname(snapshotPath), { recursive: true });
-  fs3.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 (hasBuckets) {
+    lines.push(s.warnMixedBuckets);
+    lines.push("");
   }
-  if (flags["update"]) {
-    await updateRates(getSnapshotPath(), stdout, stderr, s);
-    return 0;
+  if (report.dichiarazione) {
+    lines.push(renderDichiarazione(report, s, carryForwardWasProvided));
+  } else {
+    lines.push(s.disclaimer);
   }
-  stderr.write("Usage: minus-tracker rates --check | --update\n");
-  return 2;
+  return lines.join("\n");
 }
 
 // src/cli/commands/calc.ts
@@ -743,29 +1583,63 @@ async function runCalc(positional, flags, s, stdout, stderr) {
 `);
     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");
-      }
+  const method = flags["method"] ?? "LIFO";
+  if (method !== "LIFO" && method !== "FIFO") {
+    stderr.write("--method must be LIFO or FIFO\n");
+    return 2;
+  }
+  const sidecarPath = filePath.replace(/\.csv$/i, "") + ".classify.json";
+  let classification;
+  if (fs4.existsSync(sidecarPath)) {
+    try {
+      const classifier = new Classifier({ interactive: false });
+      classification = await classifier.load(sidecarPath);
+    } catch {
+      stderr.write(`Cannot load sidecar: ${sidecarPath}
+`);
+      return 1;
     }
-  } catch {
-    stderr.write(s.ratesAutoUpdateStart + "\n");
+  }
+  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+)?$/;
+  for (const cf of rawCarryForwards) {
+    if (!cfRegex.test(cf)) {
+      stderr.write(s.carryForwardInvalidFormat + "\n");
+      return 2;
+    }
+  }
+  const xdgConfig = process.env["XDG_CONFIG_HOME"] ?? path3.join(os2.homedir(), ".config");
+  const cfConfigPath = path3.join(
+    xdgConfig,
+    "minus-tracker",
+    "carryforward.json"
+  );
+  const cfFromFile = {};
+  if (fs4.existsSync(cfConfigPath)) {
     try {
-      await updateRates(getSnapshotPath(), stdout, stderr, s);
+      const raw = JSON.parse(fs4.readFileSync(cfConfigPath, "utf-8"));
+      for (const entry of raw.losses ?? []) {
+        cfFromFile[entry.year] = entry.amount;
+      }
     } 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");
-    return 2;
+  const cfMerged = { ...cfFromFile };
+  for (const cf of rawCarryForwards) {
+    const [yearStr, amountStr] = cf.split(":");
+    cfMerged[parseInt(yearStr, 10)] = parseFloat(amountStr);
   }
+  const carryForward = Object.entries(cfMerged).map(
+    ([year, amount]) => ({ year: parseInt(year, 10), amount })
+  );
   const parser = new DEGIROParser();
   let transactions;
   try {
@@ -781,12 +1655,32 @@ async function runCalc(positional, flags, s, stdout, stderr) {
     }
     throw err;
   }
-  const calculator = new Calculator(transactions, parser.warnings);
+  const calculator = new Calculator(transactions, parser.warnings, {
+    classification,
+    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;
 }
@@ -838,12 +1732,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) {
@@ -868,9 +1871,9 @@ async function runConfig(positional, flags, s, stdout, stderr) {
 }
 
 // src/cli/commands/stress-test.ts
-import * as fs6 from "fs";
-import * as path4 from "path";
-import * as os3 from "os";
+import * as fs7 from "fs";
+import * as path5 from "path";
+import * as os4 from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { spawnSync as spawnSync2 } from "child_process";
 
@@ -948,8 +1951,8 @@ function generateCsv(scenario) {
 
 // src/stress/runner.ts
 import { spawnSync } from "child_process";
-import { writeFileSync as writeFileSync3 } from "fs";
-import { join as join4 } from "path";
+import { writeFileSync as writeFileSync4 } from "fs";
+import { join as join5 } from "path";
 function countWarnings(text) {
   if (!text) return 0;
   const match = text.match(/(?:warnings|avvertenze)\s*:\s*(\d+)/i);
@@ -1002,8 +2005,8 @@ function runCommand(cliBin, args, cmdLabel, expectedExitCode, outputShapeCheck)
 }
 function runScenario(scenario, csvContent, outputDir, cliBin) {
   const csvFileName = `${scenario.id}-${scenario.slug}.csv`;
-  const csvFile = join4(outputDir, csvFileName);
-  writeFileSync3(csvFile, csvContent, "utf8");
+  const csvFile = join5(outputDir, csvFileName);
+  writeFileSync4(csvFile, csvContent, "utf8");
   const results = [];
   results.push(
     runCommand(
@@ -1213,11 +2216,11 @@ async function runStressTest(_positionals, flags, stdout, stderr) {
     );
     return 2;
   }
-  const __dirname = path4.dirname(fileURLToPath2(import.meta.url));
-  const manifestPath = path4.join(__dirname, "../data/stress-manifest.json");
+  const __dirname = path5.dirname(fileURLToPath2(import.meta.url));
+  const manifestPath = path5.join(__dirname, "../data/stress-manifest.json");
   let manifest;
   try {
-    const raw = fs6.readFileSync(manifestPath, "utf8");
+    const raw = fs7.readFileSync(manifestPath, "utf8");
     manifest = JSON.parse(raw);
   } catch {
     stderr.write(`Error: could not load stress manifest at ${manifestPath}
@@ -1229,9 +2232,9 @@ async function runStressTest(_positionals, flags, stdout, stderr) {
   const outputDirFlag = flags["output-dir"];
   if (outputDirFlag) {
     outputDir = outputDirFlag;
-    fs6.mkdirSync(outputDir, { recursive: true });
+    fs7.mkdirSync(outputDir, { recursive: true });
   } else {
-    outputDir = fs6.mkdtempSync(path4.join(os3.tmpdir(), "minus-tracker-stress-"));
+    outputDir = fs7.mkdtempSync(path5.join(os4.tmpdir(), "minus-tracker-stress-"));
   }
   const ratesCheck = spawnSync2("node", [cliBin, "rates", "--check"], {
     encoding: "utf8",
@@ -1268,11 +2271,122 @@ async function runStressTest(_positionals, flags, stdout, stderr) {
     stdout.write(formatTable(report) + "\n");
   }
   if (!flags["keep"]) {
-    fs6.rmSync(outputDir, { recursive: true, force: true });
+    fs7.rmSync(outputDir, { recursive: true, force: true });
   }
   return report.failed === 0 ? 0 : 1;
 }
 
+// src/cli/commands/classify.ts
+import * as fs8 from "fs";
+import * as path6 from "path";
+async function runClassify(positional, flags, s, stdout, stderr) {
+  const offline = Boolean(flags["offline"]);
+  if (!process.stdin.isTTY && !offline) {
+    stderr.write(s.classifyNonTtyError + "\n");
+    return 2;
+  }
+  const csvPath = positional[0];
+  if (!csvPath) {
+    stderr.write("Usage: minus-tracker classify [--offline] <file.csv>\n");
+    return 2;
+  }
+  let csv;
+  try {
+    csv = fs8.readFileSync(csvPath, "utf8");
+  } catch {
+    stderr.write(`Cannot read file: ${csvPath}
+`);
+    return 1;
+  }
+  const parser = new DEGIROParser();
+  let transactions;
+  try {
+    transactions = parser.parse(csv);
+  } catch (err) {
+    if (err instanceof ParseError) {
+      if (err.code === "INVALID_CSV") {
+        stderr.write(s.errorInvalidCsv + "\n");
+      } else {
+        stderr.write(s.errorMissingColumn(err.columnName) + "\n");
+      }
+      return 1;
+    }
+    throw err;
+  }
+  const base = csvPath.replace(/\.csv$/i, "");
+  const sidecarPath = base + ".classify.json";
+  if (offline) {
+    stdout.write(s.classifyOfflineWarning + "\n");
+    const isinToProduct = /* @__PURE__ */ new Map();
+    for (const tx of transactions) {
+      if (tx.isin && !isinToProduct.has(tx.isin)) {
+        isinToProduct.set(tx.isin, tx.product);
+      }
+    }
+    const classifications = {};
+    for (const [isin, product] of isinToProduct.entries()) {
+      classifications[isin] = {
+        product,
+        assetClass: "ETF",
+        bucketGain: "A",
+        bucketLoss: "B",
+        taxRate: 0.26,
+        whiteListed: null,
+        confirmedByUser: true,
+        source: "user"
+      };
+    }
+    const sidecarContent = JSON.stringify(
+      {
+        version: 1,
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        classifications,
+        warnings: []
+      },
+      null,
+      2
+    );
+    try {
+      fs8.writeFileSync(sidecarPath, sidecarContent, "utf-8");
+    } catch {
+      stderr.write(`Cannot write sidecar: ${sidecarPath}
+`);
+      return 1;
+    }
+    stdout.write(s.classifyWritten(sidecarPath) + "\n");
+    return 0;
+  }
+  const classifier = new Classifier({ interactive: true });
+  if (fs8.existsSync(sidecarPath)) {
+    const existingMap = await classifier.load(sidecarPath);
+    const confirmedCount = Object.values(existingMap).filter(
+      (e) => e.confirmedByUser
+    ).length;
+    stdout.write(s.classifyMergePrompt(confirmedCount));
+    const answer = await readLine(process.stdin);
+    if (answer.trim().toLowerCase() === "n") {
+      return 0;
+    }
+  }
+  await classifier.classify(transactions, sidecarPath);
+  stdout.write(s.classifyWritten(path6.resolve(sidecarPath)) + "\n");
+  return 0;
+}
+function readLine(stream) {
+  return new Promise((resolve2) => {
+    let buf = "";
+    const onData = (chunk) => {
+      buf += chunk.toString();
+      const nl = buf.indexOf("\n");
+      if (nl !== -1) {
+        stream.removeListener("data", onData);
+        resolve2(buf.slice(0, nl));
+      }
+    };
+    stream.on("data", onData);
+  });
+}
+
 // src/cli/index.ts
 async function main() {
   const { values, positionals } = parseArgs({
@@ -1287,7 +2401,8 @@ async function main() {
       show: { type: "boolean", default: false },
       range: { type: "string" },
       keep: { type: "boolean", default: false },
-      "output-dir": { type: "string" }
+      "output-dir": { type: "string" },
+      offline: { type: "boolean", default: false }
     },
     allowPositionals: true,
     strict: false
@@ -1317,14 +2432,20 @@ async function main() {
       case "stress-test":
         exitCode = await runStressTest(restPositionals, flags, stdout, stderr);
         break;
+      case "classify":
+        exitCode = await runClassify(restPositionals, flags, s, stdout, stderr);
+        break;
       default:
         stderr.write(
-          "Usage: minus-tracker <calc|validate|rates|config|stress-test> [options] [file]\n"
+          "Usage: minus-tracker <calc|validate|rates|config|stress-test|classify> [options] [file]\n"
         );
         exitCode = 2;
     }
   } catch (err) {
-    if (err instanceof ParseError) {
+    if (err instanceof ClassificationError) {
+      stderr.write(err.message + "\n");
+      exitCode = 1;
+    } else if (err instanceof ParseError) {
       if (err.code === "INVALID_CSV") {
         stderr.write(s.errorInvalidCsv + "\n");
       } else {