@dizzlkheinz/ynab-mcpb 0.12.2 → 0.15.0

package/.code/agents/292aa3ff-dbab-470f-97c9-e7e8fd65e0db/result.txt

@@ -0,0 +1,144 @@
+Note: I’m running in a read‑only sandbox with no escalation, so I can’t execute `node "$HOME/.codex/superpowers/.codex/superpowers-codex" bootstrap` here; you’ll need to run that manually outside this environment.
+
+Below is a concrete implementation plan for the next iteration, focused on tightening type safety for mutation dry‑run outputs and exercising them via tests. Tasks are sized to ~2–5 minutes each and follow a TDD flow.
+
+**Iteration Theme**
+
+- Strengthen type safety for transaction mutation dry‑run responses by replacing `z.record(z.string(), z.unknown())` with strongly‑typed request schemas, and ensure handlers + tests are aligned.
+
+---
+
+**Phase 0 – Context & Scoping**
+
+- Skim `SCHEMA_IMPROVEMENT_SUMMARY.md` again to align with the existing discriminated‑union pattern used for reconciliation outputs.
+- Review current output schemas in `src/tools/schemas/outputs/transactionMutationOutputs.ts` (dry‑run branches for `CreateTransactionOutputSchema`, `UpdateTransactionOutputSchema`, `DeleteTransactionOutputSchema`).
+- Review corresponding handlers in `src/tools/transactionTools.ts` (dry‑run branches in `handleCreateTransaction`, `handleUpdateTransaction`, `handleDeleteTransaction`).
+- Review existing tests touching these areas:
+  - Schema tests: `src/tools/schemas/outputs/__tests__/transactionMutationSchemas.test.ts`
+  - Tool unit tests: `src/tools/__tests__/transactionTools.test.ts`
+  - E2E transaction workflow: `src/__tests__/workflows.e2e.test.ts`
+
+---
+
+**Phase 1 – TDD for New Dry‑Run Request Schemas (Schemas Layer)**
+
+1. In `src/tools/schemas/outputs/transactionMutationOutputs.ts`, identify the three dry‑run `request` fields that still use `z.record(z.string(), z.unknown())`.
+2. Design target request shapes:
+   - `CreateTransactionDryRunRequestSchema`: mirror `CreateTransactionSchema` from `src/tools/transactionTools.ts` but omit `budget_id` and `dry_run`, and keep only fields that actually affect the YNAB API call (`account_id`, `amount`, `date`, `payee_*`, `category_id`, `memo`, `cleared`, `approved`, `flag_color`, `import_id`, `subtransactions`).
+   - `UpdateTransactionDryRunRequestSchema`: mirror `UpdateTransactionSchema` but omit `budget_id`, `dry_run`; keep `transaction_id` plus the updatable fields (`account_id`, `amount`, `date`, `payee_*`, `category_id`, `memo`, `cleared`, `approved`, `flag_color`).
+   - `DeleteTransactionDryRunRequestSchema`: mirror `DeleteTransactionSchema` but omit `budget_id`, `dry_run`; keep `transaction_id`.
+3. In `src/tools/schemas/outputs/__tests__/transactionMutationSchemas.test.ts`, add new `describe` blocks (or extend existing ones) for:
+   - `CreateTransactionOutputSchema` dry‑run branch:
+     - Accepts a `request` object matching `CreateTransactionDryRunRequestSchema` (no `budget_id`, no `dry_run`).
+     - Rejects payloads where `request` is missing required fields (e.g., no `account_id`, no `date`, or missing `amount`).
+     - Rejects payloads where `request` includes obviously wrong shapes (e.g., non‑ISO `date`), using schema’s existing validation.
+   - `UpdateTransactionOutputSchema` dry‑run branch:
+     - Accepts minimal valid request (`transaction_id` only) and one with optional fields.
+     - Rejects requests missing `transaction_id`.
+   - `DeleteTransactionOutputSchema` dry‑run branch:
+     - Accepts `{ transaction_id: '...' }` and no extra required fields.
+     - Rejects requests missing `transaction_id`.
+4. Add negative tests in the same file asserting that generic `z.record`‑style payloads (e.g., arbitrary key/value maps or requests including `budget_id`, `dry_run`) are rejected by the new schemas.
+5. Run only the schema tests to see them fail initially:
+   - `npm run test:unit -- src/tools/schemas/outputs/__tests__/transactionMutationSchemas.test.ts`
+
+---
+
+**Phase 2 – Implement Strongly‑Typed Dry‑Run Request Schemas**
+
+6. In `src/tools/schemas/outputs/transactionMutationOutputs.ts`, define:
+   - `CreateTransactionDryRunRequestSchema` using `z.object({ ... })` or `CreateTransactionSchema.omit({ budget_id: true, dry_run: true })` (import `CreateTransactionSchema` if you prefer reuse).
+   - `UpdateTransactionDryRunRequestSchema` similarly from `UpdateTransactionSchema` or a dedicated `z.object`.
+   - `DeleteTransactionDryRunRequestSchema` similarly from `DeleteTransactionSchema`.
+   - Export TypeScript types using `z.infer<...>` for each new schema.
+7. Replace the dry‑run `request` fields:
+   - `CreateTransactionOutputSchema` dry‑run branch: `request: CreateTransactionDryRunRequestSchema`.
+   - `UpdateTransactionOutputSchema` dry‑run branch: `request: UpdateTransactionDryRunRequestSchema`.
+   - `DeleteTransactionOutputSchema` dry‑run branch: `request: DeleteTransactionDryRunRequestSchema`.
+8. Ensure unions remain backward compatible:
+   - Keep the non‑dry‑run branches unchanged.
+   - Preserve `.passthrough()` where it’s used for forward‑compatible metadata.
+9. Re‑run the schema tests:
+   - `npm run test:unit -- src/tools/schemas/outputs/__tests__/transactionMutationSchemas.test.ts`
+   - Fix any mismatches between tests and actual schema shapes until green.
+
+---
+
+**Phase 3 – TDD for Handler Output Shape Changes (Tools Layer)**
+
+10. In `src/tools/__tests__/transactionTools.test.ts`, locate the `handleCreateTransaction` dry‑run test (`should not invalidate cache on dry_run transaction creation`).
+11. Update that test so it asserts:
+    - `parsedContent.dry_run === true` and `parsedContent.action === 'create_transaction'`.
+    - `parsedContent.request`:
+      - Does not include `budget_id` or `dry_run`.
+      - Contains only the transaction fields expected by `CreateTransactionDryRunRequestSchema`.
+12. Add a new unit test for `handleUpdateTransaction` dry‑run behavior:
+    - Call `handleUpdateTransaction(mockYnabAPI, { budget_id, transaction_id, amount, dry_run: true })`.
+    - Assert:
+      - No API calls are made.
+      - Parsed JSON has `dry_run: true`, `action: 'update_transaction'`.
+      - `request` includes `transaction_id` and any optional fields you passed, but not `budget_id` or `dry_run`.
+13. Add a complementary unit test for `handleDeleteTransaction` dry‑run behavior:
+    - Call `handleDeleteTransaction(mockYnabAPI, { budget_id, transaction_id, dry_run: true })`.
+    - Assert:
+      - No API calls are made.
+      - Parsed JSON has `dry_run: true`, `action: 'delete_transaction'`.
+      - `request` is `{ transaction_id: '...' }` only.
+14. Run only the transaction tool unit tests to see failures before implementation:
+    - `npm run test:unit -- src/tools/__tests__/transactionTools.test.ts`
+
+---
+
+**Phase 4 – Implement Handler Changes to Match New Schemas**
+
+15. In `src/tools/transactionTools.ts`, update the dry‑run branch of `handleCreateTransaction`:
+    - Instead of `request: params`, construct a new object that:
+      - Copies only transaction‑related fields: `account_id`, `amount`, `date`, `payee_*`, `category_id`, `memo`, `cleared`, `approved`, `flag_color`, `import_id`, `subtransactions`.
+      - Excludes `budget_id` and `dry_run`.
+    - Ensure this object’s shape matches `CreateTransactionDryRunRequestSchema`.
+16. Update the dry‑run branch of `handleUpdateTransaction`:
+    - Build `request` containing `transaction_id` plus any provided update fields (`account_id`, `amount`, `date`, etc.).
+    - Exclude `budget_id` and `dry_run` from the `request` object.
+17. Update the dry‑run branch of `handleDeleteTransaction`:
+    - Set `request: { transaction_id: params.transaction_id }` (and nothing else).
+18. Re‑run the relevant unit tests:
+    - `npm run test:unit -- src/tools/__tests__/transactionTools.test.ts`
+    - Iterate until the dry‑run shape tests pass.
+
+---
+
+**Phase 5 – Integration & E2E Validation**
+
+19. In `src/tools/__tests__/transactionTools.integration.test.ts`, optionally add a focused integration test (if not already covered) that:
+    - Calls each of the three handlers in dry‑run mode with realistic params.
+    - Parses the output and asserts it validates against `CreateTransactionOutputSchema`, `UpdateTransactionOutputSchema`, `DeleteTransactionOutputSchema` using the shared validation helper (if available).
+20. In `src/__tests__/workflows.e2e.test.ts`, add a small E2E segment under “Complete Transaction Management Workflow” that:
+    - Calls `ynab:create_transaction` with `dry_run: true`.
+    - Uses `validateOutputSchema(server, 'create_transaction', result)` and asserts `valid === true`.
+    - Asserts the `data` payload contains the new, typed `request` shape (no `budget_id` / `dry_run` in `request`).
+21. Run narrower test suites first:
+    - `npm run test:unit`
+    - `npm run test:integration`
+22. When green, run the full test suite + build to ensure no regressions:
+    - `npm test`
+    - `npm run lint`
+    - `npm run build`
+    - Optionally: `npm run build:prod` and `npm run package:mcpb` if this will cut a new release.
+
+---
+
+**Phase 6 – Documentation & Release Hygiene**
+
+23. Update any internal docs referencing dry‑run shapes:
+    - Check `docs/reference/API.md` and any tool‑specific docs for transaction mutation tools; adjust examples so `request` shows the new, typed payloads.
+24. In `CHANGELOG.md`, add an entry for the next patch version (e.g., `0.13.5`) summarizing:
+    - “Improve transaction mutation dry‑run output typing for create/update/delete_transaction tools; no breaking changes to success payloads.”
+25. Run quick formatting checks:
+    - `npm run format:check`
+    - `npm run lint` (again if needed).
+26. If everything is green, prepare the PR:
+    - Ensure `TESTING_NOTES.md` / `.pr-description.md` mention:
+      - Tests run (`npm run test:unit`, `npm run test:integration`, `npm test`, `npm run build`).
+      - That changes are backward‑compatible for non‑dry‑run responses and tool contracts.
+
+If you’d like, I can next draft the actual Zod schema snippets and handler code for these changes so you can drop them into the repo.

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

@@ -0,0 +1,416 @@
+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`);