《独立开发者的商业指南·合同、应收与风险》4.2 催收升级与法律途径的成本收益

期望回收   = 应收 × 回收概率
期望净回收 = 期望回收 − 内部工时成本 − 固定费用 − 第三方佣金

盈亏平衡应收 = (1,020 + 8,500) ÷ 70% = 13,600

期望回收   = 3,000 × 70% = 2,100
期望净回收 = 2,100 − 1,020 − 8,500 = −7,420

3,000 ÷ 1.10² = 2,479

// file: src/contract/collection.ts
// tier: L1
// verify: node --test test/contract/collection.test.ts

import { type Cents, add, sub } from "../core/money.ts";
import { type Bps, applyRate } from "../core/rate.ts";
import { type Result, fail, ok } from "../core/result.ts";

export type CollectionStage = {
  name: string;
  recoveryBps: Bps;
  internalHours: number;
  hourlyCostCents: Cents;
  fixedCostCents: Cents;
  commissionBps: Bps;
};

export type StageResult = {
  name: string;
  expectedRecoveryCents: Cents;
  internalCostCents: Cents;
  commissionCents: Cents;
  fixedCostCents: Cents;
  expectedNetCents: Cents;
  breakEvenReceivableCents: Cents;
};

function checkAmount(value: Cents, label: string): Result<true> {
  if (!Number.isInteger(value) || value < 0) {
    return fail(`${label} must be a non-negative integer amount in cents`);
  }
  return ok(true);
}

function checkRate(value: Bps, label: string): Result<true> {
  if (!Number.isInteger(value) || value < 0 || value > 10000) {
    return fail(`${label} must be between 0 and 10000 bps`);
  }
  return ok(true);
}

/**
 * Expected net recovery is probability-weighted cash minus the cost of that
 * stage:
 *   expected recovery = receivable x recovery probability
 *   commission        = expected recovery x third-party rate
 *   net               = expected recovery - internal - fixed - commission
 * The break-even receivable is the balance at which net equals zero, so a
 * small invoice can be rejected without arguing about the merits.
 */
export function evaluateStage(
  receivableCents: Cents,
  stage: CollectionStage,
): Result<StageResult> {
  const receivable = checkAmount(receivableCents, "receivable");
  if (!receivable.ok) {
    return receivable;
  }
  if (stage.name.trim() === "") {
    return fail("stage name cannot be empty");
  }
  const recovery = checkRate(stage.recoveryBps, `${stage.name} recovery rate`);
  if (!recovery.ok) {
    return recovery;
  }
  if (stage.recoveryBps === 0) {
    return fail("recovery probability must be greater than zero");
  }
  const commission = checkRate(stage.commissionBps, `${stage.name} commission`);
  if (!commission.ok) {
    return commission;
  }
  if (!Number.isInteger(stage.internalHours) || stage.internalHours < 0) {
    return fail("internal hours must be a non-negative integer");
  }
  const hourly = checkAmount(stage.hourlyCostCents, "hourly cost");
  if (!hourly.ok) {
    return hourly;
  }
  const fixed = checkAmount(stage.fixedCostCents, "fixed cost");
  if (!fixed.ok) {
    return fixed;
  }

  const expectedRecoveryCents = applyRate(receivableCents, stage.recoveryBps);
  const internalCostCents = Math.round(stage.internalHours * stage.hourlyCostCents);
  const commissionCents = applyRate(expectedRecoveryCents, stage.commissionBps);
  const expectedNetCents = sub(
    expectedRecoveryCents,
    add(add(internalCostCents, stage.fixedCostCents), commissionCents),
  );
  const netRateBps = Math.round(
    (stage.recoveryBps * (10000 - stage.commissionBps)) / 10000,
  );
  const breakEvenReceivableCents =
    netRateBps === 0
      ? 0
      : Math.ceil(
          ((internalCostCents + stage.fixedCostCents) * 10000) / netRateBps,
        );
  return ok({
    name: stage.name,
    expectedRecoveryCents,
    internalCostCents,
    commissionCents,
    fixedCostCents: stage.fixedCostCents,
    expectedNetCents,
    breakEvenReceivableCents,
  });
}

/**
 * Evaluate each rung as a standalone path: "stop here, do not escalate".
 * Summing the rows would double count the same receivable.
 */
export function evaluateLadder(
  receivableCents: Cents,
  stages: CollectionStage[],
): Result<StageResult[]> {
  if (stages.length === 0) {
    return fail("at least one collection stage is required");
  }
  const results: StageResult[] = [];
  for (const stage of stages) {
    const evaluated = evaluateStage(receivableCents, stage);
    if (!evaluated.ok) {
      return evaluated;
    }
    results.push(evaluated.value);
  }
  return ok(results);
}

/**
 * Pick the highest expected net. A tie keeps the earlier, cheaper rung so the
 * ladder never escalates without a positive gain.
 */
export function bestStage(results: StageResult[]): StageResult | null {
  if (results.length === 0) {
    return null;
  }
  let best = results[0];
  for (const result of results) {
    if (result.expectedNetCents > best.expectedNetCents) {
      best = result;
    }
  }
  return best;
}