@fuzzle/opencode-accountant 0.13.17 → 0.13.18-next.1

package/dist/index.js

@@ -4280,7 +4280,7 @@ __export(exports_accountSuggester, {
   extractRulePatternsFromFile: () => extractRulePatternsFromFile,
   clearSuggestionCache: () => clearSuggestionCache
 });
-import * as fs21 from "fs";
+import * as fs22 from "fs";
 import * as crypto from "crypto";
 function clearSuggestionCache() {
   Object.keys(suggestionCache).forEach((key) => delete suggestionCache[key]);
@@ -4290,10 +4290,10 @@ function hashTransaction(posting) {
   return crypto.createHash("md5").update(data).digest("hex");
 }
 function loadExistingAccounts(yearJournalPath) {
-  if (!fs21.existsSync(yearJournalPath)) {
+  if (!fs22.existsSync(yearJournalPath)) {
     return [];
   }
-  const content = fs21.readFileSync(yearJournalPath, "utf-8");
+  const content = fs22.readFileSync(yearJournalPath, "utf-8");
   const lines = content.split(`
 `);
   const accounts = [];
@@ -4309,10 +4309,10 @@ function loadExistingAccounts(yearJournalPath) {
   return accounts.sort();
 }
 function extractRulePatternsFromFile(rulesPath) {
-  if (!fs21.existsSync(rulesPath)) {
+  if (!fs22.existsSync(rulesPath)) {
     return [];
   }
-  const content = fs21.readFileSync(rulesPath, "utf-8");
+  const content = fs22.readFileSync(rulesPath, "utf-8");
   const lines = content.split(`
 `);
   const patterns = [];
@@ -4547,7 +4547,7 @@ var init_accountSuggester = __esm(() => {
 
 // src/index.ts
 init_agentLoader();
-import { dirname as dirname9, join as join16 } from "path";
+import { dirname as dirname9, join as join17 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // node_modules/zod/v4/classic/external.js
@@ -24208,8 +24208,8 @@ Note: This tool requires a contextId from a prior classify/import step.`,
   }
 });
 // src/tools/import-pipeline.ts
-import * as fs22 from "fs";
-import * as path16 from "path";
+import * as fs23 from "fs";
+import * as path17 from "path";
 
 // src/utils/accountDeclarations.ts
 init_journalMatchers();
@@ -24954,8 +24954,8 @@ Got:
 }
 
 // src/utils/swissquoteCsvPreprocessor.ts
-import * as fs18 from "fs";
-import * as path13 from "path";
+import * as fs19 from "fs";
+import * as path14 from "path";
 
 // src/utils/symbolNormalizer.ts
 function normalizeSymbol(symbol2) {
@@ -25462,6 +25462,18 @@ function generateMultiWayMergerEntry(group, crossCurrencyOutgoingSymbols, crossC
       entries.push(sub);
     }
   }
+  if (group.cashSettlement) {
+    const cashCurrency = group.cashSettlement.currency.toLowerCase();
+    const cashAmount = formatAmount2(group.cashSettlement.amount, group.cashSettlement.currency);
+    let sub = `${date5} ${description}
+`;
+    sub += metadata;
+    sub += `    assets:broker:swissquote:${cashCurrency}     ${cashAmount}
+`;
+    sub += `    income:capital-gains:realized
+`;
+    entries.push(sub);
+  }
   return entries.join(`
 `);
 }
@@ -25532,6 +25544,52 @@ function formatJournalFile(entries, year, currency) {
 `);
 }
 
+// src/utils/mergerFmvConfig.ts
+init_js_yaml();
+import * as fs18 from "fs";
+import * as path13 from "path";
+var CONFIG_FILE3 = "config/import/merger-fmv.yaml";
+function loadMergerFmvConfig(projectDir) {
+  const configPath = path13.join(projectDir, CONFIG_FILE3);
+  if (!fs18.existsSync(configPath)) {
+    return null;
+  }
+  const content = fs18.readFileSync(configPath, "utf-8");
+  const parsed = jsYaml.load(content);
+  if (typeof parsed !== "object" || parsed === null) {
+    return null;
+  }
+  const config2 = {};
+  for (const [rawKey, symbols] of Object.entries(parsed)) {
+    let dateKey;
+    const d = new Date(rawKey);
+    if (!isNaN(d.getTime()) && !/^\d{4}-\d{2}-\d{2}$/.test(rawKey)) {
+      dateKey = d.toISOString().split("T")[0];
+    } else {
+      dateKey = rawKey;
+    }
+    if (typeof symbols !== "object" || symbols === null) {
+      continue;
+    }
+    const symbolMap = {};
+    for (const [symbol2, price] of Object.entries(symbols)) {
+      if (typeof price === "number") {
+        symbolMap[symbol2] = price;
+      }
+    }
+    if (Object.keys(symbolMap).length > 0) {
+      config2[dateKey] = symbolMap;
+    }
+  }
+  return Object.keys(config2).length > 0 ? config2 : null;
+}
+function lookupFmvForDate(config2, date5) {
+  if (!config2) {
+    return null;
+  }
+  return config2[date5] ?? null;
+}
+
 // 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([
@@ -25742,7 +25800,26 @@ function groupMergerActions(actions) {
   }
   return Array.from(groupMap.values());
 }
-function processMultiWayMerger(group, inventory, lotInventoryPath, projectDir, logger) {
+function computeAllocationProportions(incoming, fmvData, date5, logger) {
+  if (incoming.length <= 1) {
+    return incoming.map(() => 1);
+  }
+  const quantities = incoming.map((a) => Math.abs(a.quantity));
+  const symbols = incoming.map((a) => a.symbol);
+  if (fmvData) {
+    const allCovered = symbols.every((s) => (s in fmvData));
+    if (allCovered) {
+      const fmvValues = symbols.map((s, i2) => fmvData[s] * quantities[i2]);
+      const totalFmv = fmvValues.reduce((sum, v) => sum + v, 0);
+      if (totalFmv > 0) {
+        logger?.info(`Using FMV-based cost allocation for merger (total FMV: ${totalFmv.toFixed(2)})`);
+        return fmvValues.map((v) => v / totalFmv);
+      }
+    }
+  }
+  throw new Error(`Merger on ${date5} has ${incoming.length} incoming symbols (${symbols.join(", ")}) but no FMV data. ` + `Add prices to config/import/merger-fmv.yaml for this date.`);
+}
+function processMultiWayMerger(group, inventory, lotInventoryPath, projectDir, mergerFmv, logger) {
   const entries = [];
   if (group.outgoing.length === 0 && group.incoming.length === 0) {
     return entries;
@@ -25761,12 +25838,14 @@ function processMultiWayMerger(group, inventory, lotInventoryPath, projectDir, l
           quantity: -(pendingState.outgoingQuantities[i2] || 0)
         });
       }
-      const totalIncomingQty2 = group.incoming.reduce((sum, a) => sum + Math.abs(a.quantity), 0);
+      const mergerDate = formatDate(group.date);
+      const fmvData2 = lookupFmvForDate(mergerFmv, mergerDate);
+      const proportions2 = computeAllocationProportions(group.incoming, fmvData2, mergerDate, logger);
       const incomingTotalCosts2 = [];
-      for (const inc of group.incoming) {
+      for (let idx = 0;idx < group.incoming.length; idx++) {
+        const inc = group.incoming[idx];
         const absQty = Math.abs(inc.quantity);
-        const proportion = absQty / totalIncomingQty2;
-        const allocatedCost = pendingState.totalCostBasis * proportion;
+        const allocatedCost = pendingState.totalCostBasis * proportions2[idx];
         const costBasisPerUnit = absQty > 0 ? allocatedCost / absQty : 0;
         incomingTotalCosts2.push(allocatedCost);
         const lot = {
@@ -25838,12 +25917,14 @@ function processMultiWayMerger(group, inventory, lotInventoryPath, projectDir, l
     removeLots(inventory, out.symbol, logger);
     logger?.debug(`Merger outgoing: removed ${absQty} ${out.symbol}`);
   }
-  const totalIncomingQty = group.incoming.reduce((sum, a) => sum + Math.abs(a.quantity), 0);
+  const mergerDateFull = formatDate(group.date);
+  const fmvData = lookupFmvForDate(mergerFmv, mergerDateFull);
+  const proportions = computeAllocationProportions(group.incoming, fmvData, mergerDateFull, logger);
   const incomingTotalCosts = [];
-  for (const inc of group.incoming) {
+  for (let idx = 0;idx < group.incoming.length; idx++) {
+    const inc = group.incoming[idx];
     const absQty = Math.abs(inc.quantity);
-    const proportion = totalIncomingQty > 0 ? absQty / totalIncomingQty : 0;
-    const allocatedCost = totalCostBasis * proportion;
+    const allocatedCost = totalCostBasis * proportions[idx];
     const costBasisPerUnit = absQty > 0 ? allocatedCost / absQty : 0;
     incomingTotalCosts.push(allocatedCost);
     const lot = {
@@ -25871,25 +25952,25 @@ function processMultiWayMerger(group, inventory, lotInventoryPath, projectDir, l
 }
 function getPendingMergerDir(projectDir, lotInventoryPath) {
   const lotDir = lotInventoryPath.replace(/{symbol}[^/]*$/, "");
-  return path13.join(projectDir, lotDir, "pending-mergers");
+  return path14.join(projectDir, lotDir, "pending-mergers");
 }
 function savePendingMerger(projectDir, lotInventoryPath, key, state, logger) {
   const dir = getPendingMergerDir(projectDir, lotInventoryPath);
-  if (!fs18.existsSync(dir)) {
-    fs18.mkdirSync(dir, { recursive: true });
+  if (!fs19.existsSync(dir)) {
+    fs19.mkdirSync(dir, { recursive: true });
   }
-  const filePath = path13.join(dir, `${key.replace(/[^a-zA-Z0-9-]/g, "_")}.json`);
-  fs18.writeFileSync(filePath, JSON.stringify(state, null, 2));
+  const filePath = path14.join(dir, `${key.replace(/[^a-zA-Z0-9-]/g, "_")}.json`);
+  fs19.writeFileSync(filePath, JSON.stringify(state, null, 2));
   logger?.debug(`Saved pending merger state: ${key}`);
 }
 function loadPendingMerger(projectDir, lotInventoryPath, key, logger) {
   const dir = getPendingMergerDir(projectDir, lotInventoryPath);
-  const filePath = path13.join(dir, `${key.replace(/[^a-zA-Z0-9-]/g, "_")}.json`);
-  if (!fs18.existsSync(filePath)) {
+  const filePath = path14.join(dir, `${key.replace(/[^a-zA-Z0-9-]/g, "_")}.json`);
+  if (!fs19.existsSync(filePath)) {
     return null;
   }
   try {
-    const content = fs18.readFileSync(filePath, "utf-8");
+    const content = fs19.readFileSync(filePath, "utf-8");
     return JSON.parse(content);
   } catch (error45) {
     const message = error45 instanceof Error ? error45.message : String(error45);
@@ -25899,27 +25980,27 @@ function loadPendingMerger(projectDir, lotInventoryPath, key, logger) {
 }
 function removePendingMerger(projectDir, lotInventoryPath, key, logger) {
   const dir = getPendingMergerDir(projectDir, lotInventoryPath);
-  const filePath = path13.join(dir, `${key.replace(/[^a-zA-Z0-9-]/g, "_")}.json`);
-  if (fs18.existsSync(filePath)) {
-    fs18.unlinkSync(filePath);
+  const filePath = path14.join(dir, `${key.replace(/[^a-zA-Z0-9-]/g, "_")}.json`);
+  if (fs19.existsSync(filePath)) {
+    fs19.unlinkSync(filePath);
     logger?.debug(`Removed pending merger state: ${key}`);
   }
 }
 function resolveRemainingPendingMergers(projectDir, lotInventoryPath, logger) {
   const pendingDir = getPendingMergerDir(projectDir, lotInventoryPath);
-  if (!fs18.existsSync(pendingDir)) {
+  if (!fs19.existsSync(pendingDir)) {
     return { resolved: 0, journalFilesUpdated: [] };
   }
-  const files = fs18.readdirSync(pendingDir).filter((f) => f.endsWith(".json"));
+  const files = fs19.readdirSync(pendingDir).filter((f) => f.endsWith(".json"));
   if (files.length === 0) {
     return { resolved: 0, journalFilesUpdated: [] };
   }
   const entriesByJournal = new Map;
   const resolvedFiles = [];
   for (const file2 of files) {
-    const filePath = path13.join(pendingDir, file2);
+    const filePath = path14.join(pendingDir, file2);
     try {
-      const content = fs18.readFileSync(filePath, "utf-8");
+      const content = fs19.readFileSync(filePath, "utf-8");
       const state = JSON.parse(content);
       const dateMatch = state.date.match(/\d{2}-\d{2}-(\d{4})/);
       if (!dateMatch) {
@@ -25928,12 +26009,12 @@ function resolveRemainingPendingMergers(projectDir, lotInventoryPath, logger) {
       }
       const year = parseInt(dateMatch[1], 10);
       const entry = generateDirectWorthlessEntry(state.date, state.orderNum, state.outgoingSymbols, state.outgoingIsins, state.outgoingQuantities || [], state.outgoingTotalCosts || [], state.totalCostBasis, state.currency, logger);
-      const journalFile = path13.join(projectDir, "ledger", "investments", `${year}-${state.currency.toLowerCase()}.journal`);
+      const journalFile = path14.join(projectDir, "ledger", "investments", `${year}-${state.currency.toLowerCase()}.journal`);
       if (!entriesByJournal.has(journalFile)) {
         entriesByJournal.set(journalFile, []);
       }
       entriesByJournal.get(journalFile).push(entry);
-      fs18.unlinkSync(filePath);
+      fs19.unlinkSync(filePath);
       resolvedFiles.push(file2);
       logger?.info(`Resolved pending merger ${file2} as worthless: ${state.outgoingSymbols.join(", ")} (${state.totalCostBasis.toFixed(2)} ${state.currency})`);
     } catch (error45) {
@@ -25943,32 +26024,33 @@ function resolveRemainingPendingMergers(projectDir, lotInventoryPath, logger) {
   }
   const journalFilesUpdated = [];
   for (const [journalFile, journalEntries] of entriesByJournal) {
-    if (fs18.existsSync(journalFile)) {
-      fs18.appendFileSync(journalFile, `
+    if (fs19.existsSync(journalFile)) {
+      fs19.appendFileSync(journalFile, `
 ` + journalEntries.join(`
 `));
     } else {
-      const basename5 = path13.basename(journalFile, ".journal");
+      const basename5 = path14.basename(journalFile, ".journal");
       const parts = basename5.split("-");
       const yearStr = parts[0];
       const currency = parts.slice(1).join("-");
       const header = formatJournalFile(journalEntries, parseInt(yearStr, 10), currency);
-      fs18.writeFileSync(journalFile, header);
+      fs19.writeFileSync(journalFile, header);
     }
     journalFilesUpdated.push(journalFile);
-    logger?.info(`Updated ${path13.basename(journalFile)} with worthless resolution entries`);
+    logger?.info(`Updated ${path14.basename(journalFile)} with worthless resolution entries`);
   }
-  const remaining = fs18.readdirSync(pendingDir).filter((f) => f.endsWith(".json"));
+  const remaining = fs19.readdirSync(pendingDir).filter((f) => f.endsWith(".json"));
   if (remaining.length === 0) {
     try {
-      fs18.rmdirSync(pendingDir);
+      fs19.rmdirSync(pendingDir);
       logger?.debug("Removed empty pending-mergers directory");
     } catch {}
   }
   return { resolved: resolvedFiles.length, journalFilesUpdated };
 }
 async function preprocessSwissquote(csvPath, projectDir, currency, year, lotInventoryPath = DEFAULT_LOT_INVENTORY_PATH, symbolMap = {}, logger) {
-  logger?.startSection(`Swissquote Preprocessing: ${path13.basename(csvPath)}`);
+  logger?.startSection(`Swissquote Preprocessing: ${path14.basename(csvPath)}`);
+  const mergerFmv = loadMergerFmvConfig(projectDir);
   const stats = {
     totalRows: 0,
     simpleTransactions: 0,
@@ -25978,7 +26060,7 @@ async function preprocessSwissquote(csvPath, projectDir, currency, year, lotInve
     forexTransactions: 0,
     skipped: 0
   };
-  if (!fs18.existsSync(csvPath)) {
+  if (!fs19.existsSync(csvPath)) {
     logger?.error(`CSV file not found: ${csvPath}`);
     logger?.endSection();
     return {
@@ -25990,7 +26072,7 @@ async function preprocessSwissquote(csvPath, projectDir, currency, year, lotInve
     };
   }
   logger?.logStep("parse-csv", "start", `Reading ${csvPath}`);
-  const content = fs18.readFileSync(csvPath, "utf-8");
+  const content = fs19.readFileSync(csvPath, "utf-8");
   const lines = content.split(`
 `).filter((line) => line.trim());
   const header = lines[0];
@@ -26034,6 +26116,7 @@ async function preprocessSwissquote(csvPath, projectDir, currency, year, lotInve
   const dividends = [];
   const corporateActions = [];
   const forexTransactions = [];
+  const mergerCashSettlements = [];
   for (const txn of transactions) {
     const category = categorizeTransaction(txn);
     switch (category) {
@@ -26052,8 +26135,12 @@ async function preprocessSwissquote(csvPath, projectDir, currency, year, lotInve
       case "corporate":
         if (!txn.symbol || txn.symbol.trim() === "") {
           if (txn.netAmount && txn.netAmount !== "-") {
-            simpleTransactions.push(txn);
-            stats.simpleTransactions++;
+            mergerCashSettlements.push({
+              dateOrderKey: `${txn.date}-${txn.orderNum}`,
+              amount: parseNumber(txn.netAmount),
+              currency: txn.currency
+            });
+            stats.corporateActions++;
           } else {
             stats.skipped++;
           }
@@ -26097,6 +26184,31 @@ async function preprocessSwissquote(csvPath, projectDir, currency, year, lotInve
     }
   }
   const mergerGroups = groupMergerActions(mergerActions);
+  for (const cash of mergerCashSettlements) {
+    const matchingGroup = mergerGroups.find((g) => g.key === cash.dateOrderKey);
+    if (matchingGroup) {
+      matchingGroup.cashSettlement = { amount: cash.amount, currency: cash.currency };
+    } else {
+      simpleTransactions.push({
+        date: cash.dateOrderKey.split("-").slice(0, 3).join("-"),
+        orderNum: cash.dateOrderKey.split("-").slice(3).join("-"),
+        transaction: "Merger",
+        symbol: "",
+        name: "",
+        isin: "",
+        quantity: "",
+        unitPrice: "",
+        costs: "",
+        accruedInterest: "",
+        netAmount: String(cash.amount),
+        balance: "",
+        currency: cash.currency
+      });
+      stats.simpleTransactions++;
+      stats.corporateActions--;
+      logger?.warn(`Cash settlement ${cash.dateOrderKey} has no matching merger group \u2014 routed to simple CSV`);
+    }
+  }
   for (const group of mergerGroups) {
     timeline.push({ kind: "mergerGroup", sortDate: formatDate(group.date), group });
   }
@@ -26148,7 +26260,7 @@ async function preprocessSwissquote(csvPath, projectDir, currency, year, lotInve
           break;
         }
         case "mergerGroup": {
-          const groupEntries = processMultiWayMerger(event.group, inventory, lotInventoryPath, projectDir, logger);
+          const groupEntries = processMultiWayMerger(event.group, inventory, lotInventoryPath, projectDir, mergerFmv, logger);
           journalEntries.push(...groupEntries);
           break;
         }
@@ -26165,9 +26277,9 @@ async function preprocessSwissquote(csvPath, projectDir, currency, year, lotInve
   logger?.logStep("save-inventory", "success", "Lot inventory saved");
   let simpleTransactionsCsv = null;
   let journalFile = null;
-  const csvDir = path13.dirname(csvPath);
-  const csvBasename = path13.basename(csvPath, ".csv");
-  simpleTransactionsCsv = path13.join(csvDir, `${csvBasename}-simple.csv`);
+  const csvDir = path14.dirname(csvPath);
+  const csvBasename = path14.basename(csvPath, ".csv");
+  simpleTransactionsCsv = path14.join(csvDir, `${csvBasename}-simple.csv`);
   const csvContent = [
     SWISSQUOTE_HEADER,
     ...simpleTransactions.map((txn) => [
@@ -26187,23 +26299,23 @@ async function preprocessSwissquote(csvPath, projectDir, currency, year, lotInve
     ].join(";"))
   ].join(`
 `);
-  fs18.writeFileSync(simpleTransactionsCsv, csvContent);
-  logger?.logStep("write-csv", "success", `Wrote ${simpleTransactions.length} simple transactions to ${path13.basename(simpleTransactionsCsv)}`);
+  fs19.writeFileSync(simpleTransactionsCsv, csvContent);
+  logger?.logStep("write-csv", "success", `Wrote ${simpleTransactions.length} simple transactions to ${path14.basename(simpleTransactionsCsv)}`);
   if (journalEntries.length > 0) {
-    const investmentsDir = path13.join(projectDir, "ledger", "investments");
-    if (!fs18.existsSync(investmentsDir)) {
-      fs18.mkdirSync(investmentsDir, { recursive: true });
+    const investmentsDir = path14.join(projectDir, "ledger", "investments");
+    if (!fs19.existsSync(investmentsDir)) {
+      fs19.mkdirSync(investmentsDir, { recursive: true });
     }
-    journalFile = path13.join(investmentsDir, `${year}-${currency}.journal`);
+    journalFile = path14.join(investmentsDir, `${year}-${currency}.journal`);
     const journalContent = formatJournalFile(journalEntries, year, currency);
-    if (fs18.existsSync(journalFile)) {
-      fs18.appendFileSync(journalFile, `
+    if (fs19.existsSync(journalFile)) {
+      fs19.appendFileSync(journalFile, `
 ` + journalEntries.join(`
 `));
-      logger?.logStep("write-journal", "success", `Appended ${journalEntries.length} entries to ${path13.basename(journalFile)}`);
+      logger?.logStep("write-journal", "success", `Appended ${journalEntries.length} entries to ${path14.basename(journalFile)}`);
     } else {
-      fs18.writeFileSync(journalFile, journalContent);
-      logger?.logStep("write-journal", "success", `Created ${path13.basename(journalFile)} with ${journalEntries.length} entries`);
+      fs19.writeFileSync(journalFile, journalContent);
+      logger?.logStep("write-journal", "success", `Created ${path14.basename(journalFile)} with ${journalEntries.length} entries`);
     }
   }
   const stockSymbols = new Set;
@@ -26220,9 +26332,9 @@ async function preprocessSwissquote(csvPath, projectDir, currency, year, lotInve
     }
   }
   if (stockSymbols.size > 0) {
-    const commodityJournalPath = path13.join(projectDir, "ledger", "investments", "commodities.journal");
+    const commodityJournalPath = path14.join(projectDir, "ledger", "investments", "commodities.journal");
     ensureCommodityDeclarations(commodityJournalPath, stockSymbols, logger);
-    const accountJournalPath = path13.join(projectDir, "ledger", "investments", "accounts.journal");
+    const accountJournalPath = path14.join(projectDir, "ledger", "investments", "accounts.journal");
     const investmentAccounts = new Set;
     for (const symbol2 of stockSymbols) {
       investmentAccounts.add(`assets:investments:stocks:${symbol2}`);
@@ -26259,10 +26371,10 @@ async function preprocessSwissquote(csvPath, projectDir, currency, year, lotInve
 }
 
 // src/utils/currencyExchangeGenerator.ts
-import * as fs19 from "fs";
-import * as path14 from "path";
+import * as fs20 from "fs";
+import * as path15 from "path";
 function parseExchangeRows(csvPath) {
-  const content = fs19.readFileSync(csvPath, "utf-8");
+  const content = fs20.readFileSync(csvPath, "utf-8");
   const lines = content.trim().split(`
 `);
   if (lines.length < 2)
@@ -26386,7 +26498,7 @@ function formatDateIso2(date5) {
   return `${y}-${m}-${d}`;
 }
 function filterExchangeRows(csvPath, rowIndicesToRemove, logger) {
-  const content = fs19.readFileSync(csvPath, "utf-8");
+  const content = fs20.readFileSync(csvPath, "utf-8");
   const lines = content.trim().split(`
 `);
   const filteredLines = [lines[0]];
@@ -26395,13 +26507,13 @@ function filterExchangeRows(csvPath, rowIndicesToRemove, logger) {
       continue;
     filteredLines.push(lines[i2]);
   }
-  const dir = path14.dirname(csvPath);
-  const basename6 = path14.basename(csvPath, ".csv");
-  const filteredPath = path14.join(dir, `${basename6}-filtered.csv`);
-  fs19.writeFileSync(filteredPath, filteredLines.join(`
+  const dir = path15.dirname(csvPath);
+  const basename6 = path15.basename(csvPath, ".csv");
+  const filteredPath = path15.join(dir, `${basename6}-filtered.csv`);
+  fs20.writeFileSync(filteredPath, filteredLines.join(`
 `) + `
 `);
-  logger?.info(`Filtered ${rowIndicesToRemove.size} exchange rows from ${path14.basename(csvPath)} \u2192 ${path14.basename(filteredPath)}`);
+  logger?.info(`Filtered ${rowIndicesToRemove.size} exchange rows from ${path15.basename(csvPath)} \u2192 ${path15.basename(filteredPath)}`);
   return filteredPath;
 }
 function generateCurrencyExchangeJournal(fiatCsvPaths, yearJournalPath, logger) {
@@ -26411,7 +26523,7 @@ function generateCurrencyExchangeJournal(fiatCsvPaths, yearJournalPath, logger)
     const rows = parseExchangeRows(csvPath);
     if (rows.length > 0) {
       rowsByCsv.set(csvPath, rows);
-      logger?.info(`Found ${rows.length} EXCHANGE rows in ${path14.basename(csvPath)}`);
+      logger?.info(`Found ${rows.length} EXCHANGE rows in ${path15.basename(csvPath)}`);
     }
   }
   if (rowsByCsv.size < 2) {
@@ -26428,8 +26540,8 @@ function generateCurrencyExchangeJournal(fiatCsvPaths, yearJournalPath, logger)
   const matches = matchExchangePairs(rowsByCsv);
   logger?.info(`Matched ${matches.length} exchange pairs`);
   let journalContent = "";
-  if (fs19.existsSync(yearJournalPath)) {
-    journalContent = fs19.readFileSync(yearJournalPath, "utf-8");
+  if (fs20.existsSync(yearJournalPath)) {
+    journalContent = fs20.readFileSync(yearJournalPath, "utf-8");
   }
   const newEntries = [];
   let skippedDuplicates = 0;
@@ -26456,8 +26568,8 @@ function generateCurrencyExchangeJournal(fiatCsvPaths, yearJournalPath, logger)
 
 `) + `
 `;
-    fs19.appendFileSync(yearJournalPath, appendContent);
-    logger?.info(`Appended ${newEntries.length} currency exchange entries to ${path14.basename(yearJournalPath)}`);
+    fs20.appendFileSync(yearJournalPath, appendContent);
+    logger?.info(`Appended ${newEntries.length} currency exchange entries to ${path15.basename(yearJournalPath)}`);
   } else {
     logger?.info("No new currency exchange entries to add");
   }
@@ -26480,8 +26592,8 @@ function generateCurrencyExchangeJournal(fiatCsvPaths, yearJournalPath, logger)
 }
 
 // src/utils/swissquoteForexGenerator.ts
-import * as fs20 from "fs";
-import * as path15 from "path";
+import * as fs21 from "fs";
+import * as path16 from "path";
 function formatDate2(dateStr) {
   const match2 = dateStr.match(/^(\d{2})-(\d{2})-(\d{4})/);
   if (!match2) {
@@ -26588,8 +26700,8 @@ function generateSwissquoteForexJournal(allForexRows, yearJournalPath, logger) {
     logger?.warn(`${unmatchedCount} forex rows could not be matched`);
   }
   let journalContent = "";
-  if (fs20.existsSync(yearJournalPath)) {
-    journalContent = fs20.readFileSync(yearJournalPath, "utf-8");
+  if (fs21.existsSync(yearJournalPath)) {
+    journalContent = fs21.readFileSync(yearJournalPath, "utf-8");
   }
   const newEntries = [];
   let skippedDuplicates = 0;
@@ -26611,17 +26723,17 @@ function generateSwissquoteForexJournal(allForexRows, yearJournalPath, logger) {
     newEntries.push(formatForexEntry(match2));
   }
   if (newEntries.length > 0) {
-    const dir = path15.dirname(yearJournalPath);
-    if (!fs20.existsSync(dir)) {
-      fs20.mkdirSync(dir, { recursive: true });
+    const dir = path16.dirname(yearJournalPath);
+    if (!fs21.existsSync(dir)) {
+      fs21.mkdirSync(dir, { recursive: true });
     }
     const appendContent = `
 ` + newEntries.join(`
 
 `) + `
 `;
-    fs20.appendFileSync(yearJournalPath, appendContent);
-    logger?.info(`Appended ${newEntries.length} forex entries to ${path15.basename(yearJournalPath)}`);
+    fs21.appendFileSync(yearJournalPath, appendContent);
+    logger?.info(`Appended ${newEntries.length} forex entries to ${path16.basename(yearJournalPath)}`);
   } else {
     logger?.info("No new forex entries to add");
   }
@@ -26706,7 +26818,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(path16.join(context.directory, importCtx.filePath));
+      fiatCsvPaths.push(path17.join(context.directory, importCtx.filePath));
     }
   }
   if (fiatCsvPaths.length === 0) {
@@ -26750,7 +26862,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 = path16.join(context.directory, importCtx.filePath);
+      btcCsvPath = path17.join(context.directory, importCtx.filePath);
       break;
     }
   }
@@ -26784,7 +26896,7 @@ async function executeBtcPurchaseStep(context, contextIds, logger) {
     const importCtx = loadContext(context.directory, contextId);
     if (importCtx.provider !== "revolut")
       continue;
-    const csvPath = path16.join(context.directory, importCtx.filePath);
+    const csvPath = path17.join(context.directory, importCtx.filePath);
     if (importCtx.currency === "btc") {
       btcCsvPath = csvPath;
     } else {
@@ -26797,7 +26909,7 @@ async function executeBtcPurchaseStep(context, contextIds, logger) {
   }
   logger?.startSection("Step 1b: Generate BTC Purchase Entries");
   logger?.logStep("BTC Purchases", "start");
-  const btcFilename = path16.basename(btcCsvPath);
+  const btcFilename = path17.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);
@@ -26824,7 +26936,7 @@ async function executeCurrencyExchangeStep(context, contextIds, logger) {
       continue;
     if (importCtx.currency === "btc")
       continue;
-    const csvPath = path16.join(context.directory, importCtx.filePath);
+    const csvPath = path17.join(context.directory, importCtx.filePath);
     fiatContexts.push({ contextId, csvPath });
   }
   if (fiatContexts.length < 2) {
@@ -26833,7 +26945,7 @@ async function executeCurrencyExchangeStep(context, contextIds, logger) {
   }
   logger?.startSection("Step 1e: Generate Currency Exchange Entries");
   logger?.logStep("Currency Exchanges", "start");
-  const firstFilename = path16.basename(fiatContexts[0].csvPath);
+  const firstFilename = path17.basename(fiatContexts[0].csvPath);
   const yearMatch = firstFilename.match(/(\d{4})-\d{2}-\d{2}/);
   const year = yearMatch ? parseInt(yearMatch[1], 10) : new Date().getFullYear();
   const yearJournalPath = ensureYearJournalExists(context.directory, year);
@@ -26849,9 +26961,9 @@ async function executeCurrencyExchangeStep(context, contextIds, logger) {
         continue;
       const filteredCsvPath = filterExchangeRows(csvPath, indices, logger);
       updateContext(context.directory, contextId, {
-        filePath: path16.relative(context.directory, filteredCsvPath)
+        filePath: path17.relative(context.directory, filteredCsvPath)
       });
-      logger?.info(`Updated context ${contextId} to use filtered CSV: ${path16.basename(filteredCsvPath)}`);
+      logger?.info(`Updated context ${contextId} to use filtered CSV: ${path17.basename(filteredCsvPath)}`);
     }
   }
   const message = result.entriesAdded > 0 ? `Generated ${result.entriesAdded} currency exchange entries (${result.matchCount} matched, ${result.skippedDuplicates} skipped)` : `No new currency exchange entries (${result.matchCount} matched, ${result.skippedDuplicates} duplicates)`;
@@ -26868,7 +26980,7 @@ async function executeSwissquotePreprocessStep(context, contextIds, logger) {
   for (const contextId of contextIds) {
     const importCtx = loadContext(context.directory, contextId);
     if (importCtx.provider === "swissquote") {
-      const csvPath = path16.join(context.directory, importCtx.filePath);
+      const csvPath = path17.join(context.directory, importCtx.filePath);
       const toDateMatch = importCtx.filename.match(/to-\d{4}(\d{4})\./);
       let year = new Date().getFullYear();
       if (toDateMatch) {
@@ -26892,11 +27004,11 @@ async function executeSwissquotePreprocessStep(context, contextIds, logger) {
   const lotInventoryPath = swissquoteProvider?.lotInventoryPath ?? DEFAULT_LOT_INVENTORY_PATH;
   const symbolMapPath = swissquoteProvider?.symbolMapPath ?? "config/import/symbolMap.yaml";
   let symbolMap = {};
-  const symbolMapFullPath = path16.join(context.directory, symbolMapPath);
-  if (fs22.existsSync(symbolMapFullPath)) {
+  const symbolMapFullPath = path17.join(context.directory, symbolMapPath);
+  if (fs23.existsSync(symbolMapFullPath)) {
     try {
       const yaml = await Promise.resolve().then(() => (init_js_yaml(), exports_js_yaml));
-      const content = fs22.readFileSync(symbolMapFullPath, "utf-8");
+      const content = fs23.readFileSync(symbolMapFullPath, "utf-8");
       const parsed = yaml.load(content);
       if (parsed && typeof parsed === "object") {
         symbolMap = parsed;
@@ -26920,7 +27032,7 @@ async function executeSwissquotePreprocessStep(context, contextIds, logger) {
     let lastJournalFile = null;
     const allForexRows = [];
     for (const sqCtx of swissquoteContexts) {
-      logger?.logStep("Swissquote Preprocess", "start", `Processing ${path16.basename(sqCtx.csvPath)}`);
+      logger?.logStep("Swissquote Preprocess", "start", `Processing ${path17.basename(sqCtx.csvPath)}`);
       const result = await preprocessSwissquote(sqCtx.csvPath, context.directory, sqCtx.currency, sqCtx.year, lotInventoryPath, symbolMap, logger);
       totalStats.totalRows += result.stats.totalRows;
       totalStats.simpleTransactions += result.stats.simpleTransactions;
@@ -26935,9 +27047,9 @@ async function executeSwissquotePreprocessStep(context, contextIds, logger) {
       }
       if (result.simpleTransactionsCsv) {
         updateContext(context.directory, sqCtx.contextId, {
-          filePath: path16.relative(context.directory, result.simpleTransactionsCsv)
+          filePath: path17.relative(context.directory, result.simpleTransactionsCsv)
         });
-        logger?.info(`Updated context ${sqCtx.contextId} to use filtered CSV: ${path16.basename(result.simpleTransactionsCsv)}`);
+        logger?.info(`Updated context ${sqCtx.contextId} to use filtered CSV: ${path17.basename(result.simpleTransactionsCsv)}`);
       }
       logger?.logStep("Swissquote Preprocess", "success", `Processed: ${result.stats.trades} trades, ${result.stats.dividends} dividends, ${result.stats.corporateActions} corporate actions, ${result.stats.forexTransactions} forex`);
     }
@@ -26947,11 +27059,11 @@ async function executeSwissquotePreprocessStep(context, contextIds, logger) {
     }
     if (allForexRows.length > 0) {
       const firstCtx = swissquoteContexts[0];
-      const yearJournalPath = path16.join(context.directory, "ledger", `${firstCtx.year}.journal`);
+      const yearJournalPath = path17.join(context.directory, "ledger", `${firstCtx.year}.journal`);
       logger?.info(`Generating forex journal entries for ${allForexRows.length} forex rows...`);
       const forexResult = generateSwissquoteForexJournal(allForexRows, yearJournalPath, logger);
       if (forexResult.accountsUsed.size > 0) {
-        const accountJournalPath = path16.join(context.directory, "ledger", "investments", "accounts.journal");
+        const accountJournalPath = path17.join(context.directory, "ledger", "investments", "accounts.journal");
         ensureInvestmentAccountDeclarations(accountJournalPath, forexResult.accountsUsed, logger);
       }
       logger?.logStep("Swissquote Forex", "success", `Matched ${forexResult.matchCount} forex pairs, added ${forexResult.entriesAdded} entries` + (forexResult.skippedDuplicates > 0 ? `, skipped ${forexResult.skippedDuplicates} duplicates` : "") + (forexResult.unmatchedRows > 0 ? `, ${forexResult.unmatchedRows} unmatched rows` : ""));
@@ -26977,9 +27089,9 @@ 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 = path16.join(context.directory, config2.paths.rules);
+  const rulesDir = path17.join(context.directory, config2.paths.rules);
   const importCtx = loadContext(context.directory, contextId);
-  const csvPath = path16.join(context.directory, importCtx.filePath);
+  const csvPath = path17.join(context.directory, importCtx.filePath);
   const csvFiles = [csvPath];
   const rulesMapping = loadRulesMapping(rulesDir);
   const matchedRulesFiles = new Set;
@@ -27002,7 +27114,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) => path16.relative(context.directory, f))
+      rulesScanned: Array.from(matchedRulesFiles).map((f) => path17.relative(context.directory, f))
     });
     return;
   }
@@ -27026,7 +27138,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) => path16.relative(context.directory, f))
+      rulesScanned: Array.from(matchedRulesFiles).map((f) => path17.relative(context.directory, f))
     });
     return;
   }
@@ -27037,12 +27149,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) => path16.relative(context.directory, f))
+      rulesScanned: Array.from(matchedRulesFiles).map((f) => path17.relative(context.directory, f))
     });
     return;
   }
   const result = ensureAccountDeclarations(yearJournalPath, allAccounts);
-  const message = result.added.length > 0 ? `Added ${result.added.length} account declaration(s) to ${path16.relative(context.directory, yearJournalPath)}` : "All required accounts already declared";
+  const message = result.added.length > 0 ? `Added ${result.added.length} account declaration(s) to ${path17.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) {
@@ -27051,17 +27163,17 @@ async function executeAccountDeclarationsStep(context, contextId, logger) {
   }
   context.result.steps.accountDeclarations = buildStepResult(true, message, {
     accountsAdded: result.added,
-    journalUpdated: path16.relative(context.directory, yearJournalPath),
-    rulesScanned: Array.from(matchedRulesFiles).map((f) => path16.relative(context.directory, f))
+    journalUpdated: path17.relative(context.directory, yearJournalPath),
+    rulesScanned: Array.from(matchedRulesFiles).map((f) => path17.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 = path16.join(context.directory, config2.paths.rules);
+  const rulesDir = path17.join(context.directory, config2.paths.rules);
   const importCtx = loadContext(context.directory, contextId);
-  const csvPath = path16.join(context.directory, importCtx.filePath);
+  const csvPath = path17.join(context.directory, importCtx.filePath);
   const rulesMapping = loadRulesMapping(rulesDir);
   const rulesFile = findRulesForCsv(csvPath, rulesMapping);
   if (!rulesFile) {
@@ -27290,8 +27402,8 @@ async function importPipeline(directory, agent, options, configLoader = loadImpo
       }
     }
     const importConfig = loadImportConfig(context.directory);
-    const pendingDir = path16.join(context.directory, importConfig.paths.pending);
-    const doneDir = path16.join(context.directory, importConfig.paths.done);
+    const pendingDir = path17.join(context.directory, importConfig.paths.pending);
+    const doneDir = path17.join(context.directory, importConfig.paths.done);
     const orderedContextIds = [...contextIds].sort((a, b) => {
       const ctxA = loadContext(context.directory, a);
       const ctxB = loadContext(context.directory, b);
@@ -27314,8 +27426,8 @@ async function importPipeline(directory, agent, options, configLoader = loadImpo
         totalTransactions += context.result.steps.import?.details?.summary?.totalTransactions || 0;
       } catch (error45) {
         if (error45 instanceof NoTransactionsError) {
-          const csvPath = path16.join(context.directory, importContext.filePath);
-          if (fs22.existsSync(csvPath)) {
+          const csvPath = path17.join(context.directory, importContext.filePath);
+          if (fs23.existsSync(csvPath)) {
             moveCsvToDone(csvPath, pendingDir, doneDir);
             logger.info(`No transactions to import for ${importContext.filename}, moved to done`);
           } else {
@@ -27396,16 +27508,16 @@ This tool orchestrates the full import workflow:
   }
 });
 // src/tools/init-directories.ts
-import * as fs23 from "fs";
-import * as path17 from "path";
+import * as fs24 from "fs";
+import * as path18 from "path";
 async function initDirectories(directory) {
   try {
     const config2 = loadImportConfig(directory);
     const directoriesCreated = [];
     const gitkeepFiles = [];
-    const importBase = path17.join(directory, "import");
-    if (!fs23.existsSync(importBase)) {
-      fs23.mkdirSync(importBase, { recursive: true });
+    const importBase = path18.join(directory, "import");
+    if (!fs24.existsSync(importBase)) {
+      fs24.mkdirSync(importBase, { recursive: true });
       directoriesCreated.push("import");
     }
     const pathsToCreate = [
@@ -27415,20 +27527,20 @@ async function initDirectories(directory) {
       { key: "unrecognized", path: config2.paths.unrecognized }
     ];
     for (const { path: dirPath } of pathsToCreate) {
-      const fullPath = path17.join(directory, dirPath);
-      if (!fs23.existsSync(fullPath)) {
-        fs23.mkdirSync(fullPath, { recursive: true });
+      const fullPath = path18.join(directory, dirPath);
+      if (!fs24.existsSync(fullPath)) {
+        fs24.mkdirSync(fullPath, { recursive: true });
         directoriesCreated.push(dirPath);
       }
-      const gitkeepPath = path17.join(fullPath, ".gitkeep");
-      if (!fs23.existsSync(gitkeepPath)) {
-        fs23.writeFileSync(gitkeepPath, "");
-        gitkeepFiles.push(path17.join(dirPath, ".gitkeep"));
+      const gitkeepPath = path18.join(fullPath, ".gitkeep");
+      if (!fs24.existsSync(gitkeepPath)) {
+        fs24.writeFileSync(gitkeepPath, "");
+        gitkeepFiles.push(path18.join(dirPath, ".gitkeep"));
       }
     }
-    const gitignorePath = path17.join(importBase, ".gitignore");
+    const gitignorePath = path18.join(importBase, ".gitignore");
     let gitignoreCreated = false;
-    if (!fs23.existsSync(gitignorePath)) {
+    if (!fs24.existsSync(gitignorePath)) {
       const gitignoreContent = `# Ignore CSV/PDF files in temporary directories
 /incoming/*.csv
 /incoming/*.pdf
@@ -27446,7 +27558,7 @@ async function initDirectories(directory) {
 .DS_Store
 Thumbs.db
 `;
-      fs23.writeFileSync(gitignorePath, gitignoreContent);
+      fs24.writeFileSync(gitignorePath, gitignoreContent);
       gitignoreCreated = true;
     }
     const parts = [];
@@ -27522,32 +27634,32 @@ You can now drop CSV files into import/incoming/ and run import-pipeline.`);
   }
 });
 // src/tools/generate-btc-purchases.ts
-import * as path18 from "path";
-import * as fs24 from "fs";
+import * as path19 from "path";
+import * as fs25 from "fs";
 function findFiatCsvPaths(directory, pendingDir, provider) {
-  const providerDir = path18.join(directory, pendingDir, provider);
-  if (!fs24.existsSync(providerDir))
+  const providerDir = path19.join(directory, pendingDir, provider);
+  if (!fs25.existsSync(providerDir))
     return [];
   const csvPaths = [];
-  const entries = fs24.readdirSync(providerDir, { withFileTypes: true });
+  const entries = fs25.readdirSync(providerDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
     if (entry.name === "btc")
       continue;
-    const csvFiles = findCsvFiles(path18.join(providerDir, entry.name), { fullPaths: true });
+    const csvFiles = findCsvFiles(path19.join(providerDir, entry.name), { fullPaths: true });
     csvPaths.push(...csvFiles);
   }
   return csvPaths;
 }
 function findBtcCsvPath(directory, pendingDir, provider) {
-  const btcDir = path18.join(directory, pendingDir, provider, "btc");
+  const btcDir = path19.join(directory, pendingDir, provider, "btc");
   const csvFiles = findCsvFiles(btcDir, { fullPaths: true });
   return csvFiles[0];
 }
 function determineYear(csvPaths) {
   for (const csvPath of csvPaths) {
-    const match2 = path18.basename(csvPath).match(/(\d{4})-\d{2}-\d{2}/);
+    const match2 = path19.basename(csvPath).match(/(\d{4})-\d{2}-\d{2}/);
     if (match2)
       return parseInt(match2[1], 10);
   }
@@ -27600,7 +27712,7 @@ async function generateBtcPurchases(directory, agent, options = {}, configLoader
       skippedDuplicates: result.skippedDuplicates,
       unmatchedFiat: result.unmatchedFiat.length,
       unmatchedBtc: result.unmatchedBtc.length,
-      yearJournal: path18.relative(directory, yearJournalPath)
+      yearJournal: path19.relative(directory, yearJournalPath)
     });
   } catch (err) {
     logger.error("Failed to generate BTC purchases", err);
@@ -27643,7 +27755,7 @@ to produce equity conversion entries for Bitcoin purchases.
 });
 // src/index.ts
 var __dirname2 = dirname9(fileURLToPath3(import.meta.url));
-var AGENT_FILE = join16(__dirname2, "..", "agent", "accountant.md");
+var AGENT_FILE = join17(__dirname2, "..", "agent", "accountant.md");
 var AccountantPlugin = async () => {
   const agent = loadAgent(AGENT_FILE);
   return {

package/docs/configuration/merger-fmv.md

@@ -0,0 +1,67 @@
+# Merger FMV Configuration
+
+When a merger or spinoff produces multiple incoming securities, cost basis must be allocated across them. Quantity-proportional allocation is incorrect when the incoming securities have different market values.
+
+The `merger-fmv.yaml` file provides fair market value (FMV) prices so cost basis is allocated by market value instead.
+
+## File Location
+
+`config/import/merger-fmv.yaml` (relative to project root)
+
+This file is **required** for any multi-way merger (more than one incoming symbol). The pipeline will fail with an error if a multi-way merger lacks FMV data. Single-symbol mergers (1→1) do not need FMV since 100% of the cost basis transfers to the single incoming symbol.
+
+## Format
+
+```yaml
+# date (YYYY-MM-DD) -> symbol -> FMV per share
+2015-10-14:
+  fr.to: 5.23
+  sil.to: 0.17
+```
+
+- **Date keys** use `YYYY-MM-DD` format, matching the merger transaction date
+- **Symbol keys** use normalized names (post-symbolMap, lowercase)
+- **Values** are the closing price per share on the distribution date
+
+Multiple dates can be specified for different merger events.
+
+## How It Works
+
+For each merger group, the preprocessor looks up FMV data for the transaction date. If FMV prices are found for **all** incoming symbols, cost basis is allocated by FMV-weighted proportion:
+
+```
+proportion[i] = (fmv[symbol] * quantity) / sum(fmv[symbol] * quantity)
+allocated_cost[i] = total_cost_basis * proportion[i]
+```
+
+If FMV data is missing or doesn't cover all incoming symbols for a multi-way merger, the pipeline fails with an error directing you to add the missing prices.
+
+## Example
+
+Given a merger: 3,300 SVL.TO (cost basis 5,660 CAD) → 914 FR.TO + 550 SIL.TO
+
+**Without FMV** (quantity-proportional):
+- FR.TO: 5,660 × (914 / 1,464) = 3,533.63 CAD (3.87/share)
+- SIL.TO: 5,660 × (550 / 1,464) = 2,126.37 CAD (3.87/share)
+
+Both get the same per-share cost, which is wrong.
+
+**With FMV** (FR.TO @ 5.23, SIL.TO @ 0.17):
+- FR.TO FMV total: 914 × 5.23 = 4,780.22
+- SIL.TO FMV total: 550 × 0.17 = 93.50
+- FR.TO: 5,660 × (4,780.22 / 4,873.72) = 5,551.42 CAD (6.07/share)
+- SIL.TO: 5,660 × (93.50 / 4,873.72) = 108.58 CAD (0.20/share)
+
+## Finding FMV Prices
+
+Use the regular closing price on the distribution date, not the adjusted close (which accounts for later dividends/splits):
+
+```bash
+pricehist fetch yahoo AG.TO -t close -s 2015-10-14 -e 2015-10-14
+```
+
+For delisted or illiquid securities, check portfolio market-data exports or broker statements.
+
+## When Needed
+
+FMV config is **required** whenever a merger produces multiple incoming symbols (N>1). The pipeline will refuse to process the merger without it. Single-symbol mergers (1→1) always allocate 100% and don't need FMV.

package/docs/tools/import-pipeline.md

@@ -257,7 +257,7 @@ See [classify-statements](classify-statements.md) for details.
 
 **Per-Year Journals**: Each CSV writes to a journal file named `{year}-{currency}.journal` where the year is extracted from the `to-DDMMYYYY` portion of the filename (e.g., `swissquote-cad-transactions-01012013-to-31122013.csv` → `2013-cad.journal`).
 
-**Multi-Way Mergers**: Mergers can involve multiple incoming/outgoing securities (1→N, N→1, N→M). The preprocessor groups all entries sharing the same date+orderNum, collects total cost basis from outgoing lots, and distributes it proportionally across incoming symbols.
+**Multi-Way Mergers**: Mergers can involve multiple incoming/outgoing securities (1→N, N→1, N→M). The preprocessor groups all entries sharing the same date+orderNum, collects total cost basis from outgoing lots, and distributes it across incoming symbols using FMV-weighted proportions from `config/import/merger-fmv.yaml`. FMV data is **required** for multi-way mergers (>1 incoming symbol) — the pipeline fails with an error if it is missing. Single-symbol mergers (1→1) always allocate 100% without needing FMV. See [Merger FMV Configuration](../configuration/merger-fmv.md).
 
 **Cross-Currency Mergers**: When the outgoing and incoming sides of a merger appear in different currency CSV files, the outgoing side saves its state to `pending-mergers/` under the lot inventory directory. When the incoming side is processed later, it loads the pending state to create lots with the correct cost basis.
 

package/package.json

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