差异比对三刀:客户约束不再一票否决 · 入参由基座从台账取 · 「下限~上限」一律读成范围

①**两颗一模一样的输入电压范围判成 MISMATCH**(用户送来 0bddd862):客户写「45V 以内」→ requirement `>= 45`, 而原 PN 与候选上限都是 40V;`judgePair` 只看候选过不过客户线、不看原 PN 自己过不过 —— 需求边界与在用料的差距记在了候选头上,硬约束 MISMATCH → 整颗不推荐。差异评估比的是「换上去会不会比现在差」: 候选与原 PN 相等 / 盖住、且客户线原 PN 也过不去 → 仍按比对结果判(MATCH,风险中),备注点名「需求边界,请回头核对需求」;候选更窄且过不了线仍 MISMATCH(3 形有测)。 ②**入参由基座从台账取,模型只报料号与客户约束**(用户:「这个做差异评估比对的 harness 肯定有问题」): 同一单痕里模型念出「输入上限 32V 低于客户 40V」—— 那是 S3 剧本示例的原话、不是这单的数; 工具入参只存哈希,喂了哪几对值事后查不到;写回时还把工具的 `equal` 改成 `less`。两头都靠模型抄、两头都没有基座核。改三层:工具运行时把 `taskId / activityId` 交给处理器(`ToolHandler` 入参加两个可选键); `compare-parameters` 给 `originalInternalPn + candidates[].candidateInternalPn(+ requirements)`, 参数行从 `parts.parameter`、封装 / 生命周期从 `parts.profile`、证据引用从 `parts.document` 由工具现读任务视图 (本单草稿也算),出参每项带原值与证据,写盘照抄;老形状(自带 pairs)照接,试运行走它; container 用 `compareParametersWith(ledger)` 顶掉静态名单那份;≤800 字的工具入参整份进 `result` 痕(审得了才谈得上认真)。 **基座能读到的事实,不让模型转述给工具。** ③**「下限~上限」一律是范围**(用户:「4.5~40 / -40~+85 这种我怕模型搞不清楚」):实测解析器真有洞 —— 单位写进值里(`4.5V~40V` / `-40℃~+85℃`)被读成单个数,Unicode 减号、`…`、`≥45 / 40 以内` 读成文本。分隔符认 ~ ～ - – — … 至到 to、单位可夹在值里、单边界读成半开范围;出参每项 `readAs:{original,candidate}` 写明「范围 4.5~40 / 定值 5 / 下界 ≥ 45 / 文本」—— 比对依据可见,模型照它写影响、不自己重新解释值; 契约描述与 S3 / P-08 剧本明写读法(示例用中性数 1~10,不用真数据里的 4.5~40 —— 模型会把示例当这单的值)。工具 1.0.0 → 1.3.0(注册一名一行、upsert 换版本,handler 在进程内按名绑,装完稳定版重建即生效); W05 包 1.6.2 → 1.6.4:S3 第一拍只报料号与约束、示例只留占位形,第三拍 compare_result 照抄,S4 重比只改 requirements。 13 工具测 + 包内 89。在途单要人在审核卡上「重做」并写明意见才会重比。 Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_0167qWjeyBwvfdGovd7FWbCu
2026-08-28 01:13:07 +08:00
parent e3479e0b9b
commit 88f2149d12
12 changed files with 443 additions and 39 deletions
@@ -4,6 +4,7 @@
 * 运行时受限:只拿得到**注册申报的连接目标**,没有其它环境能力 —— 这是 `ToolRuntime` 保证的。
 */
 import { evaluateUnaryTest } from '@sfeel';
+import type { TaskId } from '@contracts';
 import type { ToolHandler } from '@modules/toolbox';

 /**
@@ -375,11 +376,25 @@ type CompareCounts = { match: number; mismatch: number; unknown: number; conditi

 const UNKNOWN_WORDS = /^(未披露|未知|未给出|unknown|n\/?a|tbd|待定|-|—|–)$/i;
 const NUM = '[-+]?\\d+(?:\\.\\d+)?';
-const RANGE_RE = new RegExp(`^(${NUM})\\s*(?:~|～|-|–|—|至|to)\\s*(${NUM})`, 'i');
+/** 数字后面允许跟一段单位(V / ℃ / °C / kHz / % / mA…)—— 「4.5V~40V」「-40℃~+85℃」这种把单位写进值里的形状要认成范围 */
+const UNIT = '(?:\\s*[A-Za-z℃°%μµΩ][A-Za-z℃°%μµΩ0-9/]*)?';
+const RANGE_RE = new RegExp(`^(${NUM})${UNIT}\\s*(?:~|～|-|–|—|…|\\.\\.\\.|至|到|to)\\s*(${NUM})`, 'i');
 const NUM_RE = new RegExp(`^(${NUM})`);
+/** 单边界:「≥45」「>= 45」「45 以上」→ [45, ∞);「≤40」「<= 40」「40 以内 / 以下」→ (-∞, 40] */
+const GE_RE = new RegExp(`^(?:>=|≥)\\s*(${NUM})|^(${NUM})${UNIT}\\s*(?:以上|及以上|起)$`);
+const LE_RE = new RegExp(`^(?:<=|≤)\\s*(${NUM})|^(${NUM})${UNIT}\\s*(?:以内|以下|及以下|以内)$`);

+/**
+ * 参数值怎么读(2026-08-28 用户:「4.5~40 / -40~+85 这种我怕模型搞不清楚,harness 里强调一下是范围值」):
+ * 「下限~上限」一律是**范围**——分隔符认 ~ ～ - – — … ... 至 到 to,正负号认 + - 与 Unicode 减号(−),
+ * 单位写进值里(4.5V~40V / -40℃~+85℃)也认;「≥45 / 45 以上」「≤40 / 40 以内」是单边界,读成半开范围;
+ * 只有一个数是定值;读不出数的按文本原样比。出参会把「读作什么」摆回去,模型与人都看得见。
+ */
 export function parseParamValue(raw: unknown): Parsed {
-  const s = String(raw ?? '').trim().replace(/\s+/g, ' ');
+  const s = String(raw ?? '')
+    .trim()
+    .replace(/[\u2212\u2010\u2011\u2012]/g, '-') // Unicode 减号 / 连字号 → ASCII 减号
+    .replace(/\s+/g, ' ');
  if (s === '' || UNKNOWN_WORDS.test(s)) return { kind: 'unknown' };
  const r = RANGE_RE.exec(s);
  if (r !== null) {
@@ -387,11 +402,29 @@ export function parseParamValue(raw: unknown): Parsed {
    const hi = Number(r[2]);
    if (Number.isFinite(lo) && Number.isFinite(hi)) return { kind: 'range', lo: Math.min(lo, hi), hi: Math.max(lo, hi) };
  }
+  const ge = GE_RE.exec(s);
+  if (ge !== null) return { kind: 'range', lo: Number(ge[1] ?? ge[2]), hi: Number.POSITIVE_INFINITY };
+  const le = LE_RE.exec(s);
+  if (le !== null) return { kind: 'range', lo: Number.NEGATIVE_INFINITY, hi: Number(le[1] ?? le[2]) };
  const n = NUM_RE.exec(s);
  if (n !== null && Number.isFinite(Number(n[1]))) return { kind: 'number', value: Number(n[1]) };
  return { kind: 'text', value: s.toLowerCase() };
 }

+/** 「读作什么」—— 回给模型与人看的一句话,不是给机器再解析的 */
+export function describeParsed(p: Parsed): string {
+  if (p.kind === 'range') {
+    if (p.lo === Number.NEGATIVE_INFINITY) return `上界 ≤ ${p.hi}`;
+    if (p.hi === Number.POSITIVE_INFINITY) return `下界 ≥ ${p.lo}`;
+    return `范围 ${p.lo}~${p.hi}`;
+  }
+  if (p.kind === 'number') return `定值 ${p.value}`;
+  if (p.kind === 'unknown') return '未披露';
+  // 带数字又带范围分隔符却没读成范围的(如「4.5V 到 40 伏」),提示怎么写;纯文本(封装 TO-263-5)不啰嗦
+  const looksLikeRange = /\d[^\d]{0,6}(?:[~～…]|至|到|\bto\b)[^\d]{0,6}\d/.test(p.value) || /^[^\d]+\d.*(?:[~～…]|至|到)/.test(p.value);
+  return `文本「${p.value}」${looksLikeRange ? '(没读成范围;本意是范围请写成 下限~上限,单位放单位列)' : ''}`;
+}
+
 function compareParsed(o: Parsed, c: Parsed): CompareResult {
  if (o.kind === 'unknown' || c.kind === 'unknown') return 'unknown';
  if (o.kind === 'range' && c.kind === 'range') {
@@ -439,9 +472,26 @@ function judgePair(p: ParamPair): { compareResult: CompareResult; differenceStat
  let compareResult = compareParsed(o, c);
  if (/生命周期|lifecycle/i.test(p.parameterName)) compareResult = compareLifecycle(p.originalValue, p.candidateValue) ?? compareResult;
  const req = satisfiesRequirement(p.requirement, c);
+  /*
+   * **客户约束原 PN 自己也不满足时,不是替代差异**(2026-08-27 晚,用户送来 0bddd862:「输入电压范围两个
+   * 不是一样的吗为什么不匹配」):客户写「输入电压在 45V 以内」,模型译成 `>= 45`,而原 PN 与候选的输入上限
+   * 都是 40V —— 从前这里一票否决,候选与在用料一模一样却被记成硬约束 MISMATCH、整颗不推荐。
+   * 差异评估比的是「换上去会不会比现在差」:候选与原 PN 相等 / 盖住原范围,且这条客户边界**原 PN 一样过不去**,
+   * 那是需求边界与在用料之间的差距(该回到需求核对 / 验证),不该记在候选头上。
+   * 候选比原 PN 窄 / 不同而过不了客户线,仍是 MISMATCH;原 PN 一侧算不出(未披露 / 文本)也仍按候选过不了线判。
+   */
  if (req === false) {
-    // 客户约束不满足:比对结果照实留(narrower/differs),结论一律 MISMATCH 高风险
-    return { compareResult: compareResult === 'unknown' ? 'differs' : compareResult, differenceStatus: 'mismatch', riskLevel: 'high', note: `不满足客户约束 ${text(p.requirement)}` };
+    const parity = compareResult === 'equal' || compareResult === 'covers';
+    const originalFailsToo = parity && satisfiesRequirement(p.requirement, o) === false;
+    if (!originalFailsToo) {
+      // 客户约束不满足:比对结果照实留(narrower/differs),结论一律 MISMATCH 高风险
+      return { compareResult: compareResult === 'unknown' ? 'differs' : compareResult, differenceStatus: 'mismatch', riskLevel: 'high', note: `不满足客户约束 ${text(p.requirement)}` };
+    }
+    const boundary = `客户约束 ${text(p.requirement)} 原 PN 与候选都不满足 —— 是需求边界与在用料的差距,不是替代差异,请回头核对需求`;
+    if (hard && text(p.evidenceRef) === '') {
+      return { compareResult, differenceStatus: 'conditional', riskLevel: 'medium', note: `硬约束缺证据引用:未经证据支持不判 MATCH;${boundary}` };
+    }
+    return { compareResult, differenceStatus: 'match', riskLevel: 'medium', note: `${compareResult === 'covers' ? '候选范围盖住原范围' : '与原 PN 一致'};${boundary}` };
  }
  if (compareResult === 'unknown') return { compareResult, differenceStatus: 'unknown', riskLevel: 'medium', note: '一侧未披露:标 UNKNOWN,挂验证任务或补来源' };
  if (compareResult === 'equal' || compareResult === 'covers') {
@@ -458,22 +508,147 @@ function judgePair(p: ParamPair): { compareResult: CompareResult; differenceStat
    : { compareResult, differenceStatus: 'conditional', riskLevel: 'medium', note: '软约束不一致,须评估影响' };
 }

-const compareParameters: ToolHandler = async ({ input }) => {
-  const candidates = Array.isArray(input['candidates']) ? (input['candidates'] as Array<{ candidateInternalPn: string; pairs: ParamPair[] }>) : [];
-  const results = candidates.map((cand) => {
-    const counts: CompareCounts = { match: 0, mismatch: 0, unknown: 0, conditional: 0, hardMismatch: 0, softMismatch: 0, configurable: 0 };
-    const items = (Array.isArray(cand.pairs) ? cand.pairs : []).map((p) => {
-      const j = judgePair(p);
-      counts[j.differenceStatus] += 1;
-      if (j.differenceStatus === 'mismatch') counts[p.constraintType === 'hard' ? 'hardMismatch' : 'softMismatch'] += 1;
-      if (j.compareResult === 'configurable') counts.configurable += 1;
-      return { parameterName: p.parameterName, unit: p.unit ?? '', constraintType: p.constraintType, ...j };
-    });
-    return { candidateInternalPn: cand.candidateInternalPn, items, counts };
-  });
-  return { ok: true, output: { ruleVersion: SUBSTITUTION_RULE_VERSION, results } };
+/**
+ * 比对工具读台账用的口 —— 按地址与等值条件取行(taskId 有就取任务视图 = 正式版 + 本单草稿,没有就只读正式版)。
+ * 只读、不写;由 app 用 ledger 服务实装,测试给假的。
+ */
+export type ParameterLedger = {
+  rows(taskId: TaskId | undefined, address: { domain: string; object: string }, where: Record<string, string>): Promise<ReadonlyArray<Record<string, unknown>>>;
 };

+type CandidateInput = {
+  candidateInternalPn: string;
+  pairs?: ParamPair[] | null;
+  /** 客户给了边界的参数:{ 参数名: ">= 40" / "-40~85" } —— 客户约束在需求原文里,归模型译;值不归它 */
+  requirements?: Record<string, unknown> | null;
+  evidenceRef?: string | null;
+};
+
+/**
+ * **比对入参由基座从台账取,模型只报料号与客户约束**(2026-08-27 晚,用户:「这个做差异评估比对的 harness 肯定有问题,
+ * 要让它认真比对每一条」)。从前 pairs 由模型从 `substitution.difference_item` 抄给工具:实测它把剧本示例里的
+ * 「4.5~32 / >= 40」当成这单的值念出来,而抄了什么**不留痕**(只存 inputHash),事后没法审。
+ * 现在给 originalInternalPn + candidateInternalPn,参数行从 `parts.parameter` 现读、封装与生命周期从 `parts.profile` 现读、
+ * 证据引用没给就从 `parts.document` 取 —— 每一对都是台账里的原值;出参把 originalValue / candidateValue / evidenceRef
+ * 一并摆出来,写盘照抄即可。老形状(自带 pairs)照旧接,试运行与老调用方不受影响。
+ */
+async function pairsFromLedger(ledger: ParameterLedger, taskId: TaskId | undefined, original: string, candidate: string, cand: CandidateInput) {
+  const PARAM = { domain: 'parts', object: 'parameter' };
+  const PROFILE = { domain: 'parts', object: 'profile' };
+  const DOC = { domain: 'parts', object: 'document' };
+  const [oParams, cParams, oProfiles, cProfiles] = await Promise.all([
+    ledger.rows(taskId, PARAM, { internal_pn: original }),
+    ledger.rows(taskId, PARAM, { internal_pn: candidate }),
+    ledger.rows(taskId, PROFILE, { internal_pn: original }),
+    ledger.rows(taskId, PROFILE, { internal_pn: candidate }),
+  ]);
+  const oProfile = oProfiles[0];
+  const cProfile = cProfiles[0];
+  if (oParams.length === 0 && oProfile === undefined) {
+    return { error: `原 PN ${original} 在台账里没有主数据也没有参数行 —— 先把它建进 parts.profile / parts.parameter(数据工单),再比` };
+  }
+  if (cParams.length === 0 && cProfile === undefined) {
+    return { error: `候选 ${candidate} 在台账里没有主数据也没有参数行 —— 先建进 parts.profile / parts.parameter,再比` };
+  }
+  let evidenceRef = text(cand.evidenceRef);
+  if (evidenceRef === '') {
+    const docs = await ledger.rows(taskId, DOC, { internal_pn: candidate });
+    const sheet = docs.find((d) => text(d['document_type']) === 'datasheet' && text(d['document_ref']) !== '') ?? docs.find((d) => text(d['document_ref']) !== '');
+    if (sheet !== undefined) evidenceRef = `P-08 · P-10 ${text(sheet['document_version'])}`.trim();
+  }
+  const requirements = cand.requirements !== null && typeof cand.requirements === 'object' ? cand.requirements : {};
+  const requirementOf = (name: string) => text(requirements[name]);
+  const byName = new Map(cParams.map((r) => [text(r['param_name']), r] as const));
+  const sorted = [...oParams].sort((a, b) => text(a['param_name']).localeCompare(text(b['param_name']), 'zh-Hans-CN'));
+  const pairs: ParamPair[] = sorted
+    .filter((o) => text(o['param_name']) !== '')
+    .map((o) => {
+      const name = text(o['param_name']);
+      const c = byName.get(name);
+      return {
+        parameterName: name,
+        originalValue: text(o['param_value']),
+        candidateValue: c === undefined ? '' : text(c['param_value']),
+        unit: text(o['param_unit']) || (c === undefined ? '' : text(c['param_unit'])),
+        constraintType: text(o['constraint_type']) === 'soft' ? ('soft' as const) : ('hard' as const),
+        requirement: requirementOf(name),
+        evidenceRef,
+      };
+    });
+  // 封装(硬)与生命周期(软)不是参数,住在主数据上 —— 两颗都有档案时才比
+  if (oProfile !== undefined && cProfile !== undefined) {
+    if (text(oProfile['package']) !== '' || text(cProfile['package']) !== '') {
+      pairs.push({ parameterName: '封装', originalValue: text(oProfile['package']), candidateValue: text(cProfile['package']), unit: '', constraintType: 'hard', requirement: requirementOf('封装'), evidenceRef });
+    }
+    if (text(oProfile['lifecycle_status']) !== '' || text(cProfile['lifecycle_status']) !== '') {
+      pairs.push({ parameterName: '生命周期', originalValue: text(oProfile['lifecycle_status']), candidateValue: text(cProfile['lifecycle_status']), unit: '', constraintType: 'soft', requirement: requirementOf('生命周期'), evidenceRef });
+    }
+  }
+  const known = new Set(pairs.map((p) => p.parameterName));
+  const extraCandidateParams = [...byName.keys()].filter((n) => n !== '' && !known.has(n));
+  return { pairs, extraCandidateParams };
+}
+
+export function compareParametersWith(ledger?: ParameterLedger): ToolHandler {
+  return async ({ input, taskId }) => {
+    const original = text(input['originalInternalPn']);
+    const candidates = Array.isArray(input['candidates']) ? (input['candidates'] as CandidateInput[]) : [];
+    const results: Array<Record<string, unknown>> = [];
+    for (const cand of candidates) {
+      const candidatePn = text(cand.candidateInternalPn);
+      let pairs: ParamPair[];
+      let source: 'pairs' | 'ledger';
+      let extraCandidateParams: string[] = [];
+      if (Array.isArray(cand.pairs) && cand.pairs.length > 0) {
+        pairs = cand.pairs;
+        source = 'pairs';
+      } else {
+        if (ledger === undefined) {
+          return { ok: false, error: { code: 'invalid-input', retryable: false, message: `候选 ${candidatePn} 没给 pairs,而这条通道读不到台账 —— 给 pairs,或经任务里调用` } };
+        }
+        if (original === '') {
+          return { ok: false, error: { code: 'invalid-input', retryable: false, message: '缺 originalInternalPn:按料号从台账取参数,得先说原 PN 是谁' } };
+        }
+        const fetched = await pairsFromLedger(ledger, taskId, original, candidatePn, cand);
+        if ('error' in fetched) return { ok: false, error: { code: 'not-found', retryable: false, message: fetched.error } };
+        pairs = fetched.pairs;
+        extraCandidateParams = fetched.extraCandidateParams;
+        source = 'ledger';
+      }
+      const counts: CompareCounts = { match: 0, mismatch: 0, unknown: 0, conditional: 0, hardMismatch: 0, softMismatch: 0, configurable: 0 };
+      const items = pairs.map((p) => {
+        const j = judgePair(p);
+        counts[j.differenceStatus] += 1;
+        if (j.differenceStatus === 'mismatch') counts[p.constraintType === 'hard' ? 'hardMismatch' : 'softMismatch'] += 1;
+        if (j.compareResult === 'configurable') counts.configurable += 1;
+        return {
+          parameterName: p.parameterName,
+          originalValue: text(p.originalValue),
+          candidateValue: text(p.candidateValue),
+          // 两边各读成了什么(范围 / 定值 / 单边界 / 文本)—— 比对的依据摆出来,「4.5~40」是范围不是两个数
+          readAs: { original: describeParsed(parseParamValue(p.originalValue)), candidate: describeParsed(parseParamValue(p.candidateValue)) },
+          unit: p.unit ?? '',
+          constraintType: p.constraintType,
+          requirement: text(p.requirement),
+          evidenceRef: text(p.evidenceRef),
+          ...j,
+        };
+      });
+      results.push({
+        candidateInternalPn: candidatePn,
+        source,
+        items,
+        counts,
+        ...(extraCandidateParams.length === 0 ? {} : { extraCandidateParams }),
+      });
+    }
+    return { ok: true, output: { ruleVersion: SUBSTITUTION_RULE_VERSION, results } };
+  };
+}
+
+/** 不带台账的那份(pairs 模式):静态名单里挂它,app 用 `compareParametersWith(ledger)` 顶掉 */
+const compareParameters: ToolHandler = compareParametersWith();
+
 /**
 * 推荐定级(D02,FIRST):硬 MISMATCH → 不推荐;有 UNKNOWN → 条件推荐(等验证闭环);
 * 有 configurable(改外围配得成)→ 备选;其余 conditional → 条件推荐;全 MATCH → 推荐。与 manifest 里的 D02 表同一份规则。