aiolabs/payroll
9
0
Fork 0
Code Issues 6 Pull requests Projects Releases Packages Wiki Activity Actions

fix: resuming an auto-paused contract no longer discards the backlog

Browse source 
Found by tracing what happens when a back-dated backfill contract cannot
fetch a historical rate. The failure handling itself was fine — period 0
fails, the backlog halts so nothing settles out of order, five ledger rows
record the reason, no money moves, and the contract auto-pauses once the
retry budget is spent. The recovery was not.

The operator fixes the cause (switches to a stated rate, or to current),
clicks Resume, and periods_done jumps 0 -> 6: every unpaid payday silently
written off, contract back to looking healthy, employee never paid. The
confirm dialog even asserted the missed paydays "are written off" — true of
one kind of pause and a lie about the other.

Two features colliding. "Do not backfill a deliberate pause" is right when
the operator paused: the pause *was* the decision not to pay. It is wrong
when payroll paused, because nobody decided anything — the money is still
owed and the operator has just removed whatever blocked it.

Contracts now carry `paused_reason`, set only when payroll pauses them and
cleared by a deliberate pause. Resume infers from it, and an explicit
`catch_up` still overrides either way. The console asks a different question
for each, quoting the reason, and flags a payroll-paused contract in the
table so the distinction is visible before anyone clicks.

Verified end to end: five failing ticks leave periods_done at 0 and pause
with "period 0 (2026-08-01) failed 5 times: no historical EUR rate
available for 2026-08-01"; resuming after switching to a manual rate keeps
the position at 0, and the next tick settles all seven owed periods.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018jy52j9GRZ6XKa1Zt21LLj
This commit is contained in:
Padreug 2026-08-31 23:02:45 +02:00
commit e77f431d47
8 changed files with 168 additions and 22 deletions
Download patch file Download diff file Expand all files Collapse all files

16
views_api.py
View file

@ -214,14 +214,18 @@ async def api_pause_contract(contract_id: str) -> Contract:
@payroll_api_router.post("/api/v1/contracts/{contract_id}/resume")
async def api_resume_contract(contract_id: str, catch_up: bool = False) -> Contract:
async def api_resume_contract(
contract_id: str, catch_up: bool | None = None
) -> Contract:
"""Put a paused contract back to work.
Paydays missed during the pause are skipped by default — a pause is a
decision not to pay them, and resuming into an unannounced multi-period
transfer is the opposite of what "resume" implies. `catch_up=true` pays
them, for a pause that was an operational hold rather than a decision
about the money.
What happens to the paydays missed during the pause depends on who
paused it. An operator pause *was* the decision not to pay them, so they
are written off. A pause payroll applied itself — a period that
exhausted its retries — means the money is still owed and the operator
has just fixed whatever blocked it, so the backlog is kept.
Pass `catch_up` explicitly to override that inference.
"""
return await _transition(
contract_id, lambda c: services.resume(c, catch_up=catch_up)