@hyperscale0/hsx 1.0.338 → 1.0.339

package/std/financing.hsx

@@ -5,6 +5,17 @@ header financing
 // earnings; receipt refunds reverse captured cash. Borrower cash paid to outside
 // capital or recovery recipients passes through, whether held first or paid direct.
 
+// Terms: loan_kind names the product and caps the term. max_term defaults to
+// the longest term the library allows for that kind, and a company may lower it
+// but never raise it:
+//   mortgage    360 monthly instalments
+//   auto         84
+//   personal     84 (the default kind)
+//   short_term   12 (pay later and other short consumer credit)
+// months is the instalment count of one plan. Set it in the program to fix the
+// term, or leave it runtime and supply it at create; create refuses a plan
+// longer than max_term.
+
 // Pricing is required. amortizing reads profit_rate as an annual rate on the
 // declining balance: equal monthly instalments, the last absorbing rounding.
 // flat_total reads it as one charge on principal for the whole term (murabaha,
@@ -43,20 +54,21 @@ header financing
 // payments and no collected late charges; refund them first. unwind needs no
 // assessed late charges; waive them first. When goods never arrive on a paid plan, the
 // Product operator runs unwind_paid once the hold's deliverBy has passed, so an
-// early payoff never cuts the seller's delivery window short. It refunds every
-// payment, share, profit piece, fine and cost receipt and reverses the payoff's
-// profit, fines and costs, cancels the plan, and returns the hold's whole price
-// to the borrower; capital keeps the principal the borrower repaid. A settlement
-// a lending.distribution has paid out keeps its profit and share, since investors
-// hold that profit; only the other settlements' profit is refunded. unwind_paid
-// selects at most max_history (default and most 366) of each record kind, so
-// a payment refuses when it would leave more paid payments than max_history
-// less one, keeping a settlement for the payoff, or more paid profit pieces,
-// fine receipts or cost receipts than max_history; a fine or a recovery cost
-// refuses past max_history unwaived fines or costs on the plan, counted across
-// every late charge attachment, so a waived fine's cost keeps its own slot. A company lowers it to keep unwinds smaller. If any
-// source account is short, the whole action refuses and nothing moves; a
-// company that wants a partial refund writes that rule in its own program.
+// early payoff never cuts the seller's delivery window short. It refunds the
+// profit of every payment, every share, fine and cost receipt, reverses the
+// payoff's profit, fines and costs, cancels the plan, and returns the hold's
+// whole price to the borrower; capital keeps the principal the borrower repaid.
+// A settlement a lending.distribution has paid out keeps its profit and share,
+// since investors hold that profit; only the other settlements' profit is
+// refunded. Each refund is its own transfer, so unwind_paid moves the plan to
+// unwinding and refunds 64 payments and 16 fine and 16 cost receipts per
+// operation; the plan's unwind_step clock runs the next batch a second later
+// until none remain, then the plan cancels and the hold refunds. max_history
+// (default and most 366) caps the late charges and recovery costs on one plan,
+// counted across every late charge attachment. A company lowers it to keep
+// payoffs and amendments smaller. If any source account is short, the whole
+// action refuses and nothing moves; a company that wants a partial refund
+// writes that rule in its own program.
 // returned_goods decides the split on returned goods, before or after payoff.
 // keep_profit, the default, keeps the profit and fines paid so far with the
 // company: unwind runs with payments still paid, and on a paid plan the Product
@@ -75,8 +87,13 @@ header financing
 // Expose parent payoff separately and create a current, unexpired payoff_quote.
 // Expose late_charge.create as propose_assessment before the clock can assess;
 // provide matching plan, slice and borrower. Fine is fixed money, not a percentage.
-// Collection uses the minimum of payment cash and outstanding fine; a partial
-// payment does not settle the remaining fine. Recovery cost needs its own record,
+// A payment under fines_profit_principal first takes assessed fines and then
+// recovery costs, oldest first and at most charge_limit (default 12) of each,
+// then profit and principal slice by slice in due order. A payment that would
+// leave cash unapplied refuses, so a plan with more open charges than
+// charge_limit takes several payments. Collection uses the minimum of payment
+// cash and outstanding fine; a partial payment does not settle the remaining
+// fine. Recovery cost needs its own record,
 // which only the Product operator creates; only it cancels a proposed fine or cost.
 // Profit share credits capital's allocatedProfitPayable, not an outside agency.
 // Credit lines need adapter binding at activation; draws are ledger advances,
@@ -85,11 +102,16 @@ header financing
 // advance on it. Only the Product operator creates the portfolio limit and
 // approves borrower and portfolio limits. No clock declaration proves retries.
 
-// Cost: installments include cash and claim moves, child-account creation and
-// bounded invocations across slices and assessments. Month and charge limits affect
-// the bound. Run hsx cost on the selected policies; profit is not a platform tariff.
+// Cost: the plan holds one principal, unearned profit, earned profit, fine and
+// cost claim, so disbursement, payoff, write-off, cancellation and refunds post
+// one transfer per party and purpose, whatever the term. Slices, pieces and
+// charges are state. Only receipts carry their own transfers: a payment posts at
+// most 2 per collected charge, so charge_limit bounds it, and unwind_paid
+// batches its refunds. Run hsx cost on the selected policies; every action of a
+// 360-month plan stays under one 253-transfer batch. Profit is not a platform
+// tariff.
 
-instrument installments(months: integer(1, 366), max_history: integer(2, 366) = 366, pricing: enum(amortizing, flat_total), profit_rate: percent, charge_limit: integer(1, 3) = 3, disburse_to: enum(funds, borrower, seller) = funds, seller: party?, profit_earned: enum(on_payment, by_schedule, at_disbursement) = on_payment, apply: enum(fines_profit_principal, principal_profit, pro_rata) = fines_profit_principal, payoff_rebate: percent = 100%, write_off_after: duration = 90d, max_extension: duration = 90d, max_amendments: integer(0, 366) = 2, waiver_limit: percent = 100%, amendment_expiry: duration = 7d, payoff_quote_expiry: duration = 1h, refund_within: duration = 30d, returned_goods: enum(keep_profit, refund_all) = keep_profit, allow_overdue: enum(allowed, blocked) = allowed, assessed_fines: enum(carry, require_waiver) = carry, down_payment: percent = 0%, funds: ref?, borrower: party = party(person), capital: party = programOperator, share: percent = 0%, limits: ref<financing.limits> = object(financing.limits), portfolio: ref<financing.portfolio_limit> = object(financing.portfolio_limit)) {
+instrument installments(loan_kind: enum(mortgage, auto, personal, short_term) = personal, max_term: integer(1, 360) = 360, months: integer(1, 360) = runtime, max_history: integer(2, 366) = 366, pricing: enum(amortizing, flat_total), profit_rate: percent, charge_limit: integer(1, 24) = 12, disburse_to: enum(funds, borrower, seller) = funds, seller: party?, profit_earned: enum(on_payment, by_schedule, at_disbursement) = on_payment, apply: enum(fines_profit_principal, principal_profit, pro_rata) = fines_profit_principal, payoff_rebate: percent = 100%, write_off_after: duration = 90d, max_extension: duration = 90d, max_amendments: integer(0, 366) = 2, waiver_limit: percent = 100%, amendment_expiry: duration = 7d, payoff_quote_expiry: duration = 1h, refund_within: duration = 30d, returned_goods: enum(keep_profit, refund_all) = keep_profit, allow_overdue: enum(allowed, blocked) = allowed, assessed_fines: enum(carry, require_waiver) = carry, down_payment: percent = 0%, funds: ref?, borrower: party = party(person), capital: party = programOperator, share: percent = 0%, limits: ref<financing.limits> = object(financing.limits), portfolio: ref<financing.portfolio_limit> = object(financing.portfolio_limit)) {
   dependencies {
     funds {
       selector: disburse_to, is: funds
@@ -102,35 +124,41 @@ instrument installments(months: integer(1, 366), max_history: integer(2, 366) =
       fix: "Bind `seller: merchant` to the declared business that receives the principal."
     }
   }
+  ceilings { max_term { by: loan_kind, mortgage: 360, auto: 84, personal: 84, short_term: 12 } }
+  constraints { months: at_most(max_term) }
   revisioned: true
   familyRevision: 1
   summary: "Funding, profit recognition and payment order chosen by the program."
   fields {
     funds: ref<funds>?, borrower: account of borrower, settlementIdentity: text, borrowerLimit: ref<limits>, portfolioLimit: ref<portfolio>
-    months: integer = months, dates: list(date, months), historyLimit: integer = max_history, paymentLimit: integer = subtract(max_history, 1)
+    months: integer = months, maxTerm: integer = max_term, dates: list(date, max_term), historyLimit: integer = max_history
     allocatedPayable: account(capital, cash, "allocatedProfitPayable"), capital: account(capital, cash, "capital"), profitIncome: account(capital, cash, "profitIncome"), loss: account(capital, claim, "loss")
+    principalReceivable: account(self, claim), profitReceivable: account(self, claim), profitEarned: account(self, claim), fineReceivable: account(self, claim), costReceivable: account(self, claim), debt: account(borrower, claim, contra, "debt")
     principalOutstanding: money?, principalRepaid: money?, principalReturned: money?, profitReturned: money?, lossRecorded: money?, refundWindow: date?, refundUntil: date?
+    scheduledPrincipal: money?, scheduledProfit: money?, payoffRebate: money?, payoffProfitTotal: money?, payoffProfit: money?, payoffReceipt: text?
+    unwindAt: date?, paymentsLeft: integer?, finesLeft: integer?, costsLeft: integer?
     openSlices: integer?, openCharges: money?, openCosts: money?, payoffRefunds: integer?
     price: money = subject.price
     downPayment: money = rate(self.price, down_payment)
     principal: money = subtract(self.price, self.downPayment)
     flatProfit: money?
   }
-  lifecycle { states: [quoted, signed, active, paid, written_off, cancelled], initial: quoted }
+  lifecycle { states: [quoted, signed, active, paid, unwinding, written_off, cancelled], initial: quoted }
   invariants count of { instrument: all(financing.installments), reference: "borrowerLimit", anchor: self.borrowerLimit, states: [active], limit: 366 } <= self.borrowerLimit.activePlans
-  invariants sum "principalReceivable.balance" of { instrument: all(financing.installments.slice), reference: "borrowerLimit", anchor: self.borrowerLimit, states: [pending, due, paid], limit: 366 } <= self.borrowerLimit.limit
-  invariants sum "principalReceivable.balance" of { instrument: all(financing.installments.slice), reference: "portfolioLimit", anchor: self.portfolioLimit, states: [pending, due, paid], limit: 366 } <= self.portfolioLimit.limit
+  invariants sum "principalReceivable.balance" of { instrument: all(financing.installments), reference: "borrowerLimit", anchor: self.borrowerLimit, states: [active], limit: 366 } <= self.borrowerLimit.limit
+  invariants sum "principalReceivable.balance" of { instrument: all(financing.installments), reference: "portfolioLimit", anchor: self.portfolioLimit, states: [active], limit: 366 } <= self.portfolioLimit.limit
   action create {
     subject { price: money }
     actor: { party: borrower }
     requires self.borrowerLimit.borrower == self.borrower
+    requires self.months <= self.maxTerm
     when pricing is flat_total { calculate: [{ target: flatProfit, op: rate, base: { field: self.principal }, bps: { literal: profit_rate }, rounding: floor }] }
     when disburse_to is funds { invoke: [{ reference: self.funds, action: check, input: { plan: { field: self.id } } }] }
-    invoke: [{ range: { count: { literal: months }, maximum: months, bind: position }, instrument: slice, action: create, input: { plan: { field: self.id }, borrowerLimit: { field: self.borrowerLimit }, portfolioLimit: { field: self.portfolioLimit }, position: { field: position } } }, { selection: { instrument: slice, reference: "plan", anchor: self.id, states: [draft], limit: months, where: { first: { literal: 0 } } }, action: check_order, input: {} }]
+    invoke: [{ range: { count: { field: self.months }, maximum: max_term, bind: position }, instrument: slice, action: create, input: { plan: { field: self.id }, borrowerLimit: { field: self.borrowerLimit }, portfolioLimit: { field: self.portfolioLimit }, position: { field: position } } }, { selection: { instrument: slice, reference: "plan", anchor: self.id, states: [draft], limit: max_term, where: { first: { literal: 0 } } }, action: check_order, input: {} }]
   }
   action sign {
     from: quoted, to: signed, actor: { party: borrower }, input { signedOffer: text, affordabilityReference: text }
-    requires count of { instrument: slice, reference: "plan", anchor: self.id, states: [draft], limit: 366 } == self.months
+    requires count of { instrument: slice, reference: "plan", anchor: self.id, states: [draft], limit: max_term } == self.months
   }
   action collect_down_payment { allowZero: true,
     from: signed, to: signed, actor: { party: borrower }
@@ -142,55 +170,86 @@ instrument installments(months: integer(1, 366), max_history: integer(2, 366) =
     from: signed, to: active, actor: { party: capital }
     requires self.borrowerLimit in [approved]
     requires self.portfolioLimit in [approved]
+    calculate: [
+      { target: scheduledPrincipal, op: aggregate, selection: { instrument: slice, reference: "plan", anchor: self.id, states: [draft], limit: max_term }, measure: { sum: "principal" } }
+      { target: scheduledProfit, op: aggregate, selection: { instrument: slice, reference: "plan", anchor: self.id, states: [draft], limit: max_term }, measure: { sum: "profit" } }
+    ]
     when disburse_to is funds { invoke: [{ reference: self.funds, action: disburse, input: { plan: { field: self.id } } }] }
     when disburse_to is borrower { moves self.principal from self.capital to self.borrower economics { purpose: principal, sourceParty: capital } }
     when disburse_to is seller { moves self.principal from self.capital to seller economics { purpose: principal, sourceParty: capital } }
-    invoke: [{ selection: { instrument: slice, reference: "plan", anchor: self.id, states: [draft], limit: 366, order: [position] }, action: activate, input: {} }]
+    moves self.scheduledPrincipal from self.debt to self.principalReceivable economics { purpose: internal, sourceParty: borrower }
+    moves self.scheduledProfit from self.debt to self.profitReceivable economics { purpose: internal, sourceParty: borrower }
+    when profit_earned is at_disbursement { moves self.scheduledProfit from self.profitReceivable to self.profitEarned economics { purpose: internal, sourceParty: programOperator } }
+    invoke: [{ selection: { instrument: slice, reference: "plan", anchor: self.id, states: [draft], limit: max_term, order: [position] }, action: activate, input: {} }]
   }
   action complete {
     from: active, to: paid
     calculate: [{ target: refundWindow, op: shift, date: { field: self.now }, milliseconds: { literal: refund_within }, direction: after }]
     set: { refundUntil: { field: self.refundWindow } }
-    requires count of { instrument: slice, reference: "plan", anchor: self.id, states: [pending, due], limit: 366 } == 0
-    requires sum "receivable.balance" of { instrument: all(financing.late_charge), reference: "plan", anchor: self.id, states: [assessed, collected], limit: 366 } == "0"
-    requires sum "receivable.balance" of { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.id, states: [assessed, collected], limit: 366 } == "0"
+    requires count of { instrument: slice, reference: "plan", anchor: self.id, states: [pending, due], limit: max_term } == 0
+    requires self.fineReceivable.balance == "0"
+    requires self.costReceivable.balance == "0"
   }
   action restore { from: [active, paid], to: active, actor: { parent: payment }, input { refundUntil: date? }, set: { refundUntil: { field: input.refundUntil } } }
-  action payoff {
+  action payoff { allowZero: true,
     from: active, to: paid, actor: { party: borrower }
     input { quote: ref<payoff_quote> }
     requires input.quote.plan == self.id; requires input.quote.revision == self.productRevision
     deadline: { at: input.quote.expiresAt }
     calculate: [
-      { target: "principalReturned", op: "aggregate", selection: { instrument: slice, reference: "plan", anchor: self.id, states: [pending, due], limit: 366 }, measure: { sum: "principalReceivable.balance" } }
+      { target: principalReturned, op: sum, values: [{ field: self.principalReceivable.balance }] }
+      { target: payoffRebate, op: rate, base: { field: self.profitReceivable.balance }, bps: { literal: payoff_rebate }, rounding: floor }
+      { target: payoffProfitTotal, op: sum, values: [{ field: self.profitReceivable.balance }, { field: self.profitEarned.balance }] }
+      { target: payoffProfit, op: subtract, base: { field: self.payoffProfitTotal }, subtract: [{ field: self.payoffRebate }] }
       { target: refundWindow, op: shift, date: { field: self.now }, milliseconds: { literal: refund_within }, direction: after }
     ]
     set: { refundUntil: { field: self.refundWindow } }
-    invoke: [{ selection: { instrument: all(financing.late_charge), reference: "plan", anchor: self.id, states: [assessed, collected], limit: 366, order: [overdueAt] }, action: payoff, input: {} }, { selection: { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.id, states: [assessed, collected], limit: 366, order: [overdueAt] }, action: payoff, input: {} }]
-    invoke: [{ selection: { instrument: slice, reference: "plan", anchor: self.id, states: [pending, due], limit: 366, order: [position] }, action: payoff, input: { identity: { field: self.settlementIdentity } } }, { reference: self.id, action: record_payoff, input: {} }]
+    moves self.principalReturned from self.borrower to self.capital economics { purpose: principal, sourceParty: borrower }
+    moves self.payoffProfit from self.borrower to self.profitIncome capture "payoffReceipt" economics { recipient: capital, company: { purpose: earning, sourceParty: borrower }, participant: { purpose: pass_through, sourceParty: borrower } }
+    moves self.principalReturned from self.principalReceivable to self.debt economics { purpose: internal, sourceParty: programOperator }
+    moves self.profitReceivable.balance from self.profitReceivable to self.debt economics { purpose: internal, sourceParty: programOperator }
+    moves self.profitEarned.balance from self.profitEarned to self.debt economics { purpose: internal, sourceParty: programOperator }
+    // Each attachment's oldest open charge settles that attachment's charges in
+    // one cash transfer; four attachments per kind are enough for any program
+    // and settle_payoff refuses if a charge is still open.
+    invoke: [
+      { selection: { instrument: all(financing.late_charge), reference: "plan", anchor: self.id, states: [assessed], limit: 1, batch: true, order: [overdueAt] }, action: payoff, input: {} }
+      { selection: { instrument: all(financing.late_charge), reference: "plan", anchor: self.id, states: [assessed], limit: 1, batch: true, order: [overdueAt] }, action: payoff, input: {} }
+      { selection: { instrument: all(financing.late_charge), reference: "plan", anchor: self.id, states: [assessed], limit: 1, batch: true, order: [overdueAt] }, action: payoff, input: {} }
+      { selection: { instrument: all(financing.late_charge), reference: "plan", anchor: self.id, states: [assessed], limit: 1, batch: true, order: [overdueAt] }, action: payoff, input: {} }
+      { selection: { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.id, states: [assessed], limit: 1, batch: true, order: [overdueAt] }, action: payoff, input: {} }
+      { selection: { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.id, states: [assessed], limit: 1, batch: true, order: [overdueAt] }, action: payoff, input: {} }
+      { selection: { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.id, states: [assessed], limit: 1, batch: true, order: [overdueAt] }, action: payoff, input: {} }
+      { selection: { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.id, states: [assessed], limit: 1, batch: true, order: [overdueAt] }, action: payoff, input: {} }
+    ]
+    invoke: [{ selection: { instrument: slice, reference: "plan", anchor: self.id, states: [pending, due], limit: max_term, order: [position] }, action: payoff, input: { identity: { field: self.settlementIdentity } } }, { reference: self.id, action: settle_payoff, input: {} }]
   }
-  action record_payoff {
+  action settle_payoff {
     from: paid, to: paid, actor: { parent: current() }
-    calculate: [{ target: profitReturned, op: aggregate, selection: { instrument: slice, reference: "plan", anchor: self.id, states: [paid], limit: 366, where: { payoffIdentity: { field: self.settlementIdentity } } }, measure: { sum: "payoffProfit" } }]
-    invoke: [{ instrument: settlement, action: create, input: { plan: { field: self.id }, identity: { field: self.settlementIdentity }, principal: { field: self.principalReturned }, profit: { field: self.profitReturned }, loss: { literal: "0" }, kind: { literal: "cash" } } }]
+    requires self.fineReceivable.balance == "0"
+    requires self.costReceivable.balance == "0"
+    invoke: [{ instrument: settlement, action: create, input: { plan: { field: self.id }, identity: { field: self.settlementIdentity }, principal: { field: self.principalReturned }, profit: { field: self.payoffProfit }, loss: { literal: "0" }, kind: { literal: "cash" } } }]
   }
-  action write_off {
+  action write_off { allowZero: true,
     from: active, to: written_off, actor: { parent: write_off_request }
     input { overdueSlice: ref<slice> }
-    calculate: [{ target: "lossRecorded", op: "aggregate", selection: { instrument: slice, reference: "plan", anchor: self.id, states: [pending, due], limit: 366 }, measure: { sum: "principalReceivable.balance" } }, { target: refundWindow, op: shift, date: { field: self.now }, milliseconds: { literal: refund_within }, direction: after }]
+    calculate: [{ target: lossRecorded, op: sum, values: [{ field: self.principalReceivable.balance }] }, { target: refundWindow, op: shift, date: { field: self.now }, milliseconds: { literal: refund_within }, direction: after }]
     set: { refundUntil: { field: self.refundWindow } }
     due: { at: input.overdueSlice.lossEligibleAt }
-    requires input.overdueSlice.plan == self.id; requires input.overdueSlice.principalReceivable.balance > "0"
+    requires input.overdueSlice.plan == self.id; requires input.overdueSlice.openPrincipal > "0"
+    moves self.lossRecorded from self.principalReceivable to self.loss economics { purpose: internal, sourceParty: programOperator }
+    moves self.profitReceivable.balance from self.profitReceivable to self.debt economics { purpose: internal, sourceParty: programOperator }
+    moves self.profitEarned.balance from self.profitEarned to self.loss economics { purpose: internal, sourceParty: programOperator }
     when disburse_to is funds { invoke: [{ reference: self.funds, action: write_off, input: { plan: { field: self.id } } }] }
-    invoke: [{ selection: { instrument: slice, reference: "plan", anchor: self.id, states: [pending, due], limit: 366, order: [position] }, action: write_off, input: {} }, { instrument: settlement, action: create, input: { plan: { field: self.id }, identity: { field: self.settlementIdentity }, principal: { literal: "0" }, profit: { literal: "0" }, loss: { field: self.lossRecorded }, kind: { literal: "loss" } } }]
+    invoke: [{ selection: { instrument: slice, reference: "plan", anchor: self.id, states: [pending, due], limit: max_term, order: [position] }, action: write_off, input: {} }, { instrument: settlement, action: create, input: { plan: { field: self.id }, identity: { field: self.settlementIdentity }, principal: { literal: "0" }, profit: { literal: "0" }, loss: { field: self.lossRecorded }, kind: { literal: "loss" } } }]
   }
   action record_payment {
     from: active, to: active, actor: { parent: payment }
     input { identity: text, principal: money, profit: money }
     calculate: [
-      { target: openSlices, op: aggregate, selection: { instrument: slice, reference: "plan", anchor: self.id, states: [pending, due], limit: 366 }, measure: count }
-      { target: openCharges, op: aggregate, selection: { instrument: all(financing.late_charge), reference: "plan", anchor: self.id, states: [assessed, collected], limit: 366 }, measure: { sum: "receivable.balance" } }
-      { target: openCosts, op: aggregate, selection: { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.id, states: [assessed, collected], limit: 366 }, measure: { sum: "receivable.balance" } }
+      { target: openSlices, op: aggregate, selection: { instrument: slice, reference: "plan", anchor: self.id, states: [pending, due], limit: max_term }, measure: count }
+      { target: openCharges, op: sum, values: [{ field: self.fineReceivable.balance }] }
+      { target: openCosts, op: sum, values: [{ field: self.costReceivable.balance }] }
     ]
     invoke: [{ instrument: settlement, action: create, input: { plan: { field: self.id }, identity: { field: input.identity }, principal: { field: input.principal }, profit: { field: input.profit }, loss: { literal: "0" }, kind: { literal: "cash" } } }]
     invoke: [{ selection: { instrument: current(), reference: "borrowerLimit", anchor: self.borrowerLimit, states: [active], limit: 1, where: { id: { field: self.id }, openSlices: { literal: 0 }, openCharges: { literal: "0" }, openCosts: { literal: "0" } } }, action: complete, input: {} }]
@@ -201,24 +260,27 @@ instrument installments(months: integer(1, 366), max_history: integer(2, 366) =
     from: active, to: cancelled, actor: { party: capital }
     calculate: [
       { target: refundWindow, op: shift, date: { field: self.now }, milliseconds: { literal: refund_within }, direction: after }
-      { target: principalOutstanding, op: aggregate, selection: { instrument: slice, reference: "plan", anchor: self.id, states: [pending, due], limit: 366 }, measure: { sum: "principalReceivable.balance" } }
+      { target: principalOutstanding, op: sum, values: [{ field: self.principalReceivable.balance }] }
       { target: principalRepaid, op: subtract, base: { field: self.principal }, subtract: [{ field: self.principalOutstanding }] }
     ]
     set: { refundUntil: { field: self.refundWindow } }
     when disburse_to is borrower { requires true == false }
     when returned_goods is refund_all {
-      requires count of { instrument: payment, reference: "plan", anchor: self.id, states: [paid], limit: 366 } == 0
-      requires count of { instrument: all(financing.late_charge), reference: "plan", anchor: self.id, states: [collected], limit: 366 } == 0
-      requires count of { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.id, states: [collected], limit: 366 } == 0
+      requires count of { instrument: payment, reference: "plan", anchor: self.id, states: [paid], limit: 1, batch: true } == 0
+      requires count of { instrument: all(financing.late_charge), reference: "plan", anchor: self.id, states: [collected], limit: 1, batch: true } == 0
+      requires count of { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.id, states: [collected], limit: 1, batch: true } == 0
     }
-    requires count of { instrument: all(financing.late_charge), reference: "plan", anchor: self.id, states: [assessed], limit: 366 } == 0
-    requires count of { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.id, states: [assessed], limit: 366 } == 0
+    requires count of { instrument: all(financing.late_charge), reference: "plan", anchor: self.id, states: [assessed], limit: 1, batch: true } == 0
+    requires count of { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.id, states: [assessed], limit: 1, batch: true } == 0
     when disburse_to is funds { invoke: [{ reference: self.funds, action: refund, input: { plan: { field: self.id }, principal: { field: self.principalOutstanding } } }] }
     when disburse_to is seller {
       moves self.principalOutstanding from seller to self.capital economics { purpose: principal, sourceParty: seller }
       moves self.principalRepaid from seller to self.borrower economics { purpose: principal, sourceParty: seller }
     }
-    invoke: [{ selection: { instrument: slice, reference: "plan", anchor: self.id, states: [pending, due], limit: 366, order: [position] }, action: cancel, input: {} }]
+    moves self.principalOutstanding from self.principalReceivable to self.debt economics { purpose: internal, sourceParty: programOperator }
+    moves self.profitReceivable.balance from self.profitReceivable to self.debt economics { purpose: internal, sourceParty: programOperator }
+    moves self.profitEarned.balance from self.profitEarned to self.debt economics { purpose: internal, sourceParty: programOperator }
+    invoke: [{ selection: { instrument: slice, reference: "plan", anchor: self.id, states: [pending, due], limit: max_term, order: [position] }, action: cancel, input: {} }]
   }
   action unwind_undelivered { allowZero: true,
     from: active, to: cancelled, actor: { party: programOperator }
@@ -226,10 +288,15 @@ instrument installments(months: integer(1, 366), max_history: integer(2, 366) =
     set: { refundUntil: { field: self.refundWindow } }
     when disburse_to is borrower { requires true == false }
     when disburse_to is seller { requires true == false }
-    requires count of { instrument: payment, reference: "plan", anchor: self.id, states: [paid], limit: 366 } == 0
-    requires count of { instrument: all(financing.late_charge), reference: "plan", anchor: self.id, states: [collected], limit: 366 } == 0
-    requires count of { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.id, states: [collected], limit: 366 } == 0
-    invoke: [{ selection: { instrument: slice, reference: "plan", anchor: self.id, states: [pending, due], limit: 366, order: [position] }, action: cancel, input: {} }]
+    requires count of { instrument: payment, reference: "plan", anchor: self.id, states: [paid], limit: 1, batch: true } == 0
+    requires count of { instrument: all(financing.late_charge), reference: "plan", anchor: self.id, states: [collected], limit: 1, batch: true } == 0
+    requires count of { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.id, states: [collected], limit: 1, batch: true } == 0
+    moves self.principalReceivable.balance from self.principalReceivable to self.debt economics { purpose: internal, sourceParty: programOperator }
+    moves self.profitReceivable.balance from self.profitReceivable to self.debt economics { purpose: internal, sourceParty: programOperator }
+    moves self.profitEarned.balance from self.profitEarned to self.debt economics { purpose: internal, sourceParty: programOperator }
+    moves self.fineReceivable.balance from self.fineReceivable to self.debt economics { purpose: internal, sourceParty: programOperator }
+    moves self.costReceivable.balance from self.costReceivable to self.debt economics { purpose: internal, sourceParty: programOperator }
+    invoke: [{ selection: { instrument: slice, reference: "plan", anchor: self.id, states: [pending, due], limit: max_term, order: [position] }, action: cancel, input: {} }]
     invoke: [{ selection: { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.id, states: [proposed, assessed], limit: 366 }, action: cancel_undelivered, input: {} }, { selection: { instrument: all(financing.late_charge), reference: "plan", anchor: self.id, states: [proposed, assessed], limit: 366 }, action: cancel_undelivered, input: {} }]
     when disburse_to is funds { invoke: [{ reference: self.funds, action: cancel_undelivered, input: { plan: { field: self.id } } }] }
   }
@@ -244,22 +311,61 @@ instrument installments(months: integer(1, 366), max_history: integer(2, 366) =
     }
   }
   action unwind_paid {
-    from: paid, to: cancelled, actor: { party: programOperator }
+    from: paid, to: unwinding, actor: { party: programOperator }
     when disburse_to is borrower { requires true == false }
     when disburse_to is seller { requires true == false }
-    invoke: [{ selection: { instrument: settlement, reference: "plan", anchor: self.id, states: [recorded], limit: max_history }, action: unwind, input: {} }, { selection: { instrument: profit_piece, reference: "plan", anchor: self.id, states: [paid], limit: max_history, where: { payment.status: { literal: "refunded" } } }, action: refund, input: {} }, { selection: { instrument: payment, reference: "plan", anchor: self.id, states: [paid], limit: max_history }, action: unwind, input: {} }, { reference: self.id, action: unwind_payoff_profit, input: {} }]
-    invoke: [{ selection: { instrument: all(financing.late_charge.receipt), reference: "plan", anchor: self.id, states: [paid], limit: max_history }, action: refund, input: {} }, { selection: { instrument: all(financing.late_charge.cost.receipt), reference: "plan", anchor: self.id, states: [paid], limit: max_history }, action: refund, input: {} }, { selection: { instrument: all(financing.late_charge), reference: "plan", anchor: self.id, states: [collected], limit: max_history }, action: unwind_payoff, input: {} }, { selection: { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.id, states: [collected], limit: max_history }, action: unwind_payoff, input: {} }]
-    invoke: [{ selection: { instrument: slice, reference: "plan", anchor: self.id, states: [pending, due, paid], limit: 366, order: [position] }, action: cancel, input: {} }]
-    invoke: [{ selection: { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.id, states: [proposed, assessed, collected], limit: max_history }, action: cancel_undelivered, input: {} }, { selection: { instrument: all(financing.late_charge), reference: "plan", anchor: self.id, states: [proposed, assessed, collected], limit: max_history }, action: cancel_undelivered, input: {} }]
+    when disburse_to is funds {
+      requires self.funds.funds.deliverBy < self.now
+      when returned_goods is keep_profit { requires self.funds.funds in [funded] }
+      when returned_goods is refund_all { requires self.funds.funds in [funded, return_verified] }
+    }
+    invoke: [{ reference: self.id, action: unwind_batch, input: {} }]
+  }
+  action unwind_step {
+    from: unwinding, to: unwinding, actor: clock, due: { at: self.unwindAt }
+    invoke: [{ reference: self.id, action: unwind_batch, input: {} }]
+  }
+  // One batch stays under one 253-transfer operation: 64 payments at two
+  // transfers, 16 fine and 16 cost receipts at one, and the closing transfers.
+  action unwind_batch {
+    from: unwinding, to: unwinding, actor: { parent: current() }
+    calculate: [{ target: unwindAt, op: shift, date: { field: self.now }, milliseconds: { literal: 1s }, direction: after }]
+    invoke: [
+      { selection: { instrument: payment, reference: "plan", anchor: self.id, states: [paid], limit: 64, batch: true }, action: unwind_paid, input: {} }
+      { selection: { instrument: all(financing.late_charge.receipt), reference: "plan", anchor: self.id, states: [paid], limit: 16, batch: true }, action: unwind, input: {} }
+      { selection: { instrument: all(financing.late_charge.cost.receipt), reference: "plan", anchor: self.id, states: [paid], limit: 16, batch: true }, action: unwind, input: {} }
+      { reference: self.id, action: unwind_check, input: {} }
+    ]
+  }
+  action unwind_check {
+    from: unwinding, to: unwinding, actor: { parent: current() }
+    calculate: [
+      { target: paymentsLeft, op: aggregate, selection: { instrument: payment, reference: "plan", anchor: self.id, states: [paid], limit: 1, batch: true }, measure: count }
+      { target: finesLeft, op: aggregate, selection: { instrument: all(financing.late_charge.receipt), reference: "plan", anchor: self.id, states: [paid], limit: 1, batch: true }, measure: count }
+      { target: costsLeft, op: aggregate, selection: { instrument: all(financing.late_charge.cost.receipt), reference: "plan", anchor: self.id, states: [paid], limit: 1, batch: true }, measure: count }
+    ]
+    invoke: [{ selection: { instrument: current(), reference: "borrowerLimit", anchor: self.borrowerLimit, states: [unwinding], limit: 1, where: { id: { field: self.id }, paymentsLeft: { literal: 0 }, finesLeft: { literal: 0 }, costsLeft: { literal: 0 } } }, action: finish_unwind, input: {} }]
+  }
+  action finish_unwind { allowZero: true,
+    from: unwinding, to: cancelled, actor: { parent: current() }
+    calculate: [{ target: payoffRefunds, op: aggregate, selection: { instrument: settlement, reference: "plan", anchor: self.id, states: [recorded], limit: 1, where: { identity: { field: self.settlementIdentity } } }, measure: count }]
+    moves self.principalReceivable.balance from self.principalReceivable to self.debt economics { purpose: internal, sourceParty: programOperator }
+    moves self.profitReceivable.balance from self.profitReceivable to self.debt economics { purpose: internal, sourceParty: programOperator }
+    moves self.profitEarned.balance from self.profitEarned to self.debt economics { purpose: internal, sourceParty: programOperator }
+    moves self.fineReceivable.balance from self.fineReceivable to self.debt economics { purpose: internal, sourceParty: programOperator }
+    moves self.costReceivable.balance from self.costReceivable to self.debt economics { purpose: internal, sourceParty: programOperator }
+    invoke: [{ selection: { instrument: settlement, reference: "plan", anchor: self.id, states: [recorded], limit: 1, where: { identity: { field: self.settlementIdentity } } }, action: unwind, input: {} }, { reference: self.id, action: unwind_payoff_profit, guard: { kind: compare, left: { field: self.payoffRefunds }, operator: "==", right: { literal: 1 } }, input: {} }]
+    invoke: [{ selection: { instrument: all(financing.late_charge), reference: "plan", anchor: self.id, states: [collected], limit: 4, where: { payoffLed: { literal: 1 } } }, action: unwind_payoff, input: {} }, { selection: { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.id, states: [collected], limit: 4, where: { payoffLed: { literal: 1 } } }, action: unwind_payoff, input: {} }]
+    invoke: [{ selection: { instrument: slice, reference: "plan", anchor: self.id, states: [pending, due, paid], limit: max_term, order: [position] }, action: cancel, input: {} }]
+    invoke: [{ selection: { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.id, states: [proposed, assessed, collected], limit: 366 }, action: cancel_undelivered, input: {} }, { selection: { instrument: all(financing.late_charge), reference: "plan", anchor: self.id, states: [proposed, assessed, collected], limit: 366 }, action: cancel_undelivered, input: {} }]
     when disburse_to is funds {
       when returned_goods is keep_profit { invoke: [{ reference: self.funds, action: unwind_paid_undelivered, input: { plan: { field: self.id } } }] }
       when returned_goods is refund_all { invoke: [{ reference: self.funds, action: unwind_paid, input: { plan: { field: self.id } } }] }
     }
   }
-  action unwind_payoff_profit {
+  action unwind_payoff_profit { allowZero: true,
     from: cancelled, to: cancelled, actor: { parent: current() }
-    calculate: [{ target: payoffRefunds, op: aggregate, selection: { instrument: settlement, reference: "plan", anchor: self.id, states: [refunded], limit: 1, where: { identity: { field: self.settlementIdentity } } }, measure: count }]
-    invoke: [{ selection: { instrument: slice, reference: "plan", anchor: self.id, states: [paid], limit: 366, where: { payoffIdentity: { field: self.settlementIdentity } } }, action: unwind_payoff, guard: { kind: compare, left: { field: self.payoffRefunds }, operator: "==", right: { literal: 1 } }, input: {} }]
+    moves self.payoffProfit from self.profitIncome to self.borrower economics { recipient: capital, company: { purpose: earning, sourceParty: capital, reversalOf: self.payoffReceipt }, participant: unclassified }
   }
   records {
     write_off_request: {
@@ -281,37 +387,25 @@ instrument installments(months: integer(1, 366), max_history: integer(2, 366) =
       action create {
         requires self.plan in [active]
         set: { revision: { field: self.productRevision }, effectiveAt: { field: self.now } }
-        invoke: [
-          { selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending], limit: 366 }, action: quote_pending, input: { quote: { field: self.id } } }
-          { selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [due], limit: 366 }, action: quote_due, input: { quote: { field: self.id } } }
-          { reference: self.id, action: record, input: {} }
-        ]
-      }
-      action record {
-        from: quoted, to: quoted, actor: { parent: current() }
         calculate: [
-          { target: principal, op: aggregate, selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due, paid], limit: 366 }, measure: { sum: "principalReceivable.balance" } }
-          { target: earnedProfit, op: aggregate, selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due, paid], limit: 366 }, measure: { sum: "profitEarned.balance" } }
-          { target: unearnedProfit, op: aggregate, selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due, paid], limit: 366 }, measure: { sum: "profitReceivable.balance" } }
-          { target: rebate, op: aggregate, selection: { instrument: quote_piece, reference: "quote", anchor: self.id, states: [recorded], limit: 366 }, measure: { sum: "rebate" } }
-          { target: fines, op: aggregate, selection: { instrument: all(financing.late_charge), reference: "plan", anchor: self.plan, states: [assessed, collected], limit: 366 }, measure: { sum: "receivable.balance" } }
-          { target: costs, op: aggregate, selection: { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.plan, states: [assessed, collected], limit: 366 }, measure: { sum: "receivable.balance" } }
+          { target: principal, op: sum, values: [{ field: self.plan.principalReceivable.balance }] }
+          { target: earnedProfit, op: sum, values: [{ field: self.plan.profitEarned.balance }] }
+          { target: unearnedProfit, op: sum, values: [{ field: self.plan.profitReceivable.balance }] }
+          { target: rebate, op: rate, base: { field: self.unearnedProfit }, bps: { literal: payoff_rebate }, rounding: floor }
+          { target: fines, op: sum, values: [{ field: self.plan.fineReceivable.balance }] }
+          { target: costs, op: sum, values: [{ field: self.plan.costReceivable.balance }] }
           { target: gross, op: sum, values: [{ field: self.principal }, { field: self.earnedProfit }, { field: self.unearnedProfit }, { field: self.fines }, { field: self.costs }] }
           { target: amount, op: subtract, base: { field: self.gross }, subtract: [{ field: self.rebate }] }
         ]
       }
     }
-    quote_piece: {
-      fields { quote: ref<payoff_quote>, slice: ref<slice>, rebate: money = rate(self.slice.profitReceivable.balance, payoff_rebate) }
-      lifecycle { states: [recorded], initial: recorded }
-      action create { actor: { parent: slice }, input { quote: ref<payoff_quote>, slice: ref<slice> }, requires unique "payoff_slice_quote" on [self.quote, self.slice] }
-    }
     amendment: {
       fields {
-        plan: ref<parent>, dates: list(date, months), agreement: text, waiverPercent: percent, waiverEvidence: text, maximumWaiver: percent = waiver_limit
+        plan: ref<parent>, dates: list(date, max_term), agreement: text, waiverPercent: percent, waiverEvidence: text, maximumWaiver: percent = waiver_limit
         revision: text?, acceptedAt: date?, staleReason: text?, expiresAt: date = after(self.createdAt, amendment_expiry)
         fineDisposition: enum(carry, require_waiver) = assessed_fines, addedProfit: money = 0 SAR
         principalSnapshot: money?, earnedProfitSnapshot: money?, unearnedProfitSnapshot: money?, finesSnapshot: money?, costsSnapshot: money?
+        finesWaived: money?, costsWaived: money?
         extension: duration = max_extension, maximum: integer = max_amendments
       }
       lifecycle { states: [proposed, applied, declined, withdrawn, expired, superseded], initial: proposed }
@@ -320,14 +414,14 @@ instrument installments(months: integer(1, 366), max_history: integer(2, 366) =
         requires self.plan in [active]; requires self.waiverPercent <= self.maximumWaiver
         set: { revision: { field: self.productRevision } }
         calculate: [
-          { target: principalSnapshot, op: aggregate, selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due, paid], limit: 366 }, measure: { sum: "principalReceivable.balance" } }
-          { target: earnedProfitSnapshot, op: aggregate, selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due, paid], limit: 366 }, measure: { sum: "profitEarned.balance" } }
-          { target: unearnedProfitSnapshot, op: aggregate, selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due, paid], limit: 366 }, measure: { sum: "profitReceivable.balance" } }
-          { target: finesSnapshot, op: aggregate, selection: { instrument: all(financing.late_charge), reference: "plan", anchor: self.plan, states: [assessed, collected], limit: 366 }, measure: { sum: "receivable.balance" } }
-          { target: costsSnapshot, op: aggregate, selection: { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.plan, states: [assessed, collected], limit: 366 }, measure: { sum: "receivable.balance" } }
+          { target: principalSnapshot, op: sum, values: [{ field: self.plan.principalReceivable.balance }] }
+          { target: earnedProfitSnapshot, op: sum, values: [{ field: self.plan.profitEarned.balance }] }
+          { target: unearnedProfitSnapshot, op: sum, values: [{ field: self.plan.profitReceivable.balance }] }
+          { target: finesSnapshot, op: sum, values: [{ field: self.plan.fineReceivable.balance }] }
+          { target: costsSnapshot, op: sum, values: [{ field: self.plan.costReceivable.balance }] }
         ]
         requires count of { instrument: current(), reference: "plan", anchor: self.plan, states: [applied], limit: 366 } < self.maximum
-        invoke: [{ range: { count: { literal: months }, maximum: months, bind: position }, instrument: proposed_date, action: create, input: { amendment: { field: self.id }, position: { field: position } } }, { selection: { instrument: proposed_date, reference: "amendment", anchor: self.id, states: [recorded], limit: 366, where: { first: { literal: 0 } } }, action: check_order, input: {} }]
+        invoke: [{ range: { count: { field: self.plan.months }, maximum: max_term, bind: position }, instrument: proposed_date, action: create, input: { amendment: { field: self.id }, position: { field: position } } }, { selection: { instrument: proposed_date, reference: "amendment", anchor: self.id, states: [recorded], limit: max_term, where: { first: { literal: 0 } } }, action: check_order, input: {} }]
       }
       action accept {
         from: proposed, to: applied, actor: { party: borrower }, deadline: { at: self.expiresAt }
@@ -335,10 +429,20 @@ instrument installments(months: integer(1, 366), max_history: integer(2, 366) =
         requires count of { instrument: current(), reference: "plan", anchor: self.plan, states: [applied], limit: 366 } < self.maximum
         set: { acceptedAt: { field: self.now } }
         when assessed_fines is require_waiver { requires self.waiverPercent == 10000 }
-        invoke: [{ selection: { instrument: all(financing.late_charge), reference: "plan", anchor: self.plan, states: [assessed, collected], limit: 366 }, action: waive_for_amendment, input: { amendment: { field: self.id } } }, { selection: { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.plan, states: [assessed, collected], limit: 366 }, action: waive_for_amendment, input: { amendment: { field: self.id } } }]
+        invoke: [{ selection: { instrument: all(financing.late_charge), reference: "plan", anchor: self.plan, states: [assessed, collected], limit: 366 }, action: waive_for_amendment, input: { amendment: { field: self.id } } }, { selection: { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.plan, states: [assessed, collected], limit: 366 }, action: waive_for_amendment, input: { amendment: { field: self.id } } }, { reference: self.id, action: record_waivers, input: {} }]
         invoke: [{ selection: { instrument: all(collections.case), reference: "plan", anchor: self.plan, states: [opened, assigned], limit: 366 }, action: recall, input: {} }, { selection: { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.plan, states: [proposed], limit: 366 }, action: cancel_for_amendment, input: {} }, { selection: { instrument: all(financing.late_charge), reference: "plan", anchor: self.plan, states: [proposed], limit: 366 }, action: cancel_for_amendment, input: {} }]
-        invoke: [{ selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due], limit: 366, order: [position] }, action: amend, input: { amendment: { field: self.id } } }]
-        invoke: [{ selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [paid], limit: 366 }, action: verify_fixed_date, input: { amendment: { field: self.id } } }]
+        invoke: [{ selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due], limit: max_term, order: [position] }, action: amend, input: { amendment: { field: self.id } } }]
+        invoke: [{ selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [paid], limit: max_term }, action: verify_fixed_date, input: { amendment: { field: self.id } } }]
+      }
+      // The waivers are state on each charge; the plan's claims drop once per kind.
+      action record_waivers { allowZero: true,
+        from: applied, to: applied, actor: { parent: current() }
+        calculate: [
+          { target: finesWaived, op: aggregate, selection: { instrument: all(financing.late_charge.waiver), reference: "amendment", anchor: self.id, states: [recorded], limit: 366 }, measure: { sum: "amount" } }
+          { target: costsWaived, op: aggregate, selection: { instrument: all(financing.late_charge.cost.waiver), reference: "amendment", anchor: self.id, states: [recorded], limit: 366 }, measure: { sum: "amount" } }
+        ]
+        moves self.finesWaived from self.plan.fineReceivable to self.plan.debt economics { purpose: internal, sourceParty: programOperator }
+        moves self.costsWaived from self.plan.costReceivable to self.plan.debt economics { purpose: internal, sourceParty: programOperator }
       }
       action withdraw { from: proposed, to: withdrawn, actor: { party: capital } }
       action decline { from: proposed, to: declined, actor: { party: borrower } }
@@ -346,9 +450,9 @@ instrument installments(months: integer(1, 366), max_history: integer(2, 366) =
       action supersede { from: proposed, to: superseded, requires self.revision != self.productRevision, set: { staleReason: { literal: "economic_revision_changed" } } }
     }
     proposed_date: {
-      fields { amendment: ref<amendment>, position: integer(1, months), date: date = at(self.amendment.dates, self.position), first: integer = divide(1, self.position), prior: integer = subtract(self.position, 1), previousPosition: integer = sum(self.prior, self.first), previous: date = at(self.amendment.dates, self.previousPosition) }
+      fields { amendment: ref<amendment>, position: integer(1, max_term), date: date = at(self.amendment.dates, self.position), first: integer = divide(1, self.position), prior: integer = subtract(self.position, 1), previousPosition: integer = sum(self.prior, self.first), previous: date = at(self.amendment.dates, self.previousPosition) }
       lifecycle { states: [recorded], initial: recorded }
-      action create { actor: { parent: amendment }, input { amendment: ref<amendment>, position: integer(1, months) }, requires self.date >= self.previous }
+      action create { actor: { parent: amendment }, input { amendment: ref<amendment>, position: integer(1, max_term) }, requires self.date >= self.previous }
       action check_order { from: recorded, to: recorded, actor: { parent: amendment }, requires self.date > self.previous }
     }
     date_change: {
@@ -374,42 +478,46 @@ instrument installments(months: integer(1, 366), max_history: integer(2, 366) =
       action distribute { from: recorded, to: distributed, actor: { parent: all(lending.distribution) } }
       // profitIncome is one account per capital party, so refunding profit a
       // distribution already paid out would spend other plans' profit. unwind_paid
-      // unwinds only settlements still recorded; each marks its payment refunded,
-      // and the plan refunds the profit pieces and payoff profit behind them.
+      // unwinds only settlements still recorded, and each payment refunds its
+      // profit only when its settlement was one of them.
       action unwind { allowZero: true,
-        from: recorded, to: refunded, actor: { parent: parent }
+        from: recorded, to: refunded, actor: { parent: [parent, payment] }
         moves self.share from self.allocatedPayable to self.profitIncome economics { purpose: internal, sourceParty: capital }
-        invoke: [{ selection: { instrument: payment, reference: "plan", anchor: self.plan, states: [paid], limit: 1, where: { paymentIdentity: { field: self.identity } } }, action: unwind, input: {} }]
       }
     }
     slice: {
       revisioned: true
       fields {
-        plan: ref<parent>, borrowerLimit: ref<limits>, portfolioLimit: ref<portfolio>, position: integer(1, months)
+        plan: ref<parent>, borrowerLimit: ref<limits>, portfolioLimit: ref<portfolio>, position: integer(1, max_term)
         originalDueAt: date = at(self.plan.dates, self.position), dueAt: date?, nextDueAt: date?, previousDueAt: date?, prior: integer = subtract(self.position, 1), previousPosition: integer = sum(self.prior, self.first), previousDate: date = at(self.plan.dates, self.previousPosition), extensionLimit: date = after(self.originalDueAt, max_extension), lossEligibleAt: date?
         first: integer = divide(1, self.position)
         principalBase: money?, principalAllocated: money?, principalRemainder: money?, principalAdjustment: money?
         profitBase: money?, profitAllocated: money?, profitRemainder: money?, profitAdjustment: money?
         principal: money, profit: money, instalment: money
-        principalReceivable: account(self, claim), profitReceivable: account(self, claim), profitEarned: account(self, claim)
-        payoffIdentity: text?, payoffRebate: money?, payoffProfitTotal: money?, payoffProfit: money?, payoffReceipt: text?
-        paymentBudget: money?, principalPayment: money?, principalBasePayment: money?, principalRatio: money?, profitPayment: money?, profitBudget: money?, collectibleProfit: money?, collectibleTotal: money?, ratioDenominator: integer = sum(10000, profit_rate)
-        debt: account(borrower, claim, contra, "debt"), loss: account(capital, claim, "loss")
+        openPrincipal: money?, openProfit: money?, earnedProfit: money?, payoffIdentity: text?
+        collectibleProfit: money?, collectibleTotal: money?, paymentBudget: money?, principalRatio: money?, principalBasePayment: money?, profitBudget: money?
+        principalTake: money?, profitTake: money?, afterTake: money?, openProfitTake: money?, earnedProfitTake: money?, taken: money?
+        ratioDenominator: integer = sum(10000, profit_rate)
       }
       lifecycle { states: [draft, pending, due, paid, written_off, cancelled], initial: draft }
       action create {
         actor: { parent: parent }
-        input { plan: ref<parent>, borrowerLimit: ref<limits>, portfolioLimit: ref<portfolio>, position: integer(1, months) }
+        input { plan: ref<parent>, borrowerLimit: ref<limits>, portfolioLimit: ref<portfolio>, position: integer(1, max_term) }
         set: { dueAt: { field: self.originalDueAt } }
+        calculate: [
+          { target: openPrincipal, op: sum, values: [{ literal: "0" }] }
+          { target: openProfit, op: sum, values: [{ literal: "0" }] }
+          { target: earnedProfit, op: sum, values: [{ literal: "0" }] }
+        ]
         when pricing is flat_total {
           calculate: [
-            { target: principalBase, op: divide, amount: { field: self.plan.principal }, divisor: { literal: months }, rounding: floor }
-            { target: principalAllocated, op: multiply, amount: { field: self.principalBase }, units: { literal: months } }
+            { target: principalBase, op: divide, amount: { field: self.plan.principal }, divisor: { field: self.plan.months }, rounding: floor }
+            { target: principalAllocated, op: multiply, amount: { field: self.principalBase }, units: { field: self.plan.months } }
             { target: principalRemainder, op: subtract, base: { field: self.plan.principal }, subtract: [{ field: self.principalAllocated }] }
             { target: principalAdjustment, op: multiply, amount: { field: self.principalRemainder }, units: { field: self.first } }
             { target: principal, op: sum, values: [{ field: self.principalBase }, { field: self.principalAdjustment }] }
-            { target: profitBase, op: divide, amount: { field: self.plan.flatProfit }, divisor: { literal: months }, rounding: floor }
-            { target: profitAllocated, op: multiply, amount: { field: self.profitBase }, units: { literal: months } }
+            { target: profitBase, op: divide, amount: { field: self.plan.flatProfit }, divisor: { field: self.plan.months }, rounding: floor }
+            { target: profitAllocated, op: multiply, amount: { field: self.profitBase }, units: { field: self.plan.months } }
             { target: profitRemainder, op: subtract, base: { field: self.plan.flatProfit }, subtract: [{ field: self.profitAllocated }] }
             { target: profitAdjustment, op: multiply, amount: { field: self.profitRemainder }, units: { field: self.first } }
             { target: profit, op: sum, values: [{ field: self.profitBase }, { field: self.profitAdjustment }] }
@@ -418,8 +526,8 @@ instrument installments(months: integer(1, 366), max_history: integer(2, 366) =
         }
         when pricing is amortizing {
           calculate: [
-            { target: principal, op: annuity, amount: { field: self.plan.principal }, rate: { literal: profit_rate }, periods: { literal: months }, position: { field: self.position }, part: principal }
-            { target: profit, op: annuity, amount: { field: self.plan.principal }, rate: { literal: profit_rate }, periods: { literal: months }, position: { field: self.position }, part: interest }
+            { target: principal, op: annuity, amount: { field: self.plan.principal }, rate: { literal: profit_rate }, periods: { field: self.plan.months }, position: { field: self.position }, part: principal }
+            { target: profit, op: annuity, amount: { field: self.plan.principal }, rate: { literal: profit_rate }, periods: { field: self.plan.months }, position: { field: self.position }, part: interest }
             { target: instalment, op: sum, values: [{ field: self.principal }, { field: self.profit }] }
           ]
         }
@@ -428,16 +536,6 @@ instrument installments(months: integer(1, 366), max_history: integer(2, 366) =
         requires self.originalDueAt > self.now; requires self.originalDueAt >= self.previousDate
       }
       action check_order { from: draft, to: draft, actor: { parent: parent }, requires self.originalDueAt > self.previousDate }
-      action quote_pending {
-        from: pending, to: pending, actor: { parent: payoff_quote }, input { quote: ref<payoff_quote> }
-        requires input.quote.plan == self.plan
-        invoke: [{ instrument: quote_piece, action: create, input: { quote: { field: input.quote }, slice: { field: self.id } } }]
-      }
-      action quote_due {
-        from: due, to: due, actor: { parent: payoff_quote }, input { quote: ref<payoff_quote> }
-        requires input.quote.plan == self.plan
-        invoke: [{ instrument: quote_piece, action: create, input: { quote: { field: input.quote }, slice: { field: self.id } } }]
-      }
       action refresh_loss_date {
         from: [draft, pending, due], to: draft, actor: { parent: current() }
         calculate: [{ target: lossEligibleAt, op: shift, date: { field: self.dueAt }, milliseconds: { literal: write_off_after }, direction: after }]
@@ -460,96 +558,122 @@ instrument installments(months: integer(1, 366), max_history: integer(2, 366) =
         calculate: [{ target: nextDueAt, op: at, list: input.amendment.dates, position: { field: self.position } }]
         requires self.nextDueAt == self.dueAt
       }
-      action activate { allowZero: true,
+      // The plan posts the claims; a slice keeps its share as state.
+      action activate {
         from: draft, to: pending, actor: { parent: parent }
         requires self.dueAt > self.now
-        moves self.principal from self.debt to self.principalReceivable economics { purpose: internal, sourceParty: borrower }
-        moves self.profit from self.debt to self.profitReceivable economics { purpose: internal, sourceParty: borrower }
-        when profit_earned is at_disbursement { moves self.profit from self.profitReceivable to self.profitEarned economics { purpose: internal, sourceParty: programOperator } }
-        when profit_earned is by_schedule { invoke: [{ instrument: recognition, action: create, input: { slice: { field: self.id } } }] }
+        calculate: [{ target: openPrincipal, op: sum, values: [{ field: self.principal }] }]
+        when profit_earned is on_payment { calculate: [{ target: openProfit, op: sum, values: [{ field: self.profit }] }] }
+        when profit_earned is by_schedule {
+          calculate: [{ target: openProfit, op: sum, values: [{ field: self.profit }] }]
+          invoke: [{ instrument: recognition, action: create, input: { slice: { field: self.id } } }]
+        }
+        when profit_earned is at_disbursement { calculate: [{ target: earnedProfit, op: sum, values: [{ field: self.profit }] }] }
       }
       action mature {
         from: pending, to: due, actor: clock, due: { at: self.dueAt }
       }
+      action recognise {
+        from: [pending, due, paid, written_off, cancelled], to: preserve, actor: { parent: recognition }
+        calculate: [{ target: earnedProfit, op: sum, values: [{ field: self.earnedProfit }, { field: self.openProfit }] }]
+        invoke: [{ reference: self.id, action: clear_unearned, input: {} }]
+      }
+      action clear_unearned {
+        from: [pending, due, paid, written_off, cancelled], to: preserve, actor: { parent: current() }
+        calculate: [{ target: openProfit, op: sum, values: [{ literal: "0" }] }]
+      }
       action collect {
         from: [pending, due], to: preserve, actor: { parent: payment }
         input { payment: ref<payment> }
         requires input.payment.plan == self.plan
-        when profit_earned is on_payment { calculate: [{ target: collectibleProfit, op: sum, values: [{ field: self.profitReceivable.balance }] }] }
-        when profit_earned is by_schedule { calculate: [{ target: collectibleProfit, op: sum, values: [{ field: self.profitEarned.balance }] }] }
-        when profit_earned is at_disbursement { calculate: [{ target: collectibleProfit, op: sum, values: [{ field: self.profitEarned.balance }] }] }
-        when apply is principal_profit {
-          invoke: [
-            { instrument: principal_piece, action: create, input: { slice: { field: self.id }, payment: { field: input.payment }, limit: { field: self.principalReceivable.balance } } }
-            { instrument: profit_piece, action: create, input: { plan: { field: self.plan }, slice: { field: self.id }, payment: { field: input.payment }, limit: { field: self.collectibleProfit } } }
-            { selection: { instrument: current(), reference: "plan", anchor: self.plan, states: [pending, due], limit: 1, where: { id: { field: self.id }, principalReceivable.balance: { literal: "0" }, profitReceivable.balance: { literal: "0" }, profitEarned.balance: { literal: "0" } } }, action: complete, input: {} }
-          ]
-        }
+        when profit_earned is on_payment { calculate: [{ target: collectibleProfit, op: sum, values: [{ field: self.openProfit }] }] }
+        when profit_earned is by_schedule { calculate: [{ target: collectibleProfit, op: sum, values: [{ field: self.earnedProfit }] }] }
+        when profit_earned is at_disbursement { calculate: [{ target: collectibleProfit, op: sum, values: [{ field: self.earnedProfit }] }] }
+        calculate: [
+          { target: principalTake, op: minimum, values: [{ field: input.payment.unapplied }, { field: self.openPrincipal }] }
+          { target: afterTake, op: subtract, base: { field: input.payment.unapplied }, subtract: [{ field: self.principalTake }] }
+          { target: profitTake, op: minimum, values: [{ field: self.afterTake }, { field: self.collectibleProfit }] }
+        ]
+        invoke: [{ reference: self.id, action: take, input: { payment: { field: input.payment } } }]
       }
       action collect_waterfall {
         from: [pending, due], to: preserve, actor: { parent: payment }, input { payment: ref<payment> }
         requires input.payment.plan == self.plan
-        when profit_earned is on_payment { calculate: [{ target: collectibleProfit, op: sum, values: [{ field: self.profitReceivable.balance }] }] }
-        when profit_earned is by_schedule { calculate: [{ target: collectibleProfit, op: sum, values: [{ field: self.profitEarned.balance }] }] }
-        when profit_earned is at_disbursement { calculate: [{ target: collectibleProfit, op: sum, values: [{ field: self.profitEarned.balance }] }] }
-        invoke: [
-          { selection: { instrument: all(financing.late_charge), reference: "slice", anchor: self.id, states: [assessed], limit: charge_limit, order: [overdueAt] }, action: collect, input: { payment: { field: input.payment } } }
-          { selection: { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.plan, states: [assessed], limit: charge_limit, order: [overdueAt], where: { assessment.slice: { field: self.id } } }, action: collect, input: { payment: { field: input.payment } } }
-          { instrument: profit_piece, action: create, input: { plan: { field: self.plan }, slice: { field: self.id }, payment: { field: input.payment }, limit: { field: self.collectibleProfit } } }
-          { instrument: principal_piece, action: create, input: { slice: { field: self.id }, payment: { field: input.payment }, limit: { field: self.principalReceivable.balance } } }
-          { selection: { instrument: current(), reference: "plan", anchor: self.plan, states: [pending, due], limit: 1, where: { id: { field: self.id }, principalReceivable.balance: { literal: "0" }, profitReceivable.balance: { literal: "0" }, profitEarned.balance: { literal: "0" } } }, action: complete, input: {} }
+        when profit_earned is on_payment { calculate: [{ target: collectibleProfit, op: sum, values: [{ field: self.openProfit }] }] }
+        when profit_earned is by_schedule { calculate: [{ target: collectibleProfit, op: sum, values: [{ field: self.earnedProfit }] }] }
+        when profit_earned is at_disbursement { calculate: [{ target: collectibleProfit, op: sum, values: [{ field: self.earnedProfit }] }] }
+        calculate: [
+          { target: profitTake, op: minimum, values: [{ field: input.payment.unapplied }, { field: self.collectibleProfit }] }
+          { target: afterTake, op: subtract, base: { field: input.payment.unapplied }, subtract: [{ field: self.profitTake }] }
+          { target: principalTake, op: minimum, values: [{ field: self.afterTake }, { field: self.openPrincipal }] }
         ]
+        invoke: [{ reference: self.id, action: take, input: { payment: { field: input.payment } } }]
       }
       action collect_pro_rata {
         from: [pending, due], to: preserve, actor: { parent: payment }, input { payment: ref<payment> }
         requires input.payment.plan == self.plan
-        when profit_earned is on_payment { calculate: [{ target: collectibleProfit, op: sum, values: [{ field: self.profitReceivable.balance }] }] }
-        when profit_earned is by_schedule { calculate: [{ target: collectibleProfit, op: sum, values: [{ field: self.profitEarned.balance }] }] }
-        when profit_earned is at_disbursement { calculate: [{ target: collectibleProfit, op: sum, values: [{ field: self.profitEarned.balance }] }] }
+        when profit_earned is on_payment { calculate: [{ target: collectibleProfit, op: sum, values: [{ field: self.openProfit }] }] }
+        when profit_earned is by_schedule { calculate: [{ target: collectibleProfit, op: sum, values: [{ field: self.earnedProfit }] }] }
+        when profit_earned is at_disbursement { calculate: [{ target: collectibleProfit, op: sum, values: [{ field: self.earnedProfit }] }] }
         calculate: [
-          { target: collectibleTotal, op: sum, values: [{ field: self.principalReceivable.balance }, { field: self.collectibleProfit }] }
-          { target: paymentBudget, op: minimum, values: [{ field: input.payment.held.balance }, { field: self.collectibleTotal }] }
+          { target: collectibleTotal, op: sum, values: [{ field: self.openPrincipal }, { field: self.collectibleProfit }] }
+          { target: paymentBudget, op: minimum, values: [{ field: input.payment.unapplied }, { field: self.collectibleTotal }] }
         ]
         when pricing is flat_total { calculate: [{ target: principalRatio, op: ratio, amount: { field: self.paymentBudget }, numerator: { literal: 10000 }, denominator: { field: self.ratioDenominator }, rounding: floor }] }
         when pricing is amortizing { calculate: [{ target: principalRatio, op: ratio, amount: { field: self.paymentBudget }, numerator: { field: self.principal }, denominator: { field: self.instalment }, rounding: floor }] }
         calculate: [
-          { target: principalBasePayment, op: minimum, values: [{ field: self.principalRatio }, { field: self.principalReceivable.balance }] }
+          { target: principalBasePayment, op: minimum, values: [{ field: self.principalRatio }, { field: self.openPrincipal }] }
           { target: profitBudget, op: subtract, base: { field: self.paymentBudget }, subtract: [{ field: self.principalBasePayment }] }
-          { target: profitPayment, op: minimum, values: [{ field: self.profitBudget }, { field: self.collectibleProfit }] }
-          { target: principalPayment, op: subtract, base: { field: self.paymentBudget }, subtract: [{ field: self.profitPayment }] }
+          { target: profitTake, op: minimum, values: [{ field: self.profitBudget }, { field: self.collectibleProfit }] }
+          { target: principalTake, op: subtract, base: { field: self.paymentBudget }, subtract: [{ field: self.profitTake }] }
+        ]
+        invoke: [{ reference: self.id, action: take, input: { payment: { field: input.payment } } }]
+      }
+      // A collect action chose principalTake and profitTake; take records them
+      // as pieces, lowers the slice's open amounts and the payment's unapplied
+      // cash. The payment posts the cash and claim transfers once.
+      action take {
+        from: [pending, due], to: preserve, actor: { parent: current() }, input { payment: ref<payment> }
+        when profit_earned is on_payment { calculate: [{ target: openProfitTake, op: sum, values: [{ field: self.profitTake }] }, { target: earnedProfitTake, op: sum, values: [{ literal: "0" }] }] }
+        when profit_earned is by_schedule { calculate: [{ target: openProfitTake, op: sum, values: [{ literal: "0" }] }, { target: earnedProfitTake, op: sum, values: [{ field: self.profitTake }] }] }
+        when profit_earned is at_disbursement { calculate: [{ target: openProfitTake, op: sum, values: [{ literal: "0" }] }, { target: earnedProfitTake, op: sum, values: [{ field: self.profitTake }] }] }
+        calculate: [
+          { target: taken, op: sum, values: [{ field: self.principalTake }, { field: self.profitTake }] }
+          { target: openPrincipal, op: subtract, base: { field: self.openPrincipal }, subtract: [{ field: self.principalTake }] }
+          { target: openProfit, op: subtract, base: { field: self.openProfit }, subtract: [{ field: self.openProfitTake }] }
+          { target: earnedProfit, op: subtract, base: { field: self.earnedProfit }, subtract: [{ field: self.earnedProfitTake }] }
         ]
         invoke: [
-          { instrument: principal_piece, action: create, input: { slice: { field: self.id }, payment: { field: input.payment }, limit: { field: self.principalPayment } } }
-          { instrument: profit_piece, action: create, input: { plan: { field: self.plan }, slice: { field: self.id }, payment: { field: input.payment }, limit: { field: self.profitPayment } } }
-          { selection: { instrument: current(), reference: "plan", anchor: self.plan, states: [pending, due], limit: 1, where: { id: { field: self.id }, principalReceivable.balance: { literal: "0" }, profitReceivable.balance: { literal: "0" }, profitEarned.balance: { literal: "0" } } }, action: complete, input: {} }
+          { instrument: principal_piece, action: create, guard: { kind: compare, left: { field: self.principalTake }, operator: ">", right: { literal: "0" } }, input: { plan: { field: self.plan }, slice: { field: self.id }, payment: { field: input.payment }, amount: { field: self.principalTake } } }
+          { instrument: profit_piece, action: create, guard: { kind: compare, left: { field: self.profitTake }, operator: ">", right: { literal: "0" } }, input: { plan: { field: self.plan }, slice: { field: self.id }, payment: { field: input.payment }, amount: { field: self.profitTake } } }
+          { reference: input.payment, action: consume, input: { amount: { field: self.taken } } }
+          { selection: { instrument: current(), reference: "plan", anchor: self.plan, states: [pending, due], limit: 1, where: { id: { field: self.id }, openPrincipal: { literal: "0" }, openProfit: { literal: "0" }, earnedProfit: { literal: "0" } } }, action: complete, input: {} }
         ]
       }
       action complete {
         from: [pending, due], to: paid
-        requires self.principalReceivable.balance == "0"; requires self.profitReceivable.balance == "0"; requires self.profitEarned.balance == "0"
+        requires self.openPrincipal == "0"; requires self.openProfit == "0"; requires self.earnedProfit == "0"
       }
-      action restore { from: [pending, due, paid], to: pending, actor: { parent: payment } }
-      action payoff { allowZero: true,
+      action unpay {
+        from: [pending, due, paid], to: pending, actor: { parent: [principal_piece, profit_piece] }
+        input { principal: money, profit: money }
+        calculate: [{ target: openPrincipal, op: sum, values: [{ field: self.openPrincipal }, { field: input.principal }] }]
+        when profit_earned is on_payment { calculate: [{ target: openProfit, op: sum, values: [{ field: self.openProfit }, { field: input.profit }] }] }
+        when profit_earned is by_schedule { calculate: [{ target: earnedProfit, op: sum, values: [{ field: self.earnedProfit }, { field: input.profit }] }] }
+        when profit_earned is at_disbursement { calculate: [{ target: earnedProfit, op: sum, values: [{ field: self.earnedProfit }, { field: input.profit }] }] }
+      }
+      action payoff {
         from: [pending, due], to: paid, actor: { parent: parent }, input { identity: text }
         set: { payoffIdentity: { field: input.identity } }
-        calculate: [{ target: payoffRebate, op: rate, base: { field: self.profitReceivable.balance }, bps: { literal: payoff_rebate }, rounding: floor }, { target: payoffProfitTotal, op: sum, values: [{ field: self.profitReceivable.balance }, { field: self.profitEarned.balance }] }, { target: payoffProfit, op: subtract, base: { field: self.payoffProfitTotal }, subtract: [{ field: self.payoffRebate }] }]
-        moves self.principalReceivable.balance from self.plan.borrower to self.plan.capital economics { purpose: principal, sourceParty: borrower }
-        moves self.payoffProfit from self.plan.borrower to self.plan.profitIncome capture "payoffReceipt" economics { recipient: capital, company: { purpose: earning, sourceParty: borrower }, participant: { purpose: pass_through, sourceParty: borrower } }
-        moves self.principalReceivable.balance from self.principalReceivable to self.debt economics { purpose: internal, sourceParty: programOperator }
-        moves self.profitReceivable.balance from self.profitReceivable to self.debt economics { purpose: internal, sourceParty: programOperator }
-        moves self.profitEarned.balance from self.profitEarned to self.debt economics { purpose: internal, sourceParty: programOperator }
+        calculate: [{ target: openPrincipal, op: sum, values: [{ literal: "0" }] }, { target: openProfit, op: sum, values: [{ literal: "0" }] }, { target: earnedProfit, op: sum, values: [{ literal: "0" }] }]
       }
-      action unwind_payoff { allowZero: true,
-        from: paid, to: paid, actor: { parent: parent }
-        moves self.payoffProfit from self.plan.profitIncome to self.plan.borrower economics { recipient: capital, company: { purpose: earning, sourceParty: capital, reversalOf: self.payoffReceipt }, participant: unclassified }
-      }
-      action write_off { allowZero: true,
+      action write_off {
         from: [pending, due], to: written_off, actor: { parent: parent }
-        moves self.principalReceivable.balance from self.principalReceivable to self.loss economics { purpose: internal, sourceParty: programOperator }; moves self.profitReceivable.balance from self.profitReceivable to self.debt economics { purpose: internal, sourceParty: programOperator }; moves self.profitEarned.balance from self.profitEarned to self.loss economics { purpose: internal, sourceParty: programOperator }
+        calculate: [{ target: openPrincipal, op: sum, values: [{ literal: "0" }] }, { target: openProfit, op: sum, values: [{ literal: "0" }] }, { target: earnedProfit, op: sum, values: [{ literal: "0" }] }]
       }
-      action cancel { allowZero: true,
+      action cancel {
         from: [pending, due, paid], to: cancelled, actor: { parent: parent }
-        moves self.principalReceivable.balance from self.principalReceivable to self.debt economics { purpose: internal, sourceParty: programOperator }; moves self.profitReceivable.balance from self.profitReceivable to self.debt economics { purpose: internal, sourceParty: programOperator }; moves self.profitEarned.balance from self.profitEarned to self.debt economics { purpose: internal, sourceParty: programOperator }
+        calculate: [{ target: openPrincipal, op: sum, values: [{ literal: "0" }] }, { target: openProfit, op: sum, values: [{ literal: "0" }] }, { target: earnedProfit, op: sum, values: [{ literal: "0" }] }]
       }
     }
     recognition: {
@@ -557,100 +681,127 @@ instrument installments(months: integer(1, 366), max_history: integer(2, 366) =
       lifecycle { states: [pending, recognised], initial: pending }
       action create { actor: { parent: slice }, input { slice: ref<slice> }, requires unique "profit_recognition" on [self.slice] }
       action reschedule { from: pending, to: pending, actor: { parent: slice }, calculate: [{ target: dueAt, op: shift, date: { field: self.slice.dueAt }, milliseconds: { literal: 0 }, direction: after }] }
-      action mature { allowZero: true, from: pending, to: recognised, actor: clock, due: { at: self.dueAt }, moves self.slice.profitReceivable.balance from self.slice.profitReceivable to self.slice.profitEarned economics { purpose: internal, sourceParty: programOperator } }
+      action mature { allowZero: true,
+        from: pending, to: recognised, actor: clock, due: { at: self.dueAt }
+        moves self.slice.openProfit from self.slice.plan.profitReceivable to self.slice.plan.profitEarned economics { purpose: internal, sourceParty: programOperator }
+        invoke: [{ reference: self.slice, action: recognise, input: {} }]
+      }
     }
     payment: {
       revisioned: true
-      fields { plan: ref<parent>, amount: money, paymentIdentity: text, held: account of self
-        outstandingPrincipal: money?, outstandingProfit: money?, outstandingFines: money?, outstandingCosts: money?, outstandingTotal: money?, principalReturned: money?, profitReturned: money?, lossRecorded: money? }
+      fields { plan: ref<parent>, amount: money, paymentIdentity: text, held: account of self, cashReceipt: text?
+        outstandingPrincipal: money?, outstandingProfit: money?, outstandingFines: money?, outstandingCosts: money?, outstandingTotal: money?, unapplied: money?, principalReturned: money?, profitReturned: money?, settled: integer? }
 
       lifecycle { states: [pending, paid, refunded], initial: pending }
       action create { input { plan: ref<parent>, amount: money, paymentIdentity: text } requires self.plan in [active]; requires unique "payment_identity" on [self.plan, self.paymentIdentity] }
       action pay {
         from: pending, to: paid, actor: { party: borrower }
-        calculate: [{ target: outstandingPrincipal, op: aggregate, selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due, paid], limit: 366, order: [position] }, measure: { sum: "principalReceivable.balance" } }]
-        when profit_earned is on_payment { calculate: [{ target: outstandingProfit, op: aggregate, selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due, paid], limit: 366, order: [position] }, measure: { sum: "profitReceivable.balance" } }] }
-        when profit_earned is by_schedule { calculate: [{ target: outstandingProfit, op: aggregate, selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due, paid], limit: 366, order: [position] }, measure: { sum: "profitEarned.balance" } }] }
-        when profit_earned is at_disbursement { calculate: [{ target: outstandingProfit, op: aggregate, selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due, paid], limit: 366, order: [position] }, measure: { sum: "profitEarned.balance" } }] }
+        calculate: [{ target: outstandingPrincipal, op: sum, values: [{ field: self.plan.principalReceivable.balance }] }]
+        when profit_earned is on_payment { calculate: [{ target: outstandingProfit, op: sum, values: [{ field: self.plan.profitReceivable.balance }] }] }
+        when profit_earned is by_schedule { calculate: [{ target: outstandingProfit, op: sum, values: [{ field: self.plan.profitEarned.balance }] }] }
+        when profit_earned is at_disbursement { calculate: [{ target: outstandingProfit, op: sum, values: [{ field: self.plan.profitEarned.balance }] }] }
         when apply is fines_profit_principal {
-          calculate: [{ target: outstandingFines, op: aggregate, selection: { instrument: all(financing.late_charge), reference: "plan", anchor: self.plan, states: [assessed, collected], limit: 366, order: [overdueAt] }, measure: { sum: "receivable.balance" } }, { target: outstandingCosts, op: aggregate, selection: { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.plan, states: [assessed, collected], limit: 366, order: [overdueAt] }, measure: { sum: "receivable.balance" } }, { target: outstandingTotal, op: sum, values: [{ field: self.outstandingPrincipal }, { field: self.outstandingProfit }, { field: self.outstandingFines }, { field: self.outstandingCosts }] }]
+          calculate: [{ target: outstandingFines, op: sum, values: [{ field: self.plan.fineReceivable.balance }] }, { target: outstandingCosts, op: sum, values: [{ field: self.plan.costReceivable.balance }] }, { target: outstandingTotal, op: sum, values: [{ field: self.outstandingPrincipal }, { field: self.outstandingProfit }, { field: self.outstandingFines }, { field: self.outstandingCosts }] }]
         }
         when apply is principal_profit { calculate: [{ target: outstandingTotal, op: sum, values: [{ field: self.outstandingPrincipal }, { field: self.outstandingProfit }] }] }
         when apply is pro_rata { calculate: [{ target: outstandingTotal, op: sum, values: [{ field: self.outstandingPrincipal }, { field: self.outstandingProfit }] }] }
         requires self.plan in [active]; requires self.amount <= self.outstandingTotal
         moves self.amount from self.plan.borrower to self.held economics { purpose: principal, sourceParty: borrower }
+        when apply is fines_profit_principal {
+          invoke: [{ selection: { instrument: all(financing.late_charge), reference: "plan", anchor: self.plan, states: [assessed], limit: charge_limit, order: [overdueAt] }, action: collect, guard: { kind: compare, left: { field: self.held.balance }, operator: ">", right: { literal: "0" } }, input: { payment: { field: self.id } } }, { selection: { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.plan, states: [assessed], limit: charge_limit, order: [overdueAt] }, action: collect, guard: { kind: compare, left: { field: self.held.balance }, operator: ">", right: { literal: "0" } }, input: { payment: { field: self.id } } }]
+        }
+        invoke: [{ reference: self.id, action: allocate, input: {} }, { reference: self.id, action: record, input: {} }]
+      }
+      action allocate {
+        from: paid, to: paid, actor: { parent: current() }
+        calculate: [{ target: unapplied, op: sum, values: [{ field: self.held.balance }] }]
         when apply is principal_profit {
-          invoke: [{ selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due], limit: 366, order: [position] }, action: collect, guard: { kind: compare, left: { field: self.held.balance }, operator: ">", right: { literal: "0" } }, input: { payment: { field: self.id } } }]
+          invoke: [{ selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due], limit: max_term, order: [position] }, action: collect, guard: { kind: compare, left: { field: self.unapplied }, operator: ">", right: { literal: "0" } }, input: { payment: { field: self.id } } }]
         }
         when apply is fines_profit_principal {
-          invoke: [{ selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due], limit: 366, order: [position] }, action: collect_waterfall, guard: { kind: compare, left: { field: self.held.balance }, operator: ">", right: { literal: "0" } }, input: { payment: { field: self.id } } }]
+          invoke: [{ selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due], limit: max_term, order: [position] }, action: collect_waterfall, guard: { kind: compare, left: { field: self.unapplied }, operator: ">", right: { literal: "0" } }, input: { payment: { field: self.id } } }]
         }
         when apply is pro_rata {
-          invoke: [{ selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due], limit: 366, order: [position] }, action: collect_pro_rata, guard: { kind: compare, left: { field: self.held.balance }, operator: ">", right: { literal: "0" } }, input: { payment: { field: self.id } } }]
+          invoke: [{ selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due], limit: max_term, order: [position] }, action: collect_pro_rata, guard: { kind: compare, left: { field: self.unapplied }, operator: ">", right: { literal: "0" } }, input: { payment: { field: self.id } } }]
         }
-        invoke: [{ reference: self.id, action: record, input: {} }]
       }
-      action record {
+      action consume {
+        from: paid, to: paid, actor: { parent: slice }, input { amount: money }
+        calculate: [{ target: unapplied, op: subtract, base: { field: self.unapplied }, subtract: [{ field: input.amount }] }]
+      }
+      action record { allowZero: true,
         from: paid, to: paid, actor: { parent: current() }
-        requires self.held.balance == "0"
-        requires count of { instrument: current(), reference: "plan", anchor: self.plan, states: [paid], limit: 366 } <= self.plan.paymentLimit
-        requires count of { instrument: profit_piece, reference: "plan", anchor: self.plan, states: [paid], limit: 366 } <= self.plan.historyLimit
-        requires count of { instrument: all(financing.late_charge.receipt), reference: "plan", anchor: self.plan, states: [paid], limit: 366 } <= self.plan.historyLimit
-        requires count of { instrument: all(financing.late_charge.cost.receipt), reference: "plan", anchor: self.plan, states: [paid], limit: 366 } <= self.plan.historyLimit
-        calculate: [{ target: principalReturned, op: aggregate, selection: { instrument: principal_piece, reference: "payment", anchor: self.id, states: [paid], limit: 366 }, measure: { sum: "amount" } }, { target: profitReturned, op: aggregate, selection: { instrument: profit_piece, reference: "payment", anchor: self.id, states: [paid], limit: 366 }, measure: { sum: "amount" } }]
+        requires self.unapplied == "0"
+        calculate: [{ target: principalReturned, op: aggregate, selection: { instrument: principal_piece, reference: "payment", anchor: self.id, states: [paid], limit: max_term }, measure: { sum: "amount" } }, { target: profitReturned, op: aggregate, selection: { instrument: profit_piece, reference: "payment", anchor: self.id, states: [paid], limit: max_term }, measure: { sum: "amount" } }]
+        moves self.principalReturned from self.held to self.plan.capital economics { purpose: principal, sourceParty: programOperator }
+        moves self.profitReturned from self.held to self.plan.profitIncome capture "cashReceipt" economics { recipient: capital, company: { purpose: earning, sourceParty: borrower }, participant: { purpose: pass_through, sourceParty: programOperator } }
+        moves self.principalReturned from self.plan.principalReceivable to self.plan.debt economics { purpose: internal, sourceParty: programOperator }
+        when profit_earned is on_payment { moves self.profitReturned from self.plan.profitReceivable to self.plan.debt economics { purpose: internal, sourceParty: programOperator } }
+        when profit_earned is by_schedule { moves self.profitReturned from self.plan.profitEarned to self.plan.debt economics { purpose: internal, sourceParty: programOperator } }
+        when profit_earned is at_disbursement { moves self.profitReturned from self.plan.profitEarned to self.plan.debt economics { purpose: internal, sourceParty: programOperator } }
         invoke: [{ reference: self.plan, action: record_payment, input: { identity: { field: self.paymentIdentity }, principal: { field: self.principalReturned }, profit: { field: self.profitReturned } } }]
       }
-      action unwind { from: paid, to: refunded, actor: { parent: [parent, settlement] } }
-      action refund {
+      // unwind_paid refunds this payment's profit only when its settlement is
+      // still recorded; a distributed settlement keeps it with investors.
+      action unwind_paid {
+        from: paid, to: refunded, actor: { parent: parent }
+        calculate: [{ target: settled, op: aggregate, selection: { instrument: settlement, reference: "plan", anchor: self.plan, states: [recorded], limit: 1, where: { identity: { field: self.paymentIdentity } } }, measure: count }]
+        invoke: [{ selection: { instrument: settlement, reference: "plan", anchor: self.plan, states: [recorded], limit: 1, where: { identity: { field: self.paymentIdentity } } }, action: unwind, input: {} }, { reference: self.id, action: unwind_profit, guard: { kind: compare, left: { field: self.settled }, operator: "==", right: { literal: 1 } }, input: {} }]
+      }
+      action unwind_profit { allowZero: true,
+        from: refunded, to: refunded, actor: { parent: current() }
+        moves self.profitReturned from self.plan.profitIncome to self.plan.borrower economics { recipient: capital, company: { purpose: earning, sourceParty: capital, reversalOf: self.cashReceipt }, participant: unclassified }
+      }
+      action refund { allowZero: true,
         from: paid, to: refunded, actor: { party: capital }, deadline: { at: self.plan.refundUntil }
         requires unique "settlement_consumption" on [self.plan, self.paymentIdentity]; requires self.plan in [active, paid]
-        requires count of { instrument: settlement, reference: "plan", anchor: self.plan, states: [recorded], limit: 366, where: { identity: { field: self.paymentIdentity } } } == 1
-        invoke: [{ selection: { instrument: settlement, reference: "plan", anchor: self.plan, states: [recorded], limit: 366, where: { identity: { field: self.paymentIdentity } } }, action: refund, input: {} }]
+        requires count of { instrument: settlement, reference: "plan", anchor: self.plan, states: [recorded], limit: 1, where: { identity: { field: self.paymentIdentity } } } == 1
+        moves self.principalReturned from self.plan.capital to self.plan.borrower economics { purpose: principal, sourceParty: capital }
+        moves self.profitReturned from self.plan.profitIncome to self.plan.borrower economics { recipient: capital, company: { purpose: earning, sourceParty: capital, reversalOf: self.cashReceipt }, participant: unclassified }
+        moves self.principalReturned from self.plan.debt to self.plan.principalReceivable economics { purpose: internal, sourceParty: borrower }
+        when profit_earned is on_payment { moves self.profitReturned from self.plan.debt to self.plan.profitReceivable economics { purpose: internal, sourceParty: borrower } }
+        when profit_earned is by_schedule { moves self.profitReturned from self.plan.debt to self.plan.profitEarned economics { purpose: internal, sourceParty: borrower } }
+        when profit_earned is at_disbursement { moves self.profitReturned from self.plan.debt to self.plan.profitEarned economics { purpose: internal, sourceParty: borrower } }
+        invoke: [{ selection: { instrument: settlement, reference: "plan", anchor: self.plan, states: [recorded], limit: 1, where: { identity: { field: self.paymentIdentity } } }, action: refund, input: {} }]
         when apply is fines_profit_principal {
-          invoke: [{ selection: { instrument: all(financing.late_charge), reference: "plan", anchor: self.plan, states: [assessed, collected], limit: 366, order: [overdueAt] }, action: refund, input: { payment: { field: self.id } } }, { selection: { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.plan, states: [assessed, collected], limit: 366, order: [overdueAt] }, action: refund, input: { payment: { field: self.id } } }]
+          invoke: [{ selection: { instrument: all(financing.late_charge.receipt), reference: "payment", anchor: self.id, states: [paid], limit: charge_limit }, action: refund, input: {} }, { selection: { instrument: all(financing.late_charge.cost.receipt), reference: "payment", anchor: self.id, states: [paid], limit: charge_limit }, action: refund, input: {} }]
         }
-        invoke: [{ reference: self.plan, action: restore, input: {} }, { selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due, paid], limit: 366 }, action: restore, input: {} }, { selection: { instrument: principal_piece, reference: "payment", anchor: self.id, states: [paid], limit: 366 }, action: refund, input: {} }, { selection: { instrument: profit_piece, reference: "payment", anchor: self.id, states: [paid], limit: 366 }, action: refund, input: {} }]
+        invoke: [{ reference: self.plan, action: restore, input: {} }, { selection: { instrument: principal_piece, reference: "payment", anchor: self.id, states: [paid], limit: max_term }, action: refund, input: {} }, { selection: { instrument: profit_piece, reference: "payment", anchor: self.id, states: [paid], limit: max_term }, action: refund, input: {} }]
       }
     }
     principal_piece: {
-      fields { slice: ref<slice>, payment: ref<payment>, limit: money, amount: money? }
+      fields { plan: ref<parent>, slice: ref<slice>, payment: ref<payment>, amount: money }
       lifecycle { states: [paid, refunded], initial: paid }
-      action create { allowZero: true,
-        calculate: [{ target: amount, op: minimum, values: [{ field: self.payment.held.balance }, { field: self.slice.principalReceivable.balance }, { field: self.limit }] }]
+      action create {
         actor: { parent: slice }
-        input { slice: ref<slice>, payment: ref<payment>, limit: money }
+        input { plan: ref<parent>, slice: ref<slice>, payment: ref<payment>, amount: money }
         requires unique "principal_receipt" on [self.slice, self.payment]
-        moves self.amount from self.payment.held to self.slice.plan.capital economics { purpose: principal, sourceParty: programOperator }; moves self.amount from self.slice.principalReceivable to self.slice.debt economics { purpose: internal, sourceParty: programOperator }
       }
-      action refund { allowZero: true,
+      action refund {
         from: paid, to: refunded, actor: { parent: payment }
-        moves self.amount from self.slice.plan.capital to self.slice.plan.borrower economics { purpose: principal, sourceParty: capital }; moves self.amount from self.slice.debt to self.slice.principalReceivable economics { purpose: internal, sourceParty: borrower }
+        invoke: [{ reference: self.slice, action: unpay, input: { principal: { field: self.amount }, profit: { literal: "0" } } }]
       }
     }
     profit_piece: {
-      fields { cashReceipt: text?, plan: ref<parent>, slice: ref<slice>, payment: ref<payment>, limit: money, amount: money? }
+      fields { plan: ref<parent>, slice: ref<slice>, payment: ref<payment>, amount: money }
       lifecycle { states: [paid, refunded], initial: paid }
-      action create { allowZero: true,
-        calculate: [{ target: amount, op: minimum, values: [{ field: self.payment.held.balance }, { field: self.limit }] }]
+      action create {
         actor: { parent: slice }
-        input { plan: ref<parent>, slice: ref<slice>, payment: ref<payment>, limit: money }
+        input { plan: ref<parent>, slice: ref<slice>, payment: ref<payment>, amount: money }
         requires unique "profit_receipt" on [self.slice, self.payment]
-        moves self.amount from self.payment.held to self.slice.plan.profitIncome capture "cashReceipt" economics { recipient: capital, company: { purpose: earning, sourceParty: borrower }, participant: { purpose: pass_through, sourceParty: programOperator } }
-        when profit_earned is on_payment { moves self.amount from self.slice.profitReceivable to self.slice.debt economics { purpose: internal, sourceParty: programOperator } }
-        when profit_earned is by_schedule { moves self.amount from self.slice.profitEarned to self.slice.debt economics { purpose: internal, sourceParty: programOperator } }
-        when profit_earned is at_disbursement { moves self.amount from self.slice.profitEarned to self.slice.debt economics { purpose: internal, sourceParty: programOperator } }
       }
-      action refund { allowZero: true,
-        from: paid, to: refunded, actor: { parent: [payment, parent] }
-        moves self.amount from self.slice.plan.profitIncome to self.slice.plan.borrower economics { recipient: capital, company: { purpose: earning, sourceParty: capital, reversalOf: self.cashReceipt }, participant: unclassified }
-        when profit_earned is on_payment { moves self.amount from self.slice.debt to self.slice.profitReceivable economics { purpose: internal, sourceParty: borrower } }
-        when profit_earned is by_schedule { moves self.amount from self.slice.debt to self.slice.profitEarned economics { purpose: internal, sourceParty: borrower } }
-        when profit_earned is at_disbursement { moves self.amount from self.slice.debt to self.slice.profitEarned economics { purpose: internal, sourceParty: borrower } }
+      action refund {
+        from: paid, to: refunded, actor: { parent: payment }
+        invoke: [{ reference: self.slice, action: unpay, input: { principal: { literal: "0" }, profit: { field: self.amount } } }]
       }
     }
   }
 }
 
+// A late charge and its recovery costs keep their open amount as state. The
+// plan's fineReceivable and costReceivable hold the claims, so assessment,
+// waiver and refund post one claim transfer each, and payoff and amendment post
+// one per attachment or kind, not one per charge.
 instrument late_charge(on: ref<financing.installments>[], grace: duration = 3d, fine: money = 50 SAR, cap: money = 25 SAR, fines_to: party = programOperator, costs_to: party = programOperator, borrower: party = party(person)) {
   parameterDiagnostics {
     fine {
@@ -663,48 +814,66 @@ instrument late_charge(on: ref<financing.installments>[], grace: duration = 3d,
   familyRevision: 1
   summary: "Separate fine and evidenced recovery claims on an overdue installment."
   fields {
-    plan: ref<on>, slice: ref<on.slice>, borrower: account of borrower, fine: money = fine, overdueAt: date?, payoffAmount: money?, payoffReceipt: text?
-    receivable: account(self, claim), debt: account(borrower, claim, contra, "debt")
+    plan: ref<on>, slice: ref<on.slice>, borrower: account of borrower, fine: money = fine, overdueAt: date?, payoffAmount: money?, payoffReceipt: text?, payoffLed: integer?
+    open: money?, take: money?
   }
   lifecycle { states: [proposed, assessed, collected, waived], initial: proposed }
-  action create { input { slice: ref<on.slice>? }, calculate: [{ target: overdueAt, op: shift, date: { field: self.slice.dueAt }, milliseconds: { literal: grace }, direction: after }, { target: payoffAmount, op: sum, values: [{ literal: "0" }] }], requires unique "late_assessment" on [self.slice, self.overdueAt]; requires self.borrower == self.slice.plan.borrower; requires self.plan == self.slice.plan; requires count of { instrument: all(financing.late_charge), reference: "plan", anchor: self.plan, states: [proposed, assessed, collected], limit: 366 } < self.plan.historyLimit }
+  action create { input { slice: ref<on.slice>? }, calculate: [{ target: overdueAt, op: shift, date: { field: self.slice.dueAt }, milliseconds: { literal: grace }, direction: after }, { target: payoffAmount, op: sum, values: [{ literal: "0" }] }, { target: open, op: sum, values: [{ literal: "0" }] }], requires unique "late_assessment" on [self.slice, self.overdueAt]; requires self.borrower == self.slice.plan.borrower; requires self.plan == self.slice.plan; requires count of { instrument: all(financing.late_charge), reference: "plan", anchor: self.plan, states: [proposed, assessed, collected], limit: 366 } < self.plan.historyLimit }
   action assess { allowZero: true,
     from: proposed, to: assessed, actor: clock, due: { at: self.overdueAt }
-    requires self.slice.principalReceivable.balance > "0"
-    moves self.fine from self.debt to self.receivable economics { purpose: internal, sourceParty: borrower }
+    requires self.slice.openPrincipal > "0"
+    calculate: [{ target: open, op: sum, values: [{ field: self.fine }] }]
+    moves self.fine from self.plan.debt to self.plan.fineReceivable economics { purpose: internal, sourceParty: borrower }
   }
   action collect {
-    from: [assessed, collected], to: assessed, actor: { parent: child(on, slice) }, input { payment: ref<on.payment> }
+    from: [assessed, collected], to: assessed, actor: { parent: child(on, payment) }, input { payment: ref<on.payment> }
     requires input.payment in [paid]
     requires input.payment.plan == self.plan
-    invoke: [{ instrument: receipt, action: create, input: { plan: { field: self.plan }, assessment: { field: self.id }, payment: { field: input.payment } } }, { selection: { instrument: current(), reference: "plan", anchor: self.plan, states: [assessed], limit: 1, where: { id: { field: self.id }, receivable.balance: { literal: "0" } } }, action: finish, input: {} }]
+    calculate: [{ target: take, op: minimum, values: [{ field: input.payment.held.balance }, { field: self.open }] }]
+    invoke: [{ instrument: receipt, action: create, guard: { kind: compare, left: { field: self.take }, operator: ">", right: { literal: "0" } }, input: { plan: { field: self.plan }, assessment: { field: self.id }, payment: { field: input.payment }, amount: { field: self.take } } }, { reference: self.id, action: reduce, input: {} }, { selection: { instrument: current(), reference: "plan", anchor: self.plan, states: [assessed], limit: 1, where: { id: { field: self.id }, open: { literal: "0" } } }, action: finish, input: {} }]
   }
+  // The oldest open charge of an attachment settles them all in one transfer.
   action payoff { allowZero: true,
-    from: [assessed, collected], to: collected, actor: { parent: on }
+    from: assessed, to: collected, actor: { parent: on }
     requires self.plan in [paid]
-    calculate: [{ target: payoffAmount, op: sum, values: [{ field: self.receivable.balance }] }]
+    calculate: [{ target: payoffAmount, op: aggregate, selection: { instrument: current(), reference: "plan", anchor: self.plan, states: [assessed], limit: 366 }, measure: { sum: "open" } }]
+    set: { payoffLed: { literal: 1 } }
     moves self.payoffAmount from self.plan.borrower to fines_to capture "payoffReceipt" economics { recipient: fines_to, company: { purpose: earning, sourceParty: borrower }, participant: { purpose: pass_through, sourceParty: borrower } }
-    moves self.payoffAmount from self.receivable to self.debt economics { purpose: internal, sourceParty: programOperator }
+    moves self.payoffAmount from self.plan.fineReceivable to self.plan.debt economics { purpose: internal, sourceParty: programOperator }
+    invoke: [{ selection: { instrument: current(), reference: "plan", anchor: self.plan, states: [assessed], limit: 366 }, action: close, input: {} }, { reference: self.id, action: close, input: {} }]
   }
+  action close { from: [assessed, collected], to: collected, actor: { parent: current() }, calculate: [{ target: open, op: sum, values: [{ literal: "0" }] }] }
   action unwind_payoff { allowZero: true,
     from: collected, to: collected, actor: { parent: on }
+    set: { payoffLed: { literal: 2 } }
     moves self.payoffAmount from fines_to to self.plan.borrower economics { recipient: fines_to, company: { purpose: earning, sourceParty: fines_to, reversalOf: self.payoffReceipt }, participant: unclassified }
   }
-  action finish { from: assessed, to: collected, actor: { parent: current() }, requires self.receivable.balance == "0" }
+  action finish { from: assessed, to: collected, actor: { parent: current() }, requires self.open == "0" }
+  action reduce { from: [assessed, collected, waived], to: preserve, actor: { parent: current() }, calculate: [{ target: open, op: subtract, base: { field: self.open }, subtract: [{ field: self.take }] }] }
   action cancel { from: proposed, to: waived, actor: { party: programOperator } }
   action cancel_for_amendment { from: proposed, to: waived, actor: { parent: child(on, amendment) } }
-  action cancel_undelivered { allowZero: true, from: [proposed, assessed, collected], to: waived, actor: { parent: on }, moves self.receivable.balance from self.receivable to self.debt economics { purpose: internal, sourceParty: programOperator } }
+  action cancel_undelivered { from: [proposed, assessed, collected], to: waived, actor: { parent: on }, calculate: [{ target: open, op: sum, values: [{ literal: "0" }] }] }
   action waive_for_amendment {
     from: [assessed, collected], to: assessed, actor: { parent: child(on, amendment) }, input { amendment: ref<on.amendment> }
     requires input.amendment.plan == self.plan; requires input.amendment in [applied]
-    invoke: [{ instrument: waiver, action: create, input: { assessment: { field: self.id }, amendment: { field: input.amendment } } }]
+    calculate: [{ target: take, op: rate, base: { field: self.open }, bps: { field: input.amendment.waiverPercent }, rounding: floor }]
+    invoke: [{ instrument: waiver, action: create, input: { assessment: { field: self.id }, amendment: { field: input.amendment }, amount: { field: self.take } } }, { reference: self.id, action: reduce, input: {} }]
+  }
+  action waive { allowZero: true,
+    from: [assessed, collected], to: waived, actor: { parent: waiver_request }, input { reason: text, evidence: text }
+    calculate: [{ target: take, op: sum, values: [{ field: self.open }] }]
+    moves self.take from self.plan.fineReceivable to self.plan.debt economics { purpose: internal, sourceParty: programOperator }
+    invoke: [{ reference: self.id, action: reduce, input: {} }]
   }
-  action waive { allowZero: true, from: [assessed, collected], to: waived, actor: { parent: waiver_request }, input { reason: text, evidence: text }, moves self.receivable.balance from self.receivable to self.debt economics { purpose: internal, sourceParty: programOperator } }
   action refund {
-    from: [assessed, collected], to: assessed, actor: { party: fines_to }, input { payment: ref<on.payment> }, deadline: { at: self.plan.refundUntil }
+    from: [assessed, collected], to: preserve, actor: { party: fines_to }, input { payment: ref<on.payment> }, deadline: { at: self.plan.refundUntil }
     requires input.payment in [paid, refunded]
     requires input.payment.plan == self.plan
-    invoke: [{ selection: { instrument: receipt, reference: "payment", anchor: input.payment, states: [paid], limit: 1, where: { assessment: { field: self.id } } }, action: refund, input: {} }, { selection: { instrument: current(), reference: "plan", anchor: self.plan, states: [assessed], limit: 1, where: { id: { field: self.id }, receivable.balance: { literal: "0" } } }, action: finish, input: {} }]
+    invoke: [{ selection: { instrument: receipt, reference: "payment", anchor: input.payment, states: [paid], limit: 1, where: { assessment: { field: self.id } } }, action: refund, input: {} }]
+  }
+  action reopen {
+    from: [assessed, collected], to: assessed, actor: { parent: receipt }, input { amount: money }
+    calculate: [{ target: open, op: sum, values: [{ field: self.open }, { field: input.amount }] }]
   }
   records {
     waiver_request: {
@@ -718,67 +887,89 @@ instrument late_charge(on: ref<financing.installments>[], grace: duration = 3d,
       action cancel { from: requested, to: cancelled }
     }
     waiver: {
-      fields { assessment: ref<parent>, amendment: ref<on.amendment>, amount: money? }
+      fields { assessment: ref<parent>, amendment: ref<on.amendment>, amount: money }
       lifecycle { states: [recorded], initial: recorded }
-      action create { allowZero: true,
-        actor: { parent: parent }, input { assessment: ref<parent>, amendment: ref<on.amendment> }
-        calculate: [{ target: amount, op: rate, base: { field: self.assessment.receivable.balance }, bps: { field: self.amendment.waiverPercent }, rounding: floor }]
+      action create {
+        actor: { parent: parent }, input { assessment: ref<parent>, amendment: ref<on.amendment>, amount: money }
         requires unique "amendment_waiver" on [self.assessment, self.amendment]
-        moves self.amount from self.assessment.receivable to self.assessment.debt economics { purpose: internal, sourceParty: programOperator }
       }
     }
     receipt: {
-      fields { cashReceipt: text?, plan: ref<on>, assessment: ref<parent>, payment: ref<on.payment>, amount: money? }
+      fields { cashReceipt: text?, plan: ref<on>, assessment: ref<parent>, payment: ref<on.payment>, amount: money }
       lifecycle { states: [paid, refunded], initial: paid }
-      action create { allowZero: true, calculate: [{ target: amount, op: minimum, values: [{ field: self.payment.held.balance }, { field: self.assessment.receivable.balance }] }], actor: { parent: parent }, input { plan: ref<on>, assessment: ref<parent>, payment: ref<on.payment> }, requires input.payment.plan == self.assessment.plan; requires unique "fine_receipt" on [self.assessment, self.payment]; moves self.amount from self.payment.held to fines_to capture "cashReceipt" economics { recipient: fines_to, company: { purpose: earning, sourceParty: borrower }, participant: { purpose: pass_through, sourceParty: programOperator } }; moves self.amount from self.assessment.receivable to self.assessment.debt economics { purpose: internal, sourceParty: programOperator } }
-      action refund { allowZero: true, from: paid, to: refunded, actor: { parent: [parent, on] }, moves self.amount from fines_to to self.payment.plan.borrower economics { recipient: fines_to, company: { purpose: earning, sourceParty: fines_to, reversalOf: self.cashReceipt }, participant: unclassified }; moves self.amount from self.assessment.debt to self.assessment.receivable economics { purpose: internal, sourceParty: borrower } }
+      action create { actor: { parent: parent }, input { plan: ref<on>, assessment: ref<parent>, payment: ref<on.payment>, amount: money }, requires input.payment.plan == self.assessment.plan; requires unique "fine_receipt" on [self.assessment, self.payment]; moves self.amount from self.payment.held to fines_to capture "cashReceipt" economics { recipient: fines_to, company: { purpose: earning, sourceParty: borrower }, participant: { purpose: pass_through, sourceParty: programOperator } }; moves self.amount from self.plan.fineReceivable to self.plan.debt economics { purpose: internal, sourceParty: programOperator } }
+      action refund {
+        from: paid, to: refunded, actor: { parent: [parent, child(on, payment)] }
+        moves self.amount from fines_to to self.payment.plan.borrower economics { recipient: fines_to, company: { purpose: earning, sourceParty: fines_to, reversalOf: self.cashReceipt }, participant: unclassified }
+        moves self.amount from self.plan.debt to self.plan.fineReceivable economics { purpose: internal, sourceParty: borrower }
+        invoke: [{ reference: self.assessment, action: reopen, input: { amount: { field: self.amount } } }]
+      }
+      // unwind_paid returns the cash; the plan cancels the claims itself.
+      action unwind { from: paid, to: refunded, actor: { parent: on }, moves self.amount from fines_to to self.payment.plan.borrower economics { recipient: fines_to, company: { purpose: earning, sourceParty: fines_to, reversalOf: self.cashReceipt }, participant: unclassified } }
     }
 
     cost: {
       revisioned: true
       fields {
-        plan: ref<on>, assessment: ref<parent>, overdueAt: date?, evidence: text, evidencedCost: money, amount: money = minimum(self.evidencedCost, cap), payoffAmount: money?, payoffReceipt: text?
-        receivable: account(self, claim), debt: account(borrower, claim, contra, "debt")
+        plan: ref<on>, assessment: ref<parent>, overdueAt: date?, evidence: text, evidencedCost: money, amount: money = minimum(self.evidencedCost, cap), payoffAmount: money?, payoffReceipt: text?, payoffLed: integer?
+        open: money?, take: money?
       }
       lifecycle { states: [proposed, assessed, collected, waived], initial: proposed }
-      action create { actor: { party: programOperator }, calculate: [{ target: overdueAt, op: shift, date: { field: self.assessment.overdueAt }, milliseconds: { literal: 0 }, direction: after }, { target: payoffAmount, op: sum, values: [{ literal: "0" }] }], requires unique "recovery_assessment" on [self.assessment]; requires self.plan == self.assessment.plan; requires count of { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.plan, states: [proposed, assessed, collected], limit: 366 } < self.plan.historyLimit }
+      action create { actor: { party: programOperator }, calculate: [{ target: overdueAt, op: shift, date: { field: self.assessment.overdueAt }, milliseconds: { literal: 0 }, direction: after }, { target: payoffAmount, op: sum, values: [{ literal: "0" }] }, { target: open, op: sum, values: [{ literal: "0" }] }], requires unique "recovery_assessment" on [self.assessment]; requires self.plan == self.assessment.plan; requires count of { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.plan, states: [proposed, assessed, collected], limit: 366 } < self.plan.historyLimit }
       action assess { allowZero: true,
         from: proposed, to: assessed, actor: clock, due: { at: self.assessment.overdueAt }
-        requires self.assessment.slice.principalReceivable.balance > "0"
-        moves self.amount from self.debt to self.receivable economics { purpose: internal, sourceParty: borrower }
+        requires self.assessment.slice.openPrincipal > "0"
+        calculate: [{ target: open, op: sum, values: [{ field: self.amount }] }]
+        moves self.amount from self.plan.debt to self.plan.costReceivable economics { purpose: internal, sourceParty: borrower }
       }
       action collect {
-        from: [assessed, collected], to: assessed, actor: { parent: child(on, slice) }, input { payment: ref<on.payment> }
+        from: [assessed, collected], to: assessed, actor: { parent: child(on, payment) }, input { payment: ref<on.payment> }
         requires input.payment in [paid]
         requires input.payment.plan == self.plan
-        invoke: [{ instrument: receipt, action: create, input: { plan: { field: self.plan }, assessment: { field: self.id }, payment: { field: input.payment } } }, { selection: { instrument: current(), reference: "plan", anchor: self.plan, states: [assessed], limit: 1, where: { id: { field: self.id }, receivable.balance: { literal: "0" } } }, action: finish, input: {} }]
+        calculate: [{ target: take, op: minimum, values: [{ field: input.payment.held.balance }, { field: self.open }] }]
+        invoke: [{ instrument: receipt, action: create, guard: { kind: compare, left: { field: self.take }, operator: ">", right: { literal: "0" } }, input: { plan: { field: self.plan }, assessment: { field: self.id }, payment: { field: input.payment }, amount: { field: self.take } } }, { reference: self.id, action: reduce, input: {} }, { selection: { instrument: current(), reference: "plan", anchor: self.plan, states: [assessed], limit: 1, where: { id: { field: self.id }, open: { literal: "0" } } }, action: finish, input: {} }]
       }
       action payoff { allowZero: true,
-        from: [assessed, collected], to: collected, actor: { parent: on }
+        from: assessed, to: collected, actor: { parent: on }
         requires self.plan in [paid]
-        calculate: [{ target: payoffAmount, op: sum, values: [{ field: self.receivable.balance }] }]
+        calculate: [{ target: payoffAmount, op: aggregate, selection: { instrument: current(), reference: "plan", anchor: self.plan, states: [assessed], limit: 366 }, measure: { sum: "open" } }]
+        set: { payoffLed: { literal: 1 } }
         moves self.payoffAmount from self.plan.borrower to costs_to capture "payoffReceipt" economics { recipient: costs_to, company: { purpose: earning, sourceParty: borrower }, participant: { purpose: pass_through, sourceParty: borrower } }
-        moves self.payoffAmount from self.receivable to self.debt economics { purpose: internal, sourceParty: programOperator }
+        moves self.payoffAmount from self.plan.costReceivable to self.plan.debt economics { purpose: internal, sourceParty: programOperator }
+        invoke: [{ selection: { instrument: current(), reference: "plan", anchor: self.plan, states: [assessed], limit: 366 }, action: close, input: {} }, { reference: self.id, action: close, input: {} }]
       }
+      action close { from: [assessed, collected], to: collected, actor: { parent: current() }, calculate: [{ target: open, op: sum, values: [{ literal: "0" }] }] }
       action unwind_payoff { allowZero: true,
         from: collected, to: collected, actor: { parent: on }
+        set: { payoffLed: { literal: 2 } }
         moves self.payoffAmount from costs_to to self.plan.borrower economics { recipient: costs_to, company: { purpose: earning, sourceParty: costs_to, reversalOf: self.payoffReceipt }, participant: unclassified }
       }
-      action finish { from: assessed, to: collected, actor: { parent: current() }, requires self.receivable.balance == "0" }
+      action finish { from: assessed, to: collected, actor: { parent: current() }, requires self.open == "0" }
+      action reduce { from: [assessed, collected, waived], to: preserve, actor: { parent: current() }, calculate: [{ target: open, op: subtract, base: { field: self.open }, subtract: [{ field: self.take }] }] }
       action cancel { from: proposed, to: waived, actor: { party: programOperator } }
       action cancel_for_amendment { from: proposed, to: waived, actor: { parent: child(on, amendment) } }
-      action cancel_undelivered { allowZero: true, from: [proposed, assessed, collected], to: waived, actor: { parent: on }, moves self.receivable.balance from self.receivable to self.debt economics { purpose: internal, sourceParty: programOperator } }
+      action cancel_undelivered { from: [proposed, assessed, collected], to: waived, actor: { parent: on }, calculate: [{ target: open, op: sum, values: [{ literal: "0" }] }] }
       action waive_for_amendment {
         from: [assessed, collected], to: assessed, actor: { parent: child(on, amendment) }, input { amendment: ref<on.amendment> }
         requires input.amendment.plan == self.plan; requires input.amendment in [applied]
-        invoke: [{ instrument: waiver, action: create, input: { assessment: { field: self.id }, amendment: { field: input.amendment } } }]
+        calculate: [{ target: take, op: rate, base: { field: self.open }, bps: { field: input.amendment.waiverPercent }, rounding: floor }]
+        invoke: [{ instrument: waiver, action: create, input: { assessment: { field: self.id }, amendment: { field: input.amendment }, amount: { field: self.take } } }, { reference: self.id, action: reduce, input: {} }]
+      }
+      action waive { allowZero: true,
+        from: [assessed, collected], to: waived, actor: { parent: waiver_request }, input { reason: text, evidence: text }
+        calculate: [{ target: take, op: sum, values: [{ field: self.open }] }]
+        moves self.take from self.plan.costReceivable to self.plan.debt economics { purpose: internal, sourceParty: programOperator }
+        invoke: [{ reference: self.id, action: reduce, input: {} }]
       }
-      action waive { allowZero: true, from: [assessed, collected], to: waived, actor: { parent: waiver_request }, input { reason: text, evidence: text }, moves self.receivable.balance from self.receivable to self.debt economics { purpose: internal, sourceParty: programOperator } }
       action refund {
-        from: [assessed, collected], to: assessed, actor: { party: costs_to }, input { payment: ref<on.payment> }, deadline: { at: self.plan.refundUntil }
+        from: [assessed, collected], to: preserve, actor: { party: costs_to }, input { payment: ref<on.payment> }, deadline: { at: self.plan.refundUntil }
         requires input.payment in [paid, refunded]
         requires input.payment.plan == self.plan
-        invoke: [{ selection: { instrument: receipt, reference: "payment", anchor: input.payment, states: [paid], limit: 1, where: { assessment: { field: self.id } } }, action: refund, input: {} }, { selection: { instrument: current(), reference: "plan", anchor: self.plan, states: [assessed], limit: 1, where: { id: { field: self.id }, receivable.balance: { literal: "0" } } }, action: finish, input: {} }]
+        invoke: [{ selection: { instrument: receipt, reference: "payment", anchor: input.payment, states: [paid], limit: 1, where: { assessment: { field: self.id } } }, action: refund, input: {} }]
+      }
+      action reopen {
+        from: [assessed, collected], to: assessed, actor: { parent: receipt }, input { amount: money }
+        calculate: [{ target: open, op: sum, values: [{ field: self.open }, { field: input.amount }] }]
       }
       records {
         waiver_request: {
@@ -792,20 +983,24 @@ instrument late_charge(on: ref<financing.installments>[], grace: duration = 3d,
           action cancel { from: requested, to: cancelled }
         }
         waiver: {
-          fields { assessment: ref<parent>, amendment: ref<on.amendment>, amount: money? }
+          fields { assessment: ref<parent>, amendment: ref<on.amendment>, amount: money }
           lifecycle { states: [recorded], initial: recorded }
-          action create { allowZero: true,
-            actor: { parent: parent }, input { assessment: ref<parent>, amendment: ref<on.amendment> }
-            calculate: [{ target: amount, op: rate, base: { field: self.assessment.receivable.balance }, bps: { field: self.amendment.waiverPercent }, rounding: floor }]
+          action create {
+            actor: { parent: parent }, input { assessment: ref<parent>, amendment: ref<on.amendment>, amount: money }
             requires unique "amendment_waiver" on [self.assessment, self.amendment]
-            moves self.amount from self.assessment.receivable to self.assessment.debt economics { purpose: internal, sourceParty: programOperator }
           }
         }
         receipt: {
-          fields { cashReceipt: text?, plan: ref<on>, assessment: ref<parent>, payment: ref<on.payment>, amount: money? }
+          fields { cashReceipt: text?, plan: ref<on>, assessment: ref<parent>, payment: ref<on.payment>, amount: money }
           lifecycle { states: [paid, refunded], initial: paid }
-          action create { allowZero: true, calculate: [{ target: amount, op: minimum, values: [{ field: self.payment.held.balance }, { field: self.assessment.receivable.balance }] }], actor: { parent: parent }, input { plan: ref<on>, assessment: ref<parent>, payment: ref<on.payment> }, requires input.payment.plan == self.assessment.plan; requires unique "cost_receipt" on [self.assessment, self.payment]; moves self.amount from self.payment.held to costs_to capture "cashReceipt" economics { recipient: costs_to, company: { purpose: earning, sourceParty: borrower }, participant: { purpose: pass_through, sourceParty: programOperator } }; moves self.amount from self.assessment.receivable to self.assessment.debt economics { purpose: internal, sourceParty: programOperator } }
-          action refund { allowZero: true, from: paid, to: refunded, actor: { parent: [parent, on] }, moves self.amount from costs_to to self.payment.plan.borrower economics { recipient: costs_to, company: { purpose: earning, sourceParty: costs_to, reversalOf: self.cashReceipt }, participant: unclassified }; moves self.amount from self.assessment.debt to self.assessment.receivable economics { purpose: internal, sourceParty: borrower } }
+          action create { actor: { parent: parent }, input { plan: ref<on>, assessment: ref<parent>, payment: ref<on.payment>, amount: money }, requires input.payment.plan == self.assessment.plan; requires unique "cost_receipt" on [self.assessment, self.payment]; moves self.amount from self.payment.held to costs_to capture "cashReceipt" economics { recipient: costs_to, company: { purpose: earning, sourceParty: borrower }, participant: { purpose: pass_through, sourceParty: programOperator } }; moves self.amount from self.plan.costReceivable to self.plan.debt economics { purpose: internal, sourceParty: programOperator } }
+          action refund {
+            from: paid, to: refunded, actor: { parent: [parent, child(on, payment)] }
+            moves self.amount from costs_to to self.payment.plan.borrower economics { recipient: costs_to, company: { purpose: earning, sourceParty: costs_to, reversalOf: self.cashReceipt }, participant: unclassified }
+            moves self.amount from self.plan.debt to self.plan.costReceivable economics { purpose: internal, sourceParty: borrower }
+            invoke: [{ reference: self.assessment, action: reopen, input: { amount: { field: self.amount } } }]
+          }
+          action unwind { from: paid, to: refunded, actor: { parent: on }, moves self.amount from costs_to to self.payment.plan.borrower economics { recipient: costs_to, company: { purpose: earning, sourceParty: costs_to, reversalOf: self.cashReceipt }, participant: unclassified } }
         }
       }
     }