《独立开发者的商业指南·资本与退出》12.2 职业化管理与授权

// file: src/capital/professional-management.ts
// tier: L1
// verify: node --test test/capital/professional-management.test.ts

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

export type ManagementInput = {
  productCustomers: number;
  supportHoursPerCustomerMonth: number;
  consultingHoursMonth: number;
  coordinationHoursPerConsultingHour: number;
  adminHoursMonth: number;
  productiveHoursPerManagerMonth: number;
  managerSalaryCents: Cents;
  employerBurdenBps: Bps;
  minimumManagers: number;
  sdeCents: Cents;
  productRevenueCents: Cents;
};

export type ManagementLoad = {
  operatingHoursMonth: number;
  operatingHoursWeek: number;
  fteBps: Bps;
  managersRequired: number;
  annualSalaryCents: Cents;
  annualCostCents: Cents;
  costToSdeBps: Bps;
  costToProductRevenueBps: Bps;
};

export type AuthorityCategory =
  | "purchase"
  | "delivery"
  | "pricing"
  | "hiring"
  | "legal"
  | "asset";

export type AuthorityTier = "auto" | "manager" | "founder" | "reserved";

export type AuthorityLimits = {
  autoApproveCents: Cents;
  managerApproveCents: Cents;
  founderApproveCents: Cents;
};

export type AuthorityRequest = {
  label: string;
  amountCents: Cents;
  category: AuthorityCategory;
};

export type AuthorityDecision = { tier: AuthorityTier; reason: string };

export type AuthorityReview = {
  totalRequests: number;
  autoCount: number;
  managerCount: number;
  founderCount: number;
  reservedCount: number;
  founderMinutes: number;
  founderHours: number;
  autoExposureCents: Cents;
};

const FOUNDER_ONLY: AuthorityCategory[] = ["pricing", "legal", "asset"];

function amountError(value: Cents, label: string): string | null {
  return Number.isInteger(value) && value >= 0
    ? null
    : `${label} must be a non-negative integer amount in cents`;
}

function bpsError(value: Bps, label: string): string | null {
  return Number.isInteger(value) && value >= 0 && value <= 10000
    ? null
    : `${label} must be between 0 and 10000 bps`;
}

/**
 * Load starts from the work that reaches the founder today. Support hours,
 * consulting coordination and admin are added first; the manager count is the
 * ceiling of that load divided by one manager's productive hours. The minimum
 * headcount is explicit because two half-roles still cost two salaries.
 */
export function managementLoad(input: ManagementInput): Result<ManagementLoad> {
  const counts = [
    input.productCustomers,
    input.supportHoursPerCustomerMonth,
    input.consultingHoursMonth,
    input.coordinationHoursPerConsultingHour,
    input.adminHoursMonth,
  ];
  if (!counts.every((value) => Number.isFinite(value) && value >= 0)) {
    return fail("workload counts and hours must be non-negative numbers");
  }
  if (
    !Number.isFinite(input.productiveHoursPerManagerMonth) ||
    input.productiveHoursPerManagerMonth <= 0
  ) {
    return fail("productive hours per manager must be positive");
  }
  if (!Number.isInteger(input.minimumManagers) || input.minimumManagers < 0) {
    return fail("minimum managers must be a non-negative integer");
  }
  for (const [value, label] of [
    [input.managerSalaryCents, "manager salary"],
    [input.sdeCents, "SDE"],
    [input.productRevenueCents, "product revenue"],
  ] as Array<[Cents, string]>) {
    const error = amountError(value, label);
    if (error) return fail(error);
  }
  if (input.sdeCents <= 0) return fail("SDE must be positive");
  const burdenError = bpsError(input.employerBurdenBps, "employer burden");
  if (burdenError) return fail(burdenError);

  const operatingHoursMonth =
    input.productCustomers * input.supportHoursPerCustomerMonth +
    input.consultingHoursMonth * input.coordinationHoursPerConsultingHour +
    input.adminHoursMonth;
  const managersRequired = Math.max(
    input.minimumManagers,
    Math.ceil(operatingHoursMonth / input.productiveHoursPerManagerMonth),
  );
  const annualSalaryCents = input.managerSalaryCents * managersRequired;
  const annualCostCents = Math.round(
    (annualSalaryCents * (10000 + input.employerBurdenBps)) / 10000,
  );
  return ok({
    operatingHoursMonth,
    operatingHoursWeek: (operatingHoursMonth * 12) / 52,
    fteBps: divide(operatingHoursMonth, input.productiveHoursPerManagerMonth),
    managersRequired,
    annualSalaryCents,
    annualCostCents,
    costToSdeBps: divide(annualCostCents, input.sdeCents),
    costToProductRevenueBps: divide(annualCostCents, input.productRevenueCents),
  });
}

/**
 * Delegation is a ladder, not a switch. The first rung approves small repeats
 * without a meeting; the last rung is above the founder's own authority and
 * must go to the board or the shareholders. Pricing, legal and asset decisions
 * stay with the founder even when the amount is small.
 */
export function authorityDecision(
  request: AuthorityRequest,
  limits: AuthorityLimits,
): Result<AuthorityDecision> {
  const requestError = amountError(request.amountCents, "request amount");
  if (requestError) return fail(requestError);
  for (const [value, label] of [
    [limits.autoApproveCents, "auto approval limit"],
    [limits.managerApproveCents, "manager approval limit"],
    [limits.founderApproveCents, "founder approval limit"],
  ] as Array<[Cents, string]>) {
    const error = amountError(value, label);
    if (error) return fail(error);
  }
  if (
    limits.autoApproveCents > limits.managerApproveCents ||
    limits.managerApproveCents > limits.founderApproveCents
  ) {
    return fail("approval limits must increase from auto to manager to founder");
  }
  if (request.amountCents > limits.founderApproveCents) {
    return ok({
      tier: "reserved",
      reason: "above the founder limit; requires board or shareholder approval",
    });
  }
  if (FOUNDER_ONLY.includes(request.category)) {
    return ok({
      tier: "founder",
      reason: `${request.category} decisions stay with the founder`,
    });
  }
  if (request.amountCents <= limits.autoApproveCents) {
    return ok({ tier: "auto", reason: "within the auto-approval limit" });
  }
  if (request.amountCents <= limits.managerApproveCents) {
    return ok({ tier: "manager", reason: "within the manager approval limit" });
  }
  return ok({ tier: "founder", reason: "above the manager limit" });
}

/**
 * Review load is the price of the thresholds. A low auto limit pushes routine
 * requests to the founder; a high one leaves more spending outside review.
 * Both founder minutes and auto-approved exposure are returned.
 */
export function authorityReview(
  requests: AuthorityRequest[],
  limits: AuthorityLimits,
  minutesPerFounderDecision: number,
): Result<AuthorityReview> {
  if (requests.length === 0) return fail("at least one request is required");
  if (
    !Number.isFinite(minutesPerFounderDecision) ||
    minutesPerFounderDecision < 0
  ) {
    return fail("minutes per founder decision must be non-negative");
  }
  let autoCount = 0;
  let managerCount = 0;
  let founderCount = 0;
  let reservedCount = 0;
  let autoExposureCents = 0;
  for (const request of requests) {
    const decision = authorityDecision(request, limits);
    if (!decision.ok) return decision;
    if (decision.value.tier === "auto") {
      autoCount += 1;
      autoExposureCents += request.amountCents;
    } else if (decision.value.tier === "manager") {
      managerCount += 1;
    } else if (decision.value.tier === "founder") {
      founderCount += 1;
    } else {
      reservedCount += 1;
    }
  }
  const founderMinutes = founderCount * minutesPerFounderDecision;
  return ok({
    totalRequests: requests.length,
    autoCount,
    managerCount,
    founderCount,
    reservedCount,
    founderMinutes,
    founderHours: founderMinutes / 60,
    autoExposureCents,
  });
}