diff --git a/models/account_payment.py b/models/account_payment.py
index f8d676f..0e7feff 100644
--- a/models/account_payment.py
+++ b/models/account_payment.py
@@ -9,59 +9,45 @@ class AccountPayment(models.Model):
     def action_post(self):
         """
         Overriding to bypass hr_expense restriction and ensure deductions are synced.
+        We temporarily clear the link in the DB to avoid the 'Invalid Operation' error.
         """
-        # Identify payments that would normally be locked by hr_expense
-        locked_payouts = self.filtered(lambda p: p.expense_sheet_id)
-        if locked_payouts:
-            # Store links to restore later
-            links = {p.id: p.expense_sheet_id.id for p in locked_payouts}
-            
-            # 1. Hide the links in the cache so hr_expense's _synchronize_to_moves doesn't see them
-            for p in locked_payouts:
-                p.env.cache.set(p, p._fields['expense_sheet_id'], False)
-            
-            try:
-                # 2. Force a sync with the 'amount' field to ensure deductions are redrawn
-                for p in locked_payouts:
-                    if p.state == 'draft':
-                        p._synchronize_to_moves({'amount', 'deduction_line_ids', 'amount_substract'})
+        for payment in self:
+            if payment.expense_sheet_id and payment.state == 'draft':
+                sheet_id = payment.expense_sheet_id.id
+                # 1. Clear the link in DB and Cache (Skip sync to avoid recursion)
+                payment.with_context(skip_account_move_synchronization=True).write({'expense_sheet_id': False})
                 
-                # 3. Call the standard post logic while the link is hidden
-                res = super().action_post()
-                return res
-            finally:
-                # 4. Restore the links
-                for p in locked_payouts:
-                    if p.id in links:
-                        p.env.cache.set(p, p._fields['expense_sheet_id'], self.env['hr.expense.sheet'].browse(links[p.id]))
-        else:
-            return super().action_post()
+                try:
+                    # 2. Force Sync Deductions while 'unlinked'
+                    payment._synchronize_to_moves({'amount', 'deduction_line_ids', 'amount_substract'})
+                    
+                    # 3. Call standard post
+                    res = super(AccountPayment, payment).action_post()
+                finally:
+                    # 4. Restore the link
+                    payment.with_context(skip_account_move_synchronization=True).write({'expense_sheet_id': sheet_id})
+            else:
+                super(AccountPayment, payment).action_post()
+        return True
 
     def _synchronize_to_moves(self, changed_fields):
-        # If deductions changed, we MUST include 'amount' to trigger Odoo's refresh
+        # Trigger deduction sync if needed
         if 'deduction_line_ids' in changed_fields or 'amount_substract' in changed_fields:
-             changed_fields = set(changed_fields) | {'amount'}
+            if 'amount' not in changed_fields:
+                changed_fields = set(changed_fields) | {'amount'}
 
-        # Case for manual edits (write) when payment is draft
-        draft_locked = self.filtered(lambda p: p.state == 'draft' and p.expense_sheet_id)
-        if draft_locked:
-            links = {p.id: p.expense_sheet_id.id for p in draft_locked}
-            for p in draft_locked:
-                p.env.cache.set(p, p._fields['expense_sheet_id'], False)
-            try:
-                return super()._synchronize_to_moves(changed_fields)
-            finally:
-                for p in draft_locked:
-                    if p.id in links:
-                        p.env.cache.set(p, p._fields['expense_sheet_id'], self.env['hr.expense.sheet'].browse(links[p.id]))
+        # Bypass for manual edits
+        for payment in self:
+            if payment.expense_sheet_id and payment.state == 'draft':
+                sheet_id = payment.expense_sheet_id.id
+                payment.with_context(skip_account_move_synchronization=True).write({'expense_sheet_id': False})
+                try:
+                    return super(AccountPayment, payment)._synchronize_to_moves(changed_fields)
+                finally:
+                    payment.with_context(skip_account_move_synchronization=True).write({'expense_sheet_id': sheet_id})
         
         return super()._synchronize_to_moves(changed_fields)
 
-    def write(self, vals):
-        # Standard Odoo write: if we are editing deductions, ensure bypass is used if needed
-        # (Though _synchronize_to_moves override above should handle it)
-        return super().write(vals)
-
     def action_cancel(self):
         res = super().action_cancel()
         for payment in self: