e-arveldaja-mcp 0.36.0 → 0.37.0

package/.claude/commands/classify-unmatched.md

@@ -76,7 +76,15 @@ Show the compact `result.summary`: `counts` (unmatched transactions, groups, aut
 
 ### Step 2: Explain what can be applied and choose the groups
 
-Rows that may pay an open invoice never reach the groups: a possible invoice match, a residual on a partially paid purchase invoice, or a document-reference candidate (exact amount plus the purchase invoice's number or `Ostukorvi/tellimuse nr:` order/cart number in the description). The purchase invoice already exists, so booking such a row here would double the expense: reconcile it with the **Reconcile Bank** workflow (`reconcile_bank_transactions` `mode: "suggest"` lists it), and drop any such transaction ID a user asks to add. Apply re-checks and skips it ("matches an open purchase invoice; skipped — reconcile instead").
+Rows that may pay an open invoice never reach the groups: a possible invoice match, a residual on a partially paid purchase invoice, or a document-reference candidate (exact amount plus the purchase invoice's number or `Ostukorvi/tellimuse nr:` order/cart number in the description). They are listed, never dropped: <!-- E_ARVELDAJA_CAPABILITY_CONDITION_START:standard -->
+Capability condition for `standard`: inspect the connected MCP server's advertised tool list before this section. Run this section only when every named tool is advertised: `list_account_dimensions`. Otherwise skip this section and continue with the surrounding workflow. Never call a missing tool to probe capability.
+
+`result.invoice_matched` gives each row's transaction id, amount, date, the invoice (`invoice_type`, `invoice_id`, `invoice_number`) and what matched (`matched_by`, `matched_reference` or `match_reasons`)
+<!-- E_ARVELDAJA_CAPABILITY_CONDITION_END:standard --><!-- E_ARVELDAJA_CAPABILITY_CONDITION_START:guided -->
+Capability condition for `guided`: inspect the connected MCP server's advertised tool list before this section. Run this section only when every named tool is advertised: `classify_bank_transactions`, and none of these is advertised: `list_account_dimensions`. Otherwise skip this section and continue with the surrounding workflow. Never call a missing tool to probe capability.
+
+the `invoice_matched` count and warning in `result.summary` name each row and its invoice
+<!-- E_ARVELDAJA_CAPABILITY_CONDITION_END:guided -->. The invoice already exists, so booking such a row here would double the expense: reconcile it with the **Reconcile Bank** workflow (`reconcile_bank_transactions` `mode: "suggest"` lists it), and drop any such transaction ID a user asks to add. Apply re-checks and skips it ("matches an open purchase invoice; skipped — reconcile instead").
 
 Rows the ledger check took out of the groups are never applied here; report each with its `next_action`:
 <!-- E_ARVELDAJA_CAPABILITY_CONDITION_START:standard -->
@@ -95,6 +103,7 @@ Capability condition for `guided`: inspect the connected MCP server's advertised
 <!-- E_ARVELDAJA_CAPABILITY_CONDITION_END:guided -->
 
 - `apply_mode="purchase_invoice"` groups are auto-bookable
+- `apply_mode="account_distribution"` groups are auto-bookable from booking history: every earlier confirmed row of this counterparty (at least two, matched by its client, IBAN or legal form) went straight to one account and dimension with no invoice. Apply confirms each row to that account with its own amount, setting the row's client first when it has none. Show the proposed account, dimension and the evidence (`suggested_booking.transaction_history.history_total` and `last_journal_ids`, or the `history_distribution` warning) on the approval card. Apply re-derives the booking from the fresh ledger, so a history that changed since the dry run is `plan_drift`
 - review-only categories are reported back as skipped
 <!-- E_ARVELDAJA_CAPABILITY_CONDITION_START:guided -->
 Capability condition for `guided`: inspect the connected MCP server's advertised tool list before this section. Run this section only when every named tool is advertised: `classify_bank_transactions`, and none of these is advertised: `list_account_dimensions`. Otherwise skip this section and continue with the surrounding workflow. Never call a missing tool to probe capability.

package/.claude/commands/import-wise.md

@@ -110,7 +110,7 @@ The compact preview returns a `summary`: `summary.counts` (CSV rows, eligible, f
 <!-- E_ARVELDAJA_CAPABILITY_CONDITION_START:standard -->
 Capability condition for `standard`: inspect the connected MCP server's advertised tool list before this section. Run this section only when every named tool is advertised: `import_wise_transactions`. Otherwise skip this section and continue with the surrounding workflow. Never call a missing tool to probe capability.
 
-The dry run returns top-level `plan_handle` and `approved_command_digest`, a `summary` (`total_csv_rows`, `eligible`, `filtered_out`, `created` = would-create, `skipped`, `error_count`, `inter_account_total`, `needs_review`, `blocking_review_count` = the reviews that block approval; every review but `wise_transfer_ownership_unverified` blocks), `ownership_reviews` (transfers that could not be auto-verified as own-account transfers; never dropped), `transfer_counterpart_unresolved` (only when transfer rows are held: `message`, `unresolved_row_count`, `conflict_row_count`, `candidates[]` with `accounts_dimensions_id` + `label`; the per-row reviews are in `ownership_reviews` with `counterpart_candidate_dimension_ids` and, for a conflict, `evidence_transaction_ids`), `inter_account_reconciliation`, advisory `invoice_currency_fixes`, and `skipped_details`: skipped rows grouped by reason, each group with `count` and up to 5 `sample_ids`; for already-booked rows the ledger id is replaced in the reason by `journal (see records)` / `transaction (see records)` and the group's `records` lists every row's `wise_id` + `record_id`. In a dry run, `execution.skipped` itemises only skips that are not already-booked rows (unsupported directions, dependency skips); `execution.skipped_omitted_already_booked` counts the rest, which are in `skipped_details`. Transfers already booked by a journal are not commands: the dry run lists them in `execution.already_journalized_rows` (`wise_id`, `existing_journal_id`, date, amount, currency, direction; count in `execution.already_journalized_count`, of which `execution.already_journalized_auto_matched_count` are legacy transfers matched automatically). `execution.commands` and `command_count` cover only commands that write. An executed run keeps every write command and every skipped row itemised; the already-journalized re-check results are in `inter_account_reconciliation.details`, after the confirmed transfers.
+The dry run returns top-level `plan_handle` and `approved_command_digest`, a `summary` (`total_csv_rows`, `eligible`, `filtered_out`, `created` = would-create, `skipped`, `error_count`, `inter_account_total`, `needs_review`, `blocking_review_count` = the reviews that block approval; every review but `wise_transfer_ownership_unverified` blocks), `ownership_reviews` (transfers that could not be auto-verified as own-account transfers; never dropped), `transfer_counterpart_unresolved` (only when transfer rows are held: `message`, `unresolved_row_count`, `conflict_row_count`, `candidates[]` with `accounts_dimensions_id` + `label`; the per-row reviews are in `ownership_reviews` with `counterpart_candidate_dimension_ids` and, for a conflict, `evidence_transaction_ids`), `inter_account_reconciliation`, advisory `invoice_currency_fixes`, and `skipped_details`: skipped rows grouped by reason, each group with `count` and up to 5 `sample_ids`; for already-booked rows the ledger id is replaced in the reason by `journal (see records)` / `transaction (see records)` and the group's `records` lists every row's `wise_id` + `record_id`. In a dry run, `execution.skipped` itemises only skips that are not already-booked rows (unsupported directions, dependency skips); `execution.skipped_omitted_already_booked` counts the rest, which are in `skipped_details`. Transfers already booked by a journal are not commands: the dry run lists them in `execution.already_journalized_rows` (`wise_id`, `existing_journal_id`, date, amount, currency, direction; count in `execution.already_journalized_count`, of which `execution.already_journalized_auto_matched_count` are legacy transfers matched automatically). `execution.commands` and `command_count` cover only commands that write. An executed run keeps every write command and every skipped row itemised; the already-journalized re-check results are in `inter_account_reconciliation.details`, after the confirmed transfers. A row booked as an ordinary payment (not an own transfer) carries the client whose normalized name equals its counterparty name, ignoring case (CAMT's exact-name rule; a partial name match is not used): `clients_id`, `client_match`, also in its `create_payload`; a row several clients match exactly has `client_ambiguous` and a `client_note`, is created without a client and needs one (`clients_id`) before it can be confirmed.
 <!-- E_ARVELDAJA_CAPABILITY_CONDITION_END:standard -->
 
 Show main transactions and fee rows that would be created, exact duplicate / skip reasons, whether fees will be auto-confirmed to the chosen dimension, inter-account transfer confirmations or skips, and advisory invoice FX corrections (reported only — the import never changes confirmed purchase invoices).

package/.claude/commands/reconcile-bank.md

@@ -80,7 +80,7 @@ Capability condition for `standard`: inspect the connected MCP server's advertis
 Capability condition for `guided`: inspect the connected MCP server's advertised tool list before this section. Run this section only when every named tool is advertised: `reconcile_bank_transactions`, and none of these is advertised: `confirm_transaction`. Otherwise skip this section and continue with the surrounding workflow. Never call a missing tool to probe capability.
 
 `document_reference_candidate` warnings
-<!-- E_ARVELDAJA_CAPABILITY_CONDITION_END:guided -->): the exact amount plus the purchase invoice's number or its `Ostukorvi/tellimuse nr:` order/cart number in the bank description, scored below the threshold. They are NOT unmatched rows and are never auto-confirmed: show each one (transaction, invoice, matched reference) and ask the owner whether it is that invoice's payment.<!-- E_ARVELDAJA_CAPABILITY_CONDITION_START:standard -->
+<!-- E_ARVELDAJA_CAPABILITY_CONDITION_END:guided -->): a match whose bank description carries the exact-amount purchase invoice's number or its `Ostukorvi/tellimuse nr:` order/cart number gets the `document_reference` reason and ranks above amount/name-only candidates, capped at confidence 85, so it is never auto-confirmed — ask before confirming it. A document-reference invoice that another candidate outranked is listed in this group. They are NOT unmatched rows and are never auto-confirmed: show each one (transaction, invoice, matched reference) and ask the owner whether it is that invoice's payment.<!-- E_ARVELDAJA_CAPABILITY_CONDITION_START:standard -->
 Capability condition for `standard`: inspect the connected MCP server's advertised tool list before this section. Run this section only when every named tool is advertised: `confirm_transaction`. Otherwise skip this section and continue with the surrounding workflow. Never call a missing tool to probe capability.
 
  If approved, call `confirm_transaction` with `distributions: [{ related_table: "purchase_invoices", related_id: <invoice.id>, amount: <open balance> }]` (no `distribution` key is provided; check a partially paid invoice's open balance first).
@@ -258,7 +258,7 @@ Review the results:
 Capability condition for `standard`: inspect the connected MCP server's advertised tool list before this section. Run this section only when every named tool is advertised: `confirm_transaction`. Otherwise skip this section and continue with the surrounding workflow. Never call a missing tool to probe capability.
 
 - Treat `result.execution.summary` as the canonical source for counts, and use `result.pairs`, `result.one_sided`, `result.already_handled`, and `result.ambiguous_pairs` for the detailed breakdown.
-- `already_handled`: a journal already books the transfer. Rows WITHOUT `mirror_proposal` are only listed for the owner: they are not proven mirrors, so never offer to delete them. Propose deleting a row only when it carries `mirror_proposal` (it is then the sole candidate): show its `evidence`, `journal_id` and `counterpart_transaction_id`, and delete it through its `next_action` (`delete_transaction`) only after the owner explicitly approves that row
+- `already_handled`: a journal already books the transfer. Rows WITHOUT `mirror_proposal` are only listed for the owner: they are not proven mirrors, so never offer to delete them. Propose deleting a row only when it carries `mirror_proposal` (it is then the sole candidate): show its `evidence`, `journal_id` and `counterpart_transaction_id`, and delete it through its `next_action` (`delete_transaction`) only after the owner explicitly approves that row, or, once the owner approves all of them, re-run the dry run with `delete_proposed_mirrors: true` to put their deletions in the plan
 - `one_sided`: would confirm against the other bank account
 - `pairs`: would confirm the outgoing side and delete the duplicate incoming `PROJECT` (draft/unconfirmed) row (`incoming_action: "would_delete_duplicate"`)
 - `result.execution.errors`: any confirmation failures or other blocking issues
@@ -267,7 +267,7 @@ Capability condition for `standard`: inspect the connected MCP server's advertis
 Capability condition for `guided`: inspect the connected MCP server's advertised tool list before this section. Run this section only when every named tool is advertised: `reconcile_bank_transactions`, and none of these is advertised: `confirm_transaction`. Otherwise skip this section and continue with the surrounding workflow. Never call a missing tool to probe capability.
 
 - `summary.counts` gives the pairs, one-sided confirms, already-handled rows (`duplicates`), proposed mirror deletions (`proposed_mirrors`), and transfers needing review; `summary.samples`, `summary.warnings`, and `summary.blockers` carry the detail. Warnings show at most 3 rows per category; when a category has more, a `<category>_more` warning reports how many are not shown, and when the response size limit trims further a `warnings_truncated` warning counts the dropped rows per code: tell the owner those counts and never present the shown rows as the complete list.
-- Already-handled rows are only listed. A `mirror_proposal` warning names a row that is the sole proven mirror of a journal-booked transfer; deleting it needs the `standard` or `full` profile (`EARVELDAJA_PROFILE`) and the owner's explicit approval. Never offer to delete an already-handled row that has no mirror proposal.
+- Already-handled rows are only listed. A `mirror_proposal` warning names a row that is the sole proven mirror of a journal-booked transfer; to delete them, re-run the dry run with `delete_proposed_mirrors: true` (the summary's `next_action` says so when the plan is otherwise empty), review `proposed_mirror_deletes`, and execute with the same argument only after the owner's explicit approval; execute deletes only rows still matching the reviewed row and journal. Never offer to delete an already-handled row that has no mirror proposal.
 - `summary.next_action` is the ready-to-send execute call (`mode: "execute_inter_account"` with the `plan_handle` and the dry run's `max_date_gap` / `target_accounts_dimensions_id`); run it only after approval.
 <!-- E_ARVELDAJA_CAPABILITY_CONDITION_END:guided -->
 - Ambiguous transfers (including `direction_unresolved`) are never auto-confirmed — present them for a decision.

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ## [Unreleased]
 
+## [0.37.0] - 2026-10-30
+
+### Fixed
+
+- **A bank payment that names an invoice's order or cart number is now suggested for that invoice, even when another invoice has the same amount.** Before, two same-amount ticket payments were both suggested for the older ticket and the right invoice was hidden. Details: reconcile suggest adds the match reason `document_reference` when the description carries an exact-amount purchase invoice's number or its notes order/cart reference, raising confidence by 30 and capping it at 85 (a document reference alone never reaches the 90 auto-confirm threshold; the auto-confirm path is unchanged); `document_reference_candidates` also lists such an invoice when a different invoice won the row. Suggest now re-reads the transaction and invoice lists instead of using the short list cache, so changes made elsewhere (web UI, another client) are seen — three extra list reads per suggest.
+- **Wise payments to someone already in your client list now get that client, so they can be confirmed.** Before, a transfer to the owner imported as an ordinary payment had no client and confirming it failed with "buyer or supplier is missing". Details: the Wise import sets `clients_id` on payment rows and transfers treated as payments only on an exact (case-insensitive) name match, using the CAMT name rule (`selectClientByName`, shared); a partial name match leaves the client empty; several exact matches leave it empty with a note. The client is part of the reviewed import plan.
+- **The Wise dry run now reports how many own-account transfers it will book.** Details: the dry-run summary `inter_account_total` counts the planned `inter_account` commands (it showed 0 before execute).
+- **The guided profile can now delete the duplicate half of a transfer between your own accounts after you approve it.** Before, guided showed these rows but could not remove them. Details: `reconcile_bank_transactions` / `reconcile_inter_account_transfers` take opt-in `delete_proposed_mirrors: true` on the dry run; the deletions become plan commands run after all confirms, bound into the plan fingerprint (resend the flag at execute); before each delete the row, its confirmed counterpart and the booking journal are re-read, and any change stops that delete with nothing written.
+- **The guided invoice booking can now book a ticket that names both the seller and the carrier, once you choose the supplier.** Before, a Tpilet ticket (seller T grupp, carrier Tulisilm) could only be booked on the standard profile. Details: on a booking-binding prepare, an explicit `supplier_client_id` whose registry code (digits) or VAT number equals one of the document's printed supplier identifiers turns `supplier_identifier_ambiguous` into the warning `supplier_identifier_acknowledged`, recorded in `booking_review`; the company's own identifiers never acknowledge, and the blocker stays when they cannot be read; create re-reads the client and refuses with `plan_drift` if its identifier changed.
+
+### Added
+
+- **Classification proposes the account a counterparty has always been booked to, and you can apply it with one approval.** Details: when at least two earlier confirmed payments of the same client (or IBAN / legal form — never a name alone), in the same direction, were all booked to one account and dimension with no invoice links, the group gets apply mode `account_distribution` with the evidence (count, journal ids); apply runs only through `dry_run_apply` → `execute_apply`, re-derives the booking from the fresh ledger (a change is `plan_drift`, nothing written), sets the client first and confirms with `related_sub_id`. Mixed history stays review-only and shows the split; own bank accounts, foreign currency, saved rules and statutory categories are excluded.
+- **Classification now lists the payments it leaves out because they may pay an open invoice.** Details: new `invoice_matched` section (invoice, matched reference or score) counted in `total_partitioned_out`, a guided warning, and accounting-inbox follow-ups pointing to reconcile.
+- **The guided accounting report can force a fresh read.** Details: `run_accounting_report` takes `fresh: true`, clearing the active connection's cached data before computing.
+
 ## [0.36.0] - 2026-10-30
 
 ### Fixed

package/dist/banking/reconciliation/executor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../../src/banking/reconciliation/executor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAqB7D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AAmE5E,OAAO,KAAK,EAEV,qBAAqB,EACrB,0BAA0B,EAC1B,iBAAiB,EAGjB,mBAAmB,EAGnB,qBAAqB,EACrB,0BAA0B,EAC1B,iBAAiB,EACjB,uBAAuB,EACvB,mBAAmB,EAInB,yBAAyB,EAOzB,mBAAmB,EACpB,MAAM,YAAY,CAAC;AAkBpB,eAAO,MAAM,+BAA+B,KAAK,CAAC;AAUlD,MAAM,MAAM,YAAY,GACpB;IAAE,IAAI,EAAE,sBAAsB,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACnE;IAAE,IAAI,EAAE,kBAAkB,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAC/D;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAE9D,MAAM,MAAM,eAAe,CAAC,CAAC,IACzB;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAA;CAAE,GACvC;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAA;CAAE,CAAC;AAE3D;;;;GAIG;AACH,qBAAa,kCAAmC,SAAQ,KAAK;IAC/C,QAAQ,CAAC,OAAO,EAAE,YAAY;IAA1C,YAAqB,OAAO,EAAE,YAAY,EAGzC;CACF;AAYD,wDAAwD;AACxD,eAAO,MAAM,8BAA8B,KAAK,CAAC;AAEjD,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,UAAU,EACf,KAAK,EAAE,mBAAmB,GACzB,OAAO,CAAC,yBAAyB,CAAC,CAkOpC;AAoYD,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,UAAU,EACf,oBAAoB,EAAE,oBAAoB,EAC1C,KAAK,EAAE,iBAAiB,GACvB,OAAO,CAAC,mBAAmB,CAAC,CAI9B;AAED,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,UAAU,EACf,oBAAoB,EAAE,oBAAoB,EAC1C,KAAK,EAAE,0BAA0B,GAChC,OAAO,CAAC,eAAe,CAAC,qBAAqB,CAAC,CAAC,CA0BjD;AAID,wBAAsB,uBAAuB,CAC3C,GAAG,EAAE,UAAU,EACf,KAAK,EAAE,iBAAiB,EACxB,IAAI,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GACzB,OAAO,CAAC,uBAAuB,CAAC,CAw5BlC;AAuBD,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,UAAU,EACf,oBAAoB,EAAE,oBAAoB,EAC1C,KAAK,EAAE,iBAAiB,GACvB,OAAO,CAAC,mBAAmB,CAAC,CA6B9B;AAED,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,UAAU,EACf,oBAAoB,EAAE,oBAAoB,EAC1C,KAAK,EAAE,0BAA0B,GAChC,OAAO,CAAC,eAAe,CAAC,qBAAqB,CAAC,CAAC,CAmNjD"}
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../../src/banking/reconciliation/executor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAqB7D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AAqE5E,OAAO,KAAK,EAEV,qBAAqB,EACrB,0BAA0B,EAC1B,iBAAiB,EAGjB,mBAAmB,EAGnB,qBAAqB,EACrB,0BAA0B,EAC1B,iBAAiB,EACjB,uBAAuB,EAEvB,mBAAmB,EAInB,yBAAyB,EAOzB,mBAAmB,EACpB,MAAM,YAAY,CAAC;AAkBpB,eAAO,MAAM,+BAA+B,KAAK,CAAC;AAUlD,MAAM,MAAM,YAAY,GACpB;IAAE,IAAI,EAAE,sBAAsB,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACnE;IAAE,IAAI,EAAE,kBAAkB,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAC/D;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAE9D,MAAM,MAAM,eAAe,CAAC,CAAC,IACzB;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAA;CAAE,GACvC;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAA;CAAE,CAAC;AAE3D;;;;GAIG;AACH,qBAAa,kCAAmC,SAAQ,KAAK;IAC/C,QAAQ,CAAC,OAAO,EAAE,YAAY;IAA1C,YAAqB,OAAO,EAAE,YAAY,EAGzC;CACF;AAYD,wDAAwD;AACxD,eAAO,MAAM,8BAA8B,KAAK,CAAC;AAcjD,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,UAAU,EACf,KAAK,EAAE,mBAAmB,GACzB,OAAO,CAAC,yBAAyB,CAAC,CAoPpC;AAoYD,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,UAAU,EACf,oBAAoB,EAAE,oBAAoB,EAC1C,KAAK,EAAE,iBAAiB,GACvB,OAAO,CAAC,mBAAmB,CAAC,CAI9B;AAED,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,UAAU,EACf,oBAAoB,EAAE,oBAAoB,EAC1C,KAAK,EAAE,0BAA0B,GAChC,OAAO,CAAC,eAAe,CAAC,qBAAqB,CAAC,CAAC,CA0BjD;AAID,wBAAsB,uBAAuB,CAC3C,GAAG,EAAE,UAAU,EACf,KAAK,EAAE,iBAAiB,EACxB,IAAI,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GACzB,OAAO,CAAC,uBAAuB,CAAC,CAw6BlC;AAuBD,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,UAAU,EACf,oBAAoB,EAAE,oBAAoB,EAC1C,KAAK,EAAE,iBAAiB,GACvB,OAAO,CAAC,mBAAmB,CAAC,CA8B9B;AAED,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,UAAU,EACf,oBAAoB,EAAE,oBAAoB,EAC1C,KAAK,EAAE,0BAA0B,GAChC,OAAO,CAAC,eAAe,CAAC,qBAAqB,CAAC,CAAC,CAwQjD"}

package/dist/banking/reconciliation/executor.js

@@ -17,7 +17,7 @@ import { BookingGuard } from "../../booking-guard.js";
 import { buildBankAccountLookups, normalizeReference } from "../../tools/inter-account-utils.js";
 import { toUtcDay } from "../../date-utils.js";
 import { annotateDistinctSourceReferences, findDuplicateBankPostings, resolveBankDimensionsSafe, transactionSourceReferenceIdentity, } from "../../bank-posting-duplicate-guard.js";
-import { BANK_RECONCILIATION_PLAN_DOMAIN, buildReconciliationExecutionPlanInput, canonicalPlanJson, executeReconciliationCommands, reconClientUpdateCommandId, reconInvoiceConfirmCommandId, reconTransferConfirmCommandId, reconDeleteDuplicateCommandId, RECON_CONFIRM_INVOICE_CATEGORY, RECON_CONFIRM_TRANSFER_CATEGORY, RECON_DELETE_DUPLICATE_CATEGORY, RECON_UPDATE_CLIENT_CATEGORY, stripUndefinedDeep, } from "../../tools/bank-reconciliation-plan.js";
+import { BANK_RECONCILIATION_PLAN_DOMAIN, buildReconciliationExecutionPlanInput, canonicalPlanJson, executeReconciliationCommands, reconClientUpdateCommandId, reconInvoiceConfirmCommandId, reconTransferConfirmCommandId, reconDeleteDuplicateCommandId, reconDeleteProposedMirrorCommandId, RECON_CONFIRM_INVOICE_CATEGORY, RECON_CONFIRM_TRANSFER_CATEGORY, RECON_DELETE_DUPLICATE_CATEGORY, RECON_DELETE_PROPOSED_MIRROR_CATEGORY, RECON_UPDATE_CLIENT_CATEGORY, stripUndefinedDeep, } from "../../tools/bank-reconciliation-plan.js";
 import { buildInvoiceIndex, getIndexedCandidates } from "./invoice-index.js";
 import { documentReferenceOnTransaction } from "./document-reference.js";
 import { legacyTruncatedCamtMarkerHint } from "../../camt/duplicate-identity.js";
@@ -68,13 +68,28 @@ function validateInterAccountDateGap(maxDateGap) {
 // === Suggest =================================================================
 /** The suggestion path's default minimum confidence. */
 export const SUGGEST_DEFAULT_MIN_CONFIDENCE = 50;
+/**
+ * Suggest-only bonus for an exact-amount purchase invoice whose number or notes
+ * order / cart reference the bank description carries as a whole token.
+ * exact_amount (40) + 30 = 70 outranks every amount/name-only candidate
+ * (max 40 + 15 = 55). The cap 85 keeps it strictly below the 90 auto-confirm
+ * threshold (owner decision: a document reference alone never auto-confirms)
+ * and equals the Tier A cap. The exact-confirm path scores with matchScore
+ * alone, so ref_number_exact and >= 90 admission are untouched.
+ */
+const DOCUMENT_REFERENCE_POINTS = 30;
+const DOCUMENT_REFERENCE_CONFIDENCE_CAP = 85;
 export async function runSuggestMatches(api, input) {
     const threshold = input.minConfidence ?? SUGGEST_DEFAULT_MIN_CONFIDENCE;
-    // A caller asking for a stricter threshold than the default gets no
-    // below-threshold document-reference group (okt 2026 finding 5).
-    const documentReferenceGroupEnabled = input.minConfidence === undefined || input.minConfidence <= SUGGEST_DEFAULT_MIN_CONFIDENCE;
     const documentReferenceCandidates = [];
     const block_on_duplicate = input.blockOnDuplicate;
+    // Read uncached: the 120 s list cache does not see invoices created or paid
+    // by another process (a second MCP server, the e-arveldaja UI), so two
+    // surfaces over the same books could report different matches (live
+    // 2026-10-30: an invoice confirmed 9 s earlier elsewhere was missing).
+    api.transactions.invalidateListCache();
+    api.saleInvoices.invalidateListCache();
+    api.purchaseInvoices.invalidateListCache();
     // Get all unconfirmed transactions
     const allTx = await api.transactions.listAll();
     const unconfirmed = allTx.filter(isProjectTransaction);
@@ -104,6 +119,7 @@ export async function runSuggestMatches(api, input) {
     let matchedDateTo;
     for (const tx of unconfirmed) {
         const candidates = [];
+        const documentReferenceByInvoiceId = new Map();
         const { allowSaleInvoices, allowPurchaseInvoices } = getInvoiceMatchEligibility(tx);
         if (allowSaleInvoices) {
             for (const inv of getIndexedCandidates(saleIndex, tx.ref_number, tx.amount, tx.base_amount)) {
@@ -127,8 +143,19 @@ export async function runSuggestMatches(api, input) {
         }
         if (allowPurchaseInvoices) {
             for (const inv of getIndexedCandidates(purchaseIndex, tx.ref_number, tx.amount, tx.base_amount)) {
-                const { confidence, reasons, partiallyPaidWarning } = matchScore(tx, inv, tx.amount);
+                const scored = matchScore(tx, inv, tx.amount);
+                const { reasons, partiallyPaidWarning } = scored;
+                let confidence = scored.confidence;
+                const matchedReference = reasons.includes("exact_amount")
+                    ? documentReferenceOnTransaction(tx.description, inv)
+                    : undefined;
+                if (matchedReference !== undefined) {
+                    reasons.push("document_reference");
+                    confidence = Math.max(confidence, Math.min(confidence + DOCUMENT_REFERENCE_POINTS, DOCUMENT_REFERENCE_CONFIDENCE_CAP));
+                }
                 if (confidence >= threshold) {
+                    if (matchedReference !== undefined)
+                        documentReferenceByInvoiceId.set(inv.id, { inv, matchedReference });
                     candidates.push({
                         type: "purchase_invoice",
                         id: inv.id,
@@ -143,34 +170,36 @@ export async function runSuggestMatches(api, input) {
                         match_reasons: reasons,
                     });
                 }
-                else if (documentReferenceGroupEnabled && reasons.includes("exact_amount")) {
-                    const matchedReference = documentReferenceOnTransaction(tx.description, inv);
-                    if (matchedReference !== undefined) {
-                        // RAW domain strings — the presenter wraps the free-text fields.
-                        documentReferenceCandidates.push({
-                            transaction_id: tx.id,
-                            date: tx.date,
-                            amount: tx.amount,
-                            description: tx.description ?? undefined,
-                            bank_account_name: tx.bank_account_name ?? undefined,
-                            invoice: {
-                                type: "purchase_invoice",
-                                id: inv.id,
-                                number: inv.number,
-                                client_name: inv.client_name,
-                                gross_price: inv.gross_price ?? 0,
-                                payment_status: inv.payment_status ?? "NOT_PAID",
-                            },
-                            matched_reference: matchedReference,
-                            match_reasons: [...reasons, "document_reference"],
-                        });
-                    }
-                }
             }
         }
         if (candidates.length > 0) {
             candidates.sort((a, b) => b.confidence - a.confidence);
             const bestMatch = candidates[0];
+            // A document-reference invoice that did not win this row is listed
+            // separately so it is not hidden behind the chosen best match.
+            for (const candidate of candidates.slice(1)) {
+                const docRef = candidate.type === "purchase_invoice" ? documentReferenceByInvoiceId.get(candidate.id) : undefined;
+                if (docRef === undefined)
+                    continue;
+                // RAW domain strings — the presenter wraps the free-text fields.
+                documentReferenceCandidates.push({
+                    transaction_id: tx.id,
+                    date: tx.date,
+                    amount: tx.amount,
+                    description: tx.description ?? undefined,
+                    bank_account_name: tx.bank_account_name ?? undefined,
+                    invoice: {
+                        type: "purchase_invoice",
+                        id: docRef.inv.id,
+                        number: docRef.inv.number,
+                        client_name: docRef.inv.client_name,
+                        gross_price: docRef.inv.gross_price ?? 0,
+                        payment_status: docRef.inv.payment_status ?? "NOT_PAID",
+                    },
+                    matched_reference: docRef.matchedReference,
+                    match_reasons: candidate.match_reasons,
+                });
+            }
             const crossCurrency = (bestMatch.match_reasons.includes("exact_base_amount") ||
                 bestMatch.match_reasons.includes("cross_currency_conflict")) &&
                 !bestMatch.match_reasons.includes("exact_amount");
@@ -718,9 +747,12 @@ export async function runInterAccountMatching(api, input, opts) {
     const errors = [];
     const consumedTxIds = new Set();
     const blockedOneSidedTxIds = new Set();
+    const deleteProposedMirrors = input.deleteProposedMirrors === true;
+    const mirrorDeleteActions = [];
     function finish(companyClientsId) {
-        const planCommandProjections = buildInterAccountPlanCommandProjections(confirmActions, companyClientsId);
-        const normalizedArgs = stripUndefinedDeep({ max_date_gap: maxGap, target_accounts_dimensions_id });
+        const planCommandProjections = buildInterAccountPlanCommandProjections(confirmActions, companyClientsId, mirrorDeleteActions);
+        const normalizedArgs = stripUndefinedDeep({ max_date_gap: maxGap, target_accounts_dimensions_id,
+            ...(deleteProposedMirrors ? { delete_proposed_mirrors: true } : {}) });
         const fingerprint = interAccountFingerprint({ normalizedArgs, planCommandProjections, skippedAlreadyHandled,
             ambiguousPairs, ambiguousRefless, crossCurrencyPairs });
         const companyLegalName = (invoiceInfo.invoice_company_name ?? "").trim();
@@ -728,7 +760,8 @@ export async function runInterAccountMatching(api, input, opts) {
             ? ["Company name has no legal form; own-transfer detection relies on IBANs only."] : [];
         return { totalUnconfirmed: unconfirmed.length, invoiceInfo, dimensionToIban, dimensionToTitle,
             dimensionToAccountsId, matchedPairs, matchedOneSided, ambiguousPairs, skippedAlreadyHandled,
-            ambiguousRefless, crossCurrencyPairs, errors, confirmActions, companyClientsId, normalizedArgs,
+            ambiguousRefless, crossCurrencyPairs, errors, confirmActions,
+            ...(deleteProposedMirrors ? { mirrorDeleteActions } : {}), companyClientsId, normalizedArgs,
             fingerprint, ...(warnings.length > 0 ? { warnings } : {}) };
     }
     // With no pending bank rows there is nothing to pair, deduplicate or confirm.
@@ -1495,6 +1528,18 @@ export async function runInterAccountMatching(api, input, opts) {
         row.mirror_proposal = proposal;
         row.next_action = { tool: "delete_transaction", args: { id: row.transaction_id }, approval_required: true };
         row.reason = `Already journalized from the other account side: journal #${proposal.journal_id} books confirmed transaction ${proposal.counterpart_transaction_id}, and this PROJECT row is its likely mirror. Verify against the bank statements, then delete it with delete_transaction only after the owner explicitly approves; reconcile never deletes it automatically.`;
+        if (deleteProposedMirrors) {
+            // Opt-in: the reviewed plan carries this deletion; execute re-verifies it.
+            mirrorDeleteActions.push({
+                transactionId: row.transaction_id,
+                journalId: proposal.journal_id,
+                counterpartTransactionId: proposal.counterpart_transaction_id,
+                targetDimensionId: row.target_dimension_id,
+                material: snapshotBankTransaction(allTx.get(row.transaction_id)),
+            });
+            row.reason = `Already journalized from the other account side: journal #${proposal.journal_id} books confirmed transaction ${proposal.counterpart_transaction_id}, and this PROJECT row is its likely mirror. delete_proposed_mirrors put its deletion in this plan: verify against the bank statements before approving execute.`;
+            delete row.next_action;
+        }
     }
     const companyClientsId = await resolveCompanyClientsId();
     for (const action of confirmActions) {
@@ -1535,7 +1580,7 @@ export async function prepareInterAccount(api, runtimeSafetyContext, input) {
     const match = await runInterAccountMatching(api, input);
     if (input.mintPlanHandles === false)
         return { match };
-    const planCommandProjections = buildInterAccountPlanCommandProjections(match.confirmActions, match.companyClientsId);
+    const planCommandProjections = buildInterAccountPlanCommandProjections(match.confirmActions, match.companyClientsId, match.mirrorDeleteActions);
     const planHandle = runtimeSafetyContext.planStore.issue(BANK_RECONCILIATION_PLAN_DOMAIN, buildReconciliationExecutionPlanInput({
         normalizedArgs: match.normalizedArgs,
         sourceIdentities: [],
@@ -1550,6 +1595,7 @@ export async function prepareInterAccount(api, runtimeSafetyContext, input) {
             total_unconfirmed: match.totalUnconfirmed,
             matched_pairs: match.matchedPairs.length,
             matched_one_sided: match.matchedOneSided.length,
+            ...(match.mirrorDeleteActions !== undefined ? { proposed_mirror_deletes: match.mirrorDeleteActions.length } : {}),
         },
         totals: {},
         exclusions: [...match.skippedAlreadyHandled, ...match.ambiguousRefless, ...match.crossCurrencyPairs].map(row => stripUndefinedDeep(row)),
@@ -1780,8 +1826,68 @@ export async function executeInterAccount(api, runtimeSafetyContext, input) {
             });
         }
     }
+    for (const action of match.mirrorDeleteActions ?? []) {
+        // Every read gates the delete: the row must still be the reviewed PROJECT
+        // row, and the journal must still book its confirmed counterpart.
+        const verifyMirror = async () => {
+            api.transactions.invalidateListCache();
+            const row = await api.transactions.get(action.transactionId);
+            if (!row || !isProjectTransaction(row))
+                return "mirror_not_project";
+            if (!compareBankTransactionMaterial(action.material, row).ok)
+                return "mirror_material_drift";
+            const counterpart = await api.transactions.get(action.counterpartTransactionId);
+            if (!counterpart || counterpart.is_deleted || counterpart.status !== "CONFIRMED"
+                || counterpart.accounts_dimensions_id !== action.targetDimensionId
+                || !sameAmountToTheCent(counterpart.amount, action.material.amount ?? Number.NaN))
+                return "mirror_counterpart_drift";
+            api.journals.invalidateListCache();
+            const journal = (await api.journals.listAllWithPostings()).find(j => j.id === action.journalId);
+            if (!journal || journal.is_deleted || journal.registered !== true || journal.operation_type !== "TRANSACTION"
+                || journal.operations_id !== action.counterpartTransactionId)
+                return "mirror_journal_drift";
+            return undefined;
+        };
+        commands.push({
+            id: reconDeleteProposedMirrorCommandId(action.transactionId),
+            category: RECON_DELETE_PROPOSED_MIRROR_CATEGORY,
+            prepare: async () => {
+                const drift = await verifyMirror();
+                if (drift)
+                    return { outcome: "drift", error_code: drift };
+                // The journal read may await another actor: make the row the final read.
+                api.transactions.invalidateListCache();
+                const row = await api.transactions.get(action.transactionId);
+                if (!row || !isProjectTransaction(row) || !compareBankTransactionMaterial(action.material, row).ok) {
+                    return { outcome: "drift", error_code: "mirror_material_drift" };
+                }
+                return { outcome: "ready" };
+            },
+            mutate: async () => {
+                try {
+                    await api.transactions.delete(action.transactionId);
+                    logAudit({
+                        tool: "reconcile_inter_account_transfers", action: "DELETED", entity_type: "transaction",
+                        entity_id: action.transactionId,
+                        summary: `Deleted proposed mirror row ${action.transactionId} of confirmed transaction ${action.counterpartTransactionId} (journal ${action.journalId})`,
+                        details: { journal_id: action.journalId, counterpart_transaction_id: action.counterpartTransactionId, delete_proposed_mirrors: true },
+                    });
+                    return { outcome: "completed", known_objects: [{ entity_type: "transaction", entity_id: action.transactionId, outcome: "deleted" }] };
+                }
+                catch (err) {
+                    if (err instanceof MutationIndeterminateError)
+                        return { outcome: "indeterminate", error_code: "mutation_outcome_unknown" };
+                    return { outcome: "failed", error_code: "delete_failed", mutation_occurred: false };
+                }
+            },
+        });
+    }
     const executionReport = await executeReconciliationCommands(commands);
     const completedIds = new Set(executionReport.command_partitions.completed.map(item => item.command_id));
+    for (const row of match.skippedAlreadyHandled) {
+        if (completedIds.has(reconDeleteProposedMirrorCommandId(row.transaction_id)))
+            row.mirror_deleted = true;
+    }
     for (const pair of match.matchedPairs) {
         const action = match.confirmActions.find(action => action.confirmedTxId === pair.outgoing_transaction_id);
         if (action?.registrationJournalId != null)