Add ImportedTransaction proto and read seed transactions for FIFO

New proto: ImportedTransaction with account_id, date, type (BUY/SELL/
SPLIT/STOCK_DIVIDEND/EXPIRY), symbol, ibkr_symbol, quantity, price.
Stores the complete normalized transaction history from previous
brokers (UBS/RBC) as permanent seed data.

Merge: read seed/<account>/transactions.json and convert to Trade
protos for FIFO. Replaces the pre-computed lots.json approach with
the full transaction history so FIFO can process buys AND sells.

FIFO: sort buys before sells within the same date to handle same-day
buy+sell scenarios correctly.

Status: all 45 equity positions match IBKR truth file on quantity.
Remaining issues: bond cost basis (face value vs unit pricing),
short options (sell-to-open before buy-to-close), 8 expired options
still showing.

Author: bufdev

internal/gen/proto/go/ibctl/data/v1/imported_transaction.pb.go

@@ -89,13 +89,17 @@ func Merge(
 		// Flex Query trades within this range will be excluded.
 		csvMinDate, csvMaxDate := tradeDateRange(csvTrades)
 		allTrades = append(allTrades, csvTrades...)
-		// Step 2: Load seed lots (pre-transfer tax lots from previous broker).
-		// These are permanent data that represent the original cost basis.
+		// Step 2: Load imported transactions from previous broker (seed data).
+		// These are the complete normalized transaction history (buys, sells,
+		// splits, dividends, expiries) from UBS/RBC, converted to Trade protos.
 		if seedDirPath != "" {
-			seedLotsPath := filepath.Join(seedDirPath, alias, "lots.json")
-			seedLots, err := protoio.ReadMessagesJSON(seedLotsPath, func() *datav1.Trade { return &datav1.Trade{} })
+			seedTxnPath := filepath.Join(seedDirPath, alias, "transactions.json")
+			importedTxns, err := protoio.ReadMessagesJSON(seedTxnPath, func() *datav1.ImportedTransaction { return &datav1.ImportedTransaction{} })
 			if err == nil {
-				allTrades = append(allTrades, seedLots...)
+				for _, txn := range importedTxns {
+					trade := importedTransactionToTrade(txn)
+					allTrades = append(allTrades, trade)
+				}
 			}
 		}
 		// Step 3: Load Flex Query cached trades, excluding dates covered by CSVs.
@@ -270,6 +274,68 @@ func generateTradeID(symbol string, dateTime time.Time, quantity string, price s
 	return fmt.Sprintf("csv-%x", hash[:8])
 }
 
+// importedTransactionToTrade converts an ImportedTransaction (from the previous broker)
+// to a Trade proto for FIFO processing. Uses the ibkr_symbol field for the symbol
+// so it matches IBKR's naming convention.
+func importedTransactionToTrade(txn *datav1.ImportedTransaction) *datav1.Trade {
+	// Map imported transaction type to trade side.
+	var side datav1.TradeSide
+	switch txn.GetType() {
+	case datav1.ImportedTransactionType_IMPORTED_TRANSACTION_TYPE_BUY,
+		datav1.ImportedTransactionType_IMPORTED_TRANSACTION_TYPE_STOCK_DIVIDEND:
+		// Buys and stock dividends add to position.
+		side = datav1.TradeSide_TRADE_SIDE_BUY
+	case datav1.ImportedTransactionType_IMPORTED_TRANSACTION_TYPE_SELL,
+		datav1.ImportedTransactionType_IMPORTED_TRANSACTION_TYPE_EXPIRY:
+		// Sells and expiries reduce position.
+		side = datav1.TradeSide_TRADE_SIDE_SELL
+	case datav1.ImportedTransactionType_IMPORTED_TRANSACTION_TYPE_SPLIT:
+		// Splits are handled as buys with zero price (quantity adjustment).
+		if txn.GetQuantity() >= 0 {
+			side = datav1.TradeSide_TRADE_SIDE_BUY
+		} else {
+			side = datav1.TradeSide_TRADE_SIDE_SELL
+		}
+	case datav1.ImportedTransactionType_IMPORTED_TRANSACTION_TYPE_UNSPECIFIED:
+		// Skip unspecified transactions.
+		side = datav1.TradeSide_TRADE_SIDE_UNSPECIFIED
+	}
+	// Use ibkr_symbol for FIFO matching.
+	symbol := txn.GetIbkrSymbol()
+	// Determine currency from price if available.
+	currencyCode := "USD"
+	if txn.GetPrice() != nil {
+		currencyCode = txn.GetPrice().GetCurrencyCode()
+	}
+	// Build quantity as Decimal.
+	quantity := mathpb.FromMicros(txn.GetQuantity() * 1_000_000)
+	// Use price if available, otherwise zero.
+	tradePrice := txn.GetPrice()
+	if tradePrice == nil {
+		tradePrice = moneypb.MoneyFromMicros(currencyCode, 0)
+	}
+	// Generate a deterministic trade ID.
+	tradeID := fmt.Sprintf("imported-%s-%04d%02d%02d-%d",
+		symbol,
+		txn.GetDate().GetYear(), txn.GetDate().GetMonth(), txn.GetDate().GetDay(),
+		txn.GetQuantity(),
+	)
+	return &datav1.Trade{
+		TradeId:       tradeID,
+		AccountId:     txn.GetAccountId(),
+		TradeDate:     txn.GetDate(),
+		SettleDate:    txn.GetDate(),
+		Symbol:        symbol,
+		AssetCategory: "STK",
+		Side:          side,
+		Quantity:      quantity,
+		TradePrice:    tradePrice,
+		Proceeds:      moneypb.MoneyFromMicros(currencyCode, 0),
+		Commission:    moneypb.MoneyFromMicros(currencyCode, 0),
+		CurrencyCode:  currencyCode,
+	}
+}
+
 // protoDateString returns a sortable date string from a proto Date.
 func protoDateString(d interface {
 	GetYear() uint32

internal/ibctl/ibctlmerge/ibctlmerge.go

@@ -108,12 +108,18 @@ func ComputeTaxLots(trades []*datav1.Trade) (*TaxLotResult, error) {
 		key := lotKey{accountAlias: trade.GetAccountId(), symbol: trade.GetSymbol()}
 		keyTrades[key] = append(keyTrades[key], trade)
 	}
-	// Sort trades within each group by trade date.
+	// Sort trades within each group by trade date, with buys before sells
+	// on the same date. This ensures FIFO has lots available before sells
+	// try to consume them (important for same-day buy+sell scenarios).
 	for _, trades := range keyTrades {
 		sort.Slice(trades, func(i, j int) bool {
 			dateI := tradeDateString(trades[i])
 			dateJ := tradeDateString(trades[j])
-			return dateI < dateJ
+			if dateI != dateJ {
+				return dateI < dateJ
+			}
+			// Within the same date, buys (side=1) come before sells (side=2).
+			return trades[i].GetSide() < trades[j].GetSide()
 		})
 	}
 	// Process trades using FIFO within each (account, symbol) group.