《独立开发者的商业指南·合同、应收与风险》5.2 争议解决：管辖、仲裁与调解

(8,500 + 1,020) ÷ 70% = 13,600

(14,500 + 1,020) ÷ 70% = 22,171

期望回收 = 争议金额 × 回收概率
期望净得 = 期望回收 − 内部工时成本 − 固定费用

盈亏平衡争议额 = (内部成本 + 固定费用) ÷ 回收概率

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

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

export type Procedure = "mediation" | "arbitration" | "litigation";

export type ProcedureCost = {
  procedure: Procedure;
  internalHours: number;
  hourlyCostCents: Cents;
  fixedCostCents: Cents;
  durationMonths: number;
  recoveryBps: Bps;
};

export type ProcedureResult = {
  procedure: Procedure;
  claimCents: Cents;
  expectedRecoveryCents: Cents;
  internalCostCents: Cents;
  totalCostCents: Cents;
  expectedNetCents: Cents;
  discountedNetCents: Cents;
  breakEvenClaimCents: Cents;
  durationMonths: number;
};

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);
}

/**
 * A procedure is a project: expected recovery is probability-weighted cash,
 * while internal hours and fixed fees are paid whether or not the claim wins.
 * The break-even claim is the amount at which expected net is zero, so a
 * small invoice can be routed away from an expensive forum without arguing
 * about the merits. Discounting puts the recovery at its present value
 * because the cash arrives months after the cost.
 */
export function evaluateProcedure(
  claimCents: Cents,
  cost: ProcedureCost,
  discountRateBps: Bps = 1000,
): Result<ProcedureResult> {
  if (!Number.isInteger(claimCents) || claimCents <= 0) {
    return fail("claim must be a positive integer amount in cents");
  }
  if (!Number.isInteger(cost.internalHours) || cost.internalHours < 0) {
    return fail("internal hours must be a non-negative integer");
  }
  const hourly = checkAmount(cost.hourlyCostCents, "hourly cost");
  if (!hourly.ok) {
    return hourly;
  }
  const fixed = checkAmount(cost.fixedCostCents, "fixed cost");
  if (!fixed.ok) {
    return fixed;
  }
  if (!Number.isFinite(cost.durationMonths) || cost.durationMonths <= 0) {
    return fail("duration months must be greater than zero");
  }
  const recovery = checkRate(cost.recoveryBps, "recovery rate");
  if (!recovery.ok) {
    return recovery;
  }
  if (cost.recoveryBps === 0) {
    return fail("recovery probability must be greater than zero");
  }
  const discount = checkRate(discountRateBps, "discount rate");
  if (!discount.ok) {
    return discount;
  }

  const internalCostCents = Math.round(cost.internalHours * cost.hourlyCostCents);
  const totalCostCents = internalCostCents + cost.fixedCostCents;
  const expectedRecoveryCents = applyRate(claimCents, cost.recoveryBps);
  const years = cost.durationMonths / 12;
  const discountedRecoveryCents = Math.round(
    expectedRecoveryCents / Math.pow(1 + discountRateBps / 10000, years),
  );
  return ok({
    procedure: cost.procedure,
    claimCents,
    expectedRecoveryCents,
    internalCostCents,
    totalCostCents,
    expectedNetCents: expectedRecoveryCents - totalCostCents,
    discountedNetCents: discountedRecoveryCents - totalCostCents,
    breakEvenClaimCents: Math.ceil(
      (totalCostCents * 10000) / cost.recoveryBps,
    ),
    durationMonths: cost.durationMonths,
  });
}

/**
 * Each procedure is evaluated as a standalone path. Summing them would add
 * the same claim three times, once per forum.
 */
export function compareProcedures(
  claimCents: Cents,
  costs: ProcedureCost[],
  discountRateBps: Bps = 1000,
): Result<ProcedureResult[]> {
  if (costs.length === 0) {
    return fail("at least one procedure is required");
  }
  const results: ProcedureResult[] = [];
  for (const cost of costs) {
    const evaluated = evaluateProcedure(claimCents, cost, discountRateBps);
    if (!evaluated.ok) {
      return evaluated;
    }
    results.push(evaluated.value);
  }
  return ok(results);
}

/**
 * Pick the highest expected net. A tie keeps the earlier, cheaper procedure
 * so the model never escalates without a positive gain.
 */
export function bestProcedure(
  results: ProcedureResult[],
): ProcedureResult | 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;
}