@dizzlkheinz/ynab-mcpb 0.13.1 → 0.15.0

package/src/tools/reconciliation/matcher.ts

@@ -1,269 +1,289 @@
 /**
  * Transaction matching algorithm for reconciliation
- * Implements confidence-based matching with auto-match and suggestion tiers
+ *
+ * V2 matcher works natively in milliunits using canonical BankTransaction
+ * and NormalizedYNABTransaction types.
  */
 
-import { normalizedMatch, payeeSimilarity } from './payeeNormalizer.js';
-import { DEFAULT_MATCHING_CONFIG } from './types.js';
+import * as fuzz from 'fuzzball';
 import type {
-  BankTransaction,
-  YNABTransaction,
-  TransactionMatch,
-  MatchCandidate,
-  MatchingConfig,
-} from './types.js';
-
-/**
- * Check if two amounts match within tolerance
- */
-function amountsMatch(bankAmount: number, ynabAmount: number, toleranceCents: number): boolean {
-  // Convert YNAB milliunits to dollars
-  const ynabDollars = ynabAmount / 1000;
-
-  // Round to avoid floating point precision issues
-  const difference = Math.round(Math.abs(bankAmount - ynabDollars) * 100) / 100;
-  const toleranceDollars = toleranceCents / 100;
-
-  return difference <= toleranceDollars;
+  BankTransaction as CanonicalBankTransaction,
+  NormalizedYNABTransaction,
+} from '../../types/reconciliation.js';
+import { type MatchingConfig } from './types.js';
+
+export type { MatchingConfig };
+
+export interface MatchCandidate {
+  ynabTransaction: NormalizedYNABTransaction;
+  scores: {
+    amount: number; // 0-100
+    date: number; // 0-100
+    payee: number; // 0-100
+    combined: number; // Weighted combination
+  };
+  matchReasons: string[];
 }
 
-/**
- * Check if two dates match within tolerance
- */
-function datesMatch(date1: string, date2: string, toleranceDays: number): boolean {
-  const d1 = new Date(date1);
-  const d2 = new Date(date2);
-
-  const diffMs = Math.abs(d1.getTime() - d2.getTime());
-  const diffDays = diffMs / (1000 * 60 * 60 * 24);
-
-  return diffDays <= toleranceDays;
+export interface MatchResult {
+  bankTransaction: CanonicalBankTransaction;
+  bestMatch: MatchCandidate | null;
+  candidates: MatchCandidate[]; // Top 3
+  confidence: 'high' | 'medium' | 'low' | 'none';
+  confidenceScore: number;
 }
 
-/**
- * Calculate match confidence score between bank and YNAB transaction
- * Returns score 0-100 and match reasons
- */
-function calculateMatchScore(
-  bankTxn: BankTransaction,
-  ynabTxn: YNABTransaction,
-  config: MatchingConfig,
-): { score: number; reasons: string[] } {
-  const reasons: string[] = [];
-  let score = 0;
-
-  // Amount match (40% weight) - REQUIRED
-  const amountMatch = amountsMatch(bankTxn.amount, ynabTxn.amount, config.amountToleranceCents);
-  if (!amountMatch) {
-    return { score: 0, reasons: ['Amount does not match'] };
-  }
-  score += 40;
-  reasons.push('Amount matches');
-
-  // Date match (40% weight)
-  const dateWithinTolerance = datesMatch(bankTxn.date, ynabTxn.date, config.dateToleranceDays);
-  if (dateWithinTolerance) {
-    score += 40;
-    const daysDiff = Math.abs(
-      (new Date(bankTxn.date).getTime() - new Date(ynabTxn.date).getTime()) / (1000 * 60 * 60 * 24),
-    );
-    if (daysDiff === 0) {
-      reasons.push('Exact date match');
-    } else {
-      reasons.push(`Date within ${Math.round(daysDiff)} days`);
-    }
+export const DEFAULT_CONFIG: MatchingConfig = {
+  weights: {
+    amount: 0.5,
+    date: 0.15,
+    payee: 0.35,
+  },
+  amountToleranceMilliunits: 10, // 1 cent
+  dateToleranceDays: 7,
+  autoMatchThreshold: 85,
+  suggestedMatchThreshold: 60,
+  minimumCandidateScore: 40,
+  exactAmountBonus: 10,
+  exactDateBonus: 5,
+  exactPayeeBonus: 10,
+};
+
+export function normalizeConfig(config?: MatchingConfig): MatchingConfig {
+  if (!config) {
+    return { ...DEFAULT_CONFIG };
   }
 
-  // Payee match (20% weight)
-  const payeeScore = payeeSimilarity(bankTxn.payee, ynabTxn.payee_name);
+  return {
+    weights: config.weights ?? DEFAULT_CONFIG.weights,
+    amountToleranceMilliunits:
+      config.amountToleranceMilliunits ?? DEFAULT_CONFIG.amountToleranceMilliunits,
+    dateToleranceDays: config.dateToleranceDays ?? DEFAULT_CONFIG.dateToleranceDays,
+    autoMatchThreshold: config.autoMatchThreshold ?? DEFAULT_CONFIG.autoMatchThreshold,
+    suggestedMatchThreshold:
+      config.suggestedMatchThreshold ?? DEFAULT_CONFIG.suggestedMatchThreshold,
+    minimumCandidateScore: config.minimumCandidateScore ?? DEFAULT_CONFIG.minimumCandidateScore,
+    exactAmountBonus: config.exactAmountBonus ?? DEFAULT_CONFIG.exactAmountBonus,
+    exactDateBonus: config.exactDateBonus ?? DEFAULT_CONFIG.exactDateBonus,
+    exactPayeeBonus: config.exactPayeeBonus ?? DEFAULT_CONFIG.exactPayeeBonus,
+  };
+}
 
-  if (normalizedMatch(bankTxn.payee, ynabTxn.payee_name)) {
-    score += 20;
-    reasons.push('Payee exact match');
-  } else if (payeeScore >= 95) {
-    score += 15;
-    reasons.push(`Payee highly similar (${Math.round(payeeScore)}%)`);
-  } else if (payeeScore >= 80) {
-    score += 10;
-    reasons.push(`Payee similar (${Math.round(payeeScore)}%)`);
-  } else if (payeeScore >= 60) {
-    score += 6;
-    reasons.push(`Payee somewhat similar (${Math.round(payeeScore)}%)`);
+function matchSingle(
+  bankTxn: CanonicalBankTransaction,
+  ynabTransactions: NormalizedYNABTransaction[],
+  usedIds: Set<string>,
+  configInput: MatchingConfig | undefined,
+): MatchResult {
+  const config = normalizeConfig(configInput);
+
+  const candidates = findCandidates(bankTxn, ynabTransactions, usedIds, config);
+
+  const bestMatch = candidates.length > 0 ? candidates[0]! : null;
+  const confidenceScore = bestMatch?.scores.combined ?? 0;
+
+  let confidence: MatchResult['confidence'];
+  if (confidenceScore >= config.autoMatchThreshold) {
+    confidence = 'high';
+    if (bestMatch) usedIds.add(bestMatch.ynabTransaction.id);
+  } else if (confidenceScore >= config.suggestedMatchThreshold) {
+    confidence = 'medium';
+  } else if (confidenceScore >= config.minimumCandidateScore) {
+    confidence = 'low';
+  } else {
+    confidence = 'none';
   }
 
-  return { score: Math.round(score), reasons };
+  return {
+    bankTransaction: bankTxn,
+    bestMatch,
+    candidates: candidates.slice(0, 3),
+    confidence,
+    confidenceScore,
+  };
 }
 
-/**
- * Priority scoring for YNAB transactions
- * Uncleared transactions get higher priority than cleared ones
- */
-function getPriority(ynabTxn: YNABTransaction): number {
-  // Uncleared transactions are expecting bank confirmation
-  if (ynabTxn.cleared === 'uncleared') return 10;
-  if (ynabTxn.cleared === 'cleared') return 5;
-  if (ynabTxn.cleared === 'reconciled') return 1;
-  return 0;
+export function findMatches(
+  bankTransactions: CanonicalBankTransaction[],
+  ynabTransactions: NormalizedYNABTransaction[],
+  config?: MatchingConfig,
+): MatchResult[] {
+  const usedYnabIds = new Set<string>();
+  const results: MatchResult[] = [];
+
+  for (const bankTxn of bankTransactions) {
+    results.push(matchSingle(bankTxn, ynabTransactions, usedYnabIds, config));
+  }
+
+  return results;
 }
 
-/**
- * Find all matching candidates for a bank transaction
- */
-function findMatchCandidates(
-  bankTxn: BankTransaction,
-  ynabTransactions: YNABTransaction[],
+function findCandidates(
+  bankTxn: CanonicalBankTransaction,
+  ynabTransactions: NormalizedYNABTransaction[],
   usedIds: Set<string>,
   config: MatchingConfig,
 ): MatchCandidate[] {
   const candidates: MatchCandidate[] = [];
 
   for (const ynabTxn of ynabTransactions) {
-    // Skip already matched transactions
     if (usedIds.has(ynabTxn.id)) continue;
 
-    // Skip opposite-signed transactions (refunds vs purchases)
-    if (bankTxn.amount > 0 !== ynabTxn.amount > 0) continue;
+    // Sign check - both must be same sign (or both zero)
+    const bankSign = Math.sign(bankTxn.amount);
+    const ynabSign = Math.sign(ynabTxn.amount);
+    if (bankSign !== ynabSign && bankSign !== 0 && ynabSign !== 0) {
+      continue;
+    }
+
+    const amountDiff = Math.abs(bankTxn.amount - ynabTxn.amount);
+    if (amountDiff > config.amountToleranceMilliunits) {
+      // Outside configured amount tolerance - treat as no candidate
+      continue;
+    }
 
-    // Calculate match score
-    const { score, reasons } = calculateMatchScore(bankTxn, ynabTxn, config);
+    const scores = calculateScores(bankTxn, ynabTxn, config);
 
-    // Only include candidates with minimum score
-    if (score >= 30) {
+    if (scores.combined >= config.minimumCandidateScore) {
       candidates.push({
-        ynab_transaction: ynabTxn,
-        confidence: score,
-        match_reason: reasons.join(', '),
-        explanation: buildExplanation(bankTxn, ynabTxn, score, reasons),
+        ynabTransaction: ynabTxn,
+        scores,
+        matchReasons: buildMatchReasons(scores, config),
       });
     }
   }
 
-  // Sort by confidence (desc), then priority (desc), then date proximity
   candidates.sort((a, b) => {
-    if (b.confidence !== a.confidence) {
-      return b.confidence - a.confidence;
+    const scoreDiff = b.scores.combined - a.scores.combined;
+    if (scoreDiff !== 0) {
+      return scoreDiff;
     }
-    const priorityDiff = getPriority(b.ynab_transaction) - getPriority(a.ynab_transaction);
-    if (priorityDiff !== 0) return priorityDiff;
-
-    // Date proximity as tiebreaker
-    const dateProximityA = Math.abs(
-      new Date(bankTxn.date).getTime() - new Date(a.ynab_transaction.date).getTime(),
-    );
-    const dateProximityB = Math.abs(
-      new Date(bankTxn.date).getTime() - new Date(b.ynab_transaction.date).getTime(),
-    );
-    return dateProximityA - dateProximityB;
-  });
 
-  return candidates;
-}
+    const aUncleared = a.ynabTransaction.cleared === 'uncleared' ? 1 : 0;
+    const bUncleared = b.ynabTransaction.cleared === 'uncleared' ? 1 : 0;
+    if (aUncleared !== bUncleared) {
+      return bUncleared - aUncleared;
+    }
 
-/**
- * Build human-readable explanation for a match
- */
-function buildExplanation(
-  _bankTxn: BankTransaction,
-  ynabTxn: YNABTransaction,
-  score: number,
-  reasons: string[],
-): string {
-  const parts: string[] = [];
-
-  parts.push(`Match confidence: ${score}%`);
-  parts.push(reasons.join(', '));
-
-  if (ynabTxn.cleared === 'uncleared') {
-    parts.push('(Uncleared - awaiting confirmation)');
-  }
+    const bankTime = new Date(bankTxn.date).getTime();
+    const aDiff = Math.abs(bankTime - new Date(a.ynabTransaction.date).getTime());
+    const bDiff = Math.abs(bankTime - new Date(b.ynabTransaction.date).getTime());
+    if (aDiff !== bDiff) {
+      return aDiff - bDiff;
+    }
 
-  return parts.join(' | ');
+    return 0;
+  });
+  return candidates;
 }
 
-/**
- * Find best match for a single bank transaction
- */
-export function findBestMatch(
-  bankTxn: BankTransaction,
-  ynabTransactions: YNABTransaction[],
-  usedIds: Set<string>,
+function calculateScores(
+  bankTxn: CanonicalBankTransaction,
+  ynabTxn: NormalizedYNABTransaction,
   config: MatchingConfig,
-): TransactionMatch {
-  const candidates = findMatchCandidates(bankTxn, ynabTransactions, usedIds, config);
-
-  if (candidates.length === 0) {
-    // No match found
-    return {
-      bank_transaction: bankTxn,
-      confidence: 'none',
-      confidence_score: 0,
-      match_reason: 'No matching transaction found in YNAB',
-      action_hint: 'add_to_ynab',
-      recommendation: 'This transaction appears on bank statement but not in YNAB',
-    };
+): MatchCandidate['scores'] {
+  // Amount score - now using INTEGER comparison (milliunits)
+  const amountDiff = Math.abs(bankTxn.amount - ynabTxn.amount);
+  let amountScore: number;
+
+  if (amountDiff === 0) {
+    // Exact integer match - no floating point issues!
+    amountScore = 100;
+  } else if (amountDiff <= config.amountToleranceMilliunits) {
+    amountScore = 95;
+  } else if (amountDiff <= 1000) {
+    // Within $1
+    amountScore = 80 - (amountDiff / 1000) * 20;
+  } else {
+    amountScore = Math.max(0, 60 - (amountDiff / 1000) * 5);
   }
 
-  const bestCandidate = candidates[0]!; // Safe: we checked candidates.length > 0
-  const bestScore = bestCandidate.confidence;
-
-  // HIGH confidence: Auto-match candidate (≥90%)
-  if (bestScore >= config.autoMatchThreshold) {
-    return {
-      bank_transaction: bankTxn,
-      ynab_transaction: bestCandidate.ynab_transaction,
-      confidence: 'high',
-      confidence_score: bestScore,
-      match_reason: bestCandidate.match_reason,
-    };
+  // Date score
+  const bankDate = new Date(bankTxn.date);
+  const ynabDate = new Date(ynabTxn.date);
+  const daysDiff = Math.abs(bankDate.getTime() - ynabDate.getTime()) / (1000 * 60 * 60 * 24);
+  let dateScore: number;
+
+  if (daysDiff < 0.5) {
+    dateScore = 100;
+  } else if (daysDiff <= 1) {
+    dateScore = 95;
+  } else if (daysDiff <= config.dateToleranceDays) {
+    dateScore = 90 - (daysDiff - 1) * (40 / config.dateToleranceDays);
+  } else {
+    dateScore = Math.max(0, 50 - (daysDiff - config.dateToleranceDays) * 5);
   }
 
-  // MEDIUM confidence: Suggested match (60-89%)
-  if (bestScore >= config.suggestionThreshold) {
-    return {
-      bank_transaction: bankTxn,
-      ynab_transaction: bestCandidate.ynab_transaction,
-      candidates: candidates.slice(0, 3), // Top 3 candidates
-      confidence: 'medium',
-      confidence_score: bestScore,
-      match_reason: bestCandidate.match_reason,
-      top_confidence: bestScore,
-      action_hint: 'review_and_choose',
-    };
-  }
+  // Payee score using fuzzball
+  const payeeScore = calculatePayeeScore(bankTxn.payee, ynabTxn.payee);
+
+  // Combined score with weights
+  let combined =
+    amountScore * config.weights.amount +
+    dateScore * config.weights.date +
+    payeeScore * config.weights.payee;
+
+  // Apply bonuses
+  if (amountScore === 100) combined += config.exactAmountBonus;
+  if (dateScore === 100) combined += config.exactDateBonus;
+  if (payeeScore >= 95) combined += config.exactPayeeBonus;
+
+  combined = Math.min(100, combined);
 
-  // LOW confidence: Show as possible match but don't auto-suggest (30-59%)
   return {
-    bank_transaction: bankTxn,
-    candidates: candidates.slice(0, 3),
-    confidence: 'low',
-    confidence_score: bestScore,
-    match_reason: 'Low confidence match',
-    top_confidence: bestScore,
-    action_hint: 'review_or_add_new',
-    recommendation: 'Consider reviewing candidates or adding as new transaction',
+    amount: Math.round(amountScore),
+    date: Math.round(dateScore),
+    payee: Math.round(payeeScore),
+    combined: Math.round(combined),
   };
 }
 
-/**
- * Find matches for all bank transactions
- */
-export function findMatches(
-  bankTransactions: BankTransaction[],
-  ynabTransactions: YNABTransaction[],
-  config: MatchingConfig = DEFAULT_MATCHING_CONFIG as MatchingConfig,
-): TransactionMatch[] {
-  const matches: TransactionMatch[] = [];
-  const usedIds = new Set<string>();
+function calculatePayeeScore(bankPayee: string, ynabPayee: string | null): number {
+  if (!ynabPayee) return 30;
 
-  for (const bankTxn of bankTransactions) {
-    const match = findBestMatch(bankTxn, ynabTransactions, usedIds, config);
-    matches.push(match);
+  const scores = [
+    fuzz.token_set_ratio(bankPayee, ynabPayee),
+    fuzz.token_sort_ratio(bankPayee, ynabPayee),
+    fuzz.partial_ratio(bankPayee, ynabPayee),
+    fuzz.WRatio(bankPayee, ynabPayee),
+  ];
 
-    // Mark high-confidence matches as used to prevent duplicate matching
-    if (match.confidence === 'high' && match.ynab_transaction) {
-      usedIds.add(match.ynab_transaction.id);
-    }
+  return Math.max(...scores);
+}
+
+function buildMatchReasons(scores: MatchCandidate['scores'], config: MatchingConfig): string[] {
+  const reasons: string[] = [];
+
+  if (scores.amount === 100) {
+    reasons.push('Exact amount match');
+  } else if (scores.amount >= 95) {
+    reasons.push('Amount within tolerance');
+  }
+
+  if (scores.date === 100) {
+    reasons.push('Same date');
+  } else if (scores.date >= 90) {
+    reasons.push('Date within 1-2 days');
+  } else if (scores.date >= 50) {
+    reasons.push(`Date within ${config.dateToleranceDays} days`);
   }
 
-  return matches;
+  if (scores.payee >= 95) {
+    reasons.push('Payee exact match');
+  } else if (scores.payee >= 80) {
+    reasons.push('Payee highly similar');
+  } else if (scores.payee >= 60) {
+    reasons.push('Payee somewhat similar');
+  }
+
+  return reasons;
+}
+
+export function findBestMatch(
+  bankTransaction: CanonicalBankTransaction,
+  ynabTransactions: NormalizedYNABTransaction[],
+  usedYnabIds: Set<string> = new Set<string>(),
+  config?: MatchingConfig,
+): MatchResult {
+  return matchSingle(bankTransaction, ynabTransactions, usedYnabIds, config);
 }

package/src/tools/reconciliation/recommendationEngine.ts

@@ -11,7 +11,7 @@ import type {
   BankTransaction,
   YNABTransaction,
 } from './types.js';
-import { toMoneyValueFromDecimal, fromMilli, toMilli } from '../../utils/money.js';
+import { toMoneyValue, toMoneyValueFromDecimal, fromMilli } from '../../utils/money.js';
 
 const RECOMMENDATION_VERSION = '1.0';
 
@@ -139,17 +139,17 @@ function createSuggestedMatchRecommendation(
   match: TransactionMatch,
   context: RecommendationContext,
 ): CreateTransactionRecommendation | ReviewDuplicateRecommendation | ManualReviewRecommendation {
-  const bankTxn = match.bank_transaction;
+  const bankTxn = match.bankTransaction;
 
   // If there's a suggested YNAB transaction, review as possible duplicate
-  if (match.ynab_transaction && match.confidence !== 'none') {
+  if (match.ynabTransaction && match.confidence !== 'none') {
     return {
       id: randomUUID(),
       action_type: 'review_duplicate',
       priority: 'high',
-      confidence: Math.max(0, Math.min(1, match.confidence_score / 100)),
+      confidence: Math.max(0, Math.min(1, match.confidenceScore / 100)),
       message: `Review possible match: ${bankTxn.payee}`,
-      reason: match.match_reason,
+      reason: match.matchReason,
       estimated_impact: toMoneyValueFromDecimal(
         0,
         context.analysis.balance_info.current_cleared.currency,
@@ -160,16 +160,15 @@ function createSuggestedMatchRecommendation(
         created_at: new Date().toISOString(),
       },
       parameters: {
-        candidate_ids: [match.ynab_transaction.id],
+        candidate_ids: [match.ynabTransaction.id],
         bank_transaction: bankTxn,
-        suggested_match_id: match.ynab_transaction.id,
+        suggested_match_id: match.ynabTransaction.id,
       },
     };
   }
 
   // Check for combination matches (multiple YNAB transactions that together match the bank transaction)
-  const isCombinationMatch =
-    match.match_reason === 'combination_match' || (match.candidates?.length ?? 0) > 1;
+  const isCombinationMatch = (match.candidates?.length ?? 0) > 1;
 
   if (isCombinationMatch) {
     return createCombinationReviewRecommendation(match, context);
@@ -179,7 +178,7 @@ function createSuggestedMatchRecommendation(
   const parameters: CreateTransactionRecommendation['parameters'] = {
     account_id: context.account_id,
     date: bankTxn.date,
-    amount: toMilli(bankTxn.amount), // Convert dollars to milliunits for create_transaction
+    amount: bankTxn.amount, // Amount is already milliunits
     payee_name: bankTxn.payee,
     cleared: 'cleared',
     approved: true,
@@ -196,7 +195,7 @@ function createSuggestedMatchRecommendation(
     confidence: CONFIDENCE.CREATE_EXACT_MATCH,
     message: `Create transaction for ${bankTxn.payee}`,
     reason: `This transaction exactly matches your discrepancy`,
-    estimated_impact: toMoneyValueFromDecimal(
+    estimated_impact: toMoneyValue(
       bankTxn.amount,
       context.analysis.balance_info.current_cleared.currency,
     ),
@@ -216,7 +215,7 @@ function createCombinationReviewRecommendation(
   match: TransactionMatch,
   context: RecommendationContext,
 ): ManualReviewRecommendation {
-  const bankTxn = match.bank_transaction;
+  const bankTxn = match.bankTransaction;
   const candidateIds = match.candidates?.map((candidate) => candidate.ynab_transaction.id) ?? [];
 
   // Calculate total amount from candidates for context (convert from milliunits to decimal)
@@ -247,7 +246,7 @@ function createCombinationReviewRecommendation(
     metadata: {
       version: RECOMMENDATION_VERSION,
       created_at: new Date().toISOString(),
-      bank_transaction_amount: toMoneyValueFromDecimal(
+      bank_transaction_amount: toMoneyValue(
         bankTxn.amount,
         context.analysis.balance_info.current_cleared.currency,
       ),
@@ -269,8 +268,8 @@ function createCombinationReviewRecommendation(
           source: 'ynab' as const,
           id,
           description:
-            match.candidates?.find((c) => c.ynab_transaction.id === id)?.ynab_transaction
-              .payee_name ?? 'Unknown',
+            match.candidates?.find((c) => c.ynab_transaction.id === id)?.ynab_transaction.payee ??
+            'Unknown',
         })),
       ],
     },
@@ -388,7 +387,12 @@ function processUnmatchedTransactions(context: RecommendationContext): Actionabl
   }
 
   // Suggested matches → review as potential duplicates or auto-match
-  for (const match of context.analysis.suggested_matches) {
+  const matchesForReview = [
+    ...context.analysis.suggested_matches,
+    ...context.analysis.auto_matches,
+  ];
+
+  for (const match of matchesForReview) {
     recommendations.push(createSuggestedMatchRecommendation(match, context));
   }
 
@@ -420,7 +424,7 @@ function createUnmatchedBankRecommendation(
   const parameters: CreateTransactionRecommendation['parameters'] = {
     account_id: context.account_id,
     date: txn.date,
-    amount: toMilli(txn.amount), // Convert dollars to milliunits for create_transaction
+    amount: txn.amount, // Amount is already milliunits
     payee_name: txn.payee,
     cleared: 'cleared',
     approved: true,
@@ -437,7 +441,7 @@ function createUnmatchedBankRecommendation(
     confidence: CONFIDENCE.UNMATCHED_BANK,
     message: `Create missing transaction: ${txn.payee}`,
     reason: 'Transaction appears on bank statement but not in YNAB',
-    estimated_impact: toMoneyValueFromDecimal(
+    estimated_impact: toMoneyValue(
       txn.amount,
       context.analysis.balance_info.current_cleared.currency,
     ),
@@ -471,7 +475,7 @@ function createUpdateClearedRecommendation(
     action_type: 'update_cleared',
     priority: 'low',
     confidence: CONFIDENCE.UPDATE_CLEARED,
-    message: `Mark transaction as cleared: ${txn.payee_name || 'Unknown'}`,
+    message: `Mark transaction as cleared: ${txn.payee || 'Unknown'}`,
     reason: 'Transaction exists in YNAB but not yet cleared',
     estimated_impact: toMoneyValueFromDecimal(
       0,