@dizzlkheinz/ynab-mcpb 0.18.3 → 0.18.4

package/src/tools/reconcileAdapter.ts

@@ -115,6 +115,9 @@ const convertSummary = (analysis: ReconciliationAnalysis) => ({
   statement_date_range: analysis.summary.statement_date_range,
   bank_transactions_count: analysis.summary.bank_transactions_count,
   ynab_transactions_count: analysis.summary.ynab_transactions_count,
+  ynab_in_range_count:
+    analysis.summary.ynab_in_range_count ?? analysis.summary.ynab_transactions_count,
+  ynab_outside_range_count: analysis.summary.ynab_outside_range_count ?? 0,
   auto_matched: analysis.summary.auto_matched,
   suggested_matches: analysis.summary.suggested_matches,
   unmatched_bank: analysis.summary.unmatched_bank,
@@ -292,6 +295,9 @@ export const buildReconciliationPayload = (
     unmatched: {
       bank: analysis.unmatched_bank.map((txn) => toBankTransactionView(txn, currency)),
       ynab: analysis.unmatched_ynab.map((txn) => toYNABTransactionView(txn, currency)),
+      ynab_outside_date_range: (analysis.ynab_outside_date_range ?? []).map((txn) =>
+        toYNABTransactionView(txn, currency),
+      ),
     },
   };
 

package/src/tools/reconciliation/__tests__/adapter.causes.test.ts

@@ -3,6 +3,17 @@ import type { ReconciliationAnalysis } from '../types.js';
 import { buildReconciliationPayload } from '../../reconcileAdapter.js';
 import type { LegacyReconciliationResult } from '../executor.js';
 
+const makeMoney = (value: number, currency = 'USD') => ({
+  value_milliunits: Math.round(value * 1000),
+  value,
+  value_display: value < 0 ? `-$${Math.abs(value).toFixed(2)}` : `$${value.toFixed(2)}`,
+  currency,
+  direction: (value === 0 ? 'balanced' : value > 0 ? 'credit' : 'debit') as
+    | 'balanced'
+    | 'credit'
+    | 'debit',
+});
+
 const baseAnalysis: ReconciliationAnalysis = {
   success: true,
   phase: 'analysis',
@@ -10,25 +21,28 @@ const baseAnalysis: ReconciliationAnalysis = {
     statement_date_range: '2025-10-01 to 2025-10-31',
     bank_transactions_count: 1,
     ynab_transactions_count: 1,
+    ynab_in_range_count: 1,
+    ynab_outside_range_count: 0,
     auto_matched: 0,
     suggested_matches: 0,
     unmatched_bank: 0,
     unmatched_ynab: 0,
-    current_cleared_balance: -899.02,
-    target_statement_balance: -921.24,
-    discrepancy: 22.22,
+    current_cleared_balance: makeMoney(-899.02),
+    target_statement_balance: makeMoney(-921.24),
+    discrepancy: makeMoney(22.22),
     discrepancy_explanation: 'Need to investigate discrepancy',
   },
   auto_matches: [],
   suggested_matches: [],
   unmatched_bank: [],
   unmatched_ynab: [],
+  ynab_outside_date_range: [],
   balance_info: {
-    current_cleared: -899.02,
-    current_uncleared: 0,
-    current_total: -899.02,
-    target_statement: -921.24,
-    discrepancy: 22.22,
+    current_cleared: makeMoney(-899.02),
+    current_uncleared: makeMoney(0),
+    current_total: makeMoney(-899.02),
+    target_statement: makeMoney(-921.24),
+    discrepancy: makeMoney(22.22),
     on_track: false,
   },
   next_steps: [],

package/src/tools/reconciliation/__tests__/adapter.test.ts

@@ -23,6 +23,8 @@ const buildAnalysis = (): ReconciliationAnalysis => ({
     statement_date_range: '2025-10-01 to 2025-10-31',
     bank_transactions_count: 3,
     ynab_transactions_count: 4,
+    ynab_in_range_count: 4,
+    ynab_outside_range_count: 0,
     auto_matched: 2,
     suggested_matches: 1,
     unmatched_bank: 1,
@@ -115,6 +117,7 @@ const buildAnalysis = (): ReconciliationAnalysis => ({
       memo: null,
     },
   ],
+  ynab_outside_date_range: [],
   balance_info: {
     current_cleared: makeMoney(-899.02),
     current_uncleared: makeMoney(-45.23),

package/src/tools/reconciliation/__tests__/analyzer.test.ts

@@ -336,5 +336,70 @@ describe('analyzer', () => {
       expect(result.summary.statement_date_range).toContain('2025-10-15');
       expect(result.summary.statement_date_range).toContain('2025-10-20');
     });
+
+    it('should not flag transactions outside statement period as missing from bank', () => {
+      // Regression test for date range filtering bug
+      // Previously, ALL YNAB transactions were compared against bank CSV,
+      // causing transactions outside the statement period to be incorrectly
+      // flagged as "missing from bank"
+      vi.mocked(csvParser.parseCSV).mockReturnValue({
+        transactions: [
+          {
+            id: 'b1',
+            date: '2025-01-15',
+            amount: -50000,
+            payee: 'Grocery Store',
+            memo: '',
+            sourceRow: 1,
+            raw: {} as any,
+          },
+        ],
+        meta: {
+          detectedDelimiter: ',',
+          detectedColumns: [],
+          totalRows: 1,
+          validRows: 1,
+          skippedRows: 0,
+        },
+        errors: [],
+        warnings: [],
+      });
+
+      const ynabTxns: YNABAPITransaction[] = [
+        // Transaction OUTSIDE statement period (December, before January statement)
+        {
+          id: 'y-outside',
+          date: '2024-12-20',
+          amount: -30000,
+          payee_name: 'Old Transaction',
+          category_name: 'Shopping',
+          cleared: 'cleared' as const,
+          approved: true,
+        } as YNABAPITransaction,
+        // Transaction INSIDE statement period
+        {
+          id: 'y-inside',
+          date: '2025-01-15',
+          amount: -50000,
+          payee_name: 'Grocery Store',
+          category_name: 'Groceries',
+          cleared: 'uncleared' as const,
+          approved: true,
+        } as YNABAPITransaction,
+      ];
+
+      const result = analyzeReconciliation('csv', undefined, ynabTxns, -50.0);
+
+      // The outside-range transaction should be in ynab_outside_date_range, not unmatched_ynab
+      expect(result.ynab_outside_date_range).toHaveLength(1);
+      expect(result.ynab_outside_date_range[0]?.id).toBe('y-outside');
+
+      // The summary should reflect the correct counts
+      expect(result.summary.ynab_in_range_count).toBe(1);
+      expect(result.summary.ynab_outside_range_count).toBe(1);
+
+      // The inside-range transaction should match and not be in unmatched
+      expect(result.unmatched_ynab).toHaveLength(0);
+    });
   });
 });

package/src/tools/reconciliation/__tests__/recommendationEngine.test.ts

@@ -30,6 +30,7 @@ const createMockContext = (overrides?: Partial<RecommendationContext>): Recommen
     suggested_matches: [],
     unmatched_bank: [],
     unmatched_ynab: [],
+    ynab_outside_date_range: [],
     balance_info: {
       current_cleared: makeMoney(100),
       current_uncleared: makeMoney(0),
@@ -42,6 +43,8 @@ const createMockContext = (overrides?: Partial<RecommendationContext>): Recommen
       statement_date_range: '2024-01-01 to 2024-01-31',
       bank_transactions_count: 0,
       ynab_transactions_count: 0,
+      ynab_in_range_count: 0,
+      ynab_outside_range_count: 0,
       auto_matched: 0,
       suggested_matches: 0,
       unmatched_bank: 0,

package/src/tools/reconciliation/__tests__/reportFormatter.test.ts

@@ -39,6 +39,8 @@ const createTestAnalysis = (
     statement_date_range: '2025-10-01 to 2025-10-31',
     bank_transactions_count: 10,
     ynab_transactions_count: 12,
+    ynab_in_range_count: 12,
+    ynab_outside_range_count: 0,
     auto_matched: 8,
     suggested_matches: 1,
     unmatched_bank: 1,
@@ -52,6 +54,7 @@ const createTestAnalysis = (
   suggested_matches: [],
   unmatched_bank: [],
   unmatched_ynab: [],
+  ynab_outside_date_range: [],
   balance_info: {
     current_cleared: makeMoney(-899.02),
     current_uncleared: makeMoney(-50.0),
@@ -255,7 +258,7 @@ describe('reportFormatter', () => {
 
       const report = formatHumanReadableReport(analysis);
 
-      expect(report).toContain('Unmatched bank transactions:');
+      expect(report).toContain('Missing from YNAB (bank transactions without matches):');
       expect(report).toContain('2025-10-25');
       expect(report).toContain('EvoCarShare');
       expect(report).toContain('-$22.22');

package/src/tools/reconciliation/__tests__/scenarios/adapterCurrency.scenario.test.ts

@@ -17,6 +17,8 @@ const buildAnalysis = (currency = 'USD'): ReconciliationAnalysis => ({
     statement_date_range: '2025-10-01 to 2025-10-31',
     bank_transactions_count: 1,
     ynab_transactions_count: 1,
+    ynab_in_range_count: 1,
+    ynab_outside_range_count: 0,
     auto_matched: 0,
     suggested_matches: 1,
     unmatched_bank: 0,
@@ -30,6 +32,7 @@ const buildAnalysis = (currency = 'USD'): ReconciliationAnalysis => ({
   suggested_matches: [] as TransactionMatch[],
   unmatched_bank: [],
   unmatched_ynab: [],
+  ynab_outside_date_range: [],
   balance_info: {
     current_cleared: makeMoney(-899.02, currency),
     current_uncleared: makeMoney(0, currency),

package/src/tools/reconciliation/__tests__/scenarios/extremes.scenario.test.ts

@@ -60,7 +60,11 @@ describe('scenario: zero, negative, and large statements', () => {
     const result = analyzeReconciliation('csv', undefined, ynabTxns, 0);
 
     expect(result.summary.unmatched_bank).toBeGreaterThan(0);
-    expect(result.summary.unmatched_ynab).toBeGreaterThan(0);
+    // The YNAB transaction from Oct 31 is within the 7-day tolerance buffer
+    // of the statement period (Nov 1-2), so it's included for matching.
+    // Since it doesn't match any bank transactions, it goes to unmatched_ynab.
+    expect(result.summary.ynab_in_range_count).toBe(1);
+    expect(result.summary.unmatched_ynab).toBe(1);
     expect(result.balance_info.discrepancy).not.toBeNaN();
   });
 });

package/src/tools/reconciliation/__tests__/schemaUrl.test.ts

@@ -2,6 +2,17 @@ import { describe, it, expect } from 'vitest';
 import type { ReconciliationAnalysis } from '../types.js';
 import { buildReconciliationPayload } from '../../reconcileAdapter.js';
 
+const makeMoney = (value: number, currency = 'USD') => ({
+  value_milliunits: Math.round(value * 1000),
+  value,
+  value_display: value < 0 ? `-$${Math.abs(value).toFixed(2)}` : `$${value.toFixed(2)}`,
+  currency,
+  direction: (value === 0 ? 'balanced' : value > 0 ? 'credit' : 'debit') as
+    | 'balanced'
+    | 'credit'
+    | 'debit',
+});
+
 const minimalAnalysis: ReconciliationAnalysis = {
   success: true,
   phase: 'analysis',
@@ -9,25 +20,28 @@ const minimalAnalysis: ReconciliationAnalysis = {
     statement_date_range: '2025-10-01 to 2025-10-31',
     bank_transactions_count: 0,
     ynab_transactions_count: 0,
+    ynab_in_range_count: 0,
+    ynab_outside_range_count: 0,
     auto_matched: 0,
     suggested_matches: 0,
     unmatched_bank: 0,
     unmatched_ynab: 0,
-    current_cleared_balance: 0,
-    target_statement_balance: 0,
-    discrepancy: 0,
+    current_cleared_balance: makeMoney(0),
+    target_statement_balance: makeMoney(0),
+    discrepancy: makeMoney(0),
     discrepancy_explanation: 'Balanced',
   },
   auto_matches: [],
   suggested_matches: [],
   unmatched_bank: [],
   unmatched_ynab: [],
+  ynab_outside_date_range: [],
   balance_info: {
-    current_cleared: 0,
-    current_uncleared: 0,
-    current_total: 0,
-    target_statement: 0,
-    discrepancy: 0,
+    current_cleared: makeMoney(0),
+    current_uncleared: makeMoney(0),
+    current_total: makeMoney(0),
+    target_statement: makeMoney(0),
+    discrepancy: makeMoney(0),
     on_track: true,
   },
   next_steps: [],

package/src/tools/reconciliation/analyzer.ts

@@ -25,6 +25,97 @@ import { generateRecommendations } from './recommendationEngine.js';
 
 // --- Helper Functions ---
 
+/**
+ * Calculate the date range from bank transactions
+ * Returns { minDate, maxDate } as ISO date strings (YYYY-MM-DD)
+ */
+function calculateDateRange(bankTransactions: BankTransaction[]): {
+  minDate: string;
+  maxDate: string;
+} | null {
+  if (bankTransactions.length === 0) {
+    return null;
+  }
+
+  const dates = bankTransactions
+    .map((t) => t.date)
+    .filter((d) => d && /^\d{4}-\d{2}-\d{2}$/.test(d))
+    .sort();
+
+  if (dates.length === 0) {
+    return null;
+  }
+
+  return {
+    minDate: dates[0]!,
+    maxDate: dates[dates.length - 1]!,
+  };
+}
+
+/**
+ * Filter YNAB transactions to only those within the given date range
+ * Returns { inRange, outsideRange } arrays
+ *
+ * @param dateToleranceDays - Buffer to add to the date range to account for bank posting delays
+ */
+function filterByDateRange(
+  ynabTransactions: YNABTransaction[],
+  dateRange: { minDate: string; maxDate: string },
+  dateToleranceDays: number = 7,
+): { inRange: YNABTransaction[]; outsideRange: YNABTransaction[] } {
+  // Validate dateToleranceDays is non-negative
+  if (dateToleranceDays < 0) {
+    console.warn(
+      `[filterByDateRange] dateToleranceDays must be non-negative, got ${dateToleranceDays}. Using 0.`,
+    );
+    dateToleranceDays = 0;
+  }
+
+  const inRange: YNABTransaction[] = [];
+  const outsideRange: YNABTransaction[] = [];
+
+  // Parse date parts and use Date.UTC to avoid timezone issues
+  // This prevents 'off-by-one-day' errors from timezone conversions
+  const minParts = dateRange.minDate.split('-').map(Number);
+  const maxParts = dateRange.maxDate.split('-').map(Number);
+
+  // Validate date parts are valid numbers
+  if (
+    minParts.length !== 3 ||
+    maxParts.length !== 3 ||
+    minParts.some((n) => !Number.isFinite(n)) ||
+    maxParts.some((n) => !Number.isFinite(n))
+  ) {
+    console.warn(
+      `[filterByDateRange] Invalid date format in range: ${dateRange.minDate} to ${dateRange.maxDate} - returning all transactions`,
+    );
+    return { inRange: ynabTransactions, outsideRange: [] };
+  }
+
+  const [minYear, minMonth, minDay] = minParts as [number, number, number];
+  const [maxYear, maxMonth, maxDay] = maxParts as [number, number, number];
+
+  // Add buffer to date range to account for bank posting delays
+  // Note: Date.UTC automatically handles month rollover if day goes negative
+  // (e.g., day 3 - 7 days = -4 correctly rolls back to previous month)
+  const minDateWithBuffer = new Date(Date.UTC(minYear, minMonth - 1, minDay - dateToleranceDays));
+  const minDateStr = minDateWithBuffer.toISOString().split('T')[0]!;
+
+  const maxDateWithBuffer = new Date(Date.UTC(maxYear, maxMonth - 1, maxDay + dateToleranceDays));
+  const maxDateStr = maxDateWithBuffer.toISOString().split('T')[0]!;
+
+  for (const txn of ynabTransactions) {
+    // Compare dates as strings (YYYY-MM-DD format sorts correctly)
+    if (txn.date >= minDateStr && txn.date <= maxDateStr) {
+      inRange.push(txn);
+    } else {
+      outsideRange.push(txn);
+    }
+  }
+
+  return { inRange, outsideRange };
+}
+
 function mapToTransactionMatch(result: MatchResult): TransactionMatch {
   const candidates = result.candidates.map((c) => ({
     ynab_transaction: c.ynabTransaction,
@@ -97,7 +188,8 @@ function calculateBalances(
 
 function generateSummary(
   bankTransactions: BankTransaction[],
-  ynabTransactions: YNABTransaction[],
+  ynabTransactionsInRange: YNABTransaction[],
+  ynabTransactionsOutsideRange: YNABTransaction[],
   autoMatches: TransactionMatch[],
   suggestedMatches: TransactionMatch[],
   unmatchedBank: BankTransaction[],
@@ -108,6 +200,9 @@ function generateSummary(
   const dates = bankTransactions.map((t) => t.date).sort();
   const dateRange = dates.length > 0 ? `${dates[0]} to ${dates[dates.length - 1]}` : 'Unknown';
 
+  // Total YNAB transactions = in range + outside range
+  const totalYnabCount = ynabTransactionsInRange.length + ynabTransactionsOutsideRange.length;
+
   // Build discrepancy explanation
   let discrepancyExplanation = '';
   if (balances.on_track) {
@@ -131,7 +226,9 @@ function generateSummary(
   return {
     statement_date_range: dateRange,
     bank_transactions_count: bankTransactions.length,
-    ynab_transactions_count: ynabTransactions.length,
+    ynab_transactions_count: totalYnabCount,
+    ynab_in_range_count: ynabTransactionsInRange.length,
+    ynab_outside_range_count: ynabTransactionsOutsideRange.length,
     auto_matched: autoMatches.length,
     suggested_matches: suggestedMatches.length,
     unmatched_bank: unmatchedBank.length,
@@ -367,13 +464,30 @@ export function analyzeReconciliation(
   const csvParseWarnings = parseResult.warnings;
 
   // Step 2: Normalize YNAB transactions
-  const newYNABTransactions = normalizeYNABTransactions(ynabTransactions);
+  const allYNABTransactions = normalizeYNABTransactions(ynabTransactions);
+
+  // Step 2.5: Filter YNAB transactions by CSV date range
+  // Only compare transactions within the statement period (with tolerance buffer)
+  const csvDateRange = calculateDateRange(newBankTransactions);
+  let ynabInRange: YNABTransaction[];
+  let ynabOutsideRange: YNABTransaction[];
+
+  if (csvDateRange) {
+    const dateToleranceDays = config.dateToleranceDays ?? 7;
+    const filtered = filterByDateRange(allYNABTransactions, csvDateRange, dateToleranceDays);
+    ynabInRange = filtered.inRange;
+    ynabOutsideRange = filtered.outsideRange;
+  } else {
+    // No valid date range from CSV, use all transactions
+    ynabInRange = allYNABTransactions;
+    ynabOutsideRange = [];
+  }
 
-  // Step 3: Run new matching algorithm
+  // Step 3: Run matching algorithm ONLY on YNAB transactions within date range
   // Use normalizeConfig to convert legacy config to V2 format with defaults
   const normalizedConfig = normalizeConfig(config);
 
-  const newMatches = findMatches(newBankTransactions, newYNABTransactions, normalizedConfig);
+  const newMatches = findMatches(newBankTransactions, ynabInRange, normalizedConfig);
   const matches: TransactionMatch[] = newMatches.map(mapToTransactionMatch);
 
   // Categorize
@@ -397,25 +511,26 @@ export function analyzeReconciliation(
   );
   const unmatchedBank = unmatchedBankMatches.map((m) => m.bankTransaction);
 
-  // Find unmatched YNAB
+  // Find unmatched YNAB (only from in-range transactions)
   const matchedYnabIds = new Set<string>();
   matches.forEach((m) => {
     if (m.ynabTransaction) matchedYnabIds.add(m.ynabTransaction.id);
   });
-  const unmatchedYNAB = newYNABTransactions.filter((t) => !matchedYnabIds.has(t.id));
+  const unmatchedYNAB = ynabInRange.filter((t) => !matchedYnabIds.has(t.id));
 
-  // Step 6: Calculate balances
+  // Step 6: Calculate balances (use ALL YNAB transactions for balance calculation)
   const balances = calculateBalances(
-    newYNABTransactions,
+    allYNABTransactions,
     statementBalance,
     currency,
     accountSnapshot,
   );
 
-  // Step 7: Generate summary
+  // Step 7: Generate summary (with date range info)
   const summary = generateSummary(
     matches.map((m) => m.bankTransaction),
-    newYNABTransactions,
+    ynabInRange,
+    ynabOutsideRange,
     autoMatches,
     suggestedMatches,
     unmatchedBank,
@@ -445,6 +560,7 @@ export function analyzeReconciliation(
     suggested_matches: suggestedMatches,
     unmatched_bank: unmatchedBank,
     unmatched_ynab: unmatchedYNAB,
+    ynab_outside_date_range: ynabOutsideRange,
     balance_info: balances,
     next_steps: nextSteps,
     insights,

package/src/tools/reconciliation/reportFormatter.ts

@@ -137,6 +137,18 @@ function formatTransactionAnalysisSection(
   lines.push(SECTION_DIVIDER);
 
   const summary = analysis.summary;
+
+  // Show date range context if transactions were filtered
+  const outsideRangeCount = summary.ynab_outside_range_count ?? 0;
+  if (outsideRangeCount > 0) {
+    const inRangeCount = summary.ynab_in_range_count ?? summary.ynab_transactions_count;
+    lines.push(
+      `Comparing ${summary.bank_transactions_count} bank transactions with ${inRangeCount} YNAB transactions within statement period.`,
+    );
+    lines.push(`(${outsideRangeCount} YNAB transactions outside statement period - not compared)`);
+    lines.push('');
+  }
+
   lines.push(
     `- Automatically matched:  ${summary.auto_matched} of ${summary.bank_transactions_count} transactions`,
   );
@@ -147,7 +159,7 @@ function formatTransactionAnalysisSection(
   // Show unmatched bank transactions (if any)
   if (analysis.unmatched_bank.length > 0) {
     lines.push('');
-    lines.push('Unmatched bank transactions:');
+    lines.push('Missing from YNAB (bank transactions without matches):');
     const maxToShow = options.maxUnmatchedToShow ?? 5;
     const toShow = analysis.unmatched_bank.slice(0, maxToShow);
 
@@ -160,10 +172,26 @@ function formatTransactionAnalysisSection(
     }
   }
 
+  // Show unmatched YNAB transactions within date range (if any)
+  if (analysis.unmatched_ynab.length > 0) {
+    lines.push('');
+    lines.push('Missing from bank statement (YNAB transactions without matches):');
+    const maxToShow = options.maxUnmatchedToShow ?? 5;
+    const toShow = analysis.unmatched_ynab.slice(0, maxToShow);
+
+    for (const txn of toShow) {
+      lines.push(formatYnabTransactionLine(txn));
+    }
+
+    if (analysis.unmatched_ynab.length > maxToShow) {
+      lines.push(`   ... and ${analysis.unmatched_ynab.length - maxToShow} more`);
+    }
+  }
+
   // Show suggested matches (if any)
   if (analysis.suggested_matches.length > 0) {
     lines.push('');
-    lines.push('Suggested matches:');
+    lines.push('Suggested matches (review manually):');
     const maxToShow = options.maxUnmatchedToShow ?? 3;
     const toShow = analysis.suggested_matches.slice(0, maxToShow);
 
@@ -179,6 +207,15 @@ function formatTransactionAnalysisSection(
   return lines.join('\n');
 }
 
+/**
+ * Format a YNAB transaction line
+ */
+function formatYnabTransactionLine(txn: YNABTransaction): string {
+  const amountStr = formatAmount(txn.amount);
+  const payee = txn.payee ?? 'Unknown';
+  return `   ${txn.date} - ${payee.substring(0, 40).padEnd(40)} ${amountStr}`;
+}
+
 /**
  * Format a bank transaction line
  */

package/src/tools/reconciliation/types.ts

@@ -75,6 +75,10 @@ export interface ReconciliationSummary {
   statement_date_range: string;
   bank_transactions_count: number;
   ynab_transactions_count: number;
+  /** YNAB transactions within the statement date range (used for matching) */
+  ynab_in_range_count: number;
+  /** YNAB transactions outside the statement date range (not compared) */
+  ynab_outside_range_count: number;
   auto_matched: number;
   suggested_matches: number;
   unmatched_bank: number;
@@ -118,6 +122,8 @@ export interface ReconciliationAnalysis {
   suggested_matches: TransactionMatch[];
   unmatched_bank: BankTransaction[];
   unmatched_ynab: YNABTransaction[];
+  /** YNAB transactions outside the statement date range (not compared, expected) */
+  ynab_outside_date_range: YNABTransaction[];
   balance_info: BalanceInfo;
   next_steps: string[];
   insights: ReconciliationInsight[];