《互联网产品的 AI 架构·平台化与治理》11.1 谁拥有 AI 能力：平台团队与业务团队

// file: src/gov/org.ts
// tier: L2
// verify: node --test test/gov/org.test.ts

/** 三种所有权模型：平台全权、业务全权、平台管契约业务管内容。 */
export type OwnershipModel =
  | "platform-owns"
  | "business-owns"
  | "platform-contract-business-content";

export type ContentVolatility = "low" | "medium" | "high";

/** 判定只看这七个事实，不看组织架构图上的汇报关系。 */
export interface CapabilityProfile {
  capability: string;
  /** 调用方按团队计数，同一团队的多个入口只算一个。 */
  callingTeams: number;
  tenants: number;
  crossesTenant: boolean;
  contentVolatility: ContentVolatility;
  requiresDomainExpertise: boolean;
  regulatedOutput: boolean;
  platformPrimitive: boolean;
}

export type OwnershipBasis =
  | "regulated-output"
  | "platform-primitive"
  | "multi-team-reuse"
  | "cross-tenant"
  | "single-team-local";

export interface OwnershipDecision {
  capability: string;
  model: OwnershipModel;
  basis: readonly OwnershipBasis[];
  rationale: string;
}

/** 判定顺序就是选型判据：先合规，再原语，再复用范围，最后才允许业务自治。 */
export function decideOwnership(profile: CapabilityProfile): OwnershipDecision {
  const base = { capability: profile.capability };
  if (profile.regulatedOutput) {
    return { ...base, model: "platform-contract-business-content", basis: ["regulated-output"],
      rationale: "受监管输出由平台持有契约与审计口径，业务只维护内容" };
  }
  if (profile.platformPrimitive && profile.contentVolatility === "low"
    && !profile.requiresDomainExpertise) {
    return { ...base, model: "platform-owns", basis: ["platform-primitive"],
      rationale: "平台原语且内容稳定，平台同时持有契约、实现与默认内容" };
  }
  if (profile.callingTeams >= 2 || profile.tenants >= 2 || profile.crossesTenant) {
    const basis: OwnershipBasis[] = [];
    if (profile.callingTeams >= 2) basis.push("multi-team-reuse");
    if (profile.tenants >= 2 || profile.crossesTenant) basis.push("cross-tenant");
    return { ...base, model: "platform-contract-business-content", basis,
      rationale: "多团队或多租户复用，契约由平台冻结，业务保留内容调整权" };
  }
  return { ...base, model: "business-owns", basis: ["single-team-local"],
    rationale: "单团队单租户且非平台原语，业务可以端到端持有" };
}

/** 批量判定；重复能力标识直接拒绝，避免后者覆盖前者。 */
export function decideAll(profiles: readonly CapabilityProfile[]): OwnershipDecision[] {
  const seen = new Set<string>();
  for (const profile of profiles) {
    if (seen.has(profile.capability)) throw new Error(`duplicate capability: ${profile.capability}`);
    seen.add(profile.capability);
  }
  return profiles.map(decideOwnership);
}

/** 写进能力目录 owner 字段的最小结构。 */
export interface CapabilityOwner {
  capability: string;
  model: OwnershipModel;
  /** 最终负责团队，事故与季度复盘都找它。 */
  accountable: string;
  /** 契约所有者；模型一与模型三必填。 */
  contractOwner?: string;
  /** 内容所有者；模型二与模型三必填。 */
  contentOwner?: string;
  oncall: string;
  escalation: string;
  /** 所有权复查周期，天；受监管能力不得超过 90 天。 */
  reviewCadenceDays: number;
}

export interface Team { id: string; kind: "platform" | "business" }

export type OwnerIssueCode =
  | "duplicate-capability" | "duplicate-owner" | "unknown-capability" | "missing-owner"
  | "empty-field" | "unknown-team" | "team-kind-mismatch" | "missing-contract-owner"
  | "missing-content-owner" | "owner-same-party" | "owner-not-accountable"
  | "model-mismatch" | "invalid-cadence" | "cadence-too-slow";

export interface OwnerIssue {
  capability: string;
  code: OwnerIssueCode;
  field: string;
  detail: string;
}

const MODELS: readonly OwnershipModel[] = [
  "platform-owns", "business-owns", "platform-contract-business-content",
];

function bad(capability: string, code: OwnerIssueCode, field: string, detail: string): OwnerIssue {
  return { capability, code, field, detail };
}

function teamIssue(
  teams: ReadonlyMap<string, Team>, capability: string, field: string,
  teamId: string | undefined, kind: "platform" | "business", issues: OwnerIssue[],
): void {
  if (teamId === undefined || teamId.trim() === "") return;
  const team = teams.get(teamId);
  if (team === undefined) {
    issues.push(bad(capability, "unknown-team", field, `${teamId} is not registered`));
  } else if (team.kind !== kind) {
    issues.push(bad(capability, "team-kind-mismatch", field, `${teamId} is ${team.kind}`));
  }
}

/** 单条 owner 字段校验；模型与团队类型必须互证。 */
export function validateOwnerEntry(owner: CapabilityOwner, teams: readonly Team[]): OwnerIssue[] {
  const issues: OwnerIssue[] = [];
  const byId = new Map(teams.map((team) => [team.id, team]));
  for (const field of ["capability", "accountable", "oncall", "escalation"] as const) {
    if (owner[field].trim() === "") {
      issues.push(bad(owner.capability, "empty-field", field, `${field} is empty`));
    }
  }
  if (!MODELS.includes(owner.model)) {
    issues.push(bad(owner.capability, "model-mismatch", "model", `unknown ${owner.model}`));
  }
  if (!Number.isInteger(owner.reviewCadenceDays)
    || owner.reviewCadenceDays < 1 || owner.reviewCadenceDays > 365) {
    issues.push(bad(owner.capability, "invalid-cadence", "reviewCadenceDays", "not in 1..365"));
  }
  const add = (code: OwnerIssueCode, field: string, detail: string): void => {
    issues.push(bad(owner.capability, code, field, detail));
  };
  if (owner.model === "platform-owns") {
    if (owner.contractOwner === undefined) add("missing-contract-owner", "contractOwner", "required");
    teamIssue(byId, owner.capability, "accountable", owner.accountable, "platform", issues);
    teamIssue(byId, owner.capability, "contractOwner", owner.contractOwner, "platform", issues);
    if (owner.contractOwner !== undefined && owner.contractOwner !== owner.accountable) {
      add("owner-not-accountable", "contractOwner", "must equal accountable");
    }
    if (owner.contentOwner !== undefined && owner.contentOwner !== owner.accountable) {
      add("owner-not-accountable", "contentOwner", "platform-owns keeps content in-house");
    }
  } else if (owner.model === "business-owns") {
    if (owner.contentOwner === undefined) add("missing-content-owner", "contentOwner", "required");
    teamIssue(byId, owner.capability, "accountable", owner.accountable, "business", issues);
    teamIssue(byId, owner.capability, "contentOwner", owner.contentOwner, "business", issues);
    teamIssue(byId, owner.capability, "contractOwner", owner.contractOwner, "business", issues);
    for (const field of ["contentOwner", "contractOwner"] as const) {
      const value = owner[field];
      if (value !== undefined && value !== owner.accountable) {
        add("owner-not-accountable", field, "business-owns keeps both with accountable");
      }
    }
  } else if (owner.model === "platform-contract-business-content") {
    if (owner.contractOwner === undefined) add("missing-contract-owner", "contractOwner", "required");
    if (owner.contentOwner === undefined) add("missing-content-owner", "contentOwner", "required");
    teamIssue(byId, owner.capability, "accountable", owner.accountable, "platform", issues);
    teamIssue(byId, owner.capability, "contractOwner", owner.contractOwner, "platform", issues);
    teamIssue(byId, owner.capability, "contentOwner", owner.contentOwner, "business", issues);
    if (owner.contractOwner !== undefined && owner.contractOwner !== owner.accountable) {
      add("owner-not-accountable", "contractOwner", "must equal accountable");
    }
    if (owner.contentOwner !== undefined && owner.contentOwner === owner.contractOwner) {
      add("owner-same-party", "contentOwner", "contract and content must not collapse");
    }
  }
  return issues;
}

/** 整目录校验：能力、owner、团队三方一一对上，模型还要与现场事实一致。 */
export function validateOwners(
  profiles: readonly CapabilityProfile[],
  owners: readonly CapabilityOwner[],
  teams: readonly Team[],
): OwnerIssue[] {
  const issues: OwnerIssue[] = [];
  const profileIds = new Set<string>();
  for (const profile of profiles) {
    if (profileIds.has(profile.capability)) {
      issues.push(bad(profile.capability, "duplicate-capability", "capability", "appears twice"));
    }
    profileIds.add(profile.capability);
  }
  const ownerIds = new Set<string>();
  for (const owner of owners) {
    if (ownerIds.has(owner.capability)) {
      issues.push(bad(owner.capability, "duplicate-owner", "capability", "appears twice"));
    }
    ownerIds.add(owner.capability);
    const profile = profiles.find((item) => item.capability === owner.capability);
    if (profile === undefined) {
      issues.push(bad(owner.capability, "unknown-capability", "capability", "no profile"));
    } else {
      const expected = decideOwnership(profile).model;
      if (owner.model !== expected) {
        issues.push(bad(owner.capability, "model-mismatch", "model", `expected ${expected}`));
      }
      if (profile.regulatedOutput && owner.reviewCadenceDays > 90) {
        issues.push(bad(owner.capability, "cadence-too-slow", "reviewCadenceDays",
          `${owner.reviewCadenceDays} days for a regulated capability`));
      }
    }
    issues.push(...validateOwnerEntry(owner, teams));
  }
  for (const profile of profiles) {
    if (!ownerIds.has(profile.capability)) {
      issues.push(bad(profile.capability, "missing-owner", "capability", "no owner entry"));
    }
  }
  return issues;
}