@fuzzle/opencode-accountant 0.9.1 → 0.10.0-next.1

package/dist/index.js

@@ -4249,7 +4249,7 @@ __export(exports_accountSuggester, {
   extractRulePatternsFromFile: () => extractRulePatternsFromFile,
   clearSuggestionCache: () => clearSuggestionCache
 });
-import * as fs17 from "fs";
+import * as fs19 from "fs";
 import * as crypto from "crypto";
 function clearSuggestionCache() {
   Object.keys(suggestionCache).forEach((key) => delete suggestionCache[key]);
@@ -4259,10 +4259,10 @@ function hashTransaction(posting) {
   return crypto.createHash("md5").update(data).digest("hex");
 }
 function loadExistingAccounts(yearJournalPath) {
-  if (!fs17.existsSync(yearJournalPath)) {
+  if (!fs19.existsSync(yearJournalPath)) {
     return [];
   }
-  const content = fs17.readFileSync(yearJournalPath, "utf-8");
+  const content = fs19.readFileSync(yearJournalPath, "utf-8");
   const lines = content.split(`
 `);
   const accounts = [];
@@ -4278,10 +4278,10 @@ function loadExistingAccounts(yearJournalPath) {
   return accounts.sort();
 }
 function extractRulePatternsFromFile(rulesPath) {
-  if (!fs17.existsSync(rulesPath)) {
+  if (!fs19.existsSync(rulesPath)) {
     return [];
   }
-  const content = fs17.readFileSync(rulesPath, "utf-8");
+  const content = fs19.readFileSync(rulesPath, "utf-8");
   const lines = content.split(`
 `);
   const patterns = [];
@@ -4515,7 +4515,7 @@ var init_accountSuggester = __esm(() => {
 
 // src/index.ts
 init_agentLoader();
-import { dirname as dirname4, join as join13 } from "path";
+import { dirname as dirname6, join as join15 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // node_modules/zod/v4/classic/external.js
@@ -17446,7 +17446,9 @@ function detectProvider(filename, content, config2) {
         continue;
       }
       const actualHeader = normalizeHeader(fields);
-      if (actualHeader !== rule.header) {
+      const ruleHeaderSep = delimiter !== "," && rule.header.includes(delimiter) ? delimiter : ",";
+      const expectedHeader = normalizeHeader(rule.header.split(ruleHeaderSep));
+      if (actualHeader !== expectedHeader) {
         continue;
       }
       if (!firstRow) {
@@ -24090,7 +24092,7 @@ Note: This tool requires a contextId from a prior classify/import step.`,
   }
 });
 // src/tools/import-pipeline.ts
-import * as path12 from "path";
+import * as path14 from "path";
 
 // src/utils/accountDeclarations.ts
 import * as fs12 from "fs";
@@ -24789,6 +24791,767 @@ Got:
   return { rowsProcessed, sendRowsEnriched: enrichedRows, alreadyPreprocessed: false };
 }
 
+// src/utils/swissquoteCsvPreprocessor.ts
+import * as fs18 from "fs";
+import * as path13 from "path";
+
+// src/utils/swissquoteLotTracker.ts
+import * as fs17 from "fs";
+import * as path12 from "path";
+var DEFAULT_LOT_INVENTORY_PATH = "ledger/investments/lot-inventory/{symbol}-lot.json";
+function getLotInventoryDir(directory, lotInventoryPath) {
+  const pathWithoutPlaceholder = lotInventoryPath.replace(/{symbol}[^/]*$/, "");
+  return path12.join(directory, pathWithoutPlaceholder);
+}
+function getSymbolLotPath(directory, lotInventoryPath, symbol2) {
+  const resolvedPath = lotInventoryPath.replace("{symbol}", symbol2);
+  return path12.join(directory, resolvedPath);
+}
+function listSymbolFiles(directory, lotInventoryPath) {
+  const lotDir = getLotInventoryDir(directory, lotInventoryPath);
+  if (!fs17.existsSync(lotDir)) {
+    return [];
+  }
+  const filenamePattern = path12.basename(lotInventoryPath);
+  const patternParts = filenamePattern.split("{symbol}");
+  if (patternParts.length !== 2) {
+    return [];
+  }
+  const [prefix, suffix] = patternParts;
+  return fs17.readdirSync(lotDir).filter((file2) => file2.startsWith(prefix) && file2.endsWith(suffix)).map((file2) => {
+    const symbolPart = file2.slice(prefix.length, -suffix.length);
+    return symbolPart;
+  });
+}
+function loadSymbolLots(directory, lotInventoryPath, symbol2, logger) {
+  const filePath = getSymbolLotPath(directory, lotInventoryPath, symbol2);
+  if (!fs17.existsSync(filePath)) {
+    return [];
+  }
+  try {
+    const content = fs17.readFileSync(filePath, "utf-8");
+    const lots = JSON.parse(content);
+    logger?.debug(`Loaded ${lots.length} lots for ${symbol2}`);
+    return lots;
+  } catch (error45) {
+    const message = error45 instanceof Error ? error45.message : String(error45);
+    logger?.warn(`Failed to load lots for ${symbol2}: ${message}`);
+    return [];
+  }
+}
+function saveSymbolLots(directory, lotInventoryPath, symbol2, lots, logger) {
+  const filePath = getSymbolLotPath(directory, lotInventoryPath, symbol2);
+  const lotDir = path12.dirname(filePath);
+  const nonEmptyLots = lots.filter((lot) => lot.quantity > 0);
+  if (nonEmptyLots.length === 0) {
+    if (fs17.existsSync(filePath)) {
+      fs17.unlinkSync(filePath);
+      logger?.debug(`Removed lot file for ${symbol2} (no remaining lots)`);
+    }
+    return;
+  }
+  if (!fs17.existsSync(lotDir)) {
+    fs17.mkdirSync(lotDir, { recursive: true });
+  }
+  const content = JSON.stringify(nonEmptyLots, null, 2);
+  fs17.writeFileSync(filePath, content);
+  logger?.debug(`Saved ${nonEmptyLots.length} lots for ${symbol2}`);
+}
+function loadLotInventory(directory, lotInventoryPath = DEFAULT_LOT_INVENTORY_PATH, logger) {
+  const symbols = listSymbolFiles(directory, lotInventoryPath);
+  if (symbols.length === 0) {
+    logger?.info("No lot inventory files found, starting fresh");
+    return {};
+  }
+  const inventory = {};
+  let totalLots = 0;
+  for (const symbol2 of symbols) {
+    const lots = loadSymbolLots(directory, lotInventoryPath, symbol2, logger);
+    if (lots.length > 0) {
+      inventory[symbol2] = lots;
+      totalLots += lots.length;
+    }
+  }
+  logger?.info(`Loaded lot inventory: ${symbols.length} symbols, ${totalLots} lots`);
+  return inventory;
+}
+function saveLotInventory(directory, lotInventoryPath = DEFAULT_LOT_INVENTORY_PATH, inventory, logger) {
+  let symbolCount = 0;
+  let totalLots = 0;
+  for (const [symbol2, lots] of Object.entries(inventory)) {
+    saveSymbolLots(directory, lotInventoryPath, symbol2, lots, logger);
+    const nonEmptyLots = lots.filter((lot) => lot.quantity > 0);
+    if (nonEmptyLots.length > 0) {
+      symbolCount++;
+      totalLots += nonEmptyLots.length;
+    }
+  }
+  logger?.info(`Saved lot inventory: ${symbolCount} symbols, ${totalLots} lots`);
+}
+function addLot(inventory, trade, logger) {
+  const lot = {
+    date: trade.date,
+    quantity: trade.quantity,
+    costBasis: trade.unitPrice,
+    currency: trade.currency,
+    isin: trade.isin,
+    orderNum: trade.orderNum
+  };
+  if (!inventory[trade.symbol]) {
+    inventory[trade.symbol] = [];
+  }
+  inventory[trade.symbol].push(lot);
+  logger?.debug(`Added lot: ${trade.quantity} ${trade.symbol} @ ${trade.unitPrice} ${trade.currency} (${trade.date})`);
+}
+function consumeLotsFIFO(inventory, symbol2, quantity, logger) {
+  const lots = inventory[symbol2];
+  if (!lots || lots.length === 0) {
+    throw new Error(`No lots found for symbol ${symbol2}`);
+  }
+  lots.sort((a, b) => a.date.localeCompare(b.date));
+  let remaining = quantity;
+  const consumed = [];
+  for (const lot of lots) {
+    if (remaining <= 0)
+      break;
+    const take = Math.min(remaining, lot.quantity);
+    const totalCost = take * lot.costBasis;
+    consumed.push({
+      lot: { ...lot },
+      quantity: take,
+      totalCost
+    });
+    lot.quantity -= take;
+    remaining -= take;
+    logger?.debug(`FIFO consumed: ${take} ${symbol2} from lot ${lot.date} @ ${lot.costBasis} ${lot.currency}`);
+  }
+  if (remaining > 0) {
+    const availableQty = lots.reduce((sum, lot) => sum + lot.quantity, 0) + quantity - remaining;
+    throw new Error(`Insufficient lots for ${symbol2}: need ${quantity}, have ${availableQty}. ` + `Remaining ${remaining} shares could not be matched.`);
+  }
+  return consumed;
+}
+function calculateCapitalGain(consumed, salePrice, quantity) {
+  const totalCostBasis = consumed.reduce((sum, c) => sum + c.totalCost, 0);
+  const saleProceeds = salePrice * quantity;
+  return saleProceeds - totalCostBasis;
+}
+function adjustLotsForSplit(inventory, symbol2, ratio, logger) {
+  const lots = inventory[symbol2];
+  if (!lots || lots.length === 0) {
+    logger?.warn(`No lots found for ${symbol2} during split adjustment`);
+    return;
+  }
+  for (const lot of lots) {
+    const oldQuantity = lot.quantity;
+    const oldCostBasis = lot.costBasis;
+    lot.quantity = oldQuantity * ratio;
+    lot.costBasis = oldCostBasis / ratio;
+    logger?.debug(`Split adjusted ${symbol2}: ${oldQuantity} @ ${oldCostBasis} -> ${lot.quantity} @ ${lot.costBasis}`);
+  }
+  logger?.info(`Adjusted ${lots.length} lots for ${symbol2} split (ratio: ${ratio})`);
+}
+function adjustLotsForMerger(inventory, oldSymbol, newSymbol, ratio, logger) {
+  const oldLots = inventory[oldSymbol];
+  if (!oldLots || oldLots.length === 0) {
+    logger?.warn(`No lots found for ${oldSymbol} during merger adjustment`);
+    return;
+  }
+  const newLots = oldLots.map((lot) => ({
+    ...lot,
+    quantity: lot.quantity * ratio,
+    costBasis: lot.costBasis / ratio
+  }));
+  if (!inventory[newSymbol]) {
+    inventory[newSymbol] = [];
+  }
+  inventory[newSymbol].push(...newLots);
+  delete inventory[oldSymbol];
+  logger?.info(`Merger: ${oldLots.length} lots moved from ${oldSymbol} to ${newSymbol} (ratio: ${ratio})`);
+}
+function removeLots(inventory, symbol2, logger) {
+  const lots = inventory[symbol2];
+  if (!lots || lots.length === 0) {
+    logger?.warn(`No lots found for ${symbol2} during removal`);
+    return [];
+  }
+  const removedLots = [...lots];
+  delete inventory[symbol2];
+  const totalQuantity = removedLots.reduce((sum, lot) => sum + lot.quantity, 0);
+  const totalCost = removedLots.reduce((sum, lot) => sum + lot.quantity * lot.costBasis, 0);
+  logger?.info(`Removed ${removedLots.length} lots for ${symbol2}: ${totalQuantity} shares, cost basis ${totalCost}`);
+  return removedLots;
+}
+function getHeldQuantity(inventory, symbol2) {
+  const lots = inventory[symbol2];
+  if (!lots)
+    return 0;
+  return lots.reduce((sum, lot) => sum + lot.quantity, 0);
+}
+
+// src/utils/swissquoteJournalGenerator.ts
+function formatAmount2(amount, currency) {
+  const formatted = Math.abs(amount).toFixed(2);
+  const sign = amount < 0 ? "-" : "";
+  return `${sign}${formatted} ${currency}`;
+}
+function formatDate(dateStr) {
+  const match2 = dateStr.match(/^(\d{2})-(\d{2})-(\d{4})/);
+  if (!match2) {
+    throw new Error(`Invalid date format: ${dateStr}`);
+  }
+  const [, day, month, year] = match2;
+  return `${year}-${month}-${day}`;
+}
+function escapeDescription(desc) {
+  return desc.replace(/[;|]/g, "-").trim();
+}
+function formatQuantity(qty) {
+  return qty.toFixed(6).replace(/\.?0+$/, "");
+}
+function generateBuyEntry(trade, logger) {
+  const date5 = formatDate(trade.date);
+  const description = escapeDescription(`Buy ${trade.symbol} - ${trade.name}`);
+  const qty = formatQuantity(trade.quantity);
+  const price = trade.unitPrice.toFixed(2);
+  const totalCost = trade.quantity * trade.unitPrice;
+  const fees = trade.costs;
+  const cashOut = totalCost + fees;
+  logger?.debug(`Generating Buy entry: ${qty} ${trade.symbol} @ ${price} ${trade.currency}`);
+  let entry = `${date5} ${description}
+`;
+  entry += `    ; swissquote:order:${trade.orderNum} isin:${trade.isin}
+`;
+  entry += `    assets:investments:stocks:${trade.symbol}    ${qty} ${trade.symbol} @ ${price} ${trade.currency}
+`;
+  if (fees > 0) {
+    entry += `    expenses:fees:trading:swissquote    ${formatAmount2(fees, trade.currency)}
+`;
+  }
+  entry += `    assets:broker:swissquote:${trade.currency.toLowerCase()}    ${formatAmount2(-cashOut, trade.currency)}
+`;
+  return entry;
+}
+function generateSellEntry(trade, consumed, logger) {
+  const date5 = formatDate(trade.date);
+  const description = escapeDescription(`Sell ${trade.symbol} - ${trade.name}`);
+  const qty = formatQuantity(trade.quantity);
+  const salePrice = trade.unitPrice;
+  const fees = trade.costs;
+  const saleProceeds = trade.quantity * salePrice;
+  const cashIn = saleProceeds - fees;
+  const gain = calculateCapitalGain(consumed, salePrice, trade.quantity);
+  logger?.debug(`Generating Sell entry: ${qty} ${trade.symbol} @ ${salePrice} ${trade.currency}, gain: ${gain.toFixed(2)}`);
+  let entry = `${date5} ${description}
+`;
+  entry += `    ; swissquote:order:${trade.orderNum} isin:${trade.isin}
+`;
+  const lotDetails = consumed.map((c) => `${c.lot.date}: ${formatQuantity(c.quantity)}@${c.lot.costBasis.toFixed(2)}`).join(", ");
+  entry += `    ; FIFO lots: ${lotDetails}
+`;
+  for (const c of consumed) {
+    const lotQty = formatQuantity(c.quantity);
+    const lotPrice = c.lot.costBasis.toFixed(2);
+    entry += `    assets:investments:stocks:${trade.symbol}    -${lotQty} ${trade.symbol} @ ${lotPrice} ${trade.currency}
+`;
+  }
+  entry += `    assets:broker:swissquote:${trade.currency.toLowerCase()}    ${formatAmount2(cashIn, trade.currency)}
+`;
+  if (fees > 0) {
+    entry += `    expenses:fees:trading:swissquote    ${formatAmount2(fees, trade.currency)}
+`;
+  }
+  if (gain >= 0) {
+    entry += `    income:capital-gains:realized    ${formatAmount2(-gain, trade.currency)}
+`;
+  } else {
+    entry += `    expenses:losses:capital    ${formatAmount2(-gain, trade.currency)}
+`;
+  }
+  return entry;
+}
+function generateDividendEntry(dividend, logger) {
+  const date5 = formatDate(dividend.date);
+  const description = escapeDescription(`Dividend ${dividend.symbol} - ${dividend.name}`);
+  logger?.debug(`Generating Dividend entry: ${dividend.symbol}, net: ${dividend.netAmount} ${dividend.currency}`);
+  let entry = `${date5} ${description}
+`;
+  entry += `    ; swissquote:order:${dividend.orderNum} isin:${dividend.isin}
+`;
+  entry += `    assets:broker:swissquote:${dividend.currency.toLowerCase()}    ${formatAmount2(dividend.netAmount, dividend.currency)}
+`;
+  if (dividend.withholdingTax > 0) {
+    entry += `    expenses:taxes:withholding    ${formatAmount2(dividend.withholdingTax, dividend.currency)}
+`;
+  }
+  entry += `    income:dividends:${dividend.symbol}    ${formatAmount2(-dividend.grossAmount, dividend.currency)}
+`;
+  return entry;
+}
+function generateMergerEntry(action, oldQuantity, newQuantity, logger) {
+  const date5 = formatDate(action.date);
+  const newSymbol = action.newSymbol || "UNKNOWN";
+  const description = escapeDescription(`Merger: ${action.symbol} -> ${newSymbol}`);
+  logger?.debug(`Generating Merger entry: ${oldQuantity} ${action.symbol} -> ${newQuantity} ${newSymbol}`);
+  let entry = `${date5} ${description}
+`;
+  entry += `    ; swissquote:order:${action.orderNum}
+`;
+  entry += `    ; Old ISIN: ${action.isin}, New ISIN: ${action.newIsin || "unknown"}
+`;
+  entry += `    assets:investments:stocks:${action.symbol}    -${formatQuantity(oldQuantity)} ${action.symbol}
+`;
+  entry += `    equity:conversion    ${formatQuantity(oldQuantity)} ${action.symbol}
+`;
+  entry += `    equity:conversion    -${formatQuantity(newQuantity)} ${newSymbol}
+`;
+  entry += `    assets:investments:stocks:${newSymbol}    ${formatQuantity(newQuantity)} ${newSymbol}
+`;
+  return entry;
+}
+function generateSplitEntry(action, oldQuantity, newQuantity, logger) {
+  const date5 = formatDate(action.date);
+  const ratio = action.ratio || newQuantity / oldQuantity;
+  const splitType = ratio > 1 ? "Split" : "Reverse Split";
+  const description = escapeDescription(`${splitType}: ${action.symbol} (${action.name})`);
+  logger?.debug(`Generating ${splitType} entry: ${oldQuantity} -> ${newQuantity} ${action.symbol}`);
+  let entry = `${date5} ${description}
+`;
+  entry += `    ; swissquote:order:${action.orderNum} isin:${action.isin}
+`;
+  entry += `    ; Ratio: ${ratio.toFixed(4)} (${oldQuantity} -> ${newQuantity})
+`;
+  entry += `    assets:investments:stocks:${action.symbol}    -${formatQuantity(oldQuantity)} ${action.symbol}
+`;
+  entry += `    equity:conversion    ${formatQuantity(oldQuantity)} ${action.symbol}
+`;
+  entry += `    equity:conversion    -${formatQuantity(newQuantity)} ${action.symbol}
+`;
+  entry += `    assets:investments:stocks:${action.symbol}    ${formatQuantity(newQuantity)} ${action.symbol}
+`;
+  return entry;
+}
+function generateWorthlessEntry(action, removedLots, logger) {
+  const date5 = formatDate(action.date);
+  const description = escapeDescription(`Worthless Liquidation: ${action.symbol} - ${action.name}`);
+  const totalQuantity = removedLots.reduce((sum, lot) => sum + lot.quantity, 0);
+  const totalCost = removedLots.reduce((sum, lot) => sum + lot.quantity * lot.costBasis, 0);
+  const currency = removedLots[0]?.currency || "USD";
+  logger?.debug(`Generating Worthless entry: ${totalQuantity} ${action.symbol}, loss: ${totalCost} ${currency}`);
+  let entry = `${date5} ${description}
+`;
+  entry += `    ; swissquote:order:${action.orderNum} isin:${action.isin}
+`;
+  entry += `    ; Total loss: ${totalCost.toFixed(2)} ${currency}
+`;
+  for (const lot of removedLots) {
+    const qty = formatQuantity(lot.quantity);
+    const price = lot.costBasis.toFixed(2);
+    entry += `    assets:investments:stocks:${action.symbol}    -${qty} ${action.symbol} @ ${price} ${currency}
+`;
+  }
+  entry += `    expenses:losses:capital    ${formatAmount2(totalCost, currency)}
+`;
+  return entry;
+}
+function formatJournalFile(entries, year, currency) {
+  const header = `; Swissquote ${currency.toUpperCase()} investment transactions for ${year}
+; Generated by opencode-accountant
+; This file is auto-generated - do not edit manually
+
+`;
+  return header + entries.join(`
+`);
+}
+
+// src/utils/swissquoteCsvPreprocessor.ts
+var SWISSQUOTE_HEADER = "Date;Order #;Transaction;Symbol;Name;ISIN;Quantity;Unit price;Costs;Accrued Interest;Net Amount;Balance;Currency";
+var SIMPLE_TRANSACTION_TYPES = new Set([
+  "Custody Fees",
+  "Forex credit",
+  "Forex debit",
+  "Interest on debits",
+  "Interest on credits",
+  "Exchange fees",
+  "Exchange fees rectif."
+]);
+var TRADE_TYPES = new Set(["Buy", "Sell"]);
+var DIVIDEND_TYPES = new Set(["Dividend"]);
+var CORPORATE_ACTION_TYPES = new Set([
+  "Merger",
+  "Reverse Split",
+  "Worthless Liquidation",
+  "Internal exchange of securities"
+]);
+var SKIP_TYPES = new Set([
+  "Internal exchange",
+  "Reversal"
+]);
+function parseTransaction(line) {
+  const fields = [];
+  let current = "";
+  let inQuotes = false;
+  for (const char of line) {
+    if (char === '"') {
+      inQuotes = !inQuotes;
+    } else if (char === ";" && !inQuotes) {
+      fields.push(current.trim());
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  fields.push(current.trim());
+  if (fields.length < 13) {
+    return null;
+  }
+  return {
+    date: fields[0],
+    orderNum: fields[1],
+    transaction: fields[2],
+    symbol: fields[3],
+    name: fields[4],
+    isin: fields[5],
+    quantity: fields[6],
+    unitPrice: fields[7],
+    costs: fields[8],
+    accruedInterest: fields[9],
+    netAmount: fields[10],
+    balance: fields[11],
+    currency: fields[12]
+  };
+}
+function parseNumber(value) {
+  if (!value || value === "-" || value === "") {
+    return 0;
+  }
+  const normalized = value.replace(/,/g, ".");
+  const parsed = parseFloat(normalized);
+  return isNaN(parsed) ? 0 : parsed;
+}
+function categorizeTransaction(txn) {
+  const type2 = txn.transaction;
+  if (SKIP_TYPES.has(type2)) {
+    return "skip";
+  }
+  if (SIMPLE_TRANSACTION_TYPES.has(type2)) {
+    return "simple";
+  }
+  if (TRADE_TYPES.has(type2)) {
+    return "trade";
+  }
+  if (DIVIDEND_TYPES.has(type2)) {
+    return "dividend";
+  }
+  if (CORPORATE_ACTION_TYPES.has(type2)) {
+    return "corporate";
+  }
+  if (!txn.netAmount || txn.netAmount === "-") {
+    return "skip";
+  }
+  return "simple";
+}
+function toTradeEntry(txn) {
+  return {
+    date: txn.date,
+    orderNum: txn.orderNum,
+    type: txn.transaction,
+    symbol: txn.symbol,
+    name: txn.name,
+    isin: txn.isin,
+    quantity: parseNumber(txn.quantity),
+    unitPrice: parseNumber(txn.unitPrice),
+    costs: parseNumber(txn.costs),
+    netAmount: parseNumber(txn.netAmount),
+    currency: txn.currency
+  };
+}
+function toDividendEntry(txn) {
+  const netAmount = parseNumber(txn.netAmount);
+  const withholdingTax = parseNumber(txn.costs);
+  const grossAmount = netAmount + withholdingTax;
+  return {
+    date: txn.date,
+    orderNum: txn.orderNum,
+    symbol: txn.symbol,
+    name: txn.name,
+    isin: txn.isin,
+    grossAmount,
+    withholdingTax,
+    netAmount,
+    currency: txn.currency
+  };
+}
+function toCorporateActionEntry(txn) {
+  return {
+    date: txn.date,
+    orderNum: txn.orderNum,
+    type: txn.transaction,
+    symbol: txn.symbol,
+    name: txn.name,
+    isin: txn.isin,
+    quantity: Math.abs(parseNumber(txn.quantity))
+  };
+}
+function processCorporateActions(actions, inventory, logger) {
+  const entries = [];
+  const pendingMergers = new Map;
+  actions.sort((a, b) => a.date.localeCompare(b.date));
+  for (const action of actions) {
+    switch (action.type) {
+      case "Merger":
+      case "Internal exchange of securities": {
+        const key = `${action.date}-${action.orderNum}`;
+        if (action.quantity < 0 || pendingMergers.has(key)) {
+          const pending = pendingMergers.get(key);
+          if (pending && pending.outgoing) {
+            pending.incoming = action;
+            const oldQty = Math.abs(parseNumber(String(pending.outgoing.quantity)));
+            const newQty = Math.abs(parseNumber(String(action.quantity)));
+            const ratio = newQty / oldQty;
+            adjustLotsForMerger(inventory, pending.outgoing.symbol, action.symbol, ratio, logger);
+            const entry = generateMergerEntry({
+              ...pending.outgoing,
+              newSymbol: action.symbol,
+              newIsin: action.isin,
+              ratio
+            }, oldQty, newQty, logger);
+            entries.push(entry);
+            pendingMergers.delete(key);
+          } else {
+            pendingMergers.set(key, { outgoing: action });
+          }
+        } else {
+          pendingMergers.set(key, { outgoing: action });
+        }
+        break;
+      }
+      case "Reverse Split": {
+        const oldQty = getHeldQuantity(inventory, action.symbol);
+        const newQty = action.quantity;
+        if (oldQty > 0) {
+          const ratio = newQty / oldQty;
+          adjustLotsForSplit(inventory, action.symbol, ratio, logger);
+          const entry = generateSplitEntry(action, oldQty, newQty, logger);
+          entries.push(entry);
+        } else {
+          logger?.warn(`Reverse split for ${action.symbol} but no lots found`);
+        }
+        break;
+      }
+      case "Worthless Liquidation": {
+        const removedLots = removeLots(inventory, action.symbol, logger);
+        if (removedLots.length > 0) {
+          const entry = generateWorthlessEntry(action, removedLots, logger);
+          entries.push(entry);
+        } else {
+          logger?.warn(`Worthless liquidation for ${action.symbol} but no lots found`);
+        }
+        break;
+      }
+    }
+  }
+  for (const [key, pending] of pendingMergers.entries()) {
+    logger?.warn(`Unmatched merger entry: ${key} - ${pending.outgoing.symbol}`);
+  }
+  return entries;
+}
+async function preprocessSwissquote(csvPath, projectDir, currency, year, lotInventoryPath = DEFAULT_LOT_INVENTORY_PATH, logger) {
+  logger?.startSection(`Swissquote Preprocessing: ${path13.basename(csvPath)}`);
+  const stats = {
+    totalRows: 0,
+    simpleTransactions: 0,
+    trades: 0,
+    dividends: 0,
+    corporateActions: 0,
+    skipped: 0
+  };
+  if (!fs18.existsSync(csvPath)) {
+    logger?.error(`CSV file not found: ${csvPath}`);
+    logger?.endSection();
+    return {
+      simpleTransactionsCsv: null,
+      journalFile: null,
+      stats,
+      alreadyPreprocessed: false
+    };
+  }
+  logger?.logStep("parse-csv", "start", `Reading ${csvPath}`);
+  const content = fs18.readFileSync(csvPath, "utf-8");
+  const lines = content.split(`
+`).filter((line) => line.trim());
+  const header = lines[0];
+  if (!header.startsWith("Date;Order #;Transaction")) {
+    logger?.error(`Invalid Swissquote CSV header: ${header.substring(0, 50)}...`);
+    logger?.endSection();
+    return {
+      simpleTransactionsCsv: null,
+      journalFile: null,
+      stats,
+      alreadyPreprocessed: false
+    };
+  }
+  const transactions = [];
+  for (let i2 = 1;i2 < lines.length; i2++) {
+    const txn = parseTransaction(lines[i2]);
+    if (txn) {
+      transactions.push(txn);
+    }
+  }
+  stats.totalRows = transactions.length;
+  logger?.logStep("parse-csv", "success", `Parsed ${stats.totalRows} transactions`);
+  logger?.logStep("load-inventory", "start", "Loading lot inventory");
+  const inventory = loadLotInventory(projectDir, lotInventoryPath, logger);
+  logger?.logStep("load-inventory", "success", "Lot inventory loaded");
+  logger?.startSection("Transaction Routing", 2);
+  const simpleTransactions = [];
+  const trades = [];
+  const dividends = [];
+  const corporateActions = [];
+  for (const txn of transactions) {
+    const category = categorizeTransaction(txn);
+    switch (category) {
+      case "simple":
+        simpleTransactions.push(txn);
+        stats.simpleTransactions++;
+        break;
+      case "trade":
+        trades.push(toTradeEntry(txn));
+        stats.trades++;
+        break;
+      case "dividend":
+        dividends.push(toDividendEntry(txn));
+        stats.dividends++;
+        break;
+      case "corporate":
+        corporateActions.push(toCorporateActionEntry(txn));
+        stats.corporateActions++;
+        break;
+      case "skip":
+        stats.skipped++;
+        break;
+    }
+  }
+  logger?.logStep("route", "success", `Simple: ${stats.simpleTransactions}, Trades: ${stats.trades}, Dividends: ${stats.dividends}, Corporate: ${stats.corporateActions}, Skipped: ${stats.skipped}`);
+  logger?.endSection();
+  const journalEntries = [];
+  if (trades.length > 0) {
+    logger?.startSection("Trade Processing", 2);
+    trades.sort((a, b) => a.date.localeCompare(b.date));
+    for (const trade of trades) {
+      try {
+        if (trade.type === "Buy") {
+          const tradeInfo = {
+            date: formatDate(trade.date),
+            orderNum: trade.orderNum,
+            symbol: trade.symbol,
+            isin: trade.isin,
+            quantity: trade.quantity,
+            unitPrice: trade.unitPrice,
+            currency: trade.currency
+          };
+          addLot(inventory, tradeInfo, logger);
+          const entry = generateBuyEntry(trade, logger);
+          journalEntries.push(entry);
+          logger?.logStep("trade-buy", "success", `Buy ${trade.quantity} ${trade.symbol} @ ${trade.unitPrice} ${trade.currency}`);
+        } else if (trade.type === "Sell") {
+          const consumed = consumeLotsFIFO(inventory, trade.symbol, trade.quantity, logger);
+          const entry = generateSellEntry(trade, consumed, logger);
+          journalEntries.push(entry);
+          const totalCost = consumed.reduce((sum, c) => sum + c.totalCost, 0);
+          const gain = trade.quantity * trade.unitPrice - totalCost;
+          logger?.logStep("trade-sell", "success", `Sell ${trade.quantity} ${trade.symbol} @ ${trade.unitPrice} ${trade.currency}, gain: ${gain.toFixed(2)}`);
+        }
+      } catch (error45) {
+        const message = error45 instanceof Error ? error45.message : String(error45);
+        logger?.logStep("trade", "error", `Failed to process trade: ${message}`);
+        logger?.error(`Trade processing error for ${trade.symbol}`, error45 instanceof Error ? error45 : undefined);
+      }
+    }
+    logger?.endSection();
+  }
+  if (dividends.length > 0) {
+    logger?.startSection("Dividend Processing", 2);
+    for (const dividend of dividends) {
+      const entry = generateDividendEntry(dividend, logger);
+      journalEntries.push(entry);
+      logger?.logStep("dividend", "success", `Dividend ${dividend.symbol}: ${dividend.netAmount} ${dividend.currency} (tax: ${dividend.withholdingTax})`);
+    }
+    logger?.endSection();
+  }
+  if (corporateActions.length > 0) {
+    logger?.startSection("Corporate Actions Processing", 2);
+    const corpEntries = processCorporateActions(corporateActions, inventory, logger);
+    journalEntries.push(...corpEntries);
+    logger?.logStep("corporate", "success", `Processed ${corporateActions.length} corporate actions`);
+    logger?.endSection();
+  }
+  logger?.logStep("save-inventory", "start", "Saving lot inventory");
+  saveLotInventory(projectDir, lotInventoryPath, inventory, logger);
+  logger?.logStep("save-inventory", "success", "Lot inventory saved");
+  let simpleTransactionsCsv = null;
+  let journalFile = null;
+  if (simpleTransactions.length > 0) {
+    const csvDir = path13.dirname(csvPath);
+    const csvBasename = path13.basename(csvPath, ".csv");
+    simpleTransactionsCsv = path13.join(csvDir, `${csvBasename}-simple.csv`);
+    const csvContent = [
+      SWISSQUOTE_HEADER,
+      ...simpleTransactions.map((txn) => [
+        txn.date,
+        txn.orderNum,
+        txn.transaction,
+        txn.symbol,
+        txn.name,
+        txn.isin,
+        txn.quantity,
+        txn.unitPrice,
+        txn.costs,
+        txn.accruedInterest,
+        txn.netAmount,
+        txn.balance,
+        txn.currency
+      ].join(";"))
+    ].join(`
+`);
+    fs18.writeFileSync(simpleTransactionsCsv, csvContent);
+    logger?.logStep("write-csv", "success", `Wrote ${simpleTransactions.length} simple transactions to ${path13.basename(simpleTransactionsCsv)}`);
+  }
+  if (journalEntries.length > 0) {
+    const investmentsDir = path13.join(projectDir, "ledger", "investments");
+    if (!fs18.existsSync(investmentsDir)) {
+      fs18.mkdirSync(investmentsDir, { recursive: true });
+    }
+    journalFile = path13.join(investmentsDir, `${year}-${currency}.journal`);
+    const journalContent = formatJournalFile(journalEntries, year, currency);
+    if (fs18.existsSync(journalFile)) {
+      fs18.appendFileSync(journalFile, `
+` + journalEntries.join(`
+`));
+      logger?.logStep("write-journal", "success", `Appended ${journalEntries.length} entries to ${path13.basename(journalFile)}`);
+    } else {
+      fs18.writeFileSync(journalFile, journalContent);
+      logger?.logStep("write-journal", "success", `Created ${path13.basename(journalFile)} with ${journalEntries.length} entries`);
+    }
+  }
+  logger?.logResult({
+    totalRows: stats.totalRows,
+    simpleTransactions: stats.simpleTransactions,
+    trades: stats.trades,
+    dividends: stats.dividends,
+    corporateActions: stats.corporateActions,
+    skipped: stats.skipped,
+    journalEntries: journalEntries.length
+  });
+  logger?.endSection();
+  return {
+    simpleTransactionsCsv,
+    journalFile,
+    stats,
+    alreadyPreprocessed: false
+  };
+}
+
 // src/tools/import-pipeline.ts
 class NoTransactionsError extends Error {
   constructor() {
@@ -24861,7 +25624,7 @@ function executePreprocessFiatStep(context, contextIds, logger) {
   for (const contextId of contextIds) {
     const importCtx = loadContext(context.directory, contextId);
     if (importCtx.provider === "revolut" && importCtx.currency !== "btc") {
-      fiatCsvPaths.push(path12.join(context.directory, importCtx.filePath));
+      fiatCsvPaths.push(path14.join(context.directory, importCtx.filePath));
     }
   }
   if (fiatCsvPaths.length === 0) {
@@ -24905,7 +25668,7 @@ function executePreprocessBtcStep(context, contextIds, logger) {
   for (const contextId of contextIds) {
     const importCtx = loadContext(context.directory, contextId);
     if (importCtx.provider === "revolut" && importCtx.currency === "btc") {
-      btcCsvPath = path12.join(context.directory, importCtx.filePath);
+      btcCsvPath = path14.join(context.directory, importCtx.filePath);
       break;
     }
   }
@@ -24939,7 +25702,7 @@ async function executeBtcPurchaseStep(context, contextIds, logger) {
     const importCtx = loadContext(context.directory, contextId);
     if (importCtx.provider !== "revolut")
       continue;
-    const csvPath = path12.join(context.directory, importCtx.filePath);
+    const csvPath = path14.join(context.directory, importCtx.filePath);
     if (importCtx.currency === "btc") {
       btcCsvPath = csvPath;
     } else {
@@ -24952,7 +25715,7 @@ async function executeBtcPurchaseStep(context, contextIds, logger) {
   }
   logger?.startSection("Step 1b: Generate BTC Purchase Entries");
   logger?.logStep("BTC Purchases", "start");
-  const btcFilename = path12.basename(btcCsvPath);
+  const btcFilename = path14.basename(btcCsvPath);
   const yearMatch = btcFilename.match(/(\d{4})-\d{2}-\d{2}/);
   const year = yearMatch ? parseInt(yearMatch[1], 10) : new Date().getFullYear();
   const yearJournalPath = ensureYearJournalExists(context.directory, year);
@@ -24968,13 +25731,91 @@ async function executeBtcPurchaseStep(context, contextIds, logger) {
     unmatchedBtc: result.unmatchedBtc.length
   });
 }
+async function executeSwissquotePreprocessStep(context, contextIds, logger) {
+  const swissquoteContexts = [];
+  for (const contextId of contextIds) {
+    const importCtx = loadContext(context.directory, contextId);
+    if (importCtx.provider === "swissquote") {
+      const csvPath = path14.join(context.directory, importCtx.filePath);
+      const filenameMatch = importCtx.filename.match(/from-(\d{2})(\d{2})(\d{4})|(\d{4})-\d{2}-\d{2}/);
+      let year = new Date().getFullYear();
+      if (filenameMatch) {
+        if (filenameMatch[3]) {
+          year = parseInt(filenameMatch[3], 10);
+        } else if (filenameMatch[4]) {
+          year = parseInt(filenameMatch[4], 10);
+        }
+      }
+      swissquoteContexts.push({
+        contextId,
+        csvPath,
+        currency: importCtx.currency,
+        year
+      });
+    }
+  }
+  if (swissquoteContexts.length === 0) {
+    logger?.info("No Swissquote CSV found, skipping preprocessing");
+    return;
+  }
+  logger?.startSection("Step 1d: Preprocess Swissquote CSV");
+  const config2 = context.configLoader(context.directory);
+  const swissquoteProvider = config2.providers?.["swissquote"];
+  const lotInventoryPath = swissquoteProvider?.lotInventoryPath ?? DEFAULT_LOT_INVENTORY_PATH;
+  try {
+    let totalStats = {
+      totalRows: 0,
+      simpleTransactions: 0,
+      trades: 0,
+      dividends: 0,
+      corporateActions: 0,
+      skipped: 0
+    };
+    let lastJournalFile = null;
+    for (const sqCtx of swissquoteContexts) {
+      logger?.logStep("Swissquote Preprocess", "start", `Processing ${path14.basename(sqCtx.csvPath)}`);
+      const result = await preprocessSwissquote(sqCtx.csvPath, context.directory, sqCtx.currency, sqCtx.year, lotInventoryPath, logger);
+      totalStats.totalRows += result.stats.totalRows;
+      totalStats.simpleTransactions += result.stats.simpleTransactions;
+      totalStats.trades += result.stats.trades;
+      totalStats.dividends += result.stats.dividends;
+      totalStats.corporateActions += result.stats.corporateActions;
+      totalStats.skipped += result.stats.skipped;
+      if (result.journalFile) {
+        lastJournalFile = result.journalFile;
+      }
+      if (result.simpleTransactionsCsv) {
+        updateContext(context.directory, sqCtx.contextId, {
+          filePath: path14.relative(context.directory, result.simpleTransactionsCsv)
+        });
+        logger?.info(`Updated context ${sqCtx.contextId} to use filtered CSV: ${path14.basename(result.simpleTransactionsCsv)}`);
+      }
+      logger?.logStep("Swissquote Preprocess", "success", `Processed: ${result.stats.trades} trades, ${result.stats.dividends} dividends, ${result.stats.corporateActions} corporate actions`);
+    }
+    const message = `Preprocessed ${totalStats.totalRows} rows: ` + `${totalStats.trades} trades, ${totalStats.dividends} dividends, ` + `${totalStats.corporateActions} corporate actions, ${totalStats.simpleTransactions} simple`;
+    context.result.steps.swissquotePreprocess = buildStepResult(true, message, {
+      ...totalStats,
+      journalFile: lastJournalFile
+    });
+  } catch (error45) {
+    const errorMessage = `Swissquote preprocessing failed: ${error45 instanceof Error ? error45.message : String(error45)}`;
+    logger?.error(errorMessage);
+    logger?.logStep("Swissquote Preprocess", "error", errorMessage);
+    context.result.steps.swissquotePreprocess = buildStepResult(false, errorMessage);
+    context.result.error = errorMessage;
+    context.result.hint = "Check the Swissquote CSV format and lot inventory state";
+    throw new Error(errorMessage);
+  } finally {
+    logger?.endSection();
+  }
+}
 async function executeAccountDeclarationsStep(context, contextId, logger) {
   logger?.startSection("Step 2: Check Account Declarations");
   logger?.logStep("Check Accounts", "start");
   const config2 = context.configLoader(context.directory);
-  const rulesDir = path12.join(context.directory, config2.paths.rules);
+  const rulesDir = path14.join(context.directory, config2.paths.rules);
   const importCtx = loadContext(context.directory, contextId);
-  const csvPath = path12.join(context.directory, importCtx.filePath);
+  const csvPath = path14.join(context.directory, importCtx.filePath);
   const csvFiles = [csvPath];
   const rulesMapping = loadRulesMapping(rulesDir);
   const matchedRulesFiles = new Set;
@@ -24997,7 +25838,7 @@ async function executeAccountDeclarationsStep(context, contextId, logger) {
     context.result.steps.accountDeclarations = buildStepResult(true, "No accounts found in rules files", {
       accountsAdded: [],
       journalUpdated: "",
-      rulesScanned: Array.from(matchedRulesFiles).map((f) => path12.relative(context.directory, f))
+      rulesScanned: Array.from(matchedRulesFiles).map((f) => path14.relative(context.directory, f))
     });
     return;
   }
@@ -25021,7 +25862,7 @@ async function executeAccountDeclarationsStep(context, contextId, logger) {
     context.result.steps.accountDeclarations = buildStepResult(true, "No transactions found, skipping account declarations", {
       accountsAdded: [],
       journalUpdated: "",
-      rulesScanned: Array.from(matchedRulesFiles).map((f) => path12.relative(context.directory, f))
+      rulesScanned: Array.from(matchedRulesFiles).map((f) => path14.relative(context.directory, f))
     });
     return;
   }
@@ -25032,12 +25873,12 @@ async function executeAccountDeclarationsStep(context, contextId, logger) {
     context.result.steps.accountDeclarations = buildStepResult(false, `Failed to create year journal: ${error45 instanceof Error ? error45.message : String(error45)}`, {
       accountsAdded: [],
       journalUpdated: "",
-      rulesScanned: Array.from(matchedRulesFiles).map((f) => path12.relative(context.directory, f))
+      rulesScanned: Array.from(matchedRulesFiles).map((f) => path14.relative(context.directory, f))
     });
     return;
   }
   const result = ensureAccountDeclarations(yearJournalPath, allAccounts);
-  const message = result.added.length > 0 ? `Added ${result.added.length} account declaration(s) to ${path12.relative(context.directory, yearJournalPath)}` : "All required accounts already declared";
+  const message = result.added.length > 0 ? `Added ${result.added.length} account declaration(s) to ${path14.relative(context.directory, yearJournalPath)}` : "All required accounts already declared";
   logger?.logStep("Check Accounts", "success", message);
   if (result.added.length > 0) {
     for (const account of result.added) {
@@ -25046,17 +25887,17 @@ async function executeAccountDeclarationsStep(context, contextId, logger) {
   }
   context.result.steps.accountDeclarations = buildStepResult(true, message, {
     accountsAdded: result.added,
-    journalUpdated: path12.relative(context.directory, yearJournalPath),
-    rulesScanned: Array.from(matchedRulesFiles).map((f) => path12.relative(context.directory, f))
+    journalUpdated: path14.relative(context.directory, yearJournalPath),
+    rulesScanned: Array.from(matchedRulesFiles).map((f) => path14.relative(context.directory, f))
   });
   logger?.endSection();
 }
 async function buildSuggestionContext(context, contextId, logger) {
   const { loadExistingAccounts: loadExistingAccounts2, extractRulePatternsFromFile: extractRulePatternsFromFile2 } = await Promise.resolve().then(() => (init_accountSuggester(), exports_accountSuggester));
   const config2 = context.configLoader(context.directory);
-  const rulesDir = path12.join(context.directory, config2.paths.rules);
+  const rulesDir = path14.join(context.directory, config2.paths.rules);
   const importCtx = loadContext(context.directory, contextId);
-  const csvPath = path12.join(context.directory, importCtx.filePath);
+  const csvPath = path14.join(context.directory, importCtx.filePath);
   const rulesMapping = loadRulesMapping(rulesDir);
   const rulesFile = findRulesForCsv(csvPath, rulesMapping);
   if (!rulesFile) {
@@ -25263,6 +26104,7 @@ async function importPipeline(directory, agent, options, configLoader = loadImpo
     executePreprocessFiatStep(context, contextIds, logger);
     executePreprocessBtcStep(context, contextIds, logger);
     await executeBtcPurchaseStep(context, contextIds, logger);
+    await executeSwissquotePreprocessStep(context, contextIds, logger);
     const importConfig = loadImportConfig(context.directory);
     const orderedContextIds = [...contextIds].sort((a, b) => {
       const ctxA = loadContext(context.directory, a);
@@ -25361,16 +26203,16 @@ This tool orchestrates the full import workflow:
   }
 });
 // src/tools/init-directories.ts
-import * as fs18 from "fs";
-import * as path13 from "path";
+import * as fs20 from "fs";
+import * as path15 from "path";
 async function initDirectories(directory) {
   try {
     const config2 = loadImportConfig(directory);
     const directoriesCreated = [];
     const gitkeepFiles = [];
-    const importBase = path13.join(directory, "import");
-    if (!fs18.existsSync(importBase)) {
-      fs18.mkdirSync(importBase, { recursive: true });
+    const importBase = path15.join(directory, "import");
+    if (!fs20.existsSync(importBase)) {
+      fs20.mkdirSync(importBase, { recursive: true });
       directoriesCreated.push("import");
     }
     const pathsToCreate = [
@@ -25380,20 +26222,20 @@ async function initDirectories(directory) {
       { key: "unrecognized", path: config2.paths.unrecognized }
     ];
     for (const { path: dirPath } of pathsToCreate) {
-      const fullPath = path13.join(directory, dirPath);
-      if (!fs18.existsSync(fullPath)) {
-        fs18.mkdirSync(fullPath, { recursive: true });
+      const fullPath = path15.join(directory, dirPath);
+      if (!fs20.existsSync(fullPath)) {
+        fs20.mkdirSync(fullPath, { recursive: true });
         directoriesCreated.push(dirPath);
       }
-      const gitkeepPath = path13.join(fullPath, ".gitkeep");
-      if (!fs18.existsSync(gitkeepPath)) {
-        fs18.writeFileSync(gitkeepPath, "");
-        gitkeepFiles.push(path13.join(dirPath, ".gitkeep"));
+      const gitkeepPath = path15.join(fullPath, ".gitkeep");
+      if (!fs20.existsSync(gitkeepPath)) {
+        fs20.writeFileSync(gitkeepPath, "");
+        gitkeepFiles.push(path15.join(dirPath, ".gitkeep"));
       }
     }
-    const gitignorePath = path13.join(importBase, ".gitignore");
+    const gitignorePath = path15.join(importBase, ".gitignore");
     let gitignoreCreated = false;
-    if (!fs18.existsSync(gitignorePath)) {
+    if (!fs20.existsSync(gitignorePath)) {
       const gitignoreContent = `# Ignore CSV/PDF files in temporary directories
 /incoming/*.csv
 /incoming/*.pdf
@@ -25411,7 +26253,7 @@ async function initDirectories(directory) {
 .DS_Store
 Thumbs.db
 `;
-      fs18.writeFileSync(gitignorePath, gitignoreContent);
+      fs20.writeFileSync(gitignorePath, gitignoreContent);
       gitignoreCreated = true;
     }
     const parts = [];
@@ -25487,32 +26329,32 @@ You can now drop CSV files into import/incoming/ and run import-pipeline.`);
   }
 });
 // src/tools/generate-btc-purchases.ts
-import * as path14 from "path";
-import * as fs19 from "fs";
+import * as path16 from "path";
+import * as fs21 from "fs";
 function findFiatCsvPaths(directory, pendingDir, provider) {
-  const providerDir = path14.join(directory, pendingDir, provider);
-  if (!fs19.existsSync(providerDir))
+  const providerDir = path16.join(directory, pendingDir, provider);
+  if (!fs21.existsSync(providerDir))
     return [];
   const csvPaths = [];
-  const entries = fs19.readdirSync(providerDir, { withFileTypes: true });
+  const entries = fs21.readdirSync(providerDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
     if (entry.name === "btc")
       continue;
-    const csvFiles = findCsvFiles(path14.join(providerDir, entry.name), { fullPaths: true });
+    const csvFiles = findCsvFiles(path16.join(providerDir, entry.name), { fullPaths: true });
     csvPaths.push(...csvFiles);
   }
   return csvPaths;
 }
 function findBtcCsvPath(directory, pendingDir, provider) {
-  const btcDir = path14.join(directory, pendingDir, provider, "btc");
+  const btcDir = path16.join(directory, pendingDir, provider, "btc");
   const csvFiles = findCsvFiles(btcDir, { fullPaths: true });
   return csvFiles[0];
 }
 function determineYear(csvPaths) {
   for (const csvPath of csvPaths) {
-    const match2 = path14.basename(csvPath).match(/(\d{4})-\d{2}-\d{2}/);
+    const match2 = path16.basename(csvPath).match(/(\d{4})-\d{2}-\d{2}/);
     if (match2)
       return parseInt(match2[1], 10);
   }
@@ -25565,7 +26407,7 @@ async function generateBtcPurchases(directory, agent, options = {}, configLoader
       skippedDuplicates: result.skippedDuplicates,
       unmatchedFiat: result.unmatchedFiat.length,
       unmatchedBtc: result.unmatchedBtc.length,
-      yearJournal: path14.relative(directory, yearJournalPath)
+      yearJournal: path16.relative(directory, yearJournalPath)
     });
   } catch (err) {
     logger.error("Failed to generate BTC purchases", err);
@@ -25607,8 +26449,8 @@ to produce equity conversion entries for Bitcoin purchases.
   }
 });
 // src/index.ts
-var __dirname2 = dirname4(fileURLToPath3(import.meta.url));
-var AGENT_FILE = join13(__dirname2, "..", "agent", "accountant.md");
+var __dirname2 = dirname6(fileURLToPath3(import.meta.url));
+var AGENT_FILE = join15(__dirname2, "..", "agent", "accountant.md");
 var AccountantPlugin = async () => {
   const agent = loadAgent(AGENT_FILE);
   return {

package/docs/tools/import-pipeline.md

@@ -9,14 +9,15 @@ This tool is **restricted to the accountant agent only**.
 The pipeline automates these sequential steps:
 
 1. **Classify** - Detect provider/currency, create contexts, organize files
-1a. **Preprocess Fiat CSV** _(Revolut only)_ - Add computed `Net_Amount` column (`Amount - Fee`) for hledger rules
-1b. **Preprocess BTC CSV** _(Revolut only)_ - Add computed columns (fees in BTC, total, clean price) for hledger rules
-1c. **Generate BTC Purchases** _(Revolut only)_ - Cross-reference fiat + BTC CSVs for equity conversion entries
+   1a. **Preprocess Fiat CSV** _(Revolut only)_ - Add computed `Net_Amount` column (`Amount - Fee`) for hledger rules
+   1b. **Preprocess BTC CSV** _(Revolut only)_ - Add computed columns (fees in BTC, total, clean price) for hledger rules
+   1c. **Generate BTC Purchases** _(Revolut only)_ - Cross-reference fiat + BTC CSVs for equity conversion entries
+   1d. **Preprocess Swissquote CSV** _(Swissquote only)_ - Generate FIFO capital gains entries for trades, dividends, and corporate actions
 2. **Account Declarations** - Ensure all accounts exist in year journals
 3. **Import** - Validate transactions, add to journals, move files to done
 4. **Reconcile** - Verify balances match expectations
 
-Steps 1a–1c are Revolut-specific and are automatically skipped when no matching Revolut CSVs are present.
+Steps 1a–1c are Revolut-specific and steps 1d is Swissquote-specific. These preprocessing steps are automatically skipped when no matching CSVs are present.
 
 **Key behavior**: The pipeline processes files via **import contexts**. Each classified CSV gets a unique context ID, and subsequent steps operate on these contexts **sequentially** with **fail-fast** error handling.
 
@@ -200,6 +201,27 @@ See [classify-statements](classify-statements.md) for details.
 
 **Skipped when**: No fiat+BTC CSV pair is found among the classified files.
 
+### Step 1d: Preprocess Swissquote CSV
+
+**Purpose**: Generate FIFO capital gains journal entries for Swissquote investment transactions including trades, dividends, and corporate actions
+
+**What happens**:
+
+1. Finds Swissquote contexts from classification
+2. Parses CSV to identify transaction types (Buy, Sell, Dividend, Merger, Reverse Split, Worthless Liquidation, etc.)
+3. For Buy transactions: adds lots to per-symbol inventory files (`ledger/investments/lot-inventory/{symbol}-lot.json`)
+4. For Sell transactions: consumes lots using FIFO, calculates capital gains/losses
+5. For Dividends: generates dividend income entries with withholding tax
+6. For Corporate Actions: adjusts lot quantities (splits), transfers lots (mergers), or removes lots (worthless liquidations)
+7. Generates investment journal entries (`ledger/investments/{year}-investments.journal`)
+8. Outputs filtered CSV (simple transactions only) for hledger rules import
+
+**Why**: hledger CSV rules can't perform FIFO lot matching, capital gains calculations, or handle complex corporate actions. The preprocessor handles these computations and generates proper journal entries, while passing through simple transactions (fees, forex, interest) for standard rules-based import.
+
+**Lot Inventory**: Each symbol's lots are stored in a separate JSON file for version control and easy inspection. The path is configurable via `lotInventoryPath` in `providers.yaml`.
+
+**Skipped when**: No Swissquote CSV is present among the classified files.
+
 ### Step 2: Account Declarations
 
 **Purpose**: Ensure all accounts referenced in rules files are declared in year journals
@@ -229,7 +251,7 @@ See [classify-statements](classify-statements.md) for details.
 3. If unknown accounts found, generates account suggestions and **stops pipeline**
 4. Imports transactions using `hledger import`
 5. Moves CSV from `pending/` to `done/`
-4. Updates context with:
+6. Updates context with:
    - `rulesFile` path
    - `yearJournal` path
    - `transactionCount`
@@ -309,6 +331,14 @@ See [reconcile-statement](reconcile-statement.md) for details.
 │  STEP 1c: Generate BTC Purchase Entries                      │
 │  • Cross-reference fiat + BTC CSVs                           │
 │  • Generate equity conversion journal entries                │
+└──────────────────────────────────────────────────────────────┘
+                            │
+                            ▼
+┌──────────────────────────────────────────────────────────────┐
+│  STEP 1d: Preprocess Swissquote CSV (if swissquote context)  │
+│  • FIFO lot tracking for trades                              │
+│  • Capital gains calculation                                 │
+│  • Investment journal generation                             │
 └──────────────────────────────────────────────────────────────┘
                             │
                             ▼

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fuzzle/opencode-accountant",
-  "version": "0.9.1",
+  "version": "0.10.0-next.1",
   "description": "An OpenCode accounting agent, specialized in double-entry-bookkepping with hledger",
   "author": {
     "name": "ali bengali",