@gabrielerandelli/minus-tracker 0.5.7 → 0.6.0

package/dist/cli/index.js

@@ -36,11 +36,34 @@ var it = {
   ratesGaps: (list) => `Lacune: ${list}`,
   ratesUpdateFetching: "Recupero dati BCE SDMX in corso...",
   ratesUpdateDone: (n) => `Completato. Aggiunte ${n} nuove date.`,
-  ratesSnapshotWritten: (path4) => `Snapshot scritto in ${path4}`,
+  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}`,
+  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."
 };
 
@@ -77,11 +100,34 @@ var en = {
   ratesGaps: (list) => `Gaps: ${list}`,
   ratesUpdateFetching: "Fetching ECB SDMX...",
   ratesUpdateDone: (n) => `Done. Added ${n} new dates.`,
-  ratesSnapshotWritten: (path4) => `Snapshot written to ${path4}`,
+  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}`,
+  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."
 };
 
@@ -165,9 +211,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 fs5 from "fs";
+import * as path4 from "path";
+import * as os3 from "os";
 
 // src/rates/index.ts
 import { fileURLToPath } from "url";
@@ -319,6 +377,17 @@ var DEGIROParser = class {
   constructor(snapshot) {
     this._snapshot = snapshot;
   }
+  /**
+   * Parse a DEGIRO Transactions CSV export string.
+   *
+   * @param csv - Raw UTF-8 string from the DEGIRO Transactions export.
+   * @returns Array of normalised Transaction objects. Empty if no data rows are found.
+   * @throws {ParseError} code `"INVALID_CSV"` — malformed CSV or binary content.
+   * @throws {ParseError} code `"MISSING_COLUMN"` (+ `columnName`) — required column absent.
+   *
+   * Rows with missing ISIN, unsupported currency, zero quantity, or no ECB rate within
+   * 3 trading days are skipped silently. Inspect `parser.warnings` for details.
+   */
   parse(csv) {
     this._warningEntries = [];
     if (typeof csv !== "string" || csv.includes("\0")) {
@@ -442,10 +511,21 @@ function inferTaxYear(transactions) {
 var Calculator = class {
   _transactions;
   _parseWarnings;
-  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.
+   *
+   * @param method - `"LIFO"` or `"FIFO"`.
+   * @returns GainsReport with `plusvalenze`, `minusvalenze`, `netResult`, per-lot breakdown,
+   *          ECB rates used, and any accumulated warnings.
+   * @throws {CalculationError} when a SELL has no matching open buy lots.
+   *         `error.isin` and `error.date` identify the problematic transaction.
+   */
   calculateGains(method) {
     const warnings = [...this._parseWarnings];
     const sorted = [...this._transactions].sort((a, b) => {
@@ -529,6 +609,104 @@ 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: roundHalfUp(g.plusvalenze),
+        imposta: roundHalfUp(g.plusvalenze * taxRate)
+      }));
+      const bucketAReport = {
+        groups: bucketAGroups,
+        totalImposta: roundHalfUp(
+          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 = roundHalfUp(bPlusvalenze);
+      bMinusvalenze = roundHalfUp(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 = roundHalfUp(carryForwardApplied);
+      const bNetResult = roundHalfUp(
+        bPlusvalenze - bMinusvalenze - carryForwardApplied
+      );
+      const carryForwardRemaining = roundHalfUp(Math.max(0, -bNetResult));
+      const bucketBReport = {
+        plusvalenze: bPlusvalenze,
+        minusvalenze: bMinusvalenze,
+        carryForwardApplied,
+        carryForwardRemaining,
+        netResult: bNetResult
+      };
+      return {
+        method,
+        taxYear,
+        plusvalenze: roundHalfUp(plusvalenze),
+        minusvalenze: roundHalfUp(minusvalenze),
+        netResult: roundHalfUp(plusvalenze - minusvalenze),
+        lots: matchedLots,
+        ratesUsed,
+        warnings,
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        bucketA: bucketAGroups.length > 0 ? bucketAReport : void 0,
+        bucketB: bucketBReport
+      };
+    } 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,
@@ -543,6 +721,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) {
@@ -555,14 +1079,26 @@ function formatGainLoss(amount, locale) {
   const formatted = formatEUR(Math.abs(amount), locale);
   return amount >= 0 ? `+${formatted}` : `-${formatted}`;
 }
+function assetClassLabel(ac, s) {
+  if (ac === "ETF") return s.bucketAEtf;
+  if (ac === "GovtBondWL" || ac === "GovtBondOther") return s.bucketABtpWl;
+  return ac;
+}
 function renderReport(report, s) {
   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),
@@ -571,10 +1107,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),
@@ -583,8 +1122,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);
@@ -595,15 +1137,51 @@ function renderReport(report, s) {
   lines.push(`${s.summaryWarnings}: ${report.warnings.length}`);
   lines.push(`${s.summaryGenerated}: ${report.generatedAt}`);
   lines.push("");
+  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("");
+  }
+  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("");
+  }
+  if (hasBuckets) {
+    lines.push(s.warnMixedBuckets);
+    lines.push("");
+  }
   lines.push(s.disclaimer);
   return lines.join("\n");
 }
 
 // src/cli/commands/rates.ts
-import * as fs3 from "fs";
+import * as fs4 from "fs";
 import * as path3 from "path";
 import * as os2 from "os";
-import * as https from "https";
+import * as https2 from "https";
 function getSnapshotPath() {
   const platform = process.platform;
   let configDir;
@@ -628,9 +1206,9 @@ function getCoverage(snapshot) {
   return { start, end, currencies: currencies.sort().join(", ") };
 }
 async function fetchEcbData(currency) {
-  return new Promise((resolve, reject) => {
+  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`;
-    https.get(url, (res) => {
+    https2.get(url, (res) => {
       let data = "";
       res.on("data", (chunk) => data += chunk);
       res.on("end", () => {
@@ -645,7 +1223,7 @@ async function fetchEcbData(currency) {
             rates[date] = rate;
           }
         }
-        resolve(rates);
+        resolve2(rates);
       });
       res.on("error", reject);
     }).on("error", reject);
@@ -656,7 +1234,7 @@ async function updateRates(snapshotPath, stdout, stderr, s) {
   let existing = {};
   try {
     existing = JSON.parse(
-      fs3.readFileSync(snapshotPath, "utf8")
+      fs4.readFileSync(snapshotPath, "utf8")
     );
   } catch {
   }
@@ -677,8 +1255,8 @@ async function updateRates(snapshotPath, stdout, stderr, s) {
 `);
     }
   }
-  fs3.mkdirSync(path3.dirname(snapshotPath), { recursive: true });
-  fs3.writeFileSync(
+  fs4.mkdirSync(path3.dirname(snapshotPath), { recursive: true });
+  fs4.writeFileSync(
     snapshotPath,
     JSON.stringify(existing, null, 2) + "\n",
     "utf8"
@@ -713,7 +1291,7 @@ async function runCalc(positional, flags, s, stdout, stderr) {
   }
   let csv;
   try {
-    csv = fs4.readFileSync(filePath, "utf8");
+    csv = fs5.readFileSync(filePath, "utf8");
   } catch {
     stderr.write(`Cannot read file: ${filePath}
 `);
@@ -742,6 +1320,51 @@ async function runCalc(positional, flags, s, stdout, stderr) {
     stderr.write("--method must be LIFO or FIFO\n");
     return 2;
   }
+  const sidecarPath = filePath.replace(/\.csv$/i, "") + ".classify.json";
+  let classification;
+  if (fs5.existsSync(sidecarPath)) {
+    try {
+      const classifier = new Classifier({ interactive: false });
+      classification = await classifier.load(sidecarPath);
+    } catch {
+      stderr.write(`Cannot load sidecar: ${sidecarPath}
+`);
+      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"] ?? path4.join(os3.homedir(), ".config");
+  const cfConfigPath = path4.join(
+    xdgConfig,
+    "minus-tracker",
+    "carryforward.json"
+  );
+  const cfFromFile = {};
+  if (fs5.existsSync(cfConfigPath)) {
+    try {
+      const raw = JSON.parse(fs5.readFileSync(cfConfigPath, "utf-8"));
+      for (const entry of raw.losses ?? []) {
+        cfFromFile[entry.year] = entry.amount;
+      }
+    } catch {
+    }
+  }
+  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 {
@@ -757,7 +1380,10 @@ 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
+  });
   const report = calculator.calculateGains(method);
   if (flags["json"]) {
     stdout.write(JSON.stringify(report, null, 2) + "\n");
@@ -768,7 +1394,7 @@ async function runCalc(positional, flags, s, stdout, stderr) {
 }
 
 // src/cli/commands/validate.ts
-import * as fs5 from "fs";
+import * as fs6 from "fs";
 async function runValidate(positional, flags, s, stdout, stderr) {
   const filePath = positional[0];
   if (!filePath) {
@@ -777,7 +1403,7 @@ async function runValidate(positional, flags, s, stdout, stderr) {
   }
   let csv;
   try {
-    csv = fs5.readFileSync(filePath, "utf8");
+    csv = fs6.readFileSync(filePath, "utf8");
   } catch {
     stderr.write(`Cannot read file: ${filePath}
 `);
@@ -843,6 +1469,523 @@ async function runConfig(positional, flags, s, stdout, stderr) {
   return 2;
 }
 
+// src/cli/commands/stress-test.ts
+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";
+
+// src/stress/generator.ts
+function formatDate(isoDate) {
+  const [yyyy, mm, dd] = isoDate.split("-");
+  return `${dd}-${mm}-${yyyy}`;
+}
+function generateCsv(scenario) {
+  if (scenario.special === "invalid_csv") {
+    return "NOT_A_CSV\0
\ngarbage data";
+  }
+  const allColumns = [
+    "Date",
+    "Time",
+    "Product",
+    "ISIN",
+    "Exchange",
+    "Execution centre",
+    "Quantity",
+    "Price",
+    "Local value",
+    "Local value currency",
+    "Value",
+    "Value currency",
+    "Exchange rate",
+    "Transaction costs",
+    "Transaction costs currency",
+    "Total",
+    "Total currency",
+    "Order ID"
+  ];
+  let columns = allColumns;
+  if (scenario.special === "missing_col_isin") {
+    columns = columns.filter((c) => c !== "ISIN");
+  } else if (scenario.special === "missing_col_quantity") {
+    columns = columns.filter((c) => c !== "Quantity");
+  } else if (scenario.special === "missing_col_price") {
+    columns = columns.filter((c) => c !== "Price");
+  }
+  const buildRow = (values, includeColumns) => {
+    return includeColumns.map((col) => values[col] ?? "").join(",");
+  };
+  const header = columns.join(",");
+  const rows = [header];
+  for (let rowIndex = 0; rowIndex < scenario.transactions.length; rowIndex++) {
+    const tx = scenario.transactions[rowIndex];
+    const localValue = -tx.qty * tx.price;
+    const total = localValue - tx.fee;
+    const rowValues = {
+      Date: formatDate(tx.date),
+      Time: "09:00",
+      Product: tx.product,
+      ISIN: tx.isin,
+      Exchange: "XEUR",
+      "Execution centre": "XEUR",
+      Quantity: String(tx.qty),
+      Price: tx.price.toFixed(2),
+      "Local value": localValue.toFixed(2),
+      "Local value currency": tx.currency,
+      Value: localValue.toFixed(2),
+      "Value currency": "EUR",
+      "Exchange rate": "1",
+      "Transaction costs": (-Math.abs(tx.fee)).toFixed(2),
+      "Transaction costs currency": "EUR",
+      Total: total.toFixed(2),
+      "Total currency": "EUR",
+      "Order ID": `stress-${scenario.id}-${rowIndex}`
+    };
+    const row = buildRow(rowValues, columns);
+    rows.push(row);
+  }
+  return rows.join("\n");
+}
+
+// src/stress/runner.ts
+import { spawnSync } from "child_process";
+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);
+  return match ? parseInt(match[1], 10) : 0;
+}
+function isValidJson(jsonStr) {
+  try {
+    const obj = JSON.parse(jsonStr);
+    return typeof obj === "object" && obj !== null && "plusvalenze" in obj && "minusvalenze" in obj && "lots" in obj;
+  } catch {
+    return false;
+  }
+}
+function runCommand(cliBin, args, cmdLabel, expectedExitCode, outputShapeCheck) {
+  const isJsFile = cliBin.endsWith(".js");
+  let result;
+  if (isJsFile) {
+    result = spawnSync("node", [cliBin, ...args], {
+      encoding: "utf8",
+      timeout: 15e3,
+      env: { ...process.env, MINUS_TRACKER_LANG: void 0 }
+    });
+  } else {
+    result = spawnSync(cliBin, args, {
+      encoding: "utf8",
+      timeout: 15e3,
+      env: { ...process.env, MINUS_TRACKER_LANG: void 0 }
+    });
+  }
+  const exitCode = result.status ?? 1;
+  const stdout = result.stdout || "";
+  const stderr = result.stderr || "";
+  const exitCodeMatch = exitCode === expectedExitCode;
+  const shapeCheck = outputShapeCheck(stdout, stderr, exitCode);
+  let pass = exitCodeMatch && shapeCheck.valid;
+  let failure;
+  if (!exitCodeMatch) {
+    failure = `exit code mismatch: expected ${expectedExitCode}, got ${exitCode}`;
+  } else if (!shapeCheck.valid) {
+    failure = shapeCheck.reason;
+  }
+  return {
+    cmd: cmdLabel,
+    exitCode,
+    stdout,
+    stderr,
+    pass,
+    failure
+  };
+}
+function runScenario(scenario, csvContent, outputDir, cliBin) {
+  const csvFileName = `${scenario.id}-${scenario.slug}.csv`;
+  const csvFile = join5(outputDir, csvFileName);
+  writeFileSync4(csvFile, csvContent, "utf8");
+  const results = [];
+  results.push(
+    runCommand(
+      cliBin,
+      ["calc", csvFile],
+      "calc",
+      scenario.expect.calc_exit,
+      (stdout) => {
+        if (scenario.expect.calc_exit === 0) {
+          const hasPlus = /plusvalenze|plusvalues/i.test(stdout);
+          return hasPlus ? { valid: true } : {
+            valid: false,
+            reason: "calc output missing plusvalenze/plusvalues (exit 0)"
+          };
+        }
+        return { valid: true };
+      }
+    )
+  );
+  results.push(
+    runCommand(
+      cliBin,
+      ["calc", "--method", "FIFO", csvFile],
+      "calc --method FIFO",
+      scenario.expect.fifo_exit,
+      (stdout) => {
+        if (scenario.expect.fifo_exit === 0) {
+          const hasPlus = /plusvalenze|plusvalues/i.test(stdout);
+          return hasPlus ? { valid: true } : {
+            valid: false,
+            reason: "calc --method FIFO output missing plusvalenze/plusvalues (exit 0)"
+          };
+        }
+        return { valid: true };
+      }
+    )
+  );
+  results.push(
+    runCommand(
+      cliBin,
+      ["calc", "--json", csvFile],
+      "calc --json",
+      scenario.expect.json_exit,
+      (stdout) => {
+        if (scenario.expect.json_exit === 0) {
+          const isValid = isValidJson(stdout);
+          return isValid ? { valid: true } : {
+            valid: false,
+            reason: "calc --json output is not valid JSON with required keys (exit 0)"
+          };
+        }
+        return { valid: true };
+      }
+    )
+  );
+  results.push(
+    runCommand(
+      cliBin,
+      ["calc", "--lang", "en", csvFile],
+      "calc --lang en",
+      scenario.expect.en_exit,
+      (stdout) => {
+        if (scenario.expect.en_exit === 0) {
+          const nonEmpty = stdout.trim().length > 0;
+          return nonEmpty ? { valid: true } : {
+            valid: false,
+            reason: "calc --lang en output is empty (exit 0)"
+          };
+        }
+        return { valid: true };
+      }
+    )
+  );
+  results.push(
+    runCommand(
+      cliBin,
+      ["validate", csvFile],
+      "validate",
+      scenario.expect.validate_exit,
+      (stdout) => {
+        if (scenario.expect.validate_exit !== 0) return { valid: true };
+        const nonEmpty = stdout.trim().length > 0;
+        return nonEmpty ? { valid: true } : {
+          valid: false,
+          reason: "validate output is empty"
+        };
+      }
+    )
+  );
+  const enCalcResult = results[3];
+  const actualWarningCount = countWarnings(enCalcResult.stdout);
+  const warningCheckPass = actualWarningCount >= scenario.expect.warning_count;
+  const pass = results.every((r) => r.pass) && warningCheckPass;
+  return {
+    id: scenario.id,
+    category: scenario.category,
+    slug: scenario.slug,
+    description: scenario.description,
+    csvFile,
+    results,
+    pass,
+    warningCheckPass,
+    expectedWarningCount: scenario.expect.warning_count,
+    actualWarningCount
+  };
+}
+
+// src/stress/reporter.ts
+function buildReport(results, rangeStart, rangeEnd) {
+  const passed = results.filter((r) => r.pass).length;
+  const failed = results.length - passed;
+  return {
+    totalScenarios: results.length,
+    passed,
+    failed,
+    results,
+    rangeStart,
+    rangeEnd
+  };
+}
+function formatJson(report) {
+  return JSON.stringify(report, null, 2);
+}
+function formatTable(report) {
+  const lines = [];
+  lines.push("STRESS TEST \u2014 minus-tracker");
+  lines.push(
+    `Scenari: ${report.totalScenarios}  |  Passati: ${report.passed}  |  Falliti: ${report.failed}`
+  );
+  lines.push("");
+  const idCol = "ID";
+  const categoryCol = "CATEGORIA";
+  const descCol = "DESCRIZIONE";
+  const resultCol = "ESITO";
+  lines.push(formatRow(idCol, categoryCol, descCol, resultCol));
+  for (const result of report.results) {
+    const idStr = result.id.padStart(3, "0");
+    const status = result.pass ? "\u2713 PASS" : "\u2717 FAIL";
+    lines.push(formatRow(idStr, result.category, result.description, status));
+    if (!result.pass) {
+      for (const cmdResult of result.results) {
+        if (!cmdResult.pass) {
+          if (cmdResult.failure) {
+            let failureText = "";
+            if (cmdResult.failure.includes("exit code mismatch")) {
+              const match = cmdResult.failure.match(
+                /expected (\d+), got (\d+)/
+              );
+              if (match) {
+                failureText = `atteso exit ${match[1]}, ottenuto exit ${match[2]}`;
+              }
+            } else {
+              failureText = `output shape non valido \u2014 ${cmdResult.failure}`;
+            }
+            lines.push(`   \u2192 ${cmdResult.cmd}: ${failureText}`);
+          }
+        }
+      }
+      if (!result.warningCheckPass) {
+        lines.push(
+          `   \u2192 avvertenze: attese \u2265${result.expectedWarningCount}, trovate ${result.actualWarningCount}`
+        );
+      }
+    }
+  }
+  lines.push("");
+  lines.push(`PASSATI: ${report.passed}`);
+  lines.push(`FALLITI: ${report.failed}`);
+  lines.push("");
+  return lines.join("\n");
+}
+function formatRow(id, category, description, esito) {
+  const idWidth = 4;
+  const categoryWidth = 22;
+  const descWidth = 40;
+  const esitoWidth = 8;
+  const idCol = id.padEnd(idWidth);
+  const categoryCol = truncateOrPad(category, categoryWidth);
+  const descCol = truncateOrPad(description, descWidth);
+  const esitoCol = esito.padEnd(esitoWidth);
+  return `${idCol}  ${categoryCol}  ${descCol}  ${esitoCol}`;
+}
+function truncateOrPad(str, maxWidth) {
+  if (str.length > maxWidth) {
+    return str.slice(0, maxWidth - 2) + "..";
+  }
+  return str.padEnd(maxWidth);
+}
+
+// src/cli/commands/stress-test.ts
+async function runStressTest(_positionals, flags, stdout, stderr) {
+  const rangeStr = flags["range"] ?? "1-100";
+  const rangeParts = rangeStr.split("-");
+  if (rangeParts.length !== 2) {
+    stderr.write(
+      `Error: --range must be in the form N-M (e.g. 1-100), got: "${rangeStr}"
+`
+    );
+    return 2;
+  }
+  const rangeStart = parseInt(rangeParts[0], 10);
+  const rangeEnd = parseInt(rangeParts[1], 10);
+  if (isNaN(rangeStart) || isNaN(rangeEnd) || rangeStart <= 0 || rangeEnd <= 0 || rangeStart > rangeEnd || rangeStart > 100 || rangeEnd > 100) {
+    stderr.write(
+      `Error: --range values must be positive integers between 1 and 100 with start \u2264 end, got: "${rangeStr}"
+`
+    );
+    return 2;
+  }
+  const __dirname = path5.dirname(fileURLToPath2(import.meta.url));
+  const manifestPath = path5.join(__dirname, "../data/stress-manifest.json");
+  let manifest;
+  try {
+    const raw = fs7.readFileSync(manifestPath, "utf8");
+    manifest = JSON.parse(raw);
+  } catch {
+    stderr.write(`Error: could not load stress manifest at ${manifestPath}
+`);
+    return 1;
+  }
+  const cliBin = process.argv[1];
+  let outputDir;
+  const outputDirFlag = flags["output-dir"];
+  if (outputDirFlag) {
+    outputDir = outputDirFlag;
+    fs7.mkdirSync(outputDir, { recursive: true });
+  } else {
+    outputDir = fs7.mkdtempSync(path5.join(os4.tmpdir(), "minus-tracker-stress-"));
+  }
+  const ratesCheck = spawnSync2("node", [cliBin, "rates", "--check"], {
+    encoding: "utf8",
+    timeout: 15e3
+  });
+  if ((ratesCheck.status ?? 1) !== 0) {
+    stderr.write("Warning: rates --check failed; ECB rates may be stale.\n");
+  }
+  const configShow = spawnSync2("node", [cliBin, "config", "--show"], {
+    encoding: "utf8",
+    timeout: 15e3
+  });
+  if ((configShow.status ?? 1) !== 0) {
+    stderr.write("Warning: config --show failed.\n");
+  }
+  const scenarios = manifest.scenarios.filter((s) => {
+    const id = parseInt(s.id, 10);
+    return id >= rangeStart && id <= rangeEnd;
+  });
+  const results = [];
+  for (const scenario of scenarios) {
+    const csv = generateCsv(scenario);
+    const result = runScenario(scenario, csv, outputDir, cliBin);
+    results.push(result);
+    stdout.write(
+      `  [${result.pass ? "\u2713" : "\u2717"}] ${scenario.id} ${scenario.slug}
+`
+    );
+  }
+  const report = buildReport(results, rangeStart, rangeEnd);
+  if (flags["json"]) {
+    stdout.write(formatJson(report) + "\n");
+  } else {
+    stdout.write(formatTable(report) + "\n");
+  }
+  if (!flags["keep"]) {
+    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({
@@ -854,7 +1997,11 @@ async function main() {
       json: { type: "boolean", default: false },
       check: { type: "boolean", default: false },
       update: { type: "boolean", default: false },
-      show: { type: "boolean", default: false }
+      show: { type: "boolean", default: false },
+      range: { type: "string" },
+      keep: { type: "boolean", default: false },
+      "output-dir": { type: "string" },
+      offline: { type: "boolean", default: false }
     },
     allowPositionals: true,
     strict: false
@@ -881,14 +2028,23 @@ async function main() {
       case "config":
         exitCode = await runConfig(restPositionals, flags, s, stdout, stderr);
         break;
+      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> [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 {