《互联网产品的 AI 架构·模型接入与能力边界》1.2 哪些事该用模型，哪些不该

// file: src/core/suitability.ts
// tier: L1
// verify: node --test test/core/suitability.test.ts

/** 一个任务最终交给谁执行：规则引擎、模型，还是人。 */
export type Execution = "rule" | "model" | "human";

/** 输出能否低成本判定对错：精确匹配、按评分表、无法判定。 */
export type Verifiability = "exact" | "rubric" | "none";

export type Sensitivity = "public" | "internal" | "personal" | "secret";

/** 任务画像只放产品事实，不放“我们想用什么”的偏好。 */
export interface TaskProfile {
  /** 相同输入是否必须得到相同输出。 */
  deterministic: boolean;
  verifiability: Verifiability;
  /** 一次错误的业务代价，1 最低、5 最高（案例假设值）。 */
  errorCost: 1 | 2 | 3 | 4 | 5;
  sensitivity: Sensitivity;
  /** 长尾输入占比，0..1（案例假设值）。 */
  longTailShare: number;
}

export interface SuitabilityVerdict {
  primary: Execution;
  fallback: Execution;
  reasons: string[];
  forbidden: string[];
}

/**
 * 判断顺序固定：敏感数据 > 确定性 > 高代价无验收 > 默认。
 * 越靠前的规则越会推翻后面的默认做法，保证同一份画像永远得到同一个结论。
 */
export function chooseExecution(profile: TaskProfile): SuitabilityVerdict {
  const reasons: string[] = [];
  const forbidden: string[] = [];
  let primary: Execution;
  let fallback: Execution;

  if (profile.sensitivity === "secret") {
    forbidden.push("model");
    reasons.push("secret 数据不得离开受控环境，模型调用被直接排除");
    primary = profile.verifiability === "exact" ? "rule" : "human";
    fallback = primary === "rule" ? "human" : "rule";
    return { primary, fallback, reasons, forbidden };
  }

  if (profile.deterministic && profile.verifiability === "exact") {
    primary = "rule";
    fallback = "human";
    reasons.push("相同输入必须得到相同输出且可精确校验，规则比模型更稳");
  } else if (profile.errorCost >= 4 && profile.verifiability === "none") {
    primary = "human";
    fallback = "model";
    reasons.push("错误代价高且没有客观验收标准，最终判断必须留给人");
    reasons.push("模型只能产出候选草稿，不能直接生效");
  } else if (profile.longTailShare >= 0.3) {
    primary = "model";
    fallback = "human";
    reasons.push(`长尾输入占比 ${Math.round(profile.longTailShare * 100)}%，穷举规则的维护成本高于模型出错成本`);
  } else {
    primary = "model";
    fallback = profile.errorCost >= 3 ? "human" : "rule";
    reasons.push("输入分布相对收敛，模型负责生成，低成本路径负责兜底");
  }

  if (profile.errorCost >= 4) {
    forbidden.push("auto-publish");
    reasons.push("错误代价 >= 4，任何输出都不能不经复核直接对外");
  }
  if (profile.sensitivity === "personal") {
    forbidden.push("raw-pii-in-prompt");
    reasons.push("个人数据进入提示词前必须脱敏或最小化");
  }
  if (profile.verifiability === "none") {
    forbidden.push("exact-match-gate");
    reasons.push("没有标准答案时，不能用精确匹配充当验收门禁");
  }

  return { primary, fallback, reasons, forbidden };
}

/** 判断某个执行方式是否被画像直接排除，便于在评审里给出反对理由。 */
export function isExecutionAllowed(profile: TaskProfile, execution: Execution): boolean {
  return !chooseExecution(profile).forbidden.includes(execution);
}

// file: test/core/suitability.test.ts
// tier: L1
// verify: node --test test/core/suitability.test.ts

import assert from "node:assert/strict";
import test from "node:test";

import { chooseExecution, isExecutionAllowed } from "../../src/core/suitability.ts";
import type { TaskProfile } from "../../src/core/suitability.ts";

const base: TaskProfile = {
  deterministic: false,
  verifiability: "rubric",
  errorCost: 2,
  sensitivity: "internal",
  longTailShare: 0.1,
};

test("精确校验的确定性任务交给规则", () => {
  const verdict = chooseExecution({
    ...base,
    deterministic: true,
    verifiability: "exact",
    errorCost: 1,
  });
  assert.equal(verdict.primary, "rule");
  assert.equal(verdict.fallback, "human");
  assert.ok(!verdict.forbidden.includes("model"));
});

test("长尾表达任务交给模型并由人工兜底", () => {
  const verdict = chooseExecution({ ...base, longTailShare: 0.45, errorCost: 2 });
  assert.equal(verdict.primary, "model");
  assert.equal(verdict.fallback, "human");
  assert.match(verdict.reasons[0], /45%/);
});

test("高代价且无验收标准的任务必须留给人", () => {
  const verdict = chooseExecution({
    ...base,
    errorCost: 5,
    verifiability: "none",
    longTailShare: 0.5,
  });
  assert.equal(verdict.primary, "human");
  assert.equal(verdict.fallback, "model");
  assert.ok(verdict.forbidden.includes("auto-publish"));
  assert.ok(verdict.forbidden.includes("exact-match-gate"));
});

test("secret 数据直接排除模型", () => {
  const profile: TaskProfile = { ...base, sensitivity: "secret" };
  const verdict = chooseExecution(profile);
  assert.equal(verdict.primary, "human");
  assert.ok(verdict.forbidden.includes("model"));
  assert.equal(isExecutionAllowed(profile, "model"), false);
});

test("个人数据即使代价不高也要禁止裸提示词", () => {
  const verdict = chooseExecution({ ...base, sensitivity: "personal" });
  assert.ok(verdict.forbidden.includes("raw-pii-in-prompt"));
  assert.equal(verdict.primary, "model");
  assert.equal(verdict.fallback, "rule");
});

test("同一份画像重复计算得到相同结论", () => {
  assert.deepEqual(chooseExecution(base), chooseExecution(base));
});

node --test test/core/suitability.test.ts

✔ 精确校验的确定性任务交给规则 (0.721791ms)
✔ 长尾表达任务交给模型并由人工兜底 (0.12275ms)
✔ 高代价且无验收标准的任务必须留给人 (0.071292ms)
✔ secret 数据直接排除模型 (0.073709ms)
✔ 个人数据即使代价不高也要禁止裸提示词 (0.062625ms)
✔ 同一份画像重复计算得到相同结论 (0.57925ms)
ℹ tests 6
ℹ suites 0
ℹ pass 6
ℹ fail 0
ℹ cancelled 0
ℹ skipped 0
ℹ todo 0
ℹ duration_ms 154.589584