@dizzlkheinz/ynab-mcpb 0.17.0 → 0.18.0

package/.code/agents/3134/exec-call_IgCAMGx19lWfuo8zfYIt5FFC.txt

@@ -1,416 +0,0 @@
-src\types\reconciliation.ts:4: * AMOUNTS ARE IN MILLIUNITS (integers, 1000 = $1.00).
-src\types\reconciliation.ts:12:  /** Amount in MILLIUNITS (negative = outflow, positive = inflow) */
-src\types\reconciliation.ts:36: * AMOUNTS ARE IN MILLIUNITS - same as YNAB API native format.
-src\types\reconciliation.ts:42:  /** Amount in MILLIUNITS (same as YNAB API) */
-src\__tests__\workflows.e2e.test.ts:825:    it('should convert amounts between dollars and milliunits', async () => {
-src\__tests__\workflows.e2e.test.ts:828:      // Convert dollars to milliunits
-src\__tests__\workflows.e2e.test.ts:829:      const toMilliunitsResult = await executeToolCall(server, 'ynab:convert_amount', {
-src\__tests__\workflows.e2e.test.ts:831:        to_milliunits: true,
-src\__tests__\workflows.e2e.test.ts:833:      const milliunits = parseToolResult(toMilliunitsResult);
-src\__tests__\workflows.e2e.test.ts:835:      expect(milliunits.data?.conversion?.converted_amount).toBe(25500);
-src\__tests__\workflows.e2e.test.ts:836:      expect(milliunits.data?.conversion?.description).toContain('25500');
-src\__tests__\workflows.e2e.test.ts:837:      expect(milliunits.data?.conversion?.to_milliunits).toBe(true);
-src\__tests__\workflows.e2e.test.ts:839:      // Convert milliunits to dollars
-src\__tests__\workflows.e2e.test.ts:842:        to_milliunits: false,
-src\__tests__\workflows.e2e.test.ts:848:      expect(dollars.data?.conversion?.to_milliunits).toBe(false);
-src\__tests__\workflows.e2e.test.ts:1146:          { name: 'ynab:convert_amount', args: { amount: 100, to_milliunits: true } },
-src\__tests__\workflows.e2e.test.ts:1629:        to_milliunits: true,
-src\server\prompts.ts:154:4. Create the transaction with the correct amount in milliunits (multiply by 1000)
-src\server\prompts.ts:233:Convert milliunits to dollars for easy reading.`,
-src\__tests__\performance.test.ts:629:          to_milliunits: true,
-src\__tests__\performance.test.ts:718:          executeToolCall(server, 'ynab:convert_amount', { amount: i * 10, to_milliunits: true }),
-src\__tests__\comprehensive.integration.test.ts:53:      convertMilliUnitsToCurrencyAmount: vi.fn(
-src\__tests__\comprehensive.integration.test.ts:54:        (milliunits: number, currencyDecimalDigits: number = 2) => {
-src\__tests__\comprehensive.integration.test.ts:55:          const amount = milliunits / 1000;
-src\__tests__\comprehensive.integration.test.ts:59:      convertCurrencyAmountToMilliUnits: vi.fn((amount: number) => Math.round(amount * 1000)),
-src\__tests__\comprehensive.integration.test.ts:68:    'converts milliunits using SDK rounding rules',
-src\__tests__\comprehensive.integration.test.ts:73:      expect(utils.convertMilliUnitsToCurrencyAmount(123456, 2)).toBe(123.46);
-src\__tests__\comprehensive.integration.test.ts:74:      expect(utils.convertMilliUnitsToCurrencyAmount(123456, 3)).toBe(123.456);
-src\__tests__\comprehensive.integration.test.ts:75:      expect(utils.convertMilliUnitsToCurrencyAmount(-98765, 2)).toBe(-98.77);
-src\__tests__\comprehensive.integration.test.ts:756:        // Test dollar to milliunits conversion
-src\__tests__\comprehensive.integration.test.ts:757:        const toMilliunitsResult = await executeToolCall(server, 'ynab:convert_amount', {
-src\__tests__\comprehensive.integration.test.ts:759:          to_milliunits: true,
-src\__tests__\comprehensive.integration.test.ts:761:        validateToolResult(toMilliunitsResult);
-src\__tests__\comprehensive.integration.test.ts:763:        const toMilli = parseToolResult(toMilliunitsResult);
-src\__tests__\comprehensive.integration.test.ts:765:        expect(toMilli.data.conversion.description).toBe('$25.75 = 25750 milliunits');
-src\__tests__\comprehensive.integration.test.ts:767:        // Test milliunits to dollar conversion
-src\__tests__\comprehensive.integration.test.ts:770:          to_milliunits: false,
-src\__tests__\comprehensive.integration.test.ts:776:        expect(dollars.data.conversion.description).toBe('25750 milliunits = $25.75');
-src\tools\monthTools.ts:6:import { milliunitsToAmount } from '../utils/amountUtils.js';
-src\tools\monthTools.ts:69:                income: milliunitsToAmount(month.income),
-src\tools\monthTools.ts:70:                budgeted: milliunitsToAmount(month.budgeted),
-src\tools\monthTools.ts:71:                activity: milliunitsToAmount(month.activity),
-src\tools\monthTools.ts:72:                to_be_budgeted: milliunitsToAmount(month.to_be_budgeted),
-src\tools\monthTools.ts:83:                  budgeted: milliunitsToAmount(category.budgeted),
-src\tools\monthTools.ts:84:                  activity: milliunitsToAmount(category.activity),
-src\tools\monthTools.ts:85:                  balance: milliunitsToAmount(category.balance),
-src\tools\monthTools.ts:151:                income: milliunitsToAmount(month.income),
-src\tools\monthTools.ts:152:                budgeted: milliunitsToAmount(month.budgeted),
-src\tools\monthTools.ts:153:                activity: milliunitsToAmount(month.activity),
-src\tools\monthTools.ts:154:                to_be_budgeted: milliunitsToAmount(month.to_be_budgeted),
-src\tools\toolCategories.ts:123:   * - convert_amount: Converts between dollars and milliunits
-src\__tests__\testRunner.ts:349:- Milliunits handling
-src\__tests__\tools\reconciliation\csvParser.integration.test.ts:18:      expect(result.transactions[0].amount).toBe(-45230); // Milliunits!
-src\__tests__\tools\reconciliation\csvParser.integration.test.ts:34:      expect(result.transactions[0].amount).toBe(-45230); // Debit = negative milliunits
-src\__tests__\tools\reconciliation\csvParser.integration.test.ts:35:      expect(result.transactions[1].amount).toBe(500000); // Credit = positive milliunits
-src\__tests__\tools\reconciliation\csvParser.integration.test.ts:59:      expect(result.transactions[0].amount).toBe(1234560); // 1234.56 in milliunits
-src\__tests__\tools\reconciliation\csvParser.integration.test.ts:94:    // Shell: exact amount match (both -45230 milliunits)
-src\__tests__\tools\reconciliation\csvParser.integration.test.ts:98:    // Amazon: exact amount match (both -127990 milliunits)
-src\__tests__\tools\reconciliation\csvParser.integration.test.ts:108:      amount: -45230, // Integer milliunits
-src\__tests__\tools\reconciliation\csvParser.integration.test.ts:117:      amount: -45230, // Integer milliunits - direct from YNAB API
-src\tools\accountTools.ts:6:import { milliunitsToAmount } from '../utils/amountUtils.js';
-src\tools\accountTools.ts:108:                balance: milliunitsToAmount(account.balance),
-src\tools\accountTools.ts:109:                cleared_balance: milliunitsToAmount(account.cleared_balance),
-src\tools\accountTools.ts:110:                uncleared_balance: milliunitsToAmount(account.uncleared_balance),
-src\tools\accountTools.ts:172:                balance: milliunitsToAmount(account.balance),
-src\tools\accountTools.ts:173:                cleared_balance: milliunitsToAmount(account.cleared_balance),
-src\tools\accountTools.ts:174:                uncleared_balance: milliunitsToAmount(account.uncleared_balance),
-src\tools\accountTools.ts:242:        balance: params.balance ? params.balance * 1000 : 0, // Convert to milliunits
-src\tools\accountTools.ts:273:                balance: milliunitsToAmount(account.balance),
-src\tools\accountTools.ts:274:                cleared_balance: milliunitsToAmount(account.cleared_balance),
-src\tools\accountTools.ts:275:                uncleared_balance: milliunitsToAmount(account.uncleared_balance),
-src\tools\compareTransactions\types.ts:11:  /** Transaction amount in milliunits (YNAB format) */
-src\tools\compareTransactions\types.ts:31:  /** Transaction amount in milliunits */
-src\__tests__\testUtils.ts:362:   * Generate test amounts in milliunits
-src\tools\compareTransactions\parser.ts:47: * Convert dollar amount to milliunits
-src\tools\compareTransactions\parser.ts:49:export function amountToMilliunits(amountStr: string): Milli {
-src\tools\compareTransactions\parser.ts:482:        amount = amountToMilliunits(rawAmount);
-src\tools\reconciliation\csvParser.ts:193: * IMPORTANT: Amounts are converted to MILLIUNITS (integers) at this boundary.
-src\tools\reconciliation\csvParser.ts:194: * This is the ONLY place where float-to-milliunit conversion happens.
-src\tools\reconciliation\csvParser.ts:364:    let amountMilliunits: number;
-src\tools\reconciliation\csvParser.ts:369:      amountMilliunits = dollarStringToMilliunits(rawAmount);
-src\tools\reconciliation\csvParser.ts:375:      const debitMilliunits = dollarStringToMilliunits(debit);
-src\tools\reconciliation\csvParser.ts:376:      const creditMilliunits = dollarStringToMilliunits(credit);
-src\tools\reconciliation\csvParser.ts:379:      if (Math.abs(debitMilliunits) > 0 && Math.abs(creditMilliunits) > 0) {
-src\tools\reconciliation\csvParser.ts:385:      if (Math.abs(debitMilliunits) > 0) {
-src\tools\reconciliation\csvParser.ts:386:        amountMilliunits = -Math.abs(debitMilliunits); // Debits are outflows (negative)
-src\tools\reconciliation\csvParser.ts:387:      } else if (Math.abs(creditMilliunits) > 0) {
-src\tools\reconciliation\csvParser.ts:388:        amountMilliunits = Math.abs(creditMilliunits); // Credits are inflows (positive)
-src\tools\reconciliation\csvParser.ts:390:        amountMilliunits = 0;
-src\tools\reconciliation\csvParser.ts:394:      if (debitMilliunits < 0) {
-src\tools\reconciliation\csvParser.ts:403:    if (!Number.isFinite(amountMilliunits)) {
-src\tools\reconciliation\csvParser.ts:415:    amountMilliunits *= multiplier;
-src\tools\reconciliation\csvParser.ts:423:      amount: amountMilliunits,
-src\tools\reconciliation\csvParser.ts:555:function dollarStringToMilliunits(str: string): number {
-src\tools\reconciliation\csvParser.ts:578:  // Convert to milliunits: $1.00 → 1000
-src\tools\categoryTools.ts:6:import { milliunitsToAmount } from '../utils/amountUtils.js';
-src\tools\categoryTools.ts:44:    budgeted: z.number().int('Budgeted amount must be an integer in milliunits'),
-src\tools\categoryTools.ts:52: * Convert goal-related monetary fields from milliunits to dollars.
-src\tools\categoryTools.ts:58:      category.goal_target != null ? milliunitsToAmount(category.goal_target) : undefined,
-src\tools\categoryTools.ts:61:        ? milliunitsToAmount(category.goal_under_funded)
-src\tools\categoryTools.ts:65:        ? milliunitsToAmount(category.goal_overall_funded)
-src\tools\categoryTools.ts:69:        ? milliunitsToAmount(category.goal_overall_left)
-src\tools\categoryTools.ts:113:          budgeted: milliunitsToAmount(category.budgeted),
-src\tools\categoryTools.ts:114:          activity: milliunitsToAmount(category.activity),
-src\tools\categoryTools.ts:115:          balance: milliunitsToAmount(category.balance),
-src\tools\categoryTools.ts:191:                budgeted: milliunitsToAmount(category.budgeted),
-src\tools\categoryTools.ts:192:                activity: milliunitsToAmount(category.activity),
-src\tools\categoryTools.ts:193:                balance: milliunitsToAmount(category.balance),
-src\tools\categoryTools.ts:253:                budgeted: milliunitsToAmount(params.budgeted),
-src\tools\categoryTools.ts:320:              budgeted: milliunitsToAmount(category.budgeted),
-src\tools\categoryTools.ts:321:              activity: milliunitsToAmount(category.activity),
-src\tools\categoryTools.ts:322:              balance: milliunitsToAmount(category.balance),
-src\tools\reconciliation\analyzer.ts:5: * V2 UPDATE: Uses new parser and matcher (milliunits based)
-src\tools\reconciliation\analyzer.ts:48:    const amount = txn.amount / 1000; // Convert from milliunits to dollars
-src\tools\reconciliation\index.ts:170:        amountToleranceMilliunits: (params.amount_tolerance_cents ?? 1) * 10,
-src\tools\reconcileAdapter.ts:44:  bank_statement_balance_milliunits: number;
-src\tools\reconcileAdapter.ts:45:  ynab_calculated_balance_milliunits: number;
-src\tools\reconcileAdapter.ts:46:  discrepancy_milliunits: number;
-src\tools\reconcileAdapter.ts:54:  amount_milliunits: number;
-src\tools\reconcileAdapter.ts:123:  const discrepancyMilli = analysis.balance_info.discrepancy.value_milliunits;
-src\tools\reconcileAdapter.ts:148:  bank_statement_balance: toMoneyValue(precision.bank_statement_balance_milliunits, currency),
-src\tools\reconcileAdapter.ts:149:  ynab_calculated_balance: toMoneyValue(precision.ynab_calculated_balance_milliunits, currency),
-src\tools\reconcileAdapter.ts:150:  discrepancy: toMoneyValue(precision.discrepancy_milliunits, currency),
-src\tools\reconcileAdapter.ts:165:    amount: toMoneyValue(cause.amount_milliunits, currency),
-src\tools\reconciliation\executor.ts:14:  balance: number; // milliunits
-src\tools\reconciliation\executor.ts:15:  cleared_balance: number; // milliunits
-src\tools\reconciliation\executor.ts:16:  uncleared_balance: number; // milliunits
-src\tools\reconciliation\executor.ts:782:    bank_statement_balance_milliunits: bankMilli,
-src\tools\reconciliation\executor.ts:783:    ynab_calculated_balance_milliunits: ynabMilli,
-src\tools\reconciliation\executor.ts:784:    discrepancy_milliunits: discrepancy,
-src\tools\reconciliation\executor.ts:857:    amount_milliunits: number;
-src\tools\reconciliation\executor.ts:868:      amount_milliunits: discrepancyMilli,
-src\tools\reconciliation\executor.ts:957:    'value_milliunits' in value &&
-src\tools\reconciliation\executor.ts:958:    typeof (value as { value_milliunits: unknown }).value_milliunits === 'number'
-src\tools\reconciliation\executor.ts:960:    return (value as { value_milliunits: number }).value_milliunits;
-src\utils\money.ts:4:export type Milli = number; // integer milliunits (no bigint)
-src\utils\money.ts:9:  value_milliunits: Milli;
-src\utils\money.ts:45: * Convert milliunits to currency amount using proper decimal digits
-src\utils\money.ts:47: * @param m - Milliunits value
-src\utils\money.ts:51:  return ynab.utils.convertMilliUnitsToCurrencyAmount(m, decimalDigits);
-src\utils\money.ts:54:export const assertMilli = (m: number, msg = 'Expected safe integer milliunits') => {
-src\utils\money.ts:60:  if (!Number.isSafeInteger(s)) throw new Error('Milliunit sum overflow');
-src\utils\money.ts:84: * Format milliunits as currency string with proper decimal digits
-src\utils\money.ts:85: * @param value - Milliunits value
-src\utils\money.ts:96: * Convert milliunits to MoneyValue with proper currency format
-src\utils\money.ts:97: * @param value - Milliunits value
-src\utils\money.ts:106:  value_milliunits: value,
-src\tools\reconciliation\recommendationEngine.ts:182:    amount: toMilli(bankTxn.amount), // Convert dollars to milliunits for create_transaction
-src\tools\reconciliation\recommendationEngine.ts:222:  // Calculate total amount from candidates for context (convert from milliunits to decimal)
-src\tools\reconciliation\recommendationEngine.ts:428:    amount: toMilli(txn.amount), // Convert dollars to milliunits for create_transaction
-src\tools\reconciliation\reportFormatter.ts:93:  const discrepancyMilli = balanceInfo.discrepancy.value_milliunits;
-src\tools\reconciliation\reportFormatter.ts:352:      const amount = txn.amount / 1000; // Convert milliunits to dollars
-src\tools\reconciliation\types.ts:37:  /** Amount in milliunits */
-src\tools\reconciliation\types.ts:175:  // Tolerances (in MILLIUNITS for amount)
-src\tools\reconciliation\types.ts:176:  amountToleranceMilliunits: number; // Default: 10 (1 cent)
-src\tools\transactionTools.ts:10:import { amountToMilliunits, milliunitsToAmount } from '../utils/amountUtils.js';
-src\tools\transactionTools.ts:173:    amount: z.number().int('Amount must be an integer in milliunits'),
-src\tools\transactionTools.ts:188:            amount: z.number().int('Subtransaction amount must be an integer in milliunits'),
-src\tools\transactionTools.ts:626:    amount: z.number().int('Amount must be an integer in milliunits').optional(),
-src\tools\transactionTools.ts:651:    amount: z.number().int('Amount must be an integer in milliunits').optional(),
-src\tools\transactionTools.ts:808:                  amount: milliunitsToAmount(transaction.amount),
-src\tools\transactionTools.ts:832:                amount: milliunitsToAmount(transaction.amount),
-src\tools\transactionTools.ts:906:              amount: milliunitsToAmount(transaction.amount),
-src\tools\transactionTools.ts:979:      amount: params.amount, // Already validated as integer milliunits
-src\tools\transactionTools.ts:1047:              amount: milliunitsToAmount(transaction.amount),
-src\tools\transactionTools.ts:1066:                amount: milliunitsToAmount(subtransaction.amount),
-src\tools\transactionTools.ts:1089:  subtotal_milliunits: number;
-src\tools\transactionTools.ts:1090:  tax_milliunits: number;
-src\tools\transactionTools.ts:1093:    amount_milliunits: number;
-src\tools\transactionTools.ts:1123:  subtotalMilliunits: number,
-src\tools\transactionTools.ts:1124:  totalTaxMilliunits: number,
-src\tools\transactionTools.ts:1127:  if (totalTaxMilliunits === 0) {
-src\tools\transactionTools.ts:1128:    for (const category of categories) category.tax_milliunits = 0;
-src\tools\transactionTools.ts:1132:  if (subtotalMilliunits <= 0) {
-src\tools\transactionTools.ts:1139:      category.tax_milliunits = totalTaxMilliunits - allocated;
-src\tools\transactionTools.ts:1142:        (totalTaxMilliunits * category.subtotal_milliunits) / subtotalMilliunits,
-src\tools\transactionTools.ts:1144:      category.tax_milliunits = proportionalTax;
-src\tools\transactionTools.ts:1176:      amount_milliunits: amountToMilliunits(item.amount),
-src\tools\transactionTools.ts:1180:    const subtotalMilliunits = items.reduce((sum, item) => sum + item.amount_milliunits, 0);
-src\tools\transactionTools.ts:1184:      subtotal_milliunits: subtotalMilliunits,
-src\tools\transactionTools.ts:1185:      tax_milliunits: 0,
-src\tools\transactionTools.ts:1190:  const subtotalMilliunits = categoryCalculations.reduce(
-src\tools\transactionTools.ts:1191:    (sum, category) => sum + category.subtotal_milliunits,
-src\tools\transactionTools.ts:1195:  const declaredSubtotalMilliunits =
-src\tools\transactionTools.ts:1196:    params.receipt_subtotal !== undefined ? amountToMilliunits(params.receipt_subtotal) : undefined;
-src\tools\transactionTools.ts:1198:    declaredSubtotalMilliunits !== undefined &&
-src\tools\transactionTools.ts:1199:    Math.abs(declaredSubtotalMilliunits - subtotalMilliunits) > 1
-src\tools\transactionTools.ts:1202:      `Categorized items subtotal (${milliunitsToAmount(subtotalMilliunits)}) does not match receipt subtotal (${milliunitsToAmount(declaredSubtotalMilliunits)})`,
-src\tools\transactionTools.ts:1206:  const taxMilliunits = amountToMilliunits(params.receipt_tax);
-src\tools\transactionTools.ts:1207:  const totalMilliunits = amountToMilliunits(params.receipt_total);
-src\tools\transactionTools.ts:1208:  const computedTotal = subtotalMilliunits + taxMilliunits;
-src\tools\transactionTools.ts:1209:  if (Math.abs(computedTotal - totalMilliunits) > 1) {
-src\tools\transactionTools.ts:1211:      `Receipt total (${milliunitsToAmount(totalMilliunits)}) does not equal subtotal plus tax (${milliunitsToAmount(computedTotal)})`,
-src\tools\transactionTools.ts:1215:  distributeTaxProportionally(subtotalMilliunits, taxMilliunits, categoryCalculations);
-src\tools\transactionTools.ts:1221:        amount: -item.amount_milliunits,
-src\tools\transactionTools.ts:1229:      category.tax_milliunits > 0
-src\tools\transactionTools.ts:1232:              amount: -category.tax_milliunits,
-src\tools\transactionTools.ts:1243:    subtotal: milliunitsToAmount(subtotalMilliunits),
-src\tools\transactionTools.ts:1244:    tax: milliunitsToAmount(taxMilliunits),
-src\tools\transactionTools.ts:1245:    total: milliunitsToAmount(totalMilliunits),
-src\tools\transactionTools.ts:1252:        amount: milliunitsToAmount(item.amount_milliunits),
-src\tools\transactionTools.ts:1255:      subtotal: milliunitsToAmount(category.subtotal_milliunits),
-src\tools\transactionTools.ts:1256:      tax: milliunitsToAmount(category.tax_milliunits),
-src\tools\transactionTools.ts:1257:      total: milliunitsToAmount(category.subtotal_milliunits + category.tax_milliunits),
-src\tools\transactionTools.ts:1273:              amount: milliunitsToAmount(totalMilliunits),
-src\tools\transactionTools.ts:1278:              amount: milliunitsToAmount(-subtransaction.amount),
-src\tools\transactionTools.ts:1291:    amount: -totalMilliunits,
-src\tools\transactionTools.ts:1494:              amount: milliunitsToAmount(transaction.amount),
-src\tools\transactionTools.ts:1733:          amount: milliunitsToAmount(transaction.amount),
-src\tools\transactionTools.ts:1751:                  total_amount: milliunitsToAmount(totalAmount),
-src\tools\transactionTools.ts:2132:            before['amount'] = milliunitsToAmount(currentState.amount);
-src\tools\transactionTools.ts:2133:            after['amount'] = milliunitsToAmount(transaction.amount);
-src\tools\utilityTools.ts:13:    to_milliunits: z.boolean(),
-src\tools\utilityTools.ts:49: * Converts between dollars and milliunits with integer arithmetic for precision
-src\tools\utilityTools.ts:54:      const { amount, to_milliunits } = params;
-src\tools\utilityTools.ts:59:      if (to_milliunits) {
-src\tools\utilityTools.ts:60:        // Convert from dollars to milliunits
-src\tools\utilityTools.ts:63:        description = `$${amount.toFixed(2)} = ${result} milliunits`;
-src\tools\utilityTools.ts:65:        // Convert from milliunits to dollars
-src\tools\utilityTools.ts:66:        // Assume input amount is in milliunits
-src\tools\utilityTools.ts:68:        description = `${amount} milliunits = $${result.toFixed(2)}`;
-src\tools\utilityTools.ts:79:                to_milliunits,
-src\tools\reconciliation\__tests__\adapter.causes.test.ts:59:      bank_statement_balance_milliunits: -921240,
-src\tools\reconciliation\__tests__\adapter.causes.test.ts:60:      ynab_calculated_balance_milliunits: -899020,
-src\tools\reconciliation\__tests__\adapter.causes.test.ts:61:      discrepancy_milliunits: -22220,
-src\tools\reconciliation\__tests__\adapter.causes.test.ts:72:          amount_milliunits: -1500,
-src\tools\reconciliation\__tests__\adapter.causes.test.ts:80:          amount_milliunits: 500,
-src\tools\reconciliation\__tests__\adapter.test.ts:9:  value_milliunits: Math.round(value * 1000),
-src\tools\reconciliation\__tests__\adapter.test.ts:149:    expect(structured.matches.auto[0].bank_transaction.amount_money.value_milliunits).toBe(-45230);
-src\tools\reconciliation\__tests__\adapter.test.ts:183:          bank_statement_balance_milliunits: -921240,
-src\tools\reconciliation\__tests__\adapter.test.ts:184:          ynab_calculated_balance_milliunits: -899020,
-src\tools\reconciliation\__tests__\adapter.test.ts:185:          discrepancy_milliunits: -22220,
-src\tools\reconciliation\__tests__\adapter.test.ts:195:              amount_milliunits: 22220,
-src\tools\reconciliation\__tests__\adapter.test.ts:224:    expect(structured.execution.account_balance.after.cleared_balance.value_milliunits).toBe(
-src\tools\reconciliation\matcher.ts:4: * V2 matcher works natively in milliunits using canonical BankTransaction
-src\tools\reconciliation\matcher.ts:50:  amountToleranceMilliunits: 10, // 1 cent
-src\tools\reconciliation\matcher.ts:67:    amountToleranceMilliunits:
-src\tools\reconciliation\matcher.ts:68:      config.amountToleranceMilliunits ?? DEFAULT_CONFIG.amountToleranceMilliunits,
-src\tools\reconciliation\matcher.ts:293:    if (amountDiff > config.amountToleranceMilliunits) {
-src\tools\reconciliation\matcher.ts:338:  // Amount score - now using INTEGER comparison (milliunits)
-src\tools\reconciliation\matcher.ts:345:  } else if (amountDiff <= config.amountToleranceMilliunits) {
-src\tools\reconciliation\__tests__\analyzer.test.ts:24:            amount: -45230, // milliunits
-src\tools\reconciliation\__tests__\analyzer.test.ts:33:            amount: -100000, // milliunits
-src\tools\reconciliation\ynabAdapter.ts:10: * NOTE: Amount stays in milliunits - no conversion needed since
-src\tools\reconciliation\ynabAdapter.ts:11: * YNAB API already uses milliunits natively.
-src\tools\reconciliation\ynabAdapter.ts:17:    amount: txn.amount, // Already in milliunits - no conversion!
-src\server\YNABMCPServer.ts:901:      description: 'Convert between dollars and milliunits with integer arithmetic for precision',
-src\utils\amountUtils.ts:2: * Utility functions for converting between YNAB milliunits and dollars
-src\utils\amountUtils.ts:6: * Converts an amount from milliunits to dollars
-src\utils\amountUtils.ts:7: * @param milliunits - Amount in milliunits (1000 milliunits = $1.00)
-src\utils\amountUtils.ts:10:export function milliunitsToAmount(milliunits: number): number {
-src\utils\amountUtils.ts:11:  return Math.round(milliunits) / 1000;
-src\utils\amountUtils.ts:15: * Converts an amount from dollars to milliunits
-src\utils\amountUtils.ts:17: * @returns Amount in milliunits
-src\utils\amountUtils.ts:19:export function amountToMilliunits(amount: number): number {
-src\utils\amountUtils.ts:24: * Formats an amount from milliunits to a currency string
-src\utils\amountUtils.ts:25: * @param milliunits - Amount in milliunits
-src\utils\amountUtils.ts:29:export function formatAmount(milliunits: number, currencySymbol = '$'): string {
-src\utils\amountUtils.ts:30:  const amount = milliunitsToAmount(milliunits);
-src\tools\reconciliation\__tests__\recommendationEngine.test.ts:260:        expect(rec.parameters.amount).toBe(-75500); // In milliunits
-src\tools\reconciliation\__tests__\recommendationEngine.test.ts:458:        expect(rec.parameters.amount).toBe(-45000); // In milliunits
-src\tools\reconciliation\__tests__\recommendationEngine.test.ts:548:        expect(rec.parameters.amount).toBe(-123450); // In milliunits
-src\tools\reconciliation\__tests__\recommendationEngine.test.ts:569:        expect(rec.parameters.amount).toBe(500000); // In milliunits
-src\tools\reconciliation\__tests__\recommendationEngine.test.ts:594:        expect(rec.parameters.amount).toBe(-99990); // In milliunits
-src\tools\reconciliation\__tests__\recommendationEngine.test.ts:610:        expect(rec.parameters.amount).toBe(0); // Zero in milliunits is still zero
-src\tools\reconciliation\__tests__\recommendationEngine.test.ts:921:        expect(rec.parameters.amount).toBe(-10); // In milliunits (0.01 * 1000)
-src\tools\reconciliation\__tests__\recommendationEngine.test.ts:937:        expect(rec.parameters.amount).toBe(-999999990); // In milliunits
-src\tools\reconciliation\__tests__\recommendationEngine.integration.test.ts:17:  amount: number, // in milliunits
-src\tools\reconciliation\__tests__\recommendationEngine.integration.test.ts:87:          expect(rec.parameters.amount).toBe(22220); // In milliunits
-src\tools\reconciliation\__tests__\recommendationEngine.integration.test.ts:141:        expect(evoCarShareRec!.parameters.amount).toBe(22220); // In milliunits
-src\tools\reconciliation\__tests__\recommendationEngine.integration.test.ts:552:            // 500 dollars in milliunits
-src\tools\reconciliation\__tests__\recommendationEngine.integration.test.ts:651:        expect(createRec!.parameters.amount).toBe(25500); // In milliunits
-src\tools\reconciliation\__tests__\matcher.test.ts:15:      amountToleranceMilliunits: 10,
-src\tools\reconciliation\__tests__\matcher.test.ts:41:            amount: -45230, // milliunits
-src\tools\reconciliation\__tests__\matcher.test.ts:339:        config.amountToleranceMilliunits = 10; // 1 cent
-src\tools\reconciliation\__tests__\matcher.test.ts:532:        amountToleranceMilliunits: 100, // 10 cents
-src\tools\reconciliation\__tests__\matcher.test.ts:626:          amount: -10, // 1 cent in milliunits
-src\tools\reconciliation\__tests__\matcher.test.ts:652:          amount: -10000000, // $10,000 in milliunits
-src\tools\reconciliation\__tests__\reportFormatter.test.ts:20:  value_milliunits: Math.round(value * 1000),
-src\tools\schemas\outputs\accountOutputs.ts:68: * Represents account data with balances in dollars (converted from YNAB milliunits).
-src\tools\__tests__\accountTools.test.ts:401:      // Verify the API was called with balance 0 in milliunits
-src\tools\__tests__\accountTools.test.ts:411:    it('should convert balance to milliunits', async () => {
-src\tools\__tests__\accountTools.test.ts:435:        balance: 150, // $150 should become 150000 milliunits
-src\tools\__tests__\accountTools.test.ts:438:      // Verify the API was called with balance converted to milliunits
-src\tools\reconciliation\__tests__\scenarios\adapterCurrency.scenario.test.ts:6:  value_milliunits: Math.round(value * 1000),
-src\tools\reconciliation\__tests__\scenarios\repeatAmount.scenario.test.ts:18:        // Three -22.22 transactions in milliunits: one will match YNAB, two will remain unmatched
-src\tools\schemas\outputs\categoryOutputs.ts:9: * goal_overall_funded, goal_overall_left) are converted from YNAB API milliunits to
-src\tools\schemas\outputs\categoryOutputs.ts:123:  /** Goal target amount in dollars (converted from YNAB API milliunits, optional) */
-src\tools\schemas\outputs\comparisonOutputs.ts:344: * IMPORTANT: `amount` is the raw YNAB amount in **milliunits** (not dollar amounts).
-src\tools\schemas\outputs\comparisonOutputs.ts:346: * For example, $25.50 is represented as 25500 milliunits.
-src\tools\schemas\outputs\comparisonOutputs.ts:352: * @see src/tools/exportTransactions.ts:204 - Amount field directly from transaction.amount (milliunits)
-src\tools\schemas\outputs\comparisonOutputs.ts:357:  amount: z.number(), // Raw YNAB milliunits
-src\tools\schemas\outputs\comparisonOutputs.ts:365:  amount: z.number(), // Raw YNAB milliunits
-src\tools\schemas\outputs\comparisonOutputs.ts:417: *     { id: "txn-1", date: "2025-11-15", amount: -25500, payee_name: "Grocery Store", cleared: "cleared" }, // amount is milliunits
-src\tools\schemas\outputs\comparisonOutputs.ts:435: *       amount: -25500, // Raw milliunits: -$25.50
-src\tools\schemas\outputs\comparisonOutputs.ts:592:      amount: z.number(), // Raw YNAB milliunits
-src\utils\__tests__\money.test.ts:19:    it('converts dollars to milliunits correctly', () => {
-src\utils\__tests__\money.test.ts:32:    it('converts milliunits with 2 decimal digits (USD) by default', () => {
-src\utils\__tests__\money.test.ts:38:    it('converts milliunits with 0 decimal digits (JPY)', () => {
-src\utils\__tests__\money.test.ts:43:    it('converts milliunits with 3 decimal digits (BHD)', () => {
-src\utils\__tests__\money.test.ts:48:    it('converts milliunits with explicit 2 decimal digits', () => {
-src\utils\__tests__\money.test.ts:61:      expect(() => assertMilli(1.5)).toThrow('Expected safe integer milliunits');
-src\utils\__tests__\money.test.ts:63:        'Expected safe integer milliunits',
-src\utils\__tests__\money.test.ts:69:    it('adds milliunits correctly', () => {
-src\utils\__tests__\money.test.ts:75:      expect(() => addMilli(Number.MAX_SAFE_INTEGER, 1)).toThrow('Milliunit sum overflow');
-src\utils\__tests__\money.test.ts:152:    it('formats milliunits into currency strings with default 2 decimals', () => {
-src\utils\__tests__\money.test.ts:157:    it('formats milliunits with custom currency format', () => {
-src\utils\__tests__\money.test.ts:163:    it('creates money values from milliunits with default 2 decimals', () => {
-src\utils\__tests__\money.test.ts:184:      expect(value.value_milliunits).toBe(-45670);
-src\tools\schemas\outputs\monthOutputs.ts:128:  /** Goal target amount in milliunits (optional) */
-src\tools\schemas\outputs\monthOutputs.ts:129:  goal_target: z.number().optional().describe('Goal target in milliunits'),
-src\server\__tests__\prompts.test.ts:173:          expect(text).toContain('Create the transaction with the correct amount in milliunits');
-src\server\__tests__\prompts.test.ts:251:          expect(text).toContain('Convert milliunits to dollars');
-src\tools\schemas\outputs\transactionMutationOutputs.ts:17: *     account_balance: 1500000, // Raw milliunits: $1,500.00
-src\tools\schemas\outputs\transactionMutationOutputs.ts:18: *     account_cleared_balance: 1000000 // Raw milliunits: $1,000.00
-src\tools\schemas\outputs\transactionMutationOutputs.ts:77: * IMPORTANT: `account_balance` and `account_cleared_balance` are **raw YNAB milliunits** (not user-facing dollar amounts).
-src\tools\schemas\outputs\transactionMutationOutputs.ts:79: * For example, $1,250.50 is represented as 1250500 milliunits.
-src\tools\schemas\outputs\transactionMutationOutputs.ts:85:  account_balance: z.number().optional(), // Raw YNAB milliunits
-src\tools\schemas\outputs\transactionMutationOutputs.ts:86:  account_cleared_balance: z.number().optional(), // Raw YNAB milliunits
-src\tools\schemas\outputs\transactionMutationOutputs.ts:258: *     account_balance: 1500000, // Raw milliunits: $1,500.00
-src\tools\schemas\outputs\transactionMutationOutputs.ts:259: *     account_cleared_balance: 1000000 // Raw milliunits: $1,000.00
-src\tools\schemas\outputs\transactionMutationOutputs.ts:392: *   updated_balance: 1450000, // Raw milliunits: $1,450.00
-src\tools\schemas\outputs\transactionMutationOutputs.ts:393: *   updated_cleared_balance: 950000 // Raw milliunits: $950.00
-src\tools\schemas\outputs\transactionMutationOutputs.ts:412:    updated_balance: z.number(), // Raw YNAB milliunits
-src\tools\schemas\outputs\transactionMutationOutputs.ts:413:    updated_cleared_balance: z.number(), // Raw YNAB milliunits
-src\tools\schemas\outputs\transactionMutationOutputs.ts:529:    updated_balance: z.number(), // Raw YNAB milliunits
-src\tools\schemas\outputs\transactionMutationOutputs.ts:530:    updated_cleared_balance: z.number(), // Raw YNAB milliunits
-src\tools\schemas\outputs\transactionOutputs.ts:98: * Represents full transaction data with amounts in dollars (converted from YNAB milliunits).
-src\tools\schemas\outputs\utilityOutputs.ts:56: * Contains the conversion result between dollars and YNAB milliunits.
-src\tools\schemas\outputs\utilityOutputs.ts:61:  to_milliunits: z.boolean(),
-src\tools\schemas\outputs\utilityOutputs.ts:68: * Converts between dollars and YNAB milliunits (1 dollar = 1000 milliunits).
-src\tools\schemas\outputs\utilityOutputs.ts:78: *     to_milliunits: true,
-src\tools\schemas\outputs\utilityOutputs.ts:79: *     description: "$25.50 converted to 25500 milliunits"
-src\tools\__tests__\categoryTools.integration.test.ts:133:        console.warn(`   - Budgeted: ${category.budgeted} milliunits`);
-src\tools\__tests__\categoryTools.integration.test.ts:134:        console.warn(`   - Activity: ${category.activity} milliunits`);
-src\tools\__tests__\categoryTools.integration.test.ts:135:        console.warn(`   - Balance: ${category.balance} milliunits`);
-src\tools\__tests__\categoryTools.integration.test.ts:170:        // Update with a test amount (add 1000 milliunits = $1.00)
-src\tools\__tests__\categoryTools.integration.test.ts:204:        console.warn(`✅ Successfully updated category budget to ${testBudgetedAmount} milliunits`);
-src\tools\__tests__\categoryTools.integration.test.ts:214:        console.warn(`✅ Restored original budget amount: ${originalBudgetedAmount} milliunits`);
-src\tools\__tests__\categoryTools.integration.test.ts:281:          `✅ Successfully set negative budget amount: ${negativeBudgetedAmount} milliunits`,
-src\tools\__tests__\categoryTools.integration.test.ts:291:        console.warn(`✅ Restored original budget amount: ${originalBudgetedAmount} milliunits`);
-src\tools\schemas\outputs\__tests__\comparisonOutputs.test.ts:403:          amount: -25500, // Milliunits
-src\tools\schemas\outputs\__tests__\comparisonOutputs.test.ts:436:          amount: -15000, // Milliunits: -$15.00
-src\tools\__tests__\compareTransactions\parser.test.ts:7:  amountToMilliunits,
-src\tools\__tests__\compareTransactions\parser.test.ts:78:  describe('amountToMilliunits', () => {
-src\tools\__tests__\compareTransactions\parser.test.ts:80:      expect(amountToMilliunits('123.45')).toBe(123450);
-src\tools\__tests__\compareTransactions\parser.test.ts:84:      expect(amountToMilliunits('-123.45')).toBe(-123450);
-src\tools\__tests__\compareTransactions\parser.test.ts:88:      expect(amountToMilliunits('(123.45)')).toBe(-123450);
-src\tools\__tests__\compareTransactions\parser.test.ts:92:      expect(amountToMilliunits('$123.45')).toBe(123450);
-src\tools\__tests__\compareTransactions\parser.test.ts:96:      expect(amountToMilliunits('1,234.56')).toBe(1234560);
-src\tools\__tests__\compareTransactions\parser.test.ts:100:      expect(amountToMilliunits('+123.45')).toBe(123450);
-src\tools\__tests__\compareTransactions\parser.test.ts:104:      expect(amountToMilliunits('0.00')).toBe(0);
-src\tools\__tests__\compareTransactions\parser.test.ts:108:      expect(amountToMilliunits('  123.45  ')).toBe(123450);
-src\tools\__tests__\compareTransactions\parser.test.ts:112:      expect(amountToMilliunits('999999.99')).toBe(999999990);
-src\tools\__tests__\utilityTools.test.ts:85:    it('should convert dollars to milliunits correctly', async () => {
-src\tools\__tests__\utilityTools.test.ts:86:      const params = { amount: 10.5, to_milliunits: true };
-src\tools\__tests__\utilityTools.test.ts:93:      expect(response.conversion.to_milliunits).toBe(true);
-src\tools\__tests__\utilityTools.test.ts:94:      expect(response.conversion.description).toBe('$10.50 = 10500 milliunits');
-src\tools\__tests__\utilityTools.test.ts:97:    it('should convert milliunits to dollars correctly', async () => {
-src\tools\__tests__\utilityTools.test.ts:98:      const params = { amount: 10500, to_milliunits: false };
-src\tools\__tests__\utilityTools.test.ts:105:      expect(response.conversion.to_milliunits).toBe(false);
-src\tools\__tests__\utilityTools.test.ts:106:      expect(response.conversion.description).toBe('10500 milliunits = $10.50');
-src\tools\__tests__\utilityTools.test.ts:110:      const params = { amount: 0, to_milliunits: true };
-src\tools\__tests__\utilityTools.test.ts:117:      expect(response.conversion.description).toBe('$0.00 = 0 milliunits');
-src\tools\__tests__\utilityTools.test.ts:121:      const params = { amount: -5.25, to_milliunits: true };
-src\tools\__tests__\utilityTools.test.ts:128:      expect(response.conversion.description).toBe('$-5.25 = -5250 milliunits');
-src\tools\__tests__\utilityTools.test.ts:132:      const params = { amount: 0.01, to_milliunits: true };
-src\tools\__tests__\utilityTools.test.ts:141:      const params = { amount: 999999.99, to_milliunits: true };
-src\tools\__tests__\utilityTools.test.ts:149:    it('should round to nearest milliunit when converting from dollars', async () => {
-src\tools\__tests__\utilityTools.test.ts:150:      const params = { amount: 10.5555, to_milliunits: true };
-src\tools\__tests__\utilityTools.test.ts:161:      const validParams = { amount: 10.5, to_milliunits: true };
-src\tools\__tests__\utilityTools.test.ts:171:      const invalidParams = { amount: Infinity, to_milliunits: true };
-src\tools\__tests__\utilityTools.test.ts:178:      const invalidParams = { amount: NaN, to_milliunits: true };
-src\tools\__tests__\utilityTools.test.ts:185:      const invalidParams = { to_milliunits: true };
-src\tools\__tests__\utilityTools.test.ts:191:    it('should reject missing to_milliunits parameter', () => {
-src\tools\__tests__\utilityTools.test.ts:198:    it('should reject non-boolean to_milliunits parameter', () => {
-src\tools\__tests__\utilityTools.test.ts:199:      const invalidParams = { amount: 10.5, to_milliunits: 'true' };
-src\tools\__tests__\compareTransactions.test.ts:78:        amount: 100000, // $100.00 in milliunits
-src\tools\__tests__\compareTransactions.test.ts:90:        amount: -50000, // -$50.00 in milliunits
-src\tools\__tests__\transactionTools.test.ts:136:      amount: -50000, // $50.00 outflow in milliunits
-src\tools\__tests__\transactionTools.test.ts:558:        amount: -50000, // $50.00 outflow in milliunits
-src\tools\__tests__\transactionTools.test.ts:618:        expect(result.error.issues[0].message).toContain('Amount must be an integer in milliunits');
-src\tools\__tests__\transactionTools.test.ts:1456:        expect(result.error.issues[0].message).toContain('Amount must be an integer in milliunits');
-src\tools\__tests__\transactionTools.test.ts:1881:    it('should require integer milliunit amounts', () => {
-src\tools\__tests__\transactionTools.test.ts:2704:    it('should require integer milliunit amounts when provided', () => {
-src\tools\__tests__\utilityTools.integration.test.ts:47:      'should convert various dollar amounts to milliunits',
-src\tools\__tests__\utilityTools.integration.test.ts:51:          { dollars: 1.0, expectedMilliunits: 1000 },
-src\tools\__tests__\utilityTools.integration.test.ts:52:          { dollars: 0.01, expectedMilliunits: 10 },
-src\tools\__tests__\utilityTools.integration.test.ts:53:          { dollars: 10.5, expectedMilliunits: 10500 },
-src\tools\__tests__\utilityTools.integration.test.ts:54:          { dollars: 999.99, expectedMilliunits: 999990 },
-src\tools\__tests__\utilityTools.integration.test.ts:55:          { dollars: 0, expectedMilliunits: 0 },
-src\tools\__tests__\utilityTools.integration.test.ts:56:          { dollars: -5.25, expectedMilliunits: -5250 },
-src\tools\__tests__\utilityTools.integration.test.ts:62:            to_milliunits: true,
-src\tools\__tests__\utilityTools.integration.test.ts:66:          expect(response.conversion.converted_amount).toBe(testCase.expectedMilliunits);
-src\tools\__tests__\utilityTools.integration.test.ts:67:          expect(response.conversion.to_milliunits).toBe(true);
-src\tools\__tests__\utilityTools.integration.test.ts:70:            `${testCase.expectedMilliunits} milliunits`,
-src\tools\__tests__\utilityTools.integration.test.ts:77:      'should convert various milliunit amounts to dollars',
-src\tools\__tests__\utilityTools.integration.test.ts:81:          { milliunits: 1000, expectedDollars: 1.0 },
-src\tools\__tests__\utilityTools.integration.test.ts:82:          { milliunits: 10, expectedDollars: 0.01 },
-src\tools\__tests__\utilityTools.integration.test.ts:83:          { milliunits: 10500, expectedDollars: 10.5 },
-src\tools\__tests__\utilityTools.integration.test.ts:84:          { milliunits: 999990, expectedDollars: 999.99 },
-src\tools\__tests__\utilityTools.integration.test.ts:85:          { milliunits: 0, expectedDollars: 0 },
-src\tools\__tests__\utilityTools.integration.test.ts:86:          { milliunits: -5250, expectedDollars: -5.25 },
-src\tools\__tests__\utilityTools.integration.test.ts:91:            amount: testCase.milliunits,
-src\tools\__tests__\utilityTools.integration.test.ts:92:            to_milliunits: false,
-src\tools\__tests__\utilityTools.integration.test.ts:97:          expect(response.conversion.to_milliunits).toBe(false);
-src\tools\__tests__\utilityTools.integration.test.ts:98:          expect(response.conversion.description).toContain(`${testCase.milliunits} milliunits`);
-src\tools\__tests__\utilityTools.integration.test.ts:112:          { amount: 0.1 + 0.2, to_milliunits: true }, // Should handle 0.30000000000000004
-src\tools\__tests__\utilityTools.integration.test.ts:113:          { amount: 1.005, to_milliunits: true }, // Should round correctly
-src\tools\__tests__\utilityTools.integration.test.ts:114:          { amount: 999.999, to_milliunits: true }, // Should handle near-integer values
-src\tools\__tests__\monthTools.integration.test.ts:63:        console.warn(`   - Income: ${firstMonth.income} milliunits`);
-src\tools\__tests__\monthTools.integration.test.ts:64:        console.warn(`   - Budgeted: ${firstMonth.budgeted} milliunits`);
-src\tools\__tests__\monthTools.integration.test.ts:126:        console.warn(`   - Income: ${month.income} milliunits`);
-src\tools\__tests__\monthTools.integration.test.ts:127:        console.warn(`   - Budgeted: ${month.budgeted} milliunits`);
-src\tools\__tests__\monthTools.integration.test.ts:128:        console.warn(`   - Activity: ${month.activity} milliunits`);
-src\tools\__tests__\monthTools.integration.test.ts:129:        console.warn(`   - To be budgeted: ${month.to_be_budgeted} milliunits`);